@bytebrand/export-cars 1.5.2 → 1.6.1

package/src/exporters/auto24.exporter.ts

@@ -1,14 +1,15 @@
 import { Injectable } from '@nestjs/common';
-import { CarService, RulesService, ConfigService, LoaderService } from '../services';
-import { FsChunkInterface } from '@bytebrand/chunkable';
-import { Exporter } from '../interfaces/exporter.interface';
-import { CronicleUtils } from '@bytebrand/cronicle-helper';
-import { toNumber } from 'lodash';
 import { ModuleRef } from '@nestjs/core';
-import { Auto24XmlBuilder } from '../formats/auto24-xml.builder';
-import { Auto24Transformer } from '../transformers/auto24.transfomer';
+
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { FsChunkInterface } from '@bytebrand/chunkable';
 import { Zipper } from '@bytebrand/zipper';
 
+import { CarService, RulesService, ConfigService, LoaderService } from '../services';
+import { Auto24Transformer } from '../transformers/auto24.transfomer';
+import { Auto24XmlBuilder } from '../formats/auto24-xml.builder';
+import { Exporter } from '../interfaces/exporter.interface';
+
 @Injectable()
 export class Auto24Exporter implements Exporter {
   constructor(
@@ -17,17 +18,14 @@ export class Auto24Exporter implements Exporter {
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
     private rulesService: RulesService,
-  ) {}
+  ) { }
 
   async export(): Promise<void> {
-    for (const file of this.configService.config.outputFiles) {
-      const exists = await CronicleUtils.exists(file);
-      exists && (await CronicleUtils.unlink(file));
-    }
-
     const [fileXml, fileGZ] = this.configService.config.outputFiles;
+    await Promise.all([await CronicleUtils.unlinkIfExists(fileXml), await CronicleUtils.unlinkIfExists(fileGZ)]);
 
     const xmlBuilder = new Auto24XmlBuilder(fileXml);
+    await xmlBuilder.buildStart();
 
     const auto24Transformer = await this.moduleRef.create(Auto24Transformer);
 
@@ -35,25 +33,19 @@ export class Auto24Exporter implements Exporter {
       const chunkData = chunk.data.filter(car => this.carService.filterCar(car, this.rulesService.rules));
 
       if (chunk && chunkData) {
-        if (toNumber(chunk.id) === 0) {
-          await xmlBuilder.buildStart(chunk.total);
-        }
-
         for (let i = 0; i < chunk.data.length; i += 1) {
           const data = chunk.data[i];
           const { car, images } = data;
-          await xmlBuilder.addItem(auto24Transformer.transform(car, images), this.configService.config.location);
+          await xmlBuilder.addItem(auto24Transformer.transform(car, images), 'Deutschland');
           this.carService.counter.countCar(images);
         }
-        chunk.data = null;
+
       }
     });
 
     await xmlBuilder.buildEnd();
-    console.log(this.carService.counter.getCountedCars());
 
-    if (fileGZ) {
-      await Zipper.tar({ dest: fileGZ, fileList: [fileXml] });
-    }
+    fileGZ && await Zipper.tar({ dest: fileGZ, fileList: [fileXml] });
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/autouncle.exporter.ts

@@ -1,14 +1,15 @@
+import { get } from 'lodash';
+
 import { Injectable } from '@nestjs/common';
-import { CarService, RulesService, ConfigService, LoaderService } from '../services';
-import { FsChunkInterface } from '@bytebrand/chunkable';
-import { Exporter } from '../interfaces/exporter.interface';
-import { CronicleUtils } from '@bytebrand/cronicle-helper';
 import { ModuleRef } from '@nestjs/core';
-import { AutouncleJsonBuilder } from '../formats/autouncle-json.builder';
+
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+
 import { AutouncleTransformer } from '../transformers/autouncle.transformer';
-import { get, isNil } from 'lodash';
-import { ExportType, FileTypes } from '../enums';
-import { UserService } from '../services';
+import { AutouncleJsonBuilder } from '../formats/autouncle-json.builder';
+import { CarService, RulesService, LoaderService, ConfigService } from '../services';
+import { Exporter } from '../interfaces/exporter.interface';
 
 @Injectable()
 export class AutouncleExporter implements Exporter {
@@ -18,47 +19,35 @@ export class AutouncleExporter implements Exporter {
     private loaderService: LoaderService,
     private rulesService: RulesService,
     private moduleRef: ModuleRef,
-    private readonly userService: UserService,
-  ) {}
+  ) { }
 
   async export(): Promise<void> {
-    const fileName = this.userService.getFileName(ExportType.AUTOUNCLE, FileTypes.json);
-
-    const exists = await CronicleUtils.exists(fileName);
-    exists && (await CronicleUtils.unlink(fileName));
+    const [fileName] = this.configService.config.outputFiles;
+    await CronicleUtils.unlinkIfExists(fileName);
 
     const autouncleJsonBuilder = new AutouncleJsonBuilder(fileName);
-    const autouncleTransformer = await this.moduleRef.create(AutouncleTransformer);
-
     await autouncleJsonBuilder.buildStart();
+    
+    const autouncleTransformer = await this.moduleRef.create(AutouncleTransformer);
 
     let firstCar = true;
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
-      let chunkData;
-      if (this.configService.config.isNewCar) {
-        chunkData = chunk.data.filter(
-          e => this.carService.filterCar(e, this.rulesService.rules) && this.carService.isCarNew(e),
-        );
-      } else {
-        chunkData = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
-      }
-      chunk.data = null;
-      for (const data of chunkData) {
-        const ownerId = get(data.car, 'metaData.ownerId', null);
-        if (!isNil(ownerId)) {
-          const owner = await this.carService.getOwner(ownerId);
-          if (owner) {
-            const car = await autouncleTransformer.transform({ owner, ...data });
-            await autouncleJsonBuilder.addItem(car, firstCar);
-            this.carService.counter.countCar(data.images);
-          }
-          if (firstCar) {
-            firstCar = false;
-          }
-        }
+      chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
+
+      for (const data of chunk.data) {
+        const ownerId = get(data.car, 'metaData.ownerId');
+        const owner = await this.carService.getOwner(ownerId);
+        const car = await autouncleTransformer.transform({ owner, ...data });
+
+        await autouncleJsonBuilder.addItem(car, firstCar);
+
+        this.carService.counter.countCar(data.images);
+        
+        if (firstCar) { firstCar = false; }
       }
     });
 
     await autouncleJsonBuilder.buildEnd();
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/by-owner.exporter.ts

@@ -1,4 +1,4 @@
-import { ConfigService, LoaderService, CarService, RulesService, UserService } from '../services';
+import { ConfigService, LoaderService, CarService, RulesService } from '../services';
 import { FsChunkInterface } from '@bytebrand/chunkable';
 import { Exporter } from '../interfaces/exporter.interface';
 import { CronicleUtils } from '@bytebrand/cronicle-helper';
@@ -6,23 +6,24 @@ import { Injectable } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
 import { ByOwnerTransformer } from '../transformers/by-owner.transformer';
 import { createWriteStream } from 'fs';
-import { ExportType, FileTypes } from '../enums';
 
 const createCsvWriter = require('csv-write-stream');
 
+  /**
+  * @deprecated
+  */
 @Injectable()
 export class ByOwnerExporter implements Exporter {
   constructor(
     private configService: ConfigService,
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
-    private userService: UserService,
     private carService: CarService,
     private rulesService: RulesService,
   ) {}
 
   async export(): Promise<void> {
-    const fileName = this.userService.getFileName(ExportType.BY_OWNER, FileTypes.csv);
+    const [fileName] = this.configService.config.outputFiles;
 
     await CronicleUtils.unlinkIfExists(fileName);
 
@@ -37,6 +38,7 @@ export class ByOwnerExporter implements Exporter {
       chunk.data = null;
     });
 
-    csvWriter.end();
+    await csvWriter.end();
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/fb.exporter.ts

@@ -7,7 +7,6 @@ import { get } from 'lodash';
 import { FbXmlBuilder } from '../formats/fb-xml.builder';
 import { ModuleRef } from '@nestjs/core';
 import { FbTransformer } from '../transformers/fb.transformer';
-import { ExportType, FileTypes } from '../enums';
 import { FbXmlItem } from '../interfaces';
 
 @Injectable()
@@ -18,18 +17,17 @@ export class FbExporter implements Exporter {
     private rulesService: RulesService,
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
-    private userService: UserService,
-  ) {}
+  ) { }
 
   async export(): Promise<void> {
-    const fileName = this.userService.getFileName(ExportType.FB, FileTypes.xml);
+    const [fileName] = this.configService.config.outputFiles;
+    await CronicleUtils.unlinkIfExists(fileName);
 
-    const exists = await CronicleUtils.exists(fileName);
-    exists && (await CronicleUtils.unlink(fileName));
 
-    const fbTransformer = await this.moduleRef.create(FbTransformer);
     const fbXmlBuilder = new FbXmlBuilder(fileName);
-    await fbXmlBuilder.buildStart(this.configService.config.url);
+    await fbXmlBuilder.buildStart(this.configService.config.domain);
+
+    const fbTransformer = await this.moduleRef.create(FbTransformer);
 
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
       const chunkData = chunk.data.filter(car => this.carService.filterCar(car, this.rulesService.rules));
@@ -37,14 +35,14 @@ 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);
-        if (owner) {
-          const car = await fbTransformer.transform({ owner, ...data });
-          await fbXmlBuilder.addItem(car as FbXmlItem);
-          this.carService.counter.countCar(data.images);
-        }
+        const car = await fbTransformer.transform({ owner, ...data });
+        
+        await fbXmlBuilder.addItem(car as FbXmlItem);
+        this.carService.counter.countCar(data.images);
       }
     });
 
     await fbXmlBuilder.buildEnd();
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/google.exporter.ts

@@ -1,12 +1,13 @@
 import { Injectable } from '@nestjs/common';
-import { CarService, ConfigService, LoaderService, RulesService, UserService } from '../services';
-import { FsChunkInterface } from '@bytebrand/chunkable';
-import { Exporter } from '../interfaces/exporter.interface';
+import { ModuleRef } from '@nestjs/core';
+
 import { CronicleUtils } from '@bytebrand/cronicle-helper';
-import { GoogleXmlBuilder } from '../formats/google-xml.builder';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+
+import { CarService, ConfigService, LoaderService, RulesService } from '../services';
 import { GoogleTransformer } from '../transformers/google.transformer';
-import { ModuleRef } from '@nestjs/core';
-import { ExportType, FileTypes } from '../enums';
+import { GoogleXmlBuilder } from '../formats/google-xml.builder';
+import { Exporter } from '../interfaces/exporter.interface';
 
 @Injectable()
 export class GoogleExporter implements Exporter {
@@ -16,30 +17,28 @@ export class GoogleExporter implements Exporter {
     private rulesService: RulesService,
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
-    private userService: UserService,
   ) {}
 
   async export(): Promise<void> {
-    const exportType = this.configService.config.isCriteo ? ExportType.CRITEO : ExportType.GOOGLE;
-    const fileName = this.userService.getFileName(exportType, FileTypes.xml);
+    const [fileName] = this.configService.config.outputFiles;
+    await CronicleUtils.unlinkIfExists(fileName);
 
-    const exists = await CronicleUtils.exists(fileName);
-    exists && (await CronicleUtils.unlink(fileName));
+    const googleXmlBuilder = new GoogleXmlBuilder(fileName);
+    await googleXmlBuilder.buildStart(this.configService.config.domain);
 
     const googleTransformer = await this.moduleRef.create(GoogleTransformer);
-    const googleXmlBuilder = new GoogleXmlBuilder(fileName);
-    await googleXmlBuilder.buildStart(this.configService.config.url);
 
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
-      const chunkData = chunk.data.filter(car => this.carService.filterCar(car, this.rulesService.rules));
-      chunk.data = null;
-      for (const data of chunkData) {
-        const car = await googleTransformer.transform({ ...data });
+      chunk.data = chunk.data.filter(car => this.carService.filterCar(car, this.rulesService.rules));
+
+      for (const data of chunk.data) {
+        const car = await googleTransformer.transform(data);
         await googleXmlBuilder.addItem(car);
         this.carService.counter.countCar(data.images);
       }
     });
 
     await googleXmlBuilder.buildEnd();
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/index.ts

@@ -1,2 +1,11 @@
-export * from './rubrikk.exporter';
+export * from './as24.exporter';
+export * from './auto24.exporter';
+export * from './autouncle.exporter';
+export * from './by-owner.exporter';
+export * from './fb.exporter';
+export * from './google.exporter';
+export * from './meinstadt.exporter';
+export * from './mobile.exporter';
 export * from './modix.exporter';
+export * from './ooyyo.exporter';
+export * from './rubrikk.exporter';

package/src/exporters/meinstadt.exporter.ts

@@ -1,14 +1,15 @@
-import { CarService, RulesService, LoaderService, ConfigService } from '../services';
-import { FsChunkInterface } from '@bytebrand/chunkable';
-import { Exporter } from '../interfaces/exporter.interface';
-import { CronicleUtils } from '@bytebrand/cronicle-helper';
-import { Zipper } from '@bytebrand/zipper';
 import { Injectable } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { MeinstadtJsonBuilder } from '../formats/meinstadt-json.builder';
-import { get, isNil } from 'lodash';
+
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Zipper } from '@bytebrand/zipper';
+
+import { CarService, RulesService, LoaderService, ConfigService } from '../services';
 import { MeinstadtTransformer } from '../transformers/meinstadt.transformer';
+import { MeinstadtJsonBuilder } from '../formats/meinstadt-json.builder';
 import { MeinstadtJsonItem } from '../interfaces/export-item.interface';
+import { Exporter } from '../interfaces/exporter.interface';
 
 @Injectable()
 export class MeinstadtExporter implements Exporter {
@@ -18,50 +19,32 @@ export class MeinstadtExporter implements Exporter {
     private rulesService: RulesService,
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
-  ) {}
+  ) { }
 
   async export(): Promise<void> {
-    for (const file of this.configService.config.outputFiles) {
-      const exists = await CronicleUtils.exists(file);
-      exists && (await CronicleUtils.unlink(file));
-    }
-
-    const [fileCarJson, fileGZ] = this.configService.config.outputFiles;
+    const [fileJson, fileGZ] = this.configService.config.outputFiles;
+    await Promise.all([CronicleUtils.unlinkIfExists(fileJson), CronicleUtils.unlinkIfExists(fileGZ)])
 
-    const meinstadtJsonBuilder = new MeinstadtJsonBuilder(fileCarJson);
-    meinstadtJsonBuilder.buildStart();
+    const meinstadtJsonBuilder = new MeinstadtJsonBuilder(fileJson);
+    await meinstadtJsonBuilder.buildStart();
 
     const meinstadtTransformer = await this.moduleRef.create(MeinstadtTransformer);
 
     let firstCar = true;
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
-      let chunkData;
-      if (this.configService.config.isNewCar) {
-        chunkData = chunk.data.filter(
-          e => this.carService.filterCar(e, this.rulesService.rules) && this.carService.isCarNew(e),
-        );
-      } else {
-        chunkData = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
-      }
-      chunk.data = null;
-      for (const data of chunkData) {
-        const ownerId = get(data.car, 'metaData.ownerId', null);
-        if (!isNil(ownerId)) {
-          const owner = await this.carService.getOwner(ownerId);
-          if (owner) {
-            const car = await meinstadtTransformer.transform({ owner, ...data });
-            await meinstadtJsonBuilder.addItem(car as MeinstadtJsonItem, firstCar);
-            this.carService.counter.countCar(data.images);
-          }
-          if (firstCar) {
-            firstCar = false;
-          }
-        }
+      chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
+
+      for (const data of chunk.data) {
+        const car = await meinstadtTransformer.transform({ ...data });
+        await meinstadtJsonBuilder.addItem(car as MeinstadtJsonItem, firstCar);
+        this.carService.counter.countCar(data.images);
+
+        if (firstCar) { firstCar = false; }
       }
     });
 
-    meinstadtJsonBuilder.buildEnd();
-
-    await Zipper.zip({ dest: fileGZ, fileList: [fileCarJson] });
+    await meinstadtJsonBuilder.buildEnd();
+    await Zipper.zip({ dest: fileGZ, fileList: [fileJson] });
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/mobile.exporter.ts

@@ -1,18 +1,18 @@
-import { CarService, RulesService, LoaderService, ConfigService } from '../services';
-import { FsChunkInterface } from '@bytebrand/chunkable';
 import { writeFile } from 'fs/promises';
+import { basename, normalize } from 'path';
+
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Zipper } from '@bytebrand/zipper';
+
+import { CarService, RulesService, LoaderService, ConfigService } from '../services';
 import { MobileTransformer } from '../transformers/mobile.transformer';
 import { convertToCSV } from '../utils/converter.utils';
 import { Exporter } from '../interfaces/exporter.interface';
-import { CronicleUtils } from '@bytebrand/cronicle-helper';
-import { Zipper } from '@bytebrand/zipper';
-import { normalize, join, extname } from 'path';
-import { Injectable } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { HttpService } from '@nestjs/axios';
-import { lastValueFrom } from 'rxjs';
-import { get } from 'lodash';
-import { FileTypes } from '../enums';
+import { FileType } from '../enums';
 
 @Injectable()
 export class MobileExporter implements Exporter {
@@ -22,83 +22,41 @@ export class MobileExporter implements Exporter {
     private rulesService: RulesService,
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
-    private httpService: HttpService,
-  ) {}
+  ) { }
 
   async export(): Promise<void> {
-    const fileName = '416';
+    const [fileName] = this.configService.config.outputFiles;
 
     await CronicleUtils.ensureDir(this.configService.config.pathesConfig.localConvertedDirectory);
     await CronicleUtils.emptyDir(this.configService.config.pathesConfig.localConvertedDirectory);
-    if (this.configService.config.downloadImages) {
-      await CronicleUtils.ensureDir(join(this.configService.config.pathesConfig.localConvertedDirectory, 'images'));
-    }
 
     const mobileTransformer = await this.moduleRef.create(MobileTransformer);
 
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
-      if (this.configService.config.isNewCar) {
-        chunk.data = chunk.data.filter(
-          e => this.carService.filterCar(e, this.rulesService.rules) && this.carService.isCarNew(e),
-        );
-      } else {
-        chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
-      }
+      chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
 
       if (chunk && chunk.data) {
         for (let i = 0; i < chunk.data.length; i += 1) {
           const data = chunk.data[i];
           const { car, images } = data;
           const transformedData = await mobileTransformer.transform(car, images);
-          if (this.configService.config.downloadImages) {
-            await this.downloadImages(get(transformedData, '1'), get(transformedData, '26', '').split(';'));
-          }
-          const transformedDataCSV = `${convertToCSV(transformedData)}\n`;
 
-          await writeFile(
-            `${this.configService.config.pathesConfig.localConvertedDirectory}/${fileName}.${FileTypes.csv}`,
-            Buffer.from(transformedDataCSV),
-            { flag: 'a' },
-          );
+          const file = `${this.configService.config.pathesConfig.localConvertedDirectory}/${fileName}`;
+          await writeFile(file, Buffer.from(`${convertToCSV(transformedData)}\n`), { flag: 'a' });
+
           this.carService.counter.countCar(data.images);
         }
-        chunk.data = null;
+
       }
     });
 
-    const fileZIP = normalize(
-      `${this.configService.config.pathesConfig.localConvertedDirectory}/${fileName}.${FileTypes.zip}`,
-    );
-    const fileCSV = normalize(
-      `${this.configService.config.pathesConfig.localConvertedDirectory}/${fileName}.${FileTypes.csv}`,
-    );
+    const fileZIP = normalize(`${this.configService.config.pathesConfig.localConvertedDirectory}/${basename(fileName)}.${FileType.ZIP}`);
+    const fileCSV = normalize(`${this.configService.config.pathesConfig.localConvertedDirectory}/${fileName}`);
     const fileList = [fileCSV];
-    if (this.configService.config.downloadImages) {
-      const fileImages = normalize(join(this.configService.config.pathesConfig.localConvertedDirectory, 'images'));
-      fileList.push(fileImages);
-    }
 
     if (await CronicleUtils.exists(fileCSV)) {
       await Zipper.zip({ fileList, dest: fileZIP });
     }
-  }
-
-  private downloadImages(vehicleId: string, imageUrls: string[]): Promise<PromiseSettledResult<unknown>[]> {
-    return Promise.allSettled(
-      imageUrls.map(async (imageUrl, index) => {
-        const response = await lastValueFrom(
-          this.httpService.get(imageUrl, {
-            responseType: 'arraybuffer',
-          }),
-        );
-        const imageFile = join(
-          this.configService.config.pathesConfig.localConvertedDirectory,
-          'images',
-          `${vehicleId}_${index + 1}${extname(imageUrl) || FileTypes.jpg}`,
-        );
-
-        return writeFile(imageFile, response.data, { flag: 'w' });
-      }),
-    );
+    console.log(this.carService.counter.getCountedCars());
   }
 }

package/src/exporters/modix.exporter.ts

@@ -1,12 +1,14 @@
 import { Injectable } from '@nestjs/common';
-import { Exporter } from '../interfaces/exporter.interface';
-import { CarService, ConfigService, LoaderService } from '../services';
 import { ModuleRef } from '@nestjs/core';
+
 import { CronicleUtils } from '@bytebrand/cronicle-helper';
-import { ModixXmlBuilder } from '../formats';
-import { ModixTransformer } from '../transformers';
 import { FsChunkInterface } from '@bytebrand/chunkable';
 
+import { CarService, ConfigService, LoaderService } from '../services';
+import { Exporter } from '../interfaces/exporter.interface';
+import { ModixTransformer } from '../transformers';
+import { ModixXmlBuilder } from '../formats';
+
 @Injectable()
 export class ModixExporter implements Exporter {
   constructor(
@@ -16,30 +18,29 @@ export class ModixExporter implements Exporter {
     private moduleRef: ModuleRef,
   ) {}
   async export(): Promise<void> {
-    for (const file of this.configService.config.outputFiles) {
-      const exists = await CronicleUtils.exists(file);
-      exists && (await CronicleUtils.unlink(file));
-    }
-
     const [fileXml] = this.configService.config.outputFiles;
+    await CronicleUtils.unlinkIfExists(fileXml);
 
     const modixXmlBuilder = new ModixXmlBuilder(fileXml);
+    await modixXmlBuilder.buildStart();
+
     const modixTransformer = await this.moduleRef.create(ModixTransformer);
 
-    await modixXmlBuilder.buildStart();
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
       if (chunk && chunk.data) {
         for (let i = 0; i < chunk.data.length; i += 1) {
           const data = chunk.data[i];
-          const { car, images } = data;
 
-          const transformed_car = await modixTransformer.transform({ car, images });
+          const transformed_car = await modixTransformer.transform(data);
           await modixXmlBuilder.addItem(transformed_car);
-          this.carService.counter.countCar(images);
+
+          this.carService.counter.countCar(data.images);
         }
-        chunk.data = null;
+
       }
     });
+
     await modixXmlBuilder.buildEnd();
+    console.log(this.carService.counter.getCountedCars())
   }
 }

package/src/exporters/ooyyo.exporter.ts

@@ -16,20 +16,17 @@ export class OoyyoExporter implements Exporter {
     private loaderService: LoaderService,
     private moduleRef: ModuleRef,
     private rulesService: RulesService,
-  ) {}
+  ) { }
 
   async export(): Promise<void> {
-    for (const file of this.configService.config.outputFiles) {
-      const exists = await CronicleUtils.exists(file);
-      exists && (await CronicleUtils.unlink(file));
-    }
+    const [fileXml, fileGZ] = this.configService.config.outputFiles;
+    await Promise.all([CronicleUtils.unlinkIfExists(fileXml), CronicleUtils.unlinkIfExists(fileGZ)]);
+    
+    const ooyyoXmlBuilder = new OoyyoXmlBuilder(fileXml);
+    await ooyyoXmlBuilder.buildStart();
 
-    const [fileCarXml, fileGZ] = this.configService.config.outputFiles;
-    const ooyyoXmlBuilder = new OoyyoXmlBuilder(fileCarXml);
     const ooyyoTransformer = await this.moduleRef.create(OoyyoTransformer);
 
-    await ooyyoXmlBuilder.buildStart();
-
     await this.loaderService.process(async (chunk: FsChunkInterface) => {
       const chunkData = chunk.data.filter(car => this.carService.filterCar(car, this.rulesService.rules));
 
@@ -38,14 +35,16 @@ export class OoyyoExporter implements Exporter {
           const data = chunk.data[i];
           const { car, images } = data;
           await ooyyoXmlBuilder.addItem(ooyyoTransformer.transform(car, images));
+
           this.carService.counter.countCar(images);
         }
-        chunk.data = null;
+
       }
     });
 
     await ooyyoXmlBuilder.buildEnd();
+    console.log(this.carService.counter.getCountedCars());
 
-    await Zipper.tar({ dest: fileGZ, fileList: [fileCarXml] });
+    await Zipper.tar({ dest: fileGZ, fileList: [fileXml] });
   }
 }