@ozdao/prometheus-framework 0.2.81 → 0.2.83

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

@@ -13,16 +13,45 @@ const controllerFactory = (db) => {
     let skip = parseInt(req.query.skip) || 0;
     let limit = parseInt(req.query.limit) || 10;
 
+    console.log(req.query)
+
+
     const matchConditions = [
       ...(req.query._id ? [{ _id: new ObjectId(req.query._id) }] : []),
     ];
 
+    let search = req.query.search;
+
+    if (search) {
+      let regexPattern = '';
+
+      // Экранирование специальных символов в строке поиска
+      const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+      // Проверка, является ли строка поиска потенциальным email
+      if (escapedSearch.includes('@')) {
+        regexPattern = escapedSearch;
+      }
+      // Проверка, является ли строка поиска потенциальным телефонным номером
+      else if (escapedSearch.match(/^\+?\d{0,14}$/)) {
+        regexPattern = escapedSearch;
+      }
+      // Иначе, предполагаем, что это имя или username
+      else {
+        regexPattern = `.*${escapedSearch}.*`;
+      }
 
-    query.push({ $match: { $and: matchConditions } });
+      matchConditions.push({
+        $or: [
+          { "profile.name": { $regex: regexPattern, $options: 'i' } },
+          { "email": { $regex: regexPattern, $options: 'i' } },
+          { "phone": { $regex: regexPattern, $options: 'i' } },
+          { "username": { $regex: regexPattern, $options: 'i' } }
+        ]
+      });
+    }
 
-    console.log(req)
-    console.log(query)
-    console.log(req.body)
+    if (matchConditions.length > 0) query.push({ $match: { $and: matchConditions } });
 
     query.push({
       $lookup: {
@@ -53,7 +82,7 @@ const controllerFactory = (db) => {
 
  
     query.push(addMembersQuantity());
-    query.push(addUserStatusFields(req.query.user));
+    if (req.query.user) query.push(addUserStatusFields(req.query.user));
 
     query.push({
       $skip: skip
@@ -63,19 +92,13 @@ const controllerFactory = (db) => {
       $limit: limit
     });
 
-    console.log(req)
-    console.log(query)
-    console.log(req.body)
-
     try {
       const users = await User.aggregate(query);
-      if (!users || users.length === 0) {
-        console.log('no users')
+
+      if (!users) {
         return res.status(404).send({ message: "Users not found." });
       }
 
-      console.log(users)
-
       res.status(200).send(users);
     } catch (err) {
       console.log(err)

package/src/modules/users/middlewares/visitor.logger.js

@@ -0,0 +1,66 @@
+const crypto = require('crypto');
+
+const fingerprintCache = new Map();
+
+const generateFingerprint = (req) => {
+  const { ip, headers } = req;
+  const userAgent = headers['user-agent'];
+  const acceptLanguage = headers['accept-language'];
+  const key = `${ip}-${userAgent}-${acceptLanguage}`;
+
+  if (fingerprintCache.has(key)) {
+    return fingerprintCache.get(key);
+  }
+
+  const hash = crypto.createHash('sha256');
+  hash.update(key);
+  const digest = hash.digest('hex');
+  fingerprintCache.set(key, digest);
+  return digest;
+};
+
+const modelsFactory = (db) => {
+  const Visitor = db.visitor;
+  const Request = db.request;
+
+  const visitorLogger = async (req, res, next) => {
+    const fingerprint = generateFingerprint(req);
+
+    try {
+      // Check if the visitor already exists
+      let visitor = await Visitor.findOne({ fingerprint: fingerprint });
+
+      // If visitor does not exist, create a new one
+      if (!visitor) {
+        visitor = new Visitor({
+          ip: req.ip,
+          userAgent: req.headers['user-agent'],
+          acceptLanguage: req.headers['accept-language'],
+          fingerprint: fingerprint
+        });
+        await visitor.save();
+      }
+
+      // Log the request in a separate model
+      const newRequest = new Request({
+        visitor: visitor._id,
+        path: req.path,
+        method: req.method,
+        timestamp: new Date()
+      });
+
+      await newRequest.save();
+
+      next();
+    } catch (error) {
+      console.error('Error processing visitor and request data:', error);
+      next();
+    }
+  }
+
+  return {
+    visitorLogger
+  }
+}
+
+module.exports = modelsFactory;

package/src/modules/users/models/request.model.js

@@ -0,0 +1,18 @@
+module.exports = (db) => {
+
+  const RequestSchema = new db.mongoose.Schema({
+    visitor: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Visitor"
+    },
+    path: String,
+    method: String,
+    timestamp: { type: Date, default: Date.now }
+  });
+
+  RequestSchema.index({ visitor: 1 });
+
+  const Request = db.mongoose.model("Request", RequestSchema);
+
+  return Request;
+}

package/src/modules/users/models/user.model.js

@@ -1,71 +1,42 @@
-module.exports = (db) => {
+const applyProfileSchema = require('@pf/src/modules/globals/models/profile.schema.js');
+const applySocialsSchema = require('@pf/src/modules/globals/models/socials.schema.js');
+const applyCredentialsSchema = require('@pf/src/modules/globals/models/credentials.schema.js');
 
-  const UserSchema = new db.mongoose.Schema({ 
-    username: String,
-    
-    phone: String,
-    email: String,
+module.exports = (db) => {
 
-    apple_id: String,
-    password: String,
+  const UserSchema = new db.mongoose.Schema({
+    username: {
+      type: String,
+      unique: true
+    },
+    password: {
+      type: String,
+      required: true
+    },
 
     status: {
       type: String,
-      enum: ['active','banned','removed','inactive'], 
+      enum: ['active', 'banned', 'removed', 'inactive'],
       default: 'active',
       required: true,
     },
-    
-    profile: {
-      photo: {
-          type: String,
-          default: ''
-      },
-      name: {
-          type: String,
-          default: ''
-      },
-      description: {
-          type: String,
-          default: ''
-      },
-      birthday: {
-          type: Date,
-      }
-    },
 
-    socials: {
-        telegram: {
-            type: String,
-            default: ''
-        },
-        twitter: {
-            type: String,
-            default: ''
-        },
-        facebook: {
-            type: String,
-            default: ''
-        },
-        instagram: {
-            type: String,
-            default: ''
-        }
-    },
-
-    roles: [
-      {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "Role"
-      }
-    ]
-    },{
-      // Creation Date
-      timestamps: { currentTime: () => Date.now() 
+    roles: [{
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Role"
+    }]
+  }, {
+    // Creation Date
+    timestamps: {
+      currentTime: () => Date.now()
     }
 
   });
 
+  applyProfileSchema(UserSchema, db);
+  applySocialsSchema(UserSchema, db);
+  applyCredentialsSchema(UserSchema, db);
+
   const User = db.mongoose.model("User", UserSchema);
 
   return User;

package/src/modules/users/models/visitor.model.js

@@ -0,0 +1,14 @@
+module.exports = (db) => {
+  const VisitorSchema = new db.mongoose.Schema({
+    ip: String,
+    userAgent: String,
+    acceptLanguage: String,
+    fingerprint: { type: String, unique: true },
+  });
+
+  VisitorSchema.index({ fingerprint: 1 });
+
+  const Visitor = db.mongoose.model("Visitor", VisitorSchema);
+
+  return Visitor;
+}

package/src/modules/users/store/users.js

@@ -45,19 +45,10 @@ const actions = {
     }
   },
 
-  async read(options = {}) {
-    options.params = {}
-    
-    if (options._id) {
-      options.params._id = options._id;
-    }
-
-    if (options.user) {
-      options.params.user = options.user;
-    }
+  async read(options = {}) {  
 
     try {
-      const response = await $axios.get('/api/users', { params: options.params });
+      const response = await $axios.get('/api/users', { params: options });
       
       if (options._id) {
         mutations.set(response.data[0], 'current');

package/src/modules/wallet/controllers/routes/payments.routes.js

@@ -10,7 +10,9 @@ const Observer = require('@pf/src/modules/globals/services/globals.observer');
 // Routes
 module.exports = function(app, db, origins, publicPath) {
   const observer = new Observer(); 
+  
   const webhook = new WebhookStripe(app, db, observer); 
+
   const controller = controllerFactory(db);
   const controllerTickets = controllerFactoryTickets(db, publicPath);