dcos-core-monalisav2-latam 1.0.0

package/src/entities/taxpromotion.js

@@ -0,0 +1,249 @@
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const Validation = require("../common/utils/validation-data");
+const Logger = require("../common/utils/logger");
+
+const TAX_PROMOTION_TABLE = process?.env?.TAX_PROMOTION_TABLE;
+const LIMIT_ITEMS_PROMOTIONS= process?.env?.LIMIT_ITEMS_PROMOTIONS ?? 100;
+
+/**
+ * Obtner listado de promociones o impuestos 
+ * @param seller -- Id de seller dentro del json promociones
+ **/
+const getPerId = async (IdExternalPromotion= null) => {
+  if(!IdExternalPromotion){
+    return null;
+  }
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: TAX_PROMOTION_TABLE,
+      Key: {
+        "IdExternalPromotion": IdExternalPromotion
+      }
+    };
+    const response = await dynamodb.get(params).promise();
+    return response?.Item ? Validation.transformFirstKeysToLowerCaseValue(response?.Item) : null;
+  } catch (err) {
+    Logger.error("Error getting account data: ", err);
+    return null;
+  }
+};
+
+/**
+ * Obtner listado de promociones o impuestos 
+ * @param seller -- Id de seller dentro del json promociones
+ **/
+const getPerIdVtex = async (IdCalculatorConfiguration= null) => {
+  if(!IdCalculatorConfiguration){
+    return null;
+  }
+  try {
+    const params = {
+      TableName: TAX_PROMOTION_TABLE,
+      IndexName: "IdCalculatorConfigurationIndex",
+      KeyConditionExpression: "#n0 = :v0",
+      ExpressionAttributeNames: {
+        "#n0": "IdCalculatorConfiguration"
+      },
+      ExpressionAttributeValues: {
+        ":v0": IdCalculatorConfiguration
+      },
+      Limit: 100,
+      Select: "ALL_ATTRIBUTES",
+      ReturnConsumedCapacity: "TOTAL"
+    };
+    const response = await getListCompleteItems(params, 1, "query");
+    return response?.Items[0] ? Validation.transformFirstKeysToLowerCaseValue(response?.Items[0]) : null;
+  } catch (err) {
+    Logger.error("Error getting tax or promotion data: ", err);
+    return null;
+  }
+};
+
+/**
+ * Obtener lista de items dynamo
+ * */
+const getListCompleteItems= async (params, total=100, process="scan")=>{
+  if(parseInt(params?.Limit)===0){
+    return {Items:[], LastEvaluatedKey:null};
+  }
+  let limitP= total, countItems=0, listItems=[], lastEvaluatedKey=null;
+  return new Promise(async function(resolve, reject){
+    const dynamodb =  new DynamoAWS.DocumentClient();
+    while (countItems < limitP) {
+      let res= await dynamodb[process](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 || listItems?.length === total){
+        countItems= limitP;
+      }
+    }
+
+    resolve({Items:listItems, LastEvaluatedKey:lastEvaluatedKey});
+  });
+
+};
+
+/**
+ * CREAR O ACTULALIZA PROMOCION O IMPUESTO EN DYNAMODB 
+ * @param taxPromotionData -- json con datos de la promocion o impuesto
+ **/
+const createOrUpdate = async (taxPromotionData) => {
+  const dynamodb = new DynamoAWS.DocumentClient();
+  let data = Validation.transformFirstKeysToUpperCaseValue(taxPromotionData);
+  
+  if(data?.IdCalculatorConfiguration === null || data?.IdCalculatorConfiguration === ""){
+    delete data?.IdCalculatorConfiguration;
+  }
+  try {
+    const params = {
+      TableName: TAX_PROMOTION_TABLE,
+      Item: data,
+      ConditionExpression: "attribute_not_exists(IdExternalPromotion)",
+    };
+    
+    await dynamodb.put(params).promise();
+    
+    return taxPromotionData;
+  } catch (err) {
+
+    if (err.code === "ConditionalCheckFailedException" || err.code === "ValidationException") {
+      try{
+        let dataUpdateDynamo= setDataUpdateDynamo(data, 60);
+        for (var i = 0; i < dataUpdateDynamo.length; i++) {
+          let updateExpression='set';
+          let ExpressionAttributeNames={};
+          let ExpressionAttributeValues = {};
+          for (const property in dataUpdateDynamo[i]) {
+            if(property != 'IdExternalPromotion' && property != 'IdExternalPromotion'){
+              updateExpression += ` #${property} = :${property} ,`;
+              ExpressionAttributeNames['#'+property] = property ;
+              ExpressionAttributeValues[':'+property]=dataUpdateDynamo[i][property];
+            }
+          }
+          updateExpression= updateExpression.slice(0, -1);
+          
+          let res2= await dynamodb.update({
+            TableName: TAX_PROMOTION_TABLE,
+            Key:{
+              IdExternalPromotion: data?.IdExternalPromotion
+            },
+            UpdateExpression: updateExpression,
+            ExpressionAttributeNames: ExpressionAttributeNames,
+            ExpressionAttributeValues: ExpressionAttributeValues
+          }).promise();
+        }
+
+        return taxPromotionData;
+      }catch(err2){
+        if(err2.code === "ConditionalCheckFailedException"){
+          return taxPromotionData;
+        } 
+        Logger.error('err2err2',err2);
+        return null 
+      }
+      
+    }
+    Logger.error('error create', err);
+    return null;
+  }
+};
+
+/**
+ * Ajuste la cantidad de propiedades validar dentro de dynamo 
+ * @param data -- json promotion
+ * @param limit -- limite propiedades dynamo
+ **/
+const setDataUpdateDynamo= (data, limit=100)=>{
+  let arraData= [], objInternal={}, countItems=0, lengthData=Object.keys(data).length;
+  for (let item in data) {
+    countItems++;
+    if(Object.keys(objInternal).length < limit){
+      objInternal[item]= data[item];
+    }else{
+      arraData=[...arraData,objInternal];
+      objInternal={};
+      objInternal[item]= data[item];
+    }
+
+    if(countItems === lengthData){
+      arraData=[...arraData,objInternal];
+    }
+  }
+
+  return arraData;
+};
+
+/**
+ * Obtener lista de promociones almacenadas en dynamodb
+ * @param filters -- filtros que se pueden realizar en la entidad de datos IdSeller | TypeSearch 
+ **/
+const getAllPromotionsOrTaxes = async (filters) => { 
+  if(!filters || !filters?.IdSeller || typeof filters?.IdSeller !== 'object' || filters?.IdSeller?.length === 0){
+    return [];
+  }
+
+  try {
+    let params = {
+      TableName: TAX_PROMOTION_TABLE,
+      ExpressionAttributeNames: {
+        "#IdSeller": "IdSeller",
+        "#Type": "Type",
+        "#IsArchived": "IsArchived"
+      },
+      ExpressionAttributeValues: {
+        ":Tax": "tax",
+        ":IsArchived": false
+      },
+      FilterExpression: filters?.TypeSearch === 'taxes' ? `#Type = :Tax` : `#Type <> :Tax`,
+      Limit: LIMIT_ITEMS_PROMOTIONS,
+      Select: "ALL_ATTRIBUTES",
+      ReturnConsumedCapacity: "TOTAL"
+    };
+
+    params.FilterExpression+= ' AND #IsArchived = :IsArchived';
+
+    if(filters?.IdSeller || typeof filters?.IdSeller === 'object'){
+      let listConditionsSeller=[];
+      for (var i = 0; i < filters?.IdSeller?.length; i++) {
+        params.ExpressionAttributeValues[":SellerV"+i]= filters?.IdSeller[i];
+        listConditionsSeller=[...listConditionsSeller, `#IdSeller = :SellerV${i}`]
+      }
+      params.FilterExpression+= ` AND (${listConditionsSeller.join(' OR ')})`;
+    }
+    const response = await getListCompleteItems(params,LIMIT_ITEMS_PROMOTIONS);
+    return response?.Items?.length > 0 ?  response?.Items.map(it=>Validation.transformFirstKeysToLowerCaseValue(it)) : [];
+  } catch (err) {
+    Logger.error("Error getting tax or promotion data: ", err);
+    return null;
+  }
+};
+
+const bindIdExternalPromotionToOrderData = async (orderVtex)=>{
+  try {
+    const benefits = orderVtex?.ratesAndBenefitsData?.rateAndBenefitsIdentifiers;
+    if (typeof benefits !== 'undefined' && benefits.length > 0){
+      for (var item of benefits) {
+        let dataPromotion = await getPerIdVtex(item?.id);
+        item.IdExternalPromotion = (typeof dataPromotion?.idExternalPromotion !== 'undefined' ? dataPromotion?.idExternalPromotion : null);
+      }
+      orderVtex.ratesAndBenefitsData.rateAndBenefitsIdentifiers = benefits;
+    }
+    return orderVtex;
+  } catch (err) {
+    Logger.error("Error promotion data: ", err);
+    return null;
+  }
+}
+
+module.exports = {
+  createOrUpdate,
+  getPerId,
+  getPerIdVtex,
+  getAllPromotionsOrTaxes,
+  bindIdExternalPromotionToOrderData,
+};

package/src/functions/account/account-get.js

@@ -0,0 +1,262 @@
+const ApiResponse = require("../../common/utils/api-response");
+const AccountData = require("../../entities/account");
+const AccountErrors = require("../../common/utils/account-error-helper");
+const DataTablesHelper = require("../../common/utils/data-tables-helper");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * Ordena recursivamente las propiedades de un objeto en orden alfabético
+ */
+function sortObjectPropertiesAlphabetically(obj) {
+  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
+    return obj;
+  }
+
+  const sortedKeys = Object.keys(obj).sort();
+  const sortedObj = {};
+  
+  for (const key of sortedKeys) {
+    if (obj[key] !== null && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+      sortedObj[key] = sortObjectPropertiesAlphabetically(obj[key]);
+    } else {
+      sortedObj[key] = obj[key];
+    }
+  }
+  
+  return sortedObj;
+}
+
+/**
+ * Obtiene una lista de cuentas con soporte DataTables y Legacy - CON VALIDACIONES
+ */
+const getAccounts = async (event) => {
+  try {
+    const queryStringParameters = event.queryStringParameters || {};
+    const parentAccountName = queryStringParameters.parent;
+    
+    Logger.debug("Raw query parameters:", queryStringParameters);
+    
+    if (!DataTablesHelper) {
+      Logger.error("DataTablesHelper not loaded");
+      throw new Error("DataTablesHelper module not found");
+    }
+
+    const isDataTables = DataTablesHelper.isDataTablesFormat(queryStringParameters);
+    
+    let queryParams;
+    if (isDataTables) {
+      try {
+        queryParams = DataTablesHelper.parseDataTablesParams(queryStringParameters);
+        Logger.debug("Parsed DataTables params:", queryParams);
+      } catch (parseError) {
+        Logger.error("Error parsing DataTables params:", parseError);
+        // Fallback a Legacy si DataTables parsing falla
+        queryParams = {
+          _limit: 10,
+          _sort: "asc",
+          draw: parseInt(queryStringParameters.draw) || 1
+        };
+      }
+    } else {
+      queryParams = {
+        _limit: queryStringParameters._limit,
+        _sort: queryStringParameters._sort,
+        _from: queryStringParameters._from,
+        _to: queryStringParameters._to,
+        _moduleActive: queryStringParameters._moduleActive,
+        _accountPattern: queryStringParameters._accountPattern,
+        _integration: queryStringParameters._integration,
+        _like: queryStringParameters._like,
+        _fields: queryStringParameters._fields,
+        _excludeFields: queryStringParameters._excludeFields
+      };
+      
+      Object.keys(queryParams).forEach(key => 
+        queryParams[key] === undefined && delete queryParams[key]
+      );
+      
+      Logger.debug("Parsed Legacy params:", queryParams);
+    }
+    
+    if (parentAccountName) {
+      queryParams.parentAccountName = parentAccountName;
+    }
+
+    if (!AccountData.getAccountsForDataTables) {
+      Logger.error("getAccountsForDataTables function not found in AccountData");
+      throw new Error("Required function not available");
+    }
+
+    const result = await AccountData.getAccountsForDataTables(queryParams);
+    
+    if (!result) {
+      Logger.error("No result from getAccountsForDataTables");
+      if (isDataTables) {
+        return ApiResponse.response(200, DataTablesHelper.formatDataTablesResponse(
+          [], queryParams.draw || 1, 0, 0
+        ));
+      } else {
+        return await AccountErrors.createError('ACCOUNT_029', { 
+          parentAccountName: parentAccountName || 'N/A' 
+        });
+      }
+    }
+
+    if (result.error) {
+      Logger.error("Error in result:", result.error);
+      if (isDataTables) {
+        return ApiResponse.response(500, DataTablesHelper.formatDataTablesResponse(
+          [], queryParams.draw || 1, 0, 0
+        ));
+      } else {
+        return await AccountErrors.createWithLogging('ACCOUNT_030', new Error(result.error));
+      }
+    }
+    
+    if (!result.items && !result.data) {
+      if (isDataTables) {
+        return ApiResponse.response(200, DataTablesHelper.formatDataTablesResponse(
+          [], 
+          queryParams.draw, 
+          0, 
+          0
+        ));
+      } else {
+        // Error Legacy
+        return await AccountErrors.createError('ACCOUNT_029', { 
+          parentAccountName: parentAccountName || 'N/A' 
+        });
+      }
+    }
+    
+    if (isDataTables) {
+      const dataTablesResponse = DataTablesHelper.formatDataTablesResponse(
+        result.data || result.items || [],
+        queryParams.draw,
+        result.recordsTotal || 0,
+        result.recordsFiltered || result.count || 0
+      );
+      
+      Logger.debug("DataTables response:", {
+        draw: dataTablesResponse.draw,
+        recordsTotal: dataTablesResponse.recordsTotal,
+        recordsFiltered: dataTablesResponse.recordsFiltered,
+        dataLength: dataTablesResponse.data.length
+      });
+      
+      return ApiResponse.response(200, dataTablesResponse);
+    } else {
+      const sortedItems = (result.items || result.data || []).map(sortObjectPropertiesAlphabetically);
+      
+      return ApiResponse.response(200, { 
+        message: "Accounts retrieved successfully", 
+        data: sortedItems,
+        count: result.count,
+        pagination: {
+          nextToken: result.lastEvaluatedKey,
+          hasMore: result.lastEvaluatedKey !== null,
+          limit: parseInt(queryParams._limit) || 100
+        }
+      });
+    }
+    
+  } catch (error) {
+    Logger.error("Error retrieving accounts:", error);
+    
+    const isDataTables = DataTablesHelper && DataTablesHelper.isDataTablesFormat 
+      ? DataTablesHelper.isDataTablesFormat(event.queryStringParameters || {})
+      : false;
+    
+    if (isDataTables && DataTablesHelper.formatDataTablesResponse) {
+      return ApiResponse.response(500, DataTablesHelper.formatDataTablesResponse(
+        [], 
+        parseInt(event.queryStringParameters?.draw) || 1, 
+        0, 
+        0
+      ));
+    } else {
+      return await AccountErrors.createWithLogging('ACCOUNT_030', error);
+    }
+  }
+};
+
+// MANTENER getAccount y deleteAccount sin cambios (son las mismas funciones que ya tienes)
+
+/**
+ * Obtiene una cuenta específica por su AccountName
+ */
+const getAccount = async (event) => {
+  try {
+    const { an } = event.pathParameters || {};
+    
+    if (!an) {
+      return await AccountErrors.createError('ACCOUNT_027');
+    }
+    
+    const queryStringParameters = event.queryStringParameters || {};
+    const queryParams = {
+      _fields: queryStringParameters._fields,
+      _excludeFields: queryStringParameters._excludeFields
+    };
+    
+    Object.keys(queryParams).forEach(key => 
+      queryParams[key] === undefined && delete queryParams[key]
+    );
+    
+    const account = await AccountData.getAccountDataByAccountName(an, queryParams);
+    
+    if (!account) {
+      return await AccountErrors.createError('ACCOUNT_028', { accountName: an });
+    }
+    
+    const sortedAccount = sortObjectPropertiesAlphabetically(account);
+    
+    return ApiResponse.response(200, { 
+      message: "Account retrieved successfully", 
+      data: sortedAccount 
+    });
+  } catch (error) {
+    Logger.error(`Error retrieving account:`, error);
+    return await AccountErrors.createWithLogging('ACCOUNT_030', error);
+  }
+};
+
+/**
+ * Elimina una cuenta específica por su AccountName
+ */
+const deleteAccount = async (event) => {
+  try {
+    const { an } = event.pathParameters || {};
+    
+    if (!an) {
+      return await AccountErrors.createError('ACCOUNT_027');
+    }
+    
+    Logger.info(`Attempting to delete account: ${an}`);
+    
+    const account = await AccountData.getAccountDataByAccountName(an);
+    if (!account) {
+      return await AccountErrors.createError('ACCOUNT_028', { accountName: an });
+    }
+    
+    const result = await AccountData.deleteAccountByAccountName(an);
+    
+    if (result.success) {
+      return ApiResponse.response(200, { 
+        message: result.message,
+        deleted: true
+      });
+    } else {
+      return await AccountErrors.createError('ACCOUNT_030');
+    }
+  } catch (error) {
+    Logger.error(`Error deleting account:`, error);
+    return await AccountErrors.createWithLogging('ACCOUNT_030', error);
+  }
+};
+
+module.exports = {
+  getAccounts,
+  getAccount,
+  deleteAccount,
+};