@ozdao/prometheus-framework 0.2.43 → 0.2.46

package/dist/products.server.mjs

@@ -0,0 +1,875 @@
+import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-83b1d755.mjs";
+import "uuid";
+import require$$0 from "mongoose";
+import "path";
+import require$$3 from "openai";
+import { s as server } from "./index-d769324d.mjs";
+import "jsonwebtoken";
+import "mongodb";
+var product_model = (mongoose) => {
+  const ProductSchema = new mongoose.Schema({
+    owner: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User"
+    },
+    organization: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Organization"
+    },
+    status: { type: String },
+    name: { type: String },
+    category: { type: Array },
+    description: { type: String },
+    sale: { type: Number },
+    price: { type: Number },
+    images: { type: Array },
+    popularity: { type: Number },
+    localization: { type: Array },
+    ingredients: { type: Array },
+    information: [{
+      name: { type: String },
+      value: { type: String }
+    }],
+    // MoySklad
+    quantity: { type: Number },
+    quantityDiscount: [{
+      quantity: {
+        type: Number,
+        required: true,
+        min: [1, "Quantity cannot be less than 1"]
+      },
+      discount: {
+        type: Number,
+        required: true,
+        min: [0, "Quantity-based discount cannot be less than 0"],
+        max: [100, "Quantity-based discount cannot be more than 100"]
+      }
+    }]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  ProductSchema.index({ organization: 1 });
+  ProductSchema.index({ category: 1 });
+  ProductSchema.index({ price: 1 });
+  const Product = mongoose.model("Product", ProductSchema);
+  return Product;
+};
+const product_model$1 = /* @__PURE__ */ getDefaultExportFromCjs(product_model);
+var category_model = (mongoose) => {
+  const СategorySchema = new mongoose.Schema({
+    name: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    url: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    subcategories: {
+      type: Array
+    },
+    localization: {
+      type: Array
+    },
+    filters: {
+      type: Array
+    },
+    owner: {
+      type: {
+        type: String,
+        required: true
+      },
+      target: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.owner.type === "user")
+            return "User";
+          if (this.owner.type === "organization")
+            return "Organization";
+        },
+        required: true
+      }
+    },
+    creator: {
+      hidden: {
+        type: Boolean,
+        required: true
+      },
+      type: {
+        type: String,
+        required: true
+      },
+      target: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.owner.type === "user")
+            return "User";
+          if (this.owner.type === "organization")
+            return "Organization";
+        },
+        required: true
+      }
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  СategorySchema.index({ "owner.target": 1, "creator.target": 1 });
+  const Сategory = mongoose.model("Сategory", СategorySchema, "categories");
+  return Сategory;
+};
+const category_model$1 = /* @__PURE__ */ getDefaultExportFromCjs(category_model);
+var modification_model = (mongoose) => {
+  const ModificationSchema = new mongoose.Schema({
+    name: {
+      type: String
+    },
+    product: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      required: true
+    },
+    price: {
+      type: Number
+    },
+    quantity: {
+      type: Number
+    },
+    // dups: {type: Array},  
+    characteristics: [{
+      _id: {
+        type: String
+      },
+      name: {
+        type: String
+      },
+      value: {
+        type: String
+      }
+    }]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  ModificationSchema.index({ product: 1 });
+  const Modification = mongoose.model("Modification", ModificationSchema);
+  return Modification;
+};
+const modification_model$1 = /* @__PURE__ */ getDefaultExportFromCjs(modification_model);
+var leftover_model = (mongoose) => {
+  const LeftoverSchema = new mongoose.Schema({
+    organization: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Organization"
+    },
+    type: {
+      type: String,
+      enum: ["stock-in", "stock-out", "write-off"],
+      default: "stock-in",
+      required: true
+    },
+    order: {
+      type: String
+    },
+    store: {
+      type: Object
+    },
+    positions: [{
+      _id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Product"
+      },
+      name: {
+        type: String
+      },
+      quantity: {
+        type: Number
+      },
+      price: {
+        type: Number
+      },
+      type: {
+        type: String
+      }
+    }]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  LeftoverSchema.index({ user: 1, type: 1, target: 1 });
+  const Leftover = mongoose.model("Leftover", LeftoverSchema);
+  return Leftover;
+};
+const leftover_model$1 = /* @__PURE__ */ getDefaultExportFromCjs(leftover_model);
+const ObjectId$1 = require$$0.Types.ObjectId;
+const OpenAI = require$$3;
+const openai = new OpenAI();
+const controllerFactory$5 = (db) => {
+  const Product = db.product;
+  db.modification;
+  db.leftover;
+  const Create = async (req, res) => {
+    try {
+      const newProduct = new Product(req.body);
+      const data = await newProduct.save();
+      res.send(data);
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: err.message });
+    }
+  };
+  const Read = async (req, res) => {
+    try {
+      let query = {};
+      let options = {};
+      if (req.query.organization) {
+        query.organization = new ObjectId$1(req.query.organization);
+      }
+      if (req.query._id) {
+        query._id = req.query._id;
+      }
+      if (req.query.status) {
+        query.status = req.query.status;
+      }
+      const categories = req.query.categories?.split(",") || [];
+      if (categories.length) {
+        query.category = { $in: categories };
+      }
+      const deliveryOptions = req.query.delivery?.split(",") || [];
+      if (deliveryOptions.length) {
+        query.delivery = { $in: deliveryOptions };
+      }
+      const prices = req.query.prices?.split(",") || [];
+      console.log(prices);
+      if (prices.length) {
+        const priceConditions = prices.map((priceRange) => {
+          if (priceRange.startsWith("<")) {
+            return { price: { $lt: parseInt(priceRange.slice(1)) } };
+          }
+          if (priceRange.startsWith(">")) {
+            return { price: { $gt: parseInt(priceRange.slice(1)) } };
+          }
+          const [min, max] = priceRange.split("-").map(Number);
+          return { price: { $gte: min, $lte: max } };
+        });
+        console.log(priceConditions);
+        if (priceConditions.length) {
+          query = {
+            ...query,
+            ...{ $or: priceConditions }
+          };
+        }
+      }
+      options.skip = parseInt(req.query.skip) || 0;
+      options.limit = parseInt(req.query.limit) || 10;
+      options.sort = { createdAt: -1 };
+      if (req.query.count) {
+        try {
+          const count = await Product.countDocuments(query);
+          return res.status(200).json({ count });
+        } catch (err) {
+          return res.status(500).json({ message: err.message });
+        }
+      }
+      console.log(query);
+      const products = await Product.find(query, null, options);
+      if (!products.length) {
+        return res.status(200).json([]);
+      }
+      res.status(200).json(products);
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+  const Update = async (req, res) => {
+    try {
+      const { _id } = req.params;
+      console.log(_id);
+      const updatedProduct = await Product.findOneAndUpdate(
+        { _id },
+        {
+          name: req.body.name,
+          status: req.body.status,
+          description: req.body.description,
+          price: req.body.price,
+          sale: req.body.sale,
+          category: req.body.category,
+          images: req.body.images,
+          information: req.body.information,
+          localization: req.body.localization,
+          quantity: req.body.quantity,
+          quantityDiscount: req.body.quantityDiscount
+        },
+        { new: true }
+      );
+      if (!updatedProduct) {
+        return res.status(404).send({ message: "Something wrong when updating product." });
+      }
+      res.status(200).send(updatedProduct);
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+  const Delete = async (req, res) => {
+    try {
+      const { _id } = req.params;
+      const deletedProduct = await Product.findOneAndDelete({ _id });
+      if (!deletedProduct) {
+        return res.status(404).send({ message: "Product not found for deletion." });
+      }
+      res.status(200).send(deletedProduct);
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+  const getProducts = (req, res) => {
+    Product.aggregate([
+      {
+        $facet: {
+          "withIngredients": [
+            {
+              $match: {
+                ingridients: { $exists: true, $not: { $size: 0 } }
+                // Продукты с ингредиентами
+              }
+            },
+            {
+              $lookup: {
+                from: "products",
+                localField: "ingridients",
+                foreignField: "_id",
+                as: "ingredientDetails"
+              }
+            },
+            { $unwind: "$ingredientDetails" },
+            {
+              $lookup: {
+                from: "leftovers",
+                let: { "ingredientId": "$ingredientDetails._id" },
+                pipeline: [
+                  { $unwind: "$positions" },
+                  {
+                    $match: {
+                      $expr: {
+                        $eq: ["$positions._id", "$$ingredientId"]
+                      }
+                    }
+                  },
+                  {
+                    $project: {
+                      quantity: "$positions.quantity"
+                    }
+                  }
+                ],
+                as: "ingredientLeftovers"
+              }
+            },
+            {
+              $group: {
+                _id: "$_id",
+                name: { $first: "$name" },
+                minQuantity: { $min: "$ingredientLeftovers.quantity" }
+              }
+            }
+          ],
+          "withoutIngredients": [
+            {
+              $match: {
+                $or: [
+                  { ingridients: { $exists: false } },
+                  // Продукты без ингредиентов
+                  { ingridients: { $size: 0 } }
+                ]
+              }
+            },
+            {
+              $lookup: {
+                from: "leftovers",
+                let: { "productId": "$_id" },
+                pipeline: [
+                  { $unwind: "$positions" },
+                  {
+                    $match: {
+                      $expr: {
+                        $eq: ["$positions._id", "$$productId"]
+                      }
+                    }
+                  },
+                  {
+                    $project: {
+                      quantity: "$positions.quantity"
+                    }
+                  }
+                ],
+                as: "productLeftovers"
+              }
+            },
+            {
+              $set: {
+                minQuantity: { $sum: "$productLeftovers.quantity" }
+              }
+            }
+          ]
+        }
+      },
+      {
+        $project: {
+          products: { $setUnion: ["$withIngredients", "$withoutIngredients"] }
+        }
+      },
+      { $unwind: "$products" },
+      { $replaceRoot: { newRoot: "$products" } }
+    ]).exec((err, products) => {
+      if (err) {
+        return res.status(500).send({ message: err });
+      }
+      if (!products) {
+        return res.status(404).send({ message: "Products not found." });
+      }
+      res.status(200).send(products);
+      console.log(products);
+    });
+  };
+  const getProductRecommendation = async (req, res) => {
+    const { mood } = req.body;
+    try {
+      const products = await Product.find({
+        status: "published"
+      }).limit(40);
+      if (!products) {
+        console.log("no products");
+        return res.status(404).send({ message: "Products not found." });
+      }
+      const productsList = products.map((p) => `
+        ${p._id}: 
+        ${p.name} 
+        (${p.information[0].value}) 
+        (${p.information[1].value}%)  
+        (${p.information[2].value})
+      `).join(", ");
+      const prompt = `
+        1. When asked how the client wants to feel, they responded "${mood}". 
+        2. Here is a list of products in our store: ${productsList}. 
+        3. Based on the information about the products (strain, THC content) and the user's desires, choose 1 product to recommend to the user.
+        4. The response should be in the language that the user used in mood (${mood}).
+        5. Please format your response as a JSON object '{"_id": "ID of the recommended product (it must correspond to one of the product IDs I sent)", "recommendationText": "Text explaining why this particular product"'. Write only the JSON object without any other text outside of it.
+      `;
+      console.log(prompt);
+      let response;
+      let result;
+      while (true) {
+        try {
+          response = await openai.chat.completions.create({
+            model: "gpt-4",
+            messages: [{ role: "user", content: prompt }]
+          });
+          console.log(response);
+          result = JSON.parse(response.choices[0].message.content);
+          break;
+        } catch (err) {
+          if (err instanceof SyntaxError) {
+            console.log("Received invalid JSON, retrying...");
+          } else {
+            console.log(err);
+            res.status(500).send({ message: err });
+            return;
+          }
+        }
+      }
+      console.log(result._id);
+      console.log(result.recommendationText);
+      const recommendedProduct = await Product.findById(result._id);
+      if (!recommendedProduct) {
+        console.log(`No product found with _id: ${result._id}`);
+        return res.status(404).send({ message: "Recommended product not found." });
+      }
+      res.status(200).json({ product: recommendedProduct, recommendationText: result.recommendationText });
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: err });
+    }
+  };
+  const getProductsPopular = (req, res) => {
+    Product.find({
+      status: "published",
+      popularity: { $gt: 10 }
+    }).populate("modifications").limit(10).exec((err, products) => {
+      if (err) {
+        return res.status(500).send({ message: err });
+      }
+      if (!products) {
+        return res.status(404).send({ message: "Products not found." });
+      }
+      res.status(200).send(products);
+    });
+  };
+  const getProduct = async (req, res) => {
+    try {
+      const product = await Product.aggregate([
+        {
+          $match: { "_id": new ObjectId$1(req.params._id) }
+        },
+        {
+          $lookup: {
+            from: "leftovers",
+            let: { productId: "$_id", ingredients: { $ifNull: ["$ingredients", []] } },
+            pipeline: [
+              {
+                $unwind: "$positions"
+              },
+              {
+                "$match": { "$expr": { "$eq": ["$positions._id", "$$productId"] } }
+              },
+              {
+                "$addFields": {
+                  "positions.quantity": {
+                    $cond: {
+                      if: { $eq: ["$type", "stock-in"] },
+                      then: "$positions.quantity",
+                      else: { $multiply: ["$positions.quantity", -1] }
+                    }
+                  }
+                }
+              },
+              {
+                "$project": {
+                  _id: "$positions._id",
+                  quantity: "$positions.quantity",
+                  name: "$positions.name"
+                }
+              }
+            ],
+            as: "variants"
+          }
+        },
+        {
+          $set: {
+            quantity: {
+              $sum: ["$quantity", { $sum: "$variants.quantity" }]
+            }
+          }
+        },
+        { $unset: "variants" }
+      ]);
+      if (!product || product.length < 1) {
+        return res.status(404).send({ message: "Product not found." });
+      }
+      const updatedProduct = await Product.findOneAndUpdate(
+        { _id: req.params._id },
+        { $inc: { popularity: 1 } },
+        { new: true }
+      );
+      console.log("Popularity updated:", updatedProduct);
+      res.status(200).send(product);
+    } catch (err) {
+      console.error("Error:", err);
+      res.status(500).send({ message: err });
+    }
+  };
+  return {
+    Create,
+    Read,
+    Update,
+    Delete,
+    getProducts,
+    getProductsPopular,
+    getProduct,
+    getProductRecommendation
+  };
+};
+var products_controller = controllerFactory$5;
+const controllerFactory$4 = products_controller;
+var products_routes = function(app, db, allowedOrigins) {
+  const controller = controllerFactory$4(db);
+  app.use(function(req, res, next) {
+    res.header(
+      "Access-Control-Allow-Headers",
+      "Access-Control-Allow-Origin: *",
+      "x-access-token, Origin, Content-Type, Accept"
+    );
+    next();
+  });
+  app.post(
+    "/api/products/create",
+    controller.Create
+  );
+  app.get(
+    "/api/products/read",
+    controller.Read
+  );
+  app.post(
+    "/api/products/:_id",
+    controller.Update
+  );
+  app.delete(
+    "/api/products/:_id",
+    controller.Delete
+  );
+  app.post(
+    "/api/product/recommended",
+    controller.getProductRecommendation
+  );
+  app.get(
+    "/api/products/:_id",
+    controller.getProduct
+  );
+};
+const products_routes$1 = /* @__PURE__ */ getDefaultExportFromCjs(products_routes);
+const controllerFactory$3 = (db) => {
+  const Category = db.category;
+  const getCategories = async (req, res) => {
+    console.log(Category);
+    try {
+      const categories = await Category.find({}).sort({ "order": "asc" }).exec();
+      if (!categories) {
+        return res.status(404).send({ message: "Categories not found." });
+      }
+      res.status(200).send(categories);
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: err });
+    }
+  };
+  const updateCategories = async (req, res) => {
+    try {
+      const updates = req.body.all.map(async (categoryUpdated) => {
+        const category = await Category.findOneAndUpdate(
+          { url: categoryUpdated.url },
+          { $set: categoryUpdated },
+          { new: true }
+        ).exec();
+        if (!category) {
+          throw new Error("Categories is not updated.");
+        }
+      });
+      await Promise.all(updates);
+      console.log("success");
+      res.status(200).send({ message: "Categories updated successfully." });
+    } catch (err) {
+      res.send({ message: err.message });
+    }
+  };
+  const getCategory = async (req, res) => {
+    try {
+      const category = await Category.findOne({ url: req.params.url }).exec();
+      if (!category) {
+        return res.status(404).send({ message: "Category not found." });
+      }
+      res.status(200).send(category);
+    } catch (err) {
+      res.status(500).send({ message: err });
+    }
+  };
+  const addCategory = async (req, res) => {
+    try {
+      const category = await Category.create(req.body);
+      if (!category) {
+        return res.status(404).send({ message: "Category is not created." });
+      }
+      res.status(200).send(category);
+    } catch (err) {
+      console.log(req.body);
+      console.log(req.category);
+      res.status(500).send({ message: err });
+    }
+  };
+  const updateCategory = async (req, res) => {
+    try {
+      const category = await Category.findOneAndUpdate(
+        { url: req.params.url },
+        { $set: req.body },
+        { new: true }
+      ).exec();
+      if (!category) {
+        return res.status(404).send({ message: "Something wrong when updating category." });
+      }
+      res.status(200).send(category);
+    } catch (err) {
+      res.status(500).send({ message: err });
+    }
+  };
+  const deleteCategory = async (req, res) => {
+    try {
+      const category = await Category.findOneAndDelete({ url: req.params.url }).exec();
+      if (!category) {
+        return res.status(404).send({ message: "Category is not deleted." });
+      }
+      res.status(200).send(category);
+    } catch (err) {
+      res.status(500).send({ message: err });
+    }
+  };
+  return {
+    getCategories,
+    updateCategories,
+    getCategory,
+    addCategory,
+    updateCategory,
+    deleteCategory
+  };
+};
+var categories_controller = controllerFactory$3;
+const controllerFactory$2 = categories_controller;
+const middlewareFactory = server;
+var categories_routes = function(app, db) {
+  const controller = controllerFactory$2(db);
+  const { verifyCategory } = middlewareFactory(db);
+  app.use(function(req, res, next) {
+    res.header(
+      "Access-Control-Allow-Headers",
+      "Access-Control-Allow-Origin",
+      "x-access-token, Origin, Content-Type, Accept"
+    );
+    next();
+  });
+  app.get(
+    "/categories",
+    controller.getCategories
+  );
+  app.post(
+    "/categories",
+    controller.updateCategories
+  );
+  app.get(
+    "/categories/:url",
+    controller.getCategory
+  );
+  app.post(
+    "/categories/add",
+    [
+      verifyCategory.checkCategoryExistOrNot
+    ],
+    controller.addCategory
+  );
+  app.post(
+    "/categories/:url",
+    controller.updateCategory
+  );
+  app.delete(
+    "/categories/:url",
+    controller.deleteCategory
+  );
+};
+const categories_routes$1 = /* @__PURE__ */ getDefaultExportFromCjs(categories_routes);
+const ObjectId = require$$0.Types.ObjectId;
+const controllerFactory$1 = (db) => {
+  const Leftover = db.leftover;
+  const getAll = async (req, res) => {
+    try {
+      let query = {};
+      let options = {};
+      if (req.query.organization)
+        query.organization = new ObjectId(req.query.organization);
+      const leftoveres = await Leftover.find(query, null, options).sort({ "createdAt": "desc" }).exec();
+      if (!leftoveres) {
+        return res.status(404).send({ message: "LEFTOVERES_NOT_FOUND" });
+      }
+      res.status(200).send(leftoveres);
+    } catch (err) {
+      res.status(500).send({ message: "ERROR_GET_ALL_LEFTOVERES" });
+    }
+  };
+  const create = async (req, res) => {
+    try {
+      const leftover = await Leftover.create({
+        organization: req.body.organization,
+        type: req.body.type,
+        order: req.body.order,
+        positions: req.body.positions
+      });
+      if (!leftover) {
+        return res.status(404).send({ message: "ERROR_CREATING_LEFTOVER" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      res.status(500).send({ message: "ERROR_CREATE_LEFTOVER" });
+    }
+  };
+  const get = async (req, res) => {
+    try {
+      const leftover = await Leftover.findOne({ _id: req.params._id }).exec();
+      if (!leftover) {
+        return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      res.status(500).send({ message: "ERROR_GET_LEFTOVER" });
+    }
+  };
+  const update = async (req, res) => {
+    try {
+      const leftover = await Leftover.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true, upsert: true }).exec();
+      if (!leftover) {
+        return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: "ERROR_UPDATING_LEFTOVER" });
+    }
+  };
+  const deleteLeftover = async (req, res) => {
+    try {
+      const leftover = await Leftover.findOneAndDelete({ _id: req.params._id });
+      if (!leftover) {
+        return res.status(404).send({ message: "ERROR_DELETING_LEFTOVER" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      res.status(500).send({ message: "ERROR_DELETE_LEFTOVER" });
+    }
+  };
+  return {
+    getAll,
+    create,
+    get,
+    update,
+    delete: deleteLeftover
+  };
+};
+var leftovers_controller = controllerFactory$1;
+const controllerFactory = leftovers_controller;
+var leftovers_routes = function(app, db) {
+  const controller = controllerFactory(db);
+  app.use(function(req, res, next) {
+    res.header("Access-Control-Allow-Headers", "Access-Control-Allow-Origin: *", "x-access-token, Origin, Content-Type, Accept");
+    next();
+  });
+  app.get(
+    "/leftovers",
+    controller.getAll
+  );
+  app.get(
+    "/leftovers/:_id",
+    controller.get
+  );
+  app.post(
+    "/leftovers/:_id",
+    controller.update
+  );
+  app.post(
+    "/leftovers",
+    controller.create
+  );
+  app.delete(
+    "/leftovers/:_id",
+    controller.delete
+  );
+};
+const leftovers_routes$1 = /* @__PURE__ */ getDefaultExportFromCjs(leftovers_routes);
+export {
+  category_model$1 as CategoryModel,
+  leftover_model$1 as LeftoverModel,
+  modification_model$1 as ModificationModel,
+  product_model$1 as ProductModel,
+  categories_routes$1 as categoriesRoutes,
+  leftovers_routes$1 as leftoversRoutes,
+  products_routes$1 as productsRoutes
+};