| | | 1 | | using System.Collections.Generic; |
| | | 2 | | using System.Globalization; |
| | | 3 | | using System.Linq; |
| | | 4 | | using System.Text; |
| | | 5 | | using System.Threading; |
| | | 6 | | using System.Threading.Tasks; |
| | | 7 | | using FAU.DataAccess.Repositories; |
| | | 8 | | using FAU.Entidades; |
| | | 9 | | using FAU.Logica.DTOs; |
| | | 10 | | |
| | | 11 | | namespace FAU.Logica.Services; |
| | | 12 | | |
| | | 13 | | public class ReporteDeficitService : IReporteDeficitService |
| | | 14 | | { |
| | | 15 | | private const int AnchoLinea = 80; |
| | | 16 | | private const char SaltoPagina = '\f'; |
| | | 17 | | private const char ControlImpresora = '\u0012'; |
| | | 18 | | private const char LineaLegacy = '─'; |
| | | 19 | | private const string NuevaLinea = "\r\n"; |
| | | 20 | | |
| | 1 | 21 | | private static readonly CultureInfo CulturaMontos = CultureInfo.GetCultureInfo("en-US"); |
| | | 22 | | |
| | | 23 | | private readonly IReporteDeficitRepository _repo; |
| | | 24 | | |
| | 12 | 25 | | public ReporteDeficitService(IReporteDeficitRepository repo) |
| | | 26 | | { |
| | 12 | 27 | | _repo = repo; |
| | 12 | 28 | | } |
| | | 29 | | |
| | | 30 | | public async Task<ReporteDeficitPorPersonaDto> ObtenerDeficitPorPersonaAsync( |
| | | 31 | | long periodoId, CancellationToken ct = default) |
| | | 32 | | { |
| | 2 | 33 | | var filas = (await _repo.ObtenerPlanillaAjusteConRelacionAsync(periodoId, ct)).ToList(); |
| | | 34 | | |
| | 2 | 35 | | var situaciones = filas |
| | 3 | 36 | | .GroupBy(f => f.SituacionNombre) |
| | 1 | 37 | | .OrderBy(g => g.Key) |
| | 1 | 38 | | .Select(gSit => BuildGrupoSituacion(gSit.Key, gSit)) |
| | 2 | 39 | | .ToList(); |
| | | 40 | | |
| | 2 | 41 | | return new ReporteDeficitPorPersonaDto |
| | 2 | 42 | | { |
| | 2 | 43 | | Situaciones = situaciones, |
| | 1 | 44 | | TotalSolicitado = situaciones.Sum(s => s.TotalSolicitado), |
| | 1 | 45 | | TotalAplicado = situaciones.Sum(s => s.TotalAplicado), |
| | 1 | 46 | | TotalDeficit = situaciones.Sum(s => s.TotalDeficit) |
| | 2 | 47 | | }; |
| | 2 | 48 | | } |
| | | 49 | | |
| | | 50 | | private static DeficitGrupoSituacionDto BuildGrupoSituacion( |
| | | 51 | | string situacion, IEnumerable<PlanillaAjusteConRelacionRow> filas) |
| | | 52 | | { |
| | 1 | 53 | | var unidades = filas |
| | 3 | 54 | | .GroupBy(f => f.UnidadNombre) |
| | 1 | 55 | | .OrderBy(g => g.Key) |
| | 1 | 56 | | .Select(gUni => BuildGrupoUnidad(gUni.Key, gUni)) |
| | 1 | 57 | | .ToList(); |
| | | 58 | | |
| | 1 | 59 | | return new DeficitGrupoSituacionDto |
| | 1 | 60 | | { |
| | 1 | 61 | | Situacion = situacion, |
| | 1 | 62 | | Unidades = unidades, |
| | 1 | 63 | | TotalSolicitado = unidades.Sum(u => u.TotalSolicitado), |
| | 1 | 64 | | TotalAplicado = unidades.Sum(u => u.TotalAplicado), |
| | 1 | 65 | | TotalDeficit = unidades.Sum(u => u.TotalDeficit) |
| | 1 | 66 | | }; |
| | | 67 | | } |
| | | 68 | | |
| | | 69 | | private static DeficitGrupoUnidadDto BuildGrupoUnidad( |
| | | 70 | | string unidad, IEnumerable<PlanillaAjusteConRelacionRow> filas) |
| | | 71 | | { |
| | 1 | 72 | | var companias = filas |
| | 3 | 73 | | .GroupBy(f => f.CompaniaNombre) |
| | 1 | 74 | | .OrderBy(g => g.Key) |
| | 1 | 75 | | .Select(gCia => BuildGrupoCompania(gCia.Key, gCia)) |
| | 1 | 76 | | .ToList(); |
| | | 77 | | |
| | 1 | 78 | | return new DeficitGrupoUnidadDto |
| | 1 | 79 | | { |
| | 1 | 80 | | Unidad = unidad, |
| | 1 | 81 | | Companias = companias, |
| | 1 | 82 | | TotalSolicitado = companias.Sum(c => c.TotalSolicitado), |
| | 1 | 83 | | TotalAplicado = companias.Sum(c => c.TotalAplicado), |
| | 1 | 84 | | TotalDeficit = companias.Sum(c => c.TotalDeficit) |
| | 1 | 85 | | }; |
| | | 86 | | } |
| | | 87 | | |
| | | 88 | | private static DeficitGrupoCompaniaDto BuildGrupoCompania( |
| | | 89 | | string compania, IEnumerable<PlanillaAjusteConRelacionRow> filas) |
| | | 90 | | { |
| | 1 | 91 | | var personas = filas |
| | 3 | 92 | | .GroupBy(f => new { f.PersonaId, f.Cedula, f.PersonaNombre }) |
| | 2 | 93 | | .OrderBy(g => g.Key.PersonaNombre) |
| | 2 | 94 | | .Select(gPer => BuildPersona(gPer.Key.PersonaId, gPer.Key.Cedula, gPer.Key.PersonaNombre, gPer)) |
| | 1 | 95 | | .ToList(); |
| | | 96 | | |
| | 1 | 97 | | return new DeficitGrupoCompaniaDto |
| | 1 | 98 | | { |
| | 1 | 99 | | Compania = compania, |
| | 1 | 100 | | Personas = personas, |
| | 2 | 101 | | TotalSolicitado = personas.Sum(p => p.TotalSolicitado), |
| | 2 | 102 | | TotalAplicado = personas.Sum(p => p.TotalAplicado), |
| | 2 | 103 | | TotalDeficit = personas.Sum(p => p.TotalDeficit) |
| | 1 | 104 | | }; |
| | | 105 | | } |
| | | 106 | | |
| | | 107 | | private static DeficitPersonaDto BuildPersona( |
| | | 108 | | long personaId, string cedula, string nombre, IEnumerable<PlanillaAjusteConRelacionRow> filas) |
| | | 109 | | { |
| | 2 | 110 | | var acreedores = filas |
| | 3 | 111 | | .OrderBy(f => f.AcreedorNombre) |
| | 3 | 112 | | .Select(f => new DeficitAcreedorFilaDto |
| | 3 | 113 | | { |
| | 3 | 114 | | AcreedorId = f.AcreedorId, |
| | 3 | 115 | | AcreedorCodigo = f.AcreedorCodigo, |
| | 3 | 116 | | AcreedorNombre = f.AcreedorNombre, |
| | 3 | 117 | | MontoSolicitado = f.MontoSolicitado, |
| | 3 | 118 | | MontoAplicado = f.MontoAplicado, |
| | 3 | 119 | | MontoDeficit = f.MontoNoAplicado |
| | 3 | 120 | | }) |
| | 2 | 121 | | .ToList(); |
| | | 122 | | |
| | 2 | 123 | | return new DeficitPersonaDto |
| | 2 | 124 | | { |
| | 2 | 125 | | PersonaId = personaId, |
| | 2 | 126 | | Cedula = cedula, |
| | 2 | 127 | | Nombre = nombre, |
| | 2 | 128 | | Acreedores = acreedores, |
| | 3 | 129 | | TotalSolicitado = acreedores.Sum(a => a.MontoSolicitado), |
| | 3 | 130 | | TotalAplicado = acreedores.Sum(a => a.MontoAplicado), |
| | 3 | 131 | | TotalDeficit = acreedores.Sum(a => a.MontoDeficit) |
| | 2 | 132 | | }; |
| | | 133 | | } |
| | | 134 | | |
| | | 135 | | public async Task<byte[]> GenerarTxtDeficitPorPersonaAsync( |
| | | 136 | | long periodoId, int anio, int mes, CancellationToken ct = default) |
| | | 137 | | { |
| | 3 | 138 | | var filas = (await _repo.ObtenerPlanillaAjusteConRelacionAsync(periodoId, ct)).ToList(); |
| | 3 | 139 | | var sb = new StringBuilder(); |
| | 3 | 140 | | var hoja = 1; |
| | 3 | 141 | | var primeraPagina = true; |
| | | 142 | | |
| | 3 | 143 | | var grupos = filas |
| | 3 | 144 | | .GroupBy(f => new |
| | 3 | 145 | | { |
| | 3 | 146 | | f.SituacionCodigo, |
| | 3 | 147 | | f.UnidadCodigo, |
| | 3 | 148 | | f.CompaniaCodigo, |
| | 3 | 149 | | f.SituacionNombre, |
| | 3 | 150 | | f.UnidadNombre, |
| | 3 | 151 | | f.CompaniaNombre |
| | 3 | 152 | | }) |
| | 3 | 153 | | .OrderBy(g => g.Key.SituacionCodigo) |
| | 3 | 154 | | .ThenBy(g => g.Key.UnidadCodigo) |
| | 3 | 155 | | .ThenBy(g => g.Key.CompaniaCodigo) |
| | 3 | 156 | | .ThenBy(g => g.Key.SituacionNombre) |
| | 3 | 157 | | .ThenBy(g => g.Key.UnidadNombre) |
| | 3 | 158 | | .ThenBy(g => g.Key.CompaniaNombre) |
| | 3 | 159 | | .ToList(); |
| | | 160 | | |
| | 3 | 161 | | if (grupos.Count == 0) |
| | | 162 | | { |
| | 1 | 163 | | AgregarEncabezadoPersona(sb, hoja, anio, mes); |
| | 1 | 164 | | return CodificarLegacy(sb.ToString()); |
| | | 165 | | } |
| | | 166 | | |
| | 10 | 167 | | foreach (var grupo in grupos) |
| | | 168 | | { |
| | 3 | 169 | | if (!primeraPagina) |
| | 1 | 170 | | sb.Append(SaltoPagina); |
| | | 171 | | |
| | 3 | 172 | | AgregarEncabezadoPersona(sb, hoja++, anio, mes); |
| | 3 | 173 | | primeraPagina = false; |
| | | 174 | | |
| | 3 | 175 | | AgregarLinea(sb); |
| | 3 | 176 | | AgregarLinea(sb); |
| | 3 | 177 | | AgregarLinea(sb, $" Sit./Uni./Comp.{CodigoGrupo(grupo.Key.SituacionCodigo, 2)}/{CodigoGrupo(grupo.Key.Un |
| | | 178 | | |
| | 3 | 179 | | var personas = grupo |
| | 3 | 180 | | .GroupBy(f => new { f.PersonaId, f.Cedula, f.PersonaNombre, f.GradoNombre }) |
| | 6 | 181 | | .OrderBy(g => g.Key.PersonaNombre); |
| | | 182 | | |
| | 12 | 183 | | foreach (var persona in personas) |
| | | 184 | | { |
| | 3 | 185 | | AgregarLinea(sb); |
| | 3 | 186 | | AgregarLinea(sb, $" {Fijo(persona.Key.GradoNombre, 12)} {Fijo(persona.Key.PersonaNombre, 60)}"); |
| | 3 | 187 | | AgregarLinea(sb, $" {new string(' ',12)} {Fijo(persona.Key.PersonaNombre, 30)} {persona.Key.Cedula}"); |
| | | 188 | | |
| | 3 | 189 | | var filasPersona = persona |
| | 3 | 190 | | .OrderBy(f => CodigoNumerico(f.CodigoConcepto)) |
| | 3 | 191 | | .ThenBy(f => f.NombreConcepto) |
| | 3 | 192 | | .ToList(); |
| | | 193 | | |
| | 12 | 194 | | for (var i = 0; i < filasPersona.Count; i++) |
| | | 195 | | { |
| | 3 | 196 | | var fila = filasPersona[i]; |
| | 3 | 197 | | var marca = i == 0 ? " ®" : ""; |
| | 3 | 198 | | AgregarLinea(sb, |
| | 3 | 199 | | $" {Fijo(fila.CodigoConcepto, 15, derecha: true)} {Fijo(fila.NombreConcepto, 49)} {Monto(fila.Mo |
| | | 200 | | } |
| | | 201 | | |
| | 3 | 202 | | AgregarLinea(sb, |
| | 6 | 203 | | $"{new string(' ',47)}Total Deficit {Monto(filasPersona.Sum(f => f.MontoNoAplicado), 14)}"); |
| | | 204 | | } |
| | | 205 | | } |
| | | 206 | | |
| | 2 | 207 | | return CodificarLegacy(sb.ToString()); |
| | 3 | 208 | | } |
| | | 209 | | |
| | | 210 | | public async Task<ReporteDeficitPorAcreedorDto> ObtenerDeficitPorAcreedorAsync( |
| | | 211 | | long periodoId, CancellationToken ct = default) |
| | | 212 | | { |
| | 3 | 213 | | var filas = (await _repo.ObtenerPlanillaAjusteConRelacionAsync(periodoId, ct)).ToList(); |
| | | 214 | | |
| | 3 | 215 | | var acreedores = filas |
| | 2 | 216 | | .GroupBy(f => new { f.AcreedorId, f.AcreedorCodigo, f.AcreedorNombre }) |
| | 2 | 217 | | .OrderBy(g => g.Key.AcreedorNombre) |
| | 3 | 218 | | .Select(gAcr => |
| | 3 | 219 | | { |
| | 2 | 220 | | var personas = gAcr |
| | 2 | 221 | | .OrderBy(f => f.PersonaNombre) |
| | 2 | 222 | | .Select(f => new DeficitPersonaAcreedorFilaDto |
| | 2 | 223 | | { |
| | 2 | 224 | | Cedula = f.Cedula, |
| | 2 | 225 | | Nombre = f.PersonaNombre, |
| | 2 | 226 | | Estado = f.Estado, |
| | 2 | 227 | | Solicitado = f.MontoSolicitado, |
| | 2 | 228 | | Descontado = f.MontoAplicado, |
| | 2 | 229 | | Deficit = f.MontoNoAplicado, |
| | 2 | 230 | | Diferencia = DiferenciaLegacy(f), |
| | 2 | 231 | | Observaciones = f.Observaciones |
| | 2 | 232 | | }) |
| | 2 | 233 | | .ToList(); |
| | 3 | 234 | | |
| | 2 | 235 | | return new DeficitGrupoAcreedorDto |
| | 2 | 236 | | { |
| | 2 | 237 | | AcreedorId = gAcr.Key.AcreedorId, |
| | 2 | 238 | | AcreedorCodigo = gAcr.Key.AcreedorCodigo, |
| | 2 | 239 | | AcreedorNombre = gAcr.Key.AcreedorNombre, |
| | 2 | 240 | | Personas = personas, |
| | 2 | 241 | | TotalSolicitado = personas.Sum(p => p.Solicitado), |
| | 2 | 242 | | TotalDescontado = personas.Sum(p => p.Descontado), |
| | 2 | 243 | | TotalDeficit = personas.Sum(p => p.Deficit), |
| | 2 | 244 | | TotalDiferencia = personas.Sum(p => p.Diferencia) |
| | 2 | 245 | | }; |
| | 3 | 246 | | }) |
| | 3 | 247 | | .ToList(); |
| | | 248 | | |
| | 3 | 249 | | return new ReporteDeficitPorAcreedorDto |
| | 3 | 250 | | { |
| | 3 | 251 | | Acreedores = acreedores, |
| | 2 | 252 | | TotalSolicitado = acreedores.Sum(a => a.TotalSolicitado), |
| | 2 | 253 | | TotalDescontado = acreedores.Sum(a => a.TotalDescontado), |
| | 2 | 254 | | TotalDeficit = acreedores.Sum(a => a.TotalDeficit), |
| | 2 | 255 | | TotalDiferencia = acreedores.Sum(a => a.TotalDiferencia) |
| | 3 | 256 | | }; |
| | 3 | 257 | | } |
| | | 258 | | |
| | | 259 | | public async Task<byte[]> GenerarTxtDeficitPorAcreedorAsync( |
| | | 260 | | long periodoId, int anio, int mes, CancellationToken ct = default) |
| | | 261 | | { |
| | 4 | 262 | | var filas = (await _repo.ObtenerPlanillaAjusteConRelacionAsync(periodoId, ct)).ToList(); |
| | 4 | 263 | | var sb = new StringBuilder(); |
| | 4 | 264 | | var hoja = 1; |
| | | 265 | | |
| | 4 | 266 | | var acreedores = filas |
| | 4 | 267 | | .GroupBy(f => new { f.AcreedorId, f.AcreedorCodigo, f.AcreedorNombre }) |
| | 3 | 268 | | .OrderBy(g => g.Key.AcreedorNombre) |
| | 4 | 269 | | .ToList(); |
| | | 270 | | |
| | 4 | 271 | | if (acreedores.Count == 0) |
| | | 272 | | { |
| | 1 | 273 | | AgregarEncabezadoAcreedor(sb, hoja, "", "", anio, mes); |
| | 1 | 274 | | return CodificarLegacy(sb.ToString()); |
| | | 275 | | } |
| | | 276 | | |
| | 12 | 277 | | foreach (var acreedor in acreedores) |
| | | 278 | | { |
| | 3 | 279 | | var codigoReporte = CodigoAcreedorLegacy(acreedor); |
| | 3 | 280 | | AgregarEncabezadoAcreedor(sb, hoja++, codigoReporte, acreedor.Key.AcreedorNombre, anio, mes); |
| | | 281 | | |
| | 3 | 282 | | var filasNormales = acreedor |
| | 4 | 283 | | .Where(f => !EsNoRevista(f.Estado)) |
| | 3 | 284 | | .OrderBy(f => f.PersonaNombre) |
| | 3 | 285 | | .ToList(); |
| | | 286 | | |
| | 3 | 287 | | var filasNoRevista = acreedor |
| | 4 | 288 | | .Where(f => EsNoRevista(f.Estado)) |
| | 1 | 289 | | .OrderBy(f => f.PersonaNombre) |
| | 3 | 290 | | .ToList(); |
| | | 291 | | |
| | 12 | 292 | | foreach (var fila in filasNormales) |
| | 3 | 293 | | AgregarLinea(sb, FormatearFilaAcreedor(fila)); |
| | | 294 | | |
| | 3 | 295 | | AgregarTotalesAcreedor(sb, filasNormales, " Totales:"); |
| | | 296 | | |
| | 3 | 297 | | if (filasNoRevista.Count > 0) |
| | | 298 | | { |
| | 1 | 299 | | AgregarLinea(sb); |
| | | 300 | | |
| | 4 | 301 | | foreach (var fila in filasNoRevista) |
| | | 302 | | { |
| | 1 | 303 | | AgregarLinea(sb, FormatearFilaNoRevista(fila)); |
| | 1 | 304 | | AgregarLinea(sb); |
| | | 305 | | } |
| | | 306 | | |
| | 1 | 307 | | AgregarTotalesNoRevista(sb, filasNoRevista); |
| | | 308 | | } |
| | | 309 | | |
| | 7 | 310 | | var totalSolicitado = acreedor.Sum(f => f.MontoSolicitado); |
| | 3 | 311 | | AgregarLinea(sb); |
| | 3 | 312 | | AgregarLinea(sb, $" Total solicitado {Monto(totalSolicitado, 17)}"); |
| | 3 | 313 | | AgregarLinea(sb, $" {new string(LineaLegacy, 17)}"); |
| | | 314 | | } |
| | | 315 | | |
| | 3 | 316 | | return CodificarLegacy(sb.ToString()); |
| | 4 | 317 | | } |
| | | 318 | | |
| | | 319 | | private static void AgregarEncabezadoPersona(StringBuilder sb, int hoja, int anio, int mes) |
| | | 320 | | { |
| | 4 | 321 | | AgregarLinea(sb); |
| | 4 | 322 | | AgregarLinea(sb, ControlImpresora.ToString()); |
| | 4 | 323 | | AgregarLinea(sb, $" Inc.:03 Prog.:004 Sect.:34 U.Ej.:023 C.G.F.A. Fecha:{DateTime.Today:dd/MM/yyyy |
| | 4 | 324 | | AgregarLinea(sb, $" DEPARTAMENTO DE RETRIBUCIONES PERSONALES Prog: SUM38232 Hoja :{hoja,8}"); |
| | 4 | 325 | | AgregarLinea(sb, Separador()); |
| | 4 | 326 | | AgregarLinea(sb, Centrar($"Listado de Déficit por Funcionario * Presupuesto de {NombreMes(mes)} de {anio}")); |
| | 4 | 327 | | AgregarLinea(sb, Centrar("(Por Situacion, Unidad, Compañia)")); |
| | 4 | 328 | | AgregarLinea(sb, Separador()); |
| | 4 | 329 | | } |
| | | 330 | | |
| | | 331 | | private static void AgregarEncabezadoAcreedor(StringBuilder sb, int hoja, string codigo, string acreedor, int anio, |
| | | 332 | | { |
| | 4 | 333 | | sb.Append(SaltoPagina); |
| | 4 | 334 | | AgregarLinea(sb); |
| | 4 | 335 | | AgregarLinea(sb); |
| | 4 | 336 | | AgregarLinea(sb, ControlImpresora.ToString()); |
| | 4 | 337 | | AgregarLinea(sb, $" FUERZA AEREA.- Fecha:{DateTime.Today:dd/MM/yyyy |
| | 4 | 338 | | AgregarLinea(sb, $" COMANDO GENERAL.- Hoja :{hoja,10}"); |
| | 4 | 339 | | AgregarLinea(sb, " DIRECCION DE ECONOMIA Y FINANZAS.- Prog: SUM45037"); |
| | 4 | 340 | | AgregarLinea(sb, Separador()); |
| | 4 | 341 | | AgregarLinea(sb, Centrar($"Planilla de Ajuste de : {codigo} {acreedor}".TrimEnd())); |
| | 4 | 342 | | AgregarLinea(sb, Centrar("INSUFICIENCIAS DE LIQUIDO PRESUPUESTAL")); |
| | 4 | 343 | | AgregarLinea(sb, Separador()); |
| | 4 | 344 | | AgregarLinea(sb); |
| | 4 | 345 | | AgregarLinea(sb, "Cédula Ape. y Nomb. Solicit. Déficit Diferencia Descont. Obs."); |
| | 4 | 346 | | AgregarLinea(sb, Separador()); |
| | 4 | 347 | | } |
| | | 348 | | |
| | | 349 | | private static string FormatearFilaAcreedor(PlanillaAjusteConRelacionRow fila) |
| | | 350 | | { |
| | 3 | 351 | | var diferencia = DiferenciaLegacy(fila); |
| | 3 | 352 | | var obs = diferencia - fila.MontoAplicado; |
| | | 353 | | |
| | 3 | 354 | | return string.Concat( |
| | 3 | 355 | | Fijo(fila.Cedula, 8), |
| | 3 | 356 | | " ", |
| | 3 | 357 | | Fijo(fila.PersonaNombre, 18), |
| | 3 | 358 | | Monto(fila.MontoSolicitado, 12), |
| | 3 | 359 | | Monto(fila.MontoNoAplicado, 12), |
| | 3 | 360 | | Monto(diferencia, 13), |
| | 3 | 361 | | Monto(fila.MontoAplicado, 11), |
| | 3 | 362 | | Monto(obs, 10)); |
| | | 363 | | } |
| | | 364 | | |
| | | 365 | | private static string FormatearFilaNoRevista(PlanillaAjusteConRelacionRow fila) |
| | | 366 | | { |
| | 1 | 367 | | return string.Concat( |
| | 1 | 368 | | Fijo(fila.Cedula, 8), |
| | 1 | 369 | | " ", |
| | 1 | 370 | | Fijo(fila.PersonaNombre, 18), |
| | 1 | 371 | | Monto(fila.MontoSolicitado, 12), |
| | 1 | 372 | | " ", |
| | 1 | 373 | | new string(LineaLegacy, 10), |
| | 1 | 374 | | ">", |
| | 1 | 375 | | Monto(fila.MontoSolicitado, 13), |
| | 1 | 376 | | new string(' ', 13), |
| | 1 | 377 | | Fijo("BAJA", 8, derecha: true)); |
| | | 378 | | } |
| | | 379 | | |
| | | 380 | | private static void AgregarTotalesAcreedor(StringBuilder sb, IReadOnlyCollection<PlanillaAjusteConRelacionRow> filas |
| | | 381 | | { |
| | 3 | 382 | | if (filas.Count == 0) |
| | 0 | 383 | | return; |
| | | 384 | | |
| | 6 | 385 | | var totalSolicitado = filas.Sum(f => f.MontoSolicitado); |
| | 6 | 386 | | var totalDeficit = filas.Sum(f => f.MontoNoAplicado); |
| | 3 | 387 | | var totalDiferencia = filas.Sum(DiferenciaLegacy); |
| | 6 | 388 | | var totalDescontado = filas.Sum(f => f.MontoAplicado); |
| | | 389 | | |
| | 3 | 390 | | AgregarLinea(sb, $" {new string(' ',24)}{new string(LineaLegacy, 10)} {new string(LineaLegacy, 10)} {new strin |
| | 3 | 391 | | AgregarLinea(sb, $"{etiqueta}{Monto(totalSolicitado, 24)}{Monto(totalDeficit, 14)} {new string(LineaLegacy, 7)}{ |
| | 3 | 392 | | AgregarLinea(sb, $"{new string(' ',61)}{Monto(totalDiferencia, 13)}"); |
| | 3 | 393 | | } |
| | | 394 | | |
| | | 395 | | private static void AgregarTotalesNoRevista(StringBuilder sb, IReadOnlyCollection<PlanillaAjusteConRelacionRow> fila |
| | | 396 | | { |
| | 2 | 397 | | var total = filas.Sum(f => f.MontoSolicitado); |
| | | 398 | | |
| | 1 | 399 | | AgregarLinea(sb, $" {new string(' ',24)}{new string(LineaLegacy, 10)} {new string(LineaLegacy, 10)} {new string( |
| | 1 | 400 | | AgregarLinea(sb, $" Totales (NO REVISTAN):{Monto(total, 12)}{new string(LineaLegacy, 9)}>{Monto(total, 14)}"); |
| | 1 | 401 | | } |
| | | 402 | | |
| | | 403 | | private static decimal DiferenciaLegacy(PlanillaAjusteConRelacionRow fila) => |
| | 8 | 404 | | fila.MontoSolicitado - fila.MontoNoAplicado; |
| | | 405 | | |
| | | 406 | | private static string CodigoAcreedorLegacy(IEnumerable<PlanillaAjusteConRelacionRow> filas) |
| | | 407 | | { |
| | 3 | 408 | | var codigoConcepto = filas |
| | 3 | 409 | | .Select(f => f.CodigoConcepto) |
| | 6 | 410 | | .FirstOrDefault(c => !string.IsNullOrWhiteSpace(c)); |
| | | 411 | | |
| | 3 | 412 | | if (!string.IsNullOrWhiteSpace(codigoConcepto)) |
| | 2 | 413 | | return codigoConcepto.Trim(); |
| | | 414 | | |
| | 3 | 415 | | return filas.Select(f => f.AcreedorCodigo).FirstOrDefault(c => !string.IsNullOrWhiteSpace(c))?.Trim() ?? ""; |
| | | 416 | | } |
| | | 417 | | |
| | | 418 | | private static bool EsNoRevista(string estado) => |
| | 8 | 419 | | string.Equals(estado, "no_revista", StringComparison.OrdinalIgnoreCase); |
| | | 420 | | |
| | | 421 | | private static int CodigoNumerico(string codigo) => |
| | 3 | 422 | | int.TryParse(codigo, NumberStyles.Integer, CultureInfo.InvariantCulture, out var valor) |
| | 3 | 423 | | ? valor |
| | 3 | 424 | | : int.MaxValue; |
| | | 425 | | |
| | | 426 | | private static string CodigoGrupo(string codigo, int ancho) |
| | | 427 | | { |
| | 9 | 428 | | var texto = string.IsNullOrWhiteSpace(codigo) ? "0" : codigo.Trim(); |
| | 9 | 429 | | return Fijo(texto, ancho, derecha: true); |
| | | 430 | | } |
| | | 431 | | |
| | | 432 | | private static string Monto(decimal monto, int ancho) => |
| | 40 | 433 | | monto.ToString("#,##0.00", CulturaMontos).PadLeft(ancho); |
| | | 434 | | |
| | | 435 | | private static string Fijo(string? valor, int ancho, bool derecha = false) |
| | | 436 | | { |
| | 33 | 437 | | var texto = string.IsNullOrWhiteSpace(valor) ? "" : valor.Trim(); |
| | 33 | 438 | | if (texto.Length > ancho) |
| | 0 | 439 | | texto = texto[..ancho]; |
| | | 440 | | |
| | 33 | 441 | | return derecha ? texto.PadLeft(ancho) : texto.PadRight(ancho); |
| | | 442 | | } |
| | | 443 | | |
| | | 444 | | private static string Centrar(string texto) |
| | | 445 | | { |
| | 16 | 446 | | if (texto.Length >= AnchoLinea) |
| | 0 | 447 | | return texto; |
| | | 448 | | |
| | 16 | 449 | | var margen = (AnchoLinea - texto.Length) / 2; |
| | 16 | 450 | | return new string(' ', margen) + texto; |
| | | 451 | | } |
| | | 452 | | |
| | | 453 | | private static string Separador() => |
| | 20 | 454 | | $" {new string(LineaLegacy, AnchoLinea - 2)}"; |
| | | 455 | | |
| | | 456 | | private static string NombreMes(int mes) |
| | | 457 | | { |
| | 4 | 458 | | string[] meses = |
| | 4 | 459 | | { |
| | 4 | 460 | | "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", |
| | 4 | 461 | | "Julio", "Agosto", "Setiembre", "Octubre", "Noviembre", "Diciembre" |
| | 4 | 462 | | }; |
| | | 463 | | |
| | 4 | 464 | | return mes is >= 1 and <= 12 ? meses[mes - 1] : mes.ToString(CultureInfo.InvariantCulture); |
| | | 465 | | } |
| | | 466 | | |
| | | 467 | | private static void AgregarLinea(StringBuilder sb, string linea = "") |
| | | 468 | | { |
| | 134 | 469 | | sb.Append(linea); |
| | 134 | 470 | | sb.Append(NuevaLinea); |
| | 134 | 471 | | } |
| | | 472 | | |
| | | 473 | | private static byte[] CodificarLegacy(string texto) |
| | | 474 | | { |
| | 7 | 475 | | Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); |
| | 7 | 476 | | return Encoding.GetEncoding(850).GetBytes(texto); |
| | | 477 | | } |
| | | 478 | | } |