@ozdao/prometheus-framework 0.2.130 → 0.2.133

package/src/modules/wallet/controllers/factories/rewards.factory.aggr.js

@@ -0,0 +1,181 @@
+const ObjectId = require('mongoose').Types.ObjectId;
+const { BigNumber } = require('bignumber.js');
+
+const queryProcessorGlobals = require('@pf/src/modules/globals/controllers/utils/queryProcessor');
+
+const VIEWS_REWARD_COEFF = '0.1';
+const WDT_DECIMALS = 8;
+
+const calculateRewardForPost = (snapshot, viewsCount, reactionsCount, commentsCount) => {
+
+  console.log('views',viewsCount)
+  console.log('reactions',reactionsCount)
+  console.log('comments',commentsCount)
+  
+  if (snapshot) {
+    return new BigNumber(Math.max(viewsCount - snapshot.views, 0))
+      .multipliedBy(VIEWS_REWARD_COEFF)
+      .plus(Math.max(reactionsCount - snapshot.reactions, 0))
+      .plus(Math.max(commentsCount - snapshot.comments, 0));
+  }
+
+  return new BigNumber('10')
+    .plus(new BigNumber(viewsCount).multipliedBy(VIEWS_REWARD_COEFF))
+    .plus(reactionsCount)
+    .plus(commentsCount);
+};
+
+const rewardsControllerFactory = (db, wdmClient) => {
+  const Blogpost = db.blogpost;
+  const Reaction = db.reaction;
+  const Comment = db.comment;
+  const Reward = db.reward;
+
+
+
+  const listRewards = async (req, res) => {
+    try {
+      const aggregationResults = await Blogpost.aggregate([
+        // Соответствие блогпостов для данного пользователя
+        { $match: { "creator.target": new ObjectId(req.userId) } },
+        
+        // Добавление информации о реакциях и комментариях
+        {
+          $lookup: {
+            from: "reactions",
+            localField: "_id",
+            foreignField: "target",
+            as: "reactions"
+          }
+        },
+        {
+          $lookup: {
+            from: "comments",
+            localField: "_id",
+            foreignField: "target",
+            as: "comments"
+          }
+        },
+        
+        // Добавление информации о предыдущей награде
+        {
+          $lookup: {
+            from: "rewards",
+            let: { blogId: "$_id" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $eq: ["$user", req.userId] },
+                      { $eq: ["$type", "blogpost"] },
+                      { $eq: ["$target", "$$blogId"] }
+                    ]
+                  }
+                }
+              },
+              { $sort: { createdAt: -1 } },
+              { $limit: 1 }
+            ],
+            as: "previousReward"
+          }
+        },
+        
+        // Преобразование результатов
+        {
+          $project: {
+            _id: 1,
+            user: req.userId,
+            type: "blogpost",
+            views: 1,
+            reactionsCount: { $size: "$reactions" },
+            commentsCount: { $size: "$comments" },
+            previousReward: { $arrayElemAt: ["$previousReward", 0] },
+            name: 1,
+            content: 1,
+            url: 1
+          }
+        }
+      ])
+
+      const rewards = aggregationResults.map(result => ({
+        user: result.user,
+        type: result.type,
+        amount: calculateRewardForPost(
+          result.previousReward?.snapshot,
+          result.views,
+          result.reactionsCount,
+          result.commentsCount
+        ),
+        name: result.name,
+        content: result.content,
+        url: result.url
+      }));
+
+      res.status(200).send(rewards);
+    } catch (error) {
+      res.status(500).send({ message: "Произошла ошибка при получении наград", error: error.message });
+    }
+  };
+
+  const collectTokens = async (req, res) => {
+    const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
+
+    let totalRewards = new BigNumber(0);
+
+    for (const blog of blogs) {
+      const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
+      const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
+
+      const previousReward = await Reward
+        .findOne({ user: req.userId, type: 'blogpost', target: blog._id })
+        .sort({ createdAt: -1 })
+        .exec();
+
+      const reward = calculateRewardForPost(
+        previousReward?.snapshot,
+        blog.views,
+        reactions,
+        comments
+      );
+
+      if (reward.gt(0)) {
+        totalRewards = totalRewards.plus(reward);
+
+        const snapshot = {
+          views: previousReward ?
+            previousReward.snapshot.views < blog.views ? blog.views : previousReward.snapshot.views
+            : blog.views,
+          reactions: previousReward ?
+            previousReward.snapshot.reactions < reactions ? reactions : previousReward.snapshot.reactions
+            : reactions,
+          comments: previousReward ?
+            previousReward.snapshot.comments < comments ? comments : previousReward.snapshot.comments
+            : comments,
+        };
+
+        await Reward.create({
+          user: req.userId,
+          type: 'blogpost',
+          target: blog._id,
+          amount: reward.toString(),
+          snapshot: snapshot,
+        });
+      }
+    }
+
+    if (totalRewards.gt(0)) {
+      await wdmClient.transfer(
+        totalRewards.shiftedBy(WDT_DECIMALS).toString(),
+        req.body.recipient,
+        req.userId
+      );
+    }
+
+    res.status(200).send();
+  };
+
+  return { listRewards, collectTokens };
+};
+
+module.exports = rewardsControllerFactory;

package/src/modules/wallet/controllers/factories/rewards.factory.js

@@ -7,6 +7,9 @@ const VIEWS_REWARD_COEFF = '0.1';
 const WDT_DECIMALS = 8;
 
 const calculateRewardForPost = (snapshot, viewsCount, reactionsCount, commentsCount) => {
+
+  console.log('snapshot',snapshot)
+
   if (snapshot) {
     return new BigNumber(Math.max(viewsCount - snapshot.views, 0))
       .multipliedBy(VIEWS_REWARD_COEFF)
@@ -26,123 +29,94 @@ const rewardsControllerFactory = (db, wdmClient) => {
   const Comment = db.comment;
   const Reward = db.reward;
 
-  // const listRewards = async (req, res) => {
-  //   try {
-  //     const rewards = await Blogpost.aggregate([
-  //       // Шаг 1: Фильтрация блогпостов по создателю
-  //       { $match: { "creator.target": req.userId } },
-  //       // Шаг 2: Соединение с Reaction для подсчета реакций
-  //       {
-  //         $lookup: {
-  //           from: "reactions",
-  //           localField: "_id",
-  //           foreignField: "target",
-  //           as: "reactions"
-  //         }
-  //       },
-  //       // Шаг 3: Соединение с Comment для подсчета комментариев
-  //       {
-  //         $lookup: {
-  //           from: "comments",
-  //           localField: "_id",
-  //           foreignField: "target",
-  //           as: "comments"
-  //         }
-  //       },
-  //       // Шаг 4: Соединение с Reward для получения предыдущих наград
-  //       {
-  //         $lookup: {
-  //           from: "rewards",
-  //           let: { blogId: "$_id", userId: req.userId },
-  //           pipeline: [
-  //             { $match: { 
-  //                 $expr: { 
-  //                   $and: [
-  //                     { $eq: ["$user", "$$userId"] },
-  //                     { $eq: ["$type", "blogpost"] },
-  //                     { $eq: ["$target", "$$blogId"] }
-  //                   ] 
-  //                 } 
-  //               } 
-  //             },
-  //             { $sort: { createdAt: -1 } },
-  //             { $limit: 1 }
-  //           ],
-  //           as: "previousReward"
-  //         }
-  //       },
-  //       // Шаг 5: Проецирование результата и преобразование массивов в счетчики
-  //       {
-  //         $project: {
-  //           user: req.userId,
-  //           type: 'blogpost',
-  //           name: "$name",
-  //           content: "$content",
-  //           url: "$url",
-  //           views: "$views",
-  //           reactionsCount: { $size: "$reactions" },
-  //           commentsCount: { $size: "$comments" },
-  //           previousRewardSnapshot: { $arrayElemAt: ["$previousReward.snapshot", 0] },
-  //         }
-  //       }
-  //     ]).exec();
-
-  //     // Пересчет наград на основе полученных данных
-  //     const calculatedRewards = rewards.map(reward => ({
-  //       ...reward,
-  //       amount: calculateRewardForPost(
-  //         reward.previousRewardSnapshot,
-  //         reward.views,
-  //         reward.reactionsCount,
-  //         reward.commentsCount
-  //       ).toString(),
-  //     }));
-
-  //     res.status(200).send(calculatedRewards);
-  //   } catch (error) {
-  //     console.error("Error listing rewards:", error);
-  //     res.status(500).send({ message: "Internal server error" });
-  //   }
-  // };
-
-  const listRewards = async (req, res) => {
-    const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
-
-    const rewards = [];
 
-    for (const blog of blogs) {
-      const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
-      const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
 
-      const previousReward = await Reward
-        .findOne({ user: req.userId, type: 'blogpost', target: blog._id })
-        .populate({
-          path: 'target',
-          model: 'Blogpost' // Убедитесь, что 'Blogpost' соответствует имени вашей модели блогпоста
-        })
-        .sort({ createdAt: -1 })
-        .exec();
-
-      const reward = calculateRewardForPost(
-        previousReward?.snapshot,
-        blog.views,
-        reactions,
-        comments
-      );
-
-      rewards.push({
-        user: req.userId,
-        type: 'blogpost',
-        amount: reward.toString(),
-        name: blog.name,
-        content: blog.content,
-        url: blog.url 
-      });
+  const listRewards = async (req, res) => {
 
-      // console.log(rewards)
+    const userId = new ObjectId(req.userId)
+
+    try {
+      const aggregationResults = await Blogpost.aggregate([
+        // Соответствие блогпостов для данного пользователя
+        { $match: { "creator.target": userId } },
+        
+        // Добавление информации о реакциях и комментариях
+        {
+          $lookup: {
+            from: "reactions",
+            localField: "_id",
+            foreignField: "target",
+            as: "reactions"
+          }
+        },
+        {
+          $lookup: {
+            from: "comments",
+            localField: "_id",
+            foreignField: "target",
+            as: "comments"
+          }
+        },
+        
+        // Добавление информации о предыдущей награде
+        {
+          $lookup: {
+            from: "rewards",
+            let: { blogId: "$_id" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $eq: ["$user", userId] },
+                      { $eq: ["$type", "blogpost"] },
+                      { $eq: ["$target", "$$blogId"] }
+                    ]
+                  }
+                }
+              },
+              { $sort: { createdAt: -1 } },
+              { $limit: 1 }
+            ],
+            as: "previousReward"
+          }
+        },
+        
+        // Преобразование результатов
+        {
+          $project: {
+            _id: 1,
+            user: req.userId,
+            type: "blogpost",
+            views: 1,
+            reactionsCount: { $size: "$reactions" },
+            commentsCount: { $size: "$comments" },
+            previousReward: { $arrayElemAt: ["$previousReward", 0] },
+            name: 1,
+            content: 1,
+            url: 1
+          }
+        }
+      ])
+
+      const rewards = aggregationResults.map(result => ({
+        user: result.user,
+        type: result.type,
+        amount: calculateRewardForPost(
+          result.previousReward?.snapshot,
+          result.views,
+          result.reactionsCount,
+          result.commentsCount
+        ),
+        name: result.name,
+        content: result.content,
+        url: result.url
+      }));
+
+      res.status(200).send(rewards);
+    } catch (error) {
+      res.status(500).send({ message: "Произошла ошибка при получении наград", error: error.message });
     }
-
-    res.status(200).send(rewards);
   };
 
   const collectTokens = async (req, res) => {

package/src/modules/wallet/controllers/factories/rewards.factory.population.js

@@ -0,0 +1,213 @@
+const ObjectId = require('mongoose').Types.ObjectId;
+const { BigNumber } = require('bignumber.js');
+
+const queryProcessorGlobals = require('@pf/src/modules/globals/controllers/utils/queryProcessor');
+
+const VIEWS_REWARD_COEFF = '0.1';
+const WDT_DECIMALS = 8;
+
+const calculateRewardForPost = (snapshot, viewsCount, reactionsCount, commentsCount) => {
+   console.log('views',viewsCount)
+  console.log('reactions',reactionsCount)
+  console.log('comments',commentsCount)
+  
+  
+  if (snapshot) {
+    return new BigNumber(Math.max(viewsCount - snapshot.views, 0))
+      .multipliedBy(VIEWS_REWARD_COEFF)
+      .plus(Math.max(reactionsCount - snapshot.reactions, 0))
+      .plus(Math.max(commentsCount - snapshot.comments, 0));
+  }
+
+  return new BigNumber('10')
+    .plus(new BigNumber(viewsCount).multipliedBy(VIEWS_REWARD_COEFF))
+    .plus(reactionsCount)
+    .plus(commentsCount);
+};
+
+const rewardsControllerFactory = (db, wdmClient) => {
+  const Blogpost = db.blogpost;
+  const Reaction = db.reaction;
+  const Comment = db.comment;
+  const Reward = db.reward;
+
+  // const listRewards = async (req, res) => {
+  //   try {
+  //     const rewards = await Blogpost.aggregate([
+  //       // Шаг 1: Фильтрация блогпостов по создателю
+  //       { $match: { "creator.target": req.userId } },
+  //       // Шаг 2: Соединение с Reaction для подсчета реакций
+  //       {
+  //         $lookup: {
+  //           from: "reactions",
+  //           localField: "_id",
+  //           foreignField: "target",
+  //           as: "reactions"
+  //         }
+  //       },
+  //       // Шаг 3: Соединение с Comment для подсчета комментариев
+  //       {
+  //         $lookup: {
+  //           from: "comments",
+  //           localField: "_id",
+  //           foreignField: "target",
+  //           as: "comments"
+  //         }
+  //       },
+  //       // Шаг 4: Соединение с Reward для получения предыдущих наград
+  //       {
+  //         $lookup: {
+  //           from: "rewards",
+  //           let: { blogId: "$_id", userId: req.userId },
+  //           pipeline: [
+  //             { $match: { 
+  //                 $expr: { 
+  //                   $and: [
+  //                     { $eq: ["$user", "$$userId"] },
+  //                     { $eq: ["$type", "blogpost"] },
+  //                     { $eq: ["$target", "$$blogId"] }
+  //                   ] 
+  //                 } 
+  //               } 
+  //             },
+  //             { $sort: { createdAt: -1 } },
+  //             { $limit: 1 }
+  //           ],
+  //           as: "previousReward"
+  //         }
+  //       },
+  //       // Шаг 5: Проецирование результата и преобразование массивов в счетчики
+  //       {
+  //         $project: {
+  //           user: req.userId,
+  //           type: 'blogpost',
+  //           name: "$name",
+  //           content: "$content",
+  //           url: "$url",
+  //           views: "$views",
+  //           reactionsCount: { $size: "$reactions" },
+  //           commentsCount: { $size: "$comments" },
+  //           previousRewardSnapshot: { $arrayElemAt: ["$previousReward.snapshot", 0] },
+  //         }
+  //       }
+  //     ]).exec();
+
+  //     // Пересчет наград на основе полученных данных
+  //     const calculatedRewards = rewards.map(reward => ({
+  //       ...reward,
+  //       amount: calculateRewardForPost(
+  //         reward.previousRewardSnapshot,
+  //         reward.views,
+  //         reward.reactionsCount,
+  //         reward.commentsCount
+  //       ).toString(),
+  //     }));
+
+  //     res.status(200).send(calculatedRewards);
+  //   } catch (error) {
+  //     console.error("Error listing rewards:", error);
+  //     res.status(500).send({ message: "Internal server error" });
+  //   }
+  // };
+
+  const listRewards = async (req, res) => {
+    const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
+
+    const rewards = [];
+
+    for (const blog of blogs) {
+      const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
+      const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
+
+      const previousReward = await Reward
+        .findOne({ user: req.userId, type: 'blogpost', target: blog._id })
+        .populate({
+          path: 'target',
+          model: 'Blogpost' // Убедитесь, что 'Blogpost' соответствует имени вашей модели блогпоста
+        })
+        .sort({ createdAt: -1 })
+        .exec();
+
+      const reward = calculateRewardForPost(
+        previousReward?.snapshot,
+        blog.views,
+        reactions,
+        comments
+      );
+
+      rewards.push({
+        user: req.userId,
+        type: 'blogpost',
+        amount: reward.toString(),
+        name: blog.name,
+        content: blog.content,
+        url: blog.url 
+      });
+
+      // console.log(rewards)
+    }
+
+    res.status(200).send(rewards);
+  };
+
+  const collectTokens = async (req, res) => {
+    const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
+
+    let totalRewards = new BigNumber(0);
+
+    for (const blog of blogs) {
+      const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
+      const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
+
+      const previousReward = await Reward
+        .findOne({ user: req.userId, type: 'blogpost', target: blog._id })
+        .sort({ createdAt: -1 })
+        .exec();
+
+      const reward = calculateRewardForPost(
+        previousReward?.snapshot,
+        blog.views,
+        reactions,
+        comments
+      );
+
+      if (reward.gt(0)) {
+        totalRewards = totalRewards.plus(reward);
+
+        const snapshot = {
+          views: previousReward ?
+            previousReward.snapshot.views < blog.views ? blog.views : previousReward.snapshot.views
+            : blog.views,
+          reactions: previousReward ?
+            previousReward.snapshot.reactions < reactions ? reactions : previousReward.snapshot.reactions
+            : reactions,
+          comments: previousReward ?
+            previousReward.snapshot.comments < comments ? comments : previousReward.snapshot.comments
+            : comments,
+        };
+
+        await Reward.create({
+          user: req.userId,
+          type: 'blogpost',
+          target: blog._id,
+          amount: reward.toString(),
+          snapshot: snapshot,
+        });
+      }
+    }
+
+    if (totalRewards.gt(0)) {
+      await wdmClient.transfer(
+        totalRewards.shiftedBy(WDT_DECIMALS).toString(),
+        req.body.recipient,
+        req.userId
+      );
+    }
+
+    res.status(200).send();
+  };
+
+  return { listRewards, collectTokens };
+};
+
+module.exports = rewardsControllerFactory;

package/src/modules/wallet/localization/Wallet.json

@@ -0,0 +1,22 @@
+{
+  "messages": {
+    "en-default": {
+      "pay": "pay",
+      "youReceived": "you received",
+      "enterAmount": "enter amount to top up",
+      "backToWallet": "back to wallet",
+      "backToSelection": "back to selection",
+      "balanceReplenished": "balance replenished",
+      "depositeWithCrypto": "deposite with crypto"
+    },
+    "ru-default": {
+      "pay": "купить",
+      "youReceived": "вы пополнили на сумму",
+      "enterAmount": "введите сумму для пополнения",
+      "backToWallet": "назад к кошельку",
+      "backToSelection": "назад к списку",
+      "balanceReplenished": "баланс пополнен",
+      "depositeWithCrypto": "пополнение криптовалютой"
+    }
+  }
+}