@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/orders.server.cjs

@@ -0,0 +1,820 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const globals_logger = require("./globals.logger-CZMgIMlM.cjs");
+const queryProcessor = require("./queryProcessor-B_X680wC.cjs");
+const mailing = require("./mailing-q7sR8gCV.cjs");
+const credentials_schema = require("./credentials.schema-DwhGdrwC.cjs");
+const ownership_schema = require("./ownership.schema-DCosqOc1.cjs");
+const profile_schema = require("./profile.schema-yQuIzngl.cjs");
+const index = require("./index-YNOkL1mu.cjs");
+const axios = require("axios");
+class CRUD {
+  constructor(basePath, app, db, model, options) {
+    this.model = model;
+    this.cache = new globals_logger.Cache();
+    this.logger = new globals_logger.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 = [
+        ...queryProcessor.queryProcessorGlobals.getBasicOptions(req.query),
+        // For creator
+        queryProcessor.queryProcessorGlobals.getCreatorUserLookupStage(),
+        queryProcessor.queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+        // For owner
+        queryProcessor.queryProcessorGlobals.getOwnerUserLookupStage(),
+        queryProcessor.queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+        queryProcessor.queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+        // Pagination
+        ...queryProcessor.queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+        ...queryProcessor.queryProcessorGlobals.getPaginationOptions(req.query.skip, req.query.limit),
+        queryProcessor.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.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 = [
+      ...queryProcessor.queryProcessorGlobals.getBasicOptions(req.query),
+      ...queryProcessor.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
+      queryProcessor.queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessor.queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      queryProcessor.queryProcessorGlobals.getCreatorCustomerLookupStage(),
+      // For owner
+      queryProcessor.queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessor.queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessor.queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+      // Pagination
+      ...queryProcessor.queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+      ...queryProcessor.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()
+      }
+    }
+  );
+  credentials_schema.applyCredentialsSchema(CustomerSchema);
+  profile_schema.applyProfileSchema(CustomerSchema);
+  ownership_schema.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,
+          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
+          },
+          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
+        },
+        spot: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "User"
+        },
+        status: {
+          type: String,
+          trim: true
+        }
+      }
+    },
+    {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    }
+  );
+  ownership_schema.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
+    }
+  });
+  const Testimonial = db.mongoose.model("Testimonial", testimonialSchema);
+  return Testimonial;
+};
+const { sendChatMessageTelegram } = mailing.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." });
+      }
+      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
+      });
+    }
+    res.sendStatus(200);
+  };
+  return {
+    read,
+    create,
+    update,
+    delete: deleteMethod,
+    handleTelegramWebhook,
+    get
+  };
+};
+const RoutesApplications = function(app, db, origins) {
+  const controller = middlewareFactory(db);
+  index.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);
+  index.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);
+  }
+}
+const models = {
+  ModelOrder,
+  ModelCustomer
+};
+const routes = {
+  RoutesOrder
+};
+const controllers = {
+  FactoryOrder: controllerFactory
+};
+const orders_server = {
+  initialize: initializeOrders,
+  models,
+  routes,
+  controllers
+};
+exports.controllers = controllers;
+exports.default = orders_server;
+exports.initialize = initializeOrders;
+exports.models = models;
+exports.routes = routes;