pim-import 2.47.4 → 2.49.2

package/src/pim/methods/products.ts

@@ -26,11 +26,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,
@@ -901,15 +904,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) {
@@ -942,6 +936,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;
 };
 
@@ -1757,3 +1764,292 @@ export const generateTechSpecPdf = async (topicProductId: string) => {
 
   return s3Url;
 };
+
+const getLightModuleAutoDescriptionByProductFields = async (
+  productFileds: any
+) => {
+  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?.electrical?.wPower) {
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      if (productFileds?.optical?.numberOfHeads >= 2) {
+        autoDescription[locale] += `${productFileds.optical.numberOfHeads} x `;
+      }
+      autoDescription[locale] += `${productFileds.electrical.wPower}W`;
+    }
+    if (productFileds?.photometric?.realNetFlow) {
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      if (productFileds?.optical?.numberOfHeads >= 2) {
+        autoDescription[locale] += `${productFileds.optical.numberOfHeads} x `;
+      }
+      autoDescription[locale] += `${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) {
+      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();
+  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
+      );
+
+      break;
+    default:
+      autoDescription = await getOtherAutoDescriptionByProductFields(
+        productFileds
+      );
+
+      break;
+  }
+
+  return autoDescription;
+};
+
+const setProductAutodescription = async (topicProduct: Entry) => {
+  log(`Set audtodescription of the topic ${topicProduct.sys.id}`);
+  const autoDescription = await getTopicProductAutodescription(
+    topicProduct.fields
+  );
+  topicProduct.fields.autoDescription = autoDescription;
+  if (!topicProduct.isArchived()) {
+    topicProduct = await topicProduct.update();
+    if (topicProduct.isPublished()) {
+      topicProduct = await topicProduct.publish();
+    }
+  } else {
+    log(
+      `Product ${topicProduct.sys.id} is archived, it is not possible to update the autodescription`,
+      "WARN"
+    );
+  }
+
+  return autoDescription;
+};
+
+export const setProductsAutodescription = 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) {
+    setProductAutodescription(item);
+  }
+
+  return {
+    catalog,
+    offset: Number(offset) + Number(limit),
+    limit: Number(limit),
+    completed: Number(offset) + Number(limit) >= total,
+    total,
+  };
+};
+
+export const setProductAutodescriptionByTopicId = async (
+  topicProductId: string
+) => {
+  const topicProduct = await getEntryByID(topicProductId, "topicProduct");
+
+  return await setProductAutodescription(topicProduct);
+};
+
+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