stand_socotra_policy_transformer 3.0.11 → 3.0.13

package/__tests__/underwriter.test.js

@@ -1,169 +0,0 @@
-const {underwrite} = require('../src')
-const {claims_history_helper} = require("./helpers")
-
-beforeAll(() => {
-  jest
-    .useFakeTimers()
-    .setSystemTime(new Date('2024-07-04').getTime());
-});
-
-afterAll(() => {
-  jest.useRealTimers();
-});
-
-describe('Underwriter', () => {
-    describe('with_full_check', () =>{
-        test('Accepts with passing payload', () => {
-            let decision = underwrite(payload_helper())
-            expect(decision.decision).toBe('accept')
-            expect(decision.notes).toEqual([])
-            expect(decision.refers).toEqual([])
-
-            expect(Object.keys(decision.all_decisions).length).toEqual(43)
-            expect(decision.all_decisions['full_replacement_value']).toBe('accept')
-
-            expect(Object.keys(decision.notes_dict).length).toEqual(43)
-            expect(decision.notes_dict['full_replacement_value']).toBe(null)
-        });
-
-       test('Rejects if something in payload rejects', () => {
-           let decision = underwrite(payload_helper({flood_score: 10, is_vacant: "Yes"}))
-           expect(decision.decision).toBe('reject')
-           expect(decision.notes.length).toEqual(2)
-           expect(decision.refers).toEqual([])
-
-           expect(Object.keys(decision.all_decisions).length).toEqual(43)
-           expect(decision.all_decisions['flood_score']).toBe('reject')
-           expect(decision.all_decisions['is_vacant']).toBe('reject')
-
-           expect(Object.keys(decision.notes_dict).length).toEqual(43)
-           expect(decision.notes_dict['flood_score']).not.toBe(null)
-           expect(decision.all_decisions['is_vacant']).not.toBe(null)
-
-       });
-
-       test('Refer if something in payload refers', () => {
-           let decision = underwrite(payload_helper({"full_replacement_value": 6_500_000}))
-           expect(decision.decision).toBe('refer')
-           expect(decision.notes.length).toEqual(0)
-           expect(decision.refers).toEqual(["full_replacement_value"])
-
-           expect(Object.keys(decision.all_decisions).length).toEqual(43)
-           expect(decision.all_decisions['full_replacement_value']).toBe('refer')
-
-           expect(Object.keys(decision.notes_dict).length).toEqual(43)
-       });
-
-       test('Reject if something in payload refers and something else rejects', () => {
-           let decision = underwrite(payload_helper({full_replacement_value: 6_500_000, flood_score: 10}))
-           expect(decision.decision).toBe('reject')
-           expect(decision.notes.length).toEqual(1)
-           expect(decision.refers).toEqual(["full_replacement_value"])
-
-           expect(Object.keys(decision.all_decisions).length).toEqual(43)
-           expect(decision.all_decisions['full_replacement_value']).toBe('refer')
-           expect(decision.all_decisions['flood_score']).toBe('reject')
-
-           expect(Object.keys(decision.notes_dict).length).toEqual(43)
-           expect(decision.notes_dict['full_replacement_value']).toBeNull()
-           expect(decision.notes_dict['flood_score']).not.toBeNull()
-
-       });
-
-       test('Reject if something in payload is missing', () => {
-           payload = payload_helper()
-           delete payload.full_replacement_value
-           delete payload.arf
-           let decision = underwrite(payload)
-           expect(decision.decision).toBe('reject')
-           expect(decision.notes.length).toEqual(2)
-           expect(decision.refers).toEqual([])
-
-           expect(Object.keys(decision.all_decisions).length).toEqual(43)
-           expect(decision.all_decisions['full_replacement_value']).toBe('reject')
-           expect(decision.all_decisions['wf_score_mean']).toBe('reject')
-       });
-    });
-    describe("partial_check", () => {
-        test("doesn't reject for missing fields", ()=> {
-            let decision = underwrite({
-                multi_family_unit_count: 1, primary_dwelling_insured: 'Yes',
-                full_replacement_value: 6_000_000, prior_carrier: "Yes"}, false)
-            expect(decision.decision).toBe('accept')
-            expect(decision.notes).toEqual([])
-            expect(decision.refers).toEqual([])
-
-            expect(Object.keys(decision.all_decisions).length).toEqual(4)
-            expect(decision.all_decisions['full_replacement_value']).toBe('accept')
-        })
-
-        test("rejects if it should", ()=> {
-            let decision = underwrite({
-                multi_family_unit_count: 1, primary_dwelling_insured: 'Yes',
-                full_replacement_value: 6_000_000, prior_carrier: "Yes",
-                number_of_bankruptcies_judgements_or_liens: 2}, false)
-            expect(decision.decision).toBe('reject')
-            expect(decision.notes).toEqual(["Has bankruptcies, judgements, or liens"])
-            expect(decision.refers).toEqual([])
-
-            expect(Object.keys(decision.all_decisions).length).toEqual(5)
-            expect(decision.all_decisions['full_replacement_value']).toBe('accept')
-        });
-    });
-});
-
-function payload_helper(override){
-    let sample_payload = {
-        address: '1234 main street',
-        year_built: '2005',
-        co_applicant_address: '1234 main street',
-        multi_family_unit_count: 1,
-        primary_dwelling_insured: 'Yes',
-        full_replacement_value: 6_000_000,
-        prior_carrier: "Yes",
-        wf_variance: .001,
-        wf_score_mean: .3,
-        arf: 1.9,
-        flood_score: 5,
-        distance_to_coast: 1.4,
-        pool_features: ['Inground', "Fenced with self-locking gate"],
-        number_of_dogs: 1,
-        dog_history: 'No',
-        dog_breeds: ['non-guard dog of other breeds'],
-        exotic_pets: "No",
-        farming_type: "None",
-        number_of_mortgages: 0,
-        number_of_bankruptcies_judgements_or_liens: 0,
-        is_vacant: "No",
-        under_renovation: "No",
-        plumbing_last_update_year: 2022,
-        water_heater_last_update_year: 2022,
-        electrical_last_update_year: 2022,
-        home_heating_last_update_year: 2022,
-        heating_source: 'central gas heat',
-        has_underground_fuel_tank: "No",
-        has_steel_braided_hose: "Yes",
-        has_water_shutoff: "Yes",
-        circuit_breaker: "No",
-        home_business_type: "no",
-        has_attractive_nuisance: "No",
-        home_rental_type: "no",
-        degree_of_slope: 15,
-        construction_type: "Concrete",
-        siding_material: "Adobe",
-        protection_class: "4",
-        roof_material: "Corrugated Steel - Metal",
-        class_a_roof: "Yes",
-        foundation_type: "Crawlspace",
-        has_slab_foundation_plumbing: "No",
-        fire_protective_devices: ["Central"],
-        theft_protective_devices: ["Dead Bolt", "Direct"],
-        occupation: "writer",
-        claims: [
-          claims_history_helper('06/23/2022', 'Hurricane', 100),
-          claims_history_helper('11/1/2020', 'SlipFall', 100)
-        ]
-    }
-
-    return {...sample_payload, ...override}
-}

package/__tests__/wf_knockout.test.js

@@ -1,124 +0,0 @@
-const { knockout } = require('../src/knockouts/index.js');
-const { stand_wf_knockout } = require('../src/knockouts/wf_knockouts')
-describe("WF Knockouts", () =>
-{
-  describe("wf_score_mean", () => {
-
-    test('rejects if mean > 0.7', () => {
-      let result = stand_wf_knockout(.7, .2);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("D");
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("Stand WF mean must be less than or equal to 0.7");
-    });
-
-    test('set as c and refer if arf >= 8', () => {
-      let result = stand_wf_knockout(.1, 8.0);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("C");
-      expect(decision.decision).toBe("refer");
-      expect(decision.note).toBe(null);
-    });
-
-    test('set as c and acept if  5 < arf < 8', () => {
-      let result = stand_wf_knockout(.1, 5.0);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("C");
-      expect(decision.decision).toBe("accept");
-      expect(decision.note).toBe(null);
-    });
-
-    test('set as c and accept if arf <8 and .2 < mean < .7', () => {
-      let result = stand_wf_knockout(.34, 4.2);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("C");
-      expect(decision.decision).toBe("accept");
-      expect(decision.note).toBe(null);
-    });
-
-    test('set as B and accept if arf <5 and .1 < mean < .2', () => {
-      let result = stand_wf_knockout(.14, 4.3);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("B");
-      expect(decision.decision).toBe("accept");
-      expect(decision.note).toBe(null);
-    });
-
-    test('set as A and accept if arf <5 and 0 < mean < .1', () => {
-      let result = stand_wf_knockout(.04, 4.3);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("A");
-      expect(decision.decision).toBe("accept");
-      expect(decision.note).toBe(null);
-    });
-
-    test('negative mean used reject', () => {
-      let result = stand_wf_knockout(-.04, 4.3);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("");
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("Mean and ARF must be positive numbers");
-    });
-
-    test('negative arf used reject', () => {
-      let result = stand_wf_knockout(.04, -4.3);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("");
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("Mean and ARF must be positive numbers");
-    });
-
-    test('non number arf used reject', () => {
-      let result = stand_wf_knockout(.04, "hi");
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("");
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("ARF must be a number");
-    });
-    test('non number arf used reject', () => {
-      let result = stand_wf_knockout("hi", 4);
-      let decision = result.underwriter_result;
-
-      expect(result.category).toBe("");
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("ARF must be a number");
-    });
-
-  });
-
-  describe("WF Variance Knockout", () => {
-
-    test('accept if variance <= 0.09', () => {
-      let decision = knockout('wf_variance', 0.08);
-      expect(decision.decision).toBe("accept");
-      expect(decision.note).toBe(null)
-    });
-
-    test('refer if variance > .09', () => {
-      let decision = knockout('wf_variance', 0.1);
-      expect(decision.decision).toBe("refer");
-      expect(decision.note).toBe(null)
-    });
-
-    test('rejects if value is not an number', () => {
-      let decision = knockout('wf_variance', "hi");
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("Variance must be a number.")
-    });
-
-    test('rejects if value is negative', () => {
-      let decision = knockout('wf_variance', -3);
-      expect(decision.decision).toBe("reject");
-      expect(decision.note).toBe("Variance must be a positive number.")
-    });
-  });
-})

package/src/index.js

@@ -1,14 +0,0 @@
-const {underwrite, knockout_names} = require('./underwriter')
-const {SocotraPayloadConverter} = require('./retool_utils/socotra_payloads')
-const {entries_v1} = require('./retool_utils/versions/stand_v1_entries')
-const {entries_v2} = require('./retool_utils/versions/stand_v2_entries')
-const {entries_v3} = require('./retool_utils/versions/stand_v3_entries')
-const { version } = require('../package.json');
-
-const transformer_hash = {
-    '1': new SocotraPayloadConverter(entries_v1),
-    '2': new SocotraPayloadConverter(entries_v2),
-    '3': new SocotraPayloadConverter(entries_v3)
-}
-
-module.exports = {underwrite, knockout_names, transformer_hash, package_version: version}

package/src/knockouts/basic_knockouts.js

@@ -1,66 +0,0 @@
-function multi_family_unit_count(num_units){
-
-    if(!Number.isInteger(num_units)){
-        return {decision: "reject", note: "Number of units must be an integer"}
-    }
-    else if(num_units > 2){
-        return {decision: "reject", note: "We only allow homes with two units or less."}
-    } else if (num_units <= 0){
-        return {decision: "reject", note: "Number of units must be greater than 0"}
-    }
-    else{
-        return {decision: "accept", note: null}
-    }
-}
-
-function primary_dwelling_is_insured(is_insured_string){
-
-    if(is_insured_string == 'No'){
-        return {decision: "refer", note: null}
-    } else if(is_insured_string == 'Yes'){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Primary dwelling insured value must be in ['yes', 'no']"}
-    }
-}
-
-function full_replacement_value(replacement_value){
-    if(!Number.isInteger(replacement_value)){
-        return {decision: "reject", note: "Full replacement value must be an integer"}
-    }
-    else if(replacement_value > 6_000_000){
-        return {decision: "refer", note: null}
-    } else if (replacement_value < 2_000_000){
-        return {decision: "reject", note: "We only insure homes greater than $1M"}
-    }
-    else{
-        return {decision: "accept", note: null}
-    }
-}
-
-function prior_carrier(carrier_string){
-
-    if(carrier_string === ""){
-        return {decision: "refer", note: null}
-    } else if(typeof carrier_string == 'string'){
-        return {decision: "accept", note: null}
-    } else {
-         return {decision: "reject", note: "Prior Carrier Must be a string"}
-    }
-}
-
-function occupation(occ){
-    if(typeof occ != 'string'){
-        return {decision: "reject", note: "Occupation must be a string"}
-    } else if (['Professional Athlete', 'Entertainer', 'Journalist',' Politician'].includes(occ)){
-        return {decision: "refer", note: null}
-    } else {
-        return {decision: "accept", note: null}
-    }
-}
-
-
-module.exports = {
-    multi_family_unit_count, primary_dwelling_is_insured, full_replacement_value, prior_carrier,
-    occupation
-}

package/src/knockouts/claims_history_knockout.js

@@ -1,24 +0,0 @@
-function check_claims_history(history){
-    if (!history){
-        return {decision: 'reject', note: "For Claims use empty instead of null"}
-    }
-
-    let current_date = new Date();
-    let date_five_years_ago = new Date();
-    let date_three_years_ago = new Date();
-    date_five_years_ago.setFullYear(current_date.getFullYear() - 5);
-    date_three_years_ago.setFullYear(current_date.getFullYear() - 3);
-
-    let claims_in_last_five_years = history.filter(claim => claim['date'] > date_five_years_ago)
-    let claims_in_last_three_years = history.filter(claim => claim['date'] > date_three_years_ago)
-
-    if(claims_in_last_five_years.length > 2){
-        return {decision: 'reject', note: "To many claims in the past 5 years"}
-    } else if (claims_in_last_three_years.length > 1){
-        return {decision: 'reject', note: "To many claims in the past 3 years"}
-    } else {
-        return {decision: "accept", note: null}
-    }
-}
-
-module.exports = {check_claims_history}

package/src/knockouts/exterior_knockouts.js

@@ -1,97 +0,0 @@
-function flood_score(score){
-    if(!Number.isFinite(score) ) {
-         return {decision: "reject", note: "Flood score must be a number."}
-    } else if(score < 0){
-        return {decision: "reject", note: "Flood score must be a positive number."}
-    }
-
-    if(score < 9){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Flood risk is too high"}
-    }
-}
-
-function distance_to_coast(distance){
-    if(!Number.isFinite(distance) ) {
-         return {decision: "reject", note: "Distance to coast must be a number."}
-    } else if(distance < 0){
-        return {decision: "reject", note: "Distance to coast must be a positive number."}
-    }
-
-    if(distance > 0.19){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "refer", note: null}
-    }
-}
-
-function pool_features(feature_list){
-    if(!Array.isArray(feature_list)){
-        return {decision: "reject", note: "Pool features must be a list."}
-    }
-
-    let has_drowning_mitigation = feature_list.includes("Inground") && (
-        feature_list.includes("Electric retractable safety cover")
-        || feature_list.includes("Fenced with self-locking gate")
-    )
-
-    has_drowning_mitigation = has_drowning_mitigation || (
-        feature_list.includes("Above Ground") && feature_list.includes("Retractable/removable ladder"))
-
-
-    if(feature_list.includes('Diving Board') || feature_list.includes('Slide')){
-        return {decision: "refer", note: null}
-    } else if(has_drowning_mitigation) {
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "refer", note: null}
-    }
-}
-
-function farming_type(type){
-    let type_enum = ["Farming activities produce income",
-        "Incidental or hobby farming", "Vineyard", "None"]
-    if(typeof type != 'string') {
-         return {decision: "reject", note: "Farming type must be a string"}
-    } else if(!type_enum.includes(type)){
-        return {decision: "reject", note: `Farming type must be in [${type_enum}]`}
-    }
-
-    if(type == 'Vineyard'){
-        return {decision: "refer", note: null}
-    } else if (type == 'Farming activities produce income'){
-        return {decision: "reject", note: "Cannot insure commercial farms"}
-    } else {
-        return {decision: "accept", note: null}
-    }
-}
-
-function has_attractive_nuisance(has_nuisance){
-    if(has_nuisance == "Yes"){
-        return {decision: "refer", note: null}
-    } else if(has_nuisance == "No"){
-        return {decision: "accept", note: null}
-    }
-    return {decision: "reject", note: "Has attractive nuisance must be Yes or No."}
-}
-
-function degree_of_slope(slope_angle){
-    if(!Number.isFinite(slope_angle) ) {
-        return {decision: "reject", note: "Degree of slope must be a number."}
-    } else if(slope_angle < 0){
-        return {decision: "reject", note: "Degree of slope must be a positive number."}
-    }
-
-    if(slope_angle > 30){
-        return {decision: "reject", note: "Slope greater than 30 degrees"}
-    } else {
-        return {decision: "accept", note: null}
-    }
-}
-
-
-
-module.exports = {
-    distance_to_coast, pool_features, farming_type, has_attractive_nuisance, degree_of_slope, flood_score
-}

package/src/knockouts/home_owner_knockouts.js

@@ -1,118 +0,0 @@
-function number_of_dogs(num_dog){
-    if(!Number.isFinite(num_dog) ) {
-         return {decision: "reject", note: "Number of dogs must be a number."}
-    } else if(num_dog < 0){
-        return {decision: "reject", note: "Number of dogs must be a positive number."}
-    }
-
-    if(num_dog < 4){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Owner has 4 or more dogs"}
-    }
-}
-
-function dog_history(has_history){
-    if(has_history == "Yes"){
-        return {decision: "reject", note: "Has a dog with a history of aggressive behavior"}
-    } else if(has_history == "No"){
-        return {decision: "accept", note: null}
-    }
-    return {decision: "reject", note: "Dog has history must be Yes or No."}
-}
-
-function dog_breeds(dogs){
-    if(!Array.isArray(dogs)){
-        return {decision: "reject", note: "Dog breed must be a list"}
-    }
-
-    if(dogs.every(value => value === "non-guard dog of other breeds")){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Dog of given breed not allowed"}
-    }
-}
-
-function exotic_pets(has_exotic_pets){
-    if(has_exotic_pets == "Yes"){
-        return {decision: "reject", note: "Has an exotic pet"}
-    } else if(has_exotic_pets == "No"){
-        return {decision: "accept", note: null}
-    }
-    return {decision: "reject", note: "Has exotic pet must be Yes or No."}
-}
-
-function number_of_mortgages(num_mortgages){
-    if(!Number.isFinite(num_mortgages) ) {
-        return {decision: "reject", note: "Number of mortgages must be a number."}
-    } else if(num_mortgages < 0){
-        return {decision: "reject", note: "Number of mortgages must be a positive number."}
-    }
-
-    if(num_mortgages < 2){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "refer", note: null}
-    }
-}
-
-function number_of_bankruptcies_judgements_or_liens(num_bankruptcies){
-    if(!Number.isFinite(num_bankruptcies) ) {
-        return {decision: "reject", note: "Number of bankruptcies, judgements, or liens must be a number"}
-    } else if(num_bankruptcies < 0){
-        return {decision: "reject", note: "Number of bankruptcies, judgements, or liens must be a positive number"}
-    }
-
-    if(num_bankruptcies === 0){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Has bankruptcies, judgements, or liens"}
-    }
-}
-
-function home_business_type(type) {
-    let type_enum = ["yes - day care", "yes - other", "no"]
-    if (typeof type != 'string') {
-        return {decision: "reject", note: "Home business type must be a string"}
-    } else if (!type_enum.includes(type)) {
-        return {decision: "reject", note: "Home business type must be in [yes - day care, yes - other, no]"}
-    }
-
-    if (type == "no") {
-        return {decision: "accept", note: null}
-    } else if (type == 'yes - day care') {
-        return {decision: "reject", note: "Cannot insure daycare"}
-    } else {
-        return {decision: "refer", note: null}
-    }
-}
-
-function home_rental_type(type){
-    let type_enum = ["short-term rentals less than 6 months of the year", "short term rentals more than 6 months of the year", "timeshare", "no"]
-    if (typeof type != 'string') {
-        return {decision: "reject", note: "Home rental type must be a string"}
-    } else if (!type_enum.includes(type)) {
-        return {decision: "reject", note: "Home rental type must be in [short-term rentals less than 6 months of the year, short term rentals more than 6 months of the year, timeshare, no]"}
-    }
-
-    if (type == "no") {
-        return {decision: "accept", note: null}
-    } else if (["short-term rentals less than 6 months of the year", "timeshare"].includes(type)) {
-        return {decision: "refer", note: null}
-    } else {
-        return {decision: "reject", note: "Cannot insure rentals longer than 6 months"}
-    }
-}
-
-function same_address(applicant_address, co_applicant_address){
-    if (applicant_address === co_applicant_address){
-        return {decision: "accept", note: null}
-    } else {
-        return {decision: "reject", note: "Co-Applicant must have same address as Applicant."}
-    }
-}
-
-module.exports = {
-    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
-}