@ozdao/prometheus-framework 0.1.34 → 0.1.35

package/dist/community.server.js

@@ -3,6 +3,7 @@ const _commonjsHelpers = require("./_commonjsHelpers-3b53548e.js");
 require("uuid");
 const require$$0 = require("mongoose");
 const index = require("./index-21dfdbd9.js");
+const metadata_schema = require("./metadata.schema-4f856191.js");
 require("jsonwebtoken");
 require("mongodb");
 async function getBlockedMembers$1(Membership, userId) {
@@ -579,54 +580,18 @@ var reactions_routes = function(app, db) {
     controller.delete
   );
 };
-var blogpost_model = (mongoose) => {
-  const BlogpostSchema = new mongoose.Schema({
-    url: { type: String },
-    name: { type: String },
-    content: { type: Array },
-    views: { type: Number },
-    tags: { type: Array },
-    status: {
+const applyCommonSchema = metadata_schema.common_schema;
+const applyEngagementSchema = metadata_schema.engagement_schema;
+const applyOwnershipSchema = metadata_schema.ownership_schema;
+const applyMetadataSchema = metadata_schema.metadata_schema;
+var blogpost_model = (db) => {
+  const BlogpostSchema = new db.mongoose.Schema({
+    name: {
       type: String,
-      enum: ["draft", "published", "removed"],
-      default: "draft",
       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
-      }
-    },
-    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
-      }
+    content: {
+      type: Array
     }
   }, {
     timestamps: {
@@ -635,7 +600,11 @@ var blogpost_model = (mongoose) => {
   }, {
     strict: false
   });
-  const Blogpost = mongoose.model("Blogpost", BlogpostSchema);
+  applyCommonSchema(BlogpostSchema);
+  applyEngagementSchema(BlogpostSchema, db);
+  applyOwnershipSchema(BlogpostSchema, db);
+  applyMetadataSchema(BlogpostSchema);
+  const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);
   return Blogpost;
 };
 var comment_model = (mongoose) => {

package/dist/community.server.mjs

@@ -2,6 +2,7 @@ import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-83b1d755.mjs";
 import "uuid";
 import require$$0 from "mongoose";
 import { s as server$1 } from "./index-fa8d5df4.mjs";
+import { c as common_schema, e as engagement_schema, o as ownership_schema, m as metadata_schema } from "./metadata.schema-7f36e829.mjs";
 import "jsonwebtoken";
 import "mongodb";
 async function getBlockedMembers$1(Membership, userId) {
@@ -578,54 +579,18 @@ var reactions_routes = function(app, db) {
     controller.delete
   );
 };
-var blogpost_model = (mongoose) => {
-  const BlogpostSchema = new mongoose.Schema({
-    url: { type: String },
-    name: { type: String },
-    content: { type: Array },
-    views: { type: Number },
-    tags: { type: Array },
-    status: {
+const applyCommonSchema = common_schema;
+const applyEngagementSchema = engagement_schema;
+const applyOwnershipSchema = ownership_schema;
+const applyMetadataSchema = metadata_schema;
+var blogpost_model = (db) => {
+  const BlogpostSchema = new db.mongoose.Schema({
+    name: {
       type: String,
-      enum: ["draft", "published", "removed"],
-      default: "draft",
       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
-      }
-    },
-    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
-      }
+    content: {
+      type: Array
     }
   }, {
     timestamps: {
@@ -634,7 +599,11 @@ var blogpost_model = (mongoose) => {
   }, {
     strict: false
   });
-  const Blogpost = mongoose.model("Blogpost", BlogpostSchema);
+  applyCommonSchema(BlogpostSchema);
+  applyEngagementSchema(BlogpostSchema, db);
+  applyOwnershipSchema(BlogpostSchema, db);
+  applyMetadataSchema(BlogpostSchema);
+  const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);
   return Blogpost;
 };
 var comment_model = (mongoose) => {

package/dist/events.server.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const _commonjsHelpers = require("./_commonjsHelpers-3b53548e.js");
 const require$$0 = require("mongoose");
 const index = require("./index-21dfdbd9.js");
+const metadata_schema = require("./metadata.schema-4f856191.js");
 require("jsonwebtoken");
 require("mongodb");
 const ObjectId$1 = require$$0.Types.ObjectId;
@@ -383,8 +384,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);
       const event = await Event.create(req.body);
@@ -634,12 +634,12 @@ var tickets_routes = function(app, db, origins) {
   );
 };
 const tickets_routes$1 = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(tickets_routes);
-var event_model = (mongoose) => {
-  const EventSchema = new mongoose.Schema({
-    url: {
-      type: String,
-      required: true
-    },
+const applyCommonSchema = metadata_schema.common_schema;
+const applyEngagementSchema = metadata_schema.engagement_schema;
+const applyOwnershipSchema = metadata_schema.ownership_schema;
+const applyMetadataSchema = metadata_schema.metadata_schema;
+var event_model = (db) => {
+  const EventSchema = new db.mongoose.Schema({
     cover: {
       type: String
     },
@@ -647,12 +647,6 @@ var event_model = (mongoose) => {
       type: String,
       required: true
     },
-    status: {
-      type: String,
-      enum: ["draft", "published", "removed"],
-      default: "draft",
-      required: true
-    },
     description: {
       type: String,
       required: true
@@ -668,53 +662,25 @@ var event_model = (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: {
       currentTime: () => Date.now()
     }
   });
-  EventSchema.index({ "url": 1, "name": 1, "date.start": 1, "date.end": -1, "tags": 1, "owner.target": 1, "creator.target": 1 });
-  const Event = mongoose.model("Event", EventSchema);
+  EventSchema.index({
+    "name": 1,
+    "date.start": 1,
+    "date.end": -1
+  });
+  applyCommonSchema(EventSchema);
+  applyEngagementSchema(EventSchema, db);
+  applyOwnershipSchema(EventSchema, db);
+  applyMetadataSchema(EventSchema);
+  EventSchema.post("aggregate", async function(docs) {
+    console.log(EventSchema);
+  });
+  const Event = db.mongoose.model("Event", EventSchema);
   return Event;
 };
 const event_model$1 = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(event_model);

package/dist/events.server.mjs

@@ -1,6 +1,7 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-83b1d755.mjs";
 import require$$0 from "mongoose";
 import { s as server$1 } from "./index-fa8d5df4.mjs";
+import { c as common_schema, e as engagement_schema, o as ownership_schema, m as metadata_schema } from "./metadata.schema-7f36e829.mjs";
 import "jsonwebtoken";
 import "mongodb";
 const ObjectId$1 = require$$0.Types.ObjectId;
@@ -381,8 +382,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);
       const event = await Event.create(req.body);
@@ -632,12 +632,12 @@ var tickets_routes = function(app, db, origins) {
   );
 };
 const tickets_routes$1 = /* @__PURE__ */ getDefaultExportFromCjs(tickets_routes);
-var event_model = (mongoose) => {
-  const EventSchema = new mongoose.Schema({
-    url: {
-      type: String,
-      required: true
-    },
+const applyCommonSchema = common_schema;
+const applyEngagementSchema = engagement_schema;
+const applyOwnershipSchema = ownership_schema;
+const applyMetadataSchema = metadata_schema;
+var event_model = (db) => {
+  const EventSchema = new db.mongoose.Schema({
     cover: {
       type: String
     },
@@ -645,12 +645,6 @@ var event_model = (mongoose) => {
       type: String,
       required: true
     },
-    status: {
-      type: String,
-      enum: ["draft", "published", "removed"],
-      default: "draft",
-      required: true
-    },
     description: {
       type: String,
       required: true
@@ -666,53 +660,25 @@ var event_model = (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: {
       currentTime: () => Date.now()
     }
   });
-  EventSchema.index({ "url": 1, "name": 1, "date.start": 1, "date.end": -1, "tags": 1, "owner.target": 1, "creator.target": 1 });
-  const Event = mongoose.model("Event", EventSchema);
+  EventSchema.index({
+    "name": 1,
+    "date.start": 1,
+    "date.end": -1
+  });
+  applyCommonSchema(EventSchema);
+  applyEngagementSchema(EventSchema, db);
+  applyOwnershipSchema(EventSchema, db);
+  applyMetadataSchema(EventSchema);
+  EventSchema.post("aggregate", async function(docs) {
+    console.log(EventSchema);
+  });
+  const Event = db.mongoose.model("Event", EventSchema);
   return Event;
 };
 const event_model$1 = /* @__PURE__ */ getDefaultExportFromCjs(event_model);

package/dist/metadata.schema-4f856191.js

@@ -0,0 +1,85 @@
+"use strict";
+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
+  });
+};
+exports.common_schema = common_schema;
+exports.engagement_schema = engagement_schema;
+exports.metadata_schema = metadata_schema;
+exports.ownership_schema = ownership_schema;

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.35",
   "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/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/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/globals/models/common.schema.js

@@ -1,14 +1,10 @@
-module.exports = (mongoose) => {
-  const CommonSchema = new mongoose.Schema({
+module.exports = function applyCommonSchema(schema,db) {
+  schema.add({
     status: {
       type: String,
       enum: ['draft','published','removed'], 
       default: 'draft',
       required: true,
     },
-  });
-
-  // CommonSchema.index({ user: 1, type: 1, target: 1 });
-
-  return CommonSchema;
+  })
 }

package/src/modules/globals/models/engagement.schema.js

@@ -1,10 +1,32 @@
-module.exports = (db) => {
-  const EngagementSchema = new db.mongoose.Schema({
+module.exports = function applyEngagementSchema(schema,db) {
+  // Добавляем поля
+  schema.add({
     views: { 
       type: Number,
-      default: 0 
-    },
+    default: 0 
+    }
   });
 
-  return EngagementSchema;
-}
+  // Если есть middleware для этой схемы, добавляем его здесь
+  schema.post('aggregate', async function(docs) {
+    
+    // Проверяем, возвращены ли какие-либо документы
+    if (docs.length > 0) {
+      console.log('Post-aggregate hook in engagement schena triggered');
+      try {
+                // Так как мы не можем использовать `this` для обновления внутри агрегации, 
+                // мы должны выполнить обновление вручную для каждого соответствующего документа.
+        await Promise.all(docs.map(async (doc) => {
+                    // Предполагается, что у каждого документа есть уникальный идентификатор '_id'
+          console.log(doc._id)
+          const updatedViews = await db.event.findOneAndUpdate({ _id: doc._id }, { $inc: { views: 1 } }).exec();
+                    // console.log(updatedViews)
+        }));
+      } catch (error) {
+        console.error("Error updating views:", error);
+      }
+    }
+  });
+
+  // Возвращать схему не нужно, так как мы модифицируем её напрямую
+};

package/src/modules/globals/models/metadata.schema.js

@@ -1,5 +1,5 @@
-module.exports = (mongoose) => {
-  const MetadataSchema = new mongoose.Schema({
+module.exports = function applyMetadataSchema(schema,db) {
+  schema.add({
     url: { 
       type: String, 
       required: true 
@@ -7,9 +7,10 @@ module.exports = (mongoose) => {
     tags: [{ 
       type: String 
     }],
-  });
-
-  // MetadataSchema.index({ user: 1, type: 1, target: 1 });
+  })
 
-  return MetadataSchema;
+  schema.index({ 
+    'url': 1, 
+    'tags': 1,
+  });
 }

package/src/modules/globals/models/ownership.schema.js

@@ -1,12 +1,12 @@
-module.exports = (mongoose) => {
-  const OwnershipSchema = new mongoose.Schema({
+module.exports = function applyOwnershipSchema(schema,db) {
+  schema.add({
     owner: {
       type: {
         type: String,
         required: true
       },
       target: {
-        type: mongoose.Schema.Types.ObjectId,
+        type: db.mongoose.Schema.Types.ObjectId,
         refPath: 'owner.type',
         required: true,
       },
@@ -21,14 +21,15 @@ module.exports = (mongoose) => {
         required: true
       },
       target: {
-        type: mongoose.Schema.Types.ObjectId,
+        type: db.mongoose.Schema.Types.ObjectId,
         refPath: 'creator.type',
         required: true,
-      },
+      }
     }
   });
 
-  // OwnershipSchema.index({ user: 1, type: 1, target: 1 });
-
-  return OwnershipSchema;
+  schema.index({ 
+    'owner.target': 1,
+    'creator.target': 1 
+  });
 }

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

@@ -1,76 +0,0 @@
-const CommonSchema = require('@pf/src/modules/globals/models/common.schema.js')
-const EngagementSchema = require('@pf/src/modules/globals/models/engagement.schema.js')
-const OwnershipSchema = require('@pf/src/modules/globals/models/ownership.schema.js')
-const MetadataSchema = require('@pf/src/modules/globals/models/metadata.schema.js')
-
-module.exports = (db) => {
-
-    const EventSchema = new db.mongoose.Schema({
-        ...CommonSchema,
-        ...EngagementSchema,
-        ...OwnershipSchema,
-        ...MetadataSchema,
-        // views: { 
-        //   type: Number,
-        //   default: 0 
-        // },
-        cover: { 
-            type: String, 
-        },
-        name: { 
-            type: String, 
-            required: true 
-        },
-        description: { 
-            type: String, 
-            required: true 
-        },
-        
-        content: { 
-            type: Array 
-        },
-        date: {
-            start: { 
-                type: Date, 
-                required: true 
-            },
-            end: { 
-                type: Date, 
-            }
-        },
-    }, {
-        timestamps: { 
-            currentTime: () => Date.now() 
-        }
-    });
-
-    EventSchema.index({ 'url': 1, 'name': 1, 'date.start': 1, 'date.end': -1, 'tags': 1, 'owner.target': 1, 'creator.target': 1 });
-
-    EventSchema.post('aggregate', async function(docs) {
-
-    console.log(EventSchema)
-
-        // Проверяем, возвращены ли какие-либо документы
-        if (docs.length > 0) {
-            console.log('Post-aggregate hook triggered');
-            // console.log(docs)
-            try {
-                // Так как мы не можем использовать `this` для обновления внутри агрегации, 
-                // мы должны выполнить обновление вручную для каждого соответствующего документа.
-                await Promise.all(docs.map(async (doc) => {
-                    // Предполагается, что у каждого документа есть уникальный идентификатор '_id'
-                    console.log(doc._id)
-                    const updatedViews = await db.event.findOneAndUpdate({ _id: doc._id }, { $inc: { views: 1 } }).exec();
-                    // console.log(updatedViews)
-                }));
-            } catch (error) {
-                console.error("Error updating views:", error);
-            }
-        }
-    });
-
-    const Event = db.mongoose.model("Event", EventSchema);
-
-    return Event;
-};
-