@cool-digital-solutions/interferir-models 1.0.0

package/dist/models/portia-article.model.d.ts

@@ -0,0 +1,2 @@
+import { IPortiaArticleModel } from '../types';
+export declare const PortiaArticleModel: IPortiaArticleModel;

package/dist/models/portia-article.model.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortiaArticleModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const portia_article_type_1 = require("../types/portia-article.type");
+const _config_1 = require("../config");
+const portiaArticleSchema = new mongoose_1.Schema({
+    slug: { type: String, required: [true, 'slug is required'], unique: true },
+    url: { type: String, required: [true, 'url is required'], unique: true },
+    downloadDate: { type: Number, required: [true, 'downloadDate is required'] },
+    authors: [{ type: String, default: '' }],
+    publishDate: { type: Number, required: [true, 'publishDate is required'] },
+    imageUrl: { type: String, default: '' },
+    image: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Image', default: null },
+    title: { type: String, default: '' },
+    articleType: {
+        type: String,
+        enum: Object.values(portia_article_type_1.PortiaArticleTypes),
+        required: [true, 'articleType is required.'],
+    },
+    description: { type: String, default: '' },
+    mainText: { type: String, required: [true, 'mainText is required'] },
+    language: {
+        type: String,
+        enum: Object.values(portia_article_type_1.PortiaArticleLanguages),
+        default: portia_article_type_1.PortiaArticleLanguages.ENGLISH,
+    },
+    sourceDomain: { type: String, default: '' },
+    hyperlinks: [{ type: String, default: '' }],
+    analysisResult: {
+        type: {
+            category: {
+                type: String,
+                enum: Object.values(portia_article_type_1.PortiaArticleCategories),
+                required: [true, 'articleCategory is required.'],
+            },
+            summary: {
+                type: String,
+                default: '',
+            },
+            companies: {
+                type: [
+                    {
+                        name: String,
+                        link: String,
+                        description: String,
+                    },
+                ],
+                default: [],
+            },
+            companyReferences: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Company' }],
+            investors: [{ type: String, default: '' }],
+        },
+        default: null,
+    },
+    cardDescription: { type: String, default: '' },
+    instantResearches: [
+        {
+            instantResearchId: { type: mongoose_1.Schema.Types.ObjectId, ref: 'InstantResearch' },
+            score: { type: Number, default: 0 },
+        },
+    ],
+    status: { type: String, enum: Object.values(_config_1.ContentStatus), required: [true, 'status is required!'], default: _config_1.ContentStatus.PUBLISH },
+    sfIndustries: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Industry' }],
+    sfTechnologies: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Technology' }],
+    sfCategories: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'SFCategory' }],
+    sfSubCategories: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'SFSubCategory' }],
+    sfTags: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'SFTag' }],
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+portiaArticleSchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        if (!notUpdatedBy)
+            this.updatedBy = user._id;
+    }
+    next();
+});
+portiaArticleSchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user && !notUpdatedBy)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.PortiaArticleModel = (0, mongoose_1.model)('PortiaArticle', portiaArticleSchema);

package/dist/models/problem.model.d.ts

@@ -0,0 +1,2 @@
+import { IProblemModel } from '../types';
+export declare const ProblemModel: IProblemModel;

package/dist/models/problem.model.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProblemModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const _config_1 = require("../config");
+const problemSchema = new mongoose_1.Schema({
+    title: { type: String },
+    slug: { type: String, required: [true, 'slug is required!'], unique: true },
+    content: { type: String },
+    contentHTML: { type: String },
+    themeList: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Theme' }],
+    useCaseList: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'UseCase' }],
+    writtenBy: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'User' }],
+    privForUsers: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'User' }],
+    status: { type: String, enum: Object.values(_config_1.ContentStatus), required: [true, 'status is required!'] },
+    draftVersionStatus: { type: String, default: '' },
+    likeCount: { type: Number, default: 0 },
+    dislikeCount: { type: Number, default: 0 },
+    evidenceCount: {
+        type: Object,
+        default: { publish: 0, private: 0, draft: 0, prePublish: 0 },
+    },
+    solutionCount: {
+        type: Object,
+        default: { publish: 0, private: 0, draft: 0, prePublish: 0 },
+    },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+}, _config_1.schemaOptions);
+problemSchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        if (!notUpdatedBy)
+            this.updatedBy = user._id;
+    }
+    next();
+});
+problemSchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user && !notUpdatedBy)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.ProblemModel = (0, mongoose_1.model)('Problem', problemSchema);

package/dist/models/search-history.model.d.ts

@@ -0,0 +1,2 @@
+import { ISearchHistoryModel } from '../types';
+export declare const SearchHistoryModel: ISearchHistoryModel;

package/dist/models/search-history.model.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchHistoryModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const _config_1 = require("../config");
+const searchHistorySchema = new mongoose_1.Schema({
+    user: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: 'User',
+        required: [true, 'user required!'],
+        index: true,
+    },
+    problem: { type: String, default: '' },
+    usecase: { type: String, default: '' },
+    evidenceList: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Evidence', index: true }],
+    searchDate: { type: Number, required: [true, 'searchDate required!'] },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+searchHistorySchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+searchHistorySchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SearchHistoryModel = (0, mongoose_1.model)('SearchHistory', searchHistorySchema);

package/dist/models/sf-category.model.d.ts

@@ -0,0 +1,2 @@
+import { ISFCategoryModel } from '../types';
+export declare const SFCategoryModel: ISFCategoryModel;

package/dist/models/sf-category.model.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFCategoryModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const _config_1 = require("../config");
+const sfCategorySchema = new mongoose_1.Schema({
+    name: { type: String, required: [true, 'name required!'], unique: true },
+    synonyms: { type: String, default: '' },
+    description: { type: String, default: '' },
+    industry: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Industry', default: null },
+    technology: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Technology', default: null },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+sfCategorySchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+sfCategorySchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SFCategoryModel = (0, mongoose_1.model)('SFCategory', sfCategorySchema);

package/dist/models/sf-sub-category.model.d.ts

@@ -0,0 +1,2 @@
+import { ISFSubCategoryModel } from '../types';
+export declare const SFSubCategoryModel: ISFSubCategoryModel;

package/dist/models/sf-sub-category.model.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFSubCategoryModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const _config_1 = require("../config");
+const sfSubCategorySchema = new mongoose_1.Schema({
+    name: { type: String, required: [true, 'name required!'], unique: true },
+    synonyms: { type: String, default: '' },
+    description: { type: String, default: '' },
+    category: { type: mongoose_1.Schema.Types.ObjectId, ref: 'SFCategory', default: null },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+sfSubCategorySchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+sfSubCategorySchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SFSubCategoryModel = (0, mongoose_1.model)('SFSubCategory', sfSubCategorySchema);

package/dist/models/sf-tag.model.d.ts

@@ -0,0 +1,2 @@
+import { ISFTagModel } from '../types';
+export declare const SFTagModel: ISFTagModel;

package/dist/models/sf-tag.model.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFTagModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const _config_1 = require("../config");
+const sfTagSchema = new mongoose_1.Schema({
+    name: { type: String, required: [true, 'name required!'], unique: true },
+    synonyms: { type: String, default: '' },
+    description: { type: String, default: '' },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+sfTagSchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+sfTagSchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SFTagModel = (0, mongoose_1.model)('SFTag', sfTagSchema);

package/dist/models/site-map-cache.model.d.ts

@@ -0,0 +1,2 @@
+import { ISiteMapCacheModel } from '../types';
+export declare const SiteMapCacheModel: ISiteMapCacheModel;

package/dist/models/site-map-cache.model.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiteMapCacheModel = void 0;
+const mongoose_1 = require("mongoose");
+const _config_1 = require("../config");
+const siteMapCacheSchema = new mongoose_1.Schema({
+    data: [
+        {
+            url: { type: String, required: [true, 'url is required'] },
+            lastModified: {
+                type: String,
+                required: [true, 'lastModified is required'],
+            },
+        },
+    ],
+    updatedDate: Number,
+    createdDate: Number,
+}, _config_1.schemaOptions);
+exports.SiteMapCacheModel = (0, mongoose_1.model)('SiteMapCache', siteMapCacheSchema);

package/dist/models/spark-use-case.model.d.ts

@@ -0,0 +1,2 @@
+import { ISparkUseCaseModel } from '../types';
+export declare const SparkUseCaseModel: ISparkUseCaseModel;

package/dist/models/spark-use-case.model.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparkUseCaseModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const spark_type_1 = require("../types/spark.type");
+const spark_use_case_type_1 = require("../types/spark-use-case.type");
+const _config_1 = require("../config");
+const sparkUseCaseSchema = new mongoose_1.Schema({
+    owner: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    slug: { type: String, required: [true, 'slug is required!'], unique: true },
+    spark: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Spark', index: 1, required: [true, 'spark is required'] },
+    priority: { type: String, required: [true, 'priority is required'], enum: Object.values(spark_type_1.SparkPriorityList) },
+    priorityLevel: { type: Number, default: 0 },
+    status: {
+        type: String,
+        enum: Object.values(spark_use_case_type_1.SparkUseCaseStatusList),
+        required: [true, 'status is required'],
+        default: spark_use_case_type_1.SparkUseCaseStatusList.DRAFT,
+    },
+    statusPriorityLevel: { type: Number, default: 3 },
+    useCaseStatus: { type: String, enum: Object.values(_config_1.ContentStatus), default: _config_1.ContentStatus.DRAFT },
+    problem: { type: String, default: '' },
+    problemSourceList: [{ type: String, required: [true, 'problemSource is required'] }],
+    solution: { type: String, default: '' },
+    solutionSourceList: [{ type: String, required: [true, 'solutionSource is reuqired'] }],
+    importance: { type: String, default: '' },
+    url: { type: String, default: '' },
+    importanceSourceList: [{ type: String, required: [true, 'importanceSource is required'] }],
+    rejectNote: { type: String, default: '' },
+    rejectSolutionNote: { type: String, default: '' },
+    rejectProblemNote: { type: String, default: '' },
+    rejectImportanceNote: { type: String, default: '' },
+    requestDeleteMessage: { type: String, default: '' },
+    feedbackMessage: { type: String, default: '' },
+    actors: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Company' }],
+    themeList: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Theme' }],
+    relatedUseCaseList: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'UseCase' }],
+    technologyList: [{ type: String, required: [true, 'technoloyList element is required!'] }],
+    industryList: [{ type: String, required: [true, 'industryList element is required!'] }],
+    entramindProblem: { type: String, default: '' },
+    entramindSolution: { type: String, default: '' },
+    entramindWhy: { type: String, default: '' },
+    writtenBy: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'User' }],
+    privForUsers: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'User' }],
+    entramindDetailedResponse: [
+        {
+            question: { type: String, default: '' },
+            answers: [
+                {
+                    answer: { type: String, default: '' },
+                    longContext: { type: String, default: '' },
+                },
+            ],
+        },
+    ],
+    sfIndustries: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Industry' }],
+    sfTechnologies: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Technology' }],
+    sfCategories: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'SFCategory' }],
+    sfSubCategories: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'SFSubCategory' }],
+    sfTags: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'SFTag' }],
+    fromEmptySparkUseCase: { type: Boolean, default: false },
+    projectLocation: [{ type: String, default: [] }],
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+sparkUseCaseSchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+sparkUseCaseSchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SparkUseCaseModel = (0, mongoose_1.model)('SparkUseCase', sparkUseCaseSchema);

package/dist/models/spark.model.d.ts

@@ -0,0 +1,2 @@
+import { ISparkModel } from '../types';
+export declare const SparkModel: ISparkModel;

package/dist/models/spark.model.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparkModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const company_type_1 = require("../types/company.type");
+const spark_type_1 = require("../types/spark.type");
+const _config_1 = require("../config");
+const sparkSchema = new mongoose_1.Schema({
+    companyName: { type: String, required: [true, 'companyName is required'] },
+    companyType: { type: String, required: [true, 'companyType is required'], enum: Object.values(company_type_1.CompanyTypes) },
+    refCompany: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Company', required: [true, 'refCompany is required'] },
+    website: { type: String, default: '' },
+    useCaseSourceList: [{ type: String, required: [true, 'useCaseSource is required'] }],
+    themeList: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Theme', index: true, default: null }],
+    priority: { type: String, required: [true, 'priority is required'], enum: Object.values(spark_type_1.SparkPriorityList) },
+    priorityLevel: { type: Number, index: -1, default: 0 },
+    note: { type: String, default: '' },
+    status: {
+        type: String,
+        required: [true, 'status is required'],
+        enum: Object.values(spark_type_1.SparkStatusList),
+        default: spark_type_1.SparkStatusList.EM_WORKING,
+    },
+    entramindStatus: {
+        type: String,
+        enum: Object.values(spark_type_1.EntramindStatusList),
+        default: spark_type_1.EntramindStatusList.CREATED,
+    },
+    entramindStartCount: { type: Number, default: 0 },
+    entramindErrorCount: { type: Number, default: 0 },
+    entramindSparkId: { type: String, default: '' },
+    entramindResponseMessageList: [
+        {
+            message: { type: String, default: '' },
+            date: { type: Number, default: 0 },
+            status: { type: Number, default: 500 },
+        },
+    ],
+    requester: {
+        requesterId: [{ type: mongoose_1.Schema.Types.ObjectId }],
+        requesterType: { type: String, enum: Object.values(spark_type_1.SparkRequesterType) },
+    },
+    projectLocation: { type: String, default: '' },
+    profileDetailUrls: [{ type: String, default: '' }],
+    autoPublish: { type: Boolean, default: false },
+    extraParameter: {
+        sendedNotWorkingAlertEmail: { type: Boolean, default: false },
+    },
+    rawContent: { type: String, default: '' },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+sparkSchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        if (!notUpdatedBy)
+            this.updatedBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+sparkSchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user && !notUpdatedBy)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SparkModel = (0, mongoose_1.model)('Spark', sparkSchema);

package/dist/models/suggest.model.d.ts

@@ -0,0 +1,2 @@
+import { ISuggestModel } from '../types';
+export declare const SuggestModel: ISuggestModel;

package/dist/models/suggest.model.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const suggest_type_1 = require("../types/suggest.type");
+const _config_1 = require("../config");
+const suggestSchema = new mongoose_1.Schema({
+    message: { type: String, required: [true, 'message is required'] },
+    user: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', required: true },
+    relatedId: { type: mongoose_1.Schema.Types.ObjectId, required: [true, 'relatedId is required'] },
+    relatedModel: { type: String, enum: Object.values(suggest_type_1.RelatedModels) },
+    files: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'Image', default: null }],
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+suggestSchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        if (!notUpdatedBy)
+            this.updatedBy = user._id;
+    }
+    next();
+});
+suggestSchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    const notUpdatedBy = express_http_context_1.default.get('notUpdatedBy');
+    if (user && !notUpdatedBy)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.SuggestModel = (0, mongoose_1.model)('Suggest', suggestSchema);

package/dist/models/technology.model.d.ts

@@ -0,0 +1,2 @@
+import { ITechnologyModel } from '../types';
+export declare const TechnologyModel: ITechnologyModel;

package/dist/models/technology.model.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TechnologyModel = void 0;
+const mongoose_1 = require("mongoose");
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const _config_1 = require("../config");
+const technologySchema = new mongoose_1.Schema({
+    name: { type: String, required: [true, 'name required!'], unique: true },
+    synonyms: { type: String, default: '' },
+    description: { type: String, default: '' },
+    createdBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedBy: { type: mongoose_1.Schema.Types.ObjectId, ref: 'User', default: null },
+    updatedDate: { type: Number, index: -1 },
+    createdDate: { type: Number, index: -1 },
+}, _config_1.schemaOptions);
+technologySchema.pre('save', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user) {
+        if (!this.createdBy)
+            this.createdBy = user._id;
+        this.updatedBy = user._id;
+    }
+    next();
+});
+technologySchema.pre('findOneAndUpdate', function (next) {
+    const user = express_http_context_1.default.get('user');
+    if (user)
+        this._update.updatedBy = user._id;
+    next();
+});
+exports.TechnologyModel = (0, mongoose_1.model)('Technology', technologySchema);

package/dist/models/theme.model.d.ts

@@ -0,0 +1,2 @@
+import { IThemeModel } from '../types';
+export declare const ThemeModel: IThemeModel;