@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/AuthService.js

@@ -0,0 +1,362 @@
+"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 UserRepository_1 = require("../../repositories/UserRepository");
+const configs_1 = require("../../common/configs");
+const utils_1 = require("../../common/utils");
+const UserEnums_1 = require("../../common/enums/UserEnums");
+// import UserModel from "../models/UserModel";
+const messages_1 = require("../../common/constants/messages");
+const UserResource_1 = require("@/transformers/resources/UserResource");
+const axios_1 = require("@/common/utils/axios");
+const AdminRepository_1 = require("@/repositories/AdminRepository");
+const EmailProducer_1 = require("../../queues/producers/EmailProducer");
+const validator_1 = require("@/common/utils/validator");
+let AuthService = class AuthService {
+    userRepository;
+    adminRepository;
+    constructor() {
+        this.userRepository = new UserRepository_1.UserRepository();
+        this.adminRepository = new AdminRepository_1.AdminRepository();
+    }
+    async registerUser(req) {
+        const { email, password, full_name, phone, confirm_password, terms_and_conditions } = req;
+        let message = null;
+        if (configs_1.CONFIGS.IS_PRODUCTION) {
+            const isEmailValid = await (0, validator_1.hasValidMX)(email);
+            if (!isEmailValid) {
+                message = "Invalid email domain. Please use a valid domain.";
+                logger_1.logger.error(message);
+                throw new AppError_1.AppError(message);
+            }
+        }
+        if (!terms_and_conditions) {
+            message = "You must accept the terms and conditions to register";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message);
+        }
+        if (!terms_and_conditions) {
+            message = "You must accept the terms and conditions to register";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message);
+        }
+        if (password !== confirm_password) {
+            message = "Password anc confirm password mismatch";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message);
+        }
+        const existingUser = await this.userRepository.getRepo().findOne({
+            where: [
+                {
+                    email
+                },
+                {
+                    phone
+                }
+            ]
+        });
+        if (existingUser) {
+            message = 'Email or phone already exists';
+            throw new AppError_1.AppError(message);
+        }
+        const hashedPassword = await (0, utils_1.hashString)(password);
+        const { otp, expireAt: verification_expires_at } = (0, utils_1.generateOTP)(30);
+        const { uuid } = (0, utils_1.generateUUID)();
+        const user = await this.userRepository.create({
+            email,
+            full_name,
+            phone,
+            verification_expires_at,
+            verification_token: uuid,
+            verification_otp: otp,
+            password_hash: hashedPassword,
+            terms_and_conditions,
+        });
+        const { iv: ivHex, encryptedData } = (0, utils_1.encrypt)(email);
+        const verification_link = `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/email/verification/${uuid}?hash=${ivHex}&ref=${encryptedData}`;
+        const messageBody = {
+            otp,
+            verification_link,
+            email,
+            first_name: (0, utils_1.capitalizeFirst)(full_name),
+        };
+        await (0, EmailProducer_1.sendAccountActivationEmail)(messageBody);
+        message = messages_1.USER_MESSAGES.AUTH.REGISTRATION.SUCCESSFUL;
+        return {
+            successful: true,
+            data: { user: UserResource_1.UserResource.userToJSON(user) },
+            message,
+        };
+    }
+    async loginUser(req) {
+        const { email, password } = req;
+        const existingUser = await this.userRepository.findOneAndRelations({
+            where: { email },
+            relations: ["plan"],
+            select: [
+                'full_name',
+                'uuid',
+                'id',
+                'profile_level',
+                'is_verified',
+                'plan',
+                'email',
+                'user_status',
+                'is_verified',
+                'mode_of_sign_up',
+                'password_hash'
+            ]
+        });
+        if (!existingUser) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.INVALID_CREDENTIALS);
+        }
+        const isPasswordCheckOK = await (0, utils_1.compareHash)(password, existingUser.password_hash || "");
+        if (!isPasswordCheckOK) {
+            if (!existingUser.password_hash ||
+                existingUser.mode_of_sign_up !== UserEnums_1.ONBOARDING_MEDIUM.EMAIL_PASSWORD) {
+                throw new AppError_1.AppError("We found your account but was created using a social media account!", 400);
+            }
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.INVALID_CREDENTIALS);
+        }
+        if (existingUser.user_status !== UserEnums_1.AccountStatus.ACTIVE || !existingUser.is_verified) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.INACTIVE_ACCOUNT);
+        }
+        const jwtDetails = (0, utils_1.generateJWT)({ email: existingUser.email,
+            user_id: existingUser.id,
+            uuid: existingUser.uuid,
+            plan: existingUser.plan }, "USER");
+        logger_1.logger.debug(messages_1.USER_MESSAGES.AUTH.LOGIN.JWT_GENERATED);
+        return {
+            isSuccess: true,
+            user: UserResource_1.UserResource.userToJSON(existingUser),
+            token: jwtDetails,
+            message: messages_1.USER_MESSAGES.AUTH.LOGIN.LOGIN_SUCCESSFUL,
+        };
+    }
+    async loginWithGoolge(token) {
+        const data = await (0, axios_1.makeApiCall)("https://www.googleapis.com/oauth2/v3/userinfo", {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        let user;
+        if (data && data?.email && data?.email_verified === true) {
+            user = await this.userRepository.findOneAndRelations({
+                where: { email: data?.email },
+            });
+            if (!user) {
+                if (data?.name) {
+                    const [first_name] = data?.name.split(" ");
+                    user = await this.userRepository.create({
+                        email: data?.email,
+                        full_name: data?.name,
+                        user_status: UserEnums_1.AccountStatus.ACTIVE,
+                        is_verified: true,
+                        mode_of_sign_up: UserEnums_1.ONBOARDING_MEDIUM.GOOGLE,
+                        terms_and_conditions: true,
+                    });
+                    const messageBody = {
+                        email: data?.email,
+                        first_name: (0, utils_1.capitalizeFirst)(first_name),
+                    };
+                    await (0, EmailProducer_1.sendWelcomeEmail)(messageBody);
+                }
+                else {
+                    throw new AppError_1.AppError("Login with Google failed!", 400);
+                }
+            }
+            const jwtDetails = (0, utils_1.generateJWT)({ email: user.email, user_id: user.uuid }, "USER");
+            logger_1.logger.debug(messages_1.USER_MESSAGES.AUTH.LOGIN.JWT_GENERATED);
+            return {
+                successful: true,
+                data: {
+                    user: UserResource_1.UserResource.userToJSON(user),
+                    access_token: jwtDetails,
+                },
+                message: messages_1.USER_MESSAGES.AUTH.LOGIN.LOGIN_SUCCESSFUL,
+            };
+        }
+        else {
+            throw new AppError_1.AppError("Login with Google failed!", 400);
+        }
+    }
+    async validateEmail(req) {
+        const { verification_token, hash, ref } = req;
+        let whereConditions = {
+            verification_token,
+        };
+        const user = await this.userRepository.basicFindOneByConditions(whereConditions);
+        if (!user) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.INVALID, 404);
+        }
+        if (user.user_status === UserEnums_1.AccountStatus.ACTIVE) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.ALREADY_ACTIVATED, 404);
+        }
+        // Check if OTP has expired
+        const expectedOtpExpirationDate = user.verification_expires_at;
+        const expectedTokenExpirationDate = user.reset_token_expires_at;
+        const otpHasExpired = (0, utils_1.hasExpired)(expectedOtpExpirationDate);
+        const tokenHasExpired = (0, utils_1.hasExpired)(expectedTokenExpirationDate);
+        if (tokenHasExpired || otpHasExpired) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.EXPIRED, 400);
+        }
+        else {
+            await this.userRepository.updateOne({
+                email: user.email,
+            }, {
+                is_verified: true,
+                user_status: UserEnums_1.AccountStatus.ACTIVE,
+                verification_token: null,
+                verification_expires_at: new Date(),
+            });
+            const messageBody = {
+                email: user.email,
+                first_name: (0, utils_1.capitalizeFirst)(user.full_name),
+            };
+            await (0, EmailProducer_1.sendWelcomeEmail)(messageBody);
+            const jwtDetails = (0, utils_1.generateJWT)({ email: user.email, user_id: user.uuid }, "USER");
+            return {
+                successful: true,
+                data: {
+                    user: UserResource_1.UserResource.userToJSON(user),
+                    access_token: jwtDetails,
+                },
+                message: messages_1.USER_MESSAGES.EMAIL_VERIFICATION.SUCCESS,
+            };
+        }
+    }
+    async validateOtp(req) {
+        const { verification_token, hash, ref } = req;
+        const user = await this.userRepository.basicFindOneByConditions({
+            verification_otp: verification_token,
+            verification_token: hash
+        });
+        if (!user) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.INVALID, 404);
+        }
+        if (user.user_status === UserEnums_1.AccountStatus.ACTIVE) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.ALREADY_ACTIVATED, 404);
+        }
+        // Check if OTP has expired
+        const expectedOtpExpirationDate = user.verification_expires_at;
+        const expectedTokenExpirationDate = user.reset_token_expires_at;
+        const otpHasExpired = (0, utils_1.hasExpired)(expectedOtpExpirationDate);
+        const tokenHasExpired = (0, utils_1.hasExpired)(expectedTokenExpirationDate);
+        if (tokenHasExpired || otpHasExpired) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.EMAIL_VERIFICATION.EXPIRED, 400);
+        }
+        else {
+            await this.userRepository.updateOne({
+                email: user.email,
+            }, {
+                is_verified: true,
+                user_status: UserEnums_1.AccountStatus.ACTIVE,
+                verification_token: null,
+                verification_otp: null,
+                verification_expires_at: new Date(),
+            });
+            const messageBody = {
+                email: user.email,
+                first_name: (0, utils_1.capitalizeFirst)(user.full_name),
+            };
+            await (0, EmailProducer_1.sendWelcomeEmail)(messageBody);
+            const jwtDetails = (0, utils_1.generateJWT)({ email: user.email,
+                user_id: user.id,
+                uuid: user.uuid,
+                plan: user.plan }, "USER");
+            return {
+                successful: true,
+                data: {
+                    user: UserResource_1.UserResource.userToJSON(user),
+                    access_token: jwtDetails,
+                },
+                message: messages_1.USER_MESSAGES.EMAIL_VERIFICATION.SUCCESS,
+            };
+        }
+    }
+    async loginAdminUser(req) {
+        const { email, password } = req;
+        const existingUser = await this.adminRepository.findOneAndRelations({
+            where: { email },
+        });
+        if (!existingUser) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.INVALID_CREDENTIALS);
+        }
+        const isPasswordCheckOK = await (0, utils_1.compareHash)(password, existingUser.password_hash);
+        if (!isPasswordCheckOK) {
+            throw new AppError_1.AppError(messages_1.USER_MESSAGES.ACCOUNT.INVALID_CREDENTIALS);
+        }
+        const jwtDetails = (0, utils_1.generateJWT)({ email: existingUser.email, user_id: existingUser.uuid }, "ADMIN");
+        logger_1.logger.debug(messages_1.USER_MESSAGES.AUTH.LOGIN.JWT_GENERATED);
+        const user = UserResource_1.UserResource.adminUserToJSON(existingUser);
+        return {
+            successful: true,
+            data: {
+                ...user,
+                token: jwtDetails
+            },
+            message: messages_1.USER_MESSAGES.AUTH.LOGIN.LOGIN_SUCCESSFUL,
+        };
+    }
+    async resendAccountActivationMail(req) {
+        const { email } = req;
+        let message = null;
+        const existingUser = await this.userRepository.basicFindOneByConditions({
+            email,
+        });
+        if (!existingUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Account");
+            throw new AppError_1.AppError(message);
+        }
+        if (existingUser.user_status == UserEnums_1.AccountStatus.INACTIVE) {
+            message = "Account is inactive";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message);
+        }
+        if (existingUser.user_status == UserEnums_1.AccountStatus.SUSPENDED) {
+            message = "Account is was suspended";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message);
+        }
+        if (existingUser.user_status == UserEnums_1.AccountStatus.BANNED) {
+            message = "Account was banned";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message);
+        }
+        const { full_name, uuid: userUUid } = existingUser;
+        const { otp, expireAt: otp_expires_at } = (0, utils_1.generateOTP)(30);
+        const { uuid } = (0, utils_1.generateUUID)();
+        await this.userRepository.updateOne({ email, uuid: userUUid }, {
+            verification_token: uuid,
+            verification_otp: otp,
+            verification_expires_at: otp_expires_at
+        });
+        const verification_link = `${configs_1.CONFIGS.MAIN_WEBSITE_BASE_URL}/email/verification/${uuid}`;
+        const messageBody = {
+            otp,
+            verification_link,
+            email,
+            first_name: (0, utils_1.capitalizeFirst)(full_name),
+        };
+        await (0, EmailProducer_1.sendAccountActivationEmail)(messageBody);
+        message = `Account activation link was resent to ${email}`;
+        return { successful: true, data: null, message };
+    }
+};
+AuthService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], AuthService);
+exports.default = AuthService;

package/dist/services/mobile/BusinessService.js

@@ -0,0 +1,267 @@
+"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 BusinessRepository_1 = require("@/repositories/BusinessRepository");
+const UploadService_1 = __importDefault(require("./UploadService"));
+const UploadEnum_1 = require("@/common/enums/UploadEnum");
+const Paginator_1 = require("@/transformers/Paginator");
+const BusinessIdCategoryRepository_1 = require("@/repositories/BusinessIdCategoryRepository");
+const BusinessCategoryRepository_1 = require("@/repositories/BusinessCategoryRepository");
+const configs_1 = require("@/common/configs");
+const BusinessCollection_1 = require("@/transformers/collections/BusinessCollection");
+const BusinessResource_1 = require("@/transformers/resources/BusinessResource");
+const MarketplaceEnum_1 = require("@/common/enums/MarketplaceEnum");
+let BusinessService = class BusinessService {
+    businessRepository;
+    uploadService;
+    businessCategoryRepository;
+    businessIdCategoryRepository;
+    constructor() {
+        this.businessRepository = new BusinessRepository_1.BusinessRepository();
+        this.businessIdCategoryRepository = new BusinessIdCategoryRepository_1.BusinessIdCategoryRepository();
+        this.businessCategoryRepository = new BusinessCategoryRepository_1.BusinessCategoryRepository();
+        this.uploadService = new UploadService_1.default();
+    }
+    async createBusiness(businessData, user_id) {
+        let message;
+        const { business_name, category, business_id_category, business_id_image, location, description, } = businessData;
+        if (!business_id_image) {
+            message = "Business ID image is required!";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        const businessCategory = await this.businessCategoryRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: category
+            }
+        });
+        if (!businessCategory) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business category");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const businessIdCategory = await this.businessIdCategoryRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: business_id_category
+            }
+        });
+        if (!businessIdCategory) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business ID category");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const createdBusiness = await this.businessRepository.createWithCoordinates({
+            name: business_name,
+            category_id: businessCategory.id,
+            business_id_category_id: businessIdCategory.id,
+            location,
+            description,
+            user_id
+        }, location.longitude, location.latitude);
+        const businessId = createdBusiness.identifiers?.[0]?.id;
+        logger_1.logger.info("Business created without ID image");
+        const uploadedFile = await this.uploadService.uploadImage(business_id_image, businessId, UploadEnum_1.UploadDirectories.BUSINESS_IMAGES, "BusinessModel");
+        await this.businessRepository.updateOne({
+            id: businessId,
+            user_id,
+        }, {
+            business_id_image_id: uploadedFile.id
+        });
+        logger_1.logger.info("Business ID image successfully added");
+        return {
+            successful: true,
+            data: null,
+            message: "Business created successfully"
+        };
+    }
+    async getBusinessCreationData() {
+        const business_categories = await this.businessCategoryRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        const business_id_categories = await this.businessIdCategoryRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        return {
+            successful: true,
+            data: {
+                business_id_categories,
+                business_categories
+            },
+            message: "Business creation data fetched successfully!"
+        };
+    }
+    async getOneBusiness(business_id, user_id) {
+        let message;
+        const { data } = await this.businessRepository.getOneBusiness(business_id);
+        const { raw, entities } = data;
+        if (!raw[0]) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: BusinessResource_1.BusinessResource.toJSON(raw[0], entities[0], user_id),
+            message: "Business fetched successfully!"
+        };
+    }
+    async getBusinesses(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 businesss = await this.loadPaginatedBusinesses(dataFetchParams, user_id);
+        if (!businesss) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Businesss");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: businesss,
+            message: "Businesss fetched successfully!"
+        };
+    }
+    async loadPaginatedBusinesses(loadPagesDto, userId) {
+        const { data, total, perPage, page } = await this.businessRepository.loadPaginatedBusinesses(loadPagesDto, userId);
+        const { raw, entities } = data;
+        return (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: BusinessCollection_1.BusinnessCollection.toJSON(raw, entities, userId),
+        });
+    }
+    async updateOneBusiness(businessData, business_id, user_id) {
+        let message;
+        const { business_name, category, location, description, } = businessData;
+        const business = await this.businessRepository.basicFindOneByConditions({
+            uuid: business_id,
+            user_id
+        });
+        if (!business) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const businessCategory = await this.businessCategoryRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: category
+            }
+        });
+        if (!businessCategory) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business category");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.businessRepository.updateWithCoordinates({
+            uuid: business.uuid,
+            user_id,
+        }, {
+            name: business_name,
+            category_id: businessCategory.id,
+            location,
+            description,
+        }, location.longitude, location.latitude);
+        return {
+            successful: true,
+            data: null,
+            message: "Business updated successfully!"
+        };
+    }
+    async hideOneBusiness(business_id, user_id) {
+        let message;
+        const business = await this.businessRepository.basicFindOneByConditions({
+            uuid: business_id,
+            user_id
+        });
+        if (!business) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.businessRepository.updateOne({
+            uuid: business.uuid,
+            user_id,
+        }, {
+            status: MarketplaceEnum_1.BusinessStatus.HIDDEN
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Business hidden successfully!"
+        };
+    }
+    async deleteOneBusiness(business_id, user_id) {
+        let message;
+        const business = await this.businessRepository.basicFindOneByConditions({
+            uuid: business_id,
+            user_id
+        });
+        if (!business) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Business");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.uploadService.deleteFile(business?.business_id_image_id, business?.id, "image");
+        await this.businessRepository.deleteByCondition({
+            uuid: business.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Business deleted successfully!"
+        };
+    }
+    async searchBusinesses(search_string, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const offset = (page_number - 1) * limit;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                search_string
+            }
+        };
+        const businesss = await this.loadPaginatedBusinesses(dataFetchParams);
+        if (!businesss) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Businesss");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: businesss,
+            message: "Businesss fetched successfully!"
+        };
+    }
+};
+BusinessService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], BusinessService);
+exports.default = BusinessService;