File

src/converter/multi-slot-container-converter/msc-product-item-converter.ts

Description

This class is a converter to transform product items from CmsComponent to MSCProductItemComponentData.

Index

Properties
Methods

Constructor

constructor(productService: ProductService)
Parameters :
Name Type Optional
productService ProductService No

Methods

Public convert
convert(source: CmsComponent)
Parameters :
Name Type Optional
source CmsComponent No
Private setImage
setImage(image: CmsImageMedia, imageAltTag?: string)
Parameters :
Name Type Optional
image CmsImageMedia No
imageAltTag string Yes
Returns : void
Private setProduct
setProduct(productCode: string)
Parameters :
Name Type Optional
productCode string No
Returns : void
Private stripCatalogFromProductIdentifier
stripCatalogFromProductIdentifier(productIdentifier: string)
Parameters :
Name Type Optional
productIdentifier string No
Returns : any

Properties

Private target
Type : MSCProductItemComponentData
import { Injectable, InjectionToken } from '@angular/core';
import { CmsComponent, Converter, ProductService } from '@spartacus/core';
import { nullSafe } from 'fs-spartacus-common';
import { CmsImageMedia } from '../../components/multi-slot-container/msc-items/msc-content-item/msc-content-item.model';
import { MSCProductItemComponentData } from '../../components/multi-slot-container/msc-items/msc-product-item/msc-product-item.model';

/**
 * This class is a converter to transform product items from {@link CmsComponent} to {@link MSCProductItemComponentData}.
 *
 * @export
 * @class MSCProductItemConverter
 */
@Injectable({ providedIn: 'root' })
export class MSCProductItemConverter implements Converter<CmsComponent, CmsComponent> {
  private target: MSCProductItemComponentData;
  constructor(private productService: ProductService) {}

  public convert(source: CmsComponent): MSCProductItemComponentData {
    this.target = {};
    const { otherProperties } = source;
    const { formData } = nullSafe(otherProperties, {});

    if (source.otherProperties != null) {
      this.target.previewId = otherProperties.previewId;
      this.setProduct(this.stripCatalogFromProductIdentifier(formData.st_product?.value[0]?.identifier));
      if (formData.st_picture?.value != null) {
        this.setImage(formData.st_picture.value, formData.st_altTag?.value);
      } else this.target.image = null;
      this.target.headline = nullSafe(formData.st_headline?.value, '');
      this.target.subline = nullSafe(formData.st_subline?.value, '');
      this.target.text = nullSafe(formData.st_text?.value, '');
      this.target.buttonText = nullSafe(formData.st_linkText?.value, '');
    }
    return this.target;
  }

  private setProduct(productCode: string): void {
    this.target.product = this.productService.get(productCode);
  }

  private stripCatalogFromProductIdentifier(productIdentifier: string) {
    const identifierParts = productIdentifier.split('/').filter(Boolean);
    if (identifierParts.length === 2) {
      return identifierParts[1];
    }
  }

  private setImage(image: CmsImageMedia, imageAltTag?: string): void {
    this.target.image = {
      url: image?.resolutions?.resolutionsMetaData?.ORIGINAL?.url ?? null,
      altTag: nullSafe(imageAltTag, ''),
    };
  }
}

export const MSCProductItemConverterToken = new InjectionToken<Converter<CmsComponent, CmsComponent>>('MSCProductItemConverter');

results matching ""

    No results matching ""