@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/PostService.js

@@ -0,0 +1,640 @@
+"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 PostRepository_1 = require("@/repositories/PostRepository");
+const PostImageRepository_1 = require("@/repositories/PostImageRepository");
+const PostCollection_1 = require("../../transformers/collections/PostCollection");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const PostResource_1 = require("@/transformers/resources/PostResource");
+const CommunityMemberRepository_1 = require("@/repositories/CommunityMemberRepository");
+const CommunityRepository_1 = require("@/repositories/CommunityRepository");
+const LikeRepository_1 = require("@/repositories/LikeRepository");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const CommentModel_1 = __importDefault(require("@/models/CommentModel"));
+const LikeModel_1 = __importDefault(require("@/models/LikeModel"));
+const PostImageModel_1 = __importDefault(require("@/models/PostImageModel"));
+const TopicRepository_1 = require("@/repositories/TopicRepository");
+let PostService = class PostService {
+    postRepository;
+    uploadService;
+    postImageRepository;
+    communityMemberRepository;
+    communityRepository;
+    likeRepository;
+    topicRepository;
+    constructor() {
+        this.postRepository = new PostRepository_1.PostRepository();
+        this.uploadService = new UploadService_1.default();
+        this.postImageRepository = new PostImageRepository_1.PostImageRepository();
+        this.communityRepository = new CommunityRepository_1.CommunityRepository();
+        this.communityMemberRepository = new CommunityMemberRepository_1.CommunityMemberRepository();
+        this.likeRepository = new LikeRepository_1.LikeRepository();
+        this.topicRepository = new TopicRepository_1.TopicRepository();
+    }
+    async createPost(postData, user_id) {
+        let message;
+        const { title, visibility, community_id, is_boosted, is_sensitive, post_images, description, } = postData;
+        if (post_images && post_images?.length > 5) {
+            message = "Maximum of 5 images allowed";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        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 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 post!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const createdPost = await this.postRepository.create({
+            title: title ?? null,
+            visibility,
+            is_boosted,
+            is_sensitive,
+            description,
+            community_id: community.id,
+            user_id
+        });
+        const postId = createdPost.id;
+        logger_1.logger.info("Post created without cover image");
+        if (post_images?.length) {
+            const uploadedFiles = await Promise.all(post_images.map((post_image) => this.uploadService.uploadImage(post_image, postId, UploadEnum_1.UploadDirectories.COMMUNITY_POST_IMAGES, "PostModel")));
+            await Promise.all(uploadedFiles.map((file) => this.postImageRepository.create({
+                post_id: postId,
+                image_id: file.id,
+            })));
+        }
+        return {
+            successful: true,
+            data: {
+                post: {
+                    created_at: createdPost.created_at
+                }
+            },
+            message: "Post created successfully"
+        };
+    }
+    async getOnePost(post_id, user_id) {
+        let message;
+        const foundPost = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id
+        });
+        if (!foundPost) {
+            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: foundPost.community_id
+        });
+        if (!community) {
+            message = "We couldn't find the community that owns the post you want see";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const qb = this.postRepository
+            .getRepo()
+            .createQueryBuilder("post")
+            .leftJoin("post.user", "user")
+            .leftJoin("post.community", "community")
+            .where("post.deleted_at IS NULL")
+            .andWhere("post.uuid = :postId", {
+            postId: post_id,
+        });
+        /* ======================
+          POST FIELDS
+        ====================== */
+        qb.select([
+            "post.id",
+            "post.uuid",
+            "post.title",
+            "post.description",
+            "post.visibility",
+            "post.is_boosted",
+            "post.is_sensitive",
+            "post.created_at",
+            "user.id",
+            "user.uuid",
+            "user.full_name",
+            "community.id",
+            "community.uuid",
+            "community.name",
+        ]);
+        // Check if the user is a member of the community
+        qb.addSelect(`
+        EXISTS (
+          SELECT 1
+          FROM community_members cm
+          WHERE cm.community_id = post.community_id
+            AND cm.member_id = :user_id
+            AND cm.deleted_at IS NULL
+        )
+        `, "is_member").setParameter("user_id", user_id);
+        // Check if the user has liked the post
+        qb.addSelect(`
+          EXISTS (
+            SELECT 1
+            FROM likes l
+            WHERE l.likeable_id = post.id
+              AND l.likeable_type = :postType
+              AND l.user_id = :user_id
+              AND l.deleted_at IS NULL
+          )
+          `, "has_liked")
+            .setParameter("postType", IndexEnum_1.SYS_MODELS.POST_MODEL)
+            .setParameter("user_id", user_id);
+        /* ======================
+          TOTAL COMMENTS COUNT
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(c.id)")
+                .from(CommentModel_1.default, "c")
+                .where("c.post_id = post.id")
+                .andWhere("c.deleted_at IS NULL");
+        }, "comments_count");
+        /* ======================
+          TOTAL POST LIKES
+        ====================== */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(l.id)")
+                .from(LikeModel_1.default, "l")
+                .where("l.likeable_id = post.id")
+                .andWhere("l.likeable_type = :postType");
+        }, "likes_count")
+            .setParameter("postType", IndexEnum_1.SYS_MODELS.POST_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.POST_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(CommentModel_1.default, "c")
+                    .leftJoin("c.user", "u")
+                    .where("c.post_id = post.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(PostImageModel_1.default, "pi")
+                    .leftJoin("pi.upload", "u")
+                    .where("pi.post_id = post.id")
+                    .andWhere("pi.deleted_at IS NULL")
+                    .andWhere("u.deleted_at IS NULL");
+            }, "pi");
+        }, "images");
+        /* ======================
+          ORDERING
+        ====================== */
+        qb.orderBy("post.created_at", "DESC");
+        /* ======================
+          PAGINATION
+        ====================== */
+        const { entities, raw } = await qb.getRawAndEntities();
+        const post = entities;
+        if (!post[0] || !raw[0]) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: PostResource_1.PostResource.toJSON(raw[0], post[0], user_id),
+            message: "Post fetched successfully!"
+        };
+    }
+    async getCommunitiesPostsByTopic(topic_id, user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const foundTopic = await this.topicRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: { uuid: topic_id }
+        });
+        if (!foundTopic) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Topic");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const { data: posts, total, perPage, page } = await this.postRepository.getCommunitiesPostsByTopic({
+            page_number,
+            limit
+        }, user_id, foundTopic.id);
+        const { entities, raw } = posts;
+        const postsData = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: PostCollection_1.PostCollection.toJSON(raw, entities),
+        });
+        return {
+            successful: true,
+            data: postsData,
+            message: "posts fetched successfully!"
+        };
+    }
+    async exploreCommunityPosts(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const { data: posts, total, perPage, page } = await this.postRepository.getPageCommunityPosts({
+            page_number,
+            limit
+        }, user_id);
+        const { entities, raw } = posts;
+        const postsData = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: PostCollection_1.PostCollection.toJSON(raw, entities),
+        });
+        return {
+            successful: true,
+            data: postsData,
+            message: "posts fetched successfully!"
+        };
+    }
+    async getTrendingPosts(user_id, pageNumber) {
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const { data: posts, total, perPage, page } = await this.postRepository.getPagedTrendingPosts({
+            page_number,
+            limit
+        }, user_id);
+        const { entities, raw } = posts;
+        const postsData = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: PostCollection_1.PostCollection.toJSON(raw, entities),
+        });
+        return {
+            successful: true,
+            data: postsData,
+            message: "Posts fetched successfully!"
+        };
+    }
+    async getPosts(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 posts = await this.loadPaginatedPosts(dataFetchParams, user_id);
+        if (!posts) {
+            message = messages_1.dynamic_messages.NOT_FOUND("posts");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: posts,
+            message: "posts fetched successfully!"
+        };
+    }
+    async loadPaginatedPosts(paginationDto, userId) {
+        try {
+            const { data, total, perPage, page } = await this.postRepository.getPagedPosts(paginationDto, userId);
+            const { entities, raw } = data;
+            return (0, Paginator_1.paginator)({
+                total: total,
+                perPage: perPage,
+                currentPage: page,
+                data: PostCollection_1.PostCollection.toJSON(raw, entities),
+            });
+        }
+        catch (error) {
+            logger_1.logger.error("Error loading messages:", {
+                error: error.message,
+                stack: error.stack,
+            });
+            throw error;
+        }
+    }
+    async updateOnePost(postData, post_id, user_id) {
+        let message;
+        const { title, visibility, is_boosted, is_sensitive, description, } = postData;
+        const post = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id,
+            user_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const updatedPost = await this.postRepository.updateOne({
+            uuid: post.uuid,
+            user_id,
+        }, {
+            title: title ?? null,
+            visibility,
+            is_boosted,
+            is_sensitive,
+            description,
+        });
+        return {
+            successful: true,
+            data: updatedPost,
+            message: "Post updated successfully!"
+        };
+    }
+    async likeOrUnlikePost(post_id, user_id) {
+        let message;
+        const post = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id,
+            user_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 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 in it!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const alreadyLikedPost = await this.likeRepository.basicFindOneByConditions({
+            likeable_id: post.id,
+            likeable_type: IndexEnum_1.SYS_MODELS.POST_MODEL,
+            user_id
+        });
+        if (alreadyLikedPost) {
+            // Unlike the post
+            await this.likeRepository.deleteByCondition({
+                user_id,
+                likeable_id: post.id,
+                likeable_type: IndexEnum_1.SYS_MODELS.POST_MODEL
+            });
+            message = "Post unliked successfully";
+        }
+        else {
+            // Like the post
+            await this.likeRepository.create({
+                user_id,
+                likeable_id: post.id,
+                likeable_type: IndexEnum_1.SYS_MODELS.POST_MODEL
+            });
+            message = "Post liked successfully";
+        }
+        return {
+            successful: true,
+            data: null,
+            message
+        };
+    }
+    async deleteOnePost(post_id, user_id) {
+        let message;
+        const post = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id,
+            user_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const postUploads = await this.postImageRepository.basicFindManyByConditions({
+            post_id: post.id
+        });
+        if (postUploads?.length) {
+            await Promise.all(postUploads.map((post_image) => this.uploadService.deleteFile(post_image.image_id, post_image?.post_id, "image")));
+            await this.postImageRepository.deleteByCondition({ post_id: post.id });
+        }
+        await this.postRepository.deleteByCondition({
+            uuid: post.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Post deleted successfully!"
+        };
+    }
+    async deletePostUpload(post_id, post_image_id, user_id) {
+        let message;
+        const post = await this.postRepository.basicFindOneByConditions({
+            uuid: post_id,
+            user_id
+        });
+        if (!post) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const postUpload = await this.postImageRepository.basicFindOneByConditions({
+            post_id: post.id,
+            uuid: post_image_id
+        });
+        if (!postUpload) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Post File");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        this.uploadService.deleteFile(postUpload.image_id, postUpload?.post_id, "image");
+        await this.postImageRepository.deleteByCondition({ post_id: post.id });
+        return {
+            successful: true,
+            data: null,
+            message: "Post image deleted successfully!"
+        };
+    }
+    async getUserThatLikedPost(post_id, user_id, pageNumber) {
+        let message;
+        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";
+            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} community to continue!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                post_id: post.id
+            }
+        };
+        const { data, total, perPage, page } = await this.likeRepository.getPagedPostsUserLikes(dataFetchParams, user_id);
+        const { entities, raw } = data;
+        const postUserLikes = 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 postLikes = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: postUserLikes,
+        });
+        return {
+            successful: true,
+            data: postLikes,
+            message: "User likes fetched successfully!"
+        };
+    }
+};
+PostService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], PostService);
+exports.default = PostService;