@ozdao/prometheus-framework 0.2.330 → 0.2.332

package/dist/events.server.mjs

@@ -1,374 +1,437 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
 import require$$0 from "mongoose";
-import { q as queryProcessor$2 } from "./queryProcessor-CyQch65j.mjs";
-import { s as seoFriendlyUrl, m as metadata_schema } from "./metadata.schema-CK5e2O3f.mjs";
+import { r as requireQueryProcessor$1 } from "./queryProcessor-C_l-zkrM.mjs";
+import { a as requireSeoFriendlyUrl, r as requireMetadata_schema } from "./metadata.schema-DrLHoyi8.mjs";
 import require$$0$1 from "stripe";
-import { t as tickets_controller } from "./tickets.controller-D4HKBmCa.mjs";
-import { m as middlewares } from "./index-CW2mOwo8.mjs";
-import { g as globals_abac } from "./globals.abac-CWAEpvzq.mjs";
-import { c as common_schema } from "./common.schema-ChBVARrs.mjs";
-import { e as engagement_schema } from "./engagement.schema-CCdSLKd4.mjs";
-import { o as ownership_schema } from "./ownership.schema-oyx6eNkZ.mjs";
-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 { r as requireTickets_controller } from "./tickets.controller-YKLaYwKj.mjs";
+import { r as requireMiddlewares } from "./index-Ctf6Y61O.mjs";
+import { r as requireGlobals_abac } from "./globals.abac-dtpS1dd-.mjs";
+import { r as requireCommon_schema } from "./common.schema-C2m3O1XY.mjs";
+import { r as requireEngagement_schema } from "./engagement.schema-DnDD7Bn3.mjs";
+import { r as requireOwnership_schema } from "./ownership.schema-C0w02Vw1.mjs";
+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 [];
+    }
   }
-}
-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
+  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;
       }
-    }];
-  } 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);
+      return [{
+        $match: {
+          "date.start": {
+            $gte: startDate,
+            $lte: endDate
+          }
+        }
+      }];
+    } 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 "week":
-        endDate.setDate(now.getDate() + 7);
+      case "today":
+        matchConditions.push({ "date.start": { $gte: todayStart, $lte: todayEnd } });
         break;
-      case "month":
-        endDate.setDate(now.getDate() + 30);
+      case "live":
+        matchConditions.push({ "date.start": { $lte: now } });
+        matchConditions.push({ "date.end": { $gte: now } });
         break;
-      case "year":
-        endDate.setFullYear(now.getFullYear() + 1);
+      case "planned":
+        matchConditions.push({ "date.start": { $gt: now } });
         break;
     }
-    return [{
-      $match: {
-        "date.start": {
-          $gte: startDate,
-          $lte: endDate
-        }
-      }
-    }];
-  } 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 (matchConditions && matchConditions.length > 0) {
+      return [{ $match: { $and: matchConditions } }];
+    } else {
+      return [];
     }
-  };
-}
-function getParticipantsPhotosStage() {
-  return {
-    $addFields: {
-      participantsPhotos: {
-        $map: {
-          input: "$tickets",
-          as: "ticket",
-          in: "$$ticket.user.profile.photo"
-        }
-      }
-    }
-  };
-}
-function getNumberOfTicketsStage() {
-  return {
-    $addFields: {
-      numberOfTickets: { $size: "$tickets" }
-    }
-  };
-}
-function getHasTicketStage(user) {
-  if (user) {
-    return [{
-      $addFields: {
-        hasTicket: {
-          $in: [new ObjectId(user), "$tickets.user._id"]
-        }
+  }
+  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 }
+        }]
       }
-    }];
-  } 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({
+  function getParticipantsPhotosStage() {
+    return {
       $addFields: {
-        "participantTickets": {
-          $filter: {
+        participantsPhotos: {
+          $map: {
             input: "$tickets",
             as: "ticket",
-            cond: { $eq: ["$$ticket.user._id", participantId] }
+            in: "$$ticket.user.profile.photo"
           }
         }
       }
-    });
-    stages.push({
-      $match: {
-        "participantTickets.0": { $exists: true }
-      }
-    });
-  }
-  return stages;
-}
-var queryProcessor$1 = {
-  getDateConditions,
-  getPhaseConditions,
-  getPeriodConditions,
-  getTicketsLookupStage,
-  getParticipantsPhotosStage,
-  getNumberOfTicketsStage,
-  getHasTicketStage,
-  getProjectStage,
-  getParticipantStages
-};
-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");
+  function getNumberOfTicketsStage() {
+    return {
+      $addFields: {
+        numberOfTickets: { $size: "$tickets" }
+      }
+    };
   }
-  async deactivateСheckout(event) {
-    throw new Error("deactivateСheckout method not implemented");
+  function getHasTicketStage(user) {
+    if (user) {
+      return [{
+        $addFields: {
+          hasTicket: {
+            $in: [new ObjectId(user), "$tickets.user._id"]
+          }
+        }
+      }];
+    } else {
+      return [];
+    }
   }
-  async createRefund(event) {
-    throw new Error("createRefund 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 updateRefund(event) {
-    throw new Error("updateRefund 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 deactivateRefund(event) {
-    throw new Error("deactivateRefund 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
   }
-  // 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
+  integrations_service = serviceIntegrations;
+  return integrations_service;
 }
-var integrations_service = serviceIntegrations;
-const stripe = require$$0$1(process.env.STRIPE_API_KEY);
-const servicePayment = integrations_service;
-class servicePaymentStripe extends servicePayment {
-  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,
+var stripe_service;
+var hasRequiredStripe_service;
+function requireStripe_service() {
+  if (hasRequiredStripe_service) return stripe_service;
+  hasRequiredStripe_service = 1;
+  const stripe = require$$0$1(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,
         metadata: {
-          ticketType: item.name
+          product: entityId
         }
       });
-      const paymentLink = await stripe.paymentLinks.create({
-        line_items: [{
-          price: price.id,
-          quantity: 1,
-          adjustable_quantity: {
-            enabled: true
+      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
           }
-        }],
-        metadata: {
-          product: entityId,
-          ticketType: item.name
-        }
-      });
-      priceLinks.push({
-        productId: product.id,
-        priceId: price.id,
-        paymentLinkId: paymentLink.id,
-        paymentLink: paymentLink.url,
-        name: item.name
-      });
+        });
+        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;
     }
-    return priceLinks;
-  }
-  async updateProducts(entityId, newItems, existingItems, eventName) {
-    try {
-      const updates = [];
-      let product;
+    async updateProducts(entityId, newItems, existingItems, eventName) {
       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
-          });
+        const updates = [];
+        let product;
+        try {
+          product = await stripe.products.retrieve(entityId);
+        } catch (error) {
+          return this.createProducts(entityId, newItems, eventName);
         }
-      }
-      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 }))
+        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
             );
-            price = await stripe.prices.create({
+            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({
               product: product.id,
               unit_amount: item.price * 100,
               currency: "THB",
@@ -377,11 +440,6 @@ class servicePaymentStripe extends servicePayment {
                 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,
@@ -402,303 +460,273 @@ class servicePaymentStripe extends servicePayment {
               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 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
-    });
-    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
+    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 refund;
-    } catch (error) {
-      throw new Error("Failed to update refund: " + error.message);
+      return session.url;
     }
-  }
-  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 deactivateСheckout(sessionId) {
+      await stripe.checkout.sessions.expire(sessionId);
+      return "Payment session expired.";
     }
-  }
-}
-var stripe_service = servicePaymentStripe;
-require$$0.Types.ObjectId;
-const queryProcessor = queryProcessor$1;
-const queryProcessorGlobals = queryProcessor$2;
-const createFriendlyURL = seoFriendlyUrl;
-const integrationStripe = stripe_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"]
-        }
-      ),
-      ...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
+    async createRefund(event) {
+      const refund = await stripe.refunds.create({
+        payment_intent: event.paymentIntentId
       });
+      return refund;
     }
-  };
-  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." });
+    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);
       }
-      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
-        }));
+    }
+    async deactivateRefund(refundId) {
+      try {
+        const refund = await stripe.refunds.cancel(refundId);
+        return refund;
+      } catch (error) {
+        throw new Error("Failed to cancel refund: " + error.message);
       }
-      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."
+  }
+  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 = requireQueryProcessor$1();
+  const createFriendlyURL = 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"]
+          }
+        ),
+        ...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
         });
       }
-      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 {
+    };
+    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: stripeData?.productId,
-            stripePriceId: stripeData?.priceId,
-            stripePaymentLinkId: stripeData?.paymentLinkId,
-            link: stripeData?.paymentLink || ticket.link
-          };
+            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
         });
-      } 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
-      });
-    }
-  };
-  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."
+    };
+    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
         });
       }
-      if (event.ticketsTypes && event.ticketsTypes.length > 0) {
-        await serviceStripe.deactivateProduct(event._id.toString());
+    };
+    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
+        });
       }
-      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
+    };
+    return {
+      read,
+      create,
+      update,
+      delete: deleteMethod
+    };
   };
-};
-var events_controller = middlewareFactory;
+  events_controller = middlewareFactory;
+  return events_controller;
+}
 var verifyEvent;
 var hasRequiredVerifyEvent;
 function requireVerifyEvent() {
   if (hasRequiredVerifyEvent) return verifyEvent;
   hasRequiredVerifyEvent = 1;
-  const middlewareFactory2 = (db) => {
+  const middlewareFactory = (db) => {
     const Event = db.event;
     const checkEventExistOrNot = async (req, res, next) => {
       try {
@@ -744,245 +772,288 @@ function requireVerifyEvent() {
       checkNameNotEmpty
     };
   };
-  verifyEvent = middlewareFactory2;
+  verifyEvent = middlewareFactory;
   return verifyEvent;
 }
-const middlewareIndexFactory = (db) => {
-  const verifyEvent2 = requireVerifyEvent()(db);
-  return {
-    verifyEvent: verifyEvent2
+var server;
+var hasRequiredServer;
+function requireServer() {
+  if (hasRequiredServer) return server;
+  hasRequiredServer = 1;
+  const middlewareIndexFactory = (db) => {
+    const verifyEvent2 = requireVerifyEvent()(db);
+    return {
+      verifyEvent: verifyEvent2
+    };
   };
-};
-var server = middlewareIndexFactory;
-const controllerFactory$1 = events_controller;
-const middlewareFactoryAuth = middlewares;
-const middlewareFactoryEvents = server;
-const { getInstance } = globals_abac;
-var events_routes = function(app, db, origins) {
-  const controller = controllerFactory$1(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 controllerFactory = tickets_controller;
-var 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 applyCommonSchema = common_schema;
-const applyEngagementSchema = engagement_schema;
-const applyOwnershipSchema = ownership_schema;
-const applyMetadataSchema = metadata_schema;
-var event_model = (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,
+  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 = requireMiddlewares();
+  const middlewareFactoryEvents = requireServer();
+  const { getInstance } = 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
+    );
+  };
+  return events_routes;
+}
+var tickets_routes;
+var hasRequiredTickets_routes;
+function requireTickets_routes() {
+  if (hasRequiredTickets_routes) return tickets_routes;
+  hasRequiredTickets_routes = 1;
+  const controllerFactory = 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
+    );
+  };
+  return tickets_routes;
+}
+var event_model;
+var hasRequiredEvent_model;
+function requireEvent_model() {
+  if (hasRequiredEvent_model) return event_model;
+  hasRequiredEvent_model = 1;
+  const applyCommonSchema = requireCommon_schema();
+  const applyEngagementSchema = requireEngagement_schema();
+  const applyOwnershipSchema = requireOwnership_schema();
+  const applyMetadataSchema = requireMetadata_schema();
+  event_model = (db, additionalFields = {}) => {
+    const baseSchema = {
+      cover: {
+        type: String
+      },
+      name: {
+        type: String,
+        required: true
+      },
+      description: {
+        type: String,
         required: true
       },
-      end: {
-        type: Date
+      location: {
+        type: String
+      },
+      content: {
+        type: Array
+      },
+      date: {
+        start: {
+          type: Date,
+          required: true
+        },
+        end: {
+          type: Date
+        }
+      },
+      ticketsTypes: {
+        type: Array
       }
-    },
-    ticketsTypes: {
-      type: Array
-    }
-    // ticketsTypes: [{
-    //     image: String,
-    //     link: String,
-    //     price: Number,
-    //     name: String,
-    //     buttonText: String
-    //     stripeProductId
-    //     stripePriceId
-    //     stripePaymentLinkId
-    // }]
+      // 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);
   };
-  const EventSchema = new db.mongoose.Schema({
-    ...baseSchema,
-    ...additionalFields
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  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);
-};
-var ticket_model = (db) => {
-  const TicketSchema = new db.mongoose.Schema({
-    client: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Client"
-    },
-    client_refactor: {
-      email: {
+  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({
+      client: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Client"
+      },
+      client_refactor: {
+        email: {
+          type: String
+        },
+        name: {
+          type: String
+        }
+      },
+      seat: {
         type: String
       },
-      name: {
+      price: {
+        type: Number
+      },
+      user: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      type: {
+        type: String,
+        enum: ["event", "parking"],
+        default: "event",
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.type === "event") return "Event";
+          if (this.type === "parking") return "Parking";
+        },
+        required: true
+      },
+      role: {
+        type: String,
+        default: "participant"
+      },
+      qrcode: {
         type: String
-      }
-    },
-    seat: {
-      type: String
-    },
-    price: {
-      type: Number
-    },
-    user: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "User"
-    },
-    type: {
-      type: String,
-      enum: ["event", "parking"],
-      default: "event",
-      required: true
-    },
-    target: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: function(value) {
-        if (this.type === "event") return "Event";
-        if (this.type === "parking") return "Parking";
       },
-      required: true
-    },
-    role: {
-      type: String,
-      default: "participant"
-    },
-    qrcode: {
-      type: String
+      image: {
+        type: String
+      },
+      status: {
+        type: String,
+        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 = 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
     },
-    image: {
-      type: String
+    routes: {
+      eventsRoutes,
+      ticketsRoutes
     },
-    status: {
-      type: String,
-      enum: ["unused", "used", "deactivated"],
-      deafult: "unused"
+    controllers: {
+      EventsController,
+      TicketsController
     }
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  TicketSchema.index({ user: 1, type: 1, target: 1 });
-  const Ticket = db.mongoose.model("Ticket", TicketSchema);
-  return Ticket;
-};
-const EventsController = events_controller;
-const TicketsController = tickets_controller;
-const eventsRoutes = events_routes;
-const ticketsRoutes = tickets_routes;
-const createEventModel = event_model;
-const createTicketModel = ticket_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);
-  if (app) {
-    eventsRoutes(app, db);
-    ticketsRoutes(app, db, origins, publicPath);
-  }
+  };
+  return events_server$1;
 }
-var events_server = {
-  initialize: initializeEvent,
-  models: {
-    EventModel: createEventModel,
-    TicketModel: createTicketModel
-  },
-  routes: {
-    eventsRoutes,
-    ticketsRoutes
-  },
-  controllers: {
-    EventsController,
-    TicketsController
-  }
-};
-const events_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(events_server);
+var events_serverExports = requireEvents_server();
+const events_server = /* @__PURE__ */ getDefaultExportFromCjs(events_serverExports);
 export {
-  events_server$1 as default
+  events_server as default
 };