From 1f0bcf561176ee54584be3aebd805bb12e84fd74 Mon Sep 17 00:00:00 2001 From: Patrick Fic Date: Thu, 9 Feb 2023 12:52:57 -0800 Subject: [PATCH] Updates for dynamic ruleset choices. --- electron/decoder/constants.js | 45 ++++++++++++++++++++++++ electron/decoder/decoder.js | 62 ++++++++++++++++++++++++--------- electron/ipc-main-handler.js | 5 +++ src/graphql/jobs.queries.js | 10 ++++++ src/ipc.types.js | 6 ++-- src/ipc/ipc-estimate-utils.js | 9 +++++ src/ipc/ipc-renderer-handler.js | 13 ++++--- src/util/constants.js | 36 ++++++++++--------- 8 files changed, 147 insertions(+), 39 deletions(-) create mode 100644 electron/decoder/constants.js diff --git a/electron/decoder/constants.js b/electron/decoder/constants.js new file mode 100644 index 0000000..a371c13 --- /dev/null +++ b/electron/decoder/constants.js @@ -0,0 +1,45 @@ +const moment = require("moment"); + +const DateFormat = "MM/DD/yyyy"; +const RuleSets = [ + { + title: "V1", + range: [moment("2010-01-01"), moment("2023-04-01")], + }, + { + title: "V2", + range: [moment("2023-04-01"), moment("2040-01-01")], + }, +]; + +function ChangeOfRuleSet({ + prevDateMoment = moment(), + newDateMoment = moment(), +}) { + const prevRuleSet = RuleSets.find( + (r) => + prevDateMoment.isSameOrAfter(r.range[0]) && + prevDateMoment.isSameOrBefore(r.range[1]) + ); + + const newRuleSet = RuleSets.find( + (r) => + newDateMoment.isSameOrAfter(r.range[0]) && + newDateMoment.isSameOrBefore(r.range[1]) + ); + + return prevRuleSet?.title !== newRuleSet?.title; +} + +function WhichRulesetToApply(close_date) { + const DateMoment = moment(close_date); + const newRuleSet = RuleSets.find( + (r) => + DateMoment.isSameOrAfter(r.range[0]) && + DateMoment.isSameOrBefore(r.range[1]) + ); + console.log("Using ruleset:", newRuleSet); + + return newRuleSet?.title; +} +exports.WhichRulesetToApply = WhichRulesetToApply; diff --git a/electron/decoder/decoder.js b/electron/decoder/decoder.js index 681bfd0..ab97c9e 100644 --- a/electron/decoder/decoder.js +++ b/electron/decoder/decoder.js @@ -8,13 +8,27 @@ const ipcTypes = require("../../src/ipc.types"); const { NewNotification, } = require("../notification-wrapper/notification-wrapper"); +const { WhichRulesetToApply } = require("./constants"); //const Nucleus = require("nucleus-nodejs"); -async function ImportJob(path) { - const b = BrowserWindow.getAllWindows()[0]; - b.webContents.send(ipcTypes.default.estimate.toRenderer.estimateDecodeStart); - const newJob = await DecodeEstimate(path); +async function ImportJob(filepath) { + const parsedFilePath = path.parse(filepath); + let extensionlessFilePath = path.join( + parsedFilePath.dir, + parsedFilePath.name + ); + const decodedJob = await DecodeAd1File(extensionlessFilePath); + const b = BrowserWindow.getAllWindows()[0]; + b.webContents.send(ipcTypes.default.estimate.toRenderer.getCloseDate, { + filepath, + clm_no: decodedJob.CLM_NO, + }); +} + +async function ImportJobWithCloseDate(filepath, close_date) { + const newJob = await DecodeEstimate(filepath, false, close_date); + const b = BrowserWindow.getAllWindows()[0]; if (newJob && !newJob.ERROR) { b.webContents.send( ipcTypes.default.estimate.toRenderer.estimateDecodeSuccess, @@ -35,7 +49,13 @@ async function ImportJob(path) { } } -async function DecodeEstimate(filePath, includeFilePathInReturnJob = false) { +exports.ImportJobWithCloseDate = ImportJobWithCloseDate; + +async function DecodeEstimate( + filePath, + includeFilePathInReturnJob = false, + close_date = null +) { const parsedFilePath = path.parse(filePath); let extensionlessFilePath = path.join( parsedFilePath.dir, @@ -45,7 +65,7 @@ async function DecodeEstimate(filePath, includeFilePathInReturnJob = false) { ...(await DecodeAd1File(extensionlessFilePath)), ...(await DecodeVehFile(extensionlessFilePath)), ...(await DecodeTtlFile(extensionlessFilePath)), - ...(await DecodeLinFile(extensionlessFilePath)), + ...(await DecodeLinFile(extensionlessFilePath, close_date)), ...(includeFilePathInReturnJob ? { filePath } : {}), }; @@ -286,7 +306,7 @@ async function DecodeTtlFile(extensionlessFilePath) { return { clm_total: records[0]["G_TTL_AMT"] }; } -async function DecodeLinFile(extensionlessFilePath) { +async function DecodeLinFile(extensionlessFilePath, close_date) { let dbf = await DBFFile.open(`${extensionlessFilePath}.LIN`); let records = await dbf.readRecords(); let joblines = records.map((record) => { @@ -356,12 +376,20 @@ async function DecodeLinFile(extensionlessFilePath) { joblines.map((jobline) => { jobline.ignore = false; + const rulesetToApply = WhichRulesetToApply(close_date); - if (false) { - jobline = V2Ruleset(jobline); - } else { - jobline = V1Ruleset(jobline); + switch (rulesetToApply) { + case "V1": + jobline = V1Ruleset(jobline, joblines); + break; + case "V2": + jobline = V2Ruleset(jobline, joblines); + break; + default: + jobline = V1Ruleset(jobline, joblines); + break; } + return jobline; }); @@ -373,9 +401,8 @@ async function DecodeLinFile(extensionlessFilePath) { exports.DecodeEstimate = DecodeEstimate; exports.ImportJob = ImportJob; -function V1Ruleset(jobline) { +function V1Ruleset(jobline, joblines) { //These set of MPI rules are valid until April 1, 2023. - log.info(`Using V1 ruleset for line scanning.`); //Wheel Repair Pricing PRS-82 //Verified on 08/24/21 @@ -484,11 +511,11 @@ function V1Ruleset(jobline) { return jobline; } -function V2Ruleset(jobline) { +function V2Ruleset(jobline, joblines) { //This is the rules psot 04/01/2023. They are a further restrictive set, and therefore //V1 rules are called first, and then run through this filter as well. - V1Ruleset(jobline); + V1Ruleset(jobline, joblines); //Remove any glass related items. if (jobline.part_type.toUpperCase() === "PAG") { @@ -497,7 +524,10 @@ function V2Ruleset(jobline) { //ADAS Part Line if ( - AdasDescriptions.some((d) => jobline.line_desc.toLowerCase().includes(d)) + AdasDescriptions.some((d) => { + const ret = jobline.line_desc.toLowerCase().includes(d); + return ret; + }) ) { jobline.ignore = true; } diff --git a/electron/ipc-main-handler.js b/electron/ipc-main-handler.js index a07b835..9a73250 100644 --- a/electron/ipc-main-handler.js +++ b/electron/ipc-main-handler.js @@ -3,6 +3,7 @@ const { ipcMain, app: electronApp } = require("electron"); const { default: ipcTypes } = require("../src/ipc.types"); const { store } = require("./electron-store"); const log = require("electron-log"); +const { ImportJobWithCloseDate } = require("./decoder/decoder"); //Import Ipc Handlers require("./file-watcher/file-watcher-ipc"); @@ -46,6 +47,10 @@ ipcMain.on(ipcTypes.app.toMain.getReleaseNotes, (event, obj) => { } }); +ipcMain.on(ipcTypes.app.toMain.importJob, (event, { filepath, close_date }) => { + ImportJobWithCloseDate(filepath, close_date); +}); + ipcMain.on(ipcTypes.app.toMain.log.debug, (event, ...obj) => { log.debug(obj); }); diff --git a/src/graphql/jobs.queries.js b/src/graphql/jobs.queries.js index bff8ca1..925e0b1 100644 --- a/src/graphql/jobs.queries.js +++ b/src/graphql/jobs.queries.js @@ -140,6 +140,16 @@ export const QUERY_JOB_BY_CLM_NO = gql` } `; + +export const QUERY_CLOSE_DATE_BY_CLM_NO = gql` + query QUERY_CLOSE_DATE_BY_CLM_NO($clm_no: String!) { + jobs(where: { clm_no: { _eq: $clm_no } }) { + id + close_date + } + } +`; + export const UPDATE_JOB = gql` mutation UPDATE_JOB($jobId: uuid!, $job: jobs_set_input!) { update_jobs(where: { id: { _eq: $jobId } }, _set: $job) { diff --git a/src/ipc.types.js b/src/ipc.types.js index 8eef8eb..943b3ac 100644 --- a/src/ipc.types.js +++ b/src/ipc.types.js @@ -13,13 +13,14 @@ exports.default = { downloadUpdates: "app_downloadUpdates", installUpdates: "app_installupdates", getReleaseNotes: "app_getReleaseNotes", + importJob:"app_importJob", log: { info: "app_logInfo", debug: "app_logDebug", warn: "app_logWarn", error: "app_logError", - silly: "app_logSilly" - } + silly: "app_logSilly", + }, }, toRenderer: { updateAvailable: "app_updateAvailable", @@ -67,6 +68,7 @@ exports.default = { estimateDecodeStart: "estimatedecode__start", estimateDecodeSuccess: "estimatedecode__success", estimateDecodeFailure: "estimatedecode__failure", + getCloseDate: "getclosedate", }, }, }; diff --git a/src/ipc/ipc-estimate-utils.js b/src/ipc/ipc-estimate-utils.js index 26d8315..08201d8 100644 --- a/src/ipc/ipc-estimate-utils.js +++ b/src/ipc/ipc-estimate-utils.js @@ -5,6 +5,7 @@ import moment from "moment"; import client from "../graphql/GraphQLClient"; import { INSERT_NEW_JOB, + QUERY_CLOSE_DATE_BY_CLM_NO, QUERY_JOB_BY_CLM_NO, UPDATE_JOB, } from "../graphql/jobs.queries"; @@ -48,6 +49,14 @@ export function CalculateVehicleAge(job) { return ret; } +export async function GetR4PDateWithClaim(clm_no) { + const existingJobs = await client.query({ + query: QUERY_CLOSE_DATE_BY_CLM_NO, + variables: { clm_no: clm_no }, + }); + return existingJobs.data.jobs[0] && existingJobs.data.jobs[0].close_date; +} + export async function UpsertEstimate(job) { const shopId = store.getState().user.bodyshop.id; //logger.info("Beginning Upserting job from Renderer."); diff --git a/src/ipc/ipc-renderer-handler.js b/src/ipc/ipc-renderer-handler.js index e2e6a81..74ba9a7 100644 --- a/src/ipc/ipc-renderer-handler.js +++ b/src/ipc/ipc-renderer-handler.js @@ -8,7 +8,7 @@ import { setWatcherStatus, } from "../redux/application/application.actions"; import { store } from "../redux/store"; -import { UpsertEstimate } from "./ipc-estimate-utils"; +import { GetR4PDateWithClaim, UpsertEstimate } from "./ipc-estimate-utils"; import { setScanEstimateList } from "../redux/scan/scan.actions"; import { signOutStart } from "../redux/user/user.actions"; const { ipcRenderer } = window; @@ -44,16 +44,19 @@ ipcRenderer.on(ipcTypes.default.fileWatcher.toRenderer.error, (event, obj) => { //Estimate Section ipcRenderer.on( - ipcTypes.default.estimate.toRenderer.estimateDecodeStart, - (event, obj) => { - console.log("Decoding started!"); + ipcTypes.default.estimate.toRenderer.getCloseDate, + async (event, { filepath, clm_no }) => { + const close_date = await GetR4PDateWithClaim(clm_no); + ipcRenderer.send(ipcTypes.default.app.toMain.importJob, { + filepath, + close_date, + }); } ); ipcRenderer.on( ipcTypes.default.estimate.toRenderer.estimateDecodeSuccess, async (event, obj) => { - await UpsertEstimate(obj); } ); diff --git a/src/util/constants.js b/src/util/constants.js index 330e524..f52b405 100644 --- a/src/util/constants.js +++ b/src/util/constants.js @@ -1,27 +1,21 @@ import moment from "moment"; export const DateFormat = "MM/DD/yyyy"; +const RuleSets = [ + { + title: "V1", + range: [moment("2010-01-01"), moment("2023-04-01")], + }, + { + title: "V2", + range: [moment("2023-04-01"), moment("2040-01-01")], + }, +]; export function ChangeOfRuleSet({ prevDateMoment = moment(), newDateMoment = moment(), }) { - console.log("🚀 ~ file: constants.js ~ line 9 ~ newDateMoment", newDateMoment) - console.log("🚀 ~ file: constants.js ~ line 9 ~ prevDateMoment", prevDateMoment) - - - //Define the rule periods. - const V1 = { - title: "V1", - range: [moment("2010-01-01"), moment("2023-04-01")], - }; - const V2 = { - title: "V2", - range: [moment("2023-04-01"), moment("2040-01-01")], - }; //Arbitrarily long away date. - - const RuleSets = [V1, V2]; - const prevRuleSet = RuleSets.find( (r) => prevDateMoment.isSameOrAfter(r.range[0]) && @@ -36,3 +30,13 @@ export function ChangeOfRuleSet({ return prevRuleSet?.title !== newRuleSet?.title; } + +export function WhichRulesetToApply({ DateMoment = moment() }) { + const newRuleSet = RuleSets.find( + (r) => + DateMoment.isSameOrAfter(r.range[0]) && + DateMoment.isSameOrBefore(r.range[1]) + ); + + return newRuleSet?.title; +}