Make lock charges calculation functional for happy path

services/doorLock.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const db = require('../models/index');
+const fs = require('fs');
+const csv = require('csv-parser');
+const moment = require('moment');
+
+const {
+    USER_ENTRY_EVENT,
+    ENABLE_PASSAGE_MODE,
+    DISABLE_PASSAGE_MODE,
+    USER_UNLOCKED_DOOR,
+    USER_LOCKED_DOOR,
+    VALID_CSV_HEADERS,
+    csvParserErrors,
+} = require('../constants/constants');
+
+const { fetchAllMembers, findMember } = require('../services/officeRnD/members');
+
+
+const parseDoorLockDataFile = (file) => {
+    return new Promise ((resolve, reject) => {
+        const results = [];
+        const errors = [];
+        const unknownMembers = [];
+        let isValidFile = true;
+
+        fetchAllMembers()
+            .then(() => {
+                fs.createReadStream(file.path)
+                    .pipe(csv({
+                        mapHeaders: ({ header, index }) => header.trim().toLowerCase(),
+                        mapValues: ({ header, index, value }) => value.trim()
+                    }))
+                    .on('headers', (headers) => {
+
+                        const sortedValidHeadersArray = VALID_CSV_HEADERS.concat().sort();
+                        const sortedParsedHeadersArray = headers.map(header => header.trim()).sort();
+
+                        let validHeaders = true;
+                        if (sortedParsedHeadersArray.length !== sortedValidHeadersArray.length) {
+                            validHeaders = false;
+                        }else {
+                            for (let i = 0; i < sortedValidHeadersArray.length; i++){
+                                validHeaders = validHeaders
+                                    && (sortedValidHeadersArray[i] === sortedParsedHeadersArray[i]);
+                            }
+                        }
+
+                        if (!validHeaders){
+                            isValidFile = false;
+                            errors.push({
+                                error: csvParserErrors.INVALID_HEADERS,
+                                details: `Expected headers : ${JSON.stringify(VALID_CSV_HEADERS)}`,
+                                file: file.name,
+                            });
+                        }
+                    })
+                    .on('data', (data) => {
+                        if (!isValidFile) {
+                            return;
+                        }
+
+                        const eventType = data.event.trim();
+                        if ([USER_ENTRY_EVENT, ENABLE_PASSAGE_MODE, DISABLE_PASSAGE_MODE].includes(eventType)){
+                            results.push(data);
+                        }
+                    })
+                    .on('end', () => {
+                        const parsedData = [];
+                        let i = 0;
+                        while (i < results.length){
+                            //Verify pair
+                            //First entry type should be user entry and second should be enable / disable passage
+                            const firstEntry = results[i];
+                            const secondEntry = results[i+1];
+
+                            if (firstEntry && (firstEntry.event === USER_ENTRY_EVENT)){
+                                const memberObject = findMember(firstEntry.name);
+
+                                if (!memberObject){
+                                    //Check if member is already labeled as unknown
+                                    const unknownMember = unknownMembers.find((member) => member.details === firstEntry.name);
+                                    if (!unknownMember){
+                                        unknownMembers.push({
+                                            error: csvParserErrors.UNKNOWN_MEMBER,
+                                            details: firstEntry.name,
+                                            file: file.name,
+                                        });
+                                    }
+                                }
+
+                                if (secondEntry && (secondEntry.event === ENABLE_PASSAGE_MODE || secondEntry.event === DISABLE_PASSAGE_MODE)){
+                                    const event = (secondEntry.event === ENABLE_PASSAGE_MODE) ? USER_UNLOCKED_DOOR : USER_LOCKED_DOOR;
+                                    const dateTimeString = `${firstEntry.date} ${firstEntry.time}`;
+                                    const timestamp = moment.utc(dateTimeString, 'MM/DD/YY HH:mm:ss A').toISOString();
+
+                                    //Verify that member is registered in OfficeRnD system
+                                    if (memberObject){
+                                        const entryData = {
+                                            memberName: firstEntry.name,
+                                            memberNumber: firstEntry['user no'],
+                                            memberId: memberObject.memberId,
+                                            timestamp,
+                                            event,
+                                        };
+
+                                        parsedData.push(entryData);
+                                    }
+                                    i+=2;
+                                } else {
+                                    errors.push({
+                                        error: csvParserErrors.INVALID_ENTRY_EXPECTED_PASSAGE_MODE,
+                                        details: firstEntry,
+                                        file: file.name,
+                                    });
+                                    i+=1;
+                                }
+                            } else {
+                                errors.push({
+                                    error: csvParserErrors.INVALID_ENTRY_EXPECTED_USER,
+                                    details: firstEntry,
+                                    file: file.name,
+                                });
+                                i+=1;
+                            }
+                        }
+                        resolve({
+                            parsedData,
+                            unknownMembers,
+                            errors
+                        });
+                    });
+            })
+            .catch((error) => {
+                reject(error);
+            });
+    });
+};
+
+const writeDoorLockEvent = (entry) => {
+    db.doorLockEvent.findOrCreate({where: {...entry}, defaults: {...entry}})
+        .then()
+        .catch();
+};
+
+module.exports = {
+    parseDoorLockDataFile,
+    writeDoorLockEvent,
+};