@kipicore/dbcore 1.1.295 → 1.1.297

package/dist/db/psql/index.js

@@ -66,7 +66,7 @@ const CampusCarnivalModule = require('./seeders/Data/campusCarnival');
 const TransportModule = require('./seeders/Data/transportModule');
 const GreetingModule = require('./seeders/Data/greetingModule');
 const TaskManagementModule = require('./seeders/Data/taskManagementModule');
-const UserRoleModule = require('./seeders/Data/UserRoleModule');
+// const UserRoleModule = require('./seeders/Data/UserRoleModule');
 const ReportManagementModule = require('./seeders/Data/ReportManagementModule');
 const DashboardManagementModule = require('./seeders/Data/dashboardManagementModule'); // Need to uncomment dashboard module is ready
 const CertificateManagementModule = require('./seeders/Data/certificateManagementModule'); // Need to uncomment certificate module is ready
@@ -137,7 +137,7 @@ const allModules = [
     TaskManagementModule,
     DashboardManagementModule, // Need to uncomment dashboard module is ready
     CertificateManagementModule, // Need to uncomment certificate module is ready
-    UserRoleModule,
+    // UserRoleModule,
     ReportManagementModule,
 ];
 module.exports = allModules;

package/dist/db/psql/migrations/20260226050211-delete_old_name.d.ts

@@ -0,0 +1,2 @@
+export function up(queryInterface: any): Promise<void>;
+export function down(queryInterface: any): Promise<void>;

package/dist/db/psql/migrations/20260226050211-delete_old_name.js

@@ -0,0 +1,39 @@
+'use strict';
+module.exports = {
+    async up(queryInterface) {
+        const transaction = await queryInterface.sequelize.transaction();
+        try {
+            // Update modules table
+            await queryInterface.bulkUpdate('modules', {
+                name: 'Kipi Storage',
+                updated_at: new Date(),
+                code: 'KIPI'
+            }, {
+                code: ' KIPI',
+            }, { transaction });
+            // Update module_features table
+            await queryInterface.bulkUpdate('module_features', {
+                name: 'Kipi Store Management',
+                updated_at: new Date(),
+                code: 'KIPI.STORAGE',
+            }, {
+                code: ' KIPI.STORAGE',
+            }, { transaction });
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+    },
+    async down(queryInterface) {
+        const transaction = await queryInterface.sequelize.transaction();
+        try {
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+    },
+};

package/dist/db/psql/migrations/20260226050625-delete_old_name_1.d.ts

@@ -0,0 +1,2 @@
+export function up(queryInterface: any): Promise<void>;
+export function down(queryInterface: any): Promise<void>;

package/dist/db/psql/migrations/20260226050625-delete_old_name_1.js

@@ -0,0 +1,37 @@
+'use strict';
+module.exports = {
+    async up(queryInterface) {
+        const transaction = await queryInterface.sequelize.transaction();
+        try {
+            // Update modules table
+            await queryInterface.bulkUpdate('modules', {
+                name: 'Kipi Storage',
+                updated_at: new Date(),
+            }, {
+                code: 'KIPI'
+            }, { transaction });
+            // Update module_features table
+            await queryInterface.bulkUpdate('module_features', {
+                name: 'Kipi Store Management',
+                updated_at: new Date(),
+            }, {
+                code: 'KIPI.STORAGE',
+            }, { transaction });
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+    },
+    async down(queryInterface) {
+        const transaction = await queryInterface.sequelize.transaction();
+        try {
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+    },
+};

package/dist/db/psql/migrations/20260226054826-delete_old_code.d.ts

@@ -0,0 +1,2 @@
+export function up(queryInterface: any): Promise<void>;
+export function down(queryInterface: any): Promise<void>;

package/dist/db/psql/migrations/20260226054826-delete_old_code.js

@@ -0,0 +1,43 @@
+'use strict';
+module.exports = {
+    async up(queryInterface) {
+        const transaction = await queryInterface.sequelize.transaction();
+        try {
+            // Update modules table
+            await queryInterface.bulkUpdate('modules', {
+                name: 'User Role',
+                deleted_at: new Date(),
+            }, {
+                code: 'USERROLE'
+            }, { transaction });
+            // Update module_features table
+            await queryInterface.bulkUpdate('module_features', {
+                name: 'User Role Management',
+                deleted_at: new Date(),
+            }, {
+                code: 'USERROLE.USERROLEMANAGEMENT',
+            }, { transaction });
+            await queryInterface.bulkUpdate('feature_actions', {
+                name: 'Principle',
+                deleted_at: new Date(),
+            }, {
+                code: 'USERROLE.USERROLEMANAGEMENT.PRINCIPLE',
+            }, { transaction });
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+    },
+    async down(queryInterface) {
+        const transaction = await queryInterface.sequelize.transaction();
+        try {
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+    },
+};

package/dist/db/psql/migrations/20260226060547-add_user_has_batch_in_not_teaching.d.ts

@@ -0,0 +1,2 @@
+export function up(queryInterface: any, Sequelize: any): Promise<void>;
+export function down(queryInterface: any): Promise<void>;

package/dist/db/psql/migrations/20260226060547-add_user_has_batch_in_not_teaching.js

@@ -0,0 +1,22 @@
+'use strict';
+const up = async (queryInterface, Sequelize) => {
+    const table = await queryInterface.describeTable('user_has_batches');
+    if (!table.is_teaching_batch) {
+        await queryInterface.addColumn('user_has_batches', 'is_teaching_batch', {
+            type: Sequelize.STRING,
+            allowNull: true,
+            defaultValue: 'YES',
+            field: 'is_teaching_batch',
+        });
+    }
+};
+const down = async (queryInterface) => {
+    const table = await queryInterface.describeTable('user_has_batches');
+    if (table.is_teaching_batch) {
+        await queryInterface.removeColumn('user_has_batches', 'is_teaching_batch');
+    }
+};
+module.exports = {
+    up,
+    down,
+};

package/dist/db/psql/seeders/20250101122757-add-default-permissions-modules.js

@@ -104,59 +104,27 @@ module.exports = {
             if (newActions.length > 0) {
                 await queryInterface.bulkInsert('feature_actions', newActions, { transaction });
             }
-            // const modulesToDelete = existingModules.filter(m => !allModulesListCode.modules.has(m.code)).map(m => m.code);
-            // // Find features to delete
-            // const featuresToDelete = existingFeatures.filter(f => !allModulesListCode.features.has(f.code)).map(f => f.code);
-            // // Find actions to delete
-            // const actionsToDelete = existingActions.filter(a => !allModulesListCode.actions.has(a.code)).map(a => a.code);
-            // if (actionsToDelete.length) {
-            //     await queryInterface.sequelize.query(`DELETE FROM feature_actions WHERE code IN (:codes)`, {
-            //         replacements: { codes: actionsToDelete },
-            //         transaction,
-            //     });
-            // }
-            // if (featuresToDelete.length) {
-            //     await queryInterface.sequelize.query(`DELETE FROM module_features WHERE code IN (:codes)`, {
-            //         replacements: { codes: featuresToDelete },
-            //         transaction,
-            //     });
-            // }
-            // if (modulesToDelete.length) {
-            //     await queryInterface.sequelize.query(`DELETE FROM modules WHERE code IN (:codes)`, {
-            //         replacements: { codes: modulesToDelete },
-            //         transaction,
-            //     });
-            // }
-            async function findOldCodes(queryInterface, table, validCodes) {
-                if (validCodes.length === 0) {
-                    // If no codes in the new list, return all old ones
-                    return (await queryInterface.sequelize.query(`SELECT code FROM ${table} WHERE is_default=true`, { raw: true, transaction }))[0];
-                }
-                return (await queryInterface.sequelize.query(`SELECT code FROM ${table} WHERE is_default=true AND code NOT IN (:codes)`, {
-                    replacements: { codes: validCodes },
-                    raw: true,
-                }))[0];
+            const modulesToDelete = existingModules.filter(m => !allModulesListCode.modules.has(m.code)).map(m => m.code);
+            const featuresToDelete = existingFeatures.filter(f => !allModulesListCode.features.has(f.code)).map(f => f.code);
+            const actionsToDelete = existingActions.filter(a => !allModulesListCode.actions.has(a.code)).map(a => a.code);
+            if (actionsToDelete.length) {
+                await queryInterface.sequelize.query(`DELETE FROM feature_actions WHERE code IN (:codes)`, {
+                    replacements: { codes: actionsToDelete },
+                    transaction,
+                });
+            }
+            if (featuresToDelete.length) {
+                await queryInterface.sequelize.query(`DELETE FROM module_features WHERE code IN (:codes)`, {
+                    replacements: { codes: featuresToDelete },
+                    transaction,
+                });
+            }
+            if (modulesToDelete.length) {
+                await queryInterface.sequelize.query(`DELETE FROM modules WHERE code IN (:codes)`, {
+                    replacements: { codes: modulesToDelete },
+                    transaction,
+                });
             }
-            // ✅ Delete old entries not in allModulesListCode
-            // await queryInterface.sequelize.query(`DELETE FROM feature_actions WHERE code NOT IN (:codes)`, {
-            //     replacements: { codes: [...allModulesListCode.actions] },
-            //     transaction,
-            // });
-            // await queryInterface.sequelize.query(`DELETE FROM module_features WHERE code NOT IN (:codes)`, {
-            //     replacements: { codes: [...allModulesListCode.features] },
-            //     transaction,
-            // });
-            // await queryInterface.sequelize.query(`DELETE FROM modules WHERE code NOT IN (:codes)`, {
-            //     replacements: { codes: [...allModulesListCode.modules] },
-            //     transaction,
-            // });
-            await findOldCodes(queryInterface, 'feature_actions', [...allModulesListCode.actions]);
-            await findOldCodes(queryInterface, 'module_features', [...allModulesListCode.features]);
-            await findOldCodes(queryInterface, 'modules', [...allModulesListCode.modules]);
-            // 2️⃣ Log them (or handle however you want)
-            // console.log('🚨 Old Actions not in new list:', oldActionsNotInNew);
-            // console.log('🚨 Old Features not in new list:', oldFeaturesNotInNew);
-            // console.log('🚨 Old Modules not in new list:', oldModulesNotInNew);
             await transaction.commit();
         }
         catch (error) {
@@ -167,9 +135,9 @@ module.exports = {
     async down(queryInterface) {
         const transaction = await queryInterface.sequelize.transaction();
         try {
-            await queryInterface.bulkDelete('feature_actions', { is_default: true }, { transaction });
-            await queryInterface.bulkDelete('module_features', { is_default: true }, { transaction });
-            await queryInterface.bulkDelete('modules', { is_default: true }, { transaction });
+            // await queryInterface.bulkDelete('feature_actions', { is_default: true }, { transaction });
+            // await queryInterface.bulkDelete('module_features', { is_default: true }, { transaction });
+            // await queryInterface.bulkDelete('modules', { is_default: true }, { transaction });
             await transaction.commit();
         }
         catch (error) {

package/dist/db/psql/seeders/Data/BatchModule.js

@@ -17,6 +17,7 @@ const BatchModule = {
                 { name: 'Delete', code: 'BATCH.MANAGEMENT.DELETE', appType: [appTypeEnum.INSTITUTE_APP] },
                 { name: 'Print', code: 'BATCH.MANAGEMENT.PRINT', appType: [appTypeEnum.INSTITUTE_APP] },
                 { name: 'Approval', code: 'BATCH.MANAGEMENT.APPROVAL', appType: [appTypeEnum.INSTITUTE_APP] },
+                { name: 'Assign Not Teaching Batch', code: 'BATCH.MANAGEMENT.ASSIGNNONTEACHING', appType: [appTypeEnum.INSTITUTE_APP] },
             ],
         },
         // {

package/dist/db/psql/seeders/Data/DivisionModule.js

@@ -18,6 +18,7 @@ const BatchModule = {
                 { name: 'Print', code: 'BATCH.MANAGEMENT.PRINT', appType: [appTypeEnum.SCHOOL_APP] },
                 { name: 'Approval', code: 'BATCH.MANAGEMENT.APPROVAL', appType: [appTypeEnum.SCHOOL_APP] },
                 { name: 'Assign Teacher', code: 'BATCH.MANAGEMENT.ASSIGN', appType: [appTypeEnum.SCHOOL_APP] },
+                { name: 'Assign Not Teaching Division', code: 'BATCH.MANAGEMENT.ASSIGNNONTEACHING', appType: [appTypeEnum.SCHOOL_APP] },
             ],
         },
     ],

package/dist/db/psql/seeders/Data/KipiStorageModule.js

@@ -2,19 +2,19 @@
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const appTypeEnum = require('./appType');
 const KipiStorageModule = {
-    name: 'Kip Storage',
-    code: ' KIPI',
+    name: 'Kipi Storage',
+    code: 'KIPI',
     appType: [appTypeEnum.SCHOOL_APP],
     features: [
         {
-            name: 'Kip Store Management',
-            code: ' KIPI.STORAGE',
+            name: 'Kipi Store Management',
+            code: 'KIPI.STORAGE',
             appType: [appTypeEnum.SCHOOL_APP],
             actions: [
-                { name: 'Add', code: ' KIPI.STORAGE.ADD', appType: [appTypeEnum.SCHOOL_APP] },
-                { name: 'Update', code: ' KIPI.STORAGE.UPDATE', appType: [appTypeEnum.SCHOOL_APP] },
-                { name: 'View', code: ' KIPI.STORAGE.VIEW', appType: [appTypeEnum.SCHOOL_APP] },
-                { name: 'Delete', code: ' KIPI.STORAGE.DELETE', appType: [appTypeEnum.SCHOOL_APP] },
+                { name: 'Add', code: 'KIPI.STORAGE.ADD', appType: [appTypeEnum.SCHOOL_APP] },
+                { name: 'Update', code: 'KIPI.STORAGE.UPDATE', appType: [appTypeEnum.SCHOOL_APP] },
+                { name: 'View', code: 'KIPI.STORAGE.VIEW', appType: [appTypeEnum.SCHOOL_APP] },
+                { name: 'Delete', code: 'KIPI.STORAGE.DELETE', appType: [appTypeEnum.SCHOOL_APP] },
             ],
         },
     ],

package/dist/interfaces/userHasBatchInterface.d.ts

@@ -1,3 +1,4 @@
+import { BOOLEAN_STATUS } from '../constants';
 import { IDefaultAttributes } from './commonInterface';
 export interface IUserHasBatchModelAttributes extends IDefaultAttributes {
     id: string;
@@ -5,4 +6,5 @@ export interface IUserHasBatchModelAttributes extends IDefaultAttributes {
     userId: string;
     subjects: string[];
     academicCalendarId?: string;
+    isTeachingBatch: BOOLEAN_STATUS;
 }

package/dist/models/psql/lectureModel.js

@@ -91,22 +91,17 @@ class LectureModel extends sequelize_1.Model {
                 };
                 if (lecture.id)
                     where = { ...where, id: { [sequelize_1.Op.ne]: lecture.id } };
-                if (lecture.batchId) {
-                    if (lecture.slotId)
-                        where.slotId = lecture.slotId;
-                    const batchConflict = await LectureModel.findOne({ where: { ...where, batchId: lecture.batchId }, ...options });
-                    if (batchConflict)
-                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.BATCH_OCCUPIED);
-                }
                 if (lecture.classRoomId) {
-                    const classRoomConflict = await LectureModel.findOne({ where: { ...(0, utils_1.omit)(where, ['slotId']), classRoomId: lecture.classRoomId }, ...options });
+                    const classRoomConflict = await LectureModel.findOne({
+                        where: { ...where, classRoomId: lecture.classRoomId },
+                        ...options,
+                    });
                     if (classRoomConflict)
                         throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.CLASSROOM_OCCUPIED);
                 }
-                // const teacherConflictWhere = omit(where, ['slotId']);
                 if (lecture.primaryUserId) {
                     const teacherConflict = await LectureModel.findOne({
-                        where: { ...(0, utils_1.omit)(where, ['slotId']), primaryUserId: lecture.primaryUserId },
+                        where: { ...where, primaryUserId: lecture.primaryUserId },
                         ...options,
                     });
                     if (teacherConflict)
@@ -114,12 +109,20 @@ class LectureModel extends sequelize_1.Model {
                 }
                 if (lecture.secondaryUserId) {
                     const teacherConflict = await LectureModel.findOne({
-                        where: { ...(0, utils_1.omit)(where, ['slotId']), secondaryUserId: lecture.secondaryUserId },
+                        where: { ...where, secondaryUserId: lecture.secondaryUserId },
                         ...options,
                     });
                     if (teacherConflict)
                         throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.TEACHER_OCCUPIED);
                 }
+                if (lecture.batchId) {
+                    if (lecture.slotId)
+                        where.slotId = lecture.slotId;
+                    const batchConflict = await LectureModel.findOne({ where: { ...where, batchId: lecture.batchId }, ...options });
+                    if (batchConflict)
+                        throw new Error(errorMessages_1.LECTURE_ERROR_MESSAGES.BATCH_OCCUPIED);
+                }
+                // const teacherConflictWhere = omit(where, ['slotId']);
             }
             if (lecture.batchId) {
                 const batchWhere = { id: lecture.batchId };

package/dist/models/psql/userHasBatchModel.d.ts

@@ -1,12 +1,14 @@
 import { Model } from 'sequelize';
 import { IUserHasBatchModelAttributes } from '../../interfaces/userHasBatchInterface';
 import { TUserHasBatchModelCreationAttributes } from '../../types/userHasBatchType';
+import { BOOLEAN_STATUS } from '../../constants';
 declare class UserHasBatchModel extends Model<IUserHasBatchModelAttributes, TUserHasBatchModelCreationAttributes> {
     id: string;
     userId: string;
     batchId: string;
     subjects: string[];
     academicCalendarId: string;
+    isTeachingBatch: BOOLEAN_STATUS;
     createdBy: string;
     updatedBy: string;
     deletedBy: string;

package/dist/models/psql/userHasBatchModel.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sequelize_1 = require("sequelize");
 const index_1 = require("./index");
+const constants_1 = require("../../constants");
 class UserHasBatchModel extends sequelize_1.Model {
     static associate(models) {
         const { UserModel, BatchModel, AcademicCalendarModel } = models;
@@ -100,6 +101,11 @@ UserHasBatchModel.init({
         field: 'academic_calendar_id',
         allowNull: true,
     },
+    isTeachingBatch: {
+        type: sequelize_1.DataTypes.STRING,
+        field: 'is_teaching_batch',
+        defaultValue: constants_1.BOOLEAN_STATUS.YES,
+    },
 }, {
     modelName: 'UserHasBatchModel',
     tableName: 'user_has_batches',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kipicore/dbcore",
-    "version": "1.1.295",
+    "version": "1.1.297",
     "description": "Reusable DB core package with Postgres, MongoDB, models, services, interfaces, and types",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",