@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/CompleteProfileService.js

@@ -0,0 +1,308 @@
+"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 AppError_1 = require("../../common/errors/AppError");
+const UserRepository_1 = require("../../repositories/UserRepository");
+const DiagnosisLevelRepository_1 = require("@/repositories/DiagnosisLevelRepository");
+const InterestRepository_1 = require("@/repositories/InterestRepository");
+const UserEnums_1 = require("@/common/enums/UserEnums");
+const SpeechRepository_1 = require("@/repositories/SpeechRepository");
+const EducationRepository_1 = require("@/repositories/EducationRepository");
+const ChallengeRepository_1 = require("@/repositories/ChallengeRepository");
+const typeorm_1 = require("typeorm");
+const GoalRepository_1 = require("@/repositories/GoalRepository");
+let CompleteProfileService = class CompleteProfileService {
+    userRepository;
+    diagnosisLevelRepository;
+    interestRepository;
+    userProfileRepository;
+    speechRepository;
+    educationRepository;
+    challengeRepository;
+    goalRepository;
+    constructor() {
+        this.userRepository = new UserRepository_1.UserRepository();
+        this.diagnosisLevelRepository = new DiagnosisLevelRepository_1.DiagnosisLevelRepository();
+        this.interestRepository = new InterestRepository_1.InterestRepository();
+        this.userProfileRepository = new UserRepository_1.UserProfileRepository();
+        this.speechRepository = new SpeechRepository_1.SpeechRepository();
+        this.educationRepository = new EducationRepository_1.EducationRepository();
+        this.challengeRepository = new ChallengeRepository_1.ChallengeRepository();
+        this.goalRepository = new GoalRepository_1.GoalRepository();
+    }
+    async submitStepOneForm(createStepOneFormDto, user_id) {
+        let message;
+        const { interest, diagnosis_level, date_of_birth, user_relationship } = createStepOneFormDto;
+        const foundDiagnosis_level = await this.diagnosisLevelRepository.basicFindOneByConditions({ uuid: diagnosis_level });
+        if (!foundDiagnosis_level)
+            throw new AppError_1.AppError('Selected diagnosis level is invalid', 404);
+        const foundInterest = await this.interestRepository.basicFindOneByConditions({ uuid: interest });
+        if (!foundInterest)
+            throw new AppError_1.AppError('Selected interest is invalid', 404);
+        let existingProfile = await this.userProfileRepository.getRepo().findOne({ where: { user: { id: user_id } } });
+        if (existingProfile) {
+            await this.userProfileRepository.updateOne({
+                user_id,
+            }, {
+                diagnosis_level_id: foundDiagnosis_level.id,
+                interest_id: foundInterest.id,
+                account_type: user_relationship,
+                date_of_birth: date_of_birth,
+            });
+        }
+        else {
+            await this.userProfileRepository.create({
+                diagnosis_level_id: foundDiagnosis_level.id,
+                interest_id: foundInterest.id,
+                user_id,
+                account_type: user_relationship,
+                date_of_birth: date_of_birth,
+            });
+        }
+        await this.userRepository.updateOne({
+            id: user_id
+        }, {
+            profile_level: UserEnums_1.ProfileLevel.STEP_ONE
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Step 1 form submitted successfully"
+        };
+    }
+    async getStepOneFormOptions() {
+        const foundDiagnosis_level = await this.diagnosisLevelRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        const foundInterest = await this.interestRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        return {
+            successful: true,
+            data: {
+                interests: foundInterest,
+                diagnosis_levels: foundDiagnosis_level,
+                user_relationship: UserEnums_1.AccountType
+            },
+            message: "Step 1 form data fetched successfully!"
+        };
+    }
+    async submitStepTwoForm(createSteptwoFormDto, user_id) {
+        let message;
+        const { gender, speech } = createSteptwoFormDto;
+        const foundSpeech = await this.speechRepository.basicFindOneByConditions({ uuid: speech });
+        if (!foundSpeech)
+            throw new AppError_1.AppError('Selected speech is invalid', 404);
+        let existingProfile = await this.userProfileRepository.getRepo().findOne({ where: { user: { id: user_id } } });
+        if (existingProfile) {
+            await this.userProfileRepository.updateOne({
+                user_id,
+            }, {
+                gender,
+                speech_id: foundSpeech.id,
+            });
+        }
+        else {
+            await this.userProfileRepository.create({
+                gender,
+                speech_id: foundSpeech.id,
+                user_id,
+            });
+        }
+        await this.userRepository.updateOne({
+            id: user_id
+        }, {
+            profile_level: UserEnums_1.ProfileLevel.STEP_TWO
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Step 2 form submitted successfully"
+        };
+    }
+    async getStepTwoFormOptions() {
+        const speeches = await this.speechRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        return {
+            successful: true,
+            data: {
+                gender: UserEnums_1.GENDER,
+                speeches
+            },
+            message: "Step 2 form data fetched successfully!"
+        };
+    }
+    async submitStepThreeForm(createStepthreeFormDto, user_id) {
+        let message;
+        const { education, challenges_selections, other_challenges } = createStepthreeFormDto;
+        const foundEducation = await this.educationRepository.basicFindOneByConditions({ uuid: education });
+        if (!foundEducation)
+            throw new AppError_1.AppError('Selected education is invalid', 404);
+        let challengesId = [];
+        challenges_selections.map(async (challenge) => {
+            const existingChallenge = await this.challengeRepository.basicFindOneByConditions({ name: challenge });
+            if (!existingChallenge) {
+                const foundChallenge = await this.challengeRepository.basicFindOneByConditions({ uuid: challenge });
+                if (!foundChallenge)
+                    throw new AppError_1.AppError('Selected challenge is invalid', 404);
+                challengesId.push(foundChallenge.id);
+            }
+        });
+        if (other_challenges && other_challenges.length > 0) {
+            other_challenges.map(async (challenge) => {
+                const foundChallenge = await this.challengeRepository.create({
+                    name: challenge,
+                    user_id
+                });
+                challengesId.push(foundChallenge.id);
+            });
+        }
+        let existingProfile = await this.userProfileRepository.getRepo().findOne({ where: { user: { id: user_id } } });
+        if (existingProfile) {
+            await this.userProfileRepository.updateOne({
+                user_id,
+            }, {
+                child_education_id: foundEducation.id,
+                challenges: challengesId,
+            });
+        }
+        else {
+            await this.userProfileRepository.create({
+                child_education_id: foundEducation.id,
+                challenges: challengesId,
+                user_id,
+            });
+        }
+        await this.userRepository.updateOne({
+            id: user_id
+        }, {
+            profile_level: UserEnums_1.ProfileLevel.STEP_THREE
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Step 3 form submitted successfully"
+        };
+    }
+    async getStepThreeFormOptions() {
+        const challenges = await this.challengeRepository.getRepo().find({
+            select: ['name', 'uuid'],
+            where: {
+                user_id: (0, typeorm_1.IsNull)()
+            }
+        });
+        const education = await this.educationRepository.getRepo().find({
+            select: ['name', 'uuid'],
+        });
+        return {
+            successful: true,
+            data: {
+                education,
+                challenges
+            },
+            message: "Step 3 form data fetched successfully!"
+        };
+    }
+    async submitStepFiveForm(createStepFiveFormDto, user_id) {
+        let message;
+        const { city, state, country, coordinates } = createStepFiveFormDto;
+        let existingProfile = await this.userProfileRepository.getRepo().findOne({ where: { user: { id: user_id } } });
+        if (existingProfile) {
+            await this.userProfileRepository.updateWithCoordinates({
+                user_id,
+            }, {
+                location: {
+                    city,
+                    state,
+                    country,
+                    coordinates
+                }
+            }, coordinates.long, coordinates.lat);
+        }
+        else {
+            await this.userProfileRepository.createWithCoordinates({
+                location: {
+                    city,
+                    state,
+                    country,
+                    coordinates
+                }
+            }, coordinates.long, coordinates.lat);
+        }
+        await this.userRepository.updateOne({
+            id: user_id
+        }, {
+            profile_level: UserEnums_1.ProfileLevel.COMPLETED
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Step 4 form submitted successfully"
+        };
+    }
+    async submitStepFourForm(createStepFourFormDto, user_id) {
+        let message;
+        const { goals } = createStepFourFormDto;
+        let goalsId = [];
+        goals.map(async (goal) => {
+            const existingGoal = await this.goalRepository.basicFindOneByConditions({ name: goal });
+            if (!existingGoal) {
+                const foundGoal = await this.goalRepository.basicFindOneByConditions({ uuid: goal });
+                if (!foundGoal)
+                    throw new AppError_1.AppError('Selected goal is invalid', 404);
+                goalsId.push(foundGoal.id);
+            }
+        });
+        let existingProfile = await this.userProfileRepository.getRepo().findOne({ where: { user: { id: user_id } } });
+        if (existingProfile) {
+            await this.userProfileRepository.updateOne({
+                user_id,
+            }, {
+                goals: goalsId,
+            });
+        }
+        else {
+            await this.userProfileRepository.create({
+                goals: goalsId,
+                user_id,
+            });
+        }
+        await this.userRepository.updateOne({
+            id: user_id
+        }, {
+            profile_level: UserEnums_1.ProfileLevel.STEP_FOUR
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Step 5 form submitted successfully"
+        };
+    }
+    async getStepFourFormOptions() {
+        const goals = await this.goalRepository.getRepo().find({
+            select: ['name', 'uuid'],
+        });
+        return {
+            successful: true,
+            data: {
+                goals
+            },
+            message: "Step 5 form data fetched successfully!"
+        };
+    }
+};
+CompleteProfileService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], CompleteProfileService);
+exports.default = CompleteProfileService;

package/dist/services/mobile/ConnectionService.js

@@ -0,0 +1,338 @@
+"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 ConnectionRepository_1 = require("@/repositories/ConnectionRepository");
+const Paginator_1 = require("@/transformers/Paginator");
+const ConnectionEnum_1 = require("@/common/enums/ConnectionEnum");
+const UserRepository_1 = require("@/repositories/UserRepository");
+const configs_1 = require("@/common/configs");
+const NotificationRepository_1 = require("@/repositories/NotificationRepository");
+const NotificationEnum_1 = require("@/common/enums/NotificationEnum");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const typeorm_1 = require("typeorm");
+const UserResource_1 = require("@/transformers/resources/UserResource");
+let ConnectionService = class ConnectionService {
+    connectionRepository;
+    userRepository;
+    notificationRepository;
+    constructor() {
+        this.notificationRepository = new NotificationRepository_1.NotificationRepository();
+        this.userRepository = new UserRepository_1.UserRepository();
+        this.connectionRepository = new ConnectionRepository_1.ConnectionRepository();
+    }
+    async sendConnectionRequest(receiver_id, user_id) {
+        let message;
+        const connectionReceiver = await this.userRepository.findOneAndRelations({
+            where: {
+                uuid: receiver_id,
+                id: (0, typeorm_1.Not)(user_id)
+            }
+        });
+        if (!connectionReceiver) {
+            message = messages_1.dynamic_messages.NOT_FOUND("User account");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const connectionSender = await this.userRepository.basicFindOneByConditions({
+            id: user_id
+        });
+        if (!connectionSender) {
+            message = messages_1.dynamic_messages.NOT_FOUND("User account");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const connection = await this.connectionRepository.findOneAndRelations({
+            where: [
+                {
+                    sender_id: connectionReceiver.id
+                },
+                {
+                    receiver_id: connectionReceiver.id
+                }
+            ],
+            relations: ['receiver', 'sender']
+        });
+        if (connection && connection?.status === ConnectionEnum_1.ConnectionStatus.ACCEPTED) {
+            message = `${connectionReceiver?.full_name} is already a connection`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        if (connection && connection?.status === ConnectionEnum_1.ConnectionStatus.PENDING) {
+            message = `Your connection request is still pending`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        const newConnection = await this.connectionRepository.create({
+            sender_id: user_id,
+            receiver_id: connectionReceiver.id
+        });
+        await this.notificationRepository.save({
+            user_id: connectionReceiver.id,
+            type: NotificationEnum_1.NotificationType.NEW_CONNECTION_REQUEST,
+            message: `You have a new connection request from ${connectionSender.full_name}`,
+            notifiable_id: newConnection.id,
+            notifiable_type: IndexEnum_1.SYS_MODELS.CONNECTION_MODEL
+        });
+        return {
+            successful: true,
+            data: null,
+            message: `Your connection request was successfully sent!`
+        };
+    }
+    async rejectConnectionRequest(connection_id, user_id, rejection_type) {
+        switch (rejection_type) {
+            case ConnectionEnum_1.ConnectionRejectionType.REJECT_CONNECTION:
+                return await this.rejectReceivedConnectionRequest(user_id, connection_id);
+            case ConnectionEnum_1.ConnectionRejectionType.WITHDRAW_CONNECTION:
+                return await this.withdrawConnectionRequest(user_id, connection_id);
+            case ConnectionEnum_1.ConnectionRejectionType.REJECT_CONNECTION:
+                return await this.cancelConnection(user_id, connection_id);
+        }
+    }
+    async rejectReceivedConnectionRequest(user_id, connection_id) {
+        let message;
+        const connection = await this.connectionRepository.findOneAndRelations({
+            where: {
+                receiver_id: user_id,
+                uuid: connection_id
+            }
+        });
+        if (!connection) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Connection");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (connection && connection?.status === ConnectionEnum_1.ConnectionStatus.ACCEPTED) {
+            message = `${connection?.sender?.full_name}' connection request has already been accepted`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        await this.connectionRepository.deleteByCondition({
+            receiver_id: user_id,
+            uuid: connection_id
+        });
+        return {
+            successful: true,
+            data: null,
+            message: `Connection request was declined successfully`
+        };
+    }
+    async withdrawConnectionRequest(user_id, connection_id) {
+        let message;
+        const connection = await this.connectionRepository.findOneAndRelations({
+            where: {
+                sender_id: user_id,
+                uuid: connection_id
+            }
+        });
+        if (!connection) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Connection");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (connection && connection?.status === ConnectionEnum_1.ConnectionStatus.ACCEPTED) {
+            message = `${connection?.sender?.full_name}' connection request has already been accepted`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        await this.connectionRepository.deleteByCondition({
+            sender_id: user_id,
+            uuid: connection_id
+        });
+        return {
+            successful: true,
+            data: null,
+            message: `Connection request was declined successfully`
+        };
+    }
+    async cancelConnection(user_id, connection_id) {
+        let message;
+        const connection = await this.connectionRepository.findOneAndRelations({
+            where: [
+                {
+                    sender_id: user_id,
+                    uuid: connection_id,
+                },
+                {
+                    receiver_id: user_id,
+                    uuid: connection_id
+                }
+            ]
+        });
+        if (!connection) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Connection");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (connection && connection?.status !== ConnectionEnum_1.ConnectionStatus.ACCEPTED) {
+            message = `You can only cancel an accepted connection!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        await this.connectionRepository.deleteByCondition({
+            uuid: connection_id
+        });
+        return {
+            successful: true,
+            data: null,
+            message: `Connection was cancelled successfully`
+        };
+    }
+    async acceptConnection(connection_id, user_id) {
+        let message;
+        const user = await this.userRepository.basicFindOneByConditions({
+            id: user_id
+        });
+        const connection = await this.connectionRepository.findOneAndRelations({
+            where: {
+                receiver_id: user_id,
+                uuid: connection_id
+            }
+        });
+        if (!connection) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Connection");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (!user) {
+            message = messages_1.dynamic_messages.NOT_FOUND("User account");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (connection && connection?.status !== ConnectionEnum_1.ConnectionStatus.ACCEPTED) {
+            message = `You have already accepted this connection!`;
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        await this.connectionRepository.updateOne({
+            uuid: connection_id,
+            receiver_id: user_id
+        }, {
+            status: ConnectionEnum_1.ConnectionStatus.ACCEPTED
+        });
+        await this.notificationRepository.save({
+            user_id: connection?.sender_id,
+            type: NotificationEnum_1.NotificationType.NEW_CONNECTION_REQUEST,
+            message: `${user.full_name} accepted your have a new connection request`,
+            notifiable_id: connection.id,
+            notifiable_type: IndexEnum_1.SYS_MODELS.CONNECTION_MODEL
+        });
+        return {
+            successful: true,
+            data: null,
+            message: `Connection was accepted] successfully`
+        };
+    }
+    async fetchAcceptedConnection(user_id, pageNumber) {
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const options = {
+            metadata: {
+                user_id
+            },
+            page_number,
+            limit
+        };
+        const { rows, total } = await this.connectionRepository.getAcceptedConnections(options);
+        const connections = rows.map((connection, index) => ({
+            uuid: connection.uuid,
+            created_at: connection.created_at,
+            status: connection.status,
+            sender: {
+                ...UserResource_1.UserResource.userToJSON(connection.sender)
+            },
+            receiver: {
+                ...UserResource_1.UserResource.userToJSON(connection.receiver)
+            }
+        }));
+        const data = (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: connections,
+        });
+        return {
+            successful: true,
+            data,
+            message: `Connections fetched successfully`
+        };
+    }
+    async getReceivedPendingConnectionRequests(user_id, pageNumber) {
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const options = {
+            metadata: {
+                user_id
+            },
+            page_number,
+            limit
+        };
+        const { rows, total } = await this.connectionRepository.getReceivedPendingConnectionRequests(options);
+        const connections = rows.map((connection, index) => ({
+            uuid: connection.uuid,
+            created_at: connection.created_at,
+            status: connection.status,
+            sender: {
+                ...UserResource_1.UserResource.userToJSON(connection.sender)
+            }
+        }));
+        const data = (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: connections,
+        });
+        return {
+            successful: true,
+            data,
+            message: `Connections requests fetched successfully`
+        };
+    }
+    async getRecommendedConnctions(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 { data, total, perPage, page } = await this.connectionRepository.getRecommendedConnctions(dataFetchParams);
+        const { raw, entities } = data;
+        const users = entities.map((user, index) => ({
+            ...UserResource_1.UserResource.userToJSON(user),
+            connection_state: raw[index].connection_state,
+        }));
+        const connections = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: users,
+        });
+        message = messages_1.dynamic_messages.FETCHED_SUCCESSFULLY("User");
+        return {
+            successful: true,
+            data: connections,
+            message
+        };
+    }
+};
+ConnectionService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], ConnectionService);
+exports.default = ConnectionService;