Breaking News: Grepper is joining You.com. Read the official announcement!

mongodb aggregate part 2

Bloody Bear answered on March 8, 2022 Popularity 2/10 Helpfulness 1/10

answer mongodb aggregate part 2

related mongodb aggregation part 3

mongodb aggregate part 2

Comment

 if (count < 25) {
      // fakeTotalPagesFlag = true;
      if (count < 3) {
        fetchOthersPosts = "true";
        initialPosts = posts[0] ? posts[0].data : [];
      }
    }

    if (filteredPostsCount < 25) {
      noMoreFollowingPosts = true;
    }
    if (filteredPostsCount == 0) {
      fetchOthersPosts = "true";
    }
    followingPostsPage = followingPostsPage + 1;
  }

  if (fetchOthersPosts === "true") {
    noMoreFollowingPosts = true;
    if (noFollowers) {
      blockedUserIds.push(mongoose.Types.ObjectId(userId));
      posts = await Post.aggregate([
        {
          $lookup: {
            from: "users",
            let: { userId: "$userId" },
            pipeline: [
              {
                $match: {
                  $expr: { $eq: ["$_id", "$$userId"] },
                },
              },
              { $project: { fullName: 1, userName: 1, email: 1, image: 1, privateAccount: 1 } },
            ],
            as: "users",
          },
        },
        {
          $addFields: {
            userId: {
              $arrayElemAt: ["$users", 0],
            },
            dayssince: {
              $trunc: {
                $divide: [
                  { $subtract: [new Date(), "$createdAt"] },
                  1000 * 60 * 60 * 24,
                ],
              },
            },
          },
        },
        {
          $match: {
            $or: [
              { "userId._id": { $nin: blockedUserIds } },

              {
                $and: [
                  { "userId._id": mongoose.Types.ObjectId(userId) },
                  { dayssince: { $lt: 2 } },
                ],
              },
            ],
          },
        },
        //below condition is to filter out the blocked users data
        {
          $match: {
            $or: [
              {
                $and: [
                  { "userId._id": mongoose.Types.ObjectId(userId) },
                  { dayssince: { $lt: 2 } },
                ],
              },
              {
                $or: [
                  { "userId.privateAccount": { $exists: false } },
                  {
                    $and: [
                      { "userId.privateAccount": { $exists: true } },
                      { "userId.privateAccount": { $ne: "true" } },
                    ]
                  }
                ]
              }
            ]
          }
        },
        {
          $lookup: {
            from: "ingredients",
            localField: "ingredients.id",
            foreignField: "_id",
            as: "output"
          }
        },
        {
          $addFields: {
            "ingredients.name": "$output.name"
          }
        },
        { $project: { output: 0, postLikes: 0, userLiked: 0, ingredient: 0, dayssince: 0, users: 0, comments: 0, image: 0, video: 0 } },
        { $sort: { createdAt: -1 } },
        {
          $facet: {
            stage1: [{ $group: { _id: null, count: { $sum: 1 } } }],
            stage2: [
              {
                $skip: (allPostsPage - 1) * limit,
              },
              { $limit: limit * 1 },
            ],
          },
        },
        {
          $unwind: {
            path: "$stage1",
          },
        },
        {
          $project: {
            count: "$stage1.count",
            data: "$stage2",
          },
        },
      ]);
      allPostsPage = allPostsPage + 1;

Popularity 2/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: aggregate mongodb whatever

Link to this answer
Share Copy Link

Contributed on Mar 08 2022

Bloody Bear

0 Answers Avg Quality 2/10

Closely Related Answers

mongodb aggregation part 3

Comment

  } else {
      posts = await Post.aggregate([
        {
          $lookup: {
            from: "users",
            let: { userId: "$userId" },
            pipeline: [
              {
                $match: {
                  $expr: { $eq: ["$_id", "$$userId"] },
                },
              },
              { $project: { fullName: 1, userName: 1, email: 1, image: 1, privateAccount: 1 } },
            ],
            as: "users",
          },
        },
        {
          $addFields: {
            userId: {
              $arrayElemAt: ["$users", 0],
            },
          },
        },
        {
          $match: {
            $and: [
              { "userId._id": { $nin: blockedUserIds } },
              {
                "userId._id": { $nin: followingListIds },
              },
              { "userId._id": { $ne: mongoose.Types.ObjectId(userId) } },
            ],
          },
        },
        //below condition is to filter out the blocked users data
        {
          $match: {
            $or: [
              { "userId.privateAccount": { $exists: false } },
              {
                $and: [
                  { "userId.privateAccount": { $exists: true } },
                  { "userId.privateAccount": { $ne: "true" } },
                ]
              }
            ]
          }
        },
        {
          $lookup: {
            from: "ingredients",
            localField: "ingredients.id",
            foreignField: "_id",
            as: "output"
          }
        },
        {
          $addFields: {
            "ingredients.name": "$output.name"
          }
        },
        { $project: { output: 0, postLikes: 0, userLiked: 0, ingredient: 0, dayssince: 0, users: 0, comments: 0, image: 0, video: 0 } },
        { $sort: { createdAt: -1 } },
        {
          $facet: {
            stage1: [{ $group: { _id: null, count: { $sum: 1 } } }],
            stage2: [
              {
                $skip: (allPostsPage - 1) * limit,
              },
              { $limit: limit * 1 },
            ],
          },
        },
        {
          $unwind: {
            path: "$stage1",
          },
        },
        {
          $project: {
            count: "$stage1.count",
            data: "$stage2",
          },
        },
      ]);
      allPostsPage = allPostsPage + 1;
    }
  }

  postsCount = posts[0] ? posts[0].count : 0;
  posts = posts[0] ? posts[0].data : [];

  if (initialPosts.length > 0) {
    posts = initialPosts.concat(posts);
  }

  const postIds = posts.map((post) => post._id)

  let postLikesCount = 0
  let postCommentsCount = 0
  let isLiked = 0

  const postLikes = await Like.find({ postId: { $in: postIds }, like: true })
  const postComments = await Comment.find({ postId: { $in: postIds } })

  const updatedPosts = posts.map((post) => {
    postLikes.map((singleLike) => {
      if (post._id.toString() === singleLike.postId.toString()) {
        postLikesCount = postLikesCount + 1
      }
      if (userId.toString() === post.userId.toString()) {
        isLiked = isLiked + 1
      }
    })

    postComments.map((singleComment) => {
      if (post._id.toString() === singleComment.postId.toString()) {
        postCommentsCount = postCommentsCount + 1
      }
    })

    return { ...post, postLikesCount, postCommentsCount }
  })

  return res.status(200).send({
    posts: updatedPosts,
    totalPages: fakeTotalPagesFlag ? 2 : Math.ceil(postsCount / limit),
    currentAllPostsPage: parseInt(allPostsPage),
    currentFollowingPostsPage: parseInt(followingPostsPage),
    noMoreFollowingPosts: noMoreFollowingPosts,
  });
};

Popularity 2/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: whatever mongodb-aggregation

Link to this answer
Share Copy Link

Contributed on Mar 08 2022

Bloody Bear

0 Answers Avg Quality 2/10

mongodb aggregate part 2

Contents

More Related Answers

mongodb aggregate part 2

Closely Related Answers

mongodb aggregation part 3

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.