pim-import 2.4.2 → 2.5.2

package/src/libs/contenful-cda.ts

@@ -0,0 +1,445 @@
+import type { Entry } from "contentful-management/dist/typings/entities/entry";
+import { Locale } from "contentful-management/types";
+import {
+  CfSys,
+  TopicDetailsResponse,
+  AssetPropFieldsWithoutLocaleKey,
+} from "../types";
+import { getPimTranslations, keysToLowerCase } from "../utils";
+import { log } from "./logs";
+const contentful = require("contentful");
+
+let client: any;
+let defaultEnvironmentLocale: Locale;
+let defaultEnvironmentLocaleCode: string;
+
+const config = {
+  spaceId: process.env.FPI_CTF_SPACE_ID,
+  previewAccessToken: process.env.FPI_CTF_PREVIEW_ACCESS_TOKEN,
+  accessToken: process.env.FPI_CTF_CDA_ACCESS_TOKEN,
+  environment: process.env.FPI_CTF_ENVIRONMENT,
+  removeUnresolved: process.env.FPI_CTF_REMOVE_UNRESOLVED === "1",
+  resolveLinks: process.env.FPI_CTF_RESOLVE_LINKS === "1",
+  previewEnabled: process.env.FPI_CTF_PREVIEW_ENABLED === "1",
+  host:
+    process.env.FPI_CTF_PREVIEW_ENABLED === "1"
+      ? "preview.contentful.com"
+      : "cdn.contentful.com",
+};
+
+const initClient = async () => {
+  client = await contentful.createClient({
+    space: config.spaceId,
+    accessToken: config.previewEnabled
+      ? config.previewAccessToken || ""
+      : config.accessToken,
+    environment: config.environment || "master",
+    removeUnresolved: config.removeUnresolved,
+    resolveLinks: config.resolveLinks,
+    host: config.previewEnabled
+      ? "preview.contentful.com"
+      : "cdn.contentful.com",
+  });
+
+  console.log("host:", config.host);
+
+  return client;
+};
+
+export const getClient = async () => {
+  if (!client) {
+    return await initClient();
+  } else {
+    return client;
+  }
+};
+
+/**
+ * Get environment default locale
+ *
+ * @returns
+ */
+export const getEnvironmentDefaultLocale = async (): Promise<Locale> => {
+  if (defaultEnvironmentLocale) {
+    return new Promise((resolve) => resolve(defaultEnvironmentLocale));
+  }
+
+  const client = await getClient();
+  const environmentLocales = await client.getLocales();
+  if (!environmentLocales) {
+    throw new Error("Environment locales not found");
+  }
+
+  const findDefaultEnvironmentLocale: Locale | undefined =
+    environmentLocales.items.find((locale: Locale) => locale.default);
+
+  if (findDefaultEnvironmentLocale) {
+    defaultEnvironmentLocale = findDefaultEnvironmentLocale;
+  } else {
+    throw new Error("Default environment locales not found");
+  }
+
+  return new Promise((resolve) => resolve(defaultEnvironmentLocale));
+};
+
+/**
+ * Get environment default locale code
+ *
+ * @returns
+ */
+export const getEnvironmentDefaultLocaleCode = async (): Promise<string> => {
+  if (defaultEnvironmentLocaleCode) {
+    return new Promise((resolve) => resolve(defaultEnvironmentLocaleCode));
+  }
+
+  const defEnvironmentLocale = await getEnvironmentDefaultLocale();
+  defaultEnvironmentLocaleCode = defEnvironmentLocale.code;
+  return new Promise((resolve) => resolve(defaultEnvironmentLocaleCode));
+};
+
+/**
+ * Get entry by id
+ *
+ * @param entryID
+ * @param contentTypeId
+ * @returns
+ */
+export const getEntryByID = async (
+  entryID: string,
+  contentTypeId: string,
+  select?: string
+): Promise<Entry> => {
+  const client = await getClient();
+
+  const opts = {
+    content_type: contentTypeId,
+    "sys.id": entryID,
+    limit: 1,
+    locale: "*",
+    select,
+    include: 1,
+  };
+
+  const entries = await client.getEntries(opts);
+
+  return entries.items[0];
+};
+
+/**
+ * Get all entries
+ *
+ * @param {string} contentType
+ * @param {string} select
+ * @param {string} filterKey Ex: `fields.catalog[in]`
+ * @param {string} filterValue Ex: `ARCHITECTURAL`
+ * @param {number} limit Default: 50
+ * @returns
+ */
+export const getAllEntries = async (
+  contentType: string,
+  select?: string,
+  filterKey?: string,
+  filterValue?: string,
+  limit: number = 50
+): Promise<Entry[]> => {
+  // log(
+  //   `getAllEntries contentType: ${contentType} select: ${select} filterKey: ${filterKey} filterValue: ${filterValue}`,
+  //   "INFO"
+  // );
+
+  const client = await getClient();
+  let allItems: Entry[] = [];
+  let othersPagesToFetch = false;
+  let skip = 0;
+  // let count = 0;
+  do {
+    const opts: any = {
+      content_type: contentType,
+      limit,
+      skip,
+      locale: "*",
+      select,
+      include: 1,
+    };
+    if (filterKey) {
+      opts[filterKey] = filterValue;
+    }
+
+    const { items, total } = await client.getEntries(opts);
+
+    allItems = [...allItems, ...(items || [])];
+
+    if (total && allItems.length < total) {
+      othersPagesToFetch = true;
+      skip += limit;
+
+      // if (++count % 7 === 0) {
+      //   await sleep(200);
+      // }
+    } else {
+      othersPagesToFetch = false;
+    }
+  } while (othersPagesToFetch);
+
+  return allItems;
+};
+
+/**
+ * Get asset details
+ *
+ * @param assetId
+ * @returns
+ *
+ * // TODO: modificare quanto verrà integrato imagix
+ */
+export const getAssetDetails = async (
+  assetId: string
+): Promise<AssetPropFieldsWithoutLocaleKey> => {
+  const client = await getClient();
+  const thumbnailEntry = await client.getAsset(assetId);
+  return thumbnailEntry?.fields
+    ? keysToLowerCase(thumbnailEntry.fields, true)
+    : {};
+};
+
+/**
+ * Get entry image details
+ *
+ * @example
+ * await getEntryImageDetails(topicSubModule, 'thumbnail');
+ *
+ * @param entry The Contentful entry
+ * @param fieldKey The image field key of the entry
+ * @returns
+ *
+ * // TODO: modificare quanto verrà integrato imagix
+ */
+export const getEntryImageDetails = async (entry: Entry, fieldKey: string) => {
+  const assetId =
+    entry?.fields?.[fieldKey]?.[defaultEnvironmentLocaleCode]?.sys?.id;
+  if (assetId) {
+    const assetEntry = await getAssetDetails(assetId);
+    return assetEntry?.file?.url || "";
+  }
+
+  return "";
+};
+
+/**
+ * Get topic details
+ *
+ * @example const catalogs = await getTopicDetails(topicFamily,"catalogs", "topicCatalog");
+ * @returns   {
+ *   names: {
+ *     de: 'Architectural Lighting',
+ *     'en-US': 'Architectural Lighting',
+ *     ...
+ *   },
+ *   code: { 'en-GB': 'ARCHITECTURAL' },
+ *   slugs: {
+ *     de: 'architectural lighting',
+ *     'en-US': 'architectural lighting'
+ *     ...
+ *   }
+ * }
+ *
+ * @param topicEntry
+ * @param fieldKey
+ * @param contentType
+ * @returns
+ */
+export const getTopicDetails = async (
+  topicEntry: Entry,
+  fieldKey: string,
+  contentType: string,
+  lowerCaseKeys: boolean = false,
+  showRelatedEntities: boolean = false
+): Promise<TopicDetailsResponse[]> => {
+  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const isHasToManyField = Array.isArray(
+    topicEntry?.fields?.[fieldKey]?.[defEnvLocaleCode]
+  );
+
+  const items: TopicDetailsResponse[] = [];
+  let entryIds = [];
+  if (isHasToManyField) {
+    entryIds = topicEntry?.fields?.[fieldKey]?.[defEnvLocaleCode].map(
+      (item: CfSys) => item.sys.id
+    );
+  } else {
+    entryIds = [topicEntry?.fields?.[fieldKey]?.[defEnvLocaleCode]?.sys?.id];
+  }
+
+  if (entryIds) {
+    let select = "sys,fields.name,fields.code";
+    if (contentType === "topicSubFamily" && showRelatedEntities) {
+      select += ",fields.catalog,fields.category,fields.parentFamily";
+    }
+
+    const entries = await getAllEntries(
+      contentType,
+      select,
+      "sys.id[in]",
+      entryIds.join(",")
+    );
+
+    if (entries) {
+      // let count = 0;
+      for (const entry of entries) {
+        const entryPageId = `${entry.sys.id}_PAGE`;
+        const entryPage = await getEntryByID(
+          entryPageId,
+          "page",
+          "fields.slug"
+        );
+
+        const data: TopicDetailsResponse = {
+          names:
+            entry?.fields?.name && lowerCaseKeys
+              ? keysToLowerCase(entry.fields.name)
+              : {},
+          code: entry?.fields?.code?.[defEnvLocaleCode],
+          slugs:
+            entryPage?.fields?.slug && lowerCaseKeys
+              ? keysToLowerCase(entryPage.fields.slug)
+              : {},
+        };
+
+        if (contentType === "topicSubFamily" && showRelatedEntities) {
+          data.details = await getSubFamilySlugDetails(entry);
+        }
+
+        // if (++count > 0 && count % 7 === 0) {
+        //   await sleep(2000, true);
+        // }
+
+        items.push(data);
+      }
+    }
+  } else {
+    log(
+      `No ${fieldKey} found in the ${contentType} ${topicEntry.sys.id}`,
+      "WARN"
+    );
+  }
+
+  return items;
+};
+
+export const getSubFamilySlugDetails = async (topicSubFamily: Entry) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const catalogEntryId =
+    topicSubFamily?.fields?.catalog?.[defaultEnvironmentLocaleCode]?.sys?.id;
+  if (!catalogEntryId) {
+    log(
+      `catalogEntryId not found to ${topicSubFamily.sys.id} subFamilyEntry`,
+      "WARN"
+    );
+  }
+  const parentFamilyEntryId =
+    topicSubFamily?.fields?.parentFamily?.[defaultEnvironmentLocaleCode]?.sys
+      ?.id;
+  if (!parentFamilyEntryId) {
+    log(
+      `parentFamilyEntryId not found to ${topicSubFamily.sys.id} subFamilyEntry`,
+      "WARN"
+    );
+  }
+  const categoryEntryId =
+    topicSubFamily?.fields?.category?.[defaultEnvironmentLocaleCode]?.sys?.id;
+  if (!categoryEntryId) {
+    log(
+      `categoryEntryId not found to ${topicSubFamily.sys.id} subFamilyEntry`,
+      "WARN"
+    );
+  }
+  const subFamilyCatalogPage: any = catalogEntryId
+    ? await getEntryByID(`${catalogEntryId}_PAGE`, "page", "fields.slug")
+    : {};
+  const subFamilyFamilyPage: any = parentFamilyEntryId
+    ? await getEntryByID(`${parentFamilyEntryId}_PAGE`, "page", "fields.slug")
+    : {};
+  const subFamilyCategoryPage: any = categoryEntryId
+    ? await getEntryByID(`${categoryEntryId}_PAGE`, "page", "fields.slug")
+    : {};
+
+  return {
+    catalogPageSlugs: keysToLowerCase(subFamilyCatalogPage?.fields?.slug) || {},
+    familyPageSlugs: keysToLowerCase(subFamilyFamilyPage?.fields?.slug) || {},
+    categoryPageSlugs:
+      keysToLowerCase(subFamilyCategoryPage?.fields?.slug) || {},
+  };
+};
+
+export const getDictionaryJson = async () => {
+  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const entry = await getEntryByID("globalJsonProductFields", "globalJsonFile");
+  return entry?.fields?.json?.[defEnvLocaleCode];
+};
+
+export const getDictionaryValue = async (
+  fieldKey: string,
+  fieldValue: string,
+  fieldParent: string = "",
+  dictionaryJsonFile: any = {}
+) => {
+  const dictionaryJson = Object.entries(dictionaryJsonFile)
+    ? dictionaryJsonFile
+    : await getDictionaryJson();
+  let field = null;
+
+  if (fieldParent && dictionaryJson?.[fieldParent]?.[fieldKey]) {
+    field = dictionaryJson[fieldParent][fieldKey];
+  } else if (dictionaryJson?.[fieldKey]) {
+    field = dictionaryJson[fieldKey];
+  }
+
+  if (field) {
+    if (Array.isArray(field)) {
+      return getPimTranslations(
+        field.find((item: any) => item.code === fieldValue)
+      );
+    } else if (typeof field === "object" && field?.code) {
+      return getPimTranslations(field);
+    } else {
+      return field;
+    }
+  } else {
+    log(
+      `No field found with fieldKey: ${fieldKey} fieldValue: ${fieldValue} fieldParent: ${fieldParent}`
+    );
+  }
+};
+
+/**
+ *
+ * @example
+ * const lampCategoriesLocalizedValue = await getDictionaryLocaleValue(locale, "lampCategories", productFileds.electrical.lampCategories.code, "electrical");
+ *
+ * @param locale
+ * @param fieldKey
+ * @param fieldValue
+ * @param fieldParent
+ * @param dictionaryJsonFile
+ * @returns
+ */
+export const getDictionaryLocaleValue = async (
+  locale: string,
+  fieldKey: string,
+  fieldValue: string,
+  fieldParent: string = "",
+  dictionaryJsonFile: any = {}
+) => {
+  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const values = await getDictionaryValue(
+    fieldKey,
+    fieldValue,
+    fieldParent,
+    dictionaryJsonFile
+  );
+  if (typeof values === "object") {
+    return values?.[locale] || values?.[defEnvLocaleCode];
+  } else {
+    return values;
+  }
+};

package/src/pim/methods/models.ts

@@ -77,7 +77,7 @@ const createOrUpdatePage = async (modelEntry: Entry): Promise<Entry> => {
       `${
         modelEntry.fields.name[locale] ||
         modelEntry.fields.name[defaultEnvironmentLocaleCode]
-      }`.toLowerCase()
+      }-${modelEntry.fields.code[defaultEnvironmentLocaleCode]}`.toLowerCase()
     );
   }
 

package/src/pim/methods/subfamilies.ts

@@ -177,9 +177,34 @@ export const createOrUpdatePage = async (
       subFamilyEntry.fields.name[defaultEnvironmentLocaleCode];
   }
 
+  // Category page
+  let categoryPage: Entry = {} as Entry;
+  const categoryEntryId =
+    subFamilyEntry?.fields?.category?.[defaultEnvironmentLocaleCode]?.sys?.id;
+  if (categoryEntryId) {
+    log(
+      `Add ${categoryEntryId} category page slug to ${subFamilyEntry.sys.id} subfamily page slug`
+    );
+    categoryPage = await getEntryByID(`${categoryEntryId}_PAGE`, "page");
+    if (!categoryPage) {
+      log(
+        `No category page found with page id: ${categoryEntryId}_PAGE`,
+        "WARN"
+      );
+    }
+  } else {
+    log(`No category found with id: ${categoryEntryId}`, "WARN");
+  }
+
   for (const locale of cfLocales) {
+    let slugPrefix = "";
+    if (categoryPage?.fields?.slug) {
+      slugPrefix +=
+        (categoryPage.fields.slug[locale] ||
+          categoryPage.fields.slug[defaultEnvironmentLocaleCode]) + "-";
+    }
     slugs[locale] = stringToSlug(
-      `${
+      `${slugPrefix}${
         subFamilyEntry.fields.name[locale] ||
         subFamilyEntry.fields.name[defaultEnvironmentLocaleCode]
       }`.toLowerCase()

package/src/types.ts

@@ -147,6 +147,29 @@ export type AssetPropFields = {
   };
 };
 
+export type AssetPropFieldsWithoutLocaleKey = {
+  /** Title for this asset */
+  title: {
+    [key: string]: string;
+  };
+  /** Description for this asset */
+  description?: {
+    [key: string]: string;
+  };
+  /** File object for this asset */
+  file: {
+    fileName: string;
+    contentType: string;
+    /** Url where the file is available to be downloaded from, into the Contentful asset system. After the asset is processed this field is gone. */
+    upload?: string;
+    /** Url where the file is available at the Contentful media asset system. This field won't be available until the asset is processed. */
+    url?: string;
+    /** Details for the file, depending on file type (example: image size in bytes, etc) */
+    details?: Record<string, any>;
+    uploadFrom?: Record<string, any>;
+  };
+};
+
 export type TopicProductFieldsResponse = {
   names: CfLocalizedEntryField;
   code: string;