@lendi/act-credit-decisions-transform 1.9.0

package/lib/transform-events/transform-asset-address.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStandard = exports.transformAddress = exports.standardMapping = exports.getAddressMapping = void 0;
+const lixi_internal_request_1 = require("@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const enum_mappings_1 = require("../types/enum-mappings");
+const address_tools_1 = require("../utils/address-tools");
+/**
+ *
+ * @param address
+ */
+function getAddressMapping(address) {
+    return {
+        city: '@Suburb',
+        country: '@Country',
+        postcode: (0, address_tools_1.isOverseasAddress)(address) ? '@OverseasPostCode' : '@AustralianPostCode',
+        state: (0, address_tools_1.isOverseasAddress)(address) ? '@OverseasState' : '@AustralianState',
+        standard: 'Standard',
+        formatted: '@Country',
+    };
+}
+exports.getAddressMapping = getAddressMapping;
+exports.standardMapping = {
+    streetName: '@StreetName',
+    streetType: '@StreetType',
+    streetNumber: '@StreetNumber',
+    level: '@Level',
+    unit: '@Unit',
+};
+/**
+ * Generates an address for an asset.
+ *
+ * @param address: An address object.
+ * @param id: address event id.
+ * @param toBeUsedAsSecurity
+ * @param address
+ * @param id
+ * @returns A transformed address object.
+ */
+function transformAddress(address, id) {
+    const transformedAddress = {
+        '@UniqueID': id,
+    };
+    const addressMapping = getAddressMapping(address);
+    // for an Australian address: if no postcode is provided, infer one from the state:
+    if (!(0, address_tools_1.isOverseasAddress)(address) && address.state && !address.postcode) {
+        address.postcode = enum_mappings_1.postcodeMapping[address.state];
+    }
+    for (const [key, value] of Object.entries(address)) {
+        if (addressMapping[key]) {
+            switch (key) {
+                case 'standard':
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], transformStandard(value));
+                    break;
+                case 'country':
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], (0, address_tools_1.isOverseasAddress)(address) ? enum_mappings_1.countryCodeMapping[value] : lixi_internal_request_1.CountryCodeList.Au);
+                    break;
+                case 'formatted':
+                    if (!address.country) {
+                        const country = (0, address_tools_1.extractCountryFromFormatted)(value);
+                        (0, lodash_1.set)(transformedAddress, addressMapping[key], enum_mappings_1.countryCodeMapping[country]);
+                    }
+                    break;
+                default:
+                    (0, lodash_1.set)(transformedAddress, addressMapping[key], value);
+                    break;
+            }
+        }
+    }
+    return transformedAddress;
+}
+exports.transformAddress = transformAddress;
+/**
+ * @description Generates an address standard.
+ * @param {AddressStandard} addressStandard An address standard object.
+ * @returns {Partial<Standard>} A transformed standard object.
+ */
+function transformStandard(addressStandard) {
+    const transformedStandard = {};
+    for (const [key, value] of Object.entries(addressStandard)) {
+        if (exports.standardMapping[key]) {
+            (0, lodash_1.set)(transformedStandard, exports.standardMapping[key], value);
+        }
+    }
+    return transformedStandard;
+}
+exports.transformStandard = transformStandard;

package/lib/transform-events/transform-asset.d.ts

@@ -0,0 +1,58 @@
+import { LivingExpense, OccupancyList, PropertyExpense as LIXIPropertyExpense } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
+import { PropertyType as LixiPropertyType, Residential } from '@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request';
+import { Asset, Payload, PercentOwned, PropertyExpense, PropertyType } from '../types/events/public-asset';
+import { PartialApplication } from '../types/partial-application';
+export interface PropertyTypeMapping {
+    path: string;
+    value: Residential | LixiPropertyType;
+}
+export declare const propertyTypeNameList: string[];
+export declare const residentialTypeList: string[];
+/**
+ * Generates a partial internal request from a partial public asset event.
+ *
+ * @param {Payload} asset - A partial public asset.
+ * @returns {PartialApplication} A partial InternalRequest.
+ */
+export declare function transformAsset({ asset, applicationId, id }: Payload): PartialApplication;
+/**
+ * @description Map the propertyType to a RealEstateAsset path and the value.
+ * @param {PropertyType} propertyType - A propertyType.
+ * @returns {PropertyTypeMapping | null} A path and value to be used for property type mapping.
+ */
+export declare function getPropertyType(propertyType: PropertyType): PropertyTypeMapping | null;
+/**
+ * @description Get the asset transform mapping for various asset types.
+ * @param {Asset} asset An Asset
+ * @returns {Record<string, string>} Asset Transform Mapping.
+ */
+export declare function getAssetMapping(asset: Asset): Record<string, string>;
+/**
+ * Creates living expense items from a propertyExpense object.
+ *
+ * @param percentOwned: owners of the property
+ * @param assetId: Asset id
+ * @param propertyExpenses: propertyExpenses items
+ * @param percentOwned
+ * @param assetId
+ * @param propertyExpenses
+ */
+export declare function generateLivingExpenses(percentOwned: PercentOwned, assetId: string, propertyExpenses: PropertyExpense[]): LivingExpense[];
+/**
+ * Creates PropertyExpense array on RealEstateAsset from the same array on the event.
+ *
+ * @param propertyExpenses
+ */
+export declare function generatePropertyExpenses(propertyExpenses: PropertyExpense[]): LIXIPropertyExpense[];
+/**
+ * Determines the occupancy based on the list of property expense types available.
+ *
+ * @param propertyExpenses
+ */
+export declare function determineOccupancy(propertyExpenses: PropertyExpense[]): OccupancyList;
+/**
+ * Calculates the correct amount and frequency.
+ *
+ * @param expense
+ */
+export declare function normalizeAmounts(expense: PropertyExpense): PropertyExpense;

package/lib/transform-events/transform-asset.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAmounts = exports.determineOccupancy = exports.generatePropertyExpenses = exports.generateLivingExpenses = exports.getAssetMapping = exports.getPropertyType = exports.transformAsset = exports.residentialTypeList = exports.propertyTypeNameList = void 0;
+const lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
+const application_paths_1 = require("@lendi/integrations-credit-protocol/utils/application-paths");
+const lixi_internal_request_2 = require("@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const uuid_1 = require("uuid");
+const __1 = require("..");
+const logger_1 = require("../logger");
+const enum_mappings_1 = require("../types/enum-mappings");
+const builder_type_1 = require("../types/enum-mappings/builder-type");
+const construction_type_1 = require("../types/enum-mappings/construction-type");
+const public_asset_1 = require("../types/events/public-asset");
+const public_expense_1 = require("../types/events/public-expense");
+const get_financial_institution_1 = require("../utils/get-financial-institution");
+const is_asset_type_1 = require("../utils/is-asset-type");
+const round_decimal_1 = require("../utils/round-decimal");
+const transform_asset_address_1 = require("./transform-asset-address");
+const transform_percent_owned_1 = require("./transform-percent-owned");
+exports.propertyTypeNameList = Object.values(lixi_internal_request_2.Custom2PropertyTypeNameList);
+exports.residentialTypeList = Object.values(lixi_internal_request_1.ResidentialTypeList);
+// will add this path to protocol
+const constructionDetailsPath = `${application_paths_1.paths.RealEstateAsset}.ConstructionDetails`;
+const constructionDetailsMapping = {
+    builderType: `${constructionDetailsPath}.@BuilderType`,
+    buildPriceAmount: `${constructionDetailsPath}.@BuildPriceAmount`,
+    constructionType: `${constructionDetailsPath}.@Type`,
+    estimatedValue: `${constructionDetailsPath}.@TotalAmount`,
+    isFixedPriceContract: `${constructionDetailsPath}.@FixedPriceContract`,
+    landEstimatedValue: `${constructionDetailsPath}.@LandValue`,
+    otherConstructionCosts: `${constructionDetailsPath}.@OutOfContractItemsCost`,
+};
+/**
+ * Generates a partial internal request from a partial public asset event.
+ *
+ * @param {Payload} asset - A partial public asset.
+ * @returns {PartialApplication} A partial InternalRequest.
+ */
+function transformAsset({ asset, applicationId, id }) {
+    var _a;
+    const isPropertyAsset = (0, is_asset_type_1.isRealEstateAsset)(asset);
+    const idPath = isPropertyAsset ? `${application_paths_1.paths.RealEstateAsset}.@UniqueID` : `${application_paths_1.paths.NonRealEstateAsset}.@UniqueID`;
+    const addressId = `${id}-address`;
+    const assetMapping = getAssetMapping(asset);
+    const partialApplication = {};
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
+    (0, lodash_1.set)(partialApplication, idPath, id);
+    if (isPropertyAsset) {
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.RealEstateAsset}.@MultipleDwellings`, lixi_internal_request_1.YesNoList.No);
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.RealEstateAsset}.@x_Address`, addressId);
+    }
+    else {
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.@Type`, enum_mappings_1.assetTypeMapping[asset.type]);
+    }
+    if ((0, is_asset_type_1.isFinancialAsset)(asset)) {
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.@Type`, lixi_internal_request_1.NonRealEstateAssetTypeList.FinancialAsset);
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.FinancialAsset.@Type`, enum_mappings_1.financialAssetMapping[asset.type]);
+    }
+    if ((0, is_asset_type_1.isOtherAsset)(asset)) {
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.@Type`, lixi_internal_request_1.NonRealEstateAssetTypeList.Other);
+    }
+    switch (asset.type) {
+        case public_asset_1.AssetType.Vehicle:
+            (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.@Type`, lixi_internal_request_1.NonRealEstateAssetTypeList.MotorVehicleAndTransport);
+            break;
+        case public_asset_1.AssetType.HomeContents:
+            (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.OtherAsset.@Type`, lixi_internal_request_1.OtherAssetTypeList.HomeContents);
+            break;
+        case public_asset_1.AssetType.Gifts:
+            (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description || 'Asset Gifts');
+            break;
+        case public_asset_1.AssetType.OtherAsset:
+            if (asset.description) {
+                (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description);
+            }
+            break;
+    }
+    for (const [key, value] of Object.entries(asset)) {
+        if (assetMapping[key]) {
+            switch (key) {
+                case 'contractDetails':
+                    const { contractDate, estimatedSettlementDate } = value;
+                    if (contractDate)
+                        (0, lodash_1.set)(partialApplication, assetMapping.contractDate, contractDate);
+                    if (estimatedSettlementDate)
+                        (0, lodash_1.set)(partialApplication, assetMapping.estimatedSettlementDate, estimatedSettlementDate);
+                    break;
+                case 'primaryPurpose':
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.primaryPurposeMapping[value]);
+                    break;
+                case 'toBePurchased':
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.toBePurchasedMapping[value]);
+                    break;
+                case 'propertyExpenses':
+                    if (!asset.percentOwned || (0, lodash_1.isEmpty)((_a = asset.percentOwned) === null || _a === void 0 ? void 0 : _a.owners)) {
+                        break;
+                    }
+                    const propertyExpenses = generatePropertyExpenses(value);
+                    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.RealEstateAsset}.PropertyExpense`, propertyExpenses);
+                    const livingExpenses = generateLivingExpenses(asset.percentOwned, id, value);
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], livingExpenses);
+                    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.RealEstateAsset}.@Occupancy`, determineOccupancy(value));
+                    break;
+                case 'propertyStatus':
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.propertyStatusMapping[value]);
+                    break;
+                case 'toBeUsedAsSecurity':
+                    if (isPropertyAsset)
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.toBeUsedAsSecurityMapping[value]);
+                    break;
+                case 'propertyType':
+                    const propertyTypeMapping = getPropertyType(value);
+                    if (!propertyTypeMapping) {
+                        logger_1.logger.warn({ message: `Unknown propertyType ${value} for asset ${id}`, applicationId });
+                    }
+                    const { path, value: mappedValue } = propertyTypeMapping;
+                    (0, lodash_1.set)(partialApplication, path, mappedValue);
+                    break;
+                case 'zoneType':
+                    if (asset.zoneType === public_asset_1.ZoneType.Commercial) {
+                        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.RealEstateAsset}.Commercial.@Type`, lixi_internal_request_1.OtherAssetTypeList.Other);
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], lixi_internal_request_1.Custom6TypeList.Commercial);
+                    }
+                    else {
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], lixi_internal_request_1.Custom6TypeList.Residential);
+                    }
+                    break;
+                case 'financialInstitution':
+                    if ((0, is_asset_type_1.isFinancialAsset)(asset)) {
+                        const financialInstitution = (0, get_financial_institution_1.getFinancialInstitution)(value.toString());
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], financialInstitution);
+                    }
+                    break;
+                case 'year':
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], value.toString());
+                    break;
+                case 'address':
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], (0, transform_asset_address_1.transformAddress)(value, addressId));
+                    break;
+                case 'isConstruction':
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], (0, __1.booleanMapping)(value));
+                    break;
+                case 'percentOwned':
+                    const percentOwned = (0, transform_percent_owned_1.transformPercentOwned)(value);
+                    if (percentOwned) {
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], percentOwned);
+                    }
+                    break;
+                case 'constructionDetails':
+                    for (const [key, constructionDetailsValue] of Object.entries(value)) {
+                        switch (key) {
+                            case 'builderType':
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], builder_type_1.builderTypeMapping[constructionDetailsValue]);
+                                break;
+                            case 'constructionType':
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], construction_type_1.constructionTypeMapping[constructionDetailsValue]);
+                                break;
+                            case 'isFixedPriceContract':
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], (0, __1.booleanMapping)(constructionDetailsValue));
+                                break;
+                            default:
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], constructionDetailsValue);
+                                break;
+                        }
+                    }
+                    break;
+                case 'estimatedValue':
+                    if (asset.isConstruction) {
+                        (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], Math.trunc(value));
+                    }
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], Math.trunc(value));
+                    break;
+                default:
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], value);
+                    break;
+            }
+        }
+    }
+    return partialApplication;
+}
+exports.transformAsset = transformAsset;
+/**
+ * @description Map the propertyType to a RealEstateAsset path and the value.
+ * @param {PropertyType} propertyType - A propertyType.
+ * @returns {PropertyTypeMapping | null} A path and value to be used for property type mapping.
+ */
+function getPropertyType(propertyType) {
+    const value = enum_mappings_1.propertyTypeMapping[propertyType];
+    if (exports.residentialTypeList.includes(value)) {
+        return {
+            path: `${application_paths_1.paths.RealEstateAsset}.Residential`,
+            value: {
+                '@Type': value,
+            },
+        };
+    }
+    if (exports.propertyTypeNameList.includes(value)) {
+        return {
+            path: `${application_paths_1.paths.RealEstateAsset}.PropertyType`,
+            value: {
+                '@PropertyTypeName': value,
+                '@CategoryTypeName': lixi_internal_request_2.Custom1CategoryTypeNameList.Residential,
+            },
+        };
+    }
+    return null;
+}
+exports.getPropertyType = getPropertyType;
+/**
+ * @description Get the asset transform mapping for various asset types.
+ * @param {Asset} asset An Asset
+ * @returns {Record<string, string>} Asset Transform Mapping.
+ */
+function getAssetMapping(asset) {
+    let estimatedValue = `${application_paths_1.paths.NonRealEstateAsset}.EstimatedValue.@Value`;
+    let percentOwned = `${application_paths_1.paths.NonRealEstateAsset}.PercentOwned`;
+    const baseMapping = {
+        estimatedValue,
+        percentOwned,
+    };
+    if ((0, is_asset_type_1.isRealEstateAsset)(asset)) {
+        estimatedValue = `${application_paths_1.paths.RealEstateAsset}.EstimatedValue.@Value`;
+        percentOwned = `${application_paths_1.paths.RealEstateAsset}.PercentOwned`;
+        return {
+            address: application_paths_1.paths.Address,
+            contractDetails: 'contractDetails',
+            contractDate: `${application_paths_1.paths.RealEstateAsset}.ContractDetails.@ContractDate`,
+            estimatedSettlementDate: `${application_paths_1.paths.RealEstateAsset}.ContractDetails.@EstimatedSettlementDate`,
+            estimatedValue,
+            percentOwned,
+            primaryPurpose: `${application_paths_1.paths.RealEstateAsset}.@PrimaryPurpose`,
+            propertyExpenses: application_paths_1.paths.LivingExpenses,
+            propertyStatus: `${application_paths_1.paths.RealEstateAsset}.@Status`,
+            propertyType: `${application_paths_1.paths.RealEstateAsset}.Residential`,
+            toBePurchased: `${application_paths_1.paths.RealEstateAsset}.@Transaction`,
+            toBeUsedAsSecurity: `${application_paths_1.paths.RealEstateAsset}.@ToBeUsedAsSecurity`,
+            zoneType: `${application_paths_1.paths.RealEstateAsset}.Zoning.@Type`,
+            isConstruction: `${application_paths_1.paths.RealEstateAsset}.@Construction`,
+            constructionDetails: `${application_paths_1.paths.RealEstateAsset}.ConstructionDetails`,
+        };
+    }
+    if ((0, is_asset_type_1.isMotorVehicle)(asset)) {
+        return Object.assign(Object.assign({}, baseMapping), { make: `${application_paths_1.paths.NonRealEstateAsset}.MotorVehicle.@Make`, model: `${application_paths_1.paths.NonRealEstateAsset}.MotorVehicle.@Model`, year: `${application_paths_1.paths.NonRealEstateAsset}.MotorVehicle.@Year` });
+    }
+    if ((0, is_asset_type_1.isFinancialAsset)(asset)) {
+        return Object.assign(Object.assign({}, baseMapping), { financialInstitution: `${application_paths_1.paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@FinancialInstitution`, financialInstitutionAccountNumber: `${application_paths_1.paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@AccountNumber`, financialInstitutionBsb: `${application_paths_1.paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@BSB` });
+    }
+    return baseMapping;
+}
+exports.getAssetMapping = getAssetMapping;
+/**
+ * Creates living expense items from a propertyExpense object.
+ *
+ * @param percentOwned: owners of the property
+ * @param assetId: Asset id
+ * @param propertyExpenses: propertyExpenses items
+ * @param percentOwned
+ * @param assetId
+ * @param propertyExpenses
+ */
+function generateLivingExpenses(percentOwned, assetId, propertyExpenses) {
+    let livingExpenses = [];
+    const filteredPropertyExpenses = propertyExpenses.filter((expense) => expense.amount !== undefined);
+    percentOwned.owners.forEach((owner) => {
+        const expenses = filteredPropertyExpenses.map((expense) => {
+            normalizeAmounts(expense);
+            return {
+                '@Amount': (0, round_decimal_1.roundDecimal)(expense.amount * owner.percent),
+                '@Category': enum_mappings_1.livingExpenseMapping[expense.type],
+                '@Frequency': enum_mappings_1.incomeExpenseFrequencyMapping[expense.frequency],
+                '@UniqueID': `${(0, uuid_1.v4)()}--${assetId}`,
+                PercentResponsible: {
+                    Owner: [
+                        {
+                            '@Percent': 100,
+                            '@x_Party': owner.applicantId,
+                        },
+                    ],
+                },
+            };
+        });
+        livingExpenses = livingExpenses.concat(expenses);
+    });
+    return livingExpenses;
+}
+exports.generateLivingExpenses = generateLivingExpenses;
+/**
+ * Creates PropertyExpense array on RealEstateAsset from the same array on the event.
+ *
+ * @param propertyExpenses
+ */
+function generatePropertyExpenses(propertyExpenses) {
+    return propertyExpenses
+        .filter((expense) => expense.amount !== undefined)
+        .map((expense) => {
+        normalizeAmounts(expense);
+        return {
+            '@Amount': expense.amount,
+            '@Category': enum_mappings_1.propertyExpenseCategoryMapping[expense.type],
+            '@Frequency': enum_mappings_1.incomeExpenseFrequencyMapping[expense.frequency],
+        };
+    });
+}
+exports.generatePropertyExpenses = generatePropertyExpenses;
+/**
+ * Determines the occupancy based on the list of property expense types available.
+ *
+ * @param propertyExpenses
+ */
+function determineOccupancy(propertyExpenses) {
+    const propertyExpenseCategoryList = propertyExpenses.map((expense) => expense.type);
+    if (propertyExpenseCategoryList.includes(public_asset_1.PropertyExpenseType.InvestmentPropertyRunningCosts)) {
+        return lixi_internal_request_1.OccupancyList.NonOwner;
+    }
+    else if (propertyExpenseCategoryList.includes(public_asset_1.PropertyExpenseType.PrimaryResidenceRunningCosts && public_asset_1.PropertyExpenseType.SecondaryResidenceRunningCosts)) {
+        return lixi_internal_request_1.OccupancyList.OwnerSecondary;
+    }
+    else if (propertyExpenseCategoryList.some((item) => item !== public_asset_1.PropertyExpenseType.SecondaryResidenceRunningCosts &&
+        item === public_asset_1.PropertyExpenseType.PrimaryResidenceRunningCosts)) {
+        return lixi_internal_request_1.OccupancyList.OwnerPrimary;
+    }
+}
+exports.determineOccupancy = determineOccupancy;
+/**
+ * Calculates the correct amount and frequency.
+ *
+ * @param expense
+ */
+function normalizeAmounts(expense) {
+    if (expense.frequency === public_expense_1.Frequency.Quarterly) {
+        expense.frequency = public_expense_1.Frequency.Yearly;
+        expense.amount *= 4;
+    }
+    return expense;
+}
+exports.normalizeAmounts = normalizeAmounts;

package/lib/transform-events/transform-employment.d.ts

@@ -0,0 +1,8 @@
+import { Payload } from '../types/events/public-employment';
+/**
+ * Generates a partial application from a employment event.
+ *
+ * @param employment a employment event payload.
+ * @returns partialApplication an incomplete application.
+ */
+export declare function transformEmployment(employment: Payload, isSelfEmployed: boolean): {};

package/lib/transform-events/transform-employment.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformEmployment = void 0;
+const lixi_internal_request_1 = require("@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request");
+const lodash_1 = require("lodash");
+const application_paths_1 = require("@lendi/integrations-credit-protocol/utils/application-paths");
+const logger_1 = require("../logger");
+const public_employment_1 = require("../types/events/public-employment");
+const enum_mappings_1 = require("../types/enum-mappings");
+/**
+ * Generates a partial application from a employment event.
+ *
+ * @param employment a employment event payload.
+ * @returns partialApplication an incomplete application.
+ */
+function transformEmployment(employment, isSelfEmployed) {
+    const partialApplication = {};
+    let employmentPath = application_paths_1.paths.PAYG;
+    const companyId = employment.companyId;
+    const { applicationId } = employment;
+    // Each one Employment object can only contain one of the three types. Set the three object to undefined so that the
+    // other two types will be removed from the final result.
+    // @pliu 19/11/19
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.PAYG, undefined);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.SelfEmployed, undefined);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.NotEmployed, undefined);
+    switch (employment.employmentType) {
+        case public_employment_1.EmploymentType.Employee:
+            employmentPath = application_paths_1.paths.PAYG;
+            // Setting default for onProbation. If field exists in event value will get overwritten.
+            (0, lodash_1.set)(partialApplication, `${employmentPath}.@OnProbation`, lixi_internal_request_1.YesNoList.No);
+            break;
+        case public_employment_1.EmploymentType.SelfEmployed:
+            employmentPath = application_paths_1.paths.SelfEmployed;
+            if (companyId && isSelfEmployed) {
+                (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.CompanyApplicant}.@UniqueID`, companyId);
+                (0, lodash_1.set)(partialApplication, `${employmentPath}.@x_Employer`, companyId);
+                break;
+            }
+            break;
+        case public_employment_1.EmploymentType.NotWorking:
+            employmentPath = application_paths_1.paths.NotEmployed;
+            (0, lodash_1.set)(partialApplication, `${employmentPath}.Income.@OtherIncomeAmount`, 0);
+            (0, lodash_1.set)(partialApplication, `${employmentPath}.Income.@OtherIncomeFrequency`, lixi_internal_request_1.List.Fortnightly);
+            break;
+        default:
+            logger_1.logger.warn({ message: `Unknown EmploymentType ${employment.employmentType}`, applicationId });
+    }
+    const employmentMapping = {
+        applicationId: application_paths_1.paths.ApplicationId,
+        applicantId: `${application_paths_1.paths.PersonApplicant}.@UniqueID`,
+        companyId: `${application_paths_1.paths.RelatedCompany}.@UniqueID`,
+        id: `${employmentPath}.@UniqueID`,
+        type: `${employmentPath}.@Status`,
+        employmentBasis: `${employmentPath}.@Basis`,
+        startDate: `${employmentPath}.@StartDate`,
+        endDate: `${employmentPath}.@EndDate`,
+        role: `${employmentPath}.@Occupation`,
+        onProbation: `${employmentPath}.@OnProbation`,
+    };
+    for (const [key, value] of Object.entries(employment)) {
+        if (employmentMapping[key]) {
+            switch (key) {
+                case 'type':
+                    (0, lodash_1.set)(partialApplication, employmentMapping[key], (0, lodash_1.capitalize)(value));
+                    break;
+                case 'employmentBasis':
+                    (0, lodash_1.set)(partialApplication, employmentMapping[key], enum_mappings_1.paygEmploymentBasisMapping[value]);
+                    break;
+                case 'companyId':
+                    if (isSelfEmployed && employment.employmentType === public_employment_1.EmploymentType.Employee) {
+                        (0, lodash_1.set)(partialApplication, `${employmentPath}.@x_Employer`, value);
+                        (0, lodash_1.set)(partialApplication, employmentMapping[key], value);
+                    }
+                    if (!isSelfEmployed) {
+                        (0, lodash_1.set)(partialApplication, `${employmentPath}.@x_Employer`, value);
+                        (0, lodash_1.set)(partialApplication, employmentMapping[key], value);
+                    }
+                    break;
+                case 'onProbation':
+                    if (employment.employmentType === public_employment_1.EmploymentType.Employee) {
+                        const onProbation = value ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No;
+                        (0, lodash_1.set)(partialApplication, employmentMapping[key], onProbation);
+                    }
+                    break;
+                case 'role':
+                    const { anzsco = {}, asco = {} } = value;
+                    if (anzsco.code) {
+                        (0, lodash_1.set)(partialApplication, `${employmentPath}.@ANZSCOOccupationCode`, anzsco.code.toString());
+                    }
+                    if (asco.code) {
+                        (0, lodash_1.set)(partialApplication, `${employmentPath}.@OccupationCode`, asco.code);
+                    }
+                    if (anzsco.occupation) {
+                        (0, lodash_1.set)(partialApplication, employmentMapping[key], anzsco.occupation);
+                    }
+                    break;
+                default:
+                    (0, lodash_1.set)(partialApplication, employmentMapping[key], value);
+                    break;
+            }
+        }
+    }
+    return partialApplication;
+}
+exports.transformEmployment = transformEmployment;

package/lib/transform-events/transform-expenses.d.ts

@@ -0,0 +1,41 @@
+import { LivingExpense, OtherCommitment } from '@lendi/act-eac-integrations-protocol/lib/types/lixi-internal-request';
+import { Expense, ExpenseType, Payload as ExpensePayload } from '../types/events/public-expense';
+import { PartialApplication } from '../types/partial-application';
+export declare const otherCommitmentExpenseTypes: ExpenseType[];
+/**
+ * @description Transforms expense items on the application from the event.
+ * @returns {PartialApplication} A PartialApplication returned by transforming the expense event.
+ * @param expense
+ */
+export declare function transformExpenses(expense: ExpensePayload): PartialApplication;
+/**
+ * transforms the living expense from the expense array on the event.
+ *
+ * @param expense: Array of expenses on the event.
+ * @param applicantId: Event applicantId.
+ * @param index: Index of the map.
+ * @param id: Id of the event.
+ * @param expense
+ * @param applicantId
+ * @param index
+ * @param id
+ */
+export declare function transformExpense(expense: Expense, applicantId: string, index: number, id: string): LivingExpense | OtherCommitment;
+/**
+ * @description Normalises expense by amount to 0 if not provided and scales quarterly spending up to yearly.
+ * @param {Expense} expense An expense
+ * @returns {Expense} An normalised expense.
+ */
+export declare function normaliseExpenseAmount(expense: Expense): Expense;
+/**
+ * @description Verify if expense is an OtherCommitment.
+ * @param {Expense} expense Any Expense item.
+ * @returns {boolean} Returns true if an expense type is one of other commitment expenses.
+ */
+export declare function isOtherCommitment(expense: Expense): boolean;
+/**
+ * @description Check if expense type is LivingExpenseEstimate.
+ * @param {Expense} expense An Expense item.
+ * @returns {boolean} Returns true if an expense type is LivingExpenseEstimate
+ */
+export declare function isLivingExpenseEstimate(expense: Expense): boolean;