@ozdao/prometheus-framework 0.2.308 → 0.2.310

package/src/modules/products/controllers/categories.controller.js

@@ -1,120 +1,200 @@
+const ObjectId = require('mongoose').Types.ObjectId;
+
 const controllerFactory = (db) => {
-    const Category = db.category;
+  const Category = db.category;
 
-    const getCategories = async (req, res) => {
-        console.log(Category)
+  return {
+    async read(req, res) {
         try {
-            
-            let query = {};
-            let options = {};
+            const { 
+                parent, 
+                url, 
+                search, 
+                sort = 'order', 
+                order = 1, 
+                page = 1, 
+                limit = 10,
+                excludeChildren = false,
+                rootOnly = false 
+            } = req.query;
 
-            // Проверка наличия req.query.organization
-            if (req.query.status) {
-                // Создание ObjectId из строки
-                query.status = req.query.status;
-            }
+            const matchStage = {
+                ...(req.query.status && { status: req.query.status }),
+                ...(req.query.url && { url: req.query.url }),
+                ...(search && { name: { $regex: search, $options: 'i' } }),
+                ...(parent ? { parent: new mongoose.Types.ObjectId(parent) } : {}),
+                ...(rootOnly ? { parent: null } : {})
+            };
+
+            const pipeline = [
+                { $match: matchStage },
+                {
+                    $graphLookup: {
+                        from: 'categories',
+                        startWith: '$_id',
+                        connectFromField: '_id',
+                        connectToField: 'parent',
+                        as: 'allDescendants',
+                        maxDepth: 10
+                    }
+                },
+                { $sort: { [sort]: order === 'asc' ? 1 : -1 } },
+                { $skip: (page - 1) * limit },
+                { $limit: Number(limit) },
+            ];
 
-            const categories = await Category.find(query, null, options).sort({'order': 'asc'}).exec();
+            const flatResults = await Category.aggregate(pipeline);
             
-            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 });
-        }
-    };
+            function buildTree(items) {
+              const itemMap = {};
+              const roots = [];
+              
+              // First pass: Create map of items by ID
+              items.forEach(item => {
+                  itemMap[item._id.toString()] = {
+                      ...item,
+                      children: []
+                  };
+              });
 
-    const updateCategories = async (req, res) => {
-        console.log(req.body);
-        try {
-            const bulkOps = req.body.map((categoryUpdated) => ({
-                updateOne: {
-                    filter: { url: categoryUpdated.url },
-                    update: { $set: categoryUpdated },
-                    upsert: false 
-                }
-            }));
-
-            // Выполнение пакетного обновления
-            const result = await Category.bulkWrite(bulkOps, { ordered: false });
-            console.log('Success', result);
-            res.status(200).send({ message: "Categories updated successfully." });
+              // Second pass: Build tree structure
+              items.forEach(item => {
+                  const itemId = item._id.toString();
+                  const parentId = item.parent?._id?.toString();
+                  if (parentId && itemMap[parentId]) {
+                      itemMap[parentId].children.push(itemMap[itemId]);
+                  } else {
+                      roots.push(itemMap[itemId]);
+                  }
+              });
+
+              // Sort children arrays by order property
+              const sortByOrder = (a, b) => {
+                  const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+                  const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+                  return orderA - orderB;
+              };
+
+              // Recursive function to sort children at all levels
+              const sortChildren = (node) => {
+                  if (node.children && node.children.length > 0) {
+                      node.children.sort(sortByOrder);
+                      node.children.forEach(sortChildren);
+                  }
+              };
+
+              // Sort roots and all children
+              roots.sort(sortByOrder);
+              roots.forEach(sortChildren);
+
+              return roots;
+          }
+
+          const treeResults = flatResults.map(doc => {
+              const descendants = doc.allDescendants || [];
+              const allItems = [doc, ...descendants];
+              const tree = buildTree(allItems);
+              
+              // Find and return only the root node (original document)
+              return tree.find(node => node._id.toString() === doc._id.toString());
+          });
+
+          // Sort root categories
+          treeResults.sort((a, b) => {
+              const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+              const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+              return orderA - orderB;
+          });
+
+          res.json(treeResults);
         } catch (err) {
-            console.error('Error processing bulk update', err);
-            res.status(500).send({ message: err.message });
+            res.status(500).json({ message: err.message });
         }
-    };
+    },
 
+    async create(req, res) {
+      try {
+        const highestOrder = await Category.findOne().sort('-order');
+        const order = highestOrder ? highestOrder.order + 1 : 1;
+        const category = new Category({ ...req.body, order });
 
-    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 });
+        if (req.body.parent) {
+          const parent = await Category.findByIdAndUpdate(
+            req.body.parent,
+            { $push: { children: category._id } },
+            { new: true }
+          );
+          if (!parent) throw new Error('Parent category not found');
+          category.parent = parent._id;
         }
-    };
 
-    const addCategory = async (req, res) => {
-        try {
+        if (req.body.children && req.body.children.length > 0) {
+          await Category.updateMany(
+            { _id: { $in: req.body.children } },
+            { $set: { parent: category._id } }
+          );
+        }
 
-            const highestOrderDoc = await Category.findOne().sort('-order'); 
-            req.body.order = highestOrderDoc ? highestOrderDoc.order + 1 : 1;
+        await category.save();
+        res.status(201).json(category);
+      } catch (err) {
+        res.status(err.message === 'Parent category not found' ? 404 : 500).json({ message: err.message });
+      }
+    },
 
-            const category = await Category.create(req.body);
+    async update(req, res) {
 
-            if (!category) {
-                return res.status(404).send({ message: "Category is not created." });
+      try {
+        const { categories } = req.body;
+        
+        const bulkOps = categories.map(category => ({
+          updateOne: {
+            filter: { _id: category._id },
+            update: { 
+              $set: { 
+                order: category.order,
+                parent: category.parent ? new ObjectId(category.parent) : null
+              }
             }
-            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 });
-        }
-    };
+        await Category.bulkWrite(bulkOps);
+        const updatedCategories = await Category.find().sort({ order: 'asc' }).lean();
+        res.status(200).json(updatedCategories);
 
-    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." });
+      } catch (err) {
+        console.error('Category update error:', err);
+        res.status(500).json({ message: 'Failed to update categories' });
+      }
+    },
+
+    async delete(req, res) {
+      try {
+        const category = await Category.findOne({ url: req.body.url });
+        if (!category) throw new Error('Category not found');
+        
+        const deleteSubcategories = async (categoryId) => {
+          const cat = await Category.findById(categoryId);
+          if (cat) {
+            for (const childId of cat.children) {
+              await deleteSubcategories(childId);
             }
-            res.status(200).send(category);
-        } catch (err) {
-            res.status(500).send({ message: err });
+            await Category.findByIdAndDelete(categoryId);
+          }
+        };
+        
+        if (category.parent) {
+          await Category.findByIdAndUpdate(category.parent, { $pull: { children: category._id } });
         }
-    };
-
-    return {
-        getCategories,
-        updateCategories,
-        getCategory,
-        addCategory,
-        updateCategory,
-        deleteCategory
-    };
+        
+        await deleteSubcategories(category._id);
+        res.status(200).json({ message: 'Category deleted successfully' });
+      } catch (err) {
+        res.status(err.message === 'Category not found' ? 404 : 500).json({ message: err.message });
+      }
+    }
+  };
 };
 
-module.exports = controllerFactory;
+module.exports = controllerFactory;

package/src/modules/products/controllers/products.controller.js

@@ -35,8 +35,8 @@ const controllerFactory = (db) => {
   try {
     const query = {};
 
-    if (req.query.organization) {
-      query.organization = new ObjectId(req.query.organization);
+    if (req.query.owner) {
+      query['owner.target'] = new ObjectId(req.query.owner);
     }
 
     if (req.query._id) {
@@ -263,8 +263,10 @@ const controllerFactory = (db) => {
         {
           name: req.body.name,
           status: req.body.status,
+          listing: req.body.listing,
           description: req.body.description,
           price: req.body.price,
+          price_currency: req.body.price_currency,
           sale: req.body.sale,
           category: req.body.category,
           images: req.body.images,

package/src/modules/products/models/category.model.js

@@ -1,75 +1,24 @@
 module.exports = (db) => {
-  const СategorySchema = new db.mongoose.Schema({
-    name: {
-      type: String, 
-      required: true, 
-      trim: true
-    }, 
+  const CategorySchema = new db.mongoose.Schema({
+    name: { type: String, required: true, trim: true },
     status: {
       type: String,
-      enum: ['draft','internal','published','removed'], 
+      enum: ['draft','internal','published','removed'],
       default: 'draft',
       required: true,
     },
-    order: {
-      type: Number, 
-      required: 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,
-    //   },
-    // }
+    order: { type: Number, required: true },
+    url: { type: String, required: true, trim: true },
+    parent: { type: db.mongoose.Schema.Types.ObjectId, ref: 'Category' },
+    localization: { type: Array },
+    filters: { type: Array }
   }, {
-    timestamps: { 
-      currentTime: () => Date.now() 
-    }
+    timestamps: { currentTime: () => Date.now() }
   });
 
-  СategorySchema.index({ 'owner.target': 1, 'creator.target': 1});
-
-  const Сategory = db.mongoose.model('Сategory', СategorySchema, 'categories');
-
-  return Сategory;
-}
+  CategorySchema.index({ parent: 1 });
+  CategorySchema.index({ 'owner.target': 1, 'creator.target': 1});
+  
+  const Category = db.mongoose.model('Category', CategorySchema, 'categories');
+  return Category;
+};

package/src/modules/products/models/product.model.js

@@ -2,7 +2,13 @@ const applyOwnershipSchema = require('@pf/src/modules/globals/models/schemas/own
 
 module.exports = (db) => {
     const ProductSchema = new db.mongoose.Schema({
-        status:         {type: String}, 
+        status: {
+            type: String
+        }, 
+        listing: {
+            type: String,
+            enum: ['sale', 'rent']
+        },
         name:           {type: String}, 
         category:       {type: Array},
         description:    {type: String},
@@ -17,7 +23,13 @@ module.exports = (db) => {
             value: {type: String}
         }],
         // ЗАДАЧА: Нужно отрефачить price, перенести его в default variant
-        price: { type: Number },
+        price: { 
+            type: Number
+        },
+        price_currency: { 
+            type: String,
+            default: '$',
+        },
         prices: { type: Array}, 
         // 
         variants: [{ 
@@ -64,16 +76,7 @@ module.exports = (db) => {
                 min: [0, 'Quantity-based discount cannot be less than 0'],
                 max: [100, 'Quantity-based discount cannot be more than 100']
             },
-        }],
-        // Refactor
-        owner: {
-            type: db.mongoose.Schema.Types.ObjectId,
-            ref: 'User', 
-        },
-        organization: {
-            type: db.mongoose.Schema.Types.ObjectId,
-            ref: 'Organization',
-        },
+        }]
     }, {
         timestamps: { 
             currentTime: () => Date.now() 

package/src/modules/products/products.client.js

@@ -51,7 +51,6 @@ function initializeProducts(app, store, router, options = {}) {
   const routesProducts = createProductRoutes();
   
   router.addRoute(route, routesProducts);
-
   router.addRoute(route, routerMarketplace);
   
   store.addStore('categories', storeCategories);

package/src/modules/products/router/categories.router.js

@@ -2,21 +2,33 @@ import * as validationAuth from '@pf/src/modules/auth/views/middlewares/auth.val
 
 const categoriesRoutes = [{
   path: 'categories',
-  name: 'Categories Organization',
+  name: 'Categories',
   meta: {
     title: {
-      en: 'Category',
-      ru: 'Категория'
+      en: 'Categories',
+      ru: 'Категории'
     }
   },
   component: () => import('@pf/src/modules/products/components/pages/Categories.vue')
 }, {
   path: 'categories/add',
-  name: 'CategoryAdd',
+  name: 'Category Add',
+  meta: {
+    title: {
+      en: 'Add Category',
+      ru: 'Добавить Категорию'
+    }
+  },
   component: () => import('@pf/src/modules/products/components/pages/CategoryEdit.vue')
 },{
   path: 'categories/:category/edit',
-  name: 'CategoryEdit',
+  name: 'Category Edit',
+  meta: {
+    title: {
+      en: 'Edit Category',
+      ru: 'Редактировать Категорию'
+    }
+  },
   beforeEnter: [validationAuth.requiresAuth],
   component: () => import('@pf/src/modules/products/components/pages/CategoryEdit.vue')
 }];  

package/src/modules/products/router/products.router.js

@@ -2,7 +2,6 @@ import * as validationAuth from '@pf/src/modules/auth/views/middlewares/auth.val
 
 import * as auth from '@pf/src/modules/auth/views/store/auth';
 
-import IconPlus from '@pf/src/modules/icons/navigation/IconPlus.vue'
 
 export function createProductRoutes(prefix = '', options = {}) {
   const nameWithPrefix = (name) => prefix ? `${prefix}${name}` : name;
@@ -18,17 +17,6 @@ export function createProductRoutes(prefix = '', options = {}) {
             en: 'Products',
             ru: 'Товары'
           },
-
-          actions: [
-          {
-            component: IconPlus,
-            props: {
-              fill: "rgb(var(--main))" 
-            },
-            condition: () => auth.state.user && auth.state.user._id,
-            action: (router) => router.push({ name: 'ProductAdd' })
-          }
-        ],
           authorize: options.productsAuthorize || []
         },
         component: () => import(/* webpackChunkName: 'Products' */ '@pf/src/modules/products/components/pages/Products.vue'),

package/src/modules/products/routes/categories.routes.js

@@ -7,40 +7,11 @@ module.exports = function(app, db) {
   const controller = controllerFactory(db);
   
   const { verifyCategory } = middlewareFactoryProducts(db);
-  // Get categorys
-  app.get(
-    "/categories",
-    controller.getCategories
-  );
-  app.post(
-    "/categories",
-    controller.updateCategories
-  );
-  // Get category
-  app.get(
-    "/categories/:url",
-    controller.getCategory
-  );
-  // Add category
-  app.post(
-    "/categories/add",
-    [
-      verifyCategory.checkCategoryExistOrNot,
-    ],
-    controller.addCategory
-  );
-  // Update catagory
-  app.post(
-    "/categories/:url",
-    controller.updateCategory
-  );
-  // Delete category
-  app.delete(
-    "/categories/:url",
-    controller.deleteCategory
-  );
 
+  app.get('/api/categories', controller.read);
+  app.post('/api/categories/create', [verifyCategory.checkCategoryExistOrNot], controller.create);
+  app.post('/api/categories/update', controller.update);
+  app.post('/api/categories/delete', controller.delete);
 };
 
-
-
+module.exports.controllerFactory = controllerFactory;