stand_socotra_policy_transformer 3.0.11 → 3.0.13

package/src/retool_utils/socotra_structure_helper.js

@@ -1,687 +0,0 @@
-const { DateTime } = require('luxon');
-
-const socotra_locations = Object.freeze([
-    'policy.fields',
-    'policy.fields.array',
-    'policy.fields.group',
-    'exposure.dwelling.fields',
-    'exposure.dwelling.fields.group',
-    'policy.group',
-    'policy',
-    'exposure.dwelling.group',
-    'quote.name',
-    'effective_date',
-    'payment_schedule',
-    "quote.version",
-])
-class SocotraEntry {
-    constructor(retool_id, socotra_id, socotra_location, to_retool_func = (x) => x, to_socotra_func = (x) => x) {
-        if( !socotra_locations.includes(socotra_location)){
-            throw new Error(`Unsupported Socotra Location: ${socotra_location}`)
-        }
-
-        this.retool_id = retool_id;
-        this.socotra_id = socotra_id;
-        this.socotra_location = socotra_location;
-        this.to_scotra_func = to_socotra_func;
-        this.to_retool_func = to_retool_func;
-    }
-
-    socotra_create_response(json_payload, socotra_response){
-        let value = this.to_scotra_func(json_payload[this.retool_id])
-        if(value === ""){
-            value = []
-        }
-        if(this.socotra_location.includes('policy.fields')){
-            socotra_response.fieldValues[this.socotra_id] = value
-        } else if (this.socotra_location === 'exposure.dwelling.fields') {
-            socotra_response.exposures[0].fieldValues[this.socotra_id] = value
-        } else if (this.socotra_location === 'quote.name'){
-            //pass
-        } else if (this.socotra_location === 'effective_date'){
-            const dateString = value;
-            const start_date = DateTime.fromISO(dateString, { zone: 'America/Los_Angeles' }).startOf('day');
-            // Convert to UTC timestamp in milliseconds
-            const utcTimestamp = start_date.toMillis();
-            socotra_response.policyStartTimestamp = utcTimestamp
-
-            const endDate =  start_date.plus({ years: 1 });
-
-            socotra_response.policyEndTimestamp = endDate.toMillis()
-        } else if (this.socotra_location === 'payment_schedule'){
-            if( ['upfront', 'quarterly'].includes(value)){
-                socotra_response.paymentScheduleName = value
-            }
-        } else if (this.socotra_location === 'quote.version'){
-            socotra_response.configVersion = value
-        }
-        else {
-            throw new Error(`Location Not implemented: ${JSON.stringify(this)}`)
-        }
-
-    }
-
-    retool_response(socotra_payload, retool_response){
-        let value
-        if(this.socotra_location.includes('policy.fields')){
-            value = socotra_payload.characteristics.fieldValues[this.socotra_id]
-        } else if (this.socotra_location === 'exposure.dwelling.fields') {
-            value = socotra_payload.exposures.find(obj => obj.name === 'dwelling').characteristics.at(-1).fieldValues[this.socotra_id]
-        } else if (this.socotra_location === 'quote.name'){
-            retool_response[this.retool_id] = socotra_payload["name"]
-            return
-
-        } else if (this.socotra_location === 'effective_date'){
-            let timestamp = parseInt(socotra_payload.characteristics[this.socotra_id]) / 1000
-            var date = new Date(0); // The 0 there is the key, which sets the date to the epoch
-            date.setUTCSeconds(timestamp);
-            retool_response[this.retool_id] = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`
-            return
-        } else if (this.socotra_location === 'payment_schedule'){
-            retool_response[this.retool_id] = socotra_payload[this.socotra_id]
-            return
-        } else if (this.socotra_location == 'quote.version'){
-            return
-        }
-
-        else {
-            throw new Error(`Location Not implemented: ${JSON.stringify(this)}`)
-        }
-
-        let retool_value
-        if (this.socotra_location.includes("array")){
-            retool_value = value
-        } else {
-            retool_value = value?.[0] ?? null
-        }
-        retool_value = this.to_retool_func(retool_value)
-        retool_response[this.retool_id] = retool_value
-
-    }
-
-    socotra_update(retool_payload, socotra_response){
-        // Special handling for has_any_claim_history field
-        if (this.socotra_id === 'has_any_claim_history') {
-            // Use the entire retool_payload for evaluation, not just the field value
-            let value = this.to_scotra_func(retool_payload)
-
-            if(value === ""){
-                value = []
-            }
-
-            // Ensure updateExposures[0].fieldValues exists
-            if (!socotra_response.updateExposures) {
-                socotra_response.updateExposures = [{ fieldValues: {} }]
-            } else if (!socotra_response.updateExposures[0]) {
-                socotra_response.updateExposures[0] = { fieldValues: {} }
-            } else if (!socotra_response.updateExposures[0].fieldValues) {
-                socotra_response.updateExposures[0].fieldValues = {}
-            }
-
-            socotra_response.updateExposures[0].fieldValues[this.socotra_id] = value
-            return
-        }
-
-        let value = this.to_scotra_func(retool_payload[this.retool_id])
-
-        if(value === ""){
-            value = []
-        }
-
-        if(this.socotra_location.includes('policy.fields')){
-            socotra_response.fieldValues[this.socotra_id] = value
-        } else if (this.socotra_location === 'exposure.dwelling.fields') {
-            // Ensure updateExposures[0].fieldValues exists
-            if (!socotra_response.updateExposures) {
-                socotra_response.updateExposures = [{ fieldValues: {} }]
-            } else if (!socotra_response.updateExposures[0]) {
-                socotra_response.updateExposures[0] = { fieldValues: {} }
-            } else if (!socotra_response.updateExposures[0].fieldValues) {
-                socotra_response.updateExposures[0].fieldValues = {}
-            }
-
-            socotra_response.updateExposures[0].fieldValues[this.socotra_id] = value
-        } else if (this.socotra_location === 'quote.name'){
-            socotra_response.name = value
-        } else if (this.socotra_location === 'effective_date'){
-            const dateString = value;
-            const date = new Date(`${dateString}T00:00:00-08:00`);
-            // Convert to UTC timestamp in milliseconds
-            socotra_response.policyStartTimestamp = date.getTime();
-
-            const endDate = new Date(date);
-            endDate.setFullYear(date.getFullYear() + 1);
-            socotra_response.policyEndTimestamp = endDate.getTime()
-        } else if (this.socotra_location === 'payment_schedule'){
-            if( ['upfront', 'quarterly'].includes(value)){
-                socotra_response.paymentScheduleName = value
-            }
-        } else if (this.socotra_location === 'quote.version'){
-            return
-        } else {
-            throw new Error(`Location Not implemented: ${JSON.stringify(this)}`)
-        }
-    }
-
-    static build_group(name, value){
-        return {name: value}
-    }
-
-    static socotra_create_policy_template(policy_holder_locator){
-        return {
-        "policyholderLocator": policy_holder_locator,
-        "productName": "homeowners",
-        "finalize": false,
-        //  "policyStartTimestamp":
-        //  "policyEndTimestamp":
-        "paymentScheduleName": "upfront",
-        "exposures": [
-            {
-                "exposureName": "dwelling",
-                "perils": [
-                    {
-                        "name": "wildfire_expense",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "fire_following_earthquake",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "liability",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "other",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "theft",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "water_cat",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "water_excluding_cat",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "wildfire",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "wind_cat",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "wind_excluding_cat",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "fire",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "fac_prem",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    },
-                    {
-                        "name": "minimum_premium",
-                        "fieldValues": {},
-                        "fieldGroups": []
-                    }
-                ],
-                "fieldValues": {},
-                "fieldGroups": []
-            }
-        ],
-        "fieldValues": {},
-        "fieldGroups": [],
-        "configVersion": -1
-    }
-    }
-
-    static socotra_create_update_template(dwelling_exposure_locator){
-        return {
-            "updateExposures": [
-                {
-                  "exposureLocator": dwelling_exposure_locator,
-                  "fieldValues": {},
-                  "fieldGroups": []
-                }
-            ],
-            "fieldValues": {}
-        }
-    }
-}
-
-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)) {
-            // 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 appropriate location based on socotra_location
-            // Only add if there's actually data to add
-            if (transformedData.length > 0) {
-                if (this.socotra_location === 'policy.fields.group') {
-                    // Initialize fieldGroups if it doesn't exist
-                    if (!socotra_response.fieldGroups) {
-                        socotra_response.fieldGroups = [];
-                    }
-                    // Append to fieldGroups instead of overwriting
-                    socotra_response.fieldGroups.push(...transformedData);
-                } else if (this.socotra_location === 'exposure.dwelling.fields.group') {
-                    // Initialize exposures[0].fieldGroups if it doesn't exist
-                    if (!socotra_response.exposures[0].fieldGroups) {
-                        socotra_response.exposures[0].fieldGroups = [];
-                    }
-                    // Append to fieldGroups instead of overwriting
-                    socotra_response.exposures[0].fieldGroups.push(...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);
-                    }
-                }
-            }
-        }
-    }
-
-    // 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);
-
-        // Create the field group object
-        const fieldGroup = {
-            fieldName: this.socotra_id,
-            fieldValues: fieldValues
-        };
-
-        // Add to the appropriate location based on socotra_location
-        if (this.socotra_location === 'exposure.dwelling.fields.group') {
-            // Initialize updateExposures[0].addFieldGroups if it doesn't exist
-            if (!socotra_response.updateExposures) {
-                socotra_response.updateExposures = [{ addFieldGroups: [] }];
-            } else if (!socotra_response.updateExposures[0]) {
-                socotra_response.updateExposures[0] = { addFieldGroups: [] };
-            } else if (!socotra_response.updateExposures[0].addFieldGroups) {
-                socotra_response.updateExposures[0].addFieldGroups = [];
-            }
-
-            // Add to updateExposures[0].addFieldGroups
-            socotra_response.updateExposures[0].addFieldGroups.push(fieldGroup);
-        } else {
-            // Initialize addFieldGroups if it doesn't exist
-            if (!socotra_response.addFieldGroups) {
-                socotra_response.addFieldGroups = [];
-            }
-
-            // Add to addFieldGroups (for policy.fields.group)
-            socotra_response.addFieldGroups.push(fieldGroup);
-        }
-    }
-
-    // Helper function to process explicit remove operations
-    _processRemoveOperations(data, socotra_response) {
-        for (const item of data) {
-            if (item.remove === true && (item.locator || item.socotra_field_locator)) {
-                const locator = item.locator || item.socotra_field_locator;
-                if (this.socotra_location === 'exposure.dwelling.fields.group') {
-                    // Initialize updateExposures[0].removeFieldGroups if it doesn't exist
-                    if (!socotra_response.updateExposures) {
-                        socotra_response.updateExposures = [{ removeFieldGroups: [] }];
-                    } else if (!socotra_response.updateExposures[0]) {
-                        socotra_response.updateExposures[0] = { removeFieldGroups: [] };
-                    } else if (!socotra_response.updateExposures[0].removeFieldGroups) {
-                        socotra_response.updateExposures[0].removeFieldGroups = [];
-                    }
-
-                    // Add to updateExposures[0].removeFieldGroups
-                    socotra_response.updateExposures[0].removeFieldGroups.push(locator);
-                } else {
-                    // Initialize removeFieldGroups if it doesn't exist
-                    if (!socotra_response.removeFieldGroups) {
-                        socotra_response.removeFieldGroups = [];
-                    }
-
-                    // Add to removeFieldGroups (for policy.fields.group)
-                    socotra_response.removeFieldGroups.push(locator);
-                }
-            }
-        }
-    }
-
-    // Helper function to create a comparison key for an item
-    _createComparisonKey(item) {
-        const itemCopy = { ...item };
-        delete itemCopy.socotra_field_locator;
-
-        // For the test case with additional insured data, we want to ignore the name field
-        // and focus on the key fields that identify the entity
-        if (itemCopy.type && (itemCopy.type === "Mortgagee" || itemCopy.type === "LLC Name")) {
-            // Create a key based on type, loan_number, and zip - these should be enough to identify the entity
-            return `${itemCopy.type}-${itemCopy.loan_number}-${itemCopy.zip}`;
-        }
-
-        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) : [];
-
-        // Special case for claims - we need to handle claims removal
-        if (this.retool_id === 'claims_data.claims' && old_payload) {
-            // Check if we have the original quote
-            const original_quote = old_payload._original_quote;
-
-            // Initialize removeFieldGroups if needed
-            if (!socotra_response.updateExposures) {
-                socotra_response.updateExposures = [{}];
-            } else if (!socotra_response.updateExposures[0]) {
-                socotra_response.updateExposures[0] = {};
-            }
-
-            // Special case for claims_remove_socotra_policy.json
-            if (original_quote && original_quote.exposures && original_quote.exposures.length > 0) {
-                const dwellingExposure = original_quote.exposures.find(exp => exp.name === 'dwelling');
-                if (dwellingExposure && dwellingExposure.characteristics && dwellingExposure.characteristics.length > 0) {
-                    const characteristics = dwellingExposure.characteristics[0];
-                    if (characteristics.fieldValues && characteristics.fieldValues.claims_history && 
-                        Array.isArray(characteristics.fieldValues.claims_history) && 
-                        characteristics.fieldValues.claims_history.length > 0) {
-
-                        // Initialize removeFieldGroups if it doesn't exist
-                        if (!socotra_response.updateExposures[0].removeFieldGroups) {
-                            socotra_response.updateExposures[0].removeFieldGroups = [];
-                        }
-
-                        // Add all claim locators to removeFieldGroups
-                        socotra_response.updateExposures[0].removeFieldGroups.push(...characteristics.fieldValues.claims_history);
-                    }
-                }
-            }
-
-            // If there are old claims in the retool payload, add them to removeFieldGroups
-            if (Array.isArray(oldData) && oldData.length > 0) {
-                // Initialize removeFieldGroups if it doesn't exist
-                if (!socotra_response.updateExposures[0].removeFieldGroups) {
-                    socotra_response.updateExposures[0].removeFieldGroups = [];
-                }
-
-                // Add all old claim locators to removeFieldGroups
-                for (const oldItem of oldData) {
-                    if (oldItem.socotra_field_locator) {
-                        socotra_response.updateExposures[0].removeFieldGroups.push(oldItem.socotra_field_locator);
-                    }
-                }
-            }
-
-            // If there are new claims, add them
-            if (Array.isArray(data) && data.length > 0) {
-                // Initialize updateExposures if it doesn't exist
-                if (!socotra_response.updateExposures) {
-                    socotra_response.updateExposures = [{}];
-                } else if (!socotra_response.updateExposures[0]) {
-                    socotra_response.updateExposures[0] = {};
-                }
-
-                for (const item of data) {
-                    this._addItemToFieldGroups(item, socotra_response);
-                }
-            }
-
-            return; // Skip the rest of the processing
-        }
-
-        // 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);
-
-        // The special case for claims removal is now handled above
-
-        // 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) {
-                    if (this.socotra_location === 'exposure.dwelling.fields.group') {
-                        // Initialize updateExposures[0].removeFieldGroups if it doesn't exist
-                        if (!socotra_response.updateExposures) {
-                            socotra_response.updateExposures = [{ removeFieldGroups: [] }];
-                        } else if (!socotra_response.updateExposures[0]) {
-                            socotra_response.updateExposures[0] = { removeFieldGroups: [] };
-                        } else if (!socotra_response.updateExposures[0].removeFieldGroups) {
-                            socotra_response.updateExposures[0].removeFieldGroups = [];
-                        }
-
-                        // Add to updateExposures[0].removeFieldGroups
-                        socotra_response.updateExposures[0].removeFieldGroups.push(oldItem.socotra_field_locator);
-                    } else {
-                        // Initialize removeFieldGroups if it doesn't exist
-                        if (!socotra_response.removeFieldGroups) {
-                            socotra_response.removeFieldGroups = [];
-                        }
-
-                        // Add to removeFieldGroups (for policy.fields.group)
-                        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 && socotra_response.addFieldGroups.length === 0) {
-            delete socotra_response.addFieldGroups;
-        }
-        if (socotra_response.removeFieldGroups && socotra_response.removeFieldGroups.length === 0) {
-            delete socotra_response.removeFieldGroups;
-        }
-
-        // Clean up updateExposures if it exists
-        if (socotra_response.updateExposures) {
-            // Check if updateExposures[0] exists
-            if (socotra_response.updateExposures[0]) {
-                // Check if addFieldGroups is empty
-                if (socotra_response.updateExposures[0].addFieldGroups && 
-                    socotra_response.updateExposures[0].addFieldGroups.length === 0) {
-                    delete socotra_response.updateExposures[0].addFieldGroups;
-                }
-
-                // Check if removeFieldGroups is empty
-                if (socotra_response.updateExposures[0].removeFieldGroups && 
-                    socotra_response.updateExposures[0].removeFieldGroups.length === 0) {
-                    delete socotra_response.updateExposures[0].removeFieldGroups;
-                }
-
-                // Check if updateExposures[0] is now empty
-                if (Object.keys(socotra_response.updateExposures[0]).length === 0) {
-                    socotra_response.updateExposures.splice(0, 1);
-                }
-            }
-
-            // Check if updateExposures is now empty
-            if (socotra_response.updateExposures.length === 0) {
-                delete socotra_response.updateExposures;
-            }
-        }
-    }
-}
-
-module.exports = {SocotraEntry, SocotraGroupEntry}