stand_socotra_policy_transformer 1.0.0

package/src/knockouts/claims_history_knockout.js

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,118 @@
+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
+}

package/src/knockouts/index.js

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,155 @@
+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
+}