Finance and operations apps frameworks

  • 13 minutes

It's important to understand the customization concepts of finance and operations apps and to master the skills to make those customizations. With finance and operations apps, you can use the Task recorder and Business process modeler tools to create user acceptance test libraries. Additionally, you should also know how to use the Data management framework.

Task recorder

Use the Task recorder tool to create multiple, in-depth, instructional recordings of business processes in finance and operations apps that you can use in various scenarios. For example, if you have a business user, go through the process of creating a purchase order (PO). Then, upload that process into the asset library so that you can use it for training other resources. Use the recording with the Regression suite automation tool (RSAT) for regression testing scenarios and to share with other business users to ensure continuity across roles in the system.

Business process modeler

Use the Business process modeler tool to create user acceptance test libraries. You can create, view, and modify repeatable implementations that are based on libraries and flowcharts. Business process modeler helps you align the business processes for finance and operations apps with industry standard processes. Additionally, you can perform a fit-gap analysis between your business requirements and the default processes in the system, which helps you discover the development requirements.

Data management framework

Use the Data management framework to manage data entity packages in finance and operations apps. It uses a series of concepts to help you set up and copy the configuration for new implementations. This feature is beneficial, even if your team doesn't understand the structure of data or dependencies, and it can lead to an easier implementation.

You can use all three frameworks to enhance implementations from beginning to end, and you can use them in tandem to create an easier step-by-step implementation strategy.

Implement the SysOperation framework

The SysOperation framework replaces the older RunBase framework, and it provides more extensibility. Both frameworks support the following capabilities:

  • Parameters
  • Dialog user interface (UI)
  • Batch servers
  • Running operations interactively

For finance and operations apps, we recommend that you use the SysOperation framework instead of the RunBase framework. Use SysOperation framework when a job should process or calculate something.

SysOperation consists of four main elements:

  • Data contract class
  • Controller class
  • Service classUI
  • Builder class

Data contract class

The Data contract class indicates the attributes that are needed for the job, and the attributes automatically provide a dialog-based UI. The following code sample illustrates the Data contract class:

[DataContractAttribute]
internal final class MySysOperationContract
{
    private ItemId      itemId;

    [DataMember, SysOperationLabel(literalStr("Item Id")), SysOperationHelpText(literalStr("Item Id help")), SysOperationDisplayOrder('1')]
    public ItemId parmItemId(ItemId _itemId = itemId)
    {
        itemId = _itemId;

        return itemId;
    }
}

Controller class

The Controller class is the execution class, which contains information about the dialog, execution mode, progress bar, and other elements. The following code sample illustrates the Controller class:

internal final class MySysOperationController extends SysOperationServiceController
{
    protected void new()
    {
        super(classStr(mySysOperationService), methodStr(MySysOperationService, process), SysOperationExecutionMode::Synchronous);
    }

    public ClassDescription defaultCaption()
    {
        return "My process job";
    }

    public static MySysOperationController construct(SysOperationExecutionMode _executionMode = SysOperationExecutionMode::Synchronous)
    {
        MySysOperationController controller;
        controller = new MySysOperationController();
        controller.parmExecutionMode(_executionMode);

        return controller;
    }

    public static void main(Args _args)
    {
        MySysOperationController controller;

        controller = MySysOperationController::construct();
        controller.parmArgs(_args);
        controller.startOperation();
    }
}

Service class

The Service class is the actual code that's processed or calculated. The following sample code illustrates the Service class:

internal final class MySysOperationService extends SysOperationServiceBase
{
    public void process(MySysOperationContract _contract)
    {
        // do something

        ItemId itemId = _contract.parmItemId();

        Info(strFmt("%1", itemId));
    }
}

UI Builder class

The UI Builder class is only needed if the UI requires modification from the dynamically generated UI or if it has custom behavior.

Implement the SysExtensionSerializer

You can add fields to a table by using an extension. If you're adding more than 10 fields to a table extension, the compiler throws the best practice error. We recommend that you use the alternative way of creating a new table and adding a foreign key relation to the standard table. Maps are available to help you improve a developer’s processes. The SysExtensionSerializerMap and SysExtensionSerializerExtensionMap maps make the create, read, update, and delete (CRUD) operations automated to the custom table.

You can create a new table for your new fields, as the following image depicts.

Screenshot of the My Cust Table showing the Sys Extension Serializer Map.

Consider the following details about implementing the SysExtensionSerializer extension:

  • The CustTable field is an int64 (RecId).

  • It creates relation to the CustTable standard table and points to RecId on CustTable, as the following screenshot shows.

    Screenshot of the Properties form showing the relation to the standard table.

  • It creates mapping to map the SysExtensionSerializerExtensionMap field BaseRecId to a new table called MyCustTable and the CustTable field.

  • It creates an alternate key (Index) on the table for the CustTable field in the MyCustTable table. For the table property, the Replacement Key is set to the Alternate key, as the following screenshot shows.

    Screenshot of the Properties form showing that the Replacement Key is set to the Alternate key.

The SysExtensionSerializerMap contains methods for automatically inserting, updating, and performing many other functions. The standard CustTable table includes calls to the SysExtensionSerializer framework, which means that whenever a record in CustTable is updated, your table is also updated, as the following screenshot shows.

Screenshot showing the Cust Table.

Using the SysExtensionSerializer framework fields helps you add a related table by following best practices and enabling CRUD functionality.