@bytebrand/export-cars 0.0.2 → 1.0.6

package/src/transformers/autouncle.transformer.ts

@@ -0,0 +1,264 @@
+import { TranslatorExtended } from '@bytebrand/schema-tools';
+import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
+import { get, toString, isEmpty, toSafeInteger } from 'lodash';
+import * as moment from 'moment';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { DePostalCodesService } from '@bytebrand/car-basic-data-scope';
+import { DePostalCodesEntryInterface } from '@bytebrand/car-basic-data-scope/dist/interfaces/DePostalCodesInterface';
+import { ConfigService } from '../services/config.service';
+import { Injectable } from '@nestjs/common';
+import { DEFAULT_ADDR1, DEFAULT_CITY, DEFAULT_ZIP, MIN_MILEAGES } from '../constants/autouncle.contants';
+import { AutouncleJsonItem } from '../interfaces/export-item.interface';
+import { isNotEmptyArray } from '../utils/validator.utils';
+
+@Injectable()
+export class AutouncleTransformer {
+  private translator: TranslatorExtended;
+  private postalCodesService: DePostalCodesService;
+
+  constructor(private configService: ConfigService) {
+    const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
+    this.translator = new TranslatorExtended(dict);
+    this.postalCodesService = DePostalCodesService.getInstance();
+  }
+
+  async transform({
+    car,
+    images,
+    owner,
+  }: {
+    car: DataSchemes.Car;
+    images: unknown[];
+    metadata?: unknown;
+    owner: unknown;
+  }): Promise<AutouncleJsonItem> {
+    const autodeId = toString(get(car, '_id', ''));
+    const address = await this.getAddress(car, owner);
+
+    return {
+      back_link: `https://www.${this.configService.config.url}/search/vehicle/${autodeId}?source=autouncle&medium=cpc&campaign=listing`,
+      make: toString(get(car, 'mainData.make', '')),
+      model_name: toString(get(car, 'mainData.model', '')),
+      model_variant: toString(get(car, 'mainData.subModel', '')),
+      fuel: this.mapFuel(car),
+      body: this.mapBodyStyle(car),
+      doors: toString(get(car, 'mainData.doors', '')),
+      price: this.getPrice(car),
+      year: toString(this.getYear(car)),
+      status: toString(this.getStatus(car)),
+      mileage: toString(this.getMileage(car)) + 'km',
+      leasing: toString(get(car, '', '')),
+      color: this.getExteriorColor(car),
+      engine_size: toString(get(car, 'engineData.cubicCapacity', '')) + 'ccm',
+      power: toString(get(car, 'engineData.powerKW', '')),
+      gear_type: this.mapTransmission(car),
+      has_4wd: this.has4WD(),
+      seller_type: 'Dealer',
+      seller_region: toString(get(address, 'region', '')),
+      seller_city: toString(get(address, 'city', '')),
+      seller_street_address: toString(get(address, 'addr1', '')),
+      seller_postcode: toString(get(address, 'postal_code', '')),
+      seller_name: 'auto.de',
+      seller_id: toString(get(car, 'metaData.ownerId', '')),
+      description: toString(get(car, 'offer.offerDescription', '')),
+      images: this.getImagesField(autodeId, get(car, 'metaData.mainImageId', null), images),
+      fuel_economy: toString(get(car, 'consumption.consumptionCombined', '')),
+      co2_emission: toString(get(car, 'environmentEmissions.co2', '')),
+      co2_effiency_class: toString(get(car, 'environmentEmissions.energyEfficiencyClass', '')),
+      euro_emission_class: toString(get(car, 'environmentEmissions.emissionClass', '')),
+      enviromental_sticker: toString(get(car, 'environmentEmissions.emissionSticker', '')),
+    };
+  }
+
+  private getStatus(car: DataSchemes.Car): 'Neuwagen' | 'Gebrauchtwagen' {
+    if (get(car, 'mainData.firstRegistration', 0) === 0) {
+      return 'Neuwagen';
+    }
+    return 'Gebrauchtwagen';
+  }
+
+  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 '';
+  }
+
+  private mapBodyStyle(car: DataSchemes.Car): string {
+    const available = {
+      selector_unknown: 'Other',
+      selector_category_combi: 'Wagon',
+      selector_category_sedan: 'Sedan',
+      selector_category_compact: 'Small_car',
+      selector_category_coupe: 'Coupe',
+      selector_category_convertible: 'Convertible',
+      selector_category_suv: 'Suv',
+      selector_category_van: 'Van',
+      selector_category_transporter: 'Truck',
+      selector_category_minibus: 'Minivan',
+    };
+    const category = get(car, 'mainData.category', 'selector_unknown');
+    return get(available, category);
+  }
+
+  private mapFuel(car: DataSchemes.Car): string {
+    const available = {
+      selector_fuel_petrol: 'Gasoline',
+      selector_fuel_diesel: 'Diesel',
+      selector_fuel_electrical: 'Electric',
+      selector_fuel_hybridElectricalPetrol: 'Hybrid',
+      selector_fuel_hybridElectricalDiesel: 'Hybrid',
+      selector_fuel_carGas: 'CarGas',
+      selector_fuel_naturalGas: 'NaturalGas',
+      selector_fuel_ethanol: 'Ethanol',
+      selector_fuel_hydrogen: 'Hydrogen',
+      selector_unknown: 'Other',
+    };
+    const fuel = get(car, 'consumption.fuel', 'selector_unknown');
+    return get(available, fuel);
+  }
+
+  private mapTransmission(car: DataSchemes.Car): string {
+    const available = {
+      selector_gearbox_manualShift: 'manual',
+      selector_gearbox_semiAutomatic: 'automatic',
+      selector_gearbox_automatic: 'automatic',
+      selector_unknown: 'other',
+    };
+    const transmission = get(car, 'driveSuspension.gearbox', 'selector_unknown');
+    return get(available, transmission);
+  }
+
+  private getPrice(car: DataSchemes.Car): string {
+    const price = get(car, 'price.currentSalesPrice', '');
+    return `EUR ${price}`;
+  }
+
+  private async getAddress(
+    car: DataSchemes.Car,
+    owner: unknown,
+  ): Promise<{
+    city: string;
+    addr1: unknown;
+    region: string;
+    country: string;
+    postal_code: string;
+    latitude: number;
+    longitude: number;
+  }> {
+    let addressPath = 'businessAddress';
+    if (this.isEmptyAddress(get(owner, addressPath, {}))) {
+      addressPath = 'mainAddress';
+    }
+    let city: string = get(owner, `${addressPath}.city`, '');
+    let zip: string = get(owner, `${addressPath}.zip`, '');
+    let addr1 = get(owner, `${addressPath}.street`, '');
+    let locationEntity = await this.getLocationByInfo({ city, zip: toSafeInteger(zip) });
+
+    if (this.isEmptyLocation(locationEntity)) {
+      addr1 = DEFAULT_ADDR1;
+      city = DEFAULT_CITY;
+      zip = DEFAULT_ZIP;
+      locationEntity = await this.getLocationByInfo({ city, zip: toSafeInteger(zip) });
+    }
+
+    const coords = await this.getCoords(car, locationEntity);
+    const country: string = get(owner, `${addressPath}.country.name`, '');
+    return {
+      ...coords,
+      city,
+      addr1,
+      region: get(locationEntity, 'Place Name', 'Deutschland'),
+      country: country || 'Deutschland',
+      postal_code: zip,
+    };
+  }
+
+  private isEmptyLocation(location: DePostalCodesEntryInterface): boolean {
+    if (!location) return true;
+    return !location['Place Name'] || !(location.Latitude && location.Longitude);
+  }
+
+  private isEmptyAddress(address: unknown): boolean {
+    if (!address) return true;
+    return ['city', 'zip', 'country'].every((key: string) => isEmpty(address[key]));
+  }
+
+  private async getCoords(
+    car: DataSchemes.Car,
+    locationEntry: DePostalCodesEntryInterface,
+  ): Promise<Pick<DataSchemes.Location, 'latitude' | 'longitude'>> {
+    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(locationEntry, 'Longitude'),
+      latitude: get(locationEntry, '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 getExteriorColor(car: DataSchemes.Car): string {
+    let colorSelection = get(car, 'exterior.exteriorColor', 'other');
+    if (!colorSelection || colorSelection === 'selector_unknown') {
+      colorSelection = 'other';
+    }
+    return this.translator.translateVal(colorSelection);
+  }
+
+  private getMileage(car: DataSchemes.Car): number {
+    const mileage = get(car, 'mainData.mileage', 0);
+    return mileage <= MIN_MILEAGES ? MIN_MILEAGES + 1 : mileage;
+  }
+
+  private has4WD(): string {
+    return '';
+  }
+
+  private getImagesField(carId: string, mainImageId: string, images: unknown[]): { url: string }[] {
+    const defImages = [
+      { url: 'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg' },
+      { url: 'https://images.auto.de/carimage/noimage/GvyXmrpaf1D6/large-cached.jpeg' },
+      { url: 'https://images.auto.de/carimage/noimage/gY1zF8PXzH2W/large-cached.jpeg' },
+      { url: 'https://images.auto.de/carimage/noimage/pFyfBsqBHEso/large-cached.jpeg' },
+    ];
+    if (isNotEmptyArray(images)) {
+      const imageList = images.sort(this.setMainImageFirst(mainImageId)).map((image: any) => {
+        return { url: this.buildLargeImageUrl(carId, image.imageIdentifier) };
+      });
+
+      if (imageList.length < 17) {
+        imageList.push(...defImages);
+      }
+      return imageList;
+    }
+    return defImages;
+  }
+
+  private buildLargeImageUrl(carId: string, imageId: string): string {
+    return `${this.configService.config.imageUrl}/carimage/${carId}/${imageId}/large`;
+  }
+
+  private setMainImageFirst(mainImageId: string): (current: any, next: any) => number {
+    return (current: any, next: any): number => {
+      if (current.imageIdentifier === mainImageId) return -1;
+      if (next.imageIdentifier === mainImageId) return 1;
+      return 0;
+    };
+  }
+}

package/src/transformers/by-owner.transformer.ts

@@ -0,0 +1,364 @@
+import { get, toString, trim, toSafeInteger, toNumber, isString } from 'lodash';
+import { Translator, TranslatorExtended } from '@bytebrand/schema-tools';
+import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { Injectable } from '@nestjs/common';
+import { normalizeRateObject, getMonthlyInstallment, getComputedFinancing } from '@bytebrand/fe-financing';
+import * as moment from 'moment';
+
+type transformFn = (car: DataSchemes.Car, translator: TranslatorExtended) => string;
+
+@Injectable()
+export class ByOwnerTransformer {
+  private readonly translator: TranslatorExtended = new TranslatorExtended({
+    ...de,
+    ...deVehicleProps,
+    ...deVehicleDetailsPage,
+  });
+
+  transform(car: DataSchemes.Car, index: number): unknown {
+    const mapping = {
+      UID: '',
+      ID: '_id',
+      autode_ID: 'metaData.vehicleId',
+
+      price: 'price.currentSalesPrice',
+      '(old price) strike price': 'price.wasPrice',
+      rate: (car: DataSchemes.Car) => {
+        const { rate } = normalizeRateObject({ ...car });
+        return getMonthlyInstallment(rate);
+      },
+      'discount in %': this.mapToNumber('price.historyPriceDifferencePerCent', 1, 0),
+      'discount in €': this.mapToNumber('price.historyPriceDifference', 1, 0),
+      'first_installment in €': (car: DataSchemes.Car) => {
+        const { rate } = normalizeRateObject({ ...car });
+        const price = getComputedFinancing(rate) as ReturnType<typeof getComputedFinancing> & {
+          firstInstallment: number;
+        };
+        return price.firstInstallment;
+      },
+      'amount of month': (car: DataSchemes.Car) => {
+        const { rate } = normalizeRateObject({ ...car });
+        return rate.paybackPeriod;
+      },
+
+      Name: (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([make, model, subModel].join(' '));
+      },
+      make: 'mainData.make',
+      model: 'mainData.model',
+      Name_Sonderserie: 'mainData.subModel',
+      PS: 'engineData.powerPS',
+      EngineVolume: this.mapToNumber('engineData.cubicCapacity'),
+
+      consumptioncombined_Benzin: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_petrol',
+      ),
+      consumptioncombined_Diesel: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_diesel',
+      ),
+      'consumptioncombined_Hybrid(Elektro/Benzin)': this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_hybridElectricalPetrol',
+      ),
+      'consumptioncombined_Hybrid(Elektro/Diesel)': this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_hybridElectricalDiesel',
+      ),
+      consumptioncombined_Gemisch: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_ethanol',
+      ),
+      consumptioncombined_Erdgas: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_naturalGas',
+      ),
+      consumptioncombined_Elektro: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_electrical',
+      ),
+      consumptioncombined_Autogas: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_carGas',
+      ),
+      consumptioncombined_Ethanol: this.mapToValueDependOnPath(
+        'consumption.consumptionCombined',
+        'consumption.fuel',
+        'selector_fuel_hydrogen',
+      ),
+      consumptioncombined_Wasserstoff: '',
+
+      constructionYear: 'mainData.constructionYear',
+      first_registration: (car: DataSchemes.Car) => {
+        const val = get(car, 'mainData.firstRegistration');
+        return moment(toSafeInteger(val) * 1000).format('MM/YYYY');
+      },
+      Condition_New: this.mapToValue('mainData.condition', 'selector_condition_new', 'Neuwagen'),
+      Condition_Used: this.mapToValue('mainData.condition', 'selector_condition_used', 'Gebraucht'),
+      Mileage: 'mainData.mileage',
+      Amount_Owner: this.mapToNumber('mainData.numberOfPreviousOwners', 1, 0),
+      highSpeed: 'engineData.highSpeed',
+      cylinders: 'engineData.cylinders',
+
+      cylinders_word: (car: DataSchemes.Car) => {
+        const map = {
+          1: 'Ein',
+          2: 'Zwei',
+          3: 'Drei',
+          4: 'Vier',
+          5: 'Fünf',
+          6: 'Sechs',
+          7: 'Sieben',
+          8: 'Acht',
+          9: 'Neun',
+          10: 'Zehn',
+          12: 'Zwölf',
+          14: 'Vierzehn',
+          16: 'Sechzehn',
+        };
+
+        const cylinders = get(car, 'engineData.cylinders');
+        if (!cylinders) {
+          return '';
+        }
+
+        return map[toSafeInteger(cylinders)];
+      },
+
+      Drivetype_Heckantrieb: this.mapToValue(
+        'driveSuspension.driveType',
+        'selector_driveType_rearWheelDrive',
+        'Heckantrieb',
+      ),
+      Drivetype_Frontantrieb: this.mapToValue(
+        'driveSuspension.driveType',
+        'selector_driveType_frontWheelDrive',
+        'Frontantrieb',
+      ),
+      Drivetype_allrad: this.mapToValue('driveSuspension.driveType', 'selector_driveType_allWheelDrive', 'Allrad'),
+      weight: this.mapToNumber('sizeVolumeWeight.emptyWeight'),
+      length: this.mapToNumber('sizeVolumeWeight.length', 10, 1),
+      gearbox_manuell: this.mapToValue('driveSuspension.gearbox', 'selector_gearbox_manualShift', 'Handschaltung'),
+      gearbox_automatik: this.mapToValue('driveSuspension.gearbox', 'selector_gearbox_automatic', 'Automatik'),
+      gearbox_semiAutomatik: this.mapToValue(
+        'driveSuspension.gearbox',
+        'selector_gearbox_semiAutomatic',
+        'Semi Automatik',
+      ),
+      gearbox_unknown: this.mapToValue('driveSuspension.gearbox', 'selector_unknown', 'unknown'),
+
+      acceleration100: 'engineData.acceleration100',
+
+      gears_automatik: (car: DataSchemes.Car) => {
+        const box = get(car, 'driveSuspension.gearbox');
+        if (box === 'selector_gearbox_automatic' || box === 'selector_gearbox_semiAutomatic') {
+          return get(car, 'driveSuspension.gears');
+        }
+        return '';
+      },
+      gears_Manuell: (car: DataSchemes.Car) => {
+        const box = get(car, 'driveSuspension.gearbox');
+        if (box === 'selector_gearbox_manualShift') {
+          return get(car, 'driveSuspension.gears');
+        }
+        return '';
+      },
+      fuel_Benzin: this.mapToValue('consumption.fuel', 'selector_fuel_petrol', 'Benzin'),
+      fuel_Diesel: this.mapToValue('consumption.fuel', 'selector_fuel_diesel', 'Diesel'),
+      'fuel_Hybrid (Elektro/Benzin)': this.mapToValue(
+        'consumption.fuel',
+        'selector_fuel_hybridElectricalPetrol',
+        'Hybrid (Elektro/Benzin)',
+      ),
+      'fuel_Hybrid (Elektro/Diesel)': this.mapToValue(
+        'consumption.fuel',
+        'selector_fuel_hybridElectricalDiesel',
+        'Hybrid (Elektro/Diesel)',
+      ),
+      fuel_Elektro: this.mapToValue('consumption.fuel', 'selector_fuel_electrical', 'Elektro'),
+      fuel_autogas: this.mapToValue('consumption.fuel', 'selector_fuel_carGas', 'autogas'),
+      fuel_Erdgas: this.mapToValue('consumption.fuel', 'selector_fuel_naturalGas', 'Erdgas'),
+      fuel_Ethanol: this.mapToValue('consumption.fuel', 'selector_fuel_ethanol', 'Ethanol'),
+      fuel_Gemisch: this.mapToValue('consumption.fuel', 'selector_fuel_hydrogen', 'Ethanol'),
+      fuel_unknown: this.mapToValue('consumption.fuel', 'selector_unknown', 'unknown'),
+      CO2: 'environmentEmissions.co2',
+      doors: 'mainData.doors',
+      seats: 'mainData.seats',
+      category_Kleinwagen: this.mapToValue('mainData.category', 'selector_category_compact', 'Kleinwagen'),
+      Category_Limousine: this.mapToValue('mainData.category', 'selector_category_sedan', 'Limousine'),
+      category_Kombi: this.mapToValue('mainData.category', 'selector_category_combi', 'Kombi'),
+      'category_SUV/Geländewagen': this.mapToValue('mainData.category', 'selector_category_suv', 'SUV'),
+      category_Transporter: this.mapToValue('mainData.category', 'selector_category_transporter', 'Transporter'),
+      // tslint:disable-next-line
+      category_Coupé: this.mapToValue('mainData.category', 'selector_category_coupe', 'Coupé'),
+      Category_cabrio: this.mapToValue('mainData.category', 'selector_category_convertible', 'cabrio'),
+      category_Pickup: this.mapToValue('mainData.category', 'selector_category_transporter', 'Pickup'),
+      category_Van: this.mapToValue('mainData.category', 'selector_category_van|selector_category_minibus', 'Van'),
+      torque_in_norm: 'engineData.torque',
+      count_of_airbags: 'airbags.airbagCount',
+      Fahrer_Airbag: this.checkInArray('airbags.airbag', 'selector_airbag_driver', 'Fahrerairbag'),
+      Beifahrer_Airbag: this.checkInArray('airbags.airbag', 'selector_airbag_passenger', 'Beifahrerairbag'),
+      Kopf_Airbag: this.checkInArray('airbags.airbag', 'selector_airbag_head', 'Kopfairbag'),
+      ABS: this.checkBoolean('assistants.abs', 'ABS'),
+      ESP: this.checkBoolean('assistants.esp', 'ESP'),
+      Traktionskontrolle: this.checkBoolean('assistants.tractionControlSystem', 'Traktionskontrolle'),
+      Spurhalteassistent: this.checkBoolean('assistants.laneAssistant', 'Spurhalteassistent'),
+      Spurwechselassistent: this.checkBoolean('assistants.laneAssistant', 'Spurwechselassistent'),
+      'Bi-Xenon_Licht': this.checkBoolean('lights.xenonHeadlights', 'Bi-Xenon-Licht'),
+      Tagfahrlicht: this.checkBoolean(
+        'lights.daytimeRunningLights|lights.daytimeRunningLightsLED',
+        'Spurhalteassistent',
+      ),
+      'LED-Scheinwerfer': this.checkBoolean('lights.daytimeRunningLightsLED', 'LED-Scheinwerfer'),
+      'LED Nebel': this.checkBoolean('lights.frontFogLights', 'LED-Nebelscheinwerfer'),
+      Xenon: this.checkBoolean('lights.xenonHeadlights', 'Xenonscheinwerfer'),
+      Servolenkung: this.checkBoolean('assistants.powerAssistedSteering', 'Servolenkung'),
+      Zentralverriegelung: this.checkBoolean('doors.centralLocking', 'Zentralverriegelung'),
+      Keyless_Go: this.checkBoolean('doors.keylessEntry', 'Keyless-Go'),
+      elektrische_Heckklappe: this.checkBoolean('doors.electricTailGate', 'elektrische Heckklappe'),
+      Klimaanlage: this.checkBoolean('climatisation.selector_none', 'Klimaanlage', false),
+      Klimaautomatik: this.checkBoolean('climatisation.selector_climatisation_automaticAirCondition', 'Klimaautomatik'),
+      '2_Zonen_Klimautomatik': this.checkBoolean(
+        'climatisation.selector_climatisation_automaticAirCondition',
+        '2-Zonen-Klimautomatik',
+      ),
+      '3_Zonen_Klimaautomatik': this.checkBoolean(
+        'climatisation.selector_climatisation_automaticAirCondition',
+        '3-Zonen-Klimaautomatik',
+      ),
+      '4_Zonen_Klimaautomatik': this.checkBoolean(
+        'climatisation.selector_climatisation_automaticAirCondition',
+        '4-Zonen-Klimaautomatik',
+      ),
+      Multifunktionslenkrad: this.checkBoolean('wheel.multifunctionalWheel', 'Multifunktionslenkrad'),
+      Lenkradheizung: this.checkBoolean('wheel.heatedSteeringWheel', 'Lenkradheizung'),
+      Sitzheizung: this.checkBoolean('heatingCooling.auxiliaryHeating', 'Ja'),
+      Navigationssystem: this.checkBoolean('multimedia.navigationSystem', 'Navigationssystem'),
+      Sprachsteuerung: this.checkBoolean('multimedia.voiceControl', 'Sprachsteuerung'),
+      Start_Stop_Automatik: this.checkBoolean('engineData.startStopSystem', 'Start/Stop-Automatik'),
+      USB_Anschluss: this.checkBoolean('multimedia.usbInterface', 'USB-Anschluss'),
+      'USB_Schnittstelle /Bluetooth': this.checkBoolean('multimedia.bluetooth', 'USB_Schnittstelle /Bluetooth'),
+      max_emission_category: this.mapSelection('environmentEmissions.emissionClass'),
+      Seitenairbag:
+        this.checkInArray('airbags.airbag', 'selector_airbag_frontSideAndOther', 'Seitenairbag') ||
+        this.checkInArray('airbags.airbag', 'selector_airbag_frontAndSide', 'Seitenairbag'),
+      min_tank: 'sizeVolumeWeight.fuelCapacity',
+      Varnish: this.mapSelection('exterior.exteriorColor'),
+      Varnish_make: 'exterior.manufacturerColorName',
+      Interieur_Color: this.mapSelection('interior.interiorColor'),
+      Upholstery: this.mapSelection('interior.interiorType'),
+      accident_free: this.checkBoolean('mainData.accidentDamaged', 'Unfallfrei', false),
+      not_accident_free: this.checkBoolean('mainData.accidentDamaged', 'Beschädigt'),
+      Availability: (car: DataSchemes.Car) => {
+        const val = get(car, 'offer.availabilityMode');
+        if (val === 'selector_availabilityMode_always') return 'Sofort';
+        const date = get(car, 'offer.availabilityFrom');
+        return moment(toSafeInteger(date) * 1000).format('DD.MM.YYYY');
+      },
+      Parkassistent: (car: DataSchemes.Car) => {
+        const parks = get(car, 'assistants.parkingAssistants', []).filter(
+          (selector: string) => selector !== 'selector_unknown',
+        );
+        return parks.length ? 'Parkassistent' : '';
+      },
+      Freisprechanlage: this.checkBoolean('multimedia.handsFreePhoneSystem', 'Freisprechanlage'),
+      Car_Play: this.checkBoolean('multimedia.carplay', 'Car Play'),
+      Garantie: this.checkBoolean('offer.warranty', 'Garantie'),
+      Scheckheftgepflegt: this.checkBoolean('careService.fullServiceHistory', 'Scheckheftgepflegt'),
+      Regensenor: this.checkBoolean('assistants.automaticRainSensor', 'Regensenor'),
+      Tempomat: this.checkBoolean('assistants.cruiseControl', 'Tempomat'),
+      Panoramaschiebedach: this.checkBoolean('window.panoramaFrontWindow', 'Panoramaschiebedach'),
+      HU_Date: (car: DataSchemes.Car) => {
+        const date = get(car, 'careService.generalInspection');
+        if (!date) {
+          return '';
+        }
+        return moment(toSafeInteger(date) * 1000).format('DD.MM.YYYY');
+      },
+      Abstandsregeltempomat: this.checkBoolean('assistants.adaptiveCruiseControl', 'Abstandsregeltempomat'),
+      Verkehrszeichen_Erkennung: this.checkBoolean('assistants.trafficSignRecognition', 'Verkehrszeichen-Erkennung'),
+    };
+
+    return Object.entries(mapping)
+      .reverse()
+      .reduce(
+        (transformed, [key, value]) => {
+          return { [key]: this.transformValue(car, value as string), ...transformed };
+        },
+        { UID: index },
+      );
+  }
+
+  private transformValue(car: DataSchemes.Car, value: string | transformFn): unknown {
+    if (isString(value)) {
+      return get(car, value);
+    }
+    return value(car, this.translator);
+  }
+
+  private mapToValue(path: string, selection: string, value: string): (car: DataSchemes.Car) => string {
+    return (car: DataSchemes.Car) => {
+      const cond = get(car, path);
+      const selections = selection.split('|');
+      return selections.some(sel => sel === cond) ? value : '';
+    };
+  }
+
+  private mapToNumber(path: string, divider = 1000, toFix = 1): (car: DataSchemes.Car) => number | '' {
+    return (car: DataSchemes.Car) => {
+      const data = get(car, path);
+      const value = toNumber((toSafeInteger(data) / divider).toFixed(toFix));
+      return value > 0.0 ? value : '';
+    };
+  }
+
+  private mapToValueDependOnPath(
+    valuePath: string,
+    conditionPath: string,
+    selection: string,
+  ): (car: DataSchemes.Car) => any {
+    return (car: DataSchemes.Car) => {
+      const value = get(car, valuePath);
+      const cond = get(car, conditionPath);
+      return cond === selection ? value : '';
+    };
+  }
+
+  private checkBoolean(path: string, value: string, boolean = true): (car: DataSchemes.Car) => string {
+    return (car: DataSchemes.Car) => {
+      return path
+        .split('|')
+        .map(path => get(car, path))
+        .some(cond => cond === boolean)
+        ? value
+        : '';
+    };
+  }
+
+  private checkInArray(path: string, selector: string, value: string): (car: DataSchemes.Car) => string {
+    return (car: DataSchemes.Car) => {
+      const cond = get(car, path) as string[];
+      return cond.some((sel: string) => sel === selector) ? value : '';
+    };
+  }
+
+  private mapSelection(path: string): (car: DataSchemes.Car, translator: Translator) => any {
+    return (car: DataSchemes.Car, translator: Translator) => {
+      const selection = get(car, path);
+      return translator.translateVal(selection);
+    };
+  }
+}