@bytebrand/export-cars 1.19.1 → 1.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebrand/export-cars",
-  "version": "1.19.1",
+  "version": "1.21.0",
   "description": "",
   "author": "bytebrand",
   "license": "UNLICENSED",
@@ -28,6 +28,7 @@
     "@nestjs/cache-manager": "^2.1.0",
     "@nestjs/common": "^10.2.7",
     "@nestjs/core": "^10.2.7",
+    "axios": "^1.5.1",
     "bottleneck": "^2.19.5",
     "cache-manager": "^5.2.4",
     "csv-write-stream": "^2.0.0",
@@ -61,5 +62,5 @@
   "engines": {
     "node": ">=14.0.0"
   },
-  "gitHead": "7671c694fd83f4290ad8fa0488175cf9ef79797b"
+  "gitHead": "3ef72636ca23cee78df87f16e66089e1a532b053"
 }

package/src/configs/config.ts

@@ -12,6 +12,7 @@ export class Config {
   baseImageUrl: string;
   marketingImageUrl: string;
   imageType: ImageType;
+  downloadImage: boolean;
   isNewCar: boolean;
   isCriteo: boolean;
   exportType: ExportType;

package/src/configs/evium.config.ts

@@ -10,6 +10,7 @@ export class EviumConfig extends Config {
     this.imageUrl = `https://images.${this.domain}/carimage`;
     this.mappingSpreadsheetTitle = 'mobile_yescar';
     this.imageType = ImageType.default;
+    this.downloadImage = true;
     this.outputFiles = [
       `${this.pathesConfig.localConvertedDirectory}/api_export_cars__${ExportType.EVIUM}.${FileType.CSV}`,
       `${this.pathesConfig.localConvertedDirectory}/api_export_cars_${ExportType.EVIUM}.${FileType.ZIP}`,

package/src/constants/images.ts

@@ -0,0 +1,69 @@
+export const IMAGES_SORT_ORDER: any = {
+  ext_f_right: { order: 1 },
+  ext_f_cowl: { order: 2 },
+  ext_f_left: { order: 3 },
+  ext_l_main: { order: 4 },
+  ext_b_left: { order: 5 },
+  ext_b_main: { order: 6 },
+  ext_b_trunk: { order: 7 },
+  ext_b_right: { order: 8 },
+  ext_r_main: { order: 9 },
+  ext_f_main: { order: 10 },
+  ext_f_main_opened: { order: 11 },
+  ext_f_left_opened: { order: 12 },
+  ext_l_main_opened: { order: 13 },
+  ext_b_left_opened: { order: 14 },
+  ext_b_main_opened: { order: 15 },
+  ext_b_right_opened: { order: 16 },
+  ext_r_main_opened: { order: 17 },
+  ext_f_right_opened: { order: 18 },
+  conext_f_main: { order: 19 },
+  conext_f_left: { order: 20 },
+  conext_l_main: { order: 21 },
+  conext_b_left: { order: 22 },
+  conext_b_main: { order: 23 },
+  conext_b_right: { order: 24 },
+  conext_r_main: { order: 25 },
+  conext_f_right: { order: 26 },
+  ext_feat_engine: { order: 27 },
+  int_f_ipanel1: { order: 28 },
+  int_f_ipanel2: { order: 29 },
+  int_f_ipanel5: { order: 30 },
+  int_f_driverseats: { order: 31 },
+  int_f_assistantseats: { order: 32 },
+  int_b_rearseats: { order: 33 },
+  int_f_fandrseats: { order: 34 },
+  int_f_driverdashboard: { order: 35 },
+  int_f_doordriverside: { order: 36 },
+  int_f_stickshift: { order: 37 },
+  int_b_trunk: { order: 38 },
+  int_t_sunroof: { order: 39 },
+  int_t_panorama_sunroof: { order: 40 },
+  int_f_ipanel3: { order: 41 },
+  int_f_ipanel4: { order: 42 },
+  int_feat_seatheating: { order: 43 },
+  ext_feat_ledlights: { order: 44 },
+  ext_feat_cruisecontrol: { order: 45 },
+  int_feat_climatization: { order: 46 },
+  int_feat_bluetooth: { order: 47 },
+  ext_feat_rainsensor: { order: 48 },
+  ext_feat_rims: { order: 49 },
+  ext_feat_parkassistant: { order: 50 },
+  ext_feat_lightsensor: { order: 51 },
+  int_feat_handsfree: { order: 52 },
+  int_feat_headupdisplay: { order: 53 },
+  ext_feat_trafficsignrec: { order: 54 },
+  ext_feat_auxiliaryheating: { order: 55 },
+  ext_feat_laneassistant: { order: 56 },
+  int_feat_startstop: { order: 57 },
+  int_feat_breakassistant: { order: 58 },
+  ext_feat_nightassistant: { order: 59 },
+  dam_out_left: { order: 1000 },
+  dam_out_front: { order: 2000 },
+  dam_out_back: { order: 3000 },
+  dam_out_right: { order: 4000 },
+  dam_out_top: { order: 5000 },
+  gen_feature: { order: 6000 },
+  simple_temp: { order: 7000 },
+  simple_: { order: 8000 }
+};

package/src/exporters/as24.exporter.ts

@@ -40,9 +40,9 @@ export class As24Exporter implements Exporter {
         const data = chunkData[i];
         const ownerId = get(data.car, 'metaData.ownerId');
 
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const transformedData = await as24Transformer.transform(data.car);
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
         const transformedDataCSV = `${convertToCSV(transformedData)}\n`;
 
         const filename = `${this.configService.config.pathesConfig.localConvertedDirectory}/${ownerId}.${FileType.CSV}`

package/src/exporters/auto24.exporter.ts

@@ -35,9 +35,9 @@ export class Auto24Exporter implements Exporter {
       for (let i = 0; i < chunkData.length; i += 1) {
         const data = chunk.data[i];
         const { car, images } = data;
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         await xmlBuilder.addItem(await auto24Transformer.transform(car, images), 'Deutschland');
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
         this.carService.counter.countCar(images);
       }
     });

package/src/exporters/autouncle.exporter.ts

@@ -38,9 +38,9 @@ export class AutouncleExporter implements Exporter {
       for (const data of chunk.data) {
         const ownerId = get(data.car, 'metaData.ownerId');
         const owner = await this.carService.getOwner(ownerId);
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const car = await autouncleTransformer.transform({ owner, ...data });
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
 
         await autouncleJsonBuilder.addItem(car, firstCar);
 

package/src/exporters/facebook-shop.exporter.ts

@@ -35,9 +35,9 @@ export class FacebookShopExporter implements Exporter {
       for (let i = 0; i < chunkData.length; i += 1) {
         const data = chunk.data[i];
 
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const transformedCar = await facebookShopTransformer.transform(data);
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
 
         await facebookShopXmkBuilder.addItem(transformedCar);
         this.carService.counter.countCar(data.images);

package/src/exporters/fb.exporter.ts

@@ -35,9 +35,9 @@ export class FbExporter implements Exporter {
       for (const data of chunkData) {
         const ownerId = get(data.car, 'metaData.ownerId', null);
         const owner = await this.carService.getOwner(ownerId);
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const car = await fbTransformer.transform({ owner, ...data });
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
 
         await fbXmlBuilder.addItem(car as FbXmlItem);
         this.carService.counter.countCar(data.images);

package/src/exporters/meinstadt.exporter.ts

@@ -36,9 +36,9 @@ export class MeinstadtExporter implements Exporter {
       chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
 
       for (const data of chunk.data) {
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const car = await meinstadtTransformer.transform(data);
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
         await meinstadtJsonBuilder.addItem(car as MeinstadtJsonItem, firstCar);
         this.carService.counter.countCar(data.images);
 

package/src/exporters/mobile.exporter.ts

@@ -1,5 +1,5 @@
 import { writeFile } from 'fs/promises';
-import { basename, normalize, parse } from 'path';
+import { normalize, parse } from 'path';
 
 import { Injectable } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
@@ -8,10 +8,10 @@ import { CronicleUtils } from '@bytebrand/cronicle-helper';
 import { FsChunkInterface } from '@bytebrand/chunkable';
 import { Zipper } from '@bytebrand/zipper';
 
-import { CarService, RulesService, LoaderService, ConfigService } from '../services';
+import { CarService, RulesService, LoaderService, ConfigService, ImagesService } from '../services';
 import { MobileTransformer } from '../transformers/mobile.transformer';
-import { convertToCSV } from '../utils/converter.utils';
 import { Exporter } from '../interfaces/exporter.interface';
+import { convertToCSV } from '../utils/converter.utils';
 import { FileType } from '../enums';
 
 @Injectable()
@@ -21,6 +21,7 @@ export class MobileExporter implements Exporter {
     private configService: ConfigService,
     private rulesService: RulesService,
     private loaderService: LoaderService,
+    private imageService: ImagesService,
     private moduleRef: ModuleRef,
   ) { }
 
@@ -30,6 +31,7 @@ export class MobileExporter implements Exporter {
     await CronicleUtils.emptyDir(this.configService.config.pathesConfig.localConvertedDirectory);
 
     const mobileTransformer = await this.moduleRef.create(MobileTransformer);
+    const imagesPath = [];
 
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
       chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
@@ -38,9 +40,12 @@ export class MobileExporter implements Exporter {
         for (let i = 0; i < chunk.data.length; i += 1) {
           const data = chunk.data[i];
           const { car, images } = data;
-          console.time(`Transform ${data.car._id}`);
           const transformedData = await mobileTransformer.transform(car, images);
-          console.timeEnd(`Transform ${data.car._id}`);
+
+          if (this.configService.config.downloadImage) {
+            const urls = await this.imageService.getImages(car, images, this.configService.config.imageType, true);
+            imagesPath.push(...await this.imageService.downloadInParallel(car.metaData.vehicleId, urls, this.configService.config, 10));
+          }
 
           await writeFile(fileName, Buffer.from(`${convertToCSV(transformedData)}\n`), { flag: 'a' });
 
@@ -50,9 +55,9 @@ export class MobileExporter implements Exporter {
     });
 
     const fileZIP = normalize(`${parse(fileName).dir}/${parse(fileName).name}.${FileType.ZIP}`);
-    console.log(fileZIP);
+
     if (await CronicleUtils.exists(fileName)) {
-      await Zipper.zip({ fileList: [fileName], dest: fileZIP });
+      await Zipper.zip({ fileList: [fileName, ...imagesPath], dest: fileZIP });
     }
     console.log(this.carService.counter.getCountedCars());
   }

package/src/exporters/modix.exporter.ts

@@ -40,9 +40,9 @@ export class ModixExporter implements Exporter {
         for (let i = 0; i < chunk.data.length; i += 1) {
           const data = chunk.data[i];
 
-          console.time(`Transform ${data.car._id}`);
+          // console.time(`Transform ${data.car._id}`);
           const transformedCar = await modixTransformer.transform(data, mappingBuilder.getMappingRules({ reversTransforming: true }));
-          console.timeEnd(`Transform ${data.car._id}`);
+          // console.timeEnd(`Transform ${data.car._id}`);
           await modixXmlBuilder.addItem(transformedCar);
 
           this.carService.counter.countCar(data.images);

package/src/exporters/ooyyo.exporter.ts

@@ -33,9 +33,9 @@ export class OoyyoExporter implements Exporter {
 
         for (let i = 0; i < chunkData.length; i += 1) {
           const { car, images } = chunkData[i];
-          console.time(`Transform ${car._id}`);
+          // console.time(`Transform ${car._id}`);
           await ooyyoXmlBuilder.addItem(await ooyyoTransformer.transform(car, images));
-          console.timeEnd(`Transform ${car._id}`);
+          // console.timeEnd(`Transform ${car._id}`);
           this.carService.counter.countCar(images);
         }
     });

package/src/exporters/rubrikk.exporter.ts

@@ -36,9 +36,9 @@ export class RubrikkExporter implements Exporter {
       for (let i = 0; i < chunkData.length; i += 1) {
         const data = chunkData[i];
 
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const transformedCar = await rubrikkTransformer.transform(data);
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
 
         await rubrikkXmlBuilder.addItem(transformedCar);
         this.carService.counter.countCar(data.images);

package/src/exporters/trovit.exporter.ts

@@ -35,9 +35,9 @@ export class TrovitExporter implements Exporter {
       for (let i = 0; i < chunk.data.length; i += 1) {
         const data = chunk.data[i];
 
-        console.time(`Transform ${data.car._id}`);
+        // console.time(`Transform ${data.car._id}`);
         const transformedCar = await trovitTransformer.transform(data);
-        console.timeEnd(`Transform ${data.car._id}`);
+        // console.timeEnd(`Transform ${data.car._id}`);
 
         await trovitXmlBuilder.addItem(transformedCar);
         this.carService.counter.countCar(data.images);

package/src/formats/modix-xml.builder.ts

@@ -139,7 +139,7 @@ export class ModixXmlBuilder extends XMLBuilderBase {
     let item = `\n<media>\n<images url="${imageData.url}/">\n`;
 
     imageData.imageList.forEach(image => {
-      item += `<image name="${image.atributes?.name}" />\n`;
+      item += `<image name="${image.atributes?.name}" position="${image.atributes?.position}" />\n`;
     });
 
     item += '\n</images>\n</media>';

package/src/services/images.service.ts

@@ -1,4 +1,6 @@
-import { get } from 'lodash';
+import { createWriteStream } from 'fs';
+import { extname } from 'path';
+import axios from 'axios';
 
 import { Injectable } from '@nestjs/common';
 
@@ -7,45 +9,99 @@ import { ImboImageResponseInterface } from '@bytebrand/chunkable';
 import { DataSchemes } from '@bytebrand/car-schema';
 
 import { FB_MAX_IMAGE_COUNT_FOR_DEAFULT } from '../constants/fb.constants';
-import { isNotEmptyArray } from '../utils';
 import { ConfigService } from './config.service';
 import { UserService } from './user.service';
+import { isNotEmptyArray } from '../utils';
+import { Config } from '../configs/config';
 import { ImageType } from '../enums';
 
 @Injectable()
 export class ImagesService {
+  private readonly IMAGES_SORT_ORDER: { [imageCode: string]: number } = {
+    ext_f_right: 1,
+    ext_f_cowl: 2,
+    ext_f_left: 3,
+    ext_l_main: 4,
+    ext_b_left: 5,
+    ext_b_main: 6,
+    ext_b_trunk: 7,
+    ext_b_right: 8,
+    ext_r_main: 9,
+    ext_f_main: 10,
+    ext_f_main_opened: 11,
+    ext_f_left_opened: 12,
+    ext_l_main_opened: 13,
+    ext_b_left_opened: 14,
+    ext_b_main_opened: 15,
+    ext_b_right_opened: 16,
+    ext_r_main_opened: 17,
+    ext_f_right_opened: 18,
+    conext_f_main: 19,
+    conext_f_left: 20,
+    conext_l_main: 21,
+    conext_b_left: 22,
+    conext_b_main: 23,
+    conext_b_right: 24,
+    conext_r_main: 25,
+    conext_f_right: 26,
+    ext_feat_engine: 27,
+    int_f_ipanel1: 28,
+    int_f_ipanel2: 29,
+    int_f_ipanel5: 30,
+    int_f_driverseats: 31,
+    int_f_assistantseats: 32,
+    int_b_rearseats: 33,
+    int_f_fandrseats: 34,
+    int_f_driverdashboard: 35,
+    int_f_doordriverside: 36,
+    int_f_stickshift: 37,
+    int_b_trunk: 38,
+    int_t_sunroof: 39,
+    int_t_panorama_sunroof: 40,
+    int_f_ipanel3: 41,
+    int_f_ipanel4: 42,
+    int_feat_seatheating: 43,
+    ext_feat_ledlights: 44,
+    ext_feat_cruisecontrol: 45,
+    int_feat_climatization: 46,
+    int_feat_bluetooth: 47,
+    ext_feat_rainsensor: 48,
+    ext_feat_rims: 49,
+    ext_feat_parkassistant: 50,
+    ext_feat_lightsensor: 51,
+    int_feat_handsfree: 52,
+    int_feat_headupdisplay: 53,
+    ext_feat_trafficsignrec: 54,
+    ext_feat_auxiliaryheating: 55,
+    ext_feat_laneassistant: 56,
+    int_feat_startstop: 57,
+    int_feat_breakassistant: 58,
+    ext_feat_nightassistant: 59,
+  };
+
   private readonly DEFAULT_IMAGES = [
     'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg',
     'https://images.auto.de/carimage/noimage/GvyXmrpaf1D6/large-cached.jpeg',
     'https://images.auto.de/carimage/noimage/pFyfBsqBHEso/large-cached.jpeg',
   ];
 
-  constructor(private readonly configService: ConfigService, private readonly userService: UserService) {}
+  constructor(private readonly configService: ConfigService, private readonly userService: UserService) { }
 
-  async getImages(
-    car: DataSchemes.Car,
-    images: ImboImageResponseInterface[],
-    imageType: ImageType,
-    ignoreDefImages: boolean,
-  ): Promise<Array<string>> {
+  async getImages(car: DataSchemes.Car, images: ImboImageResponseInterface[], imageType: ImageType, ignoreDefImages: boolean): Promise<Array<string>> {
     if (imageType === ImageType.default) {
-      return this.getDefaultImages(car, images, ignoreDefImages);
+      return this.getDefaultImages(car._id, images, ignoreDefImages);
     } else {
-      return await this.getMarketingImages(car, images, ignoreDefImages);
+      return await this.getMarketingImages(car._id, images, ignoreDefImages);
     }
   }
 
-  getDefaultImages(
-    car: DataSchemes.Car,
-    images: ImboImageResponseInterface[],
-    ignoreDefImages: boolean,
-  ): Array<string> {
+  getDefaultImages(carId: string, images: ImboImageResponseInterface[], ignoreDefImages: boolean): Array<string> {
     if (!isNotEmptyArray(images)) {
       return this.DEFAULT_IMAGES;
     }
 
-    const sortedImages = this.sortImages(images, car);
-    const transformedImages = this.generateImageLinks(sortedImages, get(car, '_id'));
+    const sortedImages = this.sortImages(images);
+    const transformedImages = this.generateImageLinks(sortedImages, carId);
 
     if (!ignoreDefImages && transformedImages.length < 17) {
       transformedImages.push(...this.DEFAULT_IMAGES);
@@ -60,14 +116,10 @@ export class ImagesService {
     });
   }
 
-  async getMarketingImages(
-    car: DataSchemes.Car,
-    images: ImboImageResponseInterface[],
-    ignoreDefImages: boolean,
-  ): Promise<string[]> {
+  async getMarketingImages(carId: string, images: ImboImageResponseInterface[], ignoreDefImages: boolean): Promise<string[]> {
     const imageUrl = this.configService.config.marketingImageUrl;
 
-    const transformedImages = this.transformImagesArrayIntoObject(images);
+    const transformedImages = this.transformImagesArrayIntoObject(this.sortImages(images));
     const config = await this.userService.getMarketingImageConfig(this.configService.config.marketingImageConfigId);
     const marketingImageConfigs = config.marketingImages.map(i => ({ marketingImageCodes: i.imageCodes }));
 
@@ -78,7 +130,7 @@ export class ImagesService {
         const imageCode = marketingImage.marketingImageCodes[i];
         const imageId = transformedImages[imageCode];
         if (imageId) {
-          imageUrls.push(this.getImagePathWithExtension(imageUrl, get(car, '_id', ''), imageId, config));
+          imageUrls.push(this.getImagePathWithExtension(imageUrl, carId, imageId, config));
           break;
         }
       }
@@ -91,54 +143,62 @@ export class ImagesService {
     return imageUrls;
   }
 
-  private transformImagesArrayIntoObject(images: ImboImageResponseInterface[]) {
-    const result: { [imageCode: string]: string } = {};
-    images.forEach(image => {
+  private transformImagesArrayIntoObject(images: ImboImageResponseInterface[]): { [imageCode: string]: string } {
+    return images.reduce((result, image) => {
       const imageCode = image?.imageCodePredicted?.split('-')[0];
-      result[imageCode] = image.imageIdentifier;
-    });
-    return result;
+      if (imageCode) {
+        result[imageCode] = image.imageIdentifier;
+      }
+      return result;
+    }, {});
   }
 
   protected getChannelPath(imageUrl: string, carId: string): string {
     return `${imageUrl}/${[carId[0], carId[1], carId[2], carId].join('/')}`;
   }
 
-  protected getImagePathWithExtension(
-    imageUrl: string,
-    carId: string,
-    imageId: string,
-    config: MarketingImageConfigsInterface,
-  ): string {
+  protected getImagePathWithExtension(imageUrl: string, carId: string, imageId: string, config: MarketingImageConfigsInterface): string {
     const { channelCode, imageExtension } = config;
     return `${this.getChannelPath(imageUrl, carId)}/${channelCode.replace(/ /g, '-')}-${imageId}.${imageExtension}`;
   }
 
-  private sortImages(images: ImboImageResponseInterface[], car: DataSchemes.Car): ImboImageResponseInterface[] {
-    const firstImageId = get(car, 'metaData.mainImageId', null);
-    const secondImageId = get(car, 'metaData.secImageId', null);
-    const thirdImageId = get(car, 'metaData.thirdImageId', null);
-
-    if (firstImageId) {
-      images.forEach((image, index) => {
-        if (firstImageId === image?.imageIdentifier) {
-          const tmp = images[index];
-          images[index] = images[0];
-          images[0] = tmp;
-        }
-        if (secondImageId === image?.imageIdentifier) {
-          const tmp = images[index];
-          images[index] = images[1];
-          images[1] = tmp;
-        }
-        if (thirdImageId === image?.imageIdentifier) {
-          const tmp = images[index];
-          images[index] = images[2];
-          images[2] = tmp;
-        }
-      });
-      return images.filter(i => i); // sometimes thirdImageId exists but image is not
+  sortImages(images: ImboImageResponseInterface[]): ImboImageResponseInterface[] {
+    return images.sort((a, b) => {
+      const imageCodePredictedA = a.imageCodePredicted.includes('-') ? a.imageCodePredicted.split('-')[0] : a.imageCodePredicted;
+      const imageCodePredictedB = b.imageCodePredicted.includes('-') ? b.imageCodePredicted.split('-')[0] : b.imageCodePredicted;
+      const orderA = this.IMAGES_SORT_ORDER[imageCodePredictedA] || 100;
+      const orderB = this.IMAGES_SORT_ORDER[imageCodePredictedB] || 100;
+
+      return orderA - orderB;
+    });
+  }
+
+  async downloadInParallel(vehicleId: string, urls: string[], config: Config, concurrency = 1): Promise<string[]> {
+    for (let i = 0; i < urls.length; i += concurrency) {
+      const downloadPromises = urls.map(
+        (url: string, j: number) => this.download(
+          url,
+          `${config.pathesConfig.localConvertedDirectory}/${vehicleId}_${(i + 1).toLocaleString('en-US', { minimumIntegerDigits: 2 })}.jpeg`
+        )
+      );
+      return Promise.all(downloadPromises);
     }
-    return images;
+    return [];
   }
+
+  private async download(url: string, imagePath: string) {
+    return new Promise<string>(async resolve => {
+      try {
+        const response = await axios.get(url, { responseType: 'stream' });
+        response.data.pipe(
+          createWriteStream(imagePath)
+            .on('finish', () => { console.log(`Downloaded: ${url}`); resolve(imagePath); })
+            .on('error', (err) => { console.error(`Failed to download: ${url}`); resolve(null); })
+        );
+      } catch (error) {
+        console.error(`Failed to download: ${url}`);
+        resolve(null);
+      }
+    });
+  };
 }

package/src/transformers/fb.transformer.ts

@@ -71,12 +71,12 @@ export class FbTransformer {
     const autodeId = toString(get(car, '_id', ''));
     const year = this.getYear(car);
     const dealerInfo = this.getDealerItems(car);
-    console.time(`Address ${car._id}`);
+    // console.time(`Address ${car._id}`);
     const address = await this.getAddress(car, owner);
-    console.timeEnd(`Address ${car._id}`);
-    console.time(`Images ${car._id}`);
+    // console.timeEnd(`Address ${car._id}`);
+    // console.time(`Images ${car._id}`);
     const image_links = await this.imagesService.getImages(car, images, ImageType.marketing, false);
-    console.timeEnd(`Images ${car._id}`);
+    // console.timeEnd(`Images ${car._id}`);
     const transformedImages = image_links.map(el => {
       return { url: el };
     });

package/src/transformers/mobile.transformer.ts

@@ -12,6 +12,7 @@ import { MappingRules } from '../interfaces/mapping-rules.interface';
 import { isNotEmptyArray } from '../utils';
 import { ConfigService } from '../services';
 import { ExportType } from '../enums';
+import axios from "axios";
 
 const vinGenerator = require('vin-generator');
 
@@ -24,7 +25,7 @@ export class MobileTransformer {
     private userService: UserService,
     private configService: ConfigService,
     private imagesService: ImagesService,
-  ) {}
+  ) { }
 
   async transform(carData: DataSchemes.Car, images: ImboImageResponseInterface[]): Promise<unknown> {
     this.currentCar = carData;
@@ -364,6 +365,9 @@ export class MobileTransformer {
       false,
     );
     let imagesAsALine;
+    // console.log(' --> transformedImages', transformedImages)
+    if (this.configService.config.campaign == ExportType.EVIUM) return null;
+
     if (isNotEmptyArray(transformedImages)) {
       imagesAsALine = transformedImages.map((el: string) => el).join(';');
     }

package/src/transformers/modix.transformer.ts

@@ -11,7 +11,7 @@ import { DataSchemes } from '@bytebrand/car-schema';
 
 import { imageItem, IAtributeWrapItem, ModixXmlItem } from '../interfaces';
 import { isNotEmptyArray, isValidVin, xmlStringReplacer } from '../utils';
-import { ConfigService } from '../services';
+import { ConfigService, ImagesService } from '../services';
 import {
   BodyColorList,
   VehicleClassList,
@@ -25,7 +25,7 @@ import {
 
 @Injectable()
 export class ModixTransformer {
-  constructor(private readonly configService: ConfigService) {}
+  constructor(private readonly configService: ConfigService, private readonly imagesService: ImagesService) {}
 
   async transform(
     chunkData: { car: DataSchemes.Car; images: ImboImageResponseInterface[] },
@@ -205,7 +205,7 @@ export class ModixTransformer {
     const imageList: IAtributeWrapItem[] = [];
 
     if (isNotEmptyArray(images)) {
-      images.forEach((image: ImboImageResponseInterface, index) => {
+      this.imagesService.sortImages(images).forEach((image: ImboImageResponseInterface, index) => {
         imageList.push({ value: null, atributes: { name: `${image.imageIdentifier}/large`, position: index + 1 } });
       });
     }