@ozdao/prometheus-framework 0.2.81 → 0.2.83

package/dist/orders.server.js

@@ -0,0 +1,592 @@
+"use strict";
+const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
+const ownership_schema = require("./ownership.schema-DN0SlQL6.js");
+const profile_schema = require("./profile.schema-CkOhhf37.js");
+const credentials_schema = require("./credentials.schema-B-KD_ozQ.js");
+const mailing = require("./mailing-BX0q8DIs.js");
+const queryProcessor = require("./queryProcessor-DRMo_GWK.js");
+const index = require("./index-BCCiEK_u.js");
+const require$$0 = require("node-cache");
+const applyOwnershipSchema$1 = ownership_schema.ownership_schema;
+var order_model = (db) => {
+  const OrderSchema = new db.mongoose.Schema({
+    customer: {
+      type: {
+        type: String,
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        refPath: "customer.type",
+        required: true
+      }
+    },
+    positions: {
+      type: Array
+    },
+    referralCode: {
+      type: String
+    },
+    status: {
+      type: String
+    },
+    status_history: [{
+      status: {
+        type: String,
+        trim: true
+      },
+      changedBy: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      timestamp: {
+        type: Date,
+        default: Date.now
+      },
+      comment: {
+        type: String,
+        trim: true
+      }
+    }],
+    comment: {
+      type: String,
+      trim: true
+    },
+    payment: {
+      type: {
+        type: String,
+        trim: true
+      },
+      status: {
+        type: String,
+        trim: true
+      }
+    },
+    delivery: {
+      type: {
+        type: String,
+        trim: true
+      },
+      address: {
+        type: String,
+        trim: true
+      },
+      status: {
+        type: String,
+        trim: true
+      }
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyOwnershipSchema$1(OrderSchema, db);
+  const Order = db.mongoose.model("Order", OrderSchema);
+  return Order;
+};
+const applyOwnershipSchema = ownership_schema.ownership_schema;
+const applyProfileSchema = profile_schema.profile_schema;
+const applyCredentialsSchema = credentials_schema.credentials_schema;
+var customer_model = (db) => {
+  const CustomerSchema = new db.mongoose.Schema({
+    identity: {
+      type: {
+        type: String,
+        enum: ["Visitor", "User", "Organization"],
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        refPath: "target.type"
+      }
+    },
+    referral: {
+      code: {
+        type: String
+      }
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyCredentialsSchema(CustomerSchema);
+  applyProfileSchema(CustomerSchema);
+  applyOwnershipSchema(CustomerSchema, db);
+  CustomerSchema.index({
+    owner: 1,
+    email: 1
+  }, {
+    unique: true,
+    partialFilterExpression: {
+      email: { $exists: true, $ne: "" }
+    }
+  });
+  CustomerSchema.index({
+    owner: 1,
+    phone: 1
+  }, {
+    unique: true,
+    partialFilterExpression: {
+      phone: { $exists: true, $ne: "" }
+    }
+  });
+  CustomerSchema.index({
+    owner: 1,
+    identity: 1
+  }, {
+    unique: true,
+    partialFilterExpression: {
+      identity: { $exists: true, $ne: "" }
+    }
+  });
+  const Customer = db.mongoose.model("Customer", CustomerSchema);
+  return Customer;
+};
+var testimonial_model = (db) => {
+  const testimonialSchema = new db.mongoose.Schema({
+    source: {
+      type: String
+    },
+    author: {
+      type: Schema.Types.ObjectId,
+      ref: "User",
+      required: true
+    },
+    rating: {
+      type: String,
+      required: true
+    },
+    description: {
+      type: String,
+      required: true
+    }
+  });
+  const Testimonial = db.mongoose.model("Testimonial", testimonialSchema);
+  return Testimonial;
+};
+var application_model = (db) => {
+  const ApplicationSchema = new db.mongoose.Schema({
+    status: {
+      type: String,
+      default: "created"
+    },
+    type: {
+      type: String,
+      default: "newsletter"
+    },
+    contacts: {
+      name: {
+        type: String
+      },
+      phone: {
+        type: String
+      },
+      email: {
+        type: String
+      }
+    }
+  }, {
+    timestamps: { currentTime: () => Date.now() }
+  });
+  const Application = db.mongoose.model("Application", ApplicationSchema);
+  return Application;
+};
+const { sendChatMessageTelegram } = mailing.mailing;
+const queryProcessorGlobals = queryProcessor.queryProcessor;
+function formatPositions(positions) {
+  return positions.map((pos) => `🔹 ${pos.name} - Price: $${pos.price}, Quantity: ${pos.quantity}`).join("\n");
+}
+function formatOrderMessage(order) {
+  return `
+    🆕 New Order Received!
+    👤 Customer: ${order.customer?.name} (${order.customer?.phone?.number ? order.customer?.phone?.number : "No phone"})
+    💬 Messenger: ${order.customer?.messenger ? order.customer?.messenger?.type + " " + order.customer?.messenger?.value : "None"}
+    🏢 Organization: ${order.organization}
+    📦 Positions:
+${formatPositions(order.positions)}
+    📝 Comment: ${order.comment ? order.comment : "No comment"}
+    💳 Payment: ${order.payment?.type}
+    🚚 Delivery: ${order.delivery?.type} to ${order.delivery?.address}
+    📌 Status: ${order.status}
+    🧑 Agent: ${order.referralCode}
+  `;
+}
+function initializeOrder(orderData, userId) {
+  orderData.status = "created";
+  orderData.status_history = orderData.status_history || [];
+  orderData.status_history.push({
+    status: orderData.status,
+    changedBy: userId,
+    timestamp: /* @__PURE__ */ new Date(),
+    comment: ""
+  });
+}
+async function findOrCreateCustomer(Customer, customerInfo, orderOwner, visitor) {
+  let searchCriteria = {};
+  if (customerInfo.phone) {
+    searchCriteria.phone = customerInfo.phone;
+  }
+  if (customerInfo.email) {
+    searchCriteria.email = customerInfo.email;
+  }
+  let customer = null;
+  if (Object.keys(searchCriteria).length > 0) {
+    customer = await Customer.findOne({ $or: [searchCriteria] });
+  }
+  if (!customer) {
+    const newCustomerData = {
+      ...customerInfo,
+      owner: orderOwner,
+      creator: customerInfo.creator || { type: "Visitor", target: visitor || orderOwner.target },
+      identity: customerInfo.indentity || { type: "Visitor", target: visitor || orderOwner.target }
+    };
+    customer = await Customer.create(newCustomerData);
+  }
+  return customer;
+}
+async function sendOrderMessage(orderData) {
+  try {
+    const formattedMessage = formatOrderMessage(orderData);
+    await sendChatMessageTelegram(process.env.TELEGRAM_BOT_USERS.split(","), formattedMessage);
+  } catch (err) {
+    console.error(err);
+  }
+}
+const controllerFactory$1 = (db) => {
+  const Order = db.order;
+  const Customer = db.customer;
+  const create = async (req, res) => {
+    const orderData = req.body;
+    const userId = req.userId;
+    initializeOrder(orderData, userId);
+    try {
+      if (!orderData.customer.target) {
+        let customer = await findOrCreateCustomer(Customer, orderData.customer, orderData.owner, orderData.visitor);
+        orderData.customer = { type: "Customer", target: customer._id };
+        if (!orderData.creator?.target) {
+          orderData.creator = { type: "Customer", target: customer._id };
+        }
+      }
+      await sendOrderMessage(orderData);
+      const order = await Order.create(orderData);
+      res.status(201).send(order);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({ errorCode: "CREATE_ORDER_FAILED", message: "Error occurred while creating the order.", error: err });
+    }
+  };
+  const read = async (req, res) => {
+    stages = [
+      ...queryProcessorGlobals.getBasicOptions(
+        req.query
+      ),
+      // For customer
+      {
+        $lookup: {
+          from: "customers",
+          localField: "customer.target",
+          foreignField: "_id",
+          as: "customerTarget"
+        }
+      },
+      {
+        $addFields: {
+          "customer.target": { $arrayElemAt: ["$customerTarget", 0] }
+        }
+      },
+      // For creator
+      queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      queryProcessorGlobals.getCreatorCustomerLookupStage(),
+      // For owner
+      queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+      // Pagination
+      ...queryProcessorGlobals.getSortingOptions(
+        req.query.sortParam,
+        req.query.sortOrder
+      ),
+      ...queryProcessorGlobals.getPaginationOptions(
+        req.query.skip,
+        req.query.limit
+      )
+    ];
+    try {
+      const orders = await Order.aggregate(stages);
+      if (!orders) {
+        return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Orders not found." });
+      }
+      res.status(200).send(orders);
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ errorCode: "GET_ORDERS_FAILED", message: "Error occurred while fetching orders.", error: err });
+    }
+  };
+  const update = async (req, res) => {
+    const order = await Order.findById(new db.mongoose.Schema.Types.ObjectId(req.body._id));
+    if (!order) {
+      return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
+    }
+    if (req.body.status && req.body.status !== order.status) {
+      order.status = req.body.status;
+      order.status_history.push({
+        status: req.body.status,
+        changedBy: req.userId,
+        timestamp: /* @__PURE__ */ new Date(),
+        comment: ""
+      });
+    }
+    try {
+      await order.save();
+      res.status(200).send(order);
+    } catch (err) {
+      res.status(500).send({ errorCode: "UPDATE_ORDER_FAILED", message: "Error occurred while updating the order.", error: err });
+    }
+  };
+  const changePaymentStatus = async (req, res) => {
+    try {
+      const order = await Order.findOneAndUpdate(
+        { _id: req.params._id },
+        { status: "Оплачен", payment: { type: "Наличные", status: "Оплачено" } },
+        { new: true }
+      ).exec();
+      if (!order) {
+        return res.status(404).send({ errorCode: "PAYMENT_STATUS_CHANGE_FAILED", message: "Failed to change the payment status." });
+      }
+      res.status(200).send(order);
+    } catch (err) {
+      res.status(500).send({ errorCode: "CHANGE_PAYMENT_STATUS_FAILED", message: "Error occurred while changing the payment status.", error: err });
+    }
+  };
+  const deleteOrder = async (req, res) => {
+    try {
+      const order = await Order.findOneAndDelete({ _id: req.params._id }).exec();
+      if (!order) {
+        return res.status(404).send({ errorCode: "ORDER_DELETE_FAILED", message: "Failed to delete the order." });
+      }
+      res.status(200).send(order);
+    } catch (err) {
+      res.status(500).send({ errorCode: "DELETE_ORDER_FAILED", message: "Error occurred while deleting the order.", error: err });
+    }
+  };
+  return {
+    create,
+    read,
+    update,
+    changePaymentStatus,
+    deleteOrder
+  };
+};
+var orders_controller = controllerFactory$1;
+const controllerFactory = orders_controller;
+const middlewareFactory = index.server;
+var orders_routes = function(app, db, origins, publicPath) {
+  const controller = controllerFactory(db);
+  const middleware = middlewareFactory(db);
+  app.post(
+    "/api/orders/create",
+    controller.create
+  );
+  app.get(
+    "/api/orders/read",
+    controller.read
+  );
+  app.post(
+    "/api/orders/update",
+    [
+      middleware.authJwt.verifyToken
+    ],
+    controller.update
+  );
+  app.post(
+    "/api/orders/delete",
+    controller.deleteOrder
+  );
+};
+const NodeCache = require$$0;
+const stdTTL = 60 * 5;
+class Cache {
+  constructor(ttlSeconds = stdTTL) {
+    this.cache = new NodeCache({ stdTTL: ttlSeconds });
+  }
+  async get(key) {
+    return this.cache.get(key);
+  }
+  async set(key, value) {
+    return this.cache.set(key, value);
+  }
+  async del(keys) {
+    return this.cache.del(keys);
+  }
+  async flush() {
+    this.cache.flushAll();
+  }
+}
+var globals_cashe = Cache;
+let Logger$1 = class Logger {
+  static logModel = null;
+  constructor(db) {
+    if (!Logger.logModel) {
+      const logSchema = new db.mongoose.Schema({
+        timestamp: { type: Date, default: Date.now },
+        level: String,
+        message: String
+      }, { versionKey: false });
+      Logger.logModel = db.mongoose.model("Log", logSchema);
+    }
+    this.LogModel = Logger.logModel;
+  }
+  async log(level, message) {
+    const logEntry = new Logger.logModel({
+      level,
+      message
+    });
+    try {
+      await logEntry.save();
+      console.info(`Logged: ${level} - ${message}`);
+    } catch (err) {
+      console.error("Logging error:", err);
+    }
+  }
+  // Удобные методы для различных уровней логирования
+  async info(message) {
+    await this.log("info", message);
+  }
+  async error(message) {
+    await this.log("error", message);
+  }
+};
+var globals_logger = Logger$1;
+const globalsQuery = queryProcessor.queryProcessor;
+const Cashe = globals_cashe;
+const Logger2 = globals_logger;
+let CRUD$1 = class CRUD {
+  constructor(basePath, app, db, model) {
+    this.model = model;
+    this.cache = new Cashe();
+    this.logger = new Logger2(db);
+    this.app = app;
+    this.basePath = basePath;
+    this.registerRoutes();
+  }
+  registerRoutes() {
+    this.app.post(`${this.basePath}/create`, this.create.bind(this));
+    this.app.get(`${this.basePath}/read`, this.read.bind(this));
+    this.app.put(`${this.basePath}/update`, this.update.bind(this));
+    this.app.delete(`${this.basePath}/delete`, this.delete.bind(this));
+  }
+  async create(req, res) {
+    try {
+      const createdData = await this.model.create(req.body);
+      await this.cache.flush();
+      res.status(201).json(createdData);
+    } catch (error) {
+      console.log(error);
+      this.logger.error("Ошибка создания данных", error);
+      res.status(500).json({ error: error.message });
+    }
+  }
+  async read(req, res) {
+    try {
+      let stages2 = [];
+      stages2 = [
+        ...globalsQuery.getBasicOptions(
+          req.query
+        ),
+        // For creator
+        globalsQuery.getCreatorUserLookupStage(),
+        globalsQuery.getCreatorOrganizationLookupStage(),
+        // For owner
+        globalsQuery.getOwnerUserLookupStage(),
+        globalsQuery.getOwnerOrganizationLookupStage(),
+        globalsQuery.getAddFieldsCreatorOwnerStage(),
+        // Pagination
+        ...globalsQuery.getSortingOptions(
+          req.query.sortParam,
+          req.query.sortOrder
+        ),
+        ...globalsQuery.getPaginationOptions(
+          req.query.skip,
+          req.query.limit
+        ),
+        globalsQuery.removeTempPropeties()
+      ];
+      const cacheKey = JSON.stringify({ stages: stages2 });
+      let data = await this.cache.get(cacheKey);
+      if (!data) {
+        data = await this.model.aggregate(stages2).exec();
+        await this.cache.set(cacheKey, data);
+      }
+      res.json(data);
+    } catch (error) {
+      this.logger.error(error);
+      res.status(500).json({ error: error.message });
+    }
+  }
+  async update(req, res) {
+    try {
+      const updatedData = await this.model.findOneAndUpdate(
+        { _id: req.body._id },
+        req.body,
+        { new: true, runValidators: true }
+      );
+      if (!updatedData) {
+        throw new Error("Документ не найден.");
+      }
+      await this.cache.flush();
+      res.json(updatedData);
+    } catch (error) {
+      this.logger.error("Ошибка обновления данных", error);
+      res.status(404).json({ error: error.message });
+    }
+  }
+  async delete(req, res) {
+    try {
+      const deletedData = await this.model.findOneAndDelete({ _id: req.body._id });
+      if (!deletedData) {
+        throw new Error("Документ не найден.");
+      }
+      await this.cache.flush();
+      res.status(204).send();
+    } catch (error) {
+      this.logger.error("Ошибка удаления данных", error);
+      res.status(404).json({ error: error.message });
+    }
+  }
+};
+var globals_crud = CRUD$1;
+const ModelOrder = order_model;
+const ModelCustomer = customer_model;
+const ModelTestimonial = testimonial_model;
+const ModelApplication = application_model;
+const RoutesOrder = orders_routes;
+const FactoryOrder = orders_controller;
+const CRUD2 = globals_crud;
+function initializeOrders(app, db, origins, publicPath) {
+  db.order = ModelOrder(db);
+  db.customer = ModelCustomer(db);
+  db.testimonial = ModelTestimonial(db);
+  db.application = ModelApplication(db);
+  if (app) {
+    RoutesOrder(app, db);
+  }
+  new CRUD2("/api/customers", app, db, db.customer);
+}
+var orders_server = {
+  initialize: initializeOrders,
+  models: {
+    ModelOrder,
+    ModelCustomer
+  },
+  routes: {
+    RoutesOrder
+  },
+  controllers: {
+    FactoryOrder
+  }
+};
+const orders_server$1 = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(orders_server);
+module.exports = orders_server$1;