@kipicore/dbcore 1.1.410 → 1.1.412

package/dist/db/psql/migrations/20260410095026-add-userType-appType-to-terms-and-condition.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/20260410095026-add-userType-appType-to-terms-and-condition.js

@@ -0,0 +1,32 @@
+'use strict';
+const up = async (queryInterface, Sequelize) => {
+    const table = await queryInterface.describeTable('terms_and_condition');
+    if (!table.app_type) {
+        await queryInterface.addColumn('terms_and_condition', 'app_type', {
+            type: Sequelize.STRING,
+            allowNull: true,
+            field: 'app_type',
+        });
+    }
+    if (!table.user_type) {
+        await queryInterface.addColumn('terms_and_condition', 'user_type', {
+            type: Sequelize.STRING,
+            allowNull: true,
+            field: 'user_type',
+        });
+    }
+};
+const down = async (queryInterface) => {
+    const table = await queryInterface.describeTable('terms_and_condition');
+    // Remove only if column exists
+    if (table.app_type) {
+        await queryInterface.removeColumn('terms_and_condition', 'app_type');
+    }
+    if (table.user_type) {
+        await queryInterface.removeColumn('terms_and_condition', 'user_type');
+    }
+};
+module.exports = {
+    up,
+    down,
+};

package/dist/db/psql/migrations/20260410100410-user_accepted_terms_and_condition.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/20260410100410-user_accepted_terms_and_condition.js

@@ -0,0 +1,125 @@
+"use strict";
+const { type } = require("os");
+const up = async (queryInterface, Sequelize) => {
+    const tableName = 'user_accepted_terms_and_condition';
+    const tableExists = await queryInterface
+        .describeTable(tableName)
+        .then(() => true)
+        .catch(() => false);
+    if (!tableExists) {
+        await queryInterface.createTable(tableName, {
+            id: { type: Sequelize.UUID, defaultValue: Sequelize.UUIDV4, allowNull: false, primaryKey: true },
+            userId: { type: Sequelize.UUID, field: 'user_id', allowNull: true },
+            termsAndConditionId: { type: Sequelize.UUID, field: 'terms_and_condition_id', allowNull: true },
+            userType: {
+                type: Sequelize.STRING,
+                field: 'user_type',
+                allowNull: true,
+            },
+            appType: {
+                type: Sequelize.STRING,
+                field: 'app_type',
+                allowNull: true,
+            },
+            createdBy: {
+                type: Sequelize.UUID,
+                allowNull: true,
+                field: 'created_by',
+            },
+            updatedBy: {
+                type: Sequelize.UUID,
+                allowNull: true,
+                field: 'updated_by',
+            },
+            deletedBy: {
+                type: Sequelize.UUID,
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            createdAt: {
+                type: Sequelize.DATE,
+                allowNull: false,
+                field: 'created_at',
+            },
+            updatedAt: {
+                type: Sequelize.DATE,
+                allowNull: false,
+                field: 'updated_at',
+            },
+            deletedAt: {
+                type: Sequelize.DATE,
+                allowNull: true,
+                field: 'deleted_at',
+            },
+        });
+    }
+    else {
+        const tableDefinition = await queryInterface.describeTable(tableName);
+        const columnsToAdd = {
+            id: { type: Sequelize.UUID, defaultValue: Sequelize.UUIDV4, allowNull: false, primaryKey: true },
+            termsAndConditionId: { type: Sequelize.UUID, field: 'terms_and_condition_id', allowNull: true },
+            userId: { type: Sequelize.UUID, field: 'user_id', allowNull: true },
+            userType: {
+                type: Sequelize.STRING,
+                field: 'user_type',
+                allowNull: true,
+            },
+            appType: {
+                type: Sequelize.STRING,
+                field: 'app_type',
+                allowNull: true,
+            },
+            createdBy: {
+                type: Sequelize.UUID,
+                allowNull: true,
+                field: 'created_by',
+            },
+            updatedBy: {
+                type: Sequelize.UUID,
+                allowNull: true,
+                field: 'updated_by',
+            },
+            deletedBy: {
+                type: Sequelize.UUID,
+                allowNull: true,
+                field: 'deleted_by',
+            },
+            createdAt: {
+                type: Sequelize.DATE,
+                allowNull: false,
+                field: 'created_at',
+            },
+            updatedAt: {
+                type: Sequelize.DATE,
+                allowNull: false,
+                field: 'updated_at',
+            },
+            deletedAt: {
+                type: Sequelize.DATE,
+                allowNull: true,
+                field: 'deleted_at',
+            },
+        };
+        for (const column of Object.keys(columnsToAdd)) {
+            const columnToAdd = columnsToAdd[column];
+            const tableColumn = columnToAdd.field || column;
+            if (!tableDefinition[tableColumn]) {
+                await queryInterface.addColumn(tableName, tableColumn, columnToAdd);
+            }
+        }
+    }
+};
+const down = async (queryInterface) => {
+    const tableName = 'fee_history';
+    const tableExists = await queryInterface
+        .describeTable(tableName)
+        .then(() => true)
+        .catch(() => false);
+    if (tableExists) {
+        await queryInterface.dropTable(tableName);
+    }
+};
+module.exports = {
+    up,
+    down,
+};

package/dist/interfaces/modulePriceInterface.d.ts

@@ -2,8 +2,9 @@ import { Document } from 'mongoose';
 import { IDefaultAttributes } from './commonInterface';
 import { APP_TYPE } from '../constants';
 export interface IModulePriceList {
-    moduleCode: string;
-    price: number;
+    moduleCode: string[];
+    pricePerStudent: number;
+    pricePerUser: number;
     expiredDate?: Date;
     buyDate?: Date;
     totalPrice?: number;
@@ -13,6 +14,5 @@ export interface IModulePriceModelAttributes extends IDefaultAttributes, Documen
     title: string;
     moduleList: IModulePriceList[];
     totalPrice: number;
-    validityInDays: number;
     appType: APP_TYPE;
 }

package/dist/interfaces/termsAndConditionInterface.d.ts

@@ -1,4 +1,4 @@
-import { TERM_AND_CONDITION_STATUS } from '../constants/app';
+import { APP_TYPE, TERM_AND_CONDITION_STATUS, USER_TYPES } from '../constants/app';
 import { IDefaultAttributes } from './commonInterface';
 export interface ITermsAndConditionAttributes extends IDefaultAttributes {
     id: string;
@@ -6,4 +6,6 @@ export interface ITermsAndConditionAttributes extends IDefaultAttributes {
     status: TERM_AND_CONDITION_STATUS;
     startDate: Date;
     endDate: Date;
+    userType: USER_TYPES;
+    appType: APP_TYPE;
 }

package/dist/interfaces/userAcceptedTermsAndConditionInterface.d.ts

@@ -0,0 +1,9 @@
+import { APP_TYPE, USER_TYPES } from '../constants/app';
+import { IDefaultAttributes } from './commonInterface';
+export interface IUserAcceptedTermsAndConditionAttributes extends IDefaultAttributes {
+    id: string;
+    userId: string;
+    termsAndConditionId: string;
+    userType: USER_TYPES;
+    appType: APP_TYPE;
+}

package/dist/interfaces/userAcceptedTermsAndConditionInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/mongodb/modulePriceModel.js

@@ -36,19 +36,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
 const constants_1 = require("../../constants");
 const psql_1 = require("../psql");
+const sequelize_1 = require("sequelize");
 const modulePriceModelSchema = new mongoose_1.Schema({
     title: { type: String, required: true },
     moduleList: [
         {
             moduleCode: {
-                type: String,
+                type: [String],
                 required: true,
                 validate: {
                     validator: async function (value) {
                         const appType = this.ownerDocument().appType;
                         const module = await psql_1.ModuleModel.findOne({
                             where: {
-                                code: value,
+                                code: { [sequelize_1.Op.in]: value },
                                 isDefault: true,
                                 roleId: null,
                                 appType,
@@ -59,11 +60,11 @@ const modulePriceModelSchema = new mongoose_1.Schema({
                     message: 'Invalid module code: module not found or not allowed',
                 },
             },
-            price: { type: Number, required: true },
+            pricePerUser: { type: Number, required: true },
+            pricePerStudent: { type: Number, required: true },
         },
     ],
     totalPrice: { type: Number, required: true },
-    validityInDays: { type: Number, required: true },
     appType: {
         type: String,
         enum: Object.values(constants_1.APP_TYPE),

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

@@ -1,5 +1,5 @@
 import { Model } from 'sequelize';
-import { TERM_AND_CONDITION_STATUS } from '../../constants/app';
+import { APP_TYPE, TERM_AND_CONDITION_STATUS, USER_TYPES } from '../../constants/app';
 import { ITermsAndConditionAttributes } from '../../interfaces/termsAndConditionInterface';
 import { TTermsAndConditionCreationAttributes } from '../../types/termsAndConditionType';
 declare class TermsAndConditionModel extends Model<ITermsAndConditionAttributes, TTermsAndConditionCreationAttributes> {
@@ -8,6 +8,8 @@ declare class TermsAndConditionModel extends Model<ITermsAndConditionAttributes,
     fileStorageId: string;
     startDate: Date;
     endDate: Date;
+    userType: USER_TYPES;
+    appType: APP_TYPE;
     createdBy: string;
     updatedBy: string;
     deletedBy: string;

package/dist/models/psql/termsAndConditionModel.js

@@ -47,6 +47,16 @@ TermsAndConditionModel.init({
         allowNull: true,
         field: 'end_date',
     },
+    userType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'user_type',
+    },
+    appType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'app_type',
+    },
 }, {
     modelName: 'TermAndConditionModel',
     tableName: 'terms_and_condition',

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

@@ -0,0 +1,19 @@
+import { Model } from 'sequelize';
+import { APP_TYPE, USER_TYPES } from '../../constants/app';
+import { IUserAcceptedTermsAndConditionAttributes } from '../../interfaces/userAcceptedTermsAndConditionInterface';
+import { TUserAcceptedTermsAndConditionCreationAttributes } from '../../types/userAcceptedTermsAndConditionType';
+declare class UserAcceptedTermsAndCondition extends Model<IUserAcceptedTermsAndConditionAttributes, TUserAcceptedTermsAndConditionCreationAttributes> {
+    id: string;
+    userId: string;
+    appType: APP_TYPE;
+    userType: USER_TYPES;
+    termsAndConditionId: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedBy: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt: string;
+    static associate(models: any): void;
+}
+export default UserAcceptedTermsAndCondition;

package/dist/models/psql/userAcceptedTermsAndConditionModel.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class UserAcceptedTermsAndCondition extends sequelize_1.Model {
+    static associate(models) {
+        const { UserModel, TermAndConditionModel } = models;
+        UserAcceptedTermsAndCondition.belongsTo(UserModel, {
+            foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
+            as: 'createdByUser',
+        });
+        UserAcceptedTermsAndCondition.belongsTo(UserModel, {
+            foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
+            as: 'updatedByUser',
+        });
+        UserAcceptedTermsAndCondition.belongsTo(UserModel, {
+            foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
+            as: 'deletedByUser',
+        });
+        UserAcceptedTermsAndCondition.belongsTo(TermAndConditionModel, {
+            foreignKey: { name: 'termsAndConditionId', allowNull: true, field: 'terms_and_condition_id' },
+            as: 'userAcceptedTermsOfTermsAndCondition',
+        });
+        TermAndConditionModel.hasMany(UserAcceptedTermsAndCondition, {
+            foreignKey: { name: 'termsAndConditionId', allowNull: true, field: 'terms_and_condition_id' },
+            as: 'TermsAndConditionOfUserAcceptedTerms',
+        });
+    }
+}
+UserAcceptedTermsAndCondition.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    termsAndConditionId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'terms_and_condition_id',
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'user_id',
+    },
+    userType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'user_type',
+    },
+    appType: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'app_type',
+    },
+}, {
+    modelName: 'UserAcceptedTermsAndCondition',
+    tableName: 'user_accepted_terms_and_condition',
+    timestamps: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = UserAcceptedTermsAndCondition;

package/dist/types/userAcceptedTermsAndConditionType.d.ts

@@ -0,0 +1,3 @@
+import { Optional } from 'sequelize';
+import { IUserAcceptedTermsAndConditionAttributes } from '../interfaces/userAcceptedTermsAndConditionInterface';
+export type TUserAcceptedTermsAndConditionCreationAttributes = Optional<IUserAcceptedTermsAndConditionAttributes, 'id'>;

package/dist/types/userAcceptedTermsAndConditionType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

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