@ozdao/martyrs 0.2.550 → 0.2.552

package/dist/organizations.server.cjs

@@ -1,1590 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const abac = require("./abac-gNSxNkX1.cjs");
-const credentials_schema = require("./credentials.schema-DVXaFnXl.cjs");
-const ownership_schema = require("./ownership.schema-CRYdbemm.cjs");
-const engagement_schema = require("./engagement.schema-DHw4iY_W.cjs");
-const index = require("./index-BFxqqmgh.cjs");
-const mailing = require("./mailing-DCvDBHVh.cjs");
-const uuidv4 = require("uuidv4");
-const queryProcessor = require("./queryProcessor-DJUTwCLN.cjs");
-const mongoose = require("mongoose");
-const core_abac = require("./core.abac-DqDvtkHR.cjs");
-const core_logger = require("./core.logger-BuW7JHMY.cjs");
-const addUserStatusFields = require("./addUserStatusFields-7-66sf45.cjs");
-const jwt = require("jsonwebtoken");
-const googleMapsServicesJs = require("@googlemaps/google-maps-services-js");
-const core_verifier = require("./core.verifier-Bi-XLEi9.cjs");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const googleMapsServicesJs__namespace = /* @__PURE__ */ _interopNamespaceDefault(googleMapsServicesJs);
-const controllerFactory$2 = (db) => {
-  const Department = db.department;
-  const readOne = (req, res) => {
-    Department.findOne({ _id: req.params._id }).populate("members.user", "-password").populate("subdepartments").then((department) => {
-      if (!department) {
-        return res.status(404).send({ message: "Отдел не найден" });
-      }
-      res.send(department);
-    }).catch((err) => {
-      res.status(500).send({ message: err.message });
-    });
-  };
-  const read = async (req, res) => {
-    try {
-      const { skip = 0, limit = 10, organization, hidden, _id, search } = req.query;
-      let query = {};
-      if (_id) {
-        query._id = _id;
-      }
-      if (organization) {
-        query.organization = new db.mongoose.Types.ObjectId(organization);
-      }
-      if (hidden !== void 0) {
-        query.hidden = hidden === "true";
-      }
-      if (search) {
-        query["profile.name"] = new RegExp(search, "i");
-      }
-      const departments = await Department.find(query).skip(parseInt(skip)).limit(parseInt(limit)).populate("members.user", "-password").populate("subdepartments").sort({ createdAt: -1 });
-      res.send(departments);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      const newDepartment = new Department({
-        ...req.body,
-        organization: req.body.organization || req.params._id
-      });
-      const data = await newDepartment.save();
-      const populated = await Department.findById(data._id).populate("members.user", "-password").populate("subdepartments");
-      res.send(populated);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const update = (req, res) => {
-    Department.findOneAndUpdate({ _id: req.body._id }, req.body, { new: true }).populate("members.user", "-password").populate("subdepartments").then((department) => {
-      if (!department) {
-        return res.status(404).send({ message: "Department not found" });
-      }
-      res.send(department);
-    }).catch((err) => {
-      res.status(500).send({ message: err.message });
-    });
-  };
-  const deleteDepartment = async (req, res) => {
-    try {
-      const { _id } = req.body;
-      if (!_id) {
-        return res.status(400).send({ message: "Department ID is required" });
-      }
-      const department = await Department.findOneAndRemove({ _id });
-      if (!department) {
-        return res.status(404).send({ message: "Department not found" });
-      }
-      res.send(department);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  return {
-    readOne,
-    read,
-    create,
-    update,
-    delete: deleteDepartment
-  };
-};
-const accessesSchema = {
-  categories: {
-    create: {
-      type: Boolean,
-      default: false
-    },
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  rents: {
-    create: {
-      type: Boolean,
-      default: false
-    },
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  spots: {
-    create: {
-      type: Boolean,
-      default: false
-    },
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  members: {
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  posts: {
-    create: {
-      type: Boolean,
-      default: false
-    },
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  events: {
-    create: {
-      type: Boolean,
-      default: false
-    },
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  tickets: {
-    create: {
-      type: Boolean,
-      default: false
-    },
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  gallery: {
-    read: {
-      type: Boolean,
-      default: false
-    },
-    create: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  inventory: {
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  products: {
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  orders: {
-    read: {
-      type: Boolean,
-      default: false
-    },
-    confirm: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  },
-  departments: {
-    read: {
-      type: Boolean,
-      default: false
-    },
-    edit: {
-      type: Boolean,
-      default: false
-    },
-    delete: {
-      type: Boolean,
-      default: false
-    }
-  }
-};
-const DepartmentModel = (db) => {
-  const departmentSchema = new db.mongoose.Schema(
-    {
-      owner: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "User"
-      },
-      organization: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "Organization"
-      },
-      profile: {
-        photo: { type: String },
-        name: { type: String, required: true },
-        description: { type: String },
-        categories: [String]
-      },
-      worktime: [
-        {
-          day: String,
-          time: {
-            start: String,
-            end: String
-          }
-        }
-      ],
-      hidden: {
-        type: Boolean,
-        default: false
-      },
-      accesses: accessesSchema,
-      // Marketplace options
-      delivery: [String],
-      payment: [String],
-      members: [
-        {
-          user: {
-            type: db.mongoose.Schema.Types.ObjectId,
-            ref: "User"
-          },
-          position: {
-            type: String,
-            default: "Member"
-          }
-        }
-      ],
-      subdepartments: [
-        {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Department"
-        }
-      ]
-    },
-    {
-      timestamps: true
-    }
-  );
-  departmentSchema.index({ organization: 1 });
-  const Department = db.mongoose.model("Department", departmentSchema);
-  return Department;
-};
-const InviteModel = (db) => {
-  const InviteSchema = new db.mongoose.Schema(
-    {
-      code: {
-        type: String,
-        required: true,
-        unique: true
-      },
-      status: {
-        type: String,
-        enum: ["active", "used", "deactivated"],
-        default: "active"
-      },
-      role: {
-        type: String,
-        default: "member"
-      }
-    },
-    {
-      timestamps: true
-    }
-  );
-  ownership_schema.applyOwnershipSchema(InviteSchema, db);
-  credentials_schema.applyCredentialsSchema(InviteSchema);
-  InviteSchema.index(
-    {
-      owner: 1,
-      email: 1
-    },
-    {
-      unique: true,
-      partialFilterExpression: {
-        email: { $exists: true, $ne: "" }
-      }
-    }
-  );
-  InviteSchema.index(
-    {
-      owner: 1,
-      phone: 1
-    },
-    {
-      unique: true,
-      partialFilterExpression: {
-        phone: { $exists: true, $ne: "" }
-      }
-    }
-  );
-  const Invite = db.mongoose.model("Invite", InviteSchema);
-  return Invite;
-};
-const MembershipModel = (db) => {
-  const MembershipSchema = new db.mongoose.Schema(
-    {
-      user: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "User",
-        required: true
-      },
-      type: {
-        type: String,
-        enum: ["organization", "department", "user"],
-        default: "organization",
-        required: true
-      },
-      role: {
-        type: String,
-        default: "subscriber"
-      },
-      label: {
-        type: String,
-        default: "subscriber"
-      },
-      target: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: function(value) {
-          if (this.type === "user") return "User";
-          if (this.type === "organization") return "Organization";
-        },
-        required: true
-      }
-    },
-    {
-      timestamps: true
-    }
-  );
-  MembershipSchema.index({ user: 1, target: 1, role: 1 });
-  const Membership = db.mongoose.model("Membership", MembershipSchema);
-  return Membership;
-};
-const OrganizationModel = (db) => {
-  const OrganizationSchema = new db.mongoose.Schema(
-    {
-      // Creator and owner of organizations
-      owner: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "User",
-        required: true
-      },
-      official: {
-        type: Boolean,
-        default: false
-      },
-      // Types of organizations
-      types: {
-        type: Array,
-        required: true
-      },
-      accesses: accessesSchema,
-      // Information for profile
-      profile: {
-        photo: String,
-        name: {
-          type: String,
-          required: true
-        },
-        description: String,
-        tags: [String]
-      },
-      // Contacts
-      contacts: {
-        email: String,
-        website: String,
-        phone: {
-          type: String
-          // match: /^\+?[1-9]\d{1,14}$/
-        },
-        address: String
-      },
-      socials: {
-        telegram: String,
-        twitter: String,
-        facebook: String,
-        instagram: String,
-        youtube: String
-      },
-      // Computed Rating
-      rating: {
-        popularity: {
-          type: Number,
-          min: 0,
-          max: 1
-        },
-        median: {
-          type: Number,
-          min: 0,
-          max: 5
-        },
-        amount: Number
-      }
-    },
-    {
-      timestamps: true
-    }
-  );
-  engagement_schema.applyEngagementSchema(OrganizationSchema);
-  OrganizationSchema.index({ _id: 1, owner: 1 });
-  const Organization = db.mongoose.model("Organization", OrganizationSchema);
-  return Organization;
-};
-const departmentsRoutes = (function(app, db) {
-  const controller = controllerFactory$2(db);
-  app.get("/api/departments/read", controller.read);
-  app.post("/api/departments/create", controller.create);
-  app.put("/api/departments/update", controller.update);
-  app.post("/api/departments/delete", controller.delete);
-  app.get("/api/departments/get/:_id", controller.readOne);
-});
-const { sendEmail, sendSms } = mailing.mailing;
-const сontrollerFactory = (db) => {
-  const User = db.user;
-  const Invite = db.invite;
-  const Membership = db.membership;
-  const getOneByCode = async (req, res) => {
-    try {
-      const invite = await Invite.findOne({ code: req.params._id });
-      if (!invite) {
-        return res.status(404).send({ message: "Приглашение не найдено" });
-      }
-      res.send(invite);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const read = async (req, res) => {
-    try {
-      const { skip = 0, limit = 10, owner, target, search } = req.query;
-      const query = {};
-      if (owner) query["owner.user"] = owner;
-      if (target) query["owner.target"] = target;
-      if (search) {
-        query.$or = [
-          { email: new RegExp(search, "i") },
-          { phone: new RegExp(search, "i") }
-        ];
-      }
-      const invites = await Invite.find(query).skip(parseInt(skip)).limit(parseInt(limit)).sort({ createdAt: -1 });
-      res.send(invites);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const create = async (req, res) => {
-    const creator = req.body.creator;
-    const owner = req.body.owner;
-    const list = req.body.invites;
-    const createdInvites = [];
-    const createdMemberships = [];
-    try {
-      for (let invite of list) {
-        let user = null;
-        if (!invite || !invite.contact) {
-          continue;
-        }
-        if (invite.contact.includes("@")) {
-          user = await User.findOne({ email: invite.contact });
-        } else {
-          user = await User.findOne({ phone: invite.contact });
-        }
-        if (user) {
-          const membership = new Membership({
-            user: user._id,
-            type: "organization",
-            target: req.body.owner.target,
-            role: "member",
-            label: "member"
-          });
-          const savedMembership = await membership.save();
-          createdMemberships.push(savedMembership);
-        } else {
-          const newInvite = new Invite({
-            code: uuidv4.uuid(),
-            creator,
-            owner,
-            role: "member",
-            email: invite.contact.includes("@") ? invite.contact : null,
-            phone: !invite.contact.includes("@") ? invite.contact : null
-          });
-          const savedInvite = await newInvite.save();
-          createdInvites.push(savedInvite);
-          if (savedInvite.email !== null) {
-            const to = savedInvite.email;
-            const subject = "You have been added to the organization";
-            const text = `You have been invited to join an organization on ${process.env.APP_NAME}! Use this link to register: ${process.env.API_URL}/auth/invite?inviteCode=${newInvite.code}&type=email`;
-            await sendEmail(to, subject, text);
-          }
-          if (savedInvite.phone !== null) {
-            const phone = savedInvite.phone;
-            const message = `You have been invited to join an organization on ${process.env.APP_NAME}! Use this link to register: ${process.env.API_URL}/auth/invite?inviteCode=${newInvite.code}&type=phone`;
-            await sendSms(phone, message);
-          }
-        }
-      }
-      res.status(200).json({
-        message: "Invites sent successfully!",
-        createdInvites,
-        createdMemberships
-      });
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ message: "Something went wrong" });
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      const { _id, ...updateData } = req.body;
-      if (!_id) {
-        return res.status(400).send({ message: "Invite ID is required" });
-      }
-      const invite = await Invite.findByIdAndUpdate(
-        _id,
-        updateData,
-        { new: true, runValidators: true }
-      );
-      if (!invite) {
-        return res.status(404).send({ message: "Invite not found" });
-      }
-      res.send(invite);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const deleteInvite = async (req, res) => {
-    try {
-      const { _id } = req.body;
-      if (!_id) {
-        return res.status(400).send({ message: "Invite ID is required" });
-      }
-      const invite = await Invite.findOneAndDelete({ _id });
-      if (!invite) {
-        return res.status(404).send({ message: "Invite not found" });
-      }
-      res.send(invite);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  return {
-    getOneByCode,
-    read,
-    create,
-    update,
-    delete: deleteInvite
-  };
-};
-const invitesRoutes = (function(app, db) {
-  const controller = сontrollerFactory(db);
-  const { verifyInvites } = index.middlewareIndexFactory(db);
-  app.get("/api/invites/read", controller.read);
-  app.get("/api/invites/get/:_id", controller.getOneByCode);
-  app.post("/api/invites/create", [verifyInvites.checkInviteExist, verifyInvites.checkUsersExist], controller.create);
-  app.put("/api/invites/update", controller.update);
-  app.post("/api/invites/delete", controller.delete);
-});
-const ObjectId$1 = { Types: mongoose.Types }.Types.ObjectId;
-const controllerFactory$1 = (db) => {
-  const Membership = db.membership;
-  const Department = db.department;
-  const read = async (req, res) => {
-    try {
-      let search = req.query.search;
-      let regexPattern = "";
-      if (search) {
-        search = search.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-        const parts = search.split(".");
-        if (parts.length === 2) {
-          regexPattern = parts.join("\\.");
-        } else {
-          regexPattern = search;
-        }
-      }
-      const memberships = await Membership.aggregate([
-        {
-          $lookup: {
-            from: "users",
-            localField: "user",
-            foreignField: "_id",
-            as: "user"
-          }
-        },
-        {
-          $match: {
-            ...req.query.user && { user: new ObjectId$1(req.query.user) },
-            ...req.query.type && { type: req.query.type },
-            ...req.query.target && { target: new ObjectId$1(req.query.target) },
-            ...req.query.role && { role: { $in: req.query.role } },
-            ...req.query.search && {
-              $or: [
-                { "user.profile.name": { $regex: regexPattern, $options: "i" } },
-                { "user.email": { $regex: regexPattern, $options: "i" } },
-                { "user.phone": { $regex: regexPattern, $options: "i" } }
-              ]
-            }
-          }
-        },
-        {
-          $unwind: "$user"
-        },
-        {
-          $project: {
-            _id: 1,
-            user: {
-              _id: 1,
-              profile: 1,
-              roles: 1,
-              phone: 1,
-              email: 1,
-              username: 1,
-              socials: 1,
-              status: 1,
-              createdAt: 1,
-              updatedAt: 1
-            },
-            type: 1,
-            role: 1,
-            label: 1,
-            target: 1,
-            createdAt: 1,
-            updatedAt: 1
-          }
-        },
-        // Sorting and Pagination
-        ...queryProcessor.queryProcessorCore.getSortingOptions(req.query.sortParam, req.query.sortOrder),
-        ...queryProcessor.queryProcessorCore.getPaginationOptions(req.query.skip, req.query.limit)
-      ]);
-      if (!memberships) {
-        return res.status(404).send({ errorCode: "MEMBERSHIPS_NOT_FOUND" });
-      }
-      res.send(memberships);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ errorCode: "SERVER_ERROR" });
-    }
-  };
-  const create = async (req, res) => {
-    const newMembership = new Membership({
-      user: req.body.user,
-      type: req.body.type,
-      target: req.body.target,
-      role: req.body.role
-    });
-    try {
-      const data = await newMembership.save();
-      const populated = await Membership.findById(data._id).populate("user", "-password");
-      res.send(populated);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ errorCode: "SERVER_ERROR" });
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      const membership = await Membership.findByIdAndUpdate(req.body._id, req.body, { new: true }).populate("user", "-password");
-      if (!membership) {
-        return res.status(404).send({ errorCode: "MEMBERSHIP_NOT_FOUND" });
-      }
-      res.send(membership);
-    } catch (err) {
-      res.status(500).send({ errorCode: "SERVER_ERROR" });
-    }
-  };
-  const deleteMembership = async (req, res) => {
-    const { _id, type, target, user, role } = req.body;
-    console.log("Delete membership request:", { _id, type, target, user, role });
-    try {
-      const query = _id ? { _id: new ObjectId$1(_id) } : {
-        type,
-        target: new ObjectId$1(target),
-        user: new ObjectId$1(user),
-        role
-      };
-      console.log("Delete query:", query);
-      const membership = await Membership.findOneAndDelete(query);
-      console.log("Deleted membership:", membership);
-      if (!membership) {
-        return res.status(404).send({ errorCode: "MEMBERSHIP_NOT_FOUND" });
-      }
-      if (membership.type === "organization") {
-        await Department.updateMany({ organization: target }, { $pull: { members: { user } } });
-      }
-      res.status(200).send(membership);
-    } catch (error) {
-      console.log(error);
-      res.status(500).send({ errorCode: "SERVER_ERROR" });
-    }
-  };
-  return {
-    read,
-    create,
-    update,
-    deleteMembership
-  };
-};
-const membershipsRoutes = (function(app, db) {
-  const controller = controllerFactory$1(db);
-  app.get("/api/memberships/read", controller.read);
-  app.post("/api/memberships/create", controller.create);
-  app.put("/api/memberships/update", controller.update);
-  app.post("/api/memberships/delete", controller.deleteMembership);
-  app.get("/api/memberships", controller.read);
-});
-const lookupConfigs = {
-  products: {
-    lookup: {
-      from: "products",
-      localField: "_id",
-      foreignField: "owner.target",
-      pipeline: [
-        {
-          $lookup: {
-            from: "variants",
-            localField: "_id",
-            foreignField: "product",
-            pipeline: [
-              {
-                $project: {
-                  _id: 1,
-                  name: 1,
-                  price: 1,
-                  quantity: 1,
-                  type: 1
-                }
-              }
-            ],
-            as: "variants"
-          }
-        }
-      ],
-      as: "products"
-    },
-    additionalStages: [
-      {
-        $addFields: { numberOfProducts: { $size: "$products" } }
-      }
-    ]
-  },
-  blogposts: {
-    lookup: {
-      from: "blogposts",
-      localField: "_id",
-      foreignField: "owner.target",
-      as: "blogposts"
-    }
-  },
-  departments: {
-    lookup: {
-      from: "departments",
-      localField: "_id",
-      foreignField: "organization",
-      as: "departments"
-    }
-  },
-  spots: {
-    lookup: {
-      from: "spots",
-      localField: "_id",
-      foreignField: "organization",
-      as: "spots"
-    }
-  },
-  memberships: {
-    lookup: {
-      from: "memberships",
-      localField: "_id",
-      foreignField: "target",
-      as: "memberships"
-    }
-  }
-};
-const ObjectId = { Types: mongoose.Types }.Types.ObjectId;
-const { Client } = googleMapsServicesJs__namespace;
-const client = new Client({});
-const getRequestedLookups = (query) => query.lookup ? Array.isArray(query.lookup) ? query.lookup : [query.lookup] : [];
-const getLookupStages = (requestedLookups, configs) => {
-  if (!requestedLookups) return [];
-  const lookupsArray = Array.isArray(requestedLookups) ? requestedLookups : requestedLookups.split(",");
-  return lookupsArray.map((lookup) => configs[lookup]).filter(Boolean).flatMap((config) => [
-    { $lookup: config.lookup },
-    // Оберните lookup в объект с $lookup
-    ...config.additionalStages || []
-  ]);
-};
-const getLocationStages = async (query) => {
-  if (!hasLocationParams(query)) {
-    return { stages: [], userLocation: null };
-  }
-  const location = await resolveLocation(query);
-  const radius = getRadius(query);
-  const geoStages = radius ? [
-    {
-      $match: {
-        "spots.location.coordinates": {
-          $geoWithin: {
-            $centerSphere: [[location.coordinates[0], location.coordinates[1]], radius]
-          }
-        }
-      }
-    }
-  ] : [];
-  return {
-    stages: [...geoStages, ...getDistanceStages(location)],
-    userLocation: location
-  };
-};
-const getRadius = (query) => {
-  if (query.locationRadius) return parseFloat(query.locationRadius) / 6378.1;
-  if (query.city) return 25 / 6378.1;
-  if (query.state) return 50 / 6378.1;
-  return null;
-};
-const hasLocationParams = (query) => query.location || query.address || query.city || query.state || query.country;
-const resolveLocation = async (query) => {
-  if (query.location) {
-    const parsedLocation = typeof query.location === "string" ? JSON.parse(query.location) : query.location;
-    const coordinates = parsedLocation.lng ? [parsedLocation.lng, parsedLocation.lat] : parsedLocation.coordinates;
-    return { coordinates: coordinates.map((coord) => parseFloat(coord)) };
-  }
-  const searchString = [query.address, query.city, query.state, query.country].filter(Boolean).join(", ");
-  try {
-    const geoResponse = await client.geocode({
-      params: {
-        address: searchString,
-        key: process.env.GOOGLE_MAPS_API_KEY
-      }
-    });
-    if (!geoResponse.data.results?.length) {
-      throw new Error("Unable to geocode the provided location.");
-    }
-    const { lng, lat } = geoResponse.data.results[0].geometry.location;
-    return { coordinates: [lng, lat] };
-  } catch (err) {
-    throw new Error("Error occurred while geocoding.");
-  }
-};
-const getDistanceStages = (location) => [
-  {
-    $addFields: {
-      spots: {
-        $map: {
-          input: "$spots",
-          as: "spot",
-          in: {
-            $mergeObjects: [
-              "$$spot",
-              {
-                distance: {
-                  $function: {
-                    body: `function(spotCoords, userCoords, isMiles) {
-                      function toRad(x) {
-                        return x * Math.PI / 180;
-                      }
-                      var lon1 = spotCoords[0];
-                      var lat1 = spotCoords[1];
-                      var lon2 = userCoords[0];
-                      var lat2 = userCoords[1];
-                      var R = 6371;
-                      if (isMiles) R = 3959;
-                      var x1 = lat2 - lat1;
-                      var dLat = toRad(x1);
-                      var x2 = lon2 - lon1;
-                      var dLon = toRad(x2);
-                      var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-                              Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) *
-                              Math.sin(dLon / 2) * Math.sin(dLon / 2);
-                      var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-                      var d = R * c;
-                      return d;
-                    }`,
-                    args: ["$$spot.location.coordinates", location.coordinates, false],
-                    lang: "js"
-                  }
-                }
-              }
-            ]
-          }
-        }
-      }
-    }
-  },
-  {
-    $addFields: {
-      distance: { $min: "$spots.distance" },
-      distanceExist: {
-        $cond: {
-          if: { $eq: [{ $type: "$distance" }, "double"] },
-          then: true,
-          else: false
-        }
-      }
-    }
-  }
-];
-const getPriceConditions = (prices) => {
-  if (!prices) return [];
-  const priceRanges = prices.split(",");
-  const priceConditions = priceRanges.map((priceRange) => {
-    if (priceRange.startsWith("<")) return { "products.price": { $lt: parseInt(priceRange.slice(1)) } };
-    if (priceRange.startsWith(">")) return { "products.price": { $gt: parseInt(priceRange.slice(1)) } };
-    const [min, max] = priceRange.split("-").map(Number);
-    return { "products.price": { $gte: min, $lte: max } };
-  });
-  return priceConditions.length > 0 ? [{ $match: { $or: priceConditions } }] : [];
-};
-const getContainConditions = (contain) => {
-  if (!contain) return [];
-  const conditions = contain.map((property) => ({
-    [property]: { $exists: true, $not: { $size: 0 } }
-  }));
-  return conditions.length > 0 ? [{ $match: { $and: conditions } }] : [];
-};
-const getBasicMatchConditions = (query) => [
-  ...query._id ? [{ _id: new ObjectId(query._id) }] : [],
-  ...query.owner ? [{ owner: new ObjectId(query.owner) }] : [],
-  ...query.types ? [{ types: { $in: query.types } }] : [],
-  ...query.member ? [
-    {
-      memberships: {
-        $elemMatch: {
-          user: new ObjectId(query.member),
-          role: "member"
-        }
-      }
-    }
-  ] : [],
-  ...query.subscriber ? [
-    {
-      memberships: {
-        $elemMatch: {
-          user: new ObjectId(query.subscriber),
-          role: "subscriber"
-        }
-      }
-    }
-  ] : [],
-  ...query.categories?.split(",").length > 0 ? [{ "products.category": { $in: query.categories?.split(",") } }] : [],
-  ...query.delivery?.split(",").length > 0 ? [{ "spots.delivery": { $all: query.delivery?.split(",") } }] : []
-];
-const getPostableConditions = (postableId) => {
-  if (!postableId) return [];
-  return [
-    {
-      $match: {
-        $or: [
-          { owner: new ObjectId(postableId) },
-          {
-            $and: [
-              { types: { $elemMatch: { $eq: "public" } } },
-              {
-                memberships: {
-                  $elemMatch: {
-                    user: new ObjectId(postableId)
-                  }
-                }
-              }
-            ]
-          },
-          {
-            $and: [
-              { types: { $elemMatch: { $in: ["exclusive", "hidden"] } } },
-              {
-                memberships: {
-                  $elemMatch: {
-                    user: new ObjectId(postableId),
-                    role: { $ne: "subscriber" }
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      }
-    }
-  ];
-};
-const controllerFactory = (db) => {
-  const Organization = db.organization;
-  const Department = db.department;
-  const Membership = db.membership;
-  const cache = new core_logger.CacheNamespaced({ ttlSeconds: 60 * 5 });
-  const read = async (req, res) => {
-    console.log("controller query", req.query);
-    try {
-      const cacheKey = JSON.stringify(req.query);
-      let cachedResult = await cache.get(cacheKey);
-      if (cachedResult) {
-        return res.status(200).send(cachedResult);
-      }
-      const requestedLookups = getRequestedLookups(req.query);
-      const matchConditions = getBasicMatchConditions(req.query);
-      const stages = [
-        ...getLookupStages(requestedLookups, lookupConfigs),
-        ...getPostableConditions(req.query.postable),
-        ...getContainConditions(req.query.contain),
-        ...queryProcessor.queryProcessorCore.getSearchOptions(req.query.search, {
-          fields: requestedLookups.includes("products") ? ["profile.name", "products.name"] : ["profile.name"]
-        }),
-        ...requestedLookups.includes("products") && req.query.prices ? getPriceConditions(req.query.prices) : [],
-        ...requestedLookups.includes("spots") ? (await getLocationStages(req.query)).stages : [],
-        ...requestedLookups.includes("memberships") ? [addUserStatusFields.addUserStatusFields(req.query.user), addUserStatusFields.addMembersQuantity(req.query.user)] : [],
-        ...matchConditions.length > 0 ? [{ $match: { $and: matchConditions } }] : [],
-        ...queryProcessor.queryProcessorCore.getSortingOptions(req.query.sortParam, req.query.sortOrder),
-        ...queryProcessor.queryProcessorCore.getPaginationOptions(req.query.skip, req.query.limit)
-      ].filter(Boolean);
-      console.log(JSON.stringify(stages, null, 2));
-      const organizations = await Organization.aggregate(stages);
-      for (const org of organizations) {
-        const orgTag = `organization_${org._id}`;
-        await cache.setWithTags(cacheKey, organizations, [orgTag, "organizations"]);
-      }
-      res.status(200).send(organizations);
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const create = async (req, res) => {
-    if (req.body._id === null) {
-      delete req.body._id;
-    }
-    try {
-      const organization = new Organization(req.body);
-      const savedOrganization = await organization.save();
-      const membership = new Membership({
-        user: savedOrganization.owner,
-        type: "organization",
-        target: savedOrganization._id,
-        role: "owner",
-        label: "owner"
-      });
-      const savedMembership = await membership.save();
-      const orgTag = `organization_${savedOrganization._id}`;
-      await cache.delByTag(orgTag);
-      const organizationObject = savedOrganization.toObject();
-      const newCacheKey = JSON.stringify({ id: organizationObject._id });
-      await cache.setWithTags(newCacheKey, [organizationObject], [orgTag, "organizations"]);
-      res.status(201).json(savedOrganization);
-    } catch (error) {
-      console.error("Error:", error);
-      res.status(500).send(error);
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      const organizationId = req.params._id;
-      const updatedData = req.body;
-      const organization = await Organization.findByIdAndUpdate(organizationId, updatedData, {
-        new: true,
-        runValidators: true
-      });
-      if (!organization) {
-        return res.status(404).json({ message: "Organization not found" });
-      }
-      const orgTag = `organization_${organizationId}`;
-      await cache.delByTag(orgTag);
-      const organizationObject = organization.toObject();
-      const updateCacheKey = JSON.stringify({ _id: organizationId });
-      await cache.setWithTags(updateCacheKey, [organizationObject], [orgTag, "organizations"]);
-      res.status(200).json({ message: "Organization updated successfully", organization });
-    } catch (error) {
-      res.status(500).json({ error: error.message });
-    }
-  };
-  const deleteOrganization = async (req, res) => {
-    try {
-      const organization = await Organization.findOneAndRemove({ _id: req.params._id });
-      if (!organization) {
-        return res.status(404).send({ message: "Organization not found" });
-      }
-      await Membership.deleteMany({ target: req.params._id });
-      const newToken = jwt.sign(
-        {
-          _id: req.userId,
-          // Предполагаю, что req.userId доступен
-          organization: null
-        },
-        process.env.SECRET_KEY,
-        {
-          expiresIn: 86400
-          // 24 hours
-        }
-      );
-      const orgTag = `organization_${req.params._id}`;
-      await cache.delByTag(orgTag);
-      res.send({ newToken });
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const checkAccesses = async (req, res) => {
-    try {
-      const uid = new db.mongoose.Types.ObjectId(req.userId);
-      const cacheKey = `accesses_${uid.toString()}`;
-      const cachedResult = await cache.get(cacheKey);
-      if (cachedResult) {
-        return res.status(200).json(cachedResult);
-      }
-      const depts = await Department.find({ "members.user": uid }).lean();
-      const ownedOrgs = await Organization.find({ owner: uid }).lean();
-      const ownedOrgIds = ownedOrgs.map((org) => org._id.toString());
-      const accesses = {};
-      const processAccesses = (orgId, isOwner, deptAccesses) => {
-        if (!accesses[orgId]) {
-          accesses[orgId] = { organization: orgId, rights: {} };
-        }
-        const rights = accesses[orgId].rights;
-        const defaultAccesses = new Department().accesses;
-        const accessData = isOwner ? defaultAccesses : deptAccesses;
-        Object.keys(accessData).forEach((key) => {
-          if (!rights[key]) {
-            rights[key] = {};
-          }
-          const accessRights = accessData[key];
-          Object.entries(accessRights).forEach(([right, value]) => {
-            rights[key][right] = isOwner || rights[key][right] || value;
-          });
-        });
-      };
-      const orgDepts = depts.reduce((acc, dept) => {
-        const orgId = dept.organization.toString();
-        if (!acc[orgId]) {
-          acc[orgId] = [];
-        }
-        acc[orgId].push(dept);
-        return acc;
-      }, {});
-      Object.entries(orgDepts).forEach(([orgId, departments]) => {
-        const combinedAccesses = departments.reduce((acc, dept) => {
-          Object.entries(dept.accesses).forEach(([key, rights]) => {
-            if (!acc[key]) {
-              acc[key] = {};
-            }
-            Object.entries(rights).forEach(([right, value]) => {
-              acc[key][right] = acc[key][right] || value;
-            });
-          });
-          return acc;
-        }, {});
-        processAccesses(orgId, false, combinedAccesses);
-      });
-      ownedOrgIds.forEach((orgId) => {
-        processAccesses(orgId, true, {});
-      });
-      const accessArray = Object.values(accesses);
-      const userTag = `access_${uid.toString()}`;
-      await cache.setWithTags(cacheKey, accessArray, [userTag, "accesses"]);
-      res.status(200).json(accessArray);
-    } catch (err) {
-      console.error("Error getting accesses:", err);
-      res.status(500).json({ message: "Internal server error" });
-    }
-  };
-  return {
-    fetch,
-    read,
-    create,
-    update,
-    delete: deleteOrganization,
-    // Map the method to 'delete' key
-    checkAccesses
-  };
-};
-const { getInstance: getInstance$1 } = core_abac.coreabac;
-const organizationsRoutes = (function(app, db) {
-  const controller = controllerFactory(db);
-  const { authJwt } = index.middlewareIndexFactory(db);
-  getInstance$1(db);
-  app.get(
-    "/api/organizations",
-    [
-      authJwt.verifyToken(true)
-      // abac.middleware('organizations', 'read', {
-      //   allowPublished: true,
-      //   allowUnauthenticated: true
-      // })
-    ],
-    controller.read
-  );
-  app.post("/api/organizations/create", controller.create);
-  app.post("/api/organizations/:_id/update", controller.update);
-  app.delete("/api/organizations/:_id/delete", controller.delete);
-  app.get("/api/organizations/check-accesses", [authJwt.verifyToken()], controller.checkAccesses);
-});
-const initOrganizationPolicies = (function initializeOrganizationPolicies(abacAccessControl, db) {
-  const Organization = db.organization;
-  const Department = db.department;
-  const publicAccessVerifier = new core_verifier.Verifier({
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema({ context: "Status" }).string().required().oneOf(["published", "active", "featured"])
-    }
-  });
-  const organizationHelpers = {
-    // Проверка, является ли пользователь владельцем организации
-    async isOrganizationOwner(userId, orgId) {
-      if (!userId || !orgId) return false;
-      try {
-        const objectId = new db.mongoose.Types.ObjectId(orgId);
-        return await Organization.exists({
-          _id: objectId,
-          owner: userId
-        });
-      } catch (error) {
-        console.error("Error checking organization ownership:", error);
-        return false;
-      }
-    },
-    // Получить права пользователя в организации
-    async getUserOrganizationRights(userId, orgId) {
-      if (!userId || !orgId) return null;
-      try {
-        const objectId = new db.mongoose.Types.ObjectId(orgId);
-        const isOwner = await this.isOrganizationOwner(userId, orgId);
-        if (isOwner) {
-          const defaultAccesses = new Department().accesses;
-          return {
-            isOwner: true,
-            rights: defaultAccesses,
-            departments: []
-          };
-        }
-        const departments = await Department.find({
-          organization: objectId,
-          "members.user": userId
-        });
-        if (!departments.length) return null;
-        const combinedRights = {};
-        departments.forEach((dept) => {
-          Object.entries(dept.accesses).forEach(([resource, rights]) => {
-            if (!combinedRights[resource]) {
-              combinedRights[resource] = {};
-            }
-            Object.entries(rights).forEach(([action, allowed]) => {
-              combinedRights[resource][action] = combinedRights[resource][action] || allowed;
-            });
-          });
-        });
-        return {
-          isOwner: false,
-          rights: combinedRights,
-          departments: departments.map((d) => ({
-            _id: d._id,
-            name: d.name,
-            accesses: d.accesses,
-            members: d.members
-            // Добавляем members для проверки permissions
-          }))
-        };
-      } catch (error) {
-        console.error("Error getting user organization rights:", error);
-        return null;
-      }
-    },
-    // Проверка конкретного права
-    async hasOrganizationRight(userId, orgId, resource, action) {
-      const rights = await this.getUserOrganizationRights(userId, orgId);
-      return rights?.rights?.[resource]?.[action] || false;
-    },
-    // Получить организацию из контекста
-    getOrganizationId(context) {
-      const { currentResource, data } = context;
-      if (currentResource?.owner?.type === "organization") {
-        return String(currentResource.owner.target);
-      }
-      if (data?.owner?.type === "organization") {
-        return String(data.owner.target);
-      }
-      if (data?.organization) {
-        return String(data.organization);
-      }
-      if (currentResource?.organization) {
-        return String(currentResource.organization);
-      }
-      return null;
-    }
-  };
-  const enhanceContext = (context) => {
-    context.organizationHelpers = organizationHelpers;
-    context.checkOrganizationOwner = async (orgId = null) => {
-      const organizationId = orgId || organizationHelpers.getOrganizationId(context);
-      if (!organizationId || !context.user) return false;
-      return organizationHelpers.isOrganizationOwner(context.user, organizationId);
-    };
-    context.checkOrganizationRight = async (resource, action, orgId = null) => {
-      const organizationId = orgId || organizationHelpers.getOrganizationId(context);
-      if (!organizationId || !context.user) return false;
-      return organizationHelpers.hasOrganizationRight(context.user, organizationId, resource, action);
-    };
-    context.getOrganizationRights = async (orgId = null) => {
-      const organizationId = orgId || organizationHelpers.getOrganizationId(context);
-      if (!organizationId || !context.user) return null;
-      return organizationHelpers.getUserOrganizationRights(context.user, organizationId);
-    };
-  };
-  abacAccessControl.registerExtension("OrganizationHelpers", async (context) => {
-    enhanceContext(context);
-    return {
-      allow: true,
-      reason: "ORGANIZATION_HELPERS_ADDED"
-    };
-  });
-  abacAccessControl.registerGlobalPolicy("OrganizationAccessPolicy", async (context) => {
-    if (!context.checkOrganizationOwner) {
-      enhanceContext(context);
-    }
-    const { user, resource, data, action, currentResource, req } = context;
-    if (!resource || !action) {
-      return {
-        allow: false,
-        force: false,
-        reason: "MISSING_REQUIRED_PARAMETERS"
-      };
-    }
-    const orgId = organizationHelpers.getOrganizationId(context);
-    if (!orgId) {
-      return {
-        allow: true,
-        force: false,
-        reason: "NOT_ORGANIZATION_RESOURCE"
-      };
-    }
-    if (user) {
-      try {
-        const isOrgOwner = await organizationHelpers.isOrganizationOwner(user, orgId);
-        if (isOrgOwner) {
-          return {
-            allow: true,
-            force: true,
-            // Владелец организации получает принудительный доступ
-            reason: "ORGANIZATION_OWNER_ACCESS"
-          };
-        }
-        const hasAccess = await organizationHelpers.hasOrganizationRight(user, orgId, resource, action);
-        if (hasAccess) {
-          return {
-            allow: true,
-            force: false,
-            // Доступ через департамент не является принудительным
-            reason: "DEPARTMENT_MEMBER_ACCESS"
-          };
-        }
-      } catch (error) {
-        console.error("Error checking user access:", error);
-        return {
-          allow: false,
-          force: false,
-          reason: "ORGANIZATION_ACCESS_CHECK_ERROR"
-        };
-      }
-    }
-    if (action === "read" && req && req.query) {
-      try {
-        const validationResult = publicAccessVerifier.verify(req.query, {
-          only: ["status"]
-        });
-        req.query = validationResult.verifiedData;
-        req.queryValidation = validationResult;
-        if (currentResource && !publicAccessVerifier.verifyParam("status", currentResource.status)) {
-          return {
-            allow: false,
-            force: false,
-            // Принудительно запрещаем доступ к непубличным ресурсам
-            reason: "INVALID_RESOURCE_STATUS_FOR_PUBLIC_ACCESS"
-          };
-        }
-        if (validationResult.isValid) {
-          return {
-            allow: true,
-            force: false,
-            reason: "PUBLIC_ACCESS_ALLOWED"
-          };
-        } else {
-          return {
-            allow: false,
-            force: false,
-            // Принудительно запрещаем, если невалидные параметры
-            reason: "INVALID_PUBLIC_ACCESS_PARAMETERS"
-          };
-        }
-      } catch (error) {
-        console.error("Error validating query:", error);
-        return {
-          allow: false,
-          force: false,
-          reason: "QUERY_VALIDATION_ERROR"
-        };
-      }
-    }
-    if (action !== "read") {
-      return {
-        allow: false,
-        force: false,
-        reason: "ORGANIZATION_RESOURCE_OPERATION_FORBIDDEN"
-      };
-    }
-    return {
-      allow: false,
-      force: false,
-      reason: "ORGANIZATION_RESOURCE_ACCESS_DENIED"
-    };
-  });
-  abacAccessControl.updatePublicAccessConfig = (newConfig) => {
-    if (typeof newConfig !== "object" || newConfig === null) {
-      throw new TypeError("Config must be an object");
-    }
-    publicAccessVerifier.updateConfig(newConfig);
-  };
-  abacAccessControl.getPublicAccessConfig = () => {
-    return publicAccessVerifier.getConfig();
-  };
-  abacAccessControl.publicAccessVerifier = publicAccessVerifier;
-  abacAccessControl.organizationHelpers = organizationHelpers;
-  return abacAccessControl;
-});
-const { getInstance } = abac.ABAC;
-function initializeOrganization(app, db, origins, publicPath) {
-  db.department = DepartmentModel(db);
-  db.organization = OrganizationModel(db);
-  db.membership = MembershipModel(db);
-  db.invite = InviteModel(db);
-  const abac2 = getInstance(db);
-  initOrganizationPolicies(abac2, db);
-  if (app) {
-    departmentsRoutes(app, db);
-    organizationsRoutes(app, db);
-    membershipsRoutes(app, db);
-    invitesRoutes(app, db);
-  }
-}
-const models = {
-  DepartmentModel,
-  OrganizationModel,
-  MembershipModel,
-  InviteModel
-};
-const routes = {
-  departmentsRoutes,
-  organizationsRoutes,
-  membershipsRoutes,
-  invitesRoutes
-};
-const controllers = {
-  DepartmentsController: controllerFactory$2,
-  OrganizationsController: controllerFactory,
-  MembershipsController: controllerFactory$1,
-  InvitesController: сontrollerFactory
-};
-const organizations_server = {
-  initialize: initializeOrganization,
-  models,
-  routes,
-  controllers
-};
-exports.controllers = controllers;
-exports.default = organizations_server;
-exports.initialize = initializeOrganization;
-exports.models = models;
-exports.routes = routes;