@bytebrand/export-cars 1.26.44 → 1.26.46

package/src/services/marktde-feed-run.ts

@@ -0,0 +1,233 @@
+import { promises as fs } from 'fs';
+import { dirname, join } from 'path';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { DataSchemes } from '@bytebrand/car-schema';
+
+import { convertToCSV } from '../utils/converter.utils';
+import { MarktdeExclusion, applyMarktdeColumns, getMarktdeExclusion } from '../transformers/marktde.transformer';
+import { FeedGuard, FeedGuardError, LastGood, inspectSourceSnapshot } from './feed-guard';
+
+export interface MarktdeSourceCar {
+  car: DataSchemes.Car;
+  images: ImboImageResponseInterface[];
+}
+
+// Everything the run needs from the outside world — the Nest exporter wires the real services,
+// tests pass fakes.
+export interface MarktdeRunDeps {
+  // iterates the base export snapshot chunk by chunk (LoaderService.process)
+  forEachChunk: (fn: (cars: MarktdeSourceCar[]) => Promise<void>) => Promise<unknown>;
+  // existing shared partner filter (images count, Cronicle rules incl. the dealer filter)
+  filterCar: (source: MarktdeSourceCar) => boolean;
+  // final validated image URLs for the car, hero first; [] = no usable image
+  resolveImages: (source: MarktdeSourceCar) => Promise<string[]>;
+  // the legacy mobile.de-style row (MobileTransformer + mapping sheet), keyed by column index
+  legacyRow: (source: MarktdeSourceCar) => Promise<Record<string, unknown>>;
+  imageStats: () => Record<string, number>;
+  // packs csvFile into zipFile (entry name = basename of csvFile)
+  zip: (csvFile: string, zipFile: string) => Promise<void>;
+  guard: FeedGuard;
+}
+
+export interface MarktdeRunOptions {
+  runId?: string;
+  dryRun: boolean;
+  domain: string;
+  sourceDirectory: string;
+  sourceBaseFileName: string;
+  csvFile: string;
+  zipFile: string;
+  stateDir: string;
+  now?: () => Date;
+}
+
+export interface MarktdeRunReport {
+  runId?: string;
+  mode: 'dry-run' | 'live';
+  startedAt: string;
+  finishedAt?: string;
+  status: 'published' | 'blocked' | 'failed';
+  guard?: { code: string; message: string };
+  error?: string;
+  csvFile: string;
+  zipFile: string;
+  source: { files: number; newestChunkAt: string | null; cars: number };
+  items: number;
+  dealers: number;
+  excluded: Record<string, number>;
+  vin: Record<string, number>;
+  vat: { deductible: number; notDeductible: number; rateDefaulted: number };
+  envkv: { fuelEmpty: number; co2Empty: number };
+  description: { items: number; sanitized: number; removed: { url: number; email: number; phone: number; address: number } };
+  imagesPerItem: { min: number | null; max: number | null; total: number };
+  images: Record<string, number>;
+  lastGood: LastGood | null;
+  lastGoodAgeHours: number | null;
+  stale: boolean;
+}
+
+const increment = (counter: Record<string, number>, key: string) => {
+  counter[key] = (counter[key] ?? 0) + 1;
+};
+
+/**
+ * One markt.de feed run (ADV-328): source check -> legacy row + markt.de columns + validated images ->
+ * temp CSV -> count check -> atomic publish of the CSV -> ZIP of the published CSV -> report.
+ * Replaces the old MobileExporter flow for markt.de, which emptied the output directory first (an
+ * outage published an empty or partial file) and needed the `zip` binary the DEV host lacks.
+ * Nothing outside the output directory and `stateDir` is written; a blocked run leaves the last good
+ * CSV/ZIP in place.
+ */
+export class MarktdeFeedRun {
+  constructor(private readonly deps: MarktdeRunDeps, private readonly options: MarktdeRunOptions) { }
+
+  private now(): Date {
+    return this.options.now ? this.options.now() : new Date();
+  }
+
+  async run(): Promise<MarktdeRunReport> {
+    const { guard } = this.deps;
+    const { csvFile, zipFile, runId, dryRun } = this.options;
+    const startedAt = this.now();
+    const lastGood = await guard.readLastGood();
+    const report: MarktdeRunReport = {
+      runId,
+      mode: dryRun ? 'dry-run' : 'live',
+      startedAt: startedAt.toISOString(),
+      status: 'failed',
+      csvFile,
+      zipFile,
+      source: { files: 0, newestChunkAt: null, cars: 0 },
+      items: 0,
+      dealers: 0,
+      excluded: {},
+      vin: {},
+      vat: { deductible: 0, notDeductible: 0, rateDefaulted: 0 },
+      envkv: { fuelEmpty: 0, co2Empty: 0 },
+      description: { items: 0, sanitized: 0, removed: { url: 0, email: 0, phone: 0, address: 0 } },
+      imagesPerItem: { min: null, max: null, total: 0 },
+      images: {},
+      lastGood,
+      lastGoodAgeHours: guard.staleHours(lastGood, startedAt),
+      stale: guard.isStale(lastGood, startedAt),
+    };
+
+    await guard.acquireLock(runId ?? 'local', startedAt);
+    const tmpFile = `${csvFile}.tmp`;
+    try {
+      const snapshot = await inspectSourceSnapshot(this.options.sourceDirectory, this.options.sourceBaseFileName);
+      report.source.files = snapshot.files;
+      report.source.newestChunkAt = snapshot.newestMtime?.toISOString() ?? null;
+      guard.checkSource(snapshot, startedAt);
+
+      await fs.mkdir(dirname(csvFile), { recursive: true });
+      await fs.rm(tmpFile, { force: true });
+      const out = await fs.open(tmpFile, 'w');
+      const seen = new Set<string>();
+      const dealers = new Set<string>();
+      try {
+        await this.deps.forEachChunk(async (cars) => {
+          for (const source of cars) {
+            report.source.cars += 1;
+            const id = String(source?.car?._id ?? '');
+            if (id && seen.has(id)) {
+              increment(report.excluded, MarktdeExclusion.duplicateId);
+              continue;
+            }
+            seen.add(id);
+            if (!this.deps.filterCar(source)) {
+              increment(report.excluded, MarktdeExclusion.filtered);
+              continue;
+            }
+            // cheap checks first: no image probe for a car that is excluded anyway
+            const excluded = getMarktdeExclusion(source.car);
+            if (excluded) {
+              increment(report.excluded, excluded);
+              continue;
+            }
+            const images = await this.deps.resolveImages(source);
+            if (!images.length) {
+              increment(report.excluded, MarktdeExclusion.noImage);
+              continue;
+            }
+            const row = await this.deps.legacyRow(source);
+            const facts = applyMarktdeColumns(row, source.car, { domain: this.options.domain, images });
+            await out.write(`${convertToCSV(row)}\n`, null, 'utf8');
+            dealers.add(String(source.car?.metaData?.ownerId ?? ''));
+            this.count(report, images.length, facts);
+          }
+        });
+      } finally {
+        await out.close();
+      }
+      report.dealers = dealers.size;
+      report.images = this.deps.imageStats();
+
+      const counts = { sourceItems: report.source.cars, publishedItems: report.items };
+      guard.checkCounts(counts, lastGood);
+
+      report.lastGood = await guard.publish(tmpFile, csvFile, counts, this.now(), runId);
+      const zipTmp = zipFile.replace(/\.zip$/, '.tmp.zip');
+      await fs.rm(zipTmp, { force: true });
+      await this.deps.zip(csvFile, zipTmp);
+      await fs.rename(zipTmp, zipFile);
+      report.status = 'published';
+      report.lastGoodAgeHours = 0;
+      report.stale = false;
+      return report;
+    } catch (error) {
+      if (error instanceof FeedGuardError) {
+        report.status = 'blocked';
+        report.guard = { code: error.code, message: error.message };
+      } else {
+        report.error = error?.message ?? String(error);
+      }
+      // keep the rejected file for inspection; the published files stay untouched
+      await fs.rename(tmpFile, `${csvFile}.rejected`).catch(() => undefined);
+      throw error;
+    } finally {
+      await this.writeReport(report);
+      await guard.releaseLock();
+    }
+  }
+
+  private count(report: MarktdeRunReport, images: number, facts: ReturnType<typeof applyMarktdeColumns>): void {
+    report.items += 1;
+    increment(report.vin, facts.vin);
+    if (facts.price.deductible) {
+      report.vat.deductible += 1;
+    } else {
+      report.vat.notDeductible += 1;
+    }
+    if (facts.price.rateDefaulted) {
+      report.vat.rateDefaulted += 1;
+    }
+    if (facts.fuelEmpty) {
+      report.envkv.fuelEmpty += 1;
+    }
+    if (facts.co2Empty) {
+      report.envkv.co2Empty += 1;
+    }
+    if (facts.descriptionRemovals) {
+      report.description.items += 1;
+      const r = facts.descriptionRemovals;
+      if (r.url + r.email + r.phone + r.address > 0) {
+        report.description.sanitized += 1;
+      }
+      for (const key of Object.keys(r) as Array<keyof typeof r>) {
+        report.description.removed[key] += r[key];
+      }
+    }
+    const stats = report.imagesPerItem;
+    stats.min = stats.min === null ? images : Math.min(stats.min, images);
+    stats.max = stats.max === null ? images : Math.max(stats.max, images);
+    stats.total += images;
+  }
+
+  private async writeReport(report: MarktdeRunReport): Promise<void> {
+    report.finishedAt = this.now().toISOString();
+    await fs.mkdir(this.options.stateDir, { recursive: true });
+    await fs.writeFile(join(this.options.stateDir, 'last-run-report.json'), JSON.stringify(report, null, 2), 'utf8');
+    console.log(`marktde feed report: ${JSON.stringify(report)}`);
+  }
+}

package/src/transformers/marktde.transformer.ts

@@ -0,0 +1,255 @@
+import { get, toNumber, toString } from 'lodash';
+import { DataSchemes } from '@bytebrand/car-schema';
+
+import { OpenAiImageSelection } from './openai-image-fields';
+import { envkvCo2Value, envkvFuelConsumptionValue } from './google-feed-envkv';
+
+/**
+ * markt.de feed (ADV-328) on top of the legacy mobile.de-style CSV row that MobileTransformer builds
+ * from the `mobile_yescar` mapping sheet (ACF-4370). Only the columns below are replaced; every other
+ * column, the column order and the row format stay as they were. Pure functions, no I/O.
+ *
+ * Column indexes are 0-based (the sheet's importField): 1 = B, 10 = K, ... 402 = OM.
+ */
+export const MARKTDE_COLUMNS = {
+  vehicleId: '1', // B  stable auto.de vehicle id (metaData.vehicleId)
+  price: '10', // K  price (net for VAT-deductible cars, see getMarktdePriceColumns)
+  vatFlag: '11', // L  0 = VAT is added on top of K, 1 = no VAT shown separately
+  vin: '14', // O  VIN (optional)
+  description: '25', // Z  description (mobile.de markup)
+  images: '26', // AA image URLs, `;` separated
+  vatRate: '29', // AD VAT rate
+  fuelCombined: '98', // CU combined fuel consumption, decimal comma
+  co2: '99', // CV CO2 g/km
+  listingUrl: '402', // OM clickout link to the auto.de vehicle page
+} as const;
+
+// Clickout parameters (ADV-330, same scheme as AutoUncle ADV-324 / meinestadt ADV-327): the partner in
+// `source`, so the reporting views, the CRM source and GA4 (utm_*) all see "marktde". Legacy and utm
+// pairs carry identical values; paid / free is a contract attribute and is not encoded in the medium.
+// Pending markt.de's OK that a structured clickout field is allowed at all.
+export const MARKTDE_LINK_PARAMS =
+  'source=marktde&medium=listing&campaign=listing&utm_source=marktde&utm_medium=listing&utm_campaign=listing';
+
+export const getMarktdeListingUrl = (domain: string, carId: string): string =>
+  `https://www.${domain}/search/vehicle/${carId}?${MARKTDE_LINK_PARAMS}`;
+
+export enum MarktdeExclusion {
+  duplicateId = 'duplicate_id',
+  filtered = 'filtered',
+  noId = 'no_id',
+  noVehicleId = 'no_vehicle_id',
+  notAvailable = 'reserved_or_sold',
+  noPrice = 'no_valid_price',
+  noImage = 'no_valid_image',
+}
+
+// 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'];
+
+const positiveAmount = (value: unknown): number | null => {
+  if (value === null || value === undefined || value === '' || typeof value === 'boolean') {
+    return null;
+  }
+  const amount = toNumber(value);
+  return Number.isFinite(amount) && amount > 0 ? amount : null;
+};
+
+// Cheap checks before any image probe. null = the car can be exported.
+export const getMarktdeExclusion = (car: DataSchemes.Car): MarktdeExclusion | null => {
+  if (!toString(get(car, '_id', '')).trim()) {
+    return MarktdeExclusion.noId;
+  }
+  if (!toString(get(car, 'metaData.vehicleId', '')).trim()) {
+    return MarktdeExclusion.noVehicleId;
+  }
+  if (NOT_AVAILABLE.includes(toString(get(car, 'offer.offerAvailability', '')))) {
+    return MarktdeExclusion.notAvailable;
+  }
+  if (positiveAmount(get(car, 'price.currentSalesPrice', null)) === null) {
+    return MarktdeExclusion.noPrice;
+  }
+  return null;
+};
+
+// ISO 3779: 17 characters, digits and capital letters without I, O, Q.
+const VIN_PATTERN = /^[A-HJ-NPR-Z0-9]{17}$/;
+
+/**
+ * The car's own VIN when it is a well-formed 17-character VIN, otherwise empty. The legacy exporter
+ * sent marketing.fakeVIN or a random generated VIN for markt.de when the VIN was missing — never again.
+ */
+export const getMarktdeVin = (car: DataSchemes.Car): string => {
+  const vin = toString(get(car, 'metaData.vin', '')).trim().toUpperCase();
+  return VIN_PATTERN.test(vin) ? vin : '';
+};
+
+export interface MarktdePriceColumns {
+  price: string;
+  vatFlag: string;
+  vatRate: string;
+  deductible: boolean;
+  // vatRate was missing / 0 on a VAT-deductible car and 19 was used
+  rateDefaulted: boolean;
+}
+
+/**
+ * K / L / AD with the semantics of the legacy feed (ACF-4370): price.currentSalesPrice is the gross
+ * consumer price. VAT-deductible car: K = net, L = 0, AD = rate, so gross = K * (1 + AD/100) again.
+ * Otherwise (margin scheme / private / exempt): K = the gross price as it is, L = 1, AD = 0 — no VAT
+ * is ever added on top of an already gross price. Unlike the legacy code the net price and AD always
+ * use the same rate (legacy: a null vatRate left K gross while AD said 19, i.e. +19 % on display).
+ */
+export const getMarktdePriceColumns = (car: DataSchemes.Car): MarktdePriceColumns | null => {
+  const raw = get(car, 'price.currentSalesPrice', null);
+  const gross = positiveAmount(raw);
+  if (gross === null) {
+    return null;
+  }
+  const deductible = Boolean(get(car, 'price.vatDeductible', false));
+  if (!deductible) {
+    return { price: String(raw), vatFlag: '1', vatRate: '0', deductible, rateDefaulted: false };
+  }
+  const storedRate = positiveAmount(get(car, 'price.vatRate', null));
+  const rate = storedRate ?? 19;
+  const net = (gross * 100) / (100 + rate);
+  return { price: net.toFixed(2), vatFlag: '0', vatRate: String(rate), deductible, rateDefaulted: storedRate === null };
+};
+
+/**
+ * The markt.de image list from the shared validated clean selection (ADV-336, same rules as the
+ * OpenAI / meinestadt / AutoUncle feeds): valid 3/4 hero first, then every other valid image. Real
+ * photos only — no marketing overlays, no placeholders. No valid hero => [] (car is skipped).
+ */
+export const toMarktdeImages = (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;
+};
+
+export interface DescriptionRemovals {
+  url: number;
+  email: number;
+  phone: number;
+  address: number;
+}
+
+// mobile.de description markup: `\\` is a line break, `**…**` bold. Removed tokens never eat it.
+const URL_PATTERN = /\b(?:https?:\/\/|www\.)[^\s\\"'<>]+/gi;
+const EMAIL_PATTERN = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
+// Bare domains of other websites ("autohaus-muster.de"). Not the seller's own name: auto.de is the
+// brand and the legal entity (auto.de GmbH, the commercial identification the terms require), so
+// "auto.de", "Auto.de", "auto.de-ID" stay; only a link to it (scheme / www.) goes.
+const DOMAIN_PATTERN = /(?<![\w.-])(?!auto\.de\b)[a-z0-9][a-z0-9-]*(?:\.[a-z0-9-]+)*\.(?:de|com|net|org|eu|info|at|ch|biz|shop|online)\b(?:\/[^\s\\"'<>]*)?/gi;
+// Phone candidates: start with +, 00, 0 or (0, then digits and the usual separators; label optional.
+const PHONE_PATTERN = /(?:\b(?:Tel(?:efon|efax)?|Fon|Fax|SMS|Mobil(?:funk)?|Handy|WhatsApp|Hotline)\.?\s*:?\s*)?(?:\+|\b00|\(0|\b0)[\d \t/().-]{6,}\d/gi;
+const DATE_PATTERN = /^\d{1,2}\.\d{1,2}\.\d{2,4}$/;
+// Street + house number ("Max-Planck-Straße 19", "Hauptstr. 5a") and postal code + town ("06796 Brehna").
+const STREET_PATTERN = /\b[A-ZÄÖÜ][\wäöüß.-]*(?:[Ss]traße|[Ss]trasse|[Ss]tr\.|[Ww]eg|[Aa]llee|[Pp]latz|[Rr]ing|[Gg]asse|[Dd]amm|[Cc]haussee|[Uu]fer)\s*\d{1,4}(?![.,]?\d)\s?[a-z]?\b(?![.,]\d)/g;
+const POSTCODE_TOWN_PATTERN = /\b\d{5}\s+(?!(?:Euro|EUR|Kilometer|Km|KM|km|Stück|Kilo)\b)[A-ZÄÖÜ][a-zäöüß]+(?:[ -][A-ZÄÖÜ][a-zäöüß]+)?/g;
+// Marks a removed token until the tidy-up; never left in the output.
+const CUT = '\u0000';
+// Labels left behind right before a removed value ("Tel.: ", "E-Mail:").
+const DANGLING_LABEL = /\b(?:Tel(?:efon|efax)?|Fon|Fax|SMS|Mobil(?:funk)?|Handy|WhatsApp|Hotline|E-?Mail|Mail|Web(?:seite)?|Internet|Homepage|Adresse|Anschrift)\.?[ \t]*:?[ \t]*(?=\u0000)/gi;
+
+const digitCount = (value: string): number => (value.match(/\d/g) || []).length;
+
+/**
+ * markt.de's terms (nutzungsbedingungen, checked 08.10.2026) forbid phone numbers, physical addresses,
+ * website links and QR codes in the listing description. The dealer's free-text header / footer of the
+ * mobile.de description often carries exactly that, so it is removed from the text; the vehicle facts
+ * stay. Heuristic by nature: the run report counts every removal for review.
+ */
+export const sanitizeMarktdeDescription = (text: string): { text: string; removed: DescriptionRemovals } => {
+  const removed: DescriptionRemovals = { url: 0, email: 0, phone: 0, address: 0 };
+  if (!text) {
+    return { text, removed };
+  }
+  let out = text
+    .replace(EMAIL_PATTERN, () => { removed.email += 1; return CUT; })
+    .replace(URL_PATTERN, () => { removed.url += 1; return CUT; })
+    .replace(DOMAIN_PATTERN, () => { removed.url += 1; return CUT; })
+    .replace(PHONE_PATTERN, (match) => {
+      const digits = digitCount(match);
+      if (digits < 8 || digits > 16 || DATE_PATTERN.test(match.trim())) {
+        return match;
+      }
+      removed.phone += 1;
+      return CUT;
+    })
+    .replace(STREET_PATTERN, () => { removed.address += 1; return CUT; })
+    .replace(POSTCODE_TOWN_PATTERN, () => { removed.address += 1; return CUT; });
+  if (removed.url + removed.email + removed.phone + removed.address === 0) {
+    return { text, removed };
+  }
+  // Tidy only where something was cut (CUT marks the spot): the label that introduced it, the spaces
+  // around it; a cut at the start / end of a line leaves no space. The rest of the text is untouched.
+  out = out
+    .replace(DANGLING_LABEL, '')
+    .replace(/[ \t]*(?:\u0000[ \t]*)+/g, '\u0001')
+    .replace(/(^|\\\\)\u0001/g, '$1')
+    .replace(/\u0001(?=\\\\|$)/g, '')
+    .replace(/\u0001/g, ' ');
+  return { text: out, removed };
+};
+
+export interface MarktdeRowContext {
+  domain: string;
+  // final, validated image URLs, hero first (non-empty: callers skip cars without images)
+  images: string[];
+}
+
+export interface MarktdeRowFacts {
+  vin: 'sent' | 'empty' | 'invalid_dropped';
+  price: MarktdePriceColumns;
+  descriptionRemovals: DescriptionRemovals | null;
+  fuelEmpty: boolean;
+  co2Empty: boolean;
+}
+
+const decimalComma = (value: number | undefined): string => (value === undefined || value === null ? '' : String(value).replace('.', ','));
+
+/**
+ * Replaces the markt.de columns of a MobileTransformer row (object keyed by column index) and returns
+ * what was decided, for the run report. The row is changed in place.
+ */
+export const applyMarktdeColumns = (row: Record<string, unknown>, car: DataSchemes.Car, ctx: MarktdeRowContext): MarktdeRowFacts => {
+  const c = MARKTDE_COLUMNS;
+  const price = getMarktdePriceColumns(car);
+  row[c.price] = price.price;
+  row[c.vatFlag] = price.vatFlag;
+  row[c.vatRate] = price.vatRate;
+
+  const vin = getMarktdeVin(car);
+  const storedVin = toString(get(car, 'metaData.vin', '')).trim();
+  row[c.vin] = vin;
+
+  let descriptionRemovals: DescriptionRemovals | null = null;
+  const description = row[c.description];
+  if (typeof description === 'string' && description) {
+    const sanitized = sanitizeMarktdeDescription(description);
+    row[c.description] = sanitized.text;
+    descriptionRemovals = sanitized.removed;
+  }
+
+  row[c.images] = ctx.images.join(';');
+
+  // EnVKV: the same values as the Google / Meta / AutoUncle / meinestadt feeds (WLTP first, legacy
+  // only as fallback; BEV: no fuel consumption, CO2 0). Nothing usable -> empty (legacy: "undefined").
+  const fuel = envkvFuelConsumptionValue(car);
+  const co2 = envkvCo2Value(car);
+  row[c.fuelCombined] = decimalComma(fuel);
+  row[c.co2] = co2 === undefined || co2 === null ? '' : String(co2);
+
+  row[c.listingUrl] = getMarktdeListingUrl(ctx.domain, toString(get(car, '_id', '')));
+
+  return {
+    vin: vin ? 'sent' : storedVin ? 'invalid_dropped' : 'empty',
+    price,
+    descriptionRemovals,
+    fuelEmpty: row[c.fuelCombined] === '',
+    co2Empty: row[c.co2] === '',
+  };
+};

package/src/transformers/mobile.transformer.ts

@@ -13,8 +13,6 @@ import { isNotEmptyArray } from '../utils';
 import { ConfigService } from '../services';
 import { ExportType } from '../enums';
 
-const vinGenerator = require('vin-generator');
-
 @Injectable()
 export class MobileTransformer {
   private currentCar: DataSchemes.Car;
@@ -346,18 +344,11 @@ export class MobileTransformer {
     return String(currentSalesPrice);
   }
 
+  // ADV-328: never a fake VIN. markt.de (the only campaign that had one) used to get
+  // marketing.fakeVIN or a random generated VIN when the car had none; marktde.transformer now
+  // sends the car's own valid VIN or nothing.
   private getVinCode(car: DataSchemes.Car): string {
-    const vin = get(car, 'metaData.vin', '');
-
-    if (this.configService.config.campaign === 'marktde' && !vin) {
-      const fakeVin = get(car, 'marketing.fakeVIN', '');
-      if (!isEmpty(fakeVin)) {
-        return fakeVin;
-      }
-      return vinGenerator.generateVin();
-    }
-
-    return vin;
+    return get(car, 'metaData.vin', '');
   }
 
   private getAutodeUrl(car: DataSchemes.Car): string {