@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/PostCommentService.js

@@ -0,0 +1,611 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typedi_1 = require("typedi");
+const logger_1 = require("../../common/configs/logger");
+const AppError_1 = require("../../common/errors/AppError");
+const messages_1 = require("../../common/constants/messages");
+const PostRepository_1 = require("@/repositories/PostRepository");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const CommunityMemberRepository_1 = require("@/repositories/CommunityMemberRepository");
+const CommunityRepository_1 = require("@/repositories/CommunityRepository");
+const PostCommentRepository_1 = require("@/repositories/PostCommentRepository");
+const PostCommentResource_1 = require("@/transformers/resources/PostCommentResource");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const LikeRepository_1 = require("@/repositories/LikeRepository");
+const CommentModel_1 = __importDefault(require("@/models/CommentModel"));
+const LikeModel_1 = __importDefault(require("@/models/LikeModel"));
+let PostCommentService = class PostCommentService {
+    postRepository;
+    postCommentRepository;
+    communityMemberRepository;
+    communityRepository;
+    likeRepository;
+    constructor() {
+        this.postRepository = new PostRepository_1.PostRepository();
+        this.likeRepository = new LikeRepository_1.LikeRepository();
+        this.communityRepository = new CommunityRepository_1.CommunityRepository();
+        this.communityMemberRepository = new CommunityMemberRepository_1.CommunityMemberRepository();
+        this.postCommentRepository = new PostCommentRepository_1.PostCommentRepository();
+    }
+    async createPostComment(postCommentData, user_id, post_id) {
+        let message;
+        const { content, } = postCommentData;
+        const post = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Community");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const isCommunityMember = await this.communityMemberRepository.basicFindOneByConditions({
+            community_id: community.id,
+            member_id: user_id
+        });
+        if (!isCommunityMember) {
+            message = `You must be a member of ${community.name} to be able to make a comment on this post!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const createdPostComment = await this.postCommentRepository.create({
+            content,
+            post_id: post.id,
+            user_id
+        });
+        const comment = await this.postCommentRepository.findOneAndRelations({
+            where: { uuid: createdPostComment.uuid },
+            relations: ['user']
+        });
+        logger_1.logger.info("Post comment created successfully");
+        return {
+            successful: true,
+            data: comment ? PostCommentResource_1.PostCommentResource.toJSON(comment, user_id) : null,
+            message: "Post comment created successfully"
+        };
+    }
+    async createReplyComment(postCommentData, user_id, comment_id) {
+        let message;
+        const { content, } = postCommentData;
+        const parentComment = await this.postCommentRepository.basicFindOneByConditions({
+            uuid: comment_id
+        });
+        if (!parentComment) {
+            message = "We couldn't find the comment you want to reply";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: parentComment.post_id
+        });
+        if (!post) {
+            message = "We couldn't find the post that should have owned the comment you want to reply";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Community");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const isCommunityMember = await this.communityMemberRepository.basicFindOneByConditions({
+            community_id: community.id,
+            member_id: user_id
+        });
+        if (!isCommunityMember) {
+            message = `You must be a member of ${community.name} to be able to reply a comment on this post!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const createdPostComment = await this.postCommentRepository.create({
+            content,
+            post_id: post.id,
+            parent_id: parentComment.id,
+            user_id
+        });
+        const comment = await this.postCommentRepository.findOneAndRelations({
+            where: { uuid: createdPostComment.uuid },
+            relations: ['user']
+        });
+        logger_1.logger.info("Post's comment's reply created successfully");
+        return {
+            successful: true,
+            data: comment ? PostCommentResource_1.PostCommentResource.toJSON(comment, user_id) : null,
+            message: "Post' comment's reply created successfully"
+        };
+    }
+    async getComment(comment_id, user_id) {
+        let message;
+        const comment = await this.postCommentRepository.findOneAndRelations({
+            where: {
+                uuid: comment_id
+            },
+            relations: ['user']
+        });
+        if (!comment) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Comment");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: comment.post_id
+        });
+        if (!post) {
+            message = "We couldn't find the post that should have owned this comment";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post on which this comment was made";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const qb = this.postCommentRepository
+            .getRepo()
+            .createQueryBuilder("comment")
+            .leftJoin("comment.user", "user")
+            .leftJoin("user.user_profile", "profile")
+            .leftJoin("profile.avatar", "avatar")
+            .where("comment.deleted_at IS NULL")
+            .andWhere("comment.post_id = :postId", { postId: post.id })
+            .andWhere("comment.uuid = :commentId", {
+            commentId: comment_id,
+        })
+            .take(1)
+            .orderBy("comment.created_at", "DESC");
+        /* ======================
+          SELECT FIELDS
+        ====================== */
+        qb.select([
+            "comment.id",
+            "comment.uuid",
+            "comment.content",
+            "comment.created_at",
+            "comment.updated_at",
+            "user.id",
+            "user.uuid",
+            "user.full_name",
+            "avatar.url AS profile_image_url",
+        ]);
+        /* ======================
+          REPLIES COUNT
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(r.id)")
+                .from(CommentModel_1.default, "r")
+                .where("r.parent_id = comment.id")
+                .andWhere("r.deleted_at IS NULL");
+        }, "replies_count");
+        // Check if user has liked the comment
+        qb.addSelect(`
+          EXISTS (
+            SELECT 1
+            FROM likes l
+            WHERE l.likeable_id = comment.id
+              AND l.likeable_type = :likeType
+              AND l.user_id = :user_id
+              AND l.deleted_at IS NULL
+          )
+          `, "has_liked")
+            .setParameter("likeType", IndexEnum_1.SYS_MODELS.POST_COMMENT_MODEL)
+            .setParameter("user_id", user_id);
+        /* ======================
+          LIKES COUNT (COMMENT)
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(l.id)")
+                .from(LikeModel_1.default, "l")
+                .where("l.likeable_id = comment.id")
+                .andWhere("l.likeable_type = :commentType")
+                .andWhere("l.deleted_at IS NULL");
+        }, "likes_count")
+            .setParameter("commentType", IndexEnum_1.SYS_MODELS.POST_COMMENT_MODEL);
+        const { entities, raw } = await qb.getRawAndEntities();
+        const foundComment = entities[0];
+        const { uuid, content, created_at, updated_at, user } = foundComment;
+        const data = {
+            uuid,
+            content,
+            created_at,
+            updated_at,
+            creator: {
+                uuid: user?.uuid,
+                full_name: user?.full_name,
+                profile_image_url: raw[0]?.profile_image_url,
+            },
+            replies_count: raw[0]?.replies_count,
+            likes_count: raw[0]?.likes_count,
+            has_liked: raw[0]?.has_liked,
+        };
+        return {
+            successful: true,
+            data,
+            message: "Comment fetched successfully!"
+        };
+    }
+    async likeOrUnlikeComment(comment_id, user_id) {
+        let message;
+        const comment = await this.postCommentRepository.basicFindOneByConditions({
+            uuid: comment_id
+        });
+        if (!comment) {
+            message = "We couldn't find the comment you want to like/unlike";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: comment.post_id
+        });
+        if (!post) {
+            message = "We couldn't find the post that should have owned the comment you want to like/unlike";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post that has the comment you want to like or unlike";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const isCommunityMember = await this.communityMemberRepository.basicFindOneByConditions({
+            community_id: community.id,
+            member_id: user_id
+        });
+        if (!isCommunityMember) {
+            message = `You must be a member of ${community.name} to be to like or unlike a post's comment in it!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const alreadyLikedComment = await this.likeRepository.basicFindOneByConditions({
+            likeable_id: comment.id,
+            likeable_type: IndexEnum_1.SYS_MODELS.POST_COMMENT_MODEL,
+            user_id
+        });
+        if (alreadyLikedComment) {
+            // Unlike the comment
+            await this.likeRepository.deleteByCondition({
+                user_id,
+                likeable_id: comment.id,
+                likeable_type: IndexEnum_1.SYS_MODELS.POST_COMMENT_MODEL
+            });
+            message = "Comment unliked successfully";
+        }
+        else {
+            // Like the comment
+            await this.likeRepository.create({
+                user_id,
+                likeable_id: comment.id,
+                likeable_type: IndexEnum_1.SYS_MODELS.POST_COMMENT_MODEL
+            });
+            message = "Comment liked successfully";
+        }
+        return {
+            successful: true,
+            data: null,
+            message
+        };
+    }
+    async getPostComments(user_id, post_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const post = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post on which the comments were made";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const paginationDto = {
+            page_number, limit
+        };
+        const { data, total, perPage, page } = await this.postCommentRepository.getPagedPostComments(paginationDto, post.id, user_id);
+        const { entities, raw } = data;
+        const postCommentEntities = entities;
+        const rawPostComments = raw;
+        const postComments = postCommentEntities.map((entity, index) => {
+            const { uuid, content, created_at, updated_at, user } = entity;
+            return {
+                uuid,
+                content,
+                created_at,
+                updated_at,
+                creator: {
+                    uuid: user?.uuid,
+                    full_name: user?.full_name,
+                    profile_image_url: rawPostComments[index]?.profile_image_url,
+                },
+                replies_count: rawPostComments[index]?.replies_count,
+                likes_count: rawPostComments[index]?.likes_count,
+                has_liked: rawPostComments[index]?.has_liked,
+            };
+        });
+        const pagedPostComments = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page_number,
+            data: postComments,
+        });
+        return {
+            successful: true,
+            data: pagedPostComments,
+            message: "Comments fetched successfully!"
+        };
+    }
+    async getCommentReplies(user_id, comment_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const parentComment = await this.postCommentRepository.basicFindOneByConditions({
+            uuid: comment_id
+        });
+        if (!parentComment) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Comment");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: parentComment.post_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post on which the comments were made";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const paginationDto = {
+            page_number,
+            limit
+        };
+        const { data, total, perPage, page } = await this.postCommentRepository.getPagedCommentReplies(paginationDto, parentComment.id, user_id);
+        const { entities, raw } = data;
+        const postCommentEntities = entities;
+        const rawPostComments = raw;
+        const postComments = postCommentEntities.map((entity, index) => {
+            const { uuid, content, created_at, updated_at, user } = entity;
+            return {
+                uuid,
+                content,
+                created_at,
+                updated_at,
+                creator: {
+                    uuid: user?.uuid,
+                    full_name: user?.full_name,
+                    profile_image_url: rawPostComments[index]?.profile_image_url,
+                },
+                replies_count: rawPostComments[index]?.replies_count,
+                likes_count: rawPostComments[index]?.likes_count,
+                has_liked: rawPostComments[index]?.has_liked,
+            };
+        });
+        const pagedPostComments = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page_number,
+            data: postComments,
+        });
+        return {
+            successful: true,
+            data: pagedPostComments,
+            message: "Comments fetched successfully!"
+        };
+    }
+    async getCommentLikes(user_id, comment_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const comment = await this.postCommentRepository.basicFindOneByConditions({
+            uuid: comment_id
+        });
+        if (!comment) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Comment");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: comment.post_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post on which the comments were made";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const isCommunityMember = await this.communityMemberRepository.basicFindOneByConditions({
+            community_id: community.id,
+            member_id: user_id
+        });
+        if (!isCommunityMember) {
+            message = `You must be a member of ${community.name} to be able to read a comments in it!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const paginationDto = {
+            page_number,
+            metadata: {
+                comment_id: comment.id
+            },
+            limit
+        };
+        const { data, total, perPage, page } = await this.likeRepository.getPagedCommentUserLikes(paginationDto, user_id);
+        const { entities, raw } = data;
+        const commentUserLikes = raw.map((like) => {
+            return {
+                user: {
+                    name: like?.user_full_name,
+                    uuid: like?.user_uuid,
+                    avatar_url: like?.avatar_url,
+                },
+                liked_at: like?.like_created_at
+            };
+        });
+        const pagedCommentLikes = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page_number,
+            data: commentUserLikes,
+        });
+        return {
+            successful: true,
+            data: pagedCommentLikes,
+            message: "Comment likes fetched successfully!"
+        };
+    }
+    async updateOneComment(postCommentData, comment_id, user_id) {
+        let message;
+        const { content } = postCommentData;
+        const comment = await this.postCommentRepository.findOneAndRelations({
+            where: {
+                uuid: comment_id,
+                user_id
+            }
+        });
+        if (!comment) {
+            message = "We couldn't find the comment you want to update";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: comment.post_id
+        });
+        if (!post) {
+            message = "We couldn't find the post that should have owned the comment you want to update";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post on which this comment was made";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const isCommunityMember = await this.communityMemberRepository.basicFindOneByConditions({
+            community_id: community.id,
+            member_id: user_id
+        });
+        if (!isCommunityMember) {
+            message = `You must be a member of ${community.name} to be able to update a comment on this post!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const updatedComment = await this.postCommentRepository.updateOne({
+            uuid: comment.uuid,
+            user_id,
+        }, {
+            content
+        });
+        return {
+            successful: true,
+            data: updatedComment,
+            message: "Comment updated successfully!"
+        };
+    }
+    async deleteOneComment(comment_id, user_id) {
+        let message;
+        const comment = await this.postCommentRepository.findOneAndRelations({
+            where: {
+                uuid: comment_id,
+                user_id
+            }
+        });
+        if (!comment) {
+            message = "We couldn't find the comment you want to delete";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const post = await this.postRepository.basicFindOneByConditions({
+            id: comment.post_id
+        });
+        if (!post) {
+            message = "We couldn't find the post that should have owned the comment you want to delete";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const community = await this.communityRepository.basicFindOneByConditions({
+            id: post.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post on which this comment was made";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const isCommunityMember = await this.communityMemberRepository.basicFindOneByConditions({
+            community_id: community.id,
+            member_id: user_id
+        });
+        if (!isCommunityMember) {
+            message = `You must be a member of ${community.name} to be able to delete a comment on this post!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        await this.postCommentRepository.deleteByCondition({
+            uuid: comment.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Comment deleted successfully!"
+        };
+    }
+};
+PostCommentService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], PostCommentService);
+exports.default = PostCommentService;