@kipicore/dbcore 1.0.7 → 1.0.9

package/dist/models/psql/subjectHasPayFeeHistoryModel.ts

@@ -0,0 +1,132 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index';
+import { ISubjectHasPayFeeHistoryModelAttributes } from '../../interfaces/subjectHasPayFeeHistoryInterface';
+import { TSubjectHasPayFeeHistoryModelCreationAttributes } from '../../types/subjectHasPayFeeHistoryType';
+import InstituteModel from './instituteModel';
+import UserModel from './userModel';
+import InstituteEntityModel from './instituteEntityModel';
+import FeesCollectionModel from './feesCollectionModel';
+
+class SubjectHasPayFeeHistory extends Model<ISubjectHasPayFeeHistoryModelAttributes, TSubjectHasPayFeeHistoryModelCreationAttributes> {
+    declare id: string;
+    declare instituteId: string;
+    declare userId: string;
+    declare subjectId: string;
+    declare feeCollectionId: string;
+    declare amount: number;
+
+    declare createdBy: string;
+    declare updatedBy: string;
+    declare deletedBy: string;
+    declare readonly createdAt: Date;
+    declare readonly deletedAt: string;
+    declare readonly updatedAt: Date;
+}
+
+SubjectHasPayFeeHistory.init(
+    {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            allowNull: false,
+            primaryKey: true,
+        },
+        instituteId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        userId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        subjectId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        feeCollectionId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        amount: {
+            type: DataTypes.FLOAT,
+            allowNull: false,
+        },
+    },
+    {
+        modelName: 'SubjectHasPayFeeHistory',
+        tableName: 'subject_has_pay_fee_history',
+        timestamps: true,
+        sequelize,
+    },
+);
+
+SubjectHasPayFeeHistory.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'subjectHasPayFeeHistoryInstitute',
+});
+InstituteModel.hasMany(SubjectHasPayFeeHistory, { foreignKey: 'instituteId', as: 'instituteHasSubjectHasPayFeeHistory' });
+
+FeesCollectionModel.hasMany(SubjectHasPayFeeHistory, { foreignKey: 'feeCollectionId', as: 'feesCollectionHasSubjectHasPayFeeHistory' });
+SubjectHasPayFeeHistory.belongsTo(FeesCollectionModel, {
+    foreignKey: {
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
+    },
+    as: 'subjectHasPayFeeHistoryFeesCollection',
+});
+
+SubjectHasPayFeeHistory.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'subjectHasPayFeeHistoryUser',
+});
+UserModel.hasMany(SubjectHasPayFeeHistory, { foreignKey: 'userId', as: 'userHasSubjectHasPayFeeHistory' });
+
+SubjectHasPayFeeHistory.belongsTo(InstituteEntityModel, {
+    foreignKey: {
+        name: 'subjectId',
+        field: 'subject_id',
+    },
+    as: 'subjectHasPayFeeHistorySubject',
+});
+InstituteEntityModel.hasMany(SubjectHasPayFeeHistory, {
+    foreignKey: {
+        name: 'subjectId',
+        field: 'subject_id',
+    },
+    as: 'subjectHasSubjectHasPayFeeHistory',
+});
+
+SubjectHasPayFeeHistory.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+
+SubjectHasPayFeeHistory.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+
+SubjectHasPayFeeHistory.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+
+export default SubjectHasPayFeeHistory;

package/dist/models/psql/syllabusModel.ts

@@ -0,0 +1,149 @@
+import { DataTypes, Model } from 'sequelize';
+
+import { ISyllabusModelAttributes } from '../../interfaces/syllabusInterface';
+import { TSyllabusCreationAttributes } from '../../types/syllabusType';
+import { COMMAN_STATUS } from '../../constants/app';
+import InstituteModel from './instituteModel';
+import { sequelize } from './index';
+import UserModel from './userModel';
+import InstituteEntityModel from './instituteEntityModel';
+import FileStorageModel from './fileStorageModel';
+
+class SyllabusModel extends Model<ISyllabusModelAttributes, TSyllabusCreationAttributes> {
+    declare status: COMMAN_STATUS;
+    declare fileStorageId: string;
+    declare instituteId: string;
+    declare subjectId: string;
+    declare id: string;
+
+    declare createdBy: string;
+    declare updatedBy: string;
+    declare deletedBy: string;
+    declare readonly createdAt: Date;
+    declare readonly deletedAt: string;
+    declare readonly updatedAt: Date;
+}
+SyllabusModel.init(
+    {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            allowNull: false,
+            primaryKey: true,
+        },
+        status: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            defaultValue: COMMAN_STATUS.ACTIVE,
+        },
+        instituteId: {
+            type: DataTypes.UUID,
+            field: 'institute_id',
+            allowNull: true,
+        },
+        fileStorageId: {
+            type: DataTypes.UUID,
+            field: 'filestorage_id',
+            allowNull: true,
+        },
+        subjectId: {
+            type: DataTypes.UUID,
+            field: 'subject_id',
+            allowNull: true,
+        },
+    },
+    {
+        modelName: 'SyllabusModel',
+        tableName: 'syllabus',
+        // indexes: [
+        //     {
+        //         name: 'institute_syllabus_id',
+        //         unique: true,
+        //         fields: ['institute_id', 'subject_id'],
+        //         // eslint-disable-next-line camelcase
+        //         where: { deleted_at: null },
+        //     },
+        // ],
+        timestamps: true,
+        sequelize,
+    },
+);
+
+SyllabusModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+
+SyllabusModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+
+SyllabusModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+
+SyllabusModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'instituteDetails',
+});
+
+InstituteModel.hasMany(SyllabusModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'instituteSyllabusDetails',
+});
+
+SyllabusModel.belongsTo(InstituteEntityModel, {
+    foreignKey: {
+        name: 'subjectId',
+        field: 'subject_id',
+        allowNull: true,
+    },
+    as: 'syllabusSubjectDetails',
+});
+
+InstituteEntityModel.hasMany(SyllabusModel, {
+    foreignKey: {
+        name: 'subjectId',
+        field: 'subject_id',
+        allowNull: true,
+    },
+    as: 'subjectSyllabusDetails',
+});
+
+SyllabusModel.belongsTo(FileStorageModel, {
+    foreignKey: {
+        name: 'fileStorageId',
+        field: 'filestorage_id',
+        allowNull: true,
+    },
+    as: 'fileStorageDetails',
+});
+
+FileStorageModel.hasMany(SyllabusModel, {
+    foreignKey: {
+        name: 'fileStorageId',
+        field: 'filestorage_id',
+        allowNull: true,
+    },
+    as: 'syllabusFileStorageDetails',
+});
+
+export default SyllabusModel;

package/dist/models/psql/testimonialModel.ts

@@ -0,0 +1,215 @@
+import { DataTypes, Model, Op, UpdateOptions } from "sequelize";
+import { sequelize } from "./index";
+import { ITestimonialModelAttributes } from "../../interfaces/testimonialInterface";
+import { TTestimonialModelCreationAttributes } from "../../types/testimonialType";
+import {
+  COMMAN_STATUS,
+  USER_INSTITUTE_META_STATUS,
+  USER_TYPES,
+} from "../../constants/app";
+import UserModel from "./userModel";
+import InstituteModel from "./instituteModel";
+import {
+  INSTITUTE_ERROR_MESSAGES,
+  USER_ERROR_MESSAGES,
+  USER_INSTITUTE_META_ERROR_MESSAGES,
+} from "../../constants/errorMessages";
+import {
+  capitalizeFirst,
+  fromSnakeCaseToNormalText,
+} from "../../helpers/utils";
+import { IUserAttributes } from "../../interfaces/userInterface";
+import InstituteEntityModel from "./instituteEntityModel";
+import UserInstituteMeta from "../mongodb/userInstituteMetaModel";
+
+class TestimonialModel extends Model<
+  ITestimonialModelAttributes,
+  TTestimonialModelCreationAttributes
+> {
+  declare id: string;
+  declare instituteId: string;
+  declare message: string;
+  declare userId: string;
+  declare status: COMMAN_STATUS;
+  declare rating: number;
+  declare userType: USER_TYPES;
+  declare class?: string | null;
+
+  declare createdBy: string;
+  declare updatedBy: string;
+  declare deletedBy: string;
+  declare readonly createdAt: Date;
+  declare readonly updatedAt: Date;
+  declare readonly deletedAt?: Date;
+}
+
+TestimonialModel.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      allowNull: false,
+      primaryKey: true,
+    },
+    status: {
+      type: DataTypes.ENUM,
+      allowNull: false,
+      values: Object.values(COMMAN_STATUS),
+      defaultValue: COMMAN_STATUS.ACTIVE,
+    },
+    userType: {
+      type: DataTypes.ENUM,
+      allowNull: false,
+      values: Object.values(USER_TYPES),
+      defaultValue: USER_TYPES.STUDENT,
+    },
+    instituteId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+    },
+    userId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+    },
+    rating: {
+      type: DataTypes.FLOAT,
+      allowNull: false,
+    },
+    message: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+    },
+    class: {
+      type: DataTypes.STRING,
+      defaultValue: null,
+      allowNull: true,
+    },
+  },
+  {
+    modelName: "TestimonialModel",
+    tableName: "testimonials",
+    timestamps: true,
+    sequelize,
+  }
+);
+
+// Associations
+TestimonialModel.belongsTo(UserModel, {
+  foreignKey: {
+    name: "createdBy",
+    allowNull: true,
+    field: "created_by",
+  },
+  as: "createdByUser",
+});
+
+TestimonialModel.belongsTo(UserModel, {
+  foreignKey: {
+    name: "updatedBy",
+    allowNull: true,
+    field: "updated_by",
+  },
+  as: "updatedByUser",
+});
+
+TestimonialModel.belongsTo(UserModel, {
+  foreignKey: {
+    name: "deletedBy",
+    allowNull: true,
+    field: "deleted_by",
+  },
+  as: "deletedByUser",
+});
+
+TestimonialModel.belongsTo(InstituteModel, {
+  foreignKey: "instituteId",
+  as: "testimonialInstitute",
+});
+
+InstituteModel.hasMany(TestimonialModel, {
+  foreignKey: "instituteId",
+  as: "instituteHasTestimonials",
+});
+TestimonialModel.belongsTo(UserModel, {
+  foreignKey: "userId",
+  as: "testimonialUser",
+});
+UserModel.hasMany(TestimonialModel, {
+  foreignKey: "userId",
+  as: "userHasTestimonials",
+});
+
+const beforeCreateOrUpdateHook = async (testimonial: TestimonialModel) => {
+  if (testimonial.instituteId) {
+    const institute = await InstituteModel.findByPk(testimonial.instituteId);
+    if (!institute) {
+      throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+    }
+  }
+  let user: IUserAttributes | null = null;
+  if (testimonial.userId) {
+    user = await UserModel.findByPk(testimonial.userId);
+    if (!user) {
+      throw new Error(USER_ERROR_MESSAGES.NOT_FOUND);
+    }
+    testimonial.userType = user.type;
+  }
+  testimonial.class = `${fromSnakeCaseToNormalText(testimonial.userType)}`;
+  if (
+    testimonial.userId &&
+    testimonial.instituteId &&
+    testimonial.userType !== USER_TYPES.PARENTS
+  ) {
+    const meta = await UserInstituteMeta.findOne({
+      userId: testimonial.userId,
+      instituteId: testimonial.instituteId,
+      status: USER_INSTITUTE_META_STATUS.ACCEPTED,
+    });
+    if (!meta) {
+      throw new Error(USER_INSTITUTE_META_ERROR_MESSAGES.NOT_FOUND);
+    }
+    testimonial.userType = meta.userType;
+    let stdDataList = await InstituteEntityModel.findAll({
+      where: {
+        id: { [Op.in]: meta.entities },
+      },
+      include: {
+        association: "entityType",
+        required: true,
+        where: {
+          [Op.or]: [
+            { title: { [Op.iLike]: "STANDARD" } },
+            { title: { [Op.iLike]: "MEDIUM" } },
+            // { title: { [Op.iLike]: 'BOARD' } },
+            // { title: { [Op.iLike]: 'STREAM' } },
+            // { title: { [Op.iLike]: 'SUBJECT' } },
+          ],
+        },
+      },
+    });
+
+    stdDataList = JSON.parse(JSON.stringify(stdDataList));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const className =
+      (stdDataList as any).find(
+        (item: any) => item.entityType?.title === "STANDARD"
+      )?.title || null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mediumName =
+      (stdDataList as any).find(
+        (item: any) => item.entityType?.title === "MEDIUM"
+      )?.title || null;
+
+    testimonial.class = `${capitalizeFirst(
+      mediumName.substring(0, 3)
+    )} Medium ${capitalizeFirst(className)}`;
+  }
+};
+
+TestimonialModel.beforeCreate(beforeCreateOrUpdateHook);
+
+TestimonialModel.beforeBulkUpdate(async (options: UpdateOptions) => {
+  await beforeCreateOrUpdateHook(options.attributes);
+});
+
+export default TestimonialModel;

package/dist/models/psql/toDoModel.ts

@@ -0,0 +1,147 @@
+import { DataTypes, Model, UpdateOptions } from "sequelize";
+import { sequelize } from "./index";
+import { IToDoModelAttributes } from "../../interfaces/toDoInterface";
+import { TToDoModelCreationAttributes } from "../../types/toDoType";
+import { TO_DO_STATUS } from "../../constants/app";
+import UserModel from "./userModel";
+import InstituteModel from "./instituteModel";
+import {
+  INSTITUTE_ERROR_MESSAGES,
+  USER_ERROR_MESSAGES,
+} from "../../constants/errorMessages";
+
+class ToDoModel extends Model<
+  IToDoModelAttributes,
+  TToDoModelCreationAttributes
+> {
+  declare id: string;
+  declare instituteId?: string;
+  declare task: string;
+  declare userId: string;
+  declare dueDate?: Date;
+  declare remindMe?: Date;
+  declare status: TO_DO_STATUS;
+
+  declare createdBy: string;
+  declare updatedBy: string;
+  declare deletedBy: string;
+  declare readonly createdAt: Date;
+  declare readonly updatedAt: Date;
+  declare readonly deletedAt?: Date;
+}
+
+ToDoModel.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      allowNull: false,
+      primaryKey: true,
+    },
+    task: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+    },
+    instituteId: {
+      type: DataTypes.UUID,
+      field: "institute_id",
+      allowNull: true,
+    },
+    userId: {
+      type: DataTypes.UUID,
+      field: "user_id",
+      allowNull: false,
+    },
+    dueDate: {
+      type: DataTypes.DATE,
+      field: "due_date",
+      allowNull: true,
+    },
+    remindMe: {
+      type: DataTypes.DATE,
+      field: "remind_me",
+      allowNull: true,
+    },
+    status: {
+      type: DataTypes.ENUM,
+      allowNull: false,
+      values: Object.values(TO_DO_STATUS),
+      defaultValue: TO_DO_STATUS.PENDING,
+    },
+  },
+  {
+    modelName: "ToDoModel",
+    tableName: "toDos",
+    timestamps: true,
+    sequelize,
+  }
+);
+
+// Associations
+ToDoModel.belongsTo(UserModel, {
+  foreignKey: {
+    name: "createdBy",
+    allowNull: true,
+    field: "created_by",
+  },
+  as: "createdByUser",
+});
+
+ToDoModel.belongsTo(UserModel, {
+  foreignKey: {
+    name: "updatedBy",
+    allowNull: true,
+    field: "updated_by",
+  },
+  as: "updatedByUser",
+});
+
+ToDoModel.belongsTo(UserModel, {
+  foreignKey: {
+    name: "deletedBy",
+    allowNull: true,
+    field: "deleted_by",
+  },
+  as: "deletedByUser",
+});
+
+ToDoModel.belongsTo(InstituteModel, {
+  foreignKey: "instituteId",
+  as: "toDoInstitute",
+});
+
+InstituteModel.hasMany(ToDoModel, {
+  foreignKey: "instituteId",
+  as: "instituteHasToDos",
+});
+ToDoModel.belongsTo(UserModel, {
+  foreignKey: "userId",
+  as: "toDoUser",
+});
+UserModel.hasMany(ToDoModel, {
+  foreignKey: "userId",
+  as: "userHasToDos",
+});
+
+const beforeCreateOrUpdateHook = async (toDo: ToDoModel) => {
+  if (toDo.instituteId) {
+    const institute = await InstituteModel.findByPk(toDo.instituteId);
+    if (!institute) {
+      throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+    }
+  }
+  if (toDo.userId) {
+    const user = await UserModel.findByPk(toDo.userId);
+    if (!user) {
+      throw new Error(USER_ERROR_MESSAGES.NOT_FOUND);
+    }
+  }
+};
+
+ToDoModel.beforeCreate(beforeCreateOrUpdateHook);
+
+ToDoModel.beforeBulkUpdate(async (options: UpdateOptions) => {
+  await beforeCreateOrUpdateHook(options.attributes);
+});
+
+export default ToDoModel;

package/dist/models/psql/tokenModel.ts

@@ -0,0 +1,53 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index';
+import { ITokenAttributes } from '../../interfaces/tokenInterface';
+import { TOKEN_TYPES } from '../../constants/app';
+
+class TokenModel extends Model<ITokenAttributes> implements ITokenAttributes {
+    declare id: string;
+    declare token: string;
+    declare userId: string;
+    declare type: TOKEN_TYPES;
+    declare expiresAt: Date;
+    declare blacklisted: boolean;
+
+    declare readonly createdAt: Date;
+    declare readonly deletedAt: string;
+    declare readonly updatedAt: Date;
+}
+
+TokenModel.init(
+    {
+        id: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+            autoIncrement: true,
+            primaryKey: true,
+        },
+        token: {
+            type: DataTypes.STRING,
+            allowNull: false,
+        },
+        type: {
+            type: DataTypes.STRING,
+            allowNull: false,
+        },
+        expiresAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+            field: 'expires_at',
+        },
+        blacklisted: {
+            type: DataTypes.BOOLEAN,
+            defaultValue: false,
+        },
+    },
+    {
+        sequelize,
+        modelName: 'TokenModel',
+        tableName: 'tokens',
+        timestamps: true,
+    },
+);
+
+export default TokenModel;