@churchsoln/dbms 1.0.47 → 1.0.49

package/services/master.js

@@ -1,344 +1,344 @@
-const commonDb = require("../models/common");
-const { Op, where } = require("sequelize");
-const errorCodes = require("../config/errorCodes");
-const errorMsgs = require("../config/errorMsgs");
-class MasterService {
-  async addSubscriptionPlanService(params) {
-    try {
-      const { name } = params;
-      const alreadyExists = await commonDb.subscriptionPlan.findOne({
-        where: { name },
-        attributes: commonDb.subscriptionPlan.selectedFields,
-        raw: true,
-      });
-      if (alreadyExists)
-        return {
-          code: errorCodes.HTTP_CONFLICT,
-          message: errorMsgs.subscriptionAlreadyExists,
-        };
-      await commonDb.subscriptionPlan.create(
-        { ...params, isFree: false, isCustom: false },
-        { include: { model: commonDb.subscriptionPlanPermission, as: "subscriptionPlanPermission" } }
-      );
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async allSubscriptionPlanService(params) {
-    try {
-      const { search = null } = params;
-      const searchCondition = !!search
-        ? { name: { [Op.like]: `%${search}%` } }
-        : {};
-      let data = await commonDb.subscriptionPlan.findAll({
-        where: { status: true, ...searchCondition },
-        include: [
-          {
-            model: commonDb.subscriptionPlanPermission,
-            as: "subscriptionPlanPermission",
-            required: false,
-            attributes: commonDb.subscriptionPlanPermission.selectedFields,
-            include: {
-              model: commonDb.permission,
-              as: "permission",
-              required: false,
-              attributes: commonDb.permission.selectedFields,
-            }
-          }
-        ],
-        attributes: commonDb.subscriptionPlan.selectedFields,
-        order: [["isFree", "DESC"], ["isCustom", "ASC"]],
-      });
-      data = data.map((item) => {
-        item = item.get({ plain: true });
-        item.subscriptionPlanPermission = item.subscriptionPlanPermission.map(
-          (permission) => permission.permission
-        );
-        return item;
-      })
-      return {
-        code: errorCodes.HTTP_OK,
-        message: errorMsgs.success,
-        data,
-      };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async subscriptionPlanByIdService(params) {
-    try {
-      const { id } = params;
-      let data = await commonDb.subscriptionPlan.findOne({
-        where: { status: true, id },
-        include: [
-          {
-            model: commonDb.subscriptionPlanPermission,
-            as: "subscriptionPlanPermission",
-            required: false,
-            attributes: commonDb.subscriptionPlanPermission.selectedFields,
-            include: {
-              model: commonDb.permission,
-              as: "permission",
-              required: false,
-              attributes: commonDb.permission.selectedFields,
-            }
-          }
-        ],
-        attributes: commonDb.subscriptionPlan.selectedFields,
-      });
-      data = data.get({ plain: true });
-      data.subscriptionPlanPermission = data.subscriptionPlanPermission.map(
-        (permission) => permission.permission
-      );
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async updateSubscriptionPlanByIdService(params) {
-    try {
-      const { id, name, subscriptionPlanPermission = [], ...restData } = params;
-      const subscriptionPlanDetails = await commonDb.subscriptionPlan.findOne({
-        where: { id, status: true },
-        attributes: commonDb.subscriptionPlan.selectedFields,
-        raw: true,
-      });
-      if (!subscriptionPlanDetails)
-        return {
-          code: errorCodes.HTTP_BAD_REQUEST,
-          message: errorMsgs.invalidId,
-        };
-      const checkSubscriptionPlanExists = await commonDb.subscriptionPlan.findOne({
-        where: { id: { [Op.ne]: id }, name: { [Op.like]: `%${name}%` } },
-        raw: true,
-      });
-      if (checkSubscriptionPlanExists)
-        return {
-          code: errorCodes.HTTP_CONFLICT,
-          message: errorMsgs.subscriptionAlreadyExists,
-        };
-      await commonDb.subscriptionPlan.update(
-        { name, ...restData },
-        { where: { id } }
-      );
-      const existingSubscriptionPlanPermission = await commonDb.subscriptionPlanPermission.findAll({
-        where: { subscriptionPlanId: id },
-        attributes: commonDb.subscriptionPlanPermission.selectedFields,
-        raw: true,
-      });
-      const permissionIds = existingSubscriptionPlanPermission.map(
-        (permission) => permission.permissionId
-      );
-      const newPermissionIds = subscriptionPlanPermission.map(
-        (permission) => permission.permissionId
-      );
-      const newPermission = newPermissionIds.filter(
-        (permission) => !permissionIds.includes(permission)
-      );
-      const deletePermission = permissionIds.filter(
-        (permission) => !newPermissionIds.includes(permission)
-      );
-      if (newPermission.length) {
-        await commonDb.subscriptionPlanPermission.bulkCreate(
-          newPermission.map((permission) => ({
-            subscriptionPlanId: id,
-            permissionId: permission,
-          }))
-        );
-      }
-      if (deletePermission.length) {
-        await commonDb.subscriptionPlanPermission.destroy({
-          where: {
-            subscriptionPlanId: id,
-            permissionId: deletePermission,
-          },
-        });
-      }
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async deleteSubscriptionPlanByIdService(params) {
-    try {
-      const { id } = params;
-      await commonDb.subscriptionPlan.update(
-        { status: false },
-        { where: { id } }
-      );
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-
-  async addRoleService(params) {
-    try {
-      const { name } = params;
-      const alreadyExists = await commonDb.role.findOne({
-        where: { name },
-        attributes: commonDb.role.selectedFields,
-        raw: true,
-      });
-      if (alreadyExists)
-        return {
-          code: errorCodes.HTTP_CONFLICT,
-          message: errorMsgs.roleAlreadyExists,
-        };
-      await commonDb.role.create({ ...params });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async allRoleService(params) {
-    try {
-      const { search = null } = params;
-      const searchCondition = !!search
-        ? { name: { [Op.like]: `%${search}%` } }
-        : {};
-      const data = await commonDb.role.findAll({
-        where: { status: true, ...searchCondition },
-        attributes: commonDb.role.selectedFields,
-        raw: true,
-      });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async roleByIdService(params) {
-    try {
-      const { id } = params;
-      const data = await commonDb.role.findOne({
-        where: { status: true, id },
-        attributes: commonDb.role.selectedFields,
-        raw: true,
-      });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async updateRoleByIdService(params) {
-    try {
-      const { id, name } = params;
-      const alreadyExists = await commonDb.role.findOne({
-        where: { name, id: { [Op.ne]: id } },
-        attributes: commonDb.role.selectedFields,
-        raw: true,
-      });
-      if (alreadyExists)
-        return {
-          code: errorCodes.HTTP_CONFLICT,
-          message: errorMsgs.masterAlreadyExists,
-        };
-      await commonDb.role.update({ name }, { where: { id } });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async deleteRoleByIdService(params) {
-    try {
-      const { id } = params;
-      await commonDb.role.update({ status: false }, { where: { id } });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async addPermission(params) {
-    try {
-      const { name } = params;
-      const checkPermissionExists = await commonDb.permission.findOne({
-        where: { name: { [Op.like]: `%${name}%` } },
-        raw: true,
-      });
-      if (checkPermissionExists)
-        return {
-          code: errorCodes.HTTP_CONFLICT,
-          message: errorMsgs.permissionExists,
-        };
-      const response = await commonDb.permission.create({ name });
-      const data = response.get({ plain: true });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async getPermissionService() {
-    try {
-      const data = await commonDb.permission.findAll({
-        where: { status: true },
-        attributes: commonDb.permission.selectedFields,
-        raw: true,
-      });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async getPermissionByIdService(params) {
-    try {
-      const { id } = params;
-      const data = await commonDb.permission.findOne({
-        where: { id, status: true },
-        attributes: commonDb.permission.selectedFields,
-        raw: true,
-      });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async updatePermissionByIdService(params) {
-    try {
-      const { id, name } = params;
-      const permissionDetails = await commonDb.permission.findOne({
-        where: { id, status: true },
-        attributes: commonDb.permission.selectedFields,
-        raw: true,
-      });
-      if (!permissionDetails)
-        return {
-          code: errorCodes.HTTP_BAD_REQUEST,
-          message: errorMsgs.invalidId,
-        };
-      const checkPermissionExists = await commonDb.permission.findOne({
-        where: { id: { [Op.ne]: id }, name: { [Op.like]: `%${name}%` } },
-        raw: true,
-      });
-      if (checkPermissionExists)
-        return {
-          code: errorCodes.HTTP_CONFLICT,
-          message: errorMsgs.permissionExists,
-        };
-      await commonDb.permission.update({ name }, { where: { id } });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.updated };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-  async deletePermissionByIdService(params) {
-    try {
-      const { id } = params;
-      const permissionDetails = await commonDb.permission.findOne({
-        where: { id, status: true },
-        attributes: commonDb.permission.selectedFields,
-        raw: true,
-      });
-      if (!permissionDetails)
-        return {
-          code: errorCodes.HTTP_BAD_REQUEST,
-          message: errorMsgs.invalidId,
-        };
-      await commonDb.permission.update({ status: false }, { where: { id } });
-      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
-    } catch (err) {
-      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
-    }
-  }
-}
-module.exports = new MasterService();
+const commonDb = require("../models/common");
+const { Op, where } = require("sequelize");
+const errorCodes = require("../config/errorCodes");
+const errorMsgs = require("../config/errorMsgs");
+class MasterService {
+  async addSubscriptionPlanService(params) {
+    try {
+      const { name } = params;
+      const alreadyExists = await commonDb.subscriptionPlan.findOne({
+        where: { name },
+        attributes: commonDb.subscriptionPlan.selectedFields,
+        raw: true,
+      });
+      if (alreadyExists)
+        return {
+          code: errorCodes.HTTP_CONFLICT,
+          message: errorMsgs.subscriptionAlreadyExists,
+        };
+      await commonDb.subscriptionPlan.create(
+        { ...params, isFree: false, isCustom: false },
+        { include: { model: commonDb.subscriptionPlanPermission, as: "subscriptionPlanPermission" } }
+      );
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async allSubscriptionPlanService(params) {
+    try {
+      const { search = null } = params;
+      const searchCondition = !!search
+        ? { name: { [Op.like]: `%${search}%` } }
+        : {};
+      let data = await commonDb.subscriptionPlan.findAll({
+        where: { status: true, ...searchCondition },
+        include: [
+          {
+            model: commonDb.subscriptionPlanPermission,
+            as: "subscriptionPlanPermission",
+            required: false,
+            attributes: commonDb.subscriptionPlanPermission.selectedFields,
+            include: {
+              model: commonDb.permission,
+              as: "permission",
+              required: false,
+              attributes: commonDb.permission.selectedFields,
+            }
+          }
+        ],
+        attributes: commonDb.subscriptionPlan.selectedFields,
+        order: [["isFree", "DESC"], ["isCustom", "ASC"]],
+      });
+      data = data.map((item) => {
+        item = item.get({ plain: true });
+        item.subscriptionPlanPermission = item.subscriptionPlanPermission.map(
+          (permission) => permission.permission
+        );
+        return item;
+      })
+      return {
+        code: errorCodes.HTTP_OK,
+        message: errorMsgs.success,
+        data,
+      };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async subscriptionPlanByIdService(params) {
+    try {
+      const { id } = params;
+      let data = await commonDb.subscriptionPlan.findOne({
+        where: { status: true, id },
+        include: [
+          {
+            model: commonDb.subscriptionPlanPermission,
+            as: "subscriptionPlanPermission",
+            required: false,
+            attributes: commonDb.subscriptionPlanPermission.selectedFields,
+            include: {
+              model: commonDb.permission,
+              as: "permission",
+              required: false,
+              attributes: commonDb.permission.selectedFields,
+            }
+          }
+        ],
+        attributes: commonDb.subscriptionPlan.selectedFields,
+      });
+      data = data.get({ plain: true });
+      data.subscriptionPlanPermission = data.subscriptionPlanPermission.map(
+        (permission) => permission.permission
+      );
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async updateSubscriptionPlanByIdService(params) {
+    try {
+      const { id, name, subscriptionPlanPermission = [], ...restData } = params;
+      const subscriptionPlanDetails = await commonDb.subscriptionPlan.findOne({
+        where: { id, status: true },
+        attributes: commonDb.subscriptionPlan.selectedFields,
+        raw: true,
+      });
+      if (!subscriptionPlanDetails)
+        return {
+          code: errorCodes.HTTP_BAD_REQUEST,
+          message: errorMsgs.invalidId,
+        };
+      const checkSubscriptionPlanExists = await commonDb.subscriptionPlan.findOne({
+        where: { id: { [Op.ne]: id }, name: { [Op.like]: `%${name}%` } },
+        raw: true,
+      });
+      if (checkSubscriptionPlanExists)
+        return {
+          code: errorCodes.HTTP_CONFLICT,
+          message: errorMsgs.subscriptionAlreadyExists,
+        };
+      await commonDb.subscriptionPlan.update(
+        { name, ...restData },
+        { where: { id } }
+      );
+      const existingSubscriptionPlanPermission = await commonDb.subscriptionPlanPermission.findAll({
+        where: { subscriptionPlanId: id },
+        attributes: commonDb.subscriptionPlanPermission.selectedFields,
+        raw: true,
+      });
+      const permissionIds = existingSubscriptionPlanPermission.map(
+        (permission) => permission.permissionId
+      );
+      const newPermissionIds = subscriptionPlanPermission.map(
+        (permission) => permission.permissionId
+      );
+      const newPermission = newPermissionIds.filter(
+        (permission) => !permissionIds.includes(permission)
+      );
+      const deletePermission = permissionIds.filter(
+        (permission) => !newPermissionIds.includes(permission)
+      );
+      if (newPermission.length) {
+        await commonDb.subscriptionPlanPermission.bulkCreate(
+          newPermission.map((permission) => ({
+            subscriptionPlanId: id,
+            permissionId: permission,
+          }))
+        );
+      }
+      if (deletePermission.length) {
+        await commonDb.subscriptionPlanPermission.destroy({
+          where: {
+            subscriptionPlanId: id,
+            permissionId: deletePermission,
+          },
+        });
+      }
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async deleteSubscriptionPlanByIdService(params) {
+    try {
+      const { id } = params;
+      await commonDb.subscriptionPlan.update(
+        { status: false },
+        { where: { id } }
+      );
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+
+  async addRoleService(params) {
+    try {
+      const { name } = params;
+      const alreadyExists = await commonDb.role.findOne({
+        where: { name },
+        attributes: commonDb.role.selectedFields,
+        raw: true,
+      });
+      if (alreadyExists)
+        return {
+          code: errorCodes.HTTP_CONFLICT,
+          message: errorMsgs.roleAlreadyExists,
+        };
+      await commonDb.role.create({ ...params });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async allRoleService(params) {
+    try {
+      const { search = null } = params;
+      const searchCondition = !!search
+        ? { name: { [Op.like]: `%${search}%` } }
+        : {};
+      const data = await commonDb.role.findAll({
+        where: { status: true, ...searchCondition },
+        attributes: commonDb.role.selectedFields,
+        raw: true,
+      });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async roleByIdService(params) {
+    try {
+      const { id } = params;
+      const data = await commonDb.role.findOne({
+        where: { status: true, id },
+        attributes: commonDb.role.selectedFields,
+        raw: true,
+      });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async updateRoleByIdService(params) {
+    try {
+      const { id, name } = params;
+      const alreadyExists = await commonDb.role.findOne({
+        where: { name, id: { [Op.ne]: id } },
+        attributes: commonDb.role.selectedFields,
+        raw: true,
+      });
+      if (alreadyExists)
+        return {
+          code: errorCodes.HTTP_CONFLICT,
+          message: errorMsgs.masterAlreadyExists,
+        };
+      await commonDb.role.update({ name }, { where: { id } });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async deleteRoleByIdService(params) {
+    try {
+      const { id } = params;
+      await commonDb.role.update({ status: false }, { where: { id } });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async addPermission(params) {
+    try {
+      const { name } = params;
+      const checkPermissionExists = await commonDb.permission.findOne({
+        where: { name: { [Op.like]: `%${name}%` } },
+        raw: true,
+      });
+      if (checkPermissionExists)
+        return {
+          code: errorCodes.HTTP_CONFLICT,
+          message: errorMsgs.permissionExists,
+        };
+      const response = await commonDb.permission.create({ name });
+      const data = response.get({ plain: true });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async getPermissionService() {
+    try {
+      const data = await commonDb.permission.findAll({
+        where: { status: true },
+        attributes: commonDb.permission.selectedFields,
+        raw: true,
+      });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async getPermissionByIdService(params) {
+    try {
+      const { id } = params;
+      const data = await commonDb.permission.findOne({
+        where: { id, status: true },
+        attributes: commonDb.permission.selectedFields,
+        raw: true,
+      });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success, data };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async updatePermissionByIdService(params) {
+    try {
+      const { id, name } = params;
+      const permissionDetails = await commonDb.permission.findOne({
+        where: { id, status: true },
+        attributes: commonDb.permission.selectedFields,
+        raw: true,
+      });
+      if (!permissionDetails)
+        return {
+          code: errorCodes.HTTP_BAD_REQUEST,
+          message: errorMsgs.invalidId,
+        };
+      const checkPermissionExists = await commonDb.permission.findOne({
+        where: { id: { [Op.ne]: id }, name: { [Op.like]: `%${name}%` } },
+        raw: true,
+      });
+      if (checkPermissionExists)
+        return {
+          code: errorCodes.HTTP_CONFLICT,
+          message: errorMsgs.permissionExists,
+        };
+      await commonDb.permission.update({ name }, { where: { id } });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.updated };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+  async deletePermissionByIdService(params) {
+    try {
+      const { id } = params;
+      const permissionDetails = await commonDb.permission.findOne({
+        where: { id, status: true },
+        attributes: commonDb.permission.selectedFields,
+        raw: true,
+      });
+      if (!permissionDetails)
+        return {
+          code: errorCodes.HTTP_BAD_REQUEST,
+          message: errorMsgs.invalidId,
+        };
+      await commonDb.permission.update({ status: false }, { where: { id } });
+      return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
+    } catch (err) {
+      return { code: errorCodes.HTTP_INTERNAL_SERVER_ERROR, message: err };
+    }
+  }
+}
+module.exports = new MasterService();