feat: changing sell process sales service method

JoanVasquez · JoanVasquez · commit 802db970ec99 · 2025-03-27T21:29:49.000-04:00
diff --git a/src/controllers/SellController.ts b/src/controllers/SellController.ts
@@ -33,17 +33,17 @@ export default class SellController extends BaseController {
    * - Calls `SellService.processSale` to create the customer, bill, and sales.
    * - Returns the newly created bill with associated sales.
    */
-  processSale = async (
+  processSales = async (
     req: Request,
     res: Response,
     next: NextFunction,
   ): Promise<void> => {
     try {
-      const { customer, sales } = req.body;
+      const { sales: saleDTO } = req.body;
 
-      logger.info(`🛒 [SellController] Processing sale for: ${customer.email}`);
+      logger.info(`🛒 [SellController] Processing sale`);
 
-      const bill = await this.sellServiceImpl?.processSale(customer, sales);
+      const isSaleProcessed = await this.sellServiceImpl?.processSales(saleDTO);
 
       res
         .status(httpStatus.CREATED.code)
@@ -52,13 +52,9 @@ export default class SellController extends BaseController {
             httpStatus.CREATED.code,
             httpStatus.CREATED.status,
             'Sale processed successfully',
-            bill,
+            isSaleProcessed,
           ),
         );
-
-      logger.info(
-        `✅ [SellController] Sale processed under bill ID: ${bill?.id}`,
-      );
     } catch (error) {
       logger.error(`❌ [SellController] Sale processing failed`, { error });
       next(error);
diff --git a/src/routes/sell.router.ts b/src/routes/sell.router.ts
@@ -78,7 +78,7 @@ router.post(
   verifyToken,
   sellValidation,
   validateRequest,
-  sellController.processSale,
+  sellController.processSales,
 );
 
 /**
diff --git a/src/services/SellService.ts b/src/services/SellService.ts
@@ -4,15 +4,24 @@ import { Customer } from '../models/Customer';
 import { SellRepository } from '../repositories/SellRepository';
 import { BillRepository } from '../repositories/BillRepository';
 import { CustomerRepository } from '../repositories/CustomerRepository';
-import { ProductService } from '../services/ProductService';
 import { GenericService } from './GenericService';
 import { Cache } from '../utils/cacheUtil';
 import logger from '../utils/logger';
 import { inject, injectable } from 'tsyringe';
 import { BaseAppException } from '../errors/BaseAppException';
-import { uploadFile } from '../utils/s3Util'; // S3 utility
-import { sendEmail } from '../utils/sesUtil'; // SES utility
-import { customer_receipt } from '../email_templates/templates'; // hypothetical utility to format bill
+import { uploadFile } from '../utils/s3Util';
+import { sendEmail } from '../utils/sesUtil';
+import { customer_receipt } from '../email_templates/templates';
+import { ProductRepository } from '../repositories/ProductRepository';
+
+export interface ProcessSalesDTO {
+  customerId: number;
+  sales: Array<{
+    productId: number;
+    quantity: number;
+    sale_price: number;
+  }>;
+}
 
 @injectable()
 export class SellService extends GenericService<Sale> {
@@ -22,98 +31,129 @@ export class SellService extends GenericService<Sale> {
     @inject('BillRepository') private readonly billRepository: BillRepository,
     @inject('CustomerRepository')
     private readonly customerRepository: CustomerRepository,
-    @inject('ProductService') private readonly productService: ProductService,
+    @inject('ProductRepository')
+    private readonly productRepository: ProductRepository,
   ) {
     super(cache, sellRepository, Sale);
     logger.info('✅ [SellService] Initialized SellService');
     this.sellRepository = sellRepository;
     this.billRepository = billRepository;
     this.customerRepository = customerRepository;
-    this.productService = productService;
+    this.productRepository = productRepository;
   }
 
-  async processSale(
-    customerData: Omit<Customer, 'id' | 'bills'>,
-    sales: { productId: number; quantity: number; salePrice: number }[],
-  ): Promise<Bill> {
+  async processSales(salesDTO: ProcessSalesDTO): Promise<boolean> {
+    logger.info('🚀 Starting processSales...');
+
+    // 1️⃣ Retrieve the customer
+    const customer: Customer | null =
+      await this.customerRepository.findEntityById(salesDTO.customerId);
+    if (!customer) {
+      logger.error('❌ Customer not found with id: %s', salesDTO.customerId);
+      throw new BaseAppException('Customer not found');
+    }
     logger.info(
-      `🛒 [SellService] Processing sale for new customer: ${customerData.email}`,
+      '👤 Found customer: %s %s',
+      customer.first_name,
+      customer.last_name,
     );
 
-    const newCustomer = new Customer();
-    Object.assign(newCustomer, customerData);
-    const savedCustomer =
-      await this.customerRepository.createEntity(newCustomer);
-
-    const newBill = new Bill();
-    newBill.customer = savedCustomer!;
-    newBill.total_amount = 0;
-    newBill.sales = [];
-
-    const savedBill = await this.billRepository.createEntity(newBill);
-
-    let totalAmount = 0;
-
-    for (const sale of sales) {
-      const product = await this.productService.findById(sale.productId);
-      if (!product || product.available_quantity < sale.quantity) {
+    // 2️⃣ Create a new Bill for the customer
+    const bill = new Bill();
+    bill.customer = customer;
+    bill.total_amount = 0;
+    bill.sales = [];
+    logger.info('🧾 New bill created for customer');
+
+    // 3️⃣ Process each sale item
+    for (const saleDTO of salesDTO.sales) {
+      logger.info(
+        '🔍 Processing sale item for product id: %s',
+        saleDTO.productId,
+      );
+
+      const product = await this.productRepository.findEntityById(
+        saleDTO.productId,
+      );
+      if (!product) {
+        logger.error('❌ Product not found with id: %s', saleDTO.productId);
         throw new BaseAppException(
-          `❌ Insufficient stock or invalid product ID: ${sale.productId}`,
+          `Product with id ${saleDTO.productId} not found`,
         );
       }
+      logger.info('📦 Found product: %s', product.name);
 
-      const newSale = new Sale();
-      newSale.bill = savedBill!;
-      newSale.product = product;
-      newSale.quantity = sale.quantity;
-      newSale.sale_price = sale.salePrice;
+      if (product.available_quantity < saleDTO.quantity) {
+        logger.error('❌ Insufficient stock for product: %s', product.name);
+        throw new BaseAppException(
+          `Insufficient stock for product ${product.name}`,
+        );
+      }
 
-      await this.sellRepository.createEntity(newSale);
-      newBill.sales.push(newSale);
+      // Update product stock
+      product.available_quantity -= saleDTO.quantity;
+      await this.productRepository.updateEntity(saleDTO.productId, product);
+      logger.info(
+        '✅ Updated stock for product %s, new quantity: %s',
+        product.name,
+        product.available_quantity,
+      );
+
+      // Create and add Sale
+      const sale = new Sale();
+      sale.bill = bill;
+      sale.product = product;
+      sale.quantity = saleDTO.quantity;
+      sale.sale_price = saleDTO.sale_price;
+      bill.sales.push(sale);
+      bill.total_amount += sale.sale_price * sale.quantity;
+      logger.info(
+        '🛍️ Added sale item: %s units of %s at $%s each',
+        sale.quantity,
+        product.name,
+        sale.sale_price,
+      );
+    }
 
-      totalAmount += sale.quantity * sale.salePrice;
+    // 4️⃣ Save the Bill (cascading the sales)
+    const savedBill = await this.billRepository.createEntity(bill);
 
-      await this.productService.update(product.id, {
-        available_quantity: product.available_quantity - sale.quantity,
-      });
+    if (!savedBill) {
+      logger.error('❌ Error saving bill');
+      throw new BaseAppException('Error saving bill');
     }
 
-    savedBill!.total_amount = totalAmount;
-    const finalBill = await this.billRepository.updateEntity(savedBill!.id, {
-      total_amount: totalAmount,
-    });
+    logger.info(
+      '💾 Bill saved with id: %s, Total amount: $%s',
+      savedBill.id,
+      savedBill.total_amount,
+    );
 
-    // 🧾 Upload the bill HTML to S3
-    const billHtml = customer_receipt(finalBill!);
-    const fileName = `bill-${finalBill!.id}.html`;
+    // 5️⃣ Generate a receipt and upload it to S3
+    const billHtml = customer_receipt(savedBill);
+    const fileName = `${customer.first_name}-${customer.last_name}-bill-${savedBill.date.toISOString()}.html`;
     const contentType = 'text/html';
     const bucket = process.env.S3_BUCKET_BILL ?? 'default-bill-bucket';
-    const fileUrl = await uploadFile(
-      fileName,
-      Buffer.from(billHtml),
-      contentType,
-      bucket,
-    );
+    await uploadFile(fileName, Buffer.from(billHtml), contentType, bucket);
+    logger.info('☁️ Receipt uploaded to S3: %s', fileName);
 
-    logger.info(`📤 [SellService] Bill uploaded to S3: ${fileUrl}`);
-
-    // 📩 Email the bill
+    // 6️⃣ Send the receipt via email to the customer
     await sendEmail(
-      [savedCustomer!.email],
-      `Your Purchase Receipt - Bill #${finalBill!.id}`,
+      [customer.email],
+      `Your Purchase Receipt - Bill #${savedBill.id}`,
       billHtml,
     );
+    logger.info('📧 Receipt email sent to: %s', customer.email);
 
-    logger.info(
-      `📧 [SellService] Bill sent to customer: ${savedCustomer!.email}`,
-    );
-
+    // 7️⃣ Cache the saved bill
     await this.cache.set(
-      `bill:${finalBill!.id}`,
-      JSON.stringify(finalBill),
+      `bill:${savedBill.id}`,
+      JSON.stringify(savedBill),
       3600,
     );
+    logger.info('🔒 Bill cached with key: bill:%s', savedBill.id);
 
-    return finalBill!;
+    logger.info('🎉 processSales completed successfully.');
+    return true;
   }
 }
diff --git a/src/utils/inputValidation.ts b/src/utils/inputValidation.ts
@@ -143,61 +143,31 @@ export const productValidation = [
  * Ensures valid input fields for processing a sale.
  */
 export const sellValidation = [
-  body('customer.email')
+  body('customerId')
     .notEmpty()
     .withMessage(validationMessage.REQUIRED)
-    .isEmail()
-    .withMessage(validationMessage.INVALID_EMAIL),
-
-  body('customer.first_name')
-    .notEmpty()
-    .withMessage(validationMessage.REQUIRED)
-    .isString()
-    .withMessage('📝 First name must be a string')
-    .isLength({ min: 2, max: 50 })
-    .withMessage(validationMessage.STRING_LENGTH(2, 50)),
-
-  body('customer.last_name')
-    .notEmpty()
-    .withMessage(validationMessage.REQUIRED)
-    .isString()
-    .withMessage('📝 Last name must be a string')
-    .isLength({ min: 2, max: 50 })
-    .withMessage(validationMessage.STRING_LENGTH(2, 50)),
-
-  body('customer.address')
-    .optional()
-    .isString()
-    .withMessage('📍 Address must be a string')
-    .isLength({ min: 5, max: 255 })
-    .withMessage(validationMessage.STRING_LENGTH(5, 255)),
-
-  body('customer.phonenumber')
-    .optional()
-    .isString()
-    .withMessage('📞 Phone number must be a string')
-    .isLength({ min: 8, max: 20 })
-    .withMessage(validationMessage.STRING_LENGTH(8, 20)),
+    .isNumeric()
+    .withMessage('Customer ID must be a number'),
 
   body('sales')
     .isArray({ min: 1 })
-    .withMessage('🛍️ Sales must be an array with at least one item'),
+    .withMessage('Sales must be an array with at least one sale item'),
 
   body('sales.*.productId')
     .notEmpty()
     .withMessage(validationMessage.REQUIRED)
     .isNumeric()
-    .withMessage(validationMessage.INVALID_NUMBER),
+    .withMessage('Product ID must be a number'),
 
   body('sales.*.quantity')
     .notEmpty()
     .withMessage(validationMessage.REQUIRED)
-    .isInt({ min: 1 })
-    .withMessage(validationMessage.POSITIVE_NUMBER),
+    .isInt({ gt: 0 })
+    .withMessage('Quantity must be a positive integer'),
 
-  body('sales.*.salePrice')
+  body('sales.*.sale_price')
     .notEmpty()
     .withMessage(validationMessage.REQUIRED)
-    .isFloat({ min: 0.01 })
-    .withMessage(validationMessage.POSITIVE_NUMBER),
+    .isFloat({ gt: 0 })
+    .withMessage('Sale price must be a positive number'),
 ];
