pim-import 5.0.0 → 5.0.2

package/src/pim/methods/catalogs.ts

@@ -1,586 +0,0 @@
-import { saveCatalogToS3, getFileFromS3 } from "../../libs/s3";
-import {
-  AvailableCatalogs,
-  CfSys,
-  CfLocalizedEntryField,
-  PaginationResults,
-} from "../../types";
-import {
-  CatalogDetails,
-  CategoriesEntity,
-} from "../../resources/CatalogDetails";
-import type {
-  Entry,
-  CreateEntryProps,
-} from "contentful-management/dist/typings/entities/entry";
-import {
-  getEnvironmentDefaultLocaleCode,
-  createEntryWithId,
-  updateEntry,
-  getEntryByCode,
-  getEntryByID,
-  cfLocales,
-  deleteAllPages,
-  deleteAllEntries,
-  addToRelationFields,
-  addFieldValue,
-} from "../../libs/contentful";
-import { getCatalogTaxonomiesHierarchy } from "../endpoints";
-import { log, serverUtils } from "../../libs/logs";
-import {
-  sleep,
-  getPimTranslations,
-  getLocalISOTime,
-  stringToSlug,
-} from "../../utils";
-
-const getUnwantedCodeChars = (code: string): string[] => {
-  const toExclude = ["'", "/", " ", "&"];
-  const invalidChars = [];
-  for (const exclude of toExclude) {
-    if (code.indexOf(exclude) !== -1) {
-      invalidChars.push(exclude);
-    }
-  }
-
-  return invalidChars;
-};
-
-// Methods
-export const updateSubFamiliesRelToEntry = async (
-  entry: Entry,
-  subFamilyIds: string[],
-  field: string = "subFamilies"
-): Promise<Entry> => {
-  log(
-    `updateSubFamiliesRelToEntry - entry: ${entry.sys.id} subfamilies count: ${subFamilyIds.length} to field ${field}`,
-    "INFO"
-  );
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const oldRels = entry.fields?.[field]?.[defaultEnvironmentLocaleCode]
-    ? entry.fields[field][defaultEnvironmentLocaleCode]
-    : [];
-
-  entry.fields[field] = {};
-  entry.fields[field][defaultEnvironmentLocaleCode] = [];
-
-  // Keep Contentful sort
-
-  const newRels: CfSys[] = [];
-  for (const subFamilyId of subFamilyIds) {
-    if (!oldRels.find((rel: CfSys) => rel.sys.id === subFamilyId)) {
-      newRels.push({
-        sys: { type: "Link", linkType: "Entry", id: subFamilyId },
-      });
-    }
-  }
-
-  entry.fields[field][defaultEnvironmentLocaleCode] = [...oldRels, ...newRels];
-
-  entry = await entry.update();
-  if (entry.isPublished()) {
-    entry = await entry.publish();
-  }
-
-  return entry;
-};
-
-const getCategoryData = async (
-  names: CfLocalizedEntryField,
-  code: string,
-  catalogEntry: Entry,
-  categoryEntry: Entry
-) => {
-  const data: CreateEntryProps = {
-    fields: categoryEntry?.fields || {},
-  };
-  data.fields.name = names;
-  data.fields = await addFieldValue(data, "code", code);
-
-  // Catalogs
-  data.fields = await addToRelationFields(
-    data,
-    "catalogs",
-    catalogEntry.sys.id,
-    true
-  );
-
-  // lastPimSyncDate
-  data.fields = await addFieldValue(data, "lastPimSyncDate", getLocalISOTime());
-
-  return data;
-};
-
-const getCategorySlugs = async (
-  categoryEntry: Entry
-): Promise<CfLocalizedEntryField> => {
-  const slugs: CfLocalizedEntryField = {};
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  for (const locale of cfLocales) {
-    slugs[locale] = stringToSlug(
-      `${
-        categoryEntry.fields.name[locale] ||
-        categoryEntry.fields.name[defaultEnvironmentLocaleCode]
-      }`.toLowerCase()
-    );
-  }
-
-  return slugs;
-};
-
-const getCategoryPageData = async (
-  names: CfLocalizedEntryField,
-  slugs: CfLocalizedEntryField,
-  pageId: string,
-  categoryEntry: Entry,
-  categoryPageEntry: Entry
-): Promise<CreateEntryProps> => {
-  const pageData: CreateEntryProps = {
-    fields: categoryPageEntry?.fields || {},
-  };
-
-  pageData.fields.title = names;
-  pageData.fields.slug = slugs;
-
-  pageData.fields = await addFieldValue(pageData, "internalName", pageId);
-  pageData.fields = await addFieldValue(pageData, "type", "CatalogCategory");
-
-  // Topic
-  pageData.fields = await addToRelationFields(
-    pageData,
-    "topic",
-    categoryEntry.sys.id
-  );
-
-  return pageData;
-};
-
-const importCategoryPage = async (categoryEntry: Entry) => {
-  log(`importCategoryPage - ${categoryEntry.sys.id}`, "INFO");
-  const names = categoryEntry.fields.name;
-  const pageId = `${categoryEntry.sys.id}_PAGE`;
-  const slugs = await getCategorySlugs(categoryEntry);
-
-  // PAGE
-  log(`Importing category page ${pageId}...`);
-  let categoryPageEntry = await getEntryByID(pageId, "page");
-  const pageData: CreateEntryProps = await getCategoryPageData(
-    names,
-    slugs,
-    pageId,
-    categoryEntry,
-    categoryPageEntry
-  );
-  if (categoryPageEntry) {
-    log(`category page ${pageId} already exists. Updating...`);
-    categoryPageEntry = await updateEntry(
-      categoryPageEntry,
-      pageData,
-      categoryPageEntry.isPublished()
-    );
-  } else {
-    log(`category page ${pageId} not exists. Create new entry with data`);
-    categoryPageEntry = await createEntryWithId("page", pageId, pageData);
-  }
-
-  return categoryPageEntry;
-};
-
-export const getCategoryTopicCode = (
-  categoryPimCode: string,
-  catalogCode: AvailableCatalogs
-) => {
-  return categoryPimCode.replace(catalogCode + "_", "");
-};
-
-export const getCategoryTopicId = (
-  categoryPimCode: string,
-  catalogCode: AvailableCatalogs
-) => {
-  const code = getCategoryTopicCode(categoryPimCode, catalogCode);
-  return `CATEGORY_${code}`;
-};
-
-/**
- * Import Category
- *
- * @param categoryDetails
- * @param catalogCode
- * @param catalogEntry
- * @returns
- */
-const importCategory = async (
-  categoryDetails: CategoriesEntity,
-  catalogCode: AvailableCatalogs,
-  catalogEntry: Entry
-): Promise<Entry | boolean> => {
-  log(`importCategory - ${catalogCode} ${categoryDetails.data.code}`, "INFO");
-  const pimCode = categoryDetails.data.code;
-  const invalidCodeChars = getUnwantedCodeChars(pimCode);
-  if (invalidCodeChars?.length) {
-    log(
-      `The ${pimCode} category cannot be imported as it includes unwanted characters: ${invalidCodeChars.join(
-        ","
-      )}`,
-      "WARN"
-    );
-    return false;
-  }
-
-  const names: CfLocalizedEntryField = getPimTranslations(categoryDetails.data);
-  const code = getCategoryTopicCode(pimCode, catalogCode);
-  const id = getCategoryTopicId(pimCode, catalogCode);
-  let categoryEntry = await getEntryByCode(code, "topicCategory");
-
-  const data: CreateEntryProps = await getCategoryData(
-    names,
-    code,
-    catalogEntry,
-    categoryEntry
-  );
-
-  if (categoryEntry) {
-    log(`Category ${code} already exists. Updating...`);
-    categoryEntry = await updateEntry(
-      categoryEntry,
-      data,
-      categoryEntry.isPublished()
-    );
-  } else {
-    log(`Category ${code} not exists. Create new entry with data`);
-    categoryEntry = await createEntryWithId("topicCategory", id, data, true);
-  }
-
-  await importCategoryPage(categoryEntry);
-
-  return categoryEntry;
-};
-
-const getCatalogData = async (
-  names: CfLocalizedEntryField,
-  code: AvailableCatalogs,
-  catalogEntry: Entry | null
-): Promise<CreateEntryProps> => {
-  const data: CreateEntryProps = {
-    fields: catalogEntry?.fields || {},
-  };
-  data.fields.name = names;
-  data.fields = await addFieldValue(data, "code", code);
-
-  // lastPimSyncDate
-  data.fields = await addFieldValue(data, "lastPimSyncDate", getLocalISOTime());
-
-  return data;
-};
-
-// const getComponentTopicCategoriesData = async (
-//   componentID: string,
-//   catalogEntry: Entry,
-//   componentCatalogModule: Entry | null
-// ) => {
-//   const componentData: CreateEntryProps = {
-//     fields: componentCatalogModule?.fields || {},
-//   };
-
-//   componentData.fields = await addFieldValue(
-//     componentData,
-//     "internalName",
-//     componentID
-//   );
-
-//   // categoryPages relations
-//   const catalogCategories = await getAllEntries(
-//     "topicCategory",
-//     "sys",
-//     "fields.catalogs.sys.id[in]",
-//     catalogEntry.sys.id
-//   );
-//   for (const categoryEntry of catalogCategories) {
-//     log(
-//       `Add ${categoryEntry.sys.id} category to ${catalogEntry.sys.id} catalog`
-//     );
-//     componentData.fields = await addToRelationFields(
-//       componentData,
-//       "categories",
-//       `${categoryEntry.sys.id}`,
-//       true
-//     );
-//   }
-
-//   return componentData;
-// };
-
-// const addComponentTopicCategories = async (
-//   catalogEntry: Entry
-// ): Promise<Entry> => {
-//   const componentID = `CC_${catalogEntry.sys.id}`;
-//   const componentContentType = "componentTopicCategories";
-//   let componentModule = await getEntryByID(componentID, componentContentType);
-
-//   const componentData = await getComponentTopicCategoriesData(
-//     componentID,
-//     catalogEntry,
-//     componentModule
-//   );
-
-//   if (componentModule) {
-//     log(
-//       `Update ${componentContentType} for the ${catalogEntry.sys.id} catalog page`
-//     );
-//     componentModule = await updateEntry(
-//       componentModule,
-//       componentData,
-//       componentModule.isPublished()
-//     );
-//   } else {
-//     log(
-//       `Add ${componentContentType} for the ${catalogEntry.sys.id} catalog page`
-//     );
-//     componentModule = await createEntryWithId(
-//       componentContentType,
-//       componentID,
-//       componentData
-//     );
-//     componentModule = await componentModule.publish();
-//   }
-
-//   return componentModule;
-// };
-
-const getCatalogPageData = async (
-  names: CfLocalizedEntryField,
-  slugs: CfLocalizedEntryField,
-  pageId: string,
-  catalogEntry: Entry,
-  catalogPageEntry: Entry
-): Promise<CreateEntryProps> => {
-  const pageData: CreateEntryProps = {
-    fields: catalogPageEntry?.fields || {},
-  };
-
-  pageData.fields.title = names;
-  pageData.fields.slug = slugs;
-
-  pageData.fields = await addFieldValue(pageData, "internalName", pageId);
-  pageData.fields = await addFieldValue(pageData, "type", "CatalogCollection");
-
-  // Topic
-  pageData.fields = await addToRelationFields(
-    pageData,
-    "topic",
-    catalogEntry.sys.id
-  );
-
-  // Contents - componentCatalogModule
-  // const componentModule = await addComponentTopicCategories(catalogEntry);
-  // pageData.fields = await addToRelationFields(
-  //   pageData,
-  //   "contents",
-  //   componentModule.sys.id,
-  //   true
-  // );
-
-  return pageData;
-};
-
-export const importCatalogPage = async (catalogEntry: Entry) => {
-  log(`importCatalogPage - ${catalogEntry.sys.id}`, "INFO");
-  const names = catalogEntry.fields.name;
-  const pageId = `${catalogEntry.sys.id}_PAGE`;
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const slugs: any = {};
-  for (const locale of cfLocales) {
-    slugs[locale] = stringToSlug(
-      `${
-        catalogEntry.fields.name[locale] ||
-        catalogEntry.fields.name[defaultEnvironmentLocaleCode]
-      }`.toLowerCase()
-    );
-  }
-
-  // PAGE
-  log(`create/update catalog page ${pageId}...`);
-  let catalogPageEntry = await getEntryByID(pageId, "page");
-  const pageData: CreateEntryProps = await getCatalogPageData(
-    names,
-    slugs,
-    pageId,
-    catalogEntry,
-    catalogPageEntry
-  );
-  if (catalogPageEntry) {
-    log(`catalog page ${pageId} already exists. Updating...`);
-    catalogPageEntry = await updateEntry(
-      catalogPageEntry,
-      pageData,
-      catalogPageEntry.isPublished()
-    );
-  } else {
-    log(`catalog page ${pageId} not exists. Create new entry with data`);
-    catalogPageEntry = await createEntryWithId("page", pageId, pageData);
-  }
-
-  return catalogPageEntry;
-};
-
-/**
- * Import Catalog
- *
- * @param catalogCode
- * @param catalogDetails
- * @returns
- */
-const importCatalog = async (
-  catalogCode: AvailableCatalogs,
-  catalogDetails: any,
-  excludeImportPage: boolean = false
-) => {
-  log(`create/update catalog ${catalogCode}...`);
-  let catalogEntry = await getEntryByCode(catalogCode, "topicCatalog");
-
-  const catalogNames: CfLocalizedEntryField = getPimTranslations(
-    catalogDetails.data
-  );
-  const catalogData: CreateEntryProps = await getCatalogData(
-    catalogNames,
-    catalogCode,
-    catalogEntry
-  );
-
-  if (catalogEntry) {
-    log(`topicCatalog ${catalogCode} already exists. Updating...`);
-    catalogEntry = await updateEntry(
-      catalogEntry,
-      catalogData,
-      catalogEntry.isPublished()
-    );
-  } else {
-    log(`topicCatalog ${catalogCode} not exists. Create new entry with data`);
-    catalogEntry = await createEntryWithId(
-      "topicCatalog",
-      catalogCode,
-      catalogData,
-      true
-    );
-  }
-
-  if (!excludeImportPage) {
-    await importCatalogPage(catalogEntry);
-  }
-
-  return catalogEntry;
-};
-
-export const importCategories = async (
-  catalogCode: AvailableCatalogs,
-  offset: number = 0,
-  limit: number = -1,
-  s3FilePath: string = ""
-): Promise<PaginationResults | null> => {
-  log(
-    `importCategories - catalogCode: ${catalogCode} offset: ${offset} limit: ${limit} s3FilePath:${s3FilePath}`,
-    "INFO"
-  );
-
-  if (!s3FilePath) {
-    const s3Path: string = await saveCatalogToS3(catalogCode);
-    return {
-      offset,
-      limit: Number(limit),
-      completed: false,
-      s3FilePath: s3Path,
-    };
-  }
-
-  const JSONData = await getFileFromS3(s3FilePath);
-  const catalogDetails: CatalogDetails = await getCatalogTaxonomiesHierarchy(
-    catalogCode,
-    JSONData
-  );
-
-  let catalogEntry;
-  if (offset === 0) {
-    catalogEntry = await importCatalog(catalogCode, catalogDetails, true);
-  } else {
-    catalogEntry = await getEntryByCode(catalogCode, "topicCatalog");
-  }
-
-  const categoryEntries: string[] = [];
-  if (catalogDetails.categories?.length) {
-    let count: number = 0;
-    let current: number = 0;
-    for (const categoryDetails of catalogDetails.categories) {
-      if (offset <= count || limit === -1) {
-        log(`${count + 1} of ${catalogDetails.categories.length}`);
-        categoryDetails.data.code = categoryDetails.data.code;
-        const categoryEntry = await importCategory(
-          categoryDetails,
-          catalogCode,
-          catalogEntry
-        );
-        if (
-          categoryEntry &&
-          typeof categoryEntry === "object" &&
-          categoryEntry?.sys?.id
-        ) {
-          categoryEntries.push(categoryEntry.sys.id);
-        }
-        await sleep(100);
-
-        if (serverUtils) {
-          serverUtils.log(categoryDetails.data.code);
-          const currentTotal =
-            catalogDetails.categories.length > limit && limit !== -1
-              ? limit
-              : catalogDetails.categories.length;
-          const progress = Math.floor((++current / currentTotal) * 100);
-          serverUtils.updateProgress(progress);
-        }
-
-        if (limit !== -1 && count + 1 - offset >= limit) {
-          break;
-        }
-      }
-      count++;
-    }
-
-    const completed = count + 1 >= catalogDetails.categories.length;
-
-    if (completed) {
-      log(`Update componentTopicCategories to catalog page...`);
-      await importCatalog(catalogCode, catalogDetails);
-    }
-
-    if (serverUtils) {
-      serverUtils.updateProgress(100);
-    }
-
-    return {
-      offset: Number(offset) + Number(limit),
-      limit: Number(limit),
-      completed, // if is true the import is completed
-      s3FilePath: s3FilePath,
-      total: catalogDetails.categories.length,
-    };
-  } else {
-    log(`no data found in the catalog: ${catalogCode}`, "ERROR");
-    return null;
-  }
-};
-
-export const deleteAllCategoriesAndFamiliesData = async (
-  catalogCode: AvailableCatalogs
-) => {
-  const resCat = await deleteAllEntries("topicCategory", catalogCode);
-  const resFam = await deleteAllEntries("topicSubFamily", catalogCode);
-  const resPage = await deleteAllPages(["CatalogProduct", "CatalogSubFamily"]);
-
-  return {
-    topicCategory: resCat,
-    topicSubFamily: resFam,
-    page: resPage,
-  };
-};

package/src/pim/methods/checkTopicDraftAndPagePublished.ts

@@ -1,70 +0,0 @@
-import {
-  getEnvironment,
-  getEnvironmentDefaultLocaleCode,
-} from "../../libs/contentful";
-import { log } from "../../libs/logs";
-import * as fs from "fs";
-import * as path from "path";
-import * as csvWriter from "csv-writer";
-export const checkTopicDraftAndPagePublished = async (
-  offset: number,
-  limit: number
-) => {
-  const env = await getEnvironment();
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const opts = {
-    content_type: "page",
-    skip: offset,
-    limit,
-    locale: defEnvLocaleCode,
-    "sys.archivedAt[exists]": false,
-    "sys.publishedAt[exists]": true,
-    "fields.topic[exists]": true,
-    select: "sys,fields.type,fields.topic",
-    include: 3,
-  };
-
-  const { items, total } = await env.getEntries(opts);
-  log(`Check ${offset + limit} of ${total} pages`);
-  let filteredItems = [];
-  for (const item of items) {
-    const topicId = item.fields?.topic[defEnvLocaleCode]?.sys?.id;
-    const topicEntry = topicId ? await env.getEntry(topicId) : null;
-    if (topicEntry && (topicEntry.isDraft() || topicEntry.isArchived())) {
-      //   log(`Page ${item.sys.id} has a draft or archived topic`, "INFO");
-      filteredItems.push(item);
-    }
-  }
-
-  const records = filteredItems.map((pageEntry) => ({
-    pageId: pageEntry.sys.id,
-    pageType: pageEntry.fields.type[defEnvLocaleCode],
-    topicId: pageEntry.fields.topic[defEnvLocaleCode]?.sys?.id,
-  }));
-
-  log(`Writing ${records.length} records to CSV file`);
-
-  if (records.length) {
-    const csvFilePath = path.join("checkTopicDraftAndPagePublished.csv");
-    const fileExists = fs.existsSync(csvFilePath);
-    const writer = csvWriter.createObjectCsvWriter({
-      path: csvFilePath,
-      header: [
-        { id: "pageId", title: "Page ID" },
-        { id: "pageType", title: "Page Type" },
-        { id: "topicId", title: "Topic ID" },
-      ],
-      append: fileExists,
-    });
-    await writer.writeRecords(records);
-  }
-
-  const count: number = offset + limit;
-  return {
-    completed: !total || total === count + offset,
-    total,
-    offset,
-    limit,
-  };
-};