@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/ArticleService.js

@@ -0,0 +1,507 @@
+"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 UploadService_1 = __importDefault(require("./UploadService"));
+const UploadEnum_1 = require("@/common/enums/UploadEnum");
+const ArticleRepository_1 = require("@/repositories/ArticleRepository");
+const ArticleImageRepository_1 = require("@/repositories/ArticleImageRepository");
+const ArticleCollection_1 = require("../../transformers/collections/ArticleCollection");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const ArticleResource_1 = require("@/transformers/resources/ArticleResource");
+const CommunityRepository_1 = require("@/repositories/CommunityRepository");
+const ArticleLikeRepository_1 = require("@/repositories/ArticleLikeRepository");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const ArticleCommentModel_1 = __importDefault(require("@/models/ArticleCommentModel"));
+const LikeModel_1 = __importDefault(require("@/models/LikeModel"));
+const ArticleImageModel_1 = __importDefault(require("@/models/ArticleImageModel"));
+let ArticleService = class ArticleService {
+    articleRepository;
+    uploadService;
+    articleImageRepository;
+    communityRepository;
+    likeRepository;
+    constructor() {
+        this.articleRepository = new ArticleRepository_1.ArticleRepository();
+        this.uploadService = new UploadService_1.default();
+        this.articleImageRepository = new ArticleImageRepository_1.ArticleImageRepository();
+        this.communityRepository = new CommunityRepository_1.CommunityRepository();
+        this.likeRepository = new ArticleLikeRepository_1.ArticleLikeRepository();
+    }
+    async createArticle(articleData, user_id) {
+        let message;
+        const { title, visibility, is_sensitive, article_images, description, } = articleData;
+        if (article_images && article_images?.length > 5) {
+            message = "Maximum of 5 images allowed";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        const createdArticle = await this.articleRepository.create({
+            title: title ?? null,
+            visibility,
+            is_sensitive,
+            description,
+            user_id
+        });
+        const articleId = createdArticle.id;
+        logger_1.logger.info("Article created without cover image");
+        if (article_images?.length) {
+            const uploadedFiles = await Promise.all(article_images.map((article_image) => this.uploadService.uploadImage(article_image, articleId, UploadEnum_1.UploadDirectories.ARTICLE_IMAGES, "ArticleModel")));
+            await Promise.all(uploadedFiles.map((file) => this.articleImageRepository.create({
+                article_id: articleId,
+                image_id: file.id,
+            })));
+        }
+        return {
+            successful: true,
+            data: {
+                article: {
+                    created_at: createdArticle.created_at
+                }
+            },
+            message: "Article created successfully"
+        };
+    }
+    async getOneArticle(article_id, user_id) {
+        let message;
+        const foundArticle = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id
+        });
+        if (!foundArticle) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const qb = this.articleRepository
+            .getRepo()
+            .createQueryBuilder("article")
+            .leftJoin("article.user", "user")
+            .where("article.deleted_at IS NULL")
+            .andWhere("article.uuid = :articleId", {
+            articleId: article_id,
+        });
+        /* ======================
+          ARTICLE FIELDS
+        ====================== */
+        qb.select([
+            "article.id",
+            "article.uuid",
+            "article.title",
+            "article.description",
+            "article.visibility",
+            "article.is_sensitive",
+            "article.created_at",
+            "user.id",
+            "user.uuid",
+            "user.full_name",
+        ]);
+        // Check if the user has liked the article
+        qb.addSelect(`
+          EXISTS (
+            SELECT 1
+            FROM likes l
+            WHERE l.likeable_id = article.id
+              AND l.likeable_type = :articleType
+              AND l.user_id = :user_id
+              AND l.deleted_at IS NULL
+          )
+          `, "has_liked")
+            .setParameter("articleType", IndexEnum_1.SYS_MODELS.ARTICLE_MODEL)
+            .setParameter("user_id", user_id);
+        /* ======================
+          TOTAL COMMENTS COUNT
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(c.id)")
+                .from(ArticleCommentModel_1.default, "c")
+                .where("c.article_id = article.id")
+                .andWhere("c.deleted_at IS NULL");
+        }, "comments_count");
+        /* ======================
+          TOTAL ARTICLE LIKES
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(l.id)")
+                .from(LikeModel_1.default, "l")
+                .where("l.likeable_id = article.id")
+                .andWhere("l.likeable_type = :articleType");
+        }, "likes_count")
+            .setParameter("articleType", IndexEnum_1.SYS_MODELS.ARTICLE_MODEL);
+        /* ======================
+          LAST 4 COMMENTS (WITH META)
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select(`
+              COALESCE(
+                json_agg(
+                  json_build_object(
+                    'id', c.c_id,
+                    'uuid', c.c_uuid,
+                    'content', c.c_content,
+                    'created_at', c.c_created_at,
+
+                    'user', json_build_object(
+                      'id', c.u_id,
+                      'uuid', c.u_uuid,
+                      'full_name', c.u_full_name
+                    ),
+
+                    'likes_count', (
+                      SELECT COUNT(*)
+                      FROM likes cl
+                      WHERE cl.likeable_id = c.c_id
+                      AND cl.likeable_type = '${IndexEnum_1.SYS_MODELS.ARTICLE_COMMENT_MODEL}'
+                    ),
+
+                    'replies_count', (
+                      SELECT COUNT(*)
+                      FROM comments r
+                      WHERE r.parent_id = c.c_id
+                      AND r.deleted_at IS NULL
+                    )
+                  )
+                  ORDER BY c.c_created_at DESC
+                ),
+                '[]'
+              )
+            `)
+                .from(qb2 => {
+                return qb2
+                    .select([
+                    "c.id AS c_id",
+                    "c.uuid AS c_uuid",
+                    "c.created_at AS c_created_at",
+                    "c.content AS c_content",
+                    "u.id AS u_id",
+                    "u.uuid AS u_uuid",
+                    "u.full_name AS u_full_name",
+                ])
+                    .from(ArticleCommentModel_1.default, "c")
+                    .leftJoin("c.user", "u")
+                    .where("c.article_id = article.id")
+                    .andWhere("c.parent_id IS NULL")
+                    .andWhere("c.deleted_at IS NULL")
+                    .orderBy("c.created_at", "DESC")
+                    .limit(4);
+            }, "c");
+        }, "last_comments");
+        /* ======================
+          IMAGES (JSON AGG)
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select(`
+            COALESCE(
+              json_agg(
+                json_build_object(
+                  'id', pi.pi_id,
+                  'uuid', pi.pi_uuid,
+                  'file_name', pi.file_name,
+                  'file_size', pi.file_size,
+                  'file_mimetype', pi.file_mimetype,
+                  'url', pi.url
+                )
+                ORDER BY pi.pi_created_at ASC
+              ) FILTER (WHERE pi.pi_id IS NOT NULL),
+              '[]'
+            )
+          `)
+                .from(qb2 => {
+                return qb2
+                    .select([
+                    "pi.id AS pi_id",
+                    "pi.uuid AS pi_uuid",
+                    "pi.created_at AS pi_created_at",
+                    "u.file_name AS file_name",
+                    "u.file_size AS file_size",
+                    "u.file_mimetype AS file_mimetype",
+                    "u.url AS url",
+                ])
+                    .from(ArticleImageModel_1.default, "pi")
+                    .leftJoin("pi.upload", "u")
+                    .where("pi.article_id = article.id")
+                    .andWhere("pi.deleted_at IS NULL")
+                    .andWhere("u.deleted_at IS NULL");
+            }, "pi");
+        }, "images");
+        /* ======================
+          ORDERING
+        ====================== */
+        qb.orderBy("article.created_at", "DESC");
+        /* ======================
+          PAGINATION
+        ====================== */
+        const { entities, raw } = await qb.getRawAndEntities();
+        const article = entities;
+        if (!article[0] || !raw[0]) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: ArticleResource_1.ArticleResource.toJSON(raw[0], article[0], user_id),
+            message: "Article fetched successfully!"
+        };
+    }
+    async getPagedArticles(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const { data: articles, total, perPage, page } = await this.articleRepository.getPagedArticles({
+            page_number,
+            limit
+        }, user_id);
+        const { entities, raw } = articles;
+        const articlesData = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: ArticleCollection_1.ArticleCollection.toJSON(raw, entities),
+        });
+        return {
+            successful: true,
+            data: articlesData,
+            message: "articles fetched successfully!"
+        };
+    }
+    async getArticles(user_id, community_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const community = await this.communityRepository.basicFindOneByConditions({
+            uuid: 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 dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                community_id: community.id
+            }
+        };
+        const articles = await this.loadPaginatedArticles(dataFetchParams, user_id);
+        if (!articles) {
+            message = messages_1.dynamic_messages.NOT_FOUND("articles");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: articles,
+            message: "articles fetched successfully!"
+        };
+    }
+    async loadPaginatedArticles(paginationDto, userId) {
+        try {
+            const { data, total, perPage, page } = await this.articleRepository.getPagedArticles(paginationDto, userId);
+            const { entities, raw } = data;
+            return (0, Paginator_1.paginator)({
+                total: total,
+                perPage: perPage,
+                currentPage: page,
+                data: ArticleCollection_1.ArticleCollection.toJSON(raw, entities),
+            });
+        }
+        catch (error) {
+            logger_1.logger.error("Error loading messages:", {
+                error: error.message,
+                stack: error.stack,
+            });
+            throw error;
+        }
+    }
+    async updateOneArticle(articleData, article_id, user_id) {
+        let message;
+        const { title, visibility, is_sensitive, description, } = articleData;
+        const article = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id,
+            user_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const updatedArticle = await this.articleRepository.updateOne({
+            uuid: article.uuid,
+            user_id,
+        }, {
+            title: title ?? null,
+            visibility,
+            is_sensitive,
+            description,
+        });
+        return {
+            successful: true,
+            data: updatedArticle,
+            message: "Article updated successfully!"
+        };
+    }
+    async likeOrUnlikeArticle(article_id, user_id) {
+        let message;
+        const article = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id,
+            user_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const alreadyLikedArticle = await this.likeRepository.basicFindOneByConditions({
+            likeable_id: article.id,
+            likeable_type: IndexEnum_1.SYS_MODELS.ARTICLE_MODEL,
+            user_id
+        });
+        if (alreadyLikedArticle) {
+            // Unlike the article
+            await this.likeRepository.deleteByCondition({
+                user_id,
+                likeable_id: article.id,
+                likeable_type: IndexEnum_1.SYS_MODELS.ARTICLE_MODEL
+            });
+            message = "Article unliked successfully";
+        }
+        else {
+            // Like the article
+            await this.likeRepository.create({
+                user_id,
+                likeable_id: article.id,
+                likeable_type: IndexEnum_1.SYS_MODELS.ARTICLE_MODEL
+            });
+            message = "Article liked successfully";
+        }
+        return {
+            successful: true,
+            data: null,
+            message
+        };
+    }
+    async deleteOneArticle(article_id, user_id) {
+        let message;
+        const article = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id,
+            user_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const articleUploads = await this.articleImageRepository.basicFindManyByConditions({
+            article_id: article.id
+        });
+        if (articleUploads?.length) {
+            await Promise.all(articleUploads.map((article_image) => this.uploadService.deleteFile(article_image.image_id, article_image?.article_id, "image")));
+            await this.articleImageRepository.deleteByCondition({ article_id: article.id });
+        }
+        await this.articleRepository.deleteByCondition({
+            uuid: article.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Article deleted successfully!"
+        };
+    }
+    async deleteArticleUpload(article_id, article_image_id, user_id) {
+        let message;
+        const article = await this.articleRepository.basicFindOneByConditions({
+            uuid: article_id,
+            user_id
+        });
+        if (!article) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const articleUpload = await this.articleImageRepository.basicFindOneByConditions({
+            article_id: article.id,
+            uuid: article_image_id
+        });
+        if (!articleUpload) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Article File");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        this.uploadService.deleteFile(articleUpload.image_id, articleUpload?.article_id, "image");
+        await this.articleImageRepository.deleteByCondition({ article_id: article.id });
+        return {
+            successful: true,
+            data: null,
+            message: "Article image deleted successfully!"
+        };
+    }
+    async getUserThatLikedArticle(article_id, user_id, pageNumber) {
+        let message;
+        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 page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                article_id: article.id
+            }
+        };
+        const { data, total, perPage, page } = await this.likeRepository.getPagedArticleUserLikes(dataFetchParams, user_id);
+        const { entities, raw } = data;
+        const articleUserLikes = 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 articleLikes = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: articleUserLikes,
+        });
+        return {
+            successful: true,
+            data: articleLikes,
+            message: "User likes fetched successfully!"
+        };
+    }
+};
+ArticleService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], ArticleService);
+exports.default = ArticleService;