Invoice Generation

1
insertStatement(maxDate,null)

Based on the imported library, insertStatement(maxDate,null) is the function that handles the generation of statements.

Input parameters:

• maxDate: It is obtained by adjoining theinvariantDate of the current date to the daysBeforePolicyScheduleDueDate parameter. This variable represents the maximum date until the policies are filtered based on installments.

• null: accountId.

Output parameters: N/A.

Variables:

• libFlowParameter: import from the FTOS_PA_FlowParameter library.

• daysBeforePolicyScheduleDueDate: based on the imported library, through the getNoOfDaysInAdvance() function, this variable receives an integer value that is set as the SGDAY flow parameter .

• statementGenerationLib: import from the FTOS_PYMT_Statements library.

This function gets a JSON object from the FTOS_DFP_ProcessorSettings entity. The object contains the settings for statement processing and has the following structure:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "StatementsRules": {
    "rulesArr": [
      "multiplePolicies",
      "singlePolicies",
      "multiplePoliciesByQuoteMultipleNext",
      "multipleFirstPoliciesByQuoteSingleNext"
    ],
    "OP": 0,
    "PayU": 0,
    "PayU-on Time": 1,
    "brokerCollection": 0
  }
}

1
statementRules.getKey(k)

This function returns an array of payment types based on each Rule Name Key, from the FTOS_PYMT_StatementProcessor parameter.

This function returns an array of payment types based on each Rule Name Key for processing statements, from the FTOS_DFP_ProcessorSettings entity.

The function is used for filtering installments by payment types based on rule names (rulesArr).

Input parameters: value - The rule name key. For example: 0, 1, 2, ...

Output parameters: An array of strings with the Payment Types. For example:

• For multiplePolicies, an output example is ["OP", "PayU", "brokerCollection"].

• For singlePolicies, an output example is ["PayU-on Time"].

• For multiplePoliciesByQuoteMultipleNext and multipleFirstPoliciesByQuoteSingleNext, an output example is an empty array [].

1
getLastMonth()

This function returns an object with invariant dates: the firstDay of last month and the lastDay of last month, in order to help filtering the installments with brokerCollection Payment Type .

Input parameters: N/A,

Output parameters: An object that contains the invariant values as following:

1
2
3
4
lastMonthObj = {
    "firstDay": firstDay,
    "lastDay": lastDay
}

1
getMonthId(month)

This function gets the option set item Id from the months option set, based on the month number and, next, returns an object with the month Id and month name.

Input parameters: monthNo - The month number; it can take values from 1 to 12.

Output parameters: An object that contains monthId and monthName.

1
getStatementMonthId(invariantDate)

This function returns the FTOS_PYMT_StatementMonthid primary key attribute, from the FTOS_PYMT_StatementMonth entity, based on a query that searches for the monthId and year. If the fetch is empty, this function inserts the current search values into the FTOS_PYMT_StatementMonth entity.

Input parameters: maxDate - The invariant date for the statement.

Output parameters: statementMonthId - The Id of the statement month.

1
compareObjects(object1, object2)

This function compares objects.

Input parameters:

object1 - An object containing the specified details.

object2 - An object containing the specified details.

Output parameters: boolean.

1
compareArrays(a, b)

This function compares arrays.

Input parameters:

• a - An array containing the specified data.

• b - An array containing the specified data.

Output parameters: boolean.

1
getPosition(elem, arrEleme)

This function gets the position of a specified array element from inside the array.

Input parameters:

• elem - The element to compare.

• arrEleme - The array.

Output parameters: The element position, if found - else, null.

1
getGenericProdPosition(arr, elem)

This function gets the position of an array element from an array object.

Input parameters:

• elem - The element to compare.

• arr - The array.

Output parameters: The element position, if found - else, null.

1
getMaxDate(days)

This function gets the maximum date for the payment - such as the SGDAY or the last day of the month. The maximum date variable represents the maximum date until the policies are filtered based on installments.

Input parameters: days - The maximum date for a payment.

Output parameters: InvariantDate - The invariant date.

1
compareProdDateInArr(arr, day)

This function compares dates in an array of dates.

Input parameters:

• arr - The array of the specified dates.

• day - The invariant date.

Output parameters: The product Id, if the days match - else, it returns false.

1
compareProdDate(day1, day2)

This function compares dates.

Input parameters:

• day1 - The invariant date.

• day2 - The invariant date.

Output parameters:

The product Id, if the days match - else, it returns false.

1
getProducts(sgDay)

This function gets all the products that are in VWDraft, VWVersion Draft and VWVersion Unapproved status and also with the writeOffId attribute set to NoWriteOff, GenericWriteOff, or SpecificWriteOff, at product level. Next, it filters all found products by start date and end date.

Input parameters: sgDay - The SGDAY parameter (integer) from the processor.

Output parameters: obj - An object containing the requested data.

1
groupedSpecificProducts(productsArr)

This function filters for products with Specific WriteOff settings, based on their writeOffId attibute.

Input parameters: productsArr - An array of products.

Output parameters: productsResultArr - An array of products that satisfy the request.

1
generateGroupedProducts(resultGroupedProducts)

This function gets all products filtered by date and WriteOff type.

Input parameters: resultGroupedProducts - An array containing the products.

Output parameters: resultGroupedProducts - An array containing the products found by the fetch.

1
insertStatement(invariantDate, accountId)

This function prepares the rules for generating the invoices, by using a loop of conditions.

Based on the chosen parameter, from the FTOS_PYMT_StatementProcessor entity, the function can trigger four types of statement generation flows:

• multiplePolicies: where multiple policies are included, based on the Contractor, Currency, Payment Type, Product and Due Date;

• singlePolicies: where a single policy is included;

• multiplePoliciesByQuoteMultipleNext: for first installments - where multiple policies are generated by the same quote or for next installments - where multiple policies are included, based on the Contractor, Currency, Payment Type and Due Date;

• multipleFirstPoliciesByQuoteSingleNext: for first installments - where multiple policies are generated by the same quote or for next installments - where a single policy is included.

Input parameters:

• maxDate: The invariant date values for the statement.

• accountId: Null.

Output parameters: N/A.

Variables:

• rulesArr - An array of rule names. For example: [multiplePolicies, singlePolicies, multiplePoliciesByQuoteMultipleNext, multipleFirstPoliciesByQuoteSingleNext]

• ruleName - A string, for each rule name. For example: multiplePolicies.

• groupByPolicy - A boolean (true, false) value, used to group by policy.

• groupByQuote - A boolean (true, false) value, used to group by quote.

• paymentTypeArr - An array of payment types. For example: [OP, PayU, brokerCollection].

• groupedProducts - An array of products.

1
insertStatementByPaymentType(invariantDate, accountId, ruleName, groupByPolicy, groupByQuote, paymentTypeArr, 1)

Input parameters:

• invariantDate - The invariant date of the statement.

• accountId - The Id of the account.

• ruleName - The name of the rule.

• groupByPolicy - The boolean for grouping by policy.

• groupByQuote - The boolean for grouping by quote.

• paymentTypeArr - The array containing the payment types.

• installmentNo - The installment number variable. It can take the following values:

  null - for a filter without installment number,

  1 - for the first installment,

  2 - for all other installments except the first.

Output parameters: N/A.

Variables:

• currentDate - The current day, with the following hour format 00:00:00.000. This variable is used in statement generation for filling in the installmentsStartDate and statementDate attributes.

• lastMonth - An object containing the first day of last month and the last day of last month, returned by the getLastMonth() function.

• statementMonthId - The statementMonthid attribute from FTOS_PYMT_StatementMonth entity, returned by the getStatementMonthId(invariantDate) function. This variable is used in statement generation for filling in the statementMonthId attribute.

• libParameter - For importing the FTOS_PA_FlowParameter library.

• brokerScope - based on the FTOS_PA_FlowParameter imported library, this variable receives a string value from the option set item that is set as the BKSCOPE flow parameter.

• businessStatusPolicyProposal - The Id of Proposal status from the FTOS_INSPA_Policy entity.

• businessStatusPolicyIssued - The Id of Issued status from the FTOS_INSPA_Policy entity.

• businessStatusPolicyEnforced - The Id of Enforced status from the FTOS_INSPA_Policy entity.

• businessStatusPolicySuspended - The Id of Suspended status from the FTOS_INSPA_Policy entity.

• policyPaymentTypeOPOptionSetValue - The Id of the OP option set item from the FTOS_INSPA_PolicyPaymentType option set.

• policyPaymentTypePayUOptionSetValue - The Id of the PayU option set item from the FTOS_INSPA_PolicyPaymentType option set.

• policyPaymentTypePayUOnTimeOptionSetValue - The Id of the PayU-on time option set item from the FTOS_INSPA_PolicyPaymentType option set.

• policyPaymentTypeBrokerCollection - The Id of the brokerCollection option set item from the FTOS_INSPA_PolicyPaymentType option set.

• fetchInstallmentGroup - This fetch executes the following actions:

  Gets all the payment schedules (installments) from FTOS_INSQB_PaymentSchedule entity, for policies that have currency - currencyId is not null.

  Adds attributes needed for filtering from the FTOS_INSQB_PaymentScheduleDetail - the installments entity and also from the FTOS_INSPA_Policy entity.

  Calculates the sum out of the following installments attributes: installmentAmount, paidAmount, commissionAmount, taxAmount, netPremium, from the FTOS_INSQB_PaymentScheduleDetail entity, based on the rules conditions.

• fetchInstallments - This fetch executes the following:
  Gets each filtered payment schedule found in the fetchInstallmentGroup fetch.
  Generates the statement detail according to rules and inserts the required values in the FTOS_PYMT_StatementDetail entity.
  Calculates and updates the statement DueDate attribute from the FTOS_INSQB_PaymentScheduleDetail entity.
  Changes the installment status in StatementIssued.

For the fetchInstallmentGroup function, you can define the filtering for the fetch based on the following attributes:

The following are the types of push rules for fetching the needed data for generating statements:

The following is an example of an object aimed at filtering for Broker policies that do not have the Payment Type set to Broker Collection:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
if (brokerConditionRulesObj.notBrokerCollectionRules == true) {
    fetchInstallmentGroup.entity.join[0].entity.attributelist.push({
        "name": "dueDate"
    });
    fetchInstallmentGroup.entity.join[0].entity.join[1].entity.attributelist.push({
        "name": "AccountId"
    });


    if (brokerConditionRulesObj.brokerScopeDueInstallments = true) {
        fetchInstallmentGroup.where.expressionlist.push({
            "type": "and",
            "conditionlist": [{
                "first": "e.policyPaymentTypeId",
                "type": "notequals",
                "second": "val(" + policyPaymentTypeBrokerCollection + ")"
            }]
        });
    }

    fetchInstallmentGroup.where.expressionlist.push({
        "type": "and",
        "conditionlist": [{
            "first": "b.dueDate",
            "type": "lte",
            "second": "val(" + invariantDate + ")"
        }]
    });
}
if (brokerConditionRulesObj.pushInsuranceBroker == true) {
    fetchInstallmentGroup.entity.join[0].entity.join[1].entity.attributelist.push({
        "name": "insuranceBrokerId"
    });
}

After defining the structure of the fetch object, use it as a parameter for the function responsible for getting the results. Next, store the result in a variable:

1
var installmentGroupResult = getByQuery(fetchInstallmentGroup)

For each installment of installmentGroupResult, take the values needed and store them into statementInsertObj object in order to generate the statement:

1
var statementId = insert('FTOS_PYMT_Statement', statementInsertObj)

Based on the statementId, this changes the business status into Generated.