@bytebrand/export-cars 1.26.31 → 1.26.33

package/src/transformers/autouncle.transformer.ts

@@ -1,181 +1,259 @@
 import { TranslatorExtended } from '@bytebrand/schema-tools';
 import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
-import { get, toString, isEmpty, toSafeInteger } from 'lodash';
+import { get, toString, isEmpty, toNumber, 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, ImagesService } from '../services';
 import { Injectable } from '@nestjs/common';
-import { DEFAULT_ADDR1, DEFAULT_CITY, DEFAULT_ZIP, MIN_MILEAGES } from '../constants/autouncle.contants';
+import { DEFAULT_REGION, MIN_MILEAGES } from '../constants/autouncle.contants';
 import { AutouncleJsonItem } from '../interfaces';
-import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { OpenAiImageSelection } from './openai-image-fields';
+import { toUnixSeconds } from './meinstadt.transformer';
 
-@Injectable()
-export class AutouncleTransformer {
-  private translator: TranslatorExtended;
-  private postalCodesService: DePostalCodesService;
+export enum AutouncleExclusion {
+  duplicateId = 'duplicate_id',
+  filtered = 'filtered',
+  noId = 'no_id',
+  noDealer = 'no_dealer',
+  notAvailable = 'reserved_or_sold',
+  noPrice = 'no_valid_price',
+  noImage = 'no_valid_image',
+}
 
-  constructor(private configService: ConfigService, private imageService: ImagesService) {
-    const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
-    this.translator = new TranslatorExtended(dict);
-    this.postalCodesService = DePostalCodesService.getInstance();
+// Online cars flagged like this are not sellable stock; the partner gets the file without them.
+const NOT_AVAILABLE = ['selector_offerAvailability_reserved', 'selector_offerAvailability_sold'];
+
+export interface AutouncleAddress {
+  city: string;
+  addr1: string;
+  region: string;
+  postal_code: string;
+}
+
+export interface AutouncleMappingContext {
+  domain: string;
+  address: AutouncleAddress;
+  // final, validated image URLs, hero first
+  images: string[];
+  // German label of a selector (TranslatorExtended.translateVal)
+  translate: (key: string) => string;
+}
+
+export type AutouncleMapResult = { ok: true; item: AutouncleJsonItem } | { ok: false; reason: AutouncleExclusion };
+
+/**
+ * The AutoUncle `images` list (ADV-323) from the shared validated clean selection (ADV-336, same
+ * rules as the OpenAI and meinestadt feeds): valid 3/4 hero first, then every other valid image in
+ * clean-profile order. No valid hero => [] (car is skipped, never a placeholder). maxImages > 0
+ * cuts the list — no partner limit is known, so the default is no cut.
+ */
+export const toAutouncleImages = (selection: OpenAiImageSelection, maxImages = 0): string[] => {
+  if (!selection?.fields) {
+    return [];
   }
+  const urls = [selection.fields.image_url, ...selection.fields.additional_image_urls];
+  return maxImages > 0 ? urls.slice(0, maxImages) : urls;
+};
 
-  async transform({
-    car,
-    images,
-    owner,
-  }: {
-    car: DataSchemes.Car;
-    images: ImboImageResponseInterface[];
-    metadata?: unknown;
-    owner: unknown;
-  }): Promise<AutouncleJsonItem> {
-    const autodeId = toString(get(car, '_id', ''));
-    const address = await this.getAddress(car, owner);
-    const image_urls = await this.imageService.getImages(car, images, this.configService.config.imageType, false);
-    const transformed_images = image_urls.map(url => {
-      return { url };
-    });
-    return {
-      back_link: `https://www.${this.configService.config.domain}/search/vehicle/${autodeId}?source=classifieds&medium=cpc&campaign=autouncle`,
+/**
+ * Year of the first registration. Missing, 0, null or unparsable => '' (unknown), never the Unix
+ * epoch year 1970 (ACF-3717/3725: `get(car, path, 0)` returned null for a null value and
+ * moment(0) made it 1970). A year outside 1900..next year is a unit error (ms instead of s) => ''.
+ */
+export const getAutouncleYear = (firstRegistration: unknown, now: Date = new Date()): string => {
+  const seconds = toUnixSeconds(firstRegistration);
+  if (seconds === null) {
+    return '';
+  }
+  const year = toSafeInteger(moment(seconds * 1000).format('YYYY'));
+  return year >= 1900 && year <= now.getFullYear() + 1 ? toString(year) : '';
+};
+
+// Unchanged rule: a car without a first registration is new.
+export const getAutouncleStatus = (firstRegistration: unknown): 'Neuwagen' | 'Gebrauchtwagen' =>
+  toUnixSeconds(firstRegistration) === null ? 'Neuwagen' : 'Gebrauchtwagen';
+
+/**
+ * End-customer purchase price, `EUR <amount>` as the feed always had it. Only price.currentSalesPrice —
+ * never a monthly financing/leasing rate, never price.purchasePrice (dealer cost). null = no valid
+ * positive price; the car is not exported (it was sent as "EUR " before).
+ */
+export const getAutounclePrice = (value: unknown): string | null => {
+  if (value === null || value === undefined || value === '' || typeof value === 'boolean') {
+    return null;
+  }
+  const amount = toNumber(value);
+  return Number.isFinite(amount) && amount > 0 ? `EUR ${value}` : null;
+};
+
+const withUnit = (value: unknown, unit: string): string => {
+  const text = toString(value).trim();
+  return text ? `${text}${unit}` : '';
+};
+
+const BODY_STYLES = {
+  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 FUELS = {
+  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 TRANSMISSIONS = {
+  selector_gearbox_manualShift: 'manual',
+  selector_gearbox_semiAutomatic: 'automatic',
+  selector_gearbox_automatic: 'automatic',
+  selector_unknown: 'other',
+};
+
+// Unmapped, null or missing selector -> the map's selector_unknown value; the key never drops out
+// of the JSON (JSON.stringify omits undefined).
+const fromSelector = (map: Record<string, string>, selector: unknown): string =>
+  (typeof selector === 'string' && map[selector]) || map.selector_unknown;
+
+const getMileage = (car: DataSchemes.Car): number => {
+  const mileage = get(car, 'mainData.mileage', 0);
+  return mileage <= MIN_MILEAGES ? MIN_MILEAGES + 1 : mileage;
+};
+
+const getExteriorColor = (car: DataSchemes.Car, translate: (key: string) => string): string => {
+  let colorSelection = get(car, 'exterior.exteriorColor', 'other');
+  if (!colorSelection || colorSelection === 'selector_unknown') {
+    colorSelection = 'other';
+  }
+  return translate(colorSelection);
+};
+
+// Car-level exclusions that need no dealer lookup and no image probe; null = exportable.
+export const getAutouncleExclusion = (car: DataSchemes.Car): AutouncleExclusion | null => {
+  if (!toString(get(car, '_id', '')).trim()) {
+    return AutouncleExclusion.noId;
+  }
+  if (!toString(get(car, 'metaData.ownerId', '')).trim()) {
+    return AutouncleExclusion.noDealer;
+  }
+  if (NOT_AVAILABLE.includes(toString(get(car, 'offer.offerAvailability', '')))) {
+    return AutouncleExclusion.notAvailable;
+  }
+  if (!getAutounclePrice(get(car, 'price.currentSalesPrice', null))) {
+    return AutouncleExclusion.noPrice;
+  }
+  return null;
+};
+
+/**
+ * One `ads[]` object. Keys, their order and the historic spellings (co2_effiency_class,
+ * enviromental_sticker) are kept until AutoUncle confirms a current schema.
+ * Identity: back_link carries the stable CBD car `_id`; seller_id is the DEALER (metaData.ownerId),
+ * the same for every car of one dealer.
+ */
+export const mapAutouncleItem = (car: DataSchemes.Car, ctx: AutouncleMappingContext): AutouncleMapResult => {
+  const excluded = getAutouncleExclusion(car);
+  if (excluded) {
+    return { ok: false, reason: excluded };
+  }
+  if (!ctx.images.length) {
+    return { ok: false, reason: AutouncleExclusion.noImage };
+  }
+  const autodeId = toString(get(car, '_id', '')).trim();
+  const sellerId = toString(get(car, 'metaData.ownerId', '')).trim();
+  const price = getAutounclePrice(get(car, 'price.currentSalesPrice', null));
+  const firstRegistration = get(car, 'mainData.firstRegistration', null);
+
+  return {
+    ok: true,
+    item: {
+      back_link: `https://www.${ctx.domain}/search/vehicle/${autodeId}?source=classifieds&medium=cpc&campaign=autouncle`,
       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),
+      fuel: fromSelector(FUELS, get(car, 'consumption.fuel', null)),
+      body: fromSelector(BODY_STYLES, get(car, 'mainData.category', null)),
       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',
+      price,
+      year: getAutouncleYear(firstRegistration),
+      status: getAutouncleStatus(firstRegistration),
+      mileage: toString(getMileage(car)) + 'km',
+      leasing: '',
+      color: getExteriorColor(car, ctx.translate),
+      // no unit without a value (was "ccm")
+      engine_size: withUnit(get(car, 'engineData.cubicCapacity', ''), 'ccm'),
       power: toString(get(car, 'engineData.powerKW', '')),
-      gear_type: this.mapTransmission(car),
-      has_4wd: this.has4WD(),
+      gear_type: fromSelector(TRANSMISSIONS, get(car, 'driveSuspension.gearbox', null)),
+      has_4wd: '',
       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_region: ctx.address.region,
+      seller_city: ctx.address.city,
+      seller_street_address: ctx.address.addr1,
+      seller_postcode: ctx.address.postal_code,
       seller_name: 'auto.de',
-      seller_id: toString(get(car, 'metaData.ownerId', '')),
+      seller_id: sellerId,
       description: toString(get(car, 'offer.offerDescription', '')),
-      images: transformed_images,
+      images: ctx.images.map(url => ({ url })),
       fuel_economy: toString(get(car, 'consumption.consumptionCombined', '')),
       co2_emission: toString(get(car, 'environmentEmissions.co2', '')),
       // ADV-187: canonical CO2-derived WLTP class, not the unvalidated legacy NEFZ class.
       co2_effiency_class: toString(get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', '')),
       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';
-  }
+@Injectable()
+export class AutouncleTransformer {
+  private translator: TranslatorExtended;
+  private postalCodesService: DePostalCodesService;
 
-  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 '';
+  constructor() {
+    const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
+    this.translator = new TranslatorExtended(dict);
+    this.postalCodesService = DePostalCodesService.getInstance();
   }
 
-  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);
+  translate(key: string): string {
+    return this.translator.translateVal(key);
   }
 
-  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;
-  }> {
+  /**
+   * Dealer address from the UPA profile (businessAddress, else mainAddress). The postal code table
+   * only adds the region; when it does not know the place the dealer's own street/city/zip stay
+   * (they were blanked before) and the region is "Deutschland".
+   */
+  async getAddress(owner: unknown): Promise<AutouncleAddress> {
     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 city = toString(get(owner, `${addressPath}.city`, ''));
+    const zip = toString(get(owner, `${addressPath}.zip`, ''));
+    const addr1 = toString(get(owner, `${addressPath}.street`, ''));
+    const location = 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',
+      region: this.isEmptyLocation(location) ? DEFAULT_REGION : toString(location['Place Name']),
       postal_code: zip,
     };
   }
@@ -190,48 +268,12 @@ export class AutouncleTransformer {
     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);
+    let entry: DePostalCodesEntryInterface = info.zip ? await this.postalCodesService.getLocationByPostalCode(info.zip) : undefined;
 
-    if (!entry) {
+    if (!entry && info.city) {
       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 '';
-  }
 }

package/src/transformers/meinstadt.transformer.ts

@@ -3,90 +3,136 @@ import { get, toString } from 'lodash';
 import { Injectable } from '@nestjs/common';
 
 import { CarDescriptionFactory, DescriptionTypeEnum } from '@bytebrand/car-description';
-import { ImboImageResponseInterface } from '@bytebrand/chunkable';
 import { DataSchemes } from '@bytebrand/car-schema';
 import { de } from '@bytebrand/i18n-dictionaries';
 
-import { ConfigService, ImagesService, UserService } from '../services';
+import { UserService } from '../services';
 import { MeinstadtJsonItem } from '../interfaces';
+import { OpenAiImageSelection } from './openai-image-fields';
 
-@Injectable()
-export class MeinstadtTransformer {
-  constructor(
-    private configService: ConfigService, 
-    private readonly imageService: ImagesService,
-    private userService: UserService
-  ) {}
-
-  async transform({
-    car,
-    images,
-  }: {
-    car: DataSchemes.Car;
-    images: ImboImageResponseInterface[];
-  }): Promise<Partial<MeinstadtJsonItem>> {
-    const carImages = await this.imageService.getImages(car, images, this.configService.config.imageType, false);
+/**
+ * The meinestadt `images` list from the shared validated clean selection (ADV-336, same rules as
+ * the OpenAI feed): valid 3/4 hero first, then every other valid image in clean-profile order.
+ * No valid hero => [] (car is skipped). maxImages > 0 cuts the exported list only; the gallery
+ * itself is untouched. Another image profile (e.g. the planned marketing designs) plugs in by
+ * producing a different selection — imagesCount always follows the list exported here.
+ */
+export const toMeinstadtImages = (selection: OpenAiImageSelection, maxImages = 0): string[] => {
+  if (!selection?.fields) {
+    return [];
+  }
+  const urls = [selection.fields.image_url, ...selection.fields.additional_image_urls];
+  return maxImages > 0 ? urls.slice(0, maxImages) : urls;
+};
 
-    const carId = toString(get(car, '_id', null));
+export interface MeinstadtMappingContext {
+  domain: string;
+  // validated tariff (parseMeinstadtCpc) or null
+  cpc: string | null;
+  equipment: string;
+  // final, validated image URLs — imagesCount is derived from exactly this list
+  images: string[];
+  translate?: (key: string) => string | undefined;
+}
 
-    return {
-      id: get(car, 'metaData.vehicleId', null),
-      make: get(car, 'mainData.make', null),
-      model: get(car, 'mainData.model', null),
-      cpc: get(this.configService.config, 'cpc', '0.08'),
-      listingUrl: `https://www.${this.configService.config.domain}/search/vehicle/${carId}?source=classifieds&medium=listing&campaign=meinestadt`,
-      title: this.getTitle(car),
-      accidentFree: get(car, 'mainData.accidentDamaged', null),
-      mileage: get(car, 'mainData.mileage', null),
-      initialRegistration: get(car, 'mainData.firstRegistration', null),
-      offerCreationDate: get(car, 'metaData.creationDate', null),
-      numberOfDoors: get(car, 'mainData.doors', null),
-      numberOfSeats: get(car, 'mainData.seats', null),
-      numberOfPreviousOwners: get(car, 'mainData.numberOfPreviousOwners', null),
-      price: get(car, 'price.currentSalesPrice', null),
-      power: get(car, 'engineData.powerPS', null),
-      co2Emissions: get(car, 'environmentEmissions.co2', null),
-      fuelConsumptionCombined: get(car, 'consumption.consumptionCombined', null),
-      equipment: await this.getDescription(car),
-      color: this.translate(get(car, 'exterior.exteriorColor', null)),
-      bodyType: this.translate(get(car, 'mainData.category', null)),
-      emissionClass: this.translate(get(car, 'environmentEmissions.emissionClass', null)),
-      emissionSticker: this.translate(get(car, 'environmentEmissions.emissionSticker', null)),
-      fuelType: this.translate(get(car, 'consumption.fuel', null)),
-      'transmissionType/transmission': this.translate(get(car, 'driveSuspension.gearbox', null)),
-      imagesCount: carImages.length,
-      'customerType/sellerType': 'Händler',
-      usageState: this.translate(this.getUsageState(car)),
-      images: carImages[0],
-    };
+/**
+ * mainData.accidentDamaged is a DAMAGE flag ("Unfallschaden"), accidentFree its negation.
+ * Only an explicit `false` makes a car accident-free; missing/null (no damage history) stays
+ * unknown and is sent as null, never as accident-free.
+ */
+export const toAccidentFree = (accidentDamaged: unknown): boolean | null => {
+  if (accidentDamaged === false) {
+    return true;
   }
-
-  private getTitle(car: DataSchemes.Car): string {
-    return `${car.mainData.make} ${car.mainData.model} ${car.mainData.subModel}`;
+  if (accidentDamaged === true) {
+    return false;
   }
+  return null;
+};
 
-  private translate(val: string | null): string {
-    if (!val) return null;
-    if (de[val]) return de[val];
+/**
+ * CBD dates (firstRegistration, creationDate) as Unix seconds, the format the feed always had.
+ * Date objects / date strings are converted; 0, negative, unparsable or missing values are null —
+ * never a Unix-zero (1970) date.
+ */
+export const toUnixSeconds = (value: unknown): number | null => {
+  let seconds: number;
+  if (typeof value === 'number') {
+    seconds = value;
+  } else if (value instanceof Date) {
+    seconds = value.getTime() / 1000;
+  } else if (typeof value === 'string' && value.trim()) {
+    seconds = Date.parse(value) / 1000;
+  } else {
     return null;
   }
+  return Number.isFinite(seconds) && seconds > 0 ? Math.floor(seconds) : null;
+};
 
-  private getUsageState(car: DataSchemes.Car): string {
-    const condition = get(car, 'mainData.condition', null);
-    if (!condition || condition === 'selector_unknown') {
-      const mileage = get(car, 'mainData.mileage', 0);
-      if (mileage >= 100) {
-        return 'selector_condition_used';
-      }
-      return 'selector_condition_new';
+// German label of a selector; unknown/unmapped selectors are null, not "Unbekannt".
+export const translateSelector = (val: string | null, translate: (key: string) => string | undefined = key => de[key]): string | null => {
+  if (!val || val === 'selector_unknown') return null;
+  return translate(val) || null;
+};
+
+export const getUsageState = (car: DataSchemes.Car): string => {
+  const condition = get(car, 'mainData.condition', null);
+  if (!condition || condition === 'selector_unknown') {
+    const mileage = get(car, 'mainData.mileage', 0);
+    if (mileage >= 100) {
+      return 'selector_condition_used';
     }
-    return condition;
+    return 'selector_condition_new';
   }
+  return condition;
+};
+
+export const mapMeinstadtItem = (car: DataSchemes.Car, ctx: MeinstadtMappingContext): MeinstadtJsonItem => {
+  const carId = toString(get(car, '_id', null));
+  const translate = (val: string | null) => translateSelector(val, ctx.translate);
+
+  return {
+    id: get(car, 'metaData.vehicleId', null),
+    make: get(car, 'mainData.make', null),
+    model: get(car, 'mainData.model', null),
+    cpc: ctx.cpc,
+    listingUrl: `https://www.${ctx.domain}/search/vehicle/${carId}?source=classifieds&medium=listing&campaign=meinestadt`,
+    title: `${car.mainData.make} ${car.mainData.model} ${car.mainData.subModel}`,
+    accidentFree: toAccidentFree(get(car, 'mainData.accidentDamaged', null)),
+    mileage: get(car, 'mainData.mileage', null),
+    initialRegistration: toUnixSeconds(get(car, 'mainData.firstRegistration', null)),
+    offerCreationDate: toUnixSeconds(get(car, 'metaData.creationDate', null)),
+    numberOfDoors: get(car, 'mainData.doors', null),
+    numberOfSeats: get(car, 'mainData.seats', null),
+    numberOfPreviousOwners: get(car, 'mainData.numberOfPreviousOwners', null),
+    // end-customer purchase price (EUR) — never a rate, never price.purchasePrice (dealer cost)
+    price: get(car, 'price.currentSalesPrice', null),
+    // PS, not kW (workbook: "only put the value for PS")
+    power: get(car, 'engineData.powerPS', null),
+    co2Emissions: get(car, 'environmentEmissions.co2', null),
+    fuelConsumptionCombined: get(car, 'consumption.consumptionCombined', null),
+    equipment: ctx.equipment,
+    color: translate(get(car, 'exterior.exteriorColor', null)),
+    bodyType: translate(get(car, 'mainData.category', null)),
+    emissionClass: translate(get(car, 'environmentEmissions.emissionClass', null)),
+    emissionSticker: translate(get(car, 'environmentEmissions.emissionSticker', null)),
+    fuelType: translate(get(car, 'consumption.fuel', null)),
+    'transmissionType/transmission': translate(get(car, 'driveSuspension.gearbox', null)),
+    imagesCount: ctx.images.length,
+    'customerType/sellerType': 'Händler',
+    usageState: translate(getUsageState(car)),
+    images: [...ctx.images],
+  };
+};
+
+@Injectable()
+export class MeinstadtTransformer {
+  constructor(private userService: UserService) {}
 
-  private async getDescription(car: DataSchemes.Car): Promise<string> {
+  async getDescription(car: DataSchemes.Car): Promise<string> {
     const dealerId = get(car, 'metaData.ownerId');
-        const descriptionSchema = await this.userService.getDefaultSummaryByDealerId(dealerId);
-        const descriptionBuilder = CarDescriptionFactory.create(DescriptionTypeEnum.Mobile, car);
-        return descriptionBuilder.transform(descriptionSchema);
+    const descriptionSchema = await this.userService.getDefaultSummaryByDealerId(dealerId);
+    const descriptionBuilder = CarDescriptionFactory.create(DescriptionTypeEnum.Mobile, car);
+    return descriptionBuilder.transform(descriptionSchema);
   }
 }