@fesmex/models 0.1.3 → 0.1.5

package/dist/announcements/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Announcement } from "./models/Announcements";
+export type { AnnouncementType } from "./models/Announcements";

package/dist/announcements/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Announcement = void 0;
+var Announcements_1 = require("./models/Announcements");
+Object.defineProperty(exports, "Announcement", { enumerable: true, get: function () { return __importDefault(Announcements_1).default; } });

package/dist/announcements/models/Announcements.d.ts

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+import { UserRole } from "../../users/models/Users";
+export interface AnnouncementType {
+    created_by: mongoose.Types.ObjectId;
+    updated_by?: mongoose.Types.ObjectId;
+    deleted_by?: mongoose.Types.ObjectId;
+    created_at: Date;
+    updated_at?: Date;
+    deleted_at?: Date;
+    title: string;
+    text: string;
+    roles: UserRole[];
+}
+declare const _default: mongoose.Model<AnnouncementType, {}, {}, {}, mongoose.Document<unknown, {}, AnnouncementType> & AnnouncementType & {
+    _id: mongoose.Types.ObjectId;
+}, any>;
+export default _default;

package/dist/announcements/models/Announcements.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const Users_1 = require("../../users/models/Users");
+const announcementSchema = new mongoose_1.Schema({
+    created_by: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    updated_by: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+    },
+    deleted_by: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+    },
+    created_at: {
+        type: Date,
+        default: Date.now,
+    },
+    updated_at: Date,
+    deleted_at: Date,
+    title: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    text: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    roles: {
+        type: [String],
+        enum: Object.values(Users_1.UserRole),
+        required: true,
+        validate: {
+            validator: (roles) => roles.length > 0,
+            message: "At least one user role must be assigned.",
+        },
+    },
+});
+exports.default = (0, mongoose_1.model)("Announcement", announcementSchema, "announcements");

package/dist/customers/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Customer } from "./models/Customers";
+export type { CustomerType, CustomerStatus } from "./models/Customers";
+export { default as FiscalProfile } from "./models/FiscalProfileType";
+export type { FiscalProfileType } from "./models/FiscalProfileType";

package/dist/customers/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiscalProfile = exports.Customer = void 0;
+var Customers_1 = require("./models/Customers");
+Object.defineProperty(exports, "Customer", { enumerable: true, get: function () { return __importDefault(Customers_1).default; } });
+var FiscalProfileType_1 = require("./models/FiscalProfileType");
+Object.defineProperty(exports, "FiscalProfile", { enumerable: true, get: function () { return __importDefault(FiscalProfileType_1).default; } });

package/dist/customers/models/Customers.d.ts

@@ -0,0 +1,22 @@
+import mongoose from "mongoose";
+export declare enum CustomerStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    BANNED = "banned"
+}
+export interface CustomerType {
+    first_name: string;
+    last_name: string;
+    email: string;
+    mobile?: string;
+    password: string;
+    status: CustomerStatus;
+    fiscal_profile_id?: mongoose.Types.ObjectId;
+    created_at: Date;
+    updated_at?: Date;
+    deleted_at?: Date;
+}
+declare const _default: mongoose.Model<CustomerType, {}, {}, {}, mongoose.Document<unknown, {}, CustomerType> & CustomerType & {
+    _id: mongoose.Types.ObjectId;
+}, any>;
+export default _default;

package/dist/customers/models/Customers.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerStatus = void 0;
+const mongoose_1 = require("mongoose");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+var CustomerStatus;
+(function (CustomerStatus) {
+    CustomerStatus["ACTIVE"] = "active";
+    CustomerStatus["INACTIVE"] = "inactive";
+    CustomerStatus["BANNED"] = "banned";
+})(CustomerStatus || (exports.CustomerStatus = CustomerStatus = {}));
+const customerSchema = new mongoose_1.Schema({
+    first_name: { type: String, required: true },
+    last_name: { type: String, required: true },
+    email: { type: String, required: true, unique: true },
+    mobile: { type: String },
+    password: { type: String, required: true, select: false },
+    status: {
+        type: String,
+        enum: Object.values(CustomerStatus),
+        default: CustomerStatus.ACTIVE,
+    },
+    fiscal_profile_id: { type: mongoose_1.Schema.Types.ObjectId, ref: "FiscalProfile" },
+    created_at: { type: Date, default: Date.now },
+    updated_at: { type: Date },
+    deleted_at: { type: Date },
+});
+// Hash password
+customerSchema.pre("save", async function (next) {
+    if (this.isModified("password")) {
+        this.password = await bcryptjs_1.default.hash(this.password, 12);
+    }
+    next();
+});
+exports.default = (0, mongoose_1.model)("Customer", customerSchema, "customers");

package/dist/customers/models/FiscalProfileType.d.ts

@@ -0,0 +1,15 @@
+import mongoose from "mongoose";
+export interface FiscalProfileType {
+    customer_id: mongoose.Types.ObjectId;
+    rfc: string;
+    razon_social: string;
+    uso_cfdi: string;
+    regimen_fiscal: string;
+    cp: string;
+    created_at: Date;
+    updated_at?: Date;
+}
+declare const _default: mongoose.Model<FiscalProfileType, {}, {}, {}, mongoose.Document<unknown, {}, FiscalProfileType> & FiscalProfileType & {
+    _id: mongoose.Types.ObjectId;
+}, any>;
+export default _default;

package/dist/customers/models/FiscalProfileType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const fiscalProfileSchema = new mongoose_1.Schema({
+    customer_id: { type: mongoose_1.Schema.Types.ObjectId, ref: "Customer", required: true },
+    rfc: { type: String, required: true },
+    razon_social: { type: String, required: true },
+    uso_cfdi: { type: String, required: true },
+    regimen_fiscal: { type: String, required: true },
+    cp: { type: String, required: true },
+    created_at: { type: Date, default: Date.now },
+    updated_at: { type: Date },
+});
+exports.default = (0, mongoose_1.model)("FiscalProfile", fiscalProfileSchema, "fiscal_profiles");

package/dist/index.d.ts

@@ -1 +1,8 @@
 export * from "./clients";
+export * from "./inventory";
+export * from "./quotes";
+export * from "./customers";
+export * from "./orders";
+export * from "./sap";
+export * from "./announcements";
+export * from "./users";

package/dist/index.js

@@ -15,3 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./clients"), exports);
+__exportStar(require("./inventory"), exports);
+__exportStar(require("./quotes"), exports);
+__exportStar(require("./customers"), exports);
+__exportStar(require("./orders"), exports);
+__exportStar(require("./sap"), exports);
+__exportStar(require("./announcements"), exports);
+__exportStar(require("./users"), exports);

package/dist/inventory/index.d.ts

@@ -0,0 +1,8 @@
+export { default as Article } from "./models/Article";
+export { default as ArticleGroup } from "./models/ArticleGroups";
+export { default as ArticleClass } from "./models/ArticleClasses";
+export { default as ArticlePrice } from "./models/ArticlePrices";
+export { default as Currency } from "./models/Currencies";
+export { default as Warehouse } from "./models/Warehouses";
+export { default as InventoryStock } from "./models/InventoryStocks";
+export { default as PriceList } from "./models/PriceLists";

package/dist/inventory/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceList = exports.InventoryStock = exports.Warehouse = exports.Currency = exports.ArticlePrice = exports.ArticleClass = exports.ArticleGroup = exports.Article = void 0;
+var Article_1 = require("./models/Article");
+Object.defineProperty(exports, "Article", { enumerable: true, get: function () { return __importDefault(Article_1).default; } });
+var ArticleGroups_1 = require("./models/ArticleGroups");
+Object.defineProperty(exports, "ArticleGroup", { enumerable: true, get: function () { return __importDefault(ArticleGroups_1).default; } });
+var ArticleClasses_1 = require("./models/ArticleClasses");
+Object.defineProperty(exports, "ArticleClass", { enumerable: true, get: function () { return __importDefault(ArticleClasses_1).default; } });
+var ArticlePrices_1 = require("./models/ArticlePrices");
+Object.defineProperty(exports, "ArticlePrice", { enumerable: true, get: function () { return __importDefault(ArticlePrices_1).default; } });
+var Currencies_1 = require("./models/Currencies");
+Object.defineProperty(exports, "Currency", { enumerable: true, get: function () { return __importDefault(Currencies_1).default; } });
+var Warehouses_1 = require("./models/Warehouses");
+Object.defineProperty(exports, "Warehouse", { enumerable: true, get: function () { return __importDefault(Warehouses_1).default; } });
+var InventoryStocks_1 = require("./models/InventoryStocks");
+Object.defineProperty(exports, "InventoryStock", { enumerable: true, get: function () { return __importDefault(InventoryStocks_1).default; } });
+var PriceLists_1 = require("./models/PriceLists");
+Object.defineProperty(exports, "PriceList", { enumerable: true, get: function () { return __importDefault(PriceLists_1).default; } });

package/dist/inventory/models/Article.d.ts

@@ -0,0 +1,109 @@
+import { Schema, Types } from "mongoose";
+declare const _default: import("mongoose").Model<{
+    created_at: Date;
+    description: string;
+    article_number: string;
+    unit: string;
+    group_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    updated_at?: Date;
+    model?: string;
+    brand?: string;
+}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
+    created_at: Date;
+    description: string;
+    article_number: string;
+    unit: string;
+    group_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    updated_at?: Date;
+    model?: string;
+    brand?: string;
+}> & {
+    created_at: Date;
+    description: string;
+    article_number: string;
+    unit: string;
+    group_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    updated_at?: Date;
+    model?: string;
+    brand?: string;
+} & {
+    _id: Types.ObjectId;
+}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+    created_at: Date;
+    description: string;
+    article_number: string;
+    unit: string;
+    group_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    updated_at?: Date;
+    model?: string;
+    brand?: string;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    created_at: Date;
+    description: string;
+    article_number: string;
+    unit: string;
+    group_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    updated_at?: Date;
+    model?: string;
+    brand?: string;
+}>> & import("mongoose").FlatRecord<{
+    created_at: Date;
+    description: string;
+    article_number: string;
+    unit: string;
+    group_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    updated_at?: Date;
+    model?: string;
+    brand?: string;
+}> & {
+    _id: Types.ObjectId;
+}>>;
+export default _default;

package/dist/inventory/models/Article.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const articleSchema = new mongoose_1.Schema({
+    article_number: { type: String, required: true, unique: true }, // SAP ItemCode
+    description: { type: String, required: true },
+    unit: { type: String, required: true },
+    brand: { type: String },
+    model: { type: String },
+    group_id: { type: mongoose_1.Types.ObjectId, ref: "ArticleGroup", required: true },
+    created_at: { type: Date, default: Date.now },
+    updated_at: { type: Date },
+});
+exports.default = (0, mongoose_1.model)("Article", articleSchema, "articles");

package/dist/inventory/models/ArticleClasses.d.ts

@@ -0,0 +1,25 @@
+import { Schema } from "mongoose";
+declare const _default: import("mongoose").Model<{
+    name: string;
+    description?: string;
+}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
+    name: string;
+    description?: string;
+}> & {
+    name: string;
+    description?: string;
+} & {
+    _id: import("mongoose").Types.ObjectId;
+}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+    name: string;
+    description?: string;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    name: string;
+    description?: string;
+}>> & import("mongoose").FlatRecord<{
+    name: string;
+    description?: string;
+}> & {
+    _id: import("mongoose").Types.ObjectId;
+}>>;
+export default _default;

package/dist/inventory/models/ArticleClasses.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const articleClassSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    description: { type: String },
+});
+exports.default = (0, mongoose_1.model)("ArticleClass", articleClassSchema, "article_classes");

package/dist/inventory/models/ArticleGroups.d.ts

@@ -0,0 +1,25 @@
+import { Schema } from "mongoose";
+declare const _default: import("mongoose").Model<{
+    name: string;
+    description?: string;
+}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
+    name: string;
+    description?: string;
+}> & {
+    name: string;
+    description?: string;
+} & {
+    _id: import("mongoose").Types.ObjectId;
+}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+    name: string;
+    description?: string;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    name: string;
+    description?: string;
+}>> & import("mongoose").FlatRecord<{
+    name: string;
+    description?: string;
+}> & {
+    _id: import("mongoose").Types.ObjectId;
+}>>;
+export default _default;

package/dist/inventory/models/ArticleGroups.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const articleGroupSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    description: { type: String },
+});
+exports.default = (0, mongoose_1.model)("ArticleGroup", articleGroupSchema, "article_groups");

package/dist/inventory/models/ArticlePrices.d.ts

@@ -0,0 +1,205 @@
+import { Schema, Types } from "mongoose";
+declare const _default: import("mongoose").Model<{
+    created_at: Date;
+    article_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price_list_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    currency_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price: number;
+    updated_at?: Date;
+    valid_from?: Date;
+    valid_to?: Date;
+}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
+    created_at: Date;
+    article_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price_list_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    currency_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price: number;
+    updated_at?: Date;
+    valid_from?: Date;
+    valid_to?: Date;
+}> & {
+    created_at: Date;
+    article_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price_list_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    currency_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price: number;
+    updated_at?: Date;
+    valid_from?: Date;
+    valid_to?: Date;
+} & {
+    _id: Types.ObjectId;
+}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
+    created_at: Date;
+    article_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price_list_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    currency_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price: number;
+    updated_at?: Date;
+    valid_from?: Date;
+    valid_to?: Date;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    created_at: Date;
+    article_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price_list_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    currency_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price: number;
+    updated_at?: Date;
+    valid_from?: Date;
+    valid_to?: Date;
+}>> & import("mongoose").FlatRecord<{
+    created_at: Date;
+    article_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price_list_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    currency_id: {
+        prototype?: Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    price: number;
+    updated_at?: Date;
+    valid_from?: Date;
+    valid_to?: Date;
+}> & {
+    _id: Types.ObjectId;
+}>>;
+export default _default;

package/dist/inventory/models/ArticlePrices.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const articlePriceSchema = new mongoose_1.Schema({
+    article_id: { type: mongoose_1.Types.ObjectId, ref: "Article", required: true },
+    price_list_id: { type: mongoose_1.Types.ObjectId, ref: "PriceList", required: true },
+    currency_id: { type: mongoose_1.Types.ObjectId, ref: "Currency", required: true },
+    price: { type: Number, required: true },
+    valid_from: { type: Date },
+    valid_to: { type: Date },
+    created_at: { type: Date, default: Date.now },
+    updated_at: { type: Date },
+});
+exports.default = (0, mongoose_1.model)("ArticlePrice", articlePriceSchema, "article_prices");