pim-import 2.47.1 → 2.48.0

package/src/pim/methods/products.ts

@@ -12,6 +12,7 @@ import {
   AvailableCatalogs,
   CfLocalizedEntryField,
   WrapperImageFields,
+  CfSys,
 } from "../../types";
 import { log } from "../../libs/logs";
 import {
@@ -26,6 +27,8 @@ import {
   addFieldValue,
   addToRelationFields,
   createWrapperImgix,
+  getDictionaryLocaleValue,
+  getDictionaryJson,
 } from "../../libs/contentful";
 import type {
   Entry,
@@ -384,7 +387,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 +419,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 +463,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];
           }
@@ -1752,3 +1760,265 @@ 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?.wPower &&
+      catalogs.indexOf("ARCHITECTURAL") !== -1
+    ) {
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      autoDescription[locale] += productFileds.electrical.wPower;
+    }
+
+    if (
+      productFileds?.optical?.numberOfHeads &&
+      productFileds?.optical?.numberOfHeads > 1 &&
+      productFileds?.photometric?.realNetFlow &&
+      catalogs.indexOf("ARCHITECTURAL") !== -1
+    ) {
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      autoDescription[locale] +=
+        productFileds.optical.numberOfHeads +
+        " x " +
+        productFileds.photometric.realNetFlow;
+    } else if (
+      productFileds?.photometric?.realNetFlow &&
+      catalogs.indexOf("ARCHITECTURAL") !== -1
+    ) {
+      if (addSeparator) {
+        autoDescription[locale] += " - ";
+      } else {
+        addSeparator = true;
+      }
+      autoDescription[locale] += productFileds.photometric.realNetFlow;
+    }
+
+    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 (topicProduct: Entry) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  let catalogs = topicProduct?.fields?.catalogs?.[defaultEnvironmentLocaleCode];
+  if (catalogs) {
+    catalogs = catalogs.map((catalog: CfSys) => catalog.sys.id);
+  }
+  const productLineCode =
+    topicProduct?.fields?.productLine?.[defaultEnvironmentLocaleCode]?.sys?.id;
+  const productFileds =
+    topicProduct?.fields?.productFields?.[defaultEnvironmentLocaleCode];
+
+  let autoDescription: any = {};
+  switch (productLineCode) {
+    case "PLINE6": // Soft Plate
+    case "PLINE5": // Light Bulb
+    case "PLINE3": // Driver
+    case "PLINE2": // Accessory
+      // post_content
+      autoDescription = topicProduct?.fields?.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);
+    item.fields.autoDescription = autoDescription;
+    console.log(item.fields);
+    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,
+  };
+};