@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/events.server.mjs

@@ -1,1060 +0,0 @@
-import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import require$$0 from "mongoose";
-import { r as requireQueryProcessor$1 } from "./queryProcessor-CVKI651_.mjs";
-import { a as requireSeoFriendlyUrl, r as requireMetadata_schema } from "./metadata.schema--tle-GU8.mjs";
-import require$$0$1 from "stripe";
-import { r as requireTickets_controller } from "./tickets.controller-BIhfgjNb.mjs";
-import { r as requireMiddlewares } from "./index-C_Fw0Umg.mjs";
-import { r as requireGlobals_abac } from "./globals.abac-DZpTRxKR.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-CNCotD3D.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
-          }
-        }
-      }];
-    } 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 [];
-    }
-  }
-  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 }
-        }]
-      }
-    };
-  }
-  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"]
-          }
-        }
-      }];
-    } 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] }
-            }
-          }
-        }
-      });
-      stages.push({
-        $match: {
-          "participantTickets.0": { $exists: true }
-        }
-      });
-    }
-    return stages;
-  }
-  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
-  }
-  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,
-        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: {
-            ticketType: 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;
-    }
-    async updateProducts(entityId, newItems, existingItems, eventName) {
-      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
-            });
-          }
-        }
-        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({
-              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;
-      }
-    }
-    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
-        });
-        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);
-      }
-    }
-  }
-  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
-        });
-      }
-    };
-    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
-        });
-      }
-    };
-    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
-        });
-      }
-    };
-    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
-    };
-  };
-  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;
-          }
-          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 });
-      }
-    };
-    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
-    };
-  };
-  verifyEvent = middlewareFactory;
-  return verifyEvent;
-}
-var server;
-var hasRequiredServer;
-function requireServer() {
-  if (hasRequiredServer) return server;
-  hasRequiredServer = 1;
-  const middlewareIndexFactory = (db) => {
-    const verifyEvent2 = requireVerifyEvent()(db);
-    return {
-      verifyEvent: verifyEvent2
-    };
-  };
-  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
-      },
-      location: {
-        type: String
-      },
-      content: {
-        type: Array
-      },
-      date: {
-        start: {
-          type: Date,
-          required: true
-        },
-        end: {
-          type: Date
-        }
-      },
-      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({
-      client: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "Client"
-      },
-      client_refactor: {
-        email: {
-          type: String
-        },
-        name: {
-          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
-    },
-    routes: {
-      eventsRoutes,
-      ticketsRoutes
-    },
-    controllers: {
-      EventsController,
-      TicketsController
-    }
-  };
-  return events_server$1;
-}
-var events_serverExports = requireEvents_server();
-const events_server = /* @__PURE__ */ getDefaultExportFromCjs(events_serverExports);
-export {
-  events_server as default
-};