@ozdao/martyrs 0.2.551 → 0.2.553

package/dist/orders.server.cjs

@@ -1,1284 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-require("node-cache");
-const queryProcessor = require("./queryProcessor-DJUTwCLN.cjs");
-require("./mailing-DCvDBHVh.cjs");
-const profile_schema = require("./profile.schema-l0Dk4Ptu.cjs");
-const ownership_schema = require("./ownership.schema-CRYdbemm.cjs");
-const credentials_schema = require("./credentials.schema-DVXaFnXl.cjs");
-const crud = require("./crud-CQ3ICbm7.cjs");
-const abac = require("./abac-gNSxNkX1.cjs");
-const axios = require("axios");
-const core_verifier = require("./core.verifier-Bi-XLEi9.cjs");
-const index = require("./index-BFxqqmgh.cjs");
-const controllerFactory = (db) => {
-  const Order = db.order;
-  const Customer = db.customer;
-  const Department = db.department;
-  const { findOrCreateVisitor } = profile_schema.modelsFactory(db);
-  const getUsersWithOrdersConfirmAccess = async (organizationId) => {
-    console.log("=== Getting users with orders.confirm access ===");
-    console.log("Organization ID:", organizationId);
-    const pipeline = [
-      { $match: {
-        organization: new db.mongoose.Types.ObjectId(organizationId),
-        "accesses.orders.confirm": true
-      } },
-      { $unwind: "$members" },
-      { $group: {
-        _id: "$members.user"
-      } },
-      { $project: { userId: "$_id" } }
-    ];
-    console.log("Pipeline:", JSON.stringify(pipeline, null, 2));
-    const result = await Department.aggregate(pipeline);
-    const userIds = result.map((item) => item.userId);
-    console.log("Found departments with access:", result.length);
-    console.log("User IDs with access:", userIds);
-    console.log("=== End getting users ===");
-    return userIds;
-  };
-  const sendOrderNotifications = async (order, type, userIds, extraData = {}) => {
-    console.log("=== Sending order notifications ===");
-    console.log("Order ID:", order._id);
-    console.log("Type:", type);
-    console.log("User IDs:", userIds);
-    console.log("Extra data:", extraData);
-    if (!userIds || userIds.length === 0) {
-      console.log("No users to notify, skipping...");
-      return;
-    }
-    const notifications = userIds.map((userId) => ({
-      title: getNotificationTitle(type, order, extraData),
-      body: getNotificationBody(type, order, extraData),
-      type,
-      metadata: {
-        type,
-        orderId: order._id,
-        context: "organization",
-        ...extraData
-      },
-      userId
-    }));
-    function getNotificationTitle(type2, order2, extraData2 = {}) {
-      switch (type2) {
-        case "order_created":
-          return "New Order";
-        case "order_status":
-          return "Order Status Updated";
-        default:
-          return "Order Notification";
-      }
-    }
-    function getNotificationBody(type2, order2, extraData2 = {}) {
-      switch (type2) {
-        case "order_created":
-          return `New order #${order2._id} created`;
-        case "order_status":
-          return `Order #${order2._id} changed from ${extraData2.oldStatus} to ${extraData2.newStatus}`;
-        default:
-          return `Order #${order2._id} updated`;
-      }
-    }
-    console.log("Prepared notifications:", JSON.stringify(notifications, null, 2));
-    console.log("API URL:", `${process.env.API_URL || ""}/api/notifications/batch`);
-    try {
-      const response = await fetch(`${process.env.API_URL || ""}/api/notifications/batch`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Service-Key": process.env.SERVICE_KEY
-        },
-        body: JSON.stringify({ notifications })
-      });
-      console.log("Notification response status:", response.status);
-      if (!response.ok) {
-        const errorData = await response.text();
-        console.error("Notification API error:", errorData);
-        throw new Error(`Notification API failed: ${response.status} - ${errorData}`);
-      }
-      const result = await response.json();
-      console.log("Notification API success:", result);
-      console.log("=== End sending notifications ===");
-      return result;
-    } catch (error) {
-      console.error("=== Notification sending failed ===");
-      console.error("Error:", error.message);
-      console.error("Stack:", error.stack);
-      throw error;
-    }
-  };
-  const findOrCreateCustomer = async (customerInfo, orderOwner, orderCreator, req) => {
-    let searchCriteria = {};
-    if (customerInfo.phone) {
-      searchCriteria.phone = customerInfo.phone;
-    }
-    if (customerInfo.email) {
-      searchCriteria.email = customerInfo.email;
-    }
-    let customer = null;
-    if (Object.keys(searchCriteria).length > 0) {
-      customer = await Customer.findOne({ $or: [searchCriteria] });
-    }
-    if (!customer) {
-      const visitor = await findOrCreateVisitor(req);
-      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: "Visitor",
-          target: visitor._id
-        }
-      };
-      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;
-  };
-  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: ""
-    });
-    const session = await db.mongoose.startSession();
-    session.startTransaction();
-    try {
-      if (!orderData.customer.target) {
-        const customer = await findOrCreateCustomer(orderData.customer, orderData.owner, orderData.creator, req);
-        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];
-      await session.commitTransaction();
-      try {
-        const usersWithAccess = await getUsersWithOrdersConfirmAccess(orderData.owner.target);
-        await sendOrderNotifications(createdOrder, "order_created", usersWithAccess, {
-          organization: createdOrder.owner.target
-        });
-      } catch (notificationError) {
-        console.error("Error sending notification:", notificationError);
-      }
-      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.queryProcessorCore.getBasicOptions(req.query),
-      ...queryProcessor.queryProcessorCore.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.queryProcessorCore.getCreatorUserLookupStage(),
-      queryProcessor.queryProcessorCore.getCreatorOrganizationLookupStage(),
-      queryProcessor.queryProcessorCore.getCreatorCustomerLookupStage(),
-      // For owner
-      queryProcessor.queryProcessorCore.getOwnerUserLookupStage(),
-      queryProcessor.queryProcessorCore.getOwnerOrganizationLookupStage(),
-      queryProcessor.queryProcessorCore.getAddFieldsCreatorOwnerStage(),
-      // Pagination
-      ...queryProcessor.queryProcessorCore.getSortingOptions(req.query.sortParam, req.query.sortOrder),
-      ...queryProcessor.queryProcessorCore.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) => {
-    console.log("=== ORDER UPDATE START ===");
-    console.log("User ID:", req.userId);
-    console.log("Request body:", JSON.stringify(req.body, null, 2));
-    const session = await db.mongoose.startSession();
-    session.startTransaction();
-    console.log("Transaction started");
-    console.log("url order notifi", `${process.env.API_URL || ""}/api/inventory/adjustments/create`);
-    try {
-      console.log("Finding order with ID:", req.body._id);
-      const order = await Order.findOne({ _id: req.body._id }).session(session);
-      if (!order) {
-        console.log("Order not found");
-        await session.abortTransaction();
-        return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
-      }
-      console.log("Order found, current status:", order.status);
-      const statusChanged = req.body.status && req.body.status !== order.status;
-      const oldStatus = order.status;
-      console.log("Status changed:", statusChanged, "from", oldStatus, "to", req.body.status);
-      if (req.body.status === "confirmed" && oldStatus !== "confirmed") {
-        console.log("Processing confirmed status change - creating rents/adjustments");
-        if (req.body.positions) {
-          console.log("Updating order positions");
-          order.positions = req.body.positions;
-        }
-        console.log("Total positions to process:", order.positions.length);
-        const apiCalls = [];
-        for (const [index2, position] of order.positions.entries()) {
-          console.log(`Processing position ${index2 + 1}/${order.positions.length}:`, position.name, "listing:", position.listing);
-          switch (position.listing) {
-            case "rent":
-              console.log(`Creating rent for position ${index2 + 1}`);
-              const rentData = {
-                order: order._id,
-                product: position._id,
-                variant: position.variant,
-                quantity: position.quantity,
-                startDate: position.date.start,
-                endDate: position.date.end,
-                status: "pending",
-                creator: order.creator,
-                owner: order.owner,
-                comment: `Created from order ${order._id}`
-              };
-              const rentPromise = 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)
-              }).then(async (response) => {
-                console.log(`Rent API response for position ${index2 + 1}:`, response.status);
-                if (!response.ok) {
-                  const errorData = await response.json();
-                  throw new Error(`Failed to create rent for position ${index2 + 1}: ${JSON.stringify(errorData)}`);
-                }
-                const result = await response.json();
-                console.log(`Rent created successfully for position ${index2 + 1}:`, result._id);
-                return result;
-              });
-              apiCalls.push(rentPromise);
-              break;
-            case "sale":
-              console.log(`Creating stock adjustment for position ${index2 + 1}`);
-              const adjustmentData = {
-                product: position._id,
-                variant: position.variant,
-                storage: order.delivery?.spot,
-                source: { type: "Order", target: order._id },
-                reason: "sale",
-                quantity: -position.quantity,
-                // Negative for stock-out
-                comment: `Stock-out for order ${order._id}`,
-                owner: order.owner,
-                creator: { type: "User", target: req.userId }
-              };
-              const adjustmentPromise = fetch(`${process.env.API_URL || ""}/api/inventory/adjustments/create`, {
-                method: "POST",
-                headers: {
-                  "Content-Type": "application/json",
-                  "X-Service-Key": process.env.SERVICE_KEY
-                },
-                body: JSON.stringify(adjustmentData)
-              }).then(async (response) => {
-                console.log(`Adjustment API response for position ${index2 + 1}:`, response.status);
-                if (!response.ok) {
-                  const errorData = await response.json();
-                  throw new Error(`Failed to create stock adjustment for position ${index2 + 1}: ${JSON.stringify(errorData)}`);
-                }
-                const result = await response.json();
-                console.log(`Stock adjustment created successfully for position ${index2 + 1}:`, result._id);
-                return result;
-              });
-              apiCalls.push(adjustmentPromise);
-              break;
-            default:
-              console.warn(`Unknown listing type: ${position.listing} for position ${position._id}`);
-          }
-        }
-        if (apiCalls.length > 0) {
-          console.log(`Executing ${apiCalls.length} API calls in parallel...`);
-          await Promise.all(apiCalls);
-          console.log("All API calls completed successfully");
-        } else {
-          console.log("No API calls to execute");
-        }
-      }
-      if (statusChanged) {
-        console.log("Updating order status from", oldStatus, "to", req.body.status);
-        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) {
-        console.log("Updating payment type to:", req.body.payment.type);
-        order.payment.type = req.body.payment.type;
-      }
-      if (req.body.payment?.status && req.body.payment.status !== order.payment?.status) {
-        console.log("Updating payment status to:", req.body.payment.status);
-        order.payment.status = req.body.payment.status;
-      }
-      console.log("Saving order to database...");
-      await order.save({ session });
-      console.log("Order saved successfully");
-      console.log("Committing transaction...");
-      await session.commitTransaction();
-      console.log("Transaction committed successfully");
-      if (statusChanged) {
-        console.log("Sending notification for status change...");
-        try {
-          const usersWithAccess = await getUsersWithOrdersConfirmAccess(order.owner.target);
-          await sendOrderNotifications(order, "order_status", usersWithAccess, {
-            oldStatus,
-            newStatus: order.status,
-            organization: order.owner.target
-          });
-          console.log("Notification sent successfully");
-        } catch (notificationError) {
-          console.error("Error sending notification:", notificationError);
-        }
-      }
-      console.log("Sending response to client...");
-      res.status(200).send(order);
-      console.log("=== ORDER UPDATE COMPLETED SUCCESSFULLY ===");
-    } catch (err) {
-      console.log("=== ERROR OCCURRED ===");
-      console.error("Error details:", err);
-      console.error("Error stack:", err.stack);
-      try {
-        await session.abortTransaction();
-        console.log("Transaction aborted successfully");
-      } catch (abortErr) {
-        console.error("Error aborting transaction:", abortErr);
-      }
-      res.status(500).send({
-        errorCode: "UPDATE_ORDER_FAILED",
-        message: "Error occurred while updating the order.",
-        error: err.message
-      });
-      console.log("Error response sent to client");
-    } finally {
-      try {
-        session.endSession();
-        console.log("Session ended");
-      } catch (sessionErr) {
-        console.error("Error ending session:", sessionErr);
-      }
-      console.log("=== ORDER UPDATE PROCESS FINISHED ===");
-    }
-  };
-  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
-        }
-      },
-      text: {
-        type: String
-      },
-      data: {
-        type: Object
-      },
-      chat: {
-        type: String
-      },
-      customer: {
-        type: {
-          type: String,
-          enum: ["Customer"]
-        },
-        target: {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Customer"
-        }
-      }
-    },
-    {
-      timestamps: { currentTime: () => Date.now() }
-    }
-  );
-  ownership_schema.applyOwnershipSchema(ApplicationSchema, db);
-  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"
-        }
-      },
-      source: {
-        type: String,
-        enum: ["web", "mobile", "api", "import", "manual", "referral", "social", "email"],
-        default: "web"
-      },
-      referral: {
-        code: {
-          type: String
-        },
-        source: {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Customer"
-        }
-      },
-      tags: [{
-        type: String
-      }],
-      notes: {
-        type: String
-      },
-      lastActivity: {
-        type: Date,
-        default: Date.now
-      },
-      status: {
-        type: String,
-        enum: ["active", "inactive", "blocked"],
-        default: "active"
-      },
-      address: {
-        country: {
-          type: String
-        },
-        addressLine1: {
-          type: String,
-          required: true
-        },
-        addressLine2: {
-          type: String
-        },
-        city: {
-          type: String
-        },
-        postalCode: {
-          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 verifierFactory$1 = (function(db) {
-  const createVerifier = new core_verifier.Verifier({
-    "contacts.name": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Name must be at least 1 character").max(255, "Name must not exceed 255 characters")
-    },
-    "contacts.email": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
-    },
-    "contacts.phone": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
-    },
-    type: {
-      rule: "optional",
-      default: "newsletter",
-      validator: core_verifier.Validator.schema().string().oneOf(["newsletter", "support", "inquiry", "feedback", "other"])
-    },
-    text: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(2e3, "Text must not exceed 2000 characters")
-    },
-    chat: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(255, "Chat ID must not exceed 255 characters")
-    },
-    status: {
-      rule: "optional",
-      default: "created",
-      validator: core_verifier.Validator.schema().string().oneOf(["created", "in_progress", "completed", "cancelled"])
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization", "User", "Organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Application ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid ID format")
-    },
-    "contacts.name": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Name must be at least 1 character").max(255, "Name must not exceed 255 characters")
-    },
-    "contacts.email": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
-    },
-    "contacts.phone": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
-    },
-    type: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["newsletter", "support", "inquiry", "feedback", "other"])
-    },
-    text: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(2e3, "Text must not exceed 2000 characters")
-    },
-    chat: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(255, "Chat ID must not exceed 255 characters")
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["created", "in_progress", "completed", "cancelled"])
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["created", "in_progress", "completed", "cancelled"])
-    },
-    type: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["newsletter", "support", "inquiry", "feedback", "other"])
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["contacts.name", "contacts.email", "type", "status", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Application ID is required").pattern(/^[0-9a-fA-F]{24}$/)
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-});
-const { getInstance: getInstance$1 } = abac.ABAC;
-function setupApplicationsRoutes(app, db) {
-  const abac2 = getInstance$1(db);
-  const verifier = verifierFactory$1();
-  const applicationsCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.application,
-    modelName: "application",
-    basePath: "/api/applications",
-    auth: true,
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["application", "orders"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  applicationsCRUD.addAction("telegram-webhook", {
-    method: "post",
-    path: "/telegram-webhook",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      const update = req.body;
-      if (update.callback_query) {
-        const callbackQuery = update.callback_query;
-        const callbackData = callbackQuery.data;
-        const [action, applicationId] = callbackData.split("_");
-        try {
-          let updatedApplication = null;
-          switch (action) {
-            case "confirm":
-              updatedApplication = await db.application.findOneAndUpdate({ _id: applicationId }, { status: "confirmed" }, { new: true });
-              break;
-            case "lost":
-              updatedApplication = await db.application.findOneAndUpdate({ _id: applicationId }, { status: "lost" }, { new: true });
-              break;
-            case "delete":
-              updatedApplication = await db.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);
-    }
-  });
-  applicationsCRUD.addAction("public-create", {
-    method: "post",
-    path: "/public",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const applicationData = {
-          ...req.body,
-          owner: {
-            type: "platform",
-            target: "000000000000000000000000"
-            // заглушка для отдела платформы
-          },
-          creator: {
-            type: "platform",
-            target: "000000000000000000000000"
-          }
-        };
-        const application = new db.application(applicationData);
-        const saved = await application.save();
-        res.status(201).json(saved);
-      } catch (error) {
-        console.error("Error creating public application:", error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  return applicationsCRUD;
-}
-const RoutesOrder = (function(app, db, origins, publicPath) {
-  const controller = controllerFactory(db);
-  const middleware = index.middlewareIndexFactory(db);
-  app.post(
-    "/api/orders/create",
-    [
-      middleware.authJwt.verifyToken(true)
-    ],
-    controller.create
-  );
-  app.get(
-    "/api/orders/read",
-    [
-      middleware.authJwt.verifyToken(true)
-    ],
-    controller.read
-  );
-  app.post(
-    "/api/orders/update",
-    [
-      middleware.authJwt.verifyToken()
-    ],
-    controller.update
-  );
-  app.post(
-    "/api/orders/delete",
-    [
-      middleware.authJwt.verifyToken()
-    ],
-    controller.deleteOrder
-  );
-});
-const verifierFactory = (function(db) {
-  const createVerifier = new core_verifier.Verifier({
-    email: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
-    },
-    phone: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
-    },
-    "profile.name": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Name must be at least 1 character").max(255, "Name must not exceed 255 characters")
-    },
-    "profile.description": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
-    },
-    "profile.photo": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(500, "Photo URL must not exceed 500 characters")
-    },
-    source: {
-      rule: "optional",
-      default: "web",
-      validator: core_verifier.Validator.schema().string().oneOf(["web", "mobile", "api", "import", "manual", "referral", "social", "email"])
-    },
-    "referral.code": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(50, "Referral code must not exceed 50 characters")
-    },
-    "referral.source": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid referral source ID format")
-    },
-    tags: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(core_verifier.Validator.schema().string().max(50)).max(20, "Cannot have more than 20 tags")
-    },
-    notes: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(2e3, "Notes must not exceed 2000 characters")
-    },
-    status: {
-      rule: "optional",
-      default: "active",
-      validator: core_verifier.Validator.schema().string().oneOf(["active", "inactive", "blocked"])
-    },
-    "identity.type": {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().oneOf(["Visitor", "User", "Organization"])
-    },
-    "identity.target": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid identity target ID format")
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization", "User", "Organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    },
-    "address.country": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(100, "Country must not exceed 100 characters")
-    },
-    "address.addressLine1": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(255, "Address line 1 must not exceed 255 characters")
-    },
-    "address.addressLine2": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(255, "Address line 2 must not exceed 255 characters")
-    },
-    "address.city": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(100, "City must not exceed 100 characters")
-    },
-    "address.postalCode": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(20, "Postal code must not exceed 20 characters")
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Customer ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid ID format")
-    },
-    email: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
-    },
-    phone: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
-    },
-    "profile.name": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Name must be at least 1 character").max(255, "Name must not exceed 255 characters")
-    },
-    "profile.description": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
-    },
-    "profile.photo": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(500, "Photo URL must not exceed 500 characters")
-    },
-    source: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["web", "mobile", "api", "import", "manual", "referral", "social", "email"])
-    },
-    "referral.code": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(50, "Referral code must not exceed 50 characters")
-    },
-    "referral.source": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid referral source ID format")
-    },
-    tags: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(core_verifier.Validator.schema().string().max(50)).max(20, "Cannot have more than 20 tags")
-    },
-    notes: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(2e3, "Notes must not exceed 2000 characters")
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["active", "inactive", "blocked"])
-    },
-    "address.country": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(100, "Country must not exceed 100 characters")
-    },
-    "address.addressLine1": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(255, "Address line 1 must not exceed 255 characters")
-    },
-    "address.addressLine2": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(255, "Address line 2 must not exceed 255 characters")
-    },
-    "address.city": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(100, "City must not exceed 100 characters")
-    },
-    "address.postalCode": {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(20, "Postal code must not exceed 20 characters")
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["active", "inactive", "blocked"])
-    },
-    source: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["web", "mobile", "api", "import", "manual", "referral", "social", "email"])
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["profile.name", "email", "phone", "lastActivity", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Customer ID is required").pattern(/^[0-9a-fA-F]{24}$/)
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-});
-const { getInstance } = abac.ABAC;
-function setupCustomersRoutes(app, db) {
-  const abac2 = getInstance(db);
-  const verifier = verifierFactory();
-  const customersCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.customer,
-    modelName: "customer",
-    basePath: "/api/customers",
-    auth: true,
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["customer", "orders"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  return customersCRUD;
-}
-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);
-    setupApplicationsRoutes(app, db);
-    setupCustomersRoutes(app, db);
-  }
-}
-const models = {
-  ModelOrder,
-  ModelCustomer
-};
-const routes = {
-  RoutesOrder,
-  RoutesCustomers: setupCustomersRoutes
-};
-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;