24deenero2022

.editorconfig

@@ -0,0 +1,4 @@
+[*.cs]
+
+# IDE0055: Fix formatting
+dotnet_diagnostic.IDE0055.severity = none

MyRestFullApiAmazonBackend.sln

@@ -0,0 +1,30 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.4.33205.214
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyRestFullApiAmazonBackend", "MyRestFullApiAmazonBackend\MyRestFullApiAmazonBackend.csproj", "{9DDC5E96-E8BB-40BE-B548-D5BB2D09B473}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{723D4200-0592-4A53-88D6-E8BA44D77F3C}"
+	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9DDC5E96-E8BB-40BE-B548-D5BB2D09B473}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9DDC5E96-E8BB-40BE-B548-D5BB2D09B473}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9DDC5E96-E8BB-40BE-B548-D5BB2D09B473}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9DDC5E96-E8BB-40BE-B548-D5BB2D09B473}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3D119632-DB40-4D06-921D-ABB50DC397E8}
+	EndGlobalSection
+EndGlobal

MyRestFullApiAmazonBackend/Clientes/Amazon/Contracts/IAmazonRepository.cs

@@ -0,0 +1,38 @@
+using MyRestFullApiAmazonBackend.Clientes.Amazon.DTO;
+using MyRestFullApiAmazonBackend.DTO;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.Models;
+
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Contracts
+{
+    public interface IAmazonRepository
+    {
+        public Task<List<I2096Header>> AmazonPendingClasificationInvoiceGet();
+        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<bool> SetFraccionPendienteValidar(int id, bool valor);
+        public Task<bool> TerminaClasificarFactura(int id);
+        public Task<IEnumerable<I2096NoPartes>> NoPartesGet(string Search);
+        public Task<IEnumerable<I2096PaisClaves>> PaisClavesGet();
+        public Task<DashboardTotal> DashboardInvoicesGet(short Mode);
+        public Task<DTORespuesta> SePuedeTerminardeClasificarFactura(int id);
+        public Task<DTORespuesta> SePuedeTerminardeClasificarFacturaEsperandoRespuesta(int id);
+        public Task<DTO2096SightLine> SightLineSET(DTO2096SightLine data);
+        public Task<DTORespuesta> SePuedeTerminarXTraficoFactura(int id);
+        public Task<bool> 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<bool> EnviaEsperaRespuestaAmazon(int id);
+        public Task<bool> AssignInvoice(int IdUsuario, int IdFactura);
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096CheckDetail.cs

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

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096Descripcioncs.cs

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

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096Fraccion.cs

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

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096FraccionDescripcion.cs

@@ -0,0 +1,11 @@
+namespace MyRestFullApiAmazonBackend.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!;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096ItemAutorizado.cs

@@ -0,0 +1,10 @@
+namespace MyRestFullApiAmazonBackend.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!;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096NoParte.cs

@@ -0,0 +1,14 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.DTO
+{
+    public class DTO2096NoParte
+    {
+        public int Id { get; set; } = 0;
+        public int TipoOperacion { get; set; } = 0;
+        public string Fraccion { get; set; } = null!;
+        public string DescripcionFactura { get; set; } = null!;
+        public string DescripcionAgenteAduanal { get; set; } = null!;
+        public string PaisOrigen { get; set; } = null!;
+        public string UMF { get; set; } = null!;
+        public string UMC { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/DTO/DTO2096SightLinecs.cs

@@ -0,0 +1,9 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.DTO
+{
+    public class DTO2096SightLine
+    {
+        public int Id { get; set; } = 0;
+        public Boolean SightLine { get; set; } = false;
+        public string ComentariosSightLine { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/DashBoardTotal.cs

@@ -0,0 +1,7 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Models
+{
+    public class DashboardTotal
+    {
+        public int Total { get; set; } = 0;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/I2096Detail.cs

@@ -0,0 +1,49 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Models
+{
+    public class I2096Detail
+    {
+        public int Id { get; set; } = 0;
+        public int IdHeader { get; set; } = 0;
+        public string InvoiceNumber { get; set; } = null!;
+        public string AmazonShipmentReferenceId { get; set; } = null!;
+        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 short Estatus { get; set; } = 0;
+        public bool Autorizado { get; set; } = false;
+        public string CumplimientoNormativo { get; set; } = null!;
+        public string Comentarios { get; set; } = null!;
+        public bool SightLine { get; set; } = false;
+        public string ComentariosSightLine { get; set; } = null!;
+        public bool Checked { get; set; } = false;
+        public byte Activo { get; set; } = 0;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/I2096Header.cs

@@ -0,0 +1,31 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Models
+{
+    public class I2096Header
+    {
+        public int Id { get; set; } = 0;
+        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 short Estatus { get; set; } = 0;
+        public bool max { get; set; } = false;
+        public List<I2096Detail> Detail { get; set; } = new List<I2096Detail>();
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/I2096ListaIDs.cs

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

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/I2096NoPartes.cs

@@ -0,0 +1,24 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Models
+{
+    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 FechaConfirmacion { get; set; } = null!;
+        public int UsuarioConfirmacion { get; set; } = 0;
+        public string FechaModificacion { get; set; } = null!;
+        public int UsuarioModificacion { get; set; } = 0;
+        public byte Activo { get; set; } = 0;
+
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/I2096PaisClaves.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Models
+{
+    public class I2096PaisClaves
+    {
+        public string PaisNom { get; set; } = null!;
+        public string Clave_a3 { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Model/I2096ShipFromAddress.cs

@@ -0,0 +1,19 @@
+namespace MyRestFullApiAmazonBackend.Clientes.Amazon.Models
+{
+    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!;
+    }
+}

MyRestFullApiAmazonBackend/Clientes/Amazon/Repository/AmazonRepository.cs

@@ -0,0 +1,416 @@
+using Dapper;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.Contracts;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.DTO;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.Model;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.Models;
+using MyRestFullApiAmazonBackend.Context;
+using MyRestFullApiAmazonBackend.DTO;
+using System.Data;
+
+
+namespace MyRestFullApiAmazonBackend.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 sql = "SELECT DISTINCT(IdHeader) as id FROM[Clientes.Amazon.Invoice.Detail] WHERE(Estatus = 0 and Autorizado = 1) or(Estatus = 1 and Autorizado = 1) ORDER BY 1";
+            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';" +
+                         "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>> InvoicePendingFromAmazonGet()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT id FROM [Clientes.Amazon.Invoice.Header] WHERE Estatus=-1 ORDER BY id";
+            // var sql = "SELECT DISTINCT(IdHeader) as id FROM[Clientes.Amazon.Invoice.Detail] WHERE(Estatus = 0 and Autorizado = 1) or(Estatus = 1 and Autorizado = 1) ORDER BY 1";
+            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()
+        {
+            using var connection = _context.CreateConnection();
+            var sql = "SELECT id FROM [Clientes.Amazon.Invoice.Header] WHERE Estatus=4";
+            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<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> ItemAutorizadoSet(DTO2096ItemAutorizado 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.Autorizado,
+                    @data.RequerimientoNormativo,
+                    @data.Comentarios
+                },
+                    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<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<DTORespuesta> SePuedeTerminardeClasificarFactura(int id)
+        {
+            var query = "SELECT  dbo.IsAmazonInvoiceClasificationReady(@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<DTORespuesta> SePuedeTerminardeClasificarFacturaEsperandoRespuesta(int id)
+        {
+            var query = "SELECT  dbo.IsAmazonInvoiceClasificationReady4AmazonAnswer(@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<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  * 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 }))
+            {
+                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]";
+            using var connection = _context.CreateConnection();
+            var result = await connection.QueryAsync<I2096Header>(query, new
+            {
+                @IdUsuario,
+                @IdFactura
+            }, commandType: CommandType.StoredProcedure);
+            return true;
+        }
+
+    }
+}

MyRestFullApiAmazonBackend/Context/DapperContext.cs

@@ -0,0 +1,18 @@
+using System.Data;
+using System.Data.SqlClient;
+
+namespace MyRestFullApiAmazonBackend.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);
+    }
+}

MyRestFullApiAmazonBackend/Contracts/Clientes/CasaCuervo/ICasaCuervoRepository.cs

@@ -0,0 +1,15 @@
+using MyRestFullApiAmazonBackend.DTO.Clientes.CasaCuervo;
+using MyRestFullApiAmazonBackend.Models.Clientes.CasaCuervo;
+
+namespace MyRestFullApiAmazonBackend.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);
+    }
+}

MyRestFullApiAmazonBackend/Contracts/IMenuRepository.cs

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

MyRestFullApiAmazonBackend/Contracts/IPerfilesRepository.cs

@@ -0,0 +1,20 @@
+using MyRestFullApiAmazonBackend.DTO;
+using MyRestFullApiAmazonBackend.DTO.Usuario;
+using MyRestFullApiAmazonBackend.Models;
+
+namespace MyRestFullApiAmazonBackend.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);
+    }
+}

MyRestFullApiAmazonBackend/Contracts/IUsuarioRepository.cs

@@ -0,0 +1,21 @@
+using MyRestFullApiAmazonBackend.DTO;
+using MyRestFullApiAmazonBackend.DTO.Usuario;
+using MyRestFullApiAmazonBackend.Models;
+
+namespace MyRestFullApiAmazonBackend.Contracts
+{
+    public interface IUsuariosRepository
+    {
+        public Task<IEnumerable<DTOUsuariosShort>> getAllUsuariosShort();
+        public Task<IEnumerable<Usuarios>> getAllUsuarios();
+        public Task<Usuarios> GetUsuario(DTOLogin user);
+        public Task<Usuarios> searchUsuario(DTOLogin user);
+        public Task<Usuarios> GetUsuarioById(int id);
+        public Task<Usuarios> createUsuario(Usuarios user);
+        public Task<DTOLogin> resetPassword(DTOLogin 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);
+    }
+}

MyRestFullApiAmazonBackend/Contracts/Utils/IFileManagerRepository.cs

@@ -0,0 +1,15 @@
+using Microsoft.AspNetCore.Identity;
+using MyRestFullApiAmazonBackend.Models.Utils;
+
+namespace MyRestFullApiAmazonBackend.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);
+
+    }
+}

MyRestFullApiAmazonBackend/Contracts/Utils/IFilePaths4ProcessRepository.cs

@@ -0,0 +1,9 @@
+using MyRestFullApiAmazonBackend.Models.Utils;
+
+namespace MyRestFullApiAmazonBackend.Contracts.Utils
+{
+    public interface IFilePaths4ProcessRepository
+    {
+        public Task<FilePaths4Process> getPaths4ProcessById(long id);
+    }
+}

MyRestFullApiAmazonBackend/Contracts/Utils/IPDFGenerator.cs

@@ -0,0 +1,7 @@
+namespace MyRestFullApiAmazonBackend.Contracts.Utils
+{
+    public interface IPDFGenerator
+    {
+        public Task<byte[]> GeneratePdfFromString(string htmlContent);
+    }
+}

MyRestFullApiAmazonBackend/Contracts/Utils/IvalidaFraccion.cs

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

MyRestFullApiAmazonBackend/Controllers/AuthController.cs

@@ -0,0 +1,139 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.IdentityModel.Tokens;
+using MyRestFullApiAmazonBackend.Contracts;
+using MyRestFullApiAmazonBackend.DTO;
+using MyRestFullApiAmazonBackend.Models;
+
+namespace MyRestFullApiAmazonBackend.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();
+            }
+        }
+
+        [Authorize]
+        [Route("Validate")]
+        [HttpGet]
+        public IActionResult GetValidation()
+        {
+            return StatusCode(200, "Its Ok");
+        }
+
+    }
+}

MyRestFullApiAmazonBackend/Controllers/Clientes/Amazon/AmazonInvoiceController.cs

@@ -0,0 +1,357 @@
+using Microsoft.AspNetCore.Mvc;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.Contracts;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.DTO;
+using MyRestFullApiAmazonBackend.Clientes.Amazon.Models;
+using MyRestFullApiAmazonBackend.DTO;
+using System.Net.Http.Headers;
+using System.Net;
+using MyRestFullApiAmazonBackend.Contracts.Utils;
+using MyRestFullApiAmazonBackend.Services.ValidarFraccion;
+
+namespace MyRestFullApiAmazonBackend.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;
+
+
+        public AmazonInvoiceController(IConfiguration config, IAmazonRepository Repo, IPDFGenerator RepoPDFGenerator)
+        {
+            _config = config;
+            _Repo = Repo;
+            _RepoPDFGenerator = RepoPDFGenerator;
+            _connectionString = _config.GetConnectionString("SqlConnection");
+        }
+
+        /*************************************** Procesos Iniciales *************************************/
+        [HttpGet]
+        [Route("C2096ValidaFraccion")]
+        public IActionResult C2096ValidaFraccion(string Fraccion)
+        {
+            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);
+        }
+
+        /*************************************** 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<DTORespuesta> SePuedeTerminardeClasificarFactura(int id)
+        {
+            return await _Repo.SePuedeTerminardeClasificarFactura(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);
+        }
+        /*************************************** 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);
+        }
+
+        /***************************************End Linking Traffic ******************************************/
+
+
+
+
+        /*  [HttpPost]
+         [Route("C2096ItemAutorizado")]
+         public async Task<I2096Detail> C2096ItemAutorizado(DTO2096ItemAutorizado data)
+         {
+             return await _Repo.ItemAutorizadoSet(data);
+         } */
+
+
+
+        /***************************************  Procesos Auxiliares ******************************************/
+        [HttpGet]
+        [Route("NoPartesGet")]
+        public async Task<IEnumerable<I2096NoPartes>> NoPartesGet(string Search)
+        {
+            return await _Repo.NoPartesGet(Search);
+        }
+
+        [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("http://localhost:9090/api/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("GetArchivoExcepcionesAmazon")]
+        [HttpGet, DisableRequestSizeLimit]
+        public async Task<IActionResult> GetArchivoExcepcionesAmazon(int id)
+        {
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            try
+            {
+                using (var client = GetHttpClient("http://localhost:9090/api/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, "image/png");
+                }
+            }
+            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("http://localhost:9091/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");
+            }
+
+        }
+
+        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;
+        }
+
+        /*************************************** End Procesos Auxiliares ***************************************/
+
+
+
+
+        /******************************************** Dashboard ********************************************/
+        [HttpGet]
+        [Route("DashboardInvoices")]
+        public async Task<DashboardTotal> DashboardInvoices(Int16 Mode)
+        {
+            return await _Repo.DashboardInvoicesGet(Mode);
+        }
+        /****************************************** End Dashboard *******************************************/
+
+
+
+
+
+
+    }
+}

MyRestFullApiAmazonBackend/Controllers/FileManagerController.cs

@@ -0,0 +1,202 @@
+using Microsoft.AspNetCore.Mvc;
+using MyRestFullApiAmazonBackend.Contracts.Utils;
+using MyRestFullApiAmazonBackend.Contracts;
+using MyRestFullApiAmazonBackend.DTO;
+using MyRestFullApiAmazonBackend.Models.Utils;
+using MyRestFullApiAmazonBackend.Contracts.Clientes.CasaCuervo;
+using MyRestFullApiAmazonBackend.Services.Clientes.SCasaCuervo;
+
+namespace MyRestFullApiAmazonBackend.Controllers
+{
+    // [Authorize]
+    [Route("api/[controller]")]
+    // [ApiController]
+    public class FileManagerController : Controller
+    {
+        private readonly IFileManagerRepository _Repo;
+        private readonly IUsuariosRepository _RepoUsuarios;
+        private readonly ICasaCuervoRepository _RepoCasaCuervo;
+        private readonly IFilePaths4ProcessRepository _RepoRelativePath;
+        private readonly IConfiguration _config;
+        private readonly string RootPathCorresponsales;
+
+
+        public FileManagerController(IFileManagerRepository Repo,
+        IFilePaths4ProcessRepository RepoRelativePath,
+        IConfiguration config,
+        IUsuariosRepository RepoUsuarios,
+        ICasaCuervoRepository RepoCasaCuervo)
+        {
+            _config = config;
+            _Repo = Repo;
+            _RepoUsuarios = RepoUsuarios;
+            _RepoCasaCuervo = RepoCasaCuervo;
+            _RepoRelativePath = RepoRelativePath;
+            RootPathCorresponsales = _config.GetValue<string>("AllFiles");
+        }
+
+        [Route("GetFileInfoByProcess")]
+        [HttpGet]
+        public async Task<FileManager> GetFileInfoByProcess([FromQuery] int id, int Proceso)
+        {
+            FileManager data = new FileManager();
+            data = await _Repo.getFileByProcess(id, Proceso);
+            return data;
+        }
+
+        [Route("GetFileInfoById")]
+        [HttpGet]
+        public async Task<FileManager> GetFileInfoByProcess([FromQuery] int id)
+        {
+            FileManager data = new FileManager();
+            data = await _Repo.getFileById(id);
+            return data;
+        }
+
+        [Route("AppendFileByProcess")]
+        [HttpPost]
+        public async Task<FileManager> AppendFileByProcess(IFormFile file, int IdUsuario, int Proceso, string Tags, int crud)
+        {
+            DateTime time = DateTime.Now;
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+            string fullPath = "";
+            fullPath = RootPathCorresponsales + RelativePath.Path;
+            string fileMime = file.FileName.Substring(file.FileName.Length - 4);
+            string newFileName = file.FileName.Replace(fileMime, "") + "_" + time.ToString("yyyy_MM_dd_HH_mm_ss") + fileMime;
+            FileManager data = new FileManager();
+            data.id = 0;
+            data.IdUsuario = IdUsuario;
+            data.NombreArchivo = newFileName;
+            data.Proceso = Proceso;
+            data.FechaRegistro = "";
+            data.Tags = Tags;
+            data.Activo = 1;
+            long fileLength = 0;
+            if (@crud == 1)
+            {
+                if (file.Length > 0)
+                {
+                    var filePath = fullPath + newFileName;
+                    using (var stream = System.IO.File.Create(filePath))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+                    fileLength = new System.IO.FileInfo(filePath).Length / 1024;
+                    data.Size = fileLength;
+                    if (fileLength > 0)
+                    {
+                        return await _Repo.FileManager(data);
+                    }
+                }
+            }
+            return data;
+        }
+
+
+        // El aifuiente procaso se tiene que validar de todo a todo, ya que sera facilitado el acceso a usuarios externos a GEMCO: Clientes, Corresponsales, etc 
+        [Route("AppendFileUpdatesCasaCuervo")]
+        [HttpPost]
+        public async Task<IActionResult> AppendFileUpdatesCasaCuervo(IFormFile file, string Usuario, string Contrasenia)
+        {
+            int Proceso = 6;
+            string Tags = "-1";
+            DateTime time = DateTime.Now;
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+            string fullPath = "";
+            fullPath = RootPathCorresponsales + RelativePath.Path;
+            string fileMime = file.FileName.Substring(file.FileName.Length - 4);
+            string newFileName = file.FileName.Replace(fileMime, "") + "_" + time.ToString("yyyy_MM_dd_HH_mm_ss") + fileMime;
+            DTOLogin authUser = new DTOLogin();
+            authUser.Usuario = Usuario;
+            authUser.Contrasena = Contrasenia;
+            var ExternalUser = await _RepoUsuarios.GetUsuario(authUser);
+            FileManager data = new FileManager();
+            data.id = 0;
+            data.IdUsuario = ExternalUser.Id;
+            data.NombreArchivo = newFileName;
+            data.Proceso = Proceso;
+            data.FechaRegistro = "";
+            data.Tags = Tags;
+            data.Activo = 1;
+            long fileLength = 0;
+            string filePath = "";
+            filePath = fullPath + newFileName;
+            using (var stream = System.IO.File.Create(filePath))
+            {
+                await file.CopyToAsync(stream);
+            }
+            fileLength = new System.IO.FileInfo(filePath).Length / 1024;
+            data.Size = fileLength;
+            if (fileLength > 0)
+            {
+                SCasaCuervo proc = new SCasaCuervo(_RepoCasaCuervo, filePath);
+                var result = await proc.UpdateInfoFromCorresponsal();
+                if (result) return new OkObjectResult(new { respuesta = "El archivo se agrego exitosamente" });
+                else return new OkObjectResult(new { respuesta = "Ocurrio un error, el archivo no se guardo, verifique que el formato de fecha sea MM/dd/yyyy" });
+            }
+            return new OkObjectResult(new { respuesta = "Ocurrio un error el archivo no se guardo" });
+        }
+
+        [Route("getFile")]
+        [HttpGet, DisableRequestSizeLimit]
+        public async Task<IActionResult> getFileFromFileManager([FromQuery] long id, int Proceso)
+        {
+            Boolean ExisteEnDisco = false;
+            FileManager recFound = await _Repo.getFileByProcess(id, Proceso);
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+            string fullPath = "";
+            fullPath = RootPathCorresponsales + RelativePath.Path;
+            if (!String.IsNullOrEmpty(recFound.NombreArchivo))
+            {
+                try
+                {
+                    if (System.IO.File.Exists(Path.Combine(fullPath, recFound.NombreArchivo)))
+                    {
+                        ExisteEnDisco = true;
+                    }
+                    else return BadRequest(new { respuesta = "Ese archivo no existe" });
+                }
+                catch (IOException ex)
+                {
+                    return BadRequest(new { respuesta = "Ese archivo no existe" + ex.ToString() });
+                }
+                if (ExisteEnDisco)
+                {
+                    string fileMime = recFound.NombreArchivo.Substring(recFound.NombreArchivo.Length - 3).ToLower();
+                    var mime = "application/" + fileMime.ToLower();
+                    string targetFile = fullPath + recFound.NombreArchivo;
+                    if (System.IO.File.Exists(targetFile))
+                    {
+                        byte[] pdfBytes = System.IO.File.ReadAllBytes(targetFile);
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        return new FileStreamResult(ms, mime);
+                    }
+                }
+            }
+            return BadRequest(new { respuesta = "Ese archivo no existe" });
+        }
+
+        [HttpDelete("DeleteById/{id}")]
+        public async Task<IActionResult> DeleteByProcess(long id)
+        {
+            FileManager Found = await _Repo.getFileById(id);
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Found.Proceso);
+            string fullPath = "";
+            fullPath = RootPathCorresponsales + RelativePath.Path;
+            try
+            {
+                if (System.IO.File.Exists(Path.Combine(fullPath, Found.NombreArchivo)))
+                {
+                    System.IO.File.Delete(Path.Combine(fullPath, Found.NombreArchivo));
+                    await _Repo.deleteFileByProcess(Found.id, Found.Proceso);
+                }
+                else return new OkObjectResult(new { respuesta = "Ese archivo no existe" });
+            }
+            catch (IOException ex)
+            {
+                return new OkObjectResult(new { respuesta = "Ocurrio un error al intentar eliminar el registro: " + ex.ToString() });
+            }
+            return new OkObjectResult(new { respuesta = "Se elimino el registro" });
+        }
+    }
+}

MyRestFullApiAmazonBackend/Controllers/UsuariosController.cs

@@ -0,0 +1,175 @@
+using Microsoft.AspNetCore.Mvc;
+using MyRestFullApiAmazonBackend.Contracts;
+using MyRestFullApiAmazonBackend.DTO.Usuario;
+using MyRestFullApiAmazonBackend.DTO;
+using MyRestFullApiAmazonBackend.Models;
+using MyRestFullApiAmazonBackend.Services;
+
+namespace MyRestFullApiAmazonBackend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class UsuariosController : ControllerBase
+    {
+        private readonly IUsuariosRepository _usuariosRepo;
+        private readonly IConfiguration _config;
+
+        public UsuariosController(IUsuariosRepository usuariosRepo, IConfiguration config) { _usuariosRepo = usuariosRepo; _config = config; }
+
+        [Route("getUsuarioById")]
+        [HttpGet]
+        public async Task<IActionResult> getAllUsuarios(int id)
+        {
+            try
+            {
+                var usuario = await _usuariosRepo.GetUsuarioById(id);
+                if (usuario == null) return NotFound();
+                return Ok(usuario);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+        [Route("getAllUsuarios")]
+        [HttpGet]
+        public async Task<IActionResult> getAllUsuarios()
+        {
+            try
+            {
+                var usuarios = await _usuariosRepo.getAllUsuarios();
+                return Ok(usuarios);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+        [Route("getAllUsuariosShort")]
+        [HttpGet]
+        public async Task<IActionResult> getAllUsuariosShort()
+        {
+            try
+            {
+                var usuarios = await _usuariosRepo.getAllUsuariosShort();
+                return Ok(usuarios);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+
+        [Route("Auth")]
+        [HttpPost]
+        public async Task<IActionResult> Auth(DTOLogin user)
+        {
+            try
+            {
+                var usuarios = await _usuariosRepo.GetUsuario(user);
+                return Ok(usuarios);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+
+        [Route("resetPassword")]
+        [HttpPost]
+        public async Task<IActionResult> resetPassword(DTOLogin user)
+        {
+            try
+            {
+                var result = await _usuariosRepo.resetPassword(user);
+                if (result == null)
+                {
+                    return StatusCode(400, "Cuenta de usuario no existe");
+                }
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex);
+            }
+        }
+
+        [Route("searchUsuario")]
+        [HttpPost]
+        public async Task<IActionResult> searchUsuario(DTOLogin user)
+        {
+            try
+            {
+                var result = await _usuariosRepo.searchUsuario(user);
+                if (result != null) return StatusCode(409, new { message = "Usuario registrado previamente" });
+                return Ok(new { message = "Usuario libre, no registrado previamente" });
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex);
+            }
+        }
+
+
+        [Route("createUser")]
+        [HttpPost]
+        public async Task<IActionResult> POST(Usuarios user)
+        {
+            try
+            {
+                var usuario = await _usuariosRepo.createUsuario(user);
+                if (user.Id == 0)
+                {
+                    Utilerias email = new Utilerias(_config);
+                    Boolean sendOk = email.SendEmail("", usuario);
+                }
+                return Ok(usuario);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+        [Route("clonarUsuario")]
+        [HttpPost]
+        public async Task<IActionResult> POST(DTOClonarUsuario user)
+        {
+            try
+            {
+                var usuarios = await _usuariosRepo.clonarUsuario(user);
+                return Ok(usuarios);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+        [Route("Catalogo/Roles/GET")]
+        [HttpGet]
+        public async Task<IActionResult> CatalogoRolesGET()
+        {
+            try
+            {
+                var Roles = await _usuariosRepo.CatalogoRolesGET();
+                return Ok(Roles);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+        [Route("Catalogo/Roles/AsignadosGET")]
+        [HttpGet]
+        public async Task<IActionResult> RolesAsignadosGET(int id)
+        {
+            try
+            {
+                var Roles = await _usuariosRepo.RolesAsignadosGET(id);
+                return Ok(Roles);
+            }
+            catch (Exception ex) { return StatusCode(500, ex.Message); }
+        }
+
+
+        [Route("Catalogo/Usuarios/PerfilesParecidos")]
+        [HttpGet]
+        public async Task<IActionResult> GETPerfilesParecidos(string Perfil)
+        {
+            try
+            {
+                var perfiles = await _usuariosRepo.GETPerfilesParecidos(Perfil);
+                return Ok(perfiles);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
+        }
+    }
+}

MyRestFullApiAmazonBackend/Controllers/Utils/MfileManagerController.cs

@@ -0,0 +1,63 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using MyRestFullApiAmazonBackend.Contracts.Utils;
+using MyRestFullApiAmazonBackend.Models.Utils;
+using MyRestFullApiAmazonBackend.Services.MFileManager;
+
+namespace MyRestFullApiAmazonBackend.Controllers.Utils
+{
+    [Authorize]
+    [ApiController]
+    [Route("api/Utils/[controller]")]
+    public class MFileManagerController : ControllerBase
+    {
+
+        private readonly IFileManagerRepository _Repo;
+        private readonly IConfiguration _config;
+        private readonly IFilePaths4ProcessRepository _RepoRelativePath;
+        private readonly string RootPath;
+
+        public MFileManagerController(IConfiguration config, IFilePaths4ProcessRepository RepoRelativePath, IFileManagerRepository Repo)
+        {
+            _config = config;
+            _RepoRelativePath = RepoRelativePath;
+            _Repo = Repo;
+            RootPath = _config.GetValue<string>("AllFiles");
+        }
+
+        [HttpGet]
+        [Route("GetFilesFromLog")]
+        public async Task<List<FileManager>> GetFilesFromLog(int Tags, int Proceso)
+        {
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+            SvcMFileManager FM = new SvcMFileManager(_config, _Repo, RootPath + RelativePath.Path);
+            return await FM.GetFilesFromLog(Tags, Proceso);
+        }
+
+
+        [HttpGet]
+        [Route("GetFileContentById")]
+        public async Task<IActionResult> GetFileContentById(long id, int Proceso)
+        {
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+            SvcMFileManager FM = new SvcMFileManager(_config, _Repo, RootPath + RelativePath.Path);
+            return await FM.getFileContentById(id);
+        }
+
+
+        [HttpPost]
+        [Route("Append")]
+        public async Task<List<FileManager>> Append(List<IFormFile> FileList, int Tags, int Proceso, int Usuario)
+        {
+            List<string> data = new List<string>();
+            FilePaths4Process RelativePath = await _RepoRelativePath.getPaths4ProcessById(Proceso);
+            SvcMFileManager FM = new SvcMFileManager(_config, _Repo, RootPath + RelativePath.Path);
+            List<string> filePaths = await FM.SaveFile2DiskList(FileList);
+            var fileData = await FM.SaveFileLog(filePaths, Tags, Proceso, Usuario);
+            return fileData;
+        }
+
+
+    }
+}

MyRestFullApiAmazonBackend/DTO/Clientes/CasaCuervo/DTO325AduanaPedidos.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.DTO.Clientes.CasaCuervo
+{
+    public class DTO325AduanasPedidos
+    {
+        public string id { set; get; } = string.Empty;
+        public string value { set; get; } = string.Empty;
+    }
+}

MyRestFullApiAmazonBackend/DTO/Clientes/CasaCuervo/DTO325ComplementaPedido.cs

@@ -0,0 +1,16 @@
+namespace MyRestFullApiAmazonBackend.DTO.Clientes.CasaCuervo
+{
+    public class DTO325ComplementaPedido
+    {
+        public string Pedido { set; get; } = string.Empty;
+        public string Factura { set; get; } = string.Empty;
+        public string UUID { set; get; } = string.Empty;
+        public string Trafico { set; get; } = string.Empty;
+        public string Pedimento { set; get; } = string.Empty;
+        public string Aduana { set; get; } = string.Empty;
+        public string Patente { set; get; } = string.Empty;
+        public string Modulacion { set; get; } = string.Empty;
+        public string? FechaCompromiso { set; get; } = string.Empty;
+        public string? Comentario { set; get; } = string.Empty;
+    }
+}

MyRestFullApiAmazonBackend/DTO/Clientes/CasaCuervo/DTO325UpdateFromWeb.cs

@@ -0,0 +1,18 @@
+namespace MyRestFullApiAmazonBackend.DTO.Clientes.CasaCuervo
+{
+    public class DTO325UpdateFromWeb
+    {
+        public int id { get; set; } = 0!;
+        public string ComentarioGEMCO { get; set; } = string.Empty;
+        public string FechaCompromiso { get; set; } = string.Empty;
+        public string FechaCruce { get; set; } = string.Empty;
+        public string Factura { get; set; } = string.Empty;
+        public string MedidaCaja { get; set; } = string.Empty;
+        public string Sello1 { get; set; } = string.Empty;
+        public string Sello2 { get; set; } = string.Empty;
+        public string UUID { get; set; } = string.Empty;
+        public string Trafico { get; set; } = string.Empty;
+        public string Pedimento { get; set; } = string.Empty;
+        public string Patente { get; set; } = string.Empty;
+    }
+}

MyRestFullApiAmazonBackend/DTO/DTOIteamMenuPerfil.cs

@@ -0,0 +1,10 @@
+namespace MyRestFullApiAmazonBackend.DTO
+{
+    public class DTOItemMenuPerfil
+    {
+        public int IdPerfil { get; set; } = 0;
+        public int itemMenu { get; set; } = 0;
+        public bool asignado { get; set; } = false;
+
+    }
+}

MyRestFullApiAmazonBackend/DTO/DTOLogin.cs

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

MyRestFullApiAmazonBackend/DTO/DTORespuestacs.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.DTO
+{
+    public class DTORespuesta
+    {
+        public int code { get; set; } = 0!;
+        public string respuesta { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/DTO/DTORolesAsignados.cs

@@ -0,0 +1,10 @@
+namespace MyRestFullApiAmazonBackend.DTO
+{
+    public class DTORolesAsignados
+    {
+        public int Id { get; set; } = 0;
+        public int Usuario { get; set; } = 0;
+        public int Rol { get; set; } = 0;
+        public Boolean Activo { get; set; } = false;
+    }
+}

MyRestFullApiAmazonBackend/DTO/Usuario/DTOClonarUsuario.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.DTO.Usuario
+{
+    public class DTOClonarUsuario
+    {
+        public int IDUsuarioOrigen { get; set; } = 0!;
+        public int IdUsuarioDestino { get; set; } = 0!;
+    }
+}

MyRestFullApiAmazonBackend/DTO/Usuario/DTOPerfilCreate.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.DTO.Usuario
+{
+    public class DTOPerfilCreate
+    {
+        public string Perfil { get; set; } = null!;
+        public int IdPerfilClonado { get; set; } = 0!;
+    }
+}

MyRestFullApiAmazonBackend/DTO/Usuario/DTOUsuariosPerfilParecido.cs

@@ -0,0 +1,9 @@
+namespace MyRestFullApiAmazonBackend.DTO.Usuario
+{
+    public class DTOUsuariosPerfilParecido
+    {
+        public int IdUsuario { get; set; } = 0;
+        public string Nombre { get; set; } = null!;
+        public string Perfil { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/DTO/Usuario/DtoUsuarioShort.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.DTO.Usuario
+{
+    public class DTOUsuariosShort
+    {
+        public int id { get; set; } = 0!;
+        public string Usuario { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/Interface/IExelDataReader.cs

@@ -0,0 +1,89 @@
+using ExcelDataReader;
+using System.Data;
+
+namespace MyRestFullApiAmazonBackend.Interface
+{
+    public interface IExcelDataReader : IDataReader, IDataRecord, IDisposable
+    {
+        //
+        // Summary:
+        //     Gets the sheet name.
+        string Name { get; }
+
+        //
+        // Summary:
+        //     Gets the sheet VBA code name.
+        string CodeName { get; }
+
+        //
+        // Summary:
+        //     Gets the sheet visible state.
+        string VisibleState { get; }
+
+        //
+        // Summary:
+        //     Gets the sheet header and footer -or- null if none set.
+        HeaderFooter HeaderFooter { get; }
+
+        //
+        // Summary:
+        //     Gets the list of merged cell ranges.
+        CellRange[] MergeCells { get; }
+
+        //
+        // Summary:
+        //     Gets the number of results (workbooks).
+        int ResultsCount { get; }
+
+        //
+        // Summary:
+        //     Gets the number of rows in the current result.
+        int RowCount { get; }
+
+        //
+        // Summary:
+        //     Gets the height of the current row in points.
+        double RowHeight { get; }
+
+        //
+        // Summary:
+        //     Seeks to the first result.
+        void Reset();
+
+        //
+        // Summary:
+        //     Gets the number format for the specified field -or- null if there is no value.
+        //
+        // Parameters:
+        //   i:
+        //     The index of the field to find.
+        //
+        // Returns:
+        //     The number format string of the specified field.
+        string GetNumberFormatString(int i);
+
+        //
+        // Summary:
+        //     Gets the number format index for the specified field -or- -1 if there is no value.
+        //
+        // Parameters:
+        //   i:
+        //     The index of the field to find.
+        //
+        // Returns:
+        //     The number format index of the specified field.
+        int GetNumberFormatIndex(int i);
+
+        //
+        // Summary:
+        //     Gets the width the specified column.
+        //
+        // Parameters:
+        //   i:
+        //     The index of the column to find.
+        //
+        // Returns:
+        //     The width of the specified column.
+        double GetColumnWidth(int i);
+    }
+}

MyRestFullApiAmazonBackend/Models/CatRoles.cs

@@ -0,0 +1,9 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class CatRoles
+    {
+        public int Id { set; get; }
+        public string Rol { set; get; } = null!;
+        public byte Activo { set; get; }
+    }
+}

MyRestFullApiAmazonBackend/Models/Clientes/CasaCuervo/I3225Pedidos.cs

@@ -0,0 +1,31 @@
+namespace MyRestFullApiAmazonBackend.Models.Clientes.CasaCuervo
+{
+    public class I325Pedidos
+    {
+        public int id { set; get; } = 0;
+        public string PO { set; get; } = string.Empty;
+        public string Aduana { set; get; } = string.Empty;
+        public string Destination { set; get; } = string.Empty;
+        public string TruckNumber { set; get; } = string.Empty;
+        public string Forwarder { set; get; } = string.Empty;
+        public string Carrier { set; get; } = string.Empty;
+        public string LoadDate { set; get; } = string.Empty;
+        public string Prioridad { set; get; } = string.Empty;
+        public string? Estatus { set; get; } = string.Empty;
+        public string? ComentarioGEMCO { set; get; } = string.Empty;
+        public string? FechaCompromiso { set; get; } = string.Empty;
+        public string? FechaCruce { set; get; } = string.Empty;
+        public string? Factura { set; get; } = string.Empty;
+        public string? UUID { set; get; } = string.Empty;
+        public string? Trafico { set; get; } = string.Empty;
+        public string? Pedimento { set; get; } = string.Empty;
+        public string? Patente { set; get; } = string.Empty;
+        public string? Modulacion { set; get; } = string.Empty;
+        public string? Actualizacion { set; get; } = string.Empty;
+        //     public string? NoFactura { set; get; } = string.Empty;
+        public string? MedidaCaja { set; get; } = string.Empty;
+        public string? Sello1 { set; get; } = string.Empty;
+        public string? Sello2 { set; get; } = string.Empty;
+        public int? Activo { set; get; } = 0;
+    }
+}

MyRestFullApiAmazonBackend/Models/Menu.cs

@@ -0,0 +1,11 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class Menu
+    {
+        public int Id { get; set; }
+        public string Descripcion { get; set; } = null!;
+        public int PadreId { get; set; }
+        public int Posicion { get; set; }
+        public string Url { get; set; } = null!;
+    }
+}

MyRestFullApiAmazonBackend/Models/Perfiles.cs

@@ -0,0 +1,8 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class Perfiles
+    {
+        public int id { get; set; }
+        public string Perfil { get; set; } = string.Empty;
+    }
+}

MyRestFullApiAmazonBackend/Models/PerfilesMenu.cs

@@ -0,0 +1,16 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class PerfilesMenu
+    {
+        public int id { set; get; }
+        public int IdPerfil { set; get; }
+        public int itemMenu { set; get; }
+        public string Perfil { set; get; } = null!;
+        public string Descripcion { set; get; } = null!;
+        public int PadreId { set; get; }
+        public int Posicion { set; get; }
+        public string Url { set; get; } = null!;
+        public int Habilitado { set; get; }
+        public int Agrupado { set; get; }
+    }
+}

MyRestFullApiAmazonBackend/Models/Provedores.cs

@@ -0,0 +1,12 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class Proveedores
+    {
+        public int IdUsuario { get; set; }
+        public string sClaveCliente { get; set; } = null!;
+        public string sClave { set; get; } = null!;
+        public string sRazonSocial { set; get; } = null!;
+        public string Direccion { set; get; } = null!;
+        public byte Asignado { set; get; } = 0;
+    }
+}

MyRestFullApiAmazonBackend/Models/Transportistas.cs

@@ -0,0 +1,11 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class Transportistas
+    {
+        public int id { get; set; }
+        public int IdUsuario { get; set; }
+        public string sClave { set; get; } = null!;
+        public string sRazonSocial { set; get; } = null!;
+        public byte Asignado { set; get; } = 0;
+    }
+}

MyRestFullApiAmazonBackend/Models/Usuarios.cs

@@ -0,0 +1,37 @@
+namespace MyRestFullApiAmazonBackend.Models
+{
+    public class Usuarios
+    {
+        public int Id { get; set; } = 0;
+        public string Usuario { get; set; } = null!;
+        public string Nombre { get; set; } = null!;
+        public string Contrasena { get; set; } = null!;
+        public string Correo { get; set; } = null!;
+        public byte TipoUsuario { get; set; } = 2;
+        public byte Activo { get; set; } = 1;
+        public string FechaAlta { get; set; } = null!;
+        public int UsuarioAlta { get; set; } = 0!;
+        public string FechaModifico { get; set; } = null!;
+        public int UsuarioModifico { get; set; } = 0!;
+        public string FechaElimino { get; set; } = null!;
+        public int UsuarioElimino { get; set; } = 0!;
+        public string MotivoElimino { get; set; } = null!;
+        public int IdModulo { get; set; } = 0!;
+        public int Dept { get; set; } = 0!;
+        public string? sDept { get; set; } = null!;
+        public int Tmercancia { get; set; } = 0!;
+        public string FechaUltimaVisita { get; set; } = null!;
+        public int Visitas { get; set; } = 0!;
+        public int Internos { get; set; } = 0!;
+        public int PermisoEspecial { get; set; } = 0!;
+        public int EstadoConfiguracion { get; set; } = 0!;
+        public string FechaValidacionConf { get; set; } = null!;
+        public string RealizoEncuesta { get; set; } = null!;
+        public int EncuestaActiva { get; set; } = 0!;
+        public string FechaLimiteEncuesta { get; set; } = null!;
+        public string CodigoAccesoM { get; set; } = null!;
+        public string TokenAccesoM { set; get; } = null!;
+        public string DeviceToken { get; set; } = null!;
+        public int IdPerfil { get; set; } = 0!;
+    }
+}

MyRestFullApiAmazonBackend/Models/Utils/FileManager.cs

@@ -0,0 +1,14 @@
+namespace MyRestFullApiAmazonBackend.Models.Utils
+{
+    public class FileManager
+    {
+        public long id { get; set; } = 0!;
+        public int IdUsuario { get; set; } = 0!;
+        public int Proceso { get; set; } = 0!;
+        public string NombreArchivo { get; set; } = null!;
+        public string FechaRegistro { get; set; } = null!;
+        public string Tags { get; set; } = null!;
+        public long Size { get; set; } = 0!;
+        public byte Activo { get; set; } = 0!;
+    }
+}

MyRestFullApiAmazonBackend/Models/Utils/FilePaths4Process.cs

@@ -0,0 +1,7 @@
+namespace MyRestFullApiAmazonBackend.Models.Utils
+{
+    public class FilePaths4Process
+    {
+        public string Path { set; get; } = string.Empty;
+    }
+}

MyRestFullApiAmazonBackend/MyRestFullApiAmazonBackend.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Dapper" Version="2.0.123" />
+    <PackageReference Include="ExcelDataReader" Version="3.6.0" />
+    <PackageReference Include="ExcelDataReader.DataSet" Version="3.6.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
+    <PackageReference Include="System.Data.SqlClient" Version="4.8.5" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.26.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Repositorio\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\.editorconfig" Link=".editorconfig" />
+  </ItemGroup>
+
+</Project>

MyRestFullApiAmazonBackend/MyRestFullApiAmazonBackend.csproj.user

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Controller_SelectedScaffolderID>MvcControllerEmptyScaffolder</Controller_SelectedScaffolderID>
+    <Controller_SelectedScaffolderCategoryPath>root/Common/MVC/Controller</Controller_SelectedScaffolderCategoryPath>
+  </PropertyGroup>
+</Project>

MyRestFullApiAmazonBackend/Program.cs

@@ -0,0 +1,25 @@
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+
+builder.Services.AddControllers();
+// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+
+app.UseAuthorization();
+
+app.MapControllers();
+
+app.Run();

MyRestFullApiAmazonBackend/Properties/launchSettings.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:47126",
+      "sslPort": 44308
+    }
+  },
+  "profiles": {
+    "MyRestFullApiAmazonBackend": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7225;http://localhost:5134",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

MyRestFullApiAmazonBackend/Services/Clientes/SCasaCuervo/SCasaCuervo.cs

@@ -0,0 +1,160 @@
+using ExcelDataReader;
+using MyRestFullApiAmazonBackend.Contracts.Clientes.CasaCuervo;
+using MyRestFullApiAmazonBackend.DTO.Clientes.CasaCuervo;
+using MyRestFullApiAmazonBackend.Models.Clientes.CasaCuervo;
+using System.Data;
+
+namespace MyRestFullApiAmazonBackend.Services.Clientes.SCasaCuervo
+{
+    public class SCasaCuervo
+    {
+        public DataSet mExcelInfo = null!;
+        private readonly ICasaCuervoRepository _Repo;
+        private readonly string rutaArchivo;
+
+        public SCasaCuervo(ICasaCuervoRepository Repo, String Archivo)
+        {
+            _Repo = Repo;
+            rutaArchivo = Archivo;
+        }
+
+        public async Task<Boolean> ReadExcel()
+        {
+            DataTable dt = new DataTable();
+            List<I325Pedidos> Data = new List<I325Pedidos>();
+            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
+            using (var stream = File.Open(rutaArchivo, FileMode.Open, FileAccess.Read))
+            {
+                using (var reader = ExcelReaderFactory.CreateReader(stream))
+                {
+                    mExcelInfo = reader.AsDataSet();
+                    if (mExcelInfo != null)
+                    {
+                        int lastTable = mExcelInfo!.Tables.Count - 1;
+                        dt = mExcelInfo.Tables[lastTable];
+                        for (int r = 1; r < mExcelInfo!.Tables[mExcelInfo.Tables.Count - 1].Rows.Count; r++)
+                        {
+                            if (mExcelInfo != null)
+                            {
+                                /*    I325Pedidos data = new I325Pedidos();
+                                   data.PO = mExcelInfo.Tables[lastTable].Rows[r][0].ToString() ?? "";
+                                   data.Aduana = (string)mExcelInfo!.Tables[lastTable].Rows[r][1];
+                                   data.Destination = (string)mExcelInfo!.Tables[lastTable].Rows[r][2];
+                                   data.TruckNumber = mExcelInfo.Tables[lastTable].Rows[r][3].ToString() ?? "";
+                                   data.Forwarder = (string)mExcelInfo.Tables[lastTable].Rows[r][4];
+                                   data.Carrier = (string)mExcelInfo.Tables[lastTable].Rows[r][5];
+                                   data.LoadDate = changeDateFormat(mExcelInfo.Tables[lastTable].Rows[r][6].ToString() ?? "");
+                                   data.Prioridad = mExcelInfo.Tables[lastTable].Rows[r][7].ToString() ?? "";
+                                   data.Estatus = mExcelInfo.Tables[lastTable].Rows[r][8].ToString();
+                                   Data.Add(data); */
+
+                                I325Pedidos data = new I325Pedidos();
+                                data.PO = mExcelInfo.Tables[lastTable].Rows[r][0].ToString() ?? "";
+                                data.Aduana = mExcelInfo!.Tables[lastTable].Rows[r][1].ToString() ?? "";
+                                data.Destination = mExcelInfo!.Tables[lastTable].Rows[r][2].ToString() ?? "";
+                                data.TruckNumber = mExcelInfo.Tables[lastTable].Rows[r][3].ToString() ?? "";
+                                data.Forwarder = mExcelInfo.Tables[lastTable].Rows[r][4].ToString() ?? "";
+                                data.Carrier = mExcelInfo.Tables[lastTable].Rows[r][5].ToString() ?? "";
+                                data.LoadDate = changeDateFormat(mExcelInfo.Tables[lastTable].Rows[r][6].ToString() ?? "");
+                                data.Prioridad = mExcelInfo.Tables[lastTable].Rows[r][7].ToString() ?? "";
+                                data.Estatus = mExcelInfo.Tables[lastTable].Rows[r][8].ToString() ?? "";
+                                Data.Add(data);
+                            }
+                        }
+                        stream.Close();
+                        await _Repo.Append(Data);
+                    }
+                }
+            }
+            return true;
+        }
+
+
+        public async Task<Boolean> UpdateInfoFromCorresponsal()
+        {
+            DataTable dt = new DataTable();
+            List<DTO325ComplementaPedido> Data = new List<DTO325ComplementaPedido>();
+            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
+            using (var stream = File.Open(rutaArchivo, FileMode.Open, FileAccess.Read))
+            {
+                using (var reader = ExcelReaderFactory.CreateReader(stream))
+                {
+                    mExcelInfo = reader.AsDataSet();
+                    if (mExcelInfo != null)
+                    {
+                        int lastTable = mExcelInfo.Tables.Count - 1;
+                        dt = mExcelInfo.Tables[lastTable];
+                        for (int r = 1; r < mExcelInfo!.Tables[mExcelInfo.Tables.Count - 1].Rows.Count; r++)
+                        {
+                            if (mExcelInfo != null)
+                            {
+                                DTO325ComplementaPedido data = new DTO325ComplementaPedido();
+                                if (mExcelInfo.Tables[lastTable].Columns.Count >= 1)
+                                {
+                                    data.Pedido = mExcelInfo.Tables[lastTable].Rows[r][0].ToString() ?? "";
+                                }
+                                if (mExcelInfo.Tables[lastTable].Columns.Count >= 2)
+                                {
+                                    data.Factura = mExcelInfo.Tables[lastTable].Rows[r][1].ToString() ?? "";
+                                }
+                                if (mExcelInfo.Tables[lastTable].Columns.Count >= 3)
+                                {
+                                    data.UUID = mExcelInfo.Tables[lastTable].Rows[r][2].ToString() ?? "";
+                                }
+                                if (mExcelInfo.Tables[lastTable].Columns.Count >= 4)
+                                {
+                                    data.Trafico = mExcelInfo.Tables[lastTable].Rows[r][3].ToString() ?? "";
+                                }
+                                if (mExcelInfo.Tables[lastTable].Columns.Count >= 5)
+                                {
+                                    data.Pedimento = mExcelInfo.Tables[lastTable].Rows[r][4].ToString() ?? "";
+                                }
+                                if (mExcelInfo.Tables[lastTable].Columns.Count >= 7)
+                                {
+                                    data.Patente = mExcelInfo.Tables[lastTable].Rows[r][6].ToString() ?? "";
+                                }
+                                if (mExcelInfo?.Tables[lastTable].Columns.Count >= 8)
+                                {
+                                    data.Modulacion = mExcelInfo.Tables[lastTable].Rows[r][7].ToString() ?? "";
+                                }
+                                if (mExcelInfo?.Tables[lastTable].Columns.Count >= 9)
+                                {
+                                    string? fecha = mExcelInfo.Tables[lastTable].Rows[r][8].ToString();
+                                    if (IsDateTime(fecha!))
+                                    {
+                                        data.FechaCompromiso = fecha;
+                                        var temp = Convert.ToDateTime(fecha);
+                                        data.FechaCompromiso = temp.ToString("MM/dd/yyyy");
+                                    }
+                                    else return false;
+                                }
+                                if (mExcelInfo?.Tables[mExcelInfo.Tables.Count - 1].Columns.Count >= 10)
+                                {
+                                    data.Comentario = mExcelInfo?.Tables[lastTable].Rows[r][9].ToString();
+                                }
+                                Data.Add(data);
+                            }
+                        }
+                        stream.Close();
+                        await _Repo.UpdateInfoFromCorresponsal(Data);
+                    }
+                }
+            }
+            return true;
+        }
+
+        public static bool IsDateTime(string txtDate)
+        {
+            DateTime tempDate;
+            return DateTime.TryParse(txtDate, out tempDate);
+        }
+
+        private string changeDateFormat(String data)
+        {
+            if (data.Length == 0) return "";
+            var datePart = data.Split(' ');
+            String[] arr = datePart[0].Split('/');
+            return arr[2].Substring(0, 4) + "-" + arr[0].PadLeft(2, '0') + "-" + arr[1].PadLeft(2, '0');
+        }
+    }
+}

MyRestFullApiAmazonBackend/Services/MFileManager/SvcMFileManager.cs

@@ -0,0 +1,107 @@
+using Microsoft.AspNetCore.Mvc;
+using MyRestFullApiAmazonBackend.Contracts.Utils;
+using MyRestFullApiAmazonBackend.Models.Utils;
+
+namespace MyRestFullApiAmazonBackend.Services.MFileManager
+{
+    public class SvcMFileManager
+    {
+        private readonly IFileManagerRepository _Repo;
+        private readonly IConfiguration _config;
+        // private readonly IFilePaths4ProcessRepository _RepoRelativePath;
+        private readonly string rootPath;
+
+        public SvcMFileManager(IConfiguration config, IFileManagerRepository Repo, string _rootPath)
+        {
+            _config = config;
+            _Repo = Repo;
+            rootPath = _rootPath;
+        }
+
+        public async Task<List<FileManager>> GetFilesFromLog(int Tags, int Proceso)
+        {
+            return await _Repo.getAllFilesByProcess(Tags, Proceso);
+        }
+
+        public async Task<IActionResult> getFileContentById(long id)
+        {
+            Boolean ExisteEnDisco = false;
+            byte[] emptyFile = System.IO.File.ReadAllBytes("c:\\downs\\empty.png");
+            MemoryStream emptyms = new MemoryStream(emptyFile);
+            FileManager recFound = await _Repo.getFileById(id);
+            if (!String.IsNullOrEmpty(recFound.NombreArchivo))
+            {
+                try
+                {
+                    if (System.IO.File.Exists(Path.Combine(rootPath, recFound.NombreArchivo)))
+                    {
+                        ExisteEnDisco = true;
+                    }
+                    else
+                    {
+                        return new FileStreamResult(emptyms, "image/png");
+                    }
+                }
+                catch (IOException ex)
+                {
+                    Console.Write(ex.ToString());
+                    return new FileStreamResult(emptyms, "image/png");
+                }
+                if (ExisteEnDisco)
+                {
+                    string fileMime = recFound.NombreArchivo.Substring(recFound.NombreArchivo.Length - 3).ToLower();
+                    var mime = "application/" + fileMime.ToLower();
+                    string targetFile = rootPath + recFound.NombreArchivo;
+                    if (System.IO.File.Exists(targetFile))
+                    {
+                        byte[] pdfBytes = System.IO.File.ReadAllBytes(targetFile);
+                        MemoryStream ms = new MemoryStream(pdfBytes);
+                        return new FileStreamResult(ms, mime);
+                    }
+                }
+            }
+            return new FileStreamResult(emptyms, "image/png");
+        }
+
+        public async Task<List<string>> SaveFile2DiskList(List<IFormFile> FileList)
+        {
+            DateTime time = DateTime.Now;
+            var filePaths = new List<string>();
+            FileManager data = new FileManager();
+            foreach (var file in FileList)
+            {
+                string fileMime = file.FileName.Substring(file.FileName.Length - 4);
+                string newFileName = file.FileName.Replace(fileMime, "") + "_" + time.ToString("yyyy_MM_dd_HH_mm_ss") + fileMime;
+                if (file.Length > 0)
+                {
+                    var filePath = rootPath + newFileName;
+                    using (var stream = System.IO.File.Create(filePath))
+                    {
+                        await file.CopyToAsync(stream);
+                        filePaths.Add(newFileName);
+                    }
+                }
+            }
+            return filePaths;
+        }
+
+        public async Task<List<FileManager>> SaveFileLog(List<string> files, int Tags, int Proceso, int Usuario)
+        {
+            List<FileManager> resultados = new List<FileManager>();
+            foreach (string file in files)
+            {
+                FileManager data = new FileManager();
+                long fileLength = new System.IO.FileInfo(rootPath + file).Length / 1024;
+                data.id = 0;
+                data.IdUsuario = Usuario;
+                data.Proceso = Proceso;
+                data.NombreArchivo = file;
+                data.Tags = Tags.ToString();
+                data.Size = fileLength;
+                await _Repo.FileManager(data);
+            }
+            return await _Repo.getAllFilesByProcess(Tags, Proceso);
+        }
+    }
+
+}

MyRestFullApiAmazonBackend/Services/Utilerias.cs

@@ -0,0 +1,59 @@
+using MyRestFullApiAmazonBackend.Models;
+using System.Net.Mail;
+using System.Net;
+
+namespace MyRestFullApiAmazonBackend.Services
+{
+    public class Utilerias
+    {
+        private IConfiguration _config;
+
+        public Utilerias(IConfiguration config)
+        {
+            _config = config;
+        }
+        public Boolean SendEmail(string htmlContent, Usuarios user)
+        {
+            string defaultPassword = _config.GetValue<string>("DefaultUser:Password");
+            string emailServer = _config.GetValue<string>("EmailServer");
+            int emailPort = _config.GetValue<int>("EmailPort");
+            htmlContent = (htmlContent.Length > 0) ? htmlContent : $@"<html>
+                <body>
+                <table style='font-size:14px; border: 1px solid #225EDD; padding: 5px; width: 1500px; height: 150px;'>
+                <tr style='background-color: #225EDD; color: #FFFFFF;'><td>Hola: {user.Nombre}, mediante el siguiente correo electronico, se le notifica que se le ha creado un nuevo acceso</td></tr>
+                <tr><td>Para acceder a su cuenta, favor de entrar a: http://reportes.gemcousa.com/</td></tr>
+                <tr><td>Nombre de usuario: <b>{user.Usuario}</b></td></tr>
+                <tr><td>Contraseña: <b>{defaultPassword}</b></td></tr>
+                <tr><td>Su contraseña inicial sera: {defaultPassword}, pero es necesario que la cambie antes de poder ingresar</td></tr>
+                <tr><td>Para cambiar la contraseña, puede ir al menu Reset, proporcione su nombre de usuario y su nueva contraseña</td></tr>
+                <tr><td>Si por alguna razon, no recuerda su contrasena, repita este proceso de resetear su contraseña</td></tr>
+                <tr><td>No es necesario responder a este correo, ya que fue generado en automatico por el sistema.</td></tr>
+                <tr style='background-color: #F7192A; font-weight: bold; color: #FFFFFF'><td>Nota: Las credenciales de acceso son responsabilidad personal, nadie solo usted debe conocerlas</td></tr>
+                <tr><td>Que tenga un excelente dia!</td></tr>
+                </table>
+                </body>
+                </html> ";
+            try
+            {
+                using (var smtp = new SmtpClient(emailServer, emailPort))
+                {
+                    smtp.Credentials = new NetworkCredential("noreply@gemcousa.com", "N#16rm87");
+                    smtp.EnableSsl = false;
+                    var correo = new MailMessage();
+                    correo.From = new MailAddress("noreply@gemcousa.com", "noreply");
+                    correo.To.Add(user.Correo);
+                    correo.Subject = "Notification - Se le ha creado un nuevo acceso en http://reportes.gemcousa.com";
+                    correo.Body = htmlContent;
+                    correo.IsBodyHtml = true;
+                    smtp.Send(correo);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Write(ex.ToString());
+                return false;
+            }
+        }
+    }
+}

MyRestFullApiAmazonBackend/Services/ValidarFraccion/SrvValidaFraccion.cs

@@ -0,0 +1,102 @@
+using MyRestFullApiAmazonBackend.Contracts.Utils;
+using System.Net;
+using System.Xml.Linq;
+using System.Xml;
+
+namespace MyRestFullApiAmazonBackend.Services.ValidarFraccion
+{
+    public class SrvValidaFraccion : IValidaFraccion
+    {
+
+        public Boolean ValidaFraccion(string Fraccion)
+        {
+            if (Fraccion.Length != 10) { return false; }
+            int inicio = 0, fin = 0;
+            string Nico = Fraccion.Substring(8, 2);
+            Fraccion = Fraccion.Substring(0, 8);
+            List<string> NicosAutorizados = new List<string>();
+            DateTime now = DateTime.Now;
+            int year = now.Year;
+            int month = now.Month;
+            int day = now.Day;
+            string Fecha = String.Format("{0:00}/{1:00}/{2:0000}", day, month, year);
+            HttpWebRequest request = CreateWebRequest();
+            XmlDocument soapEnvelopeXml = new XmlDocument();
+            soapEnvelopeXml.LoadXml(@"<?xml version=""1.0"" encoding=""utf-8""?>
+                <soap:Envelope xmlns:soap=""http://www.w3.org/2003/05/soap-envelope"" xmlns:tel=""http://tel.reco/"">
+                <soap:Header/>
+                <soap:Body>
+                    <tel:TEL>
+                        <!--Optional:-->
+                        <tel:palabra></tel:palabra>
+                        <!--Optional:-->
+                        <tel:fraccion>" + Fraccion + @"</tel:fraccion>
+                        <!--Optional:-->
+                        <tel:fecha>" + Fecha + @"</tel:fecha>
+                        <!--Optional:-->
+                        <tel:operacion>I</tel:operacion>
+                        <!--Optional:-->
+                        <tel:pais_origen>MEX</tel:pais_origen>
+                        <!--Optional:-->
+                        <tel:adusecc>240</tel:adusecc>
+                        <!--Optional:-->
+                        <tel:patente>3636</tel:patente>
+                        <!--Optional:-->
+                        <tel:Fpago>" + Fecha + @"</tel:Fpago>
+                    </tel:TEL>
+                </soap:Body>
+                </soap:Envelope>");
+            using (Stream stream = request.GetRequestStream()) { soapEnvelopeXml.Save(stream); }
+            using (WebResponse response = request.GetResponse())
+            {
+                using (StreamReader rd = new StreamReader(response.GetResponseStream()))
+                {
+                    string soapResult = rd.ReadToEnd();
+                    string resultado = soapResult.ToString();
+                    try
+                    {
+                        inicio = resultado.IndexOf("&lt;desc_nicos&gt;");
+                    }
+                    catch (FormatException)
+                    {
+                        return false;
+                    }
+                    try
+                    {
+                        fin = resultado.IndexOf("&lt;/desc_nicos&gt;");
+                    }
+                    catch (FormatException)
+                    {
+                        return false;
+                    }
+                    if (inicio < 0 || fin < 0) return false;
+                    resultado = resultado.Substring(inicio, resultado.Length - fin);
+                    inicio = resultado.IndexOf("&lt;desc_nicos&gt;");
+                    fin = resultado.IndexOf("&lt;/desc_nicos&gt;");
+                    resultado = resultado.Substring(inicio, fin);
+                    resultado = resultado.Replace("&lt;", "<").Replace("&gt;", ">") + "</desc_nicos>";
+                    XElement contacts = XElement.Parse(
+                        resultado);
+                    List<XElement> Nicos = contacts.Elements("numero").ToList();
+                    foreach (var nico in Nicos)
+                    {
+                        NicosAutorizados.Add(nico.ToString().Replace("<numero>", "").Replace("</numero>", ""));
+                    }
+
+                }
+            }
+            return (NicosAutorizados.Any(Nico.Contains));
+        }
+
+        public static HttpWebRequest CreateWebRequest()
+        {
+            HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(@"https://tarifaweb.griver.com.mx/wstel/tel.asmx?op=TEL");
+            webRequest.Headers.Add(@"SOAP:Action");
+            webRequest.ContentType = "text/xml;charset=\"utf-8\"";
+            webRequest.Accept = "text/xml";
+            webRequest.Method = "POST";
+            return webRequest;
+        }
+
+    }
+}

MyRestFullApiAmazonBackend/WeatherForecast.cs

@@ -0,0 +1,13 @@
+namespace MyRestFullApiAmazonBackend
+{
+    public class WeatherForecast
+    {
+        public DateTime Date { get; set; }
+
+        public int TemperatureC { get; set; }
+
+        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
+
+        public string? Summary { get; set; }
+    }
+}

MyRestFullApiAmazonBackend/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

MyRestFullApiAmazonBackend/appsettings.json

@@ -0,0 +1,12 @@
+{
+    "ConnectionStrings": {
+        "SqlConnection": "server=.; database=GEMCO; Integrated Security=true;TrustServerCertificate=True; initial catalog = sa;user=code; password=Chispa10"
+    },
+    "Logging": {
+        "LogLevel": {
+            "Default": "Information",
+            "Microsoft.AspNetCore": "Warning"
+        }
+    },
+    "AllowedHosts": "*"
+}

MyRestFullApiAmazonBackend/bin/Debug/net6.0/MyRestFullApiAmazonBackend.deps.json

@@ -0,0 +1,466 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v6.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v6.0": {
+      "MyRestFullApiAmazonBackend/1.0.0": {
+        "dependencies": {
+          "Dapper": "2.0.123",
+          "ExcelDataReader": "3.6.0",
+          "ExcelDataReader.DataSet": "3.6.0",
+          "Swashbuckle.AspNetCore": "6.2.3",
+          "System.Data.SqlClient": "4.8.5",
+          "System.IdentityModel.Tokens.Jwt": "6.26.0"
+        },
+        "runtime": {
+          "MyRestFullApiAmazonBackend.dll": {}
+        }
+      },
+      "Dapper/2.0.123": {
+        "runtime": {
+          "lib/net5.0/Dapper.dll": {
+            "assemblyVersion": "2.0.0.0",
+            "fileVersion": "2.0.123.33578"
+          }
+        }
+      },
+      "ExcelDataReader/3.6.0": {
+        "runtime": {
+          "lib/netstandard2.0/ExcelDataReader.dll": {
+            "assemblyVersion": "3.6.0.0",
+            "fileVersion": "3.6.0.0"
+          }
+        }
+      },
+      "ExcelDataReader.DataSet/3.6.0": {
+        "dependencies": {
+          "ExcelDataReader": "3.6.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/ExcelDataReader.DataSet.dll": {
+            "assemblyVersion": "3.6.0.0",
+            "fileVersion": "3.6.0.0"
+          }
+        }
+      },
+      "Microsoft.CSharp/4.5.0": {},
+      "Microsoft.Extensions.ApiDescription.Server/3.0.0": {},
+      "Microsoft.IdentityModel.Abstractions/6.26.0": {
+        "runtime": {
+          "lib/net6.0/Microsoft.IdentityModel.Abstractions.dll": {
+            "assemblyVersion": "6.26.0.0",
+            "fileVersion": "6.26.0.40120"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.JsonWebTokens/6.26.0": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "6.26.0",
+          "System.Text.Encoding": "4.3.0",
+          "System.Text.Encodings.Web": "4.7.2",
+          "System.Text.Json": "4.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Microsoft.IdentityModel.JsonWebTokens.dll": {
+            "assemblyVersion": "6.26.0.0",
+            "fileVersion": "6.26.0.40120"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Logging/6.26.0": {
+        "dependencies": {
+          "Microsoft.IdentityModel.Abstractions": "6.26.0"
+        },
+        "runtime": {
+          "lib/net6.0/Microsoft.IdentityModel.Logging.dll": {
+            "assemblyVersion": "6.26.0.0",
+            "fileVersion": "6.26.0.40120"
+          }
+        }
+      },
+      "Microsoft.IdentityModel.Tokens/6.26.0": {
+        "dependencies": {
+          "Microsoft.CSharp": "4.5.0",
+          "Microsoft.IdentityModel.Logging": "6.26.0",
+          "System.Security.Cryptography.Cng": "4.5.0"
+        },
+        "runtime": {
+          "lib/net6.0/Microsoft.IdentityModel.Tokens.dll": {
+            "assemblyVersion": "6.26.0.0",
+            "fileVersion": "6.26.0.40120"
+          }
+        }
+      },
+      "Microsoft.NETCore.Platforms/3.1.0": {},
+      "Microsoft.NETCore.Targets/1.1.0": {},
+      "Microsoft.OpenApi/1.2.3": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.OpenApi.dll": {
+            "assemblyVersion": "1.2.3.0",
+            "fileVersion": "1.2.3.0"
+          }
+        }
+      },
+      "Microsoft.Win32.Registry/4.7.0": {
+        "dependencies": {
+          "System.Security.AccessControl": "4.7.0",
+          "System.Security.Principal.Windows": "4.7.0"
+        }
+      },
+      "runtime.native.System.Data.SqlClient.sni/4.7.0": {
+        "dependencies": {
+          "runtime.win-arm64.runtime.native.System.Data.SqlClient.sni": "4.4.0",
+          "runtime.win-x64.runtime.native.System.Data.SqlClient.sni": "4.4.0",
+          "runtime.win-x86.runtime.native.System.Data.SqlClient.sni": "4.4.0"
+        }
+      },
+      "runtime.win-arm64.runtime.native.System.Data.SqlClient.sni/4.4.0": {
+        "runtimeTargets": {
+          "runtimes/win-arm64/native/sni.dll": {
+            "rid": "win-arm64",
+            "assetType": "native",
+            "fileVersion": "4.6.25512.1"
+          }
+        }
+      },
+      "runtime.win-x64.runtime.native.System.Data.SqlClient.sni/4.4.0": {
+        "runtimeTargets": {
+          "runtimes/win-x64/native/sni.dll": {
+            "rid": "win-x64",
+            "assetType": "native",
+            "fileVersion": "4.6.25512.1"
+          }
+        }
+      },
+      "runtime.win-x86.runtime.native.System.Data.SqlClient.sni/4.4.0": {
+        "runtimeTargets": {
+          "runtimes/win-x86/native/sni.dll": {
+            "rid": "win-x86",
+            "assetType": "native",
+            "fileVersion": "4.6.25512.1"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore/6.2.3": {
+        "dependencies": {
+          "Microsoft.Extensions.ApiDescription.Server": "3.0.0",
+          "Swashbuckle.AspNetCore.Swagger": "6.2.3",
+          "Swashbuckle.AspNetCore.SwaggerGen": "6.2.3",
+          "Swashbuckle.AspNetCore.SwaggerUI": "6.2.3"
+        }
+      },
+      "Swashbuckle.AspNetCore.Swagger/6.2.3": {
+        "dependencies": {
+          "Microsoft.OpenApi": "1.2.3"
+        },
+        "runtime": {
+          "lib/net6.0/Swashbuckle.AspNetCore.Swagger.dll": {
+            "assemblyVersion": "6.2.3.0",
+            "fileVersion": "6.2.3.0"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore.SwaggerGen/6.2.3": {
+        "dependencies": {
+          "Swashbuckle.AspNetCore.Swagger": "6.2.3"
+        },
+        "runtime": {
+          "lib/net6.0/Swashbuckle.AspNetCore.SwaggerGen.dll": {
+            "assemblyVersion": "6.2.3.0",
+            "fileVersion": "6.2.3.0"
+          }
+        }
+      },
+      "Swashbuckle.AspNetCore.SwaggerUI/6.2.3": {
+        "runtime": {
+          "lib/net6.0/Swashbuckle.AspNetCore.SwaggerUI.dll": {
+            "assemblyVersion": "6.2.3.0",
+            "fileVersion": "6.2.3.0"
+          }
+        }
+      },
+      "System.Data.SqlClient/4.8.5": {
+        "dependencies": {
+          "Microsoft.Win32.Registry": "4.7.0",
+          "System.Security.Principal.Windows": "4.7.0",
+          "runtime.native.System.Data.SqlClient.sni": "4.7.0"
+        },
+        "runtime": {
+          "lib/netcoreapp2.1/System.Data.SqlClient.dll": {
+            "assemblyVersion": "4.6.1.5",
+            "fileVersion": "4.700.22.51706"
+          }
+        },
+        "runtimeTargets": {
+          "runtimes/unix/lib/netcoreapp2.1/System.Data.SqlClient.dll": {
+            "rid": "unix",
+            "assetType": "runtime",
+            "assemblyVersion": "4.6.1.5",
+            "fileVersion": "4.700.22.51706"
+          },
+          "runtimes/win/lib/netcoreapp2.1/System.Data.SqlClient.dll": {
+            "rid": "win",
+            "assetType": "runtime",
+            "assemblyVersion": "4.6.1.5",
+            "fileVersion": "4.700.22.51706"
+          }
+        }
+      },
+      "System.IdentityModel.Tokens.Jwt/6.26.0": {
+        "dependencies": {
+          "Microsoft.IdentityModel.JsonWebTokens": "6.26.0",
+          "Microsoft.IdentityModel.Tokens": "6.26.0"
+        },
+        "runtime": {
+          "lib/net6.0/System.IdentityModel.Tokens.Jwt.dll": {
+            "assemblyVersion": "6.26.0.0",
+            "fileVersion": "6.26.0.40120"
+          }
+        }
+      },
+      "System.Runtime/4.3.0": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0"
+        }
+      },
+      "System.Security.AccessControl/4.7.0": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0",
+          "System.Security.Principal.Windows": "4.7.0"
+        }
+      },
+      "System.Security.Cryptography.Cng/4.5.0": {},
+      "System.Security.Principal.Windows/4.7.0": {},
+      "System.Text.Encoding/4.3.0": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
+        }
+      },
+      "System.Text.Encodings.Web/4.7.2": {},
+      "System.Text.Json/4.7.2": {}
+    }
+  },
+  "libraries": {
+    "MyRestFullApiAmazonBackend/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Dapper/2.0.123": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-RDFF4rBLLmbpi6pwkY7q/M6UXHRJEOerplDGE5jwEkP/JGJnBauAClYavNKJPW1yOTWRPIyfj4is3EaJxQXILQ==",
+      "path": "dapper/2.0.123",
+      "hashPath": "dapper.2.0.123.nupkg.sha512"
+    },
+    "ExcelDataReader/3.6.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-eXyxTwG7EEWpgQX3juZ2KcndqTqm/ydx9GXS2lUiMJU54U4h5eXdygRtVgINv0t60ezPWEb+lL7uM7Q+wm5BBA==",
+      "path": "exceldatareader/3.6.0",
+      "hashPath": "exceldatareader.3.6.0.nupkg.sha512"
+    },
+    "ExcelDataReader.DataSet/3.6.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-miW3sWmPXnLM38YadRIfnhL4W4QZajpS6Q/OqsOpFJU5ct8h+M/fMpbGMm5INtsMP0Y1k0WK0stIfSW3RP31Xg==",
+      "path": "exceldatareader.dataset/3.6.0",
+      "hashPath": "exceldatareader.dataset.3.6.0.nupkg.sha512"
+    },
+    "Microsoft.CSharp/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kaj6Wb4qoMuH3HySFJhxwQfe8R/sJsNJnANrvv8WdFPMoNbKY5htfNscv+LHCu5ipz+49m2e+WQXpLXr9XYemQ==",
+      "path": "microsoft.csharp/4.5.0",
+      "hashPath": "microsoft.csharp.4.5.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.ApiDescription.Server/3.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LH4OE/76F6sOCslif7+Xh3fS/wUUrE5ryeXAMcoCnuwOQGT5Smw0p57IgDh/pHgHaGz/e+AmEQb7pRgb++wt0w==",
+      "path": "microsoft.extensions.apidescription.server/3.0.0",
+      "hashPath": "microsoft.extensions.apidescription.server.3.0.0.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Abstractions/6.26.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-NHEnDBvLYqP81YWqKk1pJt0qSUmqobvFsRL/SR/H6x1jmQh2D1EcuHHhmfIzDnzaOlQJL9GeBDHykqHp0JGNCw==",
+      "path": "microsoft.identitymodel.abstractions/6.26.0",
+      "hashPath": "microsoft.identitymodel.abstractions.6.26.0.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.JsonWebTokens/6.26.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-5S993Y51C6p3pQGcvJvUU4Bxq5H5tXGyAzvmXXZkELv8pSWVgbgVsQakGupjx6WLFRN+Y6clp9chVytynWYn5A==",
+      "path": "microsoft.identitymodel.jsonwebtokens/6.26.0",
+      "hashPath": "microsoft.identitymodel.jsonwebtokens.6.26.0.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Logging/6.26.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Svec5ltH4zz5ylAmFiHrUETLalw3d8siPbQ7+0H9GNGbZrVf5u7TaHpmDuJyb3EUiITfisD3vM83spsO/l1igA==",
+      "path": "microsoft.identitymodel.logging/6.26.0",
+      "hashPath": "microsoft.identitymodel.logging.6.26.0.nupkg.sha512"
+    },
+    "Microsoft.IdentityModel.Tokens/6.26.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-mFNbROC89eap6GTqoYcInCiYsaV8sLxPsgCurQnJDcJoLBk7XoAJpBJae6rkj2VEzWqfErd4jlzaqqRI7wjGOQ==",
+      "path": "microsoft.identitymodel.tokens/6.26.0",
+      "hashPath": "microsoft.identitymodel.tokens.6.26.0.nupkg.sha512"
+    },
+    "Microsoft.NETCore.Platforms/3.1.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-z7aeg8oHln2CuNulfhiLYxCVMPEwBl3rzicjvIX+4sUuCwvXw5oXQEtbiU2c0z4qYL5L3Kmx0mMA/+t/SbY67w==",
+      "path": "microsoft.netcore.platforms/3.1.0",
+      "hashPath": "microsoft.netcore.platforms.3.1.0.nupkg.sha512"
+    },
+    "Microsoft.NETCore.Targets/1.1.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-aOZA3BWfz9RXjpzt0sRJJMjAscAUm3Hoa4UWAfceV9UTYxgwZ1lZt5nO2myFf+/jetYQo4uTP7zS8sJY67BBxg==",
+      "path": "microsoft.netcore.targets/1.1.0",
+      "hashPath": "microsoft.netcore.targets.1.1.0.nupkg.sha512"
+    },
+    "Microsoft.OpenApi/1.2.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Nug3rO+7Kl5/SBAadzSMAVgqDlfGjJZ0GenQrLywJ84XGKO0uRqkunz5Wyl0SDwcR71bAATXvSdbdzPrYRYKGw==",
+      "path": "microsoft.openapi/1.2.3",
+      "hashPath": "microsoft.openapi.1.2.3.nupkg.sha512"
+    },
+    "Microsoft.Win32.Registry/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-KSrRMb5vNi0CWSGG1++id2ZOs/1QhRqROt+qgbEAdQuGjGrFcl4AOl4/exGPUYz2wUnU42nvJqon1T3U0kPXLA==",
+      "path": "microsoft.win32.registry/4.7.0",
+      "hashPath": "microsoft.win32.registry.4.7.0.nupkg.sha512"
+    },
+    "runtime.native.System.Data.SqlClient.sni/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-9kyFSIdN3T0qjDQ2R0HRXYIhS3l5psBzQi6qqhdLz+SzFyEy4sVxNOke+yyYv8Cu8rPER12c3RDjLT8wF3WBYQ==",
+      "path": "runtime.native.system.data.sqlclient.sni/4.7.0",
+      "hashPath": "runtime.native.system.data.sqlclient.sni.4.7.0.nupkg.sha512"
+    },
+    "runtime.win-arm64.runtime.native.System.Data.SqlClient.sni/4.4.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LbrynESTp3bm5O/+jGL8v0Qg5SJlTV08lpIpFesXjF6uGNMWqFnUQbYBJwZTeua6E/Y7FIM1C54Ey1btLWupdg==",
+      "path": "runtime.win-arm64.runtime.native.system.data.sqlclient.sni/4.4.0",
+      "hashPath": "runtime.win-arm64.runtime.native.system.data.sqlclient.sni.4.4.0.nupkg.sha512"
+    },
+    "runtime.win-x64.runtime.native.System.Data.SqlClient.sni/4.4.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-38ugOfkYJqJoX9g6EYRlZB5U2ZJH51UP8ptxZgdpS07FgOEToV+lS11ouNK2PM12Pr6X/PpT5jK82G3DwH/SxQ==",
+      "path": "runtime.win-x64.runtime.native.system.data.sqlclient.sni/4.4.0",
+      "hashPath": "runtime.win-x64.runtime.native.system.data.sqlclient.sni.4.4.0.nupkg.sha512"
+    },
+    "runtime.win-x86.runtime.native.System.Data.SqlClient.sni/4.4.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-YhEdSQUsTx+C8m8Bw7ar5/VesXvCFMItyZF7G1AUY+OM0VPZUOeAVpJ4Wl6fydBGUYZxojTDR3I6Bj/+BPkJNA==",
+      "path": "runtime.win-x86.runtime.native.system.data.sqlclient.sni/4.4.0",
+      "hashPath": "runtime.win-x86.runtime.native.system.data.sqlclient.sni.4.4.0.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore/6.2.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cnzQDn0Le+hInsw2SYwlOhOCPXpYi/szcvnyqZJ12v+QyrLBwAmWXBg6RIyHB18s/mLeywC+Rg2O9ndz0IUNYQ==",
+      "path": "swashbuckle.aspnetcore/6.2.3",
+      "hashPath": "swashbuckle.aspnetcore.6.2.3.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.Swagger/6.2.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-qOF7j1sL0bWm8g/qqHVPCvkO3JlVvUIB8WfC98kSh6BT5y5DAnBNctfac7XR5EZf+eD7/WasvANncTqwZYfmWQ==",
+      "path": "swashbuckle.aspnetcore.swagger/6.2.3",
+      "hashPath": "swashbuckle.aspnetcore.swagger.6.2.3.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.SwaggerGen/6.2.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-+Xq7WdMCCfcXlnbLJVFNgY8ITdP2TRYIlpbt6IKzDw5FwFxdi9lBfNDtcT+/wkKwX70iBBFmXldnnd02/VO72A==",
+      "path": "swashbuckle.aspnetcore.swaggergen/6.2.3",
+      "hashPath": "swashbuckle.aspnetcore.swaggergen.6.2.3.nupkg.sha512"
+    },
+    "Swashbuckle.AspNetCore.SwaggerUI/6.2.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-bCRI87uKJVb4G+KURWm8LQrL64St04dEFZcF6gIM67Zc0Sr/N47EO83ybLMYOvfNdO1DCv8xwPcrz9J/VEhQ5g==",
+      "path": "swashbuckle.aspnetcore.swaggerui/6.2.3",
+      "hashPath": "swashbuckle.aspnetcore.swaggerui.6.2.3.nupkg.sha512"
+    },
+    "System.Data.SqlClient/4.8.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-fRqxut4lrndPHrXD+ht1XRmCL3obuKldm4XjCRYS9p5f7FSR7shBxAwTkDrpFMsHC9BhNgjjmUtiIjvehn5zkg==",
+      "path": "system.data.sqlclient/4.8.5",
+      "hashPath": "system.data.sqlclient.4.8.5.nupkg.sha512"
+    },
+    "System.IdentityModel.Tokens.Jwt/6.26.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-GT6imbntzCpoGHTRFUa98TPCF9PTnzV1v5KiTj9sT5ZmeYZErNA5ks5VDvYBaOC59y3dQ78IsMzEJm+XrxDk6w==",
+      "path": "system.identitymodel.tokens.jwt/6.26.0",
+      "hashPath": "system.identitymodel.tokens.jwt.6.26.0.nupkg.sha512"
+    },
+    "System.Runtime/4.3.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-JufQi0vPQ0xGnAczR13AUFglDyVYt4Kqnz1AZaiKZ5+GICq0/1MH/mO/eAJHt/mHW1zjKBJd7kV26SrxddAhiw==",
+      "path": "system.runtime/4.3.0",
+      "hashPath": "system.runtime.4.3.0.nupkg.sha512"
+    },
+    "System.Security.AccessControl/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-JECvTt5aFF3WT3gHpfofL2MNNP6v84sxtXxpqhLBCcDRzqsPBmHhQ6shv4DwwN2tRlzsUxtb3G9M3763rbXKDg==",
+      "path": "system.security.accesscontrol/4.7.0",
+      "hashPath": "system.security.accesscontrol.4.7.0.nupkg.sha512"
+    },
+    "System.Security.Cryptography.Cng/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-WG3r7EyjUe9CMPFSs6bty5doUqT+q9pbI80hlNzo2SkPkZ4VTuZkGWjpp77JB8+uaL4DFPRdBsAY+DX3dBK92A==",
+      "path": "system.security.cryptography.cng/4.5.0",
+      "hashPath": "system.security.cryptography.cng.4.5.0.nupkg.sha512"
+    },
+    "System.Security.Principal.Windows/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ojD0PX0XhneCsUbAZVKdb7h/70vyYMDYs85lwEI+LngEONe/17A0cFaRFqZU+sOEidcVswYWikYOQ9PPfjlbtQ==",
+      "path": "system.security.principal.windows/4.7.0",
+      "hashPath": "system.security.principal.windows.4.7.0.nupkg.sha512"
+    },
+    "System.Text.Encoding/4.3.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BiIg+KWaSDOITze6jGQynxg64naAPtqGHBwDrLaCtixsa5bKiR8dpPOHA7ge3C0JJQizJE+sfkz1wV+BAKAYZw==",
+      "path": "system.text.encoding/4.3.0",
+      "hashPath": "system.text.encoding.4.3.0.nupkg.sha512"
+    },
+    "System.Text.Encodings.Web/4.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-iTUgB/WtrZ1sWZs84F2hwyQhiRH6QNjQv2DkwrH+WP6RoFga2Q1m3f9/Q7FG8cck8AdHitQkmkXSY8qylcDmuA==",
+      "path": "system.text.encodings.web/4.7.2",
+      "hashPath": "system.text.encodings.web.4.7.2.nupkg.sha512"
+    },
+    "System.Text.Json/4.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-TcMd95wcrubm9nHvJEQs70rC0H/8omiSGGpU4FQ/ZA1URIqD4pjmFJh2Mfv1yH1eHgJDWTi2hMDXwTET+zOOyg==",
+      "path": "system.text.json/4.7.2",
+      "hashPath": "system.text.json.4.7.2.nupkg.sha512"
+    }
+  }
+}

MyRestFullApiAmazonBackend/bin/Debug/net6.0/MyRestFullApiAmazonBackend.runtimeconfig.json

@@ -0,0 +1,19 @@
+{
+  "runtimeOptions": {
+    "tfm": "net6.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "6.0.0"
+      },
+      {
+        "name": "Microsoft.AspNetCore.App",
+        "version": "6.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.GC.Server": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

MyRestFullApiAmazonBackend/bin/Debug/net6.0/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

MyRestFullApiAmazonBackend/bin/Debug/net6.0/appsettings.json

@@ -0,0 +1,12 @@
+{
+    "ConnectionStrings": {
+        "SqlConnection": "server=.; database=GEMCO; Integrated Security=true;TrustServerCertificate=True; initial catalog = sa;user=code; password=Chispa10"
+    },
+    "Logging": {
+        "LogLevel": {
+            "Default": "Information",
+            "Microsoft.AspNetCore": "Warning"
+        }
+    },
+    "AllowedHosts": "*"
+}