@churchsoln/dbms 1.0.47 → 1.0.49

package/services/church.js

@@ -1,312 +1,312 @@
-const commonDb = require("../models/common");
-const { Op } = require("sequelize");
-const errorCodes = require("../config/errorCodes");
-const errorMsgs = require("../config/errorMsgs");
-const { masterQueue, masterQueueEvents } = require("../queues");
-const churchManager = require("../utils/churchManager");
-const { QUEUES, ROLES, AUTH_DATA, SUBSCRIPTION_PLAN_ID, CODE_LENGTH } = require("../constants");
-const bcrypt = require("bcrypt");
-const cryptr = require("../utils/crypto");
-const jwt = require("jsonwebtoken");
-const utils = require("../utils");
-
-class ChurchService {
-    async onboardChurch(params) {
-        try {
-            const { name, churchAdminDetails, validity } = params;
-            const alreadyExists = await commonDb.church.findOne({
-                where: { name: { [Op.iLike]: name } },
-                attributes: commonDb.church.selectedFields,
-                raw: true,
-            });
-            if (alreadyExists)
-                return {
-                    code: errorCodes.HTTP_CONFLICT,
-                    message: errorMsgs.churchAlreadyExists,
-                };
-            const expiresAt = new Date();
-            expiresAt.setDate(expiresAt.getDate() + validity);
-            const churchData = await commonDb.church.create(
-                {
-                    ...params,
-                    registeredAt: new Date(),
-                    subscribedAt: new Date(),
-                    expiresAt,
-                    connectionUrl: process.env.CHURCH_SHADOW_DATABASE_URL.replace(
-                        "church_shadow",
-                        name.toLowerCase()
-                    ),
-                    churchDomain: [
-                        {
-                            domain:
-                                process.env.NODE_ENV == "localdev"
-                                    ? `${name.toLowerCase()}.local.churchsoln.com`
-                                    : `${name.toLowerCase()}.churchsoln.com`,
-                        },
-                    ],
-                },
-                { include: { model: commonDb.churchDomain, as: "churchDomain" } }
-            );
-            let permissionId;
-            if (params.subscriptionPlanId == SUBSCRIPTION_PLAN_ID.CUSTOM) {
-                permissionId = params.permissionId;
-            } else {
-                let subscriptionPlan = await commonDb.subscriptionPlan.findOne({
-                    where: { id: params.subscriptionPlanId },
-                    attributes: commonDb.subscriptionPlan.selectedFields,
-                    include: {
-                        model: commonDb.subscriptionPlanPermission,
-                        as: "subscriptionPlanPermission",
-                        attributes: commonDb.subscriptionPlanPermission.selectedFields,
-                        required: false,
-                    },
-                });
-                subscriptionPlan = subscriptionPlan.get({ plain: true });
-                permissionId = subscriptionPlan.subscriptionPlanPermission.map(
-                    (x) => x.permissionId
-                );
-            }
-            await commonDb.churchPermission.bulkCreate(
-                permissionId.map((x) => ({
-                    churchId: churchData.id,
-                    permissionId: x,
-                }))
-            );
-            const jobs = [
-                {
-                    queue: QUEUES.DB_CREATE,
-                    data: { churchId: churchData.id, name: name.toLowerCase() },
-                },
-                {
-                    queue: QUEUES.MIGRATION,
-                    data: { churchId: churchData.id },
-                },
-                {
-                    queue: QUEUES.SEED,
-                    data: { churchId: churchData.id },
-                },
-            ];
-            const jobData = await masterQueue.add(QUEUES.MASTER, jobs);
-            masterQueueEvents.on("completed", async (event) => {
-                if (event.jobId === jobData.id) {
-                    const churchDb = await churchManager.getChurchDbConnectionById(churchData.id);
-                    const member = await churchDb.member.create({ 
-                        ...churchAdminDetails,
-                        envNumber: utils.generateCode(CODE_LENGTH.ENV_NUMBER) 
-                    })
-                    await churchDb.user.create({
-                        ...churchAdminDetails,
-                        status: true,
-                        roleId: ROLES.CHURCH_ADMIN,
-                        churchId: churchData.id,
-                        memberId: member.id
-                    });
-                    await churchDb.church.create(params)
-                    console.log(`Church onboarding completed for church: ${name}`);
-                }
-            });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.churchCreated };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-
-    async allChurchService(params) {
-        try {
-            const { search = null } = params;
-            const searchCondition = !!search ? { name: { [Op.like]: `%${search}%` } } : {};
-            const data = await commonDb.church.findAll({
-                where: { ...searchCondition },
-                attributes: commonDb.church.selectedFields,
-                include: {
-                    model: commonDb.subscriptionPlan,
-                    as: "subscriptionPlan",
-                    attributes: commonDb.subscriptionPlan.selectedFields,
-                    required: false,
-                },
-            });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-        } catch (err) {
-            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-        }
-    }
-
-    async churchByIdService(params) {
-        try {
-            const { id } = params;
-            const data = await commonDb.church.findOne({
-                where: { status: true, id },
-                attributes: commonDb.church.selectedFields,
-                raw: true,
-            });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-        } catch (err) {
-            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-        }
-    }
-
-    async updateChurchByIdService(params) {
-        try {
-            const { id, ...restParams } = params;
-            if(restParams.subscriptionPlanId) {
-                const churchData = await commonDb.church.findOne({
-                    where: { id },
-                    attributes: commonDb.church.selectedFields,
-                    raw: true,
-                });
-                if (churchData.expiresAt) {
-                    const expiresAt = new Date(churchData.expiresAt);
-                    expiresAt.setDate(expiresAt.getDate() + params.validity);
-                    restParams.expiresAt = expiresAt;
-                } else {
-                    const expiresAt = new Date();
-                    expiresAt.setDate(expiresAt.getDate() + params.validity);
-                    restParams.expiresAt = expiresAt;
-                }
-                restParams.subscribedAt = new Date();
-                await commonDb.churchPermission.destroy({
-                    where: { churchId: id },
-                });
-                let permissionId;
-                if (params.subscriptionPlanId == SUBSCRIPTION_PLAN_ID.CUSTOM) {
-                    permissionId = params.permissionId;
-                } else {
-                    let subscriptionPlan = await commonDb.subscriptionPlan.findOne({
-                        where: { id: params.subscriptionPlanId },
-                        attributes: commonDb.subscriptionPlan.selectedFields,
-                        include: {
-                            model: commonDb.subscriptionPlanPermission,
-                            as: "subscriptionPlanPermission",
-                            attributes: commonDb.subscriptionPlanPermission.selectedFields,
-                            required: false,
-                        },
-                    });
-                    subscriptionPlan = subscriptionPlan.get({ plain: true });
-                    permissionId = subscriptionPlan.subscriptionPlanPermission.map(
-                        (x) => x.permissionId
-                    );
-                }
-                await commonDb.churchPermission.bulkCreate(
-                    permissionId.map((x) => ({
-                        churchId: id,
-                        permissionId: x,
-                    }))
-                );
-            }
-            await commonDb.church.update(restParams, { where: { id } });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.churchUpdated };
-        } catch (err) {
-            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-        }
-    }
-
-    async addChurchPermissionService(params) {
-        try {
-            const { churchId, permissionId = [] } = params;
-            const existingChurch = await commonDb.church.findOne({
-                where: { id: churchId },
-                raw: true,
-            });
-            if (!existingChurch) {
-                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidChurchId };
-            }
-            const existingPermission = await commonDb.permission.findAll({
-                where: { id: permissionId },
-                raw: true,
-            });
-            if (existingPermission.length !== permissionId.length) {
-                return {
-                    code: errorCodes.HTTP_BAD_REQUEST,
-                    message: errorMsgs.invalidPermissionId,
-                };
-            }
-            const existingChurchPermission = await commonDb.churchPermission.findAll({
-                where: { churchId, permissionId },
-                raw: true,
-            });
-            const excludedPermissions = permissionId.filter(
-                (x) => !existingChurchPermission.map((y) => y.permissionId).includes(x)
-            );
-            if(excludedPermissions.length) {
-                const queries = excludedPermissions.map((x) => commonDb.churchPermission.create({ churchId, permissionId: x }))
-                await Promise.all(queries);
-            }
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-        } catch (err) {
-            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-        }
-    }
-    async getChurchPermissionService(params) {
-        try {
-            const { churchId } = params;
-            const data = await commonDb.churchPermission.findAll({
-                where: { churchId },
-                attributes: commonDb.churchPermission.selectedFields,
-                include: {
-                    model: commonDb.permission,
-                    as: "permission",
-                    attributes: commonDb.permission.selectedFields,
-                },
-            });
-            const response = data.map((x) => {
-                const permission = x.get({ plain: true });
-                permission.permissionId = permission.permission.id;
-                permission.permission = permission.permission.name;
-                return permission;
-            });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data: response };
-        } catch (err) {
-            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-        }
-    }
-    async deleteChurchPermissionByIdService(params) {
-        try {
-            const { id, churchId } = params;
-            const churchPermissionDetails = await commonDb.churchPermission.findOne({
-                where: { id, churchId },
-                attributes: commonDb.churchPermission.selectedFields,
-                raw: true,
-            });
-            if (!churchPermissionDetails)
-                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidId };
-            await commonDb.churchPermission.destroy({ where: { id, churchId } });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-        } catch (err) {
-            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-        }
-    }
-    
-    async login(params) {
-        try {
-            const { username, password } = params;
-            let userData = await commonDb.user.findOne({
-                where: { username },
-                attributes: commonDb.user.selectedFields,
-            });
-            userData = userData?.get({ plain: true });
-            if (!userData || !userData?.status)
-                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidCredentials };
-            if (!userData?.password)
-                return { code: errorCodes.HTTP_FORBIDDEN, message: errorMsgs.passwordNotSet };
-            const isPassowordCorrect = await bcrypt.compare(password, userData.password);
-            if (!isPassowordCorrect)
-                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidCredentials };
-            const encryptedData = {
-                id: cryptr.encrypt(userData.id),
-                username: cryptr.encrypt(userData.username),
-                email: cryptr.encrypt(userData.email),
-            };
-            const token = jwt.sign({ ...encryptedData }, process.env.JWT_SECRET, {
-                expiresIn: AUTH_DATA.SESSION_EXPIRY,
-            });
-            return {
-                code: errorCodes.HTTP_OK,
-                message: errorMsgs.loggedIn,
-                data: { token },
-            };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-}
-module.exports = new ChurchService();
+const commonDb = require("../models/common");
+const { Op } = require("sequelize");
+const errorCodes = require("../config/errorCodes");
+const errorMsgs = require("../config/errorMsgs");
+const { masterQueue, masterQueueEvents } = require("../queues");
+const churchManager = require("../utils/churchManager");
+const { QUEUES, ROLES, AUTH_DATA, SUBSCRIPTION_PLAN_ID, CODE_LENGTH } = require("../constants");
+const bcrypt = require("bcrypt");
+const cryptr = require("../utils/crypto");
+const jwt = require("jsonwebtoken");
+const utils = require("../utils");
+
+class ChurchService {
+    async onboardChurch(params) {
+        try {
+            const { name, churchAdminDetails, validity } = params;
+            const alreadyExists = await commonDb.church.findOne({
+                where: { name: { [Op.iLike]: name } },
+                attributes: commonDb.church.selectedFields,
+                raw: true,
+            });
+            if (alreadyExists)
+                return {
+                    code: errorCodes.HTTP_CONFLICT,
+                    message: errorMsgs.churchAlreadyExists,
+                };
+            const expiresAt = new Date();
+            expiresAt.setDate(expiresAt.getDate() + validity);
+            const churchData = await commonDb.church.create(
+                {
+                    ...params,
+                    registeredAt: new Date(),
+                    subscribedAt: new Date(),
+                    expiresAt,
+                    connectionUrl: process.env.CHURCH_SHADOW_DATABASE_URL.replace(
+                        "church_shadow",
+                        name.toLowerCase()
+                    ),
+                    churchDomain: [
+                        {
+                            domain:
+                                process.env.NODE_ENV == "localdev"
+                                    ? `${name.toLowerCase()}.local.churchsoln.com`
+                                    : `${name.toLowerCase()}.churchsoln.com`,
+                        },
+                    ],
+                },
+                { include: { model: commonDb.churchDomain, as: "churchDomain" } }
+            );
+            let permissionId;
+            if (params.subscriptionPlanId == SUBSCRIPTION_PLAN_ID.CUSTOM) {
+                permissionId = params.permissionId;
+            } else {
+                let subscriptionPlan = await commonDb.subscriptionPlan.findOne({
+                    where: { id: params.subscriptionPlanId },
+                    attributes: commonDb.subscriptionPlan.selectedFields,
+                    include: {
+                        model: commonDb.subscriptionPlanPermission,
+                        as: "subscriptionPlanPermission",
+                        attributes: commonDb.subscriptionPlanPermission.selectedFields,
+                        required: false,
+                    },
+                });
+                subscriptionPlan = subscriptionPlan.get({ plain: true });
+                permissionId = subscriptionPlan.subscriptionPlanPermission.map(
+                    (x) => x.permissionId
+                );
+            }
+            await commonDb.churchPermission.bulkCreate(
+                permissionId.map((x) => ({
+                    churchId: churchData.id,
+                    permissionId: x,
+                }))
+            );
+            const jobs = [
+                {
+                    queue: QUEUES.DB_CREATE,
+                    data: { churchId: churchData.id, name: name.toLowerCase() },
+                },
+                {
+                    queue: QUEUES.MIGRATION,
+                    data: { churchId: churchData.id },
+                },
+                {
+                    queue: QUEUES.SEED,
+                    data: { churchId: churchData.id },
+                },
+            ];
+            const jobData = await masterQueue.add(QUEUES.MASTER, jobs);
+            masterQueueEvents.on("completed", async (event) => {
+                if (event.jobId === jobData.id) {
+                    const churchDb = await churchManager.getChurchDbConnectionById(churchData.id);
+                    const member = await churchDb.member.create({ 
+                        ...churchAdminDetails,
+                        envNumber: utils.generateCode(CODE_LENGTH.ENV_NUMBER) 
+                    })
+                    await churchDb.user.create({
+                        ...churchAdminDetails,
+                        status: true,
+                        roleId: ROLES.CHURCH_ADMIN,
+                        churchId: churchData.id,
+                        memberId: member.id
+                    });
+                    await churchDb.church.create(params)
+                    console.log(`Church onboarding completed for church: ${name}`);
+                }
+            });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.churchCreated };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+
+    async allChurchService(params) {
+        try {
+            const { search = null } = params;
+            const searchCondition = !!search ? { name: { [Op.like]: `%${search}%` } } : {};
+            const data = await commonDb.church.findAll({
+                where: { ...searchCondition },
+                attributes: commonDb.church.selectedFields,
+                include: {
+                    model: commonDb.subscriptionPlan,
+                    as: "subscriptionPlan",
+                    attributes: commonDb.subscriptionPlan.selectedFields,
+                    required: false,
+                },
+            });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+        } catch (err) {
+            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+        }
+    }
+
+    async churchByIdService(params) {
+        try {
+            const { id } = params;
+            const data = await commonDb.church.findOne({
+                where: { status: true, id },
+                attributes: commonDb.church.selectedFields,
+                raw: true,
+            });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+        } catch (err) {
+            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+        }
+    }
+
+    async updateChurchByIdService(params) {
+        try {
+            const { id, ...restParams } = params;
+            if(restParams.subscriptionPlanId) {
+                const churchData = await commonDb.church.findOne({
+                    where: { id },
+                    attributes: commonDb.church.selectedFields,
+                    raw: true,
+                });
+                if (churchData.expiresAt) {
+                    const expiresAt = new Date(churchData.expiresAt);
+                    expiresAt.setDate(expiresAt.getDate() + params.validity);
+                    restParams.expiresAt = expiresAt;
+                } else {
+                    const expiresAt = new Date();
+                    expiresAt.setDate(expiresAt.getDate() + params.validity);
+                    restParams.expiresAt = expiresAt;
+                }
+                restParams.subscribedAt = new Date();
+                await commonDb.churchPermission.destroy({
+                    where: { churchId: id },
+                });
+                let permissionId;
+                if (params.subscriptionPlanId == SUBSCRIPTION_PLAN_ID.CUSTOM) {
+                    permissionId = params.permissionId;
+                } else {
+                    let subscriptionPlan = await commonDb.subscriptionPlan.findOne({
+                        where: { id: params.subscriptionPlanId },
+                        attributes: commonDb.subscriptionPlan.selectedFields,
+                        include: {
+                            model: commonDb.subscriptionPlanPermission,
+                            as: "subscriptionPlanPermission",
+                            attributes: commonDb.subscriptionPlanPermission.selectedFields,
+                            required: false,
+                        },
+                    });
+                    subscriptionPlan = subscriptionPlan.get({ plain: true });
+                    permissionId = subscriptionPlan.subscriptionPlanPermission.map(
+                        (x) => x.permissionId
+                    );
+                }
+                await commonDb.churchPermission.bulkCreate(
+                    permissionId.map((x) => ({
+                        churchId: id,
+                        permissionId: x,
+                    }))
+                );
+            }
+            await commonDb.church.update(restParams, { where: { id } });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.churchUpdated };
+        } catch (err) {
+            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+        }
+    }
+
+    async addChurchPermissionService(params) {
+        try {
+            const { churchId, permissionId = [] } = params;
+            const existingChurch = await commonDb.church.findOne({
+                where: { id: churchId },
+                raw: true,
+            });
+            if (!existingChurch) {
+                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidChurchId };
+            }
+            const existingPermission = await commonDb.permission.findAll({
+                where: { id: permissionId },
+                raw: true,
+            });
+            if (existingPermission.length !== permissionId.length) {
+                return {
+                    code: errorCodes.HTTP_BAD_REQUEST,
+                    message: errorMsgs.invalidPermissionId,
+                };
+            }
+            const existingChurchPermission = await commonDb.churchPermission.findAll({
+                where: { churchId, permissionId },
+                raw: true,
+            });
+            const excludedPermissions = permissionId.filter(
+                (x) => !existingChurchPermission.map((y) => y.permissionId).includes(x)
+            );
+            if(excludedPermissions.length) {
+                const queries = excludedPermissions.map((x) => commonDb.churchPermission.create({ churchId, permissionId: x }))
+                await Promise.all(queries);
+            }
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+        } catch (err) {
+            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+        }
+    }
+    async getChurchPermissionService(params) {
+        try {
+            const { churchId } = params;
+            const data = await commonDb.churchPermission.findAll({
+                where: { churchId },
+                attributes: commonDb.churchPermission.selectedFields,
+                include: {
+                    model: commonDb.permission,
+                    as: "permission",
+                    attributes: commonDb.permission.selectedFields,
+                },
+            });
+            const response = data.map((x) => {
+                const permission = x.get({ plain: true });
+                permission.permissionId = permission.permission.id;
+                permission.permission = permission.permission.name;
+                return permission;
+            });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data: response };
+        } catch (err) {
+            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+        }
+    }
+    async deleteChurchPermissionByIdService(params) {
+        try {
+            const { id, churchId } = params;
+            const churchPermissionDetails = await commonDb.churchPermission.findOne({
+                where: { id, churchId },
+                attributes: commonDb.churchPermission.selectedFields,
+                raw: true,
+            });
+            if (!churchPermissionDetails)
+                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidId };
+            await commonDb.churchPermission.destroy({ where: { id, churchId } });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+        } catch (err) {
+            return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+        }
+    }
+    
+    async login(params) {
+        try {
+            const { username, password } = params;
+            let userData = await commonDb.user.findOne({
+                where: { username },
+                attributes: commonDb.user.selectedFields,
+            });
+            userData = userData?.get({ plain: true });
+            if (!userData || !userData?.status)
+                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidCredentials };
+            if (!userData?.password)
+                return { code: errorCodes.HTTP_FORBIDDEN, message: errorMsgs.passwordNotSet };
+            const isPassowordCorrect = await bcrypt.compare(password, userData.password);
+            if (!isPassowordCorrect)
+                return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidCredentials };
+            const encryptedData = {
+                id: cryptr.encrypt(userData.id),
+                username: cryptr.encrypt(userData.username),
+                email: cryptr.encrypt(userData.email),
+            };
+            const token = jwt.sign({ ...encryptedData }, process.env.JWT_SECRET, {
+                expiresIn: AUTH_DATA.SESSION_EXPIRY,
+            });
+            return {
+                code: errorCodes.HTTP_OK,
+                message: errorMsgs.loggedIn,
+                data: { token },
+            };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+}
+module.exports = new ChurchService();

package/services/index.js

@@ -1,6 +1,6 @@
-module.exports = {
-    churchService: require("./church"),
-    migrationService: require("./migration"),
-    seedService: require("./seed"),
-    masterService: require("./master"),
-};
+module.exports = {
+    churchService: require("./church"),
+    migrationService: require("./migration"),
+    seedService: require("./seed"),
+    masterService: require("./master"),
+};