@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/ProductService.js

@@ -0,0 +1,360 @@
+"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 ProductRepository_1 = require("@/repositories/ProductRepository");
+const UploadService_1 = __importDefault(require("./UploadService"));
+const UploadEnum_1 = require("@/common/enums/UploadEnum");
+const CategoryRepository_1 = require("@/repositories/CategoryRepository");
+const ProductImageRepository_1 = require("@/repositories/ProductImageRepository");
+const BusinessRepository_1 = require("@/repositories/BusinessRepository");
+const configs_1 = require("@/common/configs");
+const Paginator_1 = require("@/transformers/Paginator");
+const ProductCollection_1 = require("@/transformers/collections/ProductCollection");
+const ProductResource_1 = require("@/transformers/resources/ProductResource");
+let ProductService = class ProductService {
+    productRepository;
+    businessRepository;
+    uploadService;
+    categoryRepository;
+    productImageRepository;
+    constructor() {
+        this.businessRepository = new BusinessRepository_1.BusinessRepository();
+        this.productRepository = new ProductRepository_1.ProductRepository();
+        this.categoryRepository = new CategoryRepository_1.CategoryRepository();
+        this.uploadService = new UploadService_1.default();
+        this.productImageRepository = new ProductImageRepository_1.ProductImageRepository();
+    }
+    async createProduct(productData, user_id) {
+        let message;
+        const { product_name, business_id, category, price, product_images, location, description, } = productData;
+        if (product_images && product_images?.length > 5) {
+            message = "Maximum of 5 product images allowed";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        const business = await this.businessRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                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 productCategory = await this.categoryRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: category
+            }
+        });
+        if (!productCategory) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product category");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const createdProduct = await this.productRepository.createWithCoordinates({
+            name: product_name,
+            business_id: business.id,
+            category_id: productCategory.id,
+            location,
+            price: price.toString(),
+            description,
+            user_id
+        }, location.longitude, location.latitude);
+        const productId = createdProduct.identifiers?.[0]?.id;
+        logger_1.logger.info("Product created without image");
+        if (product_images?.length) {
+            const uploadedFiles = await Promise.all(product_images.map((post_image) => this.uploadService.uploadImage(post_image, productId, UploadEnum_1.UploadDirectories.PRODUCT_IMAGES, "PostModel")));
+            logger_1.logger.info(`Product image added successfully for: ${productId}`);
+            await Promise.all(uploadedFiles.map((file) => this.productImageRepository.create({
+                product_id: productId,
+                image_id: file.id,
+            })));
+        }
+        logger_1.logger.info("Product image successfully created");
+        return {
+            successful: true,
+            data: null,
+            message: "Product created successfully"
+        };
+    }
+    async getProductCreationData() {
+        const categories = await this.categoryRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        return {
+            successful: true,
+            data: {
+                categories
+            },
+            message: "Product creation data fetched successfully!"
+        };
+    }
+    async getOneProduct(product_id, user_id) {
+        let message;
+        const { data } = await this.productRepository.getOneProduct(product_id, user_id);
+        const { raw } = data;
+        if (!raw[0]) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: ProductResource_1.ProductResource.toJSON(raw[0], user_id),
+            message: "Product fetched successfully!"
+        };
+    }
+    async getProductsByCategoryId(user_id, category_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        if (!category_id) {
+            message = "Category id is required";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        const category = await this.categoryRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: category_id
+            }
+        });
+        if (!category) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Category");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                category_id: category.id
+            }
+        };
+        const { data, total, perPage, page } = await this.productRepository.loadPaginatedProductsByCategoryId(dataFetchParams, user_id);
+        const { raw } = data;
+        const products = (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: ProductCollection_1.ProductCollection.toJSON(raw, user_id),
+        });
+        return {
+            successful: true,
+            data: products,
+            message: "Products fetched successfully!"
+        };
+    }
+    async getProductsByBusinessId(user_id, business_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        if (!business_id) {
+            message = "Business id is required";
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 422);
+        }
+        const business = await this.businessRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                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 dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                business_id: business.id
+            }
+        };
+        const products = await this.loadPaginatedProducts(dataFetchParams, user_id);
+        if (!products) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Products");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: products,
+            message: "Products fetched successfully!"
+        };
+    }
+    async getProducts(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 products = await this.loadPaginatedProducts(dataFetchParams, user_id);
+        if (!products) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Products");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: products,
+            message: "Products fetched successfully!"
+        };
+    }
+    async loadPaginatedProducts(loadPagesDto, userId) {
+        const { data, total, perPage, page } = await this.productRepository.loadPaginatedProducts(loadPagesDto, userId);
+        const { raw } = data;
+        return (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: ProductCollection_1.ProductCollection.toJSON(raw, userId),
+        });
+    }
+    async updateOneProduct(productData, product_id, user_id) {
+        let message;
+        const { product_name, category, price, location, description, } = productData;
+        const product = await this.productRepository.basicFindOneByConditions({
+            uuid: product_id,
+            user_id
+        });
+        if (!product) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const productCategory = await this.categoryRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: category
+            }
+        });
+        if (!productCategory) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product category");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.productRepository.updateWithCoordinates({
+            uuid: product.uuid,
+            user_id,
+        }, {
+            name: product_name,
+            category_id: productCategory.id,
+            location,
+            price: price.toString(),
+            description,
+        }, location.longitude, location.latitude);
+        return {
+            successful: true,
+            data: null,
+            message: "Product updated successfully!"
+        };
+    }
+    async deleteOneProduct(product_id, user_id) {
+        let message;
+        const product = await this.productRepository.basicFindOneByConditions({
+            uuid: product_id,
+            user_id
+        });
+        if (!product) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const productUploads = await this.productImageRepository.basicFindManyByConditions({
+            product_id: product.id
+        });
+        if (productUploads?.length) {
+            await Promise.all(productUploads.map((product_image) => this.uploadService.deleteFile(product_image.image_id, product_image?.product_id, "image")));
+            await this.productImageRepository.deleteByCondition({ product_id: product.id });
+        }
+        await this.productRepository.deleteByCondition({
+            uuid: product.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Product deleted successfully!"
+        };
+    }
+    async searchProducts(search_string, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                search_string
+            }
+        };
+        const products = await this.loadPaginatedProducts(dataFetchParams);
+        if (!products) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Products");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: products,
+            message: "Products fetched successfully!"
+        };
+    }
+    async deleteProductUpload(product_id, product_image_id, user_id) {
+        let message;
+        const product = await this.productRepository.basicFindOneByConditions({
+            uuid: product_id,
+            user_id
+        });
+        if (!product) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const productUpload = await this.productImageRepository.basicFindOneByConditions({
+            product_id: product.id,
+            uuid: product_image_id
+        });
+        if (!productUpload) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Product File");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        this.uploadService.deleteFile(productUpload.image_id, productUpload?.product_id, "image");
+        await this.productImageRepository.deleteByCondition({ product_id: product.id });
+        return {
+            successful: true,
+            data: null,
+            message: "Product image deleted successfully!"
+        };
+    }
+};
+ProductService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], ProductService);
+exports.default = ProductService;

package/dist/services/mobile/RedisService.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSessionStorage = void 0;
+// import { Session } from '@shopify/shopify-api'; 
+const redis_1 = require("../../common/configs/redis");
+class RedisSessionStorage {
+    redis;
+    prefix;
+    ttl;
+    constructor() {
+        this.redis = (0, redis_1.getRedisWorkerClient)();
+        this.prefix = 'shopify_session:';
+        this.ttl = 24 * 60 * 60; // 24 hours in seconds
+    }
+}
+exports.RedisSessionStorage = RedisSessionStorage;

package/dist/services/mobile/TransactionService.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+const logger_1 = require("@/common/configs/logger");
+const messages_1 = require("@/common/constants/messages");
+const AppError_1 = require("@/common/errors/AppError");
+const TransactionRepository_1 = require("@/repositories/TransactionRepository");
+const UserRepository_1 = require("@/repositories/UserRepository");
+const TransactionCollection_1 = require("@/transformers/collections/TransactionCollection");
+const TransactionResource_1 = require("@/transformers/resources/TransactionResource");
+class TransactionService {
+    transactionRepository;
+    userRepository;
+    constructor() {
+        this.transactionRepository = new TransactionRepository_1.TransactionRepository();
+        this.userRepository = new UserRepository_1.UserRepository();
+    }
+    async fetchTransactions(user_id) {
+        const transactions = await this.transactionRepository.findManyAndRelations({
+            where: { user_id },
+            relations: ['card', 'user']
+        });
+        return {
+            successful: true,
+            data: TransactionCollection_1.TransactionCollection.toJSON(transactions),
+            message: messages_1.dynamic_messages.FETCHED_SUCCESSFULLY("Transactions"),
+        };
+    }
+    async fetchOneTransaction(user_id, transaction_id) {
+        let message;
+        const transaction = await this.transactionRepository.getRepo()
+            .createQueryBuilder("transaction")
+            .leftJoinAndSelect("transaction.user", "user")
+            .leftJoinAndSelect("user.plan", "plan")
+            .leftJoinAndSelect("transaction.card", "card")
+            .where("transaction.id = :id", { uuid: transaction_id })
+            .andWhere("transaction.user_id = :user_id", { user_id })
+            .getOne();
+        if (!transaction) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Trsansaction");
+            logger_1.logger.error(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: transaction ? TransactionResource_1.TransactionResource.toJSON(transaction) : null,
+            message: messages_1.dynamic_messages.FETCHED_SUCCESSFULLY("Transactions"),
+        };
+    }
+}
+exports.TransactionService = TransactionService;

package/dist/services/mobile/UploadService.js

@@ -0,0 +1,110 @@
+"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 configs_1 = require("@/common/configs");
+const cloudinary_1 = __importDefault(require("@/common/configs/cloudinary"));
+const UploadEnum_1 = require("@/common/enums/UploadEnum");
+const AppError_1 = require("@/common/errors/AppError");
+const UploadRepository_1 = require("@/repositories/UploadRepository");
+const typedi_1 = require("typedi");
+const heic_convert_1 = __importDefault(require("heic-convert"));
+let UploadService = class UploadService {
+    uploadRepository;
+    constructor() {
+        this.uploadRepository = new UploadRepository_1.UploadRepository();
+    }
+    async deleteFromCloudinary(publicId, resource_type) {
+        return cloudinary_1.default.uploader.destroy(publicId, { resource_type });
+    }
+    ;
+    async uploadToCloudinary(file, folder, resource_type) {
+        return new Promise((resolve, reject) => {
+            const stream = cloudinary_1.default.uploader.upload_stream({
+                folder,
+                resource_type,
+            }, (error, result) => {
+                if (error) {
+                    return reject(new AppError_1.AppError(error.message || `${file.originalname} upload failed`));
+                }
+                resolve(result);
+            });
+            stream.end(file.buffer);
+        });
+    }
+    ;
+    async normalizeImageForUpload(file) {
+        if (file.mimetype === "image/heic" ||
+            file.mimetype === "image/heif") {
+            const outputBuffer = await (0, heic_convert_1.default)({
+                buffer: file.buffer,
+                format: "JPEG",
+                quality: 0.9,
+            });
+            return {
+                ...file,
+                buffer: Buffer.from(outputBuffer),
+                mimetype: "image/jpeg",
+                originalname: file.originalname.replace(/\.(heic|heif)$/i, ".jpg"),
+                size: Buffer.byteLength(outputBuffer),
+            };
+        }
+        return file;
+    }
+    async uploadImage(file, uploadable_id, directory, uploadable_type) {
+        const { MAX_FILE_SIZE, ALLOWED_FILE_TYPES } = configs_1.CONFIGS.UPLOAD.IMAGE;
+        if (!ALLOWED_FILE_TYPES.includes(file.mimetype)) {
+            throw new AppError_1.AppError(`Invalid file type. Allowed: ${ALLOWED_FILE_TYPES.join(", ")}`);
+        }
+        if (file.size > MAX_FILE_SIZE) {
+            throw new AppError_1.AppError(`File size exceeds limit of ${MAX_FILE_SIZE / (1024 * 1024)}MB`);
+        }
+        const resource_type = "image";
+        const normalizedFile = await this.normalizeImageForUpload(file);
+        const response = await this.uploadFile(normalizedFile, directory, resource_type);
+        return await this.uploadRepository.create({
+            metadata: response,
+            file_name: file.originalname,
+            file_mimetype: file.mimetype,
+            file_host_provider: UploadEnum_1.FILE_HOST_PROVIDER.CLOUDINARY,
+            url: response.secure_url,
+            uploadable_id,
+            uploadable_type,
+            file_size: file.size,
+        });
+    }
+    async uploadFile(file, folder, resource_type) {
+        return await this.uploadToCloudinary(file, folder, resource_type);
+    }
+    async deleteFile(file_id, uploadable_id, resource_type) {
+        const uploadedFile = await this.uploadRepository.basicFindOneByConditions({
+            id: file_id,
+            uploadable_id
+        });
+        if (uploadedFile) {
+            await this.uploadRepository.deleteByCondition({
+                uuid: uploadedFile.uuid,
+                uploadable_id
+            });
+            if (uploadedFile.file_host_provider == UploadEnum_1.FILE_HOST_PROVIDER.CLOUDINARY) {
+                const metadata = uploadedFile?.metadata;
+                await this.deleteFromCloudinary(metadata?.public_id, resource_type);
+            }
+        }
+    }
+};
+UploadService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], UploadService);
+exports.default = UploadService;

package/dist/services/mobile/UserService.js

@@ -0,0 +1,128 @@
+"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 UserRepository_1 = require("../../repositories/UserRepository");
+const messages_1 = require("../../common/constants/messages");
+const UserResource_1 = require("@/transformers/resources/UserResource");
+const UploadEnum_1 = require("@/common/enums/UploadEnum");
+const UploadService_1 = __importDefault(require("./UploadService"));
+const utils_1 = require("@/common/utils");
+let UserService = class UserService {
+    userRepository;
+    userProfileRepository;
+    uploadService;
+    constructor() {
+        this.userRepository = new UserRepository_1.UserRepository();
+        this.userProfileRepository = new UserRepository_1.UserProfileRepository();
+        this.uploadService = new UploadService_1.default();
+    }
+    async getProfile(user_id) {
+        let message;
+        const existingUser = await this.userRepository.findOneAndRelations({
+            where: {
+                id: user_id
+            },
+            relations: ["user_profile", "user_profile.avatar"]
+        });
+        if (!existingUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("User");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message);
+        }
+        message = messages_1.dynamic_messages.FETCHED_SUCCESSFULLY("User");
+        return {
+            successful: true, data: UserResource_1.UserResource.userToJSON(existingUser),
+            message
+        };
+    }
+    async getProfileByUuid(user_uuid, user_id) {
+        let message;
+        const existingUser = await this.userRepository.findOneAndRelations({
+            where: {
+                uuid: user_uuid
+            },
+            relations: ["user_profile", "user_profile.avatar"]
+        });
+        if (!existingUser) {
+            message = messages_1.dynamic_messages.NOT_FOUND("User");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message);
+        }
+        message = messages_1.dynamic_messages.FETCHED_SUCCESSFULLY("User");
+        return {
+            successful: true, data: UserResource_1.UserResource.userToJSON(existingUser),
+            message
+        };
+    }
+    async updateProfile(req, user_id) {
+        const { full_name, phone, ...rest } = req;
+        const existingProfile = await this.userProfileRepository.basicFindOneByConditions({
+            id: user_id
+        });
+        await this.userRepository.updateOne({ id: user_id }, { full_name, phone });
+        if (!existingProfile) {
+            await this.userProfileRepository.create({ ...rest, user_id });
+        }
+        else {
+            await this.userProfileRepository.updateOne({ user_id }, rest);
+        }
+        logger_1.logger.debug(messages_1.dynamic_messages.SUCCESSFULLY_UPDATED("Profile"));
+        return {
+            successful: true,
+            data: null,
+            message: messages_1.dynamic_messages.SUCCESSFULLY_UPDATED("Profile"),
+        };
+    }
+    async updateProfileAvatar(avatar, user_id) {
+        const existingProfile = await this.userProfileRepository.findOneAndRelations({
+            where: { user: {
+                    id: user_id
+                } },
+            relations: ['user']
+        });
+        const uploadedFile = await this.uploadService.uploadImage(avatar, user_id, UploadEnum_1.UploadDirectories.USERS, "UserProfileModel");
+        logger_1.logger.info("User avatar successfully created");
+        if (!existingProfile) {
+            await this.userProfileRepository.create({ profile_image_id: uploadedFile.id, user_id });
+        }
+        else {
+            await this.userProfileRepository.updateOne({ user_id }, { profile_image_id: uploadedFile.id });
+        }
+        logger_1.logger.debug(messages_1.dynamic_messages.SUCCESSFULLY_UPDATED("Profile image"));
+        return {
+            successful: true,
+            data: null,
+            message: messages_1.dynamic_messages.SUCCESSFULLY_UPDATED("Profile image"),
+        };
+    }
+    async changeUserPassword(req, user_id) {
+        const { new_password } = req;
+        const password_hash = await (0, utils_1.hashString)(new_password);
+        await this.userRepository.updateOne({ id: user_id }, { password_hash });
+        logger_1.logger.debug(messages_1.dynamic_messages.SUCCESSFULLY_UPDATED("Password"));
+        return {
+            successful: true,
+            data: null,
+            message: messages_1.dynamic_messages.SUCCESSFULLY_UPDATED("Password"),
+        };
+    }
+};
+UserService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], UserService);
+exports.default = UserService;