@bytebrand/export-cars 0.0.2 → 1.0.6

package/src/services/mapping.service.ts

@@ -0,0 +1,80 @@
+import { Injectable } from '@nestjs/common';
+import { CronicleUtils } from '@bytebrand/cronicle-helper';
+import { MappingRules } from '../interfaces/mapping-rules.interface';
+import { HttpService } from '@nestjs/axios';
+import { lastValueFrom } from 'rxjs';
+
+@Injectable()
+export class MappingService {
+  constructor(private httpService: HttpService) {}
+  private rules: MappingRules[];
+
+  async getRules(): Promise<MappingRules[]> {
+    if (!this.rules) {
+      const { data } = await lastValueFrom(
+        this.httpService.get(
+          'https://docs.google.com/spreadsheets/d/e/2PACX-1vRh14TrYZDtk2efsnVsbfKypPWGdtGSSjgJRVlY2qrqHybaQZWP4HptLb3RQhiKfBsxQUdtltCRnwHU/pub?gid=1580940856&single=true&output=csv',
+        ),
+      );
+      const rows: MappingRules[] = await CronicleUtils.parseCSV(data);
+
+      rows.map((row, _i, selfRows) => {
+        this.removeEmptyKeys(row);
+        if (row.importFieldType && row.importFieldType.includes('selector')) {
+          this.groupSelectors(row, selfRows);
+        }
+      });
+
+      this.rules = this.filterResultedRows(rows);
+    }
+    return this.rules;
+  }
+
+  // private rowsToRules(rows: GoogleSpreadsheetRow[]): MappingRulesInterface[] {
+  //   return rows.map(row =>
+  //     Object.assign(
+  //       {},
+  //       ...Object.entries(Object.getOwnPropertyDescriptors(row))
+  //         .filter(([_key, descriptor]) => typeof descriptor.get === 'function')
+  //         .map(([key, descriptor]) => ({
+  //           [key]: descriptor.get() || '',
+  //         })),
+  //     ),
+  //   );
+  // }
+
+  private filterResultedRows(rows: MappingRules[]): MappingRules[] {
+    return rows.filter((value, idx, self) => {
+      const mapped = self.map((x: MappingRules) => x.importField);
+      const equalSelectors =
+        value.importFieldType && value.importFieldType.includes('selector')
+          ? mapped.indexOf(value.importField) === idx
+          : true;
+      return value.autodeField && equalSelectors;
+    });
+  }
+
+  private removeEmptyKeys(row: MappingRules): void {
+    Object.keys(row).map(key => {
+      if (row[key] === '') {
+        delete row[key];
+      }
+    });
+  }
+
+  private groupSelectors(row: MappingRules, selfRows: MappingRules[]): void {
+    for (let i = 0; i < selfRows.length; i += 1) {
+      if (selfRows[i].importField === row.importField) {
+        if (!selfRows[i].selectors) {
+          selfRows[i].selectors = [];
+        }
+        if (row.autodeFieldSelector) {
+          selfRows[i].selectors.push(`${row.importFieldSelector}:${row.autodeFieldSelector}`);
+        }
+      }
+    }
+
+    delete row.importFieldSelector;
+    delete row.autodeFieldSelector;
+  }
+}

package/src/services/marketing-images.service.ts

@@ -0,0 +1,67 @@
+import { MarketingImageConfigInterface, MarketingImageConfigsInterface } from '@bytebrand/autode-request';
+import { ConfigService } from './config.service';
+import { UserService } from './user.service';
+
+export class MarketingImagesService {
+  constructor(private readonly configService: ConfigService, private readonly userService: UserService) {}
+
+  async getImagesUrl(images: any, imageUrl: string, carId: string): Promise<{ url: string }[]> {
+    const transformedImages = this.transformImagesArrayIntoObject(images);
+    const configs = (await this.getMarketingImageConfigs()) as any;
+    const marketingImageConfigs = this.transform(configs);
+
+    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({ url: this.getImagePathWithExtenstion(imageUrl, carId, imageId, configs) });
+          break;
+        }
+      }
+    }
+
+    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/request.service.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { ImageImboRequest, UserActionsRequest, UserProfileAdminRequest } from '@bytebrand/autode-request';
+import { ConfigService } from './config.service';
+
+@Injectable()
+export class RequestService {
+  constructor(private configService: ConfigService) {}
+
+  private _upaRequest: UserProfileAdminRequest;
+
+  get upaRequest() {
+    if (!this._upaRequest) {
+      this._upaRequest = new UserProfileAdminRequest(
+        this.configService.config.apikey,
+        this.configService.config.upaUrl,
+      );
+    }
+    return this._upaRequest;
+  }
+
+  private _userActionsRequest: UserActionsRequest;
+
+  get userActionsRequest() {
+    if (!this._userActionsRequest) {
+      this._userActionsRequest = new UserActionsRequest(
+        this.configService.config.apikey,
+        this.configService.config.userActionsUrl,
+      );
+    }
+    return this._userActionsRequest;
+  }
+
+  private _imageImboRequest: ImageImboRequest;
+
+  get imageImboRequest() {
+    if (!this._imageImboRequest) {
+      this._imageImboRequest = new ImageImboRequest(
+        this.configService.config.apikey,
+        this.configService.config.userActionsUrl,
+      );
+    }
+    return this._imageImboRequest;
+  }
+}

package/src/services/rules.service.ts

@@ -0,0 +1,61 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { concat, toSafeInteger, toString } from 'lodash';
+import { DateRule } from '../rules/date.rule';
+import { NumberRule } from '../rules/number.rule';
+import { StringRule } from '../rules/string.rule';
+import { ConfigService } from './config.service';
+
+@Injectable()
+export class RulesService {
+  private readonly logger = new Logger(RulesService.name);
+  constructor(private configService: ConfigService) {}
+
+  private _rules: Array<StringRule | NumberRule | DateRule>;
+
+  get rules() {
+    if (!this._rules) {
+      this._rules = concat(
+        [],
+        this.buildStringRules(this.configService.config.input.stringIN),
+        this.buildNumberRules(this.configService.config.input.numberIN),
+        this.buildDateRules(this.configService.config.input.dateIN),
+      );
+    }
+    return this._rules;
+  }
+
+  private buildRules(
+    value: string,
+    ruleBuilder: (key: string, params: string) => StringRule | DateRule | NumberRule,
+  ): Array<StringRule | NumberRule | DateRule> {
+    const rulesArr: Array<StringRule | NumberRule | DateRule> = [];
+    try {
+      const expressions = value.split(';');
+      if (expressions.length === 0) return [];
+
+      expressions.forEach(e => {
+        const values = e.split(':');
+        if (values.length > 1) {
+          const rule = ruleBuilder(values[0], values[1]);
+          rulesArr.push(rule);
+        }
+      });
+      return rulesArr;
+    } catch (error) {
+      this.logger.error(error);
+      return rulesArr;
+    }
+  }
+
+  private buildStringRules(value: string): Array<StringRule | NumberRule | DateRule> {
+    return this.buildRules(value, (key, params) => new StringRule(key, params, (e: string) => toString(e)));
+  }
+
+  private buildNumberRules(value: string): Array<StringRule | NumberRule | DateRule> {
+    return this.buildRules(value, (key, params) => new NumberRule(key, params, (e: string) => toSafeInteger(e)));
+  }
+
+  private buildDateRules(value: string): Array<StringRule | NumberRule | DateRule> {
+    return this.buildRules(value, (key, params) => new DateRule(key, params, (e: string) => toSafeInteger(e)));
+  }
+}

package/src/services/user.service.ts

@@ -0,0 +1,52 @@
+import { CACHE_MANAGER, Inject, Injectable } from '@nestjs/common';
+import { RequestService } from './request.service';
+import { Cache } from 'cache-manager';
+import { get } from 'lodash';
+import { MarketingImageConfigInterface, MarketingImageConfigsInterface } from '@bytebrand/autode-request';
+
+@Injectable()
+export class UserService {
+  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache, private readonly requestService: RequestService) {}
+
+  async getDefaultSummaryByDealerId(dealerId: string): Promise<any> {
+    const cacheKey = `${dealerId}_default_summary`;
+    const cachedResponse = await this.cacheManager.get(cacheKey);
+
+    if (cachedResponse) {
+      return cachedResponse;
+    }
+
+    const defaultSummary = await this.requestService.userActionsRequest.getDefaultSummaryByDealerId(dealerId);
+    const result = get(defaultSummary, 'data.schema', {});
+    await this.cacheManager.set(cacheKey, result);
+
+    return result;
+  }
+
+  async getMarketingImageConfig(configId: number): Promise<MarketingImageConfigInterface> {
+    const key = `marketingImageConfig_${configId}`;
+    let result = (await this.cacheManager.get(key)) as MarketingImageConfigInterface;
+    if (result) {
+      return result;
+    }
+
+    result = await this.requestService.upaRequest.getMarketingImageConfigById(configId);
+
+    await this.cacheManager.set(key, result);
+
+    return result;
+  }
+
+  async getMarketingImageConfigs(): Promise<MarketingImageConfigsInterface[]> {
+    const key = 'marketingImagesConfigs';
+    let result = (await this.cacheManager.get(key)) as MarketingImageConfigsInterface[];
+    if (result) {
+      return result;
+    }
+
+    result = await this.requestService.upaRequest.getMarketingImageConfigs();
+    await this.cacheManager.set(key, result);
+
+    return result;
+  }
+}

package/src/transformers/as24.transformer.ts

@@ -0,0 +1,225 @@
+import { get, isEmpty, isNil, set, upperFirst } from 'lodash';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { CarDescriptionFactory, DescriptionTypeEnum } from '@bytebrand/car-description';
+import { MappingService } from '../services/mapping.service';
+import { MappingRules } from '../interfaces/mapping-rules.interface';
+import { Injectable, Logger } from '@nestjs/common';
+
+@Injectable()
+export class As24Transformer {
+  private readonly logger = new Logger(As24Transformer.name);
+  private currentCar: DataSchemes.Car;
+  private descriptionSchemas: unknown;
+
+  constructor(private mappingService: MappingService) {}
+
+  async transform(carData: DataSchemes.Car, descriptionSchemas: unknown): Promise<unknown> {
+    this.currentCar = carData;
+    this.descriptionSchemas = descriptionSchemas;
+    const transformedCarData = {};
+    const rules = await this.mappingService.getRules();
+    for (const rule of rules) {
+      if (rule.custom === 'yes') {
+        const transformedField = await this.customTransformers(rule, carData);
+        if (transformedField) {
+          set(transformedCarData, `${rule.importField}`, transformedField);
+        }
+      } else {
+        const fieldValue: any = get(carData, `${rule.autodeField}`, null);
+        if (!isNil(fieldValue)) {
+          const transformedField = await this.transformField(fieldValue, rule);
+
+          if (!isNil(transformedField)) {
+            set(transformedCarData, `${rule.importField}`, transformedField);
+          }
+        }
+      }
+    }
+
+    const ownerId = get(carData, 'metaData.ownerId', '');
+    const carId = get(carData, '_id', '');
+    ownerId && set(transformedCarData, 0, ownerId);
+    carId && set(transformedCarData, 1, carId);
+
+    return transformedCarData;
+  }
+
+  private async transformField(fieldValue: any, rule: MappingRules): Promise<string | void> {
+    const transformProcedureName = `${rule.autodeFieldType}To${upperFirst(rule.importFieldType)}`;
+
+    switch (transformProcedureName) {
+      case 'stringToString': {
+        if (rule.autodeField === 'offer.offerDescription') {
+          return await this.offerStringToString();
+        }
+        return this.stringToString(fieldValue);
+      }
+      case 'integerToString': {
+        return this.numberToString(fieldValue);
+      }
+      case 'numberToString': {
+        return this.numberToString(fieldValue);
+      }
+      case 'booleanToString': {
+        return this.booleanToString(fieldValue);
+      }
+      case 'selectorToSelector': {
+        return this.selectorToSelector(fieldValue, rule);
+      }
+      case 'selectorToString': {
+        return this.selectorToString(fieldValue, rule);
+      }
+      case 'selector[]ToSelector': {
+        return this.selectorArrayToSelector(fieldValue, rule);
+      }
+      case 'selector[]ToString': {
+        return this.selectorArrayToString(fieldValue, rule);
+      }
+      case 'dateToString': {
+        return this.dateToString(fieldValue, rule);
+      }
+      case 'dateToMobile_delivery': {
+        return this.dateToString(fieldValue, rule);
+      }
+      case 'stringToMobile_model': {
+        return this.stringToMobile_model(fieldValue);
+      }
+      case 'numberToMobile_consumption': {
+        return this.numberToMobile_consumption(fieldValue);
+      }
+      case 'booleanToMobile_vatCalc': {
+        return this.booleanToMobile_vatCalc(fieldValue);
+      }
+      case 'selectorToMobile_extColor_selector': {
+        return this.selectorToSelector(fieldValue, rule);
+      }
+      case 'selectorToCategoryOrClass_selector': {
+        return this.selectorToCategoryOrClass_selector(fieldValue, rule);
+      }
+      default:
+        this.logger.log(`missing transform: ${transformProcedureName}`);
+        break;
+    }
+  }
+
+  private async customTransformers(rule: MappingRules, car: DataSchemes.Car): Promise<any> {
+    switch (rule.autodeField) {
+      case 'price.vatDeductible': {
+        return this.getVatDeductible(car);
+      }
+      case 'price.originalSalesPrice': {
+        return this.getOriginalSalesPrice(car);
+      }
+      case 'price.vatRate': {
+        return this.getVatRate(car);
+      }
+      default:
+        return '';
+    }
+  }
+
+  private async getVatDeductible(car: DataSchemes.Car): Promise<string> {
+    return this.booleanToString(!get(car, 'price.vatDeductible', null));
+  }
+
+  private async getOriginalSalesPrice(car: DataSchemes.Car): Promise<string> {
+    const vat = !get(car, 'price.vatDeductible', false);
+    const price = get(car, 'price.originalSalesPrice', null);
+    if (price && !vat) {
+      return (price / 1.19).toFixed(2) + '';
+    }
+    return price + '';
+  }
+
+  private async getVatRate(car: DataSchemes.Car): Promise<'19' | '0'> {
+    const vat = get(car, 'price.vatDeductible', false);
+    if (vat) {
+      return '19';
+    }
+    return '0';
+  }
+
+  private async offerStringToString(): Promise<string> {
+    const dealerID = get(this.currentCar, 'metaData.ownerId');
+    const descriptionSchema = get(this.descriptionSchemas, dealerID);
+    const descriptionBuilder = CarDescriptionFactory.create(DescriptionTypeEnum.Mobile, this.currentCar);
+    return descriptionBuilder.transform(descriptionSchema);
+  }
+
+  private stringToString(fieldValue: string): string {
+    return isEmpty(fieldValue) ? null : fieldValue;
+  }
+
+  private numberToString(fieldValue: number): string {
+    return String(fieldValue);
+  }
+
+  private booleanToString(fieldValue: boolean): string {
+    return String(Number(fieldValue));
+  }
+
+  private selectorToSelector(fieldValue: string, rule: MappingRules): string | void {
+    if (fieldValue === 'selector_unknown' && rule.autodeField === 'heatingCooling.climatisation') {
+      return 'default';
+    }
+
+    if (fieldValue === 'selector_unknown' || fieldValue === 'selector_interiorColor_rainbow') {
+      return '';
+    }
+    const pairs = rule.selectors.map(p => p.split(':').reverse());
+    const [match] = pairs.filter(p => p[0] === fieldValue);
+    // consider adding values not mapped in table
+    if (match) {
+      return match[1];
+    }
+  }
+
+  private selectorToString(fieldValue: string, rule: MappingRules): string {
+    return this.booleanToString(fieldValue === rule.autodeFieldSelector);
+  }
+
+  private selectorArrayToSelector(fieldValue: string[], rule: MappingRules): string | void {
+    const lastVal = fieldValue[fieldValue.length - 1];
+    const match = this.selectorToSelector(lastVal, rule);
+
+    if (match && match !== 'default') {
+      return match;
+    }
+  }
+
+  private selectorArrayToString(fieldValue: string[], rule: MappingRules): string {
+    const match = fieldValue.includes(rule.autodeFieldSelector);
+    return this.booleanToString(match);
+  }
+
+  private dateToString(fieldValue: number, rule: MappingRules): string {
+    const date = new Date(fieldValue * 1000);
+    if (["['6']", "['7']", "['8']"].includes(rule.importField)) {
+      return `${date.getMonth() + 1}.${date.getFullYear()}`;
+    }
+    return `${date.getDate()}.${date.getMonth() + 1}.${date.getFullYear()}`;
+  }
+
+  private stringToMobile_model(fieldValue: string): string {
+    const model = fieldValue;
+    const subModel = get(this.currentCar, 'mainData.subModel');
+    return subModel && subModel !== model ? `${model} ${subModel}` : model;
+  }
+
+  private numberToMobile_consumption(fieldValue: number): string {
+    const consumption = this.numberToString(fieldValue);
+    return consumption.replace('.', ',');
+  }
+
+  private booleanToMobile_vatCalc(fieldValue: boolean): string {
+    return this.booleanToString(fieldValue);
+  }
+
+  private selectorToCategoryOrClass_selector(fieldValue: string, rule: MappingRules): string | void {
+    const pairs = rule.selectors.map(p => p.split(':'));
+    const found = pairs.find(p => p[1] === fieldValue);
+    if (found) {
+      return found[0];
+    }
+  }
+}

package/src/transformers/auto24.transfomer.ts

@@ -0,0 +1,155 @@
+import { Translator } from '@bytebrand/schema-tools';
+import { de } from '@bytebrand/i18n-dictionaries';
+import { get, toString, isNil, isEmpty, first } from 'lodash';
+import * as moment from 'moment';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { Auto24XmlItem } from '../interfaces/export-item.interface';
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '../services/config.service';
+import { isNotEmptyArray } from '../utils/validator.utils';
+
+@Injectable()
+export class Auto24Transformer {
+  private translator: Translator;
+
+  constructor(private configService: ConfigService) {
+    this.translator = new Translator(de);
+  }
+
+  transform(car: DataSchemes.Car, imboImages: ImboImageResponseInterface[]): Auto24XmlItem {
+    const autodeid = toString(get(car, '_id', ''));
+
+    return {
+      autodeid,
+      userlink: `https://www.${this.configService.config.url}/search/vehicle/${autodeid}`,
+      apilink: `https://www.${this.configService.config.url}/service/car-basic-data/api/v1/car/${autodeid}`,
+      brand: toString(get(car, 'mainData.make', '')),
+      modell: toString(get(car, 'mainData.model', '')),
+      cartype: 'pkw',
+      variant: toString(get(car, 'mainData.subModel', '')),
+      bodytype: this.translateSelector(get(car, 'mainData.category', '')),
+      fueltype: this.translateSelector(get(car, 'consumption.fuel', '')),
+      consumptionK: toString(get(car, 'consumption.consumptionCombined', '')),
+      co2: toString(get(car, 'environmentEmissions.co2', '')),
+      efficiencyclass: this.translateSelector(get(car, 'environmentEmissions.energyEfficiencyClass', '')),
+      image: this.getImageField(autodeid, toString(get(car, 'metaData.mainImageId')), imboImages),
+      registration: this.getRegistrationField(get(car, 'mainData.firstRegistration') as number),
+      images: this.getImagesField(autodeid, imboImages),
+      price: toString(get(car, 'price.currentSalesPrice', '')),
+      power: toString(get(car, 'engineData.powerKW', '')),
+      zip: toString(get(car, 'location.zipCode', '')),
+      city: toString(get(car, 'location.city', '')),
+      mileage: toString(get(car, 'mainData.mileage', '')),
+      companyname: 'www.auto.de',
+      extras: this.getExtrasField(car),
+      sellertype: 'dealer',
+    };
+  }
+
+  private translateSelector(selector: string): string {
+    if (isEmpty(selector) || selector === 'selector_unknown') {
+      return '';
+    }
+    return this.translator.translateVal(selector);
+  }
+
+  private getRegistrationField(registration: number): string {
+    if (isNil(registration)) {
+      return '';
+    }
+    return moment(registration * 1000).format('YYYY-MM');
+  }
+
+  private getExtrasField(car: DataSchemes.Car): string {
+    const booleanFields: string[] = [
+      'engineData.startStopSystem',
+      'window.panoramicGlassRoof',
+      'assistants.automaticRainSensor',
+      'assistants.cruiseControl',
+      'assistants.headUpDisplay',
+      'assistants.abs',
+      'assistants.esp',
+      'assistants.collisionAvoidance',
+      'assistants.trafficSignRecognition',
+      'lights.xenonHeadlights',
+      'lights.ledHeadlights',
+      'lights.laserHeadlights',
+      'lights.lightSensor',
+      'wheel.multifunctionalWheel',
+      'heatingCooling.auxiliaryHeating',
+      'trailerCoupling.trailerCouplingFix',
+      'trailerCoupling.trailerCouplingRemovable',
+      'trailerCoupling.trailerCouplingRotatable',
+      'multimedia.navigationSystem',
+      'multimedia.bluetooth',
+      'multimedia.handsFreePhoneSystem',
+    ];
+
+    const selectorFields: string[] = [
+      'driveSuspension.driveType',
+      'interior.interiorType',
+      'heatingCooling.climatisation',
+    ];
+
+    const selectorListFields: string[] = [
+      'seats.driverSeats',
+      'seats.coDriverSeats',
+      'seats.backSeats',
+      'assistants.parkingAssistants',
+      'airbags.airbag',
+    ];
+
+    const filteredBooleanFields = booleanFields.filter((field: string) => {
+      return get(car, field, false);
+    });
+
+    const filteredSelectorFields = selectorFields.filter((field: string) => {
+      const value = get(car, field);
+      return value && value !== 'selector_unknown';
+    });
+
+    const filteredSelectorListFields = selectorListFields.filter((field: string) => {
+      const list: string[] = get(car, field);
+      if (isNotEmptyArray(list)) {
+        const filtered: string[] = list.filter((selector: string) => {
+          return selector && selector !== 'selector_unknown';
+        });
+        return filtered.length;
+      }
+      return false;
+    });
+
+    return filteredBooleanFields
+      .concat(filteredSelectorFields)
+      .concat(filteredSelectorListFields)
+      .map((field: string) => {
+        return this.translator.translateVal(field.replace('.', '_'));
+      })
+      .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`;
+  }
+}