@bytebrand/export-cars 0.0.3 → 1.0.8

package/src/exporters/as24.exporter.ts

@@ -0,0 +1,70 @@
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { As24Transformer } from '../transformers/as24.transformer';
+import { UserService } from '../services/user.service';
+import { get } from 'lodash';
+import { convertToCSV } from '../utils/converter.utils';
+import { writeFile } from 'fs/promises';
+
+@Injectable()
+export class As24Exporter implements Exporter {
+  constructor(
+    private configService: ConfigService,
+    private loaderService: LoaderService,
+    private userService: UserService,
+    private moduleRef: ModuleRef,
+  ) {}
+
+  async export(): Promise<any> {
+    await CronicleUtils.ensureDir(this.configService.config.pathesConfig.localConvertedDirectory);
+    await CronicleUtils.emptyDir(this.configService.config.pathesConfig.localConvertedDirectory);
+
+    const as24Transformer = await this.moduleRef.create(As24Transformer);
+    const descriptionSchemas: any = {};
+
+    for (const dealerId of this.configService.config.dealersList) {
+      descriptionSchemas[dealerId] = await this.userService.getDefaultSummaryByDealerId(dealerId);
+    }
+
+    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 ownerId = get(data.car, 'metaData.ownerId', null);
+          if (
+            ownerId &&
+            this.configService.config.dealersList &&
+            this.configService.config.dealersList.includes(ownerId)
+          ) {
+            const transformedData = await as24Transformer.transform(data.car, descriptionSchemas);
+            const transformedDataCSV = `${convertToCSV(transformedData)}\n`;
+            await writeFile(
+              `${this.configService.config.pathesConfig.localConvertedDirectory}/${ownerId}.csv`,
+              Buffer.from(transformedDataCSV),
+              { flag: 'a' },
+            );
+          }
+        }
+        chunk.data = null;
+      }
+    });
+
+    // TODO: filter dealers and zip files
+
+    // const fileZIP = normalize(
+    //   `${this.configService.config.pathesConfig.localConvertedDirectory}/${this.configService.config.fileName}.zip`,
+    // );
+    // const fileCSV = normalize(
+    //   `${this.configService.config.pathesConfig.localConvertedDirectory}/${this.configService.config.fileName}.csv`,
+    // );
+
+    // if (await CronicleUtils.exists(fileCSV)) {
+    //   await Zipper.zip({ fileList: [fileCSV], dest: fileZIP });
+    // }
+  }
+}

package/src/exporters/auto24.exporter.ts

@@ -0,0 +1,68 @@
+import { Injectable } from '@nestjs/common';
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { get, toNumber } from 'lodash';
+import { ModuleRef } from '@nestjs/core';
+import { Auto24XmlBuilder } from '../formats/auto24-xml.builder';
+import { Auto24Transformer } from '../transformers/auto24.transfomer';
+import { Zipper } from '@bytebrand/zipper';
+
+@Injectable()
+export class Auto24Exporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    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 [fileCarXml, fileMotoXml, fileNfzXml, fileWomoXml, fileGZ] = this.configService.config.outputFiles;
+    console.log(fileCarXml);
+    const carsXmlBuilder = new Auto24XmlBuilder(fileCarXml);
+    const motoXmlBuilder = new Auto24XmlBuilder(fileMotoXml);
+    const nfzXmlBuilder = new Auto24XmlBuilder(fileNfzXml);
+    const womoXmlBuilder = new Auto24XmlBuilder(fileWomoXml);
+
+    await motoXmlBuilder.buildStart();
+    await nfzXmlBuilder.buildStart();
+    await womoXmlBuilder.buildStart();
+
+    const auto24Transformer = await this.moduleRef.create(Auto24Transformer);
+
+    await this.loaderService.process(async (chunk: FsChunkInterface) => {
+      if (chunk && chunk.data) {
+        if (toNumber(chunk.id) === 0) {
+          await carsXmlBuilder.buildStart(chunk.total);
+        }
+
+        for (let i = 0; i < chunk.data.length; i += 1) {
+          const data = chunk.data[i];
+          const { car, images } = data;
+          const ownerId = get(car, 'metaData.ownerId');
+          if (this.configService.config.dealersList.indexOf(ownerId) !== -1) {
+            await carsXmlBuilder.addItem(auto24Transformer.transform(car, images));
+            this.carService.counter.countCar(images);
+          }
+        }
+        chunk.data = null;
+      }
+    });
+
+    await carsXmlBuilder.buildEnd();
+    await motoXmlBuilder.buildEnd();
+    await nfzXmlBuilder.buildEnd();
+    await womoXmlBuilder.buildEnd();
+
+    await Zipper.tar({ dest: fileGZ, fileList: [fileCarXml, fileMotoXml, fileNfzXml, fileWomoXml] });
+  }
+}

package/src/exporters/autouncle.exporter.ts

@@ -0,0 +1,62 @@
+import { Injectable } from '@nestjs/common';
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { ModuleRef } from '@nestjs/core';
+import { AutouncleJsonBuilder } from '../formats/autouncle-json.builder';
+import { AutouncleTransformer } from '../transformers/autouncle.transformer';
+import { get, isNil } from 'lodash';
+import { RulesService } from '../services/rules.service';
+
+@Injectable()
+export class AutouncleExporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    private loaderService: LoaderService,
+    private rulesService: RulesService,
+    private moduleRef: ModuleRef,
+  ) {}
+
+  async export(): Promise<void> {
+    const exists = await CronicleUtils.exists(this.configService.config.fileName);
+    exists && (await CronicleUtils.unlink(this.configService.config.fileName));
+
+    const autouncleJsonBuilder = new AutouncleJsonBuilder(this.configService.config.fileName);
+    const autouncleTransformer = await this.moduleRef.create(AutouncleTransformer);
+
+    await autouncleJsonBuilder.buildStart();
+
+    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;
+          }
+        }
+      }
+    });
+
+    await autouncleJsonBuilder.buildEnd();
+  }
+}

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

@@ -0,0 +1,45 @@
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { ByOwnerTransformer } from '../transformers/by-owner.transformer';
+import { createWriteStream } from 'fs';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { get } from 'lodash';
+const createCsvWriter = require('csv-write-stream');
+
+@Injectable()
+export class ByOwnerExporter implements Exporter {
+  constructor(
+    private configService: ConfigService,
+    private loaderService: LoaderService,
+    private moduleRef: ModuleRef,
+  ) {}
+
+  async export(): Promise<void> {
+    await CronicleUtils.unlinkIfExists(this.configService.config.fileName);
+
+    const byOwnerTransformer = await this.moduleRef.create(ByOwnerTransformer);
+    const csvWriter = createCsvWriter();
+    csvWriter.pipe(createWriteStream(this.configService.config.fileName));
+
+    let index = 0;
+    await this.loaderService.process(async (chunk: FsChunkInterface) => {
+      chunk.data
+        .map(({ car }) => car)
+        .filter((car: DataSchemes.Car) => {
+          const ownerId = get(car, 'metaData.ownerId');
+          return ownerId === this.configService.config.ownerId;
+        })
+        .map(car => byOwnerTransformer.transform(car, (index += 1)))
+        .forEach(car => csvWriter.write(car));
+
+      chunk.data = null;
+    });
+
+    csvWriter.end();
+  }
+}

package/src/exporters/fb.exporter.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@nestjs/common';
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { get } from 'lodash';
+import { FbXmlBuilder } from '../formats/fb-xml.builder';
+import { ModuleRef } from '@nestjs/core';
+import { FbTransformer } from '../transformers/fb.transformer';
+import { RulesService } from '../services/rules.service';
+import { FbXmlItem } from '../interfaces/export-item.interface';
+
+@Injectable()
+export class FbExporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    private rulesService: RulesService,
+    private loaderService: LoaderService,
+    private moduleRef: ModuleRef,
+  ) {}
+
+  async export(): Promise<void> {
+    const exists = await CronicleUtils.exists(this.configService.config.fileName);
+    exists && (await CronicleUtils.unlink(this.configService.config.fileName));
+
+    const fbTransformer = await this.moduleRef.create(FbTransformer);
+    const fbXmlBuilder = new FbXmlBuilder(this.configService.config.fileName);
+    await fbXmlBuilder.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 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);
+        }
+      }
+    });
+
+    await fbXmlBuilder.buildEnd();
+  }
+}

package/src/exporters/google.exporter.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@nestjs/common';
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { get } from 'lodash';
+import { GoogleXmlBuilder } from '../formats/google-xml.builder';
+import { GoogleTransformer } from '../transformers/google.transformer';
+import { ModuleRef } from '@nestjs/core';
+import { RulesService } from '../services/rules.service';
+
+@Injectable()
+export class GoogleExporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    private rulesService: RulesService,
+    private loaderService: LoaderService,
+    private moduleRef: ModuleRef,
+  ) {}
+
+  async export(): Promise<void> {
+    const exists = await CronicleUtils.exists(this.configService.config.fileName);
+    exists && (await CronicleUtils.unlink(this.configService.config.fileName));
+
+    const googleTransformer = await this.moduleRef.create(GoogleTransformer);
+    const googleXmlBuilder = new GoogleXmlBuilder(this.configService.config.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 ownerId = get(data.car, 'metaData.ownerId', null);
+        const owner = await this.carService.getOwner(ownerId);
+        if (owner) {
+          const car = await googleTransformer.transform({ ...data });
+          await googleXmlBuilder.addItem(car);
+          this.carService.counter.countCar(data.images);
+        }
+      }
+    });
+
+    await googleXmlBuilder.buildEnd();
+  }
+}

package/src/exporters/meinstadt.exporter.ts

@@ -0,0 +1,70 @@
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+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 { MeinstadtTransformer } from '../transformers/meinstadt.transformer';
+import { RulesService } from '../services/rules.service';
+import { MeinstadtJsonItem } from '../interfaces/export-item.interface';
+
+@Injectable()
+export class MeinstadtExporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    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 meinstadtJsonBuilder = new MeinstadtJsonBuilder(fileCarJson);
+    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;
+          }
+        }
+      }
+    });
+
+    meinstadtJsonBuilder.buildEnd();
+
+    await Zipper.zip({ dest: fileGZ, fileList: [fileCarJson] });
+  }
+}

package/src/exporters/mobile.exporter.ts

@@ -0,0 +1,113 @@
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { writeFile } from 'fs/promises';
+import { MobileTransformer } from '../transformers/mobile.transformer';
+import { convertToCSV } from '../utils/converter.utils';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+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 { createWriteStream } from 'fs';
+import { get } from 'lodash';
+import { RulesService } from '../services/rules.service';
+
+@Injectable()
+export class MobileExporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    private rulesService: RulesService,
+    private loaderService: LoaderService,
+    private moduleRef: ModuleRef,
+    private httpService: HttpService,
+  ) {}
+
+  async export(): Promise<void> {
+    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));
+      }
+
+      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}/${this.configService.config.fileName}.csv`,
+            Buffer.from(transformedDataCSV),
+            { flag: 'a' },
+          );
+          this.carService.counter.countCar(data.images);
+        }
+        chunk.data = null;
+      }
+    });
+
+    const fileZIP = normalize(
+      `${this.configService.config.pathesConfig.localConvertedDirectory}/${this.configService.config.fileName}.zip`,
+    );
+    const fileCSV = normalize(
+      `${this.configService.config.pathesConfig.localConvertedDirectory}/${this.configService.config.fileName}.csv`,
+    );
+    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((imageUrl, index) => {
+        return new Promise((resolve, reject) => {
+          lastValueFrom(
+            this.httpService.get(imageUrl, {
+              responseType: 'stream',
+            }),
+          )
+            .then(response => {
+              const writer = createWriteStream(
+                join(
+                  this.configService.config.pathesConfig.localConvertedDirectory,
+                  'images',
+                  `${vehicleId}_${index + 1}${extname(imageUrl) || '.jpg'}`,
+                ),
+              );
+              response.data.pipe(writer);
+              writer.on('finish', resolve);
+              writer.on('error', reject);
+            })
+            .catch(reject);
+        });
+      }),
+    );
+  }
+}

package/src/exporters/ooyyo.exporter.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@nestjs/common';
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Exporter } from '../interfaces/exporter.interface';
+import { LoaderService } from '../services/loader.service';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { ModuleRef } from '@nestjs/core';
+import { Zipper } from '@bytebrand/zipper';
+import { OoyyoXmlBuilder } from '../formats/ooyyo-xml.builder';
+import { OoyyoTransformer } from '../transformers/ooyyo.transformer';
+
+@Injectable()
+export class OoyyoExporter implements Exporter {
+  constructor(
+    private carService: CarService,
+    private configService: ConfigService,
+    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 [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) => {
+      if (chunk && chunk.data) {
+        for (let i = 0; i < chunk.data.length; i += 1) {
+          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();
+
+    await Zipper.tar({ dest: fileGZ, fileList: [fileCarXml] });
+  }
+}

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

@@ -0,0 +1,48 @@
+import { XMLBuilderBase } from '@bytebrand/cronicle-helper';
+import { Auto24XmlItem } from '../interfaces/export-item.interface';
+
+export class Auto24XmlBuilder extends XMLBuilderBase {
+  async buildStart(totalResults = 0): Promise<void> {
+    await this.write(`<autode version="1.1" types="detail">
+    <link>https://www.auto.de</link>
+    <language>de</language>
+    <index_totalResults>${totalResults}</index_totalResults>`);
+  }
+
+  async addItem(car: Auto24XmlItem): Promise<void> {
+    let item = '';
+
+    item += '\n<item>\n';
+    item += this.getElement('autodeid', car.autodeid);
+    item += this.getElement('userlink', car.userlink);
+    item += this.getElement('apilink', car.apilink);
+    item += this.getElement('brand', car.brand);
+    item += this.getElement('modell', car.modell);
+    item += this.getElement('cartype', car.cartype);
+    item += this.getElement('variant', car.variant, true);
+    item += this.getElement('bodytype', car.bodytype);
+    item += this.getElement('fueltype', car.fueltype);
+    item += this.getElement('consumptionK', car.consumptionK);
+    item += this.getElement('co2', car.co2);
+    item += this.getElement('efficiencyclass', car.efficiencyclass);
+    item += this.getElement('image', car.image);
+    item += this.getElement('registration', car.registration);
+    item += this.getElementsList('images', 'image', car.images);
+    item += this.getElement('price', car.price);
+    item += this.getElement('power-kw', car.power);
+    item += this.getElement('zip', car.zip);
+    item += this.getElement('city', car.city, true);
+    item += this.getElement('mileage', car.mileage);
+    item += this.getElement('companyname', car.companyname, true);
+    item += this.getElement('extras', car.extras, true);
+    item += this.getElement('sellertype', car.sellertype);
+    item += '</item>';
+
+    await this.write(item);
+  }
+
+  async buildEnd(): Promise<void> {
+    await this.write('\n</autode>');
+    await this.end();
+  }
+}

package/src/formats/autouncle-json.builder.ts

@@ -0,0 +1,20 @@
+import { XMLBuilderBase } from '@bytebrand/cronicle-helper';
+import { AutouncleJsonItem } from '../interfaces/export-item.interface';
+
+export class AutouncleJsonBuilder extends XMLBuilderBase {
+  async buildStart(): Promise<void> {
+    await this.write('{"ads":[');
+  }
+
+  async addItem(car: AutouncleJsonItem, firstSym?: boolean): Promise<void> {
+    if (firstSym) {
+      await this.write(`${JSON.stringify(car)}`);
+    }
+    await this.write(`,${JSON.stringify(car)}`);
+  }
+
+  async buildEnd(): Promise<void> {
+    await this.write(']}');
+    await this.end();
+  }
+}