d

GEMCO.Backend/.config/dotnet-tools.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "dotnet-ef": {
+      "version": "6.0.5",
+      "commands": [
+        "dotnet-ef"
+      ]
+    }
+  }
+}

GEMCO.Backend/.vscode/launch.json

@@ -0,0 +1,37 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            // Use IntelliSense to find out which attributes exist for C# debugging
+            // Use hover for the description of the existing attributes
+            // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+            "name": ".NET Core Launch (web)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/bin/Debug/net6.0.300/GEMCO.Backend.dll",
+            "args": ["run",
+            "debug"],
+            "cwd": "${workspaceFolder}",
+            "stopAtEntry": true,
+            "justMyCode": false,
+            // Enable launching a web browser when ASP.NET Core starts. For more information: https://aka.ms/VSCode-CS-LaunchJson-WebBrowser
+            "serverReadyAction": {
+                "action": "openExternally",
+                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            }
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach"
+        }
+    ]
+}

GEMCO.Backend/.vscode/tasks.json

@@ -0,0 +1,51 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/GEMCO.Backend.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/GEMCO.Backend.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/GEMCO.Backend.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "clean",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "clean",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

GEMCO.Backend/Clientes/Amazon/Contracts/IAmazonRepository.cs

@@ -0,0 +1,67 @@
+
+using GEMCO.Backend.Clientes.Amazon.DTO;
+using GEMCO.Backend.Clientes.Amazon.Model;
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.Services.Clientes.SAmazon.Models;
+
+namespace GEMCO.Backend.Clientes.Amazon.Contracts
+{
+    public interface IAmazonRepository
+    {
+        public Task<List<I2096Header>> AmazonPendingClasificationInvoiceGet();
+        /*         public Task<I2096Header> AmazonInvoiceGet(int Id); */
+        public Task<List<DTO2096Fraccion>> PartidasPendingWebServiceGet();
+        public Task<List<I2096Header>> InvoicePendingFromAmazonGet();
+        public Task<List<I2096Header>> AmazonFinishedClasificationInvoiceGet();
+        public Task<List<I2096Header>> AmazonPendingTraficInvoiceGet();
+        public Task<List<I2096Header>> AmazonLinkInvoice2TrafficGet();
+        public Task<I2096Detail> AutorizadoItemFactura(DTO2096FraccionDescripcion data);
+        public Task<I2096Detail> SetFraccionDescripcion(DTO2096FraccionDescripcion data);
+        public Task<I2096Detail> FraccionSet(DTO2096Fraccion data);
+        public Task<I2096Detail> DescripcionSet(DTO2096Descripcion data);
+        //   public Task<I2096Detail> ItemAutorizadoSet(DTO2096ItemAutorizado data);
+        public Task<IEnumerable<DTO2096Fraccion>> GetFraccionesPendientesValidar();
+        public Task<Boolean> SetFraccionPendienteValidar(int id, Boolean valor);
+        public Task<Boolean> TerminaClasificarFactura(int id);
+        public Task<IEnumerable<I2096NoPartes>> NoPartesGet(string Search);
+        public Task<I2096NoPartes> NoPartesUpdate(DTO2096NoParte data);
+        public Task<IEnumerable<I2096NoParteLog>> NoPartesLogGET(Int64 id);
+        public Task<IEnumerable<DTO2096NoParteVerificacion>> NoParteVerificacion(string Parte);
+        public Task<Boolean> ArchivoRespuestaAmazon(int Id, Int64 IdFile);
+        public Task<IEnumerable<I2096PaisClaves>> PaisClavesGet();
+        public Task<DashboardTotal> DashboardInvoicesGet(Int16 Mode);
+        public Task<DTO2096Estatus> SePuedeTerminardeClasificarFactura(int id);
+        public Task<Boolean> GeneraLogArchivoExcepciones(int IdHeader);
+        //   public Task<DTORespuesta> SePuedeTerminardeClasificarFacturaEsperandoRespuesta(int id);
+        public Task<DTO2096SightLine> SightLineSET(DTO2096SightLine data);
+        public Task<DTORespuesta> SePuedeTerminarXTraficoFactura(int id);
+        public Task<Boolean> TerminaXTraficoFactura(int id);
+
+        public Task<List<I2096Header>> AmazonInvoiceGet(int id);
+
+        public Task<IEnumerable<I2096ShipFromAddress>> AmazonShippingInfo(int id);
+        public Task<I2096Detail> CheckDetail(int id);
+        public Task<Boolean> EnviaEsperaRespuestaAmazon(int id);
+        public Task<Boolean> AssignInvoice(int IdUsuario, int IdFactura);
+        public Task<Boolean> AsignaFacturasReferencia(DTO2096LinkInvoice2Reference data);
+        public Task<Boolean> DesasociaFacturasReferencia(DTO2096LinkInvoice2Reference data);
+        public Task<Boolean> AmazonInvoiceDELETE(int Id);
+
+
+
+        public Task<Boolean> InvoiceReturnState(byte Estatus, Int64 IdFactura);
+        public Task<DTO2096Estatus> SeRecibioRespuestaDeAmazon(int id);
+        public Task<I2096Detail> TrafficFieldsUpdate(DTO2096TrafficFieldsUpdate data);
+        public Task<Boolean> InsertReferenciasSync2IONOS(String Referencia, String ArchivoZip, String ArchivoM, String Aduana, String Patente, String Pedimento, String FPago, String TipoCambio, String Clave);
+        public Task<List<DTO2096RptOperacionesPagadas>> AmazonPayedOperationsGET(String Inicio, String Fin);
+        public Task<List<DTO2096RELParteFactura>> RELParteFactruraGET(Int64 id);
+        public Task<Boolean> SETInvoiceDetail2Unchecked(int IdHeader);
+        public Task<Boolean> SETInvoiceDetailRevalidateParts(int idHeader);
+        public Task<List<DTO2096InvoiceStatus>> InvoiceStatusGET(string Invoice);
+        public Task<List<I2096Header>> InvoicePrioritySET(int Id, Boolean Prioridad);
+        public Task<String> GetACKFileById(int IDArchivoACK);
+        public Task<Boolean> AnswerFromAmazon(IAmazonAnswer data);
+        public Task<Boolean> SyncAnswers2Invoice(string Invoice);
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096CheckDetail.cs

@@ -0,0 +1,8 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096CheckDetail
+    {
+        public int Id { get; set; } = 0;
+        public Boolean Check { get; set; } = false;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096Descripcion.cs

@@ -0,0 +1,10 @@
+
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096Descripcion
+    {
+        public int Id { get; set; } = 0;
+        public string Descripcion { get; set; } = null!;
+        public byte ConfirmaDescripcion { set; get; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096Estatus.cs

@@ -0,0 +1,10 @@
+
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096Estatus
+    {
+        public int Code { get; set; } = 0;
+        public string Respuesta { get; set; } = null!;
+        public int Estatus { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096Fraccion.cs

@@ -0,0 +1,10 @@
+
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096Fraccion
+    {
+        public int Id { get; set; } = 0;
+        public string Fraccion { get; set; } = null!;
+        public byte ConfirmaFraccion { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096FraccionDescripcion.cs

@@ -0,0 +1,11 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096FraccionDescripcion
+    {
+        public int Id { get; set; } = 0;
+        public string Fraccion { get; set; } = null!;
+        public string CumplimientoNormativo { get; set; } = null!;
+        public string Comentarios { get; set; } = null!;
+        public string DescripcionGEMCO { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096InvoiceStatus.cs

@@ -0,0 +1,26 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096InvoiceStatus
+    {
+        public int Id { get; set; } = 0;
+        public String Referencia { get; set; } = string.Empty;
+        public String CommercialInvoiceDate { get; set; } = string.Empty;
+        public String InvoiceNumber { get; set; } = string.Empty;
+        public String Incoterms { get; set; } = string.Empty;
+        public String TotalInvoiceQuantityUnitOfMeasure { get; set; } = string.Empty;
+        public int TotalInvoiceQuantity { get; set; } = 0;
+        public String TotalInvoiceWeightUnitOfMeasure { get; set; } = string.Empty;
+        public double TotalInvoiceWeight { get; set; } = 0;
+        public String TotalInvoiceValueChargeOrAllowance { get; set; } = string.Empty;
+        public String TotalInvoiceValueCurrencyISOCode { get; set; } = string.Empty;
+        public double TotalInvoiceValueMonetaryAmount { get; set; } = 0;
+        public String FPago { get; set; } = string.Empty;
+        public String Patente { get; set; } = string.Empty;
+        public String Aduana { get; set; } = string.Empty;
+        public String Pedimento { get; set; } = string.Empty;
+        public String Estatus { get; set; } = string.Empty;
+        public int IDArchivoACK { get; set; } = 0;
+        public String ArchivoACK { get; set; } = string.Empty;
+        public String FHArchivoACK { get; set; } = string.Empty;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096ItemAutorizado.cs

@@ -0,0 +1,10 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096ItemAutorizado
+    {
+        public int Id { get; set; } = 0;
+        public Boolean Autorizado { get; set; } = false;
+        public string RequerimientoNormativo { get; set; } = null!;
+        public string Comentarios { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096LinkInvoice2Reference.cs

@@ -0,0 +1,10 @@
+using System.Numerics;
+
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096LinkInvoice2Reference
+    {
+        public string Referencia { get; set; } = null!;
+        public IEnumerable<int> Facturas { get; set; } = new List<int> { };
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096NoParte.cs

@@ -0,0 +1,11 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096NoParte
+    {
+        public int Id { get; set; } = 0;
+        public string FraccionGEMCO { get; set; } = null!;
+        public string SubdivisionGEMCO { get; set; } = null!;
+        public string DescripcionAgenteAduanal { get; set; } = null!;
+        public int Usuario { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096NoParteVerificacion.cs

@@ -0,0 +1,14 @@
+
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096NoParteVerificacion
+    {
+        public string Factura { get; set; } = null!;
+        public string FFactura { get; set; } = null!;
+        public string Referencia { get; set; } = null!;
+        public string Patente { get; set; } = null!;
+        public string Aduana { get; set; } = null!;
+        public string Pedimento { get; set; } = null!;
+        public string FPago { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096RELParteFactura.cs

@@ -0,0 +1,8 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096RELParteFactura
+    {
+        public string Parte { set; get; } = string.Empty;
+        public string Facturas { set; get; } = string.Empty;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096ReferenciasSync2IONOS.cs

@@ -0,0 +1,13 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096ReferenciasSync2IONOS
+    {
+        public string archivoM { get; set; } = null!;
+        public string aduana { get; set; } = null!;
+        public string patente { get; set; } = null!;
+        public string pedimento { get; set; } = null!;
+        public string fPago { get; set; } = null!;
+        public string tipoCambio { get; set; } = null!;
+        public List<IFormFile> files { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096RptOperacionesPagadas.cs

@@ -0,0 +1,25 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096RptOperacionesPagadas
+    {
+        public int Id { get; set; } = 0;
+        public String Referencia { get; set; } = string.Empty;
+        public String CommercialInvoiceDate { get; set; } = string.Empty;
+        public String InvoiceNumber { get; set; } = string.Empty;
+        public String Incoterms { get; set; } = string.Empty;
+        public String TotalInvoiceQuantityUnitOfMeasure { get; set; } = string.Empty;
+        public int TotalInvoiceQuantity { get; set; } = 0;
+        public String TotalInvoiceWeightUnitOfMeasure { get; set; } = string.Empty;
+        public double TotalInvoiceWeight { get; set; } = 0;
+        public String TotalInvoiceValueChargeOrAllowance { get; set; } = string.Empty;
+        public String TotalInvoiceValueCurrencyISOCode { get; set; } = string.Empty;
+        public double TotalInvoiceValueMonetaryAmount { get; set; } = 0;
+        public String FPago { get; set; } = string.Empty;
+        public String Patente { get; set; } = string.Empty;
+        public String Aduana { get; set; } = string.Empty;
+        public String Pedimento { get; set; } = string.Empty;
+        public int IDArchivoACK { get; set; } = 0;
+        public String ArchivoACK { get; set; } = string.Empty;
+        public String FHArchivoACK { get; set; } = string.Empty;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096SightLine.cs

@@ -0,0 +1,12 @@
+using DocumentFormat.OpenXml.Office2021.PowerPoint.Comment;
+using DocumentFormat.OpenXml.Presentation;
+
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096SightLine
+    {
+        public int Id { get; set; } = 0;
+        public Boolean SightLine { get; set; } = false;
+        public string ComentariosSightLine { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/DTO/DTO2096TrafficFieldsUpdate.cs

@@ -0,0 +1,10 @@
+namespace GEMCO.Backend.Clientes.Amazon.DTO
+{
+    public class DTO2096TrafficFieldsUpdate
+    {
+        public Int64 Id { get; set; } = 0;
+        public string UnitMeasure { get; set; } = string.Empty;
+        public float UnitOfMeasure { get; set; } = 0;
+        public float UnitCost { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096Detail.cs

@@ -0,0 +1,50 @@
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096Detail
+    {
+        public Int64 Id { get; set; } = 0;
+        public int IdHeader { get; set; } = 0;
+        public string InvoiceNumber { get; set; } = null!;
+        public string AmazonShipmentReferenceId { get; set; } = null!;
+        public int Partida { get; set; } = 0;
+        public string TrailerId { get; set; } = null!;
+        public string ItemId { get; set; } = null!;
+        public string ItemIdType { get; set; } = null!;
+        public string ItemDescription { get; set; } = null!;
+        public string PedimentoDescription { get; set; } = null!;
+        public string DestinationHTSCode { get; set; } = null!;
+        public byte ValidaFraccionOriginal { get; set; } = 0;
+        public byte ConfirmaFraccion { get; set; } = 0;
+        public string FraccionGEMCO { get; set; } = null!;
+        public byte ConfirmaDescripcion { get; set; } = 0;
+        public string DescripcionGEMCO { get; set; } = null!;
+        public string SourceHTSCode { get; set; } = null!;
+        public string ECCN { get; set; } = null!;
+        public string LicEx { get; set; } = null!;
+        public string CountryOfOrigin { get; set; } = null!;
+        public string ProductGroup { get; set; } = null!;
+        public string UPC { get; set; } = null!;
+        public string Brand { get; set; } = null!;
+        public string Model { get; set; } = null!;
+        public string ItemQuantityUnitOfMeasure { get; set; } = null!;
+        public int Quantity { get; set; } = 0;
+        public string NetWeightUnitOfMeasure { get; set; } = null!;
+        public double WeightValue { get; set; } = 0;
+        public string ActualUnitCostChargeOrAllowance { get; set; } = null!;
+        public string ActualUnitCostCurrencyISOCode { get; set; } = null!;
+        public double ActualUnitCostMonetaryAmount { get; set; } = 0;
+        public string TotalUnitValueChargeOrAllowance { get; set; } = null!;
+        public string TotalUnitValueCurrencyISOCode { get; set; } = null!;
+        public double TotalUnitValueMonetaryAmount { get; set; } = 0;
+        public string Archivo { get; set; } = null!;
+        public string FCreacion { get; set; } = null!;
+        public Int16 Estatus { get; set; } = 0;
+        public Boolean Autorizado { get; set; } = false;
+        public string CumplimientoNormativo { get; set; } = null!;
+        public string Comentarios { get; set; } = null!;
+        public Boolean SightLine { get; set; } = false;
+        public string ComentariosSightLine { get; set; } = null!;
+        public Boolean Checked { get; set; } = false;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096Header.cs

@@ -0,0 +1,34 @@
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096Header
+    {
+        public int Id { get; set; } = 0;
+        public string Referencia { get; set; } = null!;
+        public string CommercialInvoiceDate { get; set; } = null!;
+        public string InvoiceNumber { get; set; } = null!;
+        public string Name { get; set; } = null!;
+        public string TrailerNumber { get; set; } = null!;
+        public string TrailerId { get; set; } = null!;
+        public string PorOfLoading { get; set; } = null!;
+        public string PortOfEntry { get; set; } = null!;
+        public string PaymentsTerms { get; set; } = null!;
+        public string Incoterms { get; set; } = null!;
+        public string HAWB { get; set; } = null!;
+        public string TotalInvoiceQuantityUnitOfMeasure { get; set; } = null!;
+        public int TotalInvoiceQuantity { get; set; } = 0;
+        public string TotalInvoiceWeightUnitOfMeasure { get; set; } = null!;
+        public double TotalInvoiceWeight { get; set; } = 0;
+        public string TotalInvoiceValueChargeOrAllowance { get; set; } = null!;
+        public string TotalInvoiceValueCurrencyISOCode { get; set; } = null!;
+        public double TotalInvoiceValueMonetaryAmount { get; set; } = 0;
+        public string FootNote { get; set; } = null!;
+        public string Archivo { get; set; } = null!;
+        public string FCreacion { get; set; } = null!;
+        public int Clasificador { get; set; } = 0!;
+        public Byte NoVuelta { get; set; } = 0;
+        public Int16 Estatus { get; set; } = 0;
+        public Boolean max { get; set; } = false;
+        public Boolean Urgente { get; set; } = false;
+        public List<I2096Detail> Detail { get; set; } = new List<I2096Detail>();
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096ListaIDs.cs

@@ -0,0 +1,7 @@
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096ListaIDs
+    {
+        public int id { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096NoParteLog.cs

@@ -0,0 +1,18 @@
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096NoParteLog
+    {
+        public Int64 Id { get; set; } = 0;
+        public Int64 IdCatNoParte { get; set; } = 0;
+        public string NoParte { get; set; } = null!;
+        public string FraccionGEMCO { get; set; } = null!;
+        public string SubdivisionGEMCO { get; set; } = null!;
+        public string DescripcionAgenteAduanal { get; set; } = null!;
+        public string FraccionOriginal { get; set; } = null!;
+        public string SubdivisionOriginal { get; set; } = null!;
+        public string DescripcionOriginal { get; set; } = null!;
+        public int Usuario { get; set; } = 0;
+        public string FHCreacion { get; set; } = null!;
+        public string sUsuario { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096NoPartes.cs

@@ -0,0 +1,23 @@
+
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096NoPartes
+    {
+        public int id { get; set; } = 0;
+        public int ClaveCliente { get; set; } = 0;
+        public string Parte { get; set; } = null!;
+        public int ClaveProveedor { get; set; } = 0;
+        public byte TipoOperacion { get; set; } = 0;
+        public string Fraccion { get; set; } = null!;
+        public string Subdivision { get; set; } = null!;
+        public string DescripcionFactura { get; set; } = null!;
+        public string DescripcionAgenteAduanal { get; set; } = null!;
+        public string PaisOrigen { get; set; } = null!;
+        public string UnidadMedidaFactura { get; set; } = null!;
+        public string UnidadMedidaCOVE { get; set; } = null!;
+        public string FHActualizacion { get; set; } = null!;
+        public int UsuarioActualizacion { get; set; } = 0;
+        public byte Activo { get; set; } = 0;
+
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096PaisClaves.cs

@@ -0,0 +1,9 @@
+
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096PaisClaves
+    {
+        public string PaisNom { get; set; } = null!;
+        public string Clave_a3 { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/Model/I2096ShipFromAddress.cs

@@ -0,0 +1,19 @@
+namespace GEMCO.Backend.Clientes.Amazon.Model
+{
+    public class I2096ShipFromAddress
+    {
+        public int Id { get; set; } = 0;
+        public int IdHeader { get; set; } = 0;
+        public string InvoiceNumber { get; set; } = null!;
+        public string AddressType { get; set; } = null!;
+        public string Name { get; set; } = null!;
+        public string AddressLine1 { get; set; } = null!;
+        public string City { get; set; } = null!;
+        public string StateProvince { get; set; } = null!;
+        public string Zip { get; set; } = null!;
+        public string CountryCode { get; set; } = null!;
+        public string CountryName { get; set; } = null!;
+        public string Archivo { get; set; } = null!;
+        public string FCreacion { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Amazon/Repository/AmazonRepository.cs

@@ -0,0 +1,705 @@
+using System.Data;
+using Dapper;
+using GEMCO.Backend.Context;
+using GEMCO.Backend.Clientes.Amazon.Model;
+using GEMCO.Backend.Clientes.Amazon.Contracts;
+using GEMCO.Backend.Clientes.Amazon.DTO;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.Services.Clientes.SAmazon.Models;
+
+namespace GEMCO.Backend.Clientes.Amazon.Repository
+{
+    public class AmazonRepository : IAmazonRepository
+    {
+
+        private readonly DapperContext _context;
+        public AmazonRepository(DapperContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<List<I2096Header>> AmazonPendingClasificationInvoiceGet()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT id FROM [Clientes.Amazon.Invoice.Header] WHERE Estatus in (0,1)";
+            var rows = connection.Query<I2096ListaIDs>(sql);
+            connection.Close();
+
+            List<I2096Header> data = new List<I2096Header>();
+            foreach (var row in rows)
+            {
+                var parameters = new DynamicParameters();
+                parameters.Add("@id", row.id, DbType.Int64, ParameterDirection.Input);
+                var query = "SELECT  a.Id, a.Referencia, a.commercialInvoiceDate, a.InvoiceNumber, a.TrailerNumber, a.TrailerId, a.PorOfLoading, a.PaymentsTerms, a.Incoterms, " +
+                "a.HAWB, a.TotalInvoiceQuantityUnitOfMeasure, a.TotalInvoiceQuantity, a.TotalInvoiceWeightUnitOfMeasure, a.TotalInvoiceWeight, a.TotalInvoiceValueChargeOrAllowance, " +
+                "a.TotalInvoiceValueCurrencyISOCode, a.TotalInvoiceValueMonetaryAmount, a.FootNote,  a.Archivo, a.FCreacion, a.Clasificador,  a.NoVuelta, a.Estatus, b.Name, a.Urgente " +
+                "FROM [Clientes.Amazon.Invoice.Header] a JOIN[Clientes.Amazon.Invoice.ShipFromAddress] b on a.id = b.IdHeader WHERE a.Id =@Id and b.AddressType = 'SHIPPER';" +
+                         "SELECT Id, IdHeader, InvoiceNumber, AmazonShipmentReferenceId, Partida, TrailerId, ItemId, ItemIdType, ItemDescription, " +
+                        "PedimentoDescription, DestinationHTSCode, ValidaFraccionOriginal, ConfirmaFraccion, FraccionGEMCO, ConfirmaDescripcion, " +
+                        "DescripcionGEMCO, SourceHTSCode, ECCN, LicEx, CountryOfOrigin, ProductGroup, UPC, Brand, Model, ItemQuantityUnitOfMeasure, " +
+                        "Quantity, NetWeightUnitOfMeasure, WeightValue, ActualUnitCostChargeOrAllowance, ActualUnitCostCurrencyISOCode, ActualUnitCostMonetaryAmount, " +
+                        "TotalUnitValueChargeOrAllowance, TotalUnitValueCurrencyISOCode, TotalUnitValueMonetaryAmount, Archivo, FCreacion, Estatus, Autorizado," +
+                        "CumplimientoNormativo, Comentarios, SightLine, ComentariosSightLine, Checked, Activo FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id ORDER BY DestinationHTSCode";
+                /* var query = "SELECT  a.*, b.Name FROM [Clientes.Amazon.Invoice.Header] a JOIN[Clientes.Amazon.Invoice.ShipFromAddress] b on a.id = b.IdHeader WHERE a.Id =@Id and b.AddressType = 'SHIPPER';" +
+                         "SELECT * FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id ORDER BY DestinationHTSCode"; */
+                using (var connection2 = _context.CreateConnection())
+                using (var multi = await connection2.QueryMultipleAsync(query, parameters))
+                {
+                    var result = await multi.ReadSingleOrDefaultAsync<I2096Header>();
+                    if (result != null)
+                    {
+                        var detail = (await multi.ReadAsync<I2096Detail>()).ToList();
+                        if (detail != null)
+                        {
+                            result.Detail = detail;
+                            data.Add(result);
+                        }
+                    }
+                }
+            }
+            return data;
+        }
+
+        public async Task<List<DTO2096Fraccion>> PartidasPendingWebServiceGet()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT Id, DestinationHTSCode as Fraccion, ValidacionWebService as ConfirmaFraccion FROM [Clientes.Amazon.Invoice.Detail] WHERE ValidacionWebService=0";
+            var rows = await connection.QueryAsync<DTO2096Fraccion>(sql);
+            connection.Close();
+            return rows.ToList();
+        }
+
+        public async Task<List<I2096Header>> InvoicePendingFromAmazonGet()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT id FROM [Clientes.Amazon.Invoice.Header] WHERE Estatus=-1 ORDER BY id";
+            var rows = connection.Query<I2096ListaIDs>(sql);
+            connection.Close();
+
+            List<I2096Header> data = new List<I2096Header>();
+            foreach (var row in rows)
+            {
+                var query = "SELECT  a.*, b.Name FROM [Clientes.Amazon.Invoice.Header] a JOIN[Clientes.Amazon.Invoice.ShipFromAddress] b on a.id = b.IdHeader WHERE a.Id =@Id and b.AddressType = 'SHIPPER' ORDER BY a.id;" +
+                         "SELECT * FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id";
+                using (var connection2 = _context.CreateConnection())
+                using (var multi = await connection2.QueryMultipleAsync(query, new
+                {
+                    id = row.id
+                }))
+                {
+                    var result = await multi.ReadSingleOrDefaultAsync<I2096Header>();
+                    if (result != null)
+                    {
+                        result.Detail = (await multi.ReadAsync<I2096Detail>()).ToList();
+                        data.Add(result);
+                    }
+                }
+            }
+            return data;
+        }
+
+        public async Task<List<I2096Header>> AmazonFinishedClasificationInvoiceGet()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT id FROM [Clientes.Amazon.Invoice.Header] WHERE Estatus=2";
+            var rows = connection.Query<I2096ListaIDs>(sql);
+            connection.Close();
+
+            List<I2096Header> data = new List<I2096Header>();
+            foreach (var row in rows)
+            {
+                var query = "SELECT * FROM [Clientes.Amazon.Invoice.Header] WHERE Id = @Id;" +
+                         "SELECT * FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id";
+                using (var connection2 = _context.CreateConnection())
+                using (var multi = await connection2.QueryMultipleAsync(query, new
+                {
+                    id = row.id
+                }))
+                {
+                    var result = await multi.ReadSingleOrDefaultAsync<I2096Header>();
+                    if (result != null)
+                    {
+                        result.Detail = (await multi.ReadAsync<I2096Detail>()).ToList();
+                        data.Add(result);
+                    }
+                }
+            }
+            return data;
+        }
+
+        public async Task<List<I2096Header>> AmazonPendingTraficInvoiceGet()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT id FROM [Clientes.Amazon.Invoice.Header] WHERE Estatus=3";
+            var rows = connection.Query<I2096ListaIDs>(sql);
+            connection.Close();
+
+            List<I2096Header> data = new List<I2096Header>();
+            foreach (var row in rows)
+            {
+                var query = "SELECT * FROM [Clientes.Amazon.Invoice.Header] WHERE Id = @Id;" +
+                         "SELECT * FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id";
+                using (var connection2 = _context.CreateConnection())
+                using (var multi = await connection2.QueryMultipleAsync(query, new
+                {
+                    id = row.id
+                }))
+                {
+                    var result = await multi.ReadSingleOrDefaultAsync<I2096Header>();
+                    if (result != null)
+                    {
+                        result.Detail = (await multi.ReadAsync<I2096Detail>()).ToList();
+                        data.Add(result);
+                    }
+                }
+            }
+            return data;
+        }
+
+        public async Task<List<I2096Header>> AmazonLinkInvoice2TrafficGet()
+        {
+            var query = "[Clientes.Amazon.Invoice.Finished]";
+            using var connection = _context.CreateConnection();
+            var rows = await connection.QueryAsync<I2096ListaIDs>(query, new { }, commandType: CommandType.StoredProcedure);
+
+            List<I2096Header> data = new List<I2096Header>();
+            foreach (var row in rows.ToList())
+            {
+                var subquery = "SELECT * FROM [Clientes.Amazon.Invoice.Header] WHERE Id = @Id;" +
+                         "SELECT * FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id";
+                using (var connection2 = _context.CreateConnection())
+                using (var multi = await connection2.QueryMultipleAsync(subquery, new
+                {
+                    id = row.id
+                }))
+                {
+                    var result = await multi.ReadSingleOrDefaultAsync<I2096Header>();
+                    if (result != null)
+                    {
+                        result.Detail = (await multi.ReadAsync<I2096Detail>()).ToList();
+                        data.Add(result);
+                    }
+                }
+            }
+            return data;
+        }
+
+        public async Task<List<DTO2096RptOperacionesPagadas>> AmazonPayedOperationsGET(String Inicio, String Fin)
+        {
+            var query = "[Clientes.Amazon.Invoice.PayedOperations.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096RptOperacionesPagadas>(query, new
+            {
+                @Inicio,
+                @Fin
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+
+        public async Task<Boolean> AmazonInvoiceDELETE(int Id)
+        {
+            var query = "[Clientes.Amazon.Invoice.Header.Delete]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync(query, new
+            {
+                @Id
+            },
+                commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<I2096Detail> SetFraccionDescripcion(DTO2096FraccionDescripcion data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.FraccionDescripcion.Set]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096Detail>(query, new
+            {
+                @data.Id,
+                @data.Fraccion,
+                @data.CumplimientoNormativo,
+                @data.Comentarios,
+                @data.DescripcionGEMCO
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.FirstOrDefault(new I2096Detail());
+        }
+
+        public async Task<I2096Detail> FraccionSet(DTO2096Fraccion data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Fraccion.Set]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096Detail>(query, new
+            {
+                @data.Id,
+                @data.Fraccion,
+                @data.ConfirmaFraccion
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.FirstOrDefault(new I2096Detail());
+        }
+
+        public async Task<I2096Detail> DescripcionSet(DTO2096Descripcion data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Descripcion.Set]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096Detail>(query, new
+            {
+                @data.Id,
+                @data.Descripcion,
+                @data.ConfirmaDescripcion
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.FirstOrDefault(new I2096Detail());
+        }
+
+        public async Task<I2096Detail> AutorizadoItemFactura(DTO2096FraccionDescripcion data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Autorizado.Set]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096Detail>(query, new
+            {
+                @data.Id,
+                @data.Fraccion,
+                @data.CumplimientoNormativo,
+                @data.Comentarios,
+                @data.DescripcionGEMCO
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.FirstOrDefault(new I2096Detail());
+        }
+
+        public async Task<IEnumerable<DTO2096Fraccion>> GetFraccionesPendientesValidar()
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Fracciones.Iniciales.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096Fraccion>(query, new { }, commandType: CommandType.StoredProcedure);
+            return entrada;
+        }
+
+        public async Task<Boolean> SetFraccionPendienteValidar(int id, Boolean valor)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Fracciones.Iniciales.Set]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096Fraccion>(query, new
+            {
+                @id,
+                @valor
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<Boolean> TerminaClasificarFactura(int id)
+        {
+            var query = "[Clientes.Amazon.Invoice.Clasification.Finish]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096Fraccion>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<Boolean> EnviaEsperaRespuestaAmazon(int id)
+        {
+            var query = "[Clientes.Amazon.Invoice.Clasification.Send2Waiting]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096Fraccion>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<IEnumerable<I2096NoPartes>> NoPartesGet(string Search)
+        {
+            var query = "[Clientes.Amazon.Invoice.NoPartes.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096NoPartes>(query, new { @Search }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+
+        public async Task<I2096NoPartes> NoPartesUpdate(DTO2096NoParte data)
+        {
+            var query = "[Clientes.Amazon.Invoice.NoPartes.Update]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096NoPartes>(query, new
+            {
+                @data.Id,
+                @data.FraccionGEMCO,
+                @data.SubdivisionGEMCO,
+                @data.DescripcionAgenteAduanal,
+                @data.Usuario
+            }, commandType: CommandType.StoredProcedure);
+            return entrada.FirstOrDefault(new I2096NoPartes());
+        }
+
+        public async Task<IEnumerable<I2096NoParteLog>> NoPartesLogGET(Int64 id)
+        {
+            var query = "[Clientes.Amazon.Invoice.NoPartes.Log.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096NoParteLog>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+
+        public async Task<IEnumerable<DTO2096NoParteVerificacion>> NoParteVerificacion(string Parte)
+        {
+            var query = "[Clientes.Amazon.Invoice.NoPartes.Verificacion.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096NoParteVerificacion>(query, new { @Parte }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+
+        public async Task<IEnumerable<I2096PaisClaves>> PaisClavesGet()
+        {
+            var query = "[Catalogo.PaisClaves.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096PaisClaves>(query, new { }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+
+        public async Task<DashboardTotal> DashboardInvoicesGet(Int16 Mode)
+        {
+            var query = "[Dashboard.Clasificacion.Amazon.Invoices.Finished]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DashboardTotal>(query, new { @Mode }, commandType: CommandType.StoredProcedure);
+            return entrada.First();
+        }
+
+        public async Task<DTO2096Estatus> SePuedeTerminardeClasificarFactura(int id)
+        {
+            var query = "SELECT  dbo.IsAmazonInvoiceClasificationReady2Finish(@id)"; // This is a function, not a stored procedure
+            using var connection = _context.CreateConnection();
+            var respuesta = await connection.QueryAsync<Int16>(query, new { @id }, commandType: CommandType.Text);
+            DTO2096Estatus answer = new DTO2096Estatus();
+            answer.Code = 200;
+            answer.Estatus = respuesta.First();
+            if (answer.Estatus == 0)
+            {
+                answer.Respuesta = "Factura incompleta, verifique que todas las partidas tengan la fraccion y una descripcion";
+            }
+            if (answer.Estatus == 1)
+            {
+                answer.Respuesta = "Factura lista, contiene por lo menos una partida diferente, se genera archivo de excepciones";
+            }
+            if (answer.Estatus == 2)
+            {
+                answer.Respuesta = "Factura lista, se genera excel de numero de partes";
+            }
+            return answer;
+        }
+
+        public async Task<Boolean> GeneraLogArchivoExcepciones(int IdHeader)
+        {
+            var query = "[Clientes.Amazon.Invoice.ExceptionsFile.Log]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync(query, new
+            {
+                @IdHeader
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<DTO2096Estatus> SeRecibioRespuestaDeAmazon(int id)
+        {
+            var query = "SELECT  dbo.IsAmazonInvoiceClasificationAnswerRecived(@id)"; // This is a function, not a stored procedure
+            using var connection = _context.CreateConnection();
+            var respuesta = await connection.QueryAsync<Boolean>(query, new { @id }, commandType: CommandType.Text);
+            DTO2096Estatus answer = new DTO2096Estatus();
+            answer.Code = 200;
+            answer.Estatus = respuesta.First() ? 1 : 0;
+            if (answer.Estatus == 0)
+            {
+                answer.Respuesta = "Factura incompleta, verifique que todas las partidas tengan la autorizacion de Amazon";
+            }
+            else if (answer.Estatus == 1)
+            {
+                answer.Respuesta = "Factura lista para pasarse al siguiente proceso";
+            }
+
+            return answer;
+        }
+
+        public async Task<Boolean> ArchivoRespuestaAmazon(int Id, Int64 IdFile)
+        {
+            var query = "[Clientes.Amazon.Invoice.ExceptionsFile.Arrived]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I2096NoParteLog>(query, new
+            {
+                @Id,
+                @IdFile
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<DTO2096SightLine> SightLineSET(DTO2096SightLine data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.SightLine.Set]"; // This is a function, not a stored procedure
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096SightLine>(query, new { @data.Id, @data.SightLine, @data.ComentariosSightLine }, commandType: CommandType.StoredProcedure);
+            return entrada.FirstOrDefault(new DTO2096SightLine());
+        }
+
+        public async Task<DTORespuesta> SePuedeTerminarXTraficoFactura(int id)
+        {
+            var query = "SELECT  dbo.IsAmazonInvoiceTraficReady(@id)"; // This is a function, not a stored procedure
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<Boolean>(query, new { @id }, commandType: CommandType.Text);
+            DTORespuesta answer = new DTORespuesta();
+            answer.code = 200;
+            answer.respuesta = entrada.First() == true ? "Factura lista" : "Factura incompleta";
+            return answer;
+        }
+
+        public async Task<Boolean> TerminaXTraficoFactura(int id)
+        {
+            var query = "[Clientes.Amazon.Invoice.Traffic.Finish]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096Fraccion>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<List<I2096Header>> AmazonInvoiceGet(int id)
+        {
+            using var connection = _context.CreateConnection();
+            List<I2096Header> data = new List<I2096Header>();
+            var query = "SELECT  a.Id, a.Referencia, a.commercialInvoiceDate, a.InvoiceNumber, a.TrailerNumber, a.TrailerId, a.PorOfLoading, a.PaymentsTerms, a.Incoterms, " +
+      "a.HAWB, a.TotalInvoiceQuantityUnitOfMeasure, a.TotalInvoiceQuantity, a.TotalInvoiceWeightUnitOfMeasure, a.TotalInvoiceWeight, a.TotalInvoiceValueChargeOrAllowance, " +
+      "a.TotalInvoiceValueCurrencyISOCode, a.TotalInvoiceValueMonetaryAmount, a.FootNote,  a.Archivo, a.FCreacion, a.Clasificador,  a.NoVuelta, a.Estatus, b.Name, a.Urgente " +
+      "FROM [Clientes.Amazon.Invoice.Header] a JOIN[Clientes.Amazon.Invoice.ShipFromAddress] b on a.id = b.IdHeader WHERE a.Id =@Id and b.AddressType = 'SHIPPER';" +
+               "SELECT Id, IdHeader, InvoiceNumber, AmazonShipmentReferenceId, Partida, TrailerId, ItemId, ItemIdType, ItemDescription, " +
+              "PedimentoDescription, DestinationHTSCode, ValidaFraccionOriginal, ConfirmaFraccion, FraccionGEMCO, ConfirmaDescripcion, " +
+              "DescripcionGEMCO, SourceHTSCode, ECCN, LicEx, CountryOfOrigin, ProductGroup, UPC, Brand, Model, ItemQuantityUnitOfMeasure, " +
+              "Quantity, NetWeightUnitOfMeasure, WeightValue, ActualUnitCostChargeOrAllowance, ActualUnitCostCurrencyISOCode, ActualUnitCostMonetaryAmount, " +
+              "TotalUnitValueChargeOrAllowance, TotalUnitValueCurrencyISOCode, TotalUnitValueMonetaryAmount, Archivo, FCreacion, Estatus, Autorizado," +
+              "CumplimientoNormativo, Comentarios, SightLine, ComentariosSightLine, Checked, Activo FROM [Clientes.Amazon.Invoice.Detail] WHERE IdHeader = @Id ORDER BY DestinationHTSCode, ItemID";
+            using (var connection2 = _context.CreateConnection())
+            using (var multi = await connection2.QueryMultipleAsync(query, new { @id }))
+            {
+                var result = await multi.ReadSingleOrDefaultAsync<I2096Header>();
+                if (result != null)
+                {
+                    result.Detail = (await multi.ReadAsync<I2096Detail>()).ToList();
+                    data.Add(result);
+                }
+            }
+            return data;
+        }
+
+        public async Task<IEnumerable<I2096ShipFromAddress>> AmazonShippingInfo(int id)
+        {
+            var query = "[Clientes.Amazon.Invoice.ShipFromAddress.Get]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<I2096ShipFromAddress>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return result;
+        }
+
+        public async Task<I2096Detail> CheckDetail(int id)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Check]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<I2096Detail>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return result.FirstOrDefault(new I2096Detail());
+        }
+
+        public async Task<Boolean> AssignInvoice(int IdUsuario, int IdFactura)
+        {
+            var query = "[Clientes.Amazon.Invoice.Assign.Clasificator]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<I2096Header>(query, new
+            {
+                @IdUsuario,
+                @IdFactura
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<Boolean> AsignaFacturasReferencia(DTO2096LinkInvoice2Reference data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Assign.Reference]";
+            using var connection = _context.CreateConnection();
+            foreach (int IdFactura in data.Facturas)
+            {
+                var result = await connection.QueryAsync(query, new
+                {
+                    @IdFactura,
+                    @data.Referencia
+                }, commandType: CommandType.StoredProcedure);
+
+            }
+            return true;
+        }
+
+        public async Task<Boolean> DesasociaFacturasReferencia(DTO2096LinkInvoice2Reference data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Unassign.Reference]";
+            using var connection = _context.CreateConnection();
+            foreach (int IdFactura in data.Facturas)
+            {
+                var result = await connection.QueryAsync(query, new
+                {
+                    @IdFactura,
+                    @data.Referencia
+                }, commandType: CommandType.StoredProcedure);
+
+            }
+            return true;
+        }
+
+        public async Task<Boolean> InvoiceReturnState(byte Estatus, Int64 IdFactura)
+        {
+            var query = "[Clientes.Amazon.Invoice.Return.State]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<I2096Header>(query, new
+            {
+                @Estatus,
+                @IdFactura
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<I2096Detail> TrafficFieldsUpdate(DTO2096TrafficFieldsUpdate data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Traffic.Fields.Update]";
+            using var connection = _context.CreateConnection();
+            var parameters = new DynamicParameters();
+            parameters.Add("@id", data.Id, DbType.Int64, ParameterDirection.Input);
+            parameters.Add("@UnitMeasure", data.UnitMeasure, DbType.String, ParameterDirection.Input);
+            parameters.Add("@UnitOfMeasure", data.UnitOfMeasure, DbType.Double, ParameterDirection.Input, 10);
+            parameters.Add("@UnitCost", data.UnitCost, DbType.Double, ParameterDirection.Input, 10);
+            var result = await connection.QueryAsync<I2096Detail>(query, parameters, commandType: CommandType.StoredProcedure);
+            return result.First();
+        }
+
+        public async Task<Boolean> InsertReferenciasSync2IONOS(String Referencia, String ArchivoZip, String ArchivoM, String Aduana, String Patente, String Pedimento, String FPago, String TipoCambio, String Clave)
+        {
+            var query = "[Clientes.Amazon.Referencias.Sync2IONOS.Insert]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO2096Fraccion>(query, new
+            {
+                @Referencia,
+                @ArchivoZip,
+                @ArchivoM,
+                @Aduana,
+                @Patente,
+                @Pedimento,
+                @FPago,
+                @TipoCambio,
+                @Clave
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<List<DTO2096RELParteFactura>> RELParteFactruraGET(Int64 id)
+        {
+            var query = "[Clientes.Amazon.Invoice.ExceptionsFile.REL.Facturas.Get]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<DTO2096RELParteFactura>(query, new
+            {
+                @id
+            }, commandType: CommandType.StoredProcedure);
+            return result.ToList();
+        }
+
+        public async Task<Boolean> SETInvoiceDetail2Unchecked(int idHeader)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Correlacion.PartesGEMCO.UnCheked]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync(query, new
+            {
+                @idHeader
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<Boolean> SETInvoiceDetailRevalidateParts(int idHeader)
+        {
+            var query = "[Clientes.Amazon.Invoice.Detail.Correlacion.PartesGEMCO.Revalidate]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync(query, new
+            {
+                @idHeader
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<List<DTO2096InvoiceStatus>> InvoiceStatusGET(String Invoice)
+        {
+            var query = "[Clientes.Amazon.Invoice.Status.Get]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<DTO2096InvoiceStatus>(query, new
+            {
+                @Invoice
+            }, commandType: CommandType.StoredProcedure);
+            return result.ToList();
+        }
+
+
+        public async Task<List<I2096Header>> InvoicePrioritySET(int Id, Boolean Prioridad)
+        {
+            var query = "[Clientes.Amazon.Invoice.Priority.Set]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync(query, new
+            {
+                @Id,
+                @Prioridad
+            }, commandType: CommandType.StoredProcedure);
+            return await AmazonInvoiceGet(Id);
+        }
+
+
+        public async Task<string> GetACKFileById(int IDArchivoACK)
+        {
+            using (var connection = _context.CreateConnection())
+            {
+                var sql = @"SELECT replace(Archivo,'ACKs','ACKs\'+Referencia) AS Archivo FROM [Clientes.Amazon.ACKFiles] WHERE id=" + IDArchivoACK;
+                var result = await connection.QueryFirstAsync<string>(sql);
+                return result;
+            }
+        }
+
+        public async Task<Boolean> AnswerFromAmazon(IAmazonAnswer data)
+        {
+            var query = "[Clientes.Amazon.Invoice.Answers.Append]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync(query, new
+            {
+                @data.FechaSolicitud,
+                @data.VRIDFactura,
+                @data.ASIN,
+                @data.HTSFactura,
+                @data.HTSSugerido,
+                @data.HTSAmazon,
+                @data.Estatus
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+        public async Task<Boolean> SyncAnswers2Invoice(string Invoice)
+        {
+            var query = "[Clientes.Amazon.Invoice.Answers.Sync]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync(query, new
+            {
+                @VRIDFactura = Invoice
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+    }
+
+
+}

GEMCO.Backend/Clientes/DTO/DTOLogin.cs

@@ -0,0 +1,8 @@
+namespace GEMCO.Backend.Clientes.DTO
+{
+    public class DTOLogin
+    {
+        public string Usuario { get; set; } = null!;
+        public string Contrasena { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Contracts/IHeinekenRepository.cs

@@ -0,0 +1,13 @@
+using GEMCO.Backend.Clientes.Heineken.Model;
+
+namespace GEMCO.Backend.Clientes.Heineken.Contracts
+{
+    public interface IHeinekenRepository
+    {
+        public Task<IEnumerable<I2206RptEmbarquesPorImportar>> GetHeinekenEmbarquesPorImportar();
+        public Task<IEnumerable<I2206RptMensual>> GetHeinekenEmbarquesPorMes();
+        public Task<IEnumerable<I2206ExpedienteDigital>> GetHeinekenExpedienteDigital(string Coindicencia);
+        public Task<List<I2206AllFiles>> GetAllFiles(long id);
+        public Task<List<I2206RptFacturasTxtHeader>> GetRptFacturasTxtHeader(string Inicio, string Fin);
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206AllFiles.cs

@@ -0,0 +1,7 @@
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206AllFiles
+    {
+        public string Archivo { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206ExpedienteDigital.cs

@@ -0,0 +1,9 @@
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206ExpedienteDigital
+    {
+        public int id { get; set; } = 0!;
+        public string Coincidencia { get; set; } = null!;
+        public string Dato { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206ListaIDs.cs

@@ -0,0 +1,9 @@
+
+
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206ListaIDs
+    {
+        public int id { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206RptEmbarquesPorImportar.cs

@@ -0,0 +1,52 @@
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206RptEmbarquesPorImportar
+    {
+        public int id { get; set; } = 0;
+        public string Aduana { get; set; } = null!;
+        public string TipoEmbarque { get; set; } = null!;
+        public string Destino { get; set; } = null!;
+        public int DiasEnAduana { get; set; } = 0!;
+        public string Nombre { get; set; } = null!;
+        public string Trafico { get; set; } = null!;
+        public string Referencia { get; set; } = null!;
+        public string Pedimento { get; set; } = null!;
+        public string Clave { get; set; } = null!;
+        public string TipoOperacion { get; set; } = null!;
+        public string OrdenCompra { get; set; } = null!;
+        public string Factura { get; set; } = null!;
+        public string Proveedor { get; set; } = null!;
+        public string Descripcion { get; set; } = null!;
+        public string LineaTransportistaInternacional { get; set; } = null!;
+        public string LineaNaviera { get; set; } = null!;
+        public string MAWB { get; set; } = null!;
+        public string HAWB { get; set; } = null!;
+        public string FechaNotificacion { get; set; } = null!;
+        public double Bultos { get; set; } = 0!;
+        public int CantidadContenedores { get; set; } = 0!;
+        public double PesoNeto { get; set; } = 0!;
+        public string Incoterm { get; set; } = null!;
+        public string FechaETA { get; set; } = null!;
+        public string FechaEntrada { get; set; } = null!;
+        public string FechaRevalidacionGuia { get; set; } = null!;
+        public double MontoUSA { get; set; } = 0!;
+        public string Origen { get; set; } = null!;
+        public string FraccionArancelaria { get; set; } = null!;
+        public string DescripcionMercancia { get; set; } = null!;
+        public string PreferenciaArancelaria { get; set; } = null!;
+        public string Estatus { get; set; } = null!;
+        public string Observaciones { get; set; } = null!;
+        public string FAlmacenajeInicioGastos { get; set; } = null!;
+        public double CostoDiario { get; set; } = 0!;
+        public double TotalaPagar { get; set; } = 0!;
+        public string FechaPago { get; set; } = null!;
+        public string FHInstrucciones { get; set; } = null!;
+        public string HoraInstruciones { get; set; } = null!;
+        public string FDespacho { get; set; } = null!;
+        public int DiasCPPagado { get; set; } = 0!;
+        public string FechaSalidaContenedores { get; set; } = null!;
+        public string NombrePaqueteriaInternacional { get; set; } = null!;
+        public string NoGuia { get; set; } = null!;
+        public string FechaEntregaDestinoFinal { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206RptFacturasTxtDetail.cs

@@ -0,0 +1,23 @@
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206RptFacturasTxtDetail
+    {
+        public int id { get; set; } = 0;
+        public int IdHeader { get; set; } = 0;
+        public string Tipo { get; set; } = null!;
+        public string SeisDigitos { get; set; } = null!;
+        public string VeinteDigitos { get; set; } = null!;
+        public string Descripcion { get; set; } = null!;
+        public string Medida { get; set; } = null!;
+        public float Num1 { get; set; } = 0;
+        public float Num2 { get; set; } = 0;
+        public float HNumero4 { get; set; } = 0;
+        public float Num3 { get; set; } = 0;
+        public float HNumero6 { get; set; } = 0;
+        public string Unidad { get; set; } = null!;
+        public float HNumero7 { get; set; } = 0;
+        public float hNumero8 { get; set; } = 0;
+        public string FHCreacion { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206RptFacturasTxtHeader.cs

@@ -0,0 +1,30 @@
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206RptFacturasTxtHeader
+    {
+        public int id { get; set; } = 0;
+        public string Delivery { get; set; } = null!;
+        public string Fecha { get; set; } = null!;
+        public string Factura { get; set; } = null!;
+        public string POCliente { get; set; } = null!;
+        public string Heineken { get; set; } = null!;
+        public string Destino { get; set; } = null!;
+        public string Moneda { get; set; } = null!;
+        public float Numero4 { get; set; } = 0;
+        public float Numero5 { get; set; } = 0;
+        public float Numero6 { get; set; } = 0;
+        public string Unidad { get; set; } = null!;
+        public float Numero7 { get; set; } = 0;
+        public float Numero8 { get; set; } = 0;
+        public string Incoterm { get; set; } = null!;
+        public string Incoterm2 { get; set; } = null!;
+        public string PedidoSAP { get; set; } = null!;
+        public string Transportista { get; set; } = null!;
+        public string Caja { get; set; } = null!;
+        public string Numero12 { get; set; } = null!;
+        public string FHCreacion { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+        public Boolean max { get; set; } = false;
+        public List<I2206RptFacturasTxtDetail> Detail { get; set; } = new List<I2206RptFacturasTxtDetail>();
+    }
+}

GEMCO.Backend/Clientes/Heineken/Model/I2206RptMensual.cs

@@ -0,0 +1,31 @@
+namespace GEMCO.Backend.Clientes.Heineken.Model
+{
+    public class I2206RptMensual
+    {
+        public int id { get; set; } = 0;
+        public int Patente { get; set; } = 0!;
+        public int Aduana { get; set; } = 0!;
+        public string Pedimento { get; set; } = null!;
+        public int Partidas { get; set; } = 0!;
+        public string TipoInsumo { get; set; } = null!;
+        public string FechaPedimento { get; set; } = null!;
+        public string FechaArribo { get; set; } = null!;
+        public string FechaEntrada { get; set; } = null!;
+        public string OrdenCompra { get; set; } = null!;
+        public string Factura { get; set; } = null!;
+        public string NombreProveedor { get; set; } = null!;
+        public string DescripcionMaterial { get; set; } = null!;
+        public double ValorAduanaMXP { get; set; } = 0!;
+        public double MontoAlmacenajes { get; set; } = 0!;
+        public string FraccionArancelaria { get; set; } = null!;
+        public string Incoterm { get; set; } = null!;
+        public double Fletes { get; set; } = 0!;
+        public double Seguros { get; set; } = 0!;
+        public double Embalaje { get; set; } = 0!;
+        public double Otros { get; set; } = 0!;
+        public double DTA { get; set; } = 0!;
+        public double IGI { get; set; } = 0!;
+        public double IEPS { get; set; } = 0!;
+        public int PromedioDiasEnAduana { get; set; } = 0!;
+    }
+}

GEMCO.Backend/Clientes/Heineken/Repository/HeinekenRepository.cs

@@ -0,0 +1,105 @@
+using Dapper;
+using GEMCO.Backend.Context;
+using System.Data;
+using GEMCO.Backend.Clientes.Heineken.Model;
+using GEMCO.Backend.Clientes.Heineken.Contracts;
+
+namespace GEMCO.Backend.Clientes.Heineken.Repository
+{
+    public class HeinekenRepository : IHeinekenRepository
+    {
+
+        private readonly DapperContext _context;
+
+        public HeinekenRepository(DapperContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<I2206RptEmbarquesPorImportar>> GetHeinekenEmbarquesPorImportar()
+        {
+            var query = "[Reportes.Web.Clientes.Heineken.Embarques.PorImportar.Get]";
+            using (var conn = _context.CreateConnection())
+            {
+                var result = await conn.QueryAsync<I2206RptEmbarquesPorImportar>(query,
+                    new { },
+                    commandTimeout: 180,
+                    commandType: CommandType.StoredProcedure);
+                return result.ToList();
+            }
+        }
+
+        public async Task<IEnumerable<I2206RptMensual>> GetHeinekenEmbarquesPorMes()
+        {
+            var query = "[Reportes.Web.Clientes.Heineken.Embarques.PorMes.Get]";
+            using (var conn = _context.CreateConnection())
+            {
+                var result = await conn.QueryAsync<I2206RptMensual>(query,
+                    new { },
+                    commandTimeout: 180,
+                    commandType: CommandType.StoredProcedure);
+                return result.ToList();
+            }
+        }
+
+        public async Task<IEnumerable<I2206ExpedienteDigital>> GetHeinekenExpedienteDigital(string Coincidencia)
+        {
+            var query = "[Reportes.Web.Clientes.Heineken.ExpedienteDigital.Get]";
+            using (var conn = _context.CreateConnection())
+            {
+                var result = await conn.QueryAsync<I2206ExpedienteDigital>(query,
+                    new { @Coincidencia = Coincidencia },
+                    commandTimeout: 180,
+                    commandType: CommandType.StoredProcedure);
+                return result.ToList();
+            }
+        }
+
+        public async Task<List<I2206AllFiles>> GetAllFiles(long id)
+        {
+            var query = "[Clientes.Heineken.Filelist.Get]";
+            using (var conn = _context.CreateConnection())
+            {
+                var result = await conn.QueryAsync<I2206AllFiles>(query,
+                    new { @id = id },
+                    commandTimeout: 180,
+                    commandType: CommandType.StoredProcedure);
+                return result.ToList();
+            }
+        }
+
+        public async Task<List<I2206RptFacturasTxtHeader>> GetRptFacturasTxtHeader(string Inicio, string Fin)
+        {
+
+            using var connection = _context.CreateConnection();
+            /*                          var rows = connection.Query<I2206ListaIDs>("SELECT id FROM [Clientes.Heineken.FacturasTxt.Headers] WHERE Fecha BETWEN @Inicio and @Fin").ToList();
+                          connection.Close(); */
+
+            var parameters = new { @Inicio = Inicio, @Fin = Fin };
+            var sql = "SELECT id FROM [Clientes.Heineken.FacturasTxt.Headers] WHERE Fecha BETWEEN @Inicio and @Fin";
+            var rows = connection.Query<I2206ListaIDs>(sql, parameters);
+            connection.Close();
+
+            List<I2206RptFacturasTxtHeader> data = new List<I2206RptFacturasTxtHeader>();
+            foreach (var row in rows)
+            {
+                var query = "SELECT * FROM [Clientes.Heineken.FacturasTxt.Headers] WHERE Id = @Id;" +
+                         "SELECT * FROM [Clientes.Heineken.FacturasTxt.Detail] WHERE IdHeader = @Id";
+                using (var connection2 = _context.CreateConnection())
+                using (var multi = await connection2.QueryMultipleAsync(query, new
+                {
+                    id = row.id
+                }))
+                {
+                    var result = await multi.ReadSingleOrDefaultAsync<I2206RptFacturasTxtHeader>();
+                    if (result != null)
+                    {
+                        result.Detail = (await multi.ReadAsync<I2206RptFacturasTxtDetail>()).ToList();
+                        data.Add(result);
+                    }
+                }
+            }
+            return data;
+        }
+    }
+}

GEMCO.Backend/Clientes/Heineken/Servicio/SvcZipAllFiles.cs

@@ -0,0 +1,58 @@
+using GEMCO.Backend.Clientes.Heineken.Contracts;
+using GEMCO.Backend.Clientes.Heineken.Model;
+using GEMCO.Backend.Contracts;
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.DTO.ArchivoElectronico;
+using GEMCO.Backend.DTO.Reportes;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.Models.Reportes;
+using System.IO.Compression;
+
+namespace GEMCO.Backend.Clientes.Heineken.Servicio
+{
+    public class SvcZipAllFiles
+    {
+        private readonly IHeinekenRepository _Repo;
+        private readonly IConfiguration _config;
+        private readonly string DOCsPath;
+
+        public SvcZipAllFiles(IHeinekenRepository Repo, IConfiguration config)
+        {
+            _Repo = Repo;
+            _config = config;
+            DOCsPath = _config.GetValue<string>("AllFiles");
+        }
+
+        public byte[] ZipAllFiles(IEnumerable<I2206AllFiles> allFiles)
+        {
+            DateTime now = DateTime.Now;
+            string zipPath = _config.GetValue<string>("pathTemp") + "Allfiles_" + now.ToString("dd_MM_yy_hh_mm_ss") + ".zip";
+            CreateZipFileFromList(allFiles, zipPath);
+            return System.IO.File.ReadAllBytes(zipPath);
+        }
+
+        public void CreateZipFileFromList(IEnumerable<I2206AllFiles> listaPDFs, string zipPath)
+        {
+            using (ZipArchive archive = ZipFile.Open(zipPath, ZipArchiveMode.Update))
+            {
+                foreach (I2206AllFiles pdf in listaPDFs)
+                {
+                    string filename = DOCsPath + pdf.Archivo;
+                    if (System.IO.File.Exists(filename))
+                    {
+                        FileInfo file_info = new FileInfo(filename);
+                        string entry_name = file_info.Name;
+                        for (int version = 1; version < 10000; version++)
+                        {
+                            ZipArchiveEntry? old_entry = archive.GetEntry(entry_name);
+                            if (old_entry == null) break;
+                            entry_name = Path.GetFileNameWithoutExtension(file_info.Name) + $"({version})" + file_info.Extension;
+                        }
+                        archive.CreateEntryFromFile(filename, entry_name);
+                    }
+                }
+            }
+        }
+
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Contracts/IZincInternacionalRepository.cs

@@ -0,0 +1,25 @@
+using GEMCO.Backend.Clientes.ZincInternacional.Model;
+using GEMCO.Backend.Clientes.ZincInternacional.DTO;
+
+namespace GEMCO.Backend.Clientes.ZincInternacional.Contracts
+{
+    public interface IZincInternacionalRepository
+    {
+        public Task<I1868Factura> Append(I1868Factura data);
+        public Task<Boolean> AppendDetail(I1868FacturaDetalle data);
+        public Task<Boolean> RelacionaPDFaFactura(long id, string Filename);
+        public Task<Boolean> RelacionaPorProceso(int id, long IdFile, int Proceso);
+        public Task<IEnumerable<DTO1868ReporteFactura>> getAll(string Inicio, string Fin, int UserId);
+        public Task<IEnumerable<I1868FacturaDetalle>> getAllDetail(string Inicio, string Fin);
+        public Task<Boolean> UpdateMaster(DTO1868Factura data);
+        public Task<I1868FacturaDetalle> UpdateDetail(DTO1868FacturaDetalle data);
+        public Task<IEnumerable<DTO1868Clientes>> getClientes();
+        public Task<IEnumerable<I1868CatProductos>> getCatProductos();
+        public Task<IEnumerable<I1868CatClaveSAT>> getCatClaveSAT();
+        public Task<IEnumerable<I1868CatDestinos>> getCatDestinos();
+        public Task<IEnumerable<I1868CatResponsables>> GetCatResponsables();
+        public Task<I1868CatDestinos> CatDestinosAppend(I1868CatDestinos data);
+        public Task<I1868CatResponsables> CatResponsablesAppend(I1868CatResponsables data);
+        public Task<Boolean> AppendSCACCAT(DTO1868SCACCAAT data);
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/DTO/DTO1868Clientes.cs

@@ -0,0 +1,7 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.DTO
+{
+    public class DTO1868Clientes
+    {
+        public string Cliente { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/DTO/DTO1868Factura.cs

@@ -0,0 +1,13 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.DTO
+{
+    public class DTO1868Factura
+    {
+        public int id { get; set; } = 0;
+        public string Sello { get; set; } = null!;
+        public string Placas { get; set; } = null!;
+        public int IdResponsable { get; set; } = 0;
+        public string Responsable { get; set; } = null!;
+        public int IdDestino { get; set; } = 0;
+        public string Entregar { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/DTO/DTO1868FacturaDetalle.cs

@@ -0,0 +1,9 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.DTO
+{
+    public class DTO1868FacturaDetalle
+    {
+        public int id { get; set; } = 0;
+        public string ClaveSAT { get; set; } = null!;
+        public string Empaque { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/DTO/DTO1868ReporteFactura.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace GEMCO.Backend.Clientes.ZincInternacional.DTO
+{
+    public class DTO1868ReporteFactura
+    {
+        public int id { get; set; } = 0;
+        public string FechaFactura { get; set; } = null!;
+        public string Invoice { get; set; } = null!;
+        public double PesoBruto { get; set; } = 0!;
+        public string Aduana { get; set; } = null!;
+        public string Ruta { get; set; } = null!;
+        public string Cliente { get; set; } = null!;
+        public string PedidoCliente { get; set; } = null!;
+        public string Transportista { get; set; } = null!;
+        public int IdResponsableCruce { get; set; } = 0!;
+        public string ResponsableCruce { get; set; } = null!;
+        public string Sello { get; set; } = null!;
+        public string Placas { get; set; } = null!;
+        public string Carga { get; set; } = null!;
+        public string TipoPedimento { get; set; } = null!;
+        public int IdDestino { get; set; } = 0!;
+        public string Entregar { get; set; } = null!;
+        public string FolioReferencia { get; set; } = null!;
+        public long IDXML { get; set; } = 0;
+        public long IDPDF { get; set; } = 0;
+        public long IDDoda { get; set; } = 0;
+        public long IDPrefile { get; set; } = 0;
+        public long IDBL { get; set; } = 0;
+        public string FRegistro { get; set; } = null!;
+        public string FActualizacion { get; set; } = null!;
+        public byte EsHazmat { get; set; } = 0;
+        public string SCAC { get; set; } = null!;
+        public string CAAT { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/DTO/DTO1868SCACCAAT.cs

@@ -0,0 +1,9 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.DTO
+{
+    public class DTO1868SCACCAAT
+    {
+        public int id { get; set; } = 0;
+        public string SCAC { get; set; } = null!;
+        public string CAAT { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Model/I1868CatClaveSAT.cs

@@ -0,0 +1,10 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.Model
+{
+    public class I1868CatClaveSAT
+    {
+        public int id { get; set; } = 0;
+        public string Clave { get; set; } = null!;
+        public string Descripcion { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Model/I1868CatDestinos.cs

@@ -0,0 +1,9 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.Model
+{
+    public class I1868CatDestinos
+    {
+        public int id { get; set; } = 0;
+        public string Lugar { get; set; } = null!;
+        public string Direccion { get; set; } = null!;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Model/I1868CatProductos.cs

@@ -0,0 +1,10 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.Model
+{
+    public class I1868CatProductos
+    {
+        public int id { get; set; } = 0;
+        public int Codigo { get; set; } = 0;
+        public string Descripcion { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Model/I1868CatResponsables.cs

@@ -0,0 +1,9 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.Model
+{
+    public class I1868CatResponsables
+    {
+        public int id { get; set; } = 0;
+        public string Responsable { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Model/I1868Factura.cs

@@ -0,0 +1,34 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.Model
+{
+    public class I1868Factura
+    {
+        public int id { get; set; } = 0;
+        public string FechaFactura { get; set; } = null!;
+        public string Invoice { get; set; } = null!;
+        public double PesoBruto { get; set; } = 0!;
+        public string Aduana { get; set; } = null!;
+        public string Ruta { get; set; } = null!;
+        public string Cliente { get; set; } = null!;
+        public string PedidoCliente { get; set; } = null!;
+        public string Transportista { get; set; } = null!;
+        public string ResponsableCruce { get; set; } = null!;
+        public string Sello { get; set; } = null!;
+        public string Placas { get; set; } = null!;
+        public string Carga { get; set; } = null!;
+        public string TipoPedimento { get; set; } = null!;
+        public int IdDestino { get; set; } = 0;
+        public string Entregar { get; set; } = null!;
+        public string ConceptoEmbalaje { get; set; } = null!;
+        public string FolioReferencia { get; set; } = null!;
+        public long IDXML { get; set; } = 0;
+        public long IDPDF { get; set; } = 0;
+        public long IDDoda { get; set; } = 0;
+        public long IDPrefile { get; set; } = 0;
+        public string FRegistro { get; set; } = null!;
+        public string FActualizacion { get; set; } = null!;
+        public byte EsHazmat { get; set; } = 0;
+        public string SCAC { get; set; } = null!;
+        public string CAAT { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Model/I1868FacturaDetalle.cs

@@ -0,0 +1,21 @@
+namespace GEMCO.Backend.Clientes.ZincInternacional.Model
+{
+    public class I1868FacturaDetalle
+    {
+        public int id { get; set; } = 0;
+        public int IdFactura { get; set; } = 0;
+        public string Cliente { get; set; } = null!;
+        public string FFactura { get; set; } = null!;
+        public int Partida { get; set; } = 0;
+        public double PesoBruto { get; set; } = 0;
+        public double TotalBultos { get; set; } = 0;
+        public string ProductoMateriaPrima { get; set; } = null!;
+        public string FraccionArancelaria { get; set; } = null!;
+        public string Codigo { get; set; } = null!; // Me sirve para relacionar  la Fraccion Arancelaria con producto
+        public string ClaveSAT1 { get; set; } = null!;
+        public string ConceptoProductoMP { get; set; } = null!;
+        public string EmpaqueDescripcion { get; set; } = null!;
+        public string ClaveSAT2 { get; set; } = null!;
+        public byte Activo { get; set; } = 0;
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Repository/ZincInternacionalRepository.cs

@@ -0,0 +1,229 @@
+using Dapper;
+using GEMCO.Backend.Context;
+using GEMCO.Backend.Clientes.ZincInternacional.Contracts;
+using GEMCO.Backend.Clientes.ZincInternacional.Model;
+using GEMCO.Backend.Clientes.ZincInternacional.DTO;
+using System.Data;
+
+namespace GEMCO.Backend.Clientes.ZincInternacional.Repository
+{
+    public class ZincInternacionalRepository : IZincInternacionalRepository
+    {
+        private readonly DapperContext _context;
+        public ZincInternacionalRepository(DapperContext context) { _context = context; }
+        public async Task<I1868Factura> Append(I1868Factura data)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.Append]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868Factura>(query, new
+            {
+                @FechaFactura = data.FechaFactura,
+                @Invoice = data.Invoice,
+                @PesoBruto = data.PesoBruto,
+                @Ruta = data.Ruta,
+                @Cliente = data.Cliente,
+                @PedidoCliente = data.PedidoCliente,
+                @Transportista = data.Transportista,
+                @ResponsableCruce = data.ResponsableCruce,
+                @FolioReferencia = data.FolioReferencia,
+                @IdXML = data.IDXML,
+                @EsHazmat = data.EsHazmat,
+                @IdDestino = data.IdDestino,
+                @Activo = 1
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.First();
+        }
+        public async Task<Boolean> AppendDetail(I1868FacturaDetalle data)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.Detalle.Append]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync(query, new
+            {
+                @id = data.id,
+                @IdFactura = data.IdFactura,
+                @FFactura = data.FFactura,
+                @Partida = data.Partida,
+                @TotalBultos = data.TotalBultos,
+                @PesoBruto = data.PesoBruto,
+                @Codigo = data.Codigo,
+                @ProductoMateriaPrima = data.ProductoMateriaPrima,
+                @FraccionArancelaria = data.FraccionArancelaria,
+                @ClaveSAT1 = data.ClaveSAT1,
+                @ConceptoProductoMP = data.ConceptoProductoMP,
+                @EmpaqueDescripcion = data.EmpaqueDescripcion,
+                @ClaveSAT2 = data.ClaveSAT2,
+                @Activo = 1
+            },
+                commandType: CommandType.StoredProcedure);
+            return true;
+        }
+        public async Task<I1868CatDestinos> CatDestinosAppend(I1868CatDestinos data)
+        {
+            var query = "[Clientes.ZincInternacional.CatDestinos.Append]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868CatDestinos>(query, new
+            {
+                @id = data.id,
+                @Lugar = data.Lugar,
+                @Direccion = data.Direccion
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.First();
+        }
+        public async Task<I1868CatResponsables> CatResponsablesAppend(I1868CatResponsables data)
+        {
+            var query = "[Clientes.ZincInternacional.CatResponsables.Append]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868CatResponsables>(query, new
+            {
+                @id = data.id,
+                @Responsable = data.Responsable,
+                @Activo = data.Activo
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.First();
+        }
+        public async Task<Boolean> RelacionaPDFaFactura(long id, string Filename)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.Relate]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868Factura>(query, new
+            {
+                @id = id,
+                @Filename = Filename
+            },
+                commandType: CommandType.StoredProcedure);
+            return true;
+        }
+        public async Task<Boolean> RelacionaPorProceso(int id, long IdFile, int Proceso)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.RelateByProcess]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync(query, new
+            {
+                @id = id,
+                @idFile = IdFile,
+                @Proceso = Proceso
+            },
+                commandType: CommandType.StoredProcedure);
+            return true;
+        }
+        public async Task<IEnumerable<DTO1868ReporteFactura>> getAll(string Inicio, string Fin, int UserId)
+        {
+            var query = "[Reportes.Web.Clientes.ZincInternacional.Factura.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO1868ReporteFactura>(query, new
+            {
+                @Inicio = Inicio,
+                @Fin = Fin,
+                @UserId = UserId
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada;
+        }
+        public async Task<IEnumerable<I1868FacturaDetalle>> getAllDetail(string Inicio, string Fin)
+        {
+            var query = "[Reportes.Web.Clientes.ZincInternacional.Factura.Detalle.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868FacturaDetalle>(query, new
+            {
+                @Inicio = Inicio,
+                @Fin = Fin
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada;
+        }
+        public async Task<IEnumerable<I1868CatProductos>> getCatProductos()
+        {
+            var query = "[Clientes.ZincInternacional.CatProductos.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868CatProductos>(query, new
+            { }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+        public async Task<IEnumerable<I1868CatClaveSAT>> getCatClaveSAT()
+        {
+            var query = "[Clientes.ZincInternacional.CatClaveSAT.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868CatClaveSAT>(query, new
+            { }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+        public async Task<IEnumerable<I1868CatDestinos>> getCatDestinos()
+        {
+            var query = "[Clientes.ZincInternacional.CatDestinos.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868CatDestinos>(query, new
+            { }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+        public async Task<IEnumerable<I1868CatResponsables>> GetCatResponsables()
+        {
+            var query = "[Clientes.ZincInternacional.CatResponsables.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868CatResponsables>(query, new
+            { }, commandType: CommandType.StoredProcedure);
+            return entrada.ToList();
+        }
+        public async Task<Boolean> UpdateMaster(DTO1868Factura data)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.Update]";
+            using var connection = _context.CreateConnection();
+            try
+            {
+                var entrada = await connection.QueryAsync<DTO1868Factura>(query, new
+                {
+                    @id = data.id,
+                    @Sello = data.Sello,
+                    @Placas = data.Placas,
+                    @IdResponsable = data.IdResponsable,
+                    @Responsable = data.Responsable,
+                    @IdDestino = data.IdDestino,
+                    @Entregar = data.Entregar,
+                },
+                    commandType: CommandType.StoredProcedure);
+            }
+            catch (InvalidCastException e)
+            {
+                Console.WriteLine(e.ToString());
+                return false;
+            }
+            return true;
+        }
+        public async Task<I1868FacturaDetalle> UpdateDetail(DTO1868FacturaDetalle data)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.Detalle.Update]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<I1868FacturaDetalle>(query, new
+            {
+                @id = data.id,
+                @ClaveSAT = data.ClaveSAT,
+                @Empaque = data.Empaque
+            },
+                commandType: CommandType.StoredProcedure);
+            return entrada.First();
+        }
+        public async Task<IEnumerable<DTO1868Clientes>> getClientes()
+        {
+            var query = "[Clientes.ZincInternacional.Clientes.Get]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync<DTO1868Clientes>(query, new
+            { }, commandType: CommandType.StoredProcedure);
+            return entrada;
+        }
+        public async Task<Boolean> AppendSCACCAT(DTO1868SCACCAAT data)
+        {
+            var query = "[Clientes.ZincInternacional.Factura.SCACCAAT.Append]";
+            using var connection = _context.CreateConnection();
+            var entrada = await connection.QueryAsync(query, new
+            {
+                @id = data.id,
+                @SCAC = data.SCAC,
+                @CAAT = data.CAAT
+            },
+                commandType: CommandType.StoredProcedure);
+            return true;
+        }
+    }
+}

GEMCO.Backend/Clientes/ZincInternacional/Services/SvcZincInternacional.cs

@@ -0,0 +1,233 @@
+using System.Reflection.Metadata;
+using System.Numerics;
+using System;
+using System.Xml.Linq;
+using GEMCO.Backend.Clientes.ZincInternacional.Contracts;
+using GEMCO.Backend.Clientes.ZincInternacional.Model;
+namespace GEMCO.Backend.Clientes.ZincInternacional.Services
+{
+    public class SvcZincInternacional
+    {
+        private readonly IZincInternacionalRepository _Repo;
+        private readonly string rutaArchivo;
+        public SvcZincInternacional(IZincInternacionalRepository Repo, String Archivo)
+        {
+            _Repo = Repo;
+            rutaArchivo = Archivo;
+        }
+
+        public async Task<Boolean> ReadXml(long IdArchivo)
+        {
+            XDocument doc = XDocument.Load(rutaArchivo);
+            I1868Factura data = new I1868Factura();
+            var allElements = doc.Descendants();
+            // Get header for master record
+            foreach (XElement element in allElements)
+            {
+                foreach (XAttribute attribute in element.Attributes())
+                {
+                    if (attribute.ToString().Contains("FechaTimbrado")) data.FechaFactura = attribute.Value.Replace("T", " ");
+                    if (attribute.ToString().Contains("SerieFolio")) data.Invoice = attribute.Value;
+                    if (attribute.ToString().Contains("PesoBruto")) data.PesoBruto = Convert.ToDouble(attribute.Value.Length > 0 ? attribute.Value : "0");
+                    if (attribute.ToString().Contains("NoContenedor")) data.Ruta = attribute.Value;
+                    if (attribute.ToString().Contains("RazonSocial")) data.Cliente = attribute.Value;
+                    if (attribute.ToString().Contains("FolioOrdenCompra")) data.PedidoCliente = attribute.Value;
+                    if (attribute.ToString().Contains("Transportista"))
+                    {
+                        data.Transportista = attribute.Value;
+                        data.ResponsableCruce = attribute.Value;
+                    }
+                    if (attribute.ToString().Contains("FolioReferencia")) data.FolioReferencia = attribute.Value;
+                }
+            }
+            data.IDXML = IdArchivo;
+
+
+
+            // Get destination for invoice
+            I1868CatDestinos DestinoFinal = new I1868CatDestinos();
+            string Destino = "";
+            foreach (XElement element in allElements)
+            {
+                foreach (XAttribute attribute in element.Attributes())
+                {
+                    if (attribute.ToString().Contains("SucursalDesc")) Destino += attribute.Value;
+                    if (attribute.ToString().Contains("DireccionSucursal")) Destino += " " + attribute.Value;
+                    if (attribute.ToString().Contains("DomicilioSucursalCliente")) Destino += " " + attribute.Value;
+                    if (attribute.ToString().Contains("CPSucursalCliente")) Destino += " " + attribute.Value;
+                }
+            }
+            DestinoFinal.id = 0;
+            DestinoFinal.Lugar = Destino;
+            DestinoFinal.Direccion = Destino;
+            var InfoDestino = await _Repo.CatDestinosAppend(DestinoFinal);
+            data.IdDestino = InfoDestino.id;
+
+
+            // Get detail for master record
+            List<I1868FacturaDetalle> LFDetail = new List<I1868FacturaDetalle>();
+            LFDetail = getDetail(allElements.Elements());
+            I1868Factura resultMaster = await _Repo.Append(data);
+
+            foreach (I1868FacturaDetalle obj in LFDetail)
+            {
+                obj.IdFactura = resultMaster.id;
+                obj.Cliente = resultMaster.Cliente;
+                obj.FFactura = resultMaster.FechaFactura;
+            }
+            foreach (I1868FacturaDetalle obj in LFDetail)
+            {
+                await _Repo.AppendDetail(obj);
+            }
+            return true;
+        }
+
+        static List<I1868FacturaDetalle> getDetail(IEnumerable<XElement> list1)
+        {
+            List<I1868FacturaDetalle> LFDetail = new List<I1868FacturaDetalle>();
+            // var data = new I1868FacturaDetalle(); 
+            string Substring = "";
+            string LineaClave = "";
+            string LineaInnecesaria = "";
+            string Renglon = "", Codigo = "", PesoNeto = "", TotalBultos = "";
+            int NoRenglones = 0, TotBultos = 0;
+            foreach (XElement el in list1)
+            {
+                if (new string[] { "Addenda" }.Any(s => el.ToString().Contains(s))) // Header tag
+                {
+                    var Linea = el.ToString();
+
+                    for (var ciclo = 1; ciclo <= 10; ciclo++)
+                    {
+                        //Substring = getBetween(Linea, "<if:Cuerpo Renglon=", "</if:Cuerpo>");
+                        Substring = getBetween(Linea, "<if:Cuerpo", "</if:Cuerpo>");
+                        //LineaClave = "<if:Cuerpo Renglon=" + Substring + "</if:Cuerpo>";
+                        LineaClave = "<if:Cuerpo" + Substring + "</if:Cuerpo>";
+                        Linea = Linea.Replace(LineaClave, "");
+                        LineaInnecesaria = getBetween(LineaClave, "<if:Traslado", "/>");
+                        LineaClave = LineaClave.Replace("<if:Traslado" + LineaInnecesaria + "/>", "");
+                        Renglon = getValue(LineaClave, "Renglon=");
+                        var isNumeric = int.TryParse(Renglon, out int n);
+                        if (!isNumeric) break;
+                        else NoRenglones = Int32.Parse(Renglon);
+                        Codigo = getValue(LineaClave, "Codigo=");
+                        PesoNeto = getValue(LineaClave, "PesoNeto=");
+                        PesoNeto = DigitsOnly(PesoNeto);
+                        TotalBultos = getValue(LineaClave, "TotalBultos=");
+                        isNumeric = int.TryParse(TotalBultos, out int m);
+                        if (!isNumeric) break;
+                        else TotBultos = Int32.Parse(TotalBultos);
+                        var data = new I1868FacturaDetalle();
+                        data.Partida = ciclo;
+                        isNumeric = double.TryParse(PesoNeto, out double d);
+                        if (!isNumeric) data.PesoBruto = 0;
+                        else data.PesoBruto = Convert.ToDouble(PesoNeto);
+                        data.TotalBultos = TotBultos;
+                        data.Codigo = Codigo;
+                        data.ProductoMateriaPrima = "";
+                        data.FraccionArancelaria = "";
+                        data.ClaveSAT1 = "";
+                        data.ConceptoProductoMP = "";
+                        data.EmpaqueDescripcion = "";
+                        data.ClaveSAT2 = "";
+                        data.FFactura = "";
+                        LFDetail.Add(data);
+                    }
+                }
+            }
+            string NoIdentificacion = "", FraccionArancelaria = "";
+            // Extrae Numero de Identificacion y Fraccion Arancelaria
+            foreach (XElement el in list1)
+            {
+                if (new string[] { "cfdi:Complemento" }.Any(s => el.ToString().Contains(s))) // Header tag
+                {
+                    var Linea = el.ToString();
+                    Linea = getBetween(Linea, "<cce11:Mercancias>", "</cce11:Mercancias>");
+                    LineaClave = getBetween(Linea, "<cce11:Mercancia", "/>");
+                    for (var ciclo = 1; ciclo <= NoRenglones; ciclo++)
+                    {
+                        LineaClave = "<cce11:Mercancia" + LineaClave + "/>";
+                        NoIdentificacion = getValue(LineaClave, "NoIdentificacion=");
+                        FraccionArancelaria = getValue(LineaClave, "FraccionArancelaria=");
+                        foreach (I1868FacturaDetalle obj in LFDetail)
+                        {
+                            //if (obj.Partida == ciclo && obj.Codigo == NoIdentificacion)
+                            if (obj.Codigo == NoIdentificacion)
+                            {
+                                obj.FraccionArancelaria = FraccionArancelaria;
+                                break;
+                            }
+                        }
+                        //Console.WriteLine(getValue(LineaClave, "NoIdentificacion") + " " + getValue(LineaClave, "FraccionArancelaria"));
+                        LineaClave = Linea.Replace(LineaClave, "");
+                        //Console.WriteLine(""); // Child tags 
+                    }
+                    //Console.WriteLine("");
+                }
+            }
+            return LFDetail;
+        }
+
+        static string DigitsOnly(string s)
+        {
+            string res = "";
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (Char.IsDigit(s[i]) || s[i] == '.')
+                    res += s[i];
+            }
+            return res;
+        }
+
+        static string cleanValue(string strOriginal, string strRemove)
+        {
+            strOriginal = strOriginal.Replace(strRemove, "");
+            strOriginal = strOriginal.Replace("\"", "");
+            return "";
+        }
+
+        static string getBetween(string strSource, string strStart, string strEnd)
+        {
+            if (strSource.Contains(strStart) && strSource.Contains(strEnd))
+            {
+                int Start, End;
+                Start = strSource.IndexOf(strStart, 0) + strStart.Length;
+                End = strSource.IndexOf(strEnd, Start);
+                return strSource.Substring(Start, End - Start);
+            }
+            return "";
+        }
+
+        static string getValue(string Cadena, string key)
+        {
+            var array = Cadena.Split(' ');
+            foreach (string x in array)
+            {
+                if (x.Contains(key))
+                {
+                    var strOriginal = x;
+                    strOriginal = strOriginal.Replace(key, "");
+                    strOriginal = strOriginal.Replace("\"", "");
+                    return strOriginal;
+                }
+            }
+            return "";
+        }
+
+        public async Task<Byte> EsProductoHAZMAT(int Codigo)
+        {
+            IEnumerable<I1868CatProductos> ProductosHAZMAT = new List<I1868CatProductos>();
+            ProductosHAZMAT = await _Repo.getCatProductos();
+            I1868CatProductos? found = ProductosHAZMAT.FirstOrDefault(x => x.Codigo == Codigo);
+            if (found != null) return 1;
+            return 0;
+        }
+
+        public async Task<Boolean> RelacionaPDFaFactura(long id, string Filename)
+        {
+            var arrFilename = Filename.Split('_'); // El nombre del archivo viene con la fecha y hora de subida, hay que limpiar esto... 
+            await _Repo.RelacionaPDFaFactura(id, arrFilename[0]);
+            return true;
+        }
+    }
+}

GEMCO.Backend/Context/DapperContext.cs

@@ -0,0 +1,18 @@
+using Microsoft.Data.SqlClient;
+using System.Data;
+
+namespace GEMCO.Backend.Context
+{
+    public class DapperContext
+    {
+        private readonly IConfiguration _configuration;
+        private readonly string _connectionString;
+        public DapperContext(IConfiguration configuration)
+        {
+            _configuration = configuration;
+            _connectionString = _configuration.GetConnectionString("SqlConnection");
+        }
+        public IDbConnection CreateConnection()
+            => new SqlConnection(_connectionString);
+    }
+}

GEMCO.Backend/Contracts/AnexoFacturacion/IAnexoFacturacionRepository.cs

@@ -0,0 +1,12 @@
+using GEMCO.Backend.Models.AnexoFacturacion;
+using GEMCO.Backend.DTO.AnexoFacturacion;
+
+namespace GEMCO.Backend.Contracts.AnexoFacturacion
+{
+    public interface IAnexoFacturacionRepository
+    {
+        public Task<IEnumerable<RptAnexoFacturacionMission>> GetRptAnexoFacturacionMission(DTOAnexoFacturacionMission data);
+        public Task<IEnumerable<RptConsolidadosSinCerrar>> GetRptConsolidadosSinCerrar();
+        public Task<IEnumerable<RptAnexoFacturacionAlen>> GetRptAnexoFacturacionAlen(DTOAnexoFacturacionAlen data);
+    }
+}

GEMCO.Backend/Contracts/Catalogos/ICorresponsalesRepository.cs

@@ -0,0 +1,12 @@
+using GEMCO.Backend.Models.Catalogos;
+
+namespace GEMCO.Backend.Contracts.Catalogos
+{
+    public interface ICorresponsalesRepository
+    {
+        public Task<IEnumerable<CatCorresponsales>> GetAll();
+        public Task<IEnumerable<CatCorresponsales>> GetAllFormated();
+        public Task<CatCorresponsales> Append(CatCorresponsales data);
+        public Task<CatCorresponsales> Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Catalogos/IProveedoresRepository.cs

@@ -0,0 +1,11 @@
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts.Catalogos
+{
+    public interface IProveedoresRepository
+    {
+        public Task<IEnumerable<CatProveedores>> GetAll(int Clasificacion);
+        public Task<CatProveedores> Append(CatProveedores data);
+        public Task Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Catalogos/ITabuladorDetalleRepository.cs

@@ -0,0 +1,13 @@
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.Models.Catalogos;
+namespace GEMCO.Backend.Contracts.Catalogos
+{
+    public interface ITabuladorDetalleRepository
+    {
+        public Task<IEnumerable<TabuladorDetalle>> Append(TabuladorDetalle data);
+        public Task<IEnumerable<TabuladorDetalle>> GetDetailByIdTab(int id);
+        public Task<IEnumerable<TabuladorDetalle>> GetAll(int id, int IdCliente);
+        public Task Delete(int id);
+        public Task<IEnumerable<DTOConceptos>> GetAllConcepts();
+    }
+}

GEMCO.Backend/Contracts/Catalogos/ITabuladorRepository.cs

@@ -0,0 +1,10 @@
+using GEMCO.Backend.Models.Catalogos;
+namespace GEMCO.Backend.Contracts.Catalogos
+{
+    public interface ITabuladorRepository
+    {
+        public Task<IEnumerable<Tabulador>> GetAll(int id, int IdCliente);
+        public Task<Tabulador> Append(Tabulador data);
+        public Task Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Clientes/CasaCuervo/ICasaCuervoRepository.cs

@@ -0,0 +1,16 @@
+using GEMCO.Backend.Models.Clientes.CasaCuervo;
+using GEMCO.Backend.DTO.Clientes.CasaCuervo;
+
+namespace GEMCO.Backend.Contracts.Clientes.CasaCuervo
+{
+    public interface ICasaCuervoRepository
+    {
+        public Task<Boolean> Append(List<I325Pedidos> data);
+        public Task<Boolean> UpdateInfoFromCorresponsal(List<DTO325ComplementaPedido> data);
+        public Task<IEnumerable<I325Pedidos>> getAll(string Inicio, string Fin, string Aduana);
+        public Task<I325Pedidos> GetById(int Id);
+        public Task<I325Pedidos> UpdateInfoFromWeb(DTO325UpdateFromWeb data);
+        public Task<IEnumerable<DTO325AduanasPedidos>> getAduanas(int Usuario, int TipoUsuario);
+        public Task<IEnumerable<I325RptCOVE>> GetRptCOVE(string Inicio, string Fin);
+    }
+}

GEMCO.Backend/Contracts/Contabilidad/Corresponsalias/IContabilidadCorresponsaliasRepository.cs

@@ -0,0 +1,10 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Contabilidad.Corresponsalias
+{
+    public interface IContabilidadCorresponsaliasRepository
+    {
+        public Task<CorresponsalTraficoContabilidad> Append(CorresponsalTraficoContabilidad data);
+        public Task<IEnumerable<string>> Get(int IdTrafico, int tipo);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasAnticiposRepository.cs

@@ -0,0 +1,15 @@
+using GEMCO.Backend.DTO.Corresponsales;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasAnticiposRepository
+    {
+        public Task<CorresponsalAnticipos> Append(CorresponsalAnticipos data);
+        public Task<IEnumerable<CorresponsalAnticipos>> getAll(int IdTrafico);
+        public Task Delete(int id);
+        public Task<DashboardTotal> GetTotalAnticiposPendientes();
+        public Task<CorresponsalAnticipos> Autoriza(DTOCorresponsalesAnticipo data);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasCatAduanasRepository.cs

@@ -0,0 +1,9 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasCatAduanasRepository
+    {
+        public Task<IEnumerable<CorresponsalCatAduanas>> getAll(int IdCliente);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasCatDestinosRepository.cs

@@ -0,0 +1,9 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasCatDestinosRepository
+    {
+        public Task<IEnumerable<CorresponsalCatDestinos>> getAll(int IdCliente);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasCatMediosEmbarqueRepository.cs

@@ -0,0 +1,9 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasCatMediosEmbarqueRepository
+    {
+        public Task<IEnumerable<CorresponsalCatMediosEmbarque>> getAll();
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasCatTipoEmbarqueRepository.cs

@@ -0,0 +1,9 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasCatTipoEmbarqueRepository
+    {
+        public Task<IEnumerable<CorresponsalCatTipoEmbarque>> getAll();
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasCatTiposDocumentosRepository.cs

@@ -0,0 +1,11 @@
+using GEMCO.Backend.DTO.Corresponsales;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasCatTiposDocumentosRepository
+    {
+        public Task<IEnumerable<CorresponsalCatTiposDocumento>> getAll(int Cliente, int Clasificacion);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasContenedoresRepository.cs

@@ -0,0 +1,12 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasContenedoresRepository
+    {
+        public Task<IEnumerable<CorresponsalesContenedores>> GetAll(int IdTrafico);
+        public Task<CorresponsalesContenedores> Append(CorresponsalesContenedores data);
+        public Task Delete(int id);
+        public Task<CorresponsalesContenedores> Appendc1896(CorresponsalesContenedores data);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasCuentasComplementarias.cs

@@ -0,0 +1,17 @@
+using GEMCO.Backend.Models.Corresponsales;
+using GEMCO.Backend.DTO.Corresponsales;
+using GEMCO.Backend.Models;
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasCuentasComplementarias
+    {
+        public Task<CorresponsalCuentasComplementarias> Append(DTOCorresponsalCuentaComplementaria data);
+        public Task<IEnumerable<CorresponsalCuentasComplementarias>> Get(int IdTrafico);
+        public Task<DashboardTotal> GetPendientes();
+        public Task<IEnumerable<CorresponsalCuentasComplementariasEstatus>> GetEstatus();
+        public Task<CorresponsalCuentasComplementariasEstatus> AppendEstatus(CorresponsalCuentasComplementariasEstatus data);
+        public Task<Boolean> ChangeEstatus(DTOCorresponsalCuentaComplementariaEstatus data);
+        public Task<IEnumerable<DTOLogCorresposalCuentaComplementaria>> GetLogEstatus(int id);
+        public Task<Boolean> ClearFile(int id, byte witchFile);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasFacturasRepository.cs

@@ -0,0 +1,12 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasFacturasRepository
+    {
+        public Task<IEnumerable<CorresponsalFacturas>> GetAll(int idTrafico);
+        public Task<CorresponsalFacturas> Append(CorresponsalFacturas data);
+        public Task Delete(int id);
+        public Task<CorresponsalFacturas> Appendc1896(CorresponsalFacturas data, string UUID);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasFacturasTercerosRepository.cs

@@ -0,0 +1,10 @@
+using GEMCO.Backend.Models.Corresponsales;
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasFacturasTercerosRepository
+    {
+        public Task<IEnumerable<CorresponsalFacturasTerceros>> GetAll(int IdTrafico);
+        public Task<CorresponsalFacturasTerceros> Append(CorresponsalFacturasTerceros data);
+        public Task Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasGuiasRepository.cs

@@ -0,0 +1,10 @@
+using GEMCO.Backend.Models.Corresponsales;
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasGuiasRepository
+    {
+        public Task<IEnumerable<CorresponsalesGuias>> GetAll(int IdTrafico);
+        public Task<CorresponsalesGuias> Append(CorresponsalesGuias data);
+        public Task Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasPedimentoPartidasRepository.cs

@@ -0,0 +1,11 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasPedimentoPartidasRepository
+    {
+        public Task<CorresponsalPedimentoPartida> Append(CorresponsalPedimentoPartida data);
+        public Task<IEnumerable<CorresponsalPedimentoPartida>> getAll(int IdTrafico);
+        public Task Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasPedimentoRepository.cs

@@ -0,0 +1,11 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasPedimentoRepository
+    {
+        public Task<CorresponsalPedimento> Append(CorresponsalPedimento data);
+        public Task<CorresponsalPedimento> Get(int IdTrafico);
+        public Task Delete(int id);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasPrecuentaRepository.cs

@@ -0,0 +1,11 @@
+using GEMCO.Backend.Models.Corresponsales;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasPrecuentaRepository
+    {
+        public Task<IEnumerable<IPrecuenta>> GetAll(int id, int IdTrafico);
+        public Task ChangeStatus(int id);
+        public Task<IEnumerable<IPrecuenta>> Append(int IdTabulador, int IdTrafico);
+    }
+}

GEMCO.Backend/Contracts/Corresponsalias/ICorresponsaliasTraficosRepository.cs

@@ -0,0 +1,20 @@
+using GEMCO.Backend.Models;
+using GEMCO.Backend.DTO.Corresponsales;
+using GEMCO.Backend.Models.Corresponsales;
+using GEMCO.Backend.Repository.Corresponsalias;
+
+namespace GEMCO.Backend.Contracts.Corresponsalias
+{
+    public interface ICorresponsaliasTraficosRepository
+    {
+        public Task<ITrafico> Get(int id);
+        public Task<DashboardTotal> GetAll(int Mode);
+        public Task<IEnumerable<ICorRectificaciones>> GetRectificaciones(int id);
+        public Task<ICorRectificaciones> AddRectificacion(int id);
+        public Task<ITrafico> Append(ITrafico data);
+        public Task<IEnumerable<CorresponsalesTraficoEstatus>> GetTraficoEstatus();
+        public Task<Boolean> ValidaTraficoCompleto(DTOTraficoCompleto data);
+        public Task<Boolean> RectificacionHistoricoAppend(DTORectificacionHistorico data);
+        public Task<CorresponsaliasTraficoRectificacionHistorico> RectificacionHistoricoGet(int IdTrafico);
+    }
+}

GEMCO.Backend/Contracts/Dashboard/IDashboardCorresponsalesRepository.cs

@@ -0,0 +1,10 @@
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts.Dashboard
+{
+    public interface IDashboardCorresponsalesRepository
+    {
+        public Task<IEnumerable<DashboardCorresponsales>> Get();
+        public Task<Decimal> GetTipoCambio(string Fecha);
+    }
+}

GEMCO.Backend/Contracts/IArchivoElectronico.cs

@@ -0,0 +1,16 @@
+using GEMCO.Backend.DTO.ArchivoElectronico;
+using GEMCO.Backend.DTO.Battery;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.Models.Reportes;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IArchivoElectronico
+    {
+        public Task<List<AOCheckList>> GetAOCheckLists();
+        public Task<List<ArchivoElectronico>> getArchivoOficial(DTOAEPeriodoSeleccion data);
+        public Task<LogFotosBodega> createLogFotosBodega(LogFotosBodega data);
+        public Task<List<LogFotosBodega>> getLogFotosBodega(DTOLogFotosBodega data);
+        public Task<List<RptPedimentosPagadosAEO>> getRptPedimentoPagadosAEO(DTOAEPeriodo data);
+    }
+}

GEMCO.Backend/Contracts/IBatteryRepository.cs

@@ -0,0 +1,14 @@
+using GEMCO.Backend.DTO.Battery;
+using GEMCO.Backend.DTO.Reportes;
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IBatteryRepository
+    {
+        public Task<BatteryEntry> updatePallete2Warehouse(DTOBatteryEntry data);
+        public Task<IEnumerable<BatteryEntry>> getBatteryInfo(DTOBatteryInfo data);
+        public Task<IEnumerable<BatteryEntry>> getReportFromWarehouse(DTOReporte data);
+        public Task<double> getPalletWeight(string data);
+    }
+}

GEMCO.Backend/Contracts/IClientesRepository.cs

@@ -0,0 +1,16 @@
+using GEMCO.Backend.DTO.Cliente;
+using GEMCO.Backend.DTO.Usuario;
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IClientesRepository
+    {
+        public Task<IEnumerable<IClientes>> getAllClientes(int id);
+        public Task<IEnumerable<IClientes>> getClientesAsignados(int id);
+        public Task<string> GetCustomerName(int sClave);
+        public Task<IEnumerable<IClientes>> addCliente(DTOClienteUsuario CU);
+        public Task<IEnumerable<DTOClienteProveedor>> asignaClienteProveedor(DTOClienteProveedor cp);
+        public Task<IEnumerable<Transportistas>> asignaUsuarioTransportista(DTOUsuarioTransportista t);
+    }
+}

GEMCO.Backend/Contracts/IMenuRepository.cs

@@ -0,0 +1,9 @@
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IMenuRepository
+    {
+        public Task<IEnumerable<Menu>> GetItemsMenu(Usuarios user);
+    }
+}

GEMCO.Backend/Contracts/IPerfilesRepository.cs

@@ -0,0 +1,20 @@
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.DTO.Usuario;
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IPerfilesRepository
+    {
+        public Task<IEnumerable<Perfiles>> getPerfiles();
+        public Task<Perfiles> PerfilGetById(int id);
+        public Task<IEnumerable<Menu>> getMenu();
+        public Task<IEnumerable<PerfilesMenu>> getPerfilMenuById(int id);
+        public Task<IEnumerable<PerfilesMenu>> getAllPerfilesMenu();
+        public Task<IEnumerable<DTOPerfilCreate>> createPerfil(DTOPerfilCreate data);
+        public Task<IEnumerable<Menu>> createItemMenu(Menu data);
+        public Task<IEnumerable<DTOItemMenuPerfil>> asignaItemMenuPerfil(DTOItemMenuPerfil data);
+        public Task<IEnumerable<Transportistas>> getAllTransportistas(int id);
+        public Task<IEnumerable<Proveedores>> getAllProveedores(int id);
+    }
+}

GEMCO.Backend/Contracts/IUsuariosRepository.cs

@@ -0,0 +1,23 @@
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.DTO.Usuario;
+using GEMCO.Backend.Models;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IUsuariosRepository
+    {
+        public Task<IEnumerable<DTOUsuariosShort>> getAllUsuariosShort();
+        public Task<IEnumerable<Usuarios>> getAllUsuarios();
+        public Task<Usuarios> GetUsuario(DTOLogin user);
+        public Task<int> searchUsuario(string Usuario);
+        public Task<Usuarios> GetUsuarioById(int id);
+        public Task<Usuarios> createUsuario(Usuarios user);
+        public Task<DTOPINData> CreatePIN(int Id);
+        public Task<Boolean> ValidatePIN(DTOPINUsuario data);
+        public Task<DTOLogin> resetPassword(DTOResetPassword user);
+        public Task<IEnumerable<DTOClonarUsuario>> clonarUsuario(DTOClonarUsuario user);
+        public Task<IEnumerable<CatRoles>> CatalogoRolesGET();
+        public Task<IEnumerable<DTORolesAsignados>> RolesAsignadosGET(int id);
+        public Task<IEnumerable<DTOUsuariosPerfilParecido>> GETPerfilesParecidos(string Perfil);
+    }
+}

GEMCO.Backend/Contracts/ReportesRepository.cs

@@ -0,0 +1,22 @@
+using GEMCO.Backend.Models.Reportes;
+using GEMCO.Backend.DTO.Reportes;
+using GEMCO.Backend.DTO.Corresponsales;
+using GEMCO.Backend.Clientes.Heineken.Model;
+
+namespace GEMCO.Backend.Contracts
+{
+    public interface IReportesRepository
+    {
+        public Task<IEnumerable<RptPedimentosPagados>> getPedimentosPagados(DTOReporte data);
+        public Task<IEnumerable<RptPedimentosPagadosImpuestos>> getPedimentosPagadosImpuestos(DTOReporte data);
+        public Task<IEnumerable<RptPedimentosPagadosFacturasCruzadas>> getPedimentosPagadosFacturasCruzadas(DTOReporte data);
+        public Task<IEnumerable<RptDetalleAnexo24>> getDetalleAnexo24(DTOReporte data);
+        public Task<IEnumerable<RptOperacionesRemesa>> getOperacionesRemesa();
+        public Task<IEnumerable<RptPedimentosConsolidados>> getPedimentosConsolidados(DTOReporte data);
+        public Task<IEnumerable<DTOCorresponsalTrafico>> GetRptCorresponsalesTraficos(DTOReporteCorresponsales data);
+        public Task<IEnumerable<RptOperaciones>> GetRptOperaciones(string Inicio, string Fin, int TipoOperacion, int NoCliente);
+        public Task<IEnumerable<RptOperacionesConsolidadas>> GetRptOperacionesConsolidadas(string Inicio, string Fin, int TipoOperacion, int NoCliente);
+        public Task<Boolean> GenerateControlDocumentosClientes();
+        public  Task<IEnumerable<RptOperacionesDiarias>> GetRptOperacionesDiarias(string Inicio, string Fin, int TipoOperacion, int Cliente);
+    }
+}

GEMCO.Backend/Contracts/Utils/IFileManagerRepository.cs

@@ -0,0 +1,14 @@
+using GEMCO.Backend.Models.Utils;
+
+namespace GEMCO.Backend.Contracts.Utils
+{
+    public interface IFileManagerRepository
+    {
+        public Task<FileManager> FileManager(FileManager data);
+        public Task<FileManager> getFileByProcess(long id, int Proceso);
+        public Task<List<FileManager>> getAllFilesByProcess(long Tags, int Proceso);
+        public Task<FileManager> getFileById(long id);
+        public Task deleteFileByProcess(long id, int Proceso);
+
+    }
+}

GEMCO.Backend/Contracts/Utils/IFilePaths4ProcessRepository.cs

@@ -0,0 +1,10 @@
+using System.Numerics;
+using GEMCO.Backend.Models.Utils;
+
+namespace GEMCO.Backend.Contracts.Utils
+{
+    public interface IFilePaths4ProcessRepository
+    {
+        public Task<FilePaths4Process> getPaths4ProcessById(long id);
+    }
+}

GEMCO.Backend/Contracts/Utils/IPDFGenerator.cs

@@ -0,0 +1,9 @@
+using GEMCO.Backend.Models.Clientes.CasaCuervo;
+
+namespace GEMCO.Backend.Contracts.Utils
+{
+    public interface IPDFGenerator
+    {
+        public Task<byte[]> GeneratePdfFromString(string htmlContent);
+    }
+}

GEMCO.Backend/Contracts/Utils/IValidaFraccion.cs

@@ -0,0 +1,7 @@
+namespace GEMCO.Backend.Contracts.Utils
+{
+    public interface IValidaFraccion
+    {
+        public Boolean ValidaFraccion(string Fraccion);
+    }
+}

GEMCO.Backend/Contracts/Utils/Notificaciones/INotificacionesRepository.cs

@@ -0,0 +1,20 @@
+using GEMCO.Backend.DTO.Utils;
+using GEMCO.Backend.Models.Utils.Notificaciones;
+
+namespace GEMCO.Backend.Contracts.Utils.Notificaciones
+{
+    public interface INotificacionesRepository
+    {
+        public Task<INotificacionesContactos> ContactosAppend(INotificacionesContactos data);
+        public Task<IEnumerable<INotificacionesContactos>> ContactosGet();
+        public Task<INotificacionesGrupos> GruposAppend(INotificacionesGrupos data);
+        public Task<IEnumerable<INotificacionesGrupos>> GruposGet();
+        public Task<Boolean> ContactosGruposAppend(INotificacionesContactosGrupos data);
+        public Task<Boolean> AccionContactosGrupos(DTONotificacionesContactoGrupo data);
+        public Task<IEnumerable<INotificacionesContactos>> ContactosdelGrupoGet(int IdGrupo);
+        public Task<INotificacionesCatalogo> CatalogoAppend(INotificacionesCatalogo data);
+        public Task<IEnumerable<INotificacionesCatalogo>> CatalogoGet();
+        public Task<Boolean> NotificacionesLogAppend(int IdUsuario, string Concepto, int IdGrupo);
+        public Task<IEnumerable<INotificacionesLog>> NotificacionesLogGet();
+    }
+}

GEMCO.Backend/Controllers/AgenciaAduanal/AvisoCruceController.cs

@@ -0,0 +1,119 @@
+using DinkToPdf;
+using DinkToPdf.Contracts;
+using Microsoft.AspNetCore.Mvc;
+
+// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
+
+namespace GEMCO.Backend.Controllers.AgenciaAduanal
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AvisoCruceController : ControllerBase
+    {
+        private readonly IConverter _converter;
+
+        public AvisoCruceController(IConverter converter)
+        {
+            _converter = converter;
+        }
+
+        // GET: api/<AvisoCruceController>
+        [HttpGet]
+        public IEnumerable<string> Get()
+        {
+            return new string[] { "value1", "value2" };
+        }
+
+        // GET api/<AvisoCruceController>/5
+        [HttpGet("{id}")]
+        public string Get(int id)
+        {
+            return "value";
+        }
+
+        // POST api/<AvisoCruceController>
+        [HttpPost]
+        public IActionResult Post([FromBody] string value)
+        {
+            DateTime now = DateTime.Now;
+            string bgcolor = "", Issues = "", InOutText = "", ControlNumber = "", CarrierName = "", Forklift = "", InTime = "", TotPallets = "", Today = "", Trailer = "", OutTime = "", DriverName = "", TotWeight = "";
+            var Info = $@"<table style='border:1px solid #000000; font-family:Ariel; font-size: 16px; text-align:left; background-color: {bgcolor}'>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}; text-align:center; font-size:18px;'><th style='border:1px solid #000000;' colspan='6'>JOHNSON CONTROLS {InOutText} FORM</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><td style='border:1px solid #000000;'> # 115</td><th style='border:1px solid #000000;' colspan='2'>: {ControlNumber}</th><th style='border:1px solid #000000;' colspan='3'>CARRIER/BROKER NAME:</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th style='border:1px solid #000000;' colspan='3'>&nbsp;</th><th style='border:1px solid #000000;' colspan='3'>{CarrierName}</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}; font-weight:bold;'><td style='border:1px solid #000000;'>DATE :</td><th style='border:1px solid #000000;' colspan='2'>{Today}</th><th style='border:1px solid #000000;' colspan='3'>DRIVER NAME: {DriverName}</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th style='border:1px solid #000000;' colspan='3'>Forklift Driver Name: {Forklift}</th><th style='border:1px solid #000000;' colspan='3'>TRAILER # {Trailer}</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th style='border:1px solid #000000;' colspan='3'>TABLET ISSUES OR DRIVER CONCERNS:</th><th colspan='2' style='text-align:center; border:1px solid #000000;'>IN TIME</th><td style='border:1px solid #000000; text-align:center; font-weight:bold;'>OUT TIME</td></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th colspan='3'>{Issues}</th><th style='text-align:center;  font-weight:normal;' colspan='2'> {InTime}</th><td style='text-align:center;'>{OutTime}</td></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th colspan='3'>&nbsp;</th><th colspan='2'></th><td></td></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th colspan='3'>&nbsp;</th><th colspan='2'></th><td></td></tr>" +
+            $@"<tr style='font-size: 18px; font-weight:bold; text-align:center;'><th colspan='2'>PALLET STICKER NUMBER</td><td>WEIGHT</td><td colspan='2'>PALLET STICKER NUMBER</td><td>WEIGHT<td></tr>";
+            Info += $@"<tr style='font-size: 18px; font-weight:bold; text-align:center; style='border:1px solid #000000;'><th colspan='2'>TOTAL PALLET COUNT</td><td>TOT WEIGHT</td><td colspan='3'>LOADER SIGNATURE</td></tr>";
+            Info += $@"<tr style='font-size: 18px; font-weight:bold; text-align:center; style='border:1px solid #000000;'><th colspan='2' style='font-size: 24px;'>{TotPallets}</td><th colspan='2' style='font-size: 24px;'>{string.Format("{0:N2}", TotWeight)} LB</th><td colspan='2'></td></tr>";
+            Info += "</table>";
+            var html = $@"
+               <!DOCTYPE html>
+               <html lang=""en"">
+               <head>
+               </head>
+                  <body style='background-color:{bgcolor}'>
+                  {Info}
+                  </body>
+              </html>
+            ";
+            GlobalSettings globalSettings = new GlobalSettings();
+            globalSettings.ColorMode = ColorMode.Color;
+            globalSettings.Orientation = Orientation.Portrait;
+            globalSettings.PaperSize = PaperKind.A4;
+            globalSettings.Margins = new MarginSettings { Top = 25, Bottom = 25 };
+            ObjectSettings objectSettings = new ObjectSettings();
+            objectSettings.PagesCount = true;
+            objectSettings.HtmlContent = html;
+            WebSettings webSettings = new WebSettings();
+            webSettings.DefaultEncoding = "utf-8";
+            HeaderSettings headerSettings = new HeaderSettings();
+            headerSettings.FontSize = 15;
+            headerSettings.FontName = "Ariel";
+            headerSettings.Right = "";
+            headerSettings.Line = false;
+            FooterSettings footerSettings = new FooterSettings();
+            footerSettings.FontSize = 12;
+            footerSettings.FontName = "Ariel";
+            footerSettings.Center = "";
+            footerSettings.Line = false;
+            objectSettings.HeaderSettings = headerSettings;
+            objectSettings.FooterSettings = footerSettings;
+            objectSettings.WebSettings = webSettings;
+            HtmlToPdfDocument htmlToPdfDocument = new HtmlToPdfDocument()
+            {
+                GlobalSettings = globalSettings,
+                Objects = { objectSettings },
+            };
+            var pdfFile = _converter.Convert(htmlToPdfDocument);
+            Stream stream = new MemoryStream(pdfFile);
+            SaveStreamAsFile("c:\\downs\\temp", stream, now.ToString("MM_dd_yyyy_HH_mm_ss") + ".pdf");
+            return new OkObjectResult(new { respuesta = "Archivo generado" });
+        }
+
+        public static void SaveStreamAsFile(string filePath, Stream inputStream, string fileName)
+        {
+            DirectoryInfo info = new DirectoryInfo(filePath);
+            if (!info.Exists) { info.Create(); }
+            string path = Path.Combine(filePath, fileName);
+            using (FileStream outputFileStream = new FileStream(path, FileMode.Create)) { inputStream.CopyTo(outputFileStream); }
+            // CreateMessageWithAttachment(filePath + "\\" + fileName, Status);
+        }
+
+        // PUT api/<AvisoCruceController>/5
+        [HttpPut("{id}")]
+        public void Put(int id, [FromBody] string value)
+        {
+        }
+
+        // DELETE api/<AvisoCruceController>/5
+        [HttpDelete("{id}")]
+        public void Delete(int id)
+        {
+        }
+    }
+}

GEMCO.Backend/Controllers/AnexoFacturacion/AnexoFacturacionController.cs

@@ -0,0 +1,46 @@
+using System.CodeDom.Compiler;
+using GEMCO.Backend.Models.AnexoFacturacion;
+using GEMCO.Backend.Contracts.AnexoFacturacion;
+using GEMCO.Backend.DTO.AnexoFacturacion;
+using Microsoft.AspNetCore.Mvc;
+
+namespace GEMCO.Backend.Controllers.AnexoFacturacion
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class AnexoFacturacionController : ControllerBase
+    {
+
+        public IConfiguration _configuration;
+        private readonly IAnexoFacturacionRepository _Repo;
+        public AnexoFacturacionController(IConfiguration config, IAnexoFacturacionRepository Repo)
+        {
+            _configuration = config;
+            _Repo = Repo;
+        }
+
+        [Route("GetRptAnexoFacturacionMission")]
+        [HttpPost]
+        public async Task<IEnumerable<RptAnexoFacturacionMission>> GetRptAnexoFacturacionMission(DTOAnexoFacturacionMission data)
+        {
+            var result = await _Repo.GetRptAnexoFacturacionMission(data);
+            return result;
+        }
+
+        [Route("GetRptConsolidadosSinCerrar")]
+        [HttpPost]
+        public async Task<IEnumerable<RptConsolidadosSinCerrar>> GetRptConsolidadosSinCerrar()
+        {
+            var result = await _Repo.GetRptConsolidadosSinCerrar();
+            return result;
+        }
+
+        [Route("GetRptAnexoFacturacionAlen")]
+        [HttpPost]
+        public async Task<IEnumerable<RptAnexoFacturacionAlen>> GetRptAnexoFacturacionAlen(DTOAnexoFacturacionAlen data)
+        {
+            var result = await _Repo.GetRptAnexoFacturacionAlen(data);
+            return result;
+        }
+    }
+}

GEMCO.Backend/Controllers/ArchivoElectronicoController.cs

@@ -0,0 +1,213 @@
+using GEMCO.Backend.Contracts;
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.Models.Reportes;
+using Microsoft.AspNetCore.Mvc;
+using GEMCO.Backend.Services.ArchivoElectronicoOficial;
+using GEMCO.Backend.DTO.ArchivoElectronico;
+using GEMCO.Backend.DTO.Battery;
+
+namespace GEMCO.Backend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class ArchivoElectronicoController : ControllerBase
+    {
+        private readonly IClientesRepository _clientesRepo;
+        private readonly IReportesRepository _reportesRepo;
+        private readonly IArchivoElectronico _AERepo;
+        private readonly IConfiguration _config;
+        private readonly string DOCsPath;
+        private readonly string PicturesPath;
+
+        public ArchivoElectronicoController(IClientesRepository usuariosRepo, IReportesRepository reportesRepo, IArchivoElectronico AERepo,
+         IConfiguration config)
+        {
+            _config = config;
+            _clientesRepo = usuariosRepo;
+            _reportesRepo = reportesRepo;
+            _AERepo = AERepo;
+            DOCsPath = _config.GetValue<string>("pathArchivoElectronico");
+            PicturesPath = _config.GetValue<string>("pathFotosBodega");
+        }
+
+        [HttpPost]
+        [Route("upload")]
+        public async Task<ActionResult> UploadImageFromWarehouse(IFormFile image)
+        {
+            string fullPath = PicturesPath;
+            if (image.Length > 0 && (image.FileName.EndsWith(".jpg") || image.FileName.EndsWith(".png")))
+            {
+                var fileName = image.FileName;
+                if (fileName.Contains("_"))
+                {
+                    var arrfileName = fileName.Split('_');
+                    string Proceso = arrfileName[0];
+                    string Referencia = arrfileName[1];
+                    if (Proceso == "1") Proceso = "01 CAJA LLEGO";
+                    if (Proceso == "2") Proceso = "02 RECIBO ASI LLEGO";
+                    if (Proceso == "3") Proceso = "03 REVISION";
+                    if (Proceso == "4") Proceso = "04 ASI SE FUE";
+                    if (Proceso == "5") Proceso = "05 DANOS SIN GEMCO";
+                    if (Proceso == "6") Proceso = "06 ETIQUETADO";
+                    if (Proceso == "7") Proceso = "07 MANIOBRAS ARCOSA";
+                    fullPath = PicturesPath + Proceso + "\\" + Referencia;
+                    if (!Directory.Exists(fullPath))
+                    {
+                        DirectoryInfo di = Directory.CreateDirectory(fullPath);
+                    }
+                    if (image.FileName.Contains(Referencia))
+                    {
+                        var filePath = Path.Combine(PicturesPath + Proceso + "\\" + Referencia, image.FileName);
+                        fullPath = filePath;
+                        using (var stream = System.IO.File.Create(filePath)) { await image.CopyToAsync(stream); }
+                    }
+
+                }
+            }
+            //  return Ok(new { respuesta = "The file has been uploaded." });
+            LogFotosBodega log = await _AERepo.createLogFotosBodega(
+                new LogFotosBodega
+                {
+                    Id = 0,
+                    Nombre = image.FileName,
+                    Proceso = 0,
+                    Referencia = "",
+                    Registrado = "",
+                    Creado = "",
+                    Usuario = "",
+                    Activo = true
+                });
+            long fileLength = new System.IO.FileInfo(fullPath).Length / 1024;
+            return Ok(new { respuesta = "The file has been uploaded.", size = fileLength });
+        }
+
+        [HttpGet]
+        [Route("getLogFotosBodega")]
+        public async Task<List<LogFotosBodega>> getFotosBodega([FromQuery] DTOLogFotosBodega data)
+        {
+            List<LogFotosBodega> _data = await _AERepo.getLogFotosBodega(data);
+            return _data;
+        }
+
+        [HttpGet, DisableRequestSizeLimit]
+        [Route("getPictureContent")]
+        public IActionResult getPictureContent([FromQuery] LogFotosBodega data)
+        {
+            var arrFileName = data.Nombre.Split('_');
+            String Proceso = arrFileName[0], Referencia = arrFileName[1], targetFile = "";
+            if (Proceso == "1") Proceso = "01 CAJA LLEGO";
+            if (Proceso == "2") Proceso = "02 RECIBO ASI LLEGO";
+            if (Proceso == "3") Proceso = "03 REVISION";
+            if (Proceso == "4") Proceso = "04 ASI SE FUE";
+            if (Proceso == "5") Proceso = "05 DANOS SIN GEMCO";
+            if (Proceso == "6") Proceso = "06 ETIQUETADO";
+            if (Proceso == "7") Proceso = "07 MANIOBRAS ARCOSA";
+            targetFile = PicturesPath + Proceso + "\\" + Referencia + "\\" + data.Nombre;
+            byte[] pdfBytes = System.IO.File.ReadAllBytes(targetFile);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            return new FileStreamResult(ms, "image/jpeg");
+        }
+
+        [HttpGet, DisableRequestSizeLimit]
+        [Route("getFile")]
+        public async Task<IActionResult> getPDFContent([FromQuery] ArchivoElectronico data)
+        {
+            SArchivoElectronicoOficial SAEO = new SArchivoElectronicoOficial(_clientesRepo, _reportesRepo, _AERepo, _config);
+            byte[] pdfBytes = await SAEO.GetPDFContent(data);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            return new FileStreamResult(ms, "application/pdf");
+        }
+
+        // Proceso que genera un archivo zip a partir de un inicio y fin de fechas con todos los PDFs dentro de estas fechas
+        [HttpPost, DisableRequestSizeLimit]
+        [Route("downloadPDFs")]
+        public async Task<IActionResult> DownloadPDFs(DTOPedimentosSeleccion data)
+        {
+            SArchivoElectronicoOficial SAEO = new SArchivoElectronicoOficial(_clientesRepo, _reportesRepo, _AERepo, _config);
+            byte[] pdfBytes = await SAEO.GetSeveralPDFs(data);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            var resp = HttpContext.Response;
+            resp.ContentType = "application/octet-stream";
+            resp.Headers.Add("Content-Disposition", "attachment; filename=todosPedimentos.zip");
+            return new FileStreamResult(ms, "application/zip");
+        }
+
+
+        [HttpGet]
+        [Route("RptArchivoElectronicoOficial")]
+        public async Task<List<RptPedimentosPagadosAEO>> GetReporteArchivElectronicoOficial([FromQuery] DTOAEPeriodo DTOData)
+        {
+            List<RptPedimentosPagadosAEO> data = await _AERepo.getRptPedimentoPagadosAEO(DTOData);
+            return data;
+        }
+
+        [HttpPost, DisableRequestSizeLimit]
+        [Route("downloadReferencesByPeriod")]
+        public async Task<IActionResult> downloadReferenceByPeriod(DTOAEPeriodoSeleccion DTOData)
+        {
+            DateTime now = DateTime.Now;
+            string Start = now.ToString("dd_MM_yy_hh_mm_ss");
+            SArchivoElectronicoOficial SAEO = new SArchivoElectronicoOficial(_clientesRepo, _reportesRepo, _AERepo, _config);
+            byte[] pdfBytes = await SAEO.GetReferenceFilesByPeriod(DTOData, Start);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            var resp = HttpContext.Response;
+            resp.ContentType = "application/octet-stream";
+            resp.Headers.Add("Content-Disposition", "attachment; filename=" + Start + ".zip");
+            return new FileStreamResult(ms, "application/zip");
+        }
+
+
+        [HttpPost, DisableRequestSizeLimit]
+        [Route("getFilesByReference")]
+        public async Task<IActionResult> getFilesByReference(ArchivoElectronicoSeleccion data)
+        {
+            DateTime now = DateTime.Now;
+            string Start = now.ToString("dd_MM_yy_hh_mm_ss");
+            SArchivoElectronicoOficial SAEO = new SArchivoElectronicoOficial(_clientesRepo, _reportesRepo, _AERepo, _config);
+            byte[] pdfBytes = await SAEO.GetFilesByReference(data, Start);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            var resp = HttpContext.Response;
+            resp.ContentType = "application/octet-stream";
+            resp.Headers.Add("Content-Disposition", "attachment; filename=" + data.Referencia + ".zip");
+            return new FileStreamResult(ms, "application/zip");
+        }
+
+
+        [HttpGet]
+        [Route("getFileList")]
+        public async Task<IActionResult> getFileList([FromQuery] ArchivoElectronicoSeleccion data)
+        {
+            var arrPedimentoLargo = data.PedimentoLargo.Split(' ');
+            string Patente = arrPedimentoLargo[1];
+            string Pedimento = arrPedimentoLargo[2];
+            string nombreCliente = await _clientesRepo.GetCustomerName(data.NoCliente);
+            string Anio = "20" + data.Referencia.Substring(0, 2);
+            string targetFolder = DOCsPath + nombreCliente + "\\" + Anio + "\\" + data.Referencia;
+            SArchivoElectronicoOficial SAEO = new SArchivoElectronicoOficial(_clientesRepo, _reportesRepo, _AERepo, _config);
+            List<AOCheckList> MatchingFiles = await SAEO.RegExpFilesInChecklist(data, Patente, Pedimento);
+            List<string> SelectedFiles = SAEO.GetSelectedFilelist(data, MatchingFiles, targetFolder);
+            var FilterFileNames = SelectedFiles.Select(x => x.Replace(targetFolder + "\\", string.Empty)).ToList();
+            return Ok(FilterFileNames);
+        }
+
+
+        [HttpGet, DisableRequestSizeLimit]
+        [Route("getFileContent")]
+        public async Task<IActionResult> getFileContent([FromQuery] ArchivoElectronico data)
+        {
+            string nombreCliente = await _clientesRepo.GetCustomerName(data.NoCliente);
+            if (nombreCliente.Length < 1) return NotFound();
+            string Anio = "20" + data.Referencia.Substring(0, 2);
+            string fileMime = data.Archivo.Substring(data.Archivo.Length - 3).ToLower();
+            var mime = "application/" + fileMime.ToLower();
+            if (fileMime == "pdf") mime = "application/pdf";
+            else if (fileMime == "xml") mime = "application/xml";
+            else mime = "text/plain";
+            string targetFile = DOCsPath + nombreCliente + "\\" + Anio + "\\" + data.Referencia + "\\" + data.Archivo;
+            byte[] pdfBytes = System.IO.File.ReadAllBytes(targetFile);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            return new FileStreamResult(ms, mime);
+        }
+    }
+}

GEMCO.Backend/Controllers/AuthController.cs

@@ -0,0 +1,215 @@
+using GEMCO.Backend.Models;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using Microsoft.AspNetCore.Mvc;
+using GEMCO.Backend.Contracts;
+using GEMCO.Backend.DTO;
+using Microsoft.AspNetCore.Authorization;
+using GEMCO.Backend.DTO.Usuario;
+using GEMCO.Backend.Services.Utilerias;
+using GEMCO.Backend.Clientes.ZincInternacional.DTO;
+
+namespace GEMCO.Backend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AuthController : ControllerBase
+    {
+        public IConfiguration _config;
+        private readonly IUsuariosRepository _usuariosRepo;
+        private readonly IPerfilesRepository _perfilesRepo;
+        private readonly IMenuRepository _menuRepo;
+
+        public AuthController(IConfiguration config, IUsuariosRepository usuariosRepo, IMenuRepository menuRepo, IPerfilesRepository perfilesRepo)
+        {
+            _config = config;
+            _usuariosRepo = usuariosRepo;
+            _perfilesRepo = perfilesRepo;
+            _menuRepo = menuRepo;
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> Post(DTOLogin _userData)
+        {
+            if (_userData.Contrasena == _config.GetValue<string>("DefaultUser:Password"))
+            {
+                return StatusCode(401, "La primera vez que accese debera cambiar su contraseña!");
+            }
+            if (_userData != null && _userData.Usuario != null && _userData.Contrasena != null)
+            {
+                var user = await _usuariosRepo.GetUsuario(_userData);
+                if (user == null) return BadRequest("Invalid credentials");
+                if (user != null)
+                {
+                    var menu = await _menuRepo.GetItemsMenu(user);
+                    var claims = new List<Claim>();
+                    var ProfileData = await _perfilesRepo.PerfilGetById(user.Id);
+                    claims.Add(new Claim(JwtRegisteredClaimNames.Sub, _config["Jwt:Subject"]));
+                    claims.Add(new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()));
+                    claims.Add(new Claim(JwtRegisteredClaimNames.Iat, DateTime.UtcNow.ToString()));
+                    claims.Add(new Claim("UserId", user.Id.ToString()));
+                    claims.Add(new Claim("Usuario", user.Usuario));
+                    claims.Add(new Claim("Departamento", (user.sDept ?? user.sDept ?? "No asignado")));
+                    claims.Add(new Claim("UserType", (user != null) ? user.TipoUsuario.ToString() : "0"));
+                    claims.Add(new Claim("Perfil", ProfileData.Perfil));
+                    foreach (Menu item in menu) { claims.Add(new Claim(ClaimTypes.Role, item.Url)); }
+                    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
+                    var signIn = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
+                    var token = new JwtSecurityToken(
+                        _config["Jwt:Issuer"],
+                        _config["Jwt:Audience"],
+                        claims,
+                        expires: DateTime.UtcNow.AddHours(Int32.Parse(_config["Jwt:ExpirationHours"])),
+                        //expires: DateTime.UtcNow.AddMinutes(5),
+                        signingCredentials: signIn);
+
+                    var _token = new JwtSecurityTokenHandler().WriteToken(token);
+                    return new OkObjectResult(new { menu = menu, token = _token });
+                }
+                else
+                {
+                    return BadRequest("Invalid credentials");
+                }
+            }
+            else
+            {
+                return BadRequest();
+            }
+        }
+
+        [HttpGet]
+        [Route("GetPermissions")]
+        public async Task<IActionResult> GetPermissions(string Usuario, string Contrasena)
+        {
+            DTOLogin _userData = new DTOLogin();
+            _userData.Usuario = Usuario;
+            _userData.Contrasena = Contrasena;
+            if (_userData.Contrasena == _config.GetValue<string>("DefaultUser:Password"))
+            {
+                return StatusCode(401, "La primera vez que accese debera cambiar su contraseña!");
+            }
+            if (_userData != null && _userData.Usuario != null && _userData.Contrasena != null)
+            {
+                var user = await _usuariosRepo.GetUsuario(_userData);
+                if (user == null) return BadRequest("Invalid credentials");
+                if (user != null)
+                {
+                    var menu = await _menuRepo.GetItemsMenu(user);
+                    var claims = new List<Claim>();
+                    /*        claims.Add(new Claim(JwtRegisteredClaimNames.Sub, _config["Jwt:Subject"]));
+                           claims.Add(new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()));
+                           claims.Add(new Claim(JwtRegisteredClaimNames.Iat, DateTime.UtcNow.ToString()));
+                           claims.Add(new Claim("UserId", user.Id.ToString()));
+                           claims.Add(new Claim("Usuario", user.Usuario));
+                           claims.Add(new Claim("Departamento", (user.sDept ?? user.sDept ?? "No asignado")));
+                           claims.Add(new Claim("UserType", (user != null) ? user.TipoUsuario.ToString() : "0")); */
+                    foreach (Menu item in menu) { claims.Add(new Claim(ClaimTypes.Role, item.Url)); }
+                    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
+                    var signIn = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
+                    var token = new JwtSecurityToken(
+                        _config["Jwt:Issuer"],
+                        _config["Jwt:Audience"],
+                        claims,
+                        expires: DateTime.UtcNow.AddHours(Int32.Parse(_config["Jwt:ExpirationHours"])),
+                        //expires: DateTime.UtcNow.AddMinutes(5),
+                        signingCredentials: signIn);
+
+                    var _token = new JwtSecurityTokenHandler().WriteToken(token);
+                    return new OkObjectResult(new { menu = menu, token = _token });
+                }
+                else
+                {
+                    return BadRequest("Invalid credentials");
+                }
+            }
+            else
+            {
+                return BadRequest();
+            }
+        }
+
+        [HttpGet]
+        [Route("GetEnvironment")]
+        public IActionResult GetEnvironment()
+        {
+            return StatusCode(200, Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") + ' ' + _config.GetValue<string>("AmazonPyAPI"));
+        }
+
+        [HttpPost]
+        [Route("validatePIN")]
+        public async Task<IActionResult> validatePIN(DTOPINUsuario userData)
+        {
+            var EsPINValido = await _usuariosRepo.ValidatePIN(userData);
+            if (!EsPINValido)
+            {
+                //return new OkObjectResult(new { respuesta = "Acceso denegado" });
+                //return NotFound();
+                //return BadRequest(new { respuesta = "Acceso denegado" });
+                return StatusCode(403, "Acceso denegado");
+            }
+            return new OkObjectResult(new { respuesta = "Continua con el proceso" });
+        }
+
+        [HttpPost]
+        [Route("forgotPassword")]
+        public async Task<IActionResult> forgotPassword(DTOLogin userData)
+        {
+            if (userData == null) return BadRequest(new { respuesta = "Usuario invalido" });
+            int IdUser = await _usuariosRepo.searchUsuario(userData.Usuario);
+            if (IdUser == 0) return StatusCode(403, "Acceso denegado");
+            DTOPINData PINData = await _usuariosRepo.CreatePIN(IdUser);
+            string htmlContent = $@"<table>
+                    <tr><td>Estimado usuario, mediante este correo se le notifica que esta en proceso de cambiar su contraseña</td></tr>
+                    <tr><td>Se ha generado un PIN para poder cambiar su contraseña. PIN :  <b>{PINData.PIN}</b> </td></tr>
+                    <tr><td>El PIN tiene un tiempo de vida de 10 minutos, a partir de su generacion, despues de ese tiempo caduca</td></tr>
+                    <tr><td>Si usted <b>no</b> es quien ha activando este mecanismo, favor de ponerse en contacto con personal de GEMCO</td></tr>
+                    </table>";
+            if (PINData.PIN > 0)
+            {
+                Utilerias email = new Utilerias(_config);
+                var dataEmail = new DTOSendEmail()
+                {
+                    To = PINData.Correo,
+                    Subject = "GEMCO informa: Se le generado un PIN para el cambio de su contraseña, expira en 10 minutos",
+                    Text = "GEMCO informa: Se le generado un PIN para el cambio de su contraseña, expira en 10 minutos",
+                    Html = htmlContent
+                };
+                await email.SendEmail(dataEmail);
+                return new OkObjectResult(new { respuesta = "Continua con el proceso" });
+            }
+            return BadRequest(new { respuesta = "Invalid Request" });
+        }
+
+
+        [Route("resetPassword")]
+        [HttpPost]
+        public async Task<IActionResult> resetPassword(DTOResetPassword data)
+        {
+            try
+            {
+                var result = await _usuariosRepo.resetPassword(data);
+                if (result == null)
+                {
+                    return StatusCode(400, "Cuenta de usuario no existe");
+                }
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex);
+            }
+        }
+
+
+        [Authorize]
+        [Route("Validate")]
+        [HttpGet]
+        public IActionResult GetValidation()
+        {
+            return StatusCode(200, "Its Ok");
+        }
+
+    }
+}

GEMCO.Backend/Controllers/BatteryController.cs

@@ -0,0 +1,220 @@
+using DinkToPdf;
+using DinkToPdf.Contracts;
+using GEMCO.Backend.Contracts;
+using GEMCO.Backend.DTO.Battery;
+using GEMCO.Backend.DTO.Reportes;
+using GEMCO.Backend.Models;
+using Microsoft.AspNetCore.Mvc;
+using System.Net;
+using System.Net.Mail;
+using System.Net.Mime;
+
+// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
+
+namespace GEMCO.Backend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class BatteryController : ControllerBase
+    {
+        private readonly IBatteryRepository _batteryRepo;
+        private readonly IConverter _converter;
+
+        public BatteryController(IBatteryRepository batteryRepo, IConverter converter)
+        {
+            _batteryRepo = batteryRepo;
+            _converter = converter;
+        }
+
+        [HttpGet]
+        [Route("getPalletWeight")]
+        public async Task<double> GetPalletWeight(string IDPallet)
+        {
+            var entrada = await _batteryRepo.getPalletWeight(IDPallet);
+            return entrada;
+        }
+
+        [HttpPost]
+        [Route("sendEntry")]
+        public async Task<BatteryEntry> sendEntry([FromBody] DTOBatteryEntry data)
+        {
+            var entrada = await _batteryRepo.updatePallete2Warehouse(data);
+            return entrada;
+        }
+
+
+        [HttpPost("GeneratePDF")]
+        public async Task<DTOBatteryInfo> GeneratePDF([FromBody] DTOBatteryInfo data)
+        {
+            var Entry = await _batteryRepo.getBatteryInfo(data);
+            DateTime now = DateTime.Now;
+            string Trailer = "", ControlNumber = "", Today = "", CarrierName = "", DriverName = "", Forklift = "", Issues = "", InTime = "", OutTime = "";
+            string InOutText = "";
+            string bgcolor = "";
+            int r = 0;
+            List<string> Renglones = new List<string>() { };
+            int MaxRow = 24;
+            string color = "";
+            int TotPallets = Entry.Count();
+            double TotWeight = 0;
+            foreach (BatteryEntry row in Entry)
+            {
+                if (r == 0)
+                {
+                    Trailer = row.Trailer;
+                    ControlNumber = row.ControlNumber;
+                    Today = (row.Today != null) ? row.Today : "";
+                    CarrierName = row.CarrierName;
+                    DriverName = row.DriverName;
+                    Forklift = row.Forklift;
+                    Issues = (row.Issues != null) ? row.Issues : "";
+                    InTime = row.InTime;
+                    OutTime = (row.OutTime != null) ? row.OutTime : "";
+                }
+                if (r++ % 2 == 0) color = "#FFFFFF"; else color = bgcolor;
+                if (r <= MaxRow) Renglones.Add($@"<tr style='padding-top:5px; padding-bottom:5px; text-align:center; background-color:{color}'><td width='60px'>I/A</td><td style='font-size:26px; text-align:center;' width='300px'>" + row.IDPallet + "</td><td style='font-size:26px; text-align:right; padding-right:10px;' width='150'>" + row.Weight + " LB </td>");
+                else
+                {
+                    string val = Renglones[r - (MaxRow + 1)];
+                    Renglones[r - (MaxRow + 1)] = val + "<td width='60px'>I/A</td><td style='font-size:26px; text-align:center;' width='300px'>" + row.IDPallet + "</td><td style='font-size:26px; text-align:right; padding-right:10px;' width='150px'>" + row.Weight + " LB </td></tr>";
+                }
+                TotWeight += row.Weight;
+            }
+            // Termina la primer columna
+            int last = r;
+            if (last < MaxRow)
+            {
+                for (int i = (last - 1); i <= MaxRow - 1; i++)
+                {
+                    if (r++ % 2 == 0) color = "#FFFFFF"; else color = bgcolor;
+                    Renglones.Add($@"<tr style='padding-top:5px; padding-bottom:5px; text-align:center; background-color:{color}'><td width='60px'>I/A</td><td style='font-size:26px; text-align:center;' width='300px'>500 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-&nbsp;&nbsp;&nbsp;&nbsp;</td><td style='font-size:26px; text-align:right; padding-right:10px;' width='150'>&nbsp; LB </td>");
+                }
+            }
+            // Termina la segunda columna
+            last = r - 1;
+            if (last < (MaxRow * 2))
+            {
+                for (int i = (last - 1); i <= (MaxRow * 2) - 2; i++)
+                {
+                    string val = Renglones[(i - MaxRow) + 1];
+                    Renglones[(i - MaxRow) + 1] = val + $@"<td style='color:#000000;' background-color:{color} width='60px'>I/A</td><td style='font-size:26px; text-align:center;' width='300px'>500 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-&nbsp;&nbsp;&nbsp;&nbsp;</td><td style='font-size:26px; text-align:right; padding-right:10px;' width='150px'>&nbsp; LB </td></tr>";
+                }
+            }
+            string content = "";
+            for (int i = 0; i <= MaxRow - 1; i++) { content += Renglones[i]; }
+            if (data.InOut == 1)
+            {
+                InOutText = "INBOUND";
+                bgcolor = "#DBF1C3";
+            }
+            else
+            {
+                InOutText = "OUTBOUND";
+                bgcolor = "#75DCFE";
+            }
+            var Info = $@"<table style='border:1px solid #000000; font-family:Ariel; font-size: 16px; text-align:left; background-color: {bgcolor}'>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}; text-align:center; font-size:18px;'><th style='border:1px solid #000000;' colspan='6'>JOHNSON CONTROLS {InOutText} FORM</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><td style='border:1px solid #000000;'> # 115</td><th style='border:1px solid #000000;' colspan='2'>: {ControlNumber}</th><th style='border:1px solid #000000;' colspan='3'>CARRIER/BROKER NAME:</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th style='border:1px solid #000000;' colspan='3'>&nbsp;</th><th style='border:1px solid #000000;' colspan='3'>{CarrierName}</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}; font-weight:bold;'><td style='border:1px solid #000000;'>DATE :</td><th style='border:1px solid #000000;' colspan='2'>{Today}</th><th style='border:1px solid #000000;' colspan='3'>DRIVER NAME: {DriverName}</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th style='border:1px solid #000000;' colspan='3'>Forklift Driver Name: {Forklift}</th><th style='border:1px solid #000000;' colspan='3'>TRAILER # {Trailer}</th></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th style='border:1px solid #000000;' colspan='3'>TABLET ISSUES OR DRIVER CONCERNS:</th><th colspan='2' style='text-align:center; border:1px solid #000000;'>IN TIME</th><td style='border:1px solid #000000; text-align:center; font-weight:bold;'>OUT TIME</td></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th colspan='3'>{Issues}</th><th style='text-align:center;  font-weight:normal;' colspan='2'> {InTime}</th><td style='text-align:center;'>{OutTime}</td></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th colspan='3'>&nbsp;</th><th colspan='2'></th><td></td></tr>" +
+            $@"<tr style='border:1px solid #000000; background-color:{bgcolor}'><th colspan='3'>&nbsp;</th><th colspan='2'></th><td></td></tr>" +
+            $@"<tr style='font-size: 18px; font-weight:bold; text-align:center;'><th colspan='2'>PALLET STICKER NUMBER</td><td>WEIGHT</td><td colspan='2'>PALLET STICKER NUMBER</td><td>WEIGHT<td></tr>";
+            Info += content;
+            Info += $@"<tr style='font-size: 18px; font-weight:bold; text-align:center; style='border:1px solid #000000;'><th colspan='2'>TOTAL PALLET COUNT</td><td>TOT WEIGHT</td><td colspan='3'>LOADER SIGNATURE</td></tr>";
+            Info += $@"<tr style='font-size: 18px; font-weight:bold; text-align:center; style='border:1px solid #000000;'><th colspan='2' style='font-size: 24px;'>{TotPallets}</td><th colspan='2' style='font-size: 24px;'>{string.Format("{0:N2}", TotWeight)} LB</th><td colspan='2'></td></tr>";
+            Info += "</table>";
+            var html = $@"
+               <!DOCTYPE html>
+               <html lang=""en"">
+               <head>
+               </head>
+                  <body style='background-color:{bgcolor}'>
+                  {Info}
+                  </body>
+              </html>
+            ";
+            GlobalSettings globalSettings = new GlobalSettings();
+            globalSettings.ColorMode = ColorMode.Color;
+            globalSettings.Orientation = Orientation.Portrait;
+            globalSettings.PaperSize = PaperKind.A4;
+            globalSettings.Margins = new MarginSettings { Top = 25, Bottom = 25 };
+            ObjectSettings objectSettings = new ObjectSettings();
+            objectSettings.PagesCount = true;
+            objectSettings.HtmlContent = html;
+            WebSettings webSettings = new WebSettings();
+            webSettings.DefaultEncoding = "utf-8";
+            HeaderSettings headerSettings = new HeaderSettings();
+            headerSettings.FontSize = 15;
+            headerSettings.FontName = "Ariel";
+            headerSettings.Right = "";
+            headerSettings.Line = false;
+            FooterSettings footerSettings = new FooterSettings();
+            footerSettings.FontSize = 12;
+            footerSettings.FontName = "Ariel";
+            footerSettings.Center = "";
+            footerSettings.Line = false;
+            objectSettings.HeaderSettings = headerSettings;
+            objectSettings.FooterSettings = footerSettings;
+            objectSettings.WebSettings = webSettings;
+            HtmlToPdfDocument htmlToPdfDocument = new HtmlToPdfDocument()
+            {
+                GlobalSettings = globalSettings,
+                Objects = { objectSettings },
+            };
+            var pdfFile = _converter.Convert(htmlToPdfDocument);
+            Stream stream = new MemoryStream(pdfFile);
+            SaveStreamAsFile("c:\\downs\\temp", stream, now.ToString("MM_dd_yyyy_HH_mm_ss") + ".pdf", data.InOut);
+            return data;
+        }
+
+        public static void SaveStreamAsFile(string filePath, Stream inputStream, string fileName, int Status)
+        {
+            DirectoryInfo info = new DirectoryInfo(filePath);
+            if (!info.Exists) { info.Create(); }
+            string path = Path.Combine(filePath, fileName);
+            using (FileStream outputFileStream = new FileStream(path, FileMode.Create)) { inputStream.CopyTo(outputFileStream); }
+            CreateMessageWithAttachment(filePath + "\\" + fileName, Status);
+        }
+
+        public static void CreateMessageWithAttachment(string file, int Status)
+        {
+            string InOut = "";
+            if (Status == 1) InOut = "Entry";
+            else InOut = "Departure";
+            try
+            {
+                using (var smtp = new SmtpClient("146.20.161.11", 587))
+                {
+                    smtp.Credentials = new NetworkCredential("noreply@gemcousa.com", "N#16rm87");
+                    var correo = new MailMessage();
+                    correo.From = new MailAddress("noreply@gemcousa.com", "noreply");
+                    correo.To.Add("agarcia@gemcousa.com");
+                    correo.Subject = InOut + " notification";
+                    correo.Body = InOut + " notification";
+                    Attachment data = new Attachment(file, MediaTypeNames.Application.Octet);
+                    correo.Attachments.Add(data);
+                    smtp.Send(correo);
+                }
+            }
+            catch (Exception ex)
+            {
+                if (ex.Source != null)
+                    Console.WriteLine("Error, Battery Controller: {0}", ex.Source);
+                throw;
+            }
+        }
+
+        [HttpGet]
+        [Route("getWarehouseReport")]
+        public async Task<IEnumerable<BatteryEntry>> getWarehouseReport([FromQuery] DTOReporte data)
+        {
+            var entrada = await _batteryRepo.getReportFromWarehouse(data);
+            return entrada;
+        }
+
+    }
+}

GEMCO.Backend/Controllers/Catalogos/CorresponsalesController.cs

@@ -0,0 +1,56 @@
+
+using GEMCO.Backend.Models.Catalogos;
+using GEMCO.Backend.Contracts.Catalogos;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+
+namespace GEMCO.Backend.Controllers.Catalogos
+{
+    [Authorize]
+    [Route("api/Catalogos/[controller]")]
+    public class CorresponsalesController : Controller
+    {
+        private readonly ICorresponsalesRepository _Repo;
+        private readonly IConfiguration _config;
+        private readonly string ZipsCorresponsalesPath;
+        private readonly string CorresponsalesFilePath;
+
+        public CorresponsalesController(ICorresponsalesRepository Repo, IConfiguration config)
+        {
+            _config = config;
+            _Repo = Repo;
+            ZipsCorresponsalesPath = _config.GetValue<string>("pathZipCorresponsales");
+            CorresponsalesFilePath = _config.GetValue<string>("CorresponsalesFilePath");
+        }
+
+        [Route("getAll")]
+        [HttpGet]
+        public async Task<IEnumerable<CatCorresponsales>> GatAll()
+        {
+            var entrada = await _Repo.GetAll();
+            return entrada;
+        }
+
+        [Route("getAllFormated")]
+        [HttpGet]
+        public async Task<IEnumerable<CatCorresponsales>> getAllFormated()
+        {
+            var entrada = await _Repo.GetAllFormated();
+            return entrada;
+        }
+
+        [Route("Append")]
+        [HttpPost]
+        public async Task<CatCorresponsales> Append([FromBody] CatCorresponsales data)
+        {
+            var entrada = await _Repo.Append(data);
+            return entrada;
+        }
+
+        [HttpDelete("Delete/{id}")]
+        public async Task<CatCorresponsales> Delete(int id)
+        {
+            return await _Repo.Delete(id);
+        }
+    }
+}

GEMCO.Backend/Controllers/Catalogos/ProveedoresController.cs

@@ -0,0 +1,47 @@
+using GEMCO.Backend.Contracts.Catalogos;
+using GEMCO.Backend.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace GEMCO.Backend.Controllers.Catalogos
+{
+    [Authorize]
+    [Route("api/Catalogos/Corresponsales/[controller]")]
+    [ApiController]
+    public class ProveedoresController : Controller
+    {
+        private readonly IProveedoresRepository _Repo;
+        private readonly IConfiguration _config;
+
+        public ProveedoresController(IProveedoresRepository Repo, IConfiguration config)
+        {
+            _config = config;
+            _Repo = Repo;
+        }
+
+        /// Catalogo de Proveedores
+        [HttpGet]
+        [Route("getAll")]
+        public async Task<IEnumerable<CatProveedores>> GetAll(int Clasificacion)
+        {
+            var entrada = await _Repo.GetAll(Clasificacion);
+            return entrada;
+        }
+
+        [HttpPost]
+        [Route("Append")]
+        public async Task<CatProveedores> Append([FromBody] CatProveedores data)
+        {
+            var entrada = await _Repo.Append(data);
+            return entrada;
+        }
+
+        [HttpDelete("Delete/{id}")]
+        public async Task<IActionResult> Delete(int id)
+        {
+            await _Repo.Delete(id);
+            return new OkObjectResult(new { respuesta = "Se elimino el registro" });
+        }
+
+    }
+}

GEMCO.Backend/Controllers/Catalogos/TabuladorController.cs

@@ -0,0 +1,52 @@
+using GEMCO.Backend.Contracts.Catalogos;
+using GEMCO.Backend.Models.Catalogos;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+
+namespace GEMCO.Backend.Controllers.Catalogos
+{
+    [Authorize]
+    [Route("api/Catalogos/[controller]")]
+    public class TabuladorController : ControllerBase
+    {
+
+        private readonly ITabuladorRepository _Repo;
+        private readonly IConfiguration _config;
+
+        public TabuladorController(ITabuladorRepository Repo, IConfiguration config)
+        {
+            _config = config;
+            _Repo = Repo;
+        }
+
+        [HttpGet]
+        [Route("getAll")]
+        public async Task<IEnumerable<Tabulador>> GetAll(int id, int IdCliente)
+        {
+            return await _Repo.GetAll(id, IdCliente);
+        }
+
+        [HttpGet]
+        [Route("getByCustomer")]
+        public async Task<IEnumerable<Tabulador>> GetByCustomer(int IdCliente)
+        {
+            return await _Repo.GetAll(0, IdCliente);
+        }
+
+
+        [HttpPost]
+        [Route("Append")]
+        public async Task<Tabulador> Post([FromBody] Tabulador data)
+        {
+            return await _Repo.Append(data);
+        }
+
+        [HttpDelete("Delete/{id}")]
+        public async Task<IActionResult> Delete(int id)
+        {
+            await _Repo.Delete(id);
+            return new OkObjectResult(new { respuesta = "Se elimino el registro" });
+        }
+    }
+}

GEMCO.Backend/Controllers/Catalogos/TabuladorDetalleController.cs

@@ -0,0 +1,58 @@
+using GEMCO.Backend.Contracts.Catalogos;
+using GEMCO.Backend.Models.Catalogos;
+using GEMCO.Backend.DTO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+
+namespace GEMCO.Backend.Controllers.Catalogos
+{
+    [Authorize]
+    [Route("api/Catalogos/[controller]")]
+    [ApiController]
+    public class TabuladorDetalleController : ControllerBase
+    {
+        private readonly ITabuladorDetalleRepository _Repo;
+        private readonly IConfiguration _config;
+
+        public TabuladorDetalleController(ITabuladorDetalleRepository Repo, IConfiguration config)
+        {
+            _config = config;
+            _Repo = Repo;
+        }
+
+        [HttpGet]
+        [Route("getDetailByIdTab")]
+        public async Task<IEnumerable<TabuladorDetalle>> GetDetailByIdTab(int id)
+        {
+            return await _Repo.GetDetailByIdTab(id);
+        }
+
+        [HttpGet]
+        [Route("getAll")]
+        public async Task<IEnumerable<TabuladorDetalle>> GetAll(int id, int IdTabulador)
+        {
+            return await _Repo.GetAll(id, IdTabulador);
+        }
+
+        [HttpGet]
+        [Route("Conceptos/getAllConcepts")]
+        public async Task<IEnumerable<DTOConceptos>> GetAllConcepts()
+        {
+            return await _Repo.GetAllConcepts();
+        }
+
+        [HttpPost]
+        [Route("Append")]
+        public async Task<IEnumerable<TabuladorDetalle>> Post([FromBody] TabuladorDetalle data)
+        {
+            return await _Repo.Append(data);
+        }
+
+        [HttpDelete("Delete/{id}")]
+        public async Task<IActionResult> Delete(int id)
+        {
+            await _Repo.Delete(id);
+            return new OkObjectResult(new { respuesta = "Se elimino el registro" });
+        }
+    }
+}

GEMCO.Backend/Controllers/Clientes/Amazon/AmazonInvoiceController.cs

@@ -0,0 +1,711 @@
+using Microsoft.AspNetCore.Mvc;
+using GEMCO.Backend.Clientes.Amazon.Contracts;
+using GEMCO.Backend.Clientes.Amazon.Model;
+using GEMCO.Backend.Clientes.Amazon.DTO;
+using GEMCO.Backend.Services.ValidaFraccion;
+using System.Net.Http.Headers;
+using System.Net;
+using GEMCO.Backend.Models;
+using GEMCO.Backend.DTO;
+using GEMCO.Backend.Contracts.Utils;
+using System.IO.Compression;
+using GEMCO.Backend.Models.Utils;
+using GEMCO.Backend.Services.Clientes.SAmazon;
+
+namespace GEMCO.Backend.Controllers.Clientes.Amazon
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class AmazonInvoiceController : ControllerBase
+    {
+        public IConfiguration _config;
+        private readonly IAmazonRepository _Repo;
+        private readonly String _connectionString;
+        private readonly IPDFGenerator _RepoPDFGenerator;
+        private readonly string TempRootPath, PathArchivoElectronico, URLPythonAPI, URLEjsAPI, URLNodeAPI, DefaultFilePath;
+
+        public AmazonInvoiceController(IConfiguration config, IAmazonRepository Repo, IPDFGenerator RepoPDFGenerator)
+        {
+            _config = config;
+            _Repo = Repo;
+            _RepoPDFGenerator = RepoPDFGenerator;
+            _connectionString = _config.GetConnectionString("SqlConnection");
+            TempRootPath = _config.GetValue<string>("pathTemp");
+            PathArchivoElectronico = _config.GetValue<string>("PathArchivoElectronico");
+            URLPythonAPI = _config.GetValue<string>("AmazonPyAPI");
+            URLEjsAPI = _config.GetValue<string>("AmazonEJSAPI");
+            URLNodeAPI = _config.GetValue<string>("AmazonNodeAPI");
+            DefaultFilePath = _config.GetValue<string>("AllFiles");
+        }
+
+        /*************************************** Procesos Iniciales *************************************/
+        [HttpGet]
+        [Route("C2096ValidaFraccion")]
+        public IActionResult C2096ValidaFraccion(string Fraccion)
+        {
+            Fraccion = Fraccion.Replace(".", "");
+            if (Fraccion.Length != 10)
+            {
+                return Ok(new { Respuesta = "No" });
+            }
+            SrvValidaFraccion SrvValFraccion = new SrvValidaFraccion();
+            Boolean resultado = SrvValFraccion.ValidaFraccion(Fraccion);
+            if (resultado) return Ok(new { Respuesta = "Si" });
+            return Ok(new { Respuesta = "No" });
+        }
+        [HttpGet]
+        [Route("ValidaFraccionesIniciales")]
+        public async Task<Boolean> ValidaFraccionesIniciales()
+        {
+            var Fracciones = await _Repo.GetFraccionesPendientesValidar();
+            SrvValidaFraccion SrvValFraccion = new SrvValidaFraccion();
+            foreach (DTO2096Fraccion row in Fracciones)
+            {
+                await _Repo.SetFraccionPendienteValidar(row.Id, SrvValFraccion.ValidaFraccion(row.Fraccion.Replace(".", "")));
+            }
+            return true;
+        }
+        [HttpPut]
+        [Route("AsignaFactura")]
+        public async Task<Boolean> AsignaFactura(int IdUsuario, int IdFactura)
+        {
+            return await _Repo.AssignInvoice(IdUsuario, IdFactura);
+        }
+
+
+        [HttpGet]
+        [Route("ValidacionWebService")]
+        public async Task<IEnumerable<DTO2096Fraccion>> ValidacionWebService()
+        {
+            var Partidas = await _Repo.PartidasPendingWebServiceGet();
+            foreach (DTO2096Fraccion partida in Partidas)
+            {
+                var Fraccion = partida.Fraccion.Replace(".", "");
+                if (Fraccion.Length == 10)
+                {
+                    SrvValidaFraccion SrvValFraccion = new SrvValidaFraccion();
+                    Boolean resultado = SrvValFraccion.ValidaFraccion(Fraccion);
+                }
+            }
+            return Partidas;
+        }
+
+        /*************************************** Procesos Iniciales *************************************/
+
+
+        /*************************************** Pending Clasification *************************************/
+        [HttpGet]
+        [Route("AmazonPendingClasificationInvoiceGet")]
+        public async Task<List<I2096Header>> AmazonPendingClasificationInvoice()
+        {
+            var entrada = await _Repo.AmazonPendingClasificationInvoiceGet();
+            return entrada;
+        }
+
+        [HttpGet]
+        [Route("InvoicePendingFromAmazonGet")]
+        public async Task<List<I2096Header>> InvoicePendingFromAmazonGet()
+        {
+            var entrada = await _Repo.InvoicePendingFromAmazonGet();
+            return entrada;
+        }
+
+        [HttpPut]
+        [Route("C2096FraccionDescripcionSET")]
+        public async Task<I2096Detail> C2096SetFraccionDescripcion(DTO2096FraccionDescripcion data)
+        {
+            var entrada = await _Repo.SetFraccionDescripcion(data);
+            return entrada;
+        }
+
+        [HttpPost]
+        [Route("C2096FraccionSet")]
+        public async Task<I2096Detail> C2096SetFraccion(DTO2096Fraccion data)
+        {
+            var entrada = await _Repo.FraccionSet(data);
+            return entrada;
+        }
+
+        [HttpPost]
+        [Route("C2096DescripcionSet")]
+        public async Task<I2096Detail> C2096SetDescripcion(DTO2096Descripcion data)
+        {
+            var entrada = await _Repo.DescripcionSet(data);
+            return entrada;
+        }
+
+        [HttpPut]
+        [Route("C2096CheckDetail")]
+        public async Task<I2096Detail> C2096CheckDetail(int id)
+        {
+            return await _Repo.CheckDetail(id);
+        }
+        [HttpGet]
+        [Route("SePuedeTerminardeClasificarFactura")]
+        public async Task<DTO2096Estatus> SePuedeTerminardeClasificarFactura(int id)
+        {
+            return await _Repo.SePuedeTerminardeClasificarFactura(id);
+        }
+        [HttpGet]
+        [Route("SeRecibioRespuestaDeAmazon")]
+        public async Task<DTO2096Estatus> SeRecibioRespuestaDeAmazon(int id)
+        {
+            return await _Repo.SeRecibioRespuestaDeAmazon(id);
+        }
+        /* [HttpGet]
+        [Route("SePuedeTerminardeClasificarFacturaEsperandoRespuesta")]
+        public async Task<DTORespuesta> SePuedeTerminardeClasificarFacturaEsperandoRespuesta(int id)
+        {
+            return await _Repo.SePuedeTerminardeClasificarFacturaEsperandoRespuesta(id);
+        } */
+        [HttpGet]
+        [Route("EnviaEsperaRespuestaAmazon")]
+        public async Task<Boolean> EnviaEsperaRespuestaAmazon(int id)
+        {
+            return await _Repo.EnviaEsperaRespuestaAmazon(id);
+        }
+
+        [HttpPut]
+        [Route("ArchivoRespuestaAmazon")]
+        public async Task<Boolean> ArchivoRespuestaAmazon(int Id, Int64 IdFile)
+        {
+            return await _Repo.ArchivoRespuestaAmazon(Id, IdFile);
+        }
+
+        [HttpPut]
+        [Route("InvoiceReturnState")]
+        public async Task<Boolean> InvoiceReturnState(Int64 IdFactura, byte Estatus)
+        {
+            return await _Repo.InvoiceReturnState(Estatus, IdFactura);
+        }
+
+        [HttpDelete]
+        [Route("AmazonInvoiceDELETE")]
+        public async Task<Boolean> AmazonInvoiceDELETE(int Id)
+        {
+            return await _Repo.AmazonInvoiceDELETE(Id);
+        }
+
+        /*************************************** End Pending Clasification *************************************/
+
+
+        /*************************************** Finished Clasification *************************************/
+        [HttpGet]
+        [Route("AmazonFinishedClasificationInvoiceGet")]
+        public async Task<List<I2096Header>> AmazonFinishedClasificationInvoiceGet()
+        {
+            var entrada = await _Repo.AmazonFinishedClasificationInvoiceGet();
+            return entrada;
+        }
+        [HttpPut]
+        [Route("C2096AutorizaItemFactura")]
+        public async Task<I2096Detail> C2096AutorizaItemFactura(DTO2096FraccionDescripcion data)
+        {
+            return await _Repo.AutorizadoItemFactura(data);
+        }
+        [HttpGet]
+        [Route("TerminaClasificarFactura")]
+        public async Task<Boolean> TerminaClasificarFactura(int id)
+        {
+            return await _Repo.TerminaClasificarFactura(id);
+        }
+        /*************************************** End Finished Clasification *************************************/
+
+
+        /****************************************** Pending Traffic ******************************************/
+        [HttpGet]
+        [Route("AmazonPendingTraficInvoiceGet")]
+        public async Task<List<I2096Header>> AmazonPendingTraficInvoiceGet()
+        {
+            var entrada = await _Repo.AmazonPendingTraficInvoiceGet();
+            return entrada;
+        }
+        /**************************************** End Pending Traffic *****************************************/
+
+
+        /****************************************** Linking Traffic ******************************************/
+        [HttpGet]
+        [Route("AmazonLinkInvoice2TrafficGet")]
+        public async Task<List<I2096Header>> AmazonLinkInvoice2TrafficGet()
+        {
+            var entrada = await _Repo.AmazonLinkInvoice2TrafficGet();
+            return entrada;
+        }
+        [HttpPut]
+        [Route("AmazonSightLineSET")]
+        public async Task<DTO2096SightLine> AmazonSightLineSET(DTO2096SightLine data)
+        {
+            return await _Repo.SightLineSET(data);
+        }
+        [HttpGet]
+        [Route("SePuedeTerminarXTraficoFactura")]
+        public async Task<DTORespuesta> SePuedeTerminarXTraficoFactura(int id)
+        {
+            return await _Repo.SePuedeTerminarXTraficoFactura(id);
+        }
+        [HttpGet]
+        [Route("TerminaXTraficoFactura")]
+        public async Task<Boolean> TerminaXTraficoFactura(int id)
+        {
+            return await _Repo.TerminaXTraficoFactura(id);
+        }
+        [HttpPost]
+        [Route("AsignaFacturasReferencia")]
+        public async Task<Boolean> AsignaFacturasReferencia(DTO2096LinkInvoice2Reference data)
+        {
+            return await _Repo.AsignaFacturasReferencia(data);
+        }
+        [HttpPost]
+        [Route("DesasociaFacturasReferencia")]
+        public async Task<Boolean> DesasociaFacturasReferencia(DTO2096LinkInvoice2Reference data)
+        {
+            return await _Repo.AsignaFacturasReferencia(data);
+        }
+        [HttpPut]
+        [Route("TrafficFieldsUpdate")]
+        public async Task<I2096Detail> TrafficUpdateFields(DTO2096TrafficFieldsUpdate data)
+        {
+            return await _Repo.TrafficFieldsUpdate(data);
+        }
+        /***************************************End Linking Traffic ******************************************/
+
+        [HttpGet]
+        [Route("RELParteFacturasGET")]
+        public async Task<List<DTO2096RELParteFactura>> RELParteFacturasGET(Int16 id)
+        {
+            var entrada = await _Repo.RELParteFactruraGET(id);
+            return entrada;
+        }
+
+        /*****************************************Payed Operations *****************************************/
+        [HttpGet]
+        [Route("AmazonPayedOperationsGET")]
+        public async Task<List<DTO2096RptOperacionesPagadas>> AmazonPayedOperationsGET(String Inicio, String Fin)
+        {
+            var entrada = await _Repo.AmazonPayedOperationsGET(Inicio, Fin);
+            return entrada;
+        }
+        /***********************************************************************************************/
+
+        /***************************************  Procesos Auxiliares ******************************************/
+        [HttpGet]
+        [Route("NoPartesGet")]
+        public async Task<IEnumerable<I2096NoPartes>> NoPartesGet(string Search)
+        {
+            return await _Repo.NoPartesGet(Search);
+        }
+
+        [HttpPut]
+        [Route("NoPartesUpdate")]
+        public async Task<I2096NoPartes> NoPartesUpdate(DTO2096NoParte data)
+        {
+            return await _Repo.NoPartesUpdate(data);
+        }
+        [HttpGet]
+        [Route("NoPartesLogGET")]
+        public async Task<IEnumerable<I2096NoParteLog>> NoPartesLogGET(Int64 id)
+        {
+            return await _Repo.NoPartesLogGET(id);
+        }
+        [HttpGet]
+        [Route("NoParteVerificacionGET")]
+        public async Task<IEnumerable<DTO2096NoParteVerificacion>> NoParteVerificacionGET(String Parte)
+        {
+            return await _Repo.NoParteVerificacion(Parte);
+        }
+
+        [HttpGet]
+        [Route("PaisClavesGet")]
+        public async Task<IEnumerable<I2096PaisClaves>> PaisClavesGet()
+        {
+            return await _Repo.PaisClavesGet();
+        }
+
+        [Route("GetNoPartesAmazon2SIR")]
+        [HttpGet, DisableRequestSizeLimit]
+        public async Task<IActionResult> GetNoPartesAmazon2SIR(int id)
+        {
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            try
+            {
+                using (var client = GetHttpClient(URLNodeAPI + "/getNoPartesAmazon?id=" + id))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        var resp = HttpContext.Response;
+                        resp.ContentType = "application/vnd.ms-excel";
+                        resp.Headers.Add("Content-Disposition", "attachment; filename=PlantillaPartesSIR.xlsx");
+                        return new FileStreamResult(ms, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+                    }
+                    return new FileStreamResult(emptyms, "image/png");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+                return new FileStreamResult(emptyms, "image/png");
+            }
+        }
+
+        [Route("ExceptionsFileAmazonGET")]
+        [HttpGet, DisableRequestSizeLimit]
+        public async Task<IActionResult> ExceptionsFileAmazonGET(int id)
+        {
+            var generaLogExcepciones = await _Repo.GeneraLogArchivoExcepciones(id);
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            String ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+            try
+            {
+                using (var client = GetHttpClient(URLNodeAPI + "/getExceptionsFile4Amazon?id=" + id))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        var resp = HttpContext.Response;
+                        resp.ContentType = "application/vnd.ms-excel";
+                        resp.Headers.Add("Content-Disposition", "attachment; filename=ExceptionsFile.xlsx");
+                        return new FileStreamResult(ms, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+                    }
+                    return new FileStreamResult(emptyms, ContentType);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+                return new FileStreamResult(emptyms, "image/png");
+            }
+        }
+
+        [HttpGet]
+        [Route("AmazonInvoiceGET")]
+        public async Task<List<I2096Header>> AmazonInvoiceGET(int id)
+        {
+            return await _Repo.AmazonInvoiceGet(id);
+        }
+
+        [HttpGet]
+        [Route("AmazonShippingInfoGET")]
+        public async Task<IEnumerable<I2096ShipFromAddress>> AmazonShippingInfoGET(int id)
+        {
+            return await _Repo.AmazonShippingInfo(id);
+        }
+
+        [HttpGet]
+        [Route("PDFAmazonInvoiceGET")]
+        public async Task<IActionResult> PDFAmazonInvoiceGET(int id)
+        {
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            try
+            {
+                //using (var client = GetHttpClient(URLEJSAPI + "getAmazonInvoicePDF?id=" + id))
+                using (var client = GetHttpClient(URLEjsAPI + "getAmazonInvoicePDF?id=" + id))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        var resp = HttpContext.Response;
+                        resp.ContentType = "application/pdf";
+                        resp.Headers.Add("Content-Disposition", "attachment; filename=AmazonInvoice.pdf");
+                        return new FileStreamResult(ms, "application/pdf");
+                    }
+                    return new FileStreamResult(emptyms, "image/png");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+                Response.ContentType = "application/pdf";
+                Response.Headers.Add("content-disposition", $"attachment; filename=AmazonInvoice.pdf");
+                return new FileStreamResult(emptyms, "image/png");
+            }
+        }
+
+
+        [HttpGet]
+        [Route("GETAmazonPartidasByReference")]
+        public async Task<IActionResult> GETAmazonPartidasByReference(string referencia)
+        {
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            try
+            {
+                using (var client = GetHttpClient(URLNodeAPI + "/getAmazonPartidasByReferenceV2?referencia=" + referencia))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    String ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        var resp = HttpContext.Response;
+                        resp.ContentType = ContentType;
+                        resp.Headers.Add("Content-Disposition", "attachment; filename=PARTIDAS_MODIFICA.xls");
+                        return new FileStreamResult(ms, ContentType);
+                    }
+                    return new FileStreamResult(emptyms, ContentType);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+                Response.ContentType = "application/pdf";
+                Response.Headers.Add("content-disposition", $"attachment; filename=AmazonInvoice.png");
+                return new FileStreamResult(emptyms, "image/png");
+            }
+        }
+
+        [HttpGet]
+        [Route("GETAmazonFacturasByReference")]
+        public async Task<IActionResult> GETAmazonFacturasByReference(string referencia)
+        {
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            try
+            {
+                using (var client = GetHttpClient(URLNodeAPI + "/getAmazonFacturasByReferenceV2?referencia=" + referencia))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    String ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        var resp = HttpContext.Response;
+                        resp.ContentType = ContentType;
+                        resp.Headers.Add("Content-Disposition", "attachment; filename=FACTURAS_MODIFICA.xls");
+                        return new FileStreamResult(ms, ContentType);
+                    }
+                    return new FileStreamResult(emptyms, ContentType);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+                Response.ContentType = "image/png";
+                Response.Headers.Add("content-disposition", $"attachment; filename=NotFound.png");
+                return new FileStreamResult(emptyms, "image/png");
+            }
+        }
+
+        [HttpGet]
+        [Route("SETInvoiceDetail2Unchecked")]
+        public async Task<Boolean> SETInvoiceDetail2Unchecked(int id)
+        {
+            return await _Repo.SETInvoiceDetail2Unchecked(id);
+        }
+
+        [HttpGet]
+        [Route("SETInvoiceDetailRevalidateParts")]
+        public async Task<Boolean> SETInvoiceDetailRevalidateParts(int id)
+        {
+            return await _Repo.SETInvoiceDetailRevalidateParts(id);
+        }
+
+        [HttpGet]
+        [Route("AmazonInvoiceStatusGET")]
+        public async Task<IEnumerable<DTO2096InvoiceStatus>> AmazonInvoiceStatusGET(String Invoice)
+        {
+            return await _Repo.InvoiceStatusGET(Invoice);
+        }
+
+        [HttpGet]
+        [Route("AmazonInvoicePrioritySET")]
+        public async Task<IEnumerable<I2096Header>> AmazonInvoicePrioritySET(int Id, Boolean Prioridad)
+        {
+            return await _Repo.InvoicePrioritySET(Id, Prioridad);
+        }
+
+
+        [HttpGet]
+        [Route("SyncInvoicesInFilePath")]
+        public async Task<IActionResult> SyncInvoicesThruWeb()
+        {
+            try
+            {
+                using (var client = GetHttpClient(URLPythonAPI + "LoadInvoicesInFilePath"))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        return new OkObjectResult(new { respuesta = "Termino proceso" });
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, new { respuesta = "Ocurrio un error: " + ex.ToString() });
+            }
+            return StatusCode(500, new { respuesta = "Ocurrio un error" });
+        }
+
+        [HttpGet]
+        [Route("CreateACKFile")]
+        public async Task<IActionResult> CreateACKFile(String Referencia)
+        {
+            try
+            {
+                using (var client = GetHttpClient(URLPythonAPI + "CreateACKs?Referencia=" + Referencia))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        return new OkObjectResult(new { respuesta = "Termino proceso" });
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(409, new { respuesta = "No se pudo generar el archivo ACK " + ex.ToString() });
+            }
+            return StatusCode(409, new { respuesta = "No se pudo generar el archivo ACK" });
+        }
+
+
+        [HttpGet]
+        [Route("UploadACKFile2Amazon")]
+        public async Task<IActionResult> UploadACKFile2Amazon(String Referencia)
+        {
+            try
+            {
+                using (var client = GetHttpClient(URLPythonAPI + "FTPPutACK2Server?Referencia=" + Referencia))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        return new OkObjectResult(new { respuesta = "Termino proceso" });
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, new { respuesta = "Ocurrio un error: " + ex.ToString() });
+            }
+            return StatusCode(500, new { respuesta = "Ocurrio un error" });
+        }
+
+        [HttpGet]
+        [Route("SyncInvoicesByFTP")]
+        public async Task<IActionResult> SyncInvoicesByFTP()
+        {
+            try
+            {
+                using (var client = GetHttpClient(URLPythonAPI + "LoadInvoicesByFTP"))
+                {
+                    HttpResponseMessage response = await client.GetAsync("");
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        return new OkObjectResult(new { respuesta = "Termino proceso" });
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, new { respuesta = "Ocurrio un error: " + ex.ToString() });
+            }
+            return StatusCode(500, new { respuesta = "Ocurrio un error" });
+        }
+
+
+        private static HttpClient GetHttpClient(string url)
+        {
+            var client = new HttpClient { BaseAddress = new Uri(url) };
+            client.DefaultRequestHeaders.Accept.Clear();
+            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("text/csv"));
+            return client;
+        }
+
+
+        [Route("GETACKFileById")]
+        [HttpGet, DisableRequestSizeLimit]
+        public async Task<IActionResult> GETACKFileById(int IDArchivoACK)
+        {
+            string EntireFilenamePath = await _Repo.GetACKFileById(IDArchivoACK);
+            byte[] Content = System.IO.File.ReadAllBytes(EntireFilenamePath);
+            MemoryStream FileContent = new MemoryStream(Content);
+            String ContentType = "application/xhtml+xml";
+            return new FileStreamResult(FileContent, ContentType)
+            {
+                FileDownloadName = "test.xml"
+            };
+        }
+        /*************************************** End Procesos Auxiliares ***************************************/
+
+        [HttpPost]
+        [Route("UploadSIRReference")]
+        public async Task<List<string>> UpdateSIRReference(List<IFormFile> files, String ArchivoM, String Aduana, String Patente, String Pedimento, String FPago, String TipoCambio, String Clave)
+        {
+            var target = TempRootPath;
+            Directory.CreateDirectory(target);
+            foreach (var file in files)
+            {
+                var filePath = Path.Combine(target, file.FileName);
+                using (var stream = new FileStream(filePath, FileMode.Create))
+                {
+                    await file.CopyToAsync(stream);
+                }
+            }
+
+            foreach (var file in files)
+            {
+                var filePath = Path.Combine(target, file.FileName);
+                string[] fileParts = file.FileName.Split("_____");
+                string[] Reference = fileParts[0].Split("-");
+                string zipPath = file.FileName;
+                string extractPath = PathArchivoElectronico + fileParts[1].Replace(".zip", "") + "\\20" + Reference[0] + "\\" + fileParts[0];
+                if (!Directory.Exists(extractPath)) ZipFile.ExtractToDirectory(filePath, extractPath);
+            }
+
+            var Referencias = new List<string>();
+            foreach (var file in files)
+            {
+                var filePath = Path.Combine(target, file.FileName);
+                string[] fileParts = file.FileName.Split("_____");
+                string[] Reference = fileParts[0].Split("-");
+                string zipPath = file.FileName;
+                string extractPath = PathArchivoElectronico + fileParts[1].Replace(".zip", "") + "\\20" + Reference[0] + "\\" + fileParts[0];
+                if (Directory.Exists(extractPath))
+                {
+                    Referencias.Add(fileParts[0]);
+                    await _Repo.InsertReferenciasSync2IONOS(fileParts[0], file.FileName, ArchivoM, Aduana, Patente, Pedimento, FPago, TipoCambio, Clave);
+                }
+            }
+            return Referencias;
+        }
+        /*********************************** Proceso recepcion de referencias ************************************/
+
+
+        /******************************* Fin del proceso recepcion de referencias **********************************/
+
+        /******************************************** Dashboard ********************************************/
+        [HttpGet]
+        [Route("DashboardInvoices")]
+        public async Task<DashboardTotal> DashboardInvoices(Int16 Mode)
+        {
+            return await _Repo.DashboardInvoicesGet(Mode);
+        }
+        /****************************************** End Dashboard *******************************************/
+
+
+        [HttpPost]
+        [Route("ApplyAnswerFile2Invoice")]
+        public async Task<Boolean> ApplyAnswerFile2Invoice(string[] Files)
+        {
+            foreach (string filename in Files)
+            {
+                SAmazonAnswerFile srv = new SAmazonAnswerFile(_config, _Repo);
+                Boolean result = await srv.ValidateAnswerFile(filename);
+            }
+            return true;
+        }
+    }
+}

GEMCO.Backend/Controllers/Clientes/CasaCuervo/PedidosController.cs

@@ -0,0 +1,534 @@
+using Microsoft.AspNetCore.Mvc;
+using GEMCO.Backend.Services.Clientes.SCasaCuervo;
+using GEMCO.Backend.Contracts.Clientes.CasaCuervo;
+using GEMCO.Backend.Models.Clientes.CasaCuervo;
+using GEMCO.Backend.DTO.Clientes.CasaCuervo;
+using GEMCO.Backend.Contracts.Utils;
+using GEMCO.Backend.Models.Utils;
+using System.Reflection.Metadata.Ecma335;
+/* using Microsoft.AspNetCore.Authorization;
+using GEMCO.Backend.Services.PDFGenerator; */
+
+namespace GEMCO.Backend.Controllers.Clientes.CasaCuervo
+{
+    /*     [Authorize] */
+    [Route("api/Clientes/CasaCuervo/[controller]")]
+    [ApiController]
+
+    public class PedidosController : ControllerBase
+    {
+        private readonly ICasaCuervoRepository _Repo;
+        private readonly IFileManagerRepository _RepoFM;
+        private readonly IFilePaths4ProcessRepository _RepoRelativePath;
+        private readonly IConfiguration _config;
+        private readonly string rootPath;
+        private readonly IPDFGenerator _RepoPDFGenerator;
+
+
+        public PedidosController(ICasaCuervoRepository Repo, IFileManagerRepository RepoFM,
+        IFilePaths4ProcessRepository RepoRelativePath, IConfiguration config, IPDFGenerator RepoPDFGenerator)
+        {
+            _Repo = Repo;
+            _RepoFM = RepoFM;
+            _RepoRelativePath = RepoRelativePath;
+            _RepoPDFGenerator = RepoPDFGenerator;
+            _config = config;
+            rootPath = _config.GetValue<string>("AllFiles");
+        }
+
+
+        [Route("uploadExcel")]
+        [HttpGet]
+        public async Task<Boolean> UploadExcel(long id, int Proceso)
+        {
+            if (Proceso == 5)
+            {
+                FileManager archivo = await _RepoFM.getFileById(id);
+                FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+                SCasaCuervo proc = new SCasaCuervo(_Repo, rootPath + RelativePath.Path + archivo.NombreArchivo);
+                var result = await proc.ReadExcel();
+                return result;
+            }
+            if (Proceso == 6)
+            {
+                FileManager archivo = await _RepoFM.getFileById(id);
+                FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+                SCasaCuervo proc = new SCasaCuervo(_Repo, rootPath + RelativePath.Path + archivo.NombreArchivo);
+                return await proc.UpdateInfoFromCorresponsal();
+            }
+            return false;
+        }
+
+        [Route("getAll")]
+        [HttpGet]
+        public async Task<IEnumerable<I325Pedidos>> getAll([FromQuery] string Inicio, string Fin, string Aduana)
+        {
+            return await _Repo.getAll(Inicio, Fin, Aduana);
+        }
+
+        [Route("GetById")]
+        [HttpGet]
+        public async Task<I325Pedidos> GetById(int Id)
+        {
+            return await _Repo.GetById(Id);
+        }
+
+        [Route("getAduanas")]
+        [HttpGet]
+        public async Task<IEnumerable<DTO325AduanasPedidos>> getAduanas(int Usuario, int TipoUsuario)
+        {
+            return await _Repo.getAduanas(Usuario, TipoUsuario);
+        }
+
+        /*  [HttpPut("Update/{id}/{Campo}/{Valor}")]
+         public async Task<I325Pedidos> Update(int id, string Campo, string Valor)
+         {
+             var entrada = await _Repo.Update(id, Campo, Valor);
+             return entrada;
+         } */
+
+        [HttpPut("UpdateInfo/{id}")]
+        public async Task<I325Pedidos> UpdateInfoFromWeb(int id, [FromBody] DTO325UpdateFromWeb data)
+        {
+            var entrada = await _Repo.UpdateInfoFromWeb(data);
+            return entrada;
+        }
+
+
+        [Route("GeneratePDF4CC")]
+        [HttpGet]
+        public async Task<IActionResult> GeneratePDF4CC(int id)
+        {
+            I325Pedidos data = await _Repo.GetById(id);
+
+            DateTime now = DateTime.Now;
+            string MedidaCaja = "";
+            if (data.MedidaCaja == "1") MedidaCaja = "Caja 53 pies";
+            if (data.MedidaCaja == "2") MedidaCaja = "Caja 48 pies";
+            if (data.MedidaCaja == "3") MedidaCaja = "Refrigerada 53 pies";
+            if (data.MedidaCaja == "4") MedidaCaja = "Pipa";
+            var htmlContent = $@"
+            <!DOCTYPE html>
+            <html lang=""en"">
+            <head>
+              <style>
+                  body {{ width: 99% }}     
+
+                  table, th, td {{
+                    font-family: Verdana;
+                    font-size: 14px; 
+                    border: 1px solid black;
+                    border-collapse: collapse;
+                    height: 39px;
+                  }}
+              </style>
+            </head>
+            <body>
+              <table width='100%'>
+                    <tr>
+                      <td>
+                       <table width='100%'>
+                         <tr> 
+                          <td>
+                          <img src=""c:\downs\images\GEMCO.png""/>
+                          </td>
+                          <th colspan='5'>
+                           Nota de revisión de mercancía y sellos de seguridad
+                          </th> 
+                         </tr>
+                       </table>   
+                      </td>
+                    </tr>
+                    <tr>
+                      <td style='text-align: right'>
+                        Fecha y hora de impresión:&nbsp;{now}&nbsp;
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>
+                        Sr Despachador / Tramitador
+                        <br />
+                        1. Tomar sellos de seguridad
+                        <br />
+                        2. Romper los sellos de seguridad de origen
+                        <br />
+                        3. Abrir caja trailer y tomar fotos de la mercancía
+                        <br />
+                        4. Vertificar números de lote contra factura
+                        <br />
+                        5. Contar la cantidad de bultos
+                        <br />
+                        6. Colocar la caja trailer y colocar nuevos sellos
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>Si no se cuenta con sellos del cliente, poner sellos de GEMCO previa autorización del cliente</td>
+                    </tr>
+                    <tr>
+                      <td>
+                        &nbsp;
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <table width='100%'>
+                          <tr>
+                            <td width='15%'>No. de pedido</td>
+                            <td width='15%'>No. de factura</td>
+                            <td width='15%'>Cartones</td>
+                            <td width='15%'>Bultos</td>
+                            <td width='20%'>No. de Caja</td>
+                            <td width='20%'>Medida de la caja</td>
+                          </tr>
+                          <tr>
+                            <td>{data.PO}</td>
+                            <td>{data.Factura}</td>
+                            <td>&nbsp;</td>
+                            <td>&nbsp;</td>
+                            <td>{data.TruckNumber}</td>
+                            <td>{MedidaCaja}</td>
+                          </tr>
+                        </table>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <span>Nombre de la línea: </span>
+                        {data.Carrier}
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <table width='100%'>
+                          <tr>
+                            <th colspan='6'>
+                              Número de sellos
+                            </th>
+                          </tr>
+                          <tr>
+                            <td width='30%'>
+                              Origen
+                            </td>
+                            <td width='10%'>
+                              Izquierdo
+                            </td>
+                            <td width='10%'>
+                              Derecho
+                            </td>
+                            <td width='30%'>
+                              Nuevos despues de la revisión
+                            </td>
+                            <td width='10%'>
+                              Izquierdo
+                            </td>
+                            <td width='10%'>
+                              Derecho
+                            </td>
+                          </tr>
+                          <tr>
+                            <td width='30%'>{data.Sello1}</td>
+                            <td width='10%'>
+                              &nbsp;
+                            </td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='30%'>
+                              &nbsp;
+                            </td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='10%'>
+                              &nbsp;
+                            </td>
+                          </tr>
+                          <tr>
+                            <td width='30%'>{data.Sello2}</td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='30%'>&nbsp;</td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='10%'>&nbsp;</td>
+                          </tr>
+                        </table>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td style='font-weight:bold'>
+                        <center>Número de placa y estado de Origen<center>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td style='font-weight:bold'>
+                        <center>Condiciones de la caja o pipa</center>
+                      </td>
+                    </tr>
+                    <tr height='90px'>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td style='font-weight:bold'>
+                        <center>Resultado de la revisión de la mercancía</center>
+                      </td>
+                    </tr>
+                    <tr height='90px'>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <table width='100%'>
+                          <tr>
+                            <td>&nbsp;</td>
+                            <td>&nbsp;</td>
+                          </tr>
+                          <tr>
+                            <th>Nombre y firma del revisor</th>
+                            <th>Fecha y hora de la revisión</th>
+                          </tr>
+                        </table>
+                      </td>
+                    </tr>
+                    <tr height='0px'>
+                     <td style='font-weight:bold; text-align: right;'>OM-F20&nbsp;</td>
+                    </tr> 
+                  </table>
+            </body>
+            </html>
+            ";
+            var pdfBytes = await _RepoPDFGenerator.GeneratePdfFromString(htmlContent);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            Response.ContentType = "application/pdf";
+            Response.Headers.Add("content-disposition", $"attachment; filename=Formato Revision Casa Cuervo.pdf");
+            return new FileStreamResult(ms, "application/pdf");
+        }
+
+
+        [Route("GenerateTempPDF")]
+        [HttpGet]
+        public async Task<IActionResult> GenerateTempPDF(string NoPedido, string NoCaja, int NMedidaCaja, string Factura, string Sello1, string Sello2, string Carrier)
+        {
+            //I325Pedidos data = await _Repo.GetById(id);
+
+            DateTime now = DateTime.Now;
+            string MedidaCaja = "";
+            if (NMedidaCaja == 1) MedidaCaja = "Caja 53 pies";
+            if (NMedidaCaja == 2) MedidaCaja = "Caja 48 pies";
+            if (NMedidaCaja == 3) MedidaCaja = "Refrigerada 53 pies";
+            if (NMedidaCaja == 4) MedidaCaja = "Pipa";
+            if (Sello1 == ".") Sello1 = "";
+            if (Sello2 == ".") Sello2 = "";
+            var htmlContent = $@"
+   <!DOCTYPE html>
+            <html lang=""en"">
+            <head>
+              <style>
+                  body {{ width: 99% }}
+                  table, th, td {{
+                    font-family: Verdana;
+                    font-size: 14px; 
+                    border: 1px solid black;
+                    border-collapse: collapse;
+                    height: 39px;
+                  }}
+              </style>
+            </head>
+            <body>
+              <table width='100%'>
+                    <tr>
+                      <td>
+                       <table width='100%'>
+                         <tr> 
+                          <td>
+                          <img src=""c:\downs\images\GEMCO.png""/>
+                          </td>
+                          <th colspan='5'>
+                           Nota de revisión de mercancía y sellos de seguridad
+                          </th> 
+                         </tr>
+                       </table>   
+                      </td>
+                    </tr>
+                    <tr>
+                    <tr>
+                      <td style='text-align: right'>
+                        Fecha y hora de impresion:&nbsp;{now}&nbsp;
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>
+                        Sr Despachador / Tramitador
+                        <br />
+                        1. Tomar sellos de seguridad
+                        <br />
+                        2. Romper los sellos de seguridad de origen
+                        <br />
+                        3. Abrir caja trailer y tomar fotos de la mercancía
+                        <br />
+                        4. Vertificar números de lote contra factura
+                        <br />
+                        5. Contar la cantidad de bultos
+                        <br />
+                        6. Colocar la caja trailer y colocar nuevos sellos
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>Si no se cuenta con sellos del cliente, poner sellos de GEMCO previa autorización del cliente</td>
+                    </tr>
+                    <tr>
+                      <td>
+                        &nbsp;
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <table width='100%'>
+                          <tr>
+                            <td width='15%'>No. de pedido</td>
+                            <td width='15%'>No. de factura</td>
+                            <td width='15%'>Cartones</td>
+                            <td width='15%'>Bultos</td>
+                            <td width='20%'>No. de Caja</td>
+                            <td width='20%'>Medida de la caja</td>
+                          </tr>
+                          <tr>
+                            <td>{NoPedido}</td>
+                            <td>{Factura}</td>
+                            <td>&nbsp;</td>
+                            <td>&nbsp;</td>
+                            <td>{NoCaja}</td>
+                            <td>{MedidaCaja}</td>
+                          </tr>
+                        </table>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <span>Nombre de la línea: {Carrier}</span>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <table width='100%'>
+                          <tr>
+                            <th colspan='6'>
+                              Número de sellos
+                            </th>
+                          </tr>
+                          <tr>
+                            <td width='30%'>
+                              Origen
+                            </td>
+                            <td width='10%'>
+                              Izquierdo
+                            </td>
+                            <td width='10%'>
+                              Derecho
+                            </td>
+                            <td width='30%'>
+                              Nuevos despues de la revisión
+                            </td>
+                            <td width='10%'>
+                              Izquierdo
+                            </td>
+                            <td width='10%'>
+                              Derecho
+                            </td>
+                          </tr>
+                          <tr>
+                            <td width='30%'>{Sello1}</td>
+                            <td width='10%'>
+                              &nbsp;
+                            </td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='30%'>
+                              &nbsp;
+                            </td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='10%'>
+                              &nbsp;
+                            </td>
+                          </tr>
+                          <tr>
+                            <td width='30%'>{Sello2}</td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='30%'>&nbsp;</td>
+                            <td width='10%'>&nbsp;</td>
+                            <td width='10%'>&nbsp;</td>
+                          </tr>
+                        </table>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td style='font-weight:bold'>
+                        <center>Número de placa y estado de Origen</center>
+                      </td>
+                    </tr>
+                    <tr>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td style='font-weight:bold'>
+                        <center>Condiciones de la caja o pipa</center>
+                      </td>
+                    </tr>
+                    <tr height='90px'>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td style='font-weight:bold'>
+                        <center>Resultado de la revisión de la mercancía</center>
+                      </td>
+                    </tr>
+                    <tr height='90px'>
+                      <td>&nbsp;</td>
+                    </tr>
+                    <tr>
+                      <td>
+                        <table width='100%'>
+                          <tr>
+                            <td>&nbsp;</td>
+                            <td>&nbsp;</td>
+                          </tr>
+                          <tr>
+                            <th>Nombre y firma del revisor</th>
+                            <th>Fecha y hora de la revisión</th>
+                          </tr>
+                        </table>
+                      </td>
+                    </tr>
+                    <tr height='0px'>
+                     <td style='font-weight:bold; text-align: right;'>OM-F20&nbsp;</td>
+                    </tr> 
+                  </table>
+            </body>
+            </html>
+            ";
+            var pdfBytes = await _RepoPDFGenerator.GeneratePdfFromString(htmlContent);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            Response.ContentType = "application/pdf";
+            Response.Headers.Add("content-disposition", $"attachment; filename=Formato Revision Casa Cuervo.pdf");
+            return new FileStreamResult(ms, "application/pdf");
+        }
+
+
+        [Route("GetRptCOVEs")]
+        [HttpGet]
+        public async Task<IEnumerable<I325RptCOVE>> GetRptCOVE([FromQuery] string Inicio, string Fin)
+        {
+            return await _Repo.GetRptCOVE(Inicio, Fin);
+        }
+    }
+}

GEMCO.Backend/Controllers/Clientes/Heineken/C2206ReportesController.cs

@@ -0,0 +1,69 @@
+using Microsoft.AspNetCore.Mvc;
+using GEMCO.Backend.Clientes.Heineken.Contracts;
+using GEMCO.Backend.Clientes.Heineken.Model;
+
+namespace GEMCO.Backend.Controllers.Clientes.Heineken
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class C2206ReportesController : ControllerBase
+    {
+
+        public IConfiguration _configuration;
+        private readonly IHeinekenRepository _reportesRepo;
+        public C2206ReportesController(IConfiguration config, IHeinekenRepository reportesRepo)
+        {
+            _configuration = config;
+            _reportesRepo = reportesRepo;
+        }
+
+        [HttpGet]
+        [Route("Rpt2206EmbarquesPorImportar")]
+        public async Task<IEnumerable<I2206RptEmbarquesPorImportar>> Rpt2206EmbarquesPorImportar()
+        {
+            var entrada = await _reportesRepo.GetHeinekenEmbarquesPorImportar();
+            return entrada;
+        }
+
+        [HttpGet]
+        [Route("Rpt2206EmbarquesPorMes")]
+        public async Task<IEnumerable<I2206RptMensual>> Rpt2206EmbarquesPorMes()
+        {
+            var entrada = await _reportesRepo.GetHeinekenEmbarquesPorMes();
+            return entrada;
+        }
+
+        [HttpGet]
+        [Route("Rpt2206ExpedienteDigital")]
+        public async Task<IEnumerable<I2206ExpedienteDigital>> Rpt2206ExpedienteDigital([FromQuery] string Ocurrencia)
+        {
+            var entrada = await _reportesRepo.GetHeinekenExpedienteDigital(Ocurrencia);
+            return entrada;
+        }
+
+
+        [HttpGet, DisableRequestSizeLimit]
+        [Route("Get2206AllFiles")]
+        public async Task<IActionResult> Get2206AllFiles([FromQuery] long id)
+        {
+            var entrada = await _reportesRepo.GetAllFiles(id);
+            // return entrada;
+            var Servicio = new GEMCO.Backend.Clientes.Heineken.Servicio.SvcZipAllFiles(_reportesRepo, _configuration);
+            byte[] pdfBytes = Servicio.ZipAllFiles(entrada);
+            MemoryStream ms = new MemoryStream(pdfBytes);
+            var resp = HttpContext.Response;
+            resp.ContentType = "application/octet-stream";
+            resp.Headers.Add("Content-Disposition", "attachment; filename=allFiles.zip");
+            return new FileStreamResult(ms, "application/zip");
+        }
+
+        [HttpGet]
+        [Route("Rpt2206FacturasTxt")]
+        public async Task<List<I2206RptFacturasTxtHeader>> Rpt2206FacturasTxt([FromQuery] string Inicio, [FromQuery] string Fin)
+        {
+            var entrada = await _reportesRepo.GetRptFacturasTxtHeader(Inicio, Fin);
+            return entrada;
+        }
+
+    }
+}