@kipicore/dbcore 1.0.9 → 1.1.0

package/dist/src/models/psql/schoolFeeCollectionModel.d.ts

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { ISchoolFeesCollectionModelAttributes } from '../../interfaces/schoolFeeCollectionInterface.js';
+import { TSchoolFeeCollectionModelCreationAttributes } from '../../types/schoolFeeCollectionType.js';
+declare class SchoolFeeCollectionModel extends Model<ISchoolFeesCollectionModelAttributes, TSchoolFeeCollectionModelCreationAttributes> {
+    id: string;
+    date?: Date;
+    totalFeeAmount: number;
+    userId: string;
+    instituteId: string;
+    discount: number;
+    paidFee: number;
+    dueDate?: Date;
+    academicCalendarId: string;
+    perviousFeeCollectionId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt: Date;
+}
+export default SchoolFeeCollectionModel;

package/dist/src/models/psql/schoolFeeCollectionModel.js

@@ -0,0 +1,151 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import AcademicCalendarModel from './academicCalendarModel.js';
+class SchoolFeeCollectionModel extends Model {
+}
+SchoolFeeCollectionModel.init({
+    id: {
+        type: DataTypes.UUID,
+        primaryKey: true,
+        defaultValue: DataTypes.UUIDV4,
+    },
+    date: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+        allowNull: false,
+    },
+    totalFeeAmount: {
+        type: DataTypes.INTEGER,
+        field: 'total_fee_amount',
+        defaultValue: 0,
+        allowNull: false,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    discount: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: false,
+    },
+    paidFee: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        allowNull: false,
+    },
+    dueDate: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+    academicCalendarId: {
+        type: DataTypes.UUID,
+        field: 'academic_calendar_id',
+        allowNull: false,
+    },
+    perviousFeeCollectionId: {
+        type: DataTypes.UUID,
+        field: 'previous_fee_collection_id',
+        allowNull: true,
+    },
+}, {
+    modelName: 'SchoolFeeCollectionModel',
+    tableName: 'school_fee_collection',
+    timestamps: true,
+    sequelize,
+});
+SchoolFeeCollectionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+SchoolFeeCollectionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+SchoolFeeCollectionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+SchoolFeeCollectionModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+        allowNull: true,
+    },
+    as: 'schoolCollectionInstitute',
+});
+InstituteModel.hasMany(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+        allowNull: true,
+    },
+    as: 'instituteSchoolCollection',
+});
+SchoolFeeCollectionModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+        allowNull: true,
+    },
+    as: 'schoolCollectionUser',
+});
+UserModel.hasMany(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+        allowNull: true,
+    },
+    as: 'schoolCollectionHasUser',
+});
+SchoolFeeCollectionModel.belongsTo(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'perviousFeeCollectionId',
+        field: 'previous_fee_collection_id',
+        allowNull: true,
+    },
+    as: 'previousFeeCollection',
+});
+SchoolFeeCollectionModel.hasMany(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'perviousFeeCollectionId',
+        field: 'previous_fee_collection_id',
+        allowNull: true,
+    },
+    as: 'collectionPreviousCollection',
+});
+SchoolFeeCollectionModel.belongsTo(AcademicCalendarModel, {
+    foreignKey: {
+        name: 'academicCalendarId',
+        field: 'academic_calendar_id',
+        allowNull: true,
+    },
+    as: 'schoolCollectionCalendar',
+});
+AcademicCalendarModel.hasMany(SchoolFeeCollectionModel, {
+    foreignKey: {
+        name: 'academicCalendarId',
+        field: 'academic_calendar_id',
+        allowNull: true,
+    },
+    as: 'schoolCollectionHasCalendar',
+});
+export default SchoolFeeCollectionModel;

package/dist/src/models/psql/schoolOfferModel.d.ts

@@ -0,0 +1,29 @@
+import { Model } from 'sequelize';
+import { ISchoolOffersModelAttributes } from '../../interfaces/schoolOfferInterface.js';
+import { TSchoolOfferModelCreationAttributes } from '../../types/schoolOfferType.js';
+import { COMMAN_STATUS, OFFER_TYPE } from '../../constants/app.js';
+declare class SchoolOfferModel extends Model<ISchoolOffersModelAttributes, TSchoolOfferModelCreationAttributes> {
+    id: string;
+    type: OFFER_TYPE;
+    status?: COMMAN_STATUS;
+    userId?: string;
+    instituteId: string;
+    name?: string;
+    description?: string;
+    discount: number;
+    maximumDiscount?: number;
+    minimumFee?: number;
+    startTime?: Date;
+    endTime?: Date;
+    userLimit?: number;
+    noLimit: boolean;
+    account?: string;
+    applicableOn?: string[];
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default SchoolOfferModel;

package/dist/src/models/psql/schoolOfferModel.js

@@ -0,0 +1,162 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import { COMMAN_STATUS, OFFER_TYPE } from '../../constants/app.js';
+import InstituteModel from './instituteModel.js';
+import UserModel from './userModel.js';
+import BankAccountDetailsModel from './bankAccountDetailsModel.js';
+class SchoolOfferModel extends Model {
+}
+SchoolOfferModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    type: {
+        type: DataTypes.ENUM,
+        values: Object.values(OFFER_TYPE),
+        allowNull: false,
+    },
+    status: {
+        type: DataTypes.ENUM,
+        values: Object.values(COMMAN_STATUS),
+        allowNull: true,
+        defaultValue: COMMAN_STATUS.ACTIVE,
+    },
+    userId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+    },
+    name: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    description: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    discount: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+    },
+    maximumDiscount: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+    },
+    minimumFee: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+    },
+    startTime: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+    endTime: {
+        type: DataTypes.DATE,
+        allowNull: true,
+    },
+    userLimit: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 1,
+    },
+    noLimit: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+    },
+    account: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    applicableOn: {
+        type: DataTypes.ARRAY(DataTypes.UUID),
+        allowNull: true,
+    },
+}, {
+    modelName: 'SchoolOfferModel',
+    tableName: 'school_offers',
+    timestamps: true,
+    sequelize,
+});
+SchoolOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'userId',
+        field: 'user_id',
+    },
+    as: 'schoolOfferUser',
+});
+UserModel.hasMany(SchoolOfferModel, { foreignKey: 'userId', as: 'userHasSchoolOffers' });
+SchoolOfferModel.belongsTo(BankAccountDetailsModel, {
+    foreignKey: {
+        name: 'account',
+        allowNull: true,
+        field: 'account',
+    },
+    as: 'schoolOfferAccount',
+});
+BankAccountDetailsModel.hasMany(SchoolOfferModel, {
+    foreignKey: {
+        name: 'account',
+        allowNull: true,
+        field: 'account',
+    },
+    as: 'accountHasSchoolOffers',
+});
+SchoolOfferModel.belongsTo(InstituteModel, {
+    foreignKey: {
+        name: 'instituteId',
+        field: 'institute_id',
+    },
+    as: 'schoolOfferInstitute',
+});
+InstituteModel.hasMany(SchoolOfferModel, { foreignKey: 'instituteId', as: 'instituteHasSchoolOffers' });
+SchoolOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+SchoolOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+SchoolOfferModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+// const beforeCreateOrUpdateHook = async (offer: OfferModel) => {
+//     if (offer.instituteId) {
+//         const institute = await instituteService.findByPk(offer.instituteId);
+//         if (!institute) {
+//             throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+//         }
+//     }
+//     if (offer.userId) {
+//         const user = await userService.findByPk(offer.userId);
+//         if (!user) {
+//             throw new Error(USER_ERROR_MESSAGES.NOT_FOUND);
+//         }
+//     }
+// };
+// OfferModel.beforeCreate(beforeCreateOrUpdateHook);
+// OfferModel.beforeUpdate(beforeCreateOrUpdateHook);
+export default SchoolOfferModel;

package/dist/src/models/psql/sendNotificationModel.d.ts

@@ -0,0 +1,22 @@
+import { Model } from 'sequelize';
+import { NOTIFICATION_MODULE_TYPE, NOTIFICATION_STATUS } from '../../constants/app.js';
+import { INotificationModelAttributes } from '../../interfaces/sendNotificationInerface.js';
+import { TNotificationModelCreationAttributes } from '../../types/sendNotificationType.js';
+declare class SendNotificationModel extends Model<INotificationModelAttributes, TNotificationModelCreationAttributes> {
+    id: string;
+    senderId: string;
+    receiverId: string;
+    viewDate: Date;
+    status: NOTIFICATION_STATUS;
+    title: string;
+    message: string;
+    instituteId: string;
+    moduleType: NOTIFICATION_MODULE_TYPE;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default SendNotificationModel;

package/dist/src/models/psql/sendNotificationModel.js

@@ -0,0 +1,112 @@
+import { DataTypes, Model } from 'sequelize';
+import { NOTIFICATION_STATUS } from '../../constants/app.js';
+import { sequelize } from './index.js';
+import UserModel from './userModel.js';
+import InstituteModel from './instituteModel.js';
+class SendNotificationModel extends Model {
+}
+SendNotificationModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    title: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    message: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+    },
+    // type: {
+    //     type: DataTypes.STRING,
+    //     allowNull: true,
+    // },
+    senderId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: 'sender_id',
+    },
+    receiverId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: 'receiver_id',
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_Id',
+    },
+    // deviceToken: {
+    //     type: DataTypes.STRING,
+    //     allowNull: true,
+    //     field: 'device_token',
+    // },
+    viewDate: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: 'view_date',
+    },
+    status: {
+        type: DataTypes.STRING,
+        defaultValue: NOTIFICATION_STATUS.PENDING,
+    },
+    moduleType: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        field: 'module_type',
+    },
+}, {
+    modelName: 'SendnNotificationModel',
+    tableName: 'notifications',
+    sequelize,
+    timestamps: true,
+});
+// Associations
+SendNotificationModel.belongsTo(UserModel, {
+    foreignKey: 'senderId',
+    as: 'notificationSender',
+});
+SendNotificationModel.belongsTo(UserModel, {
+    foreignKey: 'receiverId',
+    as: 'notificationReceiver',
+});
+UserModel.hasMany(SendNotificationModel, {
+    foreignKey: 'senderId',
+    as: 'sentHasNotifications',
+});
+UserModel.hasMany(SendNotificationModel, {
+    foreignKey: 'receiverId',
+    as: 'receivedHasNotifications',
+});
+SendNotificationModel.belongsTo(InstituteModel, {
+    foreignKey: 'instituteId',
+    as: 'institute',
+});
+SendNotificationModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+SendNotificationModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+SendNotificationModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+export default SendNotificationModel;

package/dist/src/models/psql/slotModel.d.ts

@@ -0,0 +1,17 @@
+import { Model } from 'sequelize';
+import { ISlotModelAttributes } from '../../interfaces/slotInterface.js';
+import { TSlotModelCreationAttributes } from '../../types/slotType.js';
+import { SCHOOL_SHIFT } from '../../constants/app.js';
+declare class SlotModel extends Model<ISlotModelAttributes, TSlotModelCreationAttributes> {
+    id: string;
+    name: string;
+    instituteId: string;
+    type: SCHOOL_SHIFT;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+}
+export default SlotModel;

package/dist/src/models/psql/slotModel.js

@@ -0,0 +1,94 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import { SCHOOL_SHIFT } from '../../constants/app.js';
+import UserModel from './userModel.js';
+import InstituteModel from './instituteModel.js';
+import { INSTITUTE_ERROR_MESSAGES } from '../../constants/errorMessages.js';
+class SlotModel extends Model {
+}
+SlotModel.init({
+    id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    name: {
+        type: DataTypes.STRING,
+        allowNull: true,
+    },
+    instituteId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+    },
+    type: {
+        type: DataTypes.ENUM,
+        allowNull: false,
+        values: Object.values(SCHOOL_SHIFT),
+    },
+}, {
+    modelName: 'SlotModel',
+    tableName: 'slots',
+    indexes: [
+        {
+            name: 'institute_id_name',
+            unique: true,
+            fields: ['institute_id', 'name', 'type'],
+            // eslint-disable-next-line camelcase
+            where: { deleted_at: null },
+        },
+    ],
+    timestamps: true,
+    sequelize,
+});
+// Associations
+SlotModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+SlotModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+SlotModel.belongsTo(UserModel, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+SlotModel.belongsTo(InstituteModel, {
+    foreignKey: 'instituteId',
+    as: 'slotInstitute',
+});
+InstituteModel.hasMany(SlotModel, {
+    foreignKey: 'instituteId',
+    as: 'instituteHasSlots',
+});
+const beforeCreateOrUpdateHook = async (slot) => {
+    if (slot.instituteId) {
+        const institute = await InstituteModel.findByPk(slot.instituteId);
+        if (!institute) {
+            throw new Error(INSTITUTE_ERROR_MESSAGES.NOT_FOUND);
+        }
+    }
+};
+SlotModel.beforeCreate(beforeCreateOrUpdateHook);
+SlotModel.beforeBulkUpdate(async (options) => {
+    await beforeCreateOrUpdateHook(options.attributes);
+});
+SlotModel.beforeBulkCreate(async (instances) => {
+    for (const instance of instances) {
+        await beforeCreateOrUpdateHook(instance);
+    }
+});
+export default SlotModel;

package/dist/src/models/psql/stateModel.d.ts

@@ -0,0 +1,13 @@
+import { Model } from 'sequelize';
+import { IStateAttributes } from '../../interfaces/stateInterface.js';
+declare class StateModel extends Model<IStateAttributes> implements IStateAttributes {
+    id: number;
+    countryCode: string;
+    name: string;
+    stateCode: string;
+    isActive: boolean;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default StateModel;

package/dist/src/models/psql/stateModel.js

@@ -0,0 +1,53 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from './index.js';
+import CountryModel from './countryModel.js';
+class StateModel extends Model {
+}
+StateModel.init({
+    id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    countryCode: {
+        type: DataTypes.STRING(10),
+        allowNull: false,
+        field: 'country_code',
+    },
+    name: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+    },
+    stateCode: {
+        type: DataTypes.STRING(20),
+        allowNull: false,
+        unique: true,
+        field: 'state_code',
+    },
+    isActive: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: true,
+        field: 'is_active',
+    },
+}, {
+    sequelize,
+    modelName: 'StateModel',
+    tableName: 'states',
+    timestamps: true,
+});
+StateModel.belongsTo(CountryModel, {
+    foreignKey: {
+        name: 'countryId',
+        field: 'country_id',
+    },
+    as: 'country',
+});
+CountryModel.hasMany(StateModel, {
+    foreignKey: {
+        name: 'countryId',
+        field: 'country_id',
+    },
+    as: 'states',
+});
+export default StateModel;

package/dist/src/models/psql/subjectHasFeeModel.d.ts

@@ -0,0 +1,16 @@
+import { Model } from 'sequelize';
+import { ISubjectHasFeeModelAttributes } from '../../interfaces/subjectHasFeeInterface.js';
+import { TSubjectHasFeeModelCreationAttributes } from '../../types/subjectHasFeeType.js';
+declare class SubjectHasFeeModel extends Model<ISubjectHasFeeModelAttributes, TSubjectHasFeeModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    subjectId: string;
+    fee: number;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly deletedAt: string;
+    readonly updatedAt: Date;
+}
+export default SubjectHasFeeModel;