pim-import 2.12.0 → 2.16.0

package/src/algolia/projects.ts

@@ -0,0 +1,230 @@
+import { log } from "../libs/logs";
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+  getTopicPage,
+  getEntryImageDetails,
+} 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 = "projects";
+
+export type AlgoliaProjectRecord = {
+  objectID: string;
+  name?: CfLocalizedEntryField;
+  slugs?: {};
+  isBespoke?: boolean;
+  categories?: string[];
+  applications?: string[];
+  locations?: string[];
+  thumbnail?: string;
+  fullPageImage?: string;
+  locationLabel?: string;
+  casambiUsed?: boolean;
+  lastSyncDate?: string;
+};
+
+const getObject = async (
+  topicProject: Entry
+): Promise<AlgoliaProjectRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Sync the ${topicProject.sys.id} topicProject...`);
+  let topicProjectWithFields: Entry = topicProject;
+
+  if (!topicProjectWithFields?.fields) {
+    log(`Get the ${topicProject.sys.id} topicProject details...`);
+    topicProjectWithFields = await getEntryByID(
+      topicProject.sys.id,
+      "topicProject"
+    );
+  }
+
+  if (!topicProjectWithFields) {
+    log(`The topicProject ${topicProject.sys.id} not found`, "WARN");
+
+    const recordFail: AlgoliaProjectRecord = {
+      objectID: topicProject?.sys?.id,
+    };
+
+    return recordFail; // return objectID to delete the record if it exists
+  }
+
+  log(`Get page details...`);
+  const page = await getTopicPage(topicProject.sys.id, "fields.slug");
+  const slugs = page?.fields.slug || {};
+
+  log(`Get thumbnail details...`);
+  const thumbnail = await getEntryImageDetails(
+    topicProjectWithFields,
+    "thumbnail"
+  );
+
+  log(`Get fullPageImage details...`);
+  const fullPageImage = await getEntryImageDetails(
+    topicProjectWithFields,
+    "fullPageImage"
+  );
+
+  // Single record
+  const record: AlgoliaProjectRecord = {
+    objectID: topicProjectWithFields.sys.id,
+    name:
+      topicProjectWithFields?.fields?.title?.[defaultEnvironmentLocaleCode] ||
+      "",
+    slugs,
+    isBespoke:
+      !!topicProjectWithFields?.fields?.isBespokeProject?.[
+        defaultEnvironmentLocaleCode
+      ],
+    categories:
+      topicProjectWithFields?.fields?.categories?.[
+        defaultEnvironmentLocaleCode
+      ] || [],
+    applications:
+      topicProjectWithFields?.fields?.applications?.[
+        defaultEnvironmentLocaleCode
+      ] || [],
+    locations:
+      topicProjectWithFields?.fields?.locations?.[
+        defaultEnvironmentLocaleCode
+      ] || [],
+    locationLabel:
+      topicProjectWithFields?.fields?.locationLabel?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    casambiUsed:
+      topicProjectWithFields?.fields?.casambiUsed?.[
+        defaultEnvironmentLocaleCode
+      ] || false,
+    thumbnail,
+    fullPageImage,
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+export const reindexProject = async (topicProjectId: string) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+
+  log(`reindexProject - entryId: ${topicProjectId} `);
+
+  const topicProject = await getEntryByID(topicProjectId, "topicProject");
+
+  if (!topicProject) {
+    log(`No topicProjectId found with id ${topicProjectId}`, "WARN");
+    return false;
+  }
+
+  const object = await getObject(topicProject);
+
+  // 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: "topicProject",
+    limit,
+    skip: offset,
+    locale: "*",
+    // select: "",
+  };
+  if (filterKey && filterValue) {
+    opts[filterKey] = filterValue;
+  }
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaProjectRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicProduct of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicProduct);
+    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 reindexProjects = async (
+  offset: number = 0,
+  limit: number = 50,
+  filterKey: string = "",
+  filterValue: string = ""
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+  log(
+    `reindexProjects - 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 removeProjectObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/index.ts

@@ -71,6 +71,11 @@ export {
   reindexDownloads,
   removeDownloadObject,
 } from "./algolia/downloads";
+export {
+  reindexProject,
+  reindexProjects,
+  removeProjectObject,
+} from "./algolia/projects";
 // export { log } from "./libs/logs";
 // export { initSentry } from "./libs/sentry";
 

package/src/libs/contentful-cda.ts

@@ -455,6 +455,13 @@ export const getDictionaryLocaleValue = async (
   }
 };
 
+/**
+ * Get topic page
+ *
+ * @param topicId
+ * @param select Default: "sys,fields"
+ * @returns
+ */
 export const getTopicPage = async (
   topicId: string,
   select: string = "sys,fields"

package/src/libs/contentful.ts

@@ -20,6 +20,7 @@ import {
   TopicDetailsResponse,
   AssetPropFields,
   OtherFilters,
+  WrapperImageFields,
 } from "../types";
 import {
   sleep,
@@ -1233,3 +1234,46 @@ export const getTopicPage = async (
 
   return items?.[0];
 };
+
+/**
+ * Create wrapperImgix if not exists or get it if already exists
+ *
+ * @param id The wrapperImgix ID
+ * @param data See WrapperImageFields
+ * @returns
+ */
+export const createWrapperImgix = async (
+  id: string,
+  data: WrapperImageFields
+) => {
+  let wrapperImgix = await getEntryByID(id, "wrapperImgix");
+  if (wrapperImgix) {
+    log(`wrapperImgix with id ${id} already exists`);
+    return wrapperImgix;
+  }
+
+  log(`wrapperImgix with id  ${id} not found, create it...`);
+
+  const defaultEnvCode = await getEnvironmentDefaultLocaleCode();
+  const entryData: any = {
+    fields: {},
+  };
+  for (const [key, value] of Object.entries(data)) {
+    const fieldValue: any = value;
+    if (!entryData.fields?.[key]) {
+      entryData.fields[key] = {};
+    }
+
+    if (fieldValue?.[defaultEnvCode] || fieldValue?.[defaultEnvCode] === null) {
+      fieldValue[defaultEnvCode] =
+        fieldValue[defaultEnvCode] === null ? "" : fieldValue[defaultEnvCode];
+      entryData.fields[key] = fieldValue;
+    } else {
+      entryData.fields[key][defaultEnvCode] = fieldValue;
+    }
+  }
+
+  wrapperImgix = await createEntryWithId("wrapperImgix", id, entryData, true);
+
+  return wrapperImgix;
+};

package/src/libs/imgix.ts

@@ -0,0 +1,106 @@
+import ImgixAPI from "imgix-management-js";
+import { getPimDomain } from "../pim/endpoints";
+import { log } from "./logs";
+import { ImgixAttributes, ImgixData } from "../types";
+
+let imgix: ImgixAPI;
+export const getImgix = () => {
+  if (imgix) {
+    return imgix;
+  }
+
+  imgix = new ImgixAPI({
+    apiKey: process.env.FPI_IMGIX_API_KEY || "",
+  });
+
+  return imgix;
+};
+
+export const getSources = async () => {
+  const imgix = getImgix();
+  return await imgix.request("sources");
+};
+
+/**
+ * Get origin path by pim url
+ *
+ * @axample
+ * from: https://dam.flos.net/damflos/products//ARCHITECTURAL/ARCHITECTURAL_SYSTEMS_LED-CURTAIN/03.3901.30C/FLOS-LED-CURTAIN-WHITE-1950X1950.JPG
+ * to: damflos/products//ARCHITECTURAL/ARCHITECTURAL_SYSTEMS_LED-CURTAIN/03.3901.30C/FLOS-LED-CURTAIN-WHITE-1950X1950.JPG
+ *
+ * @param pimImgUrl
+ * @returns
+ */
+export const getOriginPathByPimUrl = (pimImgUrl: string) => {
+  const pimDomain = getPimDomain();
+  return pimImgUrl.substring(pimImgUrl.indexOf(pimDomain) + pimDomain.length);
+};
+
+export const getImageAttributesByOriginPath = async (
+  originPath: string,
+  sourceId: string
+) => {
+  const url = `assets/${sourceId}${originPath}`;
+  log(`getImageAttributesByOriginPath: ${url}`);
+  const imgix = getImgix();
+  return await imgix
+    .request(url)
+    .then((response) => {
+      const imgDetails: any = response;
+      return imgDetails?.data?.attributes as ImgixAttributes;
+    })
+    .catch((err) => {
+      console.log(err.response.errors);
+      log(
+        `${err.response.errors[0].detail} sourceId: ${sourceId} originPath: ${originPath}`,
+        "WARN"
+      );
+      return {};
+    });
+};
+
+export const getImageAttributesByPimUrl = async (pimUrl: string) => {
+  const originPath = getOriginPathByPimUrl(pimUrl);
+  const sourceId = process.env.FPI_IMGIX_PIM_SOURCE_ID || "";
+
+  return (await getImageAttributesByOriginPath(
+    originPath,
+    sourceId
+  )) as ImgixAttributes;
+};
+
+/**
+ * Get imgix URL by origin path
+ *
+ * @axample
+ * from: /damflos/products//ARCHITECTURAL/ARCHITECTURAL_SYSTEMS_LED-CURTAIN/03.3901.30C/FLOS-LED-CURTAIN-WHITE-1950X1950.JPG
+ * to: https://flos-pim.imgix.net/damflos/products//ARCHITECTURAL/ARCHITECTURAL_SYSTEMS_LED-CURTAIN/03.3901.30C/FLOS-LED-CURTAIN-WHITE-1950X1950.JPG
+ *
+ * @param originPath
+ * @returns
+ */
+const getImgixUrlByOriginPath = (originPath: string) => {
+  return `https://${process.env.FPI_IMGIX_PIM_IMAGE_DOMAIN}${originPath}`;
+};
+
+export const getWrapperImgixAttributesByPimUrl = async (pimUrl: string) => {
+  const allImgAttributes = await getImageAttributesByPimUrl(pimUrl);
+  let imgixData: ImgixData | null = null;
+
+  if (Object.entries(allImgAttributes).length) {
+    imgixData = {
+      url: getImgixUrlByOriginPath(allImgAttributes.origin_path),
+      details: {
+        size: allImgAttributes.file_size,
+        image: {
+          width: allImgAttributes.media_width,
+          height: allImgAttributes.media_height,
+        },
+      },
+      fileName: allImgAttributes?.name || "",
+      contentType: allImgAttributes.content_type,
+    };
+  }
+
+  return imgixData;
+};

package/src/pim/endpoints.ts

@@ -15,6 +15,19 @@ import { checkConfig, config } from "./config";
 
 type AvailableOtherCatalogDataEndpoint = "models" | "submodels" | "subfamilies";
 
+/**
+ * Get pim domain by pim base url
+ *
+ * @returns
+ */
+export const getPimDomain = () => {
+  const pimBaseUrl = process.env.FPI_PIM_BASE_URL || "";
+  return pimBaseUrl.substring(
+    pimBaseUrl.indexOf("://") + 3,
+    pimBaseUrl.indexOf("/.rest")
+  );
+};
+
 /**
  * Get the catalog taxonomy hierarchy
  *

package/src/pim/methods/dictionary.ts

@@ -240,36 +240,30 @@ export const importDictionaryFields = async (
 
   // Get dictionary data
   log("Get dictionary data");
-  const pimDictionaryData: DictionaryRecord[] = await getDictionary();
+  const pimDictionaryData: Partial<Record<string, DictionaryRecord[]>> =
+    await getDictionary();
 
   if (pimDictionaryData) {
     // Filter required fields
     log("Filter required fields");
-    const dictionaryData = Object.entries(pimDictionaryData);
     let count: number = 0;
     const data: ObjectPartial = {};
-    for (const [key, value] of dictionaryData) {
+    for (const productFieldRequiredData of productFieldsRequiredData) {
       if (offset <= count || limit === -1) {
-        if (value) {
-          const currentRequiredField: ProductFieldsRequiredData | undefined =
-            productFieldsRequiredData.find((e) => e.dictionary === key);
-          if (typeof currentRequiredField !== "undefined") {
-            const productFieldKey = currentRequiredField.key;
-            if (productFieldKey) {
-              const dictionaryRecord: DictionaryRecord = value;
-              if (currentRequiredField.parent) {
-                if (!data[currentRequiredField.parent]) {
-                  data[currentRequiredField.parent] = {};
-                }
-                data[currentRequiredField.parent][productFieldKey] =
-                  dictionaryRecord;
-              } else {
-                data[productFieldKey] = dictionaryRecord;
-              }
+        if (pimDictionaryData?.[productFieldRequiredData.dictionary]) {
+          const dictionaryRecord =
+            pimDictionaryData?.[productFieldRequiredData.dictionary];
+          if (productFieldRequiredData.parent) {
+            if (!data[productFieldRequiredData.parent]) {
+              data[productFieldRequiredData.parent] = {};
             }
+            data[productFieldRequiredData.parent][
+              productFieldRequiredData.key
+            ] = dictionaryRecord;
+          } else {
+            data[productFieldRequiredData.key] = dictionaryRecord;
           }
         }
-
         if (limit !== -1 && count + 1 - offset >= limit) {
           break;
         }
@@ -277,20 +271,27 @@ export const importDictionaryFields = async (
       count++;
     }
 
-    log("Create certifications");
-    let certifications: DictionaryRecord[] = [];
-    const pimCertifications: { string: DictionaryRecord[] } =
-      data.certification;
-    for (const [key, values] of Object.entries(pimCertifications)) {
-      log(`Add ${key} values to certifications`);
-      certifications = certifications.concat(values);
+    const completed = count >= productFieldsRequiredData.length;
+
+    if (completed) {
+      log("Create certifications");
+      let certifications: DictionaryRecord[] = [];
+      const pimCertifications: { string: DictionaryRecord[] } =
+        data.certification;
+      for (const [key, values] of Object.entries(pimCertifications)) {
+        log(`Add ${key} values to certifications`);
+        certifications = certifications.concat(values);
+      }
+      log(`Remove unwanted values to certifications`);
+      certifications = certifications.filter((value) => {
+        return sanitizeValue(value?.code);
+      });
+      log(`Add certifications to data`);
+      data.certifications = certifications;
+
+      log("Create catalogs");
+      data.catalogs = pimDictionaryData.Catalog;
     }
-    log(`Remove unwanted values to certifications`);
-    certifications = certifications.filter((value) => {
-      return sanitizeValue(value?.code);
-    });
-    log(`Add certifications to data`);
-    data.certifications = certifications;
 
     if (Object.entries(data).length) {
       // Create/Update Contentful entry
@@ -303,7 +304,7 @@ export const importDictionaryFields = async (
     return {
       offset: Number(offset) + Number(limit),
       limit: Number(limit),
-      completed: count >= dictionaryData.length, // if is true the import is completed
+      completed, // if is true the import is completed
     };
   } else {
     log("no data found in the dictionary", "ERROR");

package/src/pim/methods/products.ts

@@ -13,6 +13,7 @@ import {
   CfSys,
   ObjectPartial,
   ContentfulAssetFile,
+  WrapperImageFields,
 } from "../../types";
 import { log } from "../../libs/logs";
 import {
@@ -26,6 +27,7 @@ import {
   getEnvironment,
   addFieldValue,
   addToRelationFields,
+  createWrapperImgix,
 } from "../../libs/contentful";
 import type {
   Entry,
@@ -52,6 +54,7 @@ import { getAudit, getProductDetails } from "../endpoints";
 import { getCategoryTopicCode } from "./catalogs";
 import productFieldsRequiredData from "../data/productFields.json";
 import mime from "mime-types";
+import { getWrapperImgixAttributesByPimUrl } from "../../libs/imgix";
 
 export type AvailableProductStatus =
   | "To be review"
@@ -873,6 +876,48 @@ const getProductData = async (
           "Asset"
         );
       }
+
+      // THUMB WRAPPER IMGIX
+      const wrapperImgixID = pimAssetThumb.md5;
+      let wrapperImgix = await getEntryByID(wrapperImgixID, "wrapperImgix");
+      if (wrapperImgix) {
+        log(`wrapperImgix with id ${wrapperImgixID} already exists`);
+      } else {
+        log(
+          `Add thumbnail imgix wrapper with id ${wrapperImgixID} to Contentful`
+        );
+        const altText: any = getPimTranslations(pimAssetThumb, "title");
+        if (altText[defaultEnvironmentLocaleCode] === null) {
+          altText[defaultEnvironmentLocaleCode] = "Thumbnail";
+        }
+        const wrapperImgixAttributes = await getWrapperImgixAttributesByPimUrl(
+          pimAssetThumb.url
+        );
+        if (wrapperImgixAttributes) {
+          const wrapperImgixFields: WrapperImageFields = {
+            internalName: `${pimAssetThumb?.assetType?.code}_${pimAssetThumb.md5}`,
+            imgixData: wrapperImgixAttributes,
+            altText,
+          };
+          wrapperImgix = await createWrapperImgix(
+            wrapperImgixID,
+            wrapperImgixFields
+          );
+        } else {
+          log(
+            `Unable to create wrapperimagix because the image was not found on imgix. Image URL: ${pimAssetThumb.url}`,
+            "WARN"
+          );
+        }
+      }
+
+      if (wrapperImgix?.sys?.id) {
+        data.fields = await addToRelationFields(
+          data,
+          "thumbnailImgix",
+          wrapperImgix.sys.id
+        );
+      }
     } else {
       log(`No thumbnail found`, "WARN");
     }

package/src/types.ts

@@ -194,3 +194,61 @@ export interface OtherFilters {
   key: string;
   value: string;
 }
+
+export interface ImgixData {
+  url: string;
+  details: ImgixDataDetails;
+  fileName: string;
+  contentType: string;
+}
+export interface ImgixDataDetails {
+  size: number;
+  image: ImgixDataImageDetails;
+}
+interface ImgixDataImageDetails {
+  width: number;
+  height: number;
+}
+
+export type WrapperImageFields = {
+  internalName: string;
+  imgixData: ImgixData;
+  altText: CfLocalizedEntryField;
+  seoTitleTag?: "h1" | "h2" | "h3" | "h4";
+  caption?: CfLocalizedEntryField;
+  blurhash?: string;
+};
+
+export interface ImgixAttributes {
+  analyzed_content_warnings: boolean;
+  analyzed_faces: boolean;
+  analyzed_tags: boolean;
+  categories?: null[] | null;
+  color_model: string;
+  color_profile: string;
+  colors: string;
+  content_type: string;
+  custom_fields?: null;
+  date_created: number;
+  date_modified: number;
+  description?: null;
+  dpi_height: number;
+  dpi_width: number;
+  face_count?: null;
+  file_size: number;
+  has_frames: boolean;
+  media_height: number;
+  media_kind: string;
+  media_width: number;
+  name?: null;
+  origin_path: string;
+  source_id: string;
+  tags: Record<string, any>;
+  uploaded_by: string;
+  uploaded_by_api: boolean;
+  warning_adult: number;
+  warning_medical: number;
+  warning_racy: number;
+  warning_spoof: number;
+  warning_violence: number;
+}