mobioffice-cli 1.0.0 → 1.0.1

package/lib/models/geofence.model.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Geofence = void 0;
+const company_model_1 = require("./company.model");
+class Geofence {
+    static async getOrCreateGeoFence(firestore, geofenceDoc) {
+        let snapshot = await firestore.collection('Geofence').where('companyNickName', '==', geofenceDoc.companyNickName).get();
+        if (snapshot.empty) {
+            if (!geofenceDoc.companyId) {
+                let companynickname = await company_model_1.Company.getCompanyIdbyNickname(firestore, geofenceDoc.companyNickName);
+                geofenceDoc.companyId = companynickname;
+            }
+            geofenceDoc = await Geofence.convertGeofenceDataType(geofenceDoc);
+            let geofence_snapshot = firestore.collection("Geofence").doc();
+            let docId = geofence_snapshot.id;
+            geofenceDoc.id = docId;
+            geofence_snapshot.set(geofenceDoc);
+            return geofenceDoc;
+        }
+        return snapshot.docs[0].data();
+    }
+    static async convertGeofenceDataType(geoFenceDoc) {
+        if (geoFenceDoc.geoFenceIds) {
+            geoFenceDoc.geoFenceIds = geoFenceDoc.geoFenceIds.split('&').map(Number);
+        }
+        else {
+            geoFenceDoc.geoFenceIds = [];
+        }
+        for (let value of geoFenceDoc.geoFence) {
+            if (value.area) {
+                value.area = Number(value.area);
+            }
+            value.attributes = {};
+            if (value.calendarId) {
+                value.calendarId = Number(value.calendarId);
+            }
+            if (value.id) {
+                value.id = Number(value.id);
+            }
+        }
+        return geoFenceDoc;
+    }
+    static async updateGeofence(firestore, arrayUnion, geofenceDoc) {
+        let snapshot = await firestore.collection('Geofence').where('companyNickName', '==', geofenceDoc.companyNickName).get();
+        if (snapshot.empty) {
+            return `create geofence for this company ${geofenceDoc.nickName}`;
+        }
+        else {
+            for (let geofenceDetail of geofenceDoc.geoFence) {
+                snapshot.forEach((doc) => {
+                    doc.ref.update({
+                        geoFence: arrayUnion(geofenceDetail),
+                        geoFenceIds: arrayUnion(geofenceDetail.id)
+                    });
+                });
+            }
+            return "updated successfully";
+        }
+    }
+}
+exports.Geofence = Geofence;

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

@@ -0,0 +1,12 @@
+import { Post } from "./post.model";
+import * as admin from "firebase-admin";
+declare class LeaveApplication extends Post {
+    actionEvent: string;
+    actionType: string;
+    actionName: string;
+    isProcessed: boolean;
+    static setIncomingInfoToLeaveApplicationPost(info: any, post: LeaveApplication): Promise<LeaveApplication>;
+    static modifyExtraDataForLeave(info: any): Promise<any>;
+    static getOpenedLeaveRequests(firestore: admin.firestore.Firestore, nickName: string, phone: string, actionName: string): Promise<admin.firestore.DocumentData[]>;
+}
+export { LeaveApplication };

package/lib/models/leaveApplicationPost.model.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveApplication = void 0;
+const post_model_1 = require("./post.model");
+const action_model_1 = require("./action.model");
+const company_model_1 = require("./company.model");
+class LeaveApplication extends post_model_1.Post {
+    actionEvent = "";
+    actionType = "worklog";
+    actionName = "leave-application";
+    isProcessed = false;
+    static async setIncomingInfoToLeaveApplicationPost(info, post) {
+        post.actionEvent = info.extra.actionEvent;
+        post.actionId = info.extra.actionId;
+        post.actionName = info.extra.actionName;
+        post.actionType = info.extra.actionType;
+        post.companyId = info.extra.companyId;
+        post.createdAt = info.extra.createdAt;
+        post.description = `Leave application for ${info.extra.extraData.reason} on ${info.extra.extraData.leaveDate}.`;
+        post.eventId = info.extra.eventId;
+        post.isGeofence = info.extra.isGeofence;
+        post.userId = info.userId;
+        const newExtraData = await this.modifyExtraDataForLeave(info);
+        post.extraData = newExtraData;
+        post.isProcessed = false;
+        post.target = info.target || "";
+        post.time = info.extra.time;
+        post.checkInternet = info.extra.checkInternet;
+        return post;
+    }
+    static async modifyExtraDataForLeave(info) {
+        const time = info.extra.startAt;
+        const date = new Date(info.extra.startAt).toLocaleDateString("en-GB");
+        const newExtraData = {
+            ...info.extra.extraData,
+            date: date,
+            time: time,
+            reason: info.extra.extraData.reason,
+            appliedDate: info.extra.extraData.leaveDate,
+            forApprovalText: "Approval Pending"
+        };
+        return newExtraData;
+    }
+    static async getOpenedLeaveRequests(firestore, nickName, phone, actionName) {
+        try {
+            let teamList = await company_model_1.Company.getTeamListOfManager(firestore, nickName, phone);
+            teamList = teamList.map(user => user.id);
+            const allOpenRequests = [];
+            const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+            const actionId = await action_model_1.Action.getActionId(firestore, companyId, actionName);
+            for (let userId of teamList) {
+                const openRequestsDocs = await firestore.collection("Companies")
+                    .doc(companyId)
+                    .collection("Actions")
+                    .doc(actionId)
+                    .collection(actionName)
+                    .where("isProcessed", "==", false)
+                    .where("userId", "==", userId)
+                    .get();
+                const openRequests = openRequestsDocs.docs.map(doc => {
+                    return doc.data();
+                });
+                allOpenRequests.push(...openRequests);
+            }
+            return allOpenRequests;
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+}
+exports.LeaveApplication = LeaveApplication;

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

@@ -0,0 +1,25 @@
+import * as admin from 'firebase-admin';
+declare class License {
+    company: string;
+    to_date?: string;
+    from_date?: string;
+    user: string;
+    license_type?: string;
+    device_id: string;
+    static minimumDevices: number;
+    static validateUserLicense(firestore: admin.firestore.Firestore, arrayUnion: any, today_date: admin.firestore.Timestamp, nickName: string, user: string, device_id: string, modelName: string, brand: string): Promise<any[]>;
+    static getUserDevices(firestore: admin.firestore.Firestore, nickName: string, phone: string): Promise<{
+        data: {
+            resArray: any;
+        };
+        message: string;
+    }>;
+    static grantUserLicense(firestore: admin.firestore.Firestore, nickName: string, newUserDetails: License): Promise<string>;
+    static convertDatetoTimestamp(data: any): Promise<number>;
+    static convertTimestamptoDate(timestamp: number): Promise<string>;
+    static extendLicense(firestore: admin.firestore.Firestore, nickName: string, userDetails: License): Promise<"User does exists" | "User details not found" | "Updated successfully">;
+    static resetDeviceIdforUserLicense(firestore: admin.firestore.Firestore, company: string, phone: string): Promise<{
+        message: string;
+    }>;
+}
+export { License };

package/lib/models/license.model.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.License = void 0;
+const action_model_1 = require("./action.model");
+const company_model_1 = require("./company.model");
+class License {
+    company = "";
+    to_date = ""; //new Date();
+    from_date = ""; //new Date();
+    user = "";
+    license_type = "";
+    device_id = "";
+    static minimumDevices = 1;
+    static async validateUserLicense(firestore, arrayUnion, today_date, nickName, user, device_id, modelName, brand) {
+        user = user.replace(' ', '+');
+        console.log(user);
+        let userDetails_snapshot = await firestore.collection('Licenses').where('company', '==', nickName).where('user', '==', user).get();
+        if (userDetails_snapshot.empty) {
+            return ["User not found", null, null];
+        }
+        let flag = false;
+        let device_flag = false;
+        let license_date = await Promise.all(userDetails_snapshot.docs.map(async (doc) => {
+            if (doc.data().device_id == 1) {
+                doc.ref.update({
+                    device_id: device_id,
+                    extraDevices: arrayUnion({
+                        deviceId: device_id,
+                        modelName: modelName,
+                        brandName: brand,
+                        fromData: Date.now()
+                    })
+                });
+                device_flag = true;
+                if ((today_date.seconds * 1000) <= doc.data().to_date) {
+                    flag = true;
+                }
+            }
+            else {
+                let extraDevices = doc.data().extraDevices ? doc.data().extraDevices : [];
+                extraDevices = extraDevices.map((device) => {
+                    return device.deviceId;
+                });
+                const uniqueExtraDevices = Array.from(new Set([...extraDevices]));
+                for (let storedDeviceId of uniqueExtraDevices) {
+                    if (device_id == storedDeviceId) {
+                        device_flag = true;
+                    }
+                }
+                if ((today_date.seconds * 1000) <= doc.data().to_date) {
+                    flag = true;
+                }
+                if (!device_flag) {
+                    let userInfo = await company_model_1.Company.getUserDetailsByPhone(firestore, nickName, user);
+                    userInfo = userInfo[0];
+                    const devicesLimit = userInfo.devicesLimit ? userInfo.devicesLimit : this.minimumDevices;
+                    console.log("devicesLimit", devicesLimit);
+                    if (flag) {
+                        if (extraDevices.length < Number(devicesLimit)) {
+                            const objToStore = {
+                                deviceId: device_id,
+                                modelName: modelName,
+                                brandName: brand,
+                                fromDate: Date.now()
+                            };
+                            userDetails_snapshot.forEach((doc) => {
+                                doc.ref.update({
+                                    extraDevices: arrayUnion(objToStore)
+                                });
+                            });
+                            device_flag = true;
+                        }
+                    }
+                }
+            }
+            return doc.data().to_date;
+        }));
+        let filtered_newest_date = license_date.reduce((a, b) => { return a > b ? a : b; });
+        let convert_to_timestamp = await License.convertTimestamptoDate(filtered_newest_date);
+        const status = flag && device_flag;
+        const action = "requestForm";
+        const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, action);
+        return [status, convert_to_timestamp, device_flag, actionId];
+    }
+    static async getUserDevices(firestore, nickName, phone) {
+        let license = await firestore.collection("Licenses")
+            .where("user", "==", `+${phone}`)
+            .where("company", "==", nickName)
+            .get();
+        license = license.docs[0].data();
+        const devicesList = license.extraDevices.map((obj) => {
+            let label;
+            if (obj.modelName && obj.brandName) {
+                label = `${obj.brandName}(${obj.modelName})`;
+            }
+            return {
+                id: obj.deviceId,
+                label: label ? label : obj.deviceId
+            };
+        });
+        if (devicesList.length > 0) {
+            return {
+                data: {
+                    resArray: devicesList,
+                },
+                message: "success"
+            };
+        }
+        else {
+            return {
+                data: {
+                    resArray: [{
+                            label: "No devices found"
+                        }]
+                },
+                message: "Error"
+            };
+        }
+    }
+    static async grantUserLicense(firestore, nickName, newUserDetails) {
+        console.log(newUserDetails);
+        newUserDetails.user = "+" + newUserDetails.user;
+        let to_date = await License.convertDatetoTimestamp(newUserDetails["to_date"]);
+        let from_date = await License.convertDatetoTimestamp(newUserDetails["from_date"]);
+        console.log(to_date, from_date);
+        Object.assign(newUserDetails, { company: nickName }, { to_date: to_date }, { from_date: from_date });
+        let company_id = await company_model_1.Company.getCompanyIdbyNickname(firestore, newUserDetails.company);
+        if (company_id == 'Not found') {
+            return "Company does not exists";
+        }
+        let snapshot = await firestore.collection('Companies').doc(company_id).collection('Users').where('phone', '==', newUserDetails.user).get();
+        if (snapshot.empty) {
+            return "User does not exists";
+        }
+        let user_license = await firestore.collection('Licenses').where('company', '==', `${newUserDetails.company}`).where('user', '==', newUserDetails.user).get();
+        let flag = false;
+        let user_list = [];
+        user_license.forEach((doc) => {
+            user_list.push(doc.data());
+            if (newUserDetails.company == doc.data().company) {
+                if (newUserDetails.user == doc.data().user) {
+                    if (newUserDetails.license_type == doc.data().license_type) {
+                        if (newUserDetails.to_date == doc.data().to_date) {
+                            flag = true;
+                        }
+                    }
+                }
+            }
+        });
+        if (flag) {
+            return `${newUserDetails.user} data already exists`;
+        }
+        await firestore.collection('Licenses').add(newUserDetails);
+        return `${newUserDetails.user} created successfully`;
+    }
+    static async convertDatetoTimestamp(data) {
+        const [day, month, year] = data.split('-');
+        const timestamp = new Date(year, month - 1, day, 24, 0, 0).getTime();
+        return timestamp;
+    }
+    static async convertTimestamptoDate(timestamp) {
+        let date = new Date(timestamp).toLocaleString();
+        return date;
+    }
+    static async extendLicense(firestore, nickName, userDetails) {
+        userDetails.user = "+" + userDetails.user;
+        let companyId = await company_model_1.Company.getCompanyIdbyNickname(firestore, nickName);
+        let userExist = await firestore.collection('Companies').doc(companyId).collection('Users').where('phone', '==', userDetails.user).get();
+        if (userExist.empty) {
+            return "User does exists";
+        }
+        let snapshot = await firestore.collection('Licenses').where('company', '==', nickName).where('user', '==', userDetails.user).where('license_type', '==', userDetails.license_type).get();
+        if (snapshot.empty) {
+            return "User details not found";
+        }
+        let toDateTimestamp = await this.convertDatetoTimestamp(userDetails.to_date);
+        snapshot.forEach((doc) => {
+            doc.ref.update({ to_date: toDateTimestamp });
+        });
+        return 'Updated successfully';
+    }
+    static async resetDeviceIdforUserLicense(firestore, company, phone) {
+        if (phone[0] != "+") {
+            phone = "+" + phone;
+        }
+        console.log(phone);
+        let userLicense = await firestore.collection("Licenses").where("user", "==", phone).where("company", "==", company).get();
+        if (userLicense.empty) {
+            return { message: "User not found" };
+        }
+        userLicense.forEach((doc) => {
+            doc.ref.update({ device_id: 1 });
+        });
+        return { message: "updated" };
+    }
+}
+exports.License = License;

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

@@ -0,0 +1,6 @@
+import * as admin from 'firebase-admin';
+declare class Logs {
+    static logEduceResponseToDB(firestore: admin.firestore.Firestore, userId: string, companyId: string, responseFromAPI: any, apiName: string): Promise<void>;
+    static createLogDocToStore(responseFromEduce: any): Promise<any>;
+}
+export { Logs };

package/{src/models/log.model.ts → lib/models/log.model.js}

@@ -1,25 +1,25 @@
-import * as admin from 'firebase-admin';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logs = void 0;
 class Logs {
-
-    static async logEduceResponseToDB(firestore: admin.firestore.Firestore, userId: string, companyId: string, responseFromAPI: any, apiName: string) {
+    static async logEduceResponseToDB(firestore, userId, companyId, responseFromAPI, apiName) {
         const logToStore = await this.createLogDocToStore(responseFromAPI);
         let responseObj = {
             createdAt: new Date().getTime(),
             logToStore,
             apiName
-        }
-        await firestore.collection("Logs").doc(userId).collection(companyId).doc().set(responseObj)
+        };
+        await firestore.collection("Logs").doc(userId).collection(companyId).doc().set(responseObj);
     }
-
-    static async createLogDocToStore(responseFromEduce: any) {
-        let logToStore: any = {};
+    static async createLogDocToStore(responseFromEduce) {
+        let logToStore = {};
         if (responseFromEduce.data) {
             logToStore.message = responseFromEduce.message;
-        } else if (responseFromEduce.error) {
+        }
+        else if (responseFromEduce.error) {
             logToStore.error = responseFromEduce.error;
         }
         return logToStore;
     }
 }
-export { Logs }
+exports.Logs = Logs;

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

@@ -0,0 +1,11 @@
+import { Pool } from "mysql2/typings/mysql/lib/Pool";
+declare class MeetingSummary {
+    customerName: string;
+    contactName: string;
+    meetingImage: string;
+    constructor(customerName: string, contactName: string, meetingImage: string);
+    static syncReportDBFirebaseUserEntries(meetingsDBConnection: Pool, doc: any, employeeName: string): Promise<void>;
+    static uploadEntryToReportDB(meetingsConnection: Pool, info: any): Promise<void>;
+    static updateEndTimeToReportDB(meetingsConnection: Pool, eventId: string, meetingEndTime: any): Promise<void>;
+}
+export { MeetingSummary };

package/lib/models/meeting.model.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeetingSummary = void 0;
+const crud_1 = __importDefault(require("./crud/crud"));
+class MeetingSummary {
+    customerName;
+    contactName;
+    meetingImage;
+    constructor(customerName, contactName, meetingImage) {
+        this.customerName = customerName;
+        this.meetingImage = meetingImage;
+        this.contactName = contactName;
+    }
+    static async syncReportDBFirebaseUserEntries(meetingsDBConnection, doc, employeeName) {
+        try {
+            const reportData = {
+                companyId: doc.companyId ?? "",
+                employeeName: employeeName ?? "",
+                eventId: doc.eventId ?? "",
+                userId: doc.userId ?? "",
+                phone: doc.phone ?? "",
+                meetingDate: doc.extraData.date ?? "",
+                meetingStartTime: doc.extraData["Start Time"] ?? "",
+                meetingEndTime: doc.extraData["End Time"] ?? "",
+                meetingImage: doc.extraData["meetingImage"] ?? "",
+                contactName: doc.extraData.contactName ?? "",
+                customerName: doc.extraData.customerName ?? "",
+                companyNickName: "benara",
+                time: doc.date
+            };
+            await this.uploadEntryToReportDB(meetingsDBConnection, reportData);
+        }
+        catch (error) {
+            console.log(error.message);
+        }
+    }
+    static async uploadEntryToReportDB(meetingsConnection, info) {
+        const curdService = new crud_1.default(meetingsConnection);
+        try {
+            const qryString = `INSERT INTO meeting_reports
+                                (userId, eventId, companyId, name, phone, companyNickName,
+                                  meetingDate, meetingStartTime, meetingEndTime, contactName, customerName,
+                                  meetingImage, createOn )
+                                                VALUES ('${info.userId}',
+                                                        '${info.eventId}',
+                                                        '${info.companyId}',
+                                                        '${info.employeeName}',
+                                                        '${info.phone}',
+                                                        '${info.companyNickName}',
+                                                        '${info.meetingDate}',
+                                                        '${info.meetingStartTime}',
+                                                        '${info.meetingEndTime}',
+                                                        '${info.contactName}',
+                                                        '${info.customerName}',
+                                                        '${info.meetingImage}',
+                                                        '${info.time}')`;
+            await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+        }
+    }
+    static async updateEndTimeToReportDB(meetingsConnection, eventId, meetingEndTime) {
+        const curdService = new crud_1.default(meetingsConnection);
+        try {
+            const qryString = `update meeting_reports
+                          set meetingEndTime = '${meetingEndTime}'
+                        where eventId = '${eventId}'`;
+            await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+}
+exports.MeetingSummary = MeetingSummary;

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

@@ -0,0 +1,18 @@
+import { Post } from "./post.model";
+import * as admin from "firebase-admin";
+declare class Meter extends Post {
+    actionEvent: string;
+    actionType: string;
+    actionName: string;
+    static createPostForMeter(firestore: admin.firestore.Firestore, postInfo: any): Promise<unknown>;
+    static setIncomingInfoToMeter(info: any, post: Meter): Promise<Meter>;
+    static modifyExtraDataForMeter(info: any): Promise<{
+        status: any;
+        machineMeterId: any;
+        currentReading: any;
+        consumption: any;
+        date: string;
+        time: any;
+    }>;
+}
+export { Meter };

package/lib/models/meter.model.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meter = void 0;
+const post_model_1 = require("./post.model");
+class Meter extends post_model_1.Post {
+    actionEvent = "";
+    actionType = "worklog";
+    actionName = "meter_reading";
+    static async createPostForMeter(firestore, postInfo) {
+        let post = new Meter();
+        post = await Meter.setIncomingInfoToMeter(postInfo, post);
+        let eventId = await post_model_1.Post.createNewPost(firestore, post);
+        return eventId;
+    }
+    static async setIncomingInfoToMeter(info, post) {
+        post.actionEvent = info.extra.actionEvent;
+        post.id = info.id;
+        post.actionId = info.extra.actionId;
+        post.companyId = info.extra.companyId;
+        post.createdAt = info.extra.createdAt;
+        post.description = info.description;
+        post.eventId = info.extra.eventId;
+        post.isGeofence = info.extra.isGeofence;
+        post.userId = info.userId;
+        const newExtraData = await this.modifyExtraDataForMeter(info);
+        post.extraData = newExtraData;
+        post.seen = info.extra.seen;
+        post.startAt = "";
+        post.startLat = info.extra.startLat;
+        post.startLong = info.extra.startLong;
+        post.endAt = "";
+        post.endLat = info.extra.endLat;
+        post.endLong = info.extra.endLong;
+        post.stepValues = info.extra.stepValues;
+        post.time = info.extra.time;
+        post.checkInternet = info.extra.checkInternet;
+        return post;
+    }
+    static async modifyExtraDataForMeter(info) {
+        const time = info.createdAt;
+        const date = new Date(time).toLocaleDateString("en-GB");
+        const newExtraData = {
+            //   ...info.extra.extraData,
+            status: info.status,
+            machineMeterId: info.machineMeterId,
+            currentReading: info.currentReading,
+            consumption: info.consumption,
+            date: date,
+            time: time
+        };
+        return newExtraData;
+    }
+}
+exports.Meter = Meter;

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

@@ -0,0 +1,15 @@
+import { Post } from "./post.model";
+import * as admin from "firebase-admin";
+declare class MissingPunch extends Post {
+    actionEvent: string;
+    actionType: string;
+    actionName: string;
+    description: string;
+    isProcessed: boolean;
+    missedEvent: string;
+    static getOpenedMpRequests(firestore: admin.firestore.Firestore, nickName: string, phone: string): Promise<admin.firestore.DocumentData[]>;
+    static createUpdatedFeed(requestDoc: any, description: string, forApprovalText: string): Promise<any>;
+    static updateFeedByUserId(firestore: admin.firestore.Firestore, updatedFeed: any, userId: string, companyId: string): Promise<void>;
+    static updateUserManagersFeed(firestore: admin.firestore.Firestore, updatedFeed: any, userId: string, companyId: string): Promise<void>;
+}
+export { MissingPunch };

package/lib/models/missingPunchPost.model.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingPunch = void 0;
+const post_model_1 = require("./post.model");
+const action_model_1 = require("./action.model");
+const user_model_1 = require("./user.model");
+const company_model_1 = require("./company.model");
+class MissingPunch extends post_model_1.Post {
+    actionEvent = "";
+    actionType = "worklog";
+    actionName = "mp";
+    description = "";
+    isProcessed = false;
+    missedEvent = "";
+    static async getOpenedMpRequests(firestore, nickName, phone) {
+        let teamList = await company_model_1.Company.getTeamListOfManager(firestore, nickName, phone);
+        teamList = teamList.map(user => user.id);
+        const allOpenRequests = [];
+        const companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, nickName);
+        const actionId = await action_model_1.Action.getActionId(firestore, companyId, "mp");
+        for (let userId of teamList) {
+            const openRequestsDocs = await firestore.collection("Companies")
+                .doc(companyId)
+                .collection("Actions")
+                .doc(actionId)
+                .collection("mp")
+                .where("isProcessed", "==", false)
+                .where("userId", "==", userId)
+                .get();
+            const openRequests = openRequestsDocs.docs.map(doc => {
+                return doc.data();
+            });
+            allOpenRequests.push(...openRequests);
+        }
+        return allOpenRequests;
+    }
+    static async createUpdatedFeed(requestDoc, description, forApprovalText) {
+        const extraData = {
+            ...requestDoc.extraData,
+            forApprovalText
+        };
+        const updatedFeed = {
+            ...requestDoc,
+            description: description,
+            forApprovalText,
+            extraData
+        };
+        return updatedFeed;
+    }
+    static async updateFeedByUserId(firestore, updatedFeed, userId, companyId) {
+        const oldFeeds = await firestore.collection("Feeds")
+            .doc(userId)
+            .collection(companyId)
+            .where("eventId", "==", updatedFeed.eventId)
+            .get();
+        oldFeeds.forEach((doc) => {
+            doc.ref.set(updatedFeed);
+        });
+    }
+    static async updateUserManagersFeed(firestore, updatedFeed, userId, companyId) {
+        updatedFeed.description = updatedFeed.description.slice(5);
+        const userDetails = await user_model_1.User.getUserInfoById(firestore, userId, companyId);
+        const managersList = userDetails.reportingTo;
+        for (let id of managersList) {
+            await this.updateFeedByUserId(firestore, updatedFeed, id, companyId);
+        }
+    }
+}
+exports.MissingPunch = MissingPunch;