@kipicore/dbcore 1.1.5 → 1.1.8

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

@@ -1,7 +1,7 @@
-import { Model } from "sequelize";
-import { ILectureModelAttributes } from "../../interfaces/lectureInterface.js";
-import { TLectureModelCreationAttributes } from "../../types/lectureType.js";
-import { LECTURE_STATUS, LECTURE_TITLE, PLANNER_SYNC_STATUS } from "../../constants/app.js";
+import { Model } from 'sequelize';
+import { ILectureModelAttributes } from '../../interfaces/lectureInterface.js';
+import { TLectureModelCreationAttributes } from '../../types/lectureType.js';
+import { LECTURE_STATUS, LECTURE_TITLE, PLANNER_SYNC_STATUS } from '../../constants/app.js';
 declare class LectureModel extends Model<ILectureModelAttributes, TLectureModelCreationAttributes> {
     id: string;
     title: LECTURE_TITLE;

package/dist/models/psql/lectureModel.js

@@ -43,7 +43,7 @@ LectureModel.init({
     },
     slotDuration: {
         type: sequelize_1.DataTypes.INTEGER,
-        field: "slot_duration",
+        field: 'slot_duration',
         allowNull: false,
     },
     subject: {
@@ -52,47 +52,47 @@ LectureModel.init({
     },
     startTime: {
         type: sequelize_1.DataTypes.DATE,
-        field: "start_time",
+        field: 'start_time',
         allowNull: false,
     },
     endTime: {
         type: sequelize_1.DataTypes.DATE,
-        field: "end_time",
+        field: 'end_time',
         allowNull: false,
     },
     instituteId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "institute_id",
+        field: 'institute_id',
         allowNull: true,
     },
     classRoomId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "class_room_id",
+        field: 'class_room_id',
         allowNull: true,
     },
     groupId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "group_id",
+        field: 'group_id',
         allowNull: true,
     },
     primaryUserId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "primary_user_id",
+        field: 'primary_user_id',
         allowNull: true,
     },
     secondaryUserId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "secondary_user_id",
+        field: 'secondary_user_id',
         allowNull: true,
     },
     workingDayId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "working_day_id",
+        field: 'working_day_id',
         allowNull: false,
     },
     batchId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "batch_id",
+        field: 'batch_id',
         allowNull: true,
     },
     status: {
@@ -103,12 +103,12 @@ LectureModel.init({
     },
     checkedInAt: {
         type: sequelize_1.DataTypes.DATE,
-        field: "checked_in_at",
+        field: 'checked_in_at',
         allowNull: true,
     },
     checkedOutAt: {
         type: sequelize_1.DataTypes.DATE,
-        field: "checked_out_at",
+        field: 'checked_out_at',
         allowNull: true,
     },
     color: {
@@ -117,142 +117,142 @@ LectureModel.init({
     },
     plannerSyncStatus: {
         type: sequelize_1.DataTypes.STRING,
-        field: "planner_sync_status",
+        field: 'planner_sync_status',
         allowNull: true,
         defaultValue: app_js_1.PLANNER_SYNC_STATUS.PENDING,
     },
     shiftId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "shift_id",
+        field: 'shift_id',
         allowNull: true,
     },
     slotId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "slot_id",
+        field: 'slot_id',
         allowNull: true,
     },
 }, {
-    modelName: "LectureModel",
-    tableName: "lectures",
+    modelName: 'LectureModel',
+    tableName: 'lectures',
     timestamps: true,
     sequelize: index_js_1.sequelize,
 });
 // Associations
 LectureModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "createdBy",
+        name: 'createdBy',
         allowNull: true,
-        field: "created_by",
+        field: 'created_by',
     },
-    as: "createdByUser",
+    as: 'createdByUser',
 });
 LectureModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "updatedBy",
+        name: 'updatedBy',
         allowNull: true,
-        field: "updated_by",
+        field: 'updated_by',
     },
-    as: "updatedByUser",
+    as: 'updatedByUser',
 });
 LectureModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "deletedBy",
+        name: 'deletedBy',
         allowNull: true,
-        field: "deleted_by",
+        field: 'deleted_by',
     },
-    as: "deletedByUser",
+    as: 'deletedByUser',
 });
 LectureModel.belongsTo(typeManagementModel_js_1.default, {
-    foreignKey: "type",
-    as: "lectureType",
+    foreignKey: 'type',
+    as: 'lectureType',
 });
 LectureModel.belongsTo(instituteModel_js_1.default, {
-    foreignKey: "instituteId",
-    as: "institute",
+    foreignKey: 'instituteId',
+    as: 'institute',
 });
 instituteModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "instituteId",
-    as: "instituteHasLectures",
+    foreignKey: 'instituteId',
+    as: 'instituteHasLectures',
 });
 LectureModel.belongsTo(workingDayModel_js_1.default, {
-    foreignKey: "workingDayId",
-    as: "workingDay",
+    foreignKey: 'workingDayId',
+    as: 'workingDay',
 });
 workingDayModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "workingDayId",
-    as: "workingDayHasLectures",
+    foreignKey: 'workingDayId',
+    as: 'workingDayHasLectures',
 });
 LectureModel.belongsTo(slotModel_js_1.default, {
-    foreignKey: "slotId",
-    as: "lectureSlot",
+    foreignKey: 'slotId',
+    as: 'lectureSlot',
 });
 slotModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "slotId",
-    as: "slotLectureList",
+    foreignKey: 'slotId',
+    as: 'slotLectureList',
 });
 LectureModel.belongsTo(workingShiftModel_js_1.default, {
-    foreignKey: "shiftId",
-    as: "lectureShift",
+    foreignKey: 'shiftId',
+    as: 'lectureShift',
 });
 workingShiftModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "shiftId",
-    as: "shiftLectureList",
+    foreignKey: 'shiftId',
+    as: 'shiftLectureList',
 });
 LectureModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "primaryUserId",
-        field: "primary_user_id",
+        name: 'primaryUserId',
+        field: 'primary_user_id',
         allowNull: true,
     },
-    as: "user",
+    as: 'user',
 });
 userModel_js_1.default.hasMany(LectureModel, {
     foreignKey: {
-        name: "primaryUserId",
-        field: "primary_user_id",
+        name: 'primaryUserId',
+        field: 'primary_user_id',
         allowNull: true,
     },
-    as: "userHasLectures",
+    as: 'userHasLectures',
 });
 LectureModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "secondaryUserId",
-        field: "secondary_user_id",
+        name: 'secondaryUserId',
+        field: 'secondary_user_id',
         allowNull: true,
     },
-    as: "secondaryUser",
+    as: 'secondaryUser',
 });
 userModel_js_1.default.hasMany(LectureModel, {
     foreignKey: {
-        name: "secondaryUserId",
-        field: "secondary_user_id",
+        name: 'secondaryUserId',
+        field: 'secondary_user_id',
         allowNull: true,
     },
-    as: "secondaryUserHasLectures",
+    as: 'secondaryUserHasLectures',
 });
 LectureModel.belongsTo(classRoomModel_js_1.default, {
-    foreignKey: "classRoomId",
-    as: "classRoom",
+    foreignKey: 'classRoomId',
+    as: 'classRoom',
 });
 classRoomModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "classRoomId",
-    as: "classRoomHasLectures",
+    foreignKey: 'classRoomId',
+    as: 'classRoomHasLectures',
 });
 LectureModel.belongsTo(batchModel_js_1.default, {
-    foreignKey: "batchId",
-    as: "batch",
+    foreignKey: 'batchId',
+    as: 'batch',
 });
 batchModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "batchId",
-    as: "batchHasLectures",
+    foreignKey: 'batchId',
+    as: 'batchHasLectures',
 });
 LectureModel.belongsTo(instituteEntityModel_js_1.default, {
-    foreignKey: "subject",
-    as: "subjectDetails",
+    foreignKey: 'subject',
+    as: 'subjectDetails',
 });
 instituteEntityModel_js_1.default.hasMany(LectureModel, {
-    foreignKey: "subject",
-    as: "subjectHasLectures",
+    foreignKey: 'subject',
+    as: 'subjectHasLectures',
 });
 const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
     const options = {};
@@ -270,9 +270,9 @@ const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
             where: { id: lecture.workingDayId },
             include: [
                 {
-                    association: "workingDayShift",
+                    association: 'workingDayShift',
                     required: false,
-                    include: [{ association: "shiftSlot", required: false }],
+                    include: [{ association: 'shiftSlot', required: false }],
                 },
             ],
         });
@@ -325,7 +325,7 @@ const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
         const user = await userHasBatchModel_js_1.default.findOne({
             where: batchWhere,
             ...options,
-            include: [{ association: "user", where: { type: app_js_1.USER_TYPES.TEACHER } }],
+            include: [{ association: 'user', where: { type: app_js_1.USER_TYPES.TEACHER } }],
         });
         if (!user) {
             throw new Error(errorMessages_js_1.BATCH_ERROR_MESSAGES.INVALID_SELECTED);
@@ -348,22 +348,13 @@ const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
         let where = {
             [sequelize_1.Op.or]: [
                 {
-                    [sequelize_1.Op.and]: [
-                        { startTime: { [sequelize_1.Op.lte]: lecture.startTime } },
-                        { endTime: { [sequelize_1.Op.gt]: lecture.startTime } },
-                    ],
+                    [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.lte]: lecture.startTime } }, { endTime: { [sequelize_1.Op.gt]: lecture.startTime } }],
                 },
                 {
-                    [sequelize_1.Op.and]: [
-                        { startTime: { [sequelize_1.Op.lt]: lecture.endTime } },
-                        { endTime: { [sequelize_1.Op.gte]: lecture.endTime } },
-                    ],
+                    [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.lt]: lecture.endTime } }, { endTime: { [sequelize_1.Op.gte]: lecture.endTime } }],
                 },
                 {
-                    [sequelize_1.Op.and]: [
-                        { startTime: { [sequelize_1.Op.gte]: lecture.startTime } },
-                        { endTime: { [sequelize_1.Op.lte]: lecture.endTime } },
-                    ],
+                    [sequelize_1.Op.and]: [{ startTime: { [sequelize_1.Op.gte]: lecture.startTime } }, { endTime: { [sequelize_1.Op.lte]: lecture.endTime } }],
                 },
             ],
             instituteId: lecture.instituteId,
@@ -452,7 +443,7 @@ const beforeCreateOrUpdateHook = async (lecture, transaction = null) => {
             where: { id: lecture.subject },
             include: [
                 {
-                    association: "entityType",
+                    association: 'entityType',
                     where: { sequence: app_js_1.INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST },
                 },
             ],

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

@@ -1,7 +1,7 @@
-import { Model } from "sequelize";
-import { IMasterLeaveModelAttributes } from "../../interfaces/masterLeaveInterface.js";
-import { TMasterLeaveModelCreationAttributes } from "../../types/masterLeaveType.js";
-import { COMMAN_STATUS, LEAVE, TERM_DURATION } from "../../constants/app.js";
+import { Model } from 'sequelize';
+import { IMasterLeaveModelAttributes } from '../../interfaces/masterLeaveInterface.js';
+import { TMasterLeaveModelCreationAttributes } from '../../types/masterLeaveType.js';
+import { COMMAN_STATUS, LEAVE, TERM_DURATION } from '../../constants/app.js';
 declare class MasterLeaveModel extends Model<IMasterLeaveModelAttributes, TMasterLeaveModelCreationAttributes> {
     id: string;
     totalLeave: number;

package/dist/models/psql/masterLeaveModel.js

@@ -58,8 +58,8 @@ MasterLeaveModel.init({
         allowNull: true,
     },
 }, {
-    modelName: "MasterLeaveModel",
-    tableName: "master_leaves",
+    modelName: 'MasterLeaveModel',
+    tableName: 'master_leaves',
     timestamps: true,
     sequelize: index_js_1.sequelize,
 });
@@ -67,8 +67,7 @@ const validateAndCalculate = async (instance) => {
     try {
         if (instance.typeManagementId) {
             const typeManagement = await typeManagementModel_js_1.default.findByPk(instance.typeManagementId);
-            if (!typeManagement ||
-                typeManagement.type !== app_js_1.TYPE_MANAGEMENT_TYPE.LEAVE) {
+            if (!typeManagement || typeManagement.type !== app_js_1.TYPE_MANAGEMENT_TYPE.LEAVE) {
                 throw new Error(errorMessages_js_1.MASTER_LEAVE_ERROR_MESSAGES.INVALID_TYPE_MANAGEMENT_ID);
             }
         }
@@ -85,48 +84,48 @@ MasterLeaveModel.beforeBulkUpdate(async (instance) => {
 });
 MasterLeaveModel.belongsTo(instituteModel_js_1.default, {
     foreignKey: {
-        name: "instituteId",
-        field: "institute_id",
+        name: 'instituteId',
+        field: 'institute_id',
     },
-    as: "leaveInstitute",
+    as: 'leaveInstitute',
 });
 instituteModel_js_1.default.hasMany(MasterLeaveModel, {
-    foreignKey: "instituteId",
-    as: "instituteHasLeaves",
+    foreignKey: 'instituteId',
+    as: 'instituteHasLeaves',
 });
 MasterLeaveModel.belongsTo(typeManagementModel_js_1.default, {
     foreignKey: {
-        name: "typeManagementId",
-        field: "type_management_id",
+        name: 'typeManagementId',
+        field: 'type_management_id',
     },
-    as: "leaveTypeManagement",
+    as: 'leaveTypeManagement',
 });
 typeManagementModel_js_1.default.hasMany(MasterLeaveModel, {
-    foreignKey: "typeManagementId",
-    as: "typeManagementHasLeaves",
+    foreignKey: 'typeManagementId',
+    as: 'typeManagementHasLeaves',
 });
 MasterLeaveModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "createdBy",
+        name: 'createdBy',
         allowNull: true,
-        field: "created_by",
+        field: 'created_by',
     },
-    as: "createdByUser",
+    as: 'createdByUser',
 });
 MasterLeaveModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "updatedBy",
+        name: 'updatedBy',
         allowNull: true,
-        field: "updated_by",
+        field: 'updated_by',
     },
-    as: "updatedByUser",
+    as: 'updatedByUser',
 });
 MasterLeaveModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "deletedBy",
+        name: 'deletedBy',
         allowNull: true,
-        field: "deleted_by",
+        field: 'deleted_by',
     },
-    as: "deletedByUser",
+    as: 'deletedByUser',
 });
 exports.default = MasterLeaveModel;

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

@@ -1,7 +1,7 @@
-import { Model } from "sequelize";
-import { ITestimonialModelAttributes } from "../../interfaces/testimonialInterface.js";
-import { TTestimonialModelCreationAttributes } from "../../types/testimonialType.js";
-import { COMMAN_STATUS, USER_TYPES } from "../../constants/app.js";
+import { Model } from 'sequelize';
+import { ITestimonialModelAttributes } from '../../interfaces/testimonialInterface.js';
+import { TTestimonialModelCreationAttributes } from '../../types/testimonialType.js';
+import { COMMAN_STATUS, USER_TYPES } from '../../constants/app.js';
 declare class TestimonialModel extends Model<ITestimonialModelAttributes, TTestimonialModelCreationAttributes> {
     id: string;
     instituteId: string;

package/dist/models/psql/testimonialModel.js

@@ -55,51 +55,51 @@ TestimonialModel.init({
         allowNull: true,
     },
 }, {
-    modelName: "TestimonialModel",
-    tableName: "testimonials",
+    modelName: 'TestimonialModel',
+    tableName: 'testimonials',
     timestamps: true,
     sequelize: index_js_1.sequelize,
 });
 // Associations
 TestimonialModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "createdBy",
+        name: 'createdBy',
         allowNull: true,
-        field: "created_by",
+        field: 'created_by',
     },
-    as: "createdByUser",
+    as: 'createdByUser',
 });
 TestimonialModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "updatedBy",
+        name: 'updatedBy',
         allowNull: true,
-        field: "updated_by",
+        field: 'updated_by',
     },
-    as: "updatedByUser",
+    as: 'updatedByUser',
 });
 TestimonialModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "deletedBy",
+        name: 'deletedBy',
         allowNull: true,
-        field: "deleted_by",
+        field: 'deleted_by',
     },
-    as: "deletedByUser",
+    as: 'deletedByUser',
 });
 TestimonialModel.belongsTo(instituteModel_js_1.default, {
-    foreignKey: "instituteId",
-    as: "testimonialInstitute",
+    foreignKey: 'instituteId',
+    as: 'testimonialInstitute',
 });
 instituteModel_js_1.default.hasMany(TestimonialModel, {
-    foreignKey: "instituteId",
-    as: "instituteHasTestimonials",
+    foreignKey: 'instituteId',
+    as: 'instituteHasTestimonials',
 });
 TestimonialModel.belongsTo(userModel_js_1.default, {
-    foreignKey: "userId",
-    as: "testimonialUser",
+    foreignKey: 'userId',
+    as: 'testimonialUser',
 });
 userModel_js_1.default.hasMany(TestimonialModel, {
-    foreignKey: "userId",
-    as: "userHasTestimonials",
+    foreignKey: 'userId',
+    as: 'userHasTestimonials',
 });
 const beforeCreateOrUpdateHook = async (testimonial) => {
     if (testimonial.instituteId) {
@@ -117,9 +117,7 @@ const beforeCreateOrUpdateHook = async (testimonial) => {
         testimonial.userType = user.type;
     }
     testimonial.class = `${(0, utils_js_1.fromSnakeCaseToNormalText)(testimonial.userType)}`;
-    if (testimonial.userId &&
-        testimonial.instituteId &&
-        testimonial.userType !== app_js_1.USER_TYPES.PARENTS) {
+    if (testimonial.userId && testimonial.instituteId && testimonial.userType !== app_js_1.USER_TYPES.PARENTS) {
         const meta = await userInstituteMetaModel_js_1.default.findOne({
             userId: testimonial.userId,
             instituteId: testimonial.instituteId,
@@ -134,12 +132,12 @@ const beforeCreateOrUpdateHook = async (testimonial) => {
                 id: { [sequelize_1.Op.in]: meta.entities },
             },
             include: {
-                association: "entityType",
+                association: 'entityType',
                 required: true,
                 where: {
                     [sequelize_1.Op.or]: [
-                        { title: { [sequelize_1.Op.iLike]: "STANDARD" } },
-                        { title: { [sequelize_1.Op.iLike]: "MEDIUM" } },
+                        { title: { [sequelize_1.Op.iLike]: 'STANDARD' } },
+                        { title: { [sequelize_1.Op.iLike]: 'MEDIUM' } },
                         // { title: { [Op.iLike]: 'BOARD' } },
                         // { title: { [Op.iLike]: 'STREAM' } },
                         // { title: { [Op.iLike]: 'SUBJECT' } },
@@ -149,9 +147,9 @@ const beforeCreateOrUpdateHook = async (testimonial) => {
         });
         stdDataList = JSON.parse(JSON.stringify(stdDataList));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const className = stdDataList.find((item) => item.entityType?.title === "STANDARD")?.title || null;
+        const className = stdDataList.find((item) => item.entityType?.title === 'STANDARD')?.title || null;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const mediumName = stdDataList.find((item) => item.entityType?.title === "MEDIUM")?.title || null;
+        const mediumName = stdDataList.find((item) => item.entityType?.title === 'MEDIUM')?.title || null;
         testimonial.class = `${(0, utils_js_1.capitalizeFirst)(mediumName.substring(0, 3))} Medium ${(0, utils_js_1.capitalizeFirst)(className)}`;
     }
 };

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

@@ -1,7 +1,7 @@
-import { Model } from "sequelize";
-import { IToDoModelAttributes } from "../../interfaces/toDoInterface.js";
-import { TToDoModelCreationAttributes } from "../../types/toDoType.js";
-import { TO_DO_STATUS } from "../../constants/app.js";
+import { Model } from 'sequelize';
+import { IToDoModelAttributes } from '../../interfaces/toDoInterface.js';
+import { TToDoModelCreationAttributes } from '../../types/toDoType.js';
+import { TO_DO_STATUS } from '../../constants/app.js';
 declare class ToDoModel extends Model<IToDoModelAttributes, TToDoModelCreationAttributes> {
     id: string;
     instituteId?: string;