@common_ch/common 1.0.42 → 1.0.46

package/build/events/app/feedback/feedback-create-event.d.ts

@@ -0,0 +1,17 @@
+import { Subjects } from "../../subjects";
+export declare enum FeedbackTypeEnum {
+    suggestion = "suggestion",
+    complaint = "complaint",
+    review = "review"
+}
+export interface FeedbackCreatedEvent {
+    subject: Subjects.FeedbackCreatedEvent;
+    data: {
+        id: string;
+        userId: string;
+        aiId?: string;
+        comment?: string;
+        rating?: number;
+        type: FeedbackTypeEnum;
+    };
+}

package/build/events/app/feedback/feedback-create-event.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackTypeEnum = void 0;
+var FeedbackTypeEnum;
+(function (FeedbackTypeEnum) {
+    FeedbackTypeEnum["suggestion"] = "suggestion";
+    FeedbackTypeEnum["complaint"] = "complaint";
+    FeedbackTypeEnum["review"] = "review";
+})(FeedbackTypeEnum || (exports.FeedbackTypeEnum = FeedbackTypeEnum = {}));

package/build/events/{app → portal}/ticket/ticket-answered-event.ts.d.ts

@@ -1,5 +1,5 @@
 import { Subjects } from "../../subjects";
-import { TicketStatusEnum } from "./ticket-created-event";
+import { TicketStatusEnum } from "../../app/ticket/ticket-created-event";
 export interface TicketAnsweredEvent {
     subject: Subjects.TicketAnswered;
     data: {

package/build/events/subjects.d.ts

@@ -13,5 +13,6 @@ export declare enum Subjects {
     DiscountUpdated = "discount:updated",
     DiscountChangeStatus = "discount:change-status",
     TicketCreated = "ticket:created",
-    TicketAnswered = "ticket:answered"
+    TicketAnswered = "ticket:answered",
+    FeedbackCreatedEvent = "feedback:created"
 }

package/build/events/subjects.js

@@ -18,4 +18,5 @@ var Subjects;
     Subjects["DiscountChangeStatus"] = "discount:change-status";
     Subjects["TicketCreated"] = "ticket:created";
     Subjects["TicketAnswered"] = "ticket:answered";
+    Subjects["FeedbackCreatedEvent"] = "feedback:created";
 })(Subjects || (exports.Subjects = Subjects = {}));

package/build/index.d.ts

@@ -9,6 +9,16 @@ export * from './middlewares/current-admin';
 export * from './middlewares/error-handler';
 export * from './middlewares/require-auth';
 export * from './middlewares/require-auth-admin';
+export * from './models/app/ai';
+export * from './models/app/blog';
+export * from './models/app/discount';
+export * from './models/app/feedback';
+export * from './models/app/image';
+export * from './models/app/message';
+export * from './models/app/plan';
+export * from './models/app/ticket';
+export * from './models/app/user';
+export * from './models/app/voice';
 export * from './events/base-listener';
 export * from './events/base-publisher';
 export * from './events/subjects';
@@ -27,5 +37,6 @@ export * from './events/portal/blog/blog-change-status-event';
 export * from './events/portal/discount/discount-create-event';
 export * from './events/portal/discount/discount-update-event';
 export * from './events/portal/discount/discount-change-status-event';
-export * from './events/app/ticket/ticket-answered-event.ts';
+export * from './events/portal/ticket/ticket-answered-event.ts';
 export * from './events/app/ticket/ticket-created-event';
+export * from './events/app/feedback/feedback-create-event';

package/build/index.js

@@ -25,6 +25,16 @@ __exportStar(require("./middlewares/current-admin"), exports);
 __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/require-auth-admin"), exports);
+__exportStar(require("./models/app/ai"), exports);
+__exportStar(require("./models/app/blog"), exports);
+__exportStar(require("./models/app/discount"), exports);
+__exportStar(require("./models/app/feedback"), exports);
+__exportStar(require("./models/app/image"), exports);
+__exportStar(require("./models/app/message"), exports);
+__exportStar(require("./models/app/plan"), exports);
+__exportStar(require("./models/app/ticket"), exports);
+__exportStar(require("./models/app/user"), exports);
+__exportStar(require("./models/app/voice"), exports);
 __exportStar(require("./events/base-listener"), exports);
 __exportStar(require("./events/base-publisher"), exports);
 __exportStar(require("./events/subjects"), exports);
@@ -43,5 +53,6 @@ __exportStar(require("./events/portal/blog/blog-change-status-event"), exports);
 __exportStar(require("./events/portal/discount/discount-create-event"), exports);
 __exportStar(require("./events/portal/discount/discount-update-event"), exports);
 __exportStar(require("./events/portal/discount/discount-change-status-event"), exports);
-__exportStar(require("./events/app/ticket/ticket-answered-event.ts"), exports);
+__exportStar(require("./events/portal/ticket/ticket-answered-event.ts"), exports);
 __exportStar(require("./events/app/ticket/ticket-created-event"), exports);
+__exportStar(require("./events/app/feedback/feedback-create-event"), exports);

package/build/models/app/ai.d.ts

@@ -0,0 +1,26 @@
+import mongoose from 'mongoose';
+import { AiStatusEnum } from '../../events/types_/ai';
+export interface AiAttrs {
+    _id: string;
+    name: string;
+    status?: AiStatusEnum;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface AiDoc extends mongoose.Document {
+    _id: string;
+    name: string;
+    status: AiStatusEnum;
+    version: number;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface AiModel extends mongoose.Model<AiDoc> {
+    build(attrs: AiAttrs): AiDoc;
+    findByEvent(event: {
+        id: string;
+        version: number;
+    }): Promise<AiDoc | null>;
+}
+declare const Ai: AiModel;
+export { Ai };

package/build/models/app/ai.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ai = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const ai_1 = require("../../events/types_/ai");
+const aiSchema = new mongoose_1.default.Schema({
+    name: {
+        type: String,
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: ai_1.AiStatusEnum,
+        default: ai_1.AiStatusEnum.active,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    updatedAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+}, {
+    timestamps: true,
+});
+aiSchema.set('versionKey', 'version');
+aiSchema.pre('save', function (done) {
+    // @ts-ignore
+    this.$where = {
+        version: this.get('version') - 1,
+    };
+    done();
+});
+aiSchema.statics.build = (attrs) => {
+    return new Ai({
+        _id: attrs._id,
+        status: attrs.status,
+        name: attrs.name,
+        createdAt: attrs.createdAt,
+        updatedAt: attrs.updatedAt,
+    });
+};
+aiSchema.statics.findByEvent = (event) => {
+    return Ai.findOne({
+        _id: event.id,
+        version: event.version - 1,
+    });
+};
+const Ai = mongoose_1.default.model('Ai', aiSchema);
+exports.Ai = Ai;

package/build/models/app/blog.d.ts

@@ -0,0 +1,36 @@
+import mongoose from 'mongoose';
+import { BlogStatusEnum } from '../../events/portal/blog/blog-create-event';
+export interface BlogAttrs {
+    _id: string;
+    title: string;
+    publishDate?: number;
+    shortDescription: string;
+    description: string;
+    status: BlogStatusEnum;
+    category: string;
+    mainPic: string;
+    alt: string;
+    anotherPics?: string[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface BlogModel extends mongoose.Model<BlogDoc> {
+    build(attrs: BlogAttrs): BlogDoc;
+}
+export interface BlogDoc extends mongoose.Document {
+    _id: string;
+    version: number;
+    title: string;
+    publishDate?: number;
+    shortDescription: string;
+    description: string;
+    status: BlogStatusEnum;
+    category: string;
+    mainPic: string;
+    alt: string;
+    anotherPics?: string[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+declare const Blog: BlogModel;
+export { Blog };

package/build/models/app/blog.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blog = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+const blog_create_event_1 = require("../../events/portal/blog/blog-create-event");
+const blogSchema = new mongoose_1.default.Schema({
+    title: {
+        type: String,
+        required: true,
+    },
+    publishDate: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    shortDescription: {
+        type: String,
+        required: true,
+    },
+    description: {
+        type: String,
+        required: true,
+    },
+    category: {
+        type: String,
+        required: true,
+    },
+    mainPic: {
+        type: String,
+        required: true,
+    },
+    alt: {
+        type: String,
+        required: true,
+    },
+    anotherPics: [
+        {
+            type: String,
+            required: false,
+        },
+    ],
+    status: {
+        type: String,
+        enum: blog_create_event_1.BlogStatusEnum,
+        default: blog_create_event_1.BlogStatusEnum.active,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    updatedAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+}, {
+    timestamps: true,
+});
+blogSchema.set('versionKey', 'version');
+blogSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+blogSchema.statics.build = (attrs) => {
+    return new Blog(attrs);
+};
+const Blog = mongoose_1.default.model('Blog', blogSchema);
+exports.Blog = Blog;

package/build/models/app/discount.d.ts

@@ -0,0 +1,37 @@
+import mongoose from 'mongoose';
+import { UserDoc } from './user';
+import { PlanDoc } from './plan';
+import { DiscountStatusEnum, DiscountType } from '../../events/portal/discount/discount-create-event';
+export interface DiscountAttrs {
+    _id: string;
+    title: string;
+    type: DiscountType;
+    amount: string;
+    startDate: Date;
+    endDate: Date;
+    users: string[] | UserDoc[];
+    version: number;
+    plan?: PlanDoc | string;
+    status?: DiscountStatusEnum;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface DiscountModel extends mongoose.Model<DiscountDoc> {
+    build(attrs: DiscountAttrs): DiscountDoc;
+}
+export interface DiscountDoc extends mongoose.Document {
+    _id: string;
+    title: string;
+    type: DiscountType;
+    amount: string;
+    startDate: Date;
+    endDate: Date;
+    users: UserDoc[] | string[];
+    plan?: PlanDoc | string;
+    status: DiscountStatusEnum;
+    version: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+declare const Discount: DiscountModel;
+export { Discount };

package/build/models/app/discount.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Discount = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+const discount_create_event_1 = require("../../events/portal/discount/discount-create-event");
+const discountSchema = new mongoose_1.default.Schema({
+    title: {
+        type: String,
+        required: true,
+    },
+    type: {
+        type: String,
+        enum: discount_create_event_1.DiscountType,
+        required: true,
+    },
+    amount: {
+        type: String,
+        required: true,
+    },
+    startDate: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    endDate: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    status: {
+        type: String,
+        enum: discount_create_event_1.DiscountStatusEnum,
+        default: discount_create_event_1.DiscountStatusEnum.active,
+    },
+    users: [{ type: mongoose_1.default.Schema.Types.ObjectId, ref: 'User' }],
+    plan: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Plan',
+        required: false,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    updatedAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+}, {
+    timestamps: true,
+});
+discountSchema.set('versionKey', 'version');
+discountSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+discountSchema.statics.build = (attrs) => {
+    return new Discount(attrs);
+};
+const Discount = mongoose_1.default.model('Discount', discountSchema);
+exports.Discount = Discount;

package/build/models/app/feedback.d.ts

@@ -0,0 +1,27 @@
+import mongoose from 'mongoose';
+import { FeedbackTypeEnum } from '../../events/app/feedback/feedback-create-event';
+export interface FeedbackAttrs {
+    userId: string;
+    aiId?: string;
+    comment?: string;
+    rating?: number;
+    type: FeedbackTypeEnum;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface FeedbackModel extends mongoose.Model<FeedbackDoc> {
+    build(attrs: FeedbackAttrs): FeedbackDoc;
+}
+export interface FeedbackDoc extends mongoose.Document {
+    _id: string;
+    userId: string;
+    aiId?: string;
+    comment?: string;
+    rating?: number;
+    type: FeedbackTypeEnum;
+    createdAt?: number;
+    updatedAt?: number;
+    version: number;
+}
+declare const Feedback: FeedbackModel;
+export { Feedback };

package/build/models/app/feedback.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Feedback = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+const feedback_create_event_1 = require("../../events/app/feedback/feedback-create-event");
+const feedbackSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+    },
+    aiId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Ai',
+        required: false,
+    },
+    comment: {
+        type: String,
+        trim: true,
+        required: false,
+    },
+    rating: {
+        type: Number,
+        min: 1,
+        max: 5,
+        required: false,
+    },
+    type: {
+        type: String,
+        enum: feedback_create_event_1.FeedbackTypeEnum,
+        required: true,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    updatedAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+}, {
+    timestamps: true,
+});
+feedbackSchema.set('versionKey', 'version');
+feedbackSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+feedbackSchema.statics.build = (attrs) => {
+    return new Feedback(attrs);
+};
+const Feedback = mongoose_1.default.model('Feedback', feedbackSchema);
+exports.Feedback = Feedback;

package/build/models/app/image.d.ts

@@ -0,0 +1,39 @@
+import mongoose from 'mongoose';
+import { AiAttrs, AiDoc } from './ai';
+export declare enum ImageRoleEnum {
+    system = "system",
+    user = "user",
+    assistant = "assistant"
+}
+export interface ImageAttrs {
+    userId: string;
+    imageName: string;
+    planId?: string;
+    images: {
+        ai: string | AiAttrs;
+        role: ImageRoleEnum;
+        content: string;
+        createdAt: string;
+    }[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface ImageModel extends mongoose.Model<ImageDoc> {
+    build(attrs: ImageAttrs): ImageDoc;
+}
+interface ImageDoc extends mongoose.Document {
+    _id: string;
+    userId: string;
+    imageName: string;
+    planId?: string;
+    images: {
+        ai: string | AiDoc;
+        role: ImageRoleEnum;
+        content: string;
+        createdAt: string;
+    }[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+declare const ImageModel: ImageModel;
+export { ImageModel };

package/build/models/app/image.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageModel = exports.ImageRoleEnum = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+var ImageRoleEnum;
+(function (ImageRoleEnum) {
+    ImageRoleEnum["system"] = "system";
+    ImageRoleEnum["user"] = "user";
+    ImageRoleEnum["assistant"] = "assistant";
+})(ImageRoleEnum || (exports.ImageRoleEnum = ImageRoleEnum = {}));
+const ImageSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: String,
+        required: true,
+    },
+    imageName: {
+        type: String,
+        required: true,
+    },
+    planId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Plan',
+        required: false,
+    },
+    images: [
+        {
+            ai: {
+                type: mongoose_1.default.Schema.Types.ObjectId,
+                ref: 'Ai',
+            },
+            role: {
+                type: String,
+                required: true,
+                enum: Object.values(ImageRoleEnum),
+            },
+            content: {
+                type: String,
+                required: true,
+            },
+            createdAt: {
+                type: mongoose_1.default.Schema.Types.Date,
+                required: true,
+            },
+        },
+    ],
+    createdAt: mongoose_1.default.Schema.Types.Date,
+    updatedAt: mongoose_1.default.Schema.Types.Date,
+}, {
+    timestamps: true,
+});
+ImageSchema.set('versionKey', 'version');
+ImageSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+ImageSchema.statics.build = (attrs) => {
+    return new ImageModel(attrs);
+};
+const ImageModel = mongoose_1.default.model('Image', ImageSchema);
+exports.ImageModel = ImageModel;

package/build/models/app/message.d.ts

@@ -0,0 +1,41 @@
+import mongoose from 'mongoose';
+import { AiAttrs, AiDoc } from './ai';
+export declare enum MessageRoleEnum {
+    system = "system",
+    user = "user",
+    assistant = "assistant"
+}
+export interface MessageAttrs {
+    userId: string;
+    messageName: string;
+    planId?: string;
+    threadChatgptId?: string;
+    messages: {
+        ai: string | AiAttrs;
+        role: MessageRoleEnum;
+        content: string;
+        createdAt: string;
+    }[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface MessageModel extends mongoose.Model<MessageDoc> {
+    build(attrs: MessageAttrs): MessageDoc;
+}
+interface MessageDoc extends mongoose.Document {
+    _id: string;
+    userId: string;
+    messageName: string;
+    planId?: string;
+    threadChatgptId?: string;
+    messages: {
+        ai: string | AiDoc;
+        role: MessageRoleEnum;
+        content: string;
+        createdAt: string;
+    }[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+declare const Message: MessageModel;
+export { Message };

package/build/models/app/message.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.MessageRoleEnum = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+var MessageRoleEnum;
+(function (MessageRoleEnum) {
+    MessageRoleEnum["system"] = "system";
+    MessageRoleEnum["user"] = "user";
+    MessageRoleEnum["assistant"] = "assistant";
+})(MessageRoleEnum || (exports.MessageRoleEnum = MessageRoleEnum = {}));
+const messageSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: String,
+        required: true,
+    },
+    messageName: {
+        type: String,
+        required: true,
+    },
+    planId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Plan',
+        required: false,
+    },
+    threadChatgptId: {
+        type: String,
+        required: false,
+        default: null,
+    },
+    messages: [
+        {
+            ai: {
+                type: mongoose_1.default.Schema.Types.ObjectId,
+                ref: 'Ai',
+            },
+            role: {
+                type: String,
+                required: true,
+                enum: Object.values(MessageRoleEnum),
+            },
+            content: {
+                type: String,
+                required: true,
+            },
+            createdAt: {
+                type: mongoose_1.default.Schema.Types.Date,
+                required: true,
+            },
+        },
+    ],
+    createdAt: mongoose_1.default.Schema.Types.Date,
+    updatedAt: mongoose_1.default.Schema.Types.Date,
+}, {
+    timestamps: true,
+});
+messageSchema.set('versionKey', 'version');
+messageSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+messageSchema.statics.build = (attrs) => {
+    return new Message(attrs);
+};
+const Message = mongoose_1.default.model('Message', messageSchema);
+exports.Message = Message;

package/build/models/app/plan.d.ts

@@ -0,0 +1,34 @@
+import mongoose from 'mongoose';
+import { AisEnum } from '../../events/types_/ai';
+export declare enum PlanStatusEnum {
+    active = "active",
+    deactive = "deactive"
+}
+export interface PlanAttrs {
+    price: string;
+    name: string;
+    limitOfRequest: number;
+    limitUploadFiles: number;
+    ais: AisEnum[];
+    description?: string;
+    status?: PlanStatusEnum;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface PlanModel extends mongoose.Model<PlanDoc> {
+    build(attrs: PlanAttrs): PlanDoc;
+}
+export interface PlanDoc extends mongoose.Document {
+    _id: string;
+    price: string;
+    name: string;
+    limitOfRequest: number;
+    limitUploadFiles: number;
+    ais: AisEnum[];
+    description?: string;
+    status?: PlanStatusEnum;
+    createdAt?: number;
+    updatedAt?: number;
+}
+declare const Plan: PlanModel;
+export { Plan };

package/build/models/app/plan.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plan = exports.PlanStatusEnum = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+const ai_1 = require("../../events/types_/ai");
+var PlanStatusEnum;
+(function (PlanStatusEnum) {
+    PlanStatusEnum["active"] = "active";
+    PlanStatusEnum["deactive"] = "deactive";
+})(PlanStatusEnum || (exports.PlanStatusEnum = PlanStatusEnum = {}));
+const planSchema = new mongoose_1.default.Schema({
+    price: {
+        type: String,
+        required: true,
+    },
+    name: {
+        type: String,
+        required: true,
+    },
+    limitOfRequest: {
+        type: Number,
+        required: true,
+    },
+    limitUploadFiles: {
+        type: Number,
+        required: true,
+    },
+    ais: [
+        {
+            type: String,
+            required: true,
+            enum: Object.values(ai_1.AisEnum),
+        },
+    ],
+    description: {
+        type: String,
+        required: false,
+    },
+    status: {
+        type: String,
+        enum: PlanStatusEnum,
+        default: PlanStatusEnum.active,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    updatedAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+}, {
+    timestamps: true,
+});
+planSchema.set('versionKey', 'version');
+planSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+planSchema.statics.build = (attrs) => {
+    return new Plan(attrs);
+};
+const Plan = mongoose_1.default.model('Plan', planSchema);
+exports.Plan = Plan;

package/build/models/app/ticket.d.ts

@@ -0,0 +1,31 @@
+import mongoose from 'mongoose';
+import { TicketStatusEnum, TicketTypeEnum } from '../../events/app/ticket/ticket-created-event';
+export interface TicketAttrs {
+    userId: string;
+    title: string;
+    description: string;
+    file: string;
+    type: TicketTypeEnum;
+    response?: string;
+    status?: TicketStatusEnum;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface TicketModel extends mongoose.Model<TicketDoc> {
+    build(attrs: TicketAttrs): TicketDoc;
+}
+export interface TicketDoc extends mongoose.Document {
+    _id: string;
+    userId: string;
+    title: string;
+    description: string;
+    file: string;
+    type: TicketTypeEnum;
+    version: number;
+    response?: string;
+    status?: TicketStatusEnum;
+    createdAt?: number;
+    updatedAt?: number;
+}
+declare const Ticket: TicketModel;
+export { Ticket };

package/build/models/app/ticket.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ticket = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+const ticket_created_event_1 = require("../../events/app/ticket/ticket-created-event");
+const ticketSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+    },
+    title: {
+        type: String,
+        required: true,
+    },
+    description: {
+        type: String,
+        required: true,
+    },
+    file: {
+        type: String,
+        required: true,
+    },
+    response: {
+        type: String,
+        required: false,
+    },
+    type: {
+        type: String,
+        enum: Object.values(ticket_created_event_1.TicketTypeEnum),
+        required: true,
+        default: ticket_created_event_1.TicketTypeEnum.general,
+    },
+    status: {
+        type: String,
+        enum: ticket_created_event_1.TicketStatusEnum,
+        default: ticket_created_event_1.TicketStatusEnum.active,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+    updatedAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+    },
+}, {
+    timestamps: true,
+});
+ticketSchema.set('versionKey', 'version');
+ticketSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+ticketSchema.statics.build = (attrs) => {
+    return new Ticket(attrs);
+};
+const Ticket = mongoose_1.default.model('Ticket', ticketSchema);
+exports.Ticket = Ticket;

package/build/models/app/user.d.ts

@@ -0,0 +1,47 @@
+import mongoose from 'mongoose';
+export declare enum userStatusEnum {
+    active = "active",
+    deactive = "deactive"
+}
+export interface UserAttrs {
+    _id: string;
+    walletBalance?: mongoose.Types.Decimal128;
+    planId?: string;
+    startTimePlan?: string;
+    exTimePlan?: string;
+    amountApiExistPlan?: number;
+    email?: string;
+    username?: string;
+    mobile?: string;
+    status?: userStatusEnum;
+    name?: string;
+    family?: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface UserModel extends mongoose.Model<UserDoc> {
+    build(attrs: UserAttrs): UserDoc;
+}
+export interface UserDoc extends mongoose.Document {
+    walletBalance: mongoose.Types.Decimal128;
+    version: number;
+    planId?: string;
+    startTimePlan?: string;
+    exTimePlan?: string;
+    amountApiExistPlan?: number;
+    email?: string;
+    username?: string;
+    mobile?: string;
+    status?: string;
+    name?: string;
+    family?: string;
+    apiUsed?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    updateWalletBalance(amount: number): Promise<{
+        newBalance: string;
+        version: number;
+    }>;
+}
+declare const User: UserModel;
+export { User };

package/build/models/app/user.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = exports.userStatusEnum = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+var userStatusEnum;
+(function (userStatusEnum) {
+    userStatusEnum["active"] = "active";
+    userStatusEnum["deactive"] = "deactive";
+})(userStatusEnum || (exports.userStatusEnum = userStatusEnum = {}));
+const userSchema = new mongoose_1.default.Schema({
+    email: {
+        type: String,
+        required: false,
+    },
+    mobile: {
+        type: String,
+        required: true,
+    },
+    username: {
+        type: String,
+        required: false,
+    },
+    name: {
+        type: String,
+        required: false,
+    },
+    family: {
+        type: String,
+        required: false,
+    },
+    walletBalance: {
+        type: mongoose_1.default.Schema.Types.Decimal128,
+        default: mongoose_1.default.Types.Decimal128.fromString('0.00'),
+    },
+    apiUsed: {
+        type: String,
+        required: false,
+        default: '0',
+    },
+    status: {
+        type: String,
+        enum: userStatusEnum,
+        default: userStatusEnum.active,
+    },
+    createdAt: {
+        type: Number,
+    },
+    updatedAt: {
+        type: Number,
+    },
+}, {
+    timestamps: true,
+});
+userSchema.set('versionKey', 'version');
+userSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+userSchema.statics.build = (attrs) => {
+    return new User(attrs);
+};
+userSchema.methods.updateWalletBalance = function (amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const currentBalance = parseFloat(this.walletBalance.toString());
+        const newBalance = currentBalance + amount;
+        this.walletBalance = mongoose_1.default.Types.Decimal128.fromString(newBalance.toFixed(2)); //2 ragham ashar
+        yield this.save();
+        return { newBalance: this.walletBalance.toString(), version: this.version };
+    });
+};
+const User = mongoose_1.default.model('User', userSchema);
+exports.User = User;

package/build/models/app/voice.d.ts

@@ -0,0 +1,40 @@
+import mongoose from 'mongoose';
+import { AiAttrs, AiDoc } from './ai';
+export declare enum SpeechTypeEnum {
+    textToSpeech = "textToSpeech",
+    speechToText = "speechToText"
+}
+export interface SpeechAttrs {
+    userId: string;
+    speechName: string;
+    planId?: string;
+    speech: {
+        ai: string | AiAttrs;
+        type: SpeechTypeEnum;
+        file: string;
+        content: string;
+        createdAt: string;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface SpeechModel extends mongoose.Model<SpeechDoc> {
+    build(attrs: SpeechAttrs): SpeechDoc;
+}
+interface SpeechDoc extends mongoose.Document {
+    _id: string;
+    userId: string;
+    speechName: string;
+    planId?: string;
+    speech: {
+        ai: string | AiDoc;
+        type: SpeechTypeEnum;
+        file: string;
+        content: string;
+        createdAt: string;
+    }[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+declare const SpeechModel: SpeechModel;
+export { SpeechModel };

package/build/models/app/voice.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechModel = exports.SpeechTypeEnum = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+var SpeechTypeEnum;
+(function (SpeechTypeEnum) {
+    SpeechTypeEnum["textToSpeech"] = "textToSpeech";
+    SpeechTypeEnum["speechToText"] = "speechToText";
+})(SpeechTypeEnum || (exports.SpeechTypeEnum = SpeechTypeEnum = {}));
+const SpeechSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: String,
+        required: true,
+    },
+    speechName: {
+        type: String,
+        required: true,
+    },
+    planId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Plan',
+        required: false,
+    },
+    speech: {
+        ai: {
+            type: mongoose_1.default.Schema.Types.ObjectId,
+            ref: 'Ai',
+        },
+        type: {
+            type: String,
+            required: true,
+            enum: Object.values(SpeechTypeEnum),
+        },
+        content: {
+            type: String,
+            required: true,
+        },
+        file: {
+            type: String,
+            required: true,
+        },
+        createdAt: {
+            type: mongoose_1.default.Schema.Types.Date,
+            required: true,
+        },
+    },
+    createdAt: mongoose_1.default.Schema.Types.Date,
+    updatedAt: mongoose_1.default.Schema.Types.Date,
+}, {
+    timestamps: true,
+});
+SpeechSchema.set('versionKey', 'version');
+SpeechSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+SpeechSchema.statics.build = (attrs) => {
+    return new SpeechModel(attrs);
+};
+const SpeechModel = mongoose_1.default.model('Speech', SpeechSchema);
+exports.SpeechModel = SpeechModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@common_ch/common",
-  "version": "1.0.42",
+  "version": "1.0.46",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
@@ -28,6 +28,8 @@
     "express": "^4.21.2",
     "joi": "^17.13.3",
     "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.12.1",
+    "mongoose-update-if-current": "^1.4.0",
     "node-nats-streaming": "^0.3.2"
   }
 }