pim-import 5.0.1 → 5.0.2

package/src/pim/methods/products.ts

@@ -1,3297 +0,0 @@
-import {
-  ProductDetails,
-  AssetsEntity,
-  ColourVariant,
-} from "../../resources/ProductDetails";
-import { AllProductsEntry } from "../../resources/AllProducts";
-import { ProductRelation } from "../../resources/ProductRelation";
-import { FieldItem } from "../../resources/cfFields";
-import { Audit } from "../../resources/Audit";
-import {
-  AvailableCatalogs,
-  CfLocalizedEntryField,
-  WrapperImageFields,
-  CfSys,
-} from "../../types";
-import { log, serverUtils } from "../../libs/logs";
-import {
-  getEntryByCode,
-  getAllEntriesByCodes,
-  getEnvironmentDefaultLocaleCode,
-  createEntryWithId,
-  cfLocales,
-  getEntryByID,
-  updateEntry,
-  getEnvironment,
-  addFieldValue,
-  addToRelationFields,
-  removeFromRelationFields,
-  removeFromFieldObject,
-  createWrapperImgix,
-  getDictionaryLocaleValue,
-  getDictionaryJson,
-  getAllEntries,
-  archiveEntry,
-} from "../../libs/contentful";
-import type {
-  Entry,
-  CreateEntryProps,
-} from "contentful-management/dist/typings/entities/entry";
-import { KeyValueMap } from "contentful-management/dist/typings/common-types";
-import {
-  stringToSlug,
-  secondBetweenTwoDate,
-  sleep,
-  getLocalISOTime,
-  capitalizeFirstLetter,
-  sanitizeValue,
-  getPimTranslations,
-  basename,
-} from "../../utils";
-import {
-  saveAllProductsToS3,
-  getFileFromS3,
-  saveJsonToS3,
-  upload as uploadToS3,
-} from "../../libs/s3";
-import { getAudit, getProductDetails } from "../endpoints";
-import { getCategoryTopicCode } from "./catalogs";
-import productFieldsRequiredData from "../data/productFields.json";
-import {
-  getDefaultWrapperImgixAttributesByPimUrl,
-  getImgixPimUrlByOriginPath,
-  getOriginPathByPimUrl,
-  purgeImageCacheByUrl,
-} from "../../libs/imgix";
-import { generatePDFByUrl } from "../../libs/pdf";
-import { reindexProduct } from "../../algolia/products";
-import { addDesignerData } from "./designers";
-import { notify } from "../../libs/notifications";
-
-export type AvailableProductStatus =
-  | "To be review"
-  | "Published"
-  | "Unpublished";
-
-export type AvailableRelationFieldKeys =
-  | "accessories"
-  | "accessoryOf"
-  | "bulbOf"
-  | "sparepartOf"
-  | "bulbs"
-  | "spareparts";
-
-const PIM_DUPLICATE_SEPARATOR: string = "~";
-const S3_PIM_PAYLOAD_PATH = `pim/payload/`;
-
-/**
- * Check if the sku passed belongs to a product which should not be imported
- * but which needs to be used to create product associations -> additional taxonomy terms.
- *
- * It returns false only if it is an product that needs to be imported or the the updated productEntry
- *
- * @param productDetails
- * @returns peoductEntry or boolean
- */
-const isTermsToAdd = async (
-  productDetails: ProductDetails,
-  catalog: AvailableCatalogs
-): Promise<Entry | boolean> => {
-  if (!productDetails.code.includes(PIM_DUPLICATE_SEPARATOR)) {
-    return false;
-  }
-  log(
-    `Product used to create associations between product and additional taxonomy terms: ${productDetails.code}`
-  );
-
-  const realCode = productDetails.code.substring(
-    0,
-    productDetails.code.indexOf(PIM_DUPLICATE_SEPARATOR)
-  );
-
-  let productEntry: Entry = await getEntryByCode(realCode, "topicProduct");
-  if (!productEntry) {
-    log(
-      `The product ${realCode} does not exist, it is not possible to save the additional association with the ${productDetails?.currentCatalog?.subFamilyCode} family and the ${productDetails?.currentCatalog?.categoryCode} category`
-    );
-    return true;
-  } else if (productEntry.isArchived()) {
-    log(
-      `The product ${realCode} is archived, it is not possible to save the additional association with the ${productDetails?.currentCatalog?.subFamilyCode} family and the ${productDetails?.currentCatalog?.categoryCode} category`
-    );
-    return true;
-  }
-
-  // product -> catalog relation
-  const catalogFieldKey = "catalogs";
-  if (productDetails.currentCatalog?.catalogCode) {
-    const catalogEntry: Entry = await getEntryByCode(
-      productDetails.currentCatalog.catalogCode,
-      "topicCatalog",
-      "sys"
-    );
-    if (catalogEntry) {
-      log(
-        `Start the association of the ${realCode} with the ${productDetails.currentCatalog.catalogCode} catalog`
-      );
-
-      productEntry.fields = await addToRelationFields(
-        productEntry,
-        catalogFieldKey,
-        catalogEntry.sys.id,
-        true
-      );
-    } else {
-      log(
-        `The ${productDetails.currentCatalog.catalogCode} catalog does not exist`
-      );
-    }
-  } else {
-    log(`No catalog code found`, "WARN");
-  }
-
-  // product -> category relation
-  const categoriesFieldKey = "categories" + capitalizeFirstLetter(catalog);
-  if (productDetails.currentCatalog?.categoryCode) {
-    const categoryTopicCode = getCategoryTopicCode(
-      productDetails.currentCatalog.categoryCode,
-      catalog
-    );
-    const categoryEntry: Entry = await getEntryByCode(
-      categoryTopicCode,
-      "topicCategory",
-      "sys"
-    );
-    if (categoryEntry) {
-      log(
-        `Start the association of the ${realCode} with the ${categoryTopicCode} category`
-      );
-      productEntry.fields = await addToRelationFields(
-        productEntry,
-        categoriesFieldKey,
-        categoryEntry.sys.id,
-        true
-      );
-    } else {
-      log(`The ${categoryTopicCode} category does not exist`);
-    }
-  } else {
-    log(`No category code found`, "WARN");
-  }
-
-  // product -> family relation
-  const familiesFieldKey = "families";
-  if (productDetails.currentCatalog?.familyCode) {
-    const familyEntry: Entry = await getEntryByCode(
-      productDetails.currentCatalog.familyCode,
-      "topicFamily",
-      "sys"
-    );
-    if (familyEntry) {
-      log(
-        `Start the association of the ${realCode} with the ${productDetails.currentCatalog.familyCode} family`
-      );
-
-      productEntry.fields = await addToRelationFields(
-        productEntry,
-        familiesFieldKey,
-        familyEntry.sys.id,
-        true
-      );
-    } else {
-      log(
-        `The ${productDetails.currentCatalog.familyCode} family does not exist`
-      );
-    }
-  } else {
-    log(`No family code found`, "WARN");
-  }
-
-  // product -> subFamily relation
-  const subFamiliesFieldKey = "subFamilies" + capitalizeFirstLetter(catalog);
-  if (productDetails.currentCatalog?.subFamilyCode) {
-    const subFamilyEntry: Entry = await getEntryByCode(
-      productDetails.currentCatalog.subFamilyCode,
-      "topicSubFamily",
-      "sys"
-    );
-    if (subFamilyEntry) {
-      log(
-        `Start the association of the ${realCode} with the ${productDetails?.currentCatalog?.subFamilyCode} subFamily`
-      );
-
-      productEntry.fields = await addToRelationFields(
-        productEntry,
-        subFamiliesFieldKey,
-        subFamilyEntry.sys.id,
-        true
-      );
-    } else {
-      log(
-        `The ${productDetails.currentCatalog.subFamilyCode} subFamily does not exist`
-      );
-    }
-  } else {
-    log(`No subFamily code found`, "WARN");
-  }
-
-  // product -> model relations
-  const modelsFieldKey = "models" + capitalizeFirstLetter(catalog);
-  if (productDetails.models) {
-    for (const model of productDetails.models) {
-      const modelCode = model.data.code;
-      if (modelCode) {
-        log(`Get model entry with id ${modelCode}`);
-        const modelEntry = await getEntryByID(modelCode, "topicModel", "sys");
-        if (modelEntry) {
-          log(
-            `Start the association of the ${realCode} with the ${modelCode} model`
-          );
-          productEntry.fields = await addToRelationFields(
-            productEntry,
-            modelsFieldKey,
-            modelEntry.sys.id,
-            true
-          );
-        } else {
-          log(`The ${modelCode} model does not exist`);
-        }
-      } else {
-        log(`No model code found`, "WARN");
-      }
-    }
-  } else {
-    log(`No models found`);
-  }
-
-  // product -> submodel relations
-  const subModelsFieldKey = "subModels" + capitalizeFirstLetter(catalog);
-  if (productDetails.submodels) {
-    for (const submodel of productDetails.submodels) {
-      const subModelCode = submodel.data.code;
-      if (subModelCode) {
-        log(`Get subModel entry with id ${subModelCode}`);
-        const subModelEntry = await getEntryByID(
-          subModelCode,
-          "topicSubModel",
-          "sys"
-        );
-        if (subModelEntry) {
-          log(
-            `Start the association of the ${realCode} with the ${subModelCode} subModel`
-          );
-          productEntry.fields = await addToRelationFields(
-            productEntry,
-            subModelsFieldKey,
-            subModelEntry.sys.id,
-            true
-          );
-        } else {
-          log(`The ${subModelCode} subModel does not exist`);
-        }
-      } else {
-        log(`No subModel code found`, "WARN");
-      }
-    }
-  } else {
-    log(`No subModel found`);
-  }
-
-  productEntry = await productEntry.update();
-  if (productEntry.isPublished()) {
-    try {
-      productEntry = await productEntry.publish();
-    } catch (err: any) {
-      log(`Cannot publish entry.`);
-      log(err);
-    }
-  }
-
-  return productEntry;
-};
-
-const notVisibleToWebProduct = async (code: string): Promise<void> => {
-  // topicProduct
-  let productEntry: Entry = await getEntryByCode(code, "topicProduct");
-  if (productEntry) {
-    const pageId = getProductPageIdByCode(productEntry.sys.id);
-
-    log("The product exists, I proceed to archive it");
-    productEntry = await archiveEntry(productEntry, true);
-    // page
-    let pageEntry = await getEntryByID(pageId, "page");
-    if (pageEntry) {
-      pageEntry = await archiveEntry(pageEntry);
-    }
-  } else {
-    log("The product has never been imported", "WARN");
-  }
-};
-
-export const setHideInRegionField = async (
-  destinations: string[],
-  pageData: CreateEntryProps
-) => {
-  const env = await getEnvironment();
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  let productRegions = destinations
-    ?.filter(
-      (item: any) =>
-        item?.code?.includes("PROFESSIONAL_") ||
-        (typeof item === "string" && item?.includes("PROFESSIONAL_"))
-    )
-    .map((item: any) => {
-      const region =
-        item?.code?.replace("PROFESSIONAL_", "")?.toLowerCase() ||
-        item?.replace("PROFESSIONAL_", "")?.toLowerCase();
-      return region === "china" ? "cn" : region;
-    });
-
-  /* 
-  Aggiunto per risolvere il problema sul sito Cina:
-
-  se sono nascoste in global => lascio hide in regions CN
-  se non sono nascoste in global => tolgo hide in regions CN
-  */
-  if (productRegions.includes("global") && !productRegions.includes("cn")) {
-    productRegions.push("cn");
-  }
-
-  if (pageData.fields.hideInRegions?.[defEnvLocaleCode]) {
-    pageData.fields.hideInRegions[defEnvLocaleCode] = [];
-  }
-
-  if (productRegions?.length) {
-    log(`Hide from other regions other than: ${productRegions.join(", ")}`);
-    const { items } = await env.getEntries({
-      content_type: "topicRegion",
-      limit: 100,
-      skip: 0,
-      locale: defEnvLocaleCode,
-      include: 0,
-      select: "sys,fields",
-    });
-    let count = 0;
-    for (const item of items) {
-      const region = item?.fields?.region?.[defEnvLocaleCode];
-
-      if (!productRegions.includes(region)) {
-        log(`Hide in region: ${region}`);
-        pageData.fields = await addToRelationFields(
-          pageData,
-          "hideInRegions",
-          item.sys.id,
-          true,
-          count++ === 0
-        );
-      }
-    }
-  } else if (pageData.fields?.hideInRegions?.[defEnvLocaleCode]) {
-    log(`No region found remove old hideInRegions relations.`);
-  } else {
-    log(`No region found.`, "WARN");
-  }
-
-  return pageData.fields;
-};
-
-const getProductPageData = async (
-  names: CfLocalizedEntryField,
-  slugs: CfLocalizedEntryField,
-  pageId: string,
-  productEntry: Entry,
-  productPageEntry: Entry
-): Promise<CreateEntryProps> => {
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-  const pageData: CreateEntryProps = {
-    fields: productPageEntry?.fields || {},
-  };
-
-  pageData.fields.title = names;
-  pageData.fields.slug = slugs;
-
-  pageData.fields = await addFieldValue(pageData, "internalName", pageId);
-  pageData.fields = await addFieldValue(pageData, "type", "CatalogProduct");
-
-  // Topic
-  pageData.fields = await addToRelationFields(
-    pageData,
-    "topic",
-    productEntry.sys.id
-  );
-
-  // hideInRegions
-  const destinations =
-    productEntry?.fields?.productFields?.[defEnvLocaleCode]?.destinations;
-  pageData.fields = await setHideInRegionField(destinations, pageData);
-  return pageData;
-};
-
-const createOrUpdateProductPage = async (
-  productEntry: Entry,
-  unpublish: boolean
-): Promise<Entry> => {
-  const pageId = getProductPageIdByCode(productEntry.sys.id);
-  const names: CfLocalizedEntryField = productEntry.fields.name;
-  const slugs: any = {};
-  const code = productEntry.fields.code["en"];
-
-  for (const name of Object.entries(productEntry.fields.name)) {
-    slugs[name[0]] = stringToSlug(`${name[1]}-${code}`, true).toLowerCase();
-  }
-
-  // PAGE
-  let productPageEntry: Entry = await getEntryByID(pageId, "page");
-  const pageData: CreateEntryProps = await getProductPageData(
-    names,
-    slugs,
-    pageId,
-    productEntry,
-    productPageEntry
-  );
-  if (productPageEntry) {
-    if (productPageEntry.isArchived()) {
-      log(`Unarchive product page with id ${pageId}`);
-      productPageEntry = await productPageEntry.unarchive();
-    }
-    log(`Product page ${pageId} already exists. Updating...`);
-    productPageEntry = await updateEntry(
-      productPageEntry,
-      pageData,
-      productPageEntry.isPublished() && !unpublish
-    );
-  } else {
-    log(`Product page ${pageId} not exists. Create new entry with data`);
-    productPageEntry = await createEntryWithId("page", pageId, pageData);
-  }
-
-  return productPageEntry;
-};
-
-export const certificationFields = ["certification", "marking"];
-export const excludeCertificationFieldsKeys = [
-  "designAwards",
-  "energyLabel",
-  "lightObjMinDist",
-  "ilcos",
-  "dynamicLoad",
-  "staticLoad",
-  "casambi",
-  "fMarking",
-];
-
-const getProductFields = async (pimDetails: any) => {
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-  const productFields: any = {};
-  productFieldsRequiredData.forEach((fieldData) => {
-    if (fieldData.parent) {
-      if (
-        pimDetails?.[fieldData.parent]?.[fieldData.key] ||
-        pimDetails?.[fieldData.parent]?.[fieldData.key] === false
-      ) {
-        if (Array.isArray(pimDetails[fieldData.parent][fieldData.key])) {
-          pimDetails[fieldData.parent][fieldData.key].forEach((item: any) => {
-            if (
-              item.code &&
-              sanitizeValue(item.code) &&
-              sanitizeValue(item[`value_${defaultEnvironmentLocaleCode}`])
-            ) {
-              if (!productFields?.[fieldData.parent]?.[fieldData.key]) {
-                if (!productFields?.[fieldData.parent]) {
-                  productFields[fieldData.parent] = {};
-                }
-                productFields[fieldData.parent][fieldData.key] = [];
-              }
-
-              productFields[fieldData.parent][fieldData.key].push({
-                code: item.code,
-                parentName: item?.parentName || "",
-              });
-            }
-          });
-        } else {
-          let value: any = "";
-          if (
-            pimDetails?.[fieldData.parent]?.[fieldData.key]?.code &&
-            sanitizeValue(pimDetails[fieldData.parent][fieldData.key].code) &&
-            sanitizeValue(
-              pimDetails[fieldData.parent][fieldData.key][
-                `value_${defaultEnvironmentLocaleCode}`
-              ]
-            )
-          ) {
-            value = {
-              code:
-                pimDetails[fieldData.parent][fieldData.key]?.code ||
-                pimDetails[fieldData.parent][fieldData.key] ||
-                "",
-              parentName:
-                pimDetails[fieldData.parent][fieldData.key]?.parentName || "",
-            };
-          } else if (
-            (pimDetails?.[fieldData.parent]?.[fieldData.key]?.state &&
-              sanitizeValue(
-                pimDetails[fieldData.parent][fieldData.key].state
-              )) ||
-            pimDetails[fieldData.parent][fieldData.key].state === false
-          ) {
-            value = {
-              state: !!pimDetails[fieldData.parent][fieldData.key].state,
-              label:
-                pimDetails[fieldData.parent][fieldData.key]?.label?.[
-                  `value_${defaultEnvironmentLocaleCode}`
-                ] || "",
-            };
-          } else if (
-            typeof pimDetails[fieldData.parent][fieldData.key] !== "object" &&
-            (sanitizeValue(pimDetails[fieldData.parent][fieldData.key]) ||
-              pimDetails[fieldData.parent][fieldData.key] === false)
-          ) {
-            value = pimDetails[fieldData.parent][fieldData.key];
-          }
-
-          if (value || value === false) {
-            if (!productFields[fieldData.parent]) {
-              productFields[fieldData.parent] = {};
-            }
-
-            productFields[fieldData.parent][fieldData.key] = value;
-          }
-        }
-      } else {
-        log(
-          `${fieldData.parent}.${fieldData.key} product field not found on the pim or null`
-        );
-      }
-    } else {
-      if (pimDetails.hasOwnProperty(fieldData.key)) {
-        if (Array.isArray(pimDetails[fieldData.key])) {
-          pimDetails[fieldData.key].forEach((item: any) => {
-            if (
-              item.code &&
-              sanitizeValue(item.code) &&
-              sanitizeValue(item[`value_${defaultEnvironmentLocaleCode}`])
-            ) {
-              if (!productFields?.[fieldData.key]) {
-                productFields[fieldData.key] = [];
-              }
-              productFields[fieldData.key].push({
-                code: item.code,
-                parentName: item?.parentName || "",
-              });
-            }
-          });
-        } else {
-          let value: any = "";
-          if (
-            pimDetails[fieldData.key]?.code &&
-            sanitizeValue(pimDetails[fieldData.key].code) &&
-            sanitizeValue(
-              pimDetails[fieldData.key][`value_${defaultEnvironmentLocaleCode}`]
-            )
-          ) {
-            value = {
-              code:
-                pimDetails[fieldData.key]?.code ||
-                pimDetails[fieldData.key] ||
-                "",
-              parentName: pimDetails[fieldData.key]?.parentName || "",
-            };
-          } else if (
-            typeof pimDetails[fieldData.key] !== "object" &&
-            (sanitizeValue(pimDetails[fieldData.key]) ||
-              pimDetails[fieldData.key] === false)
-          ) {
-            value = pimDetails[fieldData.key];
-          }
-          if (value || value === false) {
-            productFields[fieldData.key] = value;
-          }
-        }
-      } else {
-        log(`${fieldData.key} product field not found on the pim`);
-      }
-    }
-  });
-
-  productFields.certifications = [];
-  for (const certificationField of certificationFields) {
-    if (productFields?.[certificationField]) {
-      log(`Manage certifications field: ${certificationField}`);
-      for (const [key, values] of Object.entries(
-        productFields[certificationField]
-      )) {
-        if (!excludeCertificationFieldsKeys.includes(key)) {
-          log(`Add ${key} values to productFields.certifications`);
-          productFields.certifications =
-            productFields.certifications.concat(values);
-        }
-      }
-    }
-  }
-  if (productFields.certifications.length) {
-    log(`Remove unwanted values to productFields.certifications`);
-    productFields.certifications = productFields.certifications.filter(
-      (value: any) => {
-        return sanitizeValue(value?.code);
-      }
-    );
-  }
-
-  return productFields;
-};
-
-const getTopicProductIdByCode = (productCode: string) => {
-  return productCode;
-};
-
-export const getProductPageIdByCode = (productCode: string) => {
-  return `${productCode}_PAGE`;
-};
-
-const getProductPayloadS3Details = (topicProductId: string) => {
-  return { path: S3_PIM_PAYLOAD_PATH, fileName: `${topicProductId}.json` };
-};
-
-const getProductAssets = async (
-  pimAssets: AssetsEntity[],
-  productCode: string
-) => {
-  const assets: any = {};
-  for (const pimAsset of pimAssets) {
-    if (pimAsset?.url && pimAsset?.assetType?.code) {
-      const assetCode = pimAsset?.assetType?.code;
-      const md5 = pimAsset?.md5;
-
-      if (!assetCode || !md5) {
-        log(
-          `No assetCode or md5 found for product: ${productCode} assetURL: ${pimAsset.url}`,
-          "WARN"
-        );
-        continue;
-      }
-
-      if (!assets?.[assetCode]) {
-        assets[assetCode] = [];
-      }
-
-      let assetUrl: string = "";
-      const pimDomain = "dam.flos.net";
-      const fileExtension = pimAsset.url.split(".")?.pop()?.toLowerCase() || "";
-      if (
-        process.env.FPI_IMGIX_PIM_IMAGE_DOMAIN &&
-        pimAsset.url.indexOf(pimDomain) !== -1 &&
-        ["jpg", "png", "gif"].includes(fileExtension)
-      ) {
-        assetUrl = pimAsset.url.replace(
-          pimDomain,
-          process.env.FPI_IMGIX_PIM_IMAGE_DOMAIN
-        );
-      } else if (["svg"].includes(fileExtension)) {
-        assetUrl = pimAsset.url;
-      } else {
-        const path = `product-assets/${md5}`;
-        const fileName = basename(pimAsset.url);
-
-        // FIXME: Trovare un modo per rintracciare i file già esistenti, l'unico parametro utilizzabile è l'MD5
-        // Se esistono file con lo stesso filename ma diverso MD5 questi verranno caricati più volte
-        const assetAlreadyExists = await getFileFromS3(
-          `${path}/${fileName}`,
-          true
-        );
-        if (assetAlreadyExists) {
-          log(`Asset aleady exists: ${assetAlreadyExists}`);
-          assetUrl = assetAlreadyExists;
-        } else {
-          log(`Asset not exists, importing it to S3 path: ${path}/${fileName}`);
-          try {
-            const res = await uploadToS3(pimAsset.url, fileName, path);
-            assetUrl = res.Location;
-          } catch (err: any) {
-            log(
-              `Unable to upload file: ${err.response.status} - ${err.response.statusText}`,
-              "WARN"
-            );
-          }
-        }
-      }
-
-      if (assetUrl) {
-        assets[assetCode].push(assetUrl);
-      }
-    } else {
-      log(
-        `The asset ${pimAsset?.assetType} cannot be imported because the url or assetType.code parameters are empty`,
-        "WARN"
-      );
-    }
-  }
-
-  return assets;
-};
-
-const getProductData = async (
-  productEntry: Entry,
-  productDetails: ProductDetails
-) => {
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const data: CreateEntryProps = {
-    fields: productEntry?.fields || {},
-  };
-
-  data.fields.name = getPimTranslations(
-    productDetails,
-    "webNaming",
-    productDetails.name,
-    255
-  );
-  data.fields = await addFieldValue(data, "code", productDetails.code);
-
-  data.fields.description = getPimTranslations(productDetails, "description1");
-  data.fields.excerpt = getPimTranslations(productDetails, "description2");
-  data.fields.note = getPimTranslations(productDetails, "note");
-
-  const { currentCatalog, ...pimDetails } = productDetails;
-
-  log(`Set productFields`);
-  const productFields = await getProductFields(pimDetails);
-  data.fields = await addFieldValue(data, "productFields", productFields);
-
-  // catalogs
-  const catalog = productDetails?.currentCatalog?.catalogCode || "";
-  if (catalog) {
-    const catalogEntry: Entry = await getEntryByCode(
-      catalog,
-      "topicCatalog",
-      "sys"
-    );
-    log(`Set catalog relation: ${catalog}`);
-    data.fields = await addToRelationFields(
-      data,
-      "catalogs",
-      catalogEntry.sys.id,
-      true
-    );
-  }
-
-  // categories - for catalg
-  const categoriesFieldKey = "categories" + capitalizeFirstLetter(catalog);
-  if (catalog && productDetails?.currentCatalog?.categoryCode) {
-    const categoryTopicCode = getCategoryTopicCode(
-      productDetails.currentCatalog.categoryCode,
-      catalog
-    );
-    const categoryEntry: Entry = await getEntryByCode(
-      categoryTopicCode,
-      "topicCategory",
-      "sys"
-    );
-    if (!categoryEntry) {
-      log(`The topicCategory with code ${categoryTopicCode} not found`, "WARN");
-    } else {
-      log(
-        `Set category relation: ${categoryTopicCode} in the field ${categoriesFieldKey}`
-      );
-      data.fields = await addToRelationFields(
-        data,
-        categoriesFieldKey,
-        categoryEntry.sys.id,
-        true
-      );
-    }
-  }
-
-  // families
-  if (productDetails?.currentCatalog?.familyCode) {
-    const familyEntry: Entry = await getEntryByCode(
-      productDetails.currentCatalog.familyCode,
-      "topicFamily",
-      "sys"
-    );
-    if (!familyEntry) {
-      log(
-        `The topicFamily with code ${productDetails.currentCatalog.familyCode} not found`,
-        "WARN"
-      );
-    } else {
-      log(`Set family relation: ${productDetails.currentCatalog.familyCode}`);
-      data.fields = await addToRelationFields(
-        data,
-        "families",
-        familyEntry.sys.id,
-        true
-      );
-    }
-  }
-
-  // subFamilies - for catalg
-  const subFamiliesFieldKey = "subFamilies" + capitalizeFirstLetter(catalog);
-  if (productDetails?.currentCatalog?.subFamilyCode) {
-    const subFamilyEntry: Entry = await getEntryByCode(
-      productDetails.currentCatalog.subFamilyCode,
-      "topicSubFamily",
-      "sys"
-    );
-
-    if (!subFamilyEntry) {
-      log(
-        `The topicSubFamily with code ${productDetails.currentCatalog.subFamilyCode} not found`,
-        "WARN"
-      );
-    } else {
-      log(
-        `Set subFamily relation: ${productDetails.currentCatalog.subFamilyCode} in the field ${subFamiliesFieldKey}`
-      );
-      data.fields = await addToRelationFields(
-        data,
-        subFamiliesFieldKey,
-        subFamilyEntry.sys.id,
-        true
-      );
-    }
-  }
-
-  // productLine
-  if (productDetails?.productLine) {
-    const productLineEntry: Entry = await getEntryByCode(
-      productDetails.productLine.code,
-      "topicProductLine",
-      "sys"
-    );
-    if (!productLineEntry) {
-      log(
-        `The topicProductLine with code ${productDetails.productLine.code} not found`,
-        "WARN"
-      );
-    } else {
-      log(`Set productLine relation: ${productDetails.productLine.code}`);
-      data.fields = await addToRelationFields(
-        data,
-        "productLine",
-        productLineEntry.sys.id
-      );
-    }
-  }
-
-  // productSubLine
-  if (productDetails?.productLineDetail) {
-    const productSubLineEntry: Entry = await getEntryByCode(
-      productDetails.productLineDetail.code,
-      "topicProductSubLine",
-      "sys"
-    );
-    if (!productSubLineEntry) {
-      log(
-        `The topicProductSubLine with code ${productDetails.productLineDetail.code} not found`,
-        "WARN"
-      );
-    } else {
-      log(
-        `Set productSubLine relation: ${productDetails.productLineDetail.code}`
-      );
-      data.fields = await addToRelationFields(
-        data,
-        "productSubLine",
-        productSubLineEntry.sys.id
-      );
-    }
-  }
-
-  // models - for catalg
-  const modelsFieldKey = "models" + capitalizeFirstLetter(catalog);
-  if (productDetails?.models) {
-    log(`Set ${productDetails.models.length} model relations`);
-    const modelCodes = productDetails.models.map((model) => {
-      return model.data.code;
-    });
-
-    const topicModelEntries = await getAllEntriesByCodes(
-      modelCodes,
-      "topicModel",
-      "sys,fields.catalog"
-    );
-
-    if (topicModelEntries.length) {
-      for (const topicModelEntry of topicModelEntries) {
-        if (
-          topicModelEntry?.fields?.catalog?.[defaultEnvironmentLocaleCode]?.sys
-            ?.id !== catalog
-        ) {
-          log(
-            `The model ${topicModelEntry.sys.id} belongs to the catalog ${topicModelEntry?.fields?.catalog?.[defaultEnvironmentLocaleCode]?.sys?.id} and will not be imported`
-          );
-          continue;
-        } else {
-          log(
-            `Set relation with model ${topicModelEntry.sys.id} in the field ${modelsFieldKey}`
-          );
-          data.fields = await addToRelationFields(
-            data,
-            modelsFieldKey,
-            topicModelEntry.sys.id,
-            true
-          );
-        }
-      }
-    } else {
-      log(
-        `No topicModel found for product ${
-          productDetails.code
-        }: ${modelCodes.join(",")}`,
-        "WARN"
-      );
-    }
-  }
-
-  // subModels for catalog
-  const subModelsFieldKey = "subModels" + capitalizeFirstLetter(catalog);
-  if (productDetails?.submodels) {
-    log(`Set ${productDetails.submodels.length} subModels relations`);
-    const subModelsCodes = productDetails.submodels.map((subModel) => {
-      return subModel.data.code;
-    });
-
-    const topicSubModelEntries = await getAllEntriesByCodes(
-      subModelsCodes,
-      "topicSubModel",
-      "sys,fields.catalog"
-    );
-
-    if (topicSubModelEntries.length) {
-      for (const topicSubModelEntry of topicSubModelEntries) {
-        if (
-          topicSubModelEntry?.fields?.catalog?.[defaultEnvironmentLocaleCode]
-            ?.sys?.id !== catalog
-        ) {
-          log(
-            `The subModel ${topicSubModelEntry.sys.id} belongs to the catalog ${topicSubModelEntry?.fields?.catalog?.[defaultEnvironmentLocaleCode]?.sys?.id} and will not be imported`
-          );
-          continue;
-        } else {
-          log(
-            `Set relation with subModel ${topicSubModelEntry.sys.id} in the field ${subModelsFieldKey}`
-          );
-          data.fields = await addToRelationFields(
-            data,
-            subModelsFieldKey,
-            topicSubModelEntry.sys.id,
-            true
-          );
-        }
-      }
-    } else {
-      log(
-        `No topicSubModel found for product ${
-          productDetails.code
-        }: ${subModelsCodes.join(",")}`,
-        "WARN"
-      );
-    }
-  }
-
-  // assets
-  if (productDetails?.assets) {
-    const pimAssetThumb = productDetails.assets.find(
-      (asset) => asset?.assetType.code === "THUMB"
-    );
-
-    // THUMB
-    if (pimAssetThumb?.url && pimAssetThumb?.md5) {
-      log(`Set THUMB`);
-      // THUMB WRAPPER IMGIX
-      const wrapperImgixID = pimAssetThumb.md5;
-      let wrapperImgix = await getEntryByID(
-        wrapperImgixID,
-        "wrapperImgix",
-        "sys,fields"
-      );
-      if (wrapperImgix) {
-        log(`wrapperImgix with id ${wrapperImgixID} already exists`);
-        const imgixBasename = basename(
-          wrapperImgix.fields.imgixData[defaultEnvironmentLocaleCode].url
-        );
-        const pimBasename = basename(pimAssetThumb.url);
-        if (imgixBasename !== pimBasename) {
-          log(`Update img url from ${imgixBasename} to ${pimBasename}`);
-          const newImgixUrl = getImgixPimUrlByOriginPath(
-            getOriginPathByPimUrl(pimAssetThumb.url)
-          );
-          wrapperImgix.fields.imgixData[defaultEnvironmentLocaleCode].url =
-            newImgixUrl;
-          wrapperImgix = await wrapperImgix.update();
-          if (wrapperImgix.isPublished()) {
-            wrapperImgix = await wrapperImgix.publish();
-          }
-
-          log(`The new imgix url is: ${newImgixUrl}`);
-        } else {
-          log(`wrapperImgix basename matched`);
-        }
-      } 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 = getDefaultWrapperImgixAttributesByPimUrl(
-          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 or md5 is null`, "WARN");
-    }
-
-    // OTHER ASSETS
-    const pimOtherAssets = productDetails.assets.filter(
-      (asset) => asset?.assetType.code !== "THUMB"
-    );
-    if (pimOtherAssets.length) {
-      log(`Uploading ${pimOtherAssets.length} assets to S3`);
-      const assets = await getProductAssets(
-        pimOtherAssets as AssetsEntity[],
-        productDetails.code
-      );
-      if (assets) {
-        data.fields = await addFieldValue(data, "assets", assets);
-      }
-    } else {
-      log(`No other assets found`, "WARN");
-    }
-  }
-
-  // lastPimSyncDate
-  data.fields = await addFieldValue(data, "lastPimSyncDate", getLocalISOTime());
-
-  // designers
-  if (productDetails.designers) {
-    for (const designer of productDetails.designers) {
-      data.fields = await addDesignerData(data, designer, true);
-    }
-  } else {
-    log(`No designers found`, "WARN");
-    if (data.fields.designers?.[defaultEnvironmentLocaleCode]) {
-      log(`remove old designers relation`);
-      data.fields.designers = [];
-    }
-  }
-
-  // autodescription
-  data.fields.autoDescription = await getTopicProductAutodescription(
-    data.fields
-  );
-
-  // Destinations
-  if (productDetails?.destinations?.length) {
-    log(`set destinations`);
-    data.fields = await addFieldValue(
-      data,
-      "destinations",
-      productDetails.destinations.map((item) => item.code)
-    );
-  } else {
-    log(`destinations not found`, "WARN");
-  }
-
-  // endpoint payload - used into setProductRelationships
-  const productEntryId = getTopicProductIdByCode(productDetails.code);
-  const { path, fileName } = getProductPayloadS3Details(productEntryId);
-  log(`Uploading "${fileName}" to S3 path "${path}"`);
-  const { Location } = await saveJsonToS3(pimDetails, fileName, path);
-  data.fields = await addFieldValue(data, "endpointPayload", Location);
-  log(`"${fileName}" uploaded to ${Location}`);
-
-  return data;
-};
-
-const getProductColourVariantsData = async (
-  topicProductColourVariantsCode: string,
-  productEntryId: string,
-  topicProductColourVariants: Entry | null
-) => {
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-  const data: CreateEntryProps = {
-    fields: {
-      code: {},
-      lastPimSyncDate: {},
-    },
-  };
-
-  if (topicProductColourVariants?.fields) {
-    data.fields = topicProductColourVariants.fields;
-  }
-
-  // code
-  data.fields.code[defaultEnvironmentLocaleCode] =
-    topicProductColourVariantsCode;
-
-  // products
-  data.fields = await addToRelationFields(
-    data,
-    "products",
-    productEntryId,
-    true
-  );
-
-  // lastPimSyncDate
-  data.fields.lastPimSyncDate[defaultEnvironmentLocaleCode] = getLocalISOTime();
-
-  return data;
-};
-
-const addProductColourVariants = async (
-  colourVariants: ColourVariant[],
-  productEntryId: string
-) => {
-  for (const colourVariant of colourVariants) {
-    const topicId = `PCV_${colourVariant.code}`;
-    let topicProductColourVariants: Entry = await getEntryByID(
-      topicId,
-      "topicProductColourVariants"
-    );
-    const data = await getProductColourVariantsData(
-      colourVariant.code,
-      productEntryId,
-      topicProductColourVariants
-    );
-    if (!topicProductColourVariants) {
-      log(`Create topicProductColourVariants with code ${topicId}`);
-      // Create new topicProductColourVariants
-      topicProductColourVariants = await createEntryWithId(
-        "topicProductColourVariants",
-        topicId,
-        data,
-        true
-      );
-    } else {
-      log(`Update topicProductColourVariants with code ${topicId}`);
-      // Update existing topicProductColourVariants
-      topicProductColourVariants = await updateEntry(
-        topicProductColourVariants,
-        data,
-        topicProductColourVariants.isPublished()
-      );
-    }
-  }
-};
-
-/**
- * Import product
- * - name
- * - code
- * - status
- * - categories
- * - families
- * - subfamilies
- * - models
- * - submodels
- * - productLine
- * - accessories
- * - accessoryOf
- * - bulbOf
- * - sparepartOf
- * - bulbs
- * - spareparts
- * - pimDetails
- * - lastPimSyncDate
- */
-const addProduct = async (
-  productDetails: ProductDetails
-): Promise<Entry | boolean> => {
-  // Check that the title is set
-  const title = productDetails.webNaming || productDetails.name;
-  if (!title) {
-    log(
-      `Can't possible to import the product ${productDetails.code}, name and webNaming not found`
-    );
-    return false;
-  }
-
-  log(`If exists get entry with code: ${productDetails.code}`);
-
-  let productEntry: Entry = await getEntryByCode(
-    productDetails.code,
-    "topicProduct"
-  );
-
-  const productData = await getProductData(productEntry, productDetails);
-
-  let publishEntry = false;
-
-  if (!productEntry) {
-    const productEntryId = getTopicProductIdByCode(productDetails.code);
-    log(`Create product with code ${productEntryId}`);
-    // Create new topicProduct
-    productEntry = await createEntryWithId(
-      "topicProduct",
-      productEntryId,
-      productData,
-      false
-    );
-  } else {
-    if (productEntry.isArchived()) {
-      log(`Unarchive product with code ${productDetails.code}`);
-      productEntry = await productEntry.unarchive();
-    }
-    log(`Update product with code ${productDetails.code}`);
-    productEntry = await updateEntry(
-      productEntry,
-      productData,
-      productEntry.isPublished()
-    );
-    publishEntry = productEntry?.isPublished();
-  }
-
-  log(`Publish entry: ${publishEntry}`);
-
-  // Create or update pageContent and page of the current topicProduct
-  await createOrUpdateProductPage(productEntry, !publishEntry);
-
-  if (productDetails?.colourVariants) {
-    await addProductColourVariants(
-      productDetails.colourVariants,
-      productEntry.sys.id
-    );
-  }
-
-  return productEntry;
-};
-
-const validateImportProduct = (
-  productDetails: ProductDetails,
-  catalog: AvailableCatalogs,
-  familyCodeIn?: string[],
-  subFamilyCodeIn?: string[]
-) => {
-  // Validate catalog
-  if (!productDetails.currentCatalog?.catalogCode) {
-    log(
-      `The product ${productDetails.code} does not belong to the ${catalog} catalog or the catalog is not specified. Catalog code: ${productDetails.currentCatalog?.catalogCode}`,
-      "WARN"
-    );
-    return false;
-  }
-
-  // Validate family
-  if (
-    familyCodeIn?.length &&
-    !familyCodeIn.includes(productDetails.currentCatalog?.familyCode as string)
-  ) {
-    log(
-      `The product ${
-        productDetails.code
-      } does not belong to any of the ${familyCodeIn.join(
-        ","
-      )} families or the family is not specified. Family code: ${
-        productDetails.currentCatalog?.familyCode
-      }`,
-      "WARN"
-    );
-    return false;
-  }
-
-  // Validate subfamily
-  if (
-    subFamilyCodeIn?.length &&
-    !subFamilyCodeIn.includes(
-      productDetails.currentCatalog?.subFamilyCode as string
-    )
-  ) {
-    log(
-      `The product ${
-        productDetails.code
-      } does not belong to any of the ${subFamilyCodeIn.join(
-        ","
-      )} subFamilies or the subFamily is not specified. SubFamily code: ${
-        productDetails.currentCatalog?.subFamilyCode
-      }`,
-      "WARN"
-    );
-    return false;
-  }
-
-  return true;
-};
-
-/**
- * Import product
- *
- * create/update topicProduct
- * - name
- * - code
- * - pimDetails
- * - status
- * - catalogs
- * - categories
- * - subFamilies
- * - productLine
- * - lastPimSyncDate
- *
- * @param productDetails
- * @param catalog
- * @returns
- */
-export const importProduct = async (
-  productDetails: ProductDetails,
-  catalog: AvailableCatalogs,
-  familyCodeIn?: string[],
-  subFamilyCodeIn?: string[]
-): Promise<boolean> => {
-  productDetails.currentCatalog = productDetails.catalogs?.find(
-    (itemCatalog) => itemCatalog.catalogCode === catalog
-  );
-
-  if (
-    !validateImportProduct(
-      productDetails,
-      catalog,
-      familyCodeIn,
-      subFamilyCodeIn
-    )
-  ) {
-    return false;
-  }
-
-  log(`Import product ${productDetails.code}`, "INFO");
-
-  const isTermsToAddCode = await isTermsToAdd(productDetails, catalog);
-  if (isTermsToAddCode) {
-    return false;
-  }
-
-  if (
-    (productDetails.visibleToWeb === true ||
-      productDetails.code === "0000000-TEST") &&
-    productDetails.destinations?.filter((item) =>
-      item.code.includes("PROFESSIONAL_")
-    ).length
-  ) {
-    await addProduct(productDetails);
-    return true;
-  } else {
-    await notVisibleToWebProduct(productDetails.code);
-    const destinations = productDetails.destinations
-      ?.map((item) => item.code)
-      .join(", ");
-
-    log(
-      `Product not to be imported: ${productDetails.code} - visibleToWeb = ${productDetails.visibleToWeb} - destinations = [${destinations}]`
-    );
-    return false;
-  }
-};
-
-export const setProductRelationships = async (
-  code: string,
-  fieldKey: AvailableRelationFieldKeys | null = null
-) => {
-  log(`setProductRelationships - code: ${code} fieldKey: ${fieldKey}`, "INFO");
-
-  const fieldKeys: AvailableRelationFieldKeys[] = [
-    "accessories",
-    "accessoryOf",
-    "bulbOf",
-    "sparepartOf",
-    "bulbs",
-    "spareparts",
-  ];
-
-  if (!fieldKey) {
-    log(
-      `The fieldKey parameter is empty so all fields will be imported: ${fieldKeys.join(
-        ","
-      )} `
-    );
-  }
-
-  const currentFieldKeys = fieldKey ? [fieldKey] : fieldKeys;
-  let productEntry = await getEntryByCode(code, "topicProduct");
-  if (!productEntry) {
-    log(`Product with code ${code} not found`, "WARN");
-  } else if (productEntry.isArchived()) {
-    log(`Product with code ${code} is archived`, "WARN");
-  } else if (!productEntry.isArchived()) {
-    const { path, fileName } = getProductPayloadS3Details(productEntry.sys.id);
-    log(`Get payload from ${path}${fileName} S3 path`);
-    const productDetails = await getFileFromS3(`${path}${fileName}`);
-    if (productDetails) {
-      const defaultEnvironmentLocaleCode =
-        await getEnvironmentDefaultLocaleCode();
-      let update = false;
-      let fieldKeysCount = 0;
-      for (const currentFieldKey of currentFieldKeys) {
-        log(`Set ${currentFieldKey} relations to product with code ${code}`);
-        const fieldValues: ProductRelation[] = productDetails[currentFieldKey];
-
-        if (fieldValues) {
-          const relationships = [];
-          const producRelationCodes = fieldValues.map((fieldValue) => {
-            return fieldValue.code;
-          });
-
-          const entries = await getAllEntriesByCodes(
-            producRelationCodes,
-            "topicProduct",
-            "sys,fields.code"
-          );
-
-          for (const fieldValue of fieldValues) {
-            const entry = entries.find(
-              (currentEntry) =>
-                currentEntry.fields.code[defaultEnvironmentLocaleCode] ===
-                fieldValue.code
-            );
-            if (entry) {
-              relationships.push({
-                quantity: fieldValue.quantity || "",
-                typeCode: fieldValue.typeCode || "",
-                typeLabel: fieldValue.typeLabel || "",
-                entryId: entry.sys.id,
-              });
-            } else {
-              log(
-                `The product with ${fieldValue.code} code was not found, it cannot be associated with the ${currentFieldKey} field of product ${code}`
-              );
-            }
-          }
-          const prevItemsCount =
-            productEntry?.fields[currentFieldKey]?.length || 0;
-          if (relationships.length || prevItemsCount > 0) {
-            if (!relationships.length && prevItemsCount > 0) {
-              log(
-                `No product relationships found of the field ${currentFieldKey} for the product ${code}, i remove ${prevItemsCount} pre-existing relationships`
-              );
-            } else {
-              log(
-                `Founded ${relationships.length} relationships of ${producRelationCodes.length} PIM relationships for the field ${currentFieldKey} of product ${code}`
-              );
-            }
-            productEntry.fields[currentFieldKey] = {};
-            productEntry.fields[currentFieldKey][defaultEnvironmentLocaleCode] =
-              relationships;
-            update = true;
-          } else {
-            log(
-              `No product relationships found of the field ${currentFieldKey} for the product ${code}`
-            );
-          }
-
-          if (++fieldKeysCount % 7 === 0) {
-            await sleep(2000, true);
-          }
-        } else {
-          log(`No field ${currentFieldKey} found for the product ${code}`);
-        }
-      }
-
-      if (update) {
-        try {
-          productEntry = await productEntry.update();
-          log(`Updated ${code} product changes`);
-          if (productEntry.isPublished()) {
-            try {
-              productEntry = await productEntry.publish();
-              log(`Published ${code} product`);
-            } catch (err: any) {
-              const message = `setProductRelationships - Cannot publish entry. ${code}`;
-              await notify(message, false);
-              log(message);
-              log(err);
-            }
-          }
-        } catch (err: any) {
-          const message = `setProductRelationships - Cannot update entry. ${code}`;
-          await notify(message, false);
-          log(message);
-          log(err);
-        }
-      }
-    } else {
-      log(
-        `${productEntry.sys.id} product payload was not found on S3. Relationships cannot be set.`,
-        "WARN"
-      );
-    }
-  }
-};
-
-/**
- * Set the product relationships
- *
- * TODO: È uno dei punti critici dell'import, in quanto dovento interrogare
- * l'endpoint /products?catalog&lastModified dobbiamo obbligatoriamente scorrere
- * tutti i prodotti restituiti anche se non interessano.
- * Potremmo passare la data in cui l'import inizia e ottenere a questo punto
- * tutti i topicProduct, del catalogo in questione, che hanno il campo lastPimSyncDate >= a quello di inizio import
- * di contro, facendo così aumenteremmo le chiamate fatte a contentful
- *
- * @param catalog
- * @param lastModified 20210527T00:00:01
- * @param offset
- * @param limit
- * @param s3FilePath pim/2021-05-27/all-products/all-products-ARCHITECTURAL-20200101T00:00:01.json
- * @returns
- */
-export const setProductsRelationships = async (
-  catalog: AvailableCatalogs,
-  lastModified: string,
-  fieldKey: AvailableRelationFieldKeys | null,
-  offset: number = 0,
-  limit: number = 150,
-  s3FilePath: string = ""
-) => {
-  const timeStart = new Date();
-  log(
-    `setProductsRelationships - catalog: ${catalog} lastModified: ${lastModified} fieldKey: ${fieldKey} offset: ${offset} limit: ${limit} s3FilePath: ${s3FilePath}`,
-    "INFO"
-  );
-
-  if (!s3FilePath) {
-    const s3Path: string = await saveAllProductsToS3(catalog, lastModified);
-
-    const tEnd = new Date();
-    const secs = secondBetweenTwoDate(timeStart, tEnd);
-    log(`Request time: ${secs} seconds`);
-
-    return {
-      offset: Number(offset),
-      limit: Number(limit),
-      completed: false,
-      s3FilePath: s3Path,
-    };
-  }
-
-  const JSONData: AllProductsEntry[] = await getFileFromS3(s3FilePath);
-  const total: number = JSONData.length;
-
-  log(`${total} products founded`);
-
-  let count: number = 0;
-  let updated: number = 0;
-  let current: number = 0;
-  for (const product of JSONData) {
-    if (offset <= count || limit === -1) {
-      log(`${count + 1} of ${JSONData.length}`);
-      await setProductRelationships(product.code, fieldKey);
-      updated++;
-
-      if (serverUtils) {
-        serverUtils.log(product.code);
-        const currentTotal =
-          JSONData.length > limit && limit !== -1 ? limit : JSONData.length;
-        const progress = Math.floor((++current / currentTotal) * 100);
-        serverUtils.updateProgress(progress);
-      }
-
-      if (updated % 7 === 0) {
-        await sleep(500);
-      }
-
-      if (limit !== -1 && count + 1 - offset >= limit) {
-        break;
-      }
-    }
-    count++;
-  }
-
-  const timeEnd = new Date();
-  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
-  log(`Request time: ${seconds} seconds`);
-
-  if (serverUtils) {
-    serverUtils.updateProgress(100);
-  }
-
-  return {
-    offset: Number(offset) + Number(limit),
-    limit: Number(limit),
-    completed: limit === -1 || limit > updated,
-    s3FilePath,
-    total: JSONData.length,
-  };
-};
-
-const removeProductFromAllOfRelationFields = async (
-  productCode: string,
-  fieldKey: string,
-  codes: string[]
-) => {
-  const fieldKeysOf = {
-    accessories: "accessoryOf",
-    spareparts: "sparepartOf",
-    bulb: "bulbOf",
-  };
-  const fieldKeyOf =
-    fieldKey in fieldKeysOf
-      ? fieldKeysOf[fieldKey as keyof typeof fieldKeysOf]
-      : "";
-
-  if (!fieldKeyOf) {
-    log(`The fieldKey ${fieldKey} is not valid`, "WARN");
-    return;
-  }
-  const productEntries = await getAllEntriesByCodes(
-    codes,
-    "topicProduct",
-    "sys,fields",
-    "fields.code"
-  );
-
-  log(
-    `Remove ${fieldKeyOf} relation from ${productEntries.length} topicProduct`
-  );
-  for (let productEntry of productEntries) {
-    if (productEntry.isArchived()) {
-      log(
-        `Can't remove the ${fieldKeyOf} from ${productEntry.sys.id} because it is archived.`,
-        "WARN"
-      );
-    } else {
-      log(
-        `Removing ${productCode} from the ${fieldKeyOf} of the product ${productEntry.sys.id}...`
-      );
-      productEntry.fields = await removeFromFieldObject(
-        productEntry,
-        fieldKeyOf,
-        productCode
-      );
-      try {
-        log(`update ${productEntry.sys.id}`);
-        productEntry = await productEntry.update();
-        if (productEntry.isPublished()) {
-          try {
-            productEntry = await productEntry.publish();
-          } catch (err: any) {
-            log(`Cannot publish entry ${productEntry.sys.id}.`);
-            log(err);
-          }
-        }
-      } catch (err: any) {
-        log(`Cannot update entry ${productEntry.sys.id}.`);
-        log(err);
-      }
-    }
-  }
-};
-
-/**
- * Get all product entries of a specific catalog
- *
- * @param catalog
- * @returns
- */
-export const getAllProductEntriesByCatalog = async (
-  catalog: AvailableCatalogs,
-  limit: number = 100,
-  select: string = ""
-): Promise<Entry[]> => {
-  log(`getAllProductEntriesByCatalog - catalog: ${catalog}`, "INFO");
-  const env = await getEnvironment();
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-  let allItems: Entry[] = [];
-  let othersPagesToFetch = false;
-  let skip = 0;
-  let count = 0;
-  do {
-    const { items, total } = await env.getEntries({
-      content_type: "topicProduct",
-      "fields.catalogs.sys.id": catalog,
-      limit,
-      skip,
-      locale: defEnvLocaleCode,
-      include: 0,
-      select,
-    });
-
-    allItems = [...allItems, ...(items || [])];
-
-    log(`${allItems.length} topicProduct founded of ${total}`);
-
-    if (total && allItems.length < total) {
-      othersPagesToFetch = true;
-      skip += limit;
-      if (++count % 7 === 0) {
-        await sleep(200);
-      }
-    } else {
-      othersPagesToFetch = false;
-    }
-  } while (othersPagesToFetch);
-
-  log(`${allItems.length} topicProduct founded`);
-
-  return allItems;
-};
-
-const productAudit = async (
-  audit: Audit,
-  productEntries: Entry[],
-  catalog: AvailableCatalogs,
-  defaultEnvironmentLocaleCode: string,
-  current: number,
-  allAudit: Audit[],
-  productPageEntries: Entry[]
-) => {
-  log(`Search product entry with id ${audit.product}...`);
-  let productEntry = productEntries.find(
-    (currentEntry) =>
-      currentEntry?.fields?.code?.[defaultEnvironmentLocaleCode] ===
-      audit.product
-  );
-
-  if (!productEntry) {
-    let logMessage = "";
-    if (catalog) {
-      logMessage = `The ${audit.product} product was not found in the CMS with catalog ${catalog}`;
-    } else {
-      logMessage = `The ${audit.product} product was not found in the CMS`;
-    }
-    log(logMessage, "WARN");
-
-    if (serverUtils) {
-      serverUtils.log(logMessage);
-      const progress = Math.floor((++current / allAudit.length) * 100);
-      serverUtils.updateProgress(progress);
-    }
-    return { current, continue: true };
-  }
-
-  log(`Founded product with id ${productEntry.sys.id}`);
-
-  const pageEntryFromId = getProductPageIdByCode(audit.product);
-  log(`Search product page entry with id ${pageEntryFromId}...`);
-  let pageEntryFrom = productPageEntries.find(
-    (currentEntry) => currentEntry.sys.id === pageEntryFromId
-  );
-
-  if (pageEntryFrom) {
-    log(`Founded product page with id ${pageEntryFrom.sys.id}`);
-  } else {
-    log(`Product page with id ${pageEntryFromId} not found`, "WARN");
-  }
-
-  log(`Get product catalogs...`);
-  const productCatalogs: AvailableCatalogs[] = productEntry?.fields?.catalogs?.[
-    defaultEnvironmentLocaleCode
-  ].map((entryCatalog: FieldItem) => {
-    return entryCatalog.sys.id;
-  });
-
-  if (catalog && !productCatalogs.includes(catalog)) {
-    log(`Product ${audit.product} does not belong to the ${catalog} catalog`);
-  } else if (["PRODUCT_UNPUBLISH", "PRODUCT_WEBOFF"].includes(audit.what)) {
-    log(`Set the product status as archive...`);
-    // Set the product status as archive
-    productEntry = await archiveEntry(productEntry, true);
-    if (!pageEntryFrom) {
-      log(`${pageEntryFromId} page from not found`);
-    } else if (pageEntryFrom.isArchived()) {
-      log(
-        `Can't create redirect ${audit.product} to ${audit.upgradeProduct} because the page ${pageEntryFrom.sys.id} is archived.`,
-        "WARN"
-      );
-    } else if (pageEntryFrom?.fields) {
-      if (audit.upgradeProduct && audit.upgradeProduct !== "0") {
-        log(
-          `Creating redirect from ${audit.product} to ${audit.upgradeProduct}`
-        );
-        const pageEntryToId = getProductPageIdByCode(audit.upgradeProduct);
-        const pageEntryTo = await getEntryByID(pageEntryToId, "page", "sys.id");
-
-        if (pageEntryTo) {
-          // Save redirect
-          pageEntryFrom.fields = await addToRelationFields(
-            pageEntryFrom,
-            "redirectTo",
-            pageEntryTo.sys.id
-          );
-          pageEntryFrom = await pageEntryFrom.update();
-        } else {
-          log(
-            `Can't create redirect ${audit.product} to ${audit.upgradeProduct} because the page ${pageEntryToId} not found.`,
-            "WARN"
-          );
-        }
-      }
-
-      pageEntryFrom = await archiveEntry(pageEntryFrom);
-    }
-  } else if (
-    audit.what === "REMOVE_PRODUCT_RELATIONS" &&
-    !productEntry.isArchived()
-  ) {
-    log(`Remove product relations...`);
-    if (productEntry.isUpdated()) {
-      try {
-        log(`Publish existing changes of entry ${productEntry.sys.id}.`);
-        productEntry = await productEntry.publish();
-      } catch (err: any) {
-        log(`Cannot publish changes of entry ${productEntry.sys.id}.`);
-        log(err);
-      }
-    }
-    if (audit?.catalogs) {
-      for (const item of audit?.catalogs) {
-        if (!item?.where) {
-          log(
-            `catalogs.where field not exists. Product: ${audit.product} `,
-            "WARN"
-          );
-        } else {
-          let edit = false;
-          if (item?.catalogCode) {
-            productEntry.fields = await removeFromRelationFields(
-              productEntry,
-              "catalogs",
-              item.catalogCode,
-              true
-            );
-            log(`edit catalogs`);
-            edit = true;
-          }
-          if (item?.categoryCode) {
-            const categoriesFieldKey =
-              "categories" + capitalizeFirstLetter(item.where);
-            productEntry.fields = await removeFromRelationFields(
-              productEntry,
-              categoriesFieldKey,
-              item.categoryCode,
-              true
-            );
-            log(`edit ${categoriesFieldKey}`);
-            edit = true;
-          }
-          if (item?.subfamilyCode) {
-            const subFamiliesFieldKey =
-              "subFamilies" + capitalizeFirstLetter(item.where);
-            productEntry.fields = await removeFromRelationFields(
-              productEntry,
-              subFamiliesFieldKey,
-              item.subfamilyCode,
-              true
-            );
-            log(`edit ${subFamiliesFieldKey}`);
-            edit = true;
-          }
-          if (item?.models) {
-            const modelsFieldKey = "models" + capitalizeFirstLetter(item.where);
-            productEntry.fields = await removeFromRelationFields(
-              productEntry,
-              modelsFieldKey,
-              item.models,
-              true
-            );
-            log(`edit ${modelsFieldKey}`);
-            edit = true;
-          }
-          if (item?.subModels) {
-            const subModelsFieldKey =
-              "subModels" + capitalizeFirstLetter(item.where);
-            productEntry.fields = await removeFromRelationFields(
-              productEntry,
-              subModelsFieldKey,
-              item.subModels,
-              true
-            );
-            log(`edit ${subModelsFieldKey}`);
-            edit = true;
-          }
-
-          const objectFieldsRelations: any = {
-            ACCESSORIES: "accessories",
-            SPARE_PARTS: "spareparts",
-            BULBS: "bulbs",
-          };
-
-          for (const objectFieldsRelationKey of Object.keys(
-            objectFieldsRelations
-          )) {
-            if (item.where === objectFieldsRelationKey) {
-              log(`Remove ${objectFieldsRelationKey} relations`);
-              const codes = item.codes?.split(",") ?? [];
-              if (codes.length) {
-                const fieldKey = objectFieldsRelations[objectFieldsRelationKey];
-                const lengthBefore =
-                  productEntry.fields?.[fieldKey]?.[
-                    defaultEnvironmentLocaleCode
-                  ].length;
-
-                // Remove from the main product field
-                productEntry.fields = await removeFromFieldObject(
-                  productEntry,
-                  fieldKey,
-                  codes
-                );
-                // Remove from the codes of field
-                await removeProductFromAllOfRelationFields(
-                  productEntry.sys.id,
-                  fieldKey,
-                  codes
-                );
-
-                const lengthAfter =
-                  productEntry.fields?.[fieldKey]?.[
-                    defaultEnvironmentLocaleCode
-                  ].length;
-                if (lengthBefore !== lengthAfter) {
-                  log(
-                    `edit field ${fieldKey} lengthBefore: ${lengthBefore} lengthAfter: ${lengthAfter}`
-                  );
-                  edit = true;
-                } else {
-                  log(`No valid ${objectFieldsRelationKey} to remove found`);
-                }
-              }
-            }
-          }
-
-          if (item.where === "DESIGNERS" && item?.codes) {
-            const lengthBefore =
-              productEntry.fields?.designer?.[defaultEnvironmentLocaleCode]
-                .length;
-            const designers = item.codes.split(",");
-            for (const designer of designers) {
-              log(
-                `Remove ${designer} designer to ${productEntry.sys.id} product if exists`
-              );
-              productEntry.fields = await removeFromRelationFields(
-                productEntry,
-                "designer",
-                designer,
-                false
-              );
-            }
-
-            if (
-              lengthBefore !==
-              productEntry.fields?.designer?.[defaultEnvironmentLocaleCode]
-                .length
-            ) {
-              log(`edit designer`);
-              edit = true;
-            } else {
-              log(`No valid designer to remove found`);
-            }
-          }
-
-          if (edit) {
-            // lastPimSyncDate
-            productEntry.fields = await addFieldValue(
-              productEntry,
-              "lastPimSyncDate",
-              getLocalISOTime()
-            );
-            try {
-              log(`update ${productEntry.sys.id}`);
-              productEntry = await productEntry.update();
-              if (productEntry.isPublished()) {
-                try {
-                  productEntry = await productEntry.publish();
-                } catch (err: any) {
-                  log(`Cannot publish entry ${productEntry.sys.id}.`);
-                  log(err);
-                }
-              }
-            } catch (err: any) {
-              log(`Cannot update entry ${productEntry.sys.id}.`);
-              log(err);
-            }
-          } else {
-            log(`No valid editable criteria found`);
-            console.log(productEntry.sys.id, "audit", audit);
-          }
-        }
-      }
-    } else {
-      log(
-        `No catalogs field found in the audit ${audit.product} product`,
-        "WARN"
-      );
-    }
-  } else {
-    log(`It has not yet been defined how to process the state ${audit.what}`);
-  }
-
-  return { current, continue: false };
-};
-
-const familyAudit = async (
-  audit: Audit,
-  familyEntries: Entry[],
-  catalog: AvailableCatalogs,
-  defaultEnvironmentLocaleCode: string,
-  current: number,
-  allAudit: Audit[]
-) => {
-  log(`Search family entry with id ${audit.product}...`);
-  let familyEntry = familyEntries.find(
-    (currentEntry) =>
-      currentEntry?.fields?.code?.[defaultEnvironmentLocaleCode] ===
-      audit.product
-  );
-
-  if (!familyEntry) {
-    let logMessage = "";
-    if (catalog) {
-      logMessage = `The ${audit.product} family was not found in the CMS with catalog ${catalog}`;
-    } else {
-      logMessage = `The ${audit.product} family was not found in the CMS`;
-    }
-    log(logMessage, "WARN");
-
-    if (serverUtils) {
-      serverUtils.log(logMessage);
-      const progress = Math.floor((++current / allAudit.length) * 100);
-      serverUtils.updateProgress(progress);
-    }
-    return { current, continue: true };
-  }
-
-  log(`Founded family with id ${familyEntry.sys.id}`);
-
-  log(`Get family catalogs...`);
-  const familyCatalogs: AvailableCatalogs[] = familyEntry?.fields?.catalogs?.[
-    defaultEnvironmentLocaleCode
-  ].map((entryCatalog: FieldItem) => {
-    return entryCatalog.sys.id;
-  });
-
-  if (catalog && !familyCatalogs.includes(catalog)) {
-    log(`Family ${audit.product} does not belong to the ${catalog} catalog`);
-  } else if (audit.what === "REMOVE_FAMILY_RELATIONS") {
-    for (const item of audit?.catalogs) {
-      if (!item?.where) {
-        log(
-          `catalogs.where field not exists. Family: ${audit.product} `,
-          "WARN"
-        );
-      } else {
-        if (item.where === "DESIGNERS" && item?.codes) {
-          const designers = item.codes.split(",");
-          for (const designer of designers) {
-            log(
-              `Remove ${designer} designer to ${familyEntry.sys.id} family if exists`
-            );
-            familyEntry.fields = await removeFromRelationFields(
-              familyEntry,
-              "designer",
-              designer,
-              false
-            );
-          }
-          familyEntry = await familyEntry.update();
-        }
-      }
-    }
-  } else {
-    log(`It has not yet been defined how to process the state ${audit.what}`);
-  }
-
-  return { current, continue: false };
-};
-
-const subFamilyAudit = async (
-  audit: Audit,
-  subfamilyEntries: Entry[],
-  catalog: AvailableCatalogs,
-  defaultEnvironmentLocaleCode: string,
-  current: number,
-  allAudit: Audit[]
-) => {
-  log(`Search subFamily entry with id ${audit.product}...`);
-  let subFamilyEntry = subfamilyEntries.find(
-    (currentEntry) =>
-      currentEntry?.fields?.code?.[defaultEnvironmentLocaleCode] ===
-      audit.product
-  );
-
-  if (!subFamilyEntry) {
-    let logMessage = "";
-    if (catalog) {
-      logMessage = `The ${audit.product} subFamily was not found in the CMS with catalog ${catalog}`;
-    } else {
-      logMessage = `The ${audit.product} subFamily was not found in the CMS`;
-    }
-    log(logMessage, "WARN");
-
-    if (serverUtils) {
-      serverUtils.log(logMessage);
-      const progress = Math.floor((++current / allAudit.length) * 100);
-      serverUtils.updateProgress(progress);
-    }
-    return { current, continue: true };
-  }
-
-  log(`Founded subFamily with id ${subFamilyEntry.sys.id}`);
-
-  log(`Get subFamily catalogs...`);
-  const subFamilyCatalog: AvailableCatalogs =
-    subFamilyEntry?.fields?.catalog?.[defaultEnvironmentLocaleCode].sys.id;
-
-  if (catalog && subFamilyCatalog !== catalog) {
-    log(`SubFamily ${audit.product} does not belong to the ${catalog} catalog`);
-  } else if (audit.what === "REMOVE_SUBFAMILY_RELATIONS") {
-    for (const item of audit?.catalogs) {
-      if (!item?.where) {
-        log(
-          `catalogs.where field not exists. SubFamily: ${audit.product} `,
-          "WARN"
-        );
-      } else {
-        if (item.where === "DESIGNERS" && item?.codes) {
-          const designers = item.codes.split(",");
-          for (const designer of designers) {
-            log(
-              `Remove ${designer} designer to ${subFamilyEntry.sys.id} subFamily if exists`
-            );
-            subFamilyEntry.fields = await removeFromRelationFields(
-              subFamilyEntry,
-              "designer",
-              designer,
-              false
-            );
-          }
-          subFamilyEntry = await subFamilyEntry.update();
-        }
-      }
-    }
-  } else {
-    log(`It has not yet been defined how to process the state ${audit.what}`);
-  }
-
-  return { current, continue: false };
-};
-
-/**
- *
- * Audit - Checks if there are products to publish or unpublish
- *
- * @param {string} lastModified The last modified data. Format: 20200426T07:50:00 - yearmonthdayThour:minute:second
- * @param {string} catalog
- */
-export const audit = async (
-  lastModified: string,
-  catalog: AvailableCatalogs,
-  offset: number = 0,
-  limit: number = 150,
-  s3FilePath: string = ""
-) => {
-  offset = Number(offset);
-  limit = Number(limit);
-  const timeStart = new Date();
-  log(`audit - lastModified: ${lastModified} catalog: ${catalog}`, "INFO");
-
-  // if not exists save data to s3
-  if (!s3FilePath) {
-    const allAudit = await getAudit(lastModified);
-    if (!allAudit) {
-      log(`No audits were found to process for the date ${lastModified}`);
-      return {
-        offset,
-        limit,
-        completed: true,
-        s3FilePath: "",
-        total: 0,
-        processedEntries: 0,
-      };
-    }
-
-    const filename = `${lastModified}-all-audit.json`;
-    const path = `audit`;
-    await saveJsonToS3(allAudit, filename, path);
-    const s3Path = `${path}/${filename}`;
-
-    if (serverUtils) {
-      serverUtils.log(`Saved s3FilePath: ${s3Path}`);
-      serverUtils.updateProgress(100);
-    }
-
-    return {
-      offset: Number(offset),
-      limit: Number(limit),
-      completed: false,
-      s3FilePath: s3Path,
-      total: allAudit.length,
-      processedEntries: 0,
-    };
-  }
-
-  // get data from s3
-  log(`Get audit details from ${s3FilePath}`);
-  let allAudit: Audit[] = await getFileFromS3(s3FilePath);
-  const total: number = allAudit.length;
-  allAudit = allAudit.slice(offset, offset + limit);
-  log(`Founded ${allAudit.length} items`);
-
-  if (allAudit) {
-    const defaultEnvironmentLocaleCode =
-      await getEnvironmentDefaultLocaleCode();
-
-    const productAuditWhat = [
-      "PRODUCT_UNPUBLISH",
-      "PRODUCT_WEBOFF",
-      "REMOVE_PRODUCT_RELATIONS",
-    ];
-    const productCodes = allAudit
-      .filter((item) => productAuditWhat.includes(item.what))
-      .map((audit) => audit.product);
-    const familyCodes = allAudit
-      .filter((item) => item.what === "REMOVE_FAMILY_RELATIONS")
-      .map((audit) => audit.product);
-    const subFamilyCodes = allAudit
-      .filter((item) => item.what === "REMOVE_SUBFAMILY_RELATIONS")
-      .map((audit) => audit.product);
-    const otherFilters = [];
-    if (catalog) {
-      otherFilters.push({ key: "fields.catalogs.sys.id[in]", value: catalog });
-    }
-    log(`Get ${productCodes.length} product entry from Contentful`);
-    const productEntries = await getAllEntriesByCodes(
-      productCodes,
-      "topicProduct",
-      "sys,fields",
-      "fields.code",
-      otherFilters
-    );
-    log(`Founded ${productEntries.length} topicProduct`);
-
-    let familyEntries: Entry[] = [];
-    if (familyCodes.length) {
-      familyEntries = await getAllEntriesByCodes(
-        familyCodes,
-        "topicFamily",
-        "sys,fields",
-        "fields.code",
-        otherFilters
-      );
-    }
-    log(`Founded ${familyEntries.length} topicFamily`);
-
-    let subFamilyEntries: Entry[] = [];
-    if (subFamilyCodes.length) {
-      subFamilyEntries = await getAllEntriesByCodes(
-        subFamilyCodes,
-        "topicSubFamily",
-        "sys,fields",
-        "fields.code",
-        otherFilters
-      );
-    }
-    log(`Founded ${subFamilyEntries.length} topicSubFamily`);
-
-    if (
-      !productEntries.length &&
-      !familyEntries.length &&
-      !subFamilyEntries.length
-    ) {
-      log(
-        `No items found between offset: ${offset} and limit: ${limit}. Total: ${total}`
-      );
-      const nextOffset = offset + limit;
-      const completed = limit === -1 || offset >= total;
-      if (completed) {
-        log(`Audit completed`);
-      }
-
-      const tEnd = new Date();
-      const secs = secondBetweenTwoDate(timeStart, tEnd);
-      log(`Execution time: ${secs} seconds`);
-
-      if (serverUtils) {
-        serverUtils.log(`Audit completed`);
-        serverUtils.updateProgress(100);
-      }
-
-      return {
-        offset: nextOffset,
-        limit: limit,
-        completed,
-        s3FilePath,
-        total,
-        processedEntries: 0,
-      };
-    }
-
-    const pageCodes = productEntries.map((entry: Entry) =>
-      getProductPageIdByCode(entry.fields.code[defaultEnvironmentLocaleCode])
-    );
-
-    log(`Get ${pageCodes.length} product page entry from Contentful`);
-    const productPageEntries = await getAllEntriesByCodes(
-      pageCodes,
-      "page",
-      "sys,fields",
-      "sys.id"
-    );
-    log(`Founded ${productPageEntries.length} topicProduct pages`);
-
-    let count: number = offset;
-    let current: number = 0;
-    for (const audit of allAudit) {
-      log(`${++count} of ${total}`);
-      log(`I process the item ${audit.product} with status ${audit.what}`);
-
-      if (productAuditWhat.includes(audit.what)) {
-        const result = await productAudit(
-          audit,
-          productEntries,
-          catalog,
-          defaultEnvironmentLocaleCode,
-          current,
-          allAudit,
-          productPageEntries
-        );
-        current = result.current;
-        if (result.continue) {
-          continue;
-        }
-      } else if (audit.what === "REMOVE_FAMILY_RELATIONS") {
-        const result = await familyAudit(
-          audit,
-          familyEntries,
-          catalog,
-          defaultEnvironmentLocaleCode,
-          current,
-          allAudit
-        );
-        current = result.current;
-        if (result.continue) {
-          continue;
-        }
-      } else if (audit.what === "REMOVE_SUBFAMILY_RELATIONS") {
-        const result = await subFamilyAudit(
-          audit,
-          subFamilyEntries,
-          catalog,
-          defaultEnvironmentLocaleCode,
-          current,
-          allAudit
-        );
-        current = result.current;
-        if (result.continue) {
-          continue;
-        }
-      }
-
-      if (serverUtils) {
-        serverUtils.log(audit.product);
-        const progress = Math.floor((++current / allAudit.length) * 100);
-        serverUtils.updateProgress(progress);
-      }
-    }
-
-    const nextOffset = offset + limit;
-    const tEnd = new Date();
-    const secs = secondBetweenTwoDate(timeStart, tEnd);
-    log(`Execution time: ${secs} seconds`);
-
-    return {
-      offset: nextOffset,
-      limit,
-      completed: limit === -1 || count >= total,
-      s3FilePath,
-      total,
-      processedEntries:
-        productEntries.length + familyEntries.length + subFamilyEntries.length,
-    };
-  } else {
-    log(`Execution completed`);
-    if (serverUtils) {
-      serverUtils.log(`Execution completed`);
-      serverUtils.updateProgress(100);
-    }
-  }
-  const tEnd = new Date();
-  const secs = secondBetweenTwoDate(timeStart, tEnd);
-  log(`Request time: ${secs} seconds`);
-
-  return {
-    offset: offset,
-    limit: limit,
-    completed: true,
-    s3FilePath,
-    processedEntries: 0,
-  };
-};
-
-export const importProductByCode = async (
-  code: string,
-  catalog: AvailableCatalogs
-) => {
-  const timeStart = new Date();
-  log(`importProductByCode - code: ${code} catalog: ${catalog}`, "INFO");
-  const productDetails = await getProductDetails(code);
-
-  if (productDetails) {
-    await importProduct(productDetails, catalog);
-  }
-
-  const tEnd = new Date();
-  const secs = secondBetweenTwoDate(timeStart, tEnd);
-  log(`Request time: ${secs} seconds`);
-};
-
-/**
- * Generate Tech Spec PDF by topicProducId
- *
- * @param topicProductId
- * @returns
- */
-export const generateTechSpecPdf = async (
-  topicProductId: string,
-  country: string = "global",
-  locale: string = "en"
-) => {
-  log(`generateTechSpecPdf - topicProductId: ${topicProductId}`);
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-  let topicProduct = await getEntryByID(
-    topicProductId,
-    "topicProduct",
-    "",
-    locale
-  );
-  if (!topicProduct) {
-    throw new Error(`topicProduct with id ${topicProductId} not found`);
-  } else if (topicProduct.isArchived()) {
-    throw new Error(`topicProduct with id ${topicProductId} is archived`);
-  }
-  if (serverUtils) {
-    serverUtils.updateProgress(10);
-  }
-
-  const topicProductPageId = getProductPageIdByCode(topicProduct.sys.id);
-  const topicProductPage = await getEntryByID(
-    topicProductPageId,
-    "page",
-    "",
-    locale
-  );
-  if (!topicProductPage) {
-    throw new Error(`topicProductPage with id ${topicProductPageId} not found`);
-  } else if (topicProductPage.isArchived()) {
-    throw new Error(
-      `topicProductPage with id ${topicProductPageId} is archived`
-    );
-  }
-
-  if (serverUtils) {
-    serverUtils.updateProgress(20);
-  }
-
-  const topicCatalogIds = topicProduct?.fields?.catalogs?.[
-    defaultEnvironmentLocaleCode
-  ]?.map((catalog: any) => catalog.sys.id);
-  const pageSlug =
-    topicProductPage?.fields?.slug?.[locale] ??
-    topicProductPage?.fields?.slug?.[defaultEnvironmentLocaleCode];
-  const version = topicProduct?.sys?.version;
-  const fileName =
-    (pageSlug.length >= 170
-      ? `tech-spec-${topicProductId}`
-      : `tech-spec-${pageSlug}`) + `_${country}-${locale}`; // 57 caratteri è il resto dell'url di S3
-  let baseUrl = process.env.FPI_TECH_SPEC_BASE_URL ?? "";
-  if (!baseUrl) {
-    log(`FPI_TECH_SPEC_BASE_URL process env not found`, "ERROR");
-  }
-  baseUrl = baseUrl.replace(/\/?(\?|#|$)/, "/$1");
-  let footerBaseUrl =
-    process.env.FPI_TECH_SPEC_FOOTER_BASE_URL ??
-    process.env.FPI_TECH_SPEC_BASE_URL ??
-    "";
-  if (!footerBaseUrl) {
-    log(`FPI_TECH_SPEC_FOOTER_BASE_URL process env not found`, "ERROR");
-  }
-  footerBaseUrl = footerBaseUrl.replace(/\/?(\?|#|$)/, "/$1");
-
-  const layoutUrl = `${baseUrl}${locale}/${country}/tech-spec/${pageSlug}/v-${version}/`;
-  const pdpSiteUrl =
-    `${footerBaseUrl}${locale}/${country}/product/${pageSlug}`.replace(
-      /\/?(\?|#|$)/,
-      "/$1"
-    );
-  log(`pdpSiteUrl: ${pdpSiteUrl}`);
-  const contents = {
-    // header: {
-    //   right: "Technical Specifications",
-    // },
-    footer: {
-      topLeft: `<a style="text-decoration: none; color:#000" href="${pdpSiteUrl}">${pdpSiteUrl}</a>`,
-      topRight: topicProductId,
-      bottomLeft: ``,
-      bottomRight: ``,
-      mail: topicCatalogIds.includes("OUTDOOR")
-        ? "flos.outdoor@flos.com"
-        : "info@flos.com",
-    },
-  };
-
-  if (serverUtils) {
-    serverUtils.updateProgress(35);
-  }
-
-  const s3Url = await generatePDFByUrl(layoutUrl, fileName, contents);
-  if (s3Url) {
-    if (serverUtils) {
-      serverUtils.log("PDF saved to S3!");
-      serverUtils.log(`Update techSpec field...`);
-      serverUtils.updateProgress(75);
-    }
-
-    log(`Update techSpec field...`);
-    topicProduct.fields = await addFieldValue(
-      topicProduct,
-      "techSpec",
-      s3Url,
-      false,
-      locale
-    );
-
-    topicProduct = await topicProduct.update();
-    if (topicProduct.isPublished()) {
-      try {
-        topicProduct = await topicProduct.publish();
-      } catch (err: any) {
-        log(`Cannot publish entry.`);
-        log(err);
-      }
-    }
-
-    if (serverUtils) {
-      serverUtils.log("Updated!");
-      serverUtils.updateProgress(100);
-    }
-
-    log(`${topicProductId} techSpec field updated!`);
-    return s3Url;
-  } else {
-    throw new Error(
-      `TechSpec PDF generation failed for product: ${topicProductId}!`
-    );
-  }
-};
-
-const getLightModuleAutoDescriptionByProductFields = async (
-  productFileds: any
-) => {
-  const autoDescription: any = {};
-  const dictionaryJson = await getDictionaryJson();
-  for (const locale of cfLocales) {
-    if (!autoDescription?.[locale]) {
-      autoDescription[locale] = "";
-    }
-    let addSeparator = false;
-    if (productFileds?.electrical?.lampCategories) {
-      const lampCategoriesLocalizedValues = [];
-      for (const lampCategory of productFileds.electrical.lampCategories) {
-        const lampCategoryLocalizedValue = await getDictionaryLocaleValue(
-          locale,
-          "lampCategories",
-          lampCategory.code,
-          "electrical",
-          dictionaryJson
-        );
-        if (lampCategoryLocalizedValue) {
-          lampCategoriesLocalizedValues.push(lampCategoryLocalizedValue);
-        }
-      }
-
-      if (lampCategoriesLocalizedValues.length) {
-        if (addSeparator) {
-          autoDescription[locale] += " - ";
-        } else {
-          addSeparator = true;
-        }
-        autoDescription[locale] += lampCategoriesLocalizedValues.join(", ");
-        if (
-          productFileds.electrical.lampCategories.find(
-            (item: any) => item.code === "LAMPCAT4"
-          ) &&
-          productFileds?.photometric?.ledTypes?.length
-        ) {
-          const ledTypeLocalizedValues = [];
-          for (const ledType of productFileds?.photometric?.ledTypes) {
-            const ledTypeLocalizedValue = await getDictionaryLocaleValue(
-              locale,
-              "ledTypes",
-              ledType.code,
-              "photometric",
-              dictionaryJson
-            );
-            if (ledTypeLocalizedValue) {
-              ledTypeLocalizedValues.push(ledTypeLocalizedValue);
-            }
-          }
-
-          if (ledTypeLocalizedValues.length) {
-            if (addSeparator) {
-              autoDescription[locale] += " - ";
-            } else {
-              addSeparator = true;
-            }
-            autoDescription[locale] += ledTypeLocalizedValues.join(", ");
-          }
-        }
-      }
-    }
-
-    if (productFileds?.electrical?.wPower) {
-      if (addSeparator) {
-        autoDescription[locale] += " - ";
-      } else {
-        addSeparator = true;
-      }
-      if (productFileds?.optical?.numberOfHeads >= 2) {
-        autoDescription[locale] += `${productFileds.optical.numberOfHeads} x `;
-      }
-      autoDescription[locale] += `${productFileds.electrical.wPower}W`;
-    }
-    if (productFileds?.photometric?.realNetFlow) {
-      if (addSeparator) {
-        autoDescription[locale] += " - ";
-      } else {
-        addSeparator = true;
-      }
-      if (productFileds?.optical?.numberOfHeads >= 2) {
-        autoDescription[locale] += `${productFileds.optical.numberOfHeads} x `;
-      }
-      autoDescription[locale] += `${productFileds.photometric.realNetFlow}lm`;
-    }
-
-    if (productFileds?.photometric?.temperatureColor?.code) {
-      const temperatireColorLocalizedValue = await getDictionaryLocaleValue(
-        locale,
-        "temperatureColor",
-        productFileds.photometric.temperatureColor.code,
-        "photometric",
-        dictionaryJson
-      );
-      if (temperatireColorLocalizedValue) {
-        if (addSeparator) {
-          autoDescription[locale] += " - ";
-        } else {
-          addSeparator = true;
-        }
-        autoDescription[locale] += temperatireColorLocalizedValue + "K";
-      }
-    }
-
-    if (productFileds?.photometric?.cri?.code) {
-      const CriLocalizedValue = await getDictionaryLocaleValue(
-        locale,
-        "cri",
-        productFileds.photometric.cri.code,
-        "photometric",
-        dictionaryJson
-      );
-      if (CriLocalizedValue) {
-        if (addSeparator) {
-          autoDescription[locale] += " - ";
-        } else {
-          addSeparator = true;
-        }
-        autoDescription[locale] += "CRI> " + CriLocalizedValue;
-      }
-    }
-
-    if (productFileds?.photometric?.beam0_180) {
-      if (addSeparator) {
-        autoDescription[locale] += " - ";
-      } else {
-        addSeparator = true;
-      }
-      autoDescription[locale] += "Beam° " + productFileds.photometric.beam0_180;
-    }
-  }
-
-  return autoDescription;
-};
-
-const getOtherAutoDescriptionByProductFields = async (productFileds: any) => {
-  const autoDescription: any = {};
-  const dictionaryJson = await getDictionaryJson();
-  for (const locale of cfLocales) {
-    if (!autoDescription?.[locale]) {
-      autoDescription[locale] = "";
-    }
-    let addSeparator = false;
-    // Profile and others
-    if (productFileds?.physical?.length_us && locale === "en-US") {
-      autoDescription[locale] += "Length: " + productFileds.physical.length_us;
-      addSeparator = true;
-    } else if (productFileds?.physical?.length && locale !== "en-US") {
-      autoDescription[locale] += "Length: " + productFileds.physical.length;
-      addSeparator = true;
-    }
-
-    if (productFileds?.mountings) {
-      const mountingsLocalizedValues = [];
-      for (const mounting of productFileds.mountings) {
-        const mountingLocalizedValue = await getDictionaryLocaleValue(
-          locale,
-          "mountings",
-          mounting.code,
-          "",
-          dictionaryJson
-        );
-        if (mountingLocalizedValue) {
-          mountingsLocalizedValues.push(mountingLocalizedValue);
-        }
-      }
-
-      if (addSeparator) {
-        autoDescription[locale] += " - ";
-      } else {
-        addSeparator = true;
-      }
-      autoDescription[locale] += mountingsLocalizedValues.join(", ");
-    }
-  }
-
-  return autoDescription;
-};
-
-/**
- * Get topicProduct autoDescription
- *
- * @param topicProduct
- * @returns
- */
-const getTopicProductAutodescription = async (
-  topicProductFields: KeyValueMap
-) => {
-  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
-  const productLineCode =
-    topicProductFields?.productLine?.[defaultEnvironmentLocaleCode]?.sys?.id;
-  const productFileds =
-    topicProductFields?.productFields?.[defaultEnvironmentLocaleCode];
-
-  let autoDescription: any = {};
-  switch (productLineCode) {
-    case "PLINE6": // Soft Plate
-    case "PLINE5": // Light Bulb
-    case "PLINE3": // Driver
-    case "PLINE2": // Accessory
-      // post_content
-      autoDescription = topicProductFields?.description;
-      break;
-    case "PLINE1": // Light Module
-      autoDescription = await getLightModuleAutoDescriptionByProductFields(
-        productFileds
-      );
-
-      break;
-    default:
-      autoDescription = await getOtherAutoDescriptionByProductFields(
-        productFileds
-      );
-
-      break;
-  }
-
-  return autoDescription;
-};
-
-const setProductAutodescription = async (topicProduct: Entry) => {
-  log(`Set audtodescription of the topic ${topicProduct.sys.id}`);
-  const autoDescription = await getTopicProductAutodescription(
-    topicProduct.fields
-  );
-  topicProduct.fields.autoDescription = autoDescription;
-  if (!topicProduct.isArchived()) {
-    topicProduct = await topicProduct.update();
-    if (topicProduct.isPublished()) {
-      topicProduct = await topicProduct.publish();
-    }
-  } else {
-    log(
-      `Product ${topicProduct.sys.id} is archived, it is not possible to update the autodescription`,
-      "WARN"
-    );
-  }
-
-  return autoDescription;
-};
-
-export const setProductsAutodescription = async (
-  catalog: AvailableCatalogs,
-  offset: number = 0,
-  limit: number = 100
-) => {
-  log(
-    `setProductAutodescription - catalog: ${catalog}, offset: ${offset}, limit: ${limit}`,
-    "INFO"
-  );
-  const env = await getEnvironment();
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const { items, total } = await env.getEntries({
-    content_type: "topicProduct",
-    "fields.catalogs.sys.id": catalog,
-    limit,
-    skip: offset,
-    locale: defEnvLocaleCode,
-    include: 0,
-    select: "sys,fields",
-    "sys.archivedAt[exists]": false,
-  });
-
-  let count = 0;
-  for (const item of items) {
-    setProductAutodescription(item);
-
-    if (++count % 5 === 0) {
-      log(
-        `current: ${count} of ${limit} - global: ${offset + count} of ${total}`
-      );
-      await sleep(3000, true);
-    }
-  }
-
-  return {
-    catalog,
-    offset: Number(offset) + Number(limit),
-    limit: Number(limit),
-    completed: Number(offset) + Number(limit) >= total,
-    total,
-  };
-};
-
-export const setProductAutodescriptionByTopicId = async (
-  topicProductId: string
-) => {
-  const topicProduct = await getEntryByID(topicProductId, "topicProduct");
-
-  return await setProductAutodescription(topicProduct);
-};
-
-export const getProductAutodescription = async (topicProductId: string) => {
-  const topicProduct = await getEntryByID(topicProductId, "topicProduct");
-
-  return await getTopicProductAutodescription(topicProduct.fields);
-};
-
-export const removeProductFromColorVariantsByProductLine = async (
-  productLineCode: string
-) => {
-  log(`Serch topicProduct with productLine ${productLineCode}`);
-  const topicProducts = await getAllEntries(
-    "topicProduct",
-    "sys",
-    "fields.productLine.sys.id",
-    productLineCode
-  );
-  const topicProductCodes = topicProducts.map(
-    (topicProduct) => topicProduct.sys.id
-  );
-
-  log(`Founded ${topicProductCodes.length} topicProducts`);
-
-  let count = 0;
-  for (const topicProductCode of topicProductCodes) {
-    log(`${++count} of ${topicProductCodes.length}`);
-    log(
-      `Serch topicProductColourVariants of the ${topicProductCode} topicProduct`
-    );
-    const topicProductColourVariants = await getAllEntries(
-      "topicProductColourVariants",
-      "sys,fields",
-      "fields.products.sys.id[in]",
-      topicProductCode
-    );
-
-    if (topicProductColourVariants.length) {
-      const defaultEnvironmentLocaleCode =
-        await getEnvironmentDefaultLocaleCode();
-      log(
-        `${topicProductColourVariants.length} topicProductColourVariants founded`
-      );
-      for (let topicProductColourVariant of topicProductColourVariants) {
-        log(
-          `Remove the ${topicProductCode} topicProduct from the ${topicProductColourVariant.sys.id} topicProductColourVariants`
-        );
-
-        topicProductColourVariant.fields.products[
-          defaultEnvironmentLocaleCode
-        ] = topicProductColourVariant.fields.products[
-          defaultEnvironmentLocaleCode
-        ].filter((item: CfSys) => item.sys.id !== topicProductCode);
-
-        if (
-          topicProductColourVariant.fields.products[
-            defaultEnvironmentLocaleCode
-          ].length
-        ) {
-          log(
-            `Update the ${topicProductColourVariant.sys.id} topicProductColourVariants`
-          );
-          topicProductColourVariant = await topicProductColourVariant.update();
-          if (topicProductColourVariant.isPublished()) {
-            topicProductColourVariant =
-              await topicProductColourVariant.publish();
-          }
-        } else {
-          log(
-            `Remove the ${topicProductColourVariant.sys.id} topicProductColourVariants because don't have more topicProducts`
-          );
-          if (topicProductColourVariant.isPublished()) {
-            topicProductColourVariant =
-              await topicProductColourVariant.unpublish();
-          }
-          await topicProductColourVariant.delete();
-        }
-      }
-    } else {
-      log(
-        `No topicProductColourVariants found for the ${topicProductCode} topicProduct`
-      );
-    }
-  }
-};
-
-/**
- * Remove a specific model from all product model relations
- * NOTE: require the reindex of all product updated
- *
- * @param modelCode
- */
-export const removeAllProductModelProductRelations = async (
-  modelCode: string
-) => {
-  log(`removeAllProductModelProductRelations - modelCode: ${modelCode}`);
-  const env = await getEnvironment();
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-  const { items } = await env.getEntries({
-    content_type: "topicProduct",
-    locale: defEnvLocaleCode,
-    include: 2,
-    links_to_entry: modelCode,
-    limit: 1000,
-  });
-
-  log(`Founded ${items.length} products`);
-
-  const allProductModelFields = [
-    "modelsArchitectural",
-    "modelsOutdoor",
-    "modelsDecorative",
-  ];
-  for (let item of items) {
-    for (const modelFieldKey of allProductModelFields) {
-      if (
-        item.fields?.[modelFieldKey]?.[defEnvLocaleCode].find(
-          (model: CfSys) => model.sys.id === modelCode
-        )
-      ) {
-        item.fields[modelFieldKey][defEnvLocaleCode] = item.fields[
-          modelFieldKey
-        ][defEnvLocaleCode].filter(
-          (model: CfSys) => model.sys.id !== modelCode
-        );
-      }
-    }
-
-    const productCode = item.fields.code[defEnvLocaleCode];
-    if (item.isArchived()) {
-      log(`Product with code ${productCode} is archived`, "WARN");
-    } else {
-      item = await item.update();
-      log(`Updated product ${productCode}`);
-      // log(`"${productCode}",`);
-    }
-    if (item.isPublished()) {
-      item = await item.publish();
-    }
-  }
-};
-
-/**
- *
- * Reimport audit products
- *
- * @param {string} lastModified The last modified data. Format: 20200426T07:50:00 - yearmonthdayThour:minute:second
- * @param {string} catalog
- */
-export const reimportAuditProducts = async (
-  lastModified: string,
-  catalog: AvailableCatalogs,
-  offset: number = 0,
-  limit: number = 150,
-  s3FilePath: string = ""
-) => {
-  // if not exists save data to s3
-  if (!s3FilePath) {
-    const allAudit = await getAudit(lastModified);
-    const allFilteredAudit = allAudit.filter((audit) =>
-      ["PRODUCT_WEBOFF", "PRODUCT_UNPUBLISH"].includes(audit.what)
-    );
-    if (!allFilteredAudit) {
-      log(`No audits were found to process for the date ${lastModified}`);
-      return {
-        offset,
-        limit,
-        completed: true,
-        s3FilePath: "",
-        total: 0,
-        processedEntries: 0,
-      };
-    }
-
-    const filename = `${lastModified}-all-audit-web-off.json`;
-    const path = `audit/reimport`;
-    await saveJsonToS3(allFilteredAudit, filename, path);
-    const s3Path = `${path}/${filename}`;
-
-    return {
-      offset: Number(offset),
-      limit: Number(limit),
-      completed: false,
-      s3FilePath: s3Path,
-      total: allAudit.length,
-      processedEntries: 0,
-    };
-  }
-
-  // get data from s3
-  log(`Get audit details from ${s3FilePath}`);
-  let allAudit: Audit[] = await getFileFromS3(s3FilePath);
-  const total: number = allAudit.length;
-  allAudit = allAudit.slice(offset, offset + limit);
-  log(`Founded ${allAudit.length} items`);
-
-  if (allAudit) {
-    const defaultEnvironmentLocaleCode =
-      await getEnvironmentDefaultLocaleCode();
-
-    const productCodes = allAudit.map((audit) => audit.product);
-    const otherFilters = [];
-    if (catalog) {
-      otherFilters.push({ key: "fields.catalogs.sys.id[in]", value: catalog });
-    }
-    log(`Get ${productCodes.length} product entry from Contentful`);
-    const entries = await getAllEntriesByCodes(
-      productCodes,
-      "topicProduct",
-      "sys,fields",
-      "fields.code",
-      otherFilters
-    );
-    log(`Founded ${entries.length} topicProduct`);
-
-    if (!entries.length) {
-      log(
-        `No products found between offset: ${offset} and limit: ${limit}. Total: ${total}`
-      );
-      const nextOffset = offset + limit;
-      const completed = limit === -1 || offset >= total;
-      if (completed) {
-        log(`Audit completed`);
-      }
-
-      return {
-        offset: nextOffset,
-        limit: limit,
-        completed,
-        s3FilePath,
-        total,
-        processedEntries: 0,
-      };
-    }
-
-    const pageCodes = entries.map((entry: Entry) =>
-      getProductPageIdByCode(entry.fields.code[defaultEnvironmentLocaleCode])
-    );
-
-    log(`Get ${pageCodes.length} product page entry from Contentful`);
-    const entriesPage = await getAllEntriesByCodes(
-      pageCodes,
-      "page",
-      "sys,fields",
-      "sys.id"
-    );
-    log(`Founded ${entriesPage.length} topicProduct pages`);
-    let count: number = offset;
-    for (const audit of allAudit) {
-      log(`${++count} of ${total}`);
-      log(`I process the product ${audit.product} with status ${audit.what}`);
-
-      log(`Search product entry with id ${audit.product}...`);
-      const productEntry = entries.find(
-        (currentEntry) =>
-          currentEntry?.fields?.code?.[defaultEnvironmentLocaleCode] ===
-          audit.product
-      );
-
-      if (!productEntry) {
-        let logMessage = "";
-        if (catalog) {
-          logMessage = `The ${audit.product} product was not found in the CMS with catalog ${catalog}`;
-        } else {
-          logMessage = `The ${audit.product} product was not found in the CMS`;
-        }
-        log(logMessage, "WARN");
-
-        continue;
-      }
-
-      log(`Founded product with id ${productEntry.sys.id}`);
-
-      log(`Get product catalogs...`);
-      const productCatalogs: AvailableCatalogs[] =
-        productEntry?.fields?.catalogs?.[defaultEnvironmentLocaleCode].map(
-          (entryCatalog: FieldItem) => {
-            return entryCatalog.sys.id;
-          }
-        );
-
-      if (catalog && !productCatalogs.includes(catalog)) {
-        log(
-          `Product ${audit.product} does not belong to the ${catalog} catalog`
-        );
-      } else {
-        log(`Import product...`);
-        await importProductByCode(audit.product, catalog);
-        await reindexProduct(audit.product, true);
-      }
-    }
-
-    const nextOffset = offset + limit;
-
-    return {
-      offset: nextOffset,
-      limit,
-      completed: limit === -1 || count >= total,
-      s3FilePath,
-      total,
-      processedEntries: entries.length,
-    };
-  } else {
-    log(`Execution completed`);
-  }
-
-  return {
-    offset: offset,
-    limit: limit,
-    completed: true,
-    s3FilePath,
-    processedEntries: 0,
-  };
-};
-
-export const populateDestinations = async (offset: number, limit: number) => {
-  const env = await getEnvironment();
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const opts = {
-    content_type: "topicProduct",
-    skip: offset,
-    limit,
-    locale: defEnvLocaleCode,
-    // select: 'sys.id,fields',
-    "sys.archivedAt[exists]": false,
-    // "fields.destinations[exists]": false,
-  };
-
-  const { items, total } = await env.getEntries(opts);
-
-  let count: number = offset;
-  for (let productEntry of items) {
-    log(`${++count} of ${total}`);
-    log(`Product: ${productEntry.sys.id}`);
-    const destinations =
-      productEntry.fields.productFields[defEnvLocaleCode]?.destinations?.map(
-        (destination: any) => destination.code
-      ) || [];
-
-    if (destinations.length) {
-      log(`Set destinations: ${destinations.join(", ")}`);
-      productEntry.fields = await addFieldValue(
-        productEntry,
-        "destinations",
-        destinations
-      );
-      productEntry = await productEntry.update();
-    } else {
-      log(`No destinations found.`, "WARN");
-    }
-
-    if (productEntry.isPublished()) {
-      try {
-        productEntry = await productEntry.publish();
-      } catch (err: any) {
-        log(`Cannot publish entry.`);
-        log(err);
-      }
-    }
-  }
-
-  return { completed: !total || total === count + offset, offset, limit };
-};
-
-export const purgeProductThumbCacheByProductCodes = async (
-  productCodes: string[]
-) => {
-  const defEnvLocaleCode = await getEnvironmentDefaultLocaleCode();
-
-  const productEntries = await getAllEntriesByCodes(
-    productCodes,
-    "topicProduct",
-    "sys,fields.thumbnailImgix"
-  );
-
-  let count: number = 0;
-  const total: number = productEntries.length;
-  for (const productEntry of productEntries) {
-    log(`${++count} of ${total}`);
-    const thumbEntryId =
-      productEntry.fields?.thumbnailImgix?.[defEnvLocaleCode]?.sys?.id;
-
-    if (thumbEntryId) {
-      let wrapperImgix = await getEntryByID(
-        thumbEntryId,
-        "wrapperImgix",
-        "sys,fields"
-      );
-      if (wrapperImgix) {
-        const imgixUrl =
-          wrapperImgix.fields?.imgixData?.[defEnvLocaleCode]?.url;
-        if (imgixUrl) {
-          log(`Cleaning cache for ${imgixUrl}`);
-          await purgeImageCacheByUrl(imgixUrl);
-        } else {
-          log(`No imgixUrl found in ${thumbEntryId} id`, "WARN");
-        }
-      } else {
-        log(`No wrapperImgix found with ${thumbEntryId} id`, "WARN");
-      }
-    } else {
-      log(`No thumbEntryId found in ${productEntry.sys.id}`, "WARN");
-    }
-  }
-};