<?xml version="1.0" ?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.atlassian.platform.pom</groupId>
        <artifactId>platform-defaults</artifactId>
        <version>8.0.0-m16</version>
        <relativePath>../parent-poms/platform-defaults</relativePath>
    </parent>

    <groupId>com.atlassian.refapp</groupId>
    <artifactId>atlassian-refapp-parent</artifactId>
    <packaging>pom</packaging>

    <name>Atlassian Reference Application (parent pom)</name>

    <modules>
        <module>refapp-plugins</module>
        <module>refapp-maven-enforcer-rules</module>
        <module>refapp-bundled-plugins</module>
        <module>atlassian-refapp-pageobjects</module>
        <module>refapp-api</module>
        <module>refapp-core</module>
        <module>refapp-webapp</module>
        <module>sonar-aggregator</module>
        <module>refapp-framework-bundles</module>
    </modules>

    <issueManagement>
        <system>Jira</system>
        <url>https://ecosystem.atlassian.net/browse/REFAPP</url>
    </issueManagement>
    <ciManagement>
        <system>Bamboo</system>
        <url>https://ecosystem-bamboo.internal.atlassian.com/browse/REFAPP</url>
    </ciManagement>

    <properties>
        <smartass.version>2.1.3</smartass.version>
        <tomcat.version>tomcat10x</tomcat.version>

        <node.version>16.20.2</node.version>
        <yarn.version>1.22.22</yarn.version>
        <!-- TODO: fix it later -->
        <!-- The `copy-file-from-to` package (theoretically) requires Node >=18, but works OK on Node 16 -->
        <!-- The current build of `clientside-extensions-plugin` frontend fails above Node 16 -->
        <!-- That's why for now, there's the `ignore-engines` flag. It can be removed when the above build script is updated to work with higher versions of NodeJS -->
        <yarn.cmd.install>install --frozen-lockfile --ignore-engines --no-progress</yarn.cmd.install>
        <!-- build mode is production by default. It can be overridden with the NODE_ENV environment var. -->
        <frontend.build.mode>production</frontend.build.mode>
        <frontend.maven.plugin.version>1.15.1-atlassian-3</frontend.maven.plugin.version>

        <atlassian.spring.scanner.version>3.0.1</atlassian.spring.scanner.version>
        <atlassian.selenium.version>3.7.0</atlassian.selenium.version>

        <!-- libraries need to a .libversion suffix -->
        <jetty.libversion>9.4.38.v20210224</jetty.libversion>

        <plugins.instrumentation.enabled>false</plugins.instrumentation.enabled>

        <!--
            We don't do any jdbc database provisioning by default, as we use an embedded H2 database.
            See com.atlassian.refapp.api.ConnectionProvider
            Additional properties are there just to keep the IDE and the maven-sql-plugin from parse failures.
            Note that these JDBC parameters apply only to running via AMPS; running via cargo does not use these, see REFAPPDEV-37.
        -->
        <jdbc.skip.provisioning>true</jdbc.skip.provisioning>
        <jdbc.driver.class.name>not.enabled</jdbc.driver.class.name>
        <jdbc.admin.url>not.enabled</jdbc.admin.url>
        <jdbc.admin.user>not.enabled</jdbc.admin.user>
        <jdbc.admin.pass>not.enabled</jdbc.admin.pass>
        <jdbc.app.url>not.enabled</jdbc.app.url>
        <jdbc.app.user>not.enabled</jdbc.app.user>
        <jdbc.app.pass>not.enabled</jdbc.app.pass>

        <!-- default provisioning properties -->
        <jdbc.provisioning.autocommit>false</jdbc.provisioning.autocommit>
        <jdbc.provisioning.onerror.drop>abort</jdbc.provisioning.onerror.drop>

        <jacoco.report.file>sonar-aggregator/target/site/jacoco-aggregate/jacoco.xml</jacoco.report.file>

        <functest.version>4.0.1</functest.version>

        <!-- 3rd party libraries -->
        <system.rules.version>1.19.0</system.rules.version>

        <healthcheck.version>9.0.0-jakarta-m002</healthcheck.version>
        <achoo.version>2.0.0-jakarta-m002</achoo.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.atlassian.theme</groupId>
                <artifactId>atlassian-theme-integration-tests</artifactId>
                <type>test-jar</type>
                <version>${atlassian-theme.version}</version>
            </dependency>
            <dependency>
                <groupId>com.atlassian.lookandfeel</groupId>
                <artifactId>lookandfeel-tests</artifactId>
                <type>test-jar</type>
                <version>${atlassian-lookandfeel.version}</version>
            </dependency>

            <!-- test dependencies -->
            <dependency>
                <groupId>com.atlassian.plugins.test</groupId>
                <artifactId>atlassian-plugins-test</artifactId>
                <version>7.0.3</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>io.rest-assured</groupId>
                <artifactId>rest-assured</artifactId>
                <version>5.3.2</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.2</version>
            </dependency>
            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-library</artifactId>
                <version>1.3</version>
            </dependency>
            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-core</artifactId>
                <version>1.3</version>
            </dependency>
            <dependency>
                <groupId>org.mockito</groupId>
                <artifactId>mockito-core</artifactId>
                <version>2.28.2</version>
            </dependency>
            <dependency>
                <groupId>com.atlassian.functest</groupId>
                <artifactId>functest-plugin</artifactId>
                <version>${functest.version}</version>
            </dependency>
            <dependency>
                <groupId>com.atlassian.selenium</groupId>
                <artifactId>atlassian-pageobjects-elements</artifactId>
                <version>${atlassian.selenium.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>com.atlassian.bundles</groupId>
                        <artifactId>jsr305</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.apache.velocity</groupId>
                        <artifactId>velocity</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>com.atlassian.healthcheck</groupId>
                <artifactId>atlassian-healthcheck-in-product-test-support</artifactId>
                <version>${healthcheck.version}</version>
            </dependency>
            <dependency>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-util</artifactId>
                <version>${jetty.libversion}</version>
            </dependency>
            <!-- Override to non-vulnerable version. Transitive dependency from atlassian-pageobjects-elements@3.3.3 -->
            <dependency>
                <groupId>org.json</groupId>
                <artifactId>json</artifactId>
                <version>${json.version}</version>
            </dependency>
            <!-- Override to non-vulnerable version. Transitive dependency from atlassian-pageobjects-elements@3.3.3 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-compress</artifactId>
                <version>${commons-compress.version}</version>
            </dependency>
            <!-- Override to non-vulnerable version. Transitive dependency from atlassian-pageobjects-elements@3.3.3 -->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>${guava.version}</version>
            </dependency>
            <!-- Override to non-vulnerable version. Transitive dependency from atlassian-pageobjects-elements@3.3.3 -->
            <dependency>
                <groupId>com.squareup.okio</groupId>
                <artifactId>okio</artifactId>
                <version>${okio.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>com.atlassian.maven.plugins</groupId>
                    <artifactId>smartass-maven-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <groupId>com.atlassian.maven.plugins</groupId>
                    <artifactId>amps-maven-plugin</artifactId>
                    <version>${amps.version}</version>
                    <configuration>
                        <skipRestDocGeneration>true</skipRestDocGeneration>
                        <devToolboxVersion>4.0.0-jakarta-m001</devToolboxVersion>
                        <enableWebConsole>false</enableWebConsole>
                        <!-- Enable PluginViewer once DCPL-2273 is finished  -->
                        <enablePluginViewer>false</enablePluginViewer>
                        <enablePde>false</enablePde>
                        <verifyFeManifestAssociationsFailOnUndeclaredFiles>false</verifyFeManifestAssociationsFailOnUndeclaredFiles>
                        <extractDependencies>false</extractDependencies>
                    </configuration>
                    <extensions>true</extensions>
                </plugin>
                <plugin>
                    <groupId>com.atlassian.plugin</groupId>
                    <artifactId>atlassian-spring-scanner-maven-plugin</artifactId>
                    <version>${atlassian.spring.scanner.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>atlassian-spring-scanner</goal>
                            </goals>
                            <phase>process-classes</phase>
                        </execution>
                    </executions>
                </plugin>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-enforcer-plugin</artifactId>
                </plugin>

                <!--
                This sql needs to be run BEFORE amps gets run in the atlassian-refapp (refapp-webapp) module.
                Unfortunately, the only place this works is in pre-integration-test phase and so does amps.
                The order they are executed depends on the order they appear in the effective pom. If you have
                a problem with this check your effective pom using 'mvn help:effective-pom > effective-pom.xml'
                inside refapp-webapp and check that the plugins are correctly ordered.
                -->
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>sql-maven-plugin</artifactId>
                    <version>1.5</version>
                    <configuration>
                        <skip>${jdbc.skip.provisioning}</skip>
                        <driver>${jdbc.driver.class.name}</driver>
                        <url>${jdbc.admin.url}</url>
                        <username>${jdbc.admin.user}</username>
                        <password>${jdbc.admin.pass}</password>
                        <autocommit>${jdbc.provisioning.autocommit}</autocommit>
                    </configuration>
                    <executions>
                        <!-- first invocation - drop the existing database if it's there, optionally ignoring errors -->
                        <execution>
                            <id>drop-db-before-test</id>
                            <phase>pre-integration-test</phase>
                            <goals>
                                <goal>execute</goal>
                            </goals>
                            <configuration>
                                <onError>${jdbc.provisioning.onerror.drop}</onError>
                                <sqlCommand>${jdbc.provisioning.script.drop}</sqlCommand>
                            </configuration>
                        </execution>
                        <!-- second invocation - create the database -->
                        <execution>
                            <id>create-db-before-test</id>
                            <phase>pre-integration-test</phase>
                            <goals>
                                <goal>execute</goal>
                            </goals>
                            <configuration>
                                <sqlCommand>${jdbc.provisioning.script.create.db}</sqlCommand>
                            </configuration>
                        </execution>
                    </executions>
                    <dependencies>
                        <dependency>
                            <groupId>org.postgresql</groupId>
                            <artifactId>postgresql</artifactId>
                            <version>${postgresql.version}</version>
                        </dependency>
                        <dependency>
                            <groupId>com.mysql</groupId>
                            <artifactId>mysql-connector-j</artifactId>
                            <version>${mysql.version}</version>
                        </dependency>
                        <dependency>
                            <groupId>com.oracle.database.jdbc</groupId>
                            <artifactId>ojdbc11</artifactId>
                            <version>${oracle-jdbc.version}</version>
                        </dependency>
                        <dependency>
                            <groupId>com.microsoft.sqlserver</groupId>
                            <artifactId>mssql-jdbc</artifactId>
                            <version>${mssql.version}</version>
                        </dependency>
                    </dependencies>
                </plugin>

                <plugin>
                    <groupId>com.github.eirslett</groupId>
                    <artifactId>frontend-maven-plugin</artifactId>
                    <version>${frontend.maven.plugin.version}</version>
                    <configuration>
                        <yarnVersion>v${yarn.version}</yarnVersion>
                        <installDirectory>${maven.multiModuleProjectDirectory}/.node</installDirectory>
                        <environmentVariables>
                            <NODE_ENV>${frontend.build.mode}</NODE_ENV>
                        </environmentVariables>
                    </configuration>
                    <executions>
                        <execution>
                            <id>step-1-set-up-environment</id>
                            <goals>
                                <goal>install-node-and-yarn</goal>
                            </goals>
                            <phase>initialize</phase>
                        </execution>
                        <execution>
                            <id>step-2-install-frontend-dependencies</id>
                            <goals>
                                <goal>yarn</goal>
                            </goals>
                            <configuration>
                                <workingDirectory>${project.basedir}</workingDirectory>
                                <arguments>${yarn.cmd.install}</arguments>
                                <environmentVariables>
                                    <!-- Must always be development so that we get our dev dependencies -->
                                    <NODE_ENV>development</NODE_ENV>
                                </environmentVariables>
                            </configuration>
                            <phase>initialize</phase>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.jacoco</groupId>
                    <artifactId>jacoco-maven-plugin</artifactId>
                    <version>0.8.7</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>com.atlassian.maven.plugins</groupId>
                <artifactId>amps-maven-plugin</artifactId>
                <version>${amps.version}</version>
                <extensions>true</extensions>
                <configuration>
                    <containerId>${tomcat.version}</containerId>

                    <!-- Enable QuickReload once DCPL-2395 is finished  -->
                    <enableQuickReload>false</enableQuickReload>

                    <!-- AMPS tries to be helpful and use the hostname, but on macOS it's not bound by default -->
                    <server>localhost</server>

                    <systemPropertyVariables>
                        <!-- Fail fast, any plugin exceeding this timeout needs to be fixed -->
                        <atlassian.plugins.enable.wait>10</atlassian.plugins.enable.wait>

                        <!-- Required for analytics system -->
                        <aws.region>eu-central-1</aws.region>

                        <com.atlassian.plugin.instrumentation.PluginSystemInstrumentation.enabled>
                            ${plugins.instrumentation.enabled}
                        </com.atlassian.plugin.instrumentation.PluginSystemInstrumentation.enabled>

                        <atlassian.darkfeature.atlassian.rest.default.to.licensed.access.enabled>true</atlassian.darkfeature.atlassian.rest.default.to.licensed.access.enabled>

                        <!-- Re-enable upload in UPM, used for mvn amps:install -->
                        <upm.plugin.upload.enabled>true</upm.plugin.upload.enabled>

                        <upm.pac.disable>true</upm.pac.disable>

                        <!-- You can control the batching mechanism in Refapp by using these options -->
                        <refapp.super.batching.on>true</refapp.super.batching.on>
                        <refapp.webresource.batching.on>true</refapp.webresource.batching.on>
                        <refapp.context.batching.on>true</refapp.context.batching.on>
                    </systemPropertyVariables>

                    <products>
                        <product>
                            <id>refapp</id>
                            <version>${project.version}</version>
                            <jvmArgs>-XX:+IgnoreUnrecognizedVMOptions</jvmArgs>
                            <log4j2Config>src/main/resources/log4j2.xml</log4j2Config>
                            <output>${project.build.directory}/refapp.log</output>
                        </product>
                    </products>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <executions>
                    <execution>
                        <!-- Disable the "hammer" rule -->
                        <id>ban-milestones-and-release-candidates</id>
                        <phase>none</phase>
                    </execution>
                    <execution>
                        <!-- Disable the build environment rules (allows using AMPS snapshots) -->
                        <id>enforce-build-environment</id>
                        <phase>none</phase>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <profiles>
        <profile>
            <id>debug</id>
            <build>
                <defaultGoal>verify</defaultGoal>
            </build>
            <activation>
                <activeByDefault>false</activeByDefault>
            </activation>
        </profile>
        <profile>
            <id>ide</id>
            <dependencies>
                <dependency>
                    <groupId>com.atlassian.plugins</groupId>
                    <artifactId>atlassian-plugins-osgi-bridge</artifactId>
                </dependency>
            </dependencies>
        </profile>

        <profile>
            <id>build-mode-is-set-by-node-env</id>
            <activation>
                <property>
                    <name>env.NODE_ENV</name>
                </property>
            </activation>
            <properties>
                <frontend.build.mode>${env.NODE_ENV}</frontend.build.mode>
            </properties>
        </profile>

        <profile>
            <id>postgres</id>
            <properties>
                <jdbc.skip.provisioning>false</jdbc.skip.provisioning>
                <jdbc.driver.class.name>org.postgresql.Driver</jdbc.driver.class.name>
                <jdbc.host>localhost</jdbc.host>
                <jdbc.port>5432</jdbc.port>
                <jdbc.admin.url>jdbc:postgresql://${jdbc.host}:${jdbc.port}/postgres</jdbc.admin.url>
                <jdbc.app.url>jdbc:postgresql://${jdbc.host}:${jdbc.port}/${jdbc.app.db}</jdbc.app.url>
                <jdbc.admin.user>postgres</jdbc.admin.user>
                <jdbc.admin.pass>postgres</jdbc.admin.pass>
                <jdbc.app.db>refappdb</jdbc.app.db>
                <jdbc.app.schema>refappschema</jdbc.app.schema>
                <jdbc.app.user>refappuser</jdbc.app.user>
                <jdbc.app.pass>refapppass</jdbc.app.pass>
                <jdbc.provisioning.autocommit>true</jdbc.provisioning.autocommit>
                <jdbc.provisioning.script.drop>
                    drop database if exists ${jdbc.app.db};
                    drop user if exists ${jdbc.app.user};
                </jdbc.provisioning.script.drop>
                <jdbc.provisioning.script.create.db>
                    create user ${jdbc.app.user} with password '${jdbc.app.pass}';
                    create database ${jdbc.app.db} with owner ${jdbc.app.user};
                </jdbc.provisioning.script.create.db>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.atlassian.maven.plugins</groupId>
                        <artifactId>amps-maven-plugin</artifactId>
                        <configuration>
                            <systemProperties>
                                <refapp.jdbc.external>true</refapp.jdbc.external>
                                <refapp.jdbc.driver.class.name>${jdbc.driver.class.name}</refapp.jdbc.driver.class.name>
                                <refapp.jdbc.app.url>${jdbc.app.url}</refapp.jdbc.app.url>
                                <refapp.jdbc.app.schema>${jdbc.app.schema}</refapp.jdbc.app.schema>
                                <refapp.jdbc.app.user>${jdbc.app.user}</refapp.jdbc.app.user>
                                <refapp.jdbc.app.pass>${jdbc.app.pass}</refapp.jdbc.app.pass>
                            </systemProperties>
                            <libArtifacts>
                                <libArtifact>
                                    <groupId>org.postgresql</groupId>
                                    <artifactId>postgresql</artifactId>
                                    <version>${postgresql.version}</version>
                                </libArtifact>
                            </libArtifacts>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>mysql</id>
            <properties>
                <jdbc.skip.provisioning>false</jdbc.skip.provisioning>
                <jdbc.driver.class.name>com.mysql.jdbc.Driver</jdbc.driver.class.name>
                <jdbc.host>localhost</jdbc.host>
                <jdbc.port>3306</jdbc.port>
                <jdbc.admin.url>jdbc:mysql://${jdbc.host}:${jdbc.port}/mysql</jdbc.admin.url>
                <jdbc.app.url>jdbc:mysql://${jdbc.host}:${jdbc.port}/${jdbc.app.db}</jdbc.app.url>
                <jdbc.admin.user>root</jdbc.admin.user>
                <jdbc.admin.pass>root</jdbc.admin.pass>
                <jdbc.app.db>refappdb</jdbc.app.db>
                <jdbc.app.user>refappuser</jdbc.app.user>
                <jdbc.app.pass>refapppass</jdbc.app.pass>
                <!--
                    mysql has no nice means of detecting whether a user exists prior to dropping (until 5.7, when 'if
                    exists' was introduced), so we allow failures; detecting database existence prior to drop has
                    existed since 5.1, so we use it
                  -->
                <jdbc.provisioning.onerror.drop>continue</jdbc.provisioning.onerror.drop>
                <jdbc.provisioning.script.drop>
                    drop database if exists ${jdbc.app.db};
                    drop user '${jdbc.app.user}'@'localhost';
                </jdbc.provisioning.script.drop>
                <jdbc.provisioning.script.create.db>
                    create database ${jdbc.app.db};
                    grant all on ${jdbc.app.db}.* to '${jdbc.app.user}'@'localhost' identified by '${jdbc.app.pass}';
                    flush privileges;
                </jdbc.provisioning.script.create.db>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.atlassian.maven.plugins</groupId>
                        <artifactId>amps-maven-plugin</artifactId>
                        <configuration>
                            <systemProperties>
                                <refapp.jdbc.external>true</refapp.jdbc.external>
                                <refapp.jdbc.driver.class.name>${jdbc.driver.class.name}</refapp.jdbc.driver.class.name>
                                <refapp.jdbc.app.url>${jdbc.app.url}</refapp.jdbc.app.url>
                                <refapp.jdbc.app.user>${jdbc.app.user}</refapp.jdbc.app.user>
                                <refapp.jdbc.app.pass>${jdbc.app.pass}</refapp.jdbc.app.pass>
                            </systemProperties>
                            <libArtifacts>
                                <libArtifact>
                                    <groupId>com.mysql</groupId>
                                    <artifactId>mysql-connector-j</artifactId>
                                    <version>${mysql.version}</version>
                                </libArtifact>
                            </libArtifacts>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>oracle</id>
            <properties>
                <jdbc.skip.provisioning>false</jdbc.skip.provisioning>
                <jdbc.driver.class.name>oracle.jdbc.OracleDriver</jdbc.driver.class.name>
                <jdbc.host>localhost</jdbc.host>
                <jdbc.port>1521</jdbc.port>
                <jdbc.sid>XE</jdbc.sid>
                <jdbc.admin.url>jdbc:oracle:thin:@${jdbc.host}:${jdbc.port}:${jdbc.sid}</jdbc.admin.url>
                <jdbc.app.url>${jdbc.admin.url}</jdbc.app.url>
                <jdbc.admin.user>oracle</jdbc.admin.user>
                <jdbc.admin.pass>oracle</jdbc.admin.pass>
                <jdbc.app.db>refappdb</jdbc.app.db>
                <jdbc.app.schema>refappuser</jdbc.app.schema>
                <jdbc.app.user>refappuser</jdbc.app.user>
                <jdbc.app.pass>refapppass</jdbc.app.pass>
                <!-- oracle has no nice means of detecting whether a user exists prior to dropping, so we allow failures -->
                <jdbc.provisioning.onerror.drop>continue</jdbc.provisioning.onerror.drop>
                <jdbc.provisioning.script.drop>
                    drop user ${jdbc.app.user} cascade;
                </jdbc.provisioning.script.drop>
                <jdbc.provisioning.script.create.db>
                    create user ${jdbc.app.user} identified by ${jdbc.app.pass} default tablespace users quota unlimited on users;
                    grant connect, resource to ${jdbc.app.user};
                </jdbc.provisioning.script.create.db>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.atlassian.maven.plugins</groupId>
                        <artifactId>amps-maven-plugin</artifactId>
                        <configuration>
                            <systemProperties>
                                <refapp.jdbc.external>true</refapp.jdbc.external>
                                <refapp.jdbc.driver.class.name>${jdbc.driver.class.name}</refapp.jdbc.driver.class.name>
                                <refapp.jdbc.app.url>${jdbc.app.url}</refapp.jdbc.app.url>
                                <refapp.jdbc.app.schema>${jdbc.app.schema}</refapp.jdbc.app.schema>
                                <refapp.jdbc.app.user>${jdbc.app.user}</refapp.jdbc.app.user>
                                <refapp.jdbc.app.pass>${jdbc.app.pass}</refapp.jdbc.app.pass>
                            </systemProperties>
                            <libArtifacts>
                                <libArtifact>
                                    <groupId>com.oracle.database.jdbc</groupId>
                                    <artifactId>ojdbc11</artifactId>
                                    <version>${oracle-jdbc.version}</version>
                                </libArtifact>
                            </libArtifacts>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>mssql-sqljdbc</id>
            <properties>
                <jdbc.skip.provisioning>false</jdbc.skip.provisioning>
                <jdbc.driver.class.name>com.microsoft.sqlserver.jdbc.SQLServerDriver</jdbc.driver.class.name>
                <jdbc.host>localhost</jdbc.host>
                <jdbc.port>1433</jdbc.port>
                <jdbc.admin.url>jdbc:sqlserver://${jdbc.host}:${jdbc.port};databaseName=master</jdbc.admin.url>
                <jdbc.app.url>jdbc:sqlserver://${jdbc.host}:${jdbc.port};databaseName=${jdbc.app.db}</jdbc.app.url>
                <jdbc.admin.user>sa</jdbc.admin.user>
                <jdbc.admin.pass>@!1234abc</jdbc.admin.pass>
                <jdbc.app.db>refappdb</jdbc.app.db>
                <jdbc.app.schema>refappschema</jdbc.app.schema>
                <jdbc.app.user>refappuser</jdbc.app.user>
                <jdbc.app.pass>@!1234abc</jdbc.app.pass>
                <jdbc.provisioning.autocommit>true</jdbc.provisioning.autocommit>
                <jdbc.provisioning.script.drop>
                    if exists(select 1 from master.sys.databases where name='${jdbc.app.db}') drop database ${jdbc.app.db};
                    if exists(select 1 from master.sys.database_principals where name='${jdbc.app.user}') drop user ${jdbc.app.user};
                    if exists(select 1 from master.sys.sql_logins where name='${jdbc.app.user}') drop login ${jdbc.app.user};
                </jdbc.provisioning.script.drop>
                <jdbc.provisioning.script.create.db>
                    create login ${jdbc.app.user} with password = '${jdbc.app.pass}';
                    create user ${jdbc.app.user} for login ${jdbc.app.user};
                    create database ${jdbc.app.db};
                    alter authorization on database::${jdbc.app.db} to ${jdbc.app.user};
                </jdbc.provisioning.script.create.db>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.atlassian.maven.plugins</groupId>
                        <artifactId>amps-maven-plugin</artifactId>
                        <configuration>
                            <systemProperties>
                                <refapp.jdbc.external>true</refapp.jdbc.external>
                                <refapp.jdbc.driver.class.name>${jdbc.driver.class.name}</refapp.jdbc.driver.class.name>
                                <refapp.jdbc.app.url>${jdbc.app.url}</refapp.jdbc.app.url>
                                <refapp.jdbc.app.schema>${jdbc.app.schema}</refapp.jdbc.app.schema>
                                <refapp.jdbc.app.user>${jdbc.app.user}</refapp.jdbc.app.user>
                                <refapp.jdbc.app.pass>${jdbc.app.pass}</refapp.jdbc.app.pass>
                            </systemProperties>
                            <libArtifacts>
                                <libArtifact>
                                    <groupId>com.microsoft.sqlserver</groupId>
                                    <artifactId>mssql-jdbc</artifactId>
                                    <version>${mssql.version}</version>
                                </libArtifact>
                            </libArtifacts>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>jacoco</id>
            <properties>
                <jacoco.include.pattern>com/atlassian/**</jacoco.include.pattern>
                <!--Exclude refapp-test-plugin, atlassian-refapp-pageobjects and all SpringBeans.class-->
                <jacoco.exclude.pattern>com/atlassian/refapp/test/**,com/atlassian/webdriver/refapp/**,com/atlassian/refapp/api/**,**/SpringBeans.class</jacoco.exclude.pattern>
            </properties>
            <build>
                <plugins>
                    <!-- Code coverage -->
                    <plugin>
                        <groupId>org.jacoco</groupId>
                        <artifactId>jacoco-maven-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>agent-for-ut</id>
                                <goals>
                                    <goal>prepare-agent</goal>
                                </goals>
                                <configuration>
                                    <propertyName>jacoco.agent.argLine</propertyName>
                                    <includes>
                                        <include>${jacoco.include.pattern}</include>
                                    </includes>
                                    <excludes>
                                        <exclude>${jacoco.exclude.pattern}</exclude>
                                    </excludes>
                                </configuration>
                            </execution>
                            <execution>
                                <id>agent-for-it</id>
                                <phase>initialize</phase>
                                <goals>
                                    <goal>prepare-agent-integration</goal>
                                </goals>
                                <configuration>
                                    <propertyName>jacoco.agent.it.argLine</propertyName>
                                    <includes>
                                        <include>${jacoco.include.pattern}</include>
                                    </includes>
                                    <excludes>
                                        <exclude>${jacoco.exclude.pattern}</exclude>
                                    </excludes>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-surefire-plugin</artifactId>
                        <configuration>
                            <argLine>@{jacoco.agent.argLine}</argLine>
                        </configuration>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-failsafe-plugin</artifactId>
                        <configuration>
                            <argLine>@{jacoco.agent.it.argLine}</argLine>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>
