@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/orders.server.js

@@ -1,22 +1,532 @@
-"use strict";
-const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
-const ownership_schema = require("./ownership.schema-MxfJlPtq.js");
-const profile_schema = require("./profile.schema-BLSuV_VC.js");
-const credentials_schema = require("./credentials.schema-BmOPv6FD.js");
-const queryProcessor = require("./queryProcessor-DSUqSk3I.js");
-const mailing = require("./mailing-D4kWlk3_.js");
-const index = require("./index-BOmxJQ5W.js");
-const require$$0 = require("axios");
-const globals_cache = require("./globals.cache-CwWvNGFQ.js");
-const globals_logger = require("./globals.logger-BdjooLaD.js");
-var order_model;
-var hasRequiredOrder_model;
-function requireOrder_model() {
-  if (hasRequiredOrder_model) return order_model;
-  hasRequiredOrder_model = 1;
-  const applyOwnershipSchema = ownership_schema.requireOwnership_schema();
-  order_model = (db) => {
-    const OrderSchema = new db.mongoose.Schema({
+import { C as Cache, L as Logger } from "./globals.logger-Bf6rRU7j.js";
+import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
+import { m as mailing } from "./mailing-C11EYWm-.js";
+import { a as applyCredentialsSchema } from "./credentials.schema-C9FB2EyY.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-CCZX5vfw.js";
+import { a as applyProfileSchema } from "./profile.schema-DchVS-Jr.js";
+import { m as middlewareIndexFactory } from "./index-CsJwdsBW.js";
+import axios from "axios";
+class CRUD {
+  constructor(basePath, app, db, model, options) {
+    this.model = model;
+    this.cache = new Cache();
+    this.logger = new Logger(db);
+    this.app = app;
+    this.basePath = basePath;
+    if (!options || options && !options.disableDefaultRoutes) 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 = [
+        ...queryProcessorGlobals.getBasicOptions(req.query),
+        // For creator
+        queryProcessorGlobals.getCreatorUserLookupStage(),
+        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+        // 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),
+        queryProcessorGlobals.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);
+      }
+      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 });
+    }
+  }
+}
+const { sendChatMessageTelegram: sendChatMessageTelegram$1 } = mailing;
+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}
+  `;
+}
+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;
+  if (Object.keys(searchCriteria).length > 0) {
+    customer = await Customer.findOne({ $or: [searchCriteria] });
+  }
+  if (!customer) {
+    let creatorType = customerInfo.creator?.type || orderCreator.type;
+    let creatorTarget = customerInfo.creator?.target || orderCreator.target;
+    if (!creatorTarget) {
+      creatorType = orderOwner.type;
+      creatorTarget = orderOwner.target;
+    }
+    const newCustomerData = {
+      ...customerInfo,
+      // Ensure we're not passing any null _id that might override MongoDB's auto-generation
+      _id: void 0,
+      // Let MongoDB generate this
+      owner: orderOwner,
+      creator: {
+        type: creatorType,
+        target: creatorTarget
+      },
+      identity: {
+        type: customerInfo.identity?.type || creatorType,
+        target: customerInfo.identity?.target || creatorTarget
+      }
+    };
+    try {
+      customer = await Customer.create(newCustomerData);
+      if (!customer || !customer._id) {
+        console.error("Customer creation failed to generate _id:", customer);
+        throw new Error("Customer creation did not generate a valid _id");
+      }
+    } catch (err) {
+      console.error("Error creating customer:", err);
+      throw err;
+    }
+  }
+  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 = (db) => {
+  const Order = db.order;
+  const Customer = db.customer;
+  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,
+      timestamp: /* @__PURE__ */ new Date(),
+      comment: ""
+    });
+    console.log("order.data is,", orderData);
+    const session = await db.mongoose.startSession();
+    session.startTransaction();
+    try {
+      if (!orderData.customer.target) {
+        const customer = await findOrCreateCustomer(Customer, orderData.customer, orderData.owner, orderData.creator);
+        console.log("customer is", customer);
+        if (!customer || !customer._id) {
+          throw new Error("Failed to create or find a valid customer");
+        }
+        orderData.customer = {
+          type: "customer",
+          target: customer._id
+        };
+        if (!orderData.creator || !orderData.creator.target) {
+          orderData.creator = {
+            type: "customer",
+            target: customer._id
+          };
+        }
+      }
+      console.log("Order data after customer processing:", orderData);
+      const order = await Order.create([orderData], { session });
+      const createdOrder = order[0];
+      if (orderData.positions && orderData.positions.length > 0) {
+        for (const position of orderData.positions) {
+          try {
+            switch (position.listing) {
+              case "rent":
+                const rentData = {
+                  order: createdOrder._id,
+                  product: position._id,
+                  quantity: position.quantity,
+                  startDate: position.date.start,
+                  endDate: position.date.end,
+                  status: "pending",
+                  // Initial status for rent
+                  creator: orderData.creator,
+                  owner: orderData.owner,
+                  comment: `Created from order ${createdOrder._id}`
+                };
+                console.log(rentData);
+                const rentResponse = await fetch(`${process.env.API_URL || ""}/api/rents`, {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    "X-Service-Key": process.env.SERVICE_KEY
+                  },
+                  body: JSON.stringify(rentData)
+                });
+                if (!rentResponse.ok) {
+                  const errorData = await rentResponse.json();
+                  throw new Error(`Failed to create rent: ${JSON.stringify(errorData)}`);
+                }
+                break;
+              case "sale":
+                console.log(`Sale position for product ${position.product} - leftover creation will be implemented later`);
+                break;
+              default:
+                console.warn(`Unknown listing type: ${position.listing} for position with product ${position.product}`);
+            }
+          } catch (positionError) {
+            console.log(positionError);
+            console.error(`Error processing position for product ${position.product}:`, positionError);
+            throw new Error(`Failed to process position for product ${position.product}: ${positionError.message}`);
+          }
+        }
+      }
+      await session.commitTransaction();
+      sendOrderMessage(orderData).catch(console.error);
+      res.status(201).send(createdOrder);
+    } catch (err) {
+      await session.abortTransaction();
+      console.error(err);
+      res.status(500).send({
+        errorCode: "CREATE_ORDER_FAILED",
+        message: "Error occurred while creating the order.",
+        error: err.message
+      });
+    } finally {
+      session.endSession();
+    }
+  };
+  const read = async (req, res) => {
+    console.log(req.query);
+    let stages = [
+      ...queryProcessorGlobals.getBasicOptions(req.query),
+      ...queryProcessorGlobals.getSearchOptions(req.query.search, {
+        fields: ["positions.name"]
+      }),
+      // For spots
+      {
+        $lookup: {
+          from: "spots",
+          localField: "delivery.spot",
+          foreignField: "_id",
+          as: "delivery.spot"
+        }
+      },
+      // 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) => {
+    try {
+      const order = await Order.findOne({ _id: req.body._id });
+      if (!order) {
+        return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
+      }
+      const statusChanged = req.body.status && req.body.status !== order.status;
+      const oldStatus = order.status;
+      if (statusChanged) {
+        order.status = req.body.status;
+        order.status_history.push({
+          status: req.body.status,
+          timestamp: /* @__PURE__ */ new Date(),
+          comment: ""
+        });
+      }
+      if (req.body.payment?.type && req.body.payment.type !== order.payment?.type) {
+        order.payment.type = req.body.payment.type;
+      }
+      if (req.body.payment?.status && req.body.payment.status !== order.payment?.status) {
+        order.payment.status = req.body.payment.status;
+      }
+      await order.save();
+      if (statusChanged) {
+        try {
+          const notificationData = {
+            title: `Order Status Updated`,
+            body: `Order #${order._id} status changed from ${oldStatus} to ${order.status}`,
+            type: "order_status",
+            metadata: {
+              orderId: order._id,
+              oldStatus,
+              newStatus: order.status,
+              positions: order.positions
+            },
+            userId: order.creator.target
+            // Assuming creator.target holds the user ID
+          };
+          console.log("notifiocatio data", JSON.stringify(notificationData));
+          console.log("notification api is", `${process.env.API_URL || ""}/api/notifications`);
+          const notificationResponse = await fetch(`${process.env.API_URL || ""}/api/notifications`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-Service-Key": process.env.SERVICE_KEY
+            },
+            body: JSON.stringify(notificationData)
+          });
+          if (!notificationResponse.ok) {
+            const errorData = await notificationResponse.json();
+            console.error(`Failed to create notification: ${JSON.stringify(errorData)}`);
+          }
+        } catch (notificationError) {
+          console.error("Error sending notification:", notificationError);
+        }
+      }
+      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."
+        });
+      }
+      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
+  };
+};
+const ModelApplication = (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 ModelCustomer = (db) => {
+  const CustomerSchema = new db.mongoose.Schema(
+    {
+      identity: {
+        type: {
+          type: String,
+          enum: ["Visitor", "User", "Organization"],
+          required: true
+          // set: toPascalCase
+        },
+        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;
+};
+const ModelOrder = (db) => {
+  const OrderSchema = new db.mongoose.Schema(
+    {
       customer: {
         type: {
           type: String,
@@ -42,24 +552,26 @@ function requireOrder_model() {
         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
+      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
@@ -94,832 +606,215 @@ function requireOrder_model() {
           trim: true
         }
       }
-    }, {
-      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 = ownership_schema.requireOwnership_schema();
-  const applyProfileSchema = profile_schema.requireProfile_schema();
-  const applyCredentialsSchema = credentials_schema.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"
-        }
-      },
-      referral: {
-        code: {
-          type: String
-        }
-      }
-    }, {
+    },
+    {
       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
-      },
-      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;
-  };
-  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"
-      },
-      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;
-  };
-  return application_model;
-}
-var orders_controller;
-var hasRequiredOrders_controller;
-function requireOrders_controller() {
-  if (hasRequiredOrders_controller) return orders_controller;
-  hasRequiredOrders_controller = 1;
-  const queryProcessorGlobals = queryProcessor.requireQueryProcessor();
-  const { sendChatMessageTelegram } = mailing.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"}
-    🏢 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}
-  `;
-  }
-  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;
-    if (Object.keys(searchCriteria).length > 0) {
-      customer = await Customer.findOne({ $or: [searchCriteria] });
     }
-    if (!customer) {
-      let creatorType = customerInfo.creator?.type || orderCreator.type;
-      let creatorTarget = customerInfo.creator?.target || orderCreator.target;
-      if (!creatorTarget) {
-        creatorType = orderOwner.type;
-        creatorTarget = orderOwner.target;
-      }
-      const newCustomerData = {
-        ...customerInfo,
-        // Ensure we're not passing any null _id that might override MongoDB's auto-generation
-        _id: void 0,
-        // Let MongoDB generate this
-        owner: orderOwner,
-        creator: {
-          type: creatorType,
-          target: creatorTarget
-        },
-        identity: {
-          type: customerInfo.identity?.type || creatorType,
-          target: customerInfo.identity?.target || creatorTarget
-        }
-      };
-      try {
-        customer = await Customer.create(newCustomerData);
-        if (!customer || !customer._id) {
-          console.error("Customer creation failed to generate _id:", customer);
-          throw new Error("Customer creation did not generate a valid _id");
-        }
-      } catch (err) {
-        console.error("Error creating customer:", err);
-        throw err;
-      }
+  );
+  applyOwnershipSchema(OrderSchema, db);
+  const Order = db.mongoose.model("Order", OrderSchema);
+  return Order;
+};
+const ModelTestimonial = (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
     }
-    return customer;
-  }
-  async function sendOrderMessage(orderData) {
+  });
+  const Testimonial = db.mongoose.model("Testimonial", testimonialSchema);
+  return Testimonial;
+};
+const { sendChatMessageTelegram } = mailing;
+const middlewareFactory = (db) => {
+  const Application = db.application;
+  const read = async (req, res) => {
     try {
-      const formattedMessage = formatOrderMessage(orderData);
-      await sendChatMessageTelegram(process.env.TELEGRAM_BOT_USERS.split(","), formattedMessage);
+      const applications = await Application.find({});
+      if (!applications) {
+        return res.status(404).send({ message: "Applications not found." });
+      }
+      res.status(200).send(applications);
     } catch (err) {
-      console.error(err);
+      res.status(500).send({ message: err });
     }
-  }
-  const controllerFactory = (db) => {
-    const Order = db.order;
-    const Customer = db.customer;
-    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,
-        timestamp: /* @__PURE__ */ new Date(),
-        comment: ""
-      });
-      console.log("order.data is,", orderData);
-      const session = await db.mongoose.startSession();
-      session.startTransaction();
-      try {
-        if (!orderData.customer.target) {
-          const customer = await findOrCreateCustomer(Customer, orderData.customer, orderData.owner, orderData.creator);
-          console.log("customer is", customer);
-          if (!customer || !customer._id) {
-            throw new Error("Failed to create or find a valid customer");
-          }
-          orderData.customer = {
-            type: "Customer",
-            target: customer._id
-          };
-          if (!orderData.creator || !orderData.creator.target) {
-            orderData.creator = {
-              type: "Customer",
-              target: customer._id
-            };
-          }
-        }
-        console.log("Order data after customer processing:", orderData);
-        const order = await Order.create([orderData], { session });
-        const createdOrder = order[0];
-        if (orderData.positions && orderData.positions.length > 0) {
-          for (const position of orderData.positions) {
-            try {
-              switch (position.listing) {
-                case "rent":
-                  const rentData = {
-                    order: createdOrder._id,
-                    product: position._id,
-                    quantity: position.quantity,
-                    startDate: position.date.start,
-                    endDate: position.date.end,
-                    status: "pending",
-                    // Initial status for rent
-                    creator: orderData.creator,
-                    owner: orderData.owner,
-                    comment: `Created from order ${createdOrder._id}`
-                  };
-                  console.log(rentData);
-                  const rentResponse = await fetch(`${process.env.API_URL || ""}/api/rents`, {
-                    method: "POST",
-                    headers: {
-                      "Content-Type": "application/json",
-                      "X-Service-Key": process.env.SERVICE_KEY
-                    },
-                    body: JSON.stringify(rentData)
-                  });
-                  if (!rentResponse.ok) {
-                    const errorData = await rentResponse.json();
-                    throw new Error(`Failed to create rent: ${JSON.stringify(errorData)}`);
-                  }
-                  break;
-                case "sale":
-                  console.log(`Sale position for product ${position.product} - leftover creation will be implemented later`);
-                  break;
-                default:
-                  console.warn(`Unknown listing type: ${position.listing} for position with product ${position.product}`);
-              }
-            } catch (positionError) {
-              console.log(positionError);
-              console.error(`Error processing position for product ${position.product}:`, positionError);
-              throw new Error(`Failed to process position for product ${position.product}: ${positionError.message}`);
-            }
-          }
-        }
-        await session.commitTransaction();
-        sendOrderMessage(orderData).catch(console.error);
-        res.status(201).send(createdOrder);
-      } catch (err) {
-        await session.abortTransaction();
-        console.error(err);
-        res.status(500).send({
-          errorCode: "CREATE_ORDER_FAILED",
-          message: "Error occurred while creating the order.",
-          error: err.message
-        });
-      } finally {
-        session.endSession();
+  };
+  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." });
       }
-    };
-    const read = async (req, res) => {
-      console.log(req.query);
-      let stages = [
-        ...queryProcessorGlobals.getBasicOptions(
-          req.query
-        ),
-        ...queryProcessorGlobals.getSearchOptions(
-          req.query.search,
-          {
-            fields: ["positions.name"]
-          }
-        ),
-        // For spots
-        {
-          $lookup: {
-            from: "spots",
-            localField: "delivery.spot",
-            foreignField: "_id",
-            as: "delivery.spot"
-          }
-        },
-        // 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);
+        const messageSent = await sendChatMessageTelegram(process.env.TELEGRAM_BOT_USERS.split(","), `New application from ${req.body}`);
       } 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) => {
-      try {
-        const order = await Order.findOne({ _id: req.body._id });
-        if (!order) {
-          return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
-        }
-        const statusChanged = req.body.status && req.body.status !== order.status;
-        const oldStatus = order.status;
-        if (statusChanged) {
-          order.status = req.body.status;
-          order.status_history.push({
-            status: req.body.status,
-            timestamp: /* @__PURE__ */ new Date(),
-            comment: ""
-          });
-        }
-        if (req.body.payment?.type && req.body.payment.type !== order.payment?.type) {
-          order.payment.type = req.body.payment.type;
-        }
-        if (req.body.payment?.status && req.body.payment.status !== order.payment?.status) {
-          order.payment.status = req.body.payment.status;
-        }
-        await order.save();
-        if (statusChanged) {
-          try {
-            const notificationData = {
-              title: `Order Status Updated`,
-              body: `Order #${order._id} status changed from ${oldStatus} to ${order.status}`,
-              type: "order_status",
-              metadata: {
-                orderId: order._id,
-                oldStatus,
-                newStatus: order.status,
-                positions: order.positions
-              },
-              userId: order.creator.target
-              // Assuming creator.target holds the user ID
-            };
-            console.log("notifiocatio data", JSON.stringify(notificationData));
-            console.log("notification api is", `${process.env.API_URL || ""}/api/notifications`);
-            const notificationResponse = await fetch(`${process.env.API_URL || ""}/api/notifications`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                "X-Service-Key": process.env.SERVICE_KEY
-              },
-              body: JSON.stringify(notificationData)
-            });
-            if (!notificationResponse.ok) {
-              const errorData = await notificationResponse.json();
-              console.error(`Failed to create notification: ${JSON.stringify(errorData)}`);
-            }
-          } catch (notificationError) {
-            console.error("Error sending notification:", notificationError);
-          }
-        }
-        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." });
-        }
-        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
-    };
-  };
-  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 = index.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
-    );
+      res.status(200).send(application);
+    } catch (err) {
+      res.status(500).send({ message: err });
+    }
   };
-  return orders_routes;
-}
-var applications_controller;
-var hasRequiredApplications_controller;
-function requireApplications_controller() {
-  if (hasRequiredApplications_controller) return applications_controller;
-  hasRequiredApplications_controller = 1;
-  const axios = require$$0;
-  const { sendChatMessageTelegram } = mailing.requireMailing();
-  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." });
-        }
-        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) {
-        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." });
-        }
-        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." });
-        }
-        res.status(200).send(application);
-      } catch (err) {
-        res.status(500).send({ message: err });
-      }
-    };
-    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 });
-      }
-    };
-    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
-        });
+  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.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 = index.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 globals_crud;
-var hasRequiredGlobals_crud;
-function requireGlobals_crud() {
-  if (hasRequiredGlobals_crud) return globals_crud;
-  hasRequiredGlobals_crud = 1;
-  const globalsQuery = queryProcessor.requireQueryProcessor();
-  const Cache = globals_cache.requireGlobals_cache();
-  const Logger = globals_logger.requireGlobals_logger();
-  class CRUD {
-    constructor(basePath, app, db, model, options) {
-      this.model = model;
-      this.cache = new Cache();
-      this.logger = new Logger(db);
-      this.app = app;
-      this.basePath = basePath;
-      if (!options || options && !options.disableDefaultRoutes) 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));
+      res.status(200).send(application);
+    } catch (err) {
+      res.status(500).send({ message: err });
     }
-    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 });
+  };
+  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 });
     }
-    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);
-        }
-        res.json(data);
-      } catch (error) {
-        this.logger.error(error);
-        res.status(500).json({ error: error.message });
+  };
+  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 });
     }
-    async update(req, res) {
+  };
+  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 {
-        const updatedData = await this.model.findOneAndUpdate(
-          { _id: req.body._id },
-          req.body,
-          { new: true, runValidators: true }
-        );
-        if (!updatedData) {
-          throw new Error("Документ не найден.");
+        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;
         }
-        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("Документ не найден.");
+        if (!updatedApplication) {
+          console.log("Application not found or not updated.");
+        } else {
+          console.log("Application updated:", updatedApplication);
         }
-        await this.cache.flush();
-        res.status(204).send();
-      } catch (error) {
-        this.logger.error("Ошибка удаления данных", error);
-        res.status(404).json({ error: error.message });
+      } 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
+      });
     }
-  }
-  globals_crud = CRUD;
-  return globals_crud;
-}
-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);
-    }
-  }
-  orders_server$1 = {
-    initialize: initializeOrders,
-    models: {
-      ModelOrder,
-      ModelCustomer
-    },
-    routes: {
-      RoutesOrder
-    },
-    controllers: {
-      FactoryOrder
-    }
+    res.sendStatus(200);
+  };
+  return {
+    read,
+    create,
+    update,
+    delete: deleteMethod,
+    handleTelegramWebhook,
+    get
   };
-  return orders_server$1;
+};
+const RoutesApplications = function(app, db, origins) {
+  const controller = middlewareFactory(db);
+  middlewareIndexFactory(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 RoutesOrder = function(app, db, origins, publicPath) {
+  const controller = controllerFactory(db);
+  middlewareIndexFactory(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
+  );
+};
+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 CRUD("/api/customers", app, db, db.customer);
+  }
 }
-var orders_serverExports = requireOrders_server();
-const orders_server = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(orders_serverExports);
-module.exports = orders_server;
+const models = {
+  ModelOrder,
+  ModelCustomer
+};
+const routes = {
+  RoutesOrder
+};
+const controllers = {
+  FactoryOrder: controllerFactory
+};
+const orders_server = {
+  initialize: initializeOrders,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  orders_server as default,
+  initializeOrders as initialize,
+  models,
+  routes
+};