mobioffice-cli 0.2.1 → 1.0.1

package/lib/models/company.model.js

@@ -0,0 +1,725 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Company = void 0;
+const action_model_1 = require("./action.model");
+const attendance_model_1 = require("./attendance.model");
+const license_model_1 = require("./license.model");
+const user_model_1 = require("./user.model");
+class Company {
+    id = "";
+    nickname = "";
+    description = "";
+    image = "";
+    name = "";
+    users = [];
+    endpoints = [];
+    static async initCompany(firestore) {
+        firestore.collection("Companies");
+    }
+    static async getCompanyIdByNickName(firestore, nickName) {
+        const companyInfo = await firestore
+            .collection("Companies")
+            .where("nickname", "==", nickName)
+            .get();
+        let companyId = "";
+        companyInfo.docs.forEach((info) => {
+            companyId = info.data().id;
+        });
+        return companyId;
+    }
+    static async getOrCreateCompany(firestore, companyDetails) {
+        let company_snapshot = await firestore
+            .collection("Companies")
+            .where("nickname", "==", companyDetails.nickname)
+            .get();
+        if (company_snapshot.empty) {
+            let company = await Company.createCompany(firestore, companyDetails);
+            return company;
+        }
+        else {
+            let id = "";
+            company_snapshot.forEach((doc) => {
+                id = doc.data().id;
+            });
+            let companyData = await company_snapshot.docs.map((doc) => {
+                return doc.data();
+            });
+            return companyData;
+        }
+    }
+    static async createCompany(firestore, companyDetails) {
+        //companyDetails = await Company.convertCompanyDataType(companyDetails)
+        let docRef = firestore.collection("Companies").doc();
+        companyDetails.id = docRef.id;
+        await docRef.set(companyDetails);
+        return companyDetails;
+    }
+    static async convertCompanyDataType(companyDetails) {
+        if (companyDetails.names) {
+            let names = companyDetails.names.split("&");
+            let link = companyDetails.links.split("&");
+            let map = new Map();
+            for (let i = 0; i < names.length; i++) {
+                map.set(names[i], link[i]);
+            }
+            const obj = Object.fromEntries(map);
+            delete companyDetails.names;
+            delete companyDetails.links;
+            companyDetails.endpoints = obj;
+        }
+        else {
+            companyDetails.endpoints = {};
+        }
+        if (companyDetails.users) {
+            companyDetails.users = companyDetails.users.split("&");
+        }
+        else {
+            companyDetails.users = [];
+        }
+        if (companyDetails.e10xSupport) {
+            companyDetails.e10xSupport = companyDetails.e10xSupport == "true";
+        }
+        return companyDetails;
+    }
+    static async updateCompany(firestore, nickName, companyDoc) {
+        let snapshot = await firestore
+            .collection("Companies")
+            .where("nickname", "==", nickName)
+            .get();
+        if (snapshot.empty) {
+            return "Company doesn't exists";
+        }
+        else {
+            //companyDoc = await Company.convertCompanyDataType(companyDoc)
+            if (companyDoc.users) {
+                delete companyDoc.users;
+            }
+            let endpoints = snapshot.docs[0].data().endpoints;
+            Object.assign(companyDoc.endpoints, endpoints);
+            // console.log(companyDoc)
+            snapshot.docs[0].ref.update(companyDoc);
+            return "Updated successfully";
+        }
+    }
+    static async addUserIdsInsideCompanies(firestore, arrayUnion, nickName) {
+        let usersList = await Company.getUsersListbyCompany(firestore, nickName);
+        let userIds = [];
+        for (let user of usersList) {
+            userIds.push(user.id);
+        }
+        let companyId = await Company.getCompanyIdbyNickname(firestore, nickName);
+        await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .update({
+            users: arrayUnion(...userIds),
+        });
+    }
+    static async checkIfUserExists(firestore, companyId, userId) {
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("id", "==", userId)
+            .get();
+        if (snapshot.empty) {
+            return null;
+        }
+        else {
+            return true;
+        }
+    }
+    static async intiActionsInCompany(firestore, companyId, actions) {
+        let document = firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc();
+        await document.set({
+            id: document.id,
+        });
+        for (let element of actions) {
+            let docRef = firestore
+                .collection("Companies")
+                .doc(companyId)
+                .collection("Actions")
+                .doc();
+            let id = docRef.id;
+            let docs = { companyId: companyId, name: element, id: id, users: [] };
+            await docRef.set(docs);
+        }
+        return actions;
+    }
+    static async getUserDetailsByPhone(firestore, nickName, phoneNumber) {
+        let company_id = await Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(company_id)
+            .collection("Users")
+            .where("phone", "==", phoneNumber)
+            .get();
+        if (snapshot.empty) {
+            return "Not found";
+        }
+        let userDetails_arr = [];
+        snapshot.forEach((doc) => {
+            userDetails_arr.push(doc.data());
+        });
+        return userDetails_arr;
+    }
+    static async createOrUpdateUser(firestore, auth, arrayUnion, nickName, newDetails) {
+        console.log("nickName   ===>   ", nickName);
+        newDetails.phone = "+" + newDetails.phone;
+        newDetails.isFetchFaceVisible = true;
+        newDetails.devicesLimit = 1;
+        if (newDetails.birthDate) {
+            newDetails.birthDate = await license_model_1.License.convertDatetoTimestamp(newDetails.birthDate);
+        }
+        if (newDetails.reportingTo) {
+            let reportingTo = newDetails.reportingTo.split("&");
+            const managers = [];
+            let reportingtoIds = [];
+            for (let phone of reportingTo) {
+                console.log("phone   ===>   ", phone);
+                phone = "+" + phone;
+                let user_snapshot = await Company.getUserDetailsByPhone(firestore, nickName, phone);
+                console.log(user_snapshot);
+                user_snapshot.forEach((doc) => {
+                    reportingtoIds.push(doc.id);
+                    managers.push(doc.name);
+                });
+            }
+            newDetails.reportingTo = reportingtoIds;
+            newDetails.managers = managers;
+        }
+        if (newDetails.roles) {
+            let rolesList = [];
+            rolesList = newDetails.roles.split("&");
+            newDetails.roles = rolesList;
+            newDetails.internalRoles = rolesList;
+            newDetails.fatchBGLocation = false;
+        }
+        if (newDetails.userName && newDetails.password) {
+            newDetails['loginInfo'] = {
+                username: newDetails.userName,
+                password: newDetails.password
+            };
+        }
+        delete newDetails.userName;
+        delete newDetails.password;
+        let companyId = await Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("phone", "==", newDetails.oldPhoneNo ? newDetails.oldPhoneNo : newDetails.phone)
+            .get();
+        console.log(newDetails);
+        console.log(snapshot.empty);
+        //let userCollection = await Company.updateUserPhone(firestore,newDetails.uid,newDetails.phone)
+        delete newDetails.oldPhoneNo;
+        if (snapshot.empty) {
+            return await Company.createUser(firestore, auth, arrayUnion, companyId, newDetails);
+        }
+        else {
+            let userId = "";
+            let temp = newDetails.reportingTo;
+            if (newDetails.reportingTo.length) {
+                snapshot.forEach((doc) => {
+                    doc.ref.update({
+                        reportingTo: arrayUnion(...temp),
+                    });
+                });
+                delete newDetails.reportingTo;
+            }
+            snapshot.forEach((doc) => {
+                userId = doc.data().id;
+                doc.ref.update(newDetails);
+            });
+            const userDetails = await firestore.collection('Users').doc(userId).get();
+            userDetails.ref.update({
+                phone: newDetails.phone
+            });
+            return { companyId: companyId, userId: userId, actions: [] };
+        }
+    }
+    static async createNewUser(firestore, auth, arrayUnion, nickName, newDetails) {
+        newDetails.phone = `+${newDetails.phone}`;
+        let companyId = await Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("phone", "==", newDetails.phone)
+            .get();
+        if (snapshot.empty) {
+            if (newDetails.birthDate) {
+                newDetails.birthDate = await license_model_1.License.convertDatetoTimestamp(newDetails.birthDate);
+            }
+            if (newDetails.reportingTo) {
+                await this.addReportingToInfoToDetails(firestore, newDetails, companyId);
+            }
+            console.log("newDetails", newDetails);
+            return await Company.createUser(firestore, auth, arrayUnion, companyId, newDetails);
+        }
+        else {
+            return {
+                data: snapshot.docs[0].data(),
+                message: "Phone number already used.",
+            };
+        }
+    }
+    static async updateUser(firestore, arrayUnion, nickName, newDetails) {
+        newDetails.phone = `+${newDetails.phone}`;
+        let companyId = await Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("phone", "==", newDetails.phone)
+            .get();
+        if (snapshot.empty) {
+            throw new Error("User doesn't exist, please check phone Number.");
+        }
+        if (newDetails.birthDate) {
+            newDetails.birthDate = await license_model_1.License.convertDatetoTimestamp(newDetails.birthDate);
+        }
+        if (newDetails.reportingTo) {
+            await this.addReportingToInfoToDetails(firestore, newDetails, companyId);
+            if (newDetails.reportingTo.length) {
+                snapshot.forEach((doc) => {
+                    doc.ref.update({
+                        reportingTo: arrayUnion(...newDetails.reportingTo),
+                        managers: arrayUnion(...newDetails.managers),
+                    });
+                });
+                delete newDetails.reportingTo;
+                delete newDetails.managers;
+            }
+        }
+        let userId = "";
+        await Promise.all(snapshot.docs.map(async (doc) => {
+            userId = doc.data().id;
+            await doc.ref.update(newDetails);
+        }));
+        const updatedUserDoc = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("phone", "==", newDetails.phone)
+            .get();
+        return updatedUserDoc.docs[0].data();
+    }
+    static async addReportingToInfoToDetails(firestore, newDetails, companyId) {
+        const managers = [];
+        let reportingToIds = [];
+        for (let phone of newDetails.reportingTo) {
+            phone = "+" + phone;
+            const userId = await user_model_1.User.getUserIdByPhone(firestore, phone);
+            let managerInfoDoc = await firestore
+                .collection("Companies")
+                .doc(companyId)
+                .collection("Users")
+                .doc(userId)
+                .get();
+            if (managerInfoDoc.exists) {
+                reportingToIds.push(managerInfoDoc.data().id);
+                managers.push(managerInfoDoc.data().name);
+            }
+        }
+        newDetails.reportingTo = reportingToIds;
+        newDetails.managers = managers;
+    }
+    static async getSubordinatesById(firestore, uid, cid) {
+        console.log("Path => ", `Companies/${cid}/Users`);
+        const companyUsers = await firestore
+            .collection(`Companies/${cid}/Users`)
+            .get();
+        const userDocs = companyUsers.docs.map((doc) => doc.data());
+        // console.log("UserDocs => ", userDocs);
+        const filteredUsers = userDocs.filter((user) => user["reportingTo"].includes(uid));
+        // console.log("filteredUsers => ", filteredUsers);
+        console.log("filteredUsers => ", filteredUsers.length);
+        const phones = [];
+        for (var user of filteredUsers) {
+            phones.push(user["phone"]);
+        }
+        console.log("phones => ", phones);
+        return phones;
+    }
+    static async updateUserPhone(firestore, uid, phone) {
+        let snapshot = await firestore
+            .collection("Users")
+            .where("id", "==", uid)
+            .get();
+        if (snapshot.empty) {
+            return null;
+        }
+        snapshot.forEach((doc) => {
+            doc.ref.update({ phone });
+        });
+        return true;
+    }
+    static async convertUserDataType(data) {
+        if (data.managers) {
+            data.managers = data.managers.split("&");
+        }
+        else {
+            data.managers = [];
+        }
+        if (data.roles) {
+            data.roles = data.roles.split("&");
+        }
+        else {
+            data.roles = [];
+        }
+        return data;
+    }
+    static async createUser(firestore, auth, arrayUnion, companyId, newDetails) {
+        if (!newDetails.reportingTo) {
+            newDetails.reportingTo = [];
+        }
+        let actionsList = [];
+        if (newDetails.actions) {
+            actionsList = newDetails.actions;
+            actionsList = newDetails.actions.split("&");
+            // -------------------------------------
+            // uncomment the above line while
+            // creating users through create_or_update_users script.
+            delete newDetails.actions;
+        }
+        else {
+            return "Please provide actions";
+        }
+        //newDetails = await Company.convertUserDataType(newDetails)
+        if (!newDetails.birthDate) {
+            let currectDate = await attendance_model_1.Attendance.getCurrentdate();
+            newDetails.birthDate = currectDate.replace(/\//g, "-");
+            newDetails.birthDate = await license_model_1.License.convertDatetoTimestamp(newDetails.birthDate);
+        }
+        let userExits = await auth.listUsers();
+        let flagForUser = false;
+        let uid = "";
+        if (userExits) {
+            let userList = userExits.users;
+            for (let element of userList) {
+                if (element.phoneNumber == newDetails.phone) {
+                    flagForUser = true;
+                    uid = element.uid;
+                }
+            }
+        }
+        console.log(newDetails);
+        console.log("flagForUser", flagForUser);
+        if (flagForUser) {
+            await Object.assign(newDetails, { id: uid });
+            await firestore
+                .collection("Companies")
+                .doc(companyId)
+                .collection("Users")
+                .doc(uid)
+                .set(newDetails);
+            console.log("user Created in company");
+        }
+        else {
+            let newUser = await auth.createUser({ phoneNumber: newDetails.phone });
+            uid = newUser.uid;
+            await Object.assign(newDetails, { id: newUser.uid }, { fcmToken: null });
+            await firestore
+                .collection("Companies")
+                .doc(companyId)
+                .collection("Users")
+                .doc(newUser.uid)
+                .set(newDetails);
+            await firestore
+                .collection("Users")
+                .doc(newUser.uid)
+                .set({ id: newUser.uid, phone: newDetails.phone });
+            console.log("user created in both places");
+        }
+        let actions = await Company.addUserId(firestore, arrayUnion, companyId, uid, actionsList);
+        if (actions.length) {
+            return { companyId: companyId, userId: uid, actions: actions };
+        }
+        else {
+            return "error occured when adding userId in users array";
+        }
+    }
+    static async addUserId(firestore, arrayUnion, companyId, id, actions) {
+        console.log(id);
+        await Company.addUserIdinCompany(firestore, arrayUnion, companyId, id);
+        for (let i = 0; i < actions.length; i++) {
+            await action_model_1.Action.addUserIdInAction(firestore, arrayUnion, actions[i], companyId, id);
+        }
+        return actions;
+    }
+    static async getCompanyDocByCompanyId(firestore, companyId) {
+        let companyDoc = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .get();
+        return companyDoc.data();
+    }
+    static async addUserIdinCompany(firestore, arrayUnion, companyId, userId) {
+        await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .update({
+            users: arrayUnion(userId),
+        });
+    }
+    static async getUsersListbyCompany(firestore, nickName) {
+        let company_id = await Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(company_id)
+            .collection("Users")
+            .get();
+        if (snapshot.empty) {
+            return [];
+        }
+        let user_list = [];
+        snapshot.forEach((doc) => {
+            user_list.push(doc.data());
+        });
+        return user_list;
+    }
+    static async getCompanyIdbyNickname(firestore, nickName) {
+        let company_details = await firestore
+            .collection("Companies")
+            .where("nickname", "==", nickName)
+            .get();
+        if (company_details.empty) {
+            return "Not found";
+        }
+        let company_id = "";
+        company_details.forEach((doc) => {
+            company_id = doc.data().id;
+        });
+        return company_id;
+    }
+    static async userIdbycompany(firestore, nickName) {
+        let snapshot = await firestore
+            .collection("Companies")
+            .where("nickname", "==", nickName)
+            .select("users")
+            .get();
+        let usersId = snapshot.docs.map(async (doc) => doc.data().users);
+        return usersId[0];
+    }
+    static async getMangersList(firestore, nickName) {
+        let companyId = await Company.getCompanyIdbyNickname(firestore, nickName);
+        let snapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .get();
+        let set = new Set();
+        for (let element of snapshot.docs) {
+            if (element.data().reportingTo) {
+                for (let data of element.data().reportingTo) {
+                    set.add(data);
+                }
+            }
+        }
+        return Array.from(set);
+    }
+    static async getTeamListOfManager(firestore, nickName, phone) {
+        let companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+        let userId = await user_model_1.User.getUserIdByPhone(firestore, phone);
+        console.log(userId);
+        let usersRef = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("reportingTo", "array-contains", userId)
+            .get();
+        return usersRef.docs.map((doc) => {
+            return doc.data();
+        });
+    }
+    // static async updatephone(firestore:admin.firestore.Firestore,nickName:string,phone:string,updatenumber:string){
+    //   let user_snapshot =  await firestore.collection('Users').where('phone','==',phone).get()
+    //   await user_snapshot.forEach((doc)=>{
+    //     doc.ref.update({phone:updatenumber})
+    //   })
+    //   let snapshot =  await firestore.collection('Licenses').where('user','==',phone).get()
+    //   await snapshot.forEach((doc)=>{
+    //     doc.ref.update({user:updatenumber})
+    //   })
+    //   let company_id = await Company.getCompanyIdbyNickname(firestore,nickName)
+    //   let company_snapshot = await firestore.collection('Companies').doc(company_id).collection('Users').where('phone','==',phone).get()
+    //   await company_snapshot.forEach((doc)=>{
+    //     doc.ref.update({phone:updatenumber})
+    //   })
+    //   return "Updated successfully"
+    // }
+    async initByNickname(db, nickname) {
+        var d = await Company.getCompanyDocByNickName(db, nickname);
+        this.initViaSnapshotDoc(d);
+    }
+    initViaSnapshotDoc(doc) {
+        var _data = doc;
+        this.id = _data.id;
+        this.nickname = _data.nickname;
+        this.name = _data.name;
+        this.description = _data.description;
+        this.users = _data.users;
+        this.image = _data.image;
+        this.endpoints = _data.endpoints;
+        //console.log(this.name)
+    }
+    // static async createUserbyPhone(auth:admin.auth.Auth,phoneNumber:string){
+    //   let newUser = await auth.createUser({phoneNumber})
+    //   return newUser
+    // }
+    static async testFB(fdb, s) {
+        const coRef = fdb.collection("Companies");
+        const snapshot = await coRef.where("nickname", "==", s).get();
+        if (snapshot.empty) {
+            throw "Nickname " + s + " not found";
+        }
+        else {
+            let rdoc = snapshot.docs.map((doc) => doc.data());
+            console.log(typeof snapshot.docs.map((doc) => doc.data()));
+            return rdoc[0];
+        }
+    }
+    static async getUsers(firestore, nickname) {
+        const snap = await firestore
+            .collection("Companies")
+            .where("nickname", "==", nickname)
+            .get();
+        const data = snap.docs.map((doc) => doc.data());
+        return { users: data[0].users, id: data[0].id };
+    }
+    static async getCompanyDocByNickName(fdb, nickname) {
+        const coRef = fdb.collection("Companies");
+        const snapshot = await coRef.where("nickname", "==", nickname).get();
+        snapshot.docs;
+        if (snapshot.empty) {
+            throw "Nickname " + nickname + " not found";
+        }
+        else {
+            let rdoc = snapshot.docs.map((doc) => doc.data());
+            return rdoc[0];
+        }
+    }
+    static async getCompaniesList(firestore) {
+        const companies = await firestore.collection("Companies").get();
+        const companiesList = [];
+        companies.forEach((doc) => {
+            companiesList.push({
+                label: doc.data().name,
+                id: doc.data().id,
+            });
+        });
+        return companiesList;
+    }
+    static async getActionDocByEventId(firestore, eventId, companyId, actionName) {
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+        const docArr = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .where("eventId", "==", eventId)
+            .get();
+        let requestDocArr = docArr.docs.map((doc) => {
+            return doc.data();
+        });
+        let requestDoc = requestDocArr.length ? requestDocArr[0] : null;
+        return requestDoc;
+    }
+    static async getActionDocByEnrollId(firestore, enrollId, companyId, actionId, actionName) {
+        const docArr = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .where('refId', '==', enrollId)
+            .orderBy("createdAt", "desc")
+            .limit(1)
+            .get();
+        let requestDocArr = docArr.docs.map((doc) => {
+            return doc.data();
+        });
+        let requestDoc = requestDocArr.length ? requestDocArr[0] : null;
+        return requestDoc;
+    }
+    static async getActionDocsByEventIdsForMpApproval(firestore, eventIds, companyId, actionName) {
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+        const docArr = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .where("eventId", "in", eventIds)
+            .get();
+        let requestDocsArr = docArr.docs.map((doc) => {
+            return doc.data();
+        });
+        return requestDocsArr;
+    }
+    static async markActionDocAsProcessed(firestore, eventId, companyId, actionName) {
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+        const docArr = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection(actionName)
+            .where("eventId", "==", eventId)
+            .get();
+        docArr.forEach((doc) => {
+            doc.ref.update({
+                isProcessed: true,
+            });
+        });
+    }
+    static async getActionInfo(firestore, companyId, actionName) {
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+        const actionInfoDoc = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .get();
+        const actionInfo = actionInfoDoc.data();
+        return actionInfo;
+    }
+    static async updateReportingTo(firestore, arrayUnion, nickName, userData) {
+        let managersIdList = [];
+        let managersNameList = [];
+        let managersPhoneNo = userData.reportingToArr;
+        for (let manager of managersPhoneNo) {
+            let temp = await Company.getUserDetailsByPhone(firestore, nickName, manager);
+            managersIdList.push(temp[0].id);
+            managersNameList.push(temp[0].name);
+        }
+        let companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+        let userSnapshot = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Users")
+            .where("phone", "==", userData.phone)
+            .get();
+        let userName = userSnapshot.docs.map((doc) => {
+            return doc.data().name;
+        });
+        userSnapshot.docs.map((doc) => {
+            doc.ref.update({
+                reportingTo: [],
+            });
+            doc.ref.update({
+                reportingTo: arrayUnion(...managersIdList),
+                managers: arrayUnion(...managersNameList),
+            });
+        });
+        return `${managersNameList} are managers of ${userName[0]} `;
+    }
+}
+exports.Company = Company;