dcos-core-monalisav2-latam 1.0.0

package/src/entities/orders.js

@@ -0,0 +1,195 @@
+const uuid = require("uuid");
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const Validation = require("../common/utils/validation-data");
+const Logger = require("../common/utils/logger");
+
+ORDER_DATA_TABLE = process.env.ORDER_DATA_TABLE;
+
+const getOrderDataByOrderId = async (orderId) => {
+  const data = {
+    TableName: ORDER_DATA_TABLE,
+    IndexName: "OrderIdAndAccountNameIndex",
+    KeyConditionExpression: "OrderId = :orderId",
+    ExpressionAttributeValues: {
+      ":orderId": orderId,
+    },
+  };
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const response = await dynamodb.query(data).promise();
+    return response.Items;
+  } catch (err) {
+    Logger.error("Error getting order data: ", err);
+    return null;
+  }
+};
+
+const addOrder = async (order) => {
+  order.Id = `${order.AccountNameForOrder}${order.OrderId}${order.OrderState}`;
+  let data = {};
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    data = Validation.transformKeysToUpperCaseValue(order);
+    const params = {
+      TableName: ORDER_DATA_TABLE,
+      Item: data,
+      ConditionExpression: "attribute_not_exists(Id)",
+    };
+    await dynamodb.put(params).promise();
+    return order;
+  } catch (err) {
+    if (err.code === "ConditionalCheckFailedException") {
+      Logger.error("Error creating or saving record in order notification. The Id already exists in the entity: ", data);
+      return null;
+    } else {
+      Logger.error("Error creating or saving record in order notification: ", err);
+      return null;
+    }
+  }
+};
+
+async function queryOrdersByAccountNameBetweenDatesWithPagination(accountName, fromDate, toDate, state, lastEvaluatedKey, total) {
+  let params = {
+    TableName: ORDER_DATA_TABLE,
+    IndexName: "AccountNameAndStatusDateIndex",
+    KeyConditionExpression: "#an = :accountNameForOrder AND #d BETWEEN :from AND :to",
+    ExpressionAttributeNames: {
+      "#an": "AccountNameForOrder",
+      "#d": "StatusDate",
+      "#s": "OrderState",
+      "#State": "OrderState",
+      "#OId": "OrderId",
+      "#Id": "Id"
+    },
+    ExpressionAttributeValues: {
+      ":accountNameForOrder": accountName,
+      ":from": fromDate,
+      ":to": toDate,
+      ":state": state,
+    },
+    FilterExpression: "#s = :state",
+    ProjectionExpression: "#Id, #an, #OId, #State, #d",
+    Select: "SPECIFIC_ATTRIBUTES"
+  };
+  if (lastEvaluatedKey) {
+    params.ExclusiveStartKey = lastEvaluatedKey;
+  }
+  if (!state) {
+    delete params.ExpressionAttributeValues[":state"];
+    delete params.ExpressionAttributeNames["#s"];
+    delete params.FilterExpression;
+  }
+  try {
+    let response = await getListCompleteItems(params, total);
+    const orderData = response.Items;
+    const lastEvaluatedKey = response.LastEvaluatedKey;
+    const result = {
+      orderData: orderData,
+      lastEvaluatedKey: lastEvaluatedKey,
+    };
+    return result;
+  } catch (err) {
+    Logger.error("Error getting order data: ", err);
+    return [];
+  }
+}
+
+const getListCompleteItems = async (params, total) => {
+  if (parseInt(total) == 0) {
+    return { Items: [], LastEvaluatedKey: null };
+  }
+  let limitP = total ?? 1, countItems = 0, listItems = [], lastEvaluatedKey = 1;
+  return new Promise(async function (resolve, reject) {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    while (lastEvaluatedKey) {
+      let res = await dynamodb.query(params).promise();
+      for (let i = 0; i < res.Items.length; i++) {
+        listItems = [...listItems, res.Items[i]];
+      }
+      countItems += parseInt(res.Count);
+      params.ExclusiveStartKey = res?.LastEvaluatedKey;
+      lastEvaluatedKey = res?.LastEvaluatedKey;
+      if (!res?.LastEvaluatedKey) {
+        countItems = limitP;
+        lastEvaluatedKey = null;
+      }
+    }
+    resolve({ Items: listItems, LastEvaluatedKey: lastEvaluatedKey });
+  });
+};
+
+const getOrdersByAccountNameBetweenDates = async (accountName, startDate, endDate, state, page, total, limitPage = 100) => {
+  let evaluate = await queryOrdersByAccountNameBetweenDatesWithPagination(accountName, startDate, endDate, state, null, total);
+  let orderData = evaluate.orderData.sort(function (a, b) {
+    let dateS = new Date(b.StatusDate).getTime();
+    let dateE = new Date(a.StatusDate).getTime();
+    return dateS - dateE;
+  });
+  let startPage = page == 1 || !page ? 0 : (parseInt((page - 1)) * parseInt(limitPage));
+  let endPage = page == 1 || !page ? limitPage : (parseInt(page) * parseInt(limitPage));
+  let resData = orderData.filter((item, index) => (index >= startPage && index < endPage));
+
+  return resData;
+};
+
+const getOrdersByAccountNameBetweenDatesCountTotals = async (accountName, startDate, endDate, state) => {
+  let data = {
+    TableName: ORDER_DATA_TABLE,
+    IndexName: "AccountNameAndStatusDateIndex",
+    KeyConditionExpression: "#an = :accountNameForOrder AND #d BETWEEN :from AND :to",
+    ExpressionAttributeNames: {
+      "#an": "AccountNameForOrder",
+      "#d": "StatusDate",
+      "#s": "OrderState"
+    },
+    Select: "COUNT",
+    ExpressionAttributeValues: {
+      ":accountNameForOrder": accountName,
+      ":from": startDate,
+      ":to": endDate,
+      ":state": state,
+    },
+    FilterExpression: "#s = :state"
+  };
+  if (!state) {
+    delete data.ExpressionAttributeValues[":state"];
+    delete data.ExpressionAttributeNames["#s"];
+    delete data.FilterExpression;
+  }
+  try {
+    const response = await getCount(data);
+    return response.Count;
+  } catch (err) {
+    Logger.error("Error getting order data: ", err);
+    return 0;
+  }
+};
+
+/**
+ * Funcion para obtener conteo de registros en dynamo
+ * @param params -- son los paraetros de busqueda dynamo 
+ */
+const getCount = async (params) => {
+  let countItems = 0, listItems = [], lastEvaluatedKey = 1;
+  return new Promise(async function (resolve, reject) {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    while (lastEvaluatedKey) {
+      let res = await dynamodb.query(params).promise();
+      countItems += parseInt(res?.Count);
+      params.ExclusiveStartKey = res?.LastEvaluatedKey;
+      lastEvaluatedKey = res?.LastEvaluatedKey;
+      if (!res?.LastEvaluatedKey) {
+        lastEvaluatedKey = null;
+      }
+    }
+    resolve({ Count: countItems });
+  });
+
+};
+
+module.exports = {
+  getOrderDataByOrderId,
+  addOrder,
+  getOrdersByAccountNameBetweenDates,
+  getOrdersByAccountNameBetweenDatesCountTotals,
+};

package/src/entities/sftp-inbound.js

@@ -0,0 +1,88 @@
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const Validation = require("../common/utils/validation-data");
+const Logger = require("../common/utils/logger");
+
+SFTP_INBOUND_DATA_TABLE = process.env.SFTP_INBOUND_DATA_TABLE;
+
+const getSftpConfigByDirectoryAndProcessExecute = async (directory, processExecute) => {
+  try {
+    const params = {
+      TableName: SFTP_INBOUND_DATA_TABLE,
+      Key: {
+        Directory: directory,
+        ProcessExecute: processExecute,
+      },
+    };
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const data = await dynamodb.get(params).promise();
+    return data.Item;
+  } catch (err) {
+    Logger.error("Error getting sftp inbound config: ", err);
+    return null;
+  }
+};
+
+const getSftpInboundConfigByAccountName = async (accountName) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: SFTP_INBOUND_DATA_TABLE,
+      IndexName: "AccountNameIndex",
+      KeyConditionExpression: "AccountName = :accountName",
+      ExpressionAttributeValues: {
+        ":accountName": accountName,
+      },
+    };
+    const response = await dynamodb.query(params).promise();
+    return response?.Items[0];
+  } catch (err) {
+    Logger.error("Error getting sftp inbound data: ", err);
+    return null;
+  }
+};
+
+const addSftpInboundConfig = async (sftpInboundData) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const data = Validation.transformFirstKeysToUpperCaseValue(sftpInboundData);
+    const params = {
+      TableName: SFTP_INBOUND_DATA_TABLE,
+      Item: data,
+    };
+    await dynamodb.put(params).promise();
+    return data;
+  } catch (err) {
+    Logger.error("Error saving sftp inbound data config: ", err);
+    return null;
+  }
+};
+
+const getItemsByDirectory = async (directory) => {
+  const dynamodb = new DynamoAWS.DocumentClient();
+  const params = {
+    TableName: SFTP_INBOUND_DATA_TABLE,
+    KeyConditionExpression: "#dir = :directoryValue",
+    ExpressionAttributeNames: {
+      "#dir": "Directory",
+    },
+    ExpressionAttributeValues: {
+      ":directoryValue": directory,
+    },
+  };
+
+  try {
+    const response = await dynamodb.query(params).promise();
+    const items = response.Items;
+    return items;
+  } catch (error) {
+    Logger.error("Error getting items by directory: ", error);
+    return null;
+  }
+};
+
+module.exports = {
+  getSftpConfigByDirectoryAndProcessExecute,
+  getSftpInboundConfigByAccountName,
+  addSftpInboundConfig,
+  getItemsByDirectory,
+};

package/src/entities/sku.js

@@ -0,0 +1,220 @@
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const VtexApi = require("../vtex/clients/VtexApi");
+const AccountData = require("./account");
+const Logger = require("../common/utils/logger");
+
+const INVENTORY_SKU_DATA_TABLE = process.env.INVENTORY_SKU_DATA_TABLE;
+
+const getSkuByParentAccountNameAndSku = async (accountName, sku, TradePolicyId = null) => {
+  try {
+    const id = `${accountName}${sku}`;
+    const params = {
+      TableName: INVENTORY_SKU_DATA_TABLE,
+      Key: {
+        AccountNameAndSku: id,
+        ParentAccountName: accountName,
+      },
+    };
+    const dynamodb = new DynamoAWS.DocumentClient();
+    let data = await dynamodb.get(params).promise();
+    if (typeof data.Item != 'object') {
+      data.Item = await getItemVtexPerRefId({
+        refId: sku,
+        parentAccountName: accountName,
+        TradePolicyId: TradePolicyId
+      });
+    }
+    return data.Item;
+  } catch (err) {
+    Logger.error("Error getting sku data config: ", err);
+    return null;
+  }
+};
+
+const getSkuByParentAccountNameAndEan = async (accountName, ean, TradePolicyId = null) => {
+  try {
+    const params = {
+      TableName: INVENTORY_SKU_DATA_TABLE,
+      IndexName: "AccountNameAndSkuEanIndex",
+      KeyConditionExpression: "Ean = :ean AND ParentAccountName = :parentAccount",
+      ExpressionAttributeValues: {
+        ":ean": ean,
+        ":parentAccount": accountName,
+      },
+    };
+    const dynamodb = new DynamoAWS.DocumentClient();
+    let data = await dynamodb.query(params).promise();
+    if (typeof data.Items == 'object' && data.Items.length == 0) {
+      let itemsearch = await getItemVtexPerEAN({
+        ean: ean,
+        parentAccountName: accountName,
+        TradePolicyId: TradePolicyId
+      });
+      if (itemsearch && typeof itemsearch == 'object') {
+        data.Items = [...data.Items, itemsearch];
+      }
+    }
+    return data.Items;
+  } catch (err) {
+    Logger.error("Error getting sku by ean data config: ", err);
+    return null;
+  }
+};
+
+const addSku = async (sku) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: INVENTORY_SKU_DATA_TABLE,
+      Item: sku,
+    };
+    await dynamodb.put(params).promise();
+    return sku;
+  } catch (err) {
+    Logger.error("Error saving account data config: ", err);
+    return null;
+  }
+};
+
+const getItemVtexPerRefId = async ({
+  refId = null,
+  parentAccountName = null,
+  TradePolicyId = null
+}) => {
+  if (refId && parentAccountName) {
+    try {
+      const account = await AccountData.getAccountDataByAccountName(parentAccountName);
+      if (account) {
+        const an = parentAccountName,
+          key = account?.Credentials?.key,
+          token = account?.Credentials?.token;
+        const vtexApi = new VtexApi(an, key, token);
+        const response = await vtexApi.fetch(`/catalog/pvt/stockkeepingunit?RefId=${refId}`, {
+          method: "GET",
+          data: {},
+        });
+
+        return response?.data && response?.data?.Id ? formatDataItemSku(response?.data, parentAccountName) : null;
+      } else {
+        Logger.error("account parent not found");
+        return null;
+      }
+    } catch (err) {
+      Logger.error("not fount item vtex: ", err);
+      return null;
+    }
+  } else {
+    return [];
+  }
+};
+
+const getItemVtexPerEAN = async ({
+  ean = null,
+  parentAccountName = null,
+  TradePolicyId = null
+}) => {
+  if (ean && parentAccountName) {
+    try {
+      const account = await AccountData.getAccountDataByAccountName(parentAccountName);
+      if (account) {
+        const an = parentAccountName,
+          key = account?.Credentials?.key,
+          token = account?.Credentials?.token;
+        const vtexApi = new VtexApi(an, key, token);
+        const response = await vtexApi.fetch(`/catalog_system/pvt/sku/stockkeepingunitbyean/${ean}`, {
+          method: "GET",
+          data: {},
+        });
+        return response?.data && response?.data?.Id ? formatDataItemSku(response?.data, parentAccountName) : null;
+      } else {
+        Logger.error("account parent not found");
+        return null;
+      }
+    } catch (err) {
+      Logger.error("not fount item vtex: ", err);
+      return null;
+    }
+  } else {
+    return [];
+  }
+};
+
+const formatDataItemSku = (data, parentAccountName) => {
+  if (data && parentAccountName && data?.Id) {
+    return {
+      Ean: data?.AlternateIds?.Ean ?? data?.RefId,
+      ParentAccountName: parentAccountName,
+      AccountNameAndSku: `${parentAccountName}${(data?.AlternateIds?.RefId ?? data?.RefId)}`,
+      Type: 'SKU',
+      Sku: data?.AlternateIds?.RefId ?? data?.RefId,
+      SkuId: data?.Id,
+      Name: data?.NameComplete ?? data?.Name,
+    };
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Metodo para obtener sku id VTEX 
+ **/
+const getSkuVtex = async ({
+  account = null,
+  sku = null,
+  SkuRefUsed = true
+}) => {
+  return new Promise(async (responseD, errorD) => {
+    if (!account || !sku) {
+      errorD("account and sku are required!");
+    } else {
+      let skuData = null;
+      if (SkuRefUsed) {
+        skuData = await getSkuByParentAccountNameAndSku(account, sku);
+      } else {
+        skuData = await getSkuByParentAccountNameAndEan(account, sku);
+        if (!skuData || skuData.length < 1) {
+          errorD("Not found by Ean: ", sku);
+        } else {
+          skuData = skuData?.[0];
+        }
+      }
+
+      if (skuData && skuData?.SkuId) {
+        responseD(skuData?.SkuId);
+      } else {
+        errorD("Not found by Sku: ", sku);
+      }
+    }
+  });
+};
+
+/**
+ * Save log error search sku
+ **/
+const saveLogProductsNotFount = async ({an=null, key=null, token= null, entity=null, sku=null, value= null}) => {
+  if (an && key && token && entity && sku && value) {
+    try{
+      const vtexApi = new VtexApi(an, key, token);
+      const response = await vtexApi.fetch(`/dataentities/${entity}/documents/`, {
+        method: "PATCH",
+        data: {
+          id: `${sku}-${an}`,
+          sku: sku,
+          whitelabel: an,
+          value: (typeof value === 'string') ? value : null
+        },
+      });
+    } catch(errSaveMD2) {
+      Logger.error('Error save log sku not found', errSaveMD2);
+    }
+  }
+  return true;
+};
+
+module.exports = {
+  getSkuByParentAccountNameAndSku,
+  addSku,
+  getSkuByParentAccountNameAndEan,
+  getSkuVtex,
+  saveLogProductsNotFount
+};