stand_socotra_policy_transformer 3.0.11 → 3.0.13

package/src/knockouts/index.js

@@ -1,83 +0,0 @@
-const {
-    multi_family_unit_count,
-    primary_dwelling_is_insured,
-    full_replacement_value,
-    prior_carrier, occupation
-} = require('./basic_knockouts')
-
-const { wf_variance, stand_wf_knockout } = require('./wf_knockouts');
-const { distance_to_coast, pool_features, farming_type, has_attractive_nuisance,
-    degree_of_slope, flood_score} = require('./exterior_knockouts')
-const {number_of_dogs, dog_history, dog_breeds, exotic_pets, number_of_mortgages,
-       number_of_bankruptcies_judgements_or_liens, home_business_type, home_rental_type, same_address
-} = require('./home_owner_knockouts')
-const {is_vacant, under_renovation, plumbing_last_update_year,
-       water_heater_last_update_year, electrical_last_update_year, home_heating_last_update_year,
-    heating_source, has_underground_fuel_tank, has_steel_braided_hose, has_water_shutoff, has_circuit_breaker
-      } = require('./interior_knockouts')
-
-const {
-    construction_type, siding_material, protection_class, roof_material, foundation_type,
-    has_slab_foundation_plumbing, fire_protective_devices, theft_protective_devices, has_class_a_roof
-} = require('./rate_call_knockouts')
-
-const {check_claims_history} = require('./claims_history_knockout')
-
-const questions = {
-        "multi_family_unit_count": multi_family_unit_count,
-        "primary_dwelling_insured": primary_dwelling_is_insured,
-        "full_replacement_value": full_replacement_value,
-        "prior_carrier": prior_carrier,
-        "wf_variance": wf_variance,
-        "flood_score": flood_score,
-        "distance_to_coast": distance_to_coast,
-        "pool_features": pool_features,
-        "number_of_dogs": number_of_dogs,
-        "dog_history": dog_history,
-        "dog_breeds": dog_breeds,
-        "exotic_pets": exotic_pets,
-        "farming_type": farming_type,
-        "number_of_mortgages": number_of_mortgages,
-        "number_of_bankruptcies_judgements_or_liens": number_of_bankruptcies_judgements_or_liens,
-        "is_vacant": is_vacant,
-        "under_renovation": under_renovation,
-        "plumbing_last_update_year": plumbing_last_update_year,
-        "water_heater_last_update_year": water_heater_last_update_year,
-        "electrical_last_update_year": electrical_last_update_year,
-        "home_heating_last_update_year": home_heating_last_update_year,
-        "heating_source": heating_source,
-        "has_underground_fuel_tank": has_underground_fuel_tank,
-        "has_steel_braided_hose": has_steel_braided_hose,
-        "has_water_shutoff": has_water_shutoff,
-        "home_business_type": home_business_type,
-        "has_attractive_nuisance": has_attractive_nuisance,
-        "home_rental_type": home_rental_type,
-        "degree_of_slope": degree_of_slope,
-        "construction_type": construction_type,
-        "siding_material": siding_material,
-        "protection_class": protection_class,
-        "roof_material": roof_material,
-        "foundation_type": foundation_type,
-        "has_slab_foundation_plumbing": has_slab_foundation_plumbing,
-        "fire_protective_devices": fire_protective_devices,
-        "theft_protective_devices": theft_protective_devices,
-        "occupation": occupation
-
-    }
-
-function knockout(question_name, answer){
-    if (questions.hasOwnProperty(question_name)){
-        return questions[question_name](answer)
-    } else {
-        return {decision: "question_not_found", note: null}
-    }
-}
-
-function knockout_names() {
-    return Object.keys(questions)
-}
-
-module.exports = {
-    knockout, has_circuit_breaker, same_address, knockout_names, stand_wf_knockout, has_class_a_roof,
-    check_claims_history
-}

package/src/knockouts/interior_knockouts.js

@@ -1,149 +0,0 @@
-function is_vacant(vacant){
-    if(vacant === 'No'){
-        return {decision: "accept", note: null}
-    } else if (vacant === 'Yes'){
-        return {decision: "reject", note: "Home is vacant"}
-    } else {
-        return {decision: "reject", note: "Vacant must be yes or no"}
-    }
-}
-
-function under_renovation(renovation){
-    if(renovation === 'No'){
-        return {decision: "accept", note: null}
-    } else if (renovation === 'Yes'){
-        return {decision: "reject", note: "Home is under renovation"}
-    } else {
-        return {decision: "reject", note: "Under renovation must be yes or no"}
-    }
-}
-
-function plumbing_last_update_year(year_updated){
-    if(!Number.isInteger(year_updated)){
-        return {decision: "reject", note: "Plumbing year must be an integer"}
-    }
-    if(year_updated < 1600 || year_updated > 3000){
-        return {decision: "reject", note: "Plumbing input should be the year it was last updated not the age"}
-    }
-
-    year_threshold = new Date().getFullYear() - 30
-    if(year_updated >= year_threshold){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Plumbing must have been updated in the last 30 years"}
-    }
-}
-
-function water_heater_last_update_year(year_updated){
-    if(!Number.isInteger(year_updated)){
-        return {decision: "reject", note: "Water heater year must be an integer"}
-    }
-    if(year_updated < 1600 || year_updated > 3000){
-        return {decision: "reject", note: "Water heater input should be the year it was last updated not the age"}
-    }
-
-    year_threshold = new Date().getFullYear() - 10
-    if(year_updated >= year_threshold){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Water heater must have been updated in the last 10 years"}
-    }
-}
-
-function electrical_last_update_year(year_updated){
-    if(!Number.isInteger(year_updated)){
-        return {decision: "reject", note: "Electrical year must be an integer"}
-    }
-    if(year_updated < 1600 || year_updated > 3000){
-        return {decision: "reject", note: "Electrical input should be the year it was last updated not the age"}
-    }
-
-    year_threshold = new Date().getFullYear() - 30
-    if(year_updated >= year_threshold){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Electrical must have been updated in the last 30 years"}
-    }
-}
-
-function home_heating_last_update_year(year_updated){
-    if(!Number.isInteger(year_updated)){
-        return {decision: "reject", note: "Home heating year must be an integer"}
-    }
-    if(year_updated < 1600 || year_updated > 3000){
-        return {decision: "reject", note: "Home heating input should be the year it was last updated not the age"}
-    }
-
-    year_threshold = new Date().getFullYear() - 30
-    if(year_updated >= year_threshold){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Home heating must have been updated in the last 30 years"}
-    }
-}
-
-function heating_source(heating_type) {
-    heating_type_enum = [
-        "central gas heat", "thermostatically controlled electrical heat",
-        "wood", "coal", "pellet stove"
-    ]
-
-    if(typeof heating_type !== 'string'){
-        return {decision: "reject", note: "Home heating year must be a string"}
-
-    } else if(!heating_type_enum.includes(heating_type)){
-        return {decision: "reject", note: "Heat source must be in [central gas heat, thermostatically controlled electrical heat, wood, coal, pellet stove]"}
-    }
-
-    if(!["wood", "coal", "pellet stove"].includes(heating_type)){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "refer", note: null}
-    }
-}
-
-function has_underground_fuel_tank(has_tank){
-    if(has_tank === 'No'){
-        return {decision: "accept", note: null}
-    } else if (has_tank === 'Yes'){
-        return {decision: "reject", note: "Home has underground fuel tank"}
-    } else {
-        return {decision: "reject", note: "Underground fuel tank must be yes or no"}
-    }
-}
-
-function has_steel_braided_hose(has_steel){
-    if(has_steel === 'Yes'){
-        return {decision: "accept", note: null}
-    } else if (has_steel === 'No'){
-        return {decision: "refer", note: null}
-    } else {
-        return {decision: "reject", note: "Steel braided hose must be yes or no"}
-    }
-}
-
-function has_water_shutoff(has_shutoff){
-    if(has_shutoff === 'Yes'){
-        return {decision: "accept", note: null}
-    } else if (has_shutoff === 'No'){
-        return {decision: "refer", note: null}
-    } else {
-        return {decision: "reject", note: "Water shutoff must be yes or no"}
-    }
-}
-
-function has_circuit_breaker(has_breaker, year_built){
-    if ((has_breaker === 'No') || (year_built >= 1980)){
-        return {decision: "accept", note: null}
-    } else if(has_breaker === 'Yes'){
-        return {decision: "reject", note: "Home built before 1980 cannot have circuit breakers"}
-    } else {
-        return {decision: "reject", note: "Circuit breaker must be yes or no"}
-    }
-}
-
-module.exports = {
-    is_vacant, under_renovation, plumbing_last_update_year, water_heater_last_update_year,
-    electrical_last_update_year, home_heating_last_update_year, heating_source, has_underground_fuel_tank,
-    has_steel_braided_hose, has_water_shutoff, has_circuit_breaker
-}

package/src/knockouts/rate_call_knockouts.js

@@ -1,155 +0,0 @@
-function construction_type(type){
-    let type_enum = ["Concrete", "Frame", "Log", "Masonry", "Mobile / Manufactured", "Steel", "Modular"]
-    if(typeof type != 'string') {
-         return {decision: "reject", note: "Construction type must be a string"}
-    } else if(!type_enum.includes(type)){
-        return {decision: "reject", note: "Construction type must be one of [Concrete, Frame, Log, Masonry, Mobile / Manufactured, Steel, Modular]"}
-    }
-
-    if(["Concrete", "Frame","Masonry", "Steel"].includes(type)){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Construction type not supported"}
-    }
-}
-
-function siding_material(type){
-    let material_enum = ["Adobe", "Aluminum / Steel", "Asbestos", "Brick / Masonry Veneer",
-        "Brick / Stone - Solid", "Cement Fiber", "Clapboard", "Exterior Insulation Finishing System (EIFS)", "Log",
-        "Stone Veneer", "Stucco", "Vinyl", "Wood", "Other - above descriptions do not apply"]
-    if(typeof type != 'string') {
-        return {decision: "reject", note: "Siding material must be a string"}
-    } else if(!material_enum.includes(type)){
-        return {decision: "reject", note: "Siding material must be one of [Adobe, Aluminum / Steel, Asbestos, Brick / Masonry Veneer, Brick / Stone - Solid, Cement Fiber, Clapboard, Exterior Insulation Finishing System (EIFS), Log, Stone Veneer, Stucco, Vinyl, Wood, Other - above descriptions do not apply]"}
-    }
-
-    if(["Log", "Asbestos", "Exterior Insulation Finishing System (EIFS)"].includes(type)){
-        return {decision: "reject", note: "Siding material not supported"}
-    } else if(type === 'Wood'){
-
-    } else {
-        return {decision: "accept", note: null}
-    }
-}
-
-function protection_class(protection){
-    let protection_types = ["1","2","3","4","5","6", "7", "8", "8B", "1Y", "2Y", "3Y", "4Y", "5Y", "6Y", "7Y", "8Y", "9", "1X", "2X", "3X", "4X", "5X", "6X", "7X", "8X", "9", "10", "10W"]
-
-    if(typeof protection != 'string') {
-        return {decision: "reject", note: "Protection class must be a string"}
-    } else if(!protection_types.includes(protection)){
-        return {decision: "reject", note: `Protection class must be one of ${protection_types}`}
-    }
-
-    if(["9", "10"].includes(protection)){
-        return {decision: "reject", note: "Protection class not supported"}
-    }
-
-    return {decision: "accept", note: null}
-}
-
-function roof_material(material){
-    let material_enum = ["Architecture Shingles", "Asphalt Fiberglass Composite", "Clay-Tile-Slate",
-        "Concrete Tile", "Corrugated Steel - Metal", "Flat Foam Composite"," Flat Membrane",
-        "Flat Tar Gravel", "Other", "Wood Shake", "Wood Shingle"]
-
-    if(typeof material != 'string') {
-        return {decision: "reject", note: "Roof material must be a string"}
-    } else if(!material_enum.includes(material)){
-        return {decision: "reject", note: `Roof material must be one of ${material_enum}`}
-    }
-
-    if(["Wood Shake", "Wood Shingle",].includes(material)){
-        return {decision: "reject", note: "Roof material not supported"}
-    } else {
-        return {decision: "accept", note: null}
-    }
-}
-
-function has_class_a_roof(is_class_a, wildfire_category){
-    if(typeof is_class_a != 'string') {
-        return {decision: "reject", note: "Has class a roof must be a string"}
-    } else if (!["Yes", "No"].includes(is_class_a)){
-        return{decision: "reject", note: "Has class a roof must be Yes or No"}
-    }
-
-    if(is_class_a === "Yes" || ['A', 'B'].includes(wildfire_category)){
-        return {decision: "accept", note: null}
-    } else{
-        return {decision: "reject", note: "Homes in this wildfire category must have class a roofs"}
-    }
-}
-
-function foundation_type(type){
-    let type_enum = ["Basement Finished", "Basement Partially Finished", "Basement Unfinished",
-        "Crawlspace", "Other", "Piers", "Pilings", "Stilts", "Slab"]
-    if(typeof type != 'string') {
-        return {decision: "reject", note: "Foundation type must be a string"}
-    } else if(!type_enum.includes(type)){
-        return {decision: "reject", note: `Foundation type must be one of ${type_enum}`}
-    }
-
-    if(type == 'Other'){
-        return {decision: "refer", note: null}
-    } else if(["Piers", "Pilings", "Stilts"].includes(type)){
-        return {decision: "reject", note: "Foundation type not supported"}
-    } else {
-        return {decision: "accept", note: null}
-    }
-
-
-}
-
-function has_slab_foundation_plumbing(has_bad_plumbing){
-    if(typeof has_bad_plumbing != 'string') {
-        return {decision: "reject", note: "Has slab foundation plumbing must be a string"}
-    } else if (!["Yes", "No"].includes(has_bad_plumbing)){
-        return{decision: "reject", note: "Has slab foundation plumbing must be Yes or No"}
-    }
-
-    if(has_bad_plumbing === "Yes"){
-        return {decision: "reject", note: "Homes with slab foundation plumbing are not allowed"}
-    } else{
-        return {decision: "accept", note: null}
-    }
-}
-
-function fire_protective_devices(devices_list){
-    if(!Array.isArray(devices_list)){
-        return {decision: "reject", note: "Fire protective devices must be a list"}
-    }
-
-    let device_types = ['Local', 'Central', 'Direct', "Sprinkler", "Fire Ext", "Smoke", "No"]
-    if(!devices_list.every(device => device_types.includes(device))){
-        return {decision: "reject", note: `Unrecognized fire device type. Valid devices: ${device_types}`}
-    }
-
-    if(devices_list.includes('Direct') || devices_list.includes('Central')){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Insufficient fire devices"}
-    }
-}
-
-function theft_protective_devices(devices_list) {
-    if(!Array.isArray(devices_list)){
-        return {decision: "reject", note: "Theft protective devices must be a list"}
-    }
-
-    device_types = ["Dead Bolt", "Local", "Central", "Direct", "24 Hour Security Guard", "No"]
-    if(!devices_list.every(device => device_types.includes(device))){
-        return {decision: "reject", note: `Unrecognized theft device type. Valid devices: ${device_types}`}
-    }
-
-    if(devices_list.includes('Central') || devices_list.includes('Direct') ||
-        devices_list.includes("24 Hour Security Guard")){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Insufficient theft device"}
-    }
-}
-
-module.exports = {
-    construction_type, siding_material, protection_class, roof_material, has_class_a_roof, foundation_type,
-    has_slab_foundation_plumbing, fire_protective_devices, theft_protective_devices
-}

package/src/knockouts/wf_knockouts.js

@@ -1,66 +0,0 @@
-function stand_wf_knockout(mean, arf){
-    //Safe checking logic
-    if(mean < 0 || arf < 0){
-        return {
-            category: '',
-            underwriter_result: {decision: "reject", note: "Mean and ARF must be positive numbers"}
-        }
-    }
-    if(!Number.isFinite(arf) || !Number.isFinite(mean)){
-        return {
-            category: '',
-            underwriter_result: {decision: "reject", note: "ARF must be a number"}
-        }
-    }
-
-
-    //Main logic
-    if(mean >= .7) {
-        return {
-            category: 'D',
-            underwriter_result: {decision: "reject", note: "Stand WF mean must be less than or equal to 0.7"}
-        }
-    } else if(arf >=8){
-        return {
-            category: 'C',
-            underwriter_result: { decision: "refer", note: null}
-        }
-    } else if(arf >=5){
-        return {
-            category: 'C',
-            underwriter_result: { decision: "accept", note: null}
-        }
-    } else if (mean >= .2){
-        return {
-            category: 'C',
-            underwriter_result: { decision: "accept", note: null}
-        }
-    } else if (mean >= .1){
-        return {
-            category: 'B',
-            underwriter_result:  { decision: "accept", note: null}
-        }
-    } else {
-        return {
-            category: 'A',
-            underwriter_result:  { decision: "accept", note: null}
-        }
-    }
-}
-
-function wf_variance(variance){
-    if(!Number.isFinite(variance) ) {
-         return {decision: "reject", note: "Variance must be a number."}
-    } else if(variance < 0){
-        return {decision: "reject", note: "Variance must be a positive number."}
-    }
-
-    if(variance <= 0.09){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "refer", note: null}
-    }
-}
-
-
-module.exports = {stand_wf_knockout, wf_variance}

package/src/retool_to_socotra.js

@@ -1,18 +0,0 @@
-const {
-    knockout, knockout_names, same_address, stand_wf_knockout, has_circuit_breaker, has_class_a_roof,
-    check_claims_history
-} = require('./knockouts')
-
-function build_policy_from_retool(retool_quote){
-
-}
-
-function build_quote_change_set(retool_old_quote, retool_new_quote){
-
-}
-
-function convert_quote_from_retool(socotra_quote){
-
-}
-
-module.exports = {underwrite, knockout_names}

package/src/retool_utils/socotra_payloads.js

@@ -1,161 +0,0 @@
-const {SocotraEntry, SocotraGroupEntry} = require("./socotra_structure_helper");
-class SocotraPayloadConverter {
-    constructor(entries) {
-        this.entries = entries
-    }
-    policy_holder_payload(retool_payload) {
-        let missing = []
-        let required_fields = ['owner_first_name', 'owner_last_name']
-        for (const field of required_fields) {
-            if (!retool_payload[field]) {
-                missing.push(field)
-            }
-
-        }
-        if (missing.length == 0) {
-            let values = {
-                first_name: retool_payload.owner_first_name,
-                last_name: retool_payload.owner_last_name,
-                email: retool_payload.owner_email,
-                phone_number: retool_payload.owner_phone_number,
-                mailing_street_address: retool_payload.mailing_street_address,
-                mailing_street_address_2: retool_payload.mailing_street_address2,
-                mailing_city: retool_payload.mailing_city,
-                mailing_state: retool_payload.mailing_state,
-                mailing_zip: retool_payload.mailing_zip,
-                ofac_date: retool_payload.ofac_date_pulled,
-                ofac_reason: retool_payload.ofac_reason,
-                ofac_outcome: retool_payload.ofac_outcome
-            }
-            return {
-                status: 'success',
-                error_message: '',
-                payload:
-                    {
-                        completed: true,
-                        values: this.stripNoneValues(values, true, true, false)
-                    }
-            }
-        } else {
-            return {payload: {}, status: 'error', error_message: `must include the following fields [${missing}]`}
-        }
-    }
-
-    new_policy_payload(retool_payload, policy_holder_locator) {
-        let payload = SocotraEntry.socotra_create_policy_template(policy_holder_locator)
-        this.entries.forEach(entry => {
-            entry.socotra_create_response(retool_payload, payload)
-        })
-
-        let cleaned_payload = this.stripNoneValues(payload, true, true, true)
-        return {payload: cleaned_payload, error_message: "", status: "success"}
-    }
-
-    quote_to_retool_payload(socotra_quote) {
-        let payload = {}
-        this.entries.forEach(entry => {
-            entry.retool_response(socotra_quote, payload)
-        })
-        return {payload: this.stripNoneValues(payload, false, true, false), error_message: "", status: "success"}
-    }
-
-    retool_to_quote_updated(retool_payload, old_quote) {
-        let old_payload = this.quote_to_retool_payload(old_quote)["payload"]
-
-        // Pass the original old_quote to the socotra_update method for claims handling
-        old_payload._original_quote = old_quote
-
-        let new_keys = Object.keys(retool_payload)
-        new_keys.forEach(key => {
-            if (Array.isArray(retool_payload[key])) {
-                let new_array = retool_payload[key]
-                let old_array = old_payload[key]
-
-                // Only compare if old_array exists and both are arrays
-                if (old_array && Array.isArray(old_array) && JSON.stringify(new_array) === JSON.stringify(old_array)) {
-                    delete retool_payload[key]
-                }
-            } else if (typeof retool_payload[key] === 'object' && retool_payload[key] !== null) {
-                // Handle nested objects
-                if (old_payload[key] && typeof old_payload[key] === 'object') {
-                    // If the nested objects are the same, remove the key
-                    if (JSON.stringify(retool_payload[key]) === JSON.stringify(old_payload[key])) {
-                        delete retool_payload[key]
-                    }
-                }
-            } else if (old_payload[key] === retool_payload[key]) {
-                delete retool_payload[key]
-            }
-        })
-        let dwelling_exposure_locator = old_quote.exposures.find(obj => obj.name === 'dwelling')["locator"]
-        let payload = SocotraEntry.socotra_create_update_template(dwelling_exposure_locator)
-        this.entries.forEach(entry => {
-            // Check if the entry's retool_id is in the retool_payload keys
-            // For nested keys (e.g., "additional_insured_data.additionalInterest"), check if the parent key exists
-            const retool_id_parts = entry.retool_id ? entry.retool_id.split('.') : [];
-            const parent_key = retool_id_parts[0];
-
-            // Special handling for has_any_claim_history field which depends on claims_data
-            if (entry.socotra_id === 'has_any_claim_history' && retool_payload.claims_data) {
-                entry.socotra_update(retool_payload, payload);
-            } else if (Object.keys(retool_payload).includes(entry.retool_id) || 
-                (parent_key && Object.keys(retool_payload).includes(parent_key))) {
-                if(entry instanceof SocotraGroupEntry){
-                    entry.socotra_update(retool_payload, payload, old_payload)
-                } else{
-                    entry.socotra_update(retool_payload, payload)
-                }
-            }
-        })
-
-        payload = this.stripNoneValues(payload, true, true, false)
-        if (Object.keys(payload.updateExposures[0].fieldValues).length === 0) {
-            delete payload["updateExposures"]
-        }
-
-        if (Object.keys(payload.fieldValues).length === 0) {
-            delete payload["fieldValues"]
-        }
-
-        return {payload: payload, error_message: "", status: "success"}
-    }
-
-    stripNoneValues(payload, nulls, undefineds, nans) {
-        if (nulls) {
-            payload = this.stripNulls(payload, x => x == null)
-        }
-
-        if (undefineds) {
-            payload = this.stripNulls(payload, x => x === undefined)
-        }
-
-        if (nans) {
-            payload = this.stripNulls(payload, x => Number.isNaN(x))
-        }
-        return payload
-    }
-
-//Socotra Doesn't like nulls, so we have to strip them
-
-    stripNulls(payload, filter_func) {
-        let strip_with_args = x => this.stripNulls(x, filter_func)
-
-        if (Array.isArray(payload)) {
-            // If it's an array, recursively process each item and filter out nulls
-            return payload
-                .map(strip_with_args)
-                .filter(item => !filter_func(item));
-        } else if (typeof payload === 'object' && payload !== null) {
-            // If it's an object, recursively process each key-value pair
-            return Object.fromEntries(
-                Object.entries(payload)
-                    .map(([key, value]) => [key, strip_with_args(value)]) // Recursively call for each value
-                    .filter(([_, value]) => !filter_func(value)) // Filter out null values
-            );
-        }
-        // Return the value itself if it's not an object or array
-        return payload;
-    }
-}
-
-module.exports = {SocotraPayloadConverter}