cardus 0.0.99 → 0.0.101

package/dist/index.js

@@ -17,20 +17,6 @@ const moment_1 = __importDefault(require("moment"));
 const insertTempShipment_1 = require("./insertTempShipment");
 class IntegrationManager {
     constructor(params) {
-        this.insertTempShipment = (_a) => __awaiter(this, [_a], void 0, function* ({ order, agencyId, warehouseId, sellerAddress, idUsuario, isPriority }) {
-            const tempShipmentData = yield (0, insertTempShipment_1.cookTempShipment)({
-                order,
-                shipmentType: this.shipmentType,
-                agencyId,
-                warehouseId,
-                sellerAddress,
-                idUsuario,
-                findNextPickupDate: this.findNextPickupDate,
-                countriesService: this.services.countriesService,
-                isPriority
-            });
-            return yield this.services.integrationsService.insertTempShipment(tempShipmentData, false);
-        });
         this.insertExternalShipment = ({ idUsuario, order, idEnvioTemporal }) => {
             this.dataToInsert.externals.push({
                 id_envio_temporal_usuario: idEnvioTemporal,
@@ -48,16 +34,19 @@ class IntegrationManager {
             });
         };
         this.insertTempShipmentGroupLine = ({ idEnvioTemporal, group }) => {
-            this.dataToInsert.lines.push({
-                id_envio: idEnvioTemporal,
-                bulto: {
-                    peso: group.weight,
-                    alto: group.height,
-                    ancho: group.width,
-                    largo: group.length,
-                    sku_producto: ''
+            // si agrupamos, no deberia de haber mas lineas, pero por si acaso, con el set machacamos lo que pudiera haber -que no deberia haber nada, insisto-
+            this.dataToInsert.lines.set(idEnvioTemporal, [
+                {
+                    id_envio: idEnvioTemporal,
+                    bulto: {
+                        peso: group.weight,
+                        alto: group.height,
+                        ancho: group.width,
+                        largo: group.length,
+                        sku_producto: ''
+                    }
                 }
-            });
+            ]);
         };
         this.services = {
             integrationsService: params.integrationsService,
@@ -70,7 +59,7 @@ class IntegrationManager {
             warehouseService: params.warehouseService
         };
         this.dataToInsert = {
-            lines: [],
+            lines: new Map(),
             contents: [],
             details: [],
             externals: [],
@@ -81,7 +70,7 @@ class IntegrationManager {
         this.type = params.type;
         this.executionManager = params.executionManager;
         this.findNextPickupDate = params.findNextPickupDate;
-        this.getAgencyIdForTempShipment = params.getAgencyIdForTempShipment;
+        this.getModifiedOrderBasedOnRules = params.getModifiedOrderBasedOnRules;
     }
     insertTempShipments(_a) {
         return __awaiter(this, arguments, void 0, function* ({ payload: { idUsuario, agencyId, addressId, warehouseId, group, sequentialInsertion = false }, fetchAllOrders, crearBulto, modificarOrdenOriginal }) {
@@ -92,6 +81,11 @@ class IntegrationManager {
                 ? yield addressesService.getWarehouseAddress(idUsuario)
                 : yield addressesService.getAddress(addressId, idUsuario);
             const country = yield this.services.countriesService.getCountry(sellerAddress.id_pais);
+            const userIntegrationConfiguration = yield integrationsService.getDefaultIntegrationsData({
+                id_usuario: idUsuario,
+                id_integracion: this.integrationType
+            });
+            const shouldFindWarehouseSkus = !!(userIntegrationConfiguration === null || userIntegrationConfiguration === void 0 ? void 0 : userIntegrationConfiguration.sku_almacen);
             const allOrders = yield fetchAllOrders();
             const filteredOrders = yield integrationsService.filterExternalDuplicatedOrders({
                 id_usuario: idUsuario,
@@ -121,17 +115,61 @@ class IntegrationManager {
                     if (parsedOrder.direccionSalidaId) {
                         direccionSalida = yield addressesService.getAddress(parsedOrder.direccionSalidaId, idUsuario);
                     }
-                    const idEnvioTemporal = yield this.insertTempShipment({
+                    const tempShipmentData = yield (0, insertTempShipment_1.cookTempShipment)({
                         order: parsedOrder,
+                        shipmentType: this.shipmentType,
                         agencyId,
                         warehouseId,
-                        sellerAddress: direccionSalida !== null && direccionSalida !== void 0 ? direccionSalida : sellerAddress,
+                        sellerAddress,
                         idUsuario,
+                        findNextPickupDate: this.findNextPickupDate,
+                        countriesService: this.services.countriesService,
                         isPriority: isPriorityByDefault
                     });
+                    const idEnvioTemporal = yield this.services.integrationsService.insertTempShipment(tempShipmentData, false);
                     if (!idEnvioTemporal) {
                         throw new Error('Temp shipments could not be created');
                     }
+                    yield this.insertQuantityRelatedLines({
+                        orders: [Object.assign(Object.assign({}, parsedOrder), { idEnvioTemporal })],
+                        idUsuario,
+                        crearBulto,
+                        group,
+                        warehouseId,
+                        shouldFindWarehouseSkus
+                    });
+                    const shipmentDetails = this.dataToInsert.details.filter(({ id_envio }) => {
+                        return id_envio === order.idEnvioTemporal;
+                    });
+                    const { partialTempShipmentModified, packagesModified } = yield this.getModifiedOrderBasedOnRules({
+                        defaultAgencyId: agencyId,
+                        userId: idUsuario,
+                        integrationId: this.integrationType,
+                        parsedOrder,
+                        sellerAddress,
+                        shipmentDetails,
+                        tempShipmentData,
+                        packages: this.dataToInsert.lines.get(idEnvioTemporal) || []
+                    });
+                    const isTempShipmentModified = !!partialTempShipmentModified &&
+                        Object.keys(partialTempShipmentModified).length > 0;
+                    const arePackagesModified = !!packagesModified && packagesModified.length > 0;
+                    const shouldAbortCreation = isTempShipmentModified &&
+                        partialTempShipmentModified.abort_creation === true;
+                    if (shouldAbortCreation) {
+                        yield integrationsService.deleteTempShipment({
+                            id_envio: idEnvioTemporal,
+                            id_usuario: idUsuario
+                        });
+                        return;
+                    }
+                    if (isTempShipmentModified) {
+                        delete partialTempShipmentModified.abort_creation; // por si acaso
+                        yield integrationsService.updateTempShimpment(Object.assign({ id_envio: idEnvioTemporal }, tempShipmentData));
+                    }
+                    if (arePackagesModified) {
+                        this.dataToInsert.lines.set(idEnvioTemporal, packagesModified);
+                    }
                     this.insertExternalShipment({
                         idUsuario,
                         order: parsedOrder,
@@ -142,56 +180,22 @@ class IntegrationManager {
                 regularExecutionTime: 8000, // ms
                 initialBatchQuantity: sequentialInsertion ? 1 : 5 // si la insercion no es secuencial, de cinco en cinco
             }).upload();
-            const successfullShipments = insertOrdersResult
-                .filter(Boolean)
-                .filter((each) => each.status === 'fulfilled')
-                .map((each) => each.value);
-            const userIntegrationConfiguration = yield integrationsService.getDefaultIntegrationsData({
-                id_usuario: idUsuario,
-                id_integracion: this.integrationType
-            });
-            const shouldFindWarehouseSkus = !!(userIntegrationConfiguration === null || userIntegrationConfiguration === void 0 ? void 0 : userIntegrationConfiguration.sku_almacen);
-            yield this.insertQuantityRelatedLines({
-                orders: successfullShipments,
-                idUsuario,
-                crearBulto,
-                group,
-                warehouseId,
-                shouldFindWarehouseSkus
-            });
             yield this.insertUserDefaultConfigurationContent({
                 user,
-                tempShimpmentIds: successfullShipments.map((successfullShipment) => successfullShipment.idEnvioTemporal),
                 countryName: country.nombre_pais_en
             });
-            // modificamos la agencia, cuando se tenga que hacer
-            yield Promise.allSettled(successfullShipments.map((order) => __awaiter(this, void 0, void 0, function* () {
-                const shipmentDetails = this.dataToInsert.details.filter(({ id_envio }) => {
-                    return id_envio === order.idEnvioTemporal;
-                });
-                const newAgencyId = yield this.getAgencyIdForTempShipment({
-                    defaultAgencyId: agencyId,
-                    userId: idUsuario,
-                    integrationId: this.integrationType,
-                    tempShipmentData: order,
-                    sellerAddress,
-                    shipmentDetails
-                });
-                if (newAgencyId !== order.agencyId) {
-                    yield integrationsService.updateTempShimpment({
-                        id_envio: order.idEnvioTemporal,
-                        id_usuario: idUsuario,
-                        id_agencia: newAgencyId
-                    });
-                }
-            })));
+            const arrayPackages = Array.from(Object.values(this.dataToInsert.lines)).flat();
             yield Promise.allSettled([
-                integrationsService.insertTempShipmentMultipleLines(this.dataToInsert.lines),
+                integrationsService.insertTempShipmentMultipleLines(arrayPackages),
                 integrationsService.insertTempShipmentMultipleDetails(this.dataToInsert.details),
                 integrationsService.insertTempShipmentMultipleContents(this.dataToInsert.contents),
                 integrationsService.insertTempShipmentMultipleExternals(this.dataToInsert.externals),
                 integrationsService.insertTempShipmentMultipleJsonQuantityReferences(this.dataToInsert.jsonQuantityReferences)
             ]);
+            const successfullShipments = insertOrdersResult
+                .filter(Boolean)
+                .filter((each) => each.status === 'fulfilled')
+                .map((each) => each.value);
             return {
                 filteredOrders,
                 insertedTempShipments: successfullShipments,
@@ -200,7 +204,7 @@ class IntegrationManager {
         });
     }
     insertUserDefaultConfigurationContent(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ user, tempShimpmentIds, countryName }) {
+        return __awaiter(this, arguments, void 0, function* ({ user, countryName }) {
             const idUsuario = user.id_usuario;
             const { configurationService, llmAPIService } = this.services;
             const insert = (data) => {
@@ -302,18 +306,22 @@ class IntegrationManager {
     insertQuantityRelatedLines(_a) {
         return __awaiter(this, arguments, void 0, function* ({ orders, idUsuario, crearBulto, group, warehouseId, shouldFindWarehouseSkus }) {
             /*
-             basicamente la logica es:
-             1 - si esta agrupado, crea una linea por cada pedido
-             2 - si "forzarAgrupamientoDeLinea" es true, se crea una linea por cada linea
-             3- si NO esta agrupado y "forzarAgrupamientoDeLinea" NO es true, se crea una linea por cada unidad de cada linea
+             En esta funcion se calculan los records a incluir en la tabla de detalles y en las de lineas
+             Los detalles, es facil, una por cada bulto (aqui no hay ni "agrupar" ni nada de eso, una por cada bulto y ya esta)
+             Las lineas, es mas complicado:
+               Creamos una linea por cada linea en el pedido.
+               Pero hay TRUCO, puede que haya que agrupar, puede que no, puede que haya que coger el peso y medidas del bulto, puede que del "bulto agrupado", hay que tener en cuenta las cantidades...
+               Asi que para ver todo esto, la logica esta dentro de la variable "shouldGroup".
             */
+            var _b;
             const { integrationsService } = this.services;
-            const userIntegrationConfiguration = yield integrationsService.getDefaultIntegrationsData({
+            const shouldGetMeasuresFromGroupBeingOneLine = !!((_b = (yield integrationsService.getDefaultIntegrationsData({
                 id_usuario: idUsuario,
                 id_integracion: this.integrationType
-            });
-            const measuresFromConfig = !!(userIntegrationConfiguration === null || userIntegrationConfiguration === void 0 ? void 0 : userIntegrationConfiguration.dimensiones_medidas_configuradas);
-            const createBultoFromLine = (_b) => __awaiter(this, [_b], void 0, function* ({ line, idEnvioTemporal, shouldGroup }) {
+            }))) === null || _b === void 0 ? void 0 : _b.dimensiones_medidas_configuradas);
+            // function to create package from line
+            const createBultoFromLine = (_c) => __awaiter(this, [_c], void 0, function* ({ line, idEnvioTemporal }) {
+                // funcion para crear bulto
                 const result = yield crearBulto({
                     lineItems: { idEnvioTemporal, line },
                     idUsuario
@@ -324,94 +332,96 @@ class IntegrationManager {
                         bulto,
                         cantidad,
                         idEnvioTemporal,
-                        forzarAgrupamientoDeLinea: !!forzarAgrupamientoDeLinea,
-                        shouldGroup
+                        forzarAgrupamientoDeLinea: !!forzarAgrupamientoDeLinea
                     };
                 }
                 return null;
             });
-            const obtenerBultosYCantidades = [];
-            orders.forEach(({ idEnvioTemporal, lineas }) => {
+            yield Promise.allSettled(
+            // por cada pedido/envio
+            orders.map((_d) => __awaiter(this, [_d], void 0, function* ({ idEnvioTemporal, lineas }) {
                 if (!idEnvioTemporal)
                     return;
-                // Debe agrupar si:
-                // 1. grouped es 1 + hay más de una línea
-                // 2. grouped es 1 + hay una línea + configuración integraciones tiene el campo dimensiones_medidas_configuradas a 1
-                const shouldGroup = ((group === null || group === void 0 ? void 0 : group.grouped) === 1 && lineas.length > 1) ||
-                    ((group === null || group === void 0 ? void 0 : group.grouped) === 1 && lineas.length === 1 && measuresFromConfig);
-                if (shouldGroup) {
-                    this.insertTempShipmentGroupLine({ idEnvioTemporal, group });
-                }
-                lineas.forEach((line) => {
-                    const bultoPromise = createBultoFromLine({
+                // hacemos esto primero, todavia no sabemos si vamos a agrupar (porque necesitamos crear el bulto para eso, ya que la "cantidad" podria influir)
+                const bultosYCantidades = (yield Promise.all(lineas.map((line) => __awaiter(this, void 0, void 0, function* () {
+                    const bultoYCantidad = yield createBultoFromLine({
                         line,
-                        idEnvioTemporal,
-                        shouldGroup
-                    });
-                    obtenerBultosYCantidades.push(bultoPromise);
-                });
-            });
-            let bultosYCantidades = yield Promise.all(obtenerBultosYCantidades);
-            bultosYCantidades = bultosYCantidades.filter(Boolean);
-            if (shouldFindWarehouseSkus) {
-                const bultosYCantidadesGroupedByShipment = bultosYCantidades.reduce((acc, curr) => {
-                    var _a;
-                    const tempShipmentId = curr === null || curr === void 0 ? void 0 : curr.idEnvioTemporal;
-                    if (!tempShipmentId)
-                        return acc;
-                    (_a = acc[tempShipmentId]) !== null && _a !== void 0 ? _a : (acc[tempShipmentId] = []);
-                    acc[tempShipmentId].push(curr);
-                    return acc;
-                }, {});
-                yield Promise.all(Object.entries(bultosYCantidadesGroupedByShipment).map((_c) => __awaiter(this, [_c], void 0, function* ([tempShipmentId, bultosYCantidades]) {
-                    const json_referencias_cantidades = yield this.createJsonQuantityReferencesFromLines({
-                        idUsuario,
-                        warehouseId,
-                        bultosYCantidades
+                        idEnvioTemporal
                     });
-                    if (json_referencias_cantidades.length > 0) {
-                        this.dataToInsert.jsonQuantityReferences.push({
-                            id_envio: Number(tempShipmentId),
-                            json_referencias_cantidades
-                        });
-                    }
-                })));
-            }
-            bultosYCantidades.forEach((each) => {
-                if (!each)
-                    return;
-                const { bulto, cantidad, idEnvioTemporal, forzarAgrupamientoDeLinea, shouldGroup } = each;
-                try {
+                    return bultoYCantidad;
+                })))).filter(Boolean);
+                // sacamos todos los bultos (y cantidad)
+                yield Promise.allSettled(bultosYCantidades.map((bultoYCantidad) => __awaiter(this, void 0, void 0, function* () {
+                    if (!bultoYCantidad)
+                        return;
+                    const { bulto, cantidad, idEnvioTemporal, forzarAgrupamientoDeLinea } = bultoYCantidad;
+                    // metemos los detalles siempre
                     this.dataToInsert.details.push({
                         id_envio: idEnvioTemporal,
                         bulto,
                         cantidad
                     });
-                    if (!shouldGroup && forzarAgrupamientoDeLinea) {
-                        this.dataToInsert.lines.push({
-                            id_envio: idEnvioTemporal,
-                            bulto
-                        });
+                    // Debe agrupar si:
+                    // 1. grouped es 1 + hay más de una línea
+                    // 2. grouped es 1 + hay una línea + configuración integraciones tiene el campo dimensiones_medidas_configuradas a 1 (osea, que queremos que coja las dimensiones del bulto, aunque sea una sola linea)
+                    // 3. grouped es 1 + hay una lines + cantidad es mayor que 1
+                    const shouldGroup = (group === null || group === void 0 ? void 0 : group.grouped) === 1 &&
+                        (lineas.length > 1 ||
+                            (lineas.length === 1 &&
+                                shouldGetMeasuresFromGroupBeingOneLine) ||
+                            (lineas.length === 1 && Number(cantidad) > 1));
+                    // si agrupamos, metemos solo una linea en "lineas" y cogemos las dimensiones y peso de "group" (lo que el usuario tenga por defecto)
+                    if (shouldGroup) {
+                        this.insertTempShipmentGroupLine({ idEnvioTemporal, group });
+                        // si no agrupamos, cogemos el peso y dimensiones del peso mismo
                     }
-                    if (!shouldGroup && !forzarAgrupamientoDeLinea) {
-                        if ((group === null || group === void 0 ? void 0 : group.grouped) === 1 && Number(cantidad) > 1) {
-                            this.insertTempShipmentGroupLine({ idEnvioTemporal, group });
+                    else {
+                        // lo de "forzarAgrupamientoDeLinea" se hizo solo para un usuario (Pegaso) que ya ni siquiera esta. Lo que hace es que siempre mete una linea, sin tener en cuenta la cantidad, pero con las dimensiones que les hemos preparado para ese bulto (que es una suma de todos los bultos reales... un chanchullo)
+                        const tempShipmentLines = this.dataToInsert.lines.get(idEnvioTemporal) || [];
+                        if (forzarAgrupamientoDeLinea) {
+                            tempShipmentLines.push({
+                                id_envio: idEnvioTemporal,
+                                bulto
+                            });
+                            // y esto para todo el resto de usuarios
                         }
                         else {
+                            // creamos una linea por cada una de las unidades de "cantidad" (si cantidad es 5, pues 5 lineas -todas iguales, con el peso y medidas del bulto-)
                             const arrayFake = Array.from({ length: Number(cantidad) });
-                            arrayFake.forEach(() => {
-                                this.dataToInsert.lines.push({
-                                    id_envio: idEnvioTemporal,
-                                    bulto
-                                });
-                            });
+                            const linesToAdd = arrayFake.map(() => ({
+                                id_envio: idEnvioTemporal,
+                                bulto
+                            }));
+                            tempShipmentLines.push(...linesToAdd);
                         }
                     }
-                }
-                catch (e) {
-                    console.log(e);
-                }
-            });
+                    // para cuando el usuario quiere mapear su sku con la referencia que tenga en almacen
+                    if (shouldFindWarehouseSkus) {
+                        const bultosYCantidadesGroupedByShipment = bultosYCantidades.reduce((acc, curr) => {
+                            var _a;
+                            const tempShipmentId = curr === null || curr === void 0 ? void 0 : curr.idEnvioTemporal;
+                            if (!tempShipmentId)
+                                return acc;
+                            (_a = acc[tempShipmentId]) !== null && _a !== void 0 ? _a : (acc[tempShipmentId] = []);
+                            acc[tempShipmentId].push(curr);
+                            return acc;
+                        }, {});
+                        yield Promise.all(Object.entries(bultosYCantidadesGroupedByShipment).map((_e) => __awaiter(this, [_e], void 0, function* ([tempShipmentId, bultosYCantidades]) {
+                            const json_referencias_cantidades = yield this.createJsonQuantityReferencesFromLines({
+                                idUsuario,
+                                warehouseId,
+                                bultosYCantidades
+                            });
+                            if (json_referencias_cantidades.length > 0) {
+                                this.dataToInsert.jsonQuantityReferences.push({
+                                    id_envio: Number(tempShipmentId),
+                                    json_referencias_cantidades
+                                });
+                            }
+                        })));
+                    }
+                })));
+            })));
         });
     }
 }

package/index.ts

@@ -23,14 +23,15 @@ import {
   ShipmentType,
   IntegrationType,
   UserDefaultConfigurationContent,
-  GetAgencyIdForTempShipment,
+  GetModifiedOrderBasedOnRules,
   IsPriority,
   CustomizationService,
   InsertContentShipmentLine,
   Bulto,
   DataToInsert,
   BultoYCantidad,
-  JsonReferenciasCantidades
+  JsonReferenciasCantidades,
+  Shipment
 } from './types';
 
 interface Services {
@@ -51,7 +52,7 @@ export class IntegrationManager {
   findNextPickupDate: FindNextPickupDate;
   integrationType: IntegrationType;
   shipmentType: ShipmentType;
-  getAgencyIdForTempShipment: GetAgencyIdForTempShipment;
+  getModifiedOrderBasedOnRules: GetModifiedOrderBasedOnRules;
 
   dataToInsert: DataToInsert;
 
@@ -69,7 +70,7 @@ export class IntegrationManager {
     shipmentType: ShipmentType;
     executionManager: ExecutionManager;
     findNextPickupDate: FindNextPickupDate;
-    getAgencyIdForTempShipment: GetAgencyIdForTempShipment;
+    getModifiedOrderBasedOnRules: GetModifiedOrderBasedOnRules;
   }) {
     this.services = {
       integrationsService: params.integrationsService,
@@ -83,7 +84,7 @@ export class IntegrationManager {
     };
 
     this.dataToInsert = {
-      lines: [],
+      lines: new Map(),
       contents: [],
       details: [],
       externals: [],
@@ -95,7 +96,7 @@ export class IntegrationManager {
     this.type = params.type;
     this.executionManager = params.executionManager;
     this.findNextPickupDate = params.findNextPickupDate;
-    this.getAgencyIdForTempShipment = params.getAgencyIdForTempShipment;
+    this.getModifiedOrderBasedOnRules = params.getModifiedOrderBasedOnRules;
   }
 
   async insertTempShipments({
@@ -118,10 +119,19 @@ export class IntegrationManager {
       warehouseId > 0
         ? await addressesService.getWarehouseAddress(idUsuario)
         : await addressesService.getAddress(addressId, idUsuario);
+
     const country = await this.services.countriesService.getCountry(
       sellerAddress.id_pais
     );
 
+    const userIntegrationConfiguration =
+      await integrationsService.getDefaultIntegrationsData({
+        id_usuario: idUsuario,
+        id_integracion: this.integrationType
+      });
+
+    const shouldFindWarehouseSkus = !!userIntegrationConfiguration?.sku_almacen;
+
     const allOrders = await fetchAllOrders();
     const filteredOrders =
       await integrationsService.filterExternalDuplicatedOrders({
@@ -167,19 +177,87 @@ export class IntegrationManager {
           );
         }
 
-        const idEnvioTemporal = await this.insertTempShipment({
+        const tempShipmentData = await cookTempShipment({
           order: parsedOrder,
+          shipmentType: this.shipmentType,
           agencyId,
           warehouseId,
-          sellerAddress: direccionSalida ?? sellerAddress,
+          sellerAddress,
           idUsuario,
+          findNextPickupDate: this.findNextPickupDate,
+          countriesService: this.services.countriesService,
           isPriority: isPriorityByDefault
         });
 
+        const idEnvioTemporal =
+          await this.services.integrationsService.insertTempShipment(
+            tempShipmentData,
+            false
+          );
+
         if (!idEnvioTemporal) {
           throw new Error('Temp shipments could not be created');
         }
 
+        await this.insertQuantityRelatedLines({
+          orders: [{ ...parsedOrder, idEnvioTemporal }],
+          idUsuario,
+          crearBulto,
+          group,
+          warehouseId,
+          shouldFindWarehouseSkus
+        });
+
+        const shipmentDetails = this.dataToInsert.details.filter(
+          ({ id_envio }) => {
+            return id_envio === order.idEnvioTemporal;
+          }
+        );
+
+        const { partialTempShipmentModified, packagesModified } =
+          await this.getModifiedOrderBasedOnRules({
+            defaultAgencyId: agencyId,
+            userId: idUsuario,
+            integrationId: this.integrationType,
+            parsedOrder,
+            sellerAddress,
+            shipmentDetails,
+            tempShipmentData,
+            packages: this.dataToInsert.lines.get(idEnvioTemporal) || []
+          });
+
+        const isTempShipmentModified =
+          !!partialTempShipmentModified &&
+          Object.keys(partialTempShipmentModified).length > 0;
+        const arePackagesModified =
+          !!packagesModified && packagesModified.length > 0;
+
+        const shouldAbortCreation =
+          isTempShipmentModified &&
+          partialTempShipmentModified.abort_creation === true;
+
+        if (shouldAbortCreation) {
+          await integrationsService.deleteTempShipment({
+            id_envio: idEnvioTemporal,
+            id_usuario: idUsuario
+          });
+
+          return;
+        }
+
+        if (isTempShipmentModified) {
+          delete partialTempShipmentModified.abort_creation; // por si acaso
+
+          await integrationsService.updateTempShimpment({
+            id_envio: idEnvioTemporal,
+            ...tempShipmentData
+          });
+        }
+
+        if (arePackagesModified) {
+          this.dataToInsert.lines.set(idEnvioTemporal, packagesModified);
+        }
+
         this.insertExternalShipment({
           idUsuario,
           order: parsedOrder,
@@ -192,70 +270,17 @@ export class IntegrationManager {
       initialBatchQuantity: sequentialInsertion ? 1 : 5 // si la insercion no es secuencial, de cinco en cinco
     }).upload();
 
-    const successfullShipments = insertOrdersResult
-      .filter(Boolean)
-      .filter((each) => each.status === 'fulfilled')
-      .map((each) => each.value) as (ModifiedOrder & {
-      idEnvioTemporal: number;
-      agencyId: number;
-    })[];
-
-    const userIntegrationConfiguration =
-      await integrationsService.getDefaultIntegrationsData({
-        id_usuario: idUsuario,
-        id_integracion: this.integrationType
-      });
-    const shouldFindWarehouseSkus = !!userIntegrationConfiguration?.sku_almacen;
-
-    await this.insertQuantityRelatedLines({
-      orders: successfullShipments,
-      idUsuario,
-      crearBulto,
-      group,
-      warehouseId,
-      shouldFindWarehouseSkus
-    });
-
     await this.insertUserDefaultConfigurationContent({
       user,
-      tempShimpmentIds: successfullShipments.map(
-        (successfullShipment) => successfullShipment.idEnvioTemporal
-      ),
       countryName: country.nombre_pais_en
     });
 
-    // modificamos la agencia, cuando se tenga que hacer
-    await Promise.allSettled(
-      successfullShipments.map(async (order) => {
-        const shipmentDetails = this.dataToInsert.details.filter(
-          ({ id_envio }) => {
-            return id_envio === order.idEnvioTemporal;
-          }
-        );
-
-        const newAgencyId = await this.getAgencyIdForTempShipment({
-          defaultAgencyId: agencyId,
-          userId: idUsuario,
-          integrationId: this.integrationType,
-          tempShipmentData: order,
-          sellerAddress,
-          shipmentDetails
-        });
-
-        if (newAgencyId !== order.agencyId) {
-          await integrationsService.updateTempShimpment({
-            id_envio: order.idEnvioTemporal,
-            id_usuario: idUsuario,
-            id_agencia: newAgencyId
-          });
-        }
-      })
-    );
+    const arrayPackages: InsertContentShipmentLine[] = Array.from(
+      Object.values(this.dataToInsert.lines)
+    ).flat();
 
     await Promise.allSettled([
-      integrationsService.insertTempShipmentMultipleLines(
-        this.dataToInsert.lines
-      ),
+      integrationsService.insertTempShipmentMultipleLines(arrayPackages),
       integrationsService.insertTempShipmentMultipleDetails(
         this.dataToInsert.details
       ),
@@ -270,6 +295,14 @@ export class IntegrationManager {
       )
     ]);
 
+    const successfullShipments = insertOrdersResult
+      .filter(Boolean)
+      .filter((each) => each.status === 'fulfilled')
+      .map((each) => each.value) as (ModifiedOrder & {
+      idEnvioTemporal: number;
+      agencyId: number;
+    })[];
+
     return {
       filteredOrders,
       insertedTempShipments: successfullShipments,
@@ -279,11 +312,9 @@ export class IntegrationManager {
 
   async insertUserDefaultConfigurationContent({
     user,
-    tempShimpmentIds,
     countryName
   }: {
     user: Record<string, string | number>;
-    tempShimpmentIds: number[];
     countryName: string;
   }) {
     const idUsuario = user.id_usuario as number;
@@ -374,39 +405,6 @@ export class IntegrationManager {
     }
   }
 
-  insertTempShipment = async ({
-    order,
-    agencyId,
-    warehouseId,
-    sellerAddress,
-    idUsuario,
-    isPriority
-  }: {
-    order: ModifiedOrder;
-    agencyId: number;
-    warehouseId: number;
-    sellerAddress: SellerAddress;
-    idUsuario: number;
-    isPriority: IsPriority;
-  }) => {
-    const tempShipmentData = await cookTempShipment({
-      order,
-      shipmentType: this.shipmentType,
-      agencyId,
-      warehouseId,
-      sellerAddress,
-      idUsuario,
-      findNextPickupDate: this.findNextPickupDate,
-      countriesService: this.services.countriesService,
-      isPriority
-    });
-
-    return await this.services.integrationsService.insertTempShipment(
-      tempShipmentData,
-      false
-    );
-  };
-
   insertExternalShipment = ({
     idUsuario,
     order,
@@ -439,16 +437,19 @@ export class IntegrationManager {
     idEnvioTemporal: number;
     group: Group;
   }) => {
-    this.dataToInsert.lines.push({
-      id_envio: idEnvioTemporal,
-      bulto: {
-        peso: group.weight,
-        alto: group.height,
-        ancho: group.width,
-        largo: group.length,
-        sku_producto: ''
+    // si agrupamos, no deberia de haber mas lineas, pero por si acaso, con el set machacamos lo que pudiera haber -que no deberia haber nada, insisto-
+    this.dataToInsert.lines.set(idEnvioTemporal, [
+      {
+        id_envio: idEnvioTemporal,
+        bulto: {
+          peso: group.weight,
+          alto: group.height,
+          ancho: group.width,
+          largo: group.length,
+          sku_producto: ''
+        }
       }
-    });
+    ]);
   };
 
   async createJsonQuantityReferencesFromLines({
@@ -517,32 +518,32 @@ export class IntegrationManager {
     shouldFindWarehouseSkus: boolean;
   }) {
     /*
-     basicamente la logica es: 
-     1 - si esta agrupado, crea una linea por cada pedido
-     2 - si "forzarAgrupamientoDeLinea" es true, se crea una linea por cada linea
-     3- si NO esta agrupado y "forzarAgrupamientoDeLinea" NO es true, se crea una linea por cada unidad de cada linea
+     En esta funcion se calculan los records a incluir en la tabla de detalles y en las de lineas
+     Los detalles, es facil, una por cada bulto (aqui no hay ni "agrupar" ni nada de eso, una por cada bulto y ya esta)
+     Las lineas, es mas complicado:
+       Creamos una linea por cada linea en el pedido.
+       Pero hay TRUCO, puede que haya que agrupar, puede que no, puede que haya que coger el peso y medidas del bulto, puede que del "bulto agrupado", hay que tener en cuenta las cantidades...
+       Asi que para ver todo esto, la logica esta dentro de la variable "shouldGroup". 
     */
 
     const { integrationsService } = this.services;
 
-    const userIntegrationConfiguration =
+    const shouldGetMeasuresFromGroupBeingOneLine = !!(
       await integrationsService.getDefaultIntegrationsData({
         id_usuario: idUsuario,
         id_integracion: this.integrationType
-      });
-
-    const measuresFromConfig =
-      !!userIntegrationConfiguration?.dimensiones_medidas_configuradas;
+      })
+    )?.dimensiones_medidas_configuradas;
 
+    // function to create package from line
     const createBultoFromLine = async ({
       line,
-      idEnvioTemporal,
-      shouldGroup
+      idEnvioTemporal
     }: {
       line: InsertContentShipmentLine;
       idEnvioTemporal: number;
-      shouldGroup: boolean;
     }): Promise<BultoYCantidad | null> => {
+      // funcion para crear bulto
       const result = await crearBulto({
         lineItems: { idEnvioTemporal, line },
         idUsuario
@@ -554,115 +555,127 @@ export class IntegrationManager {
           bulto,
           cantidad,
           idEnvioTemporal,
-          forzarAgrupamientoDeLinea: !!forzarAgrupamientoDeLinea,
-          shouldGroup
+          forzarAgrupamientoDeLinea: !!forzarAgrupamientoDeLinea
         };
       }
       return null;
     };
 
-    const obtenerBultosYCantidades: Array<Promise<BultoYCantidad | null>> = [];
-
-    orders.forEach(({ idEnvioTemporal, lineas }) => {
-      if (!idEnvioTemporal) return;
-
-      // Debe agrupar si:
-      // 1. grouped es 1 + hay más de una línea
-      // 2. grouped es 1 + hay una línea + configuración integraciones tiene el campo dimensiones_medidas_configuradas a 1
-      const shouldGroup =
-        (group?.grouped === 1 && lineas.length > 1) ||
-        (group?.grouped === 1 && lineas.length === 1 && measuresFromConfig);
-
-      if (shouldGroup) {
-        this.insertTempShipmentGroupLine({ idEnvioTemporal, group });
-      }
-
-      lineas.forEach((line) => {
-        const bultoPromise = createBultoFromLine({
-          line,
-          idEnvioTemporal,
-          shouldGroup
-        });
-        obtenerBultosYCantidades.push(bultoPromise);
-      });
-    });
+    await Promise.allSettled(
+      // por cada pedido/envio
+      orders.map(async ({ idEnvioTemporal, lineas }) => {
+        if (!idEnvioTemporal) return;
 
-    let bultosYCantidades = await Promise.all(obtenerBultosYCantidades);
-    bultosYCantidades = bultosYCantidades.filter(Boolean);
-
-    if (shouldFindWarehouseSkus) {
-      const bultosYCantidadesGroupedByShipment = bultosYCantidades.reduce<
-        Record<number, BultoYCantidad[]>
-      >((acc, curr) => {
-        const tempShipmentId = curr?.idEnvioTemporal;
-        if (!tempShipmentId) return acc;
-
-        acc[tempShipmentId] ??= [];
-        acc[tempShipmentId].push(curr);
-
-        return acc;
-      }, {});
-
-      await Promise.all(
-        Object.entries(bultosYCantidadesGroupedByShipment).map(
-          async ([tempShipmentId, bultosYCantidades]) => {
-            const json_referencias_cantidades =
-              await this.createJsonQuantityReferencesFromLines({
-                idUsuario,
-                warehouseId,
-                bultosYCantidades
+        // hacemos esto primero, todavia no sabemos si vamos a agrupar (porque necesitamos crear el bulto para eso, ya que la "cantidad" podria influir)
+        const bultosYCantidades = (
+          await Promise.all(
+            lineas.map(async (line) => {
+              const bultoYCantidad = await createBultoFromLine({
+                line,
+                idEnvioTemporal
               });
+              return bultoYCantidad;
+            })
+          )
+        ).filter(Boolean);
+
+        // sacamos todos los bultos (y cantidad)
+        await Promise.allSettled(
+          bultosYCantidades.map(async (bultoYCantidad) => {
+            if (!bultoYCantidad) return;
+
+            const {
+              bulto,
+              cantidad,
+              idEnvioTemporal,
+              forzarAgrupamientoDeLinea
+            } = bultoYCantidad;
+
+            // metemos los detalles siempre
+            this.dataToInsert.details.push({
+              id_envio: idEnvioTemporal,
+              bulto,
+              cantidad
+            });
 
-            if (json_referencias_cantidades.length > 0) {
-              this.dataToInsert.jsonQuantityReferences.push({
-                id_envio: Number(tempShipmentId),
-                json_referencias_cantidades
-              });
+            // Debe agrupar si:
+            // 1. grouped es 1 + hay más de una línea
+            // 2. grouped es 1 + hay una línea + configuración integraciones tiene el campo dimensiones_medidas_configuradas a 1 (osea, que queremos que coja las dimensiones del bulto, aunque sea una sola linea)
+            // 3. grouped es 1 + hay una lines + cantidad es mayor que 1
+            const shouldGroup =
+              group?.grouped === 1 &&
+              (lineas.length > 1 ||
+                (lineas.length === 1 &&
+                  shouldGetMeasuresFromGroupBeingOneLine) ||
+                (lineas.length === 1 && Number(cantidad) > 1));
+
+            // si agrupamos, metemos solo una linea en "lineas" y cogemos las dimensiones y peso de "group" (lo que el usuario tenga por defecto)
+            if (shouldGroup) {
+              this.insertTempShipmentGroupLine({ idEnvioTemporal, group });
+              // si no agrupamos, cogemos el peso y dimensiones del peso mismo
+            } else {
+              // lo de "forzarAgrupamientoDeLinea" se hizo solo para un usuario (Pegaso) que ya ni siquiera esta. Lo que hace es que siempre mete una linea, sin tener en cuenta la cantidad, pero con las dimensiones que les hemos preparado para ese bulto (que es una suma de todos los bultos reales... un chanchullo)
+              const tempShipmentLines =
+                this.dataToInsert.lines.get(idEnvioTemporal) || [];
+
+              if (forzarAgrupamientoDeLinea) {
+                tempShipmentLines.push({
+                  id_envio: idEnvioTemporal,
+                  bulto
+                });
+                // y esto para todo el resto de usuarios
+              } else {
+                // creamos una linea por cada una de las unidades de "cantidad" (si cantidad es 5, pues 5 lineas -todas iguales, con el peso y medidas del bulto-)
+
+                const arrayFake = Array.from({ length: Number(cantidad) });
+                const linesToAdd = arrayFake.map(() => ({
+                  id_envio: idEnvioTemporal,
+                  bulto
+                }));
+
+                tempShipmentLines.push(...linesToAdd);
+              }
             }
-          }
-        )
-      );
-    }
 
-    bultosYCantidades.forEach((each) => {
-      if (!each) return;
-      const {
-        bulto,
-        cantidad,
-        idEnvioTemporal,
-        forzarAgrupamientoDeLinea,
-        shouldGroup
-      } = each;
-      try {
-        this.dataToInsert.details.push({
-          id_envio: idEnvioTemporal,
-          bulto,
-          cantidad
-        });
-        if (!shouldGroup && forzarAgrupamientoDeLinea) {
-          this.dataToInsert.lines.push({
-            id_envio: idEnvioTemporal,
-            bulto
-          });
-        }
+            // para cuando el usuario quiere mapear su sku con la referencia que tenga en almacen
+            if (shouldFindWarehouseSkus) {
+              const bultosYCantidadesGroupedByShipment =
+                bultosYCantidades.reduce<Record<number, BultoYCantidad[]>>(
+                  (acc, curr) => {
+                    const tempShipmentId = curr?.idEnvioTemporal;
+                    if (!tempShipmentId) return acc;
 
-        if (!shouldGroup && !forzarAgrupamientoDeLinea) {
-          if (group?.grouped === 1 && Number(cantidad) > 1) {
-            this.insertTempShipmentGroupLine({ idEnvioTemporal, group });
-          } else {
-            const arrayFake = Array.from({ length: Number(cantidad) });
+                    acc[tempShipmentId] ??= [];
+                    acc[tempShipmentId].push(curr);
 
-            arrayFake.forEach(() => {
-              this.dataToInsert.lines.push({
-                id_envio: idEnvioTemporal,
-                bulto
-              });
-            });
-          }
-        }
-      } catch (e) {
-        console.log(e);
-      }
-    });
+                    return acc;
+                  },
+                  {}
+                );
+
+              await Promise.all(
+                Object.entries(bultosYCantidadesGroupedByShipment).map(
+                  async ([tempShipmentId, bultosYCantidades]) => {
+                    const json_referencias_cantidades =
+                      await this.createJsonQuantityReferencesFromLines({
+                        idUsuario,
+                        warehouseId,
+                        bultosYCantidades
+                      });
+
+                    if (json_referencias_cantidades.length > 0) {
+                      this.dataToInsert.jsonQuantityReferences.push({
+                        id_envio: Number(tempShipmentId),
+                        json_referencias_cantidades
+                      });
+                    }
+                  }
+                )
+              );
+            }
+          })
+        );
+      })
+    );
   }
 }

package/insertTempShipment/index.ts

@@ -6,7 +6,8 @@ import {
   CountriesService,
   FindNextPickupDate,
   SellerAddress,
-  IsPriority
+  IsPriority,
+  TempShipmentDataForCooking
 } from 'types';
 
 type ZonaLLegada = { nombre_pais: string; id_pais: number };
@@ -21,17 +22,7 @@ export const cookTempShipment = async ({
   findNextPickupDate,
   countriesService,
   isPriority
-}: {
-  order: ModifiedOrder;
-  shipmentType: ShipmentType;
-  agencyId: number;
-  warehouseId: number;
-  sellerAddress: SellerAddress;
-  idUsuario: number;
-  findNextPickupDate: FindNextPickupDate;
-  countriesService: CountriesService;
-  isPriority: IsPriority;
-}): Promise<Shipment> => {
+}: TempShipmentDataForCooking): Promise<Shipment> => {
   let zonaLLegada = {};
   if (order.codigoPaisLLegada)
     zonaLLegada = await countriesService.getCountryFromCountryCode(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cardus",
-  "version": "0.0.99",
+  "version": "0.0.101",
   "description": "an integration manager",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/types/index.ts

@@ -109,7 +109,6 @@ export type BultoYCantidad = {
   cantidad: Bulto['cantidad'];
   idEnvioTemporal: number;
   forzarAgrupamientoDeLinea: boolean;
-  shouldGroup: boolean;
 } | null;
 
 export type ModifiedOrder = {
@@ -234,7 +233,7 @@ export type IntegrationsService = {
   ) => Promise<number | false>;
 
   insertTempShipmentMultipleLines: (
-    lines: DataToInsert['lines']
+    lines: InsertContentShipmentLine[]
   ) => Promise<number | false>;
 
   insertTempShipmentMultipleDetails: (
@@ -255,12 +254,7 @@ export type IntegrationsService = {
     id_envio,
     id_usuario,
     id_agencia
-  }: {
-    id_envio: number;
-    id_usuario: number;
-    id_agencia: number;
-  }) => Promise<boolean>;
-
+  }: Partial<Shipment & { id_envio: number }>) => Promise<boolean>;
   getDefaultIntegrationsData: ({
     id_usuario,
     id_integracion
@@ -271,6 +265,13 @@ export type IntegrationsService = {
     sku_almacen: 0 | 1;
     dimensiones_medidas_configuradas: 0 | 1;
   }>;
+  deleteTempShipment: ({
+    id_envio,
+    id_usuario
+  }: {
+    id_envio: number;
+    id_usuario: number;
+  }) => Promise<number | false>;
 };
 
 export type LlmAPIService = {
@@ -408,14 +409,19 @@ type ExecutionManagerUploadReturn = {
   value: any;
 };
 
-export type GetAgencyIdForTempShipment = (params: {
+export type GetModifiedOrderBasedOnRules = (params: {
   defaultAgencyId: number;
   userId: number;
   integrationId: number;
-  tempShipmentData: ModifiedOrder;
+  parsedOrder: ModifiedOrder;
   sellerAddress: SellerAddress;
   shipmentDetails: InsertContentShipmentDetail[];
-}) => Promise<number>;
+  tempShipmentData: Shipment;
+  packages: InsertContentShipmentLine[];
+}) => Promise<{
+  partialTempShipmentModified: Partial<Shipment & { abort_creation?: boolean }>;
+  packagesModified: InsertContentShipmentLine[];
+}>;
 
 export type ExecutionManager = {
   upload(): ExecutionManagerUploadReturn[];
@@ -423,7 +429,7 @@ export type ExecutionManager = {
 };
 
 export type DataToInsert = {
-  lines: InsertContentShipmentLine[];
+  lines: Map<number, InsertContentShipmentLine[]>;
   contents: InsertContentShipmentData[];
   details: InsertContentShipmentDetail[];
   externals: InsertContentShipmentExternal[];
@@ -438,6 +444,18 @@ export type InsertContentShipmentLine = {
   >;
 };
 
+export type TempShipmentDataForCooking = {
+  order: ModifiedOrder;
+  shipmentType: ShipmentType;
+  agencyId: number;
+  warehouseId: number;
+  sellerAddress: SellerAddress;
+  idUsuario: number;
+  findNextPickupDate: FindNextPickupDate;
+  countriesService: CountriesService;
+  isPriority: IsPriority;
+};
+
 type InsertContentShipmentData = UserDefaultConfigurationContent & {
   id_envio: number;
 };