pim-import 2.22.0 → 2.24.0

package/src/algolia/{collections.ts → families.ts}

@@ -1,5 +1,5 @@
 /**
- * Collection index
+ * Families index
  */
 import {
   getClient,
@@ -52,7 +52,7 @@ export type AlgoliaFamilyRecord = {
   lastSyncDate: string;
 };
 
-const indexKey: AvailableIndicesKey = "collections";
+const indexKey: AvailableIndicesKey = "families";
 
 const getFamilyPage = async (topicFamily: Entry): Promise<pageResponse> => {
   const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
@@ -317,9 +317,7 @@ const getObject = async (topicFamily: Entry): Promise<AlgoliaFamilyRecord> => {
   log(`Get productFields details...`);
   const productFields = await getProductFields(topicFamily);
 
-  const isNew: boolean = !!productFields?.upgrade?.find(
-    (item: any) => item === "UP3"
-  );
+  const isNew: boolean = topicFamilyWithFields?.fields?.isNew || false;
 
   log(`Get thumbnail imgix details...`);
   let thumbnailImgix = {};
@@ -409,12 +407,12 @@ const getObjects = async (
   };
 };
 
-export const reindexCollections = async (
+export const reindexFamilies = async (
   offset: number = 0,
   limit: number = 50
 ) => {
   const timeStart = new Date();
-  log(`reindexCollections - offset: ${offset} limit: ${limit} `);
+  log(`reindexFamilies - offset: ${offset} limit: ${limit} `);
 
   const records = await getObjects(offset, limit);
   const objectsToSave = records.objects.filter(
@@ -440,10 +438,10 @@ export const reindexCollections = async (
   return { ...records, ...savedObjectIDs, ...deletedObjectIDs };
 };
 
-export const reindexCollection = async (topicFamilyEntryId: string) => {
+export const reindexFamily = async (topicFamilyEntryId: string) => {
   const timeStart = new Date();
 
-  log(`reindexCollection - entryId: ${topicFamilyEntryId} `);
+  log(`reindexFamily - entryId: ${topicFamilyEntryId} `);
 
   // Get single object data
   const topicFamily = await getEntryByID(topicFamilyEntryId, "topicFamily");
@@ -466,6 +464,6 @@ export const reindexCollection = async (topicFamilyEntryId: string) => {
   return { ...record, ...object };
 };
 
-export const removeCollectionObject = async (objectId: string) => {
+export const removeFamilyObject = async (objectId: string) => {
   return removeIndexObject(objectId, indexKey);
 };

package/src/algolia/models.ts

@@ -56,6 +56,7 @@ type AlgoliaModelRecord = {
   productLine?: TopicDetailsResponse;
   catalog?: TopicDetailsResponse;
   subFamily?: TopicDetailsResponse;
+  isNew?: boolean;
   priority?: number;
   colors?: string[];
   lastSyncDate?: string;
@@ -251,6 +252,7 @@ const getObject = async (
     catalog,
     subFamily,
     colors,
+    isNew: topicModelWithFields?.fields?.isNew || false,
     priority:
       topicModelWithFields?.fields?.priority?.[defaultEnvironmentLocaleCode] ||
       0,

package/src/algolia/subFamilies.ts

@@ -0,0 +1,429 @@
+/**
+ * SubFamilies index
+ */
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+  getAllEntries,
+  getTopicDetails,
+} from "../libs/contentful-cda";
+import { AlgoliaPaginateRecords } from "../types";
+import type { Entry } from "contentful-management/dist/typings/entities/entry";
+import { log } from "../libs/logs";
+import { getIndex, AvailableIndicesKey, removeIndexObject } from "./config";
+import {
+  getLocalISOTime,
+  sanitizeValue,
+  secondBetweenTwoDate,
+  keysToLowerCase,
+  addProductFieldValueCodesByPimDetails,
+  capitalizeFirstLetter,
+} from "../utils";
+import { getWrapperImgixFields } from "../libs/imgix";
+import { AlgoliaFamilyRecord, pageResponse } from "./families";
+
+const indexKey: AvailableIndicesKey = "subFamilies";
+
+const getSubFamilyPage = async (
+  topicSubFamily: Entry
+): Promise<pageResponse> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const subFamilyPage = await getEntryByID(
+    `${topicSubFamily.sys.id}_PAGE`,
+    "page"
+  );
+  if (!subFamilyPage) {
+    log(`${topicSubFamily.sys.id}_PAGE not found`, "WARN");
+    return {
+      slugs: {},
+      type: "",
+      details: {},
+    };
+  }
+
+  const subFamilyPageId = subFamilyPage.sys.id;
+
+  // check if subFamily has many relations with model
+  const client = await getClient();
+  const { items: modelEntries } = await client.getEntries({
+    content_type: "topicModel",
+    "fields.subFamily.sys.id": subFamilyPageId.replace("_PAGE", ""),
+    limit: 2,
+    locale: "*",
+    select: "sys,fields.catalog,fields.subFamily",
+  });
+
+  if (modelEntries?.length === 1) {
+    // Return model page slug
+    const modelEntry = modelEntries[0];
+    const modelPageId = `${modelEntry.sys.id}_PAGE`;
+    const modelPage = await getEntryByID(
+      modelPageId,
+      "page",
+      "fields.slug,fields.type"
+    );
+
+    const catalogEntryId =
+      modelEntry?.fields?.catalog?.[defaultEnvironmentLocaleCode]?.sys?.id;
+    const modelCatalogPage: any = catalogEntryId
+      ? await getEntryByID(`${catalogEntryId}_PAGE`, "page", "fields.slug")
+      : {};
+    const subFamilyEntryId =
+      modelEntry?.fields?.subFamily?.[defaultEnvironmentLocaleCode]?.sys?.id;
+    const modelCatalogSubFamilyPage: any = subFamilyEntryId
+      ? await getEntryByID(`${subFamilyEntryId}_PAGE`, "page", "fields.slug")
+      : {};
+    if (modelPage) {
+      return {
+        slugs: modelPage?.fields?.slug,
+        type: modelPage?.fields?.type?.[defaultEnvironmentLocaleCode],
+        details: {
+          catalogPageSlugs:
+            keysToLowerCase(modelCatalogPage?.fields?.slug) || {},
+          subFamilyPageSlugs:
+            keysToLowerCase(modelCatalogSubFamilyPage?.fields?.slug) || {},
+        },
+      };
+    } else {
+      log(`The modelPage with id "${modelPageId}" not found`, "WARN");
+    }
+  }
+
+  // Return SubFamily page slug
+  if (subFamilyPage) {
+    return {
+      slugs: subFamilyPage?.fields?.slug,
+      type: subFamilyPage?.fields?.type?.[defaultEnvironmentLocaleCode],
+      details: {},
+    };
+  } else {
+    log(
+      `The subFamilyPage with id "${topicSubFamily.sys.id}_PAGE" not found`,
+      "WARN"
+    );
+  }
+
+  // if it doesn't find any slugs
+  return null;
+};
+
+const getProductFields = async (topicSubFamily: Entry): Promise<any> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const catalogName = capitalizeFirstLetter(
+    (
+      topicSubFamily.fields.catalog?.[defaultEnvironmentLocaleCode]?.sys.id ||
+      ""
+    ).toLowerCase()
+  );
+  if (!catalogName) {
+    console.log(topicSubFamily.fields.catalog);
+    log(`Cannot find catalog name`, "WARN");
+    return {};
+  }
+
+  const fieldName = `subFamilies${catalogName}`;
+
+  const topicProductEntries = await getAllEntries(
+    "topicProduct",
+    "sys,fields.productFields",
+    `fields.${fieldName}.sys.id[in]`,
+    `${topicSubFamily.sys.id}`,
+    50
+    // [ TODO: Riabilitare il filtro una votla passati alla CDA
+    //   {
+    //     key: "fields.pimStatus",
+    //     value: "Published",
+    //   },
+    // ]
+  );
+  if (!topicProductEntries?.length) {
+    log(`No products founded for subFamily ${topicSubFamily.sys.id}`, "WARN");
+    return false;
+  } else {
+    log(`${topicProductEntries?.length} products founded`);
+  }
+
+  let productFields: any = {};
+
+  for (const topicProduct of topicProductEntries) {
+    if (topicProduct?.fields?.productFields?.[defaultEnvironmentLocaleCode]) {
+      const pimDetails =
+        topicProduct?.fields?.productFields?.[defaultEnvironmentLocaleCode];
+
+      if (!productFields?.certification) {
+        productFields.certification = [];
+      }
+
+      // CERTIFICATION - ENEC | PIM certification->enec
+      if (
+        pimDetails?.certification?.enec?.code &&
+        sanitizeValue(pimDetails.certification.enec.code) &&
+        productFields?.certification.indexOf("ENEC") === -1
+      ) {
+        productFields.certification.push("ENEC");
+      }
+      // CERTIFICATION - UL | PIM certification->ul
+      if (
+        pimDetails?.certification?.ul?.code &&
+        sanitizeValue(pimDetails.certification.ul.code) &&
+        productFields?.certification.indexOf("UL") === -1
+      ) {
+        productFields.certification.push("UL");
+      }
+
+      // MOUNTINGS [Has many]
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "mountings"
+      );
+
+      // ORINTATIONS [Has many]
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "orientations",
+        "physical"
+      );
+
+      // DRIVER TYPE | PIM powerSupplyType [Has many]
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "powerSupplyType",
+        "electrical"
+      );
+
+      // LIGHTING DISTRIBUTIONS | PIM powerSupplyType [Has many]
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "lightingDistributions",
+        "optical"
+      );
+
+      // OPTICAL TYPE [Only one]
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "opticalType",
+        "optical"
+      );
+
+      // MARKETS [Has many]
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "markets"
+      );
+
+      // UPGRADE
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "upgrade"
+      );
+
+      // CERTIFICATIONS
+      productFields = addProductFieldValueCodesByPimDetails(
+        pimDetails,
+        productFields,
+        "certifications"
+      );
+    }
+  }
+
+  return productFields;
+};
+
+const getObject = async (
+  topicSubFamily: Entry
+): Promise<AlgoliaFamilyRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Get details of the ${topicSubFamily.sys.id} topicSubFamily`);
+  const topicSubFamilyWithFields = await getEntryByID(
+    topicSubFamily.sys.id,
+    "topicSubFamily"
+  );
+
+  log(`Get page details...`);
+  const page = await getSubFamilyPage(topicSubFamilyWithFields);
+  log(`Slugs type: ${page?.type}`);
+
+  log(`Get catalogs details...`);
+  const catalogs = await getTopicDetails(
+    topicSubFamilyWithFields,
+    "catalog",
+    "topicCatalog",
+    true
+  );
+  log(`${catalogs?.length} catalogs founded`);
+
+  log(`Get categories details...`);
+  const categories = await getTopicDetails(
+    topicSubFamilyWithFields,
+    "category",
+    "topicCategory",
+    true
+  );
+  log(`${categories?.length} categories founded`);
+
+  log(`Get productFields details...`);
+  const productFields = await getProductFields(topicSubFamilyWithFields);
+
+  const isNew: boolean = topicSubFamilyWithFields?.fields?.isNew || false;
+
+  log(`Get thumbnail imgix details...`);
+  let thumbnailImgix = {};
+  const thumbnailImgixWrapperImgixID =
+    topicSubFamilyWithFields?.fields?.thumbnailImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (thumbnailImgixWrapperImgixID) {
+    thumbnailImgix = await getWrapperImgixFields(thumbnailImgixWrapperImgixID);
+  } else {
+    log(`No thumbnail imgix found`, "WARN");
+  }
+
+  log(`Get full screen imgix details...`);
+  let fullScreenImageImgix = {};
+  const fullScreenImageImgixWrapperImgixID =
+    topicSubFamilyWithFields?.fields?.fullScreenImageImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (fullScreenImageImgixWrapperImgixID) {
+    fullScreenImageImgix = await getWrapperImgixFields(
+      fullScreenImageImgixWrapperImgixID
+    );
+  } else {
+    log(`No full screen imgix found`, "WARN");
+  }
+
+  log(`Get priority details...`);
+  const priority =
+    topicSubFamilyWithFields?.fields?.priority?.[
+      defaultEnvironmentLocaleCode
+    ] || 0;
+
+  // Single record
+  const record: AlgoliaFamilyRecord = {
+    objectID: topicSubFamilyWithFields.sys.id,
+    names: keysToLowerCase(topicSubFamilyWithFields?.fields?.name) || {},
+    code:
+      topicSubFamilyWithFields?.fields?.code?.[defaultEnvironmentLocaleCode] ||
+      {},
+    thumbnailImgix,
+    fullScreenImageImgix,
+    slugs: keysToLowerCase(page?.slugs) || {},
+    slugType: page?.type || "",
+    slugDetails: page?.details || {},
+    catalogs,
+    categories,
+    productFields,
+    priority,
+    isNew,
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+const getObjects = async (
+  offset: number,
+  limit: number
+): Promise<AlgoliaPaginateRecords> => {
+  const client = await getClient();
+
+  const opts: any = {
+    content_type: "topicSubFamily",
+    limit,
+    skip: offset,
+    locale: "*",
+    select: "sys",
+  };
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaFamilyRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicSubFamily of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicSubFamily);
+    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
+  };
+};
+
+export const reindexSubFamilies = async (
+  offset: number = 0,
+  limit: number = 50
+) => {
+  const timeStart = new Date();
+  log(`reindexSubFamilies - offset: ${offset} limit: ${limit} `);
+
+  const records = await getObjects(offset, limit);
+  const objectsToSave = records.objects.filter(
+    (object) => object.productFields
+  );
+  const objectIdsToDelete = records.objects
+    .filter((object) => !object?.productFields)
+    .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 reindexSubFamily = async (topicSubFamilyEntryId: string) => {
+  const timeStart = new Date();
+
+  log(`reindexSubFamily - entryId: ${topicSubFamilyEntryId} `);
+
+  // Get single object data
+  const topicSubFamily = await getEntryByID(
+    topicSubFamilyEntryId,
+    "topicSubFamily"
+  );
+  const object = await getObject(topicSubFamily);
+
+  // Save record to Algolia
+  const index = getIndex(indexKey);
+  let record = null;
+  if (object.productFields) {
+    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 };
+};
+
+export const removeSubFamilyObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/algolia/subModels.ts

@@ -44,6 +44,7 @@ type AlgoliaSubModelRecord = {
   catalog?: TopicDetailsResponse;
   subFamily?: TopicDetailsResponse;
   parentModel?: TopicDetailsResponse;
+  isNew?: boolean;
   priority?: number;
   productCounter?: number;
   lastSyncDate?: string;
@@ -226,6 +227,7 @@ const getObject = async (
       topicSubModelWithFields?.fields?.priority?.[
         defaultEnvironmentLocaleCode
       ] || 0,
+    isNew: topicSubModelWithFields?.fields?.isNew || false,
     productCounter: await getProductCounter(topicSubModelWithFields),
     lastSyncDate: getLocalISOTime(),
   };

package/src/index.ts

@@ -38,10 +38,15 @@ export {
 } from "./pim/methods/pages/catalogs";
 export { resetIndexSettings } from "./algolia/config";
 export {
-  reindexCollections,
-  reindexCollection,
-  removeCollectionObject,
-} from "./algolia/collections";
+  reindexFamilies,
+  reindexFamily,
+  removeFamilyObject,
+} from "./algolia/families";
+export {
+  reindexSubFamilies,
+  reindexSubFamily,
+  removeSubFamilyObject,
+} from "./algolia/subFamilies";
 export {
   createOrUpdateSubFamilyPages,
   createOrUpdateSubFamilyPageByCode,

package/src/libs/contentful.ts

@@ -237,7 +237,14 @@ export const updateEntry = async (
   for (const [key, value] of Object.entries(data.fields)) {
     itemEntry.fields[key] = value;
   }
-  const entry = await itemEntry.update();
+
+  let entry = itemEntry;
+  try {
+    entry = await itemEntry.update();
+  } catch (err) {
+    log(`Cannot update entry.`);
+    log(err);
+  }
 
   if (publish) {
     try {

package/src/pim/endpoints.ts

@@ -240,6 +240,8 @@ export const getStaticDailyProducts = async (
     };
     checkConfig();
 
+    log(`Requesting daily update on ${config.baseURL}static-daily-products`);
+    log(`Params: ${JSON.stringify(opts)}`);
     const { data } = await axios.get(`${config.baseURL}static-daily-products`, {
       params: opts,
       responseType: "arraybuffer",