pim-import 2.47.4 → 2.49.2

package/src/algolia/products.ts

@@ -1,21 +1,16 @@
 /**
  * Product index
  */
-import { cfLocales } from "../libs/contentful";
 import {
   getClient,
   getEnvironmentDefaultLocaleCode,
   getEntryByID,
   getTopicDetails,
-  getDictionaryJson,
-  getDictionaryLocaleValue,
 } from "../libs/contentful-cda";
 import {
   CfLocalizedEntryField,
   TopicDetailsResponse,
-  AvailableCatalogs,
   AlgoliaPaginateRecords,
-  CfSys,
   WrapperImageFields,
 } from "../types";
 import type { Entry } from "contentful-management/dist/typings/entities/entry";
@@ -62,218 +57,6 @@ const indexKey: AvailableIndicesKey = "products";
 const topicProductSelect =
   "sys,fields.name,fields.code,fields.catalogs,fields.categoriesArchitectural,fields.categoriesOutdoor,fields.categoriesDecorative,fields.families,fields.subFamiliesArchitectural,fields.subFamiliesOutdoor,fields.subFamiliesDecorative,fields.modelsArchitectural,fields.modelsOutdoor,fields.modelsDecorative,fields.subModelsArchitectural,fields.subModelsOutdoor,fields.subModelsDecorative,fields.productLine,fields.productSubLine,fields.productFields,fields.thumbnailImgix";
 
-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;
-};
-
 const pipedreamPDFGenerator = async (topicProductId: string) => {
   if (process.env.FPI_PIPEDREAM_TECH_SPEC_PDF) {
     const res = await axios.get(process.env.FPI_PIPEDREAM_TECH_SPEC_PDF, {
@@ -455,9 +238,7 @@ const getObject = async (
   );
 
   log(`Get autoDescription...`);
-  const autoDescription = await getTopicProductAutodescription(
-    topicProductWithFields
-  );
+  const autoDescription = topicProductWithFields?.fields?.autoDescription ?? {};
 
   log(`Get thumbnail imgix details...`);
   let thumbnailImgix = {};

package/src/algolia/stories.ts

@@ -0,0 +1,187 @@
+import { log } from "../libs/logs";
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+  getTopicPage,
+} from "../libs/contentful-cda";
+import { getIndex, AvailableIndicesKey, removeIndexObject } from "./config";
+import { getLocalISOTime, secondBetweenTwoDate } from "../utils";
+import type { Entry } from "contentful-management/dist/typings/entities/entry";
+import { CfLocalizedEntryField, AlgoliaPaginateRecords } from "../types";
+
+const indexKey: AvailableIndicesKey = "stories";
+
+export type AlgoliaStoryRecord = {
+  objectID: string;
+  name?: CfLocalizedEntryField;
+  excerpt?: CfLocalizedEntryField;
+  description?: CfLocalizedEntryField;
+  slugs?: {};
+  lastSyncDate?: string;
+};
+
+const getObject = async (topicStory: Entry): Promise<AlgoliaStoryRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Sync the ${topicStory.sys.id} topicStory...`);
+  let topicStoryWithFields: Entry = topicStory;
+
+  const emptyLocalizedField: CfLocalizedEntryField = {
+    [defaultEnvironmentLocaleCode]: "",
+  };
+
+  if (!topicStoryWithFields?.fields) {
+    log(`Get the ${topicStory.sys.id} topicStory details...`);
+    topicStoryWithFields = await getEntryByID(topicStory.sys.id, "topicStory");
+  }
+
+  if (!topicStoryWithFields) {
+    log(`The topicStory ${topicStory.sys.id} not found`, "WARN");
+
+    const recordFail: AlgoliaStoryRecord = {
+      objectID: topicStory?.sys?.id,
+    };
+
+    return recordFail; // return objectID to delete the record if it exists
+  }
+
+  log(`Get page details...`);
+  const page = await getTopicPage(topicStory.sys.id, "fields.slug");
+  const slugs = page?.fields.slug || {};
+
+  // Single record
+  const record: AlgoliaStoryRecord = {
+    objectID: topicStoryWithFields.sys.id,
+    name: topicStoryWithFields?.fields?.title || emptyLocalizedField,
+    excerpt: topicStoryWithFields?.fields?.excerpt || emptyLocalizedField,
+    description:
+      topicStoryWithFields?.fields?.description || emptyLocalizedField,
+    slugs,
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+export const reindexStory = async (topicStoryId: string) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+
+  log(`reindexStory - entryId: ${topicStoryId} `);
+
+  const topicStory = await getEntryByID(topicStoryId, "topicStory");
+
+  if (!topicStory) {
+    log(`No topicStoryId found with id ${topicStoryId}`, "WARN");
+    return false;
+  }
+
+  const object = await getObject(topicStory);
+
+  // Save record to Algolia
+  const index = getIndex(indexKey);
+  let record = null;
+  const slugs: any = object?.slugs;
+  if (slugs?.[defaultEnvironmentLocaleCode]) {
+    log(`Save object`);
+    record = await index.saveObject(object);
+  } else {
+    log(`Delete object`);
+    record = await index.deleteObject(object.objectID);
+  }
+  const timeEnd = new Date();
+  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+  log(`Execution time: ${seconds} seconds`);
+
+  return { ...record, ...object };
+};
+
+/**
+ * Get Objects
+ *
+ * @param offset
+ * @param limit
+ * @param filterKey
+ * @param filterValue
+ * @returns
+ */
+const getObjects = async (
+  offset: number,
+  limit: number,
+  filterKey?: string,
+  filterValue?: string
+): Promise<AlgoliaPaginateRecords> => {
+  const client = await getClient();
+
+  const opts: any = {
+    content_type: "topicStory",
+    limit,
+    skip: offset,
+    locale: "*",
+    // select: "",
+  };
+  if (filterKey && filterValue) {
+    opts[filterKey] = filterValue;
+  }
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaStoryRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicStory of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicStory);
+    const timeEnd = new Date();
+    const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+    log(`Execution time: ${seconds} seconds`);
+    objects.push(record);
+  }
+
+  return {
+    objects,
+    offset: Number(offset) + Number(limit),
+    limit: Number(limit),
+    completed: count >= total, // if is true the import is completed
+    total,
+  };
+};
+
+export const reindexStories = async (
+  offset: number = 0,
+  limit: number = 50,
+  filterKey: string = "",
+  filterValue: string = ""
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+  log(
+    `reindexStories - filterKey: ${filterKey} filterValue: ${filterValue} offset: ${offset} limit: ${limit} `
+  );
+
+  const records = await getObjects(offset, limit, filterKey, filterValue);
+  const objectsToSave = records.objects.filter(
+    (object) => object?.slugs?.[defaultEnvironmentLocaleCode]
+  );
+  const objectIdsToDelete = records.objects
+    .filter((object) => !object?.slugs?.[defaultEnvironmentLocaleCode])
+    .map((object) => object.objectID);
+
+  // Save records to Algolia
+  const index = getIndex(indexKey);
+  log(`Save ${objectsToSave.length} objects to ${index.indexName} index`);
+  const savedObjectIDs = await index.saveObjects(objectsToSave);
+  log(
+    `Delete ${objectIdsToDelete.length} objects from ${index.indexName} index`
+  );
+  const deletedObjectIDs = await index.deleteObjects(objectIdsToDelete);
+
+  const timeEnd = new Date();
+  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+  log(`Execution time: ${seconds} seconds`);
+
+  return { ...records, ...savedObjectIDs, ...deletedObjectIDs };
+};
+
+export const removeStoryObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/index.ts

@@ -36,6 +36,9 @@ export {
   getAllProductEntriesByCatalog,
   audit,
   generateTechSpecPdf,
+  setProductsAutodescription,
+  getProductAutodescription,
+  setProductAutodescriptionByTopicId,
 } from "./pim/methods/products";
 // export {
 //   createOrUpdateCatalogPages,
@@ -86,6 +89,11 @@ export {
   reindexProjects,
   removeProjectObject,
 } from "./algolia/projects";
+export {
+  reindexStory,
+  reindexStories,
+  removeStoryObject,
+} from "./algolia/stories";
 export { importDownloads } from "./downloads/import";
 export { getLocalISOTime } from "./utils";
 export { getStaticDailyProducts } from "./pim/endpoints";

package/src/libs/contentful-cda.ts

@@ -244,7 +244,7 @@ export const getEntryImageDetails = async (entry: Entry, fieldKey: string) => {
  *     'en-US': 'Architectural Lighting',
  *     ...
  *   },
- *   code: { 'en-GB': 'ARCHITECTURAL' },
+ *   code: { 'en': 'ARCHITECTURAL' },
  *   slugs: {
  *     de: 'architectural lighting',
  *     'en-US': 'architectural lighting'

package/src/libs/contentful.ts

@@ -43,7 +43,7 @@ export let defaultEnvironmentLocale: Locale;
 export let defaultEnvironmentLocaleCode: string;
 
 export const cfLocales: ContentfulLocale[] = [
-  "en-GB",
+  "en",
   "en-US",
   "it",
   "es",
@@ -537,10 +537,10 @@ export const initBaseEntries = async (): Promise<boolean> => {
       },
     };
     regionGlobalEntryData.fields.region[defaultEnvCode] = "global";
-    regionGlobalEntryData.fields.defaultLocale[defaultEnvCode] = "en-GB";
+    regionGlobalEntryData.fields.defaultLocale[defaultEnvCode] = "en";
     regionGlobalEntryData.fields.locales[defaultEnvCode] = [
       "en-US",
-      "en-GB",
+      "en",
       "it",
       "de",
       "fr",
@@ -1023,7 +1023,7 @@ export const addFieldValue = async (
  *     'en-US': 'Architectural Lighting',
  *     ...
  *   },
- *   code: { 'en-GB': 'ARCHITECTURAL' },
+ *   code: { 'en': 'ARCHITECTURAL' },
  *   slugs: {
  *     de: 'architectural lighting',
  *     'en-US': 'architectural lighting'