mobioffice-cli 1.0.0 → 1.0.2

package/lib/models/attendance.model.js

@@ -0,0 +1,446 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attendance = void 0;
+const action_model_1 = require("./action.model");
+const company_model_1 = require("./company.model");
+const license_model_1 = require("./license.model");
+const user_model_1 = require("./user.model");
+const utility_model_1 = require("./utility.model");
+const crud_1 = __importDefault(require("./crud/crud"));
+class Attendance {
+    static async getAttendancebyUser(firestore, company, phone, from_date, to_date, isOnlyMonthRequired) {
+        console.log("in getAttendance by user");
+        console.log(from_date, to_date);
+        let epochFromDate = await Attendance.convertToTimestamp(from_date);
+        let epochToDate = await license_model_1.License.convertDatetoTimestamp(to_date);
+        let datesInMonthList = await Attendance.getDatesInInterval(from_date, to_date, isOnlyMonthRequired);
+        let userStartAtDoc = Array.apply(null, Array(datesInMonthList.length)).map(() => {
+            return [];
+        });
+        let userEndAtDoc = Array.apply(null, Array(datesInMonthList.length)).map(() => {
+            return [];
+        });
+        let userId = await user_model_1.User.getUserIdByPhone(firestore, phone);
+        let companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, company);
+        let actionId = await action_model_1.Action.getActionId(firestore, companyId, "check_in_out");
+        if (!actionId) {
+            return { data: datesInMonthList, message: "action" };
+        }
+        let userAttendance_snapshot = await Attendance.getAttendancefromFirestore(firestore, companyId, actionId, userId, epochFromDate, epochToDate);
+        if (userAttendance_snapshot.empty) {
+            return { data: datesInMonthList, message: "data not found" };
+        }
+        userAttendance_snapshot.forEach((doc) => {
+            if (epochFromDate <= doc.data().startAt &&
+                doc.data().startAt <= epochToDate) {
+                let startAt = new Date(doc.data().startAt).toLocaleString("en-GB", {
+                    year: "numeric",
+                    month: "numeric",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                });
+                let idx = parseInt(startAt.split(",")[0].split("/")[0]) - 1;
+                userStartAtDoc[idx].push(startAt.replace(",", ""));
+            }
+            else if (epochFromDate <= doc.data().endAt &&
+                doc.data().endAt <= epochToDate) {
+                let endAt = new Date(doc.data().endAt).toLocaleString("en-GB", {
+                    year: "numeric",
+                    month: "numeric",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                });
+                let idx = parseInt(endAt.split(",")[0].split("/")[0]) - 1;
+                userEndAtDoc[idx].push(endAt.replace(",", ""));
+            }
+        });
+        for (let date in datesInMonthList) {
+            let startAt = userStartAtDoc[date][userStartAtDoc[date].length - 1]
+                ? userStartAtDoc[date][userStartAtDoc[date].length - 1]
+                : "";
+            let endAt = userEndAtDoc[date][0] ? userEndAtDoc[date][0] : "";
+            Object.assign(datesInMonthList[date], { in: startAt }, { status: null });
+            Object.assign(datesInMonthList[date], { out: endAt }, { status: null });
+        }
+        return { data: datesInMonthList, message: "Success" };
+    }
+    static async getByDateAttendancebyUser(firestore, company, phone, from_date, to_date) {
+        let epochFromDate = await Attendance.convertToTimestamp(from_date);
+        let epochToDate = await license_model_1.License.convertDatetoTimestamp(to_date);
+        let attendanceObj = {
+            "In Time": "",
+            "Out Time": "",
+        };
+        let userStartAt = "";
+        let userEndAt = "";
+        let userId = await user_model_1.User.getUserIdByPhone(firestore, phone);
+        let companyId = await company_model_1.Company.getCompanyIdByNickName(firestore, company);
+        let actionId = await action_model_1.Action.getActionId(firestore, companyId, "check_in_out");
+        if (!actionId) {
+            return { data: attendanceObj, message: "No action" };
+        }
+        let userAttendance_snapshot = await Attendance.getAttendancefromFirestore(firestore, companyId, actionId, userId, epochFromDate, epochToDate);
+        if (userAttendance_snapshot.empty) {
+            return { data: attendanceObj, message: "Data not found" };
+        }
+        userAttendance_snapshot.forEach((doc) => {
+            console.log("before if condition", epochFromDate, doc.data().startAt);
+            if (epochFromDate <= doc.data().startAt &&
+                doc.data().startAt <= epochToDate) {
+                console.log(epochFromDate, doc.data().startAt);
+                let startAt = new Date(doc.data().startAt).toLocaleString("en-GB", {
+                    year: "numeric",
+                    month: "numeric",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                });
+                userStartAt = startAt.replace(",", "").split(" ")[1];
+                console.log(userStartAt);
+            }
+            else if (epochFromDate <= doc.data().endAt &&
+                doc.data().endAt <= epochToDate) {
+                let endAt = new Date(doc.data().endAt).toLocaleString("en-GB", {
+                    year: "numeric",
+                    month: "numeric",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                });
+                userEndAt = endAt.replace(",", "").split(" ")[1];
+            }
+        });
+        console.log("startAt", userStartAt);
+        console.log("endAt", userEndAt);
+        attendanceObj["In Time"] = userStartAt;
+        attendanceObj["Out Time"] = userEndAt;
+        return { data: attendanceObj, message: "Success" };
+    }
+    static async getDatesInMonth(date, from_date) {
+        console.log("here", date, from_date);
+        let startDate;
+        const endDate = Number(date.split("-")[0]);
+        if (from_date) {
+            startDate = Number(from_date.split("-")[0]);
+        }
+        else {
+            startDate = 1;
+        }
+        let month = date.split("-")[1];
+        let year = date.split("-")[2];
+        let getDatesInMonth = [];
+        // let daysinmonth = new Date(parseInt(year), parseInt(month),0).getDate();
+        for (startDate; startDate <= endDate; startDate++) {
+            getDatesInMonth.push({
+                date: `${String(startDate).padStart(2, "0")}/${month}/${year}`,
+                in: "",
+                out: "",
+                status: "",
+            });
+        }
+        console.log(getDatesInMonth);
+        return getDatesInMonth;
+    }
+    static async getDatesInInterval(startDate, endDate, isOnlyMonthRequired) {
+        if (isOnlyMonthRequired) {
+            return this.getDaysOfMonth(startDate, endDate);
+        }
+        console.log(startDate, endDate);
+        const startYear = Number(startDate.split("-")[2]);
+        const startMonth = Number(startDate.split("-")[1]);
+        const startDay = Number(startDate.split("-")[0]);
+        const endYear = Number(endDate.split("-")[2]);
+        const endMonth = Number(endDate.split("-")[1]);
+        const endDay = Number(endDate.split("-")[0]);
+        let datesInInterval = [];
+        for (let i = startYear; i <= endYear; i++) {
+            console.log("year", i);
+            const currentYear = i;
+            const isStartYear = this.isStartYear(currentYear, startYear);
+            const isEndYear = this.isEndYear(currentYear, endYear);
+            if (isStartYear && isEndYear) {
+                console.log("only year");
+                const daysOfYear = this.getDaysOfYear(i, startMonth, endMonth, startDay, endDay, "onlyYear");
+                datesInInterval = [...datesInInterval, ...daysOfYear];
+            }
+            else if (isStartYear) {
+                console.log("start year");
+                const daysOfYear = this.getDaysOfYear(i, startMonth, 12, startDay, endDay, "startYear");
+                datesInInterval = [...datesInInterval, ...daysOfYear];
+            }
+            else if (isEndYear) {
+                console.log("end year");
+                const daysOfYear = this.getDaysOfYear(i, 1, endMonth, startDay, endDay, "endYear");
+                datesInInterval = [...datesInInterval, ...daysOfYear];
+            }
+            else {
+                console.log("middle year");
+                const daysOfYear = this.getDaysOfYear(i, 1, 12, startDay, endDay, "middleYear");
+                datesInInterval = [...datesInInterval, ...daysOfYear];
+            }
+        }
+        console.log(datesInInterval);
+        return datesInInterval;
+    }
+    static isStartMonth(currMonth, startMonth) {
+        return currMonth === startMonth;
+    }
+    static isEndMonth(currMonth, endMonth) {
+        return currMonth === endMonth;
+    }
+    static isStartYear(currYear, startYear) {
+        return currYear === startYear;
+    }
+    static isEndYear(currYear, endYear) {
+        return currYear === endYear;
+    }
+    static getDaysOfYear(year, startMonth, endMonth, startDay, endDay, yearType) {
+        let datesOfYear = [];
+        console.log(startMonth, endMonth);
+        for (let j = startMonth; j < endMonth + 1; j++) {
+            console.log("currMonth", j);
+            const isStartMonth = this.isStartMonth(j, startMonth);
+            const isEndMonth = this.isEndMonth(j, endMonth);
+            console.log("isStartMonth", isStartMonth);
+            console.log("isEndMonth", isEndMonth);
+            if (isStartMonth && isEndMonth && yearType === "onlyYear") {
+                console.log("only month");
+                const from_date = `${startDay}-${j}-${year}`;
+                const to_date = `${endDay}-${j}-${year}`;
+                const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+                datesOfYear = [...datesOfYear, ...daysOfMonth];
+            }
+            else if (isStartMonth &&
+                (yearType === "startYear" || yearType === "onlyYear")) {
+                console.log("start month");
+                const from_date = `${startDay}-${j}-${year}`;
+                const lastDateOfMonth = new Date(year, j, 0).getDate();
+                const to_date = `${lastDateOfMonth}-${j}-${year}`;
+                const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+                datesOfYear = [...datesOfYear, ...daysOfMonth];
+            }
+            else if (isEndMonth &&
+                (yearType === "endYear" || yearType === "onlyYear")) {
+                console.log("last month");
+                const from_date = `${1}-${j}-${year}`;
+                const to_date = `${endDay}-${j}-${year}`;
+                const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+                datesOfYear = [...datesOfYear, ...daysOfMonth];
+            }
+            else {
+                console.log("middle month");
+                const from_date = `${1}-${j}-${year}`;
+                const lastDateOfMonth = new Date(year, j, 0).getDate();
+                const to_date = `${lastDateOfMonth}-${j}-${year}`;
+                const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+                datesOfYear = [...datesOfYear, ...daysOfMonth];
+            }
+        }
+        return datesOfYear;
+    }
+    static getDaysOfMonth(startDay, endDay) {
+        const datesOfMonth = [];
+        const start_day = Number(startDay.split("-")[0]);
+        const end_day = Number(endDay.split("-")[0]);
+        const month = Number(startDay.split("-")[1]);
+        const year = Number(startDay.split("-")[2]);
+        for (let i = start_day; i <= end_day; i++) {
+            const date = `${i.toString().padStart(2, "0")}/${month
+                .toString()
+                .padStart(2, "0")}/${year}`;
+            datesOfMonth.push({
+                date: date,
+                in: "",
+                out: "",
+                status: "",
+            });
+        }
+        return datesOfMonth;
+    }
+    static async getAttendancefromFirestore(firestore, companyId, actionId, userId, epochFromDate, epochToDate) {
+        let userAttendancebyMonth = await firestore
+            .collection("Companies")
+            .doc(companyId)
+            .collection("Actions")
+            .doc(actionId)
+            .collection("check_in_out")
+            .where("userId", "==", userId)
+            .where("createdAt", ">=", epochFromDate)
+            .where("createdAt", "<=", epochToDate + 86400000)
+            .orderBy("createdAt", "desc")
+            .get();
+        return userAttendancebyMonth;
+    }
+    static async convertToTimestamp(date) {
+        const [day, month, year] = date.split("-");
+        const timestamp = new Date(year, month - 1, day).getTime();
+        return timestamp;
+    }
+    static async getformateddate(timestamp) {
+        let temp = new Date(timestamp).toLocaleString("en-GB", {
+            year: "numeric",
+            month: "numeric",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+        let time = temp.split(",")[1].replace(" ", "");
+        let date = temp.split(",")[0].replace(",", "");
+        return [date, time];
+    }
+    static async getAttendancebyMonth(firestore, nickName, phone, month, year, fromDate, toDate) {
+        let endDate = new Date(parseInt(year), parseInt(month), 0).getDate();
+        let from_date;
+        let to_date;
+        let isOnlyMonthRequired = false;
+        if (fromDate && toDate) {
+            from_date = fromDate.split("/").join("-");
+            to_date = toDate.split("/").join("-");
+        }
+        else {
+            from_date = `01-${month}-${year}`;
+            to_date = `${endDate}-${month}-${year}`;
+            isOnlyMonthRequired = true;
+        }
+        console.log(from_date, to_date);
+        return Attendance.getAttendancebyUser(firestore, nickName, phone, from_date, to_date, isOnlyMonthRequired);
+    }
+    static async getAttendanceMonthlybyTeam(firestore, nickName, month, year) {
+        let employeeslistbycompany = await company_model_1.Company.getUsersListbyCompany(firestore, nickName);
+        if (employeeslistbycompany.length < 1) {
+            return "No employees in present company";
+        }
+        let employeesAttendance = await Promise.all(employeeslistbycompany.map(async (doc) => {
+            let userMothlyAttendance = await Attendance.getAttendancebyMonth(firestore, nickName, doc.phone, month, year);
+            let employeeName = doc.name;
+            if (!employeeName) {
+                employeeName = "unknown";
+            }
+            return { name: employeeName, data: userMothlyAttendance.data };
+        }));
+        return employeesAttendance;
+    }
+    static async getDailyReport(firestore, nickName, phoneNo) {
+        let employeeslistbycompany = await company_model_1.Company.getTeamListOfManager(firestore, nickName, phoneNo);
+        if (employeeslistbycompany.length < 1) {
+            return null;
+        }
+        let toDate = await Attendance.getCurrentdate();
+        toDate = toDate.replace(/\//g, "-");
+        console.log(toDate);
+        let employeesAttendance = await Promise.all(employeeslistbycompany.map(async (doc) => {
+            let employeeAttendance = await Attendance.getByDateAttendancebyUser(firestore, nickName, doc.phone, toDate, toDate);
+            let employeeName = doc.name;
+            console.log(employeeAttendance);
+            if (!employeeName) {
+                employeeName = "unknown";
+            }
+            return { name: employeeName, ...employeeAttendance.data };
+        }));
+        return employeesAttendance;
+    }
+    static async getCurrentdate() {
+        return new Date().toLocaleDateString("en-GB", { timeZone: "asia/kolkata" });
+    }
+    static async getCurrentTime() {
+        return new Date().toLocaleTimeString("en-GB", {
+            timeZone: "asia/kolkata",
+            hour: "2-digit",
+            minute: "2-digit",
+            hourCycle: "h12",
+        });
+    }
+    static async uploadEntryToReportDB(attendanceConnection, info) {
+        const curdService = new crud_1.default(attendanceConnection);
+        try {
+            const time = await utility_model_1.Utilities.epochToMySqlDateTime(info.time);
+            const qryString = `INSERT INTO attendanceEntries (companyId, employeeName,
+                                                            eventType, timeInt, time, actionName, phoneNo, isInactive)
+                                                    VALUES ('${info.companyId}',
+                                                            '${info.employeeName}',
+                                                            '${info.eventType}',
+                                                            ${info.time},
+                                                            '${time}',
+                                                            '${info.actionName}',
+                                                            '${info.phoneNo}', false);`;
+            const result = await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+        }
+    }
+    static async enrollWorkerFaceToDB(connection, data) {
+        const curdService = new crud_1.default(connection);
+        try {
+            const currentTimestamp = new Date()
+                .toISOString()
+                .replace(/T/, " ")
+                .replace(/\..+/, "");
+            const qryString = `INSERT INTO worker_enroll (
+            refId, companyId, faceJpg, name, faceTemplates, enrolledBy, dob, proofType, phone, inchargeName, proofImage, createdAt)
+            VALUES ('${data.id}', '${data.companyId}', '${data.faceJpg}',
+                '${data.name}', '${data.faceTemplates}', '${data.enrolledBy}', '${data.dob}',
+                '${data.proofType}','${data.phone}', '${data.inchargeName}', '${data.proofImage}', '${currentTimestamp}');`;
+            return await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            return error;
+        }
+    }
+    static async checkUserExist(connection, id) {
+        const curdService = new crud_1.default(connection);
+        try {
+            const qryString = `SELECT * FROM worker_enroll WHERE refId = '${id}'`;
+            return await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            return error;
+        }
+    }
+    static async updateExistUser(connection, data, id) {
+        const curdService = new crud_1.default(connection);
+        try {
+            const qryString = `UPDATE worker_enroll
+            SET companyId = '${data.companyId}', faceJpg = '${data.faceJpg}', faceId = '${data.faceId}', faceName = '${data.faceName}', faceTemplates = '${data.faceTemplates}', Name = '${data.Name}', 
+            DOB = '${data.DOB}', ProofType = '${data.ProofType}', Phone = '${data.Phone}', InchargeName = '${data.InchargeName}', ProofImage = '${data.ProofImage}', created_at = CURDATE()
+            WHERE refId = '${id}';`;
+            return await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            return error;
+        }
+    }
+    static async workerCheckIn(connection, enrollId, companyId, actionName) {
+        const curdService = new crud_1.default(connection);
+        try {
+            const qryString = `INSERT INTO worker_attendance (enrollId, companyId, timeStamp, actionType)
+            VALUES ('${enrollId}', '${companyId}', NOW(), '${actionName}');`;
+            return await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            return error;
+        }
+    }
+    static async cicoValidate(connection, enrollId, action) {
+        const curdService = new crud_1.default(connection);
+        try {
+            const currentDate = new Date().toISOString().split("T")[0];
+            const qryString = `SELECT * FROM worker_attendance WHERE enrollId = ${enrollId} AND actionType='${action}' AND timeStamp >= '${currentDate} 00:00:00' AND timeStamp <= '${currentDate} 23:59:59';`;
+            return await curdService.query(qryString);
+        }
+        catch (error) {
+            console.log(error.message);
+            return error;
+        }
+    }
+}
+exports.Attendance = Attendance;

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

@@ -0,0 +1,9 @@
+import { Post } from "./post.model";
+import * as admin from "firebase-admin";
+declare class CheckInCheckOutPost extends Post {
+    actionEvent: string;
+    actionType: string;
+    actionName: string;
+    static sendCICOPost(firestore: admin.firestore.Firestore, cicoPost: any): Promise<void>;
+}
+export { CheckInCheckOutPost };

package/lib/models/cicoPost.model.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckInCheckOutPost = void 0;
+const post_model_1 = require("./post.model");
+class CheckInCheckOutPost extends post_model_1.Post {
+    actionEvent = "";
+    actionType = "checkInOut";
+    actionName = "check_in_out";
+    static async sendCICOPost(firestore, cicoPost) {
+        await firestore.collection("Companies")
+            .doc(cicoPost.companyId)
+            .collection("Actions")
+            .doc(cicoPost.actionId)
+            .collection(cicoPost.actionName)
+            .doc(cicoPost.eventId)
+            .set(cicoPost);
+    }
+}
+exports.CheckInCheckOutPost = CheckInCheckOutPost;

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

@@ -0,0 +1,67 @@
+import * as admin from "firebase-admin";
+declare class Company {
+    id: string;
+    nickname: string;
+    description: string;
+    image: string;
+    name: string;
+    users: string[];
+    endpoints: string[];
+    static initCompany(firestore: admin.firestore.Firestore): Promise<void>;
+    static getCompanyIdByNickName(firestore: admin.firestore.Firestore, nickName: string): Promise<string>;
+    static getOrCreateCompany(firestore: admin.firestore.Firestore, companyDetails: any): Promise<any[]>;
+    static createCompany(firestore: admin.firestore.Firestore, companyDetails: any): Promise<any>;
+    static convertCompanyDataType(companyDetails: any): Promise<any>;
+    static updateCompany(firestore: admin.firestore.Firestore, nickName: string, companyDoc: any): Promise<"Updated successfully" | "Company doesn't exists">;
+    static addUserIdsInsideCompanies(firestore: admin.firestore.Firestore, arrayUnion: any, nickName: string): Promise<void>;
+    static checkIfUserExists(firestore: admin.firestore.Firestore, companyId: string, userId: string): Promise<true | null>;
+    static intiActionsInCompany(firestore: admin.firestore.Firestore, companyId: string, actions: []): Promise<[]>;
+    static getUserDetailsByPhone(firestore: admin.firestore.Firestore, nickName: string, phoneNumber: string): Promise<any>;
+    static createOrUpdateUser(firestore: admin.firestore.Firestore, auth: admin.auth.Auth, arrayUnion: any, nickName: string, newDetails: any): Promise<"Please provide actions" | "error occured when adding userId in users array" | {
+        companyId: string;
+        userId: string;
+        actions: string[];
+    }>;
+    static createNewUser(firestore: admin.firestore.Firestore, auth: any, arrayUnion: any, nickName: string, newDetails: any): Promise<"Please provide actions" | "error occured when adding userId in users array" | {
+        companyId: string;
+        userId: string;
+        actions: string[];
+    } | {
+        data: admin.firestore.DocumentData;
+        message: string;
+    }>;
+    static updateUser(firestore: admin.firestore.Firestore, arrayUnion: any, nickName: string, newDetails: any): Promise<admin.firestore.DocumentData>;
+    static addReportingToInfoToDetails(firestore: admin.firestore.Firestore, newDetails: any, companyId: string): Promise<void>;
+    static getSubordinatesById(firestore: admin.firestore.Firestore, uid: string, cid: string): Promise<any[]>;
+    static updateUserPhone(firestore: admin.firestore.Firestore, uid: string, phone: string): Promise<true | null>;
+    static convertUserDataType(data: any): Promise<any>;
+    static createUser(firestore: admin.firestore.Firestore, auth: admin.auth.Auth, arrayUnion: any, companyId: string, newDetails: any): Promise<"Please provide actions" | "error occured when adding userId in users array" | {
+        companyId: string;
+        userId: string;
+        actions: string[];
+    }>;
+    static addUserId(firestore: admin.firestore.Firestore, arrayUnion: any, companyId: string, id: string, actions: string[]): Promise<string[]>;
+    static getCompanyDocByCompanyId(firestore: admin.firestore.Firestore, companyId: string): Promise<admin.firestore.DocumentData | undefined>;
+    static addUserIdinCompany(firestore: admin.firestore.Firestore, arrayUnion: any, companyId: string, userId: string): Promise<void>;
+    static getUsersListbyCompany(firestore: admin.firestore.Firestore, nickName: string): Promise<any[]>;
+    static getCompanyIdbyNickname(firestore: admin.firestore.Firestore, nickName: string): Promise<string>;
+    static userIdbycompany(firestore: admin.firestore.Firestore, nickName: string): Promise<any>;
+    static getMangersList(firestore: admin.firestore.Firestore, nickName: string): Promise<unknown[]>;
+    static getTeamListOfManager(firestore: admin.firestore.Firestore, nickName: string, phone: string): Promise<admin.firestore.DocumentData[]>;
+    initByNickname(db: any, nickname: string): Promise<void>;
+    initViaSnapshotDoc(doc: admin.firestore.DocumentData): void;
+    static testFB(fdb: admin.firestore.Firestore, s: string): Promise<any>;
+    static getUsers(firestore: admin.firestore.Firestore, nickname: string): Promise<{
+        users: any;
+        id: any;
+    }>;
+    static getCompanyDocByNickName(fdb: admin.firestore.Firestore, nickname: string): Promise<admin.firestore.DocumentData>;
+    static getCompaniesList(firestore: admin.firestore.Firestore): Promise<any>;
+    static getActionDocByEventId(firestore: admin.firestore.Firestore, eventId: string, companyId: string, actionName: string): Promise<admin.firestore.DocumentData | null>;
+    static getActionDocByEnrollId(firestore: admin.firestore.Firestore, enrollId: string, companyId: string, actionId: string, actionName: string): Promise<admin.firestore.DocumentData | null>;
+    static getActionDocsByEventIdsForMpApproval(firestore: admin.firestore.Firestore, eventIds: string[], companyId: string, actionName: string): Promise<any[]>;
+    static markActionDocAsProcessed(firestore: admin.firestore.Firestore, eventId: string, companyId: string, actionName: string): Promise<void>;
+    static getActionInfo(firestore: admin.firestore.Firestore, companyId: string, actionName: string): Promise<admin.firestore.DocumentData | undefined>;
+    static updateReportingTo(firestore: admin.firestore.Firestore, arrayUnion: any, nickName: string, userData: any): Promise<string>;
+}
+export { Company };