@ozdao/prometheus-framework 0.2.330 → 0.2.332

package/dist/orders.server.mjs

@@ -1,212 +1,245 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { o as ownership_schema } from "./ownership.schema-oyx6eNkZ.mjs";
-import { p as profile_schema } from "./profile.schema-24ZpZQJe.mjs";
-import { c as credentials_schema } from "./credentials.schema-C9dmNy7o.mjs";
-import { q as queryProcessor } from "./queryProcessor-CyQch65j.mjs";
-import { m as mailing } from "./mailing-D1cjLmTB.mjs";
-import { m as middlewares } from "./index-CW2mOwo8.mjs";
+import { r as requireOwnership_schema } from "./ownership.schema-C0w02Vw1.mjs";
+import { r as requireProfile_schema } from "./profile.schema-kP_zKXNt.mjs";
+import { r as requireCredentials_schema } from "./credentials.schema-oOC8B5KL.mjs";
+import { r as requireQueryProcessor } from "./queryProcessor-C_l-zkrM.mjs";
+import { r as requireMailing } from "./mailing-C8zqHzvG.mjs";
+import { r as requireMiddlewares } from "./index-Ctf6Y61O.mjs";
 import require$$1 from "axios";
-import require$$0 from "node-cache";
-const applyOwnershipSchema$1 = ownership_schema;
-var order_model = (db) => {
-  const OrderSchema = new db.mongoose.Schema({
-    customer: {
-      type: {
-        type: String,
-        required: true
+import { r as requireGlobals_crud } from "./globals.crud-CJhMZYIU.mjs";
+var order_model;
+var hasRequiredOrder_model;
+function requireOrder_model() {
+  if (hasRequiredOrder_model) return order_model;
+  hasRequiredOrder_model = 1;
+  const applyOwnershipSchema = requireOwnership_schema();
+  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
+        }
       },
-      target: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        refPath: "customer.type",
-        required: true
-      }
-    },
-    positions: {
-      type: Array
-    },
-    referralCode: {
-      type: String
-    },
-    status: {
-      type: String
-    },
-    deadline: {
-      type: Date,
-      default: () => new Date(Date.now() + 30 * 6e4)
-      // Добавляет 30 минут к текущему времени
-    },
-    status_history: [{
-      status: {
-        type: String,
-        trim: true
+      positions: {
+        type: Array
       },
-      user: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "User"
+      referralCode: {
+        type: String
+      },
+      status: {
+        type: String
       },
-      timestamp: {
+      deadline: {
         type: Date,
-        default: Date.now
+        default: () => new Date(Date.now() + 30 * 6e4)
+        // Добавляет 30 минут к текущему времени
       },
+      status_history: [{
+        status: {
+          type: String,
+          trim: true
+        },
+        user: {
+          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,
+          default: "cash"
+        },
+        status: {
+          type: String,
+          trim: true,
+          default: "unpaid"
+        }
+      },
+      delivery: {
+        type: {
+          type: String,
+          trim: true
+        },
+        address: {
+          type: String,
+          trim: true
+        },
+        status: {
+          type: String,
+          trim: true
+        }
       }
-    }],
-    comment: {
-      type: String,
-      trim: true
-    },
-    payment: {
-      type: {
-        type: String,
-        trim: true,
-        default: "cash"
+    }, {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    });
+    applyOwnershipSchema(OrderSchema, db);
+    const Order = db.mongoose.model("Order", OrderSchema);
+    return Order;
+  };
+  return order_model;
+}
+var customer_model;
+var hasRequiredCustomer_model;
+function requireCustomer_model() {
+  if (hasRequiredCustomer_model) return customer_model;
+  hasRequiredCustomer_model = 1;
+  const applyOwnershipSchema = requireOwnership_schema();
+  const applyProfileSchema = requireProfile_schema();
+  const applyCredentialsSchema = requireCredentials_schema();
+  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"
+        }
       },
-      status: {
-        type: String,
-        trim: true,
-        default: "unpaid"
+      referral: {
+        code: {
+          type: String
+        }
       }
-    },
-    delivery: {
-      type: {
-        type: String,
-        trim: true
+    }, {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    });
+    applyCredentialsSchema(CustomerSchema, db);
+    applyProfileSchema(CustomerSchema, db);
+    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;
+  };
+  return customer_model;
+}
+var testimonial_model;
+var hasRequiredTestimonial_model;
+function requireTestimonial_model() {
+  if (hasRequiredTestimonial_model) return testimonial_model;
+  hasRequiredTestimonial_model = 1;
+  testimonial_model = (db) => {
+    const testimonialSchema = new db.mongoose.Schema({
+      source: {
+        type: String
       },
-      address: {
-        type: String,
-        trim: true
+      author: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true
       },
-      status: {
+      rating: {
         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;
-const applyProfileSchema = profile_schema;
-const applyCredentialsSchema = 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
+      description: {
+        type: String,
+        required: true
       }
-    }
-  }, {
-    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: db.mongoose.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
+    });
+    const Testimonial = db.mongoose.model("Testimonial", testimonialSchema);
+    return Testimonial;
+  };
+  return testimonial_model;
+}
+var application_model;
+var hasRequiredApplication_model;
+function requireApplication_model() {
+  if (hasRequiredApplication_model) return application_model;
+  hasRequiredApplication_model = 1;
+  application_model = (db) => {
+    const ApplicationSchema = new db.mongoose.Schema({
+      status: {
+        type: String,
+        default: "created"
       },
-      phone: {
-        type: String
+      type: {
+        type: String,
+        default: "newsletter"
       },
-      email: {
-        type: String
+      contacts: {
+        name: {
+          type: String
+        },
+        phone: {
+          type: String
+        },
+        email: {
+          type: String
+        }
       }
-    }
-  }, {
-    timestamps: { currentTime: () => Date.now() }
-  });
-  const Application = db.mongoose.model("Application", ApplicationSchema);
-  return Application;
-};
-const queryProcessorGlobals = queryProcessor;
-const { sendChatMessageTelegram: sendChatMessageTelegram$1 } = mailing;
-function formatPositions(positions) {
-  return positions.map((pos) => `🔹 ${pos.name} - Price: $${pos.price}, Quantity: ${pos.quantity}`).join("\n");
+    }, {
+      timestamps: { currentTime: () => Date.now() }
+    });
+    const Application = db.mongoose.model("Application", ApplicationSchema);
+    return Application;
+  };
+  return application_model;
 }
-function formatOrderMessage(order) {
-  return `
+var orders_controller;
+var hasRequiredOrders_controller;
+function requireOrders_controller() {
+  if (hasRequiredOrders_controller) return orders_controller;
+  hasRequiredOrders_controller = 1;
+  const queryProcessorGlobals = requireQueryProcessor();
+  const { sendChatMessageTelegram } = requireMailing();
+  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"}
@@ -219,559 +252,438 @@ ${formatPositions(order.positions)}
     📌 Status: ${order.status}
     🧑 Agent: ${order.referralCode}
   `;
-}
-async function findOrCreateCustomer(Customer, customerInfo, orderOwner, orderCreator) {
-  let searchCriteria = {};
-  if (customerInfo.phone) {
-    searchCriteria.phone = customerInfo.phone;
-  }
-  if (customerInfo.email) {
-    searchCriteria.email = customerInfo.email;
-  }
-  let customer = null;
-  console.log(searchCriteria);
-  if (Object.keys(searchCriteria).length > 0) {
-    customer = await Customer.findOne({ $or: [searchCriteria] });
-  }
-  if (!customer) {
-    const newCustomerData = {
-      ...customerInfo,
-      owner: orderOwner,
-      creator: {
-        type: customerInfo.creator?.type || orderCreator.type,
-        target: customerInfo.creator?.target || orderCreator.target
-      },
-      identity: {
-        type: customerInfo.identity?.type || orderCreator.type,
-        target: customerInfo.identity?.target || orderCreator.target
-      }
-    };
-    customer = await Customer.create(newCustomerData);
-  }
-  return customer;
-}
-async function sendOrderMessage(orderData) {
-  try {
-    const formattedMessage = formatOrderMessage(orderData);
-    await sendChatMessageTelegram$1(process.env.TELEGRAM_BOT_USERS.split(","), formattedMessage);
-  } catch (err) {
-    console.error(err);
   }
-}
-const controllerFactory$2 = (db) => {
-  const Order = db.order;
-  const Customer = db.customer;
-  const Leftover = db.leftover;
-  const create = async (req, res) => {
-    const orderData = req.body;
-    req.userId || req.body.creator.target;
-    orderData.status = "created";
-    orderData.status_history = orderData.status_history || [];
-    orderData.status_history.push({
-      status: orderData.status,
-      // user: new db.mongoose.Types.ObjectId(userId), 
-      timestamp: /* @__PURE__ */ new Date(),
-      comment: ""
-    });
-    try {
-      if (!orderData.customer.target) {
-        let customer = await findOrCreateCustomer(Customer, orderData.customer, orderData.owner, orderData.creator);
-        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 });
+  async function findOrCreateCustomer(Customer, customerInfo, orderOwner, orderCreator) {
+    let searchCriteria = {};
+    if (customerInfo.phone) {
+      searchCriteria.phone = customerInfo.phone;
     }
-  };
-  const read = async (req, res) => {
-    let stages = [
-      ...queryProcessorGlobals.getBasicOptions(
-        req.query
-      ),
-      // For customer
-      {
-        $lookup: {
-          from: "customers",
-          localField: "customer.target",
-          foreignField: "_id",
-          as: "customerTarget"
-        }
-      },
-      {
-        $addFields: {
-          "customer.target": { $arrayElemAt: ["$customerTarget", 0] }
+    if (customerInfo.email) {
+      searchCriteria.email = customerInfo.email;
+    }
+    let customer = null;
+    console.log(searchCriteria);
+    if (Object.keys(searchCriteria).length > 0) {
+      customer = await Customer.findOne({ $or: [searchCriteria] });
+    }
+    if (!customer) {
+      const newCustomerData = {
+        ...customerInfo,
+        owner: orderOwner,
+        creator: {
+          type: customerInfo.creator?.type || orderCreator.type,
+          target: customerInfo.creator?.target || orderCreator.target
+        },
+        identity: {
+          type: customerInfo.identity?.type || orderCreator.type,
+          target: customerInfo.identity?.target || orderCreator.target
         }
-      },
-      // 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
-      )
-    ];
+      };
+      customer = await Customer.create(newCustomerData);
+    }
+    return customer;
+  }
+  async function sendOrderMessage(orderData) {
     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);
+      const formattedMessage = formatOrderMessage(orderData);
+      await sendChatMessageTelegram(process.env.TELEGRAM_BOT_USERS.split(","), formattedMessage);
     } 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.findOne({ _id: req.body._id });
-    if (!order) {
-      return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
+      console.error(err);
     }
-    if (req.body.status && req.body.status !== order.status) {
-      order.status = req.body.status;
-      order.status_history.push({
-        status: req.body.status,
-        // user: new db.mongoose.Types.ObjectId(req.userId || req.body.creator.target), 
+  }
+  const controllerFactory = (db) => {
+    const Order = db.order;
+    const Customer = db.customer;
+    const Leftover = db.leftover;
+    const create = async (req, res) => {
+      const orderData = req.body;
+      req.userId || req.body.creator.target;
+      orderData.status = "created";
+      orderData.status_history = orderData.status_history || [];
+      orderData.status_history.push({
+        status: orderData.status,
+        // user: new db.mongoose.Types.ObjectId(userId), 
         timestamp: /* @__PURE__ */ new Date(),
         comment: ""
       });
-    }
-    if (req.body.status === "confirmed") {
       try {
-        const leftover = await Leftover.create({
-          organization: order.organization,
-          type: "stock-out",
-          order: order._id,
-          comment: `Stock-out for order ${order._id}`,
-          positions: order.positions,
-          creator: order.creator,
-          owner: order.owner
-        });
-        console.log("Leftover created:", leftover);
+        if (!orderData.customer.target) {
+          let customer = await findOrCreateCustomer(Customer, orderData.customer, orderData.owner, orderData.creator);
+          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("Error creating Leftover:", err);
+        console.error(err);
+        res.status(500).send({ errorCode: "CREATE_ORDER_FAILED", message: "Error occurred while creating the order.", error: err });
       }
-    }
-    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: "closed", payment: { type: "Cash", status: "paid" } },
-        { new: true }
-      ).exec();
-      if (!order) {
-        return res.status(404).send({ errorCode: "PAYMENT_STATUS_CHANGE_FAILED", message: "Failed to change the payment status." });
+    };
+    const read = async (req, res) => {
+      let 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 });
       }
-      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();
+    };
+    const update = async (req, res) => {
+      const order = await Order.findOne({ _id: req.body._id });
       if (!order) {
-        return res.status(404).send({ errorCode: "ORDER_DELETE_FAILED", message: "Failed to delete the order." });
+        return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
       }
-      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$2;
-const controllerFactory$1 = orders_controller;
-const middlewareFactoryAuth$1 = middlewares;
-var orders_routes = function(app, db, origins, publicPath) {
-  const controller = controllerFactory$1(db);
-  middlewareFactoryAuth$1(db);
-  app.post(
-    "/api/orders/create",
-    // [
-    //   middleware.authJwt.verifyToken
-    // ],
-    controller.create
-  );
-  app.get(
-    "/api/orders/read",
-    controller.read
-  );
-  app.post(
-    "/api/orders/update",
-    // [
-    //   middleware.authJwt.verifyToken
-    // ],
-    controller.update
-  );
-  app.post(
-    "/api/orders/delete",
-    // [
-    //   middleware.authJwt.verifyToken
-    // ],
-    controller.deleteOrder
-  );
-};
-const axios = require$$1;
-const { sendChatMessageTelegram } = mailing;
-const middlewareFactory = (db) => {
-  const Application = db.application;
-  const read = async (req, res) => {
-    try {
-      const applications = await Application.find({});
-      if (!applications) {
-        return res.status(404).send({ message: "Applications not found." });
+      if (req.body.status && req.body.status !== order.status) {
+        order.status = req.body.status;
+        order.status_history.push({
+          status: req.body.status,
+          // user: new db.mongoose.Types.ObjectId(req.userId || req.body.creator.target), 
+          timestamp: /* @__PURE__ */ new Date(),
+          comment: ""
+        });
       }
-      res.status(200).send(applications);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      const application = await Application.create(req.body);
-      if (!application) {
-        return res.status(404).send({ message: "Something wrong when creating application." });
+      if (req.body.status === "confirmed") {
+        try {
+          const leftover = await Leftover.create({
+            organization: order.organization,
+            type: "stock-out",
+            order: order._id,
+            comment: `Stock-out for order ${order._id}`,
+            positions: order.positions,
+            creator: order.creator,
+            owner: order.owner
+          });
+          console.log("Leftover created:", leftover);
+        } catch (err) {
+          console.error("Error creating Leftover:", err);
+        }
       }
       try {
-        const messageSent = await sendChatMessageTelegram(process.env.TELEGRAM_BOT_USERS.split(","), `New application from ${req.body}`);
+        await order.save();
+        res.status(200).send(order);
       } catch (err) {
-        console.log(err);
+        res.status(500).send({ errorCode: "UPDATE_ORDER_FAILED", message: "Error occurred while updating the order.", error: err });
       }
-      res.status(200).send(application);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      const application = await Application.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true });
-      if (!application) {
-        return res.status(404).send({ message: "Application not found." });
+    };
+    const changePaymentStatus = async (req, res) => {
+      try {
+        const order = await Order.findOneAndUpdate(
+          { _id: req.params._id },
+          { status: "closed", payment: { type: "Cash", status: "paid" } },
+          { 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 });
       }
-      res.status(200).send(application);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
-  };
-  const deleteMethod = async (req, res) => {
-    try {
-      const application = await Application.findOneAndDelete({ _id: req.params._id });
-      if (!application) {
-        return res.status(404).send({ message: "Something wrong when deleting application." });
+    };
+    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 });
       }
-      res.status(200).send(application);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
+    };
+    return {
+      create,
+      read,
+      update,
+      changePaymentStatus,
+      deleteOrder
+    };
   };
-  const get = async (req, res) => {
-    try {
-      const application = await Application.findOne({ url: req.params.url });
-      if (!application) {
-        return res.status(404).send({ message: "Application not found." });
-      }
-      res.status(200).send(application);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
+  orders_controller = controllerFactory;
+  return orders_controller;
+}
+var orders_routes;
+var hasRequiredOrders_routes;
+function requireOrders_routes() {
+  if (hasRequiredOrders_routes) return orders_routes;
+  hasRequiredOrders_routes = 1;
+  const controllerFactory = requireOrders_controller();
+  const middlewareFactoryAuth = requireMiddlewares();
+  orders_routes = function(app, db, origins, publicPath) {
+    const controller = controllerFactory(db);
+    middlewareFactoryAuth(db);
+    app.post(
+      "/api/orders/create",
+      // [
+      //   middleware.authJwt.verifyToken
+      // ],
+      controller.create
+    );
+    app.get(
+      "/api/orders/read",
+      controller.read
+    );
+    app.post(
+      "/api/orders/update",
+      // [
+      //   middleware.authJwt.verifyToken
+      // ],
+      controller.update
+    );
+    app.post(
+      "/api/orders/delete",
+      // [
+      //   middleware.authJwt.verifyToken
+      // ],
+      controller.deleteOrder
+    );
   };
-  const handleTelegramWebhook = async (req, res) => {
-    const update2 = req.body;
-    if (update2.callback_query) {
-      const callbackQuery = update2.callback_query;
-      const callbackData = callbackQuery.data;
-      const [action, applicationId] = callbackData.split("_");
+  return orders_routes;
+}
+var applications_controller;
+var hasRequiredApplications_controller;
+function requireApplications_controller() {
+  if (hasRequiredApplications_controller) return applications_controller;
+  hasRequiredApplications_controller = 1;
+  const axios = require$$1;
+  const { sendChatMessageTelegram } = requireMailing();
+  const middlewareFactory = (db) => {
+    const Application = db.application;
+    const read = async (req, res) => {
       try {
-        let updatedApplication = null;
-        switch (action) {
-          case "confirm":
-            updatedApplication = await Application.findOneAndUpdate(
-              { _id: applicationId },
-              { status: "confirmed" },
-              { new: true }
-            );
-            break;
-          case "lost":
-            updatedApplication = await Application.findOneAndUpdate(
-              { _id: applicationId },
-              { status: "lost" },
-              { new: true }
-            );
-            break;
-          case "delete":
-            updatedApplication = await Application.findOneAndDelete({ _id: applicationId });
-            break;
+        const applications = await Application.find({});
+        if (!applications) {
+          return res.status(404).send({ message: "Applications not found." });
         }
-        if (!updatedApplication) {
-          console.log("Application not found or not updated.");
-        } else {
-          console.log("Application updated:", updatedApplication);
+        res.status(200).send(applications);
+      } catch (err) {
+        res.status(500).send({ message: err });
+      }
+    };
+    const create = async (req, res) => {
+      try {
+        const application = await Application.create(req.body);
+        if (!application) {
+          return res.status(404).send({ message: "Something wrong when creating application." });
+        }
+        try {
+          const messageSent = await sendChatMessageTelegram(process.env.TELEGRAM_BOT_USERS.split(","), `New application from ${req.body}`);
+        } catch (err) {
+          console.log(err);
         }
+        res.status(200).send(application);
       } catch (err) {
-        console.log("Error updating application:", err);
+        res.status(500).send({ message: err });
       }
-      const queryId = callbackQuery.id;
-      const telegramToken = "6206215053:AAHYCYzpFZF9jDZC-TC03NSff8oo2ExqsSU";
-      axios.post(`https://api.telegram.org/bot${telegramToken}/answerCallbackQuery`, {
-        callback_query_id: queryId
-      });
-    }
-    res.sendStatus(200);
-  };
-  return {
-    read,
-    create,
-    update,
-    delete: deleteMethod,
-    handleTelegramWebhook,
-    get
-  };
-};
-var applications_controller = middlewareFactory;
-const controllerFactory = applications_controller;
-const middlewareFactoryAuth = middlewares;
-var applications_routes = function(app, db, origins) {
-  const controller = controllerFactory(db);
-  middlewareFactoryAuth(db);
-  app.post(
-    "/applications",
-    controller.create
-  );
-  app.get(
-    "/applications",
-    controller.read
-  );
-  app.post(
-    "/applications/:_id",
-    controller.update
-  );
-  app.delete(
-    "/applications/:_id",
-    controller.delete
-  );
-  app.get(
-    "/applications/:_id",
-    controller.get
-  );
-  app.post(
-    "/applications/telegram-webhook",
-    controller.handleTelegramWebhook
-  );
-};
-const NodeCache = require$$0;
-const stdTTL = 60 * 5;
-let Cache$1 = 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_cache = Cache$1;
-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;
-const Cache2 = globals_cache;
-const Logger2 = globals_logger;
-let CRUD$1 = class CRUD {
-  constructor(basePath, app, db, model) {
-    this.model = model;
-    this.cache = new Cache2();
-    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 stages = [];
-      stages = [
-        ...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 });
-      let data = await this.cache.get(cacheKey);
-      if (!data) {
-        data = await this.model.aggregate(stages).exec();
-        await this.cache.set(cacheKey, data);
+    };
+    const update = async (req, res) => {
+      try {
+        const application = await Application.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true });
+        if (!application) {
+          return res.status(404).send({ message: "Application not found." });
+        }
+        res.status(200).send(application);
+      } catch (err) {
+        res.status(500).send({ message: err });
       }
-      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("Документ не найден.");
+    };
+    const deleteMethod = async (req, res) => {
+      try {
+        const application = await Application.findOneAndDelete({ _id: req.params._id });
+        if (!application) {
+          return res.status(404).send({ message: "Something wrong when deleting application." });
+        }
+        res.status(200).send(application);
+      } catch (err) {
+        res.status(500).send({ message: err });
       }
-      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("Документ не найден.");
+    };
+    const get = async (req, res) => {
+      try {
+        const application = await Application.findOne({ url: req.params.url });
+        if (!application) {
+          return res.status(404).send({ message: "Application not found." });
+        }
+        res.status(200).send(application);
+      } catch (err) {
+        res.status(500).send({ message: err });
       }
-      await this.cache.flush();
-      res.status(204).send();
-    } catch (error) {
-      this.logger.error("Ошибка удаления данных", error);
-      res.status(404).json({ error: error.message });
+    };
+    const handleTelegramWebhook = async (req, res) => {
+      const update2 = req.body;
+      if (update2.callback_query) {
+        const callbackQuery = update2.callback_query;
+        const callbackData = callbackQuery.data;
+        const [action, applicationId] = callbackData.split("_");
+        try {
+          let updatedApplication = null;
+          switch (action) {
+            case "confirm":
+              updatedApplication = await Application.findOneAndUpdate(
+                { _id: applicationId },
+                { status: "confirmed" },
+                { new: true }
+              );
+              break;
+            case "lost":
+              updatedApplication = await Application.findOneAndUpdate(
+                { _id: applicationId },
+                { status: "lost" },
+                { new: true }
+              );
+              break;
+            case "delete":
+              updatedApplication = await Application.findOneAndDelete({ _id: applicationId });
+              break;
+          }
+          if (!updatedApplication) {
+            console.log("Application not found or not updated.");
+          } else {
+            console.log("Application updated:", updatedApplication);
+          }
+        } catch (err) {
+          console.log("Error updating application:", err);
+        }
+        const queryId = callbackQuery.id;
+        const telegramToken = "6206215053:AAHYCYzpFZF9jDZC-TC03NSff8oo2ExqsSU";
+        axios.post(`https://api.telegram.org/bot${telegramToken}/answerCallbackQuery`, {
+          callback_query_id: queryId
+        });
+      }
+      res.sendStatus(200);
+    };
+    return {
+      read,
+      create,
+      update,
+      delete: deleteMethod,
+      handleTelegramWebhook,
+      get
+    };
+  };
+  applications_controller = middlewareFactory;
+  return applications_controller;
+}
+var applications_routes;
+var hasRequiredApplications_routes;
+function requireApplications_routes() {
+  if (hasRequiredApplications_routes) return applications_routes;
+  hasRequiredApplications_routes = 1;
+  const controllerFactory = requireApplications_controller();
+  const middlewareFactoryAuth = requireMiddlewares();
+  applications_routes = function(app, db, origins) {
+    const controller = controllerFactory(db);
+    const { authJwt } = middlewareFactoryAuth(db);
+    app.post(
+      "/applications",
+      controller.create
+    );
+    app.get(
+      "/applications",
+      controller.read
+    );
+    app.post(
+      "/applications/:_id",
+      controller.update
+    );
+    app.delete(
+      "/applications/:_id",
+      controller.delete
+    );
+    app.get(
+      "/applications/:_id",
+      controller.get
+    );
+    app.post(
+      "/applications/telegram-webhook",
+      controller.handleTelegramWebhook
+    );
+  };
+  return applications_routes;
+}
+var orders_server$1;
+var hasRequiredOrders_server;
+function requireOrders_server() {
+  if (hasRequiredOrders_server) return orders_server$1;
+  hasRequiredOrders_server = 1;
+  const ModelOrder = requireOrder_model();
+  const ModelCustomer = requireCustomer_model();
+  const ModelTestimonial = requireTestimonial_model();
+  const ModelApplication = requireApplication_model();
+  const RoutesOrder = requireOrders_routes();
+  const RoutesApplications = requireApplications_routes();
+  const FactoryOrder = requireOrders_controller();
+  const CRUD = requireGlobals_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, origins, publicPath);
+      RoutesApplications(app, db, origins, publicPath);
+      new CRUD("/api/customers", app, db, db.customer);
     }
   }
-};
-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 RoutesApplications = applications_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);
-    RoutesApplications(app, db);
-    new CRUD2("/api/customers", app, db, db.customer);
-  }
+  orders_server$1 = {
+    initialize: initializeOrders,
+    models: {
+      ModelOrder,
+      ModelCustomer
+    },
+    routes: {
+      RoutesOrder
+    },
+    controllers: {
+      FactoryOrder
+    }
+  };
+  return orders_server$1;
 }
-var orders_server = {
-  initialize: initializeOrders,
-  models: {
-    ModelOrder,
-    ModelCustomer
-  },
-  routes: {
-    RoutesOrder
-  },
-  controllers: {
-    FactoryOrder
-  }
-};
-const orders_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(orders_server);
+var orders_serverExports = requireOrders_server();
+const orders_server = /* @__PURE__ */ getDefaultExportFromCjs(orders_serverExports);
 export {
-  orders_server$1 as default
+  orders_server as default
 };