@ozdao/martyrs 0.2.477 → 0.2.478

package/dist/events.server.js

@@ -1,439 +1,127 @@
-"use strict";
-const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
-const require$$0 = require("mongoose");
-const queryProcessor$1 = require("./queryProcessor-DSUqSk3I.js");
-const metadata_schema = require("./metadata.schema-CUkLXZ2f.js");
-const require$$0$1 = require("stripe");
-const tickets_controller = require("./tickets.controller-zEHIAe_B.js");
-const index = require("./index-BOmxJQ5W.js");
-const globals_abac = require("./globals.abac-Bn-4tbX8.js");
-const common_schema = require("./common.schema-O0w_rDyC.js");
-const engagement_schema = require("./engagement.schema-DAiXsvh1.js");
-const ownership_schema = require("./ownership.schema-MxfJlPtq.js");
-var queryProcessor;
-var hasRequiredQueryProcessor;
-function requireQueryProcessor() {
-  if (hasRequiredQueryProcessor) return queryProcessor;
-  hasRequiredQueryProcessor = 1;
-  const ObjectId = require$$0.Types.ObjectId;
-  function getDateConditions(date) {
-    if (date) {
-      const dateString = date.toString();
-      const day = parseInt(dateString.substring(0, 2), 10);
-      const month = parseInt(dateString.substring(2, 4), 10) - 1;
-      const year = parseInt(dateString.substring(4, 8), 10);
-      const customDate = new Date(year, month, day);
-      customDate.setHours(0, 0, 0, 0);
-      const customDateEnd = new Date(year, month, day);
-      customDateEnd.setHours(23, 59, 59, 999);
-      return [{ $match: { "date.start": { $gte: customDate, $lte: customDateEnd } } }];
-    } else {
-      return [];
-    }
+import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
+import { c as createFriendlyURL, a as applyMetadataSchema } from "./metadata.schema-CWmcDJN7.js";
+import Stripe from "stripe";
+import { Types } from "mongoose";
+import { c as controllerFactory } from "./tickets.controller-DQQcjyui.js";
+import { a as applyCommonSchema } from "./common.schema-Bw1O5_2Q.js";
+import { a as applyEngagementSchema } from "./engagement.schema-Dh1adRsn.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-CCZX5vfw.js";
+import { m as middlewareIndexFactory$1 } from "./index-CsJwdsBW.js";
+import { g as globalsabac } from "./globals.abac-DBV_kaOq.js";
+class serviceIntegrations {
+  async createProduct(event) {
+    throw new Error("createProduct method not implemented");
   }
-  function getPeriodConditions(period, periodStart, periodEnd) {
-    const now = /* @__PURE__ */ new Date();
-    let startDate, endDate;
-    if (periodStart && periodEnd) {
-      startDate = new Date(periodStart);
-      endDate = new Date(periodEnd);
-      return [{
-        $match: {
-          "date.start": {
-            $gte: startDate,
-            $lte: endDate
-          }
-        }
-      }];
-    } else if (period) {
-      startDate = new Date(now.getTime());
-      endDate = new Date(now.getTime());
-      switch (period) {
-        case "today":
-          startDate.setHours(0, 0, 0, 0);
-          endDate.setHours(23, 59, 59, 999);
-          break;
-        case "week":
-          endDate.setDate(now.getDate() + 7);
-          break;
-        case "month":
-          endDate.setDate(now.getDate() + 30);
-          break;
-        case "year":
-          endDate.setFullYear(now.getFullYear() + 1);
-          break;
-      }
-      return [{
-        $match: {
-          "date.start": {
-            $gte: startDate,
-            $lte: endDate
-          }
-        }
-      }];
-    } else {
-      return [];
-    }
+  async updateProduct(event) {
+    throw new Error("updateProduct method not implemented");
   }
-  function getPhaseConditions(phase) {
-    const now = /* @__PURE__ */ new Date();
-    const todayStart = new Date(now.getTime());
-    todayStart.setHours(0, 0, 0, 0);
-    const todayEnd = new Date(now.getTime());
-    todayEnd.setHours(23, 59, 59, 999);
-    let matchConditions = [];
-    switch (phase) {
-      case "finished":
-        matchConditions.push({ "date.start": { $lt: now } });
-        break;
-      case "today":
-        matchConditions.push({ "date.start": { $gte: todayStart, $lte: todayEnd } });
-        break;
-      case "live":
-        matchConditions.push({ "date.start": { $lte: now } });
-        matchConditions.push({ "date.end": { $gte: now } });
-        break;
-      case "planned":
-        matchConditions.push({ "date.start": { $gt: now } });
-        break;
-    }
-    if (matchConditions && matchConditions.length > 0) {
-      return [{ $match: { $and: matchConditions } }];
-    } else {
-      return [];
-    }
+  async deactivateProduct(event) {
+    throw new Error("deactivateProduct method not implemented");
   }
-  function getTicketsLookupStage() {
-    return {
-      $lookup: {
-        from: "tickets",
-        localField: "_id",
-        foreignField: "target",
-        as: "tickets",
-        pipeline: [{
-          $lookup: {
-            from: "users",
-            localField: "user",
-            foreignField: "_id",
-            as: "user"
-          }
-        }, {
-          $unwind: { path: "$user", preserveNullAndEmptyArrays: true }
-        }]
-      }
-    };
+  async createPaymentLink(event) {
+    throw new Error("createPaymentLink method not implemented");
   }
-  function getParticipantsPhotosStage() {
-    return {
-      $addFields: {
-        participantsPhotos: {
-          $map: {
-            input: "$tickets",
-            as: "ticket",
-            in: "$$ticket.user.profile.photo"
-          }
-        }
-      }
-    };
+  async updatePaymentLink(event) {
+    throw new Error("updatePaymentLink method not implemented");
   }
-  function getNumberOfTicketsStage() {
-    return {
-      $addFields: {
-        numberOfTickets: { $size: "$tickets" }
-      }
-    };
+  async deactivatePaymentLink(event) {
+    throw new Error("deactivatePaymentLink method not implemented");
   }
-  function getHasTicketStage(user) {
-    if (user) {
-      return [{
-        $addFields: {
-          hasTicket: {
-            $in: [new ObjectId(user), "$tickets.user._id"]
-          }
-        }
-      }];
-    } else {
-      return [];
-    }
+  async createСheckout(event) {
+    throw new Error("createСheckout method not implemented");
   }
-  function getProjectStage() {
-    return {
-      $project: {
-        _id: 1,
-        url: 1,
-        cover: 1,
-        name: 1,
-        phase: 1,
-        description: 1,
-        content: 1,
-        owner: 1,
-        creator: 1,
-        tags: 1,
-        date: 1,
-        numberOfTickets: 1,
-        participantsPhotos: 1,
-        special: 1,
-        specialData: 1,
-        hasTicket: 1,
-        tickets: 1,
-        createdAt: 1
-      }
-    };
+  async deactivateСheckout(event) {
+    throw new Error("deactivateСheckout method not implemented");
   }
-  function getParticipantStages(participantQuery) {
-    const participantId = participantQuery ? new ObjectId(participantQuery) : null;
-    let stages = [];
-    if (participantId) {
-      stages.push({
-        $addFields: {
-          "participantTickets": {
-            $filter: {
-              input: "$tickets",
-              as: "ticket",
-              cond: { $eq: ["$$ticket.user._id", participantId] }
-            }
-          }
-        }
-      });
-      stages.push({
-        $match: {
-          "participantTickets.0": { $exists: true }
-        }
-      });
-    }
-    return stages;
+  async createRefund(event) {
+    throw new Error("createRefund method not implemented");
   }
-  queryProcessor = {
-    getDateConditions,
-    getPhaseConditions,
-    getPeriodConditions,
-    getTicketsLookupStage,
-    getParticipantsPhotosStage,
-    getNumberOfTicketsStage,
-    getHasTicketStage,
-    getProjectStage,
-    getParticipantStages
-  };
-  return queryProcessor;
-}
-var integrations_service;
-var hasRequiredIntegrations_service;
-function requireIntegrations_service() {
-  if (hasRequiredIntegrations_service) return integrations_service;
-  hasRequiredIntegrations_service = 1;
-  class serviceIntegrations {
-    async createProduct(event) {
-      throw new Error("createProduct method not implemented");
-    }
-    async updateProduct(event) {
-      throw new Error("updateProduct method not implemented");
-    }
-    async deactivateProduct(event) {
-      throw new Error("deactivateProduct method not implemented");
-    }
-    async createPaymentLink(event) {
-      throw new Error("createPaymentLink method not implemented");
-    }
-    async updatePaymentLink(event) {
-      throw new Error("updatePaymentLink method not implemented");
-    }
-    async deactivatePaymentLink(event) {
-      throw new Error("deactivatePaymentLink method not implemented");
-    }
-    async createСheckout(event) {
-      throw new Error("createСheckout method not implemented");
-    }
-    async deactivateСheckout(event) {
-      throw new Error("deactivateСheckout method not implemented");
-    }
-    async createRefund(event) {
-      throw new Error("createRefund method not implemented");
-    }
-    async updateRefund(event) {
-      throw new Error("updateRefund method not implemented");
-    }
-    async deactivateRefund(event) {
-      throw new Error("deactivateRefund method not implemented");
-    }
-    // Balance
-    // The Balance Transaction object
-    // Retrieve a balance transaction
-    // List all balance transactions
-    // Charges
-    // The Charge object
-    // Create a charge
-    // Update a charge
-    // Retrieve a charge
-    // List all charges
-    // Capture a charge
-    // Search charges
-    // Customers
-    // The Customer object
-    // Create a customer
-    // Update a customer
-    // Retrieve a customer
-    // List all customers
-    // Delete a customer
-    // Search customers
-    // Disputes
-    // The Dispute object
-    // Update a dispute
-    // Retrieve a dispute
-    // List all disputes
-    // Close a dispute
-    // Payouts
-    // The Payout object
-    // Create a payout
-    // Update a payout
-    // Retrieve a payout
-    // List all payouts
-    // Cancel a payout
-    // Reverse a payout
-    // Tokens
-    // The Token object
-    // Create an account token
-    // Create a bank account token
-    // Create a card token
-    // Create a CVC update token
-    // Create a person token
-    // Create a PII token
-    // Retrieve a token
+  async updateRefund(event) {
+    throw new Error("updateRefund method not implemented");
+  }
+  async deactivateRefund(event) {
+    throw new Error("deactivateRefund method not implemented");
   }
-  integrations_service = serviceIntegrations;
-  return integrations_service;
 }
-var stripe_service;
-var hasRequiredStripe_service;
-function requireStripe_service() {
-  if (hasRequiredStripe_service) return stripe_service;
-  hasRequiredStripe_service = 1;
-  const Stripe = require$$0$1;
-  const stripe = Stripe(process.env.STRIPE_API_KEY);
-  const servicePayment = requireIntegrations_service();
-  class servicePaymentStripe extends servicePayment {
-    async createProducts(entityId, items, eventName) {
-      const product = await stripe.products.create({
-        id: entityId,
-        name: eventName,
+const stripe = new Stripe(process.env.STRIPE_API_KEY ?? "", {
+  apiVersion: "2025-04-30.basil"
+});
+class servicePaymentStripe extends serviceIntegrations {
+  async createProducts(entityId, items, eventName) {
+    const product = await stripe.products.create({
+      id: entityId,
+      name: eventName,
+      metadata: {
+        product: entityId
+      }
+    });
+    const priceLinks = [];
+    for (const item of items) {
+      const price = await stripe.prices.create({
+        product: product.id,
+        unit_amount: item.price * 100,
+        currency: "THB",
+        nickname: item.name,
         metadata: {
-          product: entityId
+          ticketType: item.name
         }
       });
-      const priceLinks = [];
-      for (const item of items) {
-        const price = await stripe.prices.create({
-          product: product.id,
-          unit_amount: item.price * 100,
-          currency: "THB",
-          nickname: item.name,
-          metadata: {
-            ticketType: item.name
-          }
-        });
-        const paymentLink = await stripe.paymentLinks.create({
-          line_items: [{
+      const paymentLink = await stripe.paymentLinks.create({
+        line_items: [
+          {
             price: price.id,
             quantity: 1,
             adjustable_quantity: {
               enabled: true
             }
-          }],
-          metadata: {
-            product: entityId,
-            ticketType: item.name
           }
-        });
-        priceLinks.push({
-          productId: product.id,
-          priceId: price.id,
-          paymentLinkId: paymentLink.id,
-          paymentLink: paymentLink.url,
-          name: item.name
-        });
-      }
-      return priceLinks;
+        ],
+        metadata: {
+          product: entityId,
+          ticketType: item.name
+        }
+      });
+      priceLinks.push({
+        productId: product.id,
+        priceId: price.id,
+        paymentLinkId: paymentLink.id,
+        paymentLink: paymentLink.url,
+        name: item.name
+      });
     }
-    async updateProducts(entityId, newItems, existingItems, eventName) {
+    return priceLinks;
+  }
+  async updateProducts(entityId, newItems, existingItems, eventName) {
+    try {
+      const updates = [];
+      let product;
       try {
-        const updates = [];
-        let product;
-        try {
-          product = await stripe.products.retrieve(entityId);
-        } catch (error) {
-          return this.createProducts(entityId, newItems, eventName);
-        }
-        await stripe.products.update(product.id, {
-          name: eventName
-        });
-        const deletedItems = existingItems.filter(
-          (existingItem) => !newItems.some((newItem) => newItem.name === existingItem.name)
-        );
-        for (const deletedItem of deletedItems) {
-          if (deletedItem.stripePaymentLinkId) {
-            await stripe.paymentLinks.update(deletedItem.stripePaymentLinkId, {
-              active: false
-            });
-          }
+        product = await stripe.products.retrieve(entityId);
+      } catch (error) {
+        return this.createProducts(entityId, newItems, eventName);
+      }
+      await stripe.products.update(product.id, {
+        name: eventName
+      });
+      const deletedItems = existingItems.filter((existingItem) => !newItems.some((newItem) => newItem.name === existingItem.name));
+      for (const deletedItem of deletedItems) {
+        if (deletedItem.stripePaymentLinkId) {
+          await stripe.paymentLinks.update(deletedItem.stripePaymentLinkId, {
+            active: false
+          });
         }
-        for (const item of newItems) {
-          const existingItem = existingItems.find((e) => e.name === item.name);
-          if (existingItem) {
-            const prices = await stripe.prices.list({
-              product: product.id,
-              active: true
-            });
-            let price = prices.data.find(
-              (p) => p.unit_amount === item.price * 100 && p.metadata?.ticketType === item.name
-            );
-            if (!price) {
-              await Promise.all(
-                prices.data.filter((p) => p.metadata?.ticketType === item.name).map((p) => stripe.prices.update(p.id, { active: false }))
-              );
-              price = await stripe.prices.create({
-                product: product.id,
-                unit_amount: item.price * 100,
-                currency: "THB",
-                nickname: item.name,
-                metadata: {
-                  ticketType: item.name
-                }
-              });
-              if (existingItem.stripePaymentLinkId) {
-                await stripe.paymentLinks.update(existingItem.stripePaymentLinkId, {
-                  active: false
-                });
-              }
-              const paymentLink = await stripe.paymentLinks.create({
-                line_items: [{
-                  price: price.id,
-                  quantity: 1,
-                  adjustable_quantity: {
-                    enabled: true
-                  }
-                }],
-                metadata: {
-                  product: product.id,
-                  ticketType: item.name
-                }
-              });
-              updates.push({
-                productId: product.id,
-                priceId: price.id,
-                paymentLinkId: paymentLink.id,
-                paymentLink: paymentLink.url,
-                name: item.name
-              });
-            } else {
-              updates.push({
-                productId: product.id,
-                priceId: price.id,
-                paymentLinkId: existingItem.stripePaymentLinkId,
-                paymentLink: existingItem.link,
-                name: item.name
-              });
-            }
-          } else {
-            const price = await stripe.prices.create({
+      }
+      for (const item of newItems) {
+        const existingItem = existingItems.find((e) => e.name === item.name);
+        if (existingItem) {
+          const prices = await stripe.prices.list({
+            product: product.id,
+            active: true
+          });
+          let price = prices.data.find((p) => p.unit_amount === item.price * 100 && p.metadata?.ticketType === item.name);
+          if (!price) {
+            await Promise.all(prices.data.filter((p) => p.metadata?.ticketType === item.name).map((p) => stripe.prices.update(p.id, { active: false })));
+            price = await stripe.prices.create({
               product: product.id,
               unit_amount: item.price * 100,
               currency: "THB",
@@ -442,14 +130,21 @@ function requireStripe_service() {
                 ticketType: item.name
               }
             });
+            if (existingItem.stripePaymentLinkId) {
+              await stripe.paymentLinks.update(existingItem.stripePaymentLinkId, {
+                active: false
+              });
+            }
             const paymentLink = await stripe.paymentLinks.create({
-              line_items: [{
-                price: price.id,
-                quantity: 1,
-                adjustable_quantity: {
-                  enabled: true
+              line_items: [
+                {
+                  price: price.id,
+                  quantity: 1,
+                  adjustable_quantity: {
+                    enabled: true
+                  }
                 }
-              }],
+              ],
               metadata: {
                 product: product.id,
                 ticketType: item.name
@@ -462,497 +157,525 @@ function requireStripe_service() {
               paymentLink: paymentLink.url,
               name: item.name
             });
+          } else {
+            updates.push({
+              productId: product.id,
+              priceId: price.id,
+              paymentLinkId: existingItem.stripePaymentLinkId,
+              paymentLink: existingItem.link,
+              name: item.name
+            });
           }
+        } else {
+          const price = await stripe.prices.create({
+            product: product.id,
+            unit_amount: item.price * 100,
+            currency: "THB",
+            nickname: item.name,
+            metadata: {
+              ticketType: item.name
+            }
+          });
+          const paymentLink = await stripe.paymentLinks.create({
+            line_items: [
+              {
+                price: price.id,
+                quantity: 1,
+                adjustable_quantity: {
+                  enabled: true
+                }
+              }
+            ],
+            metadata: {
+              product: product.id,
+              ticketType: item.name
+            }
+          });
+          updates.push({
+            productId: product.id,
+            priceId: price.id,
+            paymentLinkId: paymentLink.id,
+            paymentLink: paymentLink.url,
+            name: item.name
+          });
         }
-        return updates;
-      } catch (error) {
-        console.error("Error updating products:", error);
-        throw error;
       }
+      return updates;
+    } catch (error) {
+      console.error("Error updating products:", error);
+      throw error;
     }
-    async deactivateProduct(productId) {
-      try {
-        await stripe.products.update(productId, {
-          active: false
-        });
-        const prices = await stripe.prices.list({
-          product: productId,
-          active: true
-        });
-        await Promise.all(
-          prices.data.map(
-            (price) => stripe.prices.update(price.id, { active: false })
-          )
-        );
-        const paymentLinks = await stripe.paymentLinks.list({
-          metadata: {
-            product: productId
-          }
-        });
-        await Promise.all(
-          paymentLinks.data.map(
-            (link) => stripe.paymentLinks.update(link.id, { active: false })
-          )
-        );
-        return true;
-      } catch (error) {
-        console.error("Error deactivating product:", error);
-        throw error;
-      }
-    }
-    async createСheckout(event) {
-      const session = await stripe.checkout.sessions.create({
-        payment_method_types: ["card"],
-        line_items: event.variants.map((variant) => ({
-          price: variant.priceId,
-          quantity: variant.quantity
-        })),
-        mode: "payment",
-        success_url: event.successUrl,
-        cancel_url: event.cancelUrl
+  }
+  async deactivateProduct(productId) {
+    try {
+      await stripe.products.update(productId, {
+        active: false
       });
-      return session.url;
-    }
-    async deactivateСheckout(sessionId) {
-      await stripe.checkout.sessions.expire(sessionId);
-      return "Payment session expired.";
+      const prices = await stripe.prices.list({
+        product: productId,
+        active: true
+      });
+      await Promise.all(prices.data.map((price) => stripe.prices.update(price.id, { active: false })));
+      const paymentLinks = await stripe.paymentLinks.list({
+        metadata: {
+          product: productId
+        }
+      });
+      await Promise.all(paymentLinks.data.map((link) => stripe.paymentLinks.update(link.id, { active: false })));
+      return true;
+    } catch (error) {
+      console.error("Error deactivating product:", error);
+      throw error;
     }
-    async createRefund(event) {
-      const refund = await stripe.refunds.create({
-        payment_intent: event.paymentIntentId
+  }
+  async createСheckout(event) {
+    const session = await stripe.checkout.sessions.create({
+      payment_method_types: ["card"],
+      line_items: event.variants.map((variant) => ({
+        price: variant.priceId,
+        quantity: variant.quantity
+      })),
+      mode: "payment",
+      success_url: event.successUrl,
+      cancel_url: event.cancelUrl
+    });
+    return session.url;
+  }
+  async deactivateСheckout(sessionId) {
+    await stripe.checkout.sessions.expire(sessionId);
+    return "Payment session expired.";
+  }
+  async createRefund(event) {
+    const refund = await stripe.refunds.create({
+      payment_intent: event.paymentIntentId
+    });
+    return refund;
+  }
+  async updateRefund(refundId, metadata) {
+    try {
+      const refund = await stripe.refunds.update(refundId, {
+        metadata
       });
       return refund;
+    } catch (error) {
+      throw new Error("Failed to update refund: " + error.message);
     }
-    async updateRefund(refundId, metadata) {
-      try {
-        const refund = await stripe.refunds.update(refundId, {
-          metadata
-        });
-        return refund;
-      } catch (error) {
-        throw new Error("Failed to update refund: " + error.message);
-      }
-    }
-    async deactivateRefund(refundId) {
-      try {
-        const refund = await stripe.refunds.cancel(refundId);
-        return refund;
-      } catch (error) {
-        throw new Error("Failed to cancel refund: " + error.message);
-      }
+  }
+  async deactivateRefund(refundId) {
+    try {
+      const refund = await stripe.refunds.cancel(refundId);
+      return refund;
+    } catch (error) {
+      throw new Error("Failed to cancel refund: " + error.message);
     }
   }
-  stripe_service = servicePaymentStripe;
-  return stripe_service;
 }
-var events_controller;
-var hasRequiredEvents_controller;
-function requireEvents_controller() {
-  if (hasRequiredEvents_controller) return events_controller;
-  hasRequiredEvents_controller = 1;
-  require$$0.Types.ObjectId;
-  const queryProcessor2 = requireQueryProcessor();
-  const queryProcessorGlobals = queryProcessor$1.requireQueryProcessor();
-  const createFriendlyURL = metadata_schema.requireSeoFriendlyUrl();
-  const integrationStripe = requireStripe_service();
-  const middlewareFactory = (db) => {
-    db.ticket;
-    const Event = db.event;
-    db.membership;
-    const serviceStripe = new integrationStripe();
-    const read = async (req, res) => {
-      console.log("req is", req.query);
-      let stages = [];
-      stages = [
-        ...queryProcessorGlobals.getSearchOptions(
-          req.query.search,
-          {
-            fields: ["name"]
+const ObjectId = { Types }.Types.ObjectId;
+function getDateConditions(date) {
+  if (date) {
+    const dateString = date.toString();
+    const day = parseInt(dateString.substring(0, 2), 10);
+    const month = parseInt(dateString.substring(2, 4), 10) - 1;
+    const year = parseInt(dateString.substring(4, 8), 10);
+    const customDate = new Date(year, month, day);
+    customDate.setHours(0, 0, 0, 0);
+    const customDateEnd = new Date(year, month, day);
+    customDateEnd.setHours(23, 59, 59, 999);
+    return [{ $match: { "date.start": { $gte: customDate, $lte: customDateEnd } } }];
+  } else {
+    return [];
+  }
+}
+function getPeriodConditions(period, periodStart, periodEnd) {
+  const now = /* @__PURE__ */ new Date();
+  let startDate, endDate;
+  if (periodStart && periodEnd) {
+    startDate = new Date(periodStart);
+    endDate = new Date(periodEnd);
+    return [
+      {
+        $match: {
+          "date.start": {
+            $gte: startDate,
+            $lte: endDate
           }
-        ),
-        ...queryProcessorGlobals.getBasicOptions(
-          req.query
-        ),
-        ...queryProcessor2.getDateConditions(
-          req.query.date
-        ),
-        ...queryProcessor2.getPeriodConditions(
-          req.query.period,
-          req.query.periodStart,
-          req.query.periodEnd
-        ),
-        ...queryProcessor2.getPhaseConditions(
-          req.query.phase
-        ),
-        // Tickets and Participants
-        queryProcessor2.getTicketsLookupStage(),
-        queryProcessor2.getParticipantsPhotosStage(),
-        queryProcessor2.getNumberOfTicketsStage(),
-        ...queryProcessor2.getHasTicketStage(
-          req.query.user
-        ),
-        ...queryProcessor2.getParticipantStages(
-          req.query.participant
-        ),
-        // For creator
-        queryProcessorGlobals.getCreatorUserLookupStage(),
-        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
-        // For owner
-        queryProcessorGlobals.getOwnerUserLookupStage(),
-        queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-        queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-        // Get object
-        // queryProcessor.getProjectStage(),
-        // Pagination
-        ...queryProcessorGlobals.getSortingOptions(
-          req.query.sortParam,
-          req.query.sortOrder
-        ),
-        ...queryProcessorGlobals.getPaginationOptions(
-          req.query.skip,
-          req.query.limit
-        )
-      ];
-      try {
-        const events = await Event.aggregate(stages).exec();
-        res.status(200).send(events);
-      } catch (err) {
-        console.log(err);
-        return res.status(500).send({
-          message: err
-        });
-      }
-    };
-    const create = async (req, res) => {
-      delete req.body._id;
-      try {
-        req.body.url = createFriendlyURL(req.body.name);
-        let event = new Event(req.body);
-        if (!event) {
-          return res.status(404).send({ message: "Event is not created." });
-        }
-        if (event.ticketsTypes && event.ticketsTypes.length > 0) {
-          const stripeProducts = await serviceStripe.createProducts(
-            event._id.toString(),
-            event.ticketsTypes,
-            event.name
-          );
-          event.ticketsTypes = event.ticketsTypes.map((ticket, index2) => ({
-            ...ticket,
-            stripeProductId: stripeProducts[index2].productId,
-            stripePriceId: stripeProducts[index2].priceId,
-            stripePaymentLinkId: stripeProducts[index2].paymentLinkId,
-            link: stripeProducts[index2].paymentLink
-          }));
         }
-        await event.save();
-        res.status(200).send(event);
-      } catch (err) {
-        console.log(err);
-        return res.status(500).send({
-          message: err.message
-        });
       }
-    };
-    const update = async (req, res) => {
-      try {
-        let existingEvent = await Event.findOne({ url: req.body.url });
-        if (!existingEvent) {
-          return res.status(404).send({
-            message: "Event not found."
-          });
-        }
-        if (req.body.ticketsTypes && req.body.ticketsTypes.length > 0) {
-          const stripeUpdates = await serviceStripe.updateProducts(
-            existingEvent._id.toString(),
-            req.body.ticketsTypes,
-            existingEvent.ticketsTypes || [],
-            req.body.name
-          );
-          req.body.ticketsTypes = req.body.ticketsTypes.map((ticket) => {
-            const stripeData = stripeUpdates.find((update2) => update2.name === ticket.name);
-            return {
-              ...ticket,
-              stripeProductId: stripeData?.productId,
-              stripePriceId: stripeData?.priceId,
-              stripePaymentLinkId: stripeData?.paymentLinkId,
-              link: stripeData?.paymentLink || ticket.link
-            };
-          });
-        } else {
-          req.body.ticketsTypes = [];
+    ];
+  } else if (period) {
+    startDate = new Date(now.getTime());
+    endDate = new Date(now.getTime());
+    switch (period) {
+      case "today":
+        startDate.setHours(0, 0, 0, 0);
+        endDate.setHours(23, 59, 59, 999);
+        break;
+      case "week":
+        endDate.setDate(now.getDate() + 7);
+        break;
+      case "month":
+        endDate.setDate(now.getDate() + 30);
+        break;
+      case "year":
+        endDate.setFullYear(now.getFullYear() + 1);
+        break;
+    }
+    return [
+      {
+        $match: {
+          "date.start": {
+            $gte: startDate,
+            $lte: endDate
+          }
         }
-        await Event.updateOne(
-          { _id: existingEvent._id },
-          { $set: req.body }
-        );
-        res.status(200).send(req.body);
-      } catch (err) {
-        console.log(err);
-        return res.status(500).send({
-          message: err.message
-        });
       }
-    };
-    const deleteMethod = async (req, res) => {
-      try {
-        const event = await Event.findOne({ _id: req.body._id });
-        if (!event) {
-          return res.status(404).send({
-            message: "Event not found."
-          });
+    ];
+  } else {
+    return [];
+  }
+}
+function getPhaseConditions(phase) {
+  const now = /* @__PURE__ */ new Date();
+  const todayStart = new Date(now.getTime());
+  todayStart.setHours(0, 0, 0, 0);
+  const todayEnd = new Date(now.getTime());
+  todayEnd.setHours(23, 59, 59, 999);
+  let matchConditions = [];
+  switch (phase) {
+    case "finished":
+      matchConditions.push({ "date.start": { $lt: now } });
+      break;
+    case "today":
+      matchConditions.push({ "date.start": { $gte: todayStart, $lte: todayEnd } });
+      break;
+    case "live":
+      matchConditions.push({ "date.start": { $lte: now } });
+      matchConditions.push({ "date.end": { $gte: now } });
+      break;
+    case "planned":
+      matchConditions.push({ "date.start": { $gt: now } });
+      break;
+  }
+  if (matchConditions && matchConditions.length > 0) {
+    return [{ $match: { $and: matchConditions } }];
+  } else {
+    return [];
+  }
+}
+function getTicketsLookupStage() {
+  return {
+    $lookup: {
+      from: "tickets",
+      localField: "_id",
+      foreignField: "target",
+      as: "tickets",
+      pipeline: [
+        {
+          $lookup: {
+            from: "users",
+            localField: "user",
+            foreignField: "_id",
+            as: "user"
+          }
+        },
+        {
+          $unwind: { path: "$user", preserveNullAndEmptyArrays: true }
         }
-        if (event.ticketsTypes && event.ticketsTypes.length > 0) {
-          await serviceStripe.deactivateProduct(event._id.toString());
+      ]
+    }
+  };
+}
+function getParticipantsPhotosStage() {
+  return {
+    $addFields: {
+      participantsPhotos: {
+        $map: {
+          input: "$tickets",
+          as: "ticket",
+          in: "$$ticket.user.profile.photo"
         }
-        await Event.deleteOne({ _id: req.body._id });
-        res.status(200).send(event);
-      } catch (err) {
-        return res.status(500).send({
-          message: err.message
-        });
       }
-    };
-    return {
-      read,
-      create,
-      update,
-      delete: deleteMethod
-    };
+    }
   };
-  events_controller = middlewareFactory;
-  return events_controller;
 }
-var verifyEvent;
-var hasRequiredVerifyEvent;
-function requireVerifyEvent() {
-  if (hasRequiredVerifyEvent) return verifyEvent;
-  hasRequiredVerifyEvent = 1;
-  const middlewareFactory = (db) => {
-    const Event = db.event;
-    const checkEventExistOrNot = async (req, res, next) => {
-      try {
-        const url = req.body.url ? req.body.url : req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, "");
-        if (!req.body._id) {
-          const event = await Event.findOne({ url });
-          if (event) {
-            res.status(400).send({ errorCode: "EVENT_URL_ALREADY_IN_USE", accessToken: null });
-            return;
+function getNumberOfTicketsStage() {
+  return {
+    $addFields: {
+      numberOfTickets: { $size: "$tickets" }
+    }
+  };
+}
+function getHasTicketStage(user) {
+  if (user) {
+    return [
+      {
+        $addFields: {
+          hasTicket: {
+            $in: [new ObjectId(user), "$tickets.user._id"]
           }
-          next();
-          return;
-        }
-        const updatingEventId = req.body._id;
-        const existingEvent = await Event.findById(updatingEventId);
-        if (!existingEvent) {
-          res.status(404).send({ errorCode: "EVENT_NOT_FOUND", accessToken: null });
-          return;
         }
-        if (existingEvent.url !== url) {
-          const event = await Event.findOne({ url });
-          if (event) {
-            res.status(400).send({ errorCode: "EVENT_URL_ALREADY_IN_USE", accessToken: null });
-            return;
+      }
+    ];
+  } else {
+    return [];
+  }
+}
+function getProjectStage() {
+  return {
+    $project: {
+      _id: 1,
+      url: 1,
+      cover: 1,
+      name: 1,
+      phase: 1,
+      description: 1,
+      content: 1,
+      owner: 1,
+      creator: 1,
+      tags: 1,
+      date: 1,
+      numberOfTickets: 1,
+      participantsPhotos: 1,
+      special: 1,
+      specialData: 1,
+      hasTicket: 1,
+      tickets: 1,
+      createdAt: 1
+    }
+  };
+}
+function getParticipantStages(participantQuery) {
+  const participantId = participantQuery ? new ObjectId(participantQuery) : null;
+  let stages = [];
+  if (participantId) {
+    stages.push({
+      $addFields: {
+        participantTickets: {
+          $filter: {
+            input: "$tickets",
+            as: "ticket",
+            cond: { $eq: ["$$ticket.user._id", participantId] }
           }
         }
-        next();
-      } catch (err) {
-        console.log(err);
-        res.status(500).send({ message: err });
       }
-    };
-    const checkNameNotEmpty = (req, res, next) => {
-      if (!req.body.name || req.body.name.trim() === "") {
-        res.status(400).send({ errorCode: "NAME_CANNOT_BE_EMPTY", accessToken: null });
-        return;
+    });
+    stages.push({
+      $match: {
+        "participantTickets.0": { $exists: true }
       }
-      next();
-    };
-    return {
-      checkEventExistOrNot,
-      // Изменено с checkBlogpostExistOrNot на checkEventExistOrNot
-      checkNameNotEmpty
-    };
-  };
-  verifyEvent = middlewareFactory;
-  return verifyEvent;
+    });
+  }
+  return stages;
 }
-var server;
-var hasRequiredServer;
-function requireServer() {
-  if (hasRequiredServer) return server;
-  hasRequiredServer = 1;
-  const middlewareIndexFactory = (db) => {
-    const verifyEvent2 = requireVerifyEvent()(db);
-    return {
-      verifyEvent: verifyEvent2
-    };
+const queryProcessor = {
+  getDateConditions,
+  getPhaseConditions,
+  getPeriodConditions,
+  getTicketsLookupStage,
+  getParticipantsPhotosStage,
+  getNumberOfTicketsStage,
+  getHasTicketStage,
+  getProjectStage,
+  getParticipantStages
+};
+({ Types }).Types.ObjectId;
+const middlewareFactory$1 = (db) => {
+  db.ticket;
+  const Event = db.event;
+  db.membership;
+  const serviceStripe = new servicePaymentStripe();
+  const read = async (req, res) => {
+    console.log("req is", req.query);
+    let stages = [];
+    stages = [
+      ...queryProcessorGlobals.getSearchOptions(req.query.search, {
+        fields: ["name"]
+      }),
+      ...queryProcessorGlobals.getBasicOptions(req.query),
+      ...queryProcessor.getDateConditions(req.query.date),
+      ...queryProcessor.getPeriodConditions(req.query.period, req.query.periodStart, req.query.periodEnd),
+      ...queryProcessor.getPhaseConditions(req.query.phase),
+      // Tickets and Participants
+      queryProcessor.getTicketsLookupStage(),
+      queryProcessor.getParticipantsPhotosStage(),
+      queryProcessor.getNumberOfTicketsStage(),
+      ...queryProcessor.getHasTicketStage(req.query.user),
+      ...queryProcessor.getParticipantStages(req.query.participant),
+      // For creator
+      queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      // For owner
+      queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+      // Get object
+      // queryProcessor.getProjectStage(),
+      // Pagination
+      ...queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+      ...queryProcessorGlobals.getPaginationOptions(req.query.skip, req.query.limit)
+    ];
+    try {
+      const events = await Event.aggregate(stages).exec();
+      res.status(200).send(events);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).send({
+        message: err
+      });
+    }
   };
-  server = middlewareIndexFactory;
-  return server;
-}
-var events_routes;
-var hasRequiredEvents_routes;
-function requireEvents_routes() {
-  if (hasRequiredEvents_routes) return events_routes;
-  hasRequiredEvents_routes = 1;
-  const controllerFactory = requireEvents_controller();
-  const middlewareFactoryAuth = index.requireMiddlewares();
-  const middlewareFactoryEvents = requireServer();
-  const { getInstance } = globals_abac.requireGlobals_abac();
-  events_routes = function(app, db, origins) {
-    const controller = controllerFactory(db);
-    const abac = getInstance(db);
-    const { authJwt } = middlewareFactoryAuth(db);
-    const { verifyEvent: verifyEvent2 } = middlewareFactoryEvents(db);
-    app.get(
-      "/api/events/read",
-      [
-        authJwt.verifyToken(true),
-        abac.middleware("events", "read", {
-          allowPublished: true,
-          allowUnauthenticated: true
-        })
-      ],
-      controller.read
-    );
-    app.post(
-      "/api/events/create",
-      [
-        authJwt.verifyToken(),
-        abac.middleware("events", "create"),
-        verifyEvent2.checkNameNotEmpty,
-        verifyEvent2.checkEventExistOrNot
-      ],
-      controller.create
-    );
-    app.post(
-      "/api/events/update",
-      [
-        authJwt.verifyToken(),
-        abac.middleware("events", "edit"),
-        verifyEvent2.checkNameNotEmpty,
-        verifyEvent2.checkEventExistOrNot
-      ],
-      controller.update
-    );
-    app.post(
-      "/api/events/delete",
-      [
-        authJwt.verifyToken(),
-        abac.middleware("events", "delete")
-      ],
-      controller.delete
-    );
+  const create = async (req, res) => {
+    delete req.body._id;
+    try {
+      req.body.url = createFriendlyURL(req.body.name);
+      let event = new Event(req.body);
+      if (!event) {
+        return res.status(404).send({ message: "Event is not created." });
+      }
+      if (event.ticketsTypes && event.ticketsTypes.length > 0) {
+        const stripeProducts = await serviceStripe.createProducts(event._id.toString(), event.ticketsTypes, event.name);
+        event.ticketsTypes = event.ticketsTypes.map((ticket, index) => ({
+          ...ticket,
+          stripeProductId: stripeProducts[index].productId,
+          stripePriceId: stripeProducts[index].priceId,
+          stripePaymentLinkId: stripeProducts[index].paymentLinkId,
+          link: stripeProducts[index].paymentLink
+        }));
+      }
+      await event.save();
+      res.status(200).send(event);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).send({
+        message: err.message
+      });
+    }
   };
-  return events_routes;
-}
-var tickets_routes;
-var hasRequiredTickets_routes;
-function requireTickets_routes() {
-  if (hasRequiredTickets_routes) return tickets_routes;
-  hasRequiredTickets_routes = 1;
-  const controllerFactory = tickets_controller.requireTickets_controller();
-  tickets_routes = function(app, db, origins, publicPath) {
-    const controller = controllerFactory(db, publicPath);
-    app.get(
-      "/api/tickets",
-      controller.read
-    );
-    app.post(
-      "/api/tickets/create",
-      controller.create
-    );
-    app.post(
-      "/api/tickets/update",
-      controller.update
-    );
-    app.post(
-      "/api/tickets/delete",
-      controller.delete
-    );
+  const update = async (req, res) => {
+    try {
+      let existingEvent = await Event.findOne({ url: req.body.url });
+      if (!existingEvent) {
+        return res.status(404).send({
+          message: "Event not found."
+        });
+      }
+      if (req.body.ticketsTypes && req.body.ticketsTypes.length > 0) {
+        const stripeUpdates = await serviceStripe.updateProducts(existingEvent._id.toString(), req.body.ticketsTypes, existingEvent.ticketsTypes || [], req.body.name);
+        req.body.ticketsTypes = req.body.ticketsTypes.map((ticket) => {
+          const stripeData = stripeUpdates.find((update2) => update2.name === ticket.name);
+          return {
+            ...ticket,
+            stripeProductId: stripeData?.productId,
+            stripePriceId: stripeData?.priceId,
+            stripePaymentLinkId: stripeData?.paymentLinkId,
+            link: stripeData?.paymentLink || ticket.link
+          };
+        });
+      } else {
+        req.body.ticketsTypes = [];
+      }
+      await Event.updateOne({ _id: existingEvent._id }, { $set: req.body });
+      res.status(200).send(req.body);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).send({
+        message: err.message
+      });
+    }
   };
-  return tickets_routes;
-}
-var event_model;
-var hasRequiredEvent_model;
-function requireEvent_model() {
-  if (hasRequiredEvent_model) return event_model;
-  hasRequiredEvent_model = 1;
-  const applyCommonSchema = common_schema.requireCommon_schema();
-  const applyEngagementSchema = engagement_schema.requireEngagement_schema();
-  const applyOwnershipSchema = ownership_schema.requireOwnership_schema();
-  const applyMetadataSchema = metadata_schema.requireMetadata_schema();
-  event_model = (db, additionalFields = {}) => {
-    const baseSchema = {
-      cover: {
-        type: String
-      },
-      name: {
-        type: String,
-        required: true
-      },
-      description: {
-        type: String,
+  const deleteMethod = async (req, res) => {
+    try {
+      const event = await Event.findOne({ _id: req.body._id });
+      if (!event) {
+        return res.status(404).send({
+          message: "Event not found."
+        });
+      }
+      if (event.ticketsTypes && event.ticketsTypes.length > 0) {
+        await serviceStripe.deactivateProduct(event._id.toString());
+      }
+      await Event.deleteOne({ _id: req.body._id });
+      res.status(200).send(event);
+    } catch (err) {
+      return res.status(500).send({
+        message: err.message
+      });
+    }
+  };
+  return {
+    read,
+    create,
+    update,
+    delete: deleteMethod
+  };
+};
+const createEventModel = (db, additionalFields = {}) => {
+  const baseSchema = {
+    cover: {
+      type: String
+    },
+    name: {
+      type: String,
+      required: true
+    },
+    description: {
+      type: String,
+      required: true
+    },
+    location: {
+      type: String
+    },
+    content: {
+      type: Array
+    },
+    date: {
+      start: {
+        type: Date,
         required: true
       },
-      location: {
-        type: String
-      },
-      content: {
-        type: Array
-      },
-      date: {
-        start: {
-          type: Date,
-          required: true
-        },
-        end: {
-          type: Date
-        }
-      },
-      ticketsTypes: {
-        type: Array
+      end: {
+        type: Date
       }
-      // ticketsTypes: [{
-      //     image: String,
-      //     link: String,
-      //     price: Number,
-      //     name: String,
-      //     buttonText: String
-      //     stripeProductId
-      //     stripePriceId
-      //     stripePaymentLinkId
-      // }]
-    };
-    const EventSchema = new db.mongoose.Schema({
+    },
+    ticketsTypes: {
+      type: Array
+    }
+    // ticketsTypes: [{
+    //     image: String,
+    //     link: String,
+    //     price: Number,
+    //     name: String,
+    //     buttonText: String
+    //     stripeProductId
+    //     stripePriceId
+    //     stripePaymentLinkId
+    // }]
+  };
+  const EventSchema = new db.mongoose.Schema(
+    {
       ...baseSchema,
       ...additionalFields
-    }, {
+    },
+    {
       timestamps: {
         currentTime: () => Date.now()
       }
-    });
-    EventSchema.index({
-      "name": 1,
-      "date.start": 1,
-      "date.end": -1
-    });
-    applyCommonSchema(EventSchema, db);
-    applyEngagementSchema(EventSchema, db);
-    applyOwnershipSchema(EventSchema, db);
-    applyMetadataSchema(EventSchema, db);
-    return db.mongoose.model("Event", EventSchema);
-  };
-  return event_model;
-}
-var ticket_model;
-var hasRequiredTicket_model;
-function requireTicket_model() {
-  if (hasRequiredTicket_model) return ticket_model;
-  hasRequiredTicket_model = 1;
-  ticket_model = (db) => {
-    const TicketSchema = new db.mongoose.Schema({
+    }
+  );
+  EventSchema.index({
+    name: 1,
+    "date.start": 1,
+    "date.end": -1
+  });
+  applyCommonSchema(EventSchema);
+  applyEngagementSchema(EventSchema);
+  applyOwnershipSchema(EventSchema, db);
+  applyMetadataSchema(EventSchema);
+  return db.mongoose.model("Event", EventSchema);
+};
+const createTicketModel = (db) => {
+  const TicketSchema = new db.mongoose.Schema(
+    {
       client: {
         type: db.mongoose.Schema.Types.ObjectId,
         ref: "Client"
@@ -1004,56 +727,130 @@ function requireTicket_model() {
         enum: ["unused", "used", "deactivated"],
         deafult: "unused"
       }
-    }, {
+    },
+    {
       timestamps: {
         currentTime: () => Date.now()
       }
-    });
-    TicketSchema.index({ user: 1, type: 1, target: 1 });
-    const Ticket = db.mongoose.model("Ticket", TicketSchema);
-    return Ticket;
-  };
-  return ticket_model;
-}
-var events_server$1;
-var hasRequiredEvents_server;
-function requireEvents_server() {
-  if (hasRequiredEvents_server) return events_server$1;
-  hasRequiredEvents_server = 1;
-  const EventsController = requireEvents_controller();
-  const TicketsController = tickets_controller.requireTickets_controller();
-  const eventsRoutes = requireEvents_routes();
-  const ticketsRoutes = requireTickets_routes();
-  const createEventModel = requireEvent_model();
-  const createTicketModel = requireTicket_model();
-  function initializeEvent(app, db, origins, publicPath, options = {}) {
-    console.log("initializeEvent publicPath:", publicPath);
-    const { eventFields = {}, ticketFields = {} } = options;
-    console.log("new fields is", eventFields);
-    db.event = createEventModel(db, eventFields);
-    db.ticket = createTicketModel(db, ticketFields);
-    if (app) {
-      eventsRoutes(app, db, origins, publicPath);
-      ticketsRoutes(app, db, origins, publicPath);
     }
-  }
-  events_server$1 = {
-    initialize: initializeEvent,
-    models: {
-      EventModel: createEventModel,
-      TicketModel: createTicketModel
-    },
-    routes: {
-      eventsRoutes,
-      ticketsRoutes
-    },
-    controllers: {
-      EventsController,
-      TicketsController
+  );
+  TicketSchema.index({ user: 1, type: 1, target: 1 });
+  const Ticket = db.mongoose.model("Ticket", TicketSchema);
+  return Ticket;
+};
+const middlewareFactory = (db) => {
+  const Event = db.event;
+  const checkEventExistOrNot = async (req, res, next) => {
+    try {
+      const url = req.body.url ? req.body.url : req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, "");
+      if (!req.body._id) {
+        const event = await Event.findOne({ url });
+        if (event) {
+          res.status(400).send({ errorCode: "EVENT_URL_ALREADY_IN_USE", accessToken: null });
+          return;
+        }
+        next();
+        return;
+      }
+      const updatingEventId = req.body._id;
+      const existingEvent = await Event.findById(updatingEventId);
+      if (!existingEvent) {
+        res.status(404).send({ errorCode: "EVENT_NOT_FOUND", accessToken: null });
+        return;
+      }
+      if (existingEvent.url !== url) {
+        const event = await Event.findOne({ url });
+        if (event) {
+          res.status(400).send({ errorCode: "EVENT_URL_ALREADY_IN_USE", accessToken: null });
+          return;
+        }
+      }
+      next();
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: err });
     }
   };
-  return events_server$1;
+  const checkNameNotEmpty = (req, res, next) => {
+    if (!req.body.name || req.body.name.trim() === "") {
+      res.status(400).send({ errorCode: "NAME_CANNOT_BE_EMPTY", accessToken: null });
+      return;
+    }
+    next();
+  };
+  return {
+    checkEventExistOrNot,
+    // Изменено с checkBlogpostExistOrNot на checkEventExistOrNot
+    checkNameNotEmpty
+  };
+};
+const middlewareIndexFactory = (db) => {
+  const verifyEvent = middlewareFactory(db);
+  return {
+    verifyEvent
+  };
+};
+const { getInstance } = globalsabac;
+const eventsRoutes = function(app, db, origins) {
+  const controller = middlewareFactory$1(db);
+  const abac = getInstance(db);
+  const { authJwt } = middlewareIndexFactory$1(db);
+  const { verifyEvent } = middlewareIndexFactory(db);
+  app.get(
+    "/api/events/read",
+    [
+      authJwt.verifyToken(true),
+      abac.middleware("events", "read", {
+        allowPublished: true,
+        allowUnauthenticated: true
+      })
+    ],
+    controller.read
+  );
+  app.post("/api/events/create", [authJwt.verifyToken(), abac.middleware("events", "create"), verifyEvent.checkNameNotEmpty, verifyEvent.checkEventExistOrNot], controller.create);
+  app.post("/api/events/update", [authJwt.verifyToken(), abac.middleware("events", "edit"), verifyEvent.checkNameNotEmpty, verifyEvent.checkEventExistOrNot], controller.update);
+  app.post("/api/events/delete", [authJwt.verifyToken(), abac.middleware("events", "delete")], controller.delete);
+};
+const ticketsRoutes = function(app, db, origins, publicPath) {
+  const controller = controllerFactory(db, publicPath);
+  app.get("/api/tickets", controller.read);
+  app.post("/api/tickets/create", controller.create);
+  app.post("/api/tickets/update", controller.update);
+  app.post("/api/tickets/delete", controller.delete);
+};
+function initializeEvent(app, db, origins, publicPath, options = {}) {
+  console.log("initializeEvent publicPath:", publicPath);
+  const { eventFields = {}, ticketFields = {} } = options;
+  console.log("new fields is", eventFields);
+  db.event = createEventModel(db, eventFields);
+  db.ticket = createTicketModel(db);
+  if (app) {
+    eventsRoutes(app, db);
+    ticketsRoutes(app, db, origins, publicPath);
+  }
 }
-var events_serverExports = requireEvents_server();
-const events_server = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(events_serverExports);
-module.exports = events_server;
+const models = {
+  EventModel: createEventModel,
+  TicketModel: createTicketModel
+};
+const routes = {
+  eventsRoutes,
+  ticketsRoutes
+};
+const controllers = {
+  EventsController: middlewareFactory$1,
+  TicketsController: controllerFactory
+};
+const events_server = {
+  initialize: initializeEvent,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  events_server as default,
+  initializeEvent as initialize,
+  models,
+  routes
+};