stand_socotra_policy_transformer 3.0.1 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stand_socotra_policy_transformer",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Stands internal javascript module for executing underwriting",
   "main": "dist/stand_underwriter.js",
   "scripts": {

package/src/retool_utils/socotra_payloads.js

@@ -1,4 +1,4 @@
-const {SocotraEntry} = require("./socotra_structure_helper");
+const {SocotraEntry, SocotraGroupEntry} = require("./socotra_structure_helper");
 class SocotraPayloadConverter {
     constructor(entries) {
         this.entries = entries
@@ -79,7 +79,11 @@ class SocotraPayloadConverter {
         let payload = SocotraEntry.socotra_create_update_template(dwelling_exposure_locator)
         this.entries.forEach(entry => {
             if (Object.keys(retool_payload).includes(entry.retool_id)) {
-                entry.socotra_update(retool_payload, payload)
+                if(entry instanceof  SocotraGroupEntry){
+                    entry.socotra_update(retool_payload, payload, old_payload)
+                } else{
+                    entry.socotra_update(retool_payload, payload)
+                }
             }
         })
 
@@ -133,4 +137,4 @@ class SocotraPayloadConverter {
     }
 }
 
-module.exports = {SocotraPayloadConverter}
+module.exports = {SocotraPayloadConverter}

package/src/retool_utils/socotra_structure_helper.js

@@ -3,6 +3,7 @@ const { DateTime } = require('luxon');
 const socotra_locations = Object.freeze([
     'policy.fields',
     'policy.fields.array',
+    'policy.fields.group',
     'exposure.dwelling.fields',
     'policy.group',
     'policy',
@@ -236,6 +237,246 @@ class SocotraEntry {
     }
 }
 
+class SocotraGroupEntry extends SocotraEntry {
+    constructor(retool_id, socotra_id, socotra_location, socotra_schema = {}, retool_schema = {}) {
+        super(retool_id, socotra_id, socotra_location);
+        this.socotra_schema = socotra_schema;
+        this.retool_schema = retool_schema;
+    }
+
+    socotra_create_response(json_payload, socotra_response) {
+        // Handle nested data structure
+        const path = this.retool_id.split('.');
+        let data = json_payload;
+
+        // Navigate through the nested structure
+        for (const key of path) {
+            if (data && data[key] !== undefined) {
+                data = data[key];
+            } else {
+                // If the path doesn't exist, return
+                return;
+            }
+        }
+
+        // If data is an array, process each item
+        if (Array.isArray(data)) {
+            // Initialize fieldGroups if it doesn't exist
+            if (!socotra_response.fieldGroups) {
+                socotra_response.fieldGroups = [];
+            }
+
+            // Transform each item according to the schemas
+            const transformedData = data.map(item => {
+                const fieldValues = {};
+
+                // Map fields from retool schema to socotra schema
+                for (const [socotraField, retoolField] of Object.entries(this.socotra_schema)) {
+                    // If the retool field starts with ':', it's a direct mapping
+                    if (retoolField.startsWith(':')) {
+                        const actualRetoolField = retoolField.substring(1);
+                        if (item[actualRetoolField] !== undefined) {
+                            fieldValues[socotraField] = item[actualRetoolField];
+                        }
+                    }
+                }
+
+                return {
+                    fieldName: this.socotra_id,
+                    fieldValues: fieldValues
+                };
+            });
+
+            // Add the transformed data to the response
+            socotra_response.fieldGroups = transformedData;
+        }
+    }
+
+    retool_response(socotra_payload, retool_response) {
+        // Handle group entities for Socotra to Retool transformation
+        if (this.socotra_location === 'policy.fields.group') {
+            // Get the field values from the Socotra payload
+            const fieldValues = socotra_payload.characteristics.fieldValues;
+            const fieldGroupsByLocator = socotra_payload.characteristics.fieldGroupsByLocator;
+
+            // Check if the field exists and has values
+            if (fieldValues && fieldValues[this.socotra_id] && fieldGroupsByLocator) {
+                // Initialize the nested structure in the retool response
+                const path = this.retool_id.split('.');
+                let current = retool_response;
+
+                // Create the nested structure
+                for (let i = 0; i < path.length - 1; i++) {
+                    if (!current[path[i]]) {
+                        current[path[i]] = {};
+                    }
+                    current = current[path[i]];
+                }
+
+                // Get the locators for the group entities
+                const locators = fieldValues[this.socotra_id];
+
+                // Initialize the array for the group entities
+                current[path[path.length - 1]] = [];
+
+                // Transform each group entity
+                for (const locator of locators) {
+                    if (fieldGroupsByLocator[locator]) {
+                        const groupData = fieldGroupsByLocator[locator];
+                        const retoolItem = {};
+
+                        // Map fields from socotra schema to retool schema
+                        for (const [socotraField, retoolField] of Object.entries(this.retool_schema)) {
+                            // If the retool field starts with ':', it's a direct mapping
+                            if (retoolField.startsWith(':')) {
+                                const actualRetoolField = retoolField.substring(1);
+                                if (groupData[socotraField] && groupData[socotraField][0] !== undefined) {
+                                    retoolItem[actualRetoolField] = groupData[socotraField][0];
+                                }
+                            }
+                        }
+
+                        // Add the socotra field locator
+                        retoolItem.socotra_field_locator = locator;
+
+                        // Add the transformed item to the array
+                        current[path[path.length - 1]].push(retoolItem);
+                    }
+                }
+            }
+            return;
+        }
+
+        // Fall back to the parent class implementation for non-group fields
+        return super.retool_response(socotra_payload, retool_response);
+    }
+
+    // Helper function to navigate through nested structure
+    _navigateNestedStructure(obj, path) {
+        let result = obj;
+        for (const key of path) {
+            if (result && result[key] !== undefined) {
+                result = result[key];
+            } else {
+                // If the path doesn't exist, return empty array
+                return [];
+            }
+        }
+        return result;
+    }
+
+    // Helper function to create field values from an item
+    _createFieldValues(item) {
+        const fieldValues = {};
 
+        // Map fields from retool schema to socotra schema
+        for (const [socotraField, retoolField] of Object.entries(this.socotra_schema)) {
+            // If the retool field starts with ':', it's a direct mapping
+            if (retoolField.startsWith(':')) {
+                const actualRetoolField = retoolField.substring(1);
+                if (item[actualRetoolField] !== undefined) {
+                    fieldValues[socotraField] = item[actualRetoolField];
+                }
+            }
+        }
+
+        return fieldValues;
+    }
+
+    // Helper function to add an item to addFieldGroups
+    _addItemToFieldGroups(item, socotra_response) {
+        // Skip explicit remove operations
+        if (item.remove === true) return;
+
+        // Transform the item for add
+        const fieldValues = this._createFieldValues(item);
+
+        // Add to addFieldGroups
+        socotra_response.addFieldGroups.push({
+            fieldName: this.socotra_id,
+            fieldValues: fieldValues
+        });
+    }
+
+    // Helper function to process explicit remove operations
+    _processRemoveOperations(data, socotra_response) {
+        for (const item of data) {
+            if (item.remove === true && item.locator) {
+                // Add to removeFieldGroups
+                socotra_response.removeFieldGroups.push(item.locator);
+            }
+        }
+    }
+
+    // Helper function to create a comparison key for an item
+    _createComparisonKey(item) {
+        const itemCopy = { ...item };
+        delete itemCopy.socotra_field_locator;
+        return JSON.stringify(itemCopy);
+    }
+
+    socotra_update(retool_payload, socotra_response, old_payload) {
+        // Handle nested data structure
+        const path = this.retool_id.split('.');
+        let data = this._navigateNestedStructure(retool_payload, path);
+        let oldData = old_payload ? this._navigateNestedStructure(old_payload, path) : [];
+
+        // Initialize arrays for different operations if they don't exist
+        if (!socotra_response.addFieldGroups) {
+            socotra_response.addFieldGroups = [];
+        }
+        if (!socotra_response.removeFieldGroups) {
+            socotra_response.removeFieldGroups = [];
+        }
+
+        // Process explicit remove operations first
+        this._processRemoveOperations(data, socotra_response);
+
+        // If old_payload is provided, compare new and old data
+        if (old_payload && Array.isArray(oldData) && Array.isArray(data)) {
+            // Create a map of new items for easier comparison
+            const newItemsMap = new Map();
+            for (const item of data) {
+                // Create a key for comparison (excluding socotra_field_locator)
+                const key = this._createComparisonKey(item);
+                newItemsMap.set(key, item);
+            }
+
+            // Check old items
+            for (const oldItem of oldData) {
+                // Create a key for comparison (excluding socotra_field_locator)
+                const key = this._createComparisonKey(oldItem);
+
+                // If the item exists in both old and new, it's a match - skip it
+                if (newItemsMap.has(key)) {
+                    newItemsMap.delete(key);
+                } 
+                // If the item only exists in old, remove it
+                else if (oldItem.socotra_field_locator) {
+                    socotra_response.removeFieldGroups.push(oldItem.socotra_field_locator);
+                }
+            }
+
+            // Add items that only exist in new
+            for (const item of newItemsMap.values()) {
+                this._addItemToFieldGroups(item, socotra_response);
+            }
+        } 
+        // If no old_payload, process as before
+        else {
+            for (const item of data) {
+                this._addItemToFieldGroups(item, socotra_response);
+            }
+        }
+
+        // Remove empty arrays
+        if (socotra_response.addFieldGroups.length === 0) {
+            delete socotra_response.addFieldGroups;
+        }
+        if (socotra_response.removeFieldGroups.length === 0) {
+            delete socotra_response.removeFieldGroups;
+        }
+    }
+}
 
-module.exports = {SocotraEntry}
+module.exports = {SocotraEntry, SocotraGroupEntry}

package/src/retool_utils/versions/stand_v3_entries.js

@@ -1,4 +1,4 @@
-const {SocotraEntry} = require("../socotra_structure_helper");
+const {SocotraEntry, SocotraGroupEntry} = require("../socotra_structure_helper");
 
 function solar_panel_functions() {
     let to_socotra_map = {0: "No", "1+": "Yes"}
@@ -204,8 +204,44 @@ entries_v3 = [
 
     ]
 
-
-
-
-
-module.exports = {entries_v3}
+// Define schemas for Groups
+const additional_insured_socotra_schema = {
+    type: ":type",
+    name: ":name",
+    street_address: ":street_address",
+    street_address2: ":street_address2",
+    city: ":city",
+    state: ":state",
+    zip: ":zip",
+    description: ":description",
+    loan_number: ":loan_number"
+};
+
+const additional_insured_retool_schema = {
+    zip: ":zip",
+    street_address: ":street_address",
+    loan_number: ":loan_number",
+    city: ":city",
+    street_address2: ":street_address2",
+    state: ":state",
+    type: ":type",
+    name: ":name",
+    description: ":description"
+};
+
+// Add additional insured to entries_v3
+entries_v3.push(
+    new SocotraGroupEntry(
+        "additional_insured_data.additionalInterest", 
+        "additional_insured", 
+        "policy.fields.group", 
+        additional_insured_socotra_schema, 
+        additional_insured_retool_schema
+    )
+);
+
+
+
+
+
+module.exports = {entries_v3}