parse legacy work orders

helpers/lotOccupancyDB/addWorkOrderLot.js

@@ -3,14 +3,37 @@ import { lotOccupancyDB as databasePath } from "../../data/databasePaths.js";
 export const addWorkOrderLot = (workOrderLotForm, requestSession) => {
     const database = sqlite(databasePath);
     const rightNowMillis = Date.now();
-    const result = database
+    const row = database
-        .prepare("insert into WorkOrderLots (" +
+        .prepare("select recordDelete_timeMillis" +
-        "workOrderId, lotId," +
+        " from WorkOrderLots" +
-        " recordCreate_userName, recordCreate_timeMillis," +
+        " where workOrderId = ?" +
-        " recordUpdate_userName, recordUpdate_timeMillis)" +
+        " and lotId = ?")
-        " values (?, ?, ?, ?, ?, ?)")
+        .get(workOrderLotForm.workOrderId, workOrderLotForm.lotId);
-        .run(workOrderLotForm.workOrderId, workOrderLotForm.lotId, requestSession.user.userName, rightNowMillis, requestSession.user.userName, rightNowMillis);
+    if (row) {
+        if (row.recordDelete_timeMillis) {
+            database
+                .prepare("update WorkOrderLots" +
+                " set recordCreate_userName = ?," +
+                " recordCreate_timeMillis = ?," +
+                " recordUpdate_userName = ?," +
+                " recordUpdate_timeMillis = ?," +
+                " recordDelete_userName = null," +
+                " recordDelete_timeMillis = null" +
+                " where workOrderId = ?" +
+                " and lotId = ?")
+                .run(requestSession.user.userName, rightNowMillis, requestSession.user.userName, rightNowMillis, workOrderLotForm.workOrderId, workOrderLotForm.lotId);
+        }
+    }
+    else {
+        database
+            .prepare("insert into WorkOrderLots (" +
+            "workOrderId, lotId," +
+            " recordCreate_userName, recordCreate_timeMillis," +
+            " recordUpdate_userName, recordUpdate_timeMillis)" +
+            " values (?, ?, ?, ?, ?, ?)")
+            .run(workOrderLotForm.workOrderId, workOrderLotForm.lotId, requestSession.user.userName, rightNowMillis, requestSession.user.userName, rightNowMillis);
+    }
     database.close();
-    return result.changes > 0;
+    return true;
 };
 export default addWorkOrderLot;

helpers/lotOccupancyDB/addWorkOrderLot.ts

@@ -17,26 +17,60 @@ export const addWorkOrderLot = (
 
     const rightNowMillis = Date.now();
 
-    const result = database
+    const row: { recordDelete_timeMillis?: number } = database
         .prepare(
-            "insert into WorkOrderLots (" +
+            "select recordDelete_timeMillis" +
-                "workOrderId, lotId," +
+                " from WorkOrderLots" +
-                " recordCreate_userName, recordCreate_timeMillis," +
+                " where workOrderId = ?" +
-                " recordUpdate_userName, recordUpdate_timeMillis)" +
+                " and lotId = ?"
-                " values (?, ?, ?, ?, ?, ?)"
         )
-        .run(
+        .get(workOrderLotForm.workOrderId, workOrderLotForm.lotId);
-            workOrderLotForm.workOrderId,
+
-            workOrderLotForm.lotId,
+    if (row) {
-            requestSession.user.userName,
+        if (row.recordDelete_timeMillis) {
-            rightNowMillis,
+            database
-            requestSession.user.userName,
+                .prepare(
-            rightNowMillis
+                    "update WorkOrderLots" +
-        );
+                        " set recordCreate_userName = ?," +
+                        " recordCreate_timeMillis = ?," +
+                        " recordUpdate_userName = ?," +
+                        " recordUpdate_timeMillis = ?," +
+                        " recordDelete_userName = null," +
+                        " recordDelete_timeMillis = null" +
+                        " where workOrderId = ?" +
+                        " and lotId = ?"
+                )
+                .run(
+                    requestSession.user.userName,
+                    rightNowMillis,
+                    requestSession.user.userName,
+                    rightNowMillis,
+                    workOrderLotForm.workOrderId,
+                    workOrderLotForm.lotId
+                );
+        }
+    } else {
+        database
+            .prepare(
+                "insert into WorkOrderLots (" +
+                    "workOrderId, lotId," +
+                    " recordCreate_userName, recordCreate_timeMillis," +
+                    " recordUpdate_userName, recordUpdate_timeMillis)" +
+                    " values (?, ?, ?, ?, ?, ?)"
+            )
+            .run(
+                workOrderLotForm.workOrderId,
+                workOrderLotForm.lotId,
+                requestSession.user.userName,
+                rightNowMillis,
+                requestSession.user.userName,
+                rightNowMillis
+            );
+    }
 
     database.close();
 
-    return result.changes > 0;
+    return true;
 };
 
 export default addWorkOrderLot;

helpers/lotOccupancyDB/getLot.d.ts

@@ -1,3 +1,4 @@
 import type * as recordTypes from "../../types/recordTypes";
+export declare const getLotByLotName: (lotName: string) => recordTypes.Lot;
 export declare const getLot: (lotId: number | string) => recordTypes.Lot;
 export default getLot;

helpers/lotOccupancyDB/getLot.js

@@ -2,35 +2,39 @@ import sqlite from "better-sqlite3";
 import { lotOccupancyDB as databasePath } from "../../data/databasePaths.js";
 import { getLotComments } from "./getLotComments.js";
 import { getLotOccupancies } from "./getLotOccupancies.js";
-export const getLot = (lotId) => {
+const baseSQL = "select l.lotId," +
+    " l.lotTypeId, t.lotType," +
+    " l.lotName," +
+    " l.lotStatusId, s.lotStatus," +
+    " l.mapId, m.mapName, m.mapSVG, l.mapKey," +
+    " l.lotLatitude, l.lotLongitude" +
+    " from Lots l" +
+    " left join LotTypes t on l.lotTypeId = t.lotTypeId" +
+    " left join LotStatuses s on l.lotStatusId = s.lotStatusId" +
+    " left join Maps m on l.mapId = m.mapId" +
+    " where  l.recordDelete_timeMillis is null";
+const _getLot = (sql, lotId_or_lotName) => {
     const database = sqlite(databasePath, {
         readonly: true
     });
-    const lot = database
+    const lot = database.prepare(sql).get(lotId_or_lotName);
-        .prepare("select l.lotId," +
-        " l.lotTypeId, t.lotType," +
-        " l.lotName," +
-        " l.lotStatusId, s.lotStatus," +
-        " l.mapId, m.mapName, m.mapSVG, l.mapKey," +
-        " l.lotLatitude, l.lotLongitude" +
-        " from Lots l" +
-        " left join LotTypes t on l.lotTypeId = t.lotTypeId" +
-        " left join LotStatuses s on l.lotStatusId = s.lotStatusId" +
-        " left join Maps m on l.mapId = m.mapId" +
-        " where  l.recordDelete_timeMillis is null" +
-        " and l.lotId = ?")
-        .get(lotId);
     if (lot) {
         lot.lotOccupancies = getLotOccupancies({
-            lotId
+            lotId: lot.lotId
         }, {
             includeOccupants: true,
             limit: -1,
             offset: 0
         }, database).lotOccupancies;
-        lot.lotComments = getLotComments(lotId);
+        lot.lotComments = getLotComments(lot.lotId);
     }
     database.close();
     return lot;
 };
+export const getLotByLotName = (lotName) => {
+    return _getLot(baseSQL + " and l.lotName = ?", lotName);
+};
+export const getLot = (lotId) => {
+    return _getLot(baseSQL + " and l.lotId = ?", lotId);
+};
 export default getLot;

helpers/lotOccupancyDB/getLot.ts

@@ -8,32 +8,33 @@ import { getLotOccupancies } from "./getLotOccupancies.js";
 
 import type * as recordTypes from "../../types/recordTypes";
 
-export const getLot = (lotId: number | string): recordTypes.Lot => {
+const baseSQL =
+    "select l.lotId," +
+    " l.lotTypeId, t.lotType," +
+    " l.lotName," +
+    " l.lotStatusId, s.lotStatus," +
+    " l.mapId, m.mapName, m.mapSVG, l.mapKey," +
+    " l.lotLatitude, l.lotLongitude" +
+    " from Lots l" +
+    " left join LotTypes t on l.lotTypeId = t.lotTypeId" +
+    " left join LotStatuses s on l.lotStatusId = s.lotStatusId" +
+    " left join Maps m on l.mapId = m.mapId" +
+    " where  l.recordDelete_timeMillis is null";
+
+const _getLot = (
+    sql: string,
+    lotId_or_lotName: number | string
+): recordTypes.Lot => {
     const database = sqlite(databasePath, {
         readonly: true
     });
 
-    const lot: recordTypes.Lot = database
+    const lot: recordTypes.Lot = database.prepare(sql).get(lotId_or_lotName);
-        .prepare(
-            "select l.lotId," +
-                " l.lotTypeId, t.lotType," +
-                " l.lotName," +
-                " l.lotStatusId, s.lotStatus," +
-                " l.mapId, m.mapName, m.mapSVG, l.mapKey," +
-                " l.lotLatitude, l.lotLongitude" +
-                " from Lots l" +
-                " left join LotTypes t on l.lotTypeId = t.lotTypeId" +
-                " left join LotStatuses s on l.lotStatusId = s.lotStatusId" +
-                " left join Maps m on l.mapId = m.mapId" +
-                " where  l.recordDelete_timeMillis is null" +
-                " and l.lotId = ?"
-        )
-        .get(lotId);
 
     if (lot) {
         lot.lotOccupancies = getLotOccupancies(
             {
-                lotId
+                lotId: lot.lotId
             },
             {
                 includeOccupants: true,
@@ -43,7 +44,7 @@ export const getLot = (lotId: number | string): recordTypes.Lot => {
             database
         ).lotOccupancies;
 
-        lot.lotComments = getLotComments(lotId);
+        lot.lotComments = getLotComments(lot.lotId);
     }
 
     database.close();
@@ -51,4 +52,12 @@ export const getLot = (lotId: number | string): recordTypes.Lot => {
     return lot;
 };
 
+export const getLotByLotName = (lotName: string): recordTypes.Lot => {
+    return _getLot(baseSQL + " and l.lotName = ?", lotName);
+};
+
+export const getLot = (lotId: number | string): recordTypes.Lot => {
+    return _getLot(baseSQL + " and l.lotId = ?", lotId);
+};
+
 export default getLot;

helpers/lotOccupancyDB/getWorkOrder.d.ts

@@ -1,3 +1,4 @@
 import type * as recordTypes from "../../types/recordTypes";
+export declare const getWorkOrderByWorkOrderNumber: (workOrderNumber: string) => recordTypes.WorkOrder;
 export declare const getWorkOrder: (workOrderId: number | string) => recordTypes.WorkOrder;
 export default getWorkOrder;

helpers/lotOccupancyDB/getWorkOrder.js

@@ -3,22 +3,22 @@ import { lotOccupancyDB as databasePath } from "../../data/databasePaths.js";
 import { dateIntegerToString } from "@cityssm/expressjs-server-js/dateTimeFns.js";
 import { getLots } from "./getLots.js";
 import { getLotOccupancies } from "./getLotOccupancies.js";
-export const getWorkOrder = (workOrderId) => {
+const baseSQL = "select w.workOrderId," +
+    " w.workOrderTypeId, t.workOrderType," +
+    " w.workOrderNumber, w.workOrderDescription," +
+    " w.workOrderOpenDate, userFn_dateIntegerToString(w.workOrderOpenDate) as workOrderOpenDateString," +
+    " w.workOrderCloseDate, userFn_dateIntegerToString(w.workOrderCloseDate) as workOrderCloseDateString" +
+    " from WorkOrders w" +
+    " left join WorkOrderTypes t on w.workOrderTypeId = t.workOrderTypeId" +
+    " where w.recordDelete_timeMillis is null";
+const _getWorkOrder = (sql, workOrderId_or_workOrderNumber) => {
     const database = sqlite(databasePath, {
         readonly: true
     });
     database.function("userFn_dateIntegerToString", dateIntegerToString);
     const workOrder = database
-        .prepare("select w.workOrderId," +
+        .prepare(sql)
-        " w.workOrderTypeId, t.workOrderType," +
+        .get(workOrderId_or_workOrderNumber);
-        " w.workOrderNumber, w.workOrderDescription," +
-        " w.workOrderOpenDate, userFn_dateIntegerToString(w.workOrderOpenDate) as workOrderOpenDateString," +
-        " w.workOrderCloseDate, userFn_dateIntegerToString(w.workOrderCloseDate) as workOrderCloseDateString" +
-        " from WorkOrders w" +
-        " left join WorkOrderTypes t on w.workOrderTypeId = t.workOrderTypeId" +
-        " where w.recordDelete_timeMillis is null" +
-        " and w.workOrderId = ?")
-        .get(workOrderId);
     if (workOrder) {
         workOrder.workOrderLots = getLots({
             workOrderId: workOrder.workOrderId
@@ -37,4 +37,10 @@ export const getWorkOrder = (workOrderId) => {
     database.close();
     return workOrder;
 };
+export const getWorkOrderByWorkOrderNumber = (workOrderNumber) => {
+    return _getWorkOrder(baseSQL + " and w.workOrderNumber = ?", workOrderNumber);
+};
+export const getWorkOrder = (workOrderId) => {
+    return _getWorkOrder(baseSQL + " and w.workOrderId = ?", workOrderId);
+};
 export default getWorkOrder;

helpers/lotOccupancyDB/getWorkOrder.ts

@@ -10,8 +10,19 @@ import { getLotOccupancies } from "./getLotOccupancies.js";
 
 import type * as recordTypes from "../../types/recordTypes";
 
-export const getWorkOrder = (
+const baseSQL =
-    workOrderId: number | string
+    "select w.workOrderId," +
+    " w.workOrderTypeId, t.workOrderType," +
+    " w.workOrderNumber, w.workOrderDescription," +
+    " w.workOrderOpenDate, userFn_dateIntegerToString(w.workOrderOpenDate) as workOrderOpenDateString," +
+    " w.workOrderCloseDate, userFn_dateIntegerToString(w.workOrderCloseDate) as workOrderCloseDateString" +
+    " from WorkOrders w" +
+    " left join WorkOrderTypes t on w.workOrderTypeId = t.workOrderTypeId" +
+    " where w.recordDelete_timeMillis is null";
+
+const _getWorkOrder = (
+    sql: string,
+    workOrderId_or_workOrderNumber: number | string
 ): recordTypes.WorkOrder => {
     const database = sqlite(databasePath, {
         readonly: true
@@ -20,18 +31,8 @@ export const getWorkOrder = (
     database.function("userFn_dateIntegerToString", dateIntegerToString);
 
     const workOrder: recordTypes.WorkOrder = database
-        .prepare(
+        .prepare(sql)
-            "select w.workOrderId," +
+        .get(workOrderId_or_workOrderNumber);
-                " w.workOrderTypeId, t.workOrderType," +
-                " w.workOrderNumber, w.workOrderDescription," +
-                " w.workOrderOpenDate, userFn_dateIntegerToString(w.workOrderOpenDate) as workOrderOpenDateString," +
-                " w.workOrderCloseDate, userFn_dateIntegerToString(w.workOrderCloseDate) as workOrderCloseDateString" +
-                " from WorkOrders w" +
-                " left join WorkOrderTypes t on w.workOrderTypeId = t.workOrderTypeId" +
-                " where w.recordDelete_timeMillis is null" +
-                " and w.workOrderId = ?"
-        )
-        .get(workOrderId);
 
     if (workOrder) {
         workOrder.workOrderLots = getLots(
@@ -63,4 +64,19 @@ export const getWorkOrder = (
     return workOrder;
 };
 
+export const getWorkOrderByWorkOrderNumber = (
+    workOrderNumber: string
+): recordTypes.WorkOrder => {
+    return _getWorkOrder(
+        baseSQL + " and w.workOrderNumber = ?",
+        workOrderNumber
+    );
+};
+
+export const getWorkOrder = (
+    workOrderId: number | string
+): recordTypes.WorkOrder => {
+    return _getWorkOrder(baseSQL + " and w.workOrderId = ?", workOrderId);
+};
+
 export default getWorkOrder;

helpers/lotOccupancyDB/reopenWorkOrder.d.ts

@@ -0,0 +1,3 @@
+import type * as recordTypes from "../../types/recordTypes";
+export declare const reopenWorkOrder: (workOrderId: number | string, requestSession: recordTypes.PartialSession) => boolean;
+export default reopenWorkOrder;

helpers/lotOccupancyDB/reopenWorkOrder.js

@@ -0,0 +1,17 @@
+import sqlite from "better-sqlite3";
+import { lotOccupancyDB as databasePath } from "../../data/databasePaths.js";
+export const reopenWorkOrder = (workOrderId, requestSession) => {
+    const database = sqlite(databasePath);
+    const rightNowMillis = Date.now();
+    const result = database
+        .prepare("update Maps" +
+        " set workOrderCloseDate = null," +
+        " recordUpdate_userName = ?," +
+        " recordUpdate_timeMillis = ?" +
+        " where workOrderId = ?" +
+        " and workOrderCloseDate is not null")
+        .run(requestSession.user.userName, rightNowMillis, workOrderId);
+    database.close();
+    return result.changes > 0;
+};
+export default reopenWorkOrder;

helpers/lotOccupancyDB/reopenWorkOrder.ts

@@ -0,0 +1,31 @@
+import sqlite from "better-sqlite3";
+
+import { lotOccupancyDB as databasePath } from "../../data/databasePaths.js";
+
+import type * as recordTypes from "../../types/recordTypes";
+
+export const reopenWorkOrder = (
+    workOrderId: number | string,
+    requestSession: recordTypes.PartialSession
+): boolean => {
+    const database = sqlite(databasePath);
+
+    const rightNowMillis = Date.now();
+
+    const result = database
+        .prepare(
+            "update Maps" +
+                " set workOrderCloseDate = null," +
+                " recordUpdate_userName = ?," +
+                " recordUpdate_timeMillis = ?" +
+                " where workOrderId = ?" +
+                " and workOrderCloseDate is not null"
+        )
+        .run(requestSession.user.userName, rightNowMillis, workOrderId);
+
+    database.close();
+
+    return result.changes > 0;
+};
+
+export default reopenWorkOrder;

temp/legacy.importFromCSV.js

@@ -11,14 +11,16 @@ import { addLotOccupancy } from "../helpers/lotOccupancyDB/addLotOccupancy.js";
 import { addLotOccupancyOccupant } from "../helpers/lotOccupancyDB/addLotOccupancyOccupant.js";
 import { addLotOccupancyComment } from "../helpers/lotOccupancyDB/addLotOccupancyComment.js";
 import { addOrUpdateLotOccupancyField } from "../helpers/lotOccupancyDB/addOrUpdateLotOccupancyField.js";
-import { getLot } from "../helpers/lotOccupancyDB/getLot.js";
+import { getLot, getLotByLotName } from "../helpers/lotOccupancyDB/getLot.js";
-import { getLots } from "../helpers/lotOccupancyDB/getLots.js";
 import { getLotOccupancies } from "../helpers/lotOccupancyDB/getLotOccupancies.js";
 import { addLotOccupancyFee } from "../helpers/lotOccupancyDB/addLotOccupancyFee.js";
 import { addLotOccupancyTransaction } from "../helpers/lotOccupancyDB/addLotOccupancyTransaction.js";
 import { addWorkOrder } from "../helpers/lotOccupancyDB/addWorkOrder.js";
 import { addWorkOrderLot } from "../helpers/lotOccupancyDB/addWorkOrderLot.js";
 import { addWorkOrderLotOccupancy } from "../helpers/lotOccupancyDB/addWorkOrderLotOccupancy.js";
+import { getWorkOrder, getWorkOrderByWorkOrderNumber } from "../helpers/lotOccupancyDB/getWorkOrder.js";
+import { reopenWorkOrder } from "../helpers/lotOccupancyDB/reopenWorkOrder.js";
+import { dateIntegerToString } from "@cityssm/expressjs-server-js/dateTimeFns.js";
 const user = {
     user: {
         userName: "import.unix",
@@ -417,12 +419,14 @@ function importFromMasterCSV() {
                 updateLotStatus(lotId, takenLotStatus.lotStatusId, user);
             }
             if (masterRow.CM_WORK_ORDER) {
+                const workOrderDateString = deceasedOccupancyStartDateString ||
+                    preneedOccupancyStartDateString;
                 const workOrderId = addWorkOrder({
                     workOrderNumber: masterRow.CM_WORK_ORDER,
                     workOrderTypeId: 1,
                     workOrderDescription: "",
-                    workOrderOpenDateString: deceasedOccupancyStartDateString ||
+                    workOrderOpenDateString: workOrderDateString,
-                        preneedOccupancyStartDateString
+                    workOrderCloseDateString: workOrderDateString
                 }, user);
                 if (lotId) {
                     addWorkOrderLot({
@@ -486,17 +490,8 @@ function importFromPrepaidCSV() {
                     grave2: prepaidRow.CMPP_GRAVE2,
                     interment: prepaidRow.CMPP_INTERMENT
                 });
-                const possibleLots = getLots({
+                lot = getLotByLotName(lotName);
-                    mapId: map.mapId,
+                if (!lot) {
-                    lotName
-                }, {
-                    limit: -1,
-                    offset: 0
-                });
-                if (possibleLots.lots.length > 0) {
-                    lot = possibleLots.lots[0];
-                }
-                else {
                     const lotType = getLotType({
                         cemetery
                     });
@@ -686,6 +681,194 @@ function importFromPrepaidCSV() {
         console.log(prepaidRow);
     }
 }
+function importFromWorkOrderCSV() {
+    let workOrderRow;
+    const rawData = fs.readFileSync("./temp/CMWKORDR.csv").toString();
+    const cmwkordr = papa.parse(rawData, {
+        delimiter: ",",
+        header: true,
+        skipEmptyLines: true
+    });
+    for (const parseError of cmwkordr.errors) {
+        console.log(parseError);
+    }
+    try {
+        for (workOrderRow of cmwkordr.data) {
+            let workOrder = getWorkOrderByWorkOrderNumber(workOrderRow.WO_WORK_ORDER);
+            const workOrderOpenDateString = dateIntegerToString(Number.parseInt(workOrderRow.WO_INITIATION_DATE, 10));
+            if (workOrder) {
+                if (workOrder.workOrderCloseDate) {
+                    reopenWorkOrder(workOrder.workOrderId, user);
+                    delete workOrder.workOrderCloseDate;
+                    delete workOrder.workOrderCloseDateString;
+                }
+            }
+            else {
+                const workOrderId = addWorkOrder({
+                    workOrderNumber: workOrderRow.WO_WORK_ORDER,
+                    workOrderTypeId: 1,
+                    workOrderDescription: (workOrderRow.WO_REMARK1 +
+                        " " +
+                        workOrderRow.WO_REMARK2 +
+                        " " +
+                        workOrderRow.WO_REMARK3).trim(),
+                    workOrderOpenDateString
+                }, user);
+                workOrder = getWorkOrder(workOrderId);
+            }
+            let lot;
+            if (workOrderRow.WO_CEMETERY !== "00") {
+                const lotName = buildLotName({
+                    cemetery: workOrderRow.WO_CEMETERY,
+                    block: workOrderRow.WO_BLOCK,
+                    range1: workOrderRow.WO_RANGE1,
+                    range2: workOrderRow.WO_RANGE2,
+                    lot1: workOrderRow.WO_LOT1,
+                    lot2: workOrderRow.WO_LOT2,
+                    grave1: workOrderRow.WO_GRAVE1,
+                    grave2: workOrderRow.WO_GRAVE2,
+                    interment: workOrderRow.WO_INTERMENT
+                });
+                lot = getLotByLotName(lotName);
+                if (!lot) {
+                    const map = getMap({ cemetery: workOrderRow.WO_CEMETERY });
+                    const lotType = getLotType({
+                        cemetery: workOrderRow.WO_CEMETERY
+                    });
+                    const lotId = addLot({
+                        mapId: map.mapId,
+                        lotName,
+                        mapKey: lotName,
+                        lotStatusId: takenLotStatus.lotStatusId,
+                        lotTypeId: lotType.lotTypeId,
+                        lotLatitude: "",
+                        lotLongitude: ""
+                    }, user);
+                    lot = getLot(lotId);
+                }
+                else {
+                    updateLotStatus(lot.lotId, takenLotStatus.lotStatusId, user);
+                }
+                const workOrderContainsLot = workOrder.workOrderLots.find((possibleLot) => {
+                    return (possibleLot.lotId = lot.lotId);
+                });
+                if (!workOrderContainsLot) {
+                    addWorkOrderLot({
+                        workOrderId: workOrder.workOrderId,
+                        lotId: lot.lotId
+                    }, user);
+                    workOrder.workOrderLots.push(lot);
+                }
+            }
+            let occupancyStartDateString = workOrderOpenDateString;
+            if (workOrderRow.WO_INTERMENT_YR) {
+                occupancyStartDateString = formatDateString(workOrderRow.WO_INTERMENT_YR, workOrderRow.WO_INTERMENT_MON, workOrderRow.WO_INTERMENT_DAY);
+            }
+            const lotOccupancyId = addLotOccupancy({
+                lotId: lot ? lot.lotId : "",
+                occupancyTypeId: deceasedOccupancyType.occupancyTypeId,
+                occupancyStartDateString,
+                occupancyEndDateString: ""
+            }, user);
+            addLotOccupancyOccupant({
+                lotOccupancyId,
+                lotOccupantTypeId: deceasedLotOccupantType.lotOccupantTypeId,
+                occupantName: workOrderRow.WO_DECEASED_NAME,
+                occupantAddress1: workOrderRow.WO_ADDRESS,
+                occupantAddress2: "",
+                occupantCity: workOrderRow.WO_CITY,
+                occupantProvince: workOrderRow.WO_PROV.slice(0, 2),
+                occupantPostalCode: workOrderRow.WO_POST1 + " " + workOrderRow.WO_POST2,
+                occupantPhoneNumber: ""
+            }, user);
+            if (workOrderRow.WO_DEATH_YR !== "") {
+                const lotOccupancyFieldValue = formatDateString(workOrderRow.WO_DEATH_YR, workOrderRow.WO_DEATH_MON, workOrderRow.WO_DEATH_DAY);
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Death Date");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue
+                }, user);
+            }
+            if (workOrderRow.WO_AGE !== "") {
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Death Age");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue: workOrderRow.WO_AGE
+                }, user);
+            }
+            if (workOrderRow.WO_PERIOD !== "") {
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Death Age Period");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue: workOrderRow.WO_PERIOD
+                }, user);
+            }
+            if (workOrderRow.WO_FUNERAL_HOME !== "") {
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Funeral Home");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue: workOrderRow.WO_FUNERAL_HOME
+                }, user);
+            }
+            if (workOrderRow.WO_FUNERAL_YR !== "") {
+                const lotOccupancyFieldValue = formatDateString(workOrderRow.WO_FUNERAL_YR, workOrderRow.WO_FUNERAL_MON, workOrderRow.WO_FUNERAL_DAY);
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Funeral Date");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue
+                }, user);
+            }
+            if (workOrderRow.WO_CONTAINER_TYPE !== "") {
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Container Type");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue: workOrderRow.WO_CONTAINER_TYPE
+                }, user);
+            }
+            if (workOrderRow.WO_COMMITTAL_TYPE !== "") {
+                let commitalType = workOrderRow.WO_COMMITTAL_TYPE;
+                if (commitalType === "GS") {
+                    commitalType = "Graveside";
+                }
+                addOrUpdateLotOccupancyField({
+                    lotOccupancyId: lotOccupancyId,
+                    occupancyTypeFieldId: deceasedOccupancyType.occupancyTypeFields.find((occupancyTypeField) => {
+                        return (occupancyTypeField.occupancyTypeField ===
+                            "Committal Type");
+                    }).occupancyTypeFieldId,
+                    lotOccupancyFieldValue: commitalType
+                }, user);
+            }
+            addWorkOrderLotOccupancy({
+                workOrderId: workOrder.workOrderId,
+                lotOccupancyId
+            }, user);
+        }
+    }
+    catch (error) {
+        console.error(error);
+        console.log(workOrderRow);
+    }
+}
 purgeTables();
 importFromMasterCSV();
 importFromPrepaidCSV();
+importFromWorkOrderCSV();

temp/legacy.importFromCSV.ts

@@ -23,9 +23,7 @@ import { addLotOccupancyComment } from "../helpers/lotOccupancyDB/addLotOccupanc
 
 import { addOrUpdateLotOccupancyField } from "../helpers/lotOccupancyDB/addOrUpdateLotOccupancyField.js";
 
-import { getLot } from "../helpers/lotOccupancyDB/getLot.js";
+import { getLot, getLotByLotName } from "../helpers/lotOccupancyDB/getLot.js";
-
-import { getLots } from "../helpers/lotOccupancyDB/getLots.js";
 
 import { getLotOccupancies } from "../helpers/lotOccupancyDB/getLotOccupancies.js";
 
@@ -39,6 +37,15 @@ import { addWorkOrderLot } from "../helpers/lotOccupancyDB/addWorkOrderLot.js";
 
 import { addWorkOrderLotOccupancy } from "../helpers/lotOccupancyDB/addWorkOrderLotOccupancy.js";
 
+import {
+    getWorkOrder,
+    getWorkOrderByWorkOrderNumber
+} from "../helpers/lotOccupancyDB/getWorkOrder.js";
+
+import { reopenWorkOrder } from "../helpers/lotOccupancyDB/reopenWorkOrder.js";
+
+import { dateIntegerToString } from "@cityssm/expressjs-server-js/dateTimeFns.js";
+
 import type * as recordTypes from "../types/recordTypes";
 
 interface MasterRecord {
@@ -134,6 +141,56 @@ interface PrepaidRecord {
     CMPP_REMARK2: string;
 }
 
+interface WorkOrderRecord {
+    WO_SYSREC: string;
+    WO_DECEASED_NAME: string;
+    WO_DECEASED_SEQ: string;
+    WO_CEMETERY: string;
+    WO_BLOCK: string;
+    WO_RANGE1: string;
+    WO_RANGE2: string;
+    WO_LOT1: string;
+    WO_LOT2: string;
+    WO_GRAVE1: string;
+    WO_GRAVE2: string;
+    WO_INTERMENT: string;
+    WO_ADDRESS: string;
+    WO_CITY: string;
+    WO_PROV: string;
+    WO_POST1: string;
+    WO_POST2: string;
+    WO_DEATH_YR: string;
+    WO_DEATH_MON: string;
+    WO_DEATH_DAY: string;
+    WO_AGE: string;
+    WO_FUNERAL_HOME: string;
+    WO_FUNERAL_YR: string;
+    WO_FUNERAL_MON: string;
+    WO_FUNERAL_DAY: string;
+    WO_FUNERAL_HR: string;
+    WO_FUNERAL_MIN: string;
+    WO_INTERMENT_YR: string;
+    WO_INTERMENT_MON: string;
+    WO_INTERMENT_DAY: string;
+    WO_COST: string;
+    WO_COMMITTAL_TYPE: string;
+    WO_CONTAINER_TYPE: string;
+    WO_CREMATION: string;
+    WO_CONFIRMATION_IN: string;
+    WO_COMPLETION_YR: string;
+    WO_COMPLETION_MON: string;
+    WO_COMPLETION_DAY: string;
+    WO_INITIATION_DATE: string;
+    WO_WORK_ORDER: string;
+    WO_REMARK1: string;
+    WO_REMARK2: string;
+    WO_REMARK3: string;
+    WO_PERIOD: string;
+    WO_RESIDENT_TYPE: string;
+    WO_DEPTH: string;
+    WO_DEATH_PLACE: string;
+}
+
 const user: recordTypes.PartialSession = {
     user: {
         userName: "import.unix",
@@ -783,14 +840,17 @@ function importFromMasterCSV() {
             }
 
             if (masterRow.CM_WORK_ORDER) {
+                const workOrderDateString =
+                    deceasedOccupancyStartDateString ||
+                    preneedOccupancyStartDateString;
+
                 const workOrderId = addWorkOrder(
                     {
                         workOrderNumber: masterRow.CM_WORK_ORDER,
                         workOrderTypeId: 1,
                         workOrderDescription: "",
-                        workOrderOpenDateString:
+                        workOrderOpenDateString: workOrderDateString,
-                            deceasedOccupancyStartDateString ||
+                        workOrderCloseDateString: workOrderDateString
-                            preneedOccupancyStartDateString
                     },
                     user
                 );
@@ -876,20 +936,9 @@ function importFromPrepaidCSV() {
                     interment: prepaidRow.CMPP_INTERMENT
                 });
 
-                const possibleLots = getLots(
+                lot = getLotByLotName(lotName);
-                    {
-                        mapId: map.mapId,
-                        lotName
-                    },
-                    {
-                        limit: -1,
-                        offset: 0
-                    }
-                );
 
-                if (possibleLots.lots.length > 0) {
+                if (!lot) {
-                    lot = possibleLots.lots[0];
-                } else {
                     const lotType = getLotType({
                         cemetery
                     });
@@ -1165,7 +1214,313 @@ function importFromPrepaidCSV() {
     }
 }
 
+function importFromWorkOrderCSV() {
+    let workOrderRow: WorkOrderRecord;
+
+    const rawData = fs.readFileSync("./temp/CMWKORDR.csv").toString();
+
+    const cmwkordr: papa.ParseResult<WorkOrderRecord> = papa.parse(rawData, {
+        delimiter: ",",
+        header: true,
+        skipEmptyLines: true
+    });
+
+    for (const parseError of cmwkordr.errors) {
+        console.log(parseError);
+    }
+
+    try {
+        for (workOrderRow of cmwkordr.data) {
+            let workOrder = getWorkOrderByWorkOrderNumber(
+                workOrderRow.WO_WORK_ORDER
+            );
+
+            const workOrderOpenDateString = dateIntegerToString(
+                Number.parseInt(workOrderRow.WO_INITIATION_DATE, 10)
+            );
+
+            if (workOrder) {
+                if (workOrder.workOrderCloseDate) {
+                    reopenWorkOrder(workOrder.workOrderId, user);
+                    delete workOrder.workOrderCloseDate;
+                    delete workOrder.workOrderCloseDateString;
+                }
+            } else {
+                const workOrderId = addWorkOrder(
+                    {
+                        workOrderNumber: workOrderRow.WO_WORK_ORDER,
+                        workOrderTypeId: 1,
+                        workOrderDescription: (
+                            workOrderRow.WO_REMARK1 +
+                            " " +
+                            workOrderRow.WO_REMARK2 +
+                            " " +
+                            workOrderRow.WO_REMARK3
+                        ).trim(),
+                        workOrderOpenDateString
+                    },
+                    user
+                );
+
+                workOrder = getWorkOrder(workOrderId);
+            }
+
+            let lot: recordTypes.Lot;
+
+            if (workOrderRow.WO_CEMETERY !== "00") {
+                const lotName = buildLotName({
+                    cemetery: workOrderRow.WO_CEMETERY,
+                    block: workOrderRow.WO_BLOCK,
+                    range1: workOrderRow.WO_RANGE1,
+                    range2: workOrderRow.WO_RANGE2,
+                    lot1: workOrderRow.WO_LOT1,
+                    lot2: workOrderRow.WO_LOT2,
+                    grave1: workOrderRow.WO_GRAVE1,
+                    grave2: workOrderRow.WO_GRAVE2,
+                    interment: workOrderRow.WO_INTERMENT
+                });
+
+                lot = getLotByLotName(lotName);
+
+                if (!lot) {
+                    const map = getMap({ cemetery: workOrderRow.WO_CEMETERY });
+
+                    const lotType = getLotType({
+                        cemetery: workOrderRow.WO_CEMETERY
+                    });
+
+                    const lotId = addLot(
+                        {
+                            mapId: map.mapId,
+                            lotName,
+                            mapKey: lotName,
+                            lotStatusId: takenLotStatus.lotStatusId,
+                            lotTypeId: lotType.lotTypeId,
+                            lotLatitude: "",
+                            lotLongitude: ""
+                        },
+                        user
+                    );
+
+                    lot = getLot(lotId);
+                } else {
+                    updateLotStatus(
+                        lot.lotId,
+                        takenLotStatus.lotStatusId,
+                        user
+                    );
+                }
+
+                const workOrderContainsLot = workOrder.workOrderLots.find(
+                    (possibleLot) => {
+                        return (possibleLot.lotId = lot.lotId);
+                    }
+                );
+
+                if (!workOrderContainsLot) {
+                    addWorkOrderLot(
+                        {
+                            workOrderId: workOrder.workOrderId,
+                            lotId: lot.lotId
+                        },
+                        user
+                    );
+
+                    workOrder.workOrderLots.push(lot);
+                }
+            }
+
+            let occupancyStartDateString = workOrderOpenDateString;
+
+            if (workOrderRow.WO_INTERMENT_YR) {
+                occupancyStartDateString = formatDateString(workOrderRow.WO_INTERMENT_YR,
+                    workOrderRow.WO_INTERMENT_MON,
+                    workOrderRow.WO_INTERMENT_DAY);
+            }
+
+            const lotOccupancyId = addLotOccupancy({
+                lotId: lot ? lot.lotId : "",
+                occupancyTypeId: deceasedOccupancyType.occupancyTypeId,
+                occupancyStartDateString,
+                occupancyEndDateString: ""
+            }, user);
+
+            addLotOccupancyOccupant({
+                lotOccupancyId,
+                lotOccupantTypeId: deceasedLotOccupantType.lotOccupantTypeId,
+                occupantName: workOrderRow.WO_DECEASED_NAME,
+                occupantAddress1: workOrderRow.WO_ADDRESS,
+                occupantAddress2: "",
+                occupantCity: workOrderRow.WO_CITY,
+                occupantProvince: workOrderRow. WO_PROV.slice(0, 2),
+                occupantPostalCode: workOrderRow.WO_POST1 + " " + workOrderRow.WO_POST2,
+                occupantPhoneNumber: ""
+            }, user);
+
+            if (workOrderRow.WO_DEATH_YR !== "") {
+                const lotOccupancyFieldValue = formatDateString(
+                    workOrderRow.WO_DEATH_YR,
+                    workOrderRow.WO_DEATH_MON,
+                    workOrderRow.WO_DEATH_DAY
+                );
+
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Death Date"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue
+                    },
+                    user
+                );
+            }
+
+            if (workOrderRow.WO_AGE !== "") {
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Death Age"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue: workOrderRow.WO_AGE
+                    },
+                    user
+                );
+            }
+
+            if (workOrderRow.WO_PERIOD !== "") {
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Death Age Period"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue: workOrderRow.WO_PERIOD
+                    },
+                    user
+                );
+            }
+
+            if (workOrderRow.WO_FUNERAL_HOME !== "") {
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Funeral Home"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue: workOrderRow.WO_FUNERAL_HOME
+                    },
+                    user
+                );
+            }
+
+            if (workOrderRow.WO_FUNERAL_YR !== "") {
+                const lotOccupancyFieldValue = formatDateString(
+                    workOrderRow.WO_FUNERAL_YR,
+                    workOrderRow.WO_FUNERAL_MON,
+                    workOrderRow.WO_FUNERAL_DAY
+                );
+
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Funeral Date"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue
+                    },
+                    user
+                );
+            }
+
+            if (workOrderRow.WO_CONTAINER_TYPE !== "") {
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Container Type"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue: workOrderRow.WO_CONTAINER_TYPE
+                    },
+                    user
+                );
+            }
+
+            if (workOrderRow.WO_COMMITTAL_TYPE !== "") {
+                let commitalType = workOrderRow.WO_COMMITTAL_TYPE;
+
+                if (commitalType === "GS") {
+                    commitalType = "Graveside";
+                }
+
+                addOrUpdateLotOccupancyField(
+                    {
+                        lotOccupancyId: lotOccupancyId,
+                        occupancyTypeFieldId:
+                            deceasedOccupancyType.occupancyTypeFields.find(
+                                (occupancyTypeField) => {
+                                    return (
+                                        occupancyTypeField.occupancyTypeField ===
+                                        "Committal Type"
+                                    );
+                                }
+                            ).occupancyTypeFieldId,
+                        lotOccupancyFieldValue: commitalType
+                    },
+                    user
+                );
+            }
+
+            addWorkOrderLotOccupancy({
+                workOrderId: workOrder.workOrderId,
+                lotOccupancyId
+            }, user);
+        }
+    } catch (error) {
+        console.error(error);
+        console.log(workOrderRow);
+    }
+}
+
 purgeTables();
 // purgeConfigTables();
 importFromMasterCSV();
 importFromPrepaidCSV();
+importFromWorkOrderCSV();