@lendi/integrations-transform 1.6.0 → 1.6.1

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

@@ -1,24 +1,27 @@
-import { Custom6TypeList, NonRealEstateAssetTypeList, OtherAssetTypeList, ResidentialTypeList, YesNoList, OccupancyList, } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
-import { paths } from '@lendi/integrations-credit-protocol/utils/application-paths';
-import { Custom1CategoryTypeNameList, Custom2PropertyTypeNameList, } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
-import { v4 as uuidv4 } from 'uuid';
-import { isEmpty, set } from 'lodash';
-import { logger } from '../logger';
-import { assetTypeMapping, financialAssetMapping, incomeExpenseFrequencyMapping, livingExpenseMapping, primaryPurposeMapping, propertyExpenseCategoryMapping, propertyStatusMapping, propertyTypeMapping, toBePurchasedMapping, toBeUsedAsSecurityMapping, } from '../types/enum-mappings';
-import { AssetType, PropertyExpenseType, ZoneType, } from '../types/events/public-asset';
-import { Frequency } from '../types/events/public-expense';
-import { getFinancialInstitution } from '../utils/get-financial-institution';
-import { isFinancialAsset, isMotorVehicle, isOtherAsset, isRealEstateAsset } from '../utils/is-asset-type';
-import { roundDecimal } from '../utils/round-decimal';
-import { transformAddress } from './transform-asset-address';
-import { transformPercentOwned } from './transform-percent-owned';
-import { builderTypeMapping } from '../types/enum-mappings/builder-type';
-import { constructionTypeMapping } from '../types/enum-mappings/construction-type';
-import { booleanMapping } from '..';
-export const propertyTypeNameList = Object.values(Custom2PropertyTypeNameList);
-export const residentialTypeList = Object.values(ResidentialTypeList);
+"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/integrations-protocol/lib/types/lixi-internal-request");
+const uuid_1 = require("uuid");
+const lodash_1 = require("lodash");
+const logger_1 = require("../logger");
+const enum_mappings_1 = require("../types/enum-mappings");
+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");
+const builder_type_1 = require("../types/enum-mappings/builder-type");
+const construction_type_1 = require("../types/enum-mappings/construction-type");
+const __1 = require("..");
+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 = `${paths.RealEstateAsset}.ConstructionDetails`;
+const constructionDetailsPath = `${application_paths_1.paths.RealEstateAsset}.ConstructionDetails`;
 const constructionDetailsMapping = {
     builderType: `${constructionDetailsPath}.@BuilderType`,
     buildPriceAmount: `${constructionDetailsPath}.@BuildPriceAmount`,
@@ -34,42 +37,42 @@ const constructionDetailsMapping = {
  * @param {Payload} asset - A partial public asset.
  * @returns {PartialApplication} A partial InternalRequest.
  */
-export function transformAsset({ asset, applicationId, id }) {
+function transformAsset({ asset, applicationId, id }) {
     var _a;
-    const isPropertyAsset = isRealEstateAsset(asset);
-    const idPath = isPropertyAsset ? `${paths.RealEstateAsset}.@UniqueID` : `${paths.NonRealEstateAsset}.@UniqueID`;
+    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 = {};
-    set(partialApplication, paths.ApplicationId, applicationId);
-    set(partialApplication, idPath, id);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
+    (0, lodash_1.set)(partialApplication, idPath, id);
     if (isPropertyAsset) {
-        set(partialApplication, `${paths.RealEstateAsset}.@MultipleDwellings`, YesNoList.No);
-        set(partialApplication, `${paths.RealEstateAsset}.@x_Address`, addressId);
+        (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 {
-        set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, assetTypeMapping[asset.type]);
+        (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.@Type`, enum_mappings_1.assetTypeMapping[asset.type]);
     }
-    if (isFinancialAsset(asset)) {
-        set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, NonRealEstateAssetTypeList.FinancialAsset);
-        set(partialApplication, `${paths.NonRealEstateAsset}.FinancialAsset.@Type`, financialAssetMapping[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 (isOtherAsset(asset)) {
-        set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, NonRealEstateAssetTypeList.Other);
+    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 AssetType.Vehicle:
-            set(partialApplication, `${paths.NonRealEstateAsset}.@Type`, NonRealEstateAssetTypeList.MotorVehicleAndTransport);
+        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 AssetType.HomeContents:
-            set(partialApplication, `${paths.NonRealEstateAsset}.OtherAsset.@Type`, OtherAssetTypeList.HomeContents);
+        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 AssetType.Gifts:
-            set(partialApplication, `${paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description || 'Asset Gifts');
+        case public_asset_1.AssetType.Gifts:
+            (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description || 'Asset Gifts');
             break;
-        case AssetType.OtherAsset:
+        case public_asset_1.AssetType.OtherAsset:
             if (asset.description) {
-                set(partialApplication, `${paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description);
+                (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.NonRealEstateAsset}.OtherAsset.@Description`, asset.description);
             }
             break;
     }
@@ -79,167 +82,170 @@ export function transformAsset({ asset, applicationId, id }) {
                 case 'contractDetails':
                     const { contractDate } = value;
                     if (contractDate)
-                        set(partialApplication, assetMapping.contractDate, contractDate);
+                        (0, lodash_1.set)(partialApplication, assetMapping.contractDate, contractDate);
                     break;
                 case 'primaryPurpose':
-                    set(partialApplication, assetMapping[key], primaryPurposeMapping[value]);
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.primaryPurposeMapping[value]);
                     break;
                 case 'toBePurchased':
-                    set(partialApplication, assetMapping[key], toBePurchasedMapping[value]);
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.toBePurchasedMapping[value]);
                     break;
                 case 'propertyExpenses':
-                    if (!asset.percentOwned || isEmpty((_a = asset.percentOwned) === null || _a === void 0 ? void 0 : _a.owners)) {
+                    if (!asset.percentOwned || (0, lodash_1.isEmpty)((_a = asset.percentOwned) === null || _a === void 0 ? void 0 : _a.owners)) {
                         break;
                     }
                     const propertyExpenses = generatePropertyExpenses(value);
-                    set(partialApplication, `${paths.RealEstateAsset}.PropertyExpense`, propertyExpenses);
+                    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.RealEstateAsset}.PropertyExpense`, propertyExpenses);
                     const livingExpenses = generateLivingExpenses(asset.percentOwned, id, value);
-                    set(partialApplication, assetMapping[key], livingExpenses);
-                    set(partialApplication, `${paths.RealEstateAsset}.@Occupancy`, determineOccupancy(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':
-                    set(partialApplication, assetMapping[key], propertyStatusMapping[value]);
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.propertyStatusMapping[value]);
                     break;
                 case 'toBeUsedAsSecurity':
                     if (isPropertyAsset)
-                        set(partialApplication, assetMapping[key], toBeUsedAsSecurityMapping[value]);
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], enum_mappings_1.toBeUsedAsSecurityMapping[value]);
                     break;
                 case 'propertyType':
                     const propertyTypeMapping = getPropertyType(value);
                     if (!propertyTypeMapping) {
-                        logger.warn({ message: `Unknown propertyType ${value} for asset ${id}`, applicationId });
+                        logger_1.logger.warn({ message: `Unknown propertyType ${value} for asset ${id}`, applicationId });
                     }
                     const { path, value: mappedValue } = propertyTypeMapping;
-                    set(partialApplication, path, mappedValue);
+                    (0, lodash_1.set)(partialApplication, path, mappedValue);
                     break;
                 case 'zoneType':
-                    if (asset.zoneType === ZoneType.Commercial) {
-                        set(partialApplication, `${paths.RealEstateAsset}.Commercial.@Type`, OtherAssetTypeList.Other);
-                        set(partialApplication, assetMapping[key], Custom6TypeList.Commercial);
+                    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 {
-                        set(partialApplication, assetMapping[key], Custom6TypeList.Residential);
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], lixi_internal_request_1.Custom6TypeList.Residential);
                     }
                     break;
                 case 'financialInstitution':
-                    if (isFinancialAsset(asset)) {
-                        const financialInstitution = getFinancialInstitution(value.toString());
-                        set(partialApplication, assetMapping[key], 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':
-                    set(partialApplication, assetMapping[key], value.toString());
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], value.toString());
                     break;
                 case 'address':
-                    set(partialApplication, assetMapping[key], transformAddress(value, addressId));
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], (0, transform_asset_address_1.transformAddress)(value, addressId));
                     break;
                 case 'isConstruction':
-                    set(partialApplication, assetMapping[key], booleanMapping(value));
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], (0, __1.booleanMapping)(value));
                     break;
                 case 'percentOwned':
-                    const percentOwned = transformPercentOwned(value);
+                    const percentOwned = (0, transform_percent_owned_1.transformPercentOwned)(value);
                     if (percentOwned) {
-                        set(partialApplication, assetMapping[key], percentOwned);
+                        (0, lodash_1.set)(partialApplication, assetMapping[key], percentOwned);
                     }
                     break;
                 case 'constructionDetails':
                     for (const [key, constructionDetailsValue] of Object.entries(value)) {
                         switch (key) {
                             case 'builderType':
-                                set(partialApplication, constructionDetailsMapping[key], builderTypeMapping[constructionDetailsValue]);
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], builder_type_1.builderTypeMapping[constructionDetailsValue]);
                                 break;
                             case 'constructionType':
-                                set(partialApplication, constructionDetailsMapping[key], constructionTypeMapping[constructionDetailsValue]);
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], construction_type_1.constructionTypeMapping[constructionDetailsValue]);
                                 break;
                             case 'isFixedPriceContract':
-                                set(partialApplication, constructionDetailsMapping[key], booleanMapping(constructionDetailsValue));
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], (0, __1.booleanMapping)(constructionDetailsValue));
                                 break;
                             default:
-                                set(partialApplication, constructionDetailsMapping[key], constructionDetailsValue);
+                                (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], constructionDetailsValue);
                                 break;
                         }
                     }
                     break;
                 case 'estimatedValue':
                     if (asset.isConstruction) {
-                        set(partialApplication, constructionDetailsMapping[key], value);
+                        (0, lodash_1.set)(partialApplication, constructionDetailsMapping[key], value);
                     }
-                    set(partialApplication, assetMapping[key], value);
+                    (0, lodash_1.set)(partialApplication, assetMapping[key], value);
                     break;
                 default:
-                    set(partialApplication, assetMapping[key], value);
+                    (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.
  */
-export function getPropertyType(propertyType) {
-    const value = propertyTypeMapping[propertyType];
-    if (residentialTypeList.includes(value)) {
+function getPropertyType(propertyType) {
+    const value = enum_mappings_1.propertyTypeMapping[propertyType];
+    if (exports.residentialTypeList.includes(value)) {
         return {
-            path: `${paths.RealEstateAsset}.Residential`,
+            path: `${application_paths_1.paths.RealEstateAsset}.Residential`,
             value: {
                 '@Type': value,
             },
         };
     }
-    if (propertyTypeNameList.includes(value)) {
+    if (exports.propertyTypeNameList.includes(value)) {
         return {
-            path: `${paths.RealEstateAsset}.PropertyType`,
+            path: `${application_paths_1.paths.RealEstateAsset}.PropertyType`,
             value: {
                 '@PropertyTypeName': value,
-                '@CategoryTypeName': Custom1CategoryTypeNameList.Residential,
+                '@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.
  */
-export function getAssetMapping(asset) {
-    let estimatedValue = `${paths.NonRealEstateAsset}.EstimatedValue.@Value`;
-    let percentOwned = `${paths.NonRealEstateAsset}.PercentOwned`;
+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 (isRealEstateAsset(asset)) {
-        estimatedValue = `${paths.RealEstateAsset}.EstimatedValue.@Value`;
-        percentOwned = `${paths.RealEstateAsset}.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: paths.Address,
+            address: application_paths_1.paths.Address,
             contractDetails: 'contractDetails',
-            contractDate: `${paths.RealEstateAsset}.ContractDetails.@ContractDate`,
+            contractDate: `${application_paths_1.paths.RealEstateAsset}.ContractDetails.@ContractDate`,
             estimatedValue,
             percentOwned,
-            primaryPurpose: `${paths.RealEstateAsset}.@PrimaryPurpose`,
-            propertyExpenses: paths.LivingExpenses,
-            propertyStatus: `${paths.RealEstateAsset}.@Status`,
-            propertyType: `${paths.RealEstateAsset}.Residential`,
-            toBePurchased: `${paths.RealEstateAsset}.@Transaction`,
-            toBeUsedAsSecurity: `${paths.RealEstateAsset}.@ToBeUsedAsSecurity`,
-            zoneType: `${paths.RealEstateAsset}.Zoning.@Type`,
-            isConstruction: `${paths.RealEstateAsset}.@Construction`,
-            constructionDetails: `${paths.RealEstateAsset}.ConstructionDetails`,
+            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 (isMotorVehicle(asset)) {
-        return Object.assign(Object.assign({}, baseMapping), { make: `${paths.NonRealEstateAsset}.MotorVehicle.@Make`, model: `${paths.NonRealEstateAsset}.MotorVehicle.@Model`, year: `${paths.NonRealEstateAsset}.MotorVehicle.@Year` });
+    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 (isFinancialAsset(asset)) {
-        return Object.assign(Object.assign({}, baseMapping), { financialInstitution: `${paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@FinancialInstitution`, financialInstitutionAccountNumber: `${paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@AccountNumber`, financialInstitutionBsb: `${paths.NonRealEstateAsset}.FinancialAsset.AccountNumber.@BSB` });
+    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.
  *
@@ -250,17 +256,17 @@ export function getAssetMapping(asset) {
  * @param assetId
  * @param propertyExpenses
  */
-export function generateLivingExpenses(percentOwned, assetId, 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': roundDecimal(expense.amount * owner.percent),
-                '@Category': livingExpenseMapping[expense.type],
-                '@Frequency': incomeExpenseFrequencyMapping[expense.frequency],
-                '@UniqueID': `${uuidv4()}--${assetId}`,
+                '@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: [
                         {
@@ -275,50 +281,54 @@ export function generateLivingExpenses(percentOwned, assetId, propertyExpenses)
     });
     return livingExpenses;
 }
+exports.generateLivingExpenses = generateLivingExpenses;
 /**
  * Creates PropertyExpense array on RealEstateAsset from the same array on the event.
  *
  * @param propertyExpenses
  */
-export function generatePropertyExpenses(propertyExpenses) {
+function generatePropertyExpenses(propertyExpenses) {
     return propertyExpenses
         .filter((expense) => expense.amount !== undefined)
         .map((expense) => {
         normalizeAmounts(expense);
         return {
             '@Amount': expense.amount,
-            '@Category': propertyExpenseCategoryMapping[expense.type],
-            '@Frequency': incomeExpenseFrequencyMapping[expense.frequency],
+            '@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
  */
-export function determineOccupancy(propertyExpenses) {
+function determineOccupancy(propertyExpenses) {
     const propertyExpenseCategoryList = propertyExpenses.map((expense) => expense.type);
-    if (propertyExpenseCategoryList.includes(PropertyExpenseType.InvestmentPropertyRunningCosts)) {
-        return OccupancyList.NonOwner;
+    if (propertyExpenseCategoryList.includes(public_asset_1.PropertyExpenseType.InvestmentPropertyRunningCosts)) {
+        return lixi_internal_request_1.OccupancyList.NonOwner;
     }
-    else if (propertyExpenseCategoryList.includes(PropertyExpenseType.PrimaryResidenceRunningCosts && PropertyExpenseType.SecondaryResidenceRunningCosts)) {
-        return OccupancyList.OwnerSecondary;
+    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 !== PropertyExpenseType.SecondaryResidenceRunningCosts &&
-        item === PropertyExpenseType.PrimaryResidenceRunningCosts)) {
-        return OccupancyList.OwnerPrimary;
+    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
  */
-export function normalizeAmounts(expense) {
-    if (expense.frequency === Frequency.Quarterly) {
-        expense.frequency = Frequency.Yearly;
+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-expenses.js

@@ -1,24 +1,27 @@
-import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
-import { get, set, sumBy } from 'lodash';
-import { frequencyMapping, livingExpenseMapping } from '../types/enum-mappings/';
-import { ExpenseType, Frequency } from '../types/events/public-expense';
-export const otherCommitmentExpenseTypes = [
-    ExpenseType.Board,
-    ExpenseType.ChildAndSpousalMaintenance,
-    ExpenseType.Rent,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLivingExpenseEstimate = exports.isOtherCommitment = exports.normaliseExpenseAmount = exports.transformExpense = exports.transformExpenses = exports.otherCommitmentExpenseTypes = void 0;
+const application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
+const lodash_1 = require("lodash");
+const enum_mappings_1 = require("../types/enum-mappings/");
+const public_expense_1 = require("../types/events/public-expense");
+exports.otherCommitmentExpenseTypes = [
+    public_expense_1.ExpenseType.Board,
+    public_expense_1.ExpenseType.ChildAndSpousalMaintenance,
+    public_expense_1.ExpenseType.Rent,
 ];
 const propertyExpenseCategories = [
-    ExpenseType.InvestmentPropertyRunningCosts,
-    ExpenseType.BodyCorporateFeesStrataFeesAndLandTax,
-    ExpenseType.SecondaryResidenceRunningCosts,
-    ExpenseType.PrimaryResidenceRunningCosts,
+    public_expense_1.ExpenseType.InvestmentPropertyRunningCosts,
+    public_expense_1.ExpenseType.BodyCorporateFeesStrataFeesAndLandTax,
+    public_expense_1.ExpenseType.SecondaryResidenceRunningCosts,
+    public_expense_1.ExpenseType.PrimaryResidenceRunningCosts,
 ];
 /**
  * @description Transforms expense items on the application from the event.
  * @returns {PartialApplication} A PartialApplication returned by transforming the expense event.
  * @param expense
  */
-export function transformExpenses(expense) {
+function transformExpenses(expense) {
     const partialApplication = {};
     const { applicantId, applicationId, expenses = [], id } = expense;
     if (expenses.every((expense) => expense.amount === undefined || expense.amount === null)) {
@@ -29,8 +32,8 @@ export function transformExpenses(expense) {
     const livingExpenseEstimate = filteredLivingExpensesWithAmount.find(isLivingExpenseEstimate);
     const otherCommitments = filteredLivingExpensesWithAmount.filter(isOtherCommitment);
     const expenseBreakdown = filteredLivingExpensesWithAmount.filter((item) => !(isOtherCommitment(item) || isLivingExpenseEstimate(item)));
-    const livingExpenseEstimateExists = get(livingExpenseEstimate || {}, 'amount', 0) > 0;
-    const expenseBreakdownAmountSum = sumBy(expenseBreakdown, 'amount');
+    const livingExpenseEstimateExists = (0, lodash_1.get)(livingExpenseEstimate || {}, 'amount', 0) > 0;
+    const expenseBreakdownAmountSum = (0, lodash_1.sumBy)(expenseBreakdown, 'amount');
     let lixiLivingExpenses;
     // unless all individual expenses have a value of 0 and a living estimate exists, transform them without question.
     if (expenseBreakdownAmountSum === 0 && livingExpenseEstimateExists) {
@@ -41,15 +44,16 @@ export function transformExpenses(expense) {
         lixiLivingExpenses = expenseBreakdown.map((expense, index) => transformExpense(expense, applicantId, index, id));
     }
     const lixiCommitmentExpenses = otherCommitments.map((expense, index) => transformExpense(expense, applicantId, index, id));
-    set(partialApplication, paths.ApplicationId, applicationId);
-    set(partialApplication, `${paths.Household}.@UniqueID`, `${applicationId}-household`);
-    set(partialApplication, `${paths.PersonApplicant}.@UniqueID`, applicantId);
-    set(partialApplication, paths.OtherCommitments, lixiCommitmentExpenses);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
+    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.Household}.@UniqueID`, `${applicationId}-household`);
+    (0, lodash_1.set)(partialApplication, `${application_paths_1.paths.PersonApplicant}.@UniqueID`, applicantId);
+    (0, lodash_1.set)(partialApplication, application_paths_1.paths.OtherCommitments, lixiCommitmentExpenses);
     if (lixiLivingExpenses.length > 0) {
-        set(partialApplication, paths.LivingExpenses, lixiLivingExpenses);
+        (0, lodash_1.set)(partialApplication, application_paths_1.paths.LivingExpenses, lixiLivingExpenses);
     }
     return partialApplication;
 }
+exports.transformExpenses = transformExpenses;
 /**
  * transforms the living expense from the expense array on the event.
  *
@@ -62,13 +66,13 @@ export function transformExpenses(expense) {
  * @param index
  * @param id
  */
-export function transformExpense(expense, applicantId, index, id) {
+function transformExpense(expense, applicantId, index, id) {
     return {
         '@Amount': expense.amount,
-        '@Category': livingExpenseMapping[expense.type],
+        '@Category': enum_mappings_1.livingExpenseMapping[expense.type],
         '@Description': expense.type,
         '@UniqueID': isOtherCommitment(expense) ? `${id}-commitment-${index}` : `${id}-living-expense-${index}`,
-        '@Frequency': frequencyMapping[expense.frequency],
+        '@Frequency': enum_mappings_1.frequencyMapping[expense.frequency],
         PercentResponsible: {
             Owner: [
                 {
@@ -79,15 +83,16 @@ export function transformExpense(expense, applicantId, index, id) {
         },
     };
 }
+exports.transformExpense = transformExpense;
 /**
  * @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 function normaliseExpenseAmount(expense) {
-    const { amount, frequency = Frequency.Yearly, type: expenseType } = expense;
-    if (frequency === Frequency.Quarterly) {
-        expense.frequency = Frequency.Yearly;
+function normaliseExpenseAmount(expense) {
+    const { amount, frequency = public_expense_1.Frequency.Yearly, type: expenseType } = expense;
+    if (frequency === public_expense_1.Frequency.Quarterly) {
+        expense.frequency = public_expense_1.Frequency.Yearly;
         expense.amount *= 4;
     }
     if (!amount && !propertyExpenseCategories.includes(expenseType)) {
@@ -95,19 +100,22 @@ export function normaliseExpenseAmount(expense) {
     }
     return expense;
 }
+exports.normaliseExpenseAmount = normaliseExpenseAmount;
 /**
  * @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 function isOtherCommitment(expense) {
-    return otherCommitmentExpenseTypes.includes(expense.type);
+function isOtherCommitment(expense) {
+    return exports.otherCommitmentExpenseTypes.includes(expense.type);
 }
+exports.isOtherCommitment = isOtherCommitment;
 /**
  * @description Check if expense type is LivingExpenseEstimate.
  * @param {Expense} expense An Expense item.
  * @returns {boolean} Returns true if an expense type is LivingExpenseEstimate
  */
-export function isLivingExpenseEstimate(expense) {
-    return expense.type === ExpenseType.LivingExpensesEstimate;
+function isLivingExpenseEstimate(expense) {
+    return expense.type === public_expense_1.ExpenseType.LivingExpensesEstimate;
 }
+exports.isLivingExpenseEstimate = isLivingExpenseEstimate;