@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/ChatService.js

@@ -0,0 +1,324 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typedi_1 = require("typedi");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const ChatMessageRepository_1 = require("@/repositories/ChatMessageRepository");
+const AppError_1 = require("@/common/errors/AppError");
+const UserRepository_1 = require("@/repositories/UserRepository");
+const logger_1 = require("@/common/configs/logger");
+const messages_1 = require("@/common/constants/messages");
+const ConversationRepository_1 = require("@/repositories/ConversationRepository");
+const ChatEnum_1 = require("@/common/enums/ChatEnum");
+const typeorm_1 = require("typeorm");
+const NotificationEnum_1 = require("@/common/enums/NotificationEnum");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const NotificationRepository_1 = require("@/repositories/NotificationRepository");
+// import { ChatRepository } from "@/repositories/ChatRepository";
+// import { ChatCollection } from "@/transformers/collections/ChatCollection";
+let ChatService = class ChatService {
+    chatMessageRepository;
+    notificationRepository;
+    conversationRepository;
+    userRepository;
+    constructor() {
+        this.notificationRepository = new NotificationRepository_1.NotificationRepository();
+        this.chatMessageRepository = new ChatMessageRepository_1.ChatMessageRepository();
+        this.conversationRepository = new ConversationRepository_1.ConversationRepository();
+        this.userRepository = new UserRepository_1.UserRepository();
+    }
+    async joinChat(user_id, user_to_join_id) {
+        if (!user_to_join_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the user you want start or continue a chat with", 422);
+        }
+        let message;
+        const authUser = await this.userRepository.basicFindOneByConditions({
+            uuid: user_id
+        });
+        if (!authUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Auth User");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const otherUser = await this.userRepository.basicFindOneByConditions({
+            uuid: user_to_join_id
+        });
+        if (!otherUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("User");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        let conversation = await this.conversationRepository.getRepo()
+            .createQueryBuilder("c")
+            .leftJoinAndSelect("c.participants", "p")
+            .where("p.id IN (:...ids)", { ids: [authUser.id, otherUser.id] })
+            .getOne();
+        if (!conversation) {
+            conversation = await this.conversationRepository.create({ participants: [authUser, otherUser] });
+        }
+        return {
+            successful: true,
+            data: {
+                ...conversation
+            },
+            message: `Chat joined successfully`
+        };
+    }
+    async sendMessage(authUserId, conversation_id, message_body) {
+        if (!conversation_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the conversation you want to send a message to", 422);
+        }
+        let message;
+        const foundConversation = await this.conversationRepository.getRepo()
+            .createQueryBuilder("c")
+            .leftJoinAndSelect("c.participants", "p")
+            .where("c.uuid = :conversation_id", { conversation_id })
+            .andWhere("p.id = :authUserId", { authUserId })
+            .getOne();
+        if (!foundConversation) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Conversation");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const sentMessage = await this.chatMessageRepository.create({
+            text: message_body,
+            sender_id: authUserId,
+            sent_at: new Date(),
+            conversation_id: foundConversation.id,
+        });
+        const connectionReceiver = foundConversation?.participants[0];
+        await this.notificationRepository.save({
+            user_id: connectionReceiver.id,
+            type: NotificationEnum_1.NotificationType.NEW_CHAT_MESSAGE,
+            message: `You have a new message from ${connectionReceiver.full_name}`,
+            notifiable_id: sentMessage.id,
+            notifiable_type: IndexEnum_1.SYS_MODELS.CHAT_MESSAGE_MODEL,
+        });
+        return {
+            successful: true,
+            data: {
+                ...sentMessage,
+                conversation_id: foundConversation.uuid,
+            },
+            message: `Message sent successfully`
+        };
+    }
+    async readMessage(authUserId, conversation_id, message_id) {
+        if (!conversation_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the conversation you want to read a message from", 422);
+        }
+        let message;
+        const foundConversation = await this.conversationRepository.getRepo()
+            .createQueryBuilder("c")
+            .leftJoin("c.participants", "p")
+            .where("c.uuid = :conversation_id", { conversation_id })
+            .andWhere("p.id = :authUserId", { authUserId })
+            .getOne();
+        if (!foundConversation) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Conversation");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const foundMessage = await this.chatMessageRepository.basicFindOneByConditions({
+            uuid: message_id
+        });
+        if (!foundMessage) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Message");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (foundMessage.sender_id !== authUserId) {
+            await this.chatMessageRepository.updateOne({
+                uuid: message_id,
+                conversation_id: foundConversation.id
+            }, {
+                read_at: new Date(),
+                status: ChatEnum_1.MessageStatus.READ
+            });
+        }
+        return {
+            successful: true,
+            data: {
+                ...foundMessage,
+                conversation_id: foundConversation.uuid,
+            },
+            message: `Message read successfully`
+        };
+    }
+    async deliveredMessage(authUserId, conversation_id, message_id) {
+        if (!conversation_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the conversation.", 422);
+        }
+        let message;
+        const foundConversation = await this.conversationRepository.getRepo()
+            .createQueryBuilder("c")
+            .leftJoin("c.participants", "p")
+            .where("c.uuid = :conversation_id", { conversation_id })
+            .andWhere("p.id = :authUserId", { authUserId })
+            .getOne();
+        if (!foundConversation) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Conversation");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const foundMessage = await this.chatMessageRepository.basicFindOneByConditions({
+            uuid: message_id
+        });
+        if (!foundMessage) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Message");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (foundMessage.sender_id !== authUserId) {
+            await this.chatMessageRepository.updateOne({
+                uuid: message_id,
+                conversation_id: foundConversation.id
+            }, {
+                delivered_at: new Date(),
+                status: ChatEnum_1.MessageStatus.DELIVERED
+            });
+        }
+        return {
+            successful: true,
+            data: {
+                ...foundMessage,
+                conversation_id: foundConversation.uuid,
+            },
+            message: `Message delivered successfully`
+        };
+    }
+    async loadConversations(authUserId, conversation_id, pageNumber) {
+        if (!conversation_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the conversation.", 422);
+        }
+        let message;
+        const foundConversation = await this.conversationRepository.getRepo()
+            .createQueryBuilder("c")
+            .leftJoin("c.participants", "p")
+            .where("c.uuid = :conversation_id", { conversation_id })
+            .andWhere("p.id = :authUserId", { authUserId })
+            .getOne();
+        if (!foundConversation) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Conversation");
+            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
+        };
+        const { data, total, perPage, page } = await this.conversationRepository.getPagedConversations(dataFetchParams);
+        const { raw, entities } = data;
+        const messages = (0, Paginator_1.paginator)({
+            total: total,
+            perPage: perPage,
+            currentPage: page,
+            data: entities,
+        });
+        // Set as delivered
+        await this.chatMessageRepository.getRepo().update({
+            conversation_id: foundConversation.id,
+            status: ChatEnum_1.MessageStatus.SENT,
+            sender_id: (0, typeorm_1.Not)(authUserId)
+        }, {
+            delivered_at: new Date(),
+            status: ChatEnum_1.MessageStatus.DELIVERED
+        });
+        // Set as read
+        await this.chatMessageRepository.getRepo().update({
+            conversation_id: foundConversation.id,
+            sender_id: (0, typeorm_1.Not)(authUserId),
+            status: ChatEnum_1.MessageStatus.DELIVERED
+        }, {
+            read_at: new Date(),
+            status: ChatEnum_1.MessageStatus.READ
+        });
+        return {
+            successful: true,
+            data: messages,
+            message: `Messages fetched successfully`
+        };
+    }
+    async updateMessage(authUserId, message_id, message_body) {
+        if (!message_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the message you want to update", 422);
+        }
+        let message;
+        const foundMessage = await this.chatMessageRepository.basicFindOneByConditions({
+            uuid: message_id
+        });
+        if (!foundMessage) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Message");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (foundMessage.sender_id !== authUserId) {
+            message = "You are not authorized to update this message";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        await this.chatMessageRepository.updateOne({
+            uuid: message_id,
+            sender_id: authUserId
+        }, {
+            read_at: null,
+            sent_at: new Date(),
+            delivered_at: null,
+            text: message_body,
+            status: ChatEnum_1.MessageStatus.SENT
+        });
+        return {
+            successful: true,
+            data: {
+                ...foundMessage,
+            },
+            message: `Message updated successfully`
+        };
+    }
+    async deleteMessage(authUserId, message_id) {
+        if (!message_id) {
+            throw new AppError_1.AppError("You need to provide the ID of the message you want to update", 422);
+        }
+        let message;
+        const foundMessage = await this.chatMessageRepository.basicFindOneByConditions({
+            uuid: message_id
+        });
+        if (!foundMessage) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Message");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (foundMessage.sender_id !== authUserId) {
+            message = "You are not authorized to delete this message";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 403);
+        }
+        await this.chatMessageRepository.deleteByCondition({
+            uuid: message_id,
+            sender_id: authUserId
+        });
+        return {
+            successful: true,
+            data: {
+                ...foundMessage,
+            },
+            message: `Message deleted successfully`
+        };
+    }
+};
+ChatService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], ChatService);
+exports.default = ChatService;

package/dist/services/mobile/CommunityMemberService.js

@@ -0,0 +1,193 @@
+"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);
+};
+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 CommunityRepository_1 = require("@/repositories/CommunityRepository");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const CommunityMemberRepository_1 = require("@/repositories/CommunityMemberRepository");
+let CommunityMemberService = class CommunityMemberService {
+    communityRepository;
+    communityMemberRepository;
+    constructor() {
+        this.communityRepository = new CommunityRepository_1.CommunityRepository();
+        this.communityMemberRepository = new CommunityMemberRepository_1.CommunityMemberRepository();
+    }
+    async joinCommunity(community_id, user_id) {
+        let message;
+        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 alreadyMember = await this.communityMemberRepository.getRepo().findOne({
+            where: {
+                community_id: community.id,
+                member_id: user_id
+            }
+        });
+        if (!alreadyMember) {
+            await this.communityMemberRepository.create({
+                community_id: community.id,
+                member_id: user_id
+            });
+        }
+        return {
+            successful: true,
+            data: null,
+            message: `You successfully joined '${community.name}' community`
+        };
+    }
+    async leaveCommunity(community_id, user_id) {
+        let message;
+        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);
+        }
+        if (community.user_id === user_id) {
+            message = "You cannot leave an community you created";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const alreadyMember = await this.communityMemberRepository.getRepo().findOne({
+            where: {
+                community_id: community.id,
+                member_id: user_id
+            }
+        });
+        if (!alreadyMember) {
+            message = `You are not attending community ${community.name}`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.communityMemberRepository.deleteByCondition({
+            community_id: community.id,
+            member_id: user_id
+        });
+        return {
+            successful: true,
+            data: null,
+            message: `You successfully left '${community.name}' community`
+        };
+    }
+    async communitiesIamMember(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const paginationDto = {
+            page_number, limit
+        };
+        const { data, total, perPage, page } = await this.communityRepository.getPagedCommunityMembers(paginationDto, user_id);
+        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,
+            };
+        });
+        const pagedCommunities = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: communityCollections
+        });
+        return {
+            successful: true,
+            data: pagedCommunities,
+            message: "Communities I am a member fetched successfully!"
+        };
+    }
+    async communityMembers(community_id, user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const foundCommunity = await this.communityRepository.basicFindOneByConditions({
+            uuid: community_id
+        });
+        if (!foundCommunity) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Community");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message);
+        }
+        const { data, total, page, perPage } = await this.communityMemberRepository.getPagedMembersInCommunity({
+            page_number,
+            limit
+        }, foundCommunity.id);
+        const { entities, raw } = data;
+        const attendanceEntities = entities;
+        const rawAttendance = raw;
+        const attendance = rawAttendance.map((attendanceEntity, index) => {
+            const { cm_id, cm_created_at, community_created_at, user_id, uuid, full_name, email, joined_at, profile_image_uuid, profile_image_url } = attendanceEntity;
+            return {
+                created_at: cm_created_at,
+                uuid,
+                full_name,
+                joined_at,
+                profile_image_uuid,
+                profile_image_url,
+            };
+        });
+        const communityAttendance = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: attendance, //CommunityCollection.toJSON(attendance?.data, userId),
+        });
+        if (!communityAttendance) {
+            message = messages_1.dynamic_messages.NOT_FOUND("CommunityAttendance");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: communityAttendance,
+            message: "Community members fetched successfully!"
+        };
+    }
+};
+CommunityMemberService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], CommunityMemberService);
+exports.default = CommunityMemberService;