@kipicore/dbcore 1.0.3

package/dist/models/psql/floorManagementModel.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const userModel_1 = __importDefault(require("./userModel"));
+class FloorManagementModel extends sequelize_1.Model {
+}
+FloorManagementModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    title: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    floorNumber: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: false,
+        field: 'floor_number',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: false,
+        defaultValue: app_1.COMMAN_STATUS.ACTIVE,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: false,
+    },
+}, {
+    modelName: 'FloorManagementModel',
+    tableName: 'floor_management',
+    indexes: [
+        {
+            name: 'institute_floor_id',
+            unique: true,
+            fields: ['institute_id', 'floor_number'],
+            // eslint-disable-next-line camelcase
+            where: { deleted_at: null },
+        },
+    ],
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+FloorManagementModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+FloorManagementModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+FloorManagementModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+FloorManagementModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'floorInstitute',
+});
+instituteModel_1.default.hasMany(FloorManagementModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'instituteFloorList',
+});
+exports.default = FloorManagementModel;

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

@@ -0,0 +1,21 @@
+import { Model } from 'sequelize';
+import { IGreetingsModelAttributes } from '../../interfaces/greetingsInterface';
+import { TGreetingsModelCreationAttributes } from '../../types/greetingsType';
+import { COMMAN_STATUS, GREETING_TYPE } from '../../constants/app';
+declare class GreetingsModel extends Model<IGreetingsModelAttributes, TGreetingsModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    greetingType: GREETING_TYPE;
+    isDefault: boolean;
+    templateData: string;
+    status: COMMAN_STATUS;
+    title: string;
+    image: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+}
+export default GreetingsModel;

package/dist/models/psql/greetingsModel.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+const userModel_1 = __importDefault(require("./userModel"));
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const errorMessages_1 = require("../../constants/errorMessages");
+const fileStorageModel_1 = __importDefault(require("./fileStorageModel"));
+class GreetingsModel extends sequelize_1.Model {
+}
+GreetingsModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    templateData: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: true,
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        defaultValue: app_1.COMMAN_STATUS.ACTIVE,
+    },
+    greetingType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    title: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    image: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+    },
+    isDefault: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: true,
+    },
+}, {
+    modelName: 'GreetingsModel',
+    tableName: 'greeting',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+// Associations
+GreetingsModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+GreetingsModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+GreetingsModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+GreetingsModel.belongsTo(instituteModel_1.default, {
+    foreignKey: 'instituteId',
+    as: 'greetingsInstitute',
+});
+instituteModel_1.default.hasMany(GreetingsModel, {
+    foreignKey: 'instituteId',
+    as: 'instituteHasGreetings',
+});
+GreetingsModel.belongsTo(fileStorageModel_1.default, {
+    foreignKey: {
+        name: 'image',
+        allowNull: true,
+    },
+    as: 'greetingsImage',
+});
+fileStorageModel_1.default.hasMany(GreetingsModel, {
+    foreignKey: {
+        name: 'image',
+        allowNull: true,
+    },
+    as: 'imageHasGreetings',
+});
+const beforeCreateOrUpdateHook = async (greetings) => {
+    if (greetings.instituteId) {
+        const institute = await instituteModel_1.default.findByPk(greetings.instituteId);
+        if (!institute) {
+            throw new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+};
+GreetingsModel.beforeCreate(beforeCreateOrUpdateHook);
+GreetingsModel.beforeBulkUpdate(async (options) => {
+    await beforeCreateOrUpdateHook(options.attributes);
+});
+exports.default = GreetingsModel;

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

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { IHomeWorkModelAttributes } from '../../interfaces/homeworkInterface';
+import { THomeWorkModelCreationAttributes } from '../../types/homeWorkType';
+import { COMMAN_STATUS } from '../../constants/app';
+declare class HomeWorkModel extends Model<IHomeWorkModelAttributes, THomeWorkModelCreationAttributes> {
+    id: string;
+    title: string;
+    description: string;
+    status: COMMAN_STATUS;
+    instituteId: string;
+    batchId: string;
+    subjectId: string;
+    fileStorageId: string[];
+    submissionDate: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default HomeWorkModel;

package/dist/models/psql/homeWorkModel.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const app_1 = require("../../constants/app");
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+const batchModel_1 = __importDefault(require("./batchModel"));
+const index_1 = require("./index");
+const userModel_1 = __importDefault(require("./userModel"));
+const instituteEntityModel_1 = __importDefault(require("./instituteEntityModel"));
+class HomeWorkModel extends sequelize_1.Model {
+}
+HomeWorkModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    title: {
+        type: sequelize_1.DataTypes.STRING(500),
+        allowNull: true,
+    },
+    description: {
+        type: sequelize_1.DataTypes.STRING(500),
+        allowNull: true,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'institute_id',
+        allowNull: true,
+    },
+    batchId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'batch_id',
+        allowNull: true,
+    },
+    subjectId: {
+        type: sequelize_1.DataTypes.UUID,
+        field: 'subject_id',
+        allowNull: true,
+    },
+    fileStorageId: {
+        type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
+        field: 'filestorage_id',
+        allowNull: true,
+    },
+    submissionDate: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        values: Object.values(app_1.COMMAN_STATUS),
+        allowNull: false,
+        defaultValue: app_1.COMMAN_STATUS.ACTIVE,
+    },
+}, {
+    modelName: 'HomeWorkModel',
+    tableName: 'home_work',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+HomeWorkModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+HomeWorkModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+HomeWorkModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+HomeWorkModel.belongsTo(batchModel_1.default, {
+    foreignKey: {
+        name: 'batchId',
+    },
+    as: 'batch',
+});
+batchModel_1.default.hasMany(HomeWorkModel, {
+    foreignKey: {
+        name: 'batchId',
+    },
+    as: 'homework',
+});
+HomeWorkModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'institute',
+});
+instituteModel_1.default.hasMany(HomeWorkModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'homework_institute',
+});
+instituteEntityModel_1.default.hasMany(HomeWorkModel, {
+    foreignKey: {
+        name: 'subjectId',
+        field: 'subject_id',
+    },
+    as: 'subjectHomeWorkList',
+});
+HomeWorkModel.belongsTo(instituteEntityModel_1.default, {
+    foreignKey: {
+        name: 'subjectId',
+        field: 'subject_id',
+    },
+    as: 'homeWorkSubject',
+});
+exports.default = HomeWorkModel;

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

@@ -0,0 +1,4 @@
+import { Sequelize } from "sequelize";
+declare const db: any;
+declare const sequelize: Sequelize;
+export { sequelize, db, Sequelize };

package/dist/models/psql/index.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequelize = exports.db = exports.sequelize = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const sequelize_1 = require("sequelize");
+Object.defineProperty(exports, "Sequelize", { enumerable: true, get: function () { return sequelize_1.Sequelize; } });
+const postgresConfig = require("../../configs/postgresConfig.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const { database, username, password, host, port, dbLogging, dialectOptions } = postgresConfig;
+const db = {};
+exports.db = db;
+const sequelize = new sequelize_1.Sequelize(database, username, password, {
+    query: { raw: true },
+    host,
+    port,
+    logging: dbLogging,
+    dialect: "postgres",
+    define: {
+        timestamps: true,
+        underscored: true,
+        paranoid: true,
+    },
+    dialectOptions,
+});
+exports.sequelize = sequelize;
+// add all models
+fs_1.default.readdirSync(__dirname)
+    .filter((file) => file.indexOf(".") !== 0 && file !== "index.js" && file.slice(-3) === ".ts")
+    .forEach(async (file) => {
+    const model = await Promise.resolve(`${path_1.default.join(__dirname, file)}`).then(s => __importStar(require(s)));
+    db[model?.default?.name] = model;
+});
+// add all associations
+// Object.keys(db).forEach(modelName => {
+//     if ('associate' in db[modelName]) {
+//         db[modelName].associate(db);
+//     }
+// });
+sequelize.addHook("beforeBulkDestroy", async (options) => {
+    const userId = options.userId; // Pass the user ID through options
+    if (userId) {
+        // Fetch all instances matching the delete condition
+        const modelName = options.model.name; // Replace 'YourModel' with your model name
+        const instances = await sequelize.models[modelName].findAll({
+            where: options.where,
+            raw: false,
+        });
+        for (const instance of instances) {
+            if ("deletedBy" in instance || "deleted_by" in instance) {
+                instance.deletedBy = userId;
+                // Save the updated instance without triggering additional hooks
+                await instance.save({ hooks: false });
+            }
+        }
+    }
+});
+sequelize.addHook("beforeCreate", async (instance, options) => {
+    const userId = options.userId; // Extract user ID
+    if (userId && ("createdBy" in instance || "created_by" in instance)) {
+        instance.createdBy = userId;
+    }
+});
+sequelize.addHook("beforeBulkCreate", async (instances, options) => {
+    const userId = options.userId; // Extract user ID
+    if (userId) {
+        for (const instance of instances) {
+            if ("createdBy" in instance || "created_by" in instance) {
+                instance.createdBy = userId;
+            }
+        }
+    }
+});
+sequelize.addHook("beforeBulkUpdate", async (options) => {
+    const userId = options.userId; // Extract user ID from options
+    if (userId && options.attributes) {
+        // Update the 'updatedBy' or 'updated_by' attribute
+        options.attributes["updatedBy"] = userId; // Adjust as per your column name
+    }
+});
+sequelize.addHook("beforeFind", async (options) => {
+    if (options.include) {
+        options.raw = false;
+    }
+});

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

@@ -0,0 +1,25 @@
+import { Model } from 'sequelize';
+import { INSTITUTE_ENTITY_STATUS } from '../../constants/app';
+import { IInstituteEntityAttributes } from '../../interfaces/instituteEntityInterface';
+import { TInstituteEntityCreationAttributes } from '../../types/instituteEntityType';
+declare class InstituteEntityModel extends Model<IInstituteEntityAttributes, TInstituteEntityCreationAttributes> {
+    id: string;
+    title: string;
+    subTitle: string;
+    description: string;
+    svgUrl: string;
+    entityTypeId: string;
+    status: INSTITUTE_ENTITY_STATUS;
+    entityId: string;
+    instituteId: string;
+    isDefault: boolean;
+    code: string;
+    sequenceNumber: number;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default InstituteEntityModel;

package/dist/models/psql/instituteEntityModel.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+const userModel_1 = __importDefault(require("./userModel"));
+const instituteEntityTypeModel_1 = __importDefault(require("./instituteEntityTypeModel"));
+const instituteModel_1 = __importDefault(require("./instituteModel"));
+class InstituteEntityModel extends sequelize_1.Model {
+}
+InstituteEntityModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    title: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: false,
+    },
+    subTitle: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: false,
+        field: 'sub_title',
+    },
+    description: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    svgUrl: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'svg_url',
+    },
+    status: {
+        type: sequelize_1.DataTypes.ENUM,
+        allowNull: false,
+        defaultValue: app_1.INSTITUTE_ENTITY_STATUS.ACTIVE,
+        values: Object.values(app_1.INSTITUTE_ENTITY_STATUS),
+    },
+    entityTypeId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+        field: 'entity_type_id',
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    isDefault: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: true,
+        field: 'is_default',
+    },
+    code: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+    sequenceNumber: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+        field: 'sequence_number',
+    },
+}, {
+    modelName: 'InstituteEntityModel',
+    tableName: 'institute_entities',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+InstituteEntityModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+InstituteEntityModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+InstituteEntityModel.belongsTo(userModel_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+InstituteEntityModel.hasMany(InstituteEntityModel, {
+    foreignKey: {
+        name: 'entityId',
+        allowNull: true,
+        field: 'entity_id',
+    },
+    as: 'entities',
+});
+InstituteEntityModel.belongsTo(instituteEntityTypeModel_1.default, {
+    foreignKey: {
+        name: 'entityTypeId',
+        allowNull: false,
+        field: 'entity_type_id',
+    },
+    as: 'entityType',
+});
+InstituteEntityModel.belongsTo(instituteModel_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+        allowNull: true,
+        field: 'institute_id',
+    },
+    as: 'institute',
+});
+instituteModel_1.default.hasMany(InstituteEntityModel, {
+    foreignKey: {
+        name: 'instituteId',
+        allowNull: true,
+        field: 'institute_id',
+    },
+    as: 'instituteEntities',
+});
+exports.default = InstituteEntityModel;

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

@@ -0,0 +1,19 @@
+import { Model } from 'sequelize';
+import { INSTITUTE_ENTITY_TYPE_SEQUENCE, INSTITUTE_ENTITY_TYPE_STATUS } from '../../constants/app';
+import { IInstituteEntityTypeAttributes } from '../../interfaces/instituteEntityTypeInterface';
+import { TInstituteEntityTypeCreationAttributes } from '../../types/instituteEntityTypeType';
+declare class InstituteEntityTypeModel extends Model<IInstituteEntityTypeAttributes, TInstituteEntityTypeCreationAttributes> {
+    id: string;
+    title: string;
+    subTitle: string;
+    status: INSTITUTE_ENTITY_TYPE_STATUS;
+    svgUrl: string;
+    sequence: INSTITUTE_ENTITY_TYPE_SEQUENCE;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default InstituteEntityTypeModel;