@churchsoln/dbms 1.0.9 → 1.0.11

package/constants/index.js

@@ -35,4 +35,11 @@ const ONBOARD_STATUS = {
     SEED_COMPLETED: "seed_completed",
     ONBOARD_COMPLETED: "onboard_completed",
 };
-module.exports = { ROLES, TRANSFER_STATUS, QUEUES, WORKERS, AUTH_DATA, ONBOARD_STATUS };
+
+const SUBSCRIPTION_PLAN_ID = {
+    FREE_TRAIL: 1,
+    BASIC: 2,
+    PREMIUM: 3,
+    CUSTOM: 4
+}
+module.exports = { ROLES, TRANSFER_STATUS, QUEUES, WORKERS, AUTH_DATA, ONBOARD_STATUS, SUBSCRIPTION_PLAN_ID };

package/migrations/church/20240918170624-create-membershipType.js

@@ -0,0 +1,24 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "MembershipType",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    name: { type: DataTypes.STRING },
+                    isDefault: { type: DataTypes.BOOLEAN, defaultValue: false },
+                    status: { type: DataTypes.BOOLEAN, defaultValue: true },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                }
+            )
+    }
+}

package/migrations/church/20240918170625-update-user.js

@@ -0,0 +1,24 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        return Promise.all([
+            queryInterface.addColumn("User", "membershipTypeId", {
+                type: DataTypes.INTEGER,
+            }).then(() => {
+                queryInterface.addConstraint("User", {
+                    fields: ["membershipTypeId"],
+                    type: "foreign key",
+                    name: "user_membershipTypeId_fk",
+                    references: {
+                        table: "MembershipType",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                });
+            })
+        ]);
+    },
+    down: async (queryInterface) => {},
+};

package/migrations/common/20240918170625-update-permission.js

@@ -0,0 +1,17 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        return Promise.all([
+            queryInterface.addColumn("Permission", "isSubscription", {
+                type: DataTypes.BOOLEAN,
+                defaultValue: false,
+            }),
+            queryInterface.addColumn("Permission", "cost", {
+                type: DataTypes.FLOAT,
+                defaultValue: 0,
+            }),
+        ]);
+    },
+    down: async (queryInterface) => {},
+};

package/migrations/common/20240918170626-update-subscriptionPlan.js

@@ -0,0 +1,20 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        return Promise.all([
+            queryInterface.removeColumn("SubscriptionPlan", "planCost"),
+            queryInterface.removeColumn("SubscriptionPlan", "validity"),
+            queryInterface.addColumn("SubscriptionPlan", "isFree", {
+                type: DataTypes.BOOLEAN,
+                defaultValue: false,
+            }),
+            queryInterface.addColumn("SubscriptionPlan", "isCustom", {
+                type: DataTypes.BOOLEAN,
+                defaultValue: false,
+            }),
+        ]);
+    },
+
+    down: async (queryInterface) => {},
+};

package/migrations/common/20240918170627-create-subscriptionPlanPermission.js

@@ -0,0 +1,53 @@
+"use strict";
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        await queryInterface
+            .createTable(
+                "SubscriptionPlanPermission",
+                {
+                    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+                    subscriptionPlanId: { type: DataTypes.INTEGER },
+                    permissionId: { type: DataTypes.INTEGER },
+                    status: { type: DataTypes.BOOLEAN, defaultValue: true },
+                    createdAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                    updatedAt: {
+                        type: DataTypes.DATE,
+                        defaultValue: DataTypes.literal("CURRENT_TIMESTAMP"),
+                    },
+                },
+                { timestamps: false }
+            )
+            .then(() => 
+                queryInterface.addConstraint("SubscriptionPlanPermission", {
+                    fields: ["subscriptionPlanId"],
+                    type: "foreign key",
+                    name: "SPlan_SPlanPermission_Fkey",
+                    references: {
+                        table: "SubscriptionPlan",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            )
+            .then(() =>
+                queryInterface.addConstraint("SubscriptionPlanPermission", {
+                    fields: ["permissionId"],
+                    type: "foreign key",
+                    name: "SPlan_Permission_Fkey",
+                    references: {
+                        table: "Permission",
+                        field: "id",
+                    },
+                    onDelete: "cascade",
+                    onUpdate: "cascade",
+                })
+            );
+    },
+    down: async (queryInterface) => {
+        await queryInterface.dropTable("SubscriptionPlanPermission");
+    },
+};

package/migrations/common/20240918170628-update-church.js

@@ -0,0 +1,12 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, DataTypes) => {
+        return Promise.all([
+            queryInterface.addColumn("Church", "expiresAt", {
+                type: DataTypes.DATEONLY,
+            }),
+        ]);
+    },
+    down: async (queryInterface) => {},
+};

package/models/church/membershipType.js

@@ -0,0 +1,16 @@
+module.exports = (sequelize, DataTypes) => {
+    const membershipType = sequelize.define(
+        "MembershipType",
+        {
+            id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+            name: { type: DataTypes.STRING },
+            isDefault: { type: DataTypes.BOOLEAN, defaultValue: false },
+            status: { type: DataTypes.BOOLEAN, defaultValue: true },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    membershipType.selectedFields = ["id", "name", "isDefault", "status", "createdAt", "updatedAt"];
+    return membershipType;
+};

package/models/church/user.js

@@ -86,6 +86,12 @@ module.exports = (sequelize, DataTypes) => {
             postalCode: { type: DataTypes.STRING },
             showPostal: { type: DataTypes.BOOLEAN, defaultValue: false },
             otp: { type: DataTypes.INTEGER },
+            membershipTypeId: {
+                type: DataTypes.INTEGER,
+                set(membershipTypeId) {
+                    this.setDataValue("membershipTypeId", membershipTypeId?.id || membershipTypeId);
+                },
+            },
             isUserAuthenticated: { type: DataTypes.BOOLEAN, defaultValue: false },
             delUpdateAccess: { type: DataTypes.BOOLEAN, defaultValue: false },
             directoryVisibility: { type: DataTypes.BOOLEAN, defaultValue: false },
@@ -109,6 +115,10 @@ module.exports = (sequelize, DataTypes) => {
             as: "emergencyContactRelationship",
         });
         user.belongsTo(models.subRole, { foreignKey: "subRoleId", as: "subRole" });
+        user.belongsTo(models.membershipType, {
+            foreignKey: "membershipTypeId",
+            as: "membershipType",
+        });
     };
     user.selectedFields = [
         "id",
@@ -156,6 +166,7 @@ module.exports = (sequelize, DataTypes) => {
         "postalCode",
         "showPostal",
         "otp",
+        "membershipTypeId",
         "isUserAuthenticated",
         "delUpdateAccess",
         "directoryVisibility",
@@ -213,6 +224,7 @@ module.exports = (sequelize, DataTypes) => {
         "directoryVisibility",
         "userLoginAccess",
         "isEmailSubscribed",
+        "membershipTypeId",
         "status",
     ];
     user.listFields = [
@@ -226,6 +238,7 @@ module.exports = (sequelize, DataTypes) => {
         "lastName",
         "address",
         "isUserAuthenticated",
+        "membershipTypeId",
         "status",
     ];
     user.transferFields = [

package/models/common/church.js

@@ -13,6 +13,7 @@ module.exports = (sequelize, DataTypes) => {
             registeredAt: { type: DataTypes.DATEONLY },
             subscribedAt: { type: DataTypes.DATEONLY },
             subscriptionPlanId: { type: DataTypes.INTEGER },
+            expiresAt: { type: DataTypes.DATEONLY },
             dbCreationStatus: {
                 type: DataTypes.STRING,
                 defaultValue: ONBOARD_STATUS.DB_CREATION_IN_PROGRESS,
@@ -44,6 +45,7 @@ module.exports = (sequelize, DataTypes) => {
         "contactPerson",
         "registeredAt",
         "subscribedAt",
+        "expiresAt",
         "subscriptionPlanId",
         "dbCreationStatus",
         "migrationStatus",

package/models/common/permission.js

@@ -4,12 +4,14 @@ module.exports = (sequelize, DataTypes) => {
         {
             id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
             name: { type: DataTypes.STRING },
+            isSubscription: { type: DataTypes.BOOLEAN, defaultValue: false },
+            cost: { type: DataTypes.FLOAT, defaultValue: 0 },
             status: { type: DataTypes.BOOLEAN, defaultValue: true },
             createdAt: { type: DataTypes.DATE },
             updatedAt: { type: DataTypes.DATE },
         },
         { freezeTableName: true, timestamps: false }
     );
-    permission.selectedFields = ["id", "name", "createdAt"];
+    permission.selectedFields = ["id", "name", "isSubscription", "cost", "createdAt"];
     return permission;
 };

package/models/common/subscriptionPlan.js

@@ -8,19 +8,25 @@ module.exports = (sequelize, DataTypes) => {
                 autoIncrement: true,
             },
             name: { type: DataTypes.STRING },
-            planCost: { type: DataTypes.INTEGER },
-            validity: { type: DataTypes.INTEGER },
+            isFree: { type: DataTypes.BOOLEAN, defaultValue: false },
+            isCustom: { type: DataTypes.BOOLEAN, defaultValue: false },
             status: { type: DataTypes.BOOLEAN },
             createdAt: { type: DataTypes.DATE },
             updatedAt: { type: DataTypes.DATE },
         },
         { freezeTableName: true, timestamps: false }
     );
+    subscriptionPlan.associate = function (models) {
+        subscriptionPlan.hasMany(models.subscriptionPlanPermission, {
+            foreignKey: "subscriptionPlanId",
+            as: "subscriptionPlanPermission",
+        });
+    };
     subscriptionPlan.selectedFields = [
         "id",
         "name",
-        "planCost",
-        "validity",
+        "isFree",
+        "isCustom",
         "createdAt",
         "updatedAt",
     ];

package/models/common/subscriptionPlanPermission.js

@@ -0,0 +1,33 @@
+module.exports = (sequelize, DataTypes) => {
+    const subscriptionPlanPermission = sequelize.define(
+        "SubscriptionPlanPermission",
+        {
+            id: {
+                type: DataTypes.INTEGER,
+                primaryKey: true,
+                autoIncrement: true,
+            },
+            subscriptionPlanId: { type: DataTypes.INTEGER },
+            permissionId: { type: DataTypes.INTEGER },
+            status: { type: DataTypes.BOOLEAN },
+            createdAt: { type: DataTypes.DATE },
+            updatedAt: { type: DataTypes.DATE },
+        },
+        { freezeTableName: true, timestamps: false }
+    );
+    subscriptionPlanPermission.associate = function (models) {
+        subscriptionPlanPermission.belongsTo(models.permission, {
+            foreignKey: "permissionId",
+            as: "permission",
+        });
+    };
+    subscriptionPlanPermission.selectedFields = [
+        "id",
+        "subscriptionPlanId",
+        "permissionId",
+        "status",
+        "createdAt",
+        "updatedAt",
+    ];
+    return subscriptionPlanPermission;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@churchsoln/dbms",
-    "version": "1.0.9",
+    "version": "1.0.11",
     "main": "index.js",
     "scripts": {
         "prestart": "node db-setup.js",

package/public/swagger/church.json

@@ -51,6 +51,8 @@
                                 "phoneNumber": "1234",
                                 "contactPerson": "string",
                                 "subscriptionPlanId": 1,
+                                "validity": 30,
+                                "permissionId": [1],
                                 "churchAdminDetails": {
                                     "firstName": "Jose",
                                     "lastName": "Mathew",
@@ -153,6 +155,8 @@
                                 "phoneNumber": "1234",
                                 "contactPerson": "string",
                                 "subscriptionPlanId": 1,
+                                "validity": 30,
+                                "permissionId": [1],
                                 "status": true
                             }
                         }
@@ -336,6 +340,7 @@
                     "phoneNumber",
                     "contactPerson",
                     "subscriptionPlanId",
+                    "validity",
                     "churchAdminDetails"
                 ],
                 "type": "object",
@@ -356,6 +361,16 @@
                         "type": "integer",
                         "format": "int32"
                     },
+                    "validity": {
+                        "type": "integer",
+                        "format": "int32"
+                    },
+                    "permissionId": {
+                        "type": "array",
+                        "items": {
+                            "type": "number"
+                        }
+                    },
                     "churchAdminDetails": {
                         "type": "object",
                         "$ref": "#/components/schemas/ChurchAdminDataRequest"
@@ -367,6 +382,8 @@
                     "phoneNumber": "1234",
                     "contactPerson": "string",
                     "subscriptionPlanId": 1,
+                    "validity": 30,
+                    "permissionId": [1],
                     "churchAdminDetails": {
                         "firstName": "Jose",
                         "lastName": "Mathew",
@@ -397,6 +414,16 @@
                         "type": "integer",
                         "format": "int32"
                     },
+                    "validity": {
+                        "type": "integer",
+                        "format": "int32"
+                    },
+                    "permissionId": {
+                        "type": "array",
+                        "items": {
+                            "type": "number"
+                        }
+                    },
                     "status": {
                         "type": "boolean"
                     }
@@ -407,6 +434,8 @@
                     "phoneNumber": "1234",
                     "contactPerson": "string",
                     "subscriptionPlanId": 1,
+                    "validity": 30,
+                    "permissionId": [1],
                     "status": true
                 }
             },

package/public/swagger/master.json

@@ -44,8 +44,9 @@
                             },
                             "example": {
                                 "name": "Free",
-                                "planCost": 0,
-                                "validity": 365
+                                "subscriptionPlanPermission": [
+                                    { "permissionId": 1 }
+                                ]
                             }
                         }
                     },
@@ -137,8 +138,9 @@
                             },
                             "example": {
                                 "name": "Free",
-                                "planCost": 0,
-                                "validity": 365
+                                "subscriptionPlanPermission": [
+                                    { "permissionId": 1 }
+                                ]
                             }
                         }
                     },
@@ -785,25 +787,35 @@
             },
             "SubscriptionPlanDataRequest": {
                 "title": "SubscriptionPlanDataRequest",
-                "required": ["name", "planCost", "validity"],
+                "required": ["name", "subscriptionPlanPermission"],
                 "type": "object",
                 "properties": {
                     "name": {
                         "type": "string"
                     },
-                    "planCost": {
-                        "type": "integer",
-                        "format": "int32"
-                    },
-                    "validity": {
-                        "type": "integer",
-                        "format": "int32"
+                    "subscriptionPlanPermission": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "permissionId": {
+                                    "type": "integer",
+                                    "format": "int32"
+                                }
+                            },
+                            "example": {
+                                "permissionId": 1
+                            }
+                        }
                     }
                 },
                 "example": {
                     "name": "Free",
-                    "planCost": 0,
-                    "validity": 365
+                    "subscriptionPlanPermission": [
+                        {
+                            "permissionId": 1
+                        }
+                    ]
                 }
             },
             "AddPermissionDataRequest": {

package/seeders/church/20241005131417-membershipType.js

@@ -0,0 +1,39 @@
+"use strict";
+
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        const membershipTypes = [
+            { name: "Subscription", isDefault: true },
+        ];
+
+        for (const membershipType of membershipTypes) {
+            const existingMembershipType = await queryInterface.rawSelect(
+                "MembershipType",
+                {
+                    where: { name: membershipType.name },
+                },
+                ["id"]
+            );
+
+            if (existingMembershipType) {
+                await queryInterface.bulkUpdate(
+                    "MembershipType",
+                    { isDefault: membershipType.isDefault },
+                    { name: membershipType.name }
+                );
+            } else {
+                await queryInterface.bulkInsert("MembershipType", [membershipType], {});
+            }
+        }
+    },
+
+    down: async (queryInterface, Sequelize) => {
+        await queryInterface.bulkDelete(
+            "MembershipType",
+            {
+                name: membershipTypes.map((membershipType) => membershipType.name),
+            },
+            {}
+        );
+    },
+};

package/seeders/common/20241005123516-subscriptionPlan.js

@@ -1,18 +1,25 @@
 "use strict";
 
+const { SUBSCRIPTION_PLAN_ID } = require("../../constants");
+
 module.exports = {
     up: async (queryInterface, Sequelize) => {
         const subscriptionPlans = [
-            { name: "Premium", planCost: 100, validity: 365 },
-            { name: "Basic", planCost: 50, validity: 180 },
-            { name: "Free Trail", planCost: 0, validity: 30 },
+            { 
+                id: SUBSCRIPTION_PLAN_ID.FREE_TRAIL, 
+                name: "Free Trail", 
+                isFree: true
+            },
+            { id: SUBSCRIPTION_PLAN_ID.BASIC, name: "Basic" },
+            { id: SUBSCRIPTION_PLAN_ID.PREMIUM, name: "Premium" },
+            { id: SUBSCRIPTION_PLAN_ID.CUSTOM, name: "Custom", isCustom: true  },
         ];
 
         for (const plan of subscriptionPlans) {
             const existingPlan = await queryInterface.rawSelect(
                 "SubscriptionPlan",
                 {
-                    where: { name: plan.name },
+                    where: { id: plan.id },
                 },
                 ["id"] // Only need the 'id' to check existence
             );
@@ -20,11 +27,8 @@ module.exports = {
             if (existingPlan) {
                 await queryInterface.bulkUpdate(
                     "SubscriptionPlan",
-                    {
-                        planCost: plan.planCost, // Update fields if necessary
-                        validity: plan.validity, // Match on 'name'
-                    },
-                    { name: plan.name }
+                    { name: plan.name, isFree: plan.isFree || false, isCustom: plan.isCustom || false },
+                    { id: plan.id }
                 );
             } else {
                 // If the record doesn't exist, insert it

package/seeders/common/20241005153047-permission.js

@@ -1,29 +1,183 @@
 "use strict";
 
+const { SUBSCRIPTION_PLAN_ID } = require("../../constants");
+
 module.exports = {
     up: async (queryInterface, Sequelize) => {
         const permissions = [
-            { name: "Events & Updates", status: true },
-            { name: "Ministries at Church", status: true },
-            { name: "Gallery", status: true },
-            { name: "Banners", status: true },
-            { name: "Users", status: true },
-            { name: "User Transfers", status: true },
-            { name: "Director Board", status: true },
-            { name: "Volunteer", status: true },
-            { name: "Documents", status: true },
-            { name: "Urls", status: true },
-            { name: "Accounts", status: true },
-            { name: "Donations", status: true },
-            { name: "Transfer Type", status: true },
-            { name: "Groups", status: true },
+            { 
+                name: "Events & Updates", 
+                status: true, 
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.FREE_TRAIL,
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Ministries at Church", 
+                status: true, 
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.FREE_TRAIL,
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Gallery", 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.FREE_TRAIL,
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Banners", 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.FREE_TRAIL,
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Users", 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.FREE_TRAIL,
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ]
+            },
+            { 
+                name: "User Transfers", 
+                isSubscription: true, 
+                cost: 0.5, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ]
+            },
+            { 
+                name: "Director Board", 
+                isSubscription: true, 
+                cost: 1, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Volunteer", 
+                isSubscription: true, 
+                cost: 0.5, 
+                status: true, 
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Documents", 
+                isSubscription: true, 
+                cost: 0.5, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ]  
+            },
+            { 
+                name: "Urls", 
+                isSubscription: true, 
+                cost: 0.5, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ]  
+            },
+            { 
+                name: "Accounts", 
+                isSubscription: true, 
+                cost: 1.5, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Donations", 
+                isSubscription: true, 
+                cost: 4, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Transfer Type", 
+                isSubscription: true, 
+                cost: 0.5, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.BASIC,
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ]
+            },
+            { 
+                name: "Groups", 
+                isSubscription: true, 
+                cost: 3, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Membership Management", 
+                isSubscription: true, 
+                cost: 2, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
+            { 
+                name: "Accounts Management", 
+                isSubscription: true, 
+                cost: 2, 
+                status: true,
+                subscriptionPlanId: [
+                    SUBSCRIPTION_PLAN_ID.PREMIUM,
+                    SUBSCRIPTION_PLAN_ID.CUSTOM
+                ] 
+            },
         ];
-
-        for (const permission of permissions) {
+        for (const [index, { subscriptionPlanId, ...permission}] of permissions.entries()) {
             const existingPermission = await queryInterface.rawSelect(
                 "Permission",
                 {
-                    where: { name: permission.name },
+                    where: { id: index + 1 },
                 },
                 ["id"]
             );
@@ -31,11 +185,37 @@ module.exports = {
             if (existingPermission) {
                 await queryInterface.bulkUpdate(
                     "Permission",
-                    { status: permission.status },
-                    { name: permission.name }
+                    { 
+                        name: permission.name, 
+                        status: permission.status,  
+                        isSubscription: permission.isSubscription || false,
+                        cost: permission.cost || 0,
+                    },
+                    { id: index + 1 }
+                );
+                await queryInterface.bulkDelete(
+                    "SubscriptionPlanPermission",
+                    { permissionId: index + 1 },
+                    {}
+                );
+                await queryInterface.bulkInsert(
+                    "SubscriptionPlanPermission",
+                    subscriptionPlanId.map((planId) => ({
+                        permissionId: index + 1,
+                        subscriptionPlanId: planId,
+                    })),
+                    {}
                 );
             } else {
-                await queryInterface.bulkInsert("Permission", [permission], {});
+                await queryInterface.bulkInsert("Permission", [{ id: index + 1, ...permission }], {});
+                await queryInterface.bulkInsert(
+                    "SubscriptionPlanPermission",
+                    subscriptionPlanId.map((planId) => ({
+                        permissionId: index + 1,
+                        subscriptionPlanId: planId,
+                    })),
+                    {}
+                );
             }
         }
     },

package/services/church.js

@@ -4,7 +4,7 @@ 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 } = require("../constants");
+const { QUEUES, ROLES, AUTH_DATA, SUBSCRIPTION_PLAN_ID } = require("../constants");
 const bcrypt = require("bcrypt");
 const cryptr = require("../utils/crypto");
 const jwt = require("jsonwebtoken");
@@ -12,7 +12,7 @@ const jwt = require("jsonwebtoken");
 class ChurchService {
     async onboardChurch(params) {
         try {
-            const { name, churchAdminDetails } = params;
+            const { name, churchAdminDetails, validity } = params;
             const alreadyExists = await commonDb.church.findOne({
                 where: { name: { [Op.iLike]: name } },
                 attributes: commonDb.church.selectedFields,
@@ -23,11 +23,14 @@ class ChurchService {
                     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()
@@ -43,6 +46,31 @@ class ChurchService {
                 },
                 { 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,
@@ -117,7 +145,49 @@ class ChurchService {
         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 };
@@ -195,18 +265,6 @@ class ChurchService {
             });
             if (!churchPermissionDetails)
                 return { code: errorCodes.HTTP_BAD_REQUEST, message: errorMsgs.invalidId };
-            const churchDb = await churchManager.getChurchDbConnectionById(churchId);
-            const subRolesByChurchId = await churchDb.subRole.findAll({
-                attributes: churchDb.subRole.selectedFields,
-                raw: true,
-            });
-            const subRoleIds = subRolesByChurchId.map((x) => x.id);
-            await churchDb.subRolePermission.destroy({
-                where: {
-                    permissionId: churchPermissionDetails.permissionId,
-                    subRoleId: subRoleIds,
-                },
-            });
             await commonDb.churchPermission.destroy({ where: { id, churchId } });
             return { code: errorCodes.HTTP_OK, message: errorMsgs.success };
         } catch (err) {

package/services/master.js

@@ -16,7 +16,10 @@ class MasterService {
           code: errorCodes.HTTP_CONFLICT,
           message: errorMsgs.subscriptionAlreadyExists,
         };
-      await commonDb.subscriptionPlan.create({ ...params });
+      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 };
@@ -28,11 +31,32 @@ class MasterService {
       const searchCondition = !!search
         ? { name: { [Op.like]: `%${search}%` } }
         : {};
-      const data = await commonDb.subscriptionPlan.findAll({
+      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,
-        raw: true,
+        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,
@@ -45,11 +69,28 @@ class MasterService {
   async subscriptionPlanByIdService(params) {
     try {
       const { id } = params;
-      const data = await commonDb.subscriptionPlan.findOne({
+      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,
-        raw: true,
       });
+      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 };
@@ -57,21 +98,63 @@ class MasterService {
   }
   async updateSubscriptionPlanByIdService(params) {
     try {
-      const { id, name, ...restData } = params;
-      const alreadyExists = await commonDb.subscriptionPlan.findOne({
-        where: { name, id: { [Op.ne]: id } },
+      const { id, name, subscriptionPlanPermission = [], ...restData } = params;
+      const subscriptionPlanDetails = await commonDb.subscriptionPlan.findOne({
+        where: { id, status: true },
         attributes: commonDb.subscriptionPlan.selectedFields,
         raw: true,
       });
-      if (alreadyExists)
+      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.masterAlreadyExists,
+          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 };

package/validators/church.js

@@ -1,5 +1,7 @@
 const BaseJoi = require("joi");
 const response = require("../utils/response");
+const permission = require("../models/common/permission");
+const { SUBSCRIPTION_PLAN_ID } = require("../constants");
 const schemas = {
     onboardChurch: BaseJoi.object({
         name: BaseJoi.string()
@@ -10,6 +12,12 @@ const schemas = {
         phoneNumber: BaseJoi.string().required(),
         contactPerson: BaseJoi.string().optional().allow(null),
         subscriptionPlanId: BaseJoi.number().required(),
+        validity: BaseJoi.number().required(),
+        permissionId: BaseJoi.array().items(BaseJoi.number().required()).when("subscriptionPlanId", {
+            is: BaseJoi.number().valid(SUBSCRIPTION_PLAN_ID.CUSTOM),
+            then: BaseJoi.required(),
+            otherwise: BaseJoi.optional(),
+        }),
         churchAdminDetails: BaseJoi.object({
             firstName: BaseJoi.string().required(),
             lastName: BaseJoi.string().required(),
@@ -25,6 +33,19 @@ const schemas = {
         phoneNumber: BaseJoi.string().optional(),
         contactPerson: BaseJoi.string().optional(),
         subscriptionPlanId: BaseJoi.number().optional(),
+        validity: BaseJoi.number().when('subscriptionPlanId', {
+                is: BaseJoi.exist(),
+                then: BaseJoi.required(),
+                otherwise: BaseJoi.optional()
+            }),
+        permissionId: BaseJoi.array()
+            .items(BaseJoi.number().required())
+            .optional()
+            .when("subscriptionPlanId", {
+                is: BaseJoi.number().valid(SUBSCRIPTION_PLAN_ID.CUSTOM),
+                then: BaseJoi.required(),
+                otherwise: BaseJoi.optional(),
+            }),
         status: BaseJoi.boolean().optional(),
     }),
     addChurchPermission: BaseJoi.object({

package/validators/master.js

@@ -14,14 +14,16 @@ const schemas = {
     }),
     addSubscriptionPlan: BaseJoi.object({
         name: BaseJoi.string().required(),
-        planCost: BaseJoi.number().required(),
-        validity: BaseJoi.number().required(),
+        subscriptionPlanPermission: BaseJoi.array().items({
+            permissionId: BaseJoi.number().required(),
+        }),
     }),
     updateSubscriptionPlan: BaseJoi.object({
         id: BaseJoi.number().required(),
         name: BaseJoi.string().required(),
-        planCost: BaseJoi.number().required(),
-        validity: BaseJoi.number().required(),
+        subscriptionPlanPermission: BaseJoi.array().items({
+            permissionId: BaseJoi.number().required(),
+        }),
     }),
     addCity: BaseJoi.object({
         provinceId: BaseJoi.number().required(),