@ozdao/prometheus-framework 0.1.35 → 0.1.37

package/src/modules/backoffice/router/backoffice.js

@@ -8,7 +8,7 @@ const backofficeRoutes = [{
     validationAuth.requiresAdmin,
   ],
   children: [{
-    path: ':_id',
+    path: '',
     name: 'Backoffice',
     meta: {
       title: {
@@ -19,7 +19,7 @@ const backofficeRoutes = [{
     },
     component: () => import(/* webpackChunkName: 'BackofficeGallery' */ '../components/pages/Dashboard.vue'),
   },{
-    path: ':_id/gallery',
+    path: 'gallery',
     name: 'Backoffice Gallery',
     meta: {
       title: {
@@ -30,16 +30,143 @@ const backofficeRoutes = [{
     },
     component: () => import(/* webpackChunkName: 'BackofficeGallery' */ '@pf/src/modules/gallery/components/sections/BackofficeGallery.vue'),
   },{
-    path: ':_id/reports',
+    path: 'reports',
     name: 'Backoffice Reports',
     meta: {
       title: {
         en: 'Backoffice Reports',
         ru: 'Управление Жалобами'
       },
-      authorize: []
     },
     component: () => import(/* webpackChunkName: 'BackofficeGallery' */ '@pf/src/modules/reports/components/pages/BackofficeReports.vue'),
+  },{
+    path: 'organizations',
+    name: 'Backoffice Organizations',
+    meta: {
+      title: {
+        en: 'Backoffice Organizations',
+        ru: 'Управление Организациями'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficeOrganizations' */ '@pf/src/modules/organizations/components/pages/Organizations.vue'),
+  },{
+    path: 'events',
+    name: 'Backoffice Events',
+    meta: {
+      title: {
+        en: 'Backoffice Events',
+        ru: 'Управление Событиями'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficeEvents' */ '@pf/src/modules/events/components/pages/Events.vue'),
+  },{
+    path: 'community',
+    name: 'Backoffice Community',
+    meta: {
+      title: {
+        en: 'Backoffice Community',
+        ru: 'Управление Сообществом'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficeCommunity' */ '@pf/src/modules/community/components/pages/Community.vue'),
+  },{
+    path: 'products',
+    name: 'Backoffice Products',
+    meta: {
+      title: {
+        en: 'Backoffice Products',
+        ru: 'Управление Продуктами'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficeProducts' */ '@pf/src/modules/products/components/pages/ProductsBackoffice.vue'),
+  },{
+    path: 'products/add',
+    name: 'AddProduct',
+    component: () => import('@pf/src/modules/products/components/pages/ProductEdit.vue')
+  },{
+    path: 'products/:product',
+    name: 'Product Backofffice',
+    meta: {
+      title: {
+        en: 'Product',
+        ru: 'Продукт'
+      }
+    },
+    component: () => import('@pf/src/modules/products/components/pages/Product.vue')
+  }, {
+    path: 'products/:product/edit',
+    name: 'ProductEdit',
+    beforeEnter: [validationAuth.requiresAuth],
+    component: () => import('@pf/src/modules/products/components/pages/ProductEdit.vue')
+  },{
+    path: 'leftovers',
+    name: 'Backoffice Leftovers',
+    meta: {
+      title: {
+        en: 'Backoffice Leftovers',
+        ru: 'Управление Остатками'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficeLeftovers' */ '@pf/src/modules/products/components/pages/Leftovers.vue'),
+},{
+    path: 'leftovers/add',
+    name: 'LeftoverAdd',
+    meta: {
+      title: {
+        en: 'Backoffice Leftovers',
+        ru: 'Управление Остатками'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'LeftoverEdit' */ '@pf/src/modules/products/components/pages/LeftoverAdd.vue')
+  },
+  {
+    path: 'leftovers/:_id',
+    name: 'LeftoverEdit',
+    meta: {
+      title: {
+        en: 'Backoffice Leftovers',
+        ru: 'Управление Остатками'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'LeftoverEdit' */ '@pf/src/modules/products/components/pages/LeftoverAdd.vue')
+  },
+  {
+    path: 'orders',
+    name: 'Backoffice Orders',
+    meta: {
+      title: {
+        en: 'Backoffice Orders',
+        ru: 'Управление Заказами'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficeOrders' */ '@pf/src/modules/orders/components/pages/Orders.vue'),
+  },{
+    path: 'orders/add',
+    name: 'AdminOrder',
+    component: () => import(/* webpackChunkName: 'AdminOrders' */ '@pf/src/modules/orders/components/pages/EditOrder.vue')
+  },{
+    path: 'orders/:_id',
+    name: 'AdminOrderEdit',
+    component: () => import(/* webpackChunkName: 'AdminOrders' */ '@pf/src/modules/orders/components/pages/EditOrder.vue')
+  },{
+    path: 'payments',
+    name: 'Backoffice Payments',
+    meta: {
+      title: {
+        en: 'Backoffice Payments',
+        ru: 'Управление Платежами'
+      },
+      authorize: []
+    },
+    component: () => import(/* webpackChunkName: 'BackofficePayments' */ '@pf/src/modules/payments/components/pages/Payments.vue'),
   }]
 }];
 

package/src/modules/community/components/blocks/CardBlogpost.vue

@@ -88,7 +88,7 @@
 
 
 <script setup="props">
-	import CardHeader  from '@pf/src/components/CardHeader/CardHeader.vue'
+	import CardHeader  from '@pf/src/modules/globals/components/blocks/CardHeader.vue'
 	import FooterBlogpost  from '@pf/src/modules/community/components/blocks/FooterBlogpost.vue'	
 
 	import Chips  from '@pf/src/components/Chips/Chips.vue'

package/src/modules/community/components/pages/Blog.vue

@@ -4,6 +4,7 @@
       :category="route.params.category" 
       :user="auth.state.user._id"
       :period="route.query.period"
+      :following="route.params.category === 'following' ? auth.state.user._id : null"
     />
   </section>
 </template>

package/src/modules/community/components/sections/Comments.vue

@@ -37,7 +37,7 @@
 import { ref } from 'vue';
 import axios from 'axios';
 
-import CardHeader  from '@pf/src/components/CardHeader/CardHeader.vue'
+import CardHeader  from '@pf/src/modules/globals/components/blocks/CardHeader.vue'
 
 const props = defineProps(['target', 'owner', 'type'])
 

package/src/modules/community/components/sections/Feed.vue

@@ -69,6 +69,10 @@
       type: String,
       default: null
     },
+    following: {
+      type: String,
+      default: null
+    },
     status: {
       type: String,
       default: 'published'
@@ -100,6 +104,7 @@
         category: props.category,
         user: props.user,
         owner: props.owner,
+        following: props.following,
         creator: props.creator,
         status: props.status,
         period: props.period,
@@ -120,6 +125,7 @@
       category: props.category,
       user: props.user,
       owner: props.owner,
+      following: props.following,
       status: props.status,
       creator: props.creator,
       period: props.period,

package/src/modules/community/controllers/blog.controller.js

@@ -1,296 +1,140 @@
-const { getBlockedMembers, addConditionsForBlocked } = require('@pf/src/modules/organizations/controllers/utils/excludeBlockedMembers');
+// Query Processor
+const queryProcessor = require('./utils/queryProcessor');
+const queryProcessorReactions = require('@pf/src/modules/community/controllers/utils/queryProcessorReactions');
+const queryProcessorOrganizations = require('@pf/src/modules/organizations/controllers/utils/queryProcessor');
+const queryProcessorGlobals = require('@pf/src/modules/globals/controllers/utils/queryProcessor');
 
+const util = require('util');
 const controllerFactory = (db) => {
-  const Blogpost = db.blogpost;
-  const Organization = db.organization;
-  const Membership = db.membership;
-
-  const read = async (req, res) => {
-    let query = [];
-    let matchStage = {};
-
-
-    const options = {
-      skip: parseInt(req.query.skip) || 0,
-      limit: parseInt(req.query.limit) || 20
-    };
-
-    if (req.query.url) {
-      matchStage["url"] = req.query.url;
-
-      await Blogpost.findOneAndUpdate({ url: req.query.url }, { $inc: { views: 1 }}, { new: true })
-    }
-
-    if (req.query.status) {
-      matchStage["status"] = req.query.status;
-    }
-
-    if (req.query.owner) {
-      matchStage["owner.target"] = new db.mongoose.Types.ObjectId(req.query.owner);
-    }
-
-    if (req.query.creator) {
-      matchStage["creator.target"] = new db.mongoose.Types.ObjectId(req.query.creator);
-    }
-
-    // EXCLUDE USERS AND ORGS BLOCKED BY USER
-    if (req.query.user) {
-      const blockedMembers = await getBlockedMembers(Membership, req.query.user);
-
-      console.log(blockedMembers);
-
-      if (blockedMembers.length > 0) {
-          addConditionsForBlocked(matchStage, "owner.target", blockedMembers);
-          addConditionsForBlocked(matchStage, "creator.target", blockedMembers);
-      }
-    }
-    
-    if (req.query.tags) {
-      matchStage["tags"] = { $in: req.query.tags.split(',') };
-    }
-
-    if (req.query.period) {
-        const date = new Date();
-        
-        switch (req.query.period) {
-          case 'today':
-            date.setDate(date.getDate() - 1);
-            break;
-          case 'week':
-            date.setDate(date.getDate() - 7);
-            break;
-          case 'month':
-            date.setMonth(date.getMonth() - 1);
-            break;
-          case 'year':
-            date.setFullYear(date.getFullYear() - 1);
-            break;
-        }
-        matchStage["createdAt"] = { $gte: date };
-    }
-
-
-
-    // FILTER BY CATEGORY
-    if (req.query.category) {
-        switch (req.query.category) {
-          case 'featured':
-            matchStage["tags"] = { $in: ["Featured"] };
-            break;
-          case 'popular':
-            query.push({ $sort: { views: -1, likes: -1 } });
-            break;
-          case 'new':
-            query.push({ $sort: { createdAt: -1 } });
-            break;
-          case 'following':
-            if (req.query.user) { 
-               const memberships = await Membership.find({ user: req.query.user });
-                const followedOrganizations = memberships.filter(membership => membership.type === 'organization').map(membership => membership.target);
-                const followedAuthors = memberships.filter(membership => membership.type === 'user').map(membership => membership.target);
-
-                matchStage["$or"] = [
-                    { "owner.target": { $in: followedOrganizations } },
-                    { "owner.target": { $in: followedAuthors } }
-                ];
-            }
-            break;
-        }
-    }
-
-
-
-
-    query.push({ $match: matchStage });
-
-
-    query.push({
-      $lookup: {
-          from: "comments",
-          localField: "_id",
-          foreignField: "target",
-          as: "comments"
-      }
-	  });
-
-	  query.push({
-	      $lookup: {
-	          from: "reactions",
-	          localField: "_id",
-	          foreignField: "target",
-	          as: "reactions"
-	      }
-	  });
-
-	  query.push({
-	      $addFields: {
-	          numberOfComments: { $size: "$comments" },
-	          numberOfReactions: { $size: "$reactions" },
-	          isReacted: {
-	              $in: [
-	                  new db.mongoose.Types.ObjectId(req.query.user),
-	                  "$reactions.user"
-	              ]
-	          },
-            reactionId: {
-              $let: {
-                  vars: {
-                      reactionIndex: {
-                          $indexOfArray: [
-                              "$reactions.user",
-                              new db.mongoose.Types.ObjectId(req.query.user)
-                          ]
-                      }
-                  },
-                  in: {
-                      $cond: [
-                          { $gte: ["$$reactionIndex", 0] },
-                          { $arrayElemAt: ["$reactions._id", "$$reactionIndex"] },
-                          null
-                      ]
-                  }
-              }
-          }
-	      }
-	  });
-
-	  query.push({
-      $lookup: {
-        from: "users",
-        localField: "creator.target",
-        foreignField: "_id",
-        as: "creatorUser"
-      }
-    },
-    {
-      $lookup: {
-        from: "organizations",
-        localField: "creator.target",
-        foreignField: "_id",
-        as: "creatorOrganization"
-      }
-    },
-    // Для owner
-    {
-      $lookup: {
-        from: "users",
-        localField: "owner.target",
-        foreignField: "_id",
-        as: "ownerUser"
-      }
-    },
-    {
-      $lookup: {
-        from: "organizations",
-        localField: "owner.target",
-        foreignField: "_id",
-        as: "ownerOrganization"
-      }
-    },
-    {
-      $addFields: {
-        "creator.target": {
-          $cond: [
-            { $eq: ["$creator.type", "user"] },
-            { $arrayElemAt: ["$creatorUser", 0] },
-            { $arrayElemAt: ["$creatorOrganization", 0] }
-          ]
-        },
-        "owner.target": {
-          $cond: [
-            { $eq: ["$owner.type", "user"] },
-            { $arrayElemAt: ["$ownerUser", 0] },
-            { $arrayElemAt: ["$ownerOrganization", 0] }
-          ]
-        }
-      }
-    })
-
-    query.push({
-      $project: {
-          comments: 0,
-          reactions: 0
-      }
-	  });
-
-    query.push({ $skip: options.skip });
-    query.push({ $limit: options.limit });
-   
-    try {
-        const posts = await Blogpost.aggregate(query).exec();
-
-        if (posts.length === 0) {
-          return res.status(200).send([]);
-            //  return res.status(404).send({ message: "Posts not found." });
-        }
-
-        console.log(posts)
-
-        res.status(200).send(posts);
-    } catch (err) {
-        console.log(err);
-        res.status(500).send({ err });
-    }
+	const Blogpost = db.blogpost;
+	const Organization = db.organization;
+	const Membership = db.membership;
+
+	const read = async (req, res) => {
+
+		let stages = [];
+
+		stages = [
+			...queryProcessorGlobals.getBasicOptions(
+				req.query
+			),
+			...queryProcessorGlobals.getTagsOptions(
+				req.query.tags
+			), 
+			...queryProcessor.getPeriodConditions(
+				req.query.period
+			),
+			...await queryProcessor.getCategoryConditions(
+				req.query.category
+			),
+			// Following
+			...(await queryProcessorOrganizations.getFollowingStage(
+				Membership,
+				req.query.following
+			)),
+			// Blocking
+			...await queryProcessorOrganizations.getBlockedStage(
+				Membership,
+				req.query.user
+			),
+			queryProcessorReactions.getCommentsLookupStage(),
+			queryProcessorReactions.getReactionsLookupStage(),
+			queryProcessorReactions.getReactionsCommentsFields(
+				req.query.user
+			),
+			// Sorting and Pagination
+			...queryProcessorGlobals.getSortingOptions(
+		    	req.query.sortParam,
+		    	req.query.sortOrder,
+		    ),
+			...queryProcessorGlobals.getPaginationOptions(
+				req.query.skip,
+		        req.query.limit
+			),
+			// For creator
+			queryProcessorGlobals.getCreatorUserLookupStage(),
+			queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+			// For owner
+			queryProcessorGlobals.getOwnerUserLookupStage(),
+			queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+			queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+		]
+
+		try {
+			console.log(stages)
+			const posts = await Blogpost.aggregate(stages).exec();
+
+			if (posts.length === 0) {
+				return res.status(200).send([]);
+			}
+
+			// console.log(posts)
+
+			res.status(200).send(posts);
+		} catch (err) {
+			console.log(err);
+			res.status(500).send({ err });
+		}
 	};
 
 
-  const create = (req, res) => {
-    let user = JSON.parse(req.cookies.user);
-
-    const newBlogpost = {
-      url: req.body.name.toLowerCase().replace(/ /g, '-').replace(/[^\w-]+/g, ''),
-      name: req.body.name,
-      status: req.body.status,
-      tags: req.body.tags ? req.body.tags : ['All'],
-      owner: req.body.owner,
-      creator: req.body.creator,
-      content: req.body.content,
-      views: 1
-    };
-
-    Blogpost.create(newBlogpost)
-      .then((post) => {
-        res.status(200).send(post);
-      })
-      .catch((err) => {
-        res.status(500).send({ message: err.message || "Some error occurred while creating the blogpost." });
-      });
-  };
+	const create = (req, res) => {
+		let user = JSON.parse(req.cookies.user);
+
+		const newBlogpost = {
+			url: req.body.name.toLowerCase().replace(/ /g, '-').replace(/[^\w-]+/g, ''),
+			name: req.body.name,
+			status: req.body.status,
+			tags: req.body.tags ? req.body.tags : ['All'],
+			owner: req.body.owner,
+			creator: req.body.creator,
+			content: req.body.content,
+			views: 1
+		};
+
+		Blogpost.create(newBlogpost)
+			.then((post) => {
+				res.status(200).send(post);
+			})
+			.catch((err) => {
+				res.status(500).send({ message: err.message || "Some error occurred while creating the blogpost." });
+			});
+	};
 
-  const update = (req, res) => {
-    Blogpost.findOneAndUpdate({ _id: req.body._id }, { $set: req.body }, { new: true })
-      .exec()
-      .then((post) => {
-        if (!post) {
-          return res.status(404).send({ message: "Something wrong when updating the blogpost." });
-        }
-        res.status(200).send(post);
-      })
-      .catch((err) => {
-        res.status(500).send({ message: err.message || "Some error occurred while updating the blogpost." });
-      });
-  };
+	const update = (req, res) => {
+		Blogpost.findOneAndUpdate({ _id: req.body._id }, { $set: req.body }, { new: true })
+			.exec()
+			.then((post) => {
+				if (!post) {
+					return res.status(404).send({ message: "Something wrong when updating the blogpost." });
+				}
+				res.status(200).send(post);
+			})
+			.catch((err) => {
+				res.status(500).send({ message: err.message || "Some error occurred while updating the blogpost." });
+			});
+	};
 
-  const del = (req, res) => {
-    Blogpost.findOneAndDelete({ _id: req.params._id })
-      .exec()
-      .then((post) => {
-        if (!post) {
-          return res.status(404).send({ message: "The blogpost is not deleted." });
-        }
-        res.status(200).send(post);
-      })
-      .catch((err) => {
-        res.status(500).send({ message: err.message || "Some error occurred while deleting the blogpost." });
-      });
-  };
+	const del = (req, res) => {
+		Blogpost.findOneAndDelete({ _id: req.params._id })
+			.exec()
+			.then((post) => {
+				if (!post) {
+					return res.status(404).send({ message: "The blogpost is not deleted." });
+				}
+				res.status(200).send(post);
+			})
+			.catch((err) => {
+				res.status(500).send({ message: err.message || "Some error occurred while deleting the blogpost." });
+			});
+	};
 
-  return {
-    read,
-    create,
-    update,
-    delete: del
-  };
+	return {
+		read,
+		create,
+		update,
+		delete: del
+	};
 };
 
 module.exports = controllerFactory;

package/src/modules/community/controllers/reactions.controller.js

@@ -26,9 +26,11 @@ const reactionControllerFactory = (db) => {
 
     try {
       const reactions = await Reaction.find(query, null, options).populate('user');
+
       if (!reactions) {
         return res.status(404).send({ errorCode: "REACTIONS_NOT_FOUND" });
       }
+      
       res.send(reactions);
     } catch (err) {
       res.status(500).send({ errorCode: "SERVER_ERROR" });