@churchsoln/dbms 1.0.47 → 1.0.49

package/services/migration.js

@@ -1,30 +1,30 @@
-const errorCodes = require("../config/errorCodes");
-const errorMsgs = require("../config/errorMsgs");
-const { migrationsQueue } = require("../queues");
-const commonDb = require("../models/common");
-const { QUEUES } = require("../constants");
-class MigrationService {
-    async migrateAllChurchModels() {
-        try {
-            await migrationsQueue.add(QUEUES.MIGRATION, {});
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.migrationInitiated };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-
-    async migrateModelsByChurchId(churchId) {
-        try {
-            const churchExists = await commonDb.church.findOne({
-                where: { id: churchId },
-                raw: true,
-            });
-            if (!churchExists) throw new Error(`Church with id ${churchId} does not exist`);
-            await migrationsQueue.add(QUEUES.MIGRATION, { churchId });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.migrationInitiated };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-}
-module.exports = new MigrationService();
+const errorCodes = require("../config/errorCodes");
+const errorMsgs = require("../config/errorMsgs");
+const { migrationsQueue } = require("../queues");
+const commonDb = require("../models/common");
+const { QUEUES } = require("../constants");
+class MigrationService {
+    async migrateAllChurchModels() {
+        try {
+            await migrationsQueue.add(QUEUES.MIGRATION, {});
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.migrationInitiated };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+
+    async migrateModelsByChurchId(churchId) {
+        try {
+            const churchExists = await commonDb.church.findOne({
+                where: { id: churchId },
+                raw: true,
+            });
+            if (!churchExists) throw new Error(`Church with id ${churchId} does not exist`);
+            await migrationsQueue.add(QUEUES.MIGRATION, { churchId });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.migrationInitiated };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+}
+module.exports = new MigrationService();

package/services/seed.js

@@ -1,39 +1,39 @@
-const errorCodes = require("../config/errorCodes");
-const errorMsgs = require("../config/errorMsgs");
-const { seedQueue } = require("../queues");
-const commonDb = require("../models/common");
-const { QUEUES } = require("../constants");
-class SeedService {
-    async seedCommonDb() {
-        try {
-            await seedQueue.add(QUEUES.SEED, { isCommonDb: true });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.seedInitiated };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-
-    async seedAllChurch() {
-        try {
-            await seedQueue.add(QUEUES.SEED, {});
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.seedInitiated };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-
-    async seedByChurchId(churchId) {
-        try {
-            const churchExists = await commonDb.church.findOne({
-                where: { id: churchId },
-                raw: true,
-            });
-            if (!churchExists) throw new Error(`Church with id ${churchId} does not exist`);
-            await seedQueue.add(QUEUES.SEED, { churchId });
-            return { code: errorCodes.HTTP_OK, message: errorMsgs.seedInitiated };
-        } catch (err) {
-            throw new Error(err.message);
-        }
-    }
-}
-module.exports = new SeedService();
+const errorCodes = require("../config/errorCodes");
+const errorMsgs = require("../config/errorMsgs");
+const { seedQueue } = require("../queues");
+const commonDb = require("../models/common");
+const { QUEUES } = require("../constants");
+class SeedService {
+    async seedCommonDb() {
+        try {
+            await seedQueue.add(QUEUES.SEED, { isCommonDb: true });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.seedInitiated };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+
+    async seedAllChurch() {
+        try {
+            await seedQueue.add(QUEUES.SEED, {});
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.seedInitiated };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+
+    async seedByChurchId(churchId) {
+        try {
+            const churchExists = await commonDb.church.findOne({
+                where: { id: churchId },
+                raw: true,
+            });
+            if (!churchExists) throw new Error(`Church with id ${churchId} does not exist`);
+            await seedQueue.add(QUEUES.SEED, { churchId });
+            return { code: errorCodes.HTTP_OK, message: errorMsgs.seedInitiated };
+        } catch (err) {
+            throw new Error(err.message);
+        }
+    }
+}
+module.exports = new SeedService();

package/utils/churchManager.js

@@ -1,99 +1,99 @@
-const { getDbConnection } = require("../models/church");
-const commonDb = require("../models/common");
-class ChurchManager {
-  churchClients = new Map();
-  intervalId = null;
-  constructor() {}
-
-  async getCommonDbConnection() {
-    return commonDb;
-  }
-  async getChurchDbConnectionById(churchId) {
-    try {
-      if (this.churchClients.has(churchId)) {
-        const clientData = this.churchClients.get(churchId);
-        clientData.lastAccessed = Date.now();
-        return clientData.dbConnection;
-      } else {
-        if (!this.intervalId) {
-          this.startCleanupTask();
-        }
-        const churchData = await commonDb.church.findOne({
-          where: { id: churchId },
-          attributes: commonDb.church.selectedFields,
-          raw: true,
-        });
-        if (!churchData) {
-          throw new Error(`Church with id ${churchId} not found`);
-        }
-        const { connectionUrl } = churchData;
-        const dbConnection = getDbConnection(connectionUrl);
-        this.churchClients.set(churchId, {
-          dbConnection,
-          lastAccessed: Date.now(),
-        });
-        return dbConnection;
-      }
-    } catch (error) {
-      console.error("Error getting church client:", error.message);
-      throw new Error(error.message);
-    }
-  }
-
-  async getChurchDbConnectionByDomain(domain) {
-    try {
-      const churchData = await commonDb.churchDomain.findOne({
-        where: { domain },
-        attributes: commonDb.churchDomain.selectedFields,
-        raw: true,
-      });
-      if (!churchData) {
-        throw new Error(`Church with domain ${domain} not found`);
-      }
-      const { churchId } = churchData;
-      return this.getChurchDbConnectionById(churchId);
-    } catch (error) {
-      console.error("Error getting church client:", error.message);
-      throw new Error(error.message);
-    }
-  }
-
-  async getChurchIdByDomain(domain) {
-    try {
-      const churchData = await commonDb.churchDomain.findOne({
-        where: { domain },
-        attributes: commonDb.churchDomain.selectedFields,
-        raw: true,
-      });
-      if (!churchData) {
-        throw new Error(`Church with domain ${domain} not found`);
-      }
-      return churchData.churchId;
-    } catch (error) {
-      console.error("Error getting church id:", error.message);
-      throw new Error(error.message);
-    }
-  }
-
-  async disconnectInactiveConnections() {
-    const now = Date.now();
-    const timeout = 30 * 60 * 1000;
-    for (const [churchId, clientData] of this.churchClients.entries()) {
-      if (now - clientData.lastAccessed > timeout) {
-        const db = await clientData.dbConnection;
-        console.log(
-          `Disconnecting inactive connection for churchId: ${churchId}`
-        );
-        await db.sequelize.close();
-        this.churchClients.delete(churchId);
-      }
-    }
-  }
-
-  startCleanupTask() {
-    this.intervalId = setInterval(() => {
-      this.disconnectInactiveConnections();
-    }, 30 * 60 * 1000);
-  }
-}
+const { getDbConnection } = require("../models/church");
+const commonDb = require("../models/common");
+class ChurchManager {
+  churchClients = new Map();
+  intervalId = null;
+  constructor() {}
+
+  async getCommonDbConnection() {
+    return commonDb;
+  }
+  async getChurchDbConnectionById(churchId) {
+    try {
+      if (this.churchClients.has(churchId)) {
+        const clientData = this.churchClients.get(churchId);
+        clientData.lastAccessed = Date.now();
+        return clientData.dbConnection;
+      } else {
+        if (!this.intervalId) {
+          this.startCleanupTask();
+        }
+        const churchData = await commonDb.church.findOne({
+          where: { id: churchId },
+          attributes: commonDb.church.selectedFields,
+          raw: true,
+        });
+        if (!churchData) {
+          throw new Error(`Church with id ${churchId} not found`);
+        }
+        const { connectionUrl } = churchData;
+        const dbConnection = getDbConnection(connectionUrl);
+        this.churchClients.set(churchId, {
+          dbConnection,
+          lastAccessed: Date.now(),
+        });
+        return dbConnection;
+      }
+    } catch (error) {
+      console.error("Error getting church client:", error.message);
+      throw new Error(error.message);
+    }
+  }
+
+  async getChurchDbConnectionByDomain(domain) {
+    try {
+      const churchData = await commonDb.churchDomain.findOne({
+        where: { domain },
+        attributes: commonDb.churchDomain.selectedFields,
+        raw: true,
+      });
+      if (!churchData) {
+        throw new Error(`Church with domain ${domain} not found`);
+      }
+      const { churchId } = churchData;
+      return this.getChurchDbConnectionById(churchId);
+    } catch (error) {
+      console.error("Error getting church client:", error.message);
+      throw new Error(error.message);
+    }
+  }
+
+  async getChurchIdByDomain(domain) {
+    try {
+      const churchData = await commonDb.churchDomain.findOne({
+        where: { domain },
+        attributes: commonDb.churchDomain.selectedFields,
+        raw: true,
+      });
+      if (!churchData) {
+        throw new Error(`Church with domain ${domain} not found`);
+      }
+      return churchData.churchId;
+    } catch (error) {
+      console.error("Error getting church id:", error.message);
+      throw new Error(error.message);
+    }
+  }
+
+  async disconnectInactiveConnections() {
+    const now = Date.now();
+    const timeout = 30 * 60 * 1000;
+    for (const [churchId, clientData] of this.churchClients.entries()) {
+      if (now - clientData.lastAccessed > timeout) {
+        const db = await clientData.dbConnection;
+        console.log(
+          `Disconnecting inactive connection for churchId: ${churchId}`
+        );
+        await db.sequelize.close();
+        this.churchClients.delete(churchId);
+      }
+    }
+  }
+
+  startCleanupTask() {
+    this.intervalId = setInterval(() => {
+      this.disconnectInactiveConnections();
+    }, 30 * 60 * 1000);
+  }
+}
 module.exports = new ChurchManager();

package/utils/crypto.js

@@ -1,40 +1,40 @@
-const CryptoJS = require("crypto-js");
-
-const iterationCount = 1000;
-const keySize = 128;
-const passPhrase = process.env.AES_PASSPHRASE;
-
-const salt = process.env.AES_SALT;
-const iv = process.env.AES_FOUR;
-
-const AesUtil = function (keySize, iterationCount) {
-    this.keySize = keySize / 32;
-    this.iterationCount = iterationCount;
-};
-
-AesUtil.prototype.generateKey = function () {
-    const key = CryptoJS.PBKDF2(passPhrase, CryptoJS.enc.Hex.parse(salt), {
-        keySize: this.keySize,
-        iterations: this.iterationCount,
-    });
-    return key;
-};
-
-AesUtil.prototype.encrypt = function (plainText) {
-    const key = this.generateKey();
-    const encrypted = CryptoJS.AES.encrypt(String(plainText), key, {
-        iv: CryptoJS.enc.Hex.parse(iv),
-    });
-    return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
-};
-
-AesUtil.prototype.decrypt = function (cipherText) {
-    const key = this.generateKey();
-    const cipherParams = CryptoJS.lib.CipherParams.create({
-        ciphertext: CryptoJS.enc.Base64.parse(cipherText),
-    });
-    const decrypted = CryptoJS.AES.decrypt(cipherParams, key, { iv: CryptoJS.enc.Hex.parse(iv) });
-    return decrypted.toString(CryptoJS.enc.Utf8);
-};
-
-module.exports = new AesUtil(keySize, iterationCount);
+const CryptoJS = require("crypto-js");
+
+const iterationCount = 1000;
+const keySize = 128;
+const passPhrase = process.env.AES_PASSPHRASE;
+
+const salt = process.env.AES_SALT;
+const iv = process.env.AES_FOUR;
+
+const AesUtil = function (keySize, iterationCount) {
+    this.keySize = keySize / 32;
+    this.iterationCount = iterationCount;
+};
+
+AesUtil.prototype.generateKey = function () {
+    const key = CryptoJS.PBKDF2(passPhrase, CryptoJS.enc.Hex.parse(salt), {
+        keySize: this.keySize,
+        iterations: this.iterationCount,
+    });
+    return key;
+};
+
+AesUtil.prototype.encrypt = function (plainText) {
+    const key = this.generateKey();
+    const encrypted = CryptoJS.AES.encrypt(String(plainText), key, {
+        iv: CryptoJS.enc.Hex.parse(iv),
+    });
+    return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
+};
+
+AesUtil.prototype.decrypt = function (cipherText) {
+    const key = this.generateKey();
+    const cipherParams = CryptoJS.lib.CipherParams.create({
+        ciphertext: CryptoJS.enc.Base64.parse(cipherText),
+    });
+    const decrypted = CryptoJS.AES.decrypt(cipherParams, key, { iv: CryptoJS.enc.Hex.parse(iv) });
+    return decrypted.toString(CryptoJS.enc.Utf8);
+};
+
+module.exports = new AesUtil(keySize, iterationCount);

package/utils/docUpload.js

@@ -1,51 +1,51 @@
-const multer = require("multer");
-const path = require("path");
-const response = require("./response");
-const errorCodes = require("../config/errorCodes");
-const docUpload = async (req, res, next) => {
-    const storage = multer.diskStorage({
-        destination: function (req, file, cb) {
-            let file_folder = "documents";
-            if (file.mimetype.includes("image")) file_folder = "images";
-            else if (file.mimetype.includes("video")) file_folder = "videos";
-            else file_folder = "documents";
-            cb(null, `/app/uploads/${file_folder}`);
-        },
-        filename: function (req, file, cb) {
-            const filename =
-                file.fieldname +
-                "-" +
-                Date.now() +
-                path.extname(file.originalname).toLocaleLowerCase();
-            cb(null, filename);
-        },
-    });
-    const filter = (req, res, file, cb) => {
-        if (
-            file.mimetype.includes("pdf") ||
-            file.mimetype.includes("image") ||
-            file.mimetype.includes("video")
-        ) {
-            cb(null, true);
-        } else {
-            return cb(new Error("Only images/pdf/videos are allowed"));
-        }
-    };
-    req.files = {};
-    multer({
-        storage,
-        fileFilter: (req, file, cb) => filter(req, res, file, cb),
-        limits: { fileSize: 20 * 1024 * 1024 },
-    }).any()(req, res, (err) => {
-        console.log(err)
-        if (err)
-            response.invalid(
-                req,
-                res,
-                errorCodes.HTTP_BAD_REQUEST,
-                "Only images/videos under 20 MB each are permitted."
-            );
-        else next();
-    });
-};
-module.exports = docUpload;
+const multer = require("multer");
+const path = require("path");
+const response = require("./response");
+const errorCodes = require("../config/errorCodes");
+const docUpload = async (req, res, next) => {
+    const storage = multer.diskStorage({
+        destination: function (req, file, cb) {
+            let file_folder = "documents";
+            if (file.mimetype.includes("image")) file_folder = "images";
+            else if (file.mimetype.includes("video")) file_folder = "videos";
+            else file_folder = "documents";
+            cb(null, `/app/uploads/${file_folder}`);
+        },
+        filename: function (req, file, cb) {
+            const filename =
+                file.fieldname +
+                "-" +
+                Date.now() +
+                path.extname(file.originalname).toLocaleLowerCase();
+            cb(null, filename);
+        },
+    });
+    const filter = (req, res, file, cb) => {
+        if (
+            file.mimetype.includes("pdf") ||
+            file.mimetype.includes("image") ||
+            file.mimetype.includes("video")
+        ) {
+            cb(null, true);
+        } else {
+            return cb(new Error("Only images/pdf/videos are allowed"));
+        }
+    };
+    req.files = {};
+    multer({
+        storage,
+        fileFilter: (req, file, cb) => filter(req, res, file, cb),
+        limits: { fileSize: 20 * 1024 * 1024 },
+    }).any()(req, res, (err) => {
+        console.log(err)
+        if (err)
+            response.invalid(
+                req,
+                res,
+                errorCodes.HTTP_BAD_REQUEST,
+                "Only images/videos under 20 MB each are permitted."
+            );
+        else next();
+    });
+};
+module.exports = docUpload;

package/utils/encryptDecrypt.js

@@ -1,26 +1,26 @@
-const errorCodes = require("../config/errorCodes");
-const errorMessages = require("../config/errorMsgs");
-const cryptr = require("./crypto");
-const canDecrypt = process.env.API_ENCRYPT == "true";
-module.exports = {
-    decryptData: async (req, res, next) => {
-        if (!canDecrypt) return next();
-        if (req.method == "GET") return next();
-        if (req.body && req.body.data) {
-            const decryptedData = cryptr.decrypt(req.body.data);
-            if (decryptedData && decryptedData.length > 0) {
-                req.body = JSON.parse(decryptedData);
-                return next();
-            } else {
-                return res
-                    .status(errorCodes.HTTP_UNPROCESSABLE_ENTITY)
-                    .json({ messge: errorMessages[errorCodes.HTTP_UNPROCESSABLE_ENTITY] });
-            }
-        }
-        next();
-    },
-    encryptData: async (data) => {
-        if (!canDecrypt) return data;
-        return data ? { data: cryptr.encrypt(JSON.stringify(data)) } : null;
-    },
-};
+const errorCodes = require("../config/errorCodes");
+const errorMessages = require("../config/errorMsgs");
+const cryptr = require("./crypto");
+const canDecrypt = process.env.API_ENCRYPT == "true";
+module.exports = {
+    decryptData: async (req, res, next) => {
+        if (!canDecrypt) return next();
+        if (req.method == "GET") return next();
+        if (req.body && req.body.data) {
+            const decryptedData = cryptr.decrypt(req.body.data);
+            if (decryptedData && decryptedData.length > 0) {
+                req.body = JSON.parse(decryptedData);
+                return next();
+            } else {
+                return res
+                    .status(errorCodes.HTTP_UNPROCESSABLE_ENTITY)
+                    .json({ messge: errorMessages[errorCodes.HTTP_UNPROCESSABLE_ENTITY] });
+            }
+        }
+        next();
+    },
+    encryptData: async (data) => {
+        if (!canDecrypt) return data;
+        return data ? { data: cryptr.encrypt(JSON.stringify(data)) } : null;
+    },
+};

package/utils/index.js

@@ -1,33 +1,33 @@
-const bcrypt = require("bcrypt");
-const response = require("./response");
-const errorCodes = require("../config/errorCodes");
-const errorMessages = require("../config/errorMsgs");
-class Utils {
-    genHash(data) {
-        let salt = bcrypt.genSaltSync(8);
-        return bcrypt.hashSync(data, salt);
-    }
-    hasRole(roles = []) {
-        return async (req, res, next) => {
-            if (!roles.includes(req.user.roleId)) {
-                return response.invalid(
-                    req,
-                    res,
-                    errorCodes.HTTP_UNAUTHORIZED,
-                    errorMessages.actionNotPermitted
-                );
-            }
-            next();
-        };
-    }
-    generateCode(length) {
-        const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-        let code = "";
-        for (let i = 0; i < length; i++) {
-            const randomIndex = Math.floor(Math.random() * characters.length);
-            code += characters[randomIndex];
-        }
-        return code;
-    }
-}
-module.exports = new Utils();
+const bcrypt = require("bcrypt");
+const response = require("./response");
+const errorCodes = require("../config/errorCodes");
+const errorMessages = require("../config/errorMsgs");
+class Utils {
+    genHash(data) {
+        let salt = bcrypt.genSaltSync(8);
+        return bcrypt.hashSync(data, salt);
+    }
+    hasRole(roles = []) {
+        return async (req, res, next) => {
+            if (!roles.includes(req.user.roleId)) {
+                return response.invalid(
+                    req,
+                    res,
+                    errorCodes.HTTP_UNAUTHORIZED,
+                    errorMessages.actionNotPermitted
+                );
+            }
+            next();
+        };
+    }
+    generateCode(length) {
+        const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        let code = "";
+        for (let i = 0; i < length; i++) {
+            const randomIndex = Math.floor(Math.random() * characters.length);
+            code += characters[randomIndex];
+        }
+        return code;
+    }
+}
+module.exports = new Utils();