@ozdao/martyrs 0.2.557 → 0.2.559

package/dist/wallet.server.js

@@ -0,0 +1,225 @@
+import * as QRCode from "qrcode";
+import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
+import { c as controllerFactory$1 } from "./tickets.controller-B7r0mK-5.js";
+import { O as ObserverNamespaced } from "./core.observer-MZsqaE6F.js";
+import Stripe from "stripe";
+const controllerFactory = (db) => {
+  const Payment = db.payment;
+  const Wallet = db.wallet;
+  db.order;
+  const create = async (req, res) => {
+    let { amount, positions, userId } = req.body;
+    const newPayment = new Payment(req.body);
+    await newPayment.save();
+    const qrData = `PaymentID:${newPayment._id};Amount:${amount}`;
+    const qrCode = await QRCode.toDataURL(qrData);
+    res.send({ qrCode, paymentId: newPayment._id });
+  };
+  const read = async (req, res) => {
+    try {
+      const paymentes = await Payment.find({}).sort({ createdAt: "desc" }).exec();
+      if (!paymentes) {
+        return res.status(404).send({ message: "Paymentes not found." });
+      }
+      res.status(200).send(paymentes);
+    } catch (err) {
+      res.status(500).send({ message: err.toString() });
+    }
+  };
+  const update = async (req, res) => {
+    const session = await db.mongoose.startSession();
+    session.startTransaction();
+    try {
+      const { paymentId, walletId } = req.body;
+      const payment = await Payment.findById(paymentId).session(session);
+      if (!payment) {
+        throw new Error("Payment not found");
+      }
+      if (payment.status !== "pending") {
+        throw new Error("Payment is not in a pending state");
+      }
+      const wallet = await Wallet.findById(walletId).session(session);
+      if (!wallet) {
+        throw new Error("Wallet not found");
+      }
+      if (wallet.amount < payment.amount) {
+        throw new Error("Insufficient funds");
+      }
+      wallet.amount -= payment.amount;
+      await wallet.save({ session });
+      payment.status = "completed";
+      await payment.save({ session });
+      await session.commitTransaction();
+      res.send("Payment processed successfully");
+    } catch (error) {
+      await session.abortTransaction();
+      res.status(500).send(error.message);
+    } finally {
+      session.endSession();
+    }
+  };
+  const deletePayment = (req, res) => {
+    Payment.findOneAndDelete({ _id: req.params._id }, (err, payment) => {
+      if (err) {
+        return res.status(500).send({ message: err });
+      }
+      if (!payment) {
+        return res.status(404).send({ message: "Something wrong when deleting payment." });
+      }
+      res.status(200).send(payment);
+    });
+  };
+  return {
+    create,
+    read,
+    update,
+    delete: deletePayment
+  };
+};
+class Webhook {
+  constructor(app, db, observer, path, handlerMethod, middlewares = []) {
+    this.app = app;
+    this.db = db;
+    this.observer = observer;
+    this.app.post(path, [...middlewares, handlerMethod.bind(this)]);
+  }
+  // Abstract method, must be implemented in derived classes
+  handleWebhook(req, res) {
+    throw new Error("handleWebhook() must be implemented by subclasses");
+  }
+}
+const stripe = new Stripe(process.env.STRIPE_API_KEY ?? "", {
+  apiVersion: "2025-04-30.basil"
+});
+function middleware(req, res, next) {
+  next();
+}
+class StripeWebhook extends Webhook {
+  constructor(app, db, observer, path = "/api/webhook/stripe", handlerMethod = StripeWebhook.prototype.handleWebhook, middlewares = []) {
+    super(app, db, observer, path, handlerMethod, [middleware]);
+  }
+  async handleWebhook(req, res) {
+    req.headers["stripe-signature"];
+    try {
+      const payload = req.body;
+      const payloadString = JSON.stringify(payload, null, 2);
+      const secret = process.env.STRIPE_WEBHOOK_SECRET;
+      const header = stripe.webhooks.generateTestHeaderString({
+        payload: payloadString,
+        secret
+      });
+      const event = stripe.webhooks.constructEvent(payloadString, header, secret);
+      this.observer.notify(event.type, event.data.object);
+    } catch (err) {
+      console.log(`Error verifying Stripe webhook signature: ${err.message}`);
+      return res.status(400).send(`Webhook Error: ${err.message}`);
+    }
+    res.sendStatus(200);
+  }
+}
+const RoutesPayments = (function(app, db, origins, publicPath) {
+  const observer = new ObserverNamespaced();
+  new StripeWebhook(app, db, observer);
+  const controller = controllerFactory(db);
+  console.log("payments ticket", publicPath);
+  const controllerTickets = controllerFactory$1(db, publicPath);
+  middlewareIndexFactory(db);
+  observer.subscribe("checkout.session.completed", async (paymentIntent) => {
+    try {
+      const event = await db.event.findOne({ _id: paymentIntent.metadata.product });
+      if (!event) {
+        console.error("Event not found:", paymentIntent.metadata.product);
+        return;
+      }
+      const ticketType = event.ticketsTypes.find((type) => type.name === paymentIntent.metadata.ticketType);
+      if (!ticketType) {
+        console.error("Ticket type not found:", paymentIntent.metadata.ticketType);
+        return;
+      }
+      const quantity = paymentIntent.amount_total / (ticketType.price * 100);
+      console.log("Purchase details:");
+      console.log("Email:", paymentIntent.customer_details.email);
+      console.log("Name:", paymentIntent.customer_details.name);
+      console.log("Event ID:", paymentIntent.metadata.eventId);
+      console.log("Ticket Type:", ticketType.name);
+      console.log("Quantity:", quantity);
+      let ticketData = {
+        name: paymentIntent.customer_details.name,
+        email: paymentIntent.customer_details.email,
+        target: paymentIntent.metadata.product,
+        type: "event",
+        seat: ticketType.name,
+        quantity,
+        price: ticketType.price
+      };
+      await controllerTickets.saveAndSendTicket(ticketData);
+    } catch (error) {
+      console.error("Error processing checkout session:", error);
+    }
+  });
+  app.get("/api/payments/read", controller.read);
+  app.post("/api/payments/create", controller.create);
+  app.post("/api/payments/update", controller.update);
+  app.delete("/api/payments/delete", controller.delete);
+});
+const ModelPayment = (db) => {
+  const PaymentSchema = new db.mongoose.Schema(
+    {
+      data: {
+        type: Object
+      },
+      currency: {
+        type: String
+      },
+      status: {
+        type: String
+      },
+      customer: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      creator: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      }
+    },
+    {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    }
+  );
+  const Payment = db.mongoose.model("Payment", PaymentSchema);
+  return Payment;
+};
+function initializePayments(app, db, wss, origins, publicPath) {
+  db.payment = ModelPayment(db);
+  if (app) {
+    RoutesPayments(app, db, origins, publicPath);
+  }
+}
+const models = {
+  // ModelWallet,
+  ModelPayment
+  // ModelReward,
+};
+const routes = {
+  RoutesPayments
+  // RoutesRewards,
+};
+const controllers = {
+  FactoryPayments: controllerFactory
+};
+const wallet_server = {
+  initialize: initializePayments,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  wallet_server as default,
+  initializePayments as initialize,
+  models,
+  routes
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ozdao/martyrs",
-  "version": "0.2.557",
+  "version": "0.2.559",
   "description": "Fullstack framework focused on user experience and ease of development.",
   "author": "OZ DAO <hello@ozdao.dev>",
   "license": "GPL-3.0-or-later",

package/src/modules/wallet/wallet.server.js

@@ -1,15 +1,15 @@
 import FactoryPayments from './controllers/factories/payments.factory.js';
 import RoutesPayments from './controllers/routes/payments.routes.js';
-import RoutesRewards from './controllers/routes/rewards.routes.js';
+// import RoutesRewards from './controllers/routes/rewards.routes.js';
 import ModelPayment from './models/payment.model.js';
-import ModelReward from './models/reward.model.js';
-import ModelWallet from './models/wallet.model.js';
+// import ModelReward from './models/reward.model.js';
+// import ModelWallet from './models/wallet.model.js';
 // Initialization function for setting up the module within the application
-function initializePayments(app, db, wss, wdmClient, origins, publicPath) {
+function initializePayments(app, db, wss, origins, publicPath) {
   // Setup models in the database object
-  db.wallet = ModelWallet(db);
+  // db.wallet = ModelWallet(db);
   db.payment = ModelPayment(db);
-  db.reward = ModelReward(db);
+  // db.reward = ModelReward(db);
   // Setup routes if the app object is provided
   if (app) {
     RoutesPayments(app, db, origins, publicPath);
@@ -17,13 +17,13 @@ function initializePayments(app, db, wss, wdmClient, origins, publicPath) {
   }
 }
 export const models = {
-  ModelWallet,
+  // ModelWallet,
   ModelPayment,
-  ModelReward,
+  // ModelReward,
 };
 export const routes = {
   RoutesPayments,
-  RoutesRewards,
+  // RoutesRewards,
 };
 export const controllers = {
   FactoryPayments,