@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/PasswordResetService.js

@@ -0,0 +1,168 @@
+"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 UserRepository_1 = require("../../repositories/UserRepository");
+const AppError_1 = require("../../common/errors/AppError");
+const UserEnums_1 = require("../../common/enums/UserEnums");
+const utils_1 = require("../../common/utils");
+const EmailProducer_1 = require("../../queues/producers/EmailProducer");
+const configs_1 = require("../../common/configs");
+const messages_1 = require("../../common/constants/messages");
+const logger_1 = require("@/common/configs/logger");
+let PasswordResetService = class PasswordResetService {
+    userRepository;
+    constructor() {
+        this.userRepository = new UserRepository_1.UserRepository();
+    }
+    async requestPasswordReset(req) {
+        const { email } = req;
+        let message;
+        let whereConditions = {
+            email,
+        };
+        const existingUser = await this.userRepository.basicFindOneByConditions(whereConditions);
+        if (!existingUser) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.NOT_FOUND, 404);
+        }
+        if (existingUser.user_status !== UserEnums_1.AccountStatus.ACTIVE) {
+            message = "You cannot change the password of an inactive account";
+            throw new AppError_1.AppError(message, 403);
+        }
+        else {
+            const passwordResetToken = (0, utils_1.generateUUID)();
+            const { expiresAt, uuid } = passwordResetToken;
+            const { otp, expireAt: verification_expires_at } = (0, utils_1.generateOTP)(30);
+            await this.userRepository.updateOne({ uuid: existingUser.uuid, email }, {
+                reset_token: uuid,
+                reset_token_expires_at: expiresAt,
+                reset_otp: otp,
+            });
+            const { iv: ivHex, encryptedData } = (0, utils_1.encrypt)(email);
+            const reset_link = `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/password/reset/${uuid}?hash=${ivHex}&ref=${encryptedData}`;
+            const messageBody = {
+                reset_link,
+                otp,
+                first_name: (0, utils_1.capitalizeFirst)(existingUser?.full_name),
+                email,
+            };
+            await (0, EmailProducer_1.sendPasswordResetRequestEmail)(messageBody);
+            return {
+                successful: true,
+                message: messages_1.dynamic_messages.PASSWWORD_RESET_SENT(email),
+            };
+        }
+    }
+    async setNewPasswordWithOtp(setNewPassword) {
+        const { confirm_password, otp, new_password } = setNewPassword;
+        let message;
+        if (confirm_password !== new_password) {
+            message = "Confirm password does not match the password";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        const user = await this.userRepository.basicFindOneByConditions({
+            reset_otp: otp,
+        });
+        if (!user) {
+            message = "Invalid OTP";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (user.user_status !== UserEnums_1.AccountStatus.ACTIVE) {
+            message = "You cannot change the password of an inactive account";
+            throw new AppError_1.AppError(message, 403);
+        }
+        // Check if OTP has expired
+        const expectedTokenExpirationDate = user.reset_token_expires_at;
+        const tokenHasExpired = (0, utils_1.hasExpired)(expectedTokenExpirationDate);
+        if (tokenHasExpired) {
+            message = "OTP has expired!";
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.EXPIRED, 403);
+        }
+        else {
+            const password = await (0, utils_1.hashString)(new_password);
+            const { id, email, full_name } = user;
+            await this.userRepository.updateOne({
+                email: user.email,
+                id,
+            }, {
+                reset_otp: null,
+                password_hash: password,
+                reset_token_expires_at: null,
+                reset_token: null,
+            });
+            const messageBody = {
+                email,
+                first_name: (0, utils_1.capitalizeFirst)(full_name),
+                login_link: `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/login`,
+                contact_link: `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/contact-us`,
+            };
+            await (0, EmailProducer_1.sendPasswordResetConfirmationEmail)(messageBody);
+            return {
+                successful: true,
+                message: `Your account password was successfully changed`,
+            };
+        }
+    }
+    async setNewPassword(req, hash, ref, reset_token) {
+        const { confirm_password, new_password } = req;
+        if (!hash || !ref || !reset_token) {
+            throw new AppError_1.AppError(messages_1.dynamic_messages.NOT_FOUND("Required params"), 404);
+        }
+        if (new_password !== confirm_password) {
+            throw new AppError_1.AppError("Password must match confirm password", 400);
+        }
+        const existingUser = await this.userRepository.basicFindOneByConditions({
+            reset_token,
+        });
+        if (!existingUser) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.NOT_FOUND, 404);
+        }
+        else if (existingUser.user_status == UserEnums_1.AccountStatus.PENDING) {
+            await this.userRepository.updateOne({ uuid: existingUser.uuid, email: existingUser.email }, { user_status: UserEnums_1.AccountStatus.ACTIVE, is_verified: true });
+            // throw new AppError(
+            //   USER_MESSAGES.AUTH.PASSWWORD_RESET.INACTIVE_ACCOUNT
+            // );
+        }
+        const expectedTokenExpirationDate = existingUser.reset_token_expires_at;
+        const { id, email } = existingUser;
+        const tokenHasExpired = (0, utils_1.hasExpired)(expectedTokenExpirationDate);
+        if (tokenHasExpired) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.AUTH.PASSWWORD_RESET.EXPIRED, 400);
+        }
+        else {
+            const password = await (0, utils_1.hashString)(new_password);
+            await this.userRepository.updateOne({ id, email }, {
+                password_hash: password,
+                reset_otp: null,
+                reset_token_expires_at: null,
+                reset_token: null,
+            });
+        }
+        const messageBody = {
+            email,
+            first_name: (0, utils_1.capitalizeFirst)(existingUser?.full_name),
+            login_link: `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/login`,
+            contact_link: `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/contact-us`,
+        };
+        await (0, EmailProducer_1.sendPasswordResetConfirmationEmail)(messageBody);
+        return {
+            successful: true,
+            message: `Your account password was successfully changed`,
+        };
+    }
+};
+PasswordResetService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], PasswordResetService);
+exports.default = PasswordResetService;

package/dist/services/mobile/PlanService.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanService = void 0;
+const logger_1 = require("@/common/configs/logger");
+const messages_1 = require("@/common/constants/messages");
+const AppError_1 = require("@/common/errors/AppError");
+const CardRepository_1 = require("@/repositories/CardRepository");
+const PlanRepository_1 = require("@/repositories/PlanRepository");
+const UserRepository_1 = require("@/repositories/UserRepository");
+const PlanCollection_1 = require("@/transformers/collections/PlanCollection");
+const SubscriptionHistoryRepository_1 = require("@/repositories/SubscriptionHistoryRepository");
+class PlanService {
+    planRepository;
+    userRepository;
+    cardRepository;
+    subscriptionHistoryRepository;
+    constructor() {
+        this.planRepository = new PlanRepository_1.PlanRepository();
+        this.userRepository = new UserRepository_1.UserRepository();
+        this.cardRepository = new CardRepository_1.CardRepository();
+        this.subscriptionHistoryRepository = new SubscriptionHistoryRepository_1.SubscriptionHistoryRepository();
+    }
+    async fetchPlanFeatures(user_id) {
+        let message;
+        const foundUser = await this.userRepository.findOneAndRelations({
+            where: { id: user_id },
+            relations: ['plan']
+        });
+        if (!foundUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Your account");
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const plans = await this.planRepository
+            .getRepo().createQueryBuilder("plan")
+            .leftJoinAndSelect("plan.planFeatures", "planFeature")
+            .leftJoinAndSelect("planFeature.feature", "feature")
+            .getMany();
+        return {
+            successful: true,
+            data: PlanCollection_1.PlanCollection.toJSON(plans, foundUser?.plan_id),
+            message: messages_1.dynamic_messages.FETCHED_SUCCESSFULLY("Plan features"),
+        };
+    }
+    async setNewPlan(user_id, plan_id) {
+        let message;
+        const foundPlan = await this.planRepository.basicFindOneByConditions({
+            uuid: plan_id
+        });
+        if (!foundPlan) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Your plan");
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const foundUser = await this.userRepository.findOneAndRelations({
+            where: { id: user_id }
+        });
+        if (!foundUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Your account");
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const foundDefaultCard = await this.cardRepository.basicFindOneByConditions({
+            user_id: foundUser.id,
+            is_default: true
+        });
+        if (!foundDefaultCard) {
+            message = "You don't have any card set for default payment. Please set that to continue";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (foundUser.plan_id == foundPlan.id) {
+            message = `You already have ${foundPlan.name} as your plan`;
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        await this.userRepository.updateOne({ uuid: foundUser.uuid }, { plan_id: foundPlan.id });
+        return {
+            successful: true,
+            data: null,
+            message: "Plan successfully changed",
+        };
+    }
+}
+exports.PlanService = PlanService;