pim-import 2.58.1 → 2.60.1

package/src/algolia/pressRelease.ts

@@ -0,0 +1,235 @@
+import { log } from "../libs/logs";
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+  getTopicDetails,
+} 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,
+  WrapperImageFields,
+  TopicDetailsResponse,
+  CfSys,
+} from "../types";
+import { getWrapperImgixFields } from "../libs/imgix";
+import { getAssetsByComponentAssetIds } from "./downloads";
+
+const indexKey: AvailableIndicesKey = "pressRelease";
+
+export type AlgoliaPressReleaseRecord = {
+  objectID: string;
+  name?: CfLocalizedEntryField;
+  description?: string;
+  thumbnailImgix?: WrapperImageFields | {};
+  lastSyncDate?: string;
+  category?: TopicDetailsResponse;
+  assets?: {};
+  visualizationDate?: string;
+};
+
+const getObject = async (
+  topicPressRelease: Entry
+): Promise<AlgoliaPressReleaseRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Sync the ${topicPressRelease.sys.id} topicPressRelease...`);
+  let topicPressReleaseWithFields: Entry = topicPressRelease;
+
+  if (!topicPressReleaseWithFields?.fields) {
+    log(`Get the ${topicPressRelease.sys.id} topicPressRelease details...`);
+    topicPressReleaseWithFields = await getEntryByID(
+      topicPressRelease.sys.id,
+      "topicPressRelease"
+    );
+  }
+
+  if (!topicPressReleaseWithFields) {
+    log(`The topicPressRelease ${topicPressRelease.sys.id} not found`, "WARN");
+
+    const recordFail: AlgoliaPressReleaseRecord = {
+      objectID: topicPressRelease?.sys?.id,
+    };
+
+    return recordFail; // return objectID to delete the record if it exists
+  }
+
+  log(`Get thumbnail imgix details...`);
+  let thumbnailImgix = {};
+  const thumbnailImgixWrapperImgixID =
+    topicPressReleaseWithFields?.fields?.thumbnailImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (thumbnailImgixWrapperImgixID) {
+    thumbnailImgix = await getWrapperImgixFields(thumbnailImgixWrapperImgixID);
+  } else {
+    log(`No thumbnail imgix found`, "WARN");
+  }
+
+  log(`Get category details...`);
+  const category = await getTopicDetails(
+    topicPressReleaseWithFields,
+    "category",
+    "topicPressReleaseCategory",
+    true,
+    false,
+    false,
+    true
+  );
+
+  log(`Get assets details...`);
+  let assets: any = [];
+  const componentAssets =
+    topicPressReleaseWithFields?.fields?.assets?.[defaultEnvironmentLocaleCode];
+  if (componentAssets) {
+    const componentAssetIds = componentAssets.map(
+      (item: CfSys) => item?.sys?.id
+    );
+    assets = await getAssetsByComponentAssetIds(componentAssetIds);
+  }
+
+  // Single record
+  const record: AlgoliaPressReleaseRecord = {
+    objectID: topicPressReleaseWithFields.sys.id,
+    name: topicPressReleaseWithFields?.fields?.name,
+    description: topicPressReleaseWithFields?.fields?.description,
+    thumbnailImgix,
+    category: category?.[0],
+    assets,
+    visualizationDate:
+      topicPressReleaseWithFields?.fields?.visualizationDate?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+export const reindexPressRelease = async (topicPressReleaseId: string) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+
+  log(`reindexPressRelease - entryId: ${topicPressReleaseId} `);
+
+  const topicPressRelease = await getEntryByID(
+    topicPressReleaseId,
+    "topicPressRelease"
+  );
+
+  if (!topicPressRelease) {
+    log(`No topicPressReleaseId found with id ${topicPressReleaseId}`, "WARN");
+    return false;
+  }
+
+  const object = await getObject(topicPressRelease);
+
+  // Save record to Algolia
+  const index = getIndex(indexKey);
+  let record = null;
+  const names: any = object?.name;
+  if (names?.[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: "topicPressRelease",
+    limit,
+    skip: offset,
+    locale: "*",
+    // select: "",
+  };
+  if (filterKey && filterValue) {
+    opts[filterKey] = filterValue;
+  }
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaPressReleaseRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicPressRelease of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicPressRelease);
+    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 reindexPressReleases = async (
+  offset: number = 0,
+  limit: number = 50,
+  filterKey: string = "",
+  filterValue: string = ""
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+  log(
+    `reindexPressReleases - filterKey: ${filterKey} filterValue: ${filterValue} offset: ${offset} limit: ${limit} `
+  );
+
+  const records = await getObjects(offset, limit, filterKey, filterValue);
+  const objectsToSave = records.objects.filter(
+    (object) => object?.name?.[defaultEnvironmentLocaleCode]
+  );
+  const objectIdsToDelete = records.objects
+    .filter((object) => !object?.name?.[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 removePressReleaseObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/algolia/pressReview.ts

@@ -0,0 +1,228 @@
+import { log } from "../libs/logs";
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+} 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,
+  WrapperImageFields,
+} from "../types";
+import { getWrapperImgixFields } from "../libs/imgix";
+import { getAssetsByComponentAssetIds } from "./downloads";
+
+const indexKey: AvailableIndicesKey = "pressReviews";
+
+export type AlgoliaPressReviewRecord = {
+  objectID: string;
+  name?: CfLocalizedEntryField;
+  yearOfRelease?: string;
+  monthOfRelease?: string;
+  country?: string;
+  thumbnailImgix?: WrapperImageFields | {};
+  asset?: {};
+  lastSyncDate?: string;
+};
+
+const getObject = async (
+  topicPressReview: Entry
+): Promise<AlgoliaPressReviewRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Sync the ${topicPressReview.sys.id} topicPressReview...`);
+  let topicPressReviewWithFields: Entry = topicPressReview;
+
+  if (!topicPressReviewWithFields?.fields) {
+    log(`Get the ${topicPressReview.sys.id} topicPressReview details...`);
+    topicPressReviewWithFields = await getEntryByID(
+      topicPressReview.sys.id,
+      "topicPressReview"
+    );
+  }
+
+  if (!topicPressReviewWithFields) {
+    log(`The topicPressReview ${topicPressReview.sys.id} not found`, "WARN");
+
+    const recordFail: AlgoliaPressReviewRecord = {
+      objectID: topicPressReview?.sys?.id,
+    };
+
+    return recordFail; // return objectID to delete the record if it exists
+  }
+
+  log(`Get thumbnail imgix details...`);
+  let thumbnailImgix = {};
+  const thumbnailImgixWrapperImgixID =
+    topicPressReviewWithFields?.fields?.thumbnailImageImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (thumbnailImgixWrapperImgixID) {
+    thumbnailImgix = await getWrapperImgixFields(thumbnailImgixWrapperImgixID);
+  } else {
+    log(`No thumbnail imgix found`, "WARN");
+  }
+
+  log(`Get asset details...`);
+  const fileId =
+    topicPressReviewWithFields?.fields?.asset?.[defaultEnvironmentLocaleCode]
+      ?.sys?.id;
+  let asset = {};
+  if (fileId) {
+    const componentAssetIds = await getAssetsByComponentAssetIds([fileId]);
+    asset = componentAssetIds ? componentAssetIds[0] : {};
+  } else {
+    log(`No asset found`, "WARN");
+  }
+
+  // Single record
+  const record: AlgoliaPressReviewRecord = {
+    objectID: topicPressReviewWithFields.sys.id,
+    name: topicPressReviewWithFields?.fields?.name,
+    yearOfRelease:
+      topicPressReviewWithFields?.fields?.yearOfRelease?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    monthOfRelease:
+      topicPressReviewWithFields?.fields?.monthOfRelease?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    country:
+      topicPressReviewWithFields?.fields?.country?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    thumbnailImgix,
+    asset,
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+export const reindexPressReview = async (topicPressReviewId: string) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+
+  log(`reindexPressReview - entryId: ${topicPressReviewId} `);
+
+  const topicPressReview = await getEntryByID(
+    topicPressReviewId,
+    "topicPressReview"
+  );
+
+  if (!topicPressReview) {
+    log(`No topicPressReviewId found with id ${topicPressReviewId}`, "WARN");
+    return false;
+  }
+
+  const object = await getObject(topicPressReview);
+
+  // Save record to Algolia
+  const index = getIndex(indexKey);
+  let record = null;
+  const names: any = object?.name;
+  if (names?.[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: "topicPressReview",
+    limit,
+    skip: offset,
+    locale: "*",
+    // select: "",
+  };
+  if (filterKey && filterValue) {
+    opts[filterKey] = filterValue;
+  }
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaPressReviewRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicPressReview of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicPressReview);
+    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 reindexPressReviews = async (
+  offset: number = 0,
+  limit: number = 50,
+  filterKey: string = "",
+  filterValue: string = ""
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+  log(
+    `reindexPressReviews - filterKey: ${filterKey} filterValue: ${filterValue} offset: ${offset} limit: ${limit} `
+  );
+
+  const records = await getObjects(offset, limit, filterKey, filterValue);
+  const objectsToSave = records.objects.filter(
+    (object) => object?.name?.[defaultEnvironmentLocaleCode]
+  );
+  const objectIdsToDelete = records.objects
+    .filter((object) => !object?.name?.[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 removePressReviewObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/algolia/subFamilies.ts

@@ -118,7 +118,6 @@ const getProductFields = async (topicSubFamily: Entry): Promise<any> => {
     ).toLowerCase()
   );
   if (!catalogName) {
-    console.log(topicSubFamily.fields.catalog);
     log(`Cannot find catalog name`, "WARN");
     return {};
   }

package/src/index.ts

@@ -96,6 +96,16 @@ export {
   reindexStories,
   removeStoryObject,
 } from "./algolia/stories";
+export {
+  reindexPressReview,
+  reindexPressReviews,
+  removePressReviewObject,
+} from "./algolia/pressReview";
+export {
+  reindexPressRelease,
+  reindexPressReleases,
+  removePressReleaseObject,
+} from "./algolia/pressRelease";
 export { importDownloads } from "./downloads/import";
 export { getLocalISOTime } from "./utils";
 export { getStaticDailyProducts } from "./pim/endpoints";

package/src/libs/contentful.ts

@@ -1318,7 +1318,13 @@ export const archiveEntry = async (
     entry = await entry.archive();
 
     if (isProduct) {
-      await removeProductObject(entry.fields.code);
+      const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
+      const recordObjectId = entry.fields.code[defEnvLocaleCode];
+      if (recordObjectId) {
+        await removeProductObject(recordObjectId);
+      } else {
+        log(`recordObjectId not found`, "WARN");
+      }
     }
   } else {
     log(`Entry ${entry.sys.id} is already archived`);

package/src/pim/methods/products.ts

@@ -1494,6 +1494,8 @@ export const audit = async (
   limit: number = 150,
   s3FilePath: string = ""
 ) => {
+  offset = Number(offset);
+  limit = Number(limit);
   const timeStart = new Date();
   log(`audit - lastModified: ${lastModified} catalog: ${catalog}`, "INFO");
 
@@ -1503,8 +1505,8 @@ export const audit = async (
     if (!allAudit) {
       log(`No audits were found to process for the date ${lastModified}`);
       return {
-        offset: Number(offset),
-        limit: Number(limit),
+        offset,
+        limit,
         completed: true,
         s3FilePath: "",
         total: 0,
@@ -1555,7 +1557,7 @@ export const audit = async (
       log(
         `No products found between offset: ${offset} and limit: ${limit}. Total: ${total}`
       );
-      const nextOffset = Number(offset) + Number(limit);
+      const nextOffset = offset + limit;
       const completed = limit === -1 || nextOffset >= total;
       if (completed) {
         log(`Audit completed`);
@@ -1567,7 +1569,7 @@ export const audit = async (
 
       return {
         offset: nextOffset,
-        limit: Number(limit),
+        limit: limit,
         completed,
         s3FilePath,
         total,
@@ -1680,7 +1682,7 @@ export const audit = async (
       }
     }
 
-    const nextOffset = Number(offset) + Number(limit);
+    const nextOffset = offset + limit;
 
     const tEnd = new Date();
     const secs = secondBetweenTwoDate(timeStart, tEnd);
@@ -1688,7 +1690,7 @@ export const audit = async (
 
     return {
       offset: nextOffset,
-      limit: Number(limit),
+      limit,
       completed: limit === -1 || count >= total,
       s3FilePath,
       total,
@@ -1701,8 +1703,8 @@ export const audit = async (
   log(`Request time: ${secs} seconds`);
 
   return {
-    offset: Number(offset),
-    limit: Number(limit),
+    offset: offset,
+    limit: limit,
     completed: true,
     s3FilePath,
   };