@ozdao/martyrs 0.2.505 → 0.2.507

package/dist/orders.server.js

@@ -1,96 +1,14 @@
-import { C as Cache, L as Logger } from "./globals.logger-Bf6rRU7j.js";
+import "node-cache";
 import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
-import { m as mailing } from "./mailing-C11EYWm-.js";
+import "./mailing-DzlhsxCC.js";
 import { m as modelsFactory, a as applyProfileSchema } from "./profile.schema-BGAe5VN5.js";
-import { a as applyCredentialsSchema } from "./credentials.schema-C9FB2EyY.js";
 import { a as applyOwnershipSchema } from "./ownership.schema-BqH4v5vH.js";
-import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
+import { a as applyCredentialsSchema } from "./credentials.schema-C9FB2EyY.js";
+import { C as CRUD } from "./crud-sE7GLPbj.js";
+import { A as ABAC } from "./abac-Cf_9lCSh.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 });
-    }
-  }
-}
+import { V as Verifier, a as Validator } from "./globals.verifier-DFqKQ7hK.js";
+import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
 const controllerFactory = (db) => {
   const Order = db.order;
   const Customer = db.customer;
@@ -588,12 +506,29 @@ const ModelApplication = (db) => {
         email: {
           type: String
         }
+      },
+      text: {
+        type: String
+      },
+      chat: {
+        type: String
+      },
+      customer: {
+        type: {
+          type: String,
+          enum: ["Customer"]
+        },
+        target: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "Customer"
+        }
       }
     },
     {
       timestamps: { currentTime: () => Date.now() }
     }
   );
+  applyOwnershipSchema(ApplicationSchema, db);
   const Application = db.mongoose.model("Application", ApplicationSchema);
   return Application;
 };
@@ -612,10 +547,34 @@ const ModelCustomer = (db) => {
           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"
       }
     },
     {
@@ -781,125 +740,229 @@ const ModelTestimonial = (db) => {
   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 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 verifierFactory$1 = function(db) {
+  const createVerifier = new Verifier({
+    "contacts.name": {
+      rule: "optional",
+      validator: 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: Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
+    },
+    "contacts.phone": {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
+    },
+    type: {
+      rule: "optional",
+      default: "newsletter",
+      validator: Validator.schema().string().oneOf(["newsletter", "support", "inquiry", "feedback", "other"])
+    },
+    text: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Text must not exceed 2000 characters")
+    },
+    chat: {
+      rule: "optional",
+      validator: Validator.schema().string().max(255, "Chat ID must not exceed 255 characters")
+    },
+    status: {
+      rule: "optional",
+      default: "created",
+      validator: Validator.schema().string().oneOf(["created", "in_progress", "completed", "cancelled"])
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization", "User", "Organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
     }
-  };
-  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 updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Application ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid ID format")
+    },
+    "contacts.name": {
+      rule: "optional",
+      validator: 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: Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
+    },
+    "contacts.phone": {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
+    },
+    type: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["newsletter", "support", "inquiry", "feedback", "other"])
+    },
+    text: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Text must not exceed 2000 characters")
+    },
+    chat: {
+      rule: "optional",
+      validator: Validator.schema().string().max(255, "Chat ID must not exceed 255 characters")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["created", "in_progress", "completed", "cancelled"])
     }
-  };
-  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 readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().string()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["created", "in_progress", "completed", "cancelled"])
+    },
+    type: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["newsletter", "support", "inquiry", "feedback", "other"])
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["contacts.name", "contacts.email", "type", "status", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
     }
-  };
-  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 deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Application ID is required").pattern(/^[0-9a-fA-F]{24}$/)
     }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
   };
-  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." });
+};
+const { getInstance: getInstance$1 } = ABAC;
+function setupApplicationsRoutes(app, db) {
+  const abac = getInstance$1(db);
+  const verifier = verifierFactory$1();
+  const applicationsCRUD = new 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,
+    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.status(200).send(application);
-    } catch (err) {
-      res.status(500).send({ message: err });
+      res.sendStatus(200);
     }
-  };
-  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("_");
+  });
+  applicationsCRUD.addAction("public-create", {
+    method: "post",
+    path: "/public",
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
       try {
-        let updatedApplication = null;
-        switch (action) {
-          case "confirm":
-            updatedApplication = await Application.findOneAndUpdate({ _id: applicationId }, { status: "confirmed" }, { new: true });
-            break;
-          case "lost":
-            updatedApplication = await Application.findOneAndUpdate({ _id: applicationId }, { status: "lost" }, { new: true });
-            break;
-          case "delete":
-            updatedApplication = await Application.findOneAndDelete({ _id: applicationId });
-            break;
-        }
-        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 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 });
       }
-      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);
-  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);
-};
+  });
+  return applicationsCRUD;
+}
 const RoutesOrder = function(app, db, origins, publicPath) {
   const controller = controllerFactory(db);
   const middleware = middlewareIndexFactory(db);
@@ -932,6 +995,200 @@ const RoutesOrder = function(app, db, origins, publicPath) {
     controller.deleteOrder
   );
 };
+const verifierFactory = function(db) {
+  const createVerifier = new Verifier({
+    email: {
+      rule: "optional",
+      validator: Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
+    },
+    phone: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
+    },
+    "profile.name": {
+      rule: "optional",
+      validator: 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: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    "profile.photo": {
+      rule: "optional",
+      validator: Validator.schema().string().max(500, "Photo URL must not exceed 500 characters")
+    },
+    source: {
+      rule: "optional",
+      default: "web",
+      validator: Validator.schema().string().oneOf(["web", "mobile", "api", "import", "manual", "referral", "social", "email"])
+    },
+    "referral.code": {
+      rule: "optional",
+      validator: Validator.schema().string().max(50, "Referral code must not exceed 50 characters")
+    },
+    "referral.source": {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid referral source ID format")
+    },
+    tags: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string().max(50)).max(20, "Cannot have more than 20 tags")
+    },
+    notes: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Notes must not exceed 2000 characters")
+    },
+    status: {
+      rule: "optional",
+      default: "active",
+      validator: Validator.schema().string().oneOf(["active", "inactive", "blocked"])
+    },
+    "identity.type": {
+      rule: "required",
+      validator: Validator.schema().string().oneOf(["Visitor", "User", "Organization"])
+    },
+    "identity.target": {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid identity target ID format")
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization", "User", "Organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Customer ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid ID format")
+    },
+    email: {
+      rule: "optional",
+      validator: Validator.schema().string().email("Invalid email format").max(255, "Email must not exceed 255 characters")
+    },
+    phone: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^\+?[1-9]\d{1,14}$/, "Invalid phone format")
+    },
+    "profile.name": {
+      rule: "optional",
+      validator: 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: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    "profile.photo": {
+      rule: "optional",
+      validator: Validator.schema().string().max(500, "Photo URL must not exceed 500 characters")
+    },
+    source: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["web", "mobile", "api", "import", "manual", "referral", "social", "email"])
+    },
+    "referral.code": {
+      rule: "optional",
+      validator: Validator.schema().string().max(50, "Referral code must not exceed 50 characters")
+    },
+    "referral.source": {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid referral source ID format")
+    },
+    tags: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string().max(50)).max(20, "Cannot have more than 20 tags")
+    },
+    notes: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Notes must not exceed 2000 characters")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["active", "inactive", "blocked"])
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().string()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["active", "inactive", "blocked"])
+    },
+    source: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["web", "mobile", "api", "import", "manual", "referral", "social", "email"])
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["profile.name", "email", "phone", "lastActivity", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Customer ID is required").pattern(/^[0-9a-fA-F]{24}$/)
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+};
+const { getInstance } = ABAC;
+function setupCustomersRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = verifierFactory();
+  const customersCRUD = new 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,
+    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);
@@ -939,8 +1196,8 @@ function initializeOrders(app, db, origins, publicPath) {
   db.application = ModelApplication(db);
   if (app) {
     RoutesOrder(app, db);
-    RoutesApplications(app, db);
-    new CRUD("/api/customers", app, db, db.customer);
+    setupApplicationsRoutes(app, db);
+    setupCustomersRoutes(app, db);
   }
 }
 const models = {
@@ -948,7 +1205,8 @@ const models = {
   ModelCustomer
 };
 const routes = {
-  RoutesOrder
+  RoutesOrder,
+  RoutesCustomers: setupCustomersRoutes
 };
 const controllers = {
   FactoryOrder: controllerFactory