@bytebrand/export-cars 1.7.1 → 1.9.0

package/src/services/images.service.ts

@@ -0,0 +1,161 @@
+import { Injectable } from '@nestjs/common';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { get, toString } from 'lodash';
+import { isNotEmptyArray } from '../utils/validator.utils';
+import { ConfigService } from './config.service';
+import { ImageType } from '../enums';
+import { MarketingImageConfigInterface, MarketingImageConfigsInterface } from '@bytebrand/autode-request';
+import { UserService } from './user.service';
+import { FB_MAX_IMAGE_COUNT_FOR_DEAFULT } from '../constants/fb.constants';
+
+@Injectable()
+export class ImagesService {
+  constructor(private readonly configService: ConfigService, private readonly userService: UserService) {}
+
+  async getImages(
+    car: DataSchemes.Car,
+    images: ImboImageResponseInterface[],
+    imageType: ImageType,
+  ): Promise<Array<string>> {
+    if (imageType === ImageType.default) {
+      return this.getDefaultImages(car, images);
+    } else {
+      const carId = toString(get(car, '_id', ''));
+      return await this.getMarketingImages(images, carId);
+    }
+  }
+
+  getDefaultImages(car: DataSchemes.Car, images: ImboImageResponseInterface[]): Array<string> {
+    const defaultImages = [
+      'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg',
+      'https://images.auto.de/carimage/noimage/GvyXmrpaf1D6/large-cached.jpeg',
+      'https://images.auto.de/carimage/noimage/gY1zF8PXzH2W/large-cached.jpeg',
+      'https://images.auto.de/carimage/noimage/pFyfBsqBHEso/large-cached.jpeg',
+    ];
+
+    if (!isNotEmptyArray(images)) {
+      return defaultImages;
+    }
+
+    const firstImageId = get(car, 'metaData.mainImageId', null);
+    const secondImageId = get(car, 'metaData.secImageId', null);
+    const thirdImageId = get(car, 'metaData.thirdImageId', null);
+
+    if (firstImageId) {
+      images.forEach((image, index) => {
+        if (firstImageId === image.imageIdentifier) {
+          const tmp = images[index];
+          images[index] = images[0];
+          images[0] = tmp;
+        }
+      });
+    }
+
+    if (secondImageId) {
+      images.forEach((image, index) => {
+        if (secondImageId === image.imageIdentifier) {
+          const tmp = images[index];
+          images[index] = images[1];
+          images[1] = tmp;
+        }
+      });
+    }
+
+    if (thirdImageId) {
+      images.forEach((image, index) => {
+        if (thirdImageId === image.imageIdentifier) {
+          const tmp = images[index];
+          images[index] = images[2];
+          images[2] = tmp;
+        }
+      });
+    }
+
+    const carId = toString(get(car, '_id', ''));
+
+    const transformedImages = this.generateImageLinks(images, carId);
+    if (transformedImages.length < 17) {
+      transformedImages.push(...defaultImages);
+    }
+    return transformedImages;
+  }
+
+  generateImageLinks(images: ImboImageResponseInterface[], carId: string) {
+    return images.map((image: ImboImageResponseInterface) => {
+      return `${this.configService.config.baseImageUrl}/carimage/${carId}/${image.imageIdentifier}/large`;
+    });
+  }
+
+  async getMarketingImages(images: any, carId: string): Promise<string[]> {
+    const imageUrl = this.configService.config.imageUrl;
+    const transformedImages = this.transformImagesArrayIntoObject(images);
+    const configs = this.configService.config.isCriteo
+      ? await this.userService.getMarketingImageConfig(this.configService.config.criteoMarketingImagesConfigId)
+      : ((await this.getMarketingImageConfigs()) as any);
+    const marketingImageConfigs = this.transform(configs);
+
+    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' },
+    ];
+
+    const imageUrls = [];
+
+    for (let i = 0; i < marketingImageConfigs.length; i++) {
+      const marketingImage = marketingImageConfigs[i];
+      for (let i = 0; i < marketingImage.marketingImageCodes.length; i++) {
+        const imageCode = marketingImage.marketingImageCodes[i];
+        const imageId = transformedImages[imageCode];
+        if (imageId) {
+          imageUrls.push(this.getImagePathWithExtenstion(imageUrl, carId, imageId, configs));
+          break;
+        }
+      }
+    }
+    if (imageUrls.length < FB_MAX_IMAGE_COUNT_FOR_DEAFULT) {
+      imageUrls.push(...defImages);
+    }
+    return imageUrls;
+  }
+
+  async getMarketingImageConfigs(): Promise<MarketingImageConfigsInterface> {
+    const configs = await this.userService.getMarketingImageConfigs();
+    const { id } = configs.find(config => config.channelCode.includes(this.configService.config.exportType));
+
+    return this.userService.getMarketingImageConfig(id);
+  }
+
+  private transformImagesArrayIntoObject(images: { [imageCode: string]: string }[]) {
+    const result: { [imageCode: string]: string } = {};
+    images.forEach(image => {
+      const imageCode = image.imageCodePredicted.split('-')[0];
+      result[imageCode] = image.imageIdentifier;
+    });
+    return result;
+  }
+
+  private transform(config: MarketingImageConfigInterface): { marketingImageCodes: string[] }[] {
+    return config.marketingImages.map(marketingImage => {
+      return {
+        marketingImageCodes: marketingImage.imageCodes,
+      };
+    });
+  }
+
+  protected getChannelPath(imageUrl: string, carId: string): string {
+    return `${imageUrl}/${[carId[0], carId[1], carId[2], carId].join('/')}`;
+  }
+
+  protected getImagePathWithExtenstion(
+    imageUrl: string,
+    carId: string,
+    imageId: string,
+    config: MarketingImageConfigsInterface,
+  ): string {
+    const { channelCode, imageExtension } = config;
+    return `${this.getChannelPath(imageUrl, carId)}/${channelCode.replace(/ /g, '-')}-${imageId}.${imageExtension}`;
+  }
+}

package/src/services/index.ts

@@ -5,5 +5,4 @@ export * from './loader.service';
 export * from './config.service';
 export * from './request.service';
 export * from './mapping.service';
-export * from './marketing-images.service';
-
+export * from './images.service';

package/src/transformers/auto24.transfomer.ts

@@ -1,25 +1,26 @@
 import { Translator } from '@bytebrand/schema-tools';
 import { de } from '@bytebrand/i18n-dictionaries';
-import { get, toString, isNil, isEmpty, first } from 'lodash';
+import { get, isEmpty, isNil, toString } from 'lodash';
 import * as moment from 'moment';
 import { DataSchemes } from '@bytebrand/car-schema';
 import { ImboImageResponseInterface } from '@bytebrand/chunkable';
 import { Auto24XmlItem } from '../interfaces';
 import { Injectable } from '@nestjs/common';
-import { ConfigService } from '../services/config.service';
+import { ConfigService, ImagesService } from '../services';
 import { isNotEmptyArray } from '../utils/validator.utils';
+import { ImageType } from '../enums';
 
 @Injectable()
 export class Auto24Transformer {
   private translator: Translator;
 
-  constructor(private configService: ConfigService) {
+  constructor(private configService: ConfigService, private readonly imageService: ImagesService) {
     this.translator = new Translator(de);
   }
 
-  transform(car: DataSchemes.Car, imboImages: ImboImageResponseInterface[]): Auto24XmlItem {
+  async transform(car: DataSchemes.Car, imboImages: ImboImageResponseInterface[]): Promise<Auto24XmlItem> {
     const carId = toString(get(car, '_id', ''));
-
+    const transformedImages = await this.imageService.getImages(car, imboImages, ImageType.default);
     let userlink = `https://www.${this.configService.config.domain}/search/vehicle/${carId}`;
     if (this.configService.config.campaign) {
       userlink += `?source=classifieds&medium=listing&campaign=${this.configService.config.campaign}`;
@@ -37,9 +38,9 @@ export class Auto24Transformer {
       consumptionK: toString(get(car, 'consumption.consumptionCombined', '')),
       co2: toString(get(car, 'environmentEmissions.co2', '')),
       efficiencyclass: this.translateSelector(get(car, 'environmentEmissions.energyEfficiencyClass', '')),
-      image: this.getImageField(carId, toString(get(car, 'metaData.mainImageId')), imboImages),
+      image: transformedImages[0],
       registration: this.getRegistrationField(get(car, 'mainData.firstRegistration') as number),
-      images: this.getImagesField(carId, imboImages),
+      images: transformedImages,
       price: toString(get(car, 'price.currentSalesPrice', '')),
       power: toString(get(car, 'engineData.powerKW', '')),
       zip: toString(get(car, 'location.zipCode', '')),
@@ -132,28 +133,4 @@ export class Auto24Transformer {
       })
       .join(', ');
   }
-
-  private getImagesField(carId: string, images: ImboImageResponseInterface[]): string[] {
-    if (isNotEmptyArray(images)) {
-      return images.map((image: ImboImageResponseInterface) => {
-        return this.buildLargeImageUrl(carId, image.imageIdentifier);
-      });
-    }
-    return [];
-  }
-
-  private getImageField(carId: string, mainImageId: string, images: ImboImageResponseInterface[]): string {
-    if (isNil(mainImageId) || isEmpty(mainImageId)) {
-      if (isNotEmptyArray(images)) {
-        const firstImageId = first(images);
-        return this.buildLargeImageUrl(carId, firstImageId.imageIdentifier);
-      }
-      return '';
-    }
-    return this.buildLargeImageUrl(carId, mainImageId);
-  }
-
-  private buildLargeImageUrl(carId: string, imageId: string): string {
-    return `${this.configService.config.imageUrl}/carimage/${carId}/${imageId}/large`;
-  }
 }

package/src/transformers/autouncle.transformer.ts

@@ -5,18 +5,18 @@ 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 { ConfigService, ImagesService } from '../services';
 import { Injectable } from '@nestjs/common';
 import { DEFAULT_ADDR1, DEFAULT_CITY, DEFAULT_ZIP, MIN_MILEAGES } from '../constants/autouncle.contants';
 import { AutouncleJsonItem } from '../interfaces';
-import { isNotEmptyArray } from '../utils/validator.utils';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
 
 @Injectable()
 export class AutouncleTransformer {
   private translator: TranslatorExtended;
   private postalCodesService: DePostalCodesService;
 
-  constructor(private configService: ConfigService) {
+  constructor(private configService: ConfigService, private imageService: ImagesService) {
     const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
     this.translator = new TranslatorExtended(dict);
     this.postalCodesService = DePostalCodesService.getInstance();
@@ -28,7 +28,7 @@ export class AutouncleTransformer {
     owner,
   }: {
     car: DataSchemes.Car;
-    images: unknown[];
+    images: ImboImageResponseInterface[];
     metadata?: unknown;
     owner: unknown;
   }): Promise<AutouncleJsonItem> {
@@ -61,7 +61,7 @@ export class AutouncleTransformer {
       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),
+      images: this.getImagesField(car, images),
       fuel_economy: toString(get(car, 'consumption.consumptionCombined', '')),
       co2_emission: toString(get(car, 'environmentEmissions.co2', '')),
       co2_effiency_class: toString(get(car, 'environmentEmissions.energyEfficiencyClass', '')),
@@ -230,35 +230,9 @@ export class AutouncleTransformer {
     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;
-    };
+  private getImagesField(car: DataSchemes.Car, images: ImboImageResponseInterface[]): { url: string }[] {
+    return this.imageService.getDefaultImages(car, images).map(url => {
+      return { url };
+    });
   }
 }

package/src/transformers/facebook-shop.transformer.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@nestjs/common';
+
+import { escape, get, join, round, toString, trim } from 'lodash';
+
+import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
+import { TranslatorExtended } from '@bytebrand/schema-tools';
+import { DataSchemes } from '@bytebrand/car-schema';
+
+import { FacebookShopItem } from '../interfaces';
+import { ConfigService } from '../services';
+import { Description } from '../interfaces/description.interface';
+import { FbDescription } from './fb-description.transformer';
+import { FbEquipment } from './fb-equipment.transformer';
+
+@Injectable()
+export class FacebookShopTransformer {
+  private translator: TranslatorExtended;
+
+  constructor(private readonly configService: ConfigService) {
+    const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
+    this.translator = new TranslatorExtended(dict);
+  }
+
+  async transform({ car }: { car: DataSchemes.Car }): Promise<FacebookShopItem> {
+    return {
+      id: { value: get(car, 'metaData.vehicleId'), isGoogle: true },
+      title: { value: this.getTitle(car), isGoogle: true },
+      description: { value: this.getDescription(car), isGoogle: true },
+      availability: { value: 'in stock', isGoogle: true },
+      condition: { value: this.getCondition(car), isGoogle: true },
+      price: { value: this.getPrice(car), isGoogle: true },
+      link: { value: this.getCarLink(car), isGoogle: true },
+      image_link: { value: this.getImageLink(car), isGoogle: true },
+      brand: { value: get(car, 'mainData.make', ''), isGoogle: true },
+      additional_image_link: { value: this.getImageLink(car), isGoogle: false },
+      quantity_to_sell_on_facebook: { value: 1, isGoogle: true },
+      google_product_category: { value: '916', isGoogle: true },
+      sale_price: { value: this.getPrice(car), isGoogle: true },
+      status: { value: 'active', isGoogle: true },
+      color: { value: this.getColor(car), isGoogle: false },
+      product_type: {
+        value: 'Vehicles &amp; Parts > Vehicles > Motor Vehicles > Cars, Trucks &amp; Vans',
+        isGoogle: true,
+      },
+    };
+  }
+
+  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 getCondition(car: DataSchemes.Car): string {
+    const available = {
+      selector_condition_new: 'New',
+      selector_condition_used: 'Used',
+      selector_unknown: 'New',
+    };
+    const condition = get(car, 'mainData.condition', 'selector_unknown');
+    return get(available, condition);
+  }
+
+  private getCarLink(car: DataSchemes.Car): string {
+    return `https://${this.configService.config.domain}/search/vehicle/${car._id}`;
+  }
+
+  private getPrice(car: DataSchemes.Car): string {
+    const price = get(car, 'price.currentSalesPrice', 0);
+    return `${round(price, 2)} EUR`;
+  }
+
+  private getColor(car: DataSchemes.Car): string {
+    let colorSelection = get(car, 'exterior.exteriorColor', 'selector_unknown');
+    if (!colorSelection || colorSelection === 'selector_unknown') {
+      colorSelection = 'selector_unknown';
+    }
+    return this.translator.translateVal(colorSelection);
+  }
+
+  private getDescription(car: DataSchemes.Car): Description[] {
+    return FbDescription.create(car, this.translator, new FbEquipment()).getDescriptionArray();
+  }
+
+  //todo: move to image service
+  private getImageLink(car: DataSchemes.Car): string {
+    const mainImageId = get(car, 'metaData.mainImageId', '');
+    return mainImageId
+      ? `${this.configService.config.baseImageUrl}/carimage/${car._id}/${mainImageId}/large-cached.webp`
+      : `${this.configService.config.baseImageUrl}/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg`;
+  }
+}

package/src/transformers/fb.transformer.ts

@@ -1,28 +1,27 @@
 import { TranslatorExtended } from '@bytebrand/schema-tools';
 import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
 import {
+  escape,
+  findIndex,
   get,
-  toString,
+  includes,
+  isArray,
+  isBoolean,
   isEmpty,
-  trim,
+  isString,
   join,
-  escape,
   toSafeInteger,
+  toString,
+  trim,
   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 { ConfigService, ImagesService } from '../services';
 import { ImboImageResponseInterface } from '@bytebrand/chunkable';
-import { isNotEmptyArray, isValidVin } from '../utils/validator.utils';
+import { isValidVin } from '../utils/validator.utils';
 import { Injectable } from '@nestjs/common';
 import { FbDescription } from './fb-description.transformer';
 import { Description } from '../interfaces/description.interface';
@@ -31,24 +30,21 @@ 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';
 import { UserService } from 'src/services';
+import { ImageType } from '../enums';
 
 @Injectable()
 export class FbTransformer {
   private translator: TranslatorExtended;
   private postalCodesService: DePostalCodesService;
-  private marketingImages: MarketingImagesService;
+  private imagesService: ImagesService;
 
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly userService: UserService
-  ) {
-    this.marketingImages = new MarketingImagesService(configService, userService);
+  constructor(private readonly configService: ConfigService, private readonly userService: UserService) {
+    this.imagesService = new ImagesService(configService, userService);
     const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
     this.translator = new TranslatorExtended(dict);
     this.postalCodesService = DePostalCodesService.getInstance();
@@ -81,7 +77,7 @@ export class FbTransformer {
       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),
+      image: await this.imagesService.getImages(car, images, ImageType.marketing),
       year: toString(year),
       mileage: {
         value: this.getMileage(car),
@@ -152,15 +148,13 @@ export class FbTransformer {
     dealer_email: string;
     dealer_phone: string;
   } {
-    const items = {
+    return {
       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 {
@@ -372,28 +366,6 @@ export class FbTransformer {
     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' },

package/src/transformers/google.transformer.ts

@@ -1,25 +1,28 @@
-import { get, toString, trim, join, escape, round } from 'lodash';
+import { escape, get, join, round, toString, trim } from 'lodash';
 import { CarDescriptionFactory, DescriptionTypeEnum } from '@bytebrand/car-description';
 import { DataSchemes } from '@bytebrand/car-schema';
 import { TranslatorExtended } from '@bytebrand/schema-tools';
 import { de, deVehicleDetailsPage, deVehicleProps } from '@bytebrand/i18n-dictionaries';
 import { Injectable } from '@nestjs/common';
-import { UserService } from '../services/user.service';
-import { ConfigService } from '../services/config.service';
+import { ConfigService, ImagesService, UserService } from '../services';
 import { GoogleXmlItem } from '../interfaces';
+import { ImageType } from '../enums';
 
 @Injectable()
 export class GoogleTransformer {
   private translator: TranslatorExtended;
 
-  constructor(private userService: UserService, private configService: ConfigService) {
+  constructor(
+    private userService: UserService,
+    private configService: ConfigService,
+    private imageService: ImagesService,
+  ) {
     const dict = { ...de, ...deVehicleProps, ...deVehicleDetailsPage };
     this.translator = new TranslatorExtended(dict);
   }
 
-  async transform({ car }: { car: DataSchemes.Car }): Promise<GoogleXmlItem> {
+  async transform({ car, images }: { car: DataSchemes.Car; images: Array<any> }): Promise<GoogleXmlItem> {
     const carId = toString(get(car, '_id', ''));
-    const mainImageId = get(car, 'metaData.mainImageId', '');
 
     return {
       id: carId,
@@ -28,7 +31,7 @@ export class GoogleTransformer {
       google_product_category: this.getBreadcrumbs(car),
       product_type: this.getCategory(car),
       link: this.getLink(car),
-      image_link: await this.buildLargeImageUrl(carId, mainImageId),
+      image_link: await this.imageService.getImages(car, images, ImageType.marketing)[0],
       condition: this.mapState(car),
       availability: this.getAvailability(car),
       brand: get(car, 'mainData.make', ''),
@@ -98,27 +101,6 @@ export class GoogleTransformer {
     return this.translator.translateVal(colorSelection);
   }
 
-  private async buildLargeImageUrl(carId: string, imageId: string): Promise<string> {
-    if (this.configService.config.isCriteo) {
-      try {
-        const criteoConfig = await this.userService.getMarketingImageConfig(this.configService.config.criteoMarketingImagesConfigId);
-        return imageId
-          ? `${this.configService.config.imageUrl}/generated_images/${[carId[0], carId[1], carId[2], carId].join(
-              '/',
-            )}/criteo-${imageId}.${criteoConfig.imageExtension}`
-          : 'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large';
-      } catch (e) {
-        console.log('Error: Failed to get criteoConfig');
-        return imageId
-          ? `${this.configService.config.imageUrl}/carimage/${carId}/${imageId}/large`
-          : 'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large';
-      }
-    }
-    return imageId
-      ? `${this.configService.config.imageUrl}/carimage/${carId}/${imageId}/large`
-      : 'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large';
-  }
-
   private mapState(car: DataSchemes.Car): string {
     const available = {
       selector_condition_new: 'Neu',

package/src/transformers/index.ts

@@ -1,2 +1,3 @@
 export * from './rubrikk.transformer';
 export * from './modix.transformer';
+export * from './facebook-shop.transformer';

package/src/transformers/meinstadt.transformer.ts

@@ -3,7 +3,7 @@ import { DataSchemes } from '@bytebrand/car-schema';
 
 import { de } from '@bytebrand/i18n-dictionaries';
 import { Injectable } from '@nestjs/common';
-import { ConfigService } from '../services/config.service';
+import { ConfigService } from '../services';
 import { MeinstadtJsonItem } from '../interfaces';
 
 @Injectable()
@@ -73,8 +73,7 @@ export class MeinstadtTransformer {
   private getDescription(car: DataSchemes.Car): string {
     const usageType = get(car, 'offer.offerDescription', null);
     if (usageType) {
-      const afterFromatting = usageType.replace(/\\/g, ',').replace(/\\/g, ',').replace(/,,/g, ',');
-      return afterFromatting;
+      return usageType.replace(/\\/g, ',').replace(/\\/g, ',').replace(/,,/g, ',');
     } else return null;
   }
 }