@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/CommunityService.js

@@ -0,0 +1,561 @@
+"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 CommunityRepository_1 = require("@/repositories/CommunityRepository");
+const TopicRepository_1 = require("@/repositories/TopicRepository");
+const CommunityTopicRepository_1 = require("@/repositories/CommunityTopicRepository");
+const CommunityMemberRepository_1 = require("@/repositories/CommunityMemberRepository");
+const CommunityEnum_1 = require("@/common/enums/CommunityEnum");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const CommunityResource_1 = require("@/transformers/resources/CommunityResource");
+const CommunityMemberModel_1 = __importDefault(require("@/models/CommunityMemberModel"));
+const PostModel_1 = __importDefault(require("@/models/PostModel"));
+const CommunityTopicModel_1 = __importDefault(require("@/models/CommunityTopicModel"));
+let CommunityService = class CommunityService {
+    communityRepository;
+    uploadService;
+    topicRepository;
+    communityTopicRepository;
+    communityMemberRepository;
+    constructor() {
+        this.communityRepository = new CommunityRepository_1.CommunityRepository();
+        this.topicRepository = new TopicRepository_1.TopicRepository();
+        this.uploadService = new UploadService_1.default();
+        this.communityTopicRepository = new CommunityTopicRepository_1.CommunityTopicRepository();
+        this.communityMemberRepository = new CommunityMemberRepository_1.CommunityMemberRepository();
+    }
+    async createCommunity(communityData, user_id) {
+        let message;
+        const { name, visibility, topics, cover_image, profile_image, description, } = communityData;
+        let foundTopics = [];
+        let createdTopics = [];
+        topics?.map(async (topic) => {
+            if (!topic) {
+                message = "Topic is required!";
+                logger_1.logger.info(message);
+                throw new AppError_1.AppError(message, 404);
+            }
+            const foundTopic = await this.topicRepository.getRepo().findOne({
+                select: ['name', 'uuid', 'id'],
+                where: {
+                    uuid: topic
+                }
+            });
+            if (!foundTopic) {
+                message = messages_1.dynamic_messages.NOT_FOUND("Topic");
+                logger_1.logger.info(message);
+                throw new AppError_1.AppError(message, 404);
+            }
+            foundTopics.push(foundTopic.id);
+            createdTopics.push(foundTopic);
+        });
+        const createdCommunity = await this.communityRepository.create({
+            name,
+            description,
+            visibility,
+            user_id
+        });
+        const communityId = createdCommunity.id;
+        logger_1.logger.info("Community created without cover image");
+        if (profile_image) {
+            const uploadedProfileImageFile = await this.uploadService.uploadImage(profile_image, communityId, UploadEnum_1.UploadDirectories.COMMUNITY_PROFILE_IMAGES, "CommunityModel");
+            await this.communityRepository.updateOne({
+                uuid: createdCommunity.uuid,
+                user_id,
+            }, {
+                profile_image_id: uploadedProfileImageFile.id,
+            });
+            logger_1.logger.info("Community profile image added successfully");
+        }
+        if (cover_image) {
+            const uploadedCoverImageFile = await this.uploadService.uploadImage(cover_image, communityId, UploadEnum_1.UploadDirectories.COMMUNITY_COVER_IMAGES, "CommunityModel");
+            logger_1.logger.info("Community cover image successfully created");
+            await this.communityRepository.updateOne({
+                uuid: createdCommunity.uuid,
+                user_id,
+            }, {
+                cover_image_id: uploadedCoverImageFile.id,
+            });
+            logger_1.logger.info("Community cover image added successfully");
+        }
+        foundTopics.map(async (topic) => {
+            await this.communityTopicRepository.create({
+                community_id: communityId,
+                topic_id: topic,
+            });
+        });
+        await this.communityMemberRepository.create({
+            community_id: communityId,
+            member_id: user_id,
+            role: CommunityEnum_1.CommunityRole.OWNER
+        });
+        return {
+            successful: true,
+            data: {
+                community_id: createdCommunity.uuid,
+                topics: createdTopics,
+            },
+            message: "Community created successfully"
+        };
+    }
+    async getCommunityCreationData() {
+        const topics = await this.topicRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        return {
+            successful: true,
+            data: {
+                topics
+            },
+            message: "Community creation data fetched successfully!"
+        };
+    }
+    async getOneCommunity(community_id, user_id) {
+        let message;
+        const qb = this.communityRepository
+            .getRepo()
+            .createQueryBuilder("community")
+            /* BASE COMMUNITY QUERY LOGIC */
+            .leftJoinAndSelect("community.user", "user")
+            .leftJoinAndSelect("community.cover_image", "cover_image")
+            .leftJoinAndSelect("community.profile_image", "profile_image")
+            .where("community.deleted_at IS NULL")
+            .andWhere("community.uuid = :community_id", {
+            community_id,
+        });
+        /* ======================
+          SELECT FIELDS (SAFE)
+        ====================== */
+        qb.select([
+            "community.uuid",
+            "community.id",
+            "community.name",
+            "community.description",
+            "community.visibility",
+            "community.created_at",
+            "user.uuid",
+            "user.full_name",
+            "cover_image.uuid",
+            "cover_image.url",
+            "profile_image.uuid",
+            "profile_image.url",
+        ]);
+        /* MEMBERS COUNT */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(community_member.id)", "count")
+                .from(CommunityMemberModel_1.default, "community_member")
+                .where("community_member.community_id = community.id");
+        }, "members_count");
+        /* NEW MEMBERS COUNT */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select(`
+                          COUNT(
+                            CASE
+                              WHEN cm.created_at >= (
+                                date_trunc('week', now() + interval '1 day') - interval '1 day'
+                              )
+                              THEN 1
+                            END
+                          )
+                        `)
+                .from(CommunityMemberModel_1.default, "cm")
+                .where("cm.community_id = community.id")
+                .andWhere("cm.deleted_at IS NULL");
+        }, "new_members_this_week");
+        /* POSTS COUNT */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select("COUNT(post.id)", "count")
+                .from(PostModel_1.default, "post")
+                .where("post.community_id = community.id");
+        }, "posts_count");
+        /* 4 TOPICS */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select(`
+                          json_agg(
+                            json_build_object(
+                              'id', topic.id,
+                              'name', topic.name
+                            )
+                          )
+                        `)
+                .from(CommunityTopicModel_1.default, "ct")
+                .leftJoin("ct.community_topic", "topic")
+                .where("ct.community_id = community.id")
+                .limit(4);
+        }, "community_topics");
+        /* LAST 4 MEMBERS + USER DETAILS */
+        qb.addSelect(subQuery => {
+            return subQuery
+                .select(`
+                          json_agg(
+                            json_build_object(
+                              'id', cm.member_id,
+                              'joined_at', cm.joined_at,
+                              'role', cm.role,
+                              'user', json_build_object(
+                                'id', cm.user_id,
+                                'uuid', cm.user_uuid,
+                                'full_name', cm.user_full_name
+                              )
+                            )
+                          )
+                        `)
+                .from(qb2 => {
+                return qb2
+                    .select([
+                    "cm.id AS member_id",
+                    "cm.created_at AS joined_at",
+                    "cm.role AS role",
+                    "u.id AS user_id",
+                    "u.uuid AS user_uuid",
+                    "u.full_name AS user_full_name",
+                ])
+                    .from(CommunityMemberModel_1.default, "cm")
+                    .leftJoin("cm.member", "u")
+                    .where("cm.community_id = community.id")
+                    .andWhere("cm.deleted_at IS NULL")
+                    .orderBy("cm.created_at", "DESC")
+                    .limit(4);
+            }, "cm");
+        }, "last_members");
+        /* ---------- DATA QUERY ---------- */
+        const { entities, raw } = await qb.getRawAndEntities();
+        const community = entities;
+        const { uuid, visibility, name, description, cover_image, profile_image, created_at, user } = community[0];
+        const { members_count, new_members_this_week, posts_count, community_topics, last_members } = raw[0];
+        const data = {
+            uuid,
+            visibility,
+            name,
+            description,
+            cover_image: cover_image?.url,
+            profile_image: profile_image?.url,
+            created_at,
+            created_by: {
+                uuid: user?.uuid,
+                full_name: user?.full_name,
+            },
+            members_count,
+            owned_by_me: user_id === user?.id,
+            new_members_this_week,
+            posts_count,
+            community_topics,
+            last_members,
+        };
+        if (!community[0]) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Community");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data,
+            message: "Community fetched successfully!"
+        };
+    }
+    async getCommunities(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+        };
+        const communities = await this.loadPaginatedCommunities(dataFetchParams, user_id);
+        if (!communities) {
+            message = messages_1.dynamic_messages.NOT_FOUND("communities");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: communities,
+            message: "communities fetched successfully!"
+        };
+    }
+    async recommendedCommunities(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                user_id,
+                recommendation: true
+            }
+        };
+        const communities = await this.loadPaginatedCommunities(dataFetchParams, user_id);
+        if (!communities) {
+            message = messages_1.dynamic_messages.NOT_FOUND("communities");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: communities,
+            message: "communities fetched successfully!"
+        };
+    }
+    // public async getRecommendedCommunities(user_id: number, pageNumber?: number):
+    //   Promise<ServiceResponseDTO> {
+    //   let message;
+    //   const page_number = pageNumber || 1;
+    //   const data_fetch_limit = CONFIGS.DATA_FETCH_LIMIT || 10;
+    //   const limit = (page_number - 1) * data_fetch_limit;
+    //   const userRepository = new UserRepository();
+    //   const existingUser = await userRepository.findOneAndRelations({
+    //     where: {
+    //       id: user_id
+    //     },
+    //     relations: ['user_profile']
+    //   });
+    //   if (!existingUser) {
+    //     const message = dynamic_messages.NOT_FOUND("User");
+    //     logger.info(message)
+    //     throw new AppError(message)
+    //   }
+    //   const location = existingUser?.user_profile?.location;
+    //   const recommendationOptions: RecommendationOptions = {
+    //     page_number,
+    //     limit,
+    //     user_id,
+    //     lat: location?.coordinates?.lat,
+    //     lng: location?.coordinates?.long,
+    //     city: location?.city,
+    //     state: location?.state,
+    //     country: location?.country,
+    //     connections: [],
+    //   };
+    //   const communities = await this.recommendCommunities(recommendationOptions)
+    //   return {
+    //     successful: true,
+    //     data: communities,
+    //     message: "communities fetched successfully!"
+    //   };
+    // }
+    async loadPaginatedCommunities(paginationDto, userId) {
+        let message;
+        try {
+            const { data, total, perPage, page } = await this.communityRepository.getPagedCommunityData(paginationDto, userId);
+            const { entities, raw } = data;
+            const communityEntities = entities;
+            const rawCommunities = raw;
+            if (!communityEntities || !rawCommunities) {
+                message = messages_1.dynamic_messages.NOT_FOUND("Communities");
+                logger_1.logger.info(message);
+                throw new AppError_1.AppError(message, 404);
+            }
+            const communityCollections = communityEntities.map((communityEntity, index) => {
+                const { uuid, visibility, created_at, name, description, user } = communityEntity;
+                return {
+                    uuid,
+                    created_at,
+                    name,
+                    visibility,
+                    description,
+                    creator: {
+                        uuid: user?.uuid,
+                        full_name: user?.full_name,
+                        avatar_url: rawCommunities[index]?.creator_avatar_url,
+                    },
+                    community_cover_image_url: rawCommunities[index]?.cover_image_url,
+                    community_profile_image_url: rawCommunities[index]?.profile_image_url,
+                    members_count: rawCommunities[index]?.members_count,
+                    new_members_this_week: rawCommunities[index]?.new_members_this_week,
+                    community_topics: rawCommunities[index]?.community_topics,
+                    posts_count: rawCommunities[index]?.posts_count,
+                    last_members: rawCommunities[index]?.last_members,
+                };
+            });
+            return (0, Paginator_1.paginator)({
+                total,
+                perPage,
+                currentPage: page,
+                data: communityCollections
+            });
+        }
+        catch (error) {
+            logger_1.logger.error("Error loading communities:", {
+                error: error.message,
+                stack: error.stack,
+            });
+            throw error;
+        }
+    }
+    async updateOneCommunity(communityData, community_id, user_id) {
+        let message;
+        const { name, visibility, topics, cover_image, profile_image, description, } = communityData;
+        let foundTopics = [];
+        let optionalFieldsToUpdate = {};
+        const community = await this.communityRepository.basicFindOneByConditions({
+            uuid: community_id,
+            user_id
+        });
+        if (!community) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Community");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        topics?.map(async (topic) => {
+            if (!topic) {
+                message = "Topic is required!";
+                logger_1.logger.info(message);
+                throw new AppError_1.AppError(message, 404);
+            }
+            const foundTopic = await this.topicRepository.getRepo().findOne({
+                select: ['name', 'uuid', 'id'],
+                where: {
+                    uuid: topic
+                }
+            });
+            if (!foundTopic) {
+                message = messages_1.dynamic_messages.NOT_FOUND("Topic");
+                logger_1.logger.info(message);
+                throw new AppError_1.AppError(message, 404);
+            }
+            foundTopics.push(foundTopic.id);
+        });
+        if (cover_image) {
+            await this.uploadService.deleteFile(community?.cover_image_id, community?.id, "image");
+            const uploadedCoverImageFile = await this.uploadService.uploadImage(cover_image, community?.id, UploadEnum_1.UploadDirectories.COMMUNITY_COVER_IMAGES, "CommunityModel");
+            optionalFieldsToUpdate.cover_image_id = uploadedCoverImageFile.id;
+        }
+        if (profile_image) {
+            await this.uploadService.deleteFile(community?.profile_image_id, community?.id, "image");
+            const uploadedProfileImageFile = await this.uploadService.uploadImage(profile_image, community?.id, UploadEnum_1.UploadDirectories.COMMUNITY_PROFILE_IMAGES, "CommunityModel");
+            optionalFieldsToUpdate.profile_image_id = uploadedProfileImageFile.id;
+        }
+        await this.communityRepository.updateOne({
+            uuid: community.uuid,
+            user_id,
+        }, {
+            name,
+            description,
+            visibility,
+            ...optionalFieldsToUpdate,
+        });
+        await this.communityTopicRepository.deleteByCondition({
+            community_id: community.id
+        });
+        foundTopics.map(async (topic) => {
+            await this.communityTopicRepository.create({
+                community_id: community.id,
+                topic_id: topic,
+            });
+        });
+        return {
+            successful: true,
+            data: CommunityResource_1.CommunityResource.toJSON(community),
+            message: "Community updated successfully!"
+        };
+    }
+    async deleteOneCommunity(community_id, user_id) {
+        let message;
+        const community = await this.communityRepository.basicFindOneByConditions({
+            uuid: community_id,
+            user_id
+        });
+        if (!community) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Community");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (community.user_id === user_id) {
+            message = `You cannot delete a community you didn't create`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        await this.uploadService.deleteFile(community?.cover_image_id, community?.id, "image");
+        await this.uploadService.deleteFile(community?.profile_image_id, community?.id, "image");
+        await this.communityTopicRepository.deleteByCondition({
+            community_id: community.id
+        });
+        await this.communityMemberRepository.deleteByCondition({
+            community_id: community.id
+        });
+        await this.communityRepository.deleteByCondition({
+            uuid: community.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Community deleted successfully!"
+        };
+    }
+    async searchCommunities(search_string, user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const data_fetch_limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const limit = (page_number - 1) * data_fetch_limit;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                search_string
+            }
+        };
+        const communities = await this.loadPaginatedCommunities(dataFetchParams, user_id);
+        if (!communities) {
+            message = messages_1.dynamic_messages.NOT_FOUND("communities");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: communities,
+            message: "communities fetched successfully!"
+        };
+    }
+    async communitiesIOwn(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                user_id
+            }
+        };
+        const communities = await this.loadPaginatedCommunities(dataFetchParams, user_id);
+        if (!communities) {
+            message = messages_1.dynamic_messages.NOT_FOUND("communities");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: communities,
+            message: "My communities fetched successfully!"
+        };
+    }
+};
+CommunityService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], CommunityService);
+exports.default = CommunityService;