@ozdao/prometheus-framework 0.1.34 → 0.1.36

package/dist/metadata.schema-7f36e829.mjs

@@ -0,0 +1,86 @@
+var common_schema = function applyCommonSchema(schema, db) {
+  schema.add({
+    status: {
+      type: String,
+      enum: ["draft", "published", "removed"],
+      default: "draft",
+      required: true
+    }
+  });
+};
+var engagement_schema = function applyEngagementSchema(schema, db) {
+  schema.add({
+    views: {
+      type: Number,
+      default: 0
+    }
+  });
+  schema.post("aggregate", async function(docs) {
+    if (docs.length > 0) {
+      console.log("Post-aggregate hook in engagement schena triggered");
+      try {
+        await Promise.all(docs.map(async (doc) => {
+          console.log(doc._id);
+          const updatedViews = await db.event.findOneAndUpdate({ _id: doc._id }, { $inc: { views: 1 } }).exec();
+        }));
+      } catch (error) {
+        console.error("Error updating views:", error);
+      }
+    }
+  });
+};
+var ownership_schema = function applyOwnershipSchema(schema, db) {
+  schema.add({
+    owner: {
+      type: {
+        type: String,
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        refPath: "owner.type",
+        required: true
+      }
+    },
+    creator: {
+      hidden: {
+        type: Boolean,
+        required: true
+      },
+      type: {
+        type: String,
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        refPath: "creator.type",
+        required: true
+      }
+    }
+  });
+  schema.index({
+    "owner.target": 1,
+    "creator.target": 1
+  });
+};
+var metadata_schema = function applyMetadataSchema(schema, db) {
+  schema.add({
+    url: {
+      type: String,
+      required: true
+    },
+    tags: [{
+      type: String
+    }]
+  });
+  schema.index({
+    "url": 1,
+    "tags": 1
+  });
+};
+export {
+  common_schema as c,
+  engagement_schema as e,
+  metadata_schema as m,
+  ownership_schema as o
+};

package/package.json

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

package/src/modules/auth/routes/auth.routes.js

@@ -4,7 +4,7 @@ const controllerFactoryTwofa = require("../controllers/twofa.controller");
 // Middlewares
 const middlewareFactory = require('@pf/src/modules/middlewares/server');
 // Routes
-module.exports = function(app, db) {
+module.exports = function(app, db, origins) {
   const controller = controllerFactory(db);
   const controllerTwofa = controllerFactoryTwofa(db);
 
@@ -12,11 +12,14 @@ module.exports = function(app, db) {
 
   app.use(function(req, res, next) {
     
-    res.header(
-      "Access-Control-Allow-Headers",
-      "Access-Control-Allow-Origin",
-      "x-access-token, Origin, Content-Type, Accept"
-    );
+    const origin = req.headers.origin;
+
+    if (origins.includes(origin)) {
+      res.setHeader('Access-Control-Allow-Origin', origin);
+    }
+
+    res.header("Access-Control-Allow-Headers", "x-access-token, Origin, Content-Type, Accept");
+
     next();
   });
   

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

@@ -0,0 +1,290 @@
+// Query Processor
+const queryProcessor = require('./utils/queryProcessor');
+const queryProcessorGlobals = require('@pf/src/modules/globals/controllers/utils/queryProcessor');
+// Utils
+const { getBlockedMembers, addConditionsForBlocked } = require('@pf/src/modules/organizations/controllers/utils/excludeBlockedMembers');
+
+const controllerFactory = (db) => {
+  const Blogpost = db.blogpost;
+  const Organization = db.organization;
+  const Membership = db.membership;
+
+  const read = async (req, res) => {
+
+    let stages = [];
+
+    stages = [
+      ...queryProcessorGlobals.getBasicOptions(
+        req.query
+      ), 
+      // Pagination
+      ...queryProcessorGlobals.getSortingOptions(
+        req.query
+      ),
+      ...queryProcessorGlobals.getPaginationOptions(
+        req.query
+      )
+    ]
+
+    let query = [];
+    let matchStage = {};
+
+
+    if (req.query.status) {
+      matchStage["status"] = req.query.status;
+    }
+
+    // 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
+      }
+	  });
+   
+    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 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 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
+  };
+};
+
+module.exports = controllerFactory;

package/src/modules/community/models/blogpost.model.js

@@ -1,48 +1,17 @@
-module.exports = (mongoose) => {
-    const BlogpostSchema = new mongoose.Schema({
-        url:        { type: String },
-        name:       { type: String },
-        content:    { type: Array  },
-        views:      { type: Number },
-        tags:       { type: Array  },
-        status: {
-            type: String,
-            enum: ['draft','published','removed'], 
-            default: 'draft',
-            required: true,
+const applyCommonSchema = require('@pf/src/modules/globals/models/common.schema.js');
+const applyEngagementSchema = require('@pf/src/modules/globals/models/engagement.schema.js');
+const applyOwnershipSchema = require('@pf/src/modules/globals/models/ownership.schema.js');
+const applyMetadataSchema = require('@pf/src/modules/globals/models/metadata.schema.js');
+
+module.exports = (db) => {
+    const BlogpostSchema = new db.mongoose.Schema({
+        name: { 
+            type: String, 
+            required: true 
         },
-        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,
-            },
+        content: { 
+            type: Array 
         },
-        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() 
@@ -51,7 +20,12 @@ module.exports = (mongoose) => {
         strict: false
     });
 
-    const Blogpost = mongoose.model("Blogpost", BlogpostSchema);
+    applyCommonSchema(BlogpostSchema,db);
+    applyEngagementSchema(BlogpostSchema,db);
+    applyOwnershipSchema(BlogpostSchema,db);
+    applyMetadataSchema(BlogpostSchema,db);
+
+    const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);
 
     return Blogpost;
 };

package/src/modules/community/routes/blog.routes.js

@@ -3,18 +3,22 @@ const controllerFactory = require("../controllers/blog.controller");
 const middlewareFactoryGlobal = require('@pf/src/modules/middlewares/server');
 const middlewareFactoryCommunity = require('../middlewares/server');
 
-module.exports = function(app, db) {
+module.exports = function(app, db, origins) {
   const controller = controllerFactory(db);
 
   const { authJwt } = middlewareFactoryGlobal(db);
   const { verifyBlogpost } = middlewareFactoryCommunity(db);
 
   app.use(function(req, res, next) {
-    res.header(
-      "Access-Control-Allow-Headers",
-      "Access-Control-Allow-Origin",
-      "x-access-token, Origin, Content-Type, Accept"
-    );
+    
+    const origin = req.headers.origin;
+
+    if (origins.includes(origin)) {
+      res.setHeader('Access-Control-Allow-Origin', origin);
+    }
+
+    res.header("Access-Control-Allow-Headers", "x-access-token, Origin, Content-Type, Accept");
+
     next();
   });
 

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

@@ -61,6 +61,7 @@ const middlewareFactory = (db) => {
     try {
       const events = await Event.aggregate(stages).exec();
       res.status(200).send(events);
+
     } catch (err) {
       console.log(err);
       return res.status(500).send({ message: err });
@@ -69,7 +70,7 @@ const middlewareFactory = (db) => {
 
 
   const create = async (req, res) => {
-    if (req.body._id) delete req.body._id;
+    delete req.body._id;
 
     try {
       req.body.url = createFriendlyURL(req.body.name);

package/src/modules/events/middlewares/server/verifyEvent.js

@@ -23,10 +23,12 @@ const middlewareFactory = (db) => {
       // Обновление события
       const updatingEventId = req.body._id;  // Изменено с updatingBlogpostId на updatingEventId
       const existingEvent = await Event.findById(updatingEventId);  // Изменено с Blogpost на Event и с existingBlogpost на existingEvent
+      
       if (!existingEvent) {  // Изменено с existingBlogpost на existingEvent
         res.status(404).send({ errorCode: 'EVENT_NOT_FOUND', accessToken: null });  // Изменено с BLOGPOST_NOT_FOUND на EVENT_NOT_FOUND
         return;
       }
+      
       if (existingEvent.url !== url) {  // Изменено с existingBlogpost на existingEvent
         const event = await Event.findOne({ url });  // Изменено с Blogpost на Event и с blogpost на event
         if (event) {  // Изменено с blogpost на event

package/src/modules/events/models/event.model.js

@@ -1,9 +1,11 @@
-module.exports = (mongoose) => {
-    const EventSchema = new mongoose.Schema({
-        url: { 
-            type: String, 
-            required: true 
-        },
+const applyCommonSchema = require('@pf/src/modules/globals/models/common.schema.js');
+const applyEngagementSchema = require('@pf/src/modules/globals/models/engagement.schema.js');
+const applyOwnershipSchema = require('@pf/src/modules/globals/models/ownership.schema.js');
+const applyMetadataSchema = require('@pf/src/modules/globals/models/metadata.schema.js');
+
+module.exports = (db) => {
+
+    const EventSchema = new db.mongoose.Schema({
         cover: { 
             type: String, 
         },
@@ -11,12 +13,6 @@ module.exports = (mongoose) => {
             type: String, 
             required: true 
         },
-        status: {
-            type: String,
-            enum: ['draft','published','removed'], 
-            default: 'draft',
-            required: true,
-        },
         description: { 
             type: String, 
             required: true 
@@ -32,41 +28,6 @@ module.exports = (mongoose) => {
             end: { 
                 type: Date, 
             }
-        },
-        tags: [{ 
-            type: String 
-        }],
-        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: { 
@@ -74,9 +35,23 @@ module.exports = (mongoose) => {
         }
     });
 
-    EventSchema.index({ 'url': 1, 'name': 1, 'date.start': 1, 'date.end': -1, 'tags': 1, 'owner.target': 1, 'creator.target': 1 });
+    EventSchema.index({ 
+        'name': 1,
+        'date.start': 1,
+        'date.end': -1,
+    });
 
-    const Event = mongoose.model("Event", EventSchema);
+    applyCommonSchema(EventSchema,db);
+    applyEngagementSchema(EventSchema,db);
+    applyOwnershipSchema(EventSchema,db);
+    applyMetadataSchema(EventSchema,db);
+
+    EventSchema.post('aggregate', async function(docs) {
+        console.log(EventSchema)
+    });
+
+    const Event = db.mongoose.model("Event", EventSchema);
 
     return Event;
-};
+};
+

package/src/modules/events/routes/events.routes.js

@@ -4,7 +4,7 @@ const controllerFactory = require("../controllers/events.controller");
 const middlewareFactoryGlobal = require('@pf/src/modules/middlewares/server');
 const middlewareFactoryEvents = require('../middlewares/server');
 // Routes
-module.exports = function(app, db) {
+module.exports = function(app, db, origins) {
   const controller = controllerFactory(db);
 
   const { authJwt } = middlewareFactoryGlobal(db);
@@ -12,11 +12,14 @@ module.exports = function(app, db) {
 
   app.use(function(req, res, next) {
     
-    res.header(
-      "Access-Control-Allow-Headers",
-      "Access-Control-Allow-Origin",
-      "x-access-token, Origin, Content-Type, Accept"
-    );
+    const origin = req.headers.origin;
+
+    if (origins.includes(origin)) {
+      res.setHeader('Access-Control-Allow-Origin', origin);
+    }
+
+    res.header("Access-Control-Allow-Headers", "x-access-token, Origin, Content-Type, Accept");
+
     next();
   });