@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/ArticleCommentService.js

@@ -0,0 +1,479 @@
+"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 ArticleRepository_1 = require("@/repositories/ArticleRepository");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const ArticleCommentRepository_1 = require("@/repositories/ArticleCommentRepository");
+const ArticleCommentResource_1 = require("@/transformers/resources/ArticleCommentResource");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const LikeRepository_1 = require("@/repositories/LikeRepository");
+const ArticleCommentModel_1 = __importDefault(require("@/models/ArticleCommentModel"));
+const LikeModel_1 = __importDefault(require("@/models/LikeModel"));
+let ArticleCommentService = class ArticleCommentService {
+    articleRepository;
+    articleCommentRepository;
+    likeRepository;
+    constructor() {
+        this.articleRepository = new ArticleRepository_1.ArticleRepository();
+        this.likeRepository = new LikeRepository_1.LikeRepository();
+        this.articleCommentRepository = new ArticleCommentRepository_1.ArticleCommentRepository();
+    }
+    async createArticleComment(articleCommentData, user_id, article_id) {
+        let message;
+        const { content, } = articleCommentData;
+        const article = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const createdArticleComment = await this.articleCommentRepository.create({
+            content,
+            article_id: article.id,
+            user_id
+        });
+        const comment = await this.articleCommentRepository.findOneAndRelations({
+            where: { uuid: createdArticleComment.uuid },
+            relations: ['user']
+        });
+        logger_1.logger.info("Article comment created successfully");
+        return {
+            successful: true,
+            data: comment ? ArticleCommentResource_1.ArticleCommentResource.toJSON(comment, user_id) : null,
+            message: "Article comment created successfully"
+        };
+    }
+    async createReplyComment(articleCommentData, user_id, comment_id) {
+        let message;
+        const { content, } = articleCommentData;
+        const parentComment = await this.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: parentComment.article_id
+        });
+        if (!article) {
+            message = "We couldn't find the article that should have owned the comment you want to reply";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const createdArticleComment = await this.articleCommentRepository.create({
+            content,
+            article_id: article.id,
+            parent_id: parentComment.id,
+            user_id
+        });
+        const comment = await this.articleCommentRepository.findOneAndRelations({
+            where: { uuid: createdArticleComment.uuid },
+            relations: ['user']
+        });
+        logger_1.logger.info("Article's comment's reply created successfully");
+        return {
+            successful: true,
+            data: comment ? ArticleCommentResource_1.ArticleCommentResource.toJSON(comment, user_id) : null,
+            message: "Article' comment's reply created successfully"
+        };
+    }
+    async getComment(comment_id, user_id) {
+        let message;
+        const comment = await this.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: comment.article_id
+        });
+        if (!article) {
+            message = "We couldn't find the article that should have owned this comment";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const qb = this.articleCommentRepository
+            .getRepo()
+            .createQueryBuilder("comment")
+            .leftJoin("comment.user", "user")
+            .leftJoin("user.user_profile", "profile")
+            .leftJoin("profile.avatar", "avatar")
+            .where("comment.deleted_at IS NULL")
+            .andWhere("comment.article_id = :articleId", { articleId: article.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(ArticleCommentModel_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.ARTICLE_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.ARTICLE_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.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: comment.article_id
+        });
+        if (!article) {
+            message = "We couldn't find the article that should have owned the comment you want to like/unlike";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const alreadyLikedComment = await this.likeRepository.basicFindOneByConditions({
+            likeable_id: comment.id,
+            likeable_type: IndexEnum_1.SYS_MODELS.ARTICLE_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.ARTICLE_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.ARTICLE_COMMENT_MODEL
+            });
+            message = "Comment liked successfully";
+        }
+        return {
+            successful: true,
+            data: null,
+            message
+        };
+    }
+    async getArticleComments(user_id, article_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const article = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const paginationDto = {
+            page_number, limit
+        };
+        const { data, total, perPage, page } = await this.articleCommentRepository.getPagedArticleComments(paginationDto, article.id, user_id);
+        const { entities, raw } = data;
+        const articleCommentEntities = entities;
+        const rawArticleComments = raw;
+        const articleComments = articleCommentEntities.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: rawArticleComments[index]?.profile_image_url,
+                },
+                replies_count: rawArticleComments[index]?.replies_count,
+                likes_count: rawArticleComments[index]?.likes_count,
+                has_liked: rawArticleComments[index]?.has_liked,
+            };
+        });
+        const pagedArticleComments = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page_number,
+            data: articleComments,
+        });
+        return {
+            successful: true,
+            data: pagedArticleComments,
+            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.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: parentComment.article_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const paginationDto = {
+            page_number,
+            limit
+        };
+        const { data, total, perPage, page } = await this.articleCommentRepository.getPagedCommentReplies(paginationDto, parentComment.id, user_id);
+        const { entities, raw } = data;
+        const articleCommentEntities = entities;
+        const rawArticleComments = raw;
+        const articleComments = articleCommentEntities.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: rawArticleComments[index]?.profile_image_url,
+                },
+                replies_count: rawArticleComments[index]?.replies_count,
+                likes_count: rawArticleComments[index]?.likes_count,
+                has_liked: rawArticleComments[index]?.has_liked,
+            };
+        });
+        const pagedArticleComments = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page_number,
+            data: articleComments,
+        });
+        return {
+            successful: true,
+            data: pagedArticleComments,
+            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.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: comment.article_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        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(articleCommentData, comment_id, user_id) {
+        let message;
+        const { content } = articleCommentData;
+        const comment = await this.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: comment.article_id
+        });
+        if (!article) {
+            message = "We couldn't find the article that should have owned the comment you want to update";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const updatedComment = await this.articleCommentRepository.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.articleCommentRepository.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 article = await this.articleRepository.basicFindOneByConditions({
+            id: comment.article_id
+        });
+        if (!article) {
+            message = "We couldn't find the article that should have owned the comment you want to delete";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.articleCommentRepository.deleteByCondition({
+            uuid: comment.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Comment deleted successfully!"
+        };
+    }
+};
+ArticleCommentService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], ArticleCommentService);
+exports.default = ArticleCommentService;