mobioffice-cli 1.0.0 → 1.0.2

package/lib/models/user.model.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+// import * as stream from "getstream";
+const company_model_1 = require("./company.model");
+class User {
+    reportingTo = null;
+    managers = [];
+    bio = null;
+    fcmToken = null;
+    email = null;
+    avatarUrl = null;
+    satOff = null;
+    id = "";
+    designation = null;
+    roles = "";
+    roamId = null;
+    birthDate = 0;
+    name = "";
+    hasCheckedIn = false;
+    department = null;
+    empCode = null;
+    phone = "";
+    constructor(reportingTo, managers, bio, fcmToken, email, avatarUrl, satOff, id, designation, roles, roamId, birthdate, name, hasCheckedIn, department, empCode, phone) {
+        this.reportingTo = reportingTo;
+        this.managers = managers;
+        this.bio = bio;
+        this.fcmToken = fcmToken;
+        this.email = email;
+        this.avatarUrl = avatarUrl;
+        this.satOff = satOff;
+        this.id = id;
+        this.designation = designation;
+        this.roles = roles;
+        this.roamId = roamId;
+        this.birthDate = birthdate;
+        this.name = name;
+        this.hasCheckedIn = hasCheckedIn;
+        this.department = department;
+        this.empCode = empCode;
+        this.phone = phone;
+    }
+    // async initByPhone(phone:string) {
+    //   var d = await User.getUserDocByPhone(phone);
+    //   this.initViaSnapshotDoc(d);
+    // }
+    // initViaSnapshotDoc(doc) {
+    //   var _data = doc.data();
+    //   this.id = _data.id;
+    //   this.phone = _data.phone;
+    //   this.companies = _data.companies;
+    // }
+    // static async getUserDocByPhone(phone) {
+    //   const coRef = db.collection("Users");
+    //   const snapshot = await coRef.where("phone", "==", phone).limit(1).get();
+    //   if (snapshot.empty) {
+    //     throw "Phone " + phone + " not found";
+    //   } else {
+    //     var rdoc;
+    //     snapshot.forEach((doc) => {
+    //       console.log(doc.id, "=>", doc.data());
+    //       rdoc = doc;
+    //     });
+    //     return rdoc;
+    //   }
+    // }
+    // async getUserLocation() {
+    //   const coRef = db.collection("Users/" + this.id + "/location");
+    //   const snapshot = await coRef.limit(10).get();
+    //   if (snapshot.empty) {
+    //     throw "Location " + this.id + " not found";
+    //   } else {
+    //     var rdoc;
+    //     snapshot.forEach((doc) => {
+    //       console.log(doc.id, "=>", doc.data());
+    //       rdoc = doc;
+    //     });
+    //     return rdoc;
+    //   }
+    // }
+    static async initUsers(firestore) {
+        let document = firestore.collection("Users").doc();
+        await document.set({
+            id: document.id,
+        });
+        return "success";
+    }
+    static async getUsersListByManger(firestore, nickName) {
+        let companyId = await company_model_1.Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .get();
+        let map = new Map();
+        for (let element of snapshot.docs) {
+            if (element.data().reportingTo) {
+                for (let data of element.data().reportingTo) {
+                    if (map.has(data)) {
+                        let newId = map.get(data);
+                        newId.push(element.data().id);
+                        map.set(data, newId);
+                    }
+                    else {
+                        map.set(data, [element.data().id]);
+                    }
+                }
+            }
+        }
+        return map;
+    }
+    static async getUserPhonebyUserId(firestore, userId) {
+        const queryForNumber = await firestore.collection("Users")
+            .where("id", "==", userId)
+            .get();
+        const phoneFetchingDocData = queryForNumber.docs.map((doc) => doc.data());
+        var number = phoneFetchingDocData[0]["phone"];
+        return number;
+    }
+    static async getUserIdByPhone(firestore, phone) {
+        if (phone[0] != "+") {
+            phone = `+${phone}`;
+        }
+        const userInfo = await firestore.collection("Users")
+            .where("phone", "==", phone)
+            .get();
+        let userId = "";
+        userInfo.docs.forEach(info => {
+            userId = info.data().id;
+        });
+        return userId;
+    }
+    static async getUserInfoById(firestore, userId, companyId) {
+        const userInfoDoc = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .doc(userId)
+            .get();
+        const userInfo = userInfoDoc.data();
+        return userInfo;
+    }
+    static async getUsersListByCompanyNickName(firestore, nickName) {
+        console.log("Getting users list");
+        const companyId = await company_model_1.Company.getCompanyIdbyNickname(firestore, nickName);
+        const usersList_snapshot = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .select("name", "id", "phone")
+            .get();
+        let usersList = [];
+        usersList_snapshot.forEach((doc) => {
+            usersList.push(doc.data());
+        });
+        return usersList;
+    }
+    static async deleteUser(firebase, auth, arrayRemove, nickName, phone) {
+        let userId = await User.getUserIdByPhone(firebase, phone);
+        console.log(phone);
+        let companyId = await company_model_1.Company.getCompanyIdByNickName(firebase, nickName);
+        await firebase.collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .doc(userId)
+            .delete();
+        console.log("deleted user doc from company");
+        await firebase.collection("Companies")
+            .doc(companyId)
+            .collection("Report-Visibility")
+            .doc(userId)
+            .delete();
+        console.log("deleted user report visibility");
+        let companyDoc = await firebase.collection("Companies")
+            .doc(companyId)
+            .get();
+        companyDoc.ref.update({
+            users: arrayRemove(userId)
+        });
+        let actionDoc = await firebase.collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .where("users", "array-contains", userId)
+            .get();
+        actionDoc.forEach((doc) => {
+            doc.ref.update({
+                users: arrayRemove(userId)
+            });
+        });
+        let userLicenseDoc = await firebase.collection("Licenses")
+            .where("user", "==", phone)
+            .get();
+        if (!userLicenseDoc.empty) {
+            userLicenseDoc.forEach((doc) => {
+                doc.ref.delete();
+            });
+        }
+        await firebase.collection("Feeds")
+            .doc(userId)
+            .delete();
+        // await firebase.collection("Feeds").doc(userId).delete()
+        await auth.deleteUser(userId);
+        await firebase.collection("Users").doc(userId).delete();
+        return `${userId} Deleted successfully`;
+    }
+    static async getApps(firestore, phone, nickName) {
+        const userId = await User.getUserIdByPhone(firestore, phone);
+        const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+        const userAppsInfo = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .where("actionType", "==", "activitySelector")
+            .where("users", "array-contains", userId)
+            .get();
+        const userApps = userAppsInfo.docs.map((doc) => {
+            const app = doc.data();
+            return {
+                id: app.id,
+                name: app.name,
+                displayName: app.displayName,
+                icon: app.icon
+            };
+        });
+        return userApps;
+    }
+    static async getActionsByUserApp(firestore, phone, nickName, actionId) {
+        const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+        const actionList = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Report-Actions")
+            .where("activityFor", "==", actionId)
+            .get();
+        const actionIdsList = actionList.docs.map((doc) => {
+            return doc.id;
+        });
+        const userId = await User.getUserIdByPhone(firestore, phone);
+        const actionsInfo = await firestore.collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .where("id", "in", actionIdsList)
+            .where("users", "array-contains", userId)
+            .get();
+        const actions = actionsInfo.docs.map((doc) => {
+            const actionInfo = doc.data();
+            return {
+                name: actionInfo.name,
+                displayName: actionInfo.displayName,
+                icon: actionInfo.icon,
+                id: actionInfo.id
+            };
+        });
+        console.log(actions);
+        return actions;
+    }
+    static async getHostsPhoneList(firestore, companyId) {
+        try {
+            const hostsList = await firestore.collection("Companies")
+                .doc(companyId)
+                .collection("Users")
+                .where("roles", "array-contains", "host")
+                .get();
+            const hostPhoneList = hostsList.docs.map((hostDoc) => {
+                console.log(hostDoc.data());
+                return hostDoc.data().phone;
+            });
+            return hostPhoneList;
+        }
+        catch (error) {
+            console.log(error);
+            return [];
+        }
+    }
+}
+exports.User = User;

package/lib/models/utility.model.d.ts

@@ -0,0 +1,13 @@
+declare class Utilities {
+    static formatTimeTo12hr(epochTime: number): string;
+    static padWithZero(str: string): string;
+    static getTimeFromEpoch(time: number): Promise<string>;
+    static dateFromEpochTime(epochTime: number): string;
+    static epochToMySqlDateTime(epochTime: number): Promise<string>;
+    static readLineAsync(msg: string, readLineInterface: any): Promise<unknown>;
+    static readLineClose(readLineInterface: any): void;
+    static hold(readline: any): Promise<void>;
+    static encryptAString(secretText: string): Promise<string>;
+    static decryptEncryptedStr(encryptedString: string): Promise<string>;
+}
+export { Utilities };

package/lib/models/utility.model.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utilities = void 0;
+const crypto_1 = require("crypto");
+class Utilities {
+    static formatTimeTo12hr(epochTime) {
+        const dateObj = new Date(epochTime);
+        let hrs = dateObj.getHours();
+        const amOrPm = hrs >= 12 ? "pm" : "am";
+        hrs = (hrs % 12) || 12;
+        const formattedTime = `${this.padWithZero(String(hrs))}:${this.padWithZero(String(dateObj.getMinutes()))} ${amOrPm}`;
+        return formattedTime;
+    }
+    static padWithZero(str) {
+        return str.padStart(2, "0");
+    }
+    static async getTimeFromEpoch(time) {
+        return new Date(time).toLocaleTimeString("en-GB", { timeZone: "asia/kolkata", hour: '2-digit', minute: '2-digit', hourCycle: "h12" });
+    }
+    static dateFromEpochTime(epochTime) {
+        const dateObj = new Date(epochTime);
+        const date = `${this.padWithZero(String(dateObj.getDate()))}/`;
+        const month = `${this.padWithZero(String(dateObj.getMonth()))}/`;
+        const year = `${dateObj.getFullYear()}`;
+        return date + month + year;
+    }
+    static async epochToMySqlDateTime(epochTime) {
+        const date = new Date(epochTime);
+        const dateTimeInfo = date.toISOString().split("T");
+        const result = dateTimeInfo[0] + " " + dateTimeInfo[1].split(".")[0];
+        return result;
+    }
+    static async readLineAsync(msg, readLineInterface) {
+        return new Promise((resolve) => {
+            readLineInterface.question(msg, (userRes) => {
+                resolve(userRes);
+            });
+        });
+    }
+    static readLineClose(readLineInterface) {
+        readLineInterface.close();
+    }
+    static async hold(readline) {
+        const response = await this.readLineAsync("is wait over: ", readline);
+        console.log("response: ", response);
+        if (response.toLowerCase() === "yes") {
+            return;
+        }
+        else {
+            await this.hold(readline);
+        }
+    }
+    static async encryptAString(secretText) {
+        try {
+            // Encryption
+            const algorithm = 'aes-256-cbc';
+            // const key = randomBytes(32);
+            const key = "wearethebestoneswearethebestones"; // Replace with your secret key
+            // const iv = randomBytes(16);   // Initialization Vector
+            const iv = "wearethebestones"; // Initialization Vector
+            const cipher = (0, crypto_1.createCipheriv)(algorithm, key, iv);
+            let encryptedString = cipher.update(secretText, 'utf8', 'hex');
+            encryptedString += cipher.final('hex');
+            return encryptedString;
+        }
+        catch (error) {
+            console.log(error.message);
+            throw {
+                message: error.message
+            };
+        }
+    }
+    static async decryptEncryptedStr(encryptedString) {
+        try {
+            const algorithm = 'aes-256-cbc';
+            const key = "wearethebestoneswearethebestones"; // Replace with your secret key
+            // const iv = randomBytes(16);   // Initialization Vector
+            const iv = "wearethebestones"; // Initialization Vector
+            // Decryption
+            const decipher = (0, crypto_1.createDecipheriv)(algorithm, key, iv);
+            let decryptedString = decipher.update(encryptedString, 'hex', 'utf8');
+            decryptedString += decipher.final('utf8');
+            return decryptedString;
+        }
+        catch (error) {
+            console.log(error.message);
+            throw {
+                message: error.message
+            };
+        }
+    }
+}
+exports.Utilities = Utilities;

package/lib/models/visitorManagement/acknowledgement.model.d.ts

@@ -0,0 +1,9 @@
+import { Post } from "../post.model";
+import { Pool } from "mysql2";
+declare class Acknowledgement extends Post {
+    static setIncomingInfoToAcknowledgement(invitationInfo: any, post: Acknowledgement, toBeUpdatedDoc: any): Promise<Acknowledgement>;
+    static modifyExtraDAtaForAcknowledgement(toBeUpdatedDoc: any): Promise<any>;
+    static updateVisitEntryOnAck(connection: Pool, visitId: string, acknowledgedTime: string, approverPhone: string): Promise<void>;
+    static updateVisitEntryOnCheckout(connection: Pool, visitId: string, checkOutTime: string): Promise<void>;
+}
+export { Acknowledgement };

package/lib/models/visitorManagement/acknowledgement.model.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Acknowledgement = void 0;
+const post_model_1 = require("../post.model");
+const crud_1 = __importDefault(require("../crud/crud"));
+class Acknowledgement extends post_model_1.Post {
+    static async setIncomingInfoToAcknowledgement(invitationInfo, post, toBeUpdatedDoc) {
+        post.actionEvent = invitationInfo.extra.actionEvent;
+        post.actionId = invitationInfo.extra.actionId;
+        post.actionName = invitationInfo.extra.actionName;
+        post.actionType = invitationInfo.extra.actionType;
+        post.companyId = invitationInfo.extra.companyId;
+        post.createdAt = invitationInfo.extra.createdAt;
+        post.description = "Meeting Completed";
+        post.eventId = invitationInfo.extra.eventId;
+        post.isGeofence = invitationInfo.extra.isGeofence;
+        post.userId = invitationInfo.userId;
+        const newExtraData = await this.modifyExtraDAtaForAcknowledgement(toBeUpdatedDoc);
+        post.extraData = newExtraData;
+        post.time = invitationInfo.extra.time;
+        return post;
+    }
+    static async modifyExtraDAtaForAcknowledgement(toBeUpdatedDoc) {
+        return toBeUpdatedDoc;
+    }
+    static async updateVisitEntryOnAck(connection, visitId, acknowledgedTime, approverPhone) {
+        const crudServicce = new crud_1.default(connection);
+        try {
+            const qryString = `UPDATE visits SET
+                          meetingTime = '${acknowledgedTime}',
+                          approvedBy = '${approverPhone}'
+                          WHERE visitId='${visitId}'`;
+            await crudServicce.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            throw new Error(error.message);
+        }
+    }
+    static async updateVisitEntryOnCheckout(connection, visitId, checkOutTime) {
+        const crudServicce = new crud_1.default(connection);
+        try {
+            const qryString = `UPDATE visits SET checkOutTime = '${checkOutTime}' WHERE visitId = '${visitId}'`;
+            await crudServicce.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            throw new Error(error.message);
+        }
+    }
+}
+exports.Acknowledgement = Acknowledgement;

package/lib/models/visitorManagement/invite.model.d.ts

@@ -0,0 +1,32 @@
+import { Post } from "../post.model";
+import * as admin from "firebase-admin";
+import { Pool } from "mysql2/typings/mysql/lib/Pool";
+declare class Invitation extends Post {
+    isProcessed: boolean;
+    static setIncomingInfoToInvitation(firestore: admin.firestore.Firestore, invitationInfo: any, post: Invitation, nickName: string): Promise<any>;
+    static modifyExtraDAtaForInvitation(invitationInfo: any, whomToMeet: string): Promise<{
+        visitorName: any;
+        personToMeet: string;
+        visitorPhoneNumber: any;
+        status: string;
+        acknowledgedTime: null;
+        time: number;
+        date: any;
+        checkInTimeOfVisitor: null;
+        checkInDateOfVisitor: string;
+        checkOutTimeOfVisitor: null;
+    }>;
+    static uploadEntryToMySql(connection: Pool, info: any): Promise<void>;
+    static updateInvitationEntryOnReception(connection: Pool, visitId: string, redId: string, inGateKeeperId: string, checkInTime: string): Promise<void>;
+    static updateInvitationOnApproval(connection: Pool, visitId: string, isApproved: boolean): Promise<void>;
+    static updateInvitationWithCardColor(connection: Pool, visitId: string, cardColor: string): Promise<void>;
+    static updateInvitationWithIdProof(connection: Pool, visitId: string, proofType: string, proofImage: string): Promise<void>;
+    static updateInvitationWithVisitorsLeaving(connection: Pool, visitId: string, outGateKeeperId: string, visitorsLeaving: string): Promise<void>;
+    static updateInvitationWithImage(connection: Pool, visitId: string, imageBase64: string, additionalVisitors: string, assets: string): Promise<void>;
+    static updateInvitationWithApprovedAt(connection: Pool, visitId: string, approvedAt: string): Promise<void>;
+    static fetchHostMeetingsForTheDay(connection: Pool, hostPhone: string, companyId: string): Promise<any>;
+    static checkUserIsExist(connection: Pool, Phone: string, companyId: string): Promise<import("mysql2/typings/mysql/lib/protocol/packets/ResultSetHeader").ResultSetHeader | import("mysql2/typings/mysql/lib/protocol/packets/OkPacket").OkPacket | import("mysql2/typings/mysql/lib/protocol/packets/RowDataPacket").RowDataPacket[]>;
+    static createGatePass(connection: Pool, companyId: string, phone: string, from: string, to: string, name: string, createdBy: string, faceJpg: string): Promise<import("mysql2/typings/mysql/lib/protocol/packets/ResultSetHeader").ResultSetHeader | import("mysql2/typings/mysql/lib/protocol/packets/OkPacket").OkPacket | import("mysql2/typings/mysql/lib/protocol/packets/RowDataPacket").RowDataPacket[]>;
+    static updateUserGatePassData(connection: Pool, id: number, to: string): Promise<import("mysql2/typings/mysql/lib/protocol/packets/ResultSetHeader").ResultSetHeader | import("mysql2/typings/mysql/lib/protocol/packets/OkPacket").OkPacket | import("mysql2/typings/mysql/lib/protocol/packets/RowDataPacket").RowDataPacket[]>;
+}
+export { Invitation };