dcos-core-monalisav2-latam 1.0.0

package/src/functions/distributors/distributor.js

@@ -0,0 +1,535 @@
+const ApiResponse = require("../../common/utils/api-response");
+const { DynamoDB } = require("aws-sdk");
+const ClientData = require("../../entities/clients");
+const Logger = require("../../common/utils/logger");
+
+const dynamoDb = new DynamoDB.DocumentClient();
+const SKU_DATA_DISTRIBUTOR_TABLE = process?.env?.SKU_DATA_DISTRIBUTOR_TABLE;
+
+/**
+ * Function to validate input data manually.
+ * @param {Object} data
+ * @returns {Object|null} Returns an error object if validation fails, otherwise null.
+ */
+function validateInputData(data) {
+    const errors = [];
+    if (typeof data.ERPCode !== 'string') {
+        errors.push('ERPCode debe ser una cadena');
+    }
+    if (typeof data.Name !== 'string' || data.Name.length < 1 || data.Name.length > 50) {
+        errors.push('Name debe ser una cadena entre 1 y 50 caracteres');
+    }
+    if (typeof data.Sku !== 'string') {
+        errors.push('Sku debe ser una cadena');
+    }
+    if (typeof data.Active !== 'boolean') {
+        errors.push('Active debe ser un booleano');
+    }
+
+    if (errors.length > 0) {
+        Logger.error('Errores de validación:', errors);
+        return { message: 'Datos de entrada inválidos', errors: errors };
+    }
+    return null;
+}
+
+/**
+ * Function to create a new distributor code.
+ * @param {string} accountNameAndSkuDis
+ * @param {string} accountName
+ * @param {Object} data
+ * @returns {Promise<Object|null>}
+ * @throws {Error}
+ */
+async function createDistributorCodeTemplate(accountNameAndSkuDis, accountName, data) {
+    try {
+        const item = {
+            AccountNameAndSkuDis: accountNameAndSkuDis,
+            AccountName: accountName,
+            ERPCode: data.ERPCode,
+            Name: data.Name,
+            Sku: data.Sku,
+            Active: data.Active,
+        };
+
+        const params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            Item: item,
+        };
+
+        await dynamoDb.put(params).promise();
+
+        return item;
+    } catch (error) {
+        Logger.error('Error al crear distribuidor:', error);
+        return null;
+    }
+}
+
+/**
+ * Handler function for creating a new distributor code.
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<any>}
+ */
+async function createDistributorCode(event) {
+    try {
+        const request = JSON.parse(event.body);
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+        const requestDataArray = Array.isArray(request) ? request : [request];
+
+        for (const requestData of requestDataArray) {
+            const accountName = requestData?.AccountName;
+            const isValid = await ClientData.validateAccount(clientId, accountName);
+
+            if (!isValid) {
+                Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+                return ApiResponse.responseNoCors(404, "Account not found");
+            }
+
+            // Generate AccountNameAndSkuDis by concatenating AccountName and ERPCode
+            requestData.AccountNameAndSkuDis = `${requestData.AccountName}-${requestData.ERPCode.toString()}`;
+
+            const result = await createDistributorCodeTemplate(requestData.AccountNameAndSkuDis, requestData.AccountName, requestData);
+            if (!result) {
+                return ApiResponse.responseNoCors(500, 'Error interno al crear distributor');
+            }
+        }
+
+        return ApiResponse.responseNoCors(200, { message: 'Distribuidor creado correctamente' });
+    } catch (error) {
+        Logger.error('Error al crear distribuidor:', error);
+        return ApiResponse.responseNoCors(500, 'Error interno al crear distribuidor');
+    }
+}
+
+/**
+ * Handler function for create or update a list of distributor codes.
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<any>}
+ */
+async function createOrUpdateDistributorCodes(event) {
+    try {
+        const request = JSON.parse(event.body);
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+
+        // Array to store the log messages
+        const logMessages = [];
+
+        // Validate input
+        if (!Array.isArray(request.ErpData)) {
+            return ApiResponse.responseNoCors(400, "Invalid input data");
+        }
+
+        // Obtener todos los accountName únicos del ErpData
+        const accountNames = [...new Set(request.ErpData.map(erpData => erpData.AccountName))];
+
+        // Mapa para almacenar todos los items existentes por accountName
+        const allExistingItemsMap = {};
+
+        // Obtener los distribuidores para cada accountName
+        for (const accountName of accountNames) {
+            allExistingItemsMap[accountName] = await getAllItemsByAccountName(accountName);
+        }
+
+        for (const erpData of request.ErpData) {
+            // Validar la cuenta
+            const isValid = await ClientData.validateAccount(clientId, erpData.AccountName);
+            if (!isValid) {
+                logMessages.push(`Error: Account not found for ${erpData.AccountName}`);
+                continue;
+            }
+
+            // Obtener los distribuidores existentes para el accountName actual
+            const existingItems = allExistingItemsMap[erpData.AccountName] || [];
+
+            const accountNameAndSkuDis = erpData?.AccountNameAndSkuDis ?? `${erpData.AccountName}-${erpData.ERPCode.toString()}`;
+            const existingItem = existingItems.find(item => item.AccountNameAndSkuDis === accountNameAndSkuDis);
+
+            if (erpData.Delete === true) {
+                if (existingItem) {
+                    if (await deleteDistributorByTemplate(accountNameAndSkuDis, erpData.AccountName)) {
+                        logMessages.push(`Distribuidor eliminado correctamente: ${accountNameAndSkuDis}`);
+                    } else {
+                        logMessages.push(`Error al eliminar distribuidor: ${accountNameAndSkuDis}`);
+                    }
+                } else {
+                    logMessages.push(`Distribuidor no encontrado para eliminación: ${accountNameAndSkuDis}`);
+                }
+            } else {
+                if (existingItem) {
+                    // Actualizar el item existente
+                    const result = await updateDistributorCodeTemplate(accountNameAndSkuDis, erpData.AccountName, erpData);
+                    logMessages.push(`Distribuidor actualizado correctamente: ${result}`);
+                } else {
+                    // Crear un nuevo item
+                    const result = await createDistributorCodeTemplate(accountNameAndSkuDis, erpData.AccountName, erpData);
+                    logMessages.push(`Distribuidor creado correctamente: ${result}`);
+                }
+            }
+        }
+
+        return ApiResponse.responseNoCors(200, { message: 'Operación completada', logs: logMessages });
+    } catch (error) {
+        Logger.error('Error al crear distribuidor:', error);
+        return ApiResponse.responseNoCors(500, 'Error interno al crear distribuidor');
+    }
+}
+
+/**
+ * Function to update an existing distributor code.
+ * @param {string} accountNameAndSkuDis
+ * @param {string} accountName
+ * @param {Object} data
+ * @returns {Promise<Object|null>}
+ * @throws {Error}
+ */
+async function updateDistributorCodeTemplate(accountNameAndSkuDis, accountName, data) {
+    try {
+        //for update we need to delete the existing item and create a new one
+        const isDeleted = await deleteDistributorByTemplate(accountNameAndSkuDis, accountName);
+        if (!isDeleted) {
+            return null;
+        }
+        const newAccountNameAndSkuDis = `${accountName}-${data?.ERPCode.toString()}`;
+        const result = await createDistributorCodeTemplate(newAccountNameAndSkuDis, accountName, data);
+        return result;
+    } catch (error) {
+        Logger.error('Error al actualizar distribuidor:', error);
+        return null;
+    }
+}
+
+/**
+ * Handler function for updating an existing distributor code.
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<any>}
+ */
+async function updateDistributorCode(event) {
+    try {
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+        const distributorCode = event?.pathParameters?.id;
+        const accountName = distributorCode.split('-')[0];
+        const isValid = await ClientData.validateAccount(clientId, accountName);
+
+        if (!isValid) {
+            Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+            return ApiResponse.responseNoCors(404, "Account not found");
+        }
+
+        if (!distributorCode || !accountName) {
+            return ApiResponse.responseNoCors(400, { message: 'Distributor code and AccountName required' });
+        }
+
+        const data = JSON.parse(event.body);
+
+        const validationError = validateInputData(data);
+        if (validationError) {
+            return ApiResponse.responseNoCors(400, validationError);
+        };
+
+        const result = await updateDistributorCodeTemplate(distributorCode, data.AccountName, data);
+
+        return ApiResponse.responseNoCors(200, { message: 'Distribuidor actualizado correctamente', attributes: result });
+    } catch (error) {
+        Logger.error('Error al actualizar distribuidor:', error);
+        return ApiResponse.responseNoCors(500, 'Error interno al actualizar distribuidor');
+    }
+}
+
+/**
+ * Handler function for deleting a distributor code.
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<any>}
+ */
+async function deleteDistributorCode(event) {
+    try {
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+        const distributorCode = event?.pathParameters?.id;
+        const accountName = distributorCode.split('-')[0];
+        const isValid = await ClientData.validateAccount(clientId, accountName);
+
+        if (!isValid) {
+            Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+            return ApiResponse.responseNoCors(404, "Account not found");
+        }
+
+        if (!distributorCode || !accountName) {
+            return ApiResponse.responseNoCors(400, { message: 'Distributor code and AccountName required' });
+        }
+
+        await deleteDistributorByTemplate(distributorCode, accountName);
+
+        return ApiResponse.responseNoCors(200, { message: 'Distribuidor eliminado correctamente' });
+    } catch (error) {
+        Logger.error('Error al eliminar distribuidor:', error);
+        return ApiResponse.responseNoCors(500, 'Error interno al eliminar distribuidor');
+    }
+}
+
+/**
+ * Handler function for deleting a distributor code.
+ * @param {string} distributorCode
+ * @param {string} accountName
+ * @returns {Promise<boolean>}
+ */
+async function deleteDistributorByTemplate(distributorCode, accountName) {
+    try {
+        const params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            Key: {
+                AccountNameAndSkuDis: distributorCode,
+                AccountName: accountName,
+            },
+        };
+        await dynamoDb.delete(params).promise();
+        return true;
+    } catch (error) {
+        Logger.error('Error al eliminar distribuidor:', error);
+        return false;
+    }
+}
+
+/**
+ * Function to get all items by account name.
+ * @param {string} accountName
+ * @returns {Promise<any>}
+ * @throws {Error}
+ */
+async function getAllItemsByAccountName(accountName) {
+    try {
+        const params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            IndexName: 'AccountNameIndex',
+            KeyConditionExpression: '#AccountName = :AccountName',
+            ExpressionAttributeNames: {
+                '#AccountName': 'AccountName',
+            },
+            ExpressionAttributeValues: {
+                ':AccountName': accountName,
+            },
+        };
+        let result = await dynamoDb.query(params).promise();
+        let items = result.Items;
+
+        while (result.LastEvaluatedKey) {
+            params.ExclusiveStartKey = result.LastEvaluatedKey;
+            result = await dynamoDb.query(params).promise();
+            items = items.concat(result.Items);
+        }
+
+        return items;
+    } catch (error) {
+        Logger.error('Error al obtener items por accountName:', error);
+        return [];
+    }
+}
+
+/**
+ * Handler function for retrieving all distributors.
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<any>}
+ * @throws {Error}
+ */
+async function getAllDistributorsCodes(event) {
+    try {
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+        const accountName = event?.queryStringParameters?.accountName;
+
+        let params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            Limit: 300,
+            Select: !accountName ? "ALL_ATTRIBUTES" : "ALL_PROJECTED_ATTRIBUTES",
+            ReturnConsumedCapacity: "TOTAL",
+        };
+
+        let result = null;
+        // Verificamos si el accountName fue pasado como query param
+        if (accountName) {
+            const isValid = await ClientData.validateAccount(clientId, accountName);
+            if (!isValid) {
+                Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+                return ApiResponse.responseNoCors(404, "Account not found");
+            }
+            params.IndexName = 'AccountNameIndex';
+            params.KeyConditionExpression = '#AccountName = :AccountName';
+            params.ExpressionAttributeNames = {
+                '#AccountName': 'AccountName',
+            };
+            params.ExpressionAttributeValues = {
+                ':AccountName': accountName,
+            };
+            result = await dynamoDb.query(params).promise();
+
+        } else {
+            // Si no se proporciona el accountName, hacemos la consulta total
+            result = await dynamoDb.scan(params).promise();
+        }
+        let items = result.Items;
+        while (result.LastEvaluatedKey) {
+            params.ExclusiveStartKey = result.LastEvaluatedKey;
+            result = await dynamoDb.query(params).promise();
+            items = items.concat(result.Items);
+        }
+        return ApiResponse.responseNoCors(200, items);
+    } catch (error) {
+        Logger.error('Error al obtener distribuidores:', error);
+        return ApiResponse.responseNoCors(500, 'Error interno al obtener distribuidores');
+    }
+}
+
+/**
+ * Handler function for retrieving a distributor by code.
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<any>}
+ */
+async function getDistributorByCode(event) {
+    try {
+        const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+        const distributorCode = event?.pathParameters?.id;
+        const accountName = distributorCode.split('-')[0];
+        const isValid = await ClientData.validateAccount(clientId, accountName);
+
+        if (!isValid) {
+            Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+            return ApiResponse.responseNoCors(404, "Account not found");
+        }
+
+        if (!distributorCode || !accountName) {
+            return ApiResponse.responseNoCors(400, { message: 'Código de distribuidor y AccountName requeridos' });
+        }
+
+        const params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            Key: {
+                AccountNameAndSkuDis: distributorCode,
+                AccountName: accountName,
+            },
+        };
+        const result = await dynamoDb.get(params).promise();
+
+        if (!result.Item) {
+            return ApiResponse.responseNoCors(404, { message: 'Distribuidor no encontrado' });
+        }
+
+        return ApiResponse.responseNoCors(200, result.Item);
+    } catch (error) {
+        Logger.error('Error al obtener distribuidor por código:', error);
+        return ApiResponse.responseNoCors(500, 'Error interno al obtener distribuidor por código');
+    }
+}
+
+/**
+ * Handler function for retrieving a distributor by sku.
+ * @param {string} accountName Name of the account  
+ * @param {string} sku Sku of the product
+ * @param {boolean} skuDistributorManagement Flag to manage distributor by sku
+ * @returns {Promise<any>}
+ */
+async function getDistributorByErpCode(accountName, erpCode, skuDistributorManagement) {
+    try {
+        if (!skuDistributorManagement || skuDistributorManagement === false) {
+            return erpCode;
+        }
+
+        if (!accountName || !erpCode) {
+            Logger.error('Error al obtener distribuidor por erpCode');
+            throw new Error('Error al obtener distribuidor por erpCode');
+        }
+
+        const AccountNameAndSkuDis = `${accountName}-${erpCode?.toString()}`;
+        const params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            Key: {
+                AccountNameAndSkuDis: AccountNameAndSkuDis,
+                AccountName: accountName,
+            },
+        };
+        const result = await dynamoDb.get(params).promise();
+
+        if (!result.Item) {
+            Logger.error('Item no encontrado por código de distribuidor');
+            throw new Error('Item no encontrado por código de distribuidor');
+        }
+
+        if (!result?.Item?.Active || result?.Item?.Active === false) {
+            Logger.error('Sku inactivo en distribuidor');
+            throw new Error('Sku inactivo en distribuidor');
+        }
+
+        return result?.Item?.Sku ?? erpCode;
+
+    } catch (error) {
+        Logger.error('Error al obtener distribuidor por erpCode:', error);
+        throw error;
+    }
+}
+
+/**
+ * Handler function for retrieving a distributor by ean.
+ * @param {string} accountName Name of the account
+ * @param {string} ean Ean of the product
+ * @param {boolean} skuDistributorManagement Flag to manage distributor by sku
+ * @returns {Promise<any>}
+ */
+async function getDistributorByRefId(accountName, sku, skuDistributorManagement) {
+    try {
+        if (!skuDistributorManagement || skuDistributorManagement === false) {
+            Logger.error('No se gestiona distribuidor por sku');
+            return sku;
+        }
+
+        if (!accountName || !sku) {
+            Logger.error('Error al obtener distribuidor por sku');
+            throw new Error('Error al obtener distribuidor por sku');
+        }
+
+        const params = {
+            TableName: SKU_DATA_DISTRIBUTOR_TABLE,
+            IndexName: 'SkuIndex',
+            KeyConditionExpression: '#AccountName = :AccountName AND #Sku = :Sku',
+            ExpressionAttributeNames: {
+                '#AccountName': 'AccountName',
+                '#Sku': 'Sku',
+                '#Active': 'Active'
+            },
+            ExpressionAttributeValues: {
+                ':AccountName': accountName,
+                ':Sku': sku,
+                ':Active': true
+            },
+            FilterExpression: '#Active = :Active',
+            Limit: 300,
+            Select: "ALL_PROJECTED_ATTRIBUTES",
+        };
+        let result = await dynamoDb.query(params).promise();
+        let items = result.Items;
+
+        while (result.LastEvaluatedKey) {
+            params.ExclusiveStartKey = result.LastEvaluatedKey;
+            result = await dynamoDb.query(params).promise();
+            items = items.concat(result.Items);
+        }
+
+        if (!items || items.length === 0) {
+            Logger.error('Item no encontrado por código de distribuidor');
+            throw new Error('Item no encontrado por código de distribuidor');
+        }
+
+        return items[0]?.ERPCode ?? sku;
+
+    } catch (error) {
+        Logger.error('Error al obtener distribuidor por sku:', error);
+        throw error;
+    }
+}
+
+module.exports = {
+    createDistributorCode,
+    createOrUpdateDistributorCodes,
+    updateDistributorCode,
+    deleteDistributorCode,
+    getAllDistributorsCodes,
+    getDistributorByCode,
+    getDistributorByErpCode,
+    getDistributorByRefId,
+};

package/src/functions/distributors/index.js

@@ -0,0 +1,60 @@
+
+const ApiResponse = require("../../common/utils/api-response");
+const distributor = require("./distributor");
+
+module.exports.handler= async (req,res)=>{
+  const resource= req?.resource ?? null;
+  const method= req?.httpMethod ? String(req?.httpMethod).toUpperCase() : null;
+
+  if(resource && method){
+    switch(resource){
+      case "/distributors":
+          switch(method){
+            case "POST":
+              return await distributor?.createDistributorCode(req,res);
+            case "GET":
+              return await distributor?.getAllDistributorsCodes(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/distributors/import":
+          switch(method){
+            case "POST":
+              return await distributor?.createOrUpdateDistributorCodes(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/distributors/get/{id}":
+          switch(method){
+            case "GET":
+              return await distributor?.getDistributorByCode(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/distributors/update/{id}":
+          switch(method){
+            case "PUT":
+              return await distributor?.updateDistributorCode(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/distributors/delete/{id}":
+          switch(method){
+            case "DELETE":
+              return await distributor?.deleteDistributorCode(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+
+      default:
+        return ApiResponse.response(400, {error: "error resource!."}); 
+    }
+  }else{
+    return ApiResponse.response(400, {error: "error resource!."});
+  }  
+}