Development

.github/workflows/workflow.yml

@@ -37,3 +37,12 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      - name: ChatGPT comment
+        uses: kxxt/chatgpt-action@v0.3
+        id: chatgpr
+        with:
+          number: ${{ github.event.pull_request.number }}
+          sessionToken: ${{ secrets.CHATGPT_SESSION_TOKEN }}
+          split: "yolo"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

backend/src/application/constants/types.ts

@@ -22,4 +22,5 @@ export const TYPES = {
   IAddonRepository: Symbol('IAddonRepository'),
   IOrderRepository: Symbol('IOrderRepository'),
   IOrderService: Symbol('IOrderService'),
+  ICartItemRepository: Symbol('ICartItemRepository'),
 };

backend/src/cart/cart-item.ts

@@ -47,7 +47,7 @@ export class CartItem extends Entity<ICartItem> implements ICartItem {
     return this._selectedItems;
   }
 
-  set setSelectedItems(selectedItems: SelectedCartItem[] | undefined) {
+  set selectedItems(selectedItems: SelectedCartItem[] | undefined) {
     this._selectedItems = selectedItems;
   }
 

backend/src/infrastructure/data_access/repositories/cart-item.repository.ts

@@ -1,19 +1,32 @@
-import { CartItemMapper } from './../../../cart/cart-item.mapper';
 import { Injectable } from '@nestjs/common';
+import { InjectConnection, InjectModel } from '@nestjs/mongoose';
+import { Connection, Model } from 'mongoose';
 import { CartItem } from 'src/cart/cart-item';
 import { GenericDocumentRepository } from 'src/infrastructure/database';
+import { CartItemMapper } from './../../../cart/cart-item.mapper';
+import { ICartItemRepository } from './interfaces/cart-item-repository.interface';
 import { CartItemDataModel, CartItemDocument } from './schemas/cartItem.schema';
-import { InjectConnection, InjectModel } from '@nestjs/mongoose';
-import { Connection, Model } from 'mongoose';
+import { Result } from 'src/domain';
 
 @Injectable()
-export class CartItemRepository extends GenericDocumentRepository<CartItem, CartItemDocument> {
+export class CartItemRepository
+  extends GenericDocumentRepository<CartItem, CartItemDocument>
+  implements ICartItemRepository
+{
   cartItemMapper: CartItemMapper;
   constructor(
     @InjectModel(CartItemDataModel.name) cartItemDataModel: Model<CartItemDocument>,
     @InjectConnection() readonly connection: Connection,
     cartItemMapper: CartItemMapper,
   ) {
     super(cartItemDataModel, connection, cartItemMapper);
+    this.cartItemMapper = cartItemMapper;
+  }
+
+  async updateCartItemSelectedItems(cartItems: CartItem[]): Promise<void> {
+    const document = cartItems.map((doc) => this.cartItemMapper.toPersistence(doc));
+    document.forEach((item) => {
+      this.updateOne({ _id: item._id }, { selectedItems: item.selectedItems });
+    });
   }
 }

backend/src/infrastructure/data_access/repositories/interfaces/cart-item-repository.interface.ts

@@ -0,0 +1,7 @@
+import { CartItem } from 'src/cart/cart-item';
+import { IGenericDocument } from 'src/infrastructure/database';
+import { CartItemDocument } from '../schemas/cartItem.schema';
+
+export interface ICartItemRepository extends IGenericDocument<CartItem, CartItemDocument> {
+  updateCartItemSelectedItems(cartItems: CartItem[]): Promise<void>;
+}

backend/src/infrastructure/database/mongoDB/generic-document.interface.ts

@@ -16,7 +16,7 @@ export interface IGenericDocument<TEntity, T> {
 
   findOneAndUpdate(filterQuery: FilterQuery<T>, update: UpdateQuery<T>): Promise<Result<TEntity | null>>;
 
-  upsert(filterQuery: FilterQuery<T>, document: Partial<T>): Promise<TEntity | unknown>;
+  upsert(filterQuery: FilterQuery<T>, document: Partial<T>): Promise<Result<TEntity | null>>;
 
   deleteMany(filterQuery: FilterQuery<T>): Promise<boolean>;
 

backend/src/infrastructure/database/mongoDB/generic-document.repository.ts

@@ -75,13 +75,20 @@ export abstract class GenericDocumentRepository<TEntity, T extends Document> imp
     select?: ProjectionType<T | null>,
     options?: QueryOptions<T>,
   ): Promise<Result<TEntity[] | []>> {
-    const documents = await this.DocumentModel.find(query, select, options)
-      .skip(options ? options.skip : null)
-      .limit(options ? options.limit : null)
-      .lean()
-      .exec();
-    const entities = documents?.length ? documents.map((document) => this.mapper.toDomain(document)) : [];
-    return Result.ok(entities);
+    try {
+      const documents = await this.DocumentModel.find(query, select, options)
+        .skip(options ? options.skip : null)
+        .limit(options ? options.limit : null)
+        .lean()
+        .exec();
+      if (!documents?.length) {
+        throwApplicationError(HttpStatus.INTERNAL_SERVER_ERROR, 'documents does not exist');
+      }
+      const entities = documents?.length ? documents.map((document) => this.mapper.toDomain(document)) : [];
+      return Result.ok(entities);
+    } catch (error) {
+      console.error(error);
+    }
   }
 
   async pagination(query: FilterQuery<T>, select: ProjectionType<T | null>, options: QueryOptions<T>) {
@@ -116,7 +123,7 @@ export abstract class GenericDocumentRepository<TEntity, T extends Document> imp
     return Result.ok(entity);
   }
 
-  async upsert(filterQuery: FilterQuery<T>, document: Partial<T>): Promise<unknown> {
+  async upsert(filterQuery: FilterQuery<T>, document: Partial<T>): Promise<Result<TEntity | null>> {
     const result = await this.DocumentModel.findOneAndUpdate(filterQuery, document, {
       lean: true,
       upsert: true,
@@ -127,7 +134,7 @@ export abstract class GenericDocumentRepository<TEntity, T extends Document> imp
       return Result.fail('Unable to update the database', HttpStatus.INTERNAL_SERVER_ERROR);
     }
     const entity = this.mapper.toDomain(result);
-    return entity;
+    return Result.ok(entity);
   }
 
   async deleteMany(filterQuery: FilterQuery<T>): Promise<boolean> {
@@ -159,9 +166,32 @@ export abstract class GenericDocumentRepository<TEntity, T extends Document> imp
   }
 
   async updateOne(filter: any, query: any): Promise<Result<TEntity>> {
-    const document = await this.DocumentModel.updateOne(filter, { $set: query });
-    const entity: TEntity = this.mapper.toDomain(document as any);
-    return Result.ok(entity);
+    try {
+      const document = await this.DocumentModel.updateOne(filter, { $set: query });
+      if (!document) {
+        throwApplicationError(HttpStatus.INTERNAL_SERVER_ERROR, 'Unable to update document in the database');
+      }
+      const entity: TEntity = this.mapper.toDomain(document as any);
+      return Result.ok(entity);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  async updateMany(query: FilterQuery<T>, updateBody: UpdateQuery<T>): Promise<Result<TEntity[]>> {
+    try {
+      const saved = await this.DocumentModel.updateMany(query, updateBody, {
+        multi: true,
+      });
+      if (saved.matchedCount < 1) {
+        throwApplicationError(HttpStatus.INTERNAL_SERVER_ERROR, 'Unable to update documents into the database');
+      }
+      const updatedDocuments = await this.DocumentModel.find(query);
+      const entities: TEntity[] = updatedDocuments.map((doc) => this.mapper.toDomain(doc));
+      return Result.ok(entities);
+    } catch (error) {
+      console.error(error);
+    }
   }
 
   createDocument(document: any) {

backend/src/order/order.module.ts

@@ -42,6 +42,7 @@ import { ContextMiddleWare } from 'src/infrastructure/middlewares';
   controllers: [OrderController],
   providers: [
     { provide: TYPES.IOrderService, useClass: OrderService },
+    { provide: TYPES.ICartItemRepository, useClass: CartItemRepository },
     { provide: TYPES.IOrderRepository, useClass: OrderRepository },
     { provide: TYPES.IMerchantService, useClass: MerchantService },
     { provide: TYPES.IContextService, useClass: ContextService },

backend/src/order/order.service.ts

@@ -20,6 +20,7 @@ import { Order } from './order';
 import { IOrderResponseDTO } from './order-response.dto';
 import { OrderMapper } from './order.mapper';
 import { OrderParser } from './order.parser';
+import { ICartItemRepository } from 'src/infrastructure/data_access/repositories/interfaces/cart-item-repository.interface';
 
 export class OrderService implements IOrderService {
   private context: Context;
@@ -29,11 +30,11 @@ export class OrderService implements IOrderService {
     @Inject(TYPES.IContextService)
     private readonly contextService: IContextService,
     private readonly merchantRepository: MerchantRepository,
-    private readonly cartItemRepository: CartItemRepository,
     private readonly selectedCartItemRepository: SelectedCartItemRepository,
     private readonly orderMapper: OrderMapper,
     private readonly selectedItemMapper: SelectedCartItemMapper,
     private readonly cartItemMapper: CartItemMapper,
+    @Inject(TYPES.ICartItemRepository) private readonly cartItemRepository: ICartItemRepository,
   ) {
     this.context = this.contextService.getContext();
   }
@@ -64,6 +65,14 @@ export class OrderService implements IOrderService {
         const cartItemDataModels: CartItemDataModel[] = items.map((item) => this.cartItemMapper.toPersistence(item));
         const savedCartItems: Result<CartItem[]> = await this.cartItemRepository.insertMany(cartItemDataModels);
         const savedItems = savedCartItems.getValue();
+        savedOrder.cartItems = savedItems;
+        const orderWithCartItems = await this.orderRepository.upsert(
+          { _id: orderId },
+          this.orderMapper.toPersistence(savedOrder),
+        );
+        if (orderWithCartItems.isSuccess === false) {
+          throwApplicationError(HttpStatus.INTERNAL_SERVER_ERROR, `Error while creating order`);
+        }
 
         const cartItemMap = savedItems.reduce((map, item) => {
           map.set(this.orderRepository.objectIdToString(item.menuId), this.orderRepository.objectIdToString(item.id));
@@ -73,13 +82,12 @@ export class OrderService implements IOrderService {
         const cartSelectedItems = cartItems.map((item) => item.selectedItems);
         const flattenedSelectedItems = cartSelectedItems.flat();
         flattenedSelectedItems.forEach((item) => {
-          console.log(item.menuId);
           if (cartItemMap.has(this.orderRepository.objectIdToString(item.menuId))) {
-            item.cartItemId = this.orderRepository.stringToObjectId(
-              cartItemMap.get(this.orderRepository.objectIdToString(item.menuId)),
-            );
+            const cartItemId = cartItemMap.get(this.orderRepository.objectIdToString(item.menuId));
+            item.cartItemId = this.orderRepository.stringToObjectId(cartItemId);
           }
         });
+
         const selectedItems = flattenedSelectedItems.map((item) => SelectedCartItem.create({ ...item, audit }));
         const selectedCartItemsDataModel = selectedItems.map((item) => this.selectedItemMapper.toPersistence(item));
         const insertedItems: Result<SelectedCartItem[]> = await this.selectedCartItemRepository.insertMany(
@@ -91,12 +99,25 @@ export class OrderService implements IOrderService {
         } else {
           throwApplicationError(HttpStatus.INTERNAL_SERVER_ERROR, `Could not create an order`);
         }
+
+        const savedSelectedItems = insertedItems.getValue();
+        const savedItemsMap = savedSelectedItems.reduce((map, item) => {
+          const cartItemIdToString = this.cartItemRepository.objectIdToString(item.cartItemId);
+          !map.has(cartItemIdToString) ? map.set(cartItemIdToString, [item]) : map.get(cartItemIdToString).push(item);
+          return map;
+        }, new Map<string, SelectedCartItem[]>());
+        savedItems.forEach((item) => {
+          if (savedItemsMap.has(this.cartItemRepository.objectIdToString(item.id))) {
+            item.selectedItems = savedItemsMap.get(this.cartItemRepository.objectIdToString(item.id));
+          }
+        });
+        await this.cartItemRepository.updateCartItemSelectedItems(savedItems);
+        await session.commitTransaction();
         return Result.ok(response);
       }
     } catch (error) {
       session.abortTransaction();
     } finally {
-      await session.commitTransaction();
       await session.endSession();
     }
   }