Backend Del Proyecto del Book

master
Luis Rendon 1 month ago
commit a10e4bb992
  1. BIN
      .vs/BookPrectaBackend/DesignTimeBuild/.dtbcache.v2
  2. BIN
      .vs/BookPrectaBackend/FileContentIndex/1cc7bfe6-fd87-4f3d-9746-1d1a09ba971f.vsidx
  3. BIN
      .vs/BookPrectaBackend/FileContentIndex/2bb4b97a-9820-4853-ad2d-63181eccee08.vsidx
  4. BIN
      .vs/BookPrectaBackend/FileContentIndex/c08b8cb4-c2d0-423c-8c8b-3da13fe67bb5.vsidx
  5. BIN
      .vs/BookPrectaBackend/FileContentIndex/d7486bef-4b32-4024-b4f9-89de501cf95b.vsidx
  6. BIN
      .vs/BookPrectaBackend/FileContentIndex/d754bad4-af28-45e8-bed3-5fcf7ec2533e.vsidx
  7. 1021
      .vs/BookPrectaBackend/config/applicationhost.config
  8. BIN
      .vs/BookPrectaBackend/v17/.futdcache.v2
  9. BIN
      .vs/BookPrectaBackend/v17/.suo
  10. 85
      .vs/BookPrectaBackend/v17/DocumentLayout.json
  11. BIN
      .vs/ProjectEvaluation/bookprectabackend.metadata.v7.bin
  12. BIN
      .vs/ProjectEvaluation/bookprectabackend.projects.v7.bin
  13. 25
      BookPrectaBackend.sln
  14. 402
      BookPrectaBackend/.gitignore
  15. 19
      BookPrectaBackend/BookPrectaBackend.csproj
  16. 24
      BookPrectaBackend/Clientes/Contracts/ICatResponsablesRepository.cs
  17. 10
      BookPrectaBackend/Clientes/Email/DTOSendEmail.cs
  18. 13
      BookPrectaBackend/Clientes/Email/DTOSendEmailBcc.cs
  19. 163
      BookPrectaBackend/Clientes/Repository/CatResponsablesRepository.cs
  20. 19
      BookPrectaBackend/Context/DapperContext.cs
  21. 129
      BookPrectaBackend/Contracts/Catalogos/ExelController.cs
  22. 20
      BookPrectaBackend/Contracts/Catalogos/ICatChequesPrecuenta.cs
  23. 10
      BookPrectaBackend/Contracts/IMenuRepository.cs
  24. 19
      BookPrectaBackend/Contracts/IPerfilesRepository.cs
  25. 25
      BookPrectaBackend/Contracts/IUsuariosRepository.cs
  26. 16
      BookPrectaBackend/Contracts/Reportes/IRptBookPrectacs.cs
  27. 294
      BookPrectaBackend/Controllers/AuthController.cs
  28. 103
      BookPrectaBackend/Controllers/Catalogos/CatalogoRelacionesController.cs
  29. 167
      BookPrectaBackend/Controllers/PerfilesController.cs
  30. 51
      BookPrectaBackend/Controllers/Reportes/ReportesController.cs
  31. 173
      BookPrectaBackend/Controllers/UsuariosController.cs
  32. 33
      BookPrectaBackend/Controllers/WeatherForecastController.cs
  33. 48
      BookPrectaBackend/Crypto/Crypto.cs
  34. 10
      BookPrectaBackend/DTO/DTOItemMenuPerfil.cs
  35. 8
      BookPrectaBackend/DTO/DTOLogin.cs
  36. 11
      BookPrectaBackend/DTO/DTORolesAsignados.cs
  37. 21
      BookPrectaBackend/DTO/ExelServices/Book.cs
  38. 17
      BookPrectaBackend/DTO/ExelServices/Precta.cs
  39. 10
      BookPrectaBackend/DTO/Usuario/DTOClonarUsuario.cs
  40. 8
      BookPrectaBackend/DTO/Usuario/DTOPINData.cs
  41. 8
      BookPrectaBackend/DTO/Usuario/DTOPINUsuario.cs
  42. 8
      BookPrectaBackend/DTO/Usuario/DTOPerfilCreate.cs
  43. 8
      BookPrectaBackend/DTO/Usuario/DTOResetPassword.cs
  44. 14
      BookPrectaBackend/DTO/Usuario/DTOUsuario.cs
  45. 9
      BookPrectaBackend/DTO/Usuario/DTOUsuarioTransportista.cs
  46. 8
      BookPrectaBackend/DTO/Usuario/DTOUsuariosPerfilParecido.cs
  47. 9
      BookPrectaBackend/DTO/Usuario/DTOUsuariosShort.cs
  48. 9
      BookPrectaBackend/Models/CatRoles.cs
  49. 11
      BookPrectaBackend/Models/Catalogos/CatRelacionPrecuentaCheque.cs
  50. 11
      BookPrectaBackend/Models/Menu.cs
  51. 8
      BookPrectaBackend/Models/Perfiles.cs
  52. 16
      BookPrectaBackend/Models/PerfilesMenu.cs
  53. 41
      BookPrectaBackend/Models/Reportes/RelacionBookPrecta.cs
  54. 44
      BookPrectaBackend/Models/Reportes/WorkingHours.cs
  55. 37
      BookPrectaBackend/Models/Usuarios.cs
  56. 164
      BookPrectaBackend/Program.cs
  57. 31
      BookPrectaBackend/Properties/launchSettings.json
  58. 102
      BookPrectaBackend/Repository/Catalogos/CatRelacionPrecuentaCheques.cs
  59. 161
      BookPrectaBackend/Repository/ExelServices/ExelHourWorking/ExelHours.cs
  60. 250
      BookPrectaBackend/Repository/ExelServices/ExelRepository.cs
  61. 96
      BookPrectaBackend/Repository/ExelServices/ExelRepositoryPrecta.cs
  62. 35
      BookPrectaBackend/Repository/MenuRepository.cs
  63. 107
      BookPrectaBackend/Repository/PerfilesRepository.cs
  64. 54
      BookPrectaBackend/Repository/Reportes/ReportesRepository.cs
  65. 203
      BookPrectaBackend/Repository/UsuariosRepository.cs
  66. 52
      BookPrectaBackend/Services/Utilerias.cs
  67. 13
      BookPrectaBackend/WeatherForecast.cs
  68. 26
      BookPrectaBackend/appsettings.Development.json
  69. 25
      BookPrectaBackend/appsettings.Staging.json
  70. 36
      BookPrectaBackend/appsettings.json

File diff suppressed because it is too large Load Diff

Binary file not shown.

@ -0,0 +1,85 @@
{
"Version": 1,
"WorkspaceRootPath": "C:\\Projects\\staging\\BookPrectaBackend\\",
"Documents": [
{
"AbsoluteMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|c:\\projects\\staging\\bookprectabackend\\bookprectabackend\\contracts\\catalogos\\exelcontroller.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}",
"RelativeMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|solutionrelative:bookprectabackend\\contracts\\catalogos\\exelcontroller.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}"
},
{
"AbsoluteMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|c:\\projects\\staging\\bookprectabackend\\bookprectabackend\\repository\\exelservices\\exelhourworking\\exelhours.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}",
"RelativeMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|solutionrelative:bookprectabackend\\repository\\exelservices\\exelhourworking\\exelhours.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}"
},
{
"AbsoluteMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|c:\\projects\\staging\\bookprectabackend\\bookprectabackend\\models\\reportes\\workinghours.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}",
"RelativeMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|solutionrelative:bookprectabackend\\models\\reportes\\workinghours.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}"
},
{
"AbsoluteMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|c:\\projects\\staging\\bookprectabackend\\bookprectabackend\\program.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}",
"RelativeMoniker": "D:0:0:{7500AEA0-C734-4235-8087-ED479F4DA80B}|BookPrectaBackend\\BookPrectaBackend.csproj|solutionrelative:bookprectabackend\\program.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}"
}
],
"DocumentGroupContainers": [
{
"Orientation": 0,
"VerticalTabListWidth": 256,
"DocumentGroups": [
{
"DockedWidth": 219,
"SelectedChildIndex": 3,
"Children": [
{
"$type": "Document",
"DocumentIndex": 1,
"Title": "ExelHours.cs",
"DocumentMoniker": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Repository\\ExelServices\\ExelHourWorking\\ExelHours.cs",
"RelativeDocumentMoniker": "BookPrectaBackend\\Repository\\ExelServices\\ExelHourWorking\\ExelHours.cs",
"ToolTip": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Repository\\ExelServices\\ExelHourWorking\\ExelHours.cs",
"RelativeToolTip": "BookPrectaBackend\\Repository\\ExelServices\\ExelHourWorking\\ExelHours.cs",
"ViewState": "AQIAAEsAAAAAAAAAAAAYwGUAAABQAAAA",
"Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|",
"WhenOpened": "2024-08-13T21:45:07.731Z"
},
{
"$type": "Document",
"DocumentIndex": 2,
"Title": "WorkingHours.cs",
"DocumentMoniker": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Models\\Reportes\\WorkingHours.cs",
"RelativeDocumentMoniker": "BookPrectaBackend\\Models\\Reportes\\WorkingHours.cs",
"ToolTip": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Models\\Reportes\\WorkingHours.cs",
"RelativeToolTip": "BookPrectaBackend\\Models\\Reportes\\WorkingHours.cs",
"ViewState": "AQIAAA0AAAAAAAAAAAAgwCIAAAAtAAAA",
"Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|",
"WhenOpened": "2024-08-14T04:24:51.983Z"
},
{
"$type": "Document",
"DocumentIndex": 3,
"Title": "Program.cs",
"DocumentMoniker": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Program.cs",
"RelativeDocumentMoniker": "BookPrectaBackend\\Program.cs",
"ToolTip": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Program.cs",
"RelativeToolTip": "BookPrectaBackend\\Program.cs",
"ViewState": "AQIAAAsAAAAAAAAAAAAowCoAAAA2AAAA",
"Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|",
"WhenOpened": "2024-08-13T23:21:32.915Z"
},
{
"$type": "Document",
"DocumentIndex": 0,
"Title": "ExelController.cs",
"DocumentMoniker": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Contracts\\Catalogos\\ExelController.cs",
"RelativeDocumentMoniker": "BookPrectaBackend\\Contracts\\Catalogos\\ExelController.cs",
"ToolTip": "C:\\Projects\\staging\\BookPrectaBackend\\BookPrectaBackend\\Contracts\\Catalogos\\ExelController.cs",
"RelativeToolTip": "BookPrectaBackend\\Contracts\\Catalogos\\ExelController.cs",
"ViewState": "AQIAADQAAAAAAAAAAAApwEgAAAAIAAAA",
"Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|",
"WhenOpened": "2024-08-13T23:12:09.253Z",
"EditorCaption": ""
}
]
}
]
}
]
}

@ -0,0 +1,25 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.9.34714.143
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BookPrectaBackend", "BookPrectaBackend\BookPrectaBackend.csproj", "{7500AEA0-C734-4235-8087-ED479F4DA80B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{7500AEA0-C734-4235-8087-ED479F4DA80B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{7500AEA0-C734-4235-8087-ED479F4DA80B}.Debug|Any CPU.Build.0 = Debug|Any CPU
{7500AEA0-C734-4235-8087-ED479F4DA80B}.Release|Any CPU.ActiveCfg = Release|Any CPU
{7500AEA0-C734-4235-8087-ED479F4DA80B}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {1BAD9F1C-5D2F-4C53-B1AC-44A99A151E4A}
EndGlobalSection
EndGlobal

@ -0,0 +1,402 @@
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
##
## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
# User-specific files
*.rsuser
*.suo
*.user
*.userosscache
*.sln.docstates
*.dll
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Mono auto generated files
mono_crash.*
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
[Ww][Ii][Nn]32/
[Aa][Rr][Mm]/
[Aa][Rr][Mm]64/
bld/
bin/*
Bin/*
obj/*
Obj/*
[Ll]og/
[Ll]ogs/
# Visual Studio 2015/2017 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# Visual Studio 2017 auto generated files
Generated\ Files/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUnit
*.VisualState.xml
TestResult.xml
nunit-*.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# Benchmark Results
BenchmarkDotNet.Artifacts/
# .NET Core
project.lock.json
project.fragment.lock.json
artifacts/
# ASP.NET Scaffolding
ScaffoldingReadMe.txt
# StyleCop
StyleCopReport.xml
# Files built by Visual Studio
*_i.c
*_p.c
*_h.h
*.ilk
*.meta
*.obj
*.iobj
*.pch
*.pdb
*.ipdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*_wpftmp.csproj
*.log
*.tlog
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# Visual Studio Trace Files
*.e2e
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# AxoCover is a Code Coverage Tool
.axoCover/*
!.axoCover/settings.json
# Coverlet is a free, cross platform Code Coverage Tool
coverage*.json
coverage*.xml
coverage*.info
# Visual Studio code coverage results
*.coverage
*.coveragexml
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# Note: Comment the next line if you want to checkin your web deploy settings,
# but database connection strings (with potential passwords) will be unencrypted
*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# NuGet Symbol Packages
*.snupkg
# The packages folder can be ignored because of Package Restore
**/[Pp]ackages/*
# except build/, which is used as an MSBuild target.
!**/[Pp]ackages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/[Pp]ackages/repositories.config
# NuGet v3's project.json files produces more ignorable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
*.appx
*.appxbundle
*.appxupload
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!?*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
orleans.codegen.cs
# Including strong name files can present a security risk
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
#*.snk
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
ServiceFabricBackup/
*.rptproj.bak
# SQL Server files
*.mdf
*.ldf
*.ndf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
*.rptproj.rsuser
*- [Bb]ackup.rdl
*- [Bb]ackup ([0-9]).rdl
*- [Bb]ackup ([0-9][0-9]).rdl
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
node_modules/
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw
# Visual Studio 6 auto-generated project file (contains which files were open etc.)
*.vbp
# Visual Studio 6 workspace and project file (working project files containing files to include in project)
*.dsw
*.dsp
# Visual Studio 6 technical files
*.ncb
*.aps
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# CodeRush personal settings
.cr/personal
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.config
# Tabs Studio
*.tss
# Telerik's JustMock configuration file
*.jmconfig
# BizTalk build output
*.btp.cs
*.btm.cs
*.odx.cs
*.xsd.cs
# OpenCover UI analysis results
OpenCover/
# Azure Stream Analytics local run output
ASALocalRun/
# MSBuild Binary and Structured Log
*.binlog
# NVidia Nsight GPU debugger configuration file
*.nvuser
# MFractors (Xamarin productivity tool) working folder
.mfractor/
# Local History for Visual Studio
.localhistory/
# Visual Studio History (VSHistory) files
.vshistory/
# BeatPulse healthcheck temp database
healthchecksdb
# Backup folder for Package Reference Convert tool in Visual Studio 2017
MigrationBackup/
# Ionide (cross platform F# VS Code tools) working folder
.ionide/
# Fody - auto-generated XML schema
FodyWeavers.xsd
# VS Code files for those working on multiple tools
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
*.code-workspace
# Local History for Visual Studio Code
.history/
# Windows Installer files from build outputs
*.cab
*.msi
*.msix
*.msm
*.msp
# JetBrains Rider
*.sln.iml

@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Dapper" Version="2.1.35" />
<PackageReference Include="EPPlus" Version="7.2.2" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.16" />
<PackageReference Include="Microsoft.Data.SqlClient" Version="5.2.1" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
<PackageReference Include="NPOI" Version="2.7.1" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
</ItemGroup>
</Project>

@ -0,0 +1,24 @@
using BookPrectaBackend.Clientes.Email;
/*using ZINCBackend.Clientes.ZincInternacional.Model;*/
using BookPrectaBackend.DTO;
using BookPrectaBackend.DTO.Usuario;
namespace BookPrectaBackend.Clientes.Contracts
{
public interface ICatResponsablesRepository
{
/* public Task<IEnumerable<I1868CatResponsables>> Get();
public Task<IEnumerable<I1868CatResponsableCorreos>> ResponsablesEmailsGetAll();*/
/*public Task<I1868CatResponsables> GetByUser(DTOLogin data);*/
/* public Task<int> searchResponsable(string Usuario);*/
public Task<IEnumerable<DTOPINData>> CreatePIN(int Id);
public Task<Boolean> ValidatePIN(DTOPINUsuario data);
public Task<DTOLogin> resetPassword(DTOResetPassword user);
/* public Task<IEnumerable<I1868CatResponsableCorreos>> GetEmailsByResponsable(int id);*/
/*public Task<I1868CatResponsableCorreos> EmailAppend(I1868CatResponsableCorreos data);*/
/* public Task<Boolean> UserAppend(int id, String Usuario);*/
/* public Task<DTONotificacionTransportista> GetEmailsByIdDetalle(int id);
public Task<DTONotificacionTransportista> GetEmailsByInvoice(int id);*/
/*public Task<Boolean> DeleteEmail(int id);*/
}
}

@ -0,0 +1,10 @@
namespace BookPrectaBackend.Clientes.Email;
public class DTOSendEmail
{
public string To { get; set; } = null!;
public string Subject { get; set; } = null!;
public string Text { get; set; } = null!;
public string Html { get; set; } = null!;
}

@ -0,0 +1,13 @@
namespace BookPrectaBackend.Clientes.Email
{
public class DTOSendEmailBcc
{
public string To { get; set; } = null!;
public string Cc { get; set; } = null!;
public string Bcc { get; set; } = null!;
public string Subject { get; set; } = null!;
public string Text { get; set; } = null!;
public string Html { get; set; } = null!;
}
}

@ -0,0 +1,163 @@
using System.Data.Common;
using System.ComponentModel.DataAnnotations.Schema;
using Dapper;
using Microsoft.AspNetCore.Server.IIS.Core;
using System.Data;
using BookPrectaBackend.Clientes.Email;
using BookPrectaBackend.Clientes.Contracts;
using BookPrectaBackend.Context;
using BookPrectaBackend.Crypto;
using BookPrectaBackend.DTO;
using BookPrectaBackend.DTO.Usuario;
namespace BookPrectaBackend.Clientes.Repository
{
public class CatResponsablesRepository : ICatResponsablesRepository
{
private readonly DapperContext _context;
public CatResponsablesRepository(DapperContext context) { _context = context; }
/*public async Task<IEnumerable<I1868CatResponsables>> Get()
{
var query = "[CatResponsables.Get]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<I1868CatResponsables>(query, new { }, commandType: CommandType.StoredProcedure);
return entrada;
}
*//*
public async Task<I1868CatResponsables> GetByUser(DTOLogin data)
{
var query = "[CatResponsables.GetByUser]";
using var connection = _context.CreateConnection();
var hashedPassword = CryptDecrypt.Encrypt(data.Contrasena);
var entrada = await connection.QueryAsync<I1868CatResponsables>(query, new
{
@data.Usuario,
@Contrasena = hashedPassword
}, commandType: CommandType.StoredProcedure);
return entrada.First();
}
*//*
public async Task<int> searchResponsable(string Usuario)
{
var query = "SELECT * FROM CatResponsables WHERE Usuario=@Usuario";
using (var connection = _context.CreateConnection())
{
var usuario = await connection.QueryAsync<I1868CatResponsables>(query, new { @Usuario });
return usuario.Count() > 0 ? usuario.First().id : 0;
}
}
*/
public async Task<IEnumerable<DTOPINData>> CreatePIN(int Id)
{
var query = "[CatResponsables.PIN.Create]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<DTOPINData>(query, new { @Id }, commandType: CommandType.StoredProcedure);
return entrada;
}
public async Task<Boolean> ValidatePIN(DTOPINUsuario data)
{
var query = "[CatResponsables.PIN.Validate]";
using (var connection = _context.CreateConnection())
{
var result = await connection.QueryAsync<DTOPINUsuario>(query, new { @data.PIN, @data.Usuario }, commandType: CommandType.StoredProcedure);
if (result.Count() == 0) return false;
return true;
}
}
public async Task<DTOLogin> resetPassword(DTOResetPassword user)
{
var query = "[CatResponsables.Password.Reset]";
DTOLogin userFound = new DTOLogin();
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<DTOLogin>(query, new
{
@user.PIN,
@Contrasena = user.Contrasena,
@HashContrasena = CryptDecrypt.Encrypt(user.Contrasena),
}, commandType: CommandType.StoredProcedure);
if (usuarios.Count() > 0) userFound = usuarios.First();
}
return userFound;
}
/*public async Task<I1868CatResponsableCorreos> EmailAppend(I1868CatResponsableCorreos data)
{
var query = "[CatResponsables.Correo.Append]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<I1868CatResponsableCorreos>(query, new
{
@id = data.id,
@IdResponsable = data.IdResponsable,
@Correo = data.Correo
}, commandType: CommandType.StoredProcedure);
return entrada.First();
}
*/
/* public async Task<Boolean> UserAppend(int id, String Usuario)
{
var query = "[CatResponsables.Usuario.Append]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<I1868CatResponsableCorreos>(query, new
{
@id,
@Usuario
}, commandType: CommandType.StoredProcedure);
return true;
}
*//*
public async Task<IEnumerable<I1868CatResponsableCorreos>> GetEmailsByResponsable(int id)
{
var query = "[CatResponsables.Correo.Get]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<I1868CatResponsableCorreos>(query, new { @id }, commandType: CommandType.StoredProcedure);
return entrada;
}*/
/*
public async Task<IEnumerable<I1868CatResponsableCorreos>> ResponsablesEmailsGetAll()
{
var query = "[CatResponsables.Correo.GetAll]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<I1868CatResponsableCorreos>(query, new { }, commandType: CommandType.StoredProcedure);
return entrada;
}
*/
/* public async Task<DTONotificacionTransportista> GetEmailsByIdDetalle(int id)
{
var query = "[CatResponsables.Correo.GetByIdDetalle]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<DTONotificacionTransportista>(query, new
{
@id
},
commandType: CommandType.StoredProcedure);
return entrada.FirstOrDefault(new DTONotificacionTransportista { Correos = "", Pedido = "", Factura = "", Direccion = "", ResponsableCruce = "" });
}*/
/*
public async Task<DTONotificacionTransportista> GetEmailsByInvoice(int id)
{
var query = "[CatResponsables.Correo.GetByInvoice]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<DTONotificacionTransportista>(query, new
{
@id
},
commandType: CommandType.StoredProcedure);
return entrada.FirstOrDefault(new DTONotificacionTransportista { Correos = "", Pedido = "", Factura = "", Direccion = "", ResponsableCruce = "" });
}*/
/* public async Task<Boolean> DeleteEmail(int id)
{
var query = "[CatResponsables.Correo.Delete]";
using var connection = _context.CreateConnection();
var entrada = await connection.QueryAsync<I1868CatResponsableCorreos>(query, new { @id }, commandType: CommandType.StoredProcedure);
return true;
}*/
}
}

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

@ -0,0 +1,129 @@
using Microsoft.AspNetCore.Mvc;
using System.IO;
using System.Threading.Tasks;
using BookPrectaBackend.Repository.ExelServices;
using BookPrectaBackend.Repository.ExcelServices;
using BookPrectaBackend.Repository.EcxelServices.ExelHourWorking;
namespace BookPrectaBackend.Contracts.Catalogos
{
[Route("api/[controller]")]
[ApiController]
public class ExcelController : ControllerBase
{
private readonly ExcelRepository _repository;
private readonly ExcelRepositoryPrecta _repositoryp;
private readonly ExelHours _repositoryWH;
public ExcelController(ExcelRepository repository, ExcelRepositoryPrecta repositoryp, ExelHours repositoryWH)
{
_repository = repository;
_repositoryp = repositoryp;
_repositoryWH = repositoryWH;
}
[HttpPost("uploadBook")]
public async Task<IActionResult> UploadFile([FromForm] IFormFile file)
{
if (file == null || file.Length == 0)
{
return BadRequest("No file uploaded.");
}
using (var stream = new MemoryStream())
{
await file.CopyToAsync(stream);
await _repository.ProcessExcelFileAsync(stream);
}
return Ok(new { message = "File processed successfully." });
}
[HttpPost("uploadPrecta")]
public async Task<IActionResult> UploadFileP([FromForm] IFormFile file)
{
if (file == null || file.Length == 0)
{
return BadRequest("No file uploaded.");
}
using (var stream = new MemoryStream())
{
await file.CopyToAsync(stream);
await _repositoryp.ProcessPrectaExcelFileAsync(stream);
}
return Ok(new { message = "File processed successfully." });
}
[HttpPost("UploadWorkingHours")]
public async Task<IActionResult> UploadFileWHours([FromForm] IFormFile file)
{
if (file == null || file.Length == 0) { return BadRequest("No File Uploades"); }
using var stream = new MemoryStream();
{
await file.CopyToAsync(stream);
await _repositoryWH.ProccesHoursExelFileAysn(stream);
}
return Ok(new { message = "File processed successfully" });
}
// Si La ultima Fecha de los registros de la tabla es 14-08-2024 Las Nuevas inseciones Deben Ser > ala Fecha actal del registro en las Tablas ejemplos: 15-08-2024.
/*
[HttpPost("UploadWorkingHours")]
public async Task<IActionResult> UploadFileWHours([FromForm] IFormFile file)
{
if (file == null || file.Length == 0)
{
return BadRequest("No file uploaded");
}
var fileExtension = Path.GetExtension(file.FileName);
if (fileExtension != ".xls" && fileExtension != ".xlsx")
{
return BadRequest("Unsupported file format. Please upload a .xls or .xlsx file.");
}
using var stream = new MemoryStream();
await file.CopyToAsync(stream);
// Reinicia la posición del stream a 0
stream.Position = 0;
try
{
await _repositoryWH.ProcessHoursExcelFileAsync(stream, fileExtension);
return Ok(new { message = "File processed successfully" });
}
catch (Exception ex)
{
return StatusCode(500, $"An error occurred while processing the file: {ex.Message}");
}
}
*/
}
}

@ -0,0 +1,20 @@
using BookPrectaBackend.DTO.ExelServices;
using BookPrectaBackend.Models.Catalogos;
using BookPrectaBackend.Models.Reportes;
namespace BookPrectaBackend.Contracts.Catalogos
{
public interface ICatChequesPrecuenta
{
public Task<IEnumerable<RelacionBookPrecta>> GetRelacionBooKPrectaPrecuenta();
public Task<IEnumerable<RelacionBookPrecta>> GetRelacionBookPrecta(string Inicio, string Fin);
public Task<IEnumerable<CatRelacionPrecuentaCheque>> PostRelacionPrecuentaCheques(string Precuenta,string Cheques);
public Task<IEnumerable<CatRelacionPrecuentaCheque>> GetRelacionPrecuentaCheque();
public Task<IEnumerable<CatRelacionPrecuentaCheque>> DeleteRelacionPrecuentaCheque(string Precuenta);
public Task<IEnumerable<RelacionBookPrecta>>GetRelacionPrecuentaCheque(string Inicio, string Fin);
}
}

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

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

@ -0,0 +1,25 @@

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

@ -0,0 +1,16 @@
using BookPrectaBackend.Models.Reportes;
namespace BookPrectaBackend.Contracts.Reportes
{
public interface IRptBookPrectacs
{
public Task<IEnumerable<RelacionBookPrecta>> GetRelacionesTrafico( );
/*public Task<IEnumerable<RelacionBookPrecta>>GetNoRelaciones();*/
public Task<IEnumerable<RelacionBookPrecta>> GetNoRelaciones();
}
}

@ -0,0 +1,294 @@
using BookPrectaBackend.Models;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.AspNetCore.Mvc;
using BookPrectaBackend.Contracts;
using BookPrectaBackend.DTO;
using Microsoft.AspNetCore.Authorization;
using BookPrectaBackend.Clientes.Contracts;
using BookPrectaBackend.Services.Utilerias;
using BookPrectaBackend.Clientes.Email;
using BookPrectaBackend.DTO.Usuario;
namespace BookPrectaBackend.Controllers
{
[Route("api/[Controller]")]
[ApiController]
public class AuthController : ControllerBase
{
public IConfiguration _config;
private readonly IUsuariosRepository _usuariosRepo;
private readonly IPerfilesRepository _perfilesRepo;
private readonly IMenuRepository _menuRepo;
private readonly ICatResponsablesRepository _transportRepo;
public AuthController(IConfiguration config, IUsuariosRepository usuariosRepo, IMenuRepository menuRepo, IPerfilesRepository perfilesRepo, ICatResponsablesRepository transportRepo )
{
_config = config;
_usuariosRepo = usuariosRepo;
_perfilesRepo = perfilesRepo;
_menuRepo = menuRepo;
_transportRepo = transportRepo;
}
[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(2),
signingCredentials: signIn);
var _token = new JwtSecurityTokenHandler().WriteToken(token);
return new OkObjectResult(new { menu = menu, token = _token });
}
else
{
return BadRequest("Invalid credentials");
}
}
else
{
return BadRequest();
}
}
/*[HttpPost]
[Route("AreYouTransport")]
public async Task<IActionResult> IsItTransportUser(DTOLogin _userData)
{
if (_userData != null && _userData.Usuario != null && _userData.Contrasena != null)
{
var user = await _transportRepo.GetByUser(_userData);
if (user == null) return BadRequest("Invalid credentials");
if (user != null)
{
var menu = await _menuRepo.GetItemsMenuTransportista();
var claims = new List<Claim>();
var ProfileData = await _perfilesRepo.PerfilGetById(0);
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", "No asignado"));
claims.Add(new Claim("UserType", "0"));
claims.Add(new Claim("Perfil", "Transportista"));
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"])),
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>();
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();
}
}
[HttpPost]
[Route("forgotPassword")]
public async Task<IActionResult> forgotPassword(DTOLogin userData)
{
if (userData == null) return BadRequest(new { respuesta = "Usuario invalido" });
int IdUser = await _usuariosRepo.searchUsuario(userData.Usuario);
if (IdUser > 0) // Es un usuario del ZINC
{
DTOPINData PINData = await _usuariosRepo.CreatePIN(IdUser);
string htmlContent = $@"<table>
<tr><td>Estimado usuario, mediante este correo se le notifica que esta en proceso de cambiar su contraseña</td></tr>
<tr><td>Se ha generado un PIN para poder cambiar su contraseña. PIN : <b>{PINData.PIN}</b> </td></tr>
<tr><td>El PIN tiene un tiempo de vida de 10 minutos, a partir de su generacion, despues de ese tiempo caduca</td></tr>
<tr><td>Si usted <b>no</b> es quien ha activando este mecanismo, favor de ponerse en contacto con personal de GEMCO</td></tr>
</table>";
if (PINData.PIN > 0)
{
Utilerias email = new Utilerias(_config);
var dataEmail = new DTOSendEmail()
{
To = PINData.Correo,
Subject = "BookPrecta informa: Se le generado un PIN para el cambio de su contraseña, expira en 10 minutos",
Text = "BooKPrecta informa: Se le generado un PIN para el cambio de su contraseña, expira en 10 minutos",
Html = htmlContent
};
await email.SendEmail(dataEmail);
return new OkObjectResult(new { respuesta = "Continua con el proceso" });
}
}
/*else // Es un usuario : Transportista / Responsable
{
int IdResponsable = await _transportRepo.searchResponsable(userData.Usuario);
if (IdResponsable > 0)
{
var PINData = await _transportRepo.CreatePIN(IdResponsable);
int PIN = 0;
string EmailGroup = "";
foreach (DTOPINData data in PINData)
{
PIN = data.PIN;
EmailGroup += data.Correo + ",";
}
EmailGroup = EmailGroup.Remove(EmailGroup.Length - 1, 1);
string htmlContent = $@"<table>
<tr><td>Estimado usuario, mediante este correo se le notifica que esta en proceso de cambiar su contraseña</td></tr>
<tr><td>Se ha generado un PIN para poder cambiar su contraseña. PIN : <b>{PIN}</b> </td></tr>
<tr><td>El PIN tiene un tiempo de vida de 10 minutos, a partir de su generacion, despues de ese tiempo caduca</td></tr>
<tr><td>Si usted <b>no</b> es quien ha activando este mecanismo, favor de ponerse en contacto con personal de ZINC</td></tr>
</table>";
if (PIN > 0)
{
Utilerias email = new Utilerias(_config);
var dataEmail = new DTOSendEmail()
{
To = EmailGroup,
Subject = "ZINC informa: Se le generado un PIN para el cambio de su contraseña, expira en 10 minutos",
Text = "ZINC informa: Se le generado un PIN para el cambio de su contraseña, expira en 10 minutos",
Html = htmlContent
};
await email.SendEmail(dataEmail);
return new OkObjectResult(new { respuesta = "Continua con el proceso" });
}
}
else return StatusCode(403, "Acceso denegado");
}*/
return BadRequest(new { respuesta = "Invalid Request" });
}
[HttpPost]
[Route("validatePIN")]
public async Task<IActionResult> validatePIN(DTOPINUsuario userData)
{
var PINUsuario = await _usuariosRepo.ValidatePIN(userData);
if (!PINUsuario)
{
var PINTransportista = await _transportRepo.ValidatePIN(userData);
if (!PINTransportista) return StatusCode(403, "Acceso denegado");
}
return new OkObjectResult(new { respuesta = "Continua con el proceso" });
}
[Route("resetPassword")]
[HttpPost]
public async Task<IActionResult> resetPassword(DTOResetPassword data)
{
try
{
var result = await _usuariosRepo.resetPassword(data);
if (result.Usuario == null)
{
var resetPassword = await _transportRepo.resetPassword(data);
if (resetPassword == null) return StatusCode(400, "Cuenta de usuario no existe");
}
return Ok(result);
}
catch (Exception ex)
{
return StatusCode(500, ex);
}
}
[HttpGet]
[Route("GetEnvironment")]
public IActionResult GetEnvironment()
{
return StatusCode(200, Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") + ' ' + _config.GetValue<string>("AmazonPyAPI"));
}
[Authorize]
[Route("Validate")]
[HttpGet]
public IActionResult GetValidation()
{
return StatusCode(200, "Its Ok");
}
}
}

@ -0,0 +1,103 @@
using BookPrectaBackend.Models.Catalogos;
using BookPrectaBackend.Models.Reportes;
using BookPrectaBackend.Contracts.Catalogos;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace BookPrectaBackend.Controllers.Catalogos
{
/*[Authorize]*/
[Route("api/Catalogos/[Controller]")]
public class CatRelacionesBookPrectaController : Controller
{
public IConfiguration _Configuration;
private readonly ICatChequesPrecuenta _Repo;
private readonly string URLNodeAPI;
public CatRelacionesBookPrectaController(IConfiguration config, ICatChequesPrecuenta Repo)
{
_Configuration = config;
URLNodeAPI = _Configuration.GetValue<string>("AmazonNodeApi");
_Repo = Repo;
}
[Route("GetAll")]
[HttpGet]
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionBookPrecta(string Inicio, string Fin)
{
var result = await _Repo.GetRelacionBookPrecta(Inicio, Fin);
return result;
}
[Route("GetAllPreChe")]
[HttpGet]
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionBookPrectaPrecuenta()
{
var result = await _Repo.GetRelacionBooKPrectaPrecuenta();
return result;
}
[Route("PrecuentaChequesAppend")]
[HttpPost]
public async Task<IEnumerable<CatRelacionPrecuentaCheque>> PostRelacionPrecuentaCheques(string Precuenta, string Cheques)
{
var result = await _Repo.PostRelacionPrecuentaCheques(Precuenta, Cheques);
return result;
}
[Route("GetAllPrecuentaCheques")]
[HttpGet]
public async Task<IEnumerable<CatRelacionPrecuentaCheque>> GetRelacionPrecuentaCheques()
{
var result = await _Repo.GetRelacionPrecuentaCheque();
return result;
}
[Route("DeleteAllPrecuentaCheques")]
[HttpDelete]
public async Task<IEnumerable<CatRelacionPrecuentaCheque>> DeleteRelacionChequesPrecuenta(string Precuenta)
{
var result = await _Repo.DeleteRelacionPrecuentaCheque(Precuenta);
return result;
}
/*Este edn point relaiza la busqueda de datos por un filtro de un rango de fechas selecionado pero con las relaciones ya de la tabla y no con codigo */
[Route("GetAllPrecuentaChequesF")]
[HttpGet]
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionPrecuentaCheque(string Inicio, string Fin)
{
var result = await _Repo.GetRelacionPrecuentaCheque(Inicio, Fin);
return result;
}
}
}

@ -0,0 +1,167 @@
using BookPrectaBackend.Contracts;
using BookPrectaBackend.DTO;
using BookPrectaBackend.DTO.Usuario;
using BookPrectaBackend.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
namespace BookPrectaBackend.Controllers
{
[Authorize]
[Route("api/[controller]")]
[ApiController]
public class PerfilesController : ControllerBase
{
public IConfiguration _configuration;
private readonly IUsuariosRepository _usuariosRepo;
private readonly IMenuRepository _menuRepo;
private readonly IPerfilesRepository _perfilesRepo;
public PerfilesController(IConfiguration config, IUsuariosRepository usuariosRepo, IMenuRepository menuRepo, IPerfilesRepository perfilesRepo)
{
_configuration = config;
_usuariosRepo = usuariosRepo;
_menuRepo = menuRepo;
_perfilesRepo = perfilesRepo;
}
[Route("getPerfiles")]
[HttpGet]
public async Task<IActionResult> GetPerfiles()
{
try
{
var perfiles = await _perfilesRepo.getPerfiles();
return Ok(perfiles);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("getMenu")]
[HttpGet]
public async Task<IActionResult> GetMenu()
{
try
{
var perfiles = await _perfilesRepo.getMenu();
return Ok(perfiles);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("asignaItemMenu")]
[HttpPost]
public async Task<IActionResult> asignaItemMenu(DTOItemMenuPerfil data)
{
try
{
var perfiles = await _perfilesRepo.asignaItemMenuPerfil(data);
return Ok(perfiles);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("getAllPerfilesMenu")]
[HttpGet]
public async Task<IActionResult> GetAllPerfilesMenu()
{
try
{
var perfiles = await _perfilesRepo.getAllPerfilesMenu();
return Ok(perfiles);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("getPerfilMenuById")]
[HttpGet]
public async Task<IActionResult> GetPerfilMenuBuId(int id)
{
try
{
var perfiles = await _perfilesRepo.getPerfilMenuById(id);
return Ok(perfiles);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("createPerfil")]
[HttpPost]
public async Task<IActionResult> createPerfil(DTOPerfilCreate data)
{
try
{
var perfiles = await _perfilesRepo.createPerfil(data);
return Ok(perfiles);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("createItemMenu")]
[HttpPost]
public async Task<IActionResult> createItemMenu(Menu data)
{
try
{
var result = await _perfilesRepo.createItemMenu(data);
return Ok(result);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
/*
[Route("getAllTransportistas")]
[HttpGet]
public async Task<IActionResult> GetAllTransportistas(int id)
{
try
{
var transportistas = await _perfilesRepo.getAllTransportistas(id);
return Ok(transportistas);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
[Route("getAllProveedores")]
[HttpGet]
public async Task<IActionResult> GetAllProveedores(int id)
{
try
{
var proveedores = await _perfilesRepo.getAllProveedores(id);
return Ok(proveedores);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}*/
}
}

@ -0,0 +1,51 @@
using BookPrectaBackend.Contracts.Catalogos;
using BookPrectaBackend.Contracts.Reportes;
using BookPrectaBackend.Models.Reportes;
using Microsoft.AspNetCore.Mvc;
using NPOI.Util;
namespace BookPrectaBackend.Controllers.Reportes
{
[Route("api/[controller]")]
public class ReportesController : Controller
{
public IConfiguration _Configuration;
private readonly IRptBookPrectacs _Repo;
public ReportesController(IConfiguration config, IRptBookPrectacs Repo)
{
_Configuration = config;
_Repo = Repo;
}
[Route("GetAllSoloTrafico")]
[HttpGet]
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionTrafico()
{
var result = await _Repo.GetRelacionesTrafico();
return result;
}
[Route("GetAllNoRelaciones")]
[HttpGet]
public async Task<IEnumerable<RelacionBookPrecta>> GetNoRelaciones()
{
var result = await _Repo.GetNoRelaciones();
return result;
}
}
}

@ -0,0 +1,173 @@
using BookPrectaBackend.Contracts;
using BookPrectaBackend.DTO;
using BookPrectaBackend.Models;
using Microsoft.AspNetCore.Mvc;
// La siguiente libreria sirve para enviar un email de notificacion al usuario de que se le ha creado un acceso a este sitio
// using ZINCBackend.Services.Utilerias;
using BookPrectaBackend.DTO.Usuario;
using Microsoft.AspNetCore.Authorization;
namespace BookPrectaBackend.Controllers
{
/*[Authorize]*/
[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("searchUsuario")]
[HttpPost]
public async Task<IActionResult> searchUsuario(DTOLogin user)
{
try
{
var result = await _usuariosRepo.searchUsuario(user.Usuario);
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("createUsuario")]
[HttpPost]
public async Task<IActionResult> POST(DTOUsuario user)
{
try
{
var usuario = await _usuariosRepo.createUsuario(user);
if (user.Id == 0)
{
// El siguiente bloque de codigo enviar email al usuario para notificarle que ya se le he creado un acceso
// Utilerias email = new Utilerias(_config);
// Boolean sendOk = email.SendEmail("", usuario);
//Boolean sendOk = true;
}
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);
}
}
[Route("DisableUser")]
[HttpPut]
public async Task<IActionResult> DisableUser(int id)
{
try
{
var result = await _usuariosRepo.DisableUser(id);
return Ok(result);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
}
}

@ -0,0 +1,33 @@
using Microsoft.AspNetCore.Mvc;
namespace BookPrectaBackend.Controllers
{
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
private static readonly string[] Summaries = new[]
{
"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};
private readonly ILogger<WeatherForecastController> _logger;
public WeatherForecastController(ILogger<WeatherForecastController> logger)
{
_logger = logger;
}
[HttpGet(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
return Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
})
.ToArray();
}
}
}

@ -0,0 +1,48 @@
using System.Security.Cryptography;
using System.Text;
namespace BookPrectaBackend.Crypto
{
public class CryptDecrypt
{
private readonly static string key = "G3mc0H42hk3y2!0$2*2#n4813dc2h47p";
public static string Encrypt(string text)
{
byte[] iv = new byte[16];
byte[] array;
using (Aes aes = Aes.Create()) {
aes.Key = Encoding.UTF8.GetBytes(key);
aes.IV = iv;
ICryptoTransform encrypt = aes.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream((Stream)ms, encrypt, CryptoStreamMode.Write)) {
using (StreamWriter streamWriter = new StreamWriter(cryptoStream)) {
streamWriter.Write(text);
}
array = ms.ToArray();
}
}
}
return Convert.ToBase64String(array);
}
public static string Decrypt(string text)
{
byte[] iv = new byte[16];
byte[] buffer = Convert.FromBase64String(text);
using (Aes aes = Aes.Create()) {
aes.Key = Encoding.UTF8.GetBytes(key);
aes.IV = iv;
ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key,aes.IV);
using (MemoryStream ms = new MemoryStream(buffer)) {
using(CryptoStream cryptoStream = new CryptoStream((Stream)ms, decryptor, CryptoStreamMode.Read)) {
using (StreamReader sr = new StreamReader(cryptoStream)) {
return sr.ReadToEnd();
}
}
}
}
}
}
}

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

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

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

@ -0,0 +1,21 @@
namespace BookPrectaBackend.DTO.ExelServices
{
public class Book
{
public string? Type { get; set; }
public string? Cheques { get; set; }
public string? Date { get; set; }
public string? Num { get; set; }
public string? Name { get; set; }
public string? Memo { get; set; }
public float Amount { get; set; }
public string? Trafico { get; set; }
}
}

@ -0,0 +1,17 @@
namespace BookPrectaBackend.DTO.ExelServices
{
public class Precta
{
public string? Trafico { get; set; }
public string? Precuenta { get; set; }
public string? Concepto { get; set; }
public string? Importe { get; set; }
public string? Cantidad { get; set; }
public string? Tipo { get; set; }
public string? IdProvedor { get; set; }
public string? NomProvedor { get; set; }
public string? TagTabulador { get; set; }
public string? NombreTabulador { get; set; }
public string? Rctadeb { get; set; }
}
}

@ -0,0 +1,10 @@

namespace BookPrectaBackend.DTO.Usuario
{
public class DTOClonarUsuario
{
public int IDUsuarioOrigen { get; set; } = 0!;
public int IdUsuarioDestino { get; set; } = 0!;
}
}

@ -0,0 +1,8 @@
namespace BookPrectaBackend.DTO.Usuario
{
public class DTOPINData
{
public int PIN { get; set; } = 0!;
public string Correo { get; set; } = string.Empty;
}
}

@ -0,0 +1,8 @@
namespace BookPrectaBackend.DTO.Usuario
{
public class DTOPINUsuario
{
public int PIN { get; set; } = 0!;
public string Usuario { get; set; } = string.Empty;
}
}

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

@ -0,0 +1,8 @@
namespace BookPrectaBackend.DTO.Usuario
{
public class DTOResetPassword
{
public int PIN { get; set; } = 0;
public string Contrasena { get; set; } = null!;
}
}

@ -0,0 +1,14 @@
namespace BookPrectaBackend.DTO.Usuario
{
public class DTOUsuario
{
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 int TipoUsuario { get; set; } = 0;
public int IdPerfil { get; set; } = 0;
public string? FechaAlta { get; set; } = null!;
}
}

@ -0,0 +1,9 @@
namespace BookPrectaBackend.DTO.Usuario
{
public class DTOUsuarioTransportista
{
public int IdUsuario { get; set; }
public int sClave { get; set; }
public bool Asignado { get; set; }
}
}

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

@ -0,0 +1,9 @@
namespace BookPrectaBackend.DTO.Usuario
{
public class DTOUsuariosShort
{
public int id { get; set; } = 0!;
public string Usuario { get; set; } = null!;
public Boolean Activo { get; set; } = false;
}
}

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

@ -0,0 +1,11 @@
namespace BookPrectaBackend.Models.Catalogos
{
public class CatRelacionPrecuentaCheque
{
public int id { get; set; }
public string? Precuenta { get; set; }
public string? Cheques { get; set; }
}
}

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

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

@ -0,0 +1,16 @@
namespace BookPrectaBackend.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; }
}
}

@ -0,0 +1,41 @@
namespace BookPrectaBackend.Models.Reportes
{
public class RelacionBookPrecta
{
public string? Type { get; set; }
public string? Cheques { get; set; }
public string? Date { get; set; }
public string? Num { get; set; }
public string? Name { get; set; }
public string? Memo { get; set; }
public double Amount { get; set; }
public string? Trafico { get; set; }
public string? Trafico1 { get; set; }
public string? Precuenta { get; set; }
public string? Concepto { get; set; }
public double Importe { get; set; }
public string? Cantidad { get; set; }
public char? Tipo { get; set; }
public string? IdProvedor { get; set; }
public string? NomProvedor { get; set; }
public string? TagTabulador { get; set; }
public string? NombreTabulador { get; set; }
public string? Rctadeb { get; set; }
public string? Diferencia { get; set; }
// precuenta 5404016 cheques 5215013
// precuenta 5213001 cheques 5215011
}
}

@ -0,0 +1,44 @@
using Org.BouncyCastle.Asn1.X509;
namespace BookPrectaBackend.Models.Reportes
{
public class WorkingHours
{
public string EmpNo { get; set; }
public string AcNo { get; set; }
public string No { get; set; }
public string Name { get; set; }
public string Date { get; set; } // Almacenando la fecha como string
/*public TimeSpan? ClockIn1 { get; set; }*/
/*public TimeSpan? ClockOut1 { get; set; }
public TimeSpan? ClockIn2 { get; set; }
public TimeSpan? ClockOut2 { get; set; }
public TimeSpan? ClockIn3 { get; set; }
public TimeSpan? ClockOut3 { get; set; }
public TimeSpan? ClockIn4 { get; set; }
public TimeSpan? ClockOut4 { get; set; }
public TimeSpan? ClockIn5 { get; set; }
public TimeSpan? ClockOut5 { get; set; }
public TimeSpan? TotalInTime { get; set; }*/
public string? ClockIn1 { get; set; }
public string? ClockOut1 { get; set;}
public string? ClockIn2 { get; set; }
public string? ClockOut2 { get; set; }
public string? ClockIn3 { get; set; }
public string? ClockOut3 { get; set; }
public string? ClockIn4 { get; set; }
public string? ClockOut4 { get; set; }
public string? ClockIn5 { get; set; }
public string? ClockOut5 { get; set; }
public string? TotalInTime { get; set; }
}
}

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

@ -0,0 +1,164 @@
using BookPrectaBackend.Context;
using BookPrectaBackend.Catalogos;
using BookPrectaBackend.Contracts;
using BookPrectaBackend.Contracts.Catalogos;
using BookPrectaBackend.Repository;
using Microsoft.OpenApi.Models;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;
using BookPrectaBackend.Clientes.Contracts;
using BookPrectaBackend.Clientes.Repository;
using BookPrectaBackend.Repository.ExelServices;
using BookPrectaBackend.Repository.ExcelServices;
using BookPrectaBackend.Contracts.Reportes;
using BookPrectaBackend.Repository.Reportes;
using BookPrectaBackend.Repository.EcxelServices.ExelHourWorking;
internal class Program
{
private static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddSingleton<DapperContext>();
builder.Services.AddScoped<IUsuariosRepository, UsuariosRepository>();
builder.Services.AddScoped<IMenuRepository, MenuRepository>();
builder.Services.AddScoped<IPerfilesRepository, PerfilesRepository>();
builder.Services.AddScoped<ICatResponsablesRepository, CatResponsablesRepository>();
// Reportes
builder.Services.AddScoped<IRptBookPrectacs , ReportesRepository>();
// Servivios Exel
builder.Services.AddScoped<ExcelRepository>();
builder.Services.AddScoped<ExcelRepositoryPrecta>();
builder.Services.AddScoped<ExelHours>();
//Catalogos
builder.Services.AddScoped<ICatChequesPrecuenta, CatRelacionPrecuentaCheques>();
builder.Services.AddControllers();
/* builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new TokenValidationParameters()
{
ValidateIssuer = true,
ValidateAudience = true,
ValidAudience = builder.Configuration["Jwt:Audience"],
ValidIssuer = builder.Configuration["Jwt:Issuer"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
};
});*/
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = builder.Configuration["Jwt:Issuer"],
ValidAudience = builder.Configuration["Jwt:Audience"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
};
});
var key = builder.Configuration["Jwt:Key"];
Console.WriteLine(key);
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "BookPrecta Backend",
Version = "v1"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
{
Name = "Authorization",
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer",
BearerFormat = "JWT",
In = ParameterLocation.Header,
Description = "JWT Authorization header using the Bearer scheme. \r\n\r\n Enter 'Bearer' [space] and then your token in the text input below.\r\n\r\nExample: \"Bearer 1safsfsdfdfd\"",
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement {
{
new OpenApiSecurityScheme {
Reference = new OpenApiReference {
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
new string[] {}
}
});
});
//services cors
builder.Services.AddCors(p => p.AddPolicy("corsapp", builder =>
{
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.WithOrigins("http://localhost:3000",
"http://localhost:5263",
"https://localhost:5020").AllowAnyMethod().AllowAnyHeader();
}
else if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Staging")
{
builder.WithOrigins(
).AllowAnyMethod().AllowAnyHeader();
}
else if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production")
{
builder.WithOrigins(
).AllowAnyMethod().AllowAnyHeader();
}
}));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseCors("corsapp");
app.UseAuthorization();
app.MapControllers();
app.Run();
}
}

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

@ -0,0 +1,102 @@
using BookPrectaBackend.Models.Catalogos;
using BookPrectaBackend.Models.Reportes;
using Dapper;
using BookPrectaBackend. Context;
using BookPrectaBackend.Contracts.Catalogos;
using System.Data;
namespace BookPrectaBackend.Catalogos
{
public class CatRelacionPrecuentaCheques : ICatChequesPrecuenta
{
private readonly DapperContext _context;
public CatRelacionPrecuentaCheques(DapperContext context) { _context = context; }
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionBookPrecta(string Inicio, string Fin)
{
var query = "[RelacionBookPrecta]";
using (var conn = _context.CreateConnection())
{
var result = await conn.QueryAsync<RelacionBookPrecta>(query,
new { @Inicio = Inicio, @Fin = Fin }, commandType: CommandType.StoredProcedure);
return result.ToList();
}
}
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionBooKPrectaPrecuenta()
{
var query = "[RelacionBookPrectaPrecuentaCheques]";
using (var con = _context.CreateConnection())
{
var result = await con.QueryAsync<RelacionBookPrecta>(query);
return result.ToList();
}
}
public async Task<IEnumerable<CatRelacionPrecuentaCheque>> PostRelacionPrecuentaCheques(string Precuenta, string Cheques)
{
var query = "UpsertRelacionChequesPrecuenta";
using (var con = _context.CreateConnection())
{
var result = await con.QueryAsync<CatRelacionPrecuentaCheque>(query, new { @Precuenta = Precuenta, @Cheques = Cheques }, commandType: CommandType.StoredProcedure);
return result.ToList();
}
}
public async Task<IEnumerable<CatRelacionPrecuentaCheque>> GetRelacionPrecuentaCheque()
{
var query = "Select * from RelacionPrecuentaCheque ";
using (var con = _context.CreateConnection())
{
var result = await con.QueryAsync <CatRelacionPrecuentaCheque> (query);
return result.ToList ();
}
}
public async Task<IEnumerable<CatRelacionPrecuentaCheque>> DeleteRelacionPrecuentaCheque(string Precuenta)
{
var query = "Delete from RelacionPrecuentaCheque where Precuenta= @Precuenta";
using (var con = _context.CreateConnection())
{
var result = await con.QueryAsync<CatRelacionPrecuentaCheque>(query,
new { Precuenta });
return result.ToList();
}
}
public async Task<IEnumerable<RelacionBookPrecta>> GetRelacionPrecuentaCheque(string Inicio, string Fin)
{
var query = "[RelacionBookPrecta]";
using (var con = _context.CreateConnection())
{
var result = await con.QueryAsync<RelacionBookPrecta>(query, new {@Inicio = Inicio, @Fin = Fin }, commandType: CommandType.StoredProcedure);
return result.ToList();
}
}
}
}

@ -0,0 +1,161 @@

using Dapper;
using BookPrectaBackend.Context;
using OfficeOpenXml;
using BookPrectaBackend.Models.Reportes;
using Microsoft.AspNetCore.Mvc;
namespace BookPrectaBackend.Repository.EcxelServices.ExelHourWorking
{
public class ExelHours
{
private readonly DapperContext _dapperContext;
public ExelHours(DapperContext dapperContext)
{
_dapperContext = dapperContext;
ExcelPackage.LicenseContext = LicenseContext.Commercial;
}
public async Task<IActionResult> ProccesHoursExelFileAysn(Stream fileStream)
{
List<WorkingHours> records = new List<WorkingHours>();
using (var package = new ExcelPackage(fileStream))
{
var worksheet = package.Workbook.Worksheets[0];
var rowCount = worksheet.Dimension.Rows;
// Obtener la fecha máxima existente en la tabla
DateTime? maxDate = await GetMaxDateAsync();
Console.WriteLine($"Fecha máxima existente en la tabla: {maxDate}");
for (int row = 2; row <= rowCount; row++)
{
try
{
// Especificar el formato de la fecha en Excel
DateTime date = DateTime.ParseExact(worksheet.Cells[row, 5].Text, "M/d/yyyy", null);
Console.WriteLine($"Fecha en la fila {row}: {date}");
// Validar que la fecha sea mayor a la fecha máxima
if (maxDate == null || date > maxDate)
{
var record = new WorkingHours
{
EmpNo = worksheet.Cells[row, 1].Text,
AcNo = worksheet.Cells[row, 2].Text,
No = worksheet.Cells[row, 3].Text,
Name = worksheet.Cells[row, 4].Text,
Date = date.ToString("yyyy-MM-dd"), // Convertir la fecha a un formato estándar antes de guardarla
ClockIn1 = worksheet.Cells[row, 6].Text,
ClockOut1 = worksheet.Cells[row, 7].Text,
ClockIn2 = worksheet.Cells[row, 8].Text,
ClockOut2 = worksheet.Cells[row, 9].Text,
ClockIn3 = worksheet.Cells[row, 10].Text,
ClockOut3 = worksheet.Cells[row, 11].Text,
ClockIn4 = worksheet.Cells[row, 12].Text,
ClockOut4 = worksheet.Cells[row, 13].Text,
ClockIn5 = worksheet.Cells[row, 14].Text,
ClockOut5 = worksheet.Cells[row, 15].Text,
TotalInTime = worksheet.Cells[row, 16].Text
};
records.Add(record);
}
else
{
Console.WriteLine($"Fecha en la fila {row} es menor o igual a la fecha máxima existente y no será insertada.");
}
}
catch (FormatException ex)
{
Console.WriteLine($"Error al parsear la fecha en la fila {row}: {worksheet.Cells[row, 5].Text}. Excepción: {ex.Message}");
}
}
}
if (records.Any())
{
await InsertWorkingHoursAsync(records);
return new OkObjectResult("Datos insertados correctamente.");
}
else
{
return new BadRequestObjectResult("No se encontraron registros con fechas mayores a la fecha máxima existente.");
}
}
private async Task<DateTime?> GetMaxDateAsync()
{
using (var connection = _dapperContext.CreateConnection())
{
var query = "SELECT MAX(CAST(Date AS DATE)) FROM WorkingHours";
try
{
var maxDate = await connection.ExecuteScalarAsync<DateTime?>(query);
return maxDate ?? DateTime.MinValue; // Retorna una fecha mínima si la tabla está vacía
}
catch (Exception ex)
{
Console.WriteLine($"Error al obtener la fecha máxima: {ex.Message}");
return null;
}
}
}
private async Task InsertWorkingHoursAsync(IEnumerable<WorkingHours> records)
{
using (var connection = _dapperContext.CreateConnection())
{
var createTableQuery = @"
IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'WorkingHours')
CREATE TABLE WorkingHours (
EmpNo VARCHAR(50),
AcNo VARCHAR(50),
No VARCHAR(50),
Name VARCHAR(100),
Date VARCHAR(20),
ClockIn1 VARCHAR(20),
ClockOut1 VARCHAR(20),
ClockIn2 VARCHAR(20),
ClockOut2 VARCHAR(20),
ClockIn3 VARCHAR(20),
ClockOut3 VARCHAR(20),
ClockIn4 VARCHAR(20),
ClockOut4 VARCHAR(20),
ClockIn5 VARCHAR(20),
ClockOut5 VARCHAR(20),
TotalInTime VARCHAR(20))";
await connection.ExecuteAsync(createTableQuery);
var insertQuery = @"
INSERT INTO WorkingHours (
EmpNo, AcNo, No, Name, Date, ClockIn1, ClockOut1, ClockIn2, ClockOut2,
ClockIn3, ClockOut3, ClockIn4, ClockOut4, ClockIn5, ClockOut5, TotalInTime)
VALUES (
@EmpNo, @AcNo, @No, @Name, @Date, @ClockIn1, @ClockOut1, @ClockIn2, @ClockOut2,
@ClockIn3, @ClockOut3, @ClockIn4, @ClockOut4, @ClockIn5, @ClockOut5, @TotalInTime)";
try
{
await connection.ExecuteAsync(insertQuery, records);
}
catch (Exception ex)
{
Console.WriteLine($"Error al insertar datos: {ex.Message}");
throw;
}
}
}
}
}

@ -0,0 +1,250 @@

using Dapper;
using OfficeOpenXml;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BookPrectaBackend.DTO.ExelServices;
using Microsoft.Extensions.Configuration;
using BookPrectaBackend.Context;
namespace BookPrectaBackend.Repository.ExelServices
{
public class ExcelRepository
{
private readonly DapperContext _dapperContext;
public ExcelRepository(DapperContext dapperContext)
{
_dapperContext = dapperContext;
ExcelPackage.LicenseContext = LicenseContext.Commercial;
}
public async Task ProcessExcelFileAsync(Stream fileStream)
{
List<Book> records = new List<Book>();
using (var package = new ExcelPackage(fileStream))
{
var worksheet = package.Workbook.Worksheets[0];
var rowCount = worksheet.Dimension.Rows;
var colCount = worksheet.Dimension.Columns;
string valorActual = null;
for (int row = 2; row <= rowCount; row++) // Asumiendo que la primera fila tiene encabezados
{
var typeValue = worksheet.Cells[row, 1].Text;
if (typeValue.Contains("·"))
{
valorActual = typeValue.Split('·')[0].Trim();
}
else
{
var match = Regex.Match(typeValue, @"\b\d+[-]?\d*\b");
if (match.Success)
{
valorActual = match.Value;
}
}
string cheques = valorActual;
if (typeValue.StartsWith("Total"))
{
valorActual = null;
}
var record = new Book
{
Type = typeValue,
Cheques = cheques ?? string.Empty,
Date = worksheet.Cells[row, 2].Text,
Num = worksheet.Cells[row, 3].Text,
Name = worksheet.Cells[row, 4].Text,
Memo = worksheet.Cells[row, 5].Text,
Amount = float.TryParse(worksheet.Cells[row, 6].Text, out float amount) ? amount : 0f,
Trafico = worksheet.Cells[row, 5].Text.Split().FirstOrDefault()
};
records.Add(record);
}
}
await InsertRecordsAsync(records);
}
private async Task InsertRecordsAsync(IEnumerable<Book> records)
{
using (var connection = _dapperContext.CreateConnection())
{
var createTableQuery = @"
IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'UnifiedTable')
CREATE TABLE UnifiedTable (
Type VARCHAR(255),
Cheques VARCHAR(255),
Date VARCHAR(255), -- Mantener como VARCHAR
Num VARCHAR(255),
Name VARCHAR(255),
Memo VARCHAR(MAX),
Amount FLOAT,
Trafico VARCHAR(255)
)";
await connection.ExecuteAsync(createTableQuery);
var insertQuery = @"
INSERT INTO UnifiedTable (Type, Cheques, Date, Num, Name, Memo, Amount, Trafico)
VALUES (@Type, @Cheques, @Date, @Num, @Name, @Memo, @Amount, @Trafico)";
try
{
await connection.ExecuteAsync(insertQuery, records);
Console.WriteLine($"Se insertaron {records.Count()} registros correctamente en la tabla UnifiedTable.");
}
catch (Exception ex)
{
Console.WriteLine($"Error al insertar datos: {ex.Message}");
throw; // Opcional, vuelve a lanzar la excepción para que el llamador también pueda manejarla
}
}
}
}
}
/*using Dapper;
using OfficeOpenXml;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BookPrectaBackend.DTO.ExelServices;
using BookPrectaBackend.Context;
using Microsoft.Data.SqlClient;
namespace BookPrectaBackend.Repository.ExelServices
{
public class ExcelRepository
{
private readonly DapperContext _dapperContext;
public ExcelRepository(DapperContext dapperContext)
{
_dapperContext = dapperContext;
ExcelPackage.LicenseContext = LicenseContext.Commercial;
}
public async Task ProcessExcelFileAsync(Stream fileStream)
{
var records = new List<Book>();
using (var package = new ExcelPackage(fileStream))
{
var worksheet = package.Workbook.Worksheets[0];
var rowCount = worksheet.Dimension.Rows;
string valorActual = null;
for (int row = 2; row <= rowCount; row++) // Asumiendo que la primera fila tiene encabezados
{
var typeValue = worksheet.Cells[row, 1].Text.Trim();
// Extraer el contenido numérico antes del primer delimitador "·"
if (!string.IsNullOrWhiteSpace(typeValue))
{
if (typeValue.Contains("·"))
{
valorActual = typeValue.Split('·')[0].Trim();
}
else
{
var matchType = Regex.Match(typeValue, @"\b\d+[-]?\d*\b");
if (matchType.Success)
{
valorActual = matchType.Value;
}
}
}
// Asignar el valor encontrado a la columna 2
string cheques = valorActual;
if (typeValue.StartsWith("Total"))
{
valorActual = null;
}
var memo = worksheet.Cells[row, 6].Text.Trim();
string trafico = !string.IsNullOrWhiteSpace(memo) ? memo.Split().FirstOrDefault() : null;
var record = new Book
{
Type = typeValue,
Cheques = cheques ?? string.Empty,
Date = DateTime.TryParse(worksheet.Cells[row, 2].Text.Trim(), out DateTime dateValue) ? dateValue : (DateTime?)null,
Num = worksheet.Cells[row, 3].Text.Trim(),
Name = worksheet.Cells[row, 4].Text.Trim(),
Memo = worksheet.Cells[row, 5].Text.Trim(),
Amount = float.TryParse(worksheet.Cells[row, 6].Text, out float amount) ? amount : 0f,
Trafico = trafico
};
records.Add(record);
}
}
await InsertRecordsAsync(records);
}
private async Task InsertRecordsAsync(IEnumerable<Book> records)
{
using (var connection = _dapperContext.CreateConnection())
{
var createTableQuery = @"
IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'UnifiedTable')
CREATE TABLE UnifiedTable (
Type VARCHAR(255),
Cheques VARCHAR(255),
Date VARCHAR(255),
Num VARCHAR(255),
Name VARCHAR(255),
Memo VARCHAR(MAX),
Amount FLOAT,
Trafico VARCHAR(255)
)";
await connection.ExecuteAsync(createTableQuery);
var insertQuery = @"
INSERT INTO UnifiedTable (Type, Cheques, Date, Num, Name, Memo, Amount, Trafico)
VALUES (@Type, @Cheques, @Date, @Num, @Name, @Memo, @Amount, @Trafico)";
try
{
await connection.ExecuteAsync(insertQuery, records);
Console.WriteLine($"Se insertaron {records.Count()} registros correctamente en la tabla UnifiedTable.");
}
catch (Exception ex)
{
Console.WriteLine($"Error al insertar datos: {ex.Message}");
throw;
}
}
}
}
}*/

@ -0,0 +1,96 @@
using Dapper;
using OfficeOpenXml;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using BookPrectaBackend.DTO.ExelServices;
using BookPrectaBackend.Context;
namespace BookPrectaBackend.Repository.ExcelServices
{
public class ExcelRepositoryPrecta
{
private readonly DapperContext _dapperContext;
public ExcelRepositoryPrecta(DapperContext dapperContext)
{
_dapperContext = dapperContext;
ExcelPackage.LicenseContext = LicenseContext.Commercial;
}
// Método para procesar archivos Excel tipo Precta
public async Task ProcessPrectaExcelFileAsync(Stream fileStream)
{
List<Precta> records = new List<Precta>();
using (var package = new ExcelPackage(fileStream))
{
var worksheet = package.Workbook.Worksheets[0];
var rowCount = worksheet.Dimension.Rows;
for (int row = 2; row <= rowCount; row++) // Asumiendo que la primera fila tiene encabezados
{
var record = new Precta
{
Trafico = worksheet.Cells[row, 1].Text,
Precuenta = worksheet.Cells[row, 2].Text,
Concepto = worksheet.Cells[row, 3].Text,
Importe = worksheet.Cells[row, 4].Text,
Cantidad = worksheet.Cells[row, 5].Text,
Tipo = worksheet.Cells[row, 6].Text,
IdProvedor = worksheet.Cells[row, 7].Text,
NomProvedor = worksheet.Cells[row, 8].Text,
TagTabulador = worksheet.Cells[row, 9].Text,
NombreTabulador = worksheet.Cells[row, 10].Text,
Rctadeb = worksheet.Cells[row, 11].Text
};
records.Add(record);
}
}
await InsertPrectaRecordsAsync(records);
}
private async Task InsertPrectaRecordsAsync(IEnumerable<Precta> records)
{
using (var connection = _dapperContext.CreateConnection())
{
var createTableQuery = @"
IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'UnifiedTable2')
CREATE TABLE UnifiedTable2 (
Trafico VARCHAR(255),
Precuenta VARCHAR(255),
Concepto VARCHAR(255),
Importe VARCHAR(255),
Cantidad VARCHAR(255),
Tipo VARCHAR(255),
IdProvedor VARCHAR(255),
NomProvedor VARCHAR(255),
TagTabulador VARCHAR(255),
NombreTabulador VARCHAR(255),
Rctadeb VARCHAR(255)
)";
await connection.ExecuteAsync(createTableQuery);
var insertQuery = @"
INSERT INTO UnifiedTable2 (Trafico, Precuenta, Concepto, Importe, Cantidad, Tipo, IdProvedor, NomProvedor, TagTabulador, NombreTabulador, Rctadeb)
VALUES (@Trafico, @Precuenta, @Concepto, @Importe, @Cantidad, @Tipo, @IdProvedor, @NomProvedor, @TagTabulador, @NombreTabulador, @Rctadeb)";
try
{
await connection.ExecuteAsync(insertQuery, records);
Console.WriteLine($"Se insertaron {records.Count()} registros correctamente en la tabla UnifiedTable2.");
}
catch (Exception ex)
{
Console.WriteLine($"Error al insertar datos: {ex.Message}");
throw; // Opcional, vuelve a lanzar la excepción para que el llamador también pueda manejarla
}
}
}
}
}

@ -0,0 +1,35 @@
using Dapper;
using BookPrectaBackend.Context;
using BookPrectaBackend.Contracts;
using BookPrectaBackend.Models;
using System.Data;
namespace BookPrectaBackend.Repository
{
public class MenuRepository : IMenuRepository
{
private readonly DapperContext _context;
public MenuRepository(DapperContext context) { _context = context; }
public async Task<IEnumerable<Menu>> GetItemsMenu(Usuarios user)
{
var query = "[Menu.Get]";
using (var connection = _context.CreateConnection())
{
var menu = await connection.QueryAsync<Menu>(query, new { @id = user.Id }, commandType: CommandType.StoredProcedure);
return menu.ToList();
}
}
public async Task<IEnumerable<Menu>> GetItemsMenuTransportista()
{
var query = "[Menu.Transportista.Get]";
using (var connection = _context.CreateConnection())
{
var menu = await connection.QueryAsync<Menu>(query, new { }, commandType: CommandType.StoredProcedure);
return menu.ToList();
}
}
}
}

@ -0,0 +1,107 @@
using Dapper;
using BookPrectaBackend.Context;
using BookPrectaBackend.Contracts;
using BookPrectaBackend.DTO;
using BookPrectaBackend.DTO.Usuario;
using BookPrectaBackend.Models;
using System.Data;
namespace BookPrectaBackend.Repository
{
public class PerfilesRepository : IPerfilesRepository
{
private readonly DapperContext _context;
public PerfilesRepository(DapperContext context) { _context = context; }
public async Task<IEnumerable<Perfiles>> getPerfiles()
{
var query = "[Perfiles.Get]";
using (var connection = _context.CreateConnection())
{
var perfiles = await connection.QueryAsync<Perfiles>(query, new { @id = 0 }, commandType: CommandType.StoredProcedure);
return perfiles.ToList();
}
}
public async Task<Perfiles> PerfilGetById(int id)
{
var query = "[Perfil.GetById]";
using (var connection = _context.CreateConnection())
{
var perfiles = await connection.QueryAsync<Perfiles>(query, new { @id }, commandType: CommandType.StoredProcedure);
return perfiles.FirstOrDefault(new Perfiles());
}
}
public async Task<IEnumerable<Menu>> getMenu()
{
var query = "SELECT * FROM Menu";
using (var connection = _context.CreateConnection())
{
var result = await connection.QueryAsync<Menu>(query);
return result.ToList();
}
}
public async Task<IEnumerable<PerfilesMenu>> getPerfilMenuById(int id)
{
var query = "[Perfil.MenuById]";
using (var connection = _context.CreateConnection())
{
var perfiles = await connection.QueryAsync<PerfilesMenu>(query, new { @id = id }, commandType: CommandType.StoredProcedure);
return perfiles.ToList();
}
}
public async Task<IEnumerable<PerfilesMenu>> getAllPerfilesMenu()
{
var query = "getAllPerfilesMenu";
using (var connection = _context.CreateConnection())
{
var perfiles = await connection.QueryAsync<PerfilesMenu>(query, new { }, commandType: CommandType.StoredProcedure);
return perfiles.ToList();
}
}
public async Task<IEnumerable<DTOPerfilCreate>> createPerfil(DTOPerfilCreate data)
{
var query = "[Perfil.Append]";
using (var connection = _context.CreateConnection())
{
var perfiles = await connection.QueryAsync<DTOPerfilCreate>(query, new { @Perfil = data.Perfil, @IdPerfilClonado = data.IdPerfilClonado }, commandType: CommandType.StoredProcedure);
return perfiles.ToList();
}
}
public async Task<IEnumerable<Menu>> createItemMenu(Menu data)
{
var query = "[Menu.Item.Append]";
using (var connection = _context.CreateConnection())
{
var result = await connection.QueryAsync<Menu>(query, new { @Descripcion = data.Descripcion, @PadreId = data.PadreId, @Posicion = data.Posicion, @URL = data.Url }, commandType: CommandType.StoredProcedure);
return result.ToList();
}
}
public async Task<IEnumerable<DTOItemMenuPerfil>> asignaItemMenuPerfil(DTOItemMenuPerfil data)
{
var query = "[Menu.Item.Perfil.Assign]";
using (var connection = _context.CreateConnection())
{
var perfiles = await connection.QueryAsync<DTOItemMenuPerfil>(query, new { @IdPerfil = data.IdPerfil, @itemMenu = data.itemMenu, @asignado = data.asignado }, commandType: CommandType.StoredProcedure);
return perfiles.ToList();
}
}
/*public async Task<IEnumerable<Transportistas>> getAllTransportistas(int id)
{
//var query = "SELECT sClave, CONCAT(sClave,' | ',sRazonSocial) as sRazonSocial FROM SIR.Admin.ADMINC_42_PROVEEDORES ORDER BY 2";
var query = "getAllTransportistas";
using (var connection = _context.CreateConnection())
{
var transportistas = await connection.QueryAsync<Transportistas>(query, new { @IdUsuario = id }, commandType: CommandType.StoredProcedure);
return transportistas.ToList();
}
}
public async Task<IEnumerable<Proveedores>> getAllProveedores(int id)
{
var query = "getAllProveedores";
using (var connection = _context.CreateConnection())
{
var proveedores = await connection.QueryAsync<Proveedores>(query, new { @IdUsuario = id }, commandType: CommandType.StoredProcedure);
return proveedores.ToList();
}
}*/
}
}

@ -0,0 +1,54 @@
using BookPrectaBackend.Context;
using BookPrectaBackend.Contracts.Reportes;
using BookPrectaBackend.Models.Reportes;
using Dapper;
using System.Data;
namespace BookPrectaBackend.Repository.Reportes
{
public class ReportesRepository : IRptBookPrectacs
{
private readonly DapperContext _context;
public ReportesRepository(DapperContext context) { _context = context; }
public async Task<IEnumerable< RelacionBookPrecta>>GetRelacionesTrafico()
{
var query = "[RelacionesSoloTrafico]";
using (var con = _context.CreateConnection())
{
var result = await con.QueryAsync<RelacionBookPrecta>(query );
return result.ToList();
}
}
public async Task <IEnumerable<RelacionBookPrecta>> GetNoRelaciones()
{
var query = "[DatosNoRelacionan]";
using (var con =_context.CreateConnection())
{
var result = await con.QueryAsync<RelacionBookPrecta>(query);
return result.ToList();
}
}
/*public async Task<IEnumerable<RelacionBookPrecta>> GetNoRelaciones()
{
}*/
}
}

@ -0,0 +1,203 @@
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Common;
using Dapper;
using BookPrectaBackend.Context;
using BookPrectaBackend.Contracts;
using BookPrectaBackend.DTO;
using BookPrectaBackend.Models;
using System.Data;
using BookPrectaBackend.Crypto;
using BookPrectaBackend.DTO.Usuario;
namespace BookPrectaBackend.Repository
{
public class UsuariosRepository : IUsuariosRepository
{
private readonly DapperContext _context;
private readonly IConfiguration _config;
public UsuariosRepository(DapperContext context, IConfiguration config)
{
_context = context;
_config = config;
}
public async Task<IEnumerable<DTOUsuariosShort>> getAllUsuariosShort()
{
var query = "SELECT id, Usuario, Activo FROM Usuario WHERE Usuario<>'Admin' ORDER BY Usuario";
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<DTOUsuariosShort>(query);
return usuarios.ToList();
}
}
public async Task<IEnumerable<Usuarios>> getAllUsuarios()
{
var query = "SELECT * FROM Usuario";
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<Usuarios>(query);
return usuarios.ToList();
}
}
public async Task<Usuarios> GetUsuarioById(int id)
{
var query = "SELECT * FROM Usuario WHERE id=@id";
using (var connection = _context.CreateConnection())
{
var usuario = await connection.QueryAsync<Usuarios>(query, new { id = id });
var usr = usuario.First();
return usr;
}
}
public async Task<Usuarios> GetUsuario(DTOLogin user)
{
var query = "[Usuario.Get]";
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<Usuarios>(query,
new
{
Usuario = user.Usuario,
Contrasena = user.Contrasena,
@HashContrasena = CryptDecrypt.Encrypt(user.Contrasena),
}, commandType: CommandType.StoredProcedure);
Usuarios userFound = usuarios.First();
if (userFound == null) return null!;
var hashed = CryptDecrypt.Decrypt(userFound.Contrasena);
if (hashed != user.Contrasena) return null!;
return userFound;
}
}
public async Task<int> searchUsuario(string Usuario)
{
var query = "SELECT * FROM Usuario WHERE Usuario=@Usuario";
using (var connection = _context.CreateConnection())
{
var usuario = await connection.QueryAsync<Usuarios>(query, new { @Usuario });
return usuario.Count() > 0 ? usuario.First().Id : 0;
}
}
public async Task<DTOPINData> CreatePIN(int Id)
{
var query = "[Usuario.PIN.Create]";
using (var connection = _context.CreateConnection())
{
var data = await connection.QueryAsync<DTOPINData>(query, new { @Id }, commandType: CommandType.StoredProcedure);
return data.First();
}
}
public async Task<Boolean> ValidatePIN(DTOPINUsuario data)
{
var query = "[Usuario.PIN.Validate]";
using (var connection = _context.CreateConnection())
{
var result = await connection.QueryAsync<DTOPINUsuario>(query, new { @data.PIN, @data.Usuario }, commandType: CommandType.StoredProcedure);
if (result.Count() == 0) return false;
return true;
}
}
public async Task<DTOLogin> resetPassword(DTOResetPassword user)
{
var query = "[Usuario.Password.Reset]";
DTOLogin userFound = new DTOLogin();
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<DTOLogin>(query, new
{
@user.PIN,
@Contrasena = user.Contrasena,
@HashContrasena = CryptDecrypt.Encrypt(user.Contrasena),
}, commandType: CommandType.StoredProcedure);
if (usuarios.Count() > 0) userFound = usuarios.First();
}
return userFound;
}
public async Task<Usuarios> createUsuario(DTOUsuario user)
{
var query = "[Usuario.Append]";
using (var connection = _context.CreateConnection())
{
if (user.Id == 0) user.Contrasena = _config.GetValue<string>("DefaultUser:Password");
var usuario = await connection.QueryAsync<Usuarios>(query, new
{
@id = user.Id,
@Usuario = user.Usuario,
@Nombre = user.Nombre,
@Contrasena = CryptDecrypt.Encrypt(user.Contrasena),
@user.TipoUsuario,
@Correo = user.Correo,
@user.IdPerfil
}, commandType: CommandType.StoredProcedure);
return usuario.First();
}
}
public async Task<IEnumerable<DTOClonarUsuario>> clonarUsuario(DTOClonarUsuario user)
{
var query = "[Usuario.Clonar]";
using (var connection = _context.CreateConnection())
{
var usuario = await connection.QueryAsync<DTOClonarUsuario>(query, new
{
@IdUsuarioOrigen = user.IDUsuarioOrigen,
@IdUsuarioDestino = user.IdUsuarioDestino
}, commandType: CommandType.StoredProcedure);
return usuario.ToList();
}
}
// Catalogo de Roles
public async Task<IEnumerable<CatRoles>> CatalogoRolesGET()
{
var query = "[CatRoles.GET]";
using (var connection = _context.CreateConnection())
{
var result = await connection.QueryAsync<CatRoles>(query, new
{
}, commandType: CommandType.StoredProcedure);
return result.ToList();
}
}
public async Task<IEnumerable<DTORolesAsignados>> RolesAsignadosGET(int id)
{
var query = "[RolesAsignados.GET]";
using (var connection = _context.CreateConnection())
{
var result = await connection.QueryAsync<DTORolesAsignados>(query, new
{
@id
}, commandType: CommandType.StoredProcedure);
return result.ToList();
}
}
public async Task<IEnumerable<DTOUsuariosPerfilParecido>> GETPerfilesParecidos(string Perfil)
{
var query = "[Usuarios.Perfiles.Parecidos.Get]";
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<DTOUsuariosPerfilParecido>(query, new { @Perfil }, commandType: CommandType.StoredProcedure);
return usuarios.ToList();
}
}
public async Task<Boolean> DisableUser(int id)
{
var query = "[Usuario.Disable]";
using (var connection = _context.CreateConnection())
{
var usuarios = await connection.QueryAsync<DTOUsuariosPerfilParecido>(query, new { @id }, commandType: CommandType.StoredProcedure);
return true;
}
}
}
}

@ -0,0 +1,52 @@
using System.Net.Mail;
using System.Text;
using Newtonsoft.Json;
using BookPrectaBackend.Clientes.Email;
namespace BookPrectaBackend.Services.Utilerias
{
public class Utilerias
{
private IConfiguration _config;
public Utilerias(IConfiguration config)
{
_config = config;
}
public static string Base64Encode(string plainText)
{
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
return System.Convert.ToBase64String(plainTextBytes);
}
public async Task<Boolean> SendEmail(DTOSendEmail data)
{
using var client = new HttpClient();
string EmailAPI = _config.GetValue<string>("EmailAPI");
client.BaseAddress = new Uri(EmailAPI);
HttpContent body = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = client.PostAsync("SendEmail", body).Result;
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
}
return true;
}
public async Task<Boolean> SendEmailBcc(DTOSendEmailBcc data)
{
using var client = new HttpClient();
string EmailAPI = _config.GetValue<string>("EmailAPI");
client.BaseAddress = new Uri(EmailAPI);
HttpContent body = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var response = client.PostAsync("SendEmailBcc", body).Result;
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
}
return true;
}
}
}

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

@ -0,0 +1,26 @@
{
"ConnectionStrings": {
"SqlConnection": "server=.; database=BookPrectaa; Integrated Security=true;TrustServerCertificate=True;Command Timeout=360"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"DefaultUser": {
"Password": "Bienvenido123!"
},
"EmailServer": "gemcousa-com.mail.protection.outlook.com",
"EmailPort": 25,
"EmailPassword": "N#16rm87",
"EmailAccount": "noreply@gemcousa.com",
"pathArchivoElectronico": "C:\\downs\\ArchivoElectronicoSIR\\www.gemcousa.com\\SIR-GEMCO\\DOCS-SIR\\",
"pathTemp": "C:\\downs\\temp\\",
"Allfiles": "C:\\data\\",
"Twilio_SID": "AC59baecf4872fa93e3c315180c96b4cc2",
"Twilio_Token":"5416fe0460e9afaf5400697def878c04",
"NodeAPI" : "https://nodeapi.gemcousa.mx/",
/* "EmailAPI" : "http://127.0.0.1:5000/" */
"EmailAPI" : "https://pyapi.gemcousa.mx/"
}

@ -0,0 +1,25 @@
{
"ConnectionStrings": {
"SqlConnection": "server=.,14033;database=BookPrectaa;User Id=sa;Password=T3st1n93nv4Qa;TrustServerCertificate=True;"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"DefaultUser": {
"Password": "Bienvenido123!"
},
"EmailServer": "gemcousa-com.mail.protection.outlook.com",
"EmailPort": 25,
"EmailPassword": "N#16rm87",
"EmailAccount": "noreply@gemcousa.com",
"pathArchivoElectronico": "D:\\data\\ArchivoElectronicoSIR\\www.gemcousa.com\\SIR-GEMCO\\DOCS-SIR\\",
"pathTemp": "D:\\data\\temp\\",
"AllFiles": "D:\\data\\",
"Twilio_SID": "AC59baecf4872fa93e3c315180c96b4cc2",
"Twilio_Token":"5416fe0460e9afaf5400697def878c04",
"NodeAPI" : "https://nodeapi.gemcousa.mx/",
"EmailAPI" : "https://pyapi.gemcousa.mx/"
}

@ -0,0 +1,36 @@
{
"ConnectionStrings": {
"SqlConnection": "server=.; database=BooKPrectaa;User Id=sa;Password=Chispa10192;TrustServerCertificate=True;"
},
"DefaultUser": {
"Password": "Bienvenido123!"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"Jwt": {
"Key": "GFE1j5KLolZHDK9iKw5xK17Rz4ty7BlbXgnjPL6dNwVCCNQWU8uRGVyZmAZPWZMs4XX0phFMS849p25Lrwsn31Bi4J7GT2HQ9xeWlJLarJPDyoRZZvChpovwgrquQ9Pd",
"Issuer": "JWTAuthenticationServer",
"Audience": "JWTServicePostmanClient",
"Subject": "JWTServiceAccessToken",
"ExpirationHours": 4
},
"EmailServer": "gemcousa-com.mail.protection.outlook.com",
"EmailPort": 25,
"EmailPassword": "N#16rm87",
"EmailAccount": "noreply@gemcousa.com",
"pathArchivoElectronico": "D:\\data\\ArchivoElectronicoSIR\\www.gemcousa.com\\SIR-GEMCO\\DOCS-SIR\\",
"pathTemp": "D:\\data\\temp\\",
"pathFotosBodega": "D:\\data\\Bodega\\Fotos\\",
"pathZipCorresponsales": "D:\\data\\Corresponsales\\Zips\\",
"CorresponsalesFilePath": "D:\\data\\Corresponsales\\",
"AllFiles": "D:\\data\\",
"Twilio_SID": "AC59baecf4872fa93e3c315180c96b4cc2",
"Twilio_Token":"5416fe0460e9afaf5400697def878c04",
"NodeAPI" : "https://nodeapi.gemcousa.mx/",
"EmailAPI" : "https://pyapi.gemcousa.mx/"
}
Loading…
Cancel
Save