@ozdao/martyrs 0.2.487 → 0.2.489

package/dist/orders.server.js

@@ -2,9 +2,9 @@ import { C as Cache, L as Logger } from "./globals.logger-Bf6rRU7j.js";
 import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
 import { m as mailing } from "./mailing-C11EYWm-.js";
 import { a as applyCredentialsSchema } from "./credentials.schema-C9FB2EyY.js";
-import { a as applyOwnershipSchema } from "./ownership.schema-CCZX5vfw.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-BqH4v5vH.js";
 import { a as applyProfileSchema } from "./profile.schema-DchVS-Jr.js";
-import { m as middlewareIndexFactory } from "./index-CVuQC4k1.js";
+import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
 import axios from "axios";
 class CRUD {
   constructor(basePath, app, db, model, options) {
@@ -168,7 +168,6 @@ async function sendOrderMessage(orderData) {
 const controllerFactory = (db) => {
   const Order = db.order;
   const Customer = db.customer;
-  db.leftover;
   const create = async (req, res) => {
     const orderData = req.body;
     req.userId || req.body.creator?.target;
@@ -179,7 +178,6 @@ const controllerFactory = (db) => {
       timestamp: /* @__PURE__ */ new Date(),
       comment: ""
     });
-    console.log("order.data is,", orderData);
     const session = await db.mongoose.startSession();
     session.startTransaction();
     try {
@@ -203,50 +201,6 @@ const controllerFactory = (db) => {
       console.log("Order data after customer processing:", orderData);
       const order = await Order.create([orderData], { session });
       const createdOrder = order[0];
-      if (orderData.positions && orderData.positions.length > 0) {
-        for (const position of orderData.positions) {
-          try {
-            switch (position.listing) {
-              case "rent":
-                const rentData = {
-                  order: createdOrder._id,
-                  product: position._id,
-                  quantity: position.quantity,
-                  startDate: position.date.start,
-                  endDate: position.date.end,
-                  status: "pending",
-                  // Initial status for rent
-                  creator: orderData.creator,
-                  owner: orderData.owner,
-                  comment: `Created from order ${createdOrder._id}`
-                };
-                console.log(rentData);
-                const rentResponse = await fetch(`${process.env.API_URL || ""}/api/rents`, {
-                  method: "POST",
-                  headers: {
-                    "Content-Type": "application/json",
-                    "X-Service-Key": process.env.SERVICE_KEY
-                  },
-                  body: JSON.stringify(rentData)
-                });
-                if (!rentResponse.ok) {
-                  const errorData = await rentResponse.json();
-                  throw new Error(`Failed to create rent: ${JSON.stringify(errorData)}`);
-                }
-                break;
-              case "sale":
-                console.log(`Sale position for product ${position.product} - leftover creation will be implemented later`);
-                break;
-              default:
-                console.warn(`Unknown listing type: ${position.listing} for position with product ${position.product}`);
-            }
-          } catch (positionError) {
-            console.log(positionError);
-            console.error(`Error processing position for product ${position.product}:`, positionError);
-            throw new Error(`Failed to process position for product ${position.product}: ${positionError.message}`);
-          }
-        }
-      }
       await session.commitTransaction();
       sendOrderMessage(orderData).catch(console.error);
       res.status(201).send(createdOrder);
@@ -320,14 +274,115 @@ const controllerFactory = (db) => {
     }
   };
   const update = async (req, res) => {
+    console.log("=== ORDER UPDATE START ===");
+    console.log("User ID:", req.userId);
+    console.log("Request body:", JSON.stringify(req.body, null, 2));
+    const session = await db.mongoose.startSession();
+    session.startTransaction();
+    console.log("Transaction started");
     try {
-      const order = await Order.findOne({ _id: req.body._id });
+      console.log("Finding order with ID:", req.body._id);
+      const order = await Order.findOne({ _id: req.body._id }).session(session);
       if (!order) {
+        console.log("Order not found");
+        await session.abortTransaction();
         return res.status(404).send({ errorCode: "ORDER_NOT_FOUND", message: "Order not found." });
       }
+      console.log("Order found, current status:", order.status);
       const statusChanged = req.body.status && req.body.status !== order.status;
       const oldStatus = order.status;
+      console.log("Status changed:", statusChanged, "from", oldStatus, "to", req.body.status);
+      if (req.body.status === "confirmed" && oldStatus !== "confirmed") {
+        console.log("Processing confirmed status change - creating rents/adjustments");
+        if (req.body.positions) {
+          console.log("Updating order positions");
+          order.positions = req.body.positions;
+        }
+        console.log("Total positions to process:", order.positions.length);
+        const apiCalls = [];
+        for (const [index, position] of order.positions.entries()) {
+          console.log(`Processing position ${index + 1}/${order.positions.length}:`, position.name, "listing:", position.listing);
+          switch (position.listing) {
+            case "rent":
+              console.log(`Creating rent for position ${index + 1}`);
+              const rentData = {
+                order: order._id,
+                product: position._id,
+                variant: position.variant,
+                quantity: position.quantity,
+                startDate: position.date.start,
+                endDate: position.date.end,
+                status: "pending",
+                creator: order.creator,
+                owner: order.owner,
+                comment: `Created from order ${order._id}`
+              };
+              const rentPromise = fetch(`${process.env.API_URL || ""}/api/rents`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-Service-Key": process.env.SERVICE_KEY
+                },
+                body: JSON.stringify(rentData)
+              }).then(async (response) => {
+                console.log(`Rent API response for position ${index + 1}:`, response.status);
+                if (!response.ok) {
+                  const errorData = await response.json();
+                  throw new Error(`Failed to create rent for position ${index + 1}: ${JSON.stringify(errorData)}`);
+                }
+                const result = await response.json();
+                console.log(`Rent created successfully for position ${index + 1}:`, result._id);
+                return result;
+              });
+              apiCalls.push(rentPromise);
+              break;
+            case "sale":
+              console.log(`Creating stock adjustment for position ${index + 1}`);
+              const adjustmentData = {
+                product: position._id,
+                variant: position.variant,
+                storage: order.delivery?.spot || process.env.DEFAULT_STORAGE_ID,
+                source: { type: "Order", target: order._id },
+                reason: "sale",
+                quantity: -position.quantity,
+                // Negative for stock-out
+                comment: `Stock-out for order ${order._id}`,
+                owner: order.owner,
+                creator: { type: "User", target: req.userId }
+              };
+              const adjustmentPromise = fetch(`${process.env.API_URL || ""}/api/inventory/adjustments/create`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-Service-Key": process.env.SERVICE_KEY
+                },
+                body: JSON.stringify(adjustmentData)
+              }).then(async (response) => {
+                console.log(`Adjustment API response for position ${index + 1}:`, response.status);
+                if (!response.ok) {
+                  const errorData = await response.json();
+                  throw new Error(`Failed to create stock adjustment for position ${index + 1}: ${JSON.stringify(errorData)}`);
+                }
+                const result = await response.json();
+                console.log(`Stock adjustment created successfully for position ${index + 1}:`, result._id);
+                return result;
+              });
+              apiCalls.push(adjustmentPromise);
+              break;
+            default:
+              console.warn(`Unknown listing type: ${position.listing} for position ${position._id}`);
+          }
+        }
+        if (apiCalls.length > 0) {
+          console.log(`Executing ${apiCalls.length} API calls in parallel...`);
+          await Promise.all(apiCalls);
+          console.log("All API calls completed successfully");
+        } else {
+          console.log("No API calls to execute");
+        }
+      }
       if (statusChanged) {
+        console.log("Updating order status from", oldStatus, "to", req.body.status);
         order.status = req.body.status;
         order.status_history.push({
           status: req.body.status,
@@ -336,13 +391,21 @@ const controllerFactory = (db) => {
         });
       }
       if (req.body.payment?.type && req.body.payment.type !== order.payment?.type) {
+        console.log("Updating payment type to:", req.body.payment.type);
         order.payment.type = req.body.payment.type;
       }
       if (req.body.payment?.status && req.body.payment.status !== order.payment?.status) {
+        console.log("Updating payment status to:", req.body.payment.status);
         order.payment.status = req.body.payment.status;
       }
-      await order.save();
+      console.log("Saving order to database...");
+      await order.save({ session });
+      console.log("Order saved successfully");
+      console.log("Committing transaction...");
+      await session.commitTransaction();
+      console.log("Transaction committed successfully");
       if (statusChanged) {
+        console.log("Sending notification for status change...");
         try {
           const notificationData = {
             title: `Order Status Updated`,
@@ -357,8 +420,7 @@ const controllerFactory = (db) => {
             userId: order.creator.target
             // Assuming creator.target holds the user ID
           };
-          console.log("notifiocatio data", JSON.stringify(notificationData));
-          console.log("notification api is", `${process.env.API_URL || ""}/api/notifications`);
+          console.log("Notification data:", JSON.stringify(notificationData));
           const notificationResponse = await fetch(`${process.env.API_URL || ""}/api/notifications`, {
             method: "POST",
             headers: {
@@ -367,21 +429,44 @@ const controllerFactory = (db) => {
             },
             body: JSON.stringify(notificationData)
           });
+          console.log("Notification response status:", notificationResponse.status);
           if (!notificationResponse.ok) {
             const errorData = await notificationResponse.json();
             console.error(`Failed to create notification: ${JSON.stringify(errorData)}`);
+          } else {
+            console.log("Notification sent successfully");
           }
         } catch (notificationError) {
           console.error("Error sending notification:", notificationError);
         }
       }
+      console.log("Sending response to client...");
       res.status(200).send(order);
+      console.log("=== ORDER UPDATE COMPLETED SUCCESSFULLY ===");
     } catch (err) {
+      console.log("=== ERROR OCCURRED ===");
+      console.error("Error details:", err);
+      console.error("Error stack:", err.stack);
+      try {
+        await session.abortTransaction();
+        console.log("Transaction aborted successfully");
+      } catch (abortErr) {
+        console.error("Error aborting transaction:", abortErr);
+      }
       res.status(500).send({
         errorCode: "UPDATE_ORDER_FAILED",
         message: "Error occurred while updating the order.",
-        error: err
+        error: err.message
       });
+      console.log("Error response sent to client");
+    } finally {
+      try {
+        session.endSession();
+        console.log("Session ended");
+      } catch (sessionErr) {
+        console.error("Error ending session:", sessionErr);
+      }
+      console.log("=== ORDER UPDATE PROCESS FINISHED ===");
     }
   };
   const changePaymentStatus = async (req, res) => {
@@ -760,27 +845,33 @@ const RoutesApplications = function(app, db, origins) {
 };
 const RoutesOrder = function(app, db, origins, publicPath) {
   const controller = controllerFactory(db);
-  middlewareIndexFactory(db);
+  const middleware = middlewareIndexFactory(db);
   app.post(
     "/api/orders/create",
-    // [
-    //   middleware.authJwt.verifyToken
-    // ],
+    [
+      middleware.authJwt.verifyToken(true)
+    ],
     controller.create
   );
-  app.get("/api/orders/read", controller.read);
+  app.get(
+    "/api/orders/read",
+    [
+      middleware.authJwt.verifyToken(true)
+    ],
+    controller.read
+  );
   app.post(
     "/api/orders/update",
-    // [
-    //   middleware.authJwt.verifyToken
-    // ],
+    [
+      middleware.authJwt.verifyToken()
+    ],
     controller.update
   );
   app.post(
     "/api/orders/delete",
-    // [
-    //   middleware.authJwt.verifyToken
-    // ],
+    [
+      middleware.authJwt.verifyToken()
+    ],
     controller.deleteOrder
   );
 };

package/dist/organizations.server.cjs

@@ -2,14 +2,14 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const abac = require("./abac-6LjoG9u-.cjs");
 const credentials_schema = require("./credentials.schema-DwhGdrwC.cjs");
-const ownership_schema = require("./ownership.schema-DCosqOc1.cjs");
+const ownership_schema = require("./ownership.schema-D1p5XSpt.cjs");
 const engagement_schema = require("./engagement.schema-JADHu8pj.cjs");
-const index = require("./index-DiSKVCaA.cjs");
+const index = require("./index-BFxqqmgh.cjs");
 const mailing = require("./mailing-q7sR8gCV.cjs");
 const uuidv4 = require("uuidv4");
 const queryProcessor = require("./queryProcessor-B_X680wC.cjs");
 const mongoose = require("mongoose");
-const globals_abac = require("./globals.abac-Cm9e8Jdk.cjs");
+const globals_abac = require("./globals.abac-CPXLas7N.cjs");
 const globals_logger = require("./globals.logger-CZMgIMlM.cjs");
 const addUserStatusFields = require("./addUserStatusFields-7-66sf45.cjs");
 const jwt = require("jsonwebtoken");
@@ -243,7 +243,7 @@ const accessesSchema = {
       default: false
     }
   },
-  leftovers: {
+  inventory: {
     read: {
       type: Boolean,
       default: false
@@ -762,6 +762,27 @@ const lookupConfigs = {
       from: "products",
       localField: "_id",
       foreignField: "owner.target",
+      pipeline: [
+        {
+          $lookup: {
+            from: "variants",
+            localField: "_id",
+            foreignField: "product",
+            pipeline: [
+              {
+                $project: {
+                  _id: 1,
+                  name: 1,
+                  price: 1,
+                  quantity: 1,
+                  type: 1
+                }
+              }
+            ],
+            as: "variants"
+          }
+        }
+      ],
       as: "products"
     },
     additionalStages: [

package/dist/organizations.server.js

@@ -1,13 +1,13 @@
 import { A as ABAC } from "./abac-Cf_9lCSh.js";
 import { a as applyCredentialsSchema } from "./credentials.schema-C9FB2EyY.js";
-import { a as applyOwnershipSchema } from "./ownership.schema-CCZX5vfw.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-BqH4v5vH.js";
 import { a as applyEngagementSchema } from "./engagement.schema-Dh1adRsn.js";
-import { m as middlewareIndexFactory } from "./index-CVuQC4k1.js";
+import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
 import { m as mailing } from "./mailing-C11EYWm-.js";
 import { uuid } from "uuidv4";
 import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
 import { Types } from "mongoose";
-import { g as globalsabac } from "./globals.abac-DBV_kaOq.js";
+import { g as globalsabac } from "./globals.abac-DNdtSYop.js";
 import { C as Cache } from "./globals.logger-Bf6rRU7j.js";
 import { a as addUserStatusFields, b as addMembersQuantity } from "./addUserStatusFields-Cc-JpmPo.js";
 import jwt from "jsonwebtoken";
@@ -224,7 +224,7 @@ const accessesSchema = {
       default: false
     }
   },
-  leftovers: {
+  inventory: {
     read: {
       type: Boolean,
       default: false
@@ -743,6 +743,27 @@ const lookupConfigs = {
       from: "products",
       localField: "_id",
       foreignField: "owner.target",
+      pipeline: [
+        {
+          $lookup: {
+            from: "variants",
+            localField: "_id",
+            foreignField: "product",
+            pipeline: [
+              {
+                $project: {
+                  _id: 1,
+                  name: 1,
+                  price: 1,
+                  quantity: 1,
+                  type: 1
+                }
+              }
+            ],
+            as: "variants"
+          }
+        }
+      ],
       as: "products"
     },
     additionalStages: [

package/dist/{ownership.schema-CCZX5vfw.js → ownership.schema-BqH4v5vH.js}

@@ -4,7 +4,7 @@ const applyOwnershipSchema = function applyOwnershipSchema2(schema, db) {
       type: {
         type: String,
         required: true,
-        enum: ["user", "organization", "platform"]
+        enum: ["user", "organization", "platform", "User", "Organization"]
       },
       target: {
         type: db.mongoose.Schema.Types.ObjectId,
@@ -22,7 +22,7 @@ const applyOwnershipSchema = function applyOwnershipSchema2(schema, db) {
       type: {
         type: String,
         required: true,
-        enum: ["user", "organization", "customer", "platform"]
+        enum: ["user", "organization", "customer", "platform", "User", "Organization"]
       },
       target: {
         type: db.mongoose.Schema.Types.ObjectId,

package/dist/{ownership.schema-DCosqOc1.cjs → ownership.schema-D1p5XSpt.cjs}

@@ -5,7 +5,7 @@ const applyOwnershipSchema = function applyOwnershipSchema2(schema, db) {
       type: {
         type: String,
         required: true,
-        enum: ["user", "organization", "platform"]
+        enum: ["user", "organization", "platform", "User", "Organization"]
       },
       target: {
         type: db.mongoose.Schema.Types.ObjectId,
@@ -23,7 +23,7 @@ const applyOwnershipSchema = function applyOwnershipSchema2(schema, db) {
       type: {
         type: String,
         required: true,
-        enum: ["user", "organization", "customer", "platform"]
+        enum: ["user", "organization", "customer", "platform", "User", "Organization"]
       },
       target: {
         type: db.mongoose.Schema.Types.ObjectId,