@bytebrand/export-cars 1.21.35 → 1.21.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebrand/export-cars",
-  "version": "1.21.35",
+  "version": "1.21.38",
   "description": "",
   "author": "bytebrand",
   "license": "UNLICENSED",

package/src/exporters/santander.exporter.ts

@@ -3,6 +3,7 @@ import { ModuleRef } from '@nestjs/core';
 
 import { CronicleUtils } from '@bytebrand/cronicle-helper';
 import { FsChunkInterface } from '@bytebrand/chunkable';
+import { Car } from '@bytebrand/car-schema/dist/schema/data';
 
 import { CarService, RulesService, LoaderService, ConfigService } from '../services';
 import { MobileTransformer } from '../transformers/mobile.transformer';
@@ -35,7 +36,8 @@ export class SantanderExporter implements Exporter {
 			chunk.data = chunk.data.filter(e => this.carService.filterCar(e, this.rulesService.rules));
 
 			if (chunk && chunk.data) {
-				for (const data of chunk.data) {
+				const filteredData = chunk.data.filter(({ car }) => !(!car.mainData.firstRegistration && car.mainData.mileage > 1000))
+				for (const data of filteredData) {
 					const { car, images } = data;
 					const transformedData = await santanderTransformer.transform(car, images);
 					const transformedNormalizedData = await santanderTransformer.normalizeCarData(transformedData);

package/src/transformers/mobile.transformer.ts

@@ -413,7 +413,7 @@ export class MobileTransformer {
     return this.booleanToString(match);
   }
 
-  private dateToString(fieldValue: number, rule: MappingRules): string {
+  protected 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()}`;

package/src/transformers/santander.transformer.ts

@@ -13,19 +13,20 @@ import { isNotEmptyArray } from '../utils';
 import { ConfigService } from '../services';
 import { ExportType } from '../enums';
 import { MobileTransformer } from './mobile.transformer';
+import { Car } from '@bytebrand/car-schema/dist/schema/data';
 
 const vinGenerator = require('vin-generator');
 
 @Injectable()
-export class SantanderTransformer extends MobileTransformer {
+export class SantanderTransformer {
+	private currentCar: DataSchemes.Car;
+
 	constructor(
-		mappingService: MappingService,
-		userService: UserService,
-		configService: ConfigService,
-		imagesService: ImagesService,
-	) {
-		super(mappingService, userService, configService, imagesService);
-	}
+		private mappingService: MappingService,
+		private userService: UserService,
+		private configService: ConfigService,
+		private imagesService: ImagesService,
+	) { }
 
 	async normalizeCarData(transformedCarData: unknown) {
 		const data = transformedCarData as Array<{ [key: string]: any }>;
@@ -44,4 +45,465 @@ export class SantanderTransformer extends MobileTransformer {
 		return outputArray;
 	}
 
+	async transform(carData: DataSchemes.Car, images: ImboImageResponseInterface[]): Promise<unknown> {
+		this.currentCar = carData;
+		const transformedCarData = {};
+		const rules = await this.mappingService.getRules();
+		for (const rule of rules) {
+			if (rule.custom === 'yes') {
+				const transformedField = await this.customTransformers(rule, carData, images);
+				if (transformedField) {
+					set(transformedCarData, `${rule.importField}`, transformedField);
+				}
+			} else {
+				const fieldValue: any = get(carData, `${rule.autodeField}`, null);
+				if (rule.autodeField === 'driveSuspension.gearbox' || rule.autodeField === 'mainData.mileage') {
+					set(transformedCarData, `${rule.importField}`, await this.customTransformers(rule, carData, images));
+				} else {
+					if (!isNil(fieldValue)) {
+						const transformedField = await this.transformField(fieldValue, rule);
+
+						if (!isNil(transformedField)) {
+							set(transformedCarData, `${rule.importField}`, transformedField);
+						}
+					}
+				}
+			}
+		}
+
+		set(transformedCarData, 150, toString(get(carData, 'rate.monthlyInstallment', '')));
+		set(transformedCarData, 293, toString(get(carData, 'leasing.monthlyInstallment', '')));
+		set(transformedCarData, 1, get(carData, 'metaData.vehicleId', null));
+
+		if (this.configService.config.campaign === 'eauto' && carData.offer.ftpFolder === 'auto_de_eautos') {
+			set(transformedCarData, 12, get(carData, 'offer.internalNumber', null));
+		}
+
+		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);
+			}
+			default:
+				LoggerService.log(`missing transform: ${transformProcedureName}`);
+				break;
+		}
+	}
+
+	private async offerStringToString(): Promise<string> {
+		const dealerId = get(this.currentCar, 'metaData.ownerId');
+		const descriptionSchema = await this.userService.getDefaultSummaryByDealerId(dealerId);
+		const descriptionBuilder = CarDescriptionFactory.create(DescriptionTypeEnum.Mobile, this.currentCar);
+		return descriptionBuilder.transform(descriptionSchema);
+	}
+
+	private async customTransformers(rule: MappingRules, car: DataSchemes.Car, images: ImboImageResponseInterface[]): Promise<unknown> {
+		switch (rule.autodeField) {
+			case 'image': {
+				return this.getImages(car, images);
+			}
+			case 'autodeUrl': {
+				return this.getAutodeUrl(car);
+			}
+			case 'persistentId': {
+				return this.getPersistentId(car);
+			}
+			case 'price.vatDeductible': {
+				return this.getVatDeductible(car);
+			}
+			case 'mainData.numberOfPreviousOwners': {
+				return this.getNumberOfPreviousOwners(car);
+			}
+			case 'mainData.condition': {
+				return this.getUsageType(car);
+			}
+			case 'price.vatRate': {
+				return this.getVatRate(car);
+			}
+			case 'price.currentSalesPrice': {
+				return this.getCurrentSalesPrice(car);
+			}
+			case 'driveSuspension.gearbox': {
+				return this.getGearBox(car);
+			}
+			case 'mainData.mileage': {
+				return this.getMilage(car);
+			}
+			case 'consumption.consumptionPowerCombined': {
+				return this.getWLTP(car);
+			}
+			case 'environmentEmissions.emissionClass': {
+				return this.getEmissionClass(car);
+			}
+			case 'environmentEmissions.energyEfficiencyClass': {
+				return this.getEnergyEfficiencyClass(car);
+			}
+			case 'environmentEmissions.emissionSticker': {
+				return this.getEmissionSticker(car);
+			}
+			case 'environmentEmissions.co2': {
+				return this.getCO2(car);
+			}
+			case 'metaData.vin': {
+				return this.getVinCode(car);
+			}
+			default:
+				return '';
+		}
+	}
+
+	private async getPersistentId(car: DataSchemes.Car) {
+		switch (this.configService.config.campaign) {
+			case ExportType.EAUTO:
+				if (car.offer.ftpFolder === 'auto_de_eautos') {
+					const dealers = await this.mappingService.getDealersMapping();
+					const dealerId = dealers.find(dealer => dealer.firebaseUserId === car.metaData.ownerId)?.dealerId;
+					if (dealerId) {
+						return dealerId;
+					}
+				}
+				return '416';
+			case ExportType.MARKTDE:
+				return '04109003';
+			case ExportType.EVIUM:
+				return '10022';
+			default:
+				throw new Error(`Wrong export type ${this.configService.config.campaign}`);
+		}
+	}
+
+	private getVatDeductible(car: DataSchemes.Car): string {
+		return this.booleanToString(!get(car, 'price.vatDeductible', false));
+	}
+
+	private getWLTP(car: DataSchemes.Car): string | void {
+		const envkvCompliant = get(car, 'consumption.envkvCompliant');
+		const hybridPlagin = get(car, 'engineData.hybridPlugin');
+
+		if (envkvCompliant && hybridPlagin) {
+			const powerCombined = get(car, 'consumption.consumptionPowerCombined');
+			return String(powerCombined);
+		}
+	}
+
+	private getEmissionClass(car: DataSchemes.Car): string | void {
+		const emissionClass = get(car, 'environmentEmissions.emissionClass', 'selector_unknown');
+		switch (emissionClass) {
+			case 'selector_emissionClass_euro1': {
+				return '1';
+			}
+			case 'selector_emissionClass_euro2': {
+				return '2';
+			}
+			case 'selector_emissionClass_euro3': {
+				return '3';
+			}
+			case 'selector_emissionClass_euro4':
+			case 'selector_unknown': {
+				return '4';
+			}
+			case 'selector_emissionClass_euro5': {
+				return '5';
+			}
+			case 'selector_emissionClass_euro6': {
+				return '6';
+			}
+			case 'selector_emissionClass_euro6b': {
+				return '6b';
+			}
+			case 'selector_emissionClass_euro6c': {
+				return '6c';
+			}
+			case 'selector_emissionClass_euro6d': {
+				return '6d';
+			}
+			case 'selector_emissionClass_euro6d_temp': {
+				return '6d-TEMP';
+			}
+		}
+	}
+
+	private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
+		const energyEfficiencyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+		switch (energyEfficiencyClass) {
+			case 'selector_energyEfficiencyClass_appp': {
+				return 'A+++';
+			}
+			case 'selector_energyEfficiencyClass_app': {
+				return 'A++';
+			}
+			case 'selector_energyEfficiencyClass_ap': {
+				return 'A+';
+			}
+			case 'selector_unknown':
+			case null: {
+				return 'C';
+			}
+			default: {
+				return energyEfficiencyClass.slice(-1).toUpperCase();
+			}
+		}
+	}
+
+	private getEmissionSticker(car: DataSchemes.Car): string | void {
+		const emissionSticker = get(car, 'environmentEmissions.emissionSticker', 'selector_unknown');
+		switch (emissionSticker) {
+			case 'selector_emissionSticker_no': {
+				return '1';
+			}
+			case 'selector_emissionSticker_red': {
+				return '2';
+			}
+			case 'selector_emissionSticker_yellow':
+			case 'selector_unknown': {
+				return '3';
+			}
+			case 'selector_emissionSticker_green': {
+				return '4';
+			}
+		}
+	}
+
+	private getCO2(car: DataSchemes.Car): string {
+		const consumptionFuel = get(car, 'consumption.fuel', 'selector_unknown');
+		if (consumptionFuel === 'selector_fuel_electrical') {
+			return '0';
+		}
+		return String(get(car, 'environmentEmissions.co2'));
+	}
+
+	private getNumberOfPreviousOwners(car: DataSchemes.Car): string {
+		const usageType = this.getUsageType(car);
+		if (usageType === '1' || !get(car, 'mainData.numberOfPreviousOwners')) {
+			return '0';
+		}
+		return String(get(car, 'mainData.numberOfPreviousOwners'));
+	}
+
+	private getUsageType(car: DataSchemes.Car): string {
+		const firstRegistration = get(car, 'mainData.firstRegistration');
+		if (firstRegistration) {
+			return '0';
+		}
+		return '1';
+	}
+
+	private getVatRate(car: DataSchemes.Car): string {
+		const isVatDeductible = get(car, 'price.vatDeductible', false);
+		if (isVatDeductible) {
+			return String(car.price.vatRate || 19);
+		}
+		return '0';
+	}
+
+	private getCurrentSalesPrice(car: DataSchemes.Car): string {
+		const vat = get(car, 'price.vatDeductible', false);
+		const currentSalesPrice = get(car, 'price.currentSalesPrice');
+		if (vat) {
+			const vatRate = get(car, 'price.vatRate', 19);
+			const price = (currentSalesPrice * 100) / (100 + vatRate);
+			return String(price.toFixed(2));
+		}
+		return String(currentSalesPrice);
+	}
+
+	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;
+	}
+
+	private getAutodeUrl(car: DataSchemes.Car): string {
+		return `https://www.${this.configService.config.domain}${car._id}?source=classifieds&medium=listing&campaign=${this.configService.config.campaign}`;
+	}
+
+	private async getImages(car: DataSchemes.Car, images: ImboImageResponseInterface[]): Promise<string | null> {
+		const transformedImages = await this.imagesService.getImages(car, images, this.configService.config.imageType, false);
+
+		if (this.configService.config.campaign == ExportType.EVIUM) return null;
+
+		if (isNotEmptyArray(transformedImages)) {
+			return transformedImages.map((el: string) => el).join(';');
+		}
+		return null;
+	}
+
+	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 '';
+		}
+
+		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 (["['8']"].includes(rule.importField)) {
+			if (!fieldValue) {
+				const now = new Date()
+				const month = String(now.getMonth() + 1);
+				const year = now.getFullYear();
+				return `${month}.${year}`;
+			}
+		}
+		if (["['6']", "['7']"].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): string {
+		const rules: { [key: string]: string } = {
+			selector_category_convertible: 'Cabrio',
+			selector_category_combi: 'Kombi',
+			selector_category_sedan: 'Limousine',
+			selector_category_suv: 'OffRoad',
+			selector_category_compact: 'SmallCar',
+			selector_category_coupe: 'SportsCar',
+			selector_category_van: 'Van',
+			selector_category_minibus: 'Van',
+			selector_category_transporter: 'OtherCar',
+			selector_unknown: 'OtherCar',
+		};
+
+		const found = rules[fieldValue];
+		if (found) {
+			return `Car.${found}`;
+		} else {
+			LoggerService.log(`Missing mapping for: ${fieldValue}`);
+			return 'Car.OtherCar';
+		}
+	}
+
+	private getGearBox(car: DataSchemes.Car): unknown {
+		const rules: { [x: string]: string } = {
+			selector_gearbox_manualShift: '1',
+			selector_gearbox_semiAutomatic: '2',
+			selector_gearbox_automatic: '3',
+			selector_unknown: '0',
+		};
+		const autodeGearboxSelector = get(car, 'driveSuspension.gearbox', 'selector_unknown');
+
+		return rules[autodeGearboxSelector];
+	}
+
+	private getMilage(car: DataSchemes.Car): string {
+		// TODO:: fix if cbd
+		const mileage = car.mainData.mileage;
+		if (mileage <= 0) {
+			return '0';
+		}
+		return mileage.toString();
+	}
 }