@bytebrand/export-cars 0.0.2 → 1.0.6

package/src/transformers/fb.transformer.ts

@@ -0,0 +1,640 @@
+import { TranslatorExtended } from '@bytebrand/schema-tools';
+import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
+import {
+  get,
+  toString,
+  isEmpty,
+  trim,
+  join,
+  escape,
+  toSafeInteger,
+  truncate,
+  isBoolean,
+  isString,
+  isArray,
+  includes,
+  findIndex,
+} 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 { MarketingImagesService } from '../services/marketing-images.service';
+import { ConfigService } from '../services/config.service';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { isNotEmptyArray, isValidVin } from '../utils/validator.utils';
+import { Injectable } from '@nestjs/common';
+import { FbDescription } from './fb-description.transformer';
+import { Description } from '../interfaces/description.interface';
+import { FbEquipment } from './fb-equipment.transformer';
+import {
+  DEFAULT_ADDR1,
+  DEFAULT_CITY,
+  DEFAULT_ZIP,
+  FB_MAX_IMAGE_COUNT_FOR_DEAFULT,
+  FB_MAX_TRIM_LENGTH,
+  FB_MIN_MILEAGES,
+  TIMESTAMP_FIRST_YEAR,
+} from '../constants/fb.constants';
+
+@Injectable()
+export class FbTransformer {
+  private translator: TranslatorExtended;
+  private postalCodesService: DePostalCodesService;
+
+  constructor(private readonly configService: ConfigService, private readonly marketingImages: MarketingImagesService) {
+    const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
+    this.translator = new TranslatorExtended(dict);
+    this.postalCodesService = DePostalCodesService.getInstance();
+  }
+
+  async transform({
+    car,
+    images,
+    owner,
+  }: {
+    car: DataSchemes.Car;
+    images: ImboImageResponseInterface[];
+    owner: unknown;
+  }): Promise<unknown> {
+    const autodeId = toString(get(car, '_id', ''));
+    const year = this.getYear(car);
+    const dealerInfo = this.getDealerItems(car);
+    const address = await this.getAddress(car, owner);
+
+    return {
+      fb_page_id: '176306386132',
+      ...address,
+      ...dealerInfo,
+      vehicle_id: get(car, 'metaData.vehicleId', autodeId),
+      title: this.getTitle(car),
+      features: this.getHighlights(car),
+      description: this.getDescription(car), // be careful it changes car object
+      url: `https://www.${this.configService.config.url}/search/vehicle/${autodeId}`,
+      dealer_url: `https://www.${this.configService.config.url}/search/vehicle/${autodeId}?source=FACEBOOK&medium=direkt&campaign=marketplace_link`,
+      make: toString(get(car, 'mainData.make', '')),
+      model: toString(get(car, 'mainData.model', '')),
+      trim: this.getTrim(car),
+      image: await this.getImagesField(autodeId, get(car, 'metaData.mainImageId', null), images),
+      year: toString(year),
+      mileage: {
+        value: this.getMileage(car),
+        unit: 'KM',
+      },
+      drivetrain: this.mapDrivetrain(car),
+      vin: this.getVin(car),
+      body_style: this.mapBodyStyle(car),
+      fuel_type: this.mapFuel(car),
+      transmission: this.mapTransmission(car),
+      price: this.getPrice(car),
+      exterior_color: this.getExteriorColor(car),
+      interior_color: this.getInteriorColor(car),
+      state_of_vehicle: this.mapState(car),
+      energy_efficiency_class_eu: this.getEnergyEfficiencyClass(car),
+      vehicle_specifications: [
+        {
+          type: 'gas_mileage_combined',
+          units: 'l/100km',
+          value: get(car, 'consumption.consumptionCombined', ''),
+        },
+        {
+          type: 'gas_mileage_city',
+          units: 'l/100km',
+          value: get(car, 'consumption.consumptionInner', ''),
+        },
+        {
+          type: 'gas_mileage_highway',
+          units: 'l/100km',
+          value: get(car, 'consumption.consumptionOuter', ''),
+        },
+        {
+          type: 'CO2_emissions',
+          units: 'g/km',
+          value: get(car, 'environmentEmissions.co2', ''),
+        },
+      ],
+    };
+  }
+
+  private getYear(car: DataSchemes.Car): number {
+    const firstModelsProductionDate = get(car, 'mainData.firstModelsProductionDate', 0) as number;
+    const firstModelsProductionYear = moment(firstModelsProductionDate * 1000).format('YYYY');
+
+    const firstRegistration = get(car, 'mainData.firstRegistration', 0) as number;
+    const firstRegistrationYear = moment(firstRegistration * 1000).format('YYYY');
+
+    const constructionYear = get(car, 'mainData.constructionYear') as string;
+
+    const metaCreationDate = get(car, 'metaData.creationDate') as number;
+    const metaCreationYear = moment(metaCreationDate * 1000).format('YYYY');
+
+    const currentYear = moment().format('YYYY');
+
+    return getFirstValidYear(
+      firstModelsProductionYear,
+      firstRegistrationYear,
+      constructionYear,
+      metaCreationYear,
+      currentYear,
+    );
+  }
+
+  private getDealerItems(car: DataSchemes.Car): {
+    dealer_communication_channel: string;
+    dealer_id: unknown;
+    dealer_privacy_policy_url: string;
+    dealer_email: string;
+    dealer_phone: string;
+  } {
+    const items = {
+      dealer_communication_channel: 'LEAD_FORM',
+      dealer_id: get(car, 'metaData.ownerId'),
+      dealer_privacy_policy_url: 'https://www.auto.de/einwilligungserklaerung-datenschutz-agb/',
+      dealer_email: 'auto@auto.de',
+      dealer_phone: '+498000008300',
+    };
+
+    return items;
+  }
+
+  private getTitle(car: DataSchemes.Car): string {
+    const year = toString(get(car, 'mainData.constructionYear', ''));
+    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([year, make, model, subModel], ' ')));
+  }
+
+  private getTrim(car: DataSchemes.Car): string {
+    const trim = toString(get(car, 'mainData.subModel', ''));
+    return truncate(trim, { length: FB_MAX_TRIM_LENGTH, separator: ' ' });
+  }
+
+  private getDescription(car: DataSchemes.Car): Description[] {
+    return FbDescription.create(car, this.translator, new FbEquipment()).getDescriptionArray();
+  }
+
+  private mapDrivetrain(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 getVin(car: DataSchemes.Car): string {
+    let vin: string = get(car, 'metaData.vin', '');
+
+    if (!isValidVin(vin)) {
+      vin = get(car, 'marketing.fakeVIN', '');
+    }
+
+    return vin;
+  }
+
+  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: 'OTHER',
+      selector_fuel_naturalGas: 'OTHER',
+      selector_fuel_ethanol: 'OTHER',
+      selector_fuel_hydrogen: 'OTHER',
+      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', 0);
+    return `${price} EUR`;
+  }
+
+  private async getAddress(
+    car: DataSchemes.Car,
+    owner: unknown,
+  ): Promise<{
+    address: { 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,
+      address: {
+        city,
+        addr1,
+        region: get(locationEntity, 'Place Name', ''),
+        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 getInteriorColor(car: DataSchemes.Car): string {
+    let colorSelection = get(car, 'interior.interiorColor', 'other');
+    if (!colorSelection || colorSelection === 'selector_unknown') {
+      colorSelection = 'other';
+    }
+    return this.translator.translateVal(colorSelection);
+  }
+
+  private mapState(car: DataSchemes.Car): string {
+    const available = {
+      selector_condition_new: 'CPO',
+      selector_condition_used: 'USED',
+      selector_unknown: 'USED',
+    };
+    const condition = get(car, 'mainData.condition', 'selector_unknown');
+    return get(available, condition);
+  }
+
+  private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
+    const available = {
+      selector_energyEfficiencyClass_appp: 'A+',
+      selector_energyEfficiencyClass_app: 'A+',
+      selector_energyEfficiencyClass_ap: 'A+',
+      selector_energyEfficiencyClass_a: '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: 'G',
+    };
+    const energyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+    return get(available, energyClass);
+  }
+
+  private getMileage(car: DataSchemes.Car): number {
+    const mileage = get(car, 'mainData.mileage', 0);
+    return mileage <= FB_MIN_MILEAGES ? FB_MIN_MILEAGES + 1 : mileage;
+  }
+
+  private async getImagesField(
+    carId: string,
+    _mainImageId: string,
+    images: ImboImageResponseInterface[],
+  ): Promise<{ 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 = await this.marketingImages.getImagesUrl(images, this.configService.config.imageUrl, carId);
+
+      if (imageList.length < FB_MAX_IMAGE_COUNT_FOR_DEAFULT) {
+        imageList.push(...defImages);
+      }
+      return imageList;
+    }
+    return defImages;
+  }
+
+  private getHighlights(car: DataSchemes.Car): { type: unknown; value: unknown }[] {
+    const facebookFeatures = [
+      { key: 'assistants.abs', type: 'abs_brakes', value: 'ABS' },
+      { key: 'assistants.adaptiveCruiseControl', type: 'adaptive_cruise_control', value: 'Abstandsregeltempomat' },
+      { key: 'theftProtection.alarmSystem', type: 'alarm', value: 'Alarmanlage' },
+      { key: 'multimedia.auxiliaryAudioInput', type: 'aux_audio_input', value: 'AUX-Anschluss' },
+      { key: 'assistants.blindSpotDetection', type: 'blind_spot_alert', value: 'Totwinkel-Assistent' },
+      { key: 'multimedia.bluetooth', type: 'bluetooth', value: 'Bluetooth' },
+      { key: 'assistants.collisionAvoidance', type: 'collision_avoidance', value: 'Notbrems Assistent' },
+      { key: 'assistants.cruiseControl', type: 'cruise_control', value: 'Tempomat' },
+      { key: 'lights.daytimeRunningLights', type: 'daytime_running_lights', value: 'Tagfahrlicht' },
+      { key: 'lights.daytimeRunningLightsLED', type: 'daytime_running_lights', value: 'Tagfahrlicht LED' },
+      { key: 'lights.frontFogLights', type: 'fog_lights', value: 'Nebelscheinwerfer' },
+      { key: 'wheel.heatedSteeringWheel', type: 'heated_steering_wheel', value: 'Lenkradheizung' },
+      { key: 'lights.xenonHeadlights', type: 'hid_headlights', value: 'Xenonscheinwerfer' },
+      { key: 'assistants.hillStartDrivingAssistant', type: 'hill_start_assist', value: 'Berganfahrhilfe' },
+      { key: 'doors.keylessEntry', type: 'keyless_entry', value: 'Keyless-Go' },
+      { key: 'doors.keylessEntry', type: 'keyless_start', value: 'Keyless-Go' },
+      { key: 'assistants.laneAssistant', type: 'lane_keep_assist', value: 'Spurhalte-Assistent' },
+      { key: 'lights.ledHeadlights', type: 'led_headlights', value: 'LED Scheinwerfer' },
+      { key: 'window.sunroof', type: 'moon_roof', value: 'Schiebedach' },
+      { key: 'multimedia.mp3Interface', type: 'mp3		MP3', value: 'Schnittstelle' },
+      { key: 'multimedia.navigationSystem', type: 'navigation', value: 'Navigationssystem' },
+      { key: 'assistants.nightVisionAssistant', type: 'night_view', value: 'Nachsicht Assistent' },
+      { key: 'window.panoramicGlassRoof', type: 'panorama_roof', value: 'Panoramaschiebedach' },
+      { key: 'doors.centralLocking', type: 'power_door_locks', value: 'Zentralverriegelung' },
+      { key: 'doors.electricTailGate', type: 'power_liftgate', value: 'elektrische Heckklappe' },
+      { key: 'assistants.powerAssistedSteering', type: 'power_steering', value: 'powerAssistedSteering' },
+      { key: 'window.electricWindows', type: 'power_windows', value: 'Elektrische Fenster' },
+      { key: 'extras.roofBars', type: 'roof_rack', value: 'Dachgepäckträger' },
+      { key: 'extras.roofRails', type: 'roof_rack', value: 'Dachreling' },
+      { key: 'assistants.esp', type: 'stability_control', value: 'ESP' },
+      { key: 'multimedia.onBoardComputer', type: 'telematics', value: 'Bordcomputer' },
+      { key: 'wheel.adjustableSteeringWheel', type: 'tilt_steering_wheel', value: 'höhenverst Lenkrad' },
+      { key: 'window.tintedWindowBack', type: 'tinted_windows', value: 'getönte Scheiben hinten' },
+      { key: 'assistants.tirePressureMonitor', type: 'tire_pressure_monitor', value: 'Reifendruckkontrolle' },
+      { key: 'trailerCoupling.trailerCouplingFix', type: 'tow_package', value: 'Anhängerkupplung  fest' },
+      { key: 'trailerCoupling.trailerCouplingRemovable', type: 'tow_package', value: 'Anhängerkupplung abnehmbar' },
+      { key: 'trailerCoupling.trailerCouplingRotatable', type: 'tow_package', value: 'Anhängerkupplung schwenkbar' },
+      { key: 'assistants.tractionControlSystem', type: 'traction_control', value: 'Traktionskontrolle' },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_unknown',
+        value: 'Unbekannt',
+      },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_climatisation_no_airCondition',
+        value: 'Keine Klimaanlage oder -automatik',
+      },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_climatisation_airCondition',
+        value: 'Klimaanlage oder -automatik',
+      },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_climatisation_automaticAirCondition',
+        value: 'Klimaautomatik',
+      },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_climatisation_2_automaticAirCondition',
+        value: '2-Zonen Klimaautomatik',
+      },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_climatisation_3_automaticAirCondition',
+        value: '3-Zonen Klimaautomatik',
+      },
+      {
+        key: 'heatingCooling.climatisation',
+        type: 'air_conditioning',
+        selector: 'selector_climatisation_4_automaticAirCondition',
+        value: '4-Zonen Klimaautomatik',
+      },
+      {
+        key: 'wheels.summerTiresRims',
+        type: 'alloy_wheels',
+        selector: 'selector_tiresRims_alloy',
+        value: 'Leichtmetallfelgen',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'backup_camera',
+        selector: 'selector_parkingAssistants_camera',
+        value: 'Rückfahrkamera',
+      },
+      {
+        key: 'seats.driverSeats',
+        type: 'heated_seats',
+        selector: 'selector_driverSeats_electricHeated',
+        value: 'Sitzheizung Fahrersitz',
+      },
+      {
+        key: 'seats.coDriverSeats',
+        type: 'heated_seats',
+        selector: 'selector_coDriverSeats_electricHeated',
+        value: 'Sitzheizung Beifahrersitz',
+      },
+      {
+        key: 'seats.backSeats',
+        type: 'heated_seats',
+        selector: 'selector_backSeats_electricHeated',
+        value: 'Sitzheizung Rücksitz',
+      },
+      {
+        key: 'interior.interiorType',
+        type: 'leather',
+        selector: 'selector_interiorType_fullLeather',
+        value: 'Vollleder',
+      },
+      {
+        key: 'interior.interiorType',
+        type: 'leather',
+        selector: 'selector_interiorType_partLeather',
+        value: 'Teilleder',
+      },
+      { key: 'assistants.parkingAssistants', type: 'park_assist', selector: 'selector_unknown', value: 'Unbekannt' },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'park_assist',
+        selector: 'selector_parkingAssistants_other',
+        value: 'Andere',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'park_assist',
+        selector: 'selector_parkingAssistants_front',
+        value: 'Vorderseite',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'park_assist',
+        selector: 'selector_parkingAssistants_rear',
+        value: 'Rückseite',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'park_assist',
+        selector: 'selector_parkingAssistants_camera',
+        value: 'Kamera',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'park_assist',
+        selector: 'selector_parkingAssistants_selfSteeringSystems',
+        value: 'Selbstlenkende Systeme',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'park_assist',
+        selector: 'selector_parkingAssistants_360Camera',
+        value: '360° Kamera',
+      },
+      {
+        key: 'seats.driverSeats',
+        type: 'power_seats',
+        selector: 'selector_driverSeats_electricAdjustable',
+        value: 'Fahrersitz elektr. einstellbar',
+      },
+      {
+        key: 'seats.coDriverSeats',
+        type: 'power_seats',
+        selector: 'selector_coDriverSeats_electricAdjustable',
+        value: 'Beifahrersitz elektr. einstellbar',
+      },
+      {
+        key: 'assistants.parkingAssistants',
+        type: 'surround_view_camera',
+        selector: 'selector_parkingAssistants_360Camera',
+        value: '360° Kamera',
+      },
+      {
+        key: 'seats.driverSeats',
+        type: 'ventilated_seats',
+        selector: 'selector_driverSeats_seatVentilationSystem',
+        value: 'Sitzbelüftung Fahrersitz',
+      },
+      {
+        key: 'seats.coDriverSeats',
+        type: 'ventilated_seats',
+        selector: 'selector_coDriverSeats_seatVentilationSystem',
+        value: 'Sitzbelüftung Beifahrersitz',
+      },
+      {
+        key: 'seats.backSeats',
+        type: 'ventilated_seats',
+        selector: 'selector_backSeats_seatVentilationSystem',
+        value: 'Sitzbelüftung Rücksitz',
+      },
+    ];
+    return facebookFeatures
+      .map(feature => {
+        const value = get(car, feature.key);
+        if (isBoolean(value)) {
+          return this.getBooleanValue(value, feature);
+        }
+        if (isString(value)) {
+          return this.getStringValue(value, feature);
+        }
+        if (isArray(value) && includes(value, feature.selector)) {
+          const index = findIndex(value, item => item === feature.selector);
+          return this.getStringValue(value[index], feature);
+        }
+        return null;
+      })
+      .filter(el => el);
+  }
+
+  private getBooleanValue(
+    value: boolean,
+    feature:
+      | { key: string; type: string; value: string; selector?: undefined }
+      | { key: string; type: string; selector: string; value: string },
+  ): { type: string; value: string } {
+    if (value) {
+      return {
+        type: feature.type,
+        value: feature.value,
+      };
+    }
+    return null;
+  }
+
+  private getStringValue(
+    selector: string,
+    feature:
+      | { key: string; type: string; value: string; selector?: undefined }
+      | { key: string; type: string; selector: string; value: string },
+  ): { type: string; value: string } {
+    if (selector === feature.selector) {
+      return {
+        type: feature.type,
+        value: feature.value,
+      };
+    }
+    return null;
+  }
+}
+
+function getFirstValidYear(...years: string[]): number {
+  return years.map((year: string) => toSafeInteger(year)).filter((year: number) => year > TIMESTAMP_FIRST_YEAR)[0];
+}