Revert "fix: try to fix order details randomly returning 404"

This reverts commit 504489c.

Author: marcinkrasowski

apps/api-harmonization/src/blocks/order-details/order-details.mapper.ts

@@ -9,7 +9,7 @@ import { OrderDetailsBlock } from './order-details.model';
 
 export const mapOrderDetails = (
     cms: CMS.Model.OrderDetailsBlock.OrderDetailsBlock,
-    order: Orders.Model.Order,
+    order: Orders.Model.Order & { totalItems: number },
     locale: string,
     timezone: string,
     defaultProductUnit: string,
@@ -37,7 +37,7 @@ export const mapOrderDetails = (
                 title: cms.totalValue.title,
                 icon: cms.totalValue.icon,
                 label: checkNegativeValue(order.total).value.toString(),
-                description: cms.totalValue.message?.replace(/{value}/g, order.items.length.toString()),
+                description: cms.totalValue.message?.replace(/{value}/g, order.totalItems.toString()),
                 value: order.total,
             },
             createdAt: {
@@ -90,7 +90,7 @@ export const mapOrderDetails = (
             title: cms.productsTitle,
             products: {
                 data: mapOrderItems(order.items, cms.fieldMapping, defaultProductUnit),
-                total: order.items.length,
+                total: order.totalItems,
             },
             table: cms.table,
             pagination: cms.pagination,

apps/api-harmonization/src/blocks/order-details/order-details.service.ts

@@ -1,6 +1,8 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { Observable, forkJoin, map } from 'rxjs';
+import { Observable, forkJoin, map, of, switchMap } from 'rxjs';
+
+import { Models } from '@o2s/framework/modules';
 
 import { AppHeaders } from '@o2s/api-harmonization/utils/headers';
 
@@ -32,18 +34,82 @@ export class OrderDetailsService {
         const order = this.orderService.getOrder({ ...params }, headers['authorization']);
 
         return forkJoin([cms, order]).pipe(
-            map(([cms, order]) => {
+            switchMap(([cms, order]) => {
                 if (!order) {
                     throw new NotFoundException();
                 }
-                return mapOrderDetails(
+
+                if (!order.items || order.items.length === 0) {
+                    return of({ cms, order });
+                }
+
+                const productRequests = order.items.map((item) => {
+                    if (item.product?.id) {
+                        return of(item);
+                    }
+
+                    return this.productService
+                        .getProduct({
+                            id: item.productId,
+                            locale: headers['x-locale'],
+                        })
+                        .pipe(
+                            map((product) => ({
+                                ...item,
+                                product,
+                            })),
+                        );
+                });
+
+                return forkJoin(productRequests).pipe(
+                    map((updatedItems) => {
+                        let filteredItems = updatedItems;
+                        const { offset = 0, limit = 5, sort = 'name_ASC' } = query;
+
+                        if (sort) {
+                            const [field, order] = sort.split('_');
+                            const isAscending = order === 'ASC';
+
+                            filteredItems = filteredItems.sort((a, b) => {
+                                const aValue = a[field as keyof Orders.Model.OrderItem];
+                                const bValue = b[field as keyof Orders.Model.OrderItem];
+
+                                if (field === 'discountTotal' || field === 'total' || field === 'price') {
+                                    if (!aValue || !bValue) return 0;
+
+                                    const aValueNumber = (aValue as Models.Price.Price).value;
+                                    const bValueNumber = (bValue as Models.Price.Price).value;
+                                    return isAscending ? aValueNumber - bValueNumber : bValueNumber - aValueNumber;
+                                } else if (field === 'name' || field === 'sku') {
+                                    const aField = a.product?.[field] ?? '';
+                                    const bField = b.product?.[field] ?? '';
+                                    return isAscending ? aField.localeCompare(bField) : bField.localeCompare(aField);
+                                } else if (typeof aValue === 'string' && typeof bValue === 'string') {
+                                    return isAscending ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
+                                } else if (typeof aValue === 'number' && typeof bValue === 'number') {
+                                    return isAscending ? aValue - bValue : bValue - aValue;
+                                }
+                                return 0;
+                            });
+                        }
+                        return {
+                            ...order,
+                            items: filteredItems.slice(Number(offset), Number(offset) + Number(limit)),
+                            totalItems: updatedItems.length,
+                        };
+                    }),
+                    map((updatedOrder) => ({ cms, order: updatedOrder })),
+                );
+            }),
+            map(({ cms, order }) =>
+                mapOrderDetails(
                     cms,
-                    order,
+                    order as Orders.Model.Order & { totalItems: number },
                     headers['x-locale'],
                     headers['x-client-timezone'] || '',
                     this.defaultProductUnit,
-                );
-            }),
+                ),
+            ),
         );
     }
 }