@bytebrand/export-cars 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebrand/export-cars",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "",
   "author": "bytebrand",
   "license": "UNLICENSED",
@@ -65,5 +65,5 @@
   "engines": {
     "node": ">=14.0.0"
   },
-  "gitHead": "4006e3bfe30c1ec48542fdf3d1f98e83cb5718e2"
+  "gitHead": "d5ac6fed61ba0e2f5a476b547a1b039fb97e881a"
 }

package/src/config/kleinanzeigeFocus.config.ts

@@ -0,0 +1,12 @@
+import { Params } from '../interfaces/params.interface';
+import { Config } from './config';
+
+export class KleinanzeigeFocusConfig extends Config {
+  constructor(params: Params) {
+    super(params);
+    this.pathesConfig.localConvertedDirectory = this.environmentConfig[params.environment].localConvertedDirectory;
+    this.pathesConfig.remoteDirectory = this.environmentConfig[params.environment].remoteDirectory;
+    this.imageUrl = this.environmentConfig[params.environment].imageUrl;
+    this.outputFiles = ['api_export_cars_RUBRIKK.xml', 'autode.tar.gz'];
+  }
+}

package/src/enums/export-type.enum.ts

@@ -13,4 +13,5 @@ export enum ExportType {
   AS24 = 'as24',
   ALLESKRALLE = 'alleskralle',
   DASPARKING = 'dasparking',
+  KLEINANZEIGE_FOCUS = 'kleinanzeigefocus',
 }

package/src/export.schema.ts

@@ -12,6 +12,7 @@ import { MarktdeConfig } from './config/marktde.config';
 import { MeinstadtConfig } from './config/meinstadt.config';
 import { OoyyoConfig } from './config/ooyyo.config';
 import { YescarConfig } from './config/yescar.config';
+import { KleinanzeigeFocusConfig } from './config/kleinanzeigeFocus.config';
 import { ExportType } from './enums/export-type.enum';
 import { As24Exporter } from './exporters/as24.exporter';
 import { Auto24Exporter } from './exporters/auto24.exporter';
@@ -22,6 +23,7 @@ import { GoogleExporter } from './exporters/google.exporter';
 import { MeinstadtExporter } from './exporters/meinstadt.exporter';
 import { MobileExporter } from './exporters/mobile.exporter';
 import { OoyyoExporter } from './exporters/ooyyo.exporter';
+import { RubrikkExporter } from './exporters';
 
 export const exportSchema = {
   [ExportType.EAUTO]: {
@@ -80,4 +82,8 @@ export const exportSchema = {
     config: DasparkingConfig,
     exporter: Auto24Exporter,
   },
+  [ExportType.KLEINANZEIGE_FOCUS]: {
+    config: KleinanzeigeFocusConfig,
+    exporter: RubrikkExporter,
+  },
 };

package/src/exporters/index.ts

@@ -0,0 +1 @@
+export * from './rubrikk.exporter';

package/src/exporters/rubrikk.exporter.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import { Exporter } from '../interfaces/exporter.interface';
+import { CarService } from '../services/car.service';
+import { ConfigService } from '../services/config.service';
+import { LoaderService } from '../services/loader.service';
+import { ModuleRef } from '@nestjs/core';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { Zipper } from '@bytebrand/zipper';
+import { RubrikkXmlBuilder } from '../formats';
+import { RubrikkTransformer } from '../transformers';
+import { FsChunkInterface } from '@bytebrand/chunkable';
+
+@Injectable()
+export class RubrikkExporter 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 [fileXml, fileGZ] = this.configService.config.outputFiles;
+
+    const rubrikkXmlBuilder = new RubrikkXmlBuilder(fileXml);
+    const rubrikkTransformer = await this.moduleRef.create(RubrikkTransformer);
+
+    await rubrikkXmlBuilder.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 rubrikkTransformer.transform({ car, images });
+
+          await rubrikkXmlBuilder.addItem(transformed_car);
+          this.carService.counter.countCar(images);
+        }
+        chunk.data = null;
+      }
+    });
+    await rubrikkXmlBuilder.buildEnd();
+
+    if (fileGZ) {
+      await Zipper.tar({ dest: fileGZ, fileList: [fileXml] });
+    }
+  }
+}

package/src/formats/index.ts

@@ -0,0 +1 @@
+export * from './rubrikk-xml.builder';

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

@@ -0,0 +1,27 @@
+import { XMLBuilderBase } from '@bytebrand/cronicle-helper';
+import { RubrikkXmlItem } from '../interfaces/export-item.interface';
+
+export class RubrikkXmlBuilder extends XMLBuilderBase {
+  async buildStart(): Promise<void> {
+    await this.write('<?xml version="1.0" encoding="UTF-8"?><rubrikk>');
+  }
+
+  async addItem(car: RubrikkXmlItem): Promise<void> {
+    let item = '\n<ad>\n';
+
+    const tags = Object.keys(car);
+
+    for (const tag of tags) {
+      const value = car[tag];
+      item += this.getElement(tag, value, true);
+    }
+    item += '</ad>';
+
+    await this.write(item);
+  }
+
+  async buildEnd(): Promise<void> {
+    await this.write('</rubrikk>');
+    await this.end();
+  }
+}

package/src/interfaces/export-item.interface.ts

@@ -144,3 +144,57 @@ export interface GoogleXmlItem {
   color: string;
   installment: { paybackPeriod: any; monthlyInstallment: any };
 }
+
+export interface RubrikkXmlItem {
+  ad__all_imageurls: string[];
+  ad__condition_new_used_etc: string;
+  ad__description: string;
+  ad__headline: string;
+  ad__imageurl: string;
+  ad__price: number;
+  ad__price_currency: string;
+  product__type: string;
+  ad__url: string;
+  efficiency_class: string;
+  ad__number_ad__number_reference_id: string;
+  category_original: string;
+  maincategory_original: string;
+  advertiser__company_homepage_url: string;
+  advertiser__company_logo_url: string;
+  advertiser__email: string;
+  advertiser__name_company_name: string;
+  advertiser__phone: string;
+  advertiser__type: string;
+  advertiser__company_employee: string;
+  location__abroad_region: string;
+  location__country: string;
+  location__municipality_city: string;
+  location__zip_postal_code: string;
+  location__streetaddress: string;
+  location__latitude: number;
+  location__longitude: number;
+  motoring__body_type: string;
+  motoring__color: string;
+  motoring__drivetrain: string;
+  motoring__emission_class: string;
+  motoring__emission_co2: number;
+  motoring__emission_co2_unit: string;
+  motoring__emission_sticker: string;
+  motoring__engine_displacement_cubic_centimeters: number;
+  motoring__fuel_consumption_combined: number;
+  motoring__fuel_consumption_extra_urban: number;
+  motoring__fuel_consumption_extra_urban_unit: string;
+  motoring__fuel_consumption_combined_unit: string;
+  motoring__fuel_consumption_urban: number;
+  motoring__fuel_consumption_urban_unit: string;
+  motoring__fuel_type: string;
+  motoring__make: string;
+  motoring__mileage_kilometers: number;
+  motoring__model: string;
+  motoring__model_year: number;
+  motoring__number_of_doors: number;
+  motoring__number_of_seats: number;
+  motoring__power_kw: number;
+  motoring__power_hp: number;
+  motoring__transmission: string;
+}

package/src/transformers/index.ts

@@ -0,0 +1 @@
+export * from './rubrikk.transformer';

package/src/transformers/rubrikk.transformer.ts

@@ -0,0 +1,237 @@
+import { escape, get, isEmpty, join, toNumber, toSafeInteger, toString, trim } from 'lodash';
+import { Injectable } from '@nestjs/common';
+
+import { DePostalCodesEntryInterface } from '@bytebrand/car-basic-data-scope/dist/interfaces/DePostalCodesInterface';
+import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
+import { DePostalCodesService } from '@bytebrand/car-basic-data-scope';
+import { TranslatorExtended } from '@bytebrand/schema-tools';
+import { DataSchemes } from '@bytebrand/car-schema';
+
+import { RubrikkXmlItem } from '../interfaces/export-item.interface';
+import { ConfigService } from '../services/config.service';
+import * as moment from 'moment/moment';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { isNotEmptyArray } from '../utils/validator.utils';
+
+@Injectable()
+export class RubrikkTransformer {
+  private translator: TranslatorExtended;
+  private postalCodesService: DePostalCodesService;
+
+  constructor(private readonly configService: ConfigService) {
+    const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
+    this.postalCodesService = DePostalCodesService.getInstance();
+    this.translator = new TranslatorExtended(dict);
+  }
+
+  async transform({
+    car,
+    images,
+  }: {
+    car: DataSchemes.Car;
+    images: ImboImageResponseInterface[];
+  }): Promise<RubrikkXmlItem> {
+    const autodeId = toString(get(car, '_id', ''));
+    const region = await this.getRegion(car);
+    const { longitude, latitude } = await this.getCoords(car);
+
+    return {
+      //Common Fields
+      ad__all_imageurls: this.getImagesLinks(autodeId, images),
+      ad__condition_new_used_etc: this.getCondition(car),
+      ad__description: toString(get(car, 'offer.offerDescription', '')),
+      ad__headline: this.getTitle(car),
+      ad__imageurl: this.getImageLink(car),
+      ad__price: toNumber(get(car, 'price.currentSalesPrice', null)),
+      ad__price_currency: toString(get(car, 'price.currency', 'EUR')),
+      product__type: this.getCategory(car),
+      ad__url: this.getCarLink(car),
+      efficiency_class: this.getEnergyClass(car),
+      ad__number_ad__number_reference_id: toString(get(car, 'metaData.vehicleId', '')),
+
+      //Categorization
+      category_original: 'Vehicles',
+      maincategory_original: 'Cars',
+
+      //Advertiser Info
+      advertiser__company_homepage_url: 'https://www.auto.de',
+      advertiser__company_logo_url:
+        'https://autode-static.de/wp-content/themes/autode/front/img/header/b_logo_autode.svg',
+      advertiser__email: 'auto@auto.de',
+      advertiser__name_company_name: 'Auto.de',
+      advertiser__phone: '+498000008300',
+      advertiser__type: 'Dealer',
+      advertiser__company_employee: 'auto.de',
+
+      // Geography Info
+      location__abroad_region: region,
+      location__country: 'Deutschland',
+      location__municipality_city: get(car, 'location.city', ''),
+      location__zip_postal_code: toString(get(car, 'location.zipCode', '')),
+      location__streetaddress: this.getStreetAddress(car),
+      location__longitude: longitude,
+      location__latitude: latitude,
+
+      // Motoring Fields
+      motoring__body_type: this.translateSelector(get(car, 'mainData.category', '')),
+      motoring__color: this.getColor(car),
+      motoring__drivetrain: this.getDrivetrain(car),
+      motoring__emission_class: this.translateSelector(get(car, 'environmentEmissions.emissionClass', '')),
+      motoring__emission_co2: get(car, 'environmentEmissions.co2', null),
+      motoring__emission_co2_unit: 'g/km',
+      motoring__emission_sticker: this.translateSelector(get(car, 'environmentEmissions.emissionSticker', '')),
+      motoring__engine_displacement_cubic_centimeters: toNumber(get(car, 'engineData.cubicCapacity', null)),
+      motoring__fuel_consumption_combined: get(car, 'consumption.consumptionCombined', null),
+      motoring__fuel_consumption_combined_unit: 'l',
+      motoring__fuel_consumption_extra_urban: get(car, 'consumption.consumptionOuter', null),
+      motoring__fuel_consumption_extra_urban_unit: 'l',
+      motoring__fuel_consumption_urban: get(car, 'consumption.consumptionInner', null),
+      motoring__fuel_consumption_urban_unit: 'l',
+      motoring__fuel_type: this.translateSelector(get(car, 'consumption.fuel', '')),
+      motoring__make: toString(get(car, 'mainData.make', '')),
+      motoring__mileage_kilometers: get(car, 'mainData.mileage', null),
+      motoring__model: toString(get(car, 'mainData.model', '')),
+      motoring__model_year: this.getYear(car),
+      motoring__number_of_doors: get(car, 'mainData.doors', null),
+      motoring__number_of_seats: get(car, 'mainData.seats', null),
+      motoring__power_kw: get(car, 'engineData.powerKW', null),
+      motoring__power_hp: get(car, 'engineData.powerPS', null),
+      motoring__transmission: this.getDrivetrain(car),
+    };
+  }
+
+  private translateSelector(selector: string): string {
+    if (isEmpty(selector) || selector === 'selector_unknown') {
+      return '';
+    }
+    return this.translator.translateVal(selector);
+  }
+
+  private getTitle(car: DataSchemes.Car): string {
+    const make = toString(get(car, 'mainData.make', ''));
+    const model = toString(get(car, 'mainData.model', ''));
+    const subModel = toString(get(car, 'mainData.subModel', ''));
+    return trim(escape(join([make, model, subModel], ' ')));
+  }
+
+  private getCondition(car: DataSchemes.Car): string {
+    const available = {
+      selector_condition_new: 'Neu',
+      selector_condition_used: 'Gebraucht',
+      selector_unknown: 'Gebraucht',
+    };
+    const condition = get(car, 'mainData.condition', 'selector_unknown');
+    return get(available, condition);
+  }
+
+  private getCategory(car: DataSchemes.Car): string {
+    return this.translator.translateVal(get(car, 'mainData.category', ''));
+  }
+
+  private getCarLink(car: DataSchemes.Car): string {
+    const autodeId = toString(get(car, '_id', ''));
+    return `https://www.${this.configService.config.url}/search/vehicle/${autodeId}?source=classifieds&medium=listing&campaign=focus`;
+  }
+
+  private getImageLink(car: DataSchemes.Car): string {
+    const mainImageId = get(car, 'metaData.mainImageId', '');
+    return mainImageId
+      ? `https://images.auto.de/carimage/${car._id}/${mainImageId}/large-cached.webp`
+      : 'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg';
+  }
+
+  private getImagesLinks(carId: string, images: ImboImageResponseInterface[]): string[] {
+    if (isNotEmptyArray(images)) {
+      return images.map((image: ImboImageResponseInterface) => {
+        return `${this.configService.config.url}/carimage/${carId}/${image.imageIdentifier}/large`;
+      });
+    }
+    return [];
+  }
+
+  private getEnergyClass(car: DataSchemes.Car): string {
+    const available = {
+      selector_energyEfficiencyClass_a: 'A',
+      selector_energyEfficiencyClass_ap: 'A+',
+      selector_energyEfficiencyClass_app: 'A++',
+      selector_energyEfficiencyClass_appp: 'A+++',
+      selector_energyEfficiencyClass_b: 'B',
+      selector_energyEfficiencyClass_c: 'C',
+      selector_energyEfficiencyClass_d: 'D',
+      selector_energyEfficiencyClass_e: 'E',
+      selector_energyEfficiencyClass_f: 'F',
+      selector_energyEfficiencyClass_g: 'G',
+      selector_unknown: 'default',
+    };
+    const energyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+    return get(available, energyClass);
+  }
+
+  private getStreetAddress(car: DataSchemes.Car): string {
+    const street = get(car, 'location.street', '');
+    const streetNumber = get(car, 'location.streetNumber', '');
+    return trim(escape(join([street, streetNumber], ' ')));
+  }
+
+  private async getRegion(car: DataSchemes.Car): Promise<string> {
+    const city: string = get(car, 'location.city', '');
+    const zipCode: number = toNumber(get(car, 'location.zipCode', ''));
+
+    const locationEntity = await this.getLocationByInfo({ city, zip: toSafeInteger(zipCode) });
+    return get(locationEntity, 'Place Name', 'Deutschland');
+  }
+
+  private async getCoords(car: DataSchemes.Car): Promise<Pick<DataSchemes.Location, 'latitude' | 'longitude'>> {
+    const city: string = get(car, 'location.city', '');
+    const zipCode: number = toNumber(get(car, 'location.zipCode', ''));
+    const locationEntity = await this.getLocationByInfo({ city, zip: toSafeInteger(zipCode) });
+
+    const data: Pick<DataSchemes.Location, 'latitude' | 'longitude'> = {
+      latitude: get(car, 'location.latitude'),
+      longitude: get(car, 'location.longitude'),
+    };
+
+    if (data.latitude && data.longitude) return data;
+
+    return {
+      longitude: get(locationEntity, 'Longitude'),
+      latitude: get(locationEntity, 'Latitude'),
+    };
+  }
+
+  private async getLocationByInfo(info: { zip: number; city: string }): Promise<DePostalCodesEntryInterface> {
+    let entry: DePostalCodesEntryInterface = await this.postalCodesService.getLocationByPostalCode(info.zip);
+
+    if (!entry) {
+      entry = await this.postalCodesService.getLocationByCity(info.city);
+    }
+    return entry;
+  }
+
+  private getColor(car: DataSchemes.Car): string {
+    let colorSelection = get(car, 'exterior.exteriorColor', 'other');
+    if (!colorSelection || colorSelection === 'selector_unknown') {
+      colorSelection = 'other';
+    }
+    return this.translator.translateVal(colorSelection);
+  }
+
+  private getDrivetrain(car: DataSchemes.Car): string {
+    const available = {
+      selector_unknown: 'Other',
+      selector_driveType_frontWheelDrive: 'FWD',
+      selector_driveType_rearWheelDrive: 'RWD',
+      selector_driveType_allWheelDrive: 'AWD',
+    };
+    const driveType = get(car, 'driveSuspension.driveType', 'selector_unknown');
+    return get(available, driveType);
+  }
+
+  private getYear(car: DataSchemes.Car): number {
+    const firstRegistration = get(car, 'mainData.firstRegistration', 0) as number;
+    if (firstRegistration !== 0) {
+      return toSafeInteger(moment(firstRegistration * 1000).format('YYYY'));
+    }
+    return 0;
+  }
+}