☰
Navigation :

Getting Started

Prerequisites

Before you begin, ensure you have the following installed:

  • Java 21+
  • Maven 3.8+

Artifactory Access

Please ensure you have access to our private Maven repositories in your Maven settings.xml file before installation. You will need access to the following repositories:

Atoti Server Server repository

This repository contains all the dependencies required to run Atoti Server. Atoti Sign-Off is itself an Atoti Server product, which is why this repository is required.

<repository>
    <id>ActiveViamInternalRepository</id>
    <name>ActiveViam Internal Repository</name>
    <url>https://activeviam.jfrog.io/activeviam/mvn-internal/</url>
    <layout>default</layout>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
</repository>

Business Solutions repository

This repository contains all the dependencies required to run ActiveViam Business Solutions.


<repository>
    <id>ActiveViamBusinessSolutionsRepository</id>
    <name>ActiveViam Business Solutions Repository</name>
    <url>https://activeviam.jfrog.io/activeviam/activeviam-mvn-accelerators/</url>
    <layout>default</layout>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
</repository>

License

To use Atoti Server, you will need a valid license. Atoti Sign-Off is itself an Atoti Server product, which is why this license is required. For details on how to get one, see the Atoti Server documentation.

Installing the Starter Project

The starter project is a reference Spring Boot application that demonstrates how to use Atoti Sign-Off. It contains the default configurations and workflows. It can be configured, customized, or extended for your specific use cases using Spring.

To install the starter project:

  1. Download the Atoti Sign-Off source code. This contains the starter project and the parent pom file.
  2. Extract the source code folder into your workspace.
  3. Open the project in your IDE.
  4. Run mvn clean install.

This will compile the source code, run tests, and package the application. You may exclude test execution by running mvn clean install -DskipTests.

Running the Starter

Start the application with:

java -jar ./signoff-starter/target/sign-off-exec.jar

By default, the application starts on http://localhost:9090.

Alternatively, if using your IDE, run the com.activeviam.signoff.starter.SignOff class.

Connecting Atoti Sign-Off to your Application Server

Atoti Sign-Off performs its sign-off and adjustment logic on another Atoti Server application, known as the application server. You must ensure this application is configured to communicate via REST with Atoti Sign-Off. This is done by implementing the Atoti Sign-Off API. Please refer to the Atoti Sign-Off API documentation for how this is done.

Once the application server is configured to communicate with Atoti Sign-Off, you must configure the Atoti Sign-Off starter to communicate with the application server. This is done by setting configuartion properties.

info

We recommend externalizing these properties into a profile. For example if you wish to connect to the Atoti Market Risk Solution then you can use an mr profile by placing these properties in application-mr.yml in ./signoff-starter/src/main/resources and starting the application with -Dspring.profiles.active=mr. See the Spring Boot docs for more details on profiles.

Please see the following snippet for an example of the properties required to connect to the Atoti Market Risk Solution

MR connection properties

Customizing the Starter

The following section outlines how to modify the starter project to suit your needs. We recommend that you make changes in the following order:

  1. Configurations: these are usually non-code related changes and are the easiest to migrate.
  2. Customizations: these are usually code additions that can be easily “swapped in” to the existing codebase to either safely override or augment existing functionality.
  3. Overrides: these are usually code changes that require a more in-depth understanding of the codebase and may require changes to existing code. These are the hardest to migrate, and if you need to do them we recommend you raise a Jira for us to see if there is a better alternative or if there is a gap in our product that needs to be addressed.

1. Configurations

We recommend that you configure the application as much as possible before customizing existing code. The following configurations are commonly used:

Configuring Application Properties

Application properties are used to configure functionality of Atoti Sign-Off and most of its dependencies. These can be found in the properties section and updated by modifying the src/main/resources/application.yml file, or by using environment variables:

Database Configuration with Spring JPA

By default, the application uses an in-memory H2 database.

info

Using the H2 database in production is not recommended. Instead, please use a production-grade database. There is none in particular that we recommend, but popular choices include:

To use your database, add any relevant drivers to your pom.xml and configure connection properties in your application.yml. For example, for PostgreSQL this might look as follows:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

Configure JPA properties:

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.datasource.driver-class-name=org.postgresql.Driver

2. Customizations

info

When you add new code as a customization to the starter project, we highly recommend that you use your own package name and avoid using the com.activeviam package. This will separate your code from our code and make it much easier to migrate.

Customizing via Spring Beans

The application follows Spring best practices. To customize, you can override existing beans and components by defining them in your application. This is the safest form of overriding or augmenting existing code behavior. We aim to use @ConditionalOnMissingBean as much as possible to allow for easy customization. If we have not exposed a bean you wish to override as @ConditionalOnMissingBean, please raise a Jira with us and mark your bean as @Primary.

Activiti Workflow Customization

The application includes default Activiti workflows located in src/main/resources/processes/. You’ll probably want to implement your own workflows. To customize workflows, you need to:

  1. Create your BPMN file. You can either edit the existing BPMN files or use a BPMN editor, such as BPMN.io.
  2. Import any Spring beans or services required by your workflow. This is detailed further in customizing the Sign-Off workflow.
  3. Add the new processes in src/main/resources/processes/.
  4. Restart the application to ensure the changes are picked up.

Security customizations

The application comes with a default security configuration. You need to customize this by implementing your own security configuration. This is done by implementing and exposing the following interfaces:

  • com.activeviam.web.spring.api.config.ICorsConfig: This interface is used to configure CORS settings.
  • org.springframework.security.web.SecurityFilterChain: This interface is used to configure security filters for REST requests.
  • org.springframework.security.core.userdetails.UserDetailsService: This interface is used to load user-specific data.

3. Override

If you cannot configure or customize the application to meet your requirements, you may need to override the application. This is the most complex form of modification as it requires an in-depth knowledge of the core codebase and may result in unintended consequences. It is also the most difficult code to migrate, because it may be difficult to remember if the code was an override in the first place or is a legitimate starter class. We recommend adding a javadoc to differentiate overrides from released source code.

warning

If you need to override our code we recommend that you raise a Jira ticket with us to see if there is a better alternative or if there is a gap in our product that needs to be addressed.

Migrating Atoti Sign-Off

When migrating to a new version of Atoti Sign-Off, we recommend the following steps:

  1. Ensure your code customizations is under a separate package name from the com.activeviam package.
  2. Create a new branch in your VCS for the upgrade.
  3. If you have overridden any of our code, move it to a tmp.com.activiam package. This should only apply to overrides, not to starter code.
  4. Install the starter project for your new version, replacing the old starter com.activeviam packages with the new packages.
  5. Verify if any of the tmp.com.activeviam code can be removed. If so, remove it, otherwise, please raise a Jira and merge it with the new code.
  6. Run mvn clean install
  7. If you have any compile errors, consult the migration notes in the release notes for the new version.
  8. Repeat steps 6-7 until the code compiles and is correctly installed.

Frequently asked questions

I can’t download the starter project dependencies due to my company’s policy. What can I do?

We store Maven repositories for all of our artifacts on Artifactory. The core Atoti Server jars are available in the ActiveViam share page, as described in the Atoti Server download guide. From there you can download the Atoti Server 6.1.4 jars.

The Atoti Sign-Off jars are available from the Business Solutions artifacts repository. From there you can download the Atoti Sign-Off jars. Once downloaded, install these jars in your local repository and re-run the Maven build.