pim-import 2.47.3 → 2.49.1

package/src/pim/methods/products.ts

@@ -12,6 +12,7 @@ import {
   AvailableCatalogs,
   CfLocalizedEntryField,
   WrapperImageFields,
+  CfSys,
 } from "../../types";
 import { log } from "../../libs/logs";
 import {
@@ -26,11 +27,14 @@ import {
   addFieldValue,
   addToRelationFields,
   createWrapperImgix,
+  getDictionaryLocaleValue,
+  getDictionaryJson,
 } from "../../libs/contentful";
 import type {
   Entry,
   CreateEntryProps,
 } from "contentful-management/dist/typings/entities/entry";
+import { KeyValueMap } from "contentful-management/dist/typings/common-types";
 import {
   stringToSlug,
   secondBetweenTwoDate,
@@ -384,7 +388,10 @@ const getProductFields = (pimDetails: any) => {
   const productFields: any = {};
   productFieldsRequiredData.forEach((fieldData) => {
     if (fieldData.parent) {
-      if (pimDetails?.[fieldData.parent]?.[fieldData.key]) {
+      if (
+        pimDetails?.[fieldData.parent]?.[fieldData.key] ||
+        pimDetails?.[fieldData.parent]?.[fieldData.key] === false
+      ) {
         if (Array.isArray(pimDetails[fieldData.parent][fieldData.key])) {
           pimDetails[fieldData.parent][fieldData.key].forEach((item: any) => {
             if (!productFields?.[fieldData.parent]?.[fieldData.key]) {
@@ -413,7 +420,8 @@ const getProductFields = (pimDetails: any) => {
             };
           } else if (
             typeof pimDetails[fieldData.parent][fieldData.key] !== "object" &&
-            sanitizeValue(pimDetails[fieldData.parent][fieldData.key])
+            (sanitizeValue(pimDetails[fieldData.parent][fieldData.key]) ||
+              pimDetails[fieldData.parent][fieldData.key] === false)
           ) {
             value = pimDetails[fieldData.parent][fieldData.key];
           }
@@ -456,7 +464,8 @@ const getProductFields = (pimDetails: any) => {
             };
           } else if (
             typeof pimDetails[fieldData.key] !== "object" &&
-            sanitizeValue(pimDetails[fieldData.key])
+            (sanitizeValue(pimDetails[fieldData.key]) ||
+              pimDetails[fieldData.key] === false)
           ) {
             value = pimDetails[fieldData.key];
           }
@@ -896,15 +905,6 @@ const getProductData = async (
   // lastPimSyncDate
   data.fields = await addFieldValue(data, "lastPimSyncDate", getLocalISOTime());
 
-  // endpoint payload - used into setProductRelationships
-
-  const productEntryId = getTopicProductIdByCode(productDetails.code);
-  const { path, fileName } = getProductPayloadS3Details(productEntryId);
-  log(`Uploading "${fileName}" to S3 path "${path}"`);
-  const { Location } = await saveJsonToS3(pimDetails, fileName, path);
-  data.fields = await addFieldValue(data, "endpointPayload", Location);
-  log(`"${fileName}" uploaded to ${Location}`);
-
   // designers
   if (productDetails.designers) {
     for (const designer of productDetails.designers) {
@@ -937,6 +937,19 @@ const getProductData = async (
     }
   }
 
+  // autodescription
+  data.fields.autoDescription = await getTopicProductAutodescription(
+    data.fields
+  );
+
+  // endpoint payload - used into setProductRelationships
+  const productEntryId = getTopicProductIdByCode(productDetails.code);
+  const { path, fileName } = getProductPayloadS3Details(productEntryId);
+  log(`Uploading "${fileName}" to S3 path "${path}"`);
+  const { Location } = await saveJsonToS3(pimDetails, fileName, path);
+  data.fields = await addFieldValue(data, "endpointPayload", Location);
+  log(`"${fileName}" uploaded to ${Location}`);
+
   return data;
 };
 
@@ -1752,3 +1765,288 @@ export const generateTechSpecPdf = async (topicProductId: string) => {
 
   return s3Url;
 };
+
+const getLightModuleAutoDescriptionByProductFields = async (
+  productFileds: any,
+  catalogs: AvailableCatalogs[]
+) => {
+  const autoDescription: any = {};
+  const dictionaryJson = await getDictionaryJson();
+  for (const locale of cfLocales) {
+    if (!autoDescription?.[locale]) {
+      autoDescription[locale] = "";
+    }
+    let addSeparator = false;
+    if (productFileds?.electrical?.lampCategories) {
+      const lampCategoriesLocalizedValues = [];
+      for (const lampCategory of productFileds.electrical.lampCategories) {
+        const lampCategoryLocalizedValue = await getDictionaryLocaleValue(
+          locale,
+          "lampCategories",
+          lampCategory.code,
+          "electrical",
+          dictionaryJson
+        );
+        if (lampCategoryLocalizedValue) {
+          lampCategoriesLocalizedValues.push(lampCategoryLocalizedValue);
+        }
+      }
+
+      if (lampCategoriesLocalizedValues.length) {
+        if (addSeparator) {
+          autoDescription[locale] += " - ";
+        } else {
+          addSeparator = true;
+        }
+        autoDescription[locale] += lampCategoriesLocalizedValues.join(", ");
+        if (
+          productFileds.electrical.lampCategories.find(
+            (item: any) => item.code === "LAMPCAT4"
+          ) &&
+          productFileds?.photometric?.ledTypes?.length
+        ) {
+          const ledTypeLocalizedValues = [];
+          for (const ledType of productFileds?.photometric?.ledTypes) {
+            const ledTypeLocalizedValue = await getDictionaryLocaleValue(
+              locale,
+              "ledTypes",
+              ledType.code,
+              "photometric",
+              dictionaryJson
+            );
+            if (ledTypeLocalizedValue) {
+              ledTypeLocalizedValues.push(ledTypeLocalizedValue);
+            }
+          }
+
+          if (ledTypeLocalizedValues.length) {
+            if (addSeparator) {
+              autoDescription[locale] += " - ";
+            } else {
+              addSeparator = true;
+            }
+            autoDescription[locale] += ledTypeLocalizedValues.join(", ");
+          }
+        }
+      }
+    }
+
+    if (
+      productFileds?.optical?.numberOfHeads &&
+      productFileds?.optical?.numberOfHeads >= 2
+    ) {
+      if (productFileds?.electrical?.wPower) {
+        if (addSeparator) {
+          autoDescription[locale] += " - ";
+        } else {
+          addSeparator = true;
+        }
+        autoDescription[
+          locale
+        ] += `${productFileds.optical.numberOfHeads} x ${productFileds.electrical.wPower}`;
+      }
+      if (productFileds?.photometric?.realNetFlow) {
+        if (addSeparator) {
+          autoDescription[locale] += " - ";
+        } else {
+          addSeparator = true;
+        }
+        autoDescription[
+          locale
+        ] += `${productFileds.optical.numberOfHeads} x ${productFileds.photometric.realNetFlow}lm`;
+      }
+    }
+
+    if (productFileds?.photometric?.temperatureColor?.code) {
+      const temperatireColorLocalizedValue = await getDictionaryLocaleValue(
+        locale,
+        "temperatureColor",
+        productFileds.photometric.temperatureColor.code,
+        "photometric",
+        dictionaryJson
+      );
+      if (temperatireColorLocalizedValue) {
+        if (addSeparator) {
+          autoDescription[locale] += " - ";
+        } else {
+          addSeparator = true;
+        }
+        autoDescription[locale] += temperatireColorLocalizedValue;
+      }
+    }
+
+    if (productFileds?.photometric?.cri?.code) {
+      const CriLocalizedValue = await getDictionaryLocaleValue(
+        locale,
+        "cri",
+        productFileds.photometric.cri.code,
+        "photometric",
+        dictionaryJson
+      );
+      if (CriLocalizedValue) {
+        if (addSeparator) {
+          autoDescription[locale] += " - ";
+        } else {
+          addSeparator = true;
+        }
+        autoDescription[locale] += "CRI " + CriLocalizedValue;
+      }
+    }
+
+    if (
+      productFileds?.photometric?.beam0_180 &&
+      catalogs.indexOf("OUTDOOR") !== -1
+    ) {
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      autoDescription[locale] += "BEAM " + productFileds.photometric.beam0_180;
+    }
+  }
+
+  return autoDescription;
+};
+
+const getOtherAutoDescriptionByProductFields = async (productFileds: any) => {
+  const autoDescription: any = {};
+  const dictionaryJson = await getDictionaryJson();
+  for (const locale of cfLocales) {
+    if (!autoDescription?.[locale]) {
+      autoDescription[locale] = "";
+    }
+    let addSeparator = false;
+    // Profile and others
+    if (productFileds?.physical?.length) {
+      autoDescription[locale] += "Length: " + productFileds.physical.length;
+      addSeparator = true;
+    }
+
+    if (productFileds?.mountings) {
+      const mountingsLocalizedValues = [];
+      for (const mounting of productFileds.mountings) {
+        const mountingLocalizedValue = await getDictionaryLocaleValue(
+          locale,
+          "mountings",
+          mounting.code,
+          "",
+          dictionaryJson
+        );
+        if (mountingLocalizedValue) {
+          mountingsLocalizedValues.push(mountingLocalizedValue);
+        }
+      }
+
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      autoDescription[locale] += mountingsLocalizedValues.join(", ");
+    }
+  }
+
+  return autoDescription;
+};
+
+/**
+ * Get topicProduct autoDescription
+ *
+ * @param topicProduct
+ * @returns
+ */
+const getTopicProductAutodescription = async (
+  topicProductFields: KeyValueMap
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  let catalogs = topicProductFields?.catalogs?.[defaultEnvironmentLocaleCode];
+  if (catalogs) {
+    catalogs = catalogs.map((catalog: CfSys) => catalog.sys.id);
+  }
+  const productLineCode =
+    topicProductFields?.productLine?.[defaultEnvironmentLocaleCode]?.sys?.id;
+  const productFileds =
+    topicProductFields?.productFields?.[defaultEnvironmentLocaleCode];
+
+  let autoDescription: any = {};
+  switch (productLineCode) {
+    case "PLINE6": // Soft Plate
+    case "PLINE5": // Light Bulb
+    case "PLINE3": // Driver
+    case "PLINE2": // Accessory
+      // post_content
+      autoDescription = topicProductFields?.description;
+      break;
+    case "PLINE1": // Light Module
+      autoDescription = await getLightModuleAutoDescriptionByProductFields(
+        productFileds,
+        catalogs
+      );
+
+      break;
+    default:
+      autoDescription = await getOtherAutoDescriptionByProductFields(
+        productFileds
+      );
+
+      break;
+  }
+
+  return autoDescription;
+};
+
+export const setProductAutodescription = async (
+  catalog: AvailableCatalogs,
+  offset: number = 0,
+  limit: number = 100
+) => {
+  log(
+    `setProductAutodescription - catalog: ${catalog}, offset: ${offset}, limit: ${limit}`,
+    "INFO"
+  );
+  const env = await getEnvironment();
+  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
+
+  const { items, total } = await env.getEntries({
+    content_type: "topicProduct",
+    "fields.catalogs.sys.id": catalog,
+    limit,
+    skip: offset,
+    locale: defEnvLocaleCode,
+    include: 0,
+    select: "sys,fields",
+    "sys.archivedAt[exists]": false,
+  });
+
+  for (let item of items) {
+    log(`Set audtodescription of the topic ${item.sys.id}`);
+    const autoDescription = await getTopicProductAutodescription(item.fields);
+    item.fields.autoDescription = autoDescription;
+    if (!item.isArchived()) {
+      item = await item.update();
+      if (item.isPublished()) {
+        item = await item.publish();
+      }
+    } else {
+      log(
+        `Product ${item.sys.id} is archived, it is not possible to update the autodescription`,
+        "WARN"
+      );
+    }
+  }
+
+  return {
+    catalog,
+    offset: Number(offset),
+    limit: Number(limit),
+    completed: false,
+    total,
+  };
+};
+
+export const getProductAutodescription = async (topicProductId: string) => {
+  const topicProduct = await getEntryByID(topicProductId, "topicProduct");
+
+  return await getTopicProductAutodescription(topicProduct.fields);
+};

package/src/types.ts

@@ -40,7 +40,7 @@ export type PimLocale =
   | "no"
   | "da"
   | "ru";
-export type ContentfulLocale = "en-GB" | "en-US" | "it" | "es" | "de" | "fr";
+export type ContentfulLocale = "en" | "en-US" | "it" | "es" | "de" | "fr";
 
 export type PimValues = {
   value_en: string;

package/src/utils.ts

@@ -95,7 +95,7 @@ export const stringToSlug = (str: string, skipReplaceDots: boolean = false) => {
 };
 
 export const pimLocaleMap: Partial<Record<PimLocale, ContentfulLocale>> = {
-  en: "en-GB",
+  en: "en",
   en_US: "en-US",
   it: "it",
   es: "es",
@@ -210,7 +210,7 @@ export const capitalizeFirstLetter = (text: string) => {
  * Convert the keys of the object to lowercase
  *
  * @example
- * keysToLowerCase({'en-GB' : "Foo"}) -> {'en-gb': 'Foo'}
+ * keysToLowerCase({'en' : "Foo"}) -> {'en': 'Foo'}
  *
  * @param obj
  * @param includeNestedKeys if true all keys of all levels nested in the object will be converted