private void ConstruirConsulta(out string errorMessage) { errorMessage = ""; if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } string usuario = User.Identity.Name; if (Session["BalanceGeneral_Parametros"] == null) { errorMessage = "Aparentemente, Ud. no ha definido un filtro para esta consulta. Por favor defina un filtro para esta consulta antes de continuar."; return; } BalanceGeneral_Parametros parametros = Session["BalanceGeneral_Parametros"] as BalanceGeneral_Parametros; dbContab_Contab_Entities dbContab = new dbContab_Contab_Entities(); // leemos la tabla de parámetros para omitir del query las cuentas que no correspondan, dependiendo del tipo de reporte (BG / GyP) // nótese que la clase ParametrosContab existe en varios name spaces ContabSysNet_Web.ModelosDatos_EF.Contab.ParametrosContab parametrosContab = dbContab.ParametrosContabs.Where(p => p.Cia == parametros.CiaContab).FirstOrDefault(); if (parametrosContab == null) { errorMessage = "Aparentemente, la tabla de parámetros (Contab) no ha sido inicializada. " + "Por favor inicialize esta tabla con los valores que sean adecuados, para la Cia Contab seleccionada para esta consulta."; return; } // ahora modificamos el filtro para incluir/excluir las cuentas del tipo GyP ... string filtroBalGen_GyP = ""; ConstruirFiltroBalGenGyP(parametros, parametrosContab, dbContab, out filtroBalGen_GyP); string filtroConsulta = parametros.Filtro + filtroBalGen_GyP; // obtenemos el mes y año fiscal que corresponde al mes de la consulta; la función que determina el saldo anterior para cada cuenta contable, // en realidad lee el saldo para el mes fiscal *anterior* al de la consulta; una consulta para Marzo, necesita como saldos anteriores los del mes Febrero ... var fecha_sqlParam = new SqlParameter("@fecha", parametros.Desde); var ciaContab_sqlParam = new SqlParameter("@ciaContab", parametros.CiaContab); var mesFiscal_sqlParam = new SqlParameter("@mesFiscal", System.Data.SqlDbType.SmallInt); var anoFiscal_sqlParam = new SqlParameter("@anoFiscal", System.Data.SqlDbType.SmallInt); var nombreMes_sqlParam = new SqlParameter("@nombreMes", System.Data.SqlDbType.NVarChar, 50); var errorMessage_sqlParam = new SqlParameter("@errorMessage", System.Data.SqlDbType.NVarChar, 500); mesFiscal_sqlParam.Direction = ParameterDirection.Output; anoFiscal_sqlParam.Direction = ParameterDirection.Output; nombreMes_sqlParam.Direction = ParameterDirection.Output; errorMessage_sqlParam.Direction = ParameterDirection.Output; var contabDbContext = new ContabSysNet_Web.ModelosDatos_EF.code_first.contab.ContabContext(); var result = contabDbContext.Database.SqlQuery <int?>("dbo.spDeterminarMesFiscal @fecha, @ciaContab, @mesFiscal OUT, @anoFiscal OUT, @nombreMes OUT, @errorMessage OUT", fecha_sqlParam, ciaContab_sqlParam, mesFiscal_sqlParam, anoFiscal_sqlParam, nombreMes_sqlParam, errorMessage_sqlParam) .FirstOrDefault(); if (!string.IsNullOrEmpty(errorMessage_sqlParam.Value.ToString())) { string functionErrorMessage = errorMessage_sqlParam.Value.ToString(); errorMessage = "Hemos obtenido un error, al intentar obtener obtener el mes y año fiscal para la fecha indicada como criterio de ejecución.<br /> " + "A continuación, mostramos el mensaje específico de error:<br /> " + functionErrorMessage; return; } short mesFiscal = Convert.ToInt16(mesFiscal_sqlParam.Value); short anoFiscal = Convert.ToInt16(anoFiscal_sqlParam.Value); string nombreMes = (nombreMes_sqlParam.Value).ToString(); // refinar el filtro para, por ejemplo, GyP: leer solo gastos/ingresos; BG: no leer gastos/ingresos (depende de opción, etc.) // antes eliminamos los registros que puedan existir int cantRegistrosEliminados = dbContab.ExecuteStoreCommand("Delete From Temp_Contab_Report_BalanceGeneral Where Usuario = {0}", usuario); // nótese como leemos *solo* cuentas contables que tengan registros de saldo contable agregado ... var query = dbContab.CuentasContables.Where(filtroConsulta).Where(c => c.TotDet == "D").Where(c => c.SaldosContables.Any()).Select(c => c.ID); // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { errorMessage = monedaNacional_return.message;; return; } ContabSysNet_Web.ModelosDatos_EF.code_first.contab.Monedas monedaNacional = monedaNacional_return.moneda; // ponemos la moneda nacional en un session pues la usa el popup que muestra los movimientos; así no la tiene que leer cada vez Session["monedaNacional"] = monedaNacional.Moneda; // ---------------------------------------------------------------------------------------------------------------------- int cuentasContablesAgregadas = 0; foreach (int cuentaContableID in query) { // nótese como obtenemos el mes fiscal para el mes *anterior* al mes de inicio del período; la idea es obtener (luego) los saldos del mes // *anterior* al inicio del período; por ejemplo: si el usuario intenta obtener la consulta para Abril, debemos obtener los saldos para // Marzo, que serán los iniciales para Abril .... var cuentaContableID_sqlParam = new SqlParameter("@cuentaContableID", cuentaContableID); var mesFiscal2_sqlParam = new SqlParameter("@mesFiscal", mesFiscal); var anoFiscal2_sqlParam = new SqlParameter("@anoFiscal", anoFiscal); var desde_sqlParam = new SqlParameter("@desde", parametros.Desde); var hasta_sqlParam = new SqlParameter("@hasta", parametros.Hasta); var moneda_sqlParam = new SqlParameter("@moneda", parametros.Moneda); var monedaNacional_sqlParam = new SqlParameter("@monedaNacional", monedaNacional.Moneda); var monedaOriginal_sqlParam = new SqlParameter("@monedaOriginal", System.Data.SqlDbType.Int); // el valor de este parámetro puede ser null if (parametros.MonedaOriginal == null) { monedaOriginal_sqlParam.Value = DBNull.Value; } else { monedaOriginal_sqlParam.Value = parametros.MonedaOriginal; } var nombreUsuario_sqlParam = new SqlParameter("@nombreUsuario", usuario); var excluirCuentasSaldoYMovtosCero_sqlParam = new SqlParameter("@excluirSaldoInicialDebeHaberCero", parametros.ExcluirCuentasSaldoYMovtosCero); var excluirCuentasSaldosFinalCero_sqlParam = new SqlParameter("@excluirSaldoFinalCero", parametros.ExcluirCuentasSaldosFinalCero); var excluirCuentasSinMovimientos_sqlParam = new SqlParameter("@excluirSinMovimientosPeriodo", parametros.ExcluirCuentasSinMovimientos); var excluirAsientosContablesTipoCierreAnual_sqlParam = new SqlParameter("@excluirAsientoTipoCierreAnual", parametros.ExcluirAsientosContablesTipoCierreAnual); var reconvertirCifrasAntes_01Oct2021_sqlParam = new SqlParameter("@reconvertirCifrasAntes_01Oct2021", parametros.reconvertirCifrasAntes_01Oct2021); var errorMessage2_sqlParam = new SqlParameter("@errorMessage", ""); errorMessage2_sqlParam.Direction = ParameterDirection.Output; var resultadoFuncion = contabDbContext.Database.SqlQuery <int?>("dbo.spBalanceGeneral " + "@cuentaContableID, @mesFiscal, @anoFiscal, @desde, @hasta, " + "@moneda, @MonedaNacional, @monedaOriginal, @nombreUsuario, @excluirSaldoInicialDebeHaberCero, " + "@excluirSaldoFinalCero, @excluirSinMovimientosPeriodo, @excluirAsientoTipoCierreAnual, " + "@reconvertirCifrasAntes_01Oct2021, @errorMessage OUT", cuentaContableID_sqlParam, mesFiscal2_sqlParam, anoFiscal2_sqlParam, desde_sqlParam, hasta_sqlParam, moneda_sqlParam, monedaNacional_sqlParam, monedaOriginal_sqlParam, nombreUsuario_sqlParam, excluirCuentasSaldoYMovtosCero_sqlParam, excluirCuentasSaldosFinalCero_sqlParam, excluirCuentasSinMovimientos_sqlParam, excluirAsientosContablesTipoCierreAnual_sqlParam, reconvertirCifrasAntes_01Oct2021_sqlParam, errorMessage2_sqlParam) .FirstOrDefault(); if (!string.IsNullOrEmpty(errorMessage_sqlParam.Value.ToString())) { errorMessage = errorMessage_sqlParam.Value.ToString(); return; } // la función regresa la cantidad de registros agregadados (1 o 0) ... if (resultadoFuncion != null && resultadoFuncion.Value == 1) { cuentasContablesAgregadas++; } } string ajaxPopUpMessage = ""; ajaxPopUpMessage = "<br /><b>Ok, el proceso de lectura de cuentas, movimientos y saldos contables ha finalizado.</b><br /><br />" + "En total, fueron leídos (y registrados en la base de datos): <br /><br />" + "*) " + cuentasContablesAgregadas.ToString() + " cuentas contables, sus saldos del mes anterior y movimiento en el período. <br />"; this.ModalPopupTitle_span.InnerHtml = "... Ok, el proceso ha finalizado."; this.ModalPopupBody_span.InnerHtml = ajaxPopUpMessage; this.btnOk.Visible = false; this.btnCancel.Text = "Ok"; this.ModalPopupExtender1.Show(); this.MonedasFilter_DropDownList.DataBind(); this.CompaniasFilter_DropDownList.DataBind(); this.BalanceGeneral_GridView.DataBind(); // para mostrar la cantidad de registros seleccionados this.selectedRecs_p.InnerHtml = $"{cuentasContablesAgregadas.ToString()} registros seleccionados ..."; this.selectedRecs_div.Style["display"] = "block"; }
protected void Page_Load(object sender, EventArgs e) { ErrMessage_Span.InnerHtml = ""; ErrMessage_Span.Style["display"] = "none"; if (!Page.IsPostBack) { HtmlGenericControl MyHtmlH2; MyHtmlH2 = (HtmlGenericControl)Master.FindControl("PageTitle_TableCell"); if (!(MyHtmlH2 == null)) { MyHtmlH2.InnerHtml = "Consulta de Asientos Contables"; } dbContabDataContext dbContab = new dbContabDataContext(); int numeroAutomaticoAsiento = Convert.ToInt32(Page.Request.QueryString["NumeroAutomatico"]); // nótese que las páginas que usan esta página reciben, todas, este parámetro bool bReconvertirCifrasAntes_01Oct2021 = false; try { bReconvertirCifrasAntes_01Oct2021 = (bool)Session["ReconvertirCifrasAntes_01Oct2021"]; } catch (Exception ex) { ErrMessage_Span.InnerHtml = "Ud. debe aplicar un filtro antes de intentar abrir esta página. <br />" + "Aparentemente, no se ha aplicado un filtro aún. <br /> " + "Por favor aplique un filtro. Luego regrese y ejecute esta función."; ErrMessage_Span.Style["display"] = "block"; return; } // si el usuario quiere aplicar la reconversión Oct/2021, lo indicamos al SqlDataSource con un parámetro // el sqldatasource usa un Case para aplicar o no la operación (x/1M y redondear a 2 decimales) // solo intentamos reconvertir si el asiento es en Bs y de fecha *anterior* a 1-oct-2021 if (bReconvertirCifrasAntes_01Oct2021) { var asiento = dbContab.Asientos.Where(x => x.NumeroAutomatico == numeroAutomaticoAsiento).Select(x => new { moneda = x.Moneda, fecha = x.Fecha }).First(); if (asiento.fecha >= new DateTime(2021, 10, 1)) { bReconvertirCifrasAntes_01Oct2021 = false; } else { // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { ErrMessage_Span.InnerHtml = monedaNacional_return.message; ErrMessage_Span.Style["display"] = "block"; return; } Monedas monedaNacional = monedaNacional_return.moneda; // ---------------------------------------------------------------------------------------------------------------------- if (asiento.moneda != monedaNacional.Moneda) { bReconvertirCifrasAntes_01Oct2021 = false; } else { this.Partidas_SqlDataSource.SelectParameters["Reconversion_2021"].DefaultValue = "si"; } } } this.AsientosContables_SqlDataSource.SelectParameters["NumeroAutomatico"].DefaultValue = numeroAutomaticoAsiento.ToString(); this.Partidas_SqlDataSource.SelectParameters["NumeroAutomatico"].DefaultValue = numeroAutomaticoAsiento.ToString(); this.Asientos_Log_SqlDataSource.SelectParameters["NumeroAutomatico"].DefaultValue = numeroAutomaticoAsiento.ToString(); this.AsientosLinks_SqlDataSource.SelectParameters["NumeroAutomatico"].DefaultValue = numeroAutomaticoAsiento.ToString(); decimal?nTotalDebe = (from d in dbContab.dAsientos where d.NumeroAutomatico == numeroAutomaticoAsiento select(decimal?) d.Debe).Sum(); decimal?nTotalHaber = (from d in dbContab.dAsientos where d.NumeroAutomatico == numeroAutomaticoAsiento select(decimal?) d.Haber).Sum(); if (bReconvertirCifrasAntes_01Oct2021) { nTotalDebe = Convert.ToDecimal(Math.Round(Convert.ToDouble(nTotalDebe) / 1000000, 2)); nTotalHaber = Convert.ToDecimal(Math.Round(Convert.ToDouble(nTotalHaber) / 1000000, 2)); } Label MySumOfDebe_Label = (Label)Partidas_ListView.FindControl("SumOfDebe_Label"); Label MySumOfHaber_Label = (Label)Partidas_ListView.FindControl("SumOfHaber_Label"); if (MySumOfDebe_Label != null) { MySumOfDebe_Label.Text = nTotalDebe != null?nTotalDebe.Value.ToString("#,##0.000") : "0,000"; } if (MySumOfHaber_Label != null) { MySumOfHaber_Label.Text = nTotalHaber != null?nTotalHaber.Value.ToString("#,##0.000") : "0,000"; } dbContab = null; // establecemos la propiedad del link que permite obtener el reporte para este asiento contable ... string url = ""; url = "../../../ReportViewer.aspx?rpt=unasientocontable&NumeroAutomatico=" + numeroAutomaticoAsiento.ToString(); ImprimirAsientoContable_HyperLink.HRef = "javascript:PopupWin('" + url + "', 1000, 680)"; } }
private void RefreshAndBindInfo() { if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (Session["filtroForma_consultaAsientosContables"] == null) { ErrMessage_Span.InnerHtml = "Aparentemente, Ud. no ha indicado un filtro aún.<br />Por favor indique y aplique un filtro " + "antes de intentar mostrar el resultado de la consulta."; ErrMessage_Span.Style["display"] = "block"; return; } // -------------------------------------------------------------------------------------------- // determinamos el mes y año fiscales, para usarlos como criterio para buscar el saldo en la tabla // SaldosContables. En esta table, los saldos están para el mes fiscal y no para el mes calendario. // Los meses solo varían cuando el año fiscal no es igual al año calendario // -------------------------------------------------------------------------------------------- // eliminamos el contenido de la tabla temporal dbContab_Contab_Entities context = new dbContab_Contab_Entities(); try { context.ExecuteStoreCommand("Delete From tTempWebReport_ConsultaComprobantesContables Where NombreUsuario = {0}", Membership.GetUser().UserName); } catch (Exception ex) { context.Dispose(); ErrMessage_Span.InnerHtml = "Ha ocurrido un error al intentar ejecutar una operación de acceso a la base de datos. <br /> " + "El mensaje específico de error es: " + ex.Message + "<br /><br />"; ErrMessage_Span.Style["display"] = "block"; return; } // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { ErrMessage_Span.InnerHtml = monedaNacional_return.message; ErrMessage_Span.Style["display"] = "block"; return; } Monedas monedaNacional = monedaNacional_return.moneda; // ---------------------------------------------------------------------------------------------------------------------- // agregamos este flag luego de la reconversión del 1-Oct-21 // la idea es que el usuario pueda decidir si reconvertir montos bool bReconvertirCifrasAntes_01Oct2021 = (bool)Session["ReconvertirCifrasAntes_01Oct2021"]; // el usuario puede indicar que desea *solo* asientos con uploads string joinTableAsientosUploads = "Left Outer Join "; if (Session["SoloAsientosConUploads_CheckBox"] != null && Convert.ToBoolean(Session["SoloAsientosConUploads_CheckBox"])) { joinTableAsientosUploads = "Join "; } // usamos el criterio que indico el usuario para leer las cuentas contables y grabarlas a una tabla en la base de datos temporal // NOTA: *solo* si el usuario usa algunos criterios en el filtro, usamos un subquery en el select a los asientos contables // nótese que el select a la tabla de links (asientos_documentos_links) se hace en un subquery; la idea es evitar que los counts se multipliquen // por la cantidad de registros en el primer join. cuando en sql se hacen counts, sum, etc., y hay más de dos tablas en el select, los montos // se desvirtúan. La solución es usar subqueries para las tablas que siguen a la segunda ... string sSqlQueryString = ""; if (Session["filtroForma_consultaAsientosContables_subQuery"] == null || Session["filtroForma_consultaAsientosContables_subQuery"].ToString() == "1 = 1") { sSqlQueryString = "SELECT Asientos.NumeroAutomatico, Asientos.Moneda, Asientos.Fecha, " + "Count(dAsientos.Partida) As NumPartidas, Sum(dAsientos.Debe) As TotalDebe, Sum(dAsientos.Haber) AS TotalHaber, " + "iif(links.NumLinks Is Not Null, links.NumLinks, 0) As NumLinks, Lote As Lote " + "FROM Asientos Left Outer Join dAsientos On Asientos.NumeroAutomatico = dAsientos.NumeroAutomatico " + joinTableAsientosUploads + // 'join' o 'left join' dependiendo de si el usuario quiere *solo* asientos con uploads "(SELECT Asientos_Documentos_Links.NumeroAutomatico, Count(Asientos_Documentos_Links.Id) as NumLinks " + "FROM Asientos_Documentos_Links " + "Group By Asientos_Documentos_Links.NumeroAutomatico) as links On Asientos.NumeroAutomatico = links.NumeroAutomatico " + "Where " + Session["filtroForma_consultaAsientosContables"].ToString() + " " + "Group By Asientos.NumeroAutomatico, Asientos.Moneda, Asientos.Fecha, Asientos.Lote, links.NumLinks"; } else { // usamos un subquery para que solo asientos con ciertas cuentas *o* partidas con montos con más de 2 decimales sean seleccionados sSqlQueryString = "SELECT Asientos.NumeroAutomatico, Asientos.Moneda, Asientos.Fecha, " + "Count(dAsientos.Partida) As NumPartidas, Sum(dAsientos.Debe) As TotalDebe, Sum(dAsientos.Haber) AS TotalHaber, " + "iif(links.NumLinks Is Not Null, links.NumLinks, 0) As NumLinks, Lote As Lote " + "FROM Asientos " + "Left Outer Join dAsientos On Asientos.NumeroAutomatico = dAsientos.NumeroAutomatico " + "Left Outer Join CuentasContables On CuentasContables.ID = dAsientos.CuentaContableID " + joinTableAsientosUploads + // 'join' o 'left join' dependiendo de si el usuario quiere *solo* asientos con uploads "(SELECT Asientos_Documentos_Links.NumeroAutomatico, Count(Asientos_Documentos_Links.Id) as NumLinks " + "FROM Asientos_Documentos_Links " + "Group By Asientos_Documentos_Links.NumeroAutomatico) as links On Asientos.NumeroAutomatico = links.NumeroAutomatico " + "Where " + Session["filtroForma_consultaAsientosContables"].ToString() + " And (Asientos.NumeroAutomatico In (SELECT Asientos.NumeroAutomatico FROM Asientos " + "Left Outer Join dAsientos On Asientos.NumeroAutomatico = dAsientos.NumeroAutomatico " + "Left Outer Join CuentasContables On CuentasContables.ID = dAsientos.CuentaContableID " + "Where " + Session["filtroForma_consultaAsientosContables"].ToString() + " And " + Session["filtroForma_consultaAsientosContables_subQuery"].ToString() + "))" + "Group By Asientos.NumeroAutomatico, Asientos.Moneda, Asientos.Fecha, Asientos.Lote, links.NumLinks"; } if (Session["SoloAsientosDescuadrados"] != null && Convert.ToBoolean(Session["SoloAsientosDescuadrados"])) { sSqlQueryString = sSqlQueryString + " Having Sum(dAsientos.Debe) <> Sum(dAsientos.Haber)"; } List <ComprobanteContable_Object> query = context.ExecuteStoreQuery <ComprobanteContable_Object>(sSqlQueryString).ToList(); tTempWebReport_ConsultaComprobantesContables MyComprobantesContable; decimal nTotalDebe = 0; decimal nTotalHaber = 0; int cantidadRegistros = 0; DateTime fechaReconversion2021 = new DateTime(2021, 10, 1); foreach (ComprobanteContable_Object a in query) { decimal totalDebe = a.TotalDebe != null ? a.TotalDebe.Value : 0; decimal totalHaber = a.TotalHaber != null ? a.TotalHaber.Value : 0; // ----------------------------------------------------------------------------------------- // el usuario puede indicar que quiere reconvertir cifras anteriores al 31/Oct/21 if (bReconvertirCifrasAntes_01Oct2021 && (a.Moneda == monedaNacional.Moneda) && (a.Fecha < fechaReconversion2021)) { totalDebe /= 1000000; totalDebe = Math.Round(totalDebe, 2); totalHaber /= 1000000; totalHaber = Math.Round(totalHaber, 2); } MyComprobantesContable = new tTempWebReport_ConsultaComprobantesContables(); MyComprobantesContable.NumeroAutomatico = a.NumeroAutomatico; MyComprobantesContable.NumPartidas = Convert.ToInt16(a.NumPartidas); MyComprobantesContable.TotalDebe = totalDebe; MyComprobantesContable.TotalHaber = totalHaber; MyComprobantesContable.NombreUsuario = Membership.GetUser().UserName; MyComprobantesContable.NumUploads = Convert.ToInt16(a.NumLinks); MyComprobantesContable.Lote = a.Lote; context.tTempWebReport_ConsultaComprobantesContables.AddObject(MyComprobantesContable); nTotalDebe += totalDebe; nTotalHaber += totalHaber; cantidadRegistros++; } try { context.SaveChanges(); } catch (Exception ex) { string errorMessage = ex.Message; if (ex.InnerException != null) { errorMessage += "<br />" + ex.InnerException.Message; } ErrMessage_Span.InnerHtml = "Ha ocurrido un error al intentar ejecutar una operación de acceso a la base de datos. <br /> " + "El mensaje específico de error es: " + errorMessage; ErrMessage_Span.Style["display"] = "block"; context.Dispose(); return; } context.Dispose(); this.CompaniasFilter_DropDownList.DataBind(); this.MonedasFilter_DropDownList.DataBind(); ComprobantesContables_ListView.DataBind(); // actualizamos los totales en el footer en el ListView Label numberOfRecords_label = (Label)ComprobantesContables_ListView.FindControl("numberOfRecords_label"); Label MySumOfDebe_Label = (Label)ComprobantesContables_ListView.FindControl("SumOfDebe_Label"); Label MySumOfHaber_Label = (Label)ComprobantesContables_ListView.FindControl("SumOfHaber_Label"); if (numberOfRecords_label != null) { numberOfRecords_label.Text = cantidadRegistros.ToString(); } if (MySumOfDebe_Label != null) { MySumOfDebe_Label.Text = nTotalDebe.ToString("#,##0.000"); } if (MySumOfHaber_Label != null) { MySumOfHaber_Label.Text = nTotalHaber.ToString("#,##0.000"); } }
private void RefreshAndBindInfo() { if (this.User != null && this.User.Identity != null && !User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (Session["FiltroForma"] == null) { Session["Thread_ErrorMessage"] = "Aparentemente, Ud. no ha indicado un filtro aún.<br /> " + "Por favor indique y aplique un filtro antes de intentar mostrar el resultado de " + "la consulta."; return; } Session["Progress_Percentage"] = 0; string errorMessage = ""; // nota importante: esta consulta (y otras?) deben, al menos por ahora, ser pedidas para una CiaContab // en particular, pues los años fiscales para las Cias Contab pueden variar entre ellas ... if (Session["CiaContabSeleccionada"] == null) { // el usuario debe seleccionar una cia contab en particular, pues los saldos contables se leen // de acuerdo al año fiscal de la misma ... Session["Thread_ErrorMessage"] = "Aparentemente, no se ha seleccionado una Cia Contab.<br /> " + "Por favor seleccione una Cia Contab al establecer el filtro a usar para esta consulta."; Session["Progress_SelectedRecs"] = 0; Session["Progress_Completed"] = 1; Session["Progress_Percentage"] = 0; return; } var ciaContabSeleccionada = Convert.ToInt32(Session["CiaContabSeleccionada"].ToString()); var dFechaInicialPeriodoIndicado = (System.DateTime)Session["FechaInicialPeriodo"]; var dFechaFinalPeriodoIndicado = (System.DateTime)Session["FechaFinalPeriodo"]; bool bReconvertirCifrasAntes_01Oct2021 = (bool)Session["ReconvertirCifrasAntes_01Oct2021"]; bool bExcluirAsientosReconversion_01Oct2021 = (bool)Session["ExcluirAsientosReconversion_01Oct2021"]; bool bExcluirAsientosTipoCierreAnual = (bool)Session["ExcluirAsientosTipoCierreAnual"]; // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { ErrMessage_Span.InnerHtml = monedaNacional_return.message; ErrMessage_Span.Style["display"] = "block"; return; } Monedas monedaNacional = monedaNacional_return.moneda; Session["monedaNacional"] = monedaNacional.Moneda; // ---------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------- // eliminamos el contenido de la tabla temporal dbContab_Contab_Entities dbContext = new dbContab_Contab_Entities(); try { int cantRegistrosEliminados = dbContext.ExecuteStoreCommand("Delete From Contab_BalanceComprobacion Where NombreUsuario = {0}", Membership.GetUser().UserName); } catch (Exception ex) { dbContext.Dispose(); Session["Thread_ErrorMessage"] = "Ha ocurrido un error al intentar ejecutar una operación de " + "acceso a la base de datos. <br /> El mensaje específico de error es: " + ex.Message + "<br /><br />"; return; } // ----------------------------------------------------------------------------------------------- // para evitar que el reporte se genere en forma incompleta, intentamos buscar cuentas que tengan // asientos, más no registros en SaldosContables. De haberlas, lo notificamos al usuario y le // indicamos que ejecute un cierre contable para corregir esta situación string filtroFormParaAsientos = Session["FiltroForma"].ToString(); filtroFormParaAsientos = filtroFormParaAsientos.Replace("SaldosContables", "Asientos"); string filtroFormaParaSaldosContables = Session["FiltroForma"].ToString(); string sSqlQueryString = "Select dAsientos.CuentaContableID From dAsientos " + "Inner Join Asientos On dAsientos.NumeroAutomatico = Asientos.NumeroAutomatico " + "Inner Join CuentasContables On dAsientos.CuentaContableID = CuentasContables.ID " + "Where Asientos.Fecha Between '" + dFechaInicialPeriodoIndicado.ToString("yyyy-MM-dd") + "' And '" + dFechaFinalPeriodoIndicado.ToString("yyyy-MM-dd") + "' And " + filtroFormParaAsientos + " And dAsientos.CuentaContableID Not In " + "(Select CuentaContableID From SaldosContables Inner Join CuentasContables On SaldosContables.CuentaContableID = CuentasContables.ID " + "Where " + filtroFormaParaSaldosContables + ")"; int nCuentasSinSaldo = dbContext.ExecuteStoreQuery <int>(sSqlQueryString).Count(); if (nCuentasSinSaldo > 0) { // hay cuentas contables en asientos que no tienen un registro en SaldosContables; lo notificamos al // usuario para que corrija esta situación con un cierre contable Session["Thread_ErrorMessage"] = "Existen cuentas contables usadas en asientos contables que no tienen " + "un registro en la tabla de saldos. <br /> " + "Por favor ejecute un cierre contable para el mes (o los meses) de esta consulta, " + "para corregir esta situación (y agregar un registro de saldos a las cuentas contables que no lo tienen)."; Session["Progress_SelectedRecs"] = 0; Session["Progress_Completed"] = 1; Session["Progress_Percentage"] = 0; return; } // hacemos una validación similar a la anterior, pero esta vez buscando cuentas contables que hayan cambiado de detalle a total // recuérdese que solo cuentas de tipo detalle pueden recibir asientos; notificamos ésto al usuario, para que corrija esta // situación antes de continuar ... sSqlQueryString = "Select CuentasContables.CuentaEditada + ' ' + CuentasContables.Descripcion From dAsientos " + "Inner Join Asientos On dAsientos.NumeroAutomatico = Asientos.NumeroAutomatico " + "Inner Join CuentasContables On dAsientos.CuentaContableID = CuentasContables.ID " + "Where Asientos.Fecha Between '" + dFechaInicialPeriodoIndicado.ToString("yyyy-MM-dd") + "' And '" + dFechaFinalPeriodoIndicado.ToString("yyyy-MM-dd") + "' And " + filtroFormParaAsientos + " And CuentasContables.TotDet <> 'D'"; List <string> query0 = dbContext.ExecuteStoreQuery <string>(sSqlQueryString).ToList(); errorMessage = ""; foreach (string cuentaTipoTotal in query0) { if (string.IsNullOrEmpty(errorMessage)) { errorMessage = cuentaTipoTotal; } else { errorMessage += ", " + cuentaTipoTotal; } } if (errorMessage != "") { Session["Thread_ErrorMessage"] = "Aparentemente, existen cuentas contables que han recibido asientos contables en el período indicado y que " + "no son de tipo 'detalle'; <br />deben serlo, pues solo cuentas de tipo 'detalle' pueden recibir asientos. <br /> " + "Es probable que una cuenta de tipo 'detalle' y que recibió asientos en el período indicado, fue cambiada a tipo 'total' y mantuvo sus asientos.<br /> " + "A continuación mostramos las cuentas que están en este estado y que ha detectado este proceso: " + errorMessage; Session["Progress_SelectedRecs"] = 0; Session["Progress_Completed"] = 1; Session["Progress_Percentage"] = 0; return; } ; // para leer los saldos, debemos determinar el año fiscal de la Cia Contab; un año calendario puede ser // 2013 y el año fiscal 2012. Los saldos contables se registran para el año fiscal. Por esta razón, // debemos obtenerlo *antes* de hacer el select que sigue GetMesFiscalContable MyGetMesFiscalContable = new GetMesFiscalContable(dFechaInicialPeriodoIndicado, ciaContabSeleccionada); string sErrorMessage = ""; // antes usabamos Linq to Sql en vez de EF ... ContabSysNet_Web.ModelosDatos.dbContabDataContext ContabDB = new ContabSysNet_Web.ModelosDatos.dbContabDataContext(); MyGetMesFiscalContable.dbContabDataContext = ContabDB; if (!MyGetMesFiscalContable.DeterminarMesFiscal(ref sErrorMessage)) { ContabDB.Dispose(); ErrMessage_Span.InnerHtml = sErrorMessage; ErrMessage_Span.Style["display"] = "block"; return; } int anoFiscalCiaSeleccionada = MyGetMesFiscalContable.AnoFiscal; // ------------------------------------------------------------------------------------------------------------------------------ // como vamos a usar esta conexión mientras se ejecute el ciclo que viene, la abrimos aquí y la cerramos al final ... SqlConnection sqlConnection = new SqlConnection(); sqlConnection.ConnectionString = ConfigurationManager.ConnectionStrings["dbContabConnectionString"].ConnectionString; sqlConnection.Open(); // ----------------------------------------------------------------------------------------------------- // usamos esta clase para leer los movimientos (debe, haber) para cada cuenta contable y moneda DeterminarMovimientoCuentaContable determinarMovimientoCuentaContable = new DeterminarMovimientoCuentaContable(sqlConnection, bExcluirAsientosTipoCierreAnual, bReconvertirCifrasAntes_01Oct2021, bExcluirAsientosReconversion_01Oct2021, dFechaInicialPeriodoIndicado, dFechaFinalPeriodoIndicado, monedaNacional.Moneda); // ----------------------------------------------------------------------------------------------------- // primero determinamos la cantidad de registros, para mostrar progreso al usuario // NOTA IMPORTANTE: usamos el año para leer en la tabla SaldosContables SOLO cuentas/monedas/cias que // corresopondan al año indicado. Recuérdese que una cuenta/moneda/cia puede tener MUCHOS registros // en SaldosContables, uno para cada año. SIN EMBARGO, deberíamos usar el año fiscal y no el año de // la fecha inicial del período (año calendario). Lo hacemos así, sabiendo que muy pocas veces ésto // tendrá un efecto importante en el proceso. Creo que bastaría con hacer un cierre contable anual en // los casos en que el efecto exista // ---------------------------------------------------------------------- // ahora ejecutamos el query para que regrese los rows uno a uno // leemos las cuentas contables y todos sus datos de compañías, grupos, monedas, etc. Nótese que leemos // SOLO las que tienen un registro en SaldosContables y para el año de la fecha de inicio. La idea es // solo traernos cuentas que tengan un registro en SaldosContables, no leer su saldo, lo cual hacemos // más adelante, para cada una, en el loop que sigue // nótese como cambiamos el Select que sigue, para eliminar la tabla SaldosContables de la // sección Inner Join. La razón es que, a veces, puede ocurrir que una cuenta tiene asientos // más no tiene un registro en SaldosContables. Imaginamos que ésto puede ocurrir cuando una // cuenta se usa por 1ra. vez y no se ha corrido el cierre contable aún para el mes del reporte. // ordenamos por CiaContab para que la lista que resulta de aquí también lo esté sSqlQueryString = "Select Distinct CuentasContables.ID As CuentaContableID, CuentasContables.Cuenta As CuentaContable, " + "CuentasContables.Descripcion As NombreCuentaContable, " + "tGruposContables.Grupo As GrupoContable, " + "tGruposContables.Descripcion As NombreGrupoContable, " + "IsNull(tGruposContables.OrdenBalanceGeneral, 0) As GrupoContable_OrdenBalance, " + "CuentasContables.Cia As CiaContab, Companias.NombreCorto As NombreCiaContab, " + "CuentaEditada As CuentaContableEditada, Monedas.Moneda, Monedas.Descripcion As " + "NombreMoneda, " + "Monedas.Simbolo As SimboloMoneda, " + "Case NumNiveles When 2 Then Nivel1 When 3 Then Nivel1 + Nivel2 When 4 Then Nivel1 + " + "Nivel2 + Nivel3 " + "When 5 Then Nivel1 + Nivel2 + Nivel3 + Nivel4 When 6 Then Nivel1 + " + "Nivel2 + Nivel3 + Nivel4 + Nivel5 " + "When 7 Then Nivel1 + Nivel2 + Nivel3 + Nivel4 + Nivel5 + Nivel6 End AS " + "CuentaContable_NivelPrevio, " + "Nivel1, Nivel2, Nivel3, Nivel4, Nivel5, Nivel6, NumNiveles " + "From CuentasContables " + "Inner Join Companias On CuentasContables.Cia = Companias.Numero " + "Inner Join SaldosContables On CuentasContables.ID = SaldosContables.CuentaContableID " + "Inner Join Monedas On SaldosContables.Moneda = Monedas.Moneda " + "Inner Join tGruposContables On CuentasContables.Grupo = tGruposContables.Grupo " + "Where CuentasContables.TotDet = 'D' And SaldosContables.Ano = " + anoFiscalCiaSeleccionada.ToString() + " And " + Session["FiltroForma"].ToString() + " Order by CuentasContables.Cia"; List <CuentaContable_Object> query = dbContext.ExecuteStoreQuery <CuentaContable_Object>(sSqlQueryString).ToList(); if (query.Count() == 0) { Session["Thread_ErrorMessage"] = "No existen registros que cumplan el criterio de selección " + "(filtro) que Ud. ha indicado. <br /> Para regresar registros, " + "Ud. puede intentar un filtro diferente al que ha indicado."; Session["Progress_SelectedRecs"] = 0; Session["Progress_Completed"] = 1; Session["Progress_Percentage"] = 0; return; } // --------------------------------------------------------------------------------------------- // variables usadas para mostrar el meter en la página ... int nCantidadRegistros = query.Count(); int nRegistroActual = 0; int nProgreesPercentaje = 0; string nombreUsuario = Membership.GetUser().UserName; Session["Progress_SelectedRecs"] = 0; // --------------------------------------------------------------------------------------------- List <BalanceComprobacion_Item> MyBalanceComprobacion_Lista = new List <BalanceComprobacion_Item>(); BalanceComprobacion_Item MyBalanceComprobacion_Record; foreach (CuentaContable_Object MyComprobanteContable_Query in query) { MyBalanceComprobacion_Record = new BalanceComprobacion_Item(); MyBalanceComprobacion_Record.CuentaContableID = MyComprobanteContable_Query.CuentaContableID; MyBalanceComprobacion_Record.Moneda = MyComprobanteContable_Query.Moneda; MyBalanceComprobacion_Record.NivelPrevioCuentaContable = MyComprobanteContable_Query.CuentaContable_NivelPrevio; MyBalanceComprobacion_Record.Cia = MyComprobanteContable_Query.CiaContab; // nótese como agregamos todos los niveles 'previos' de la cuenta, para poder totalizar por éstos en el reporte ... switch (MyComprobanteContable_Query.NumNiveles) { case 2: MyBalanceComprobacion_Record.nivel1 = MyComprobanteContable_Query.Nivel1; break; case 3: MyBalanceComprobacion_Record.nivel1 = MyComprobanteContable_Query.Nivel1; MyBalanceComprobacion_Record.nivel2 = MyBalanceComprobacion_Record.nivel1 + MyComprobanteContable_Query.Nivel2; break; case 4: MyBalanceComprobacion_Record.nivel1 = MyComprobanteContable_Query.Nivel1; MyBalanceComprobacion_Record.nivel2 = MyBalanceComprobacion_Record.nivel1 + MyComprobanteContable_Query.Nivel2; MyBalanceComprobacion_Record.nivel3 = MyBalanceComprobacion_Record.nivel2 + MyComprobanteContable_Query.Nivel3; break; case 5: MyBalanceComprobacion_Record.nivel1 = MyComprobanteContable_Query.Nivel1; MyBalanceComprobacion_Record.nivel2 = MyBalanceComprobacion_Record.nivel1 + MyComprobanteContable_Query.Nivel2; MyBalanceComprobacion_Record.nivel3 = MyBalanceComprobacion_Record.nivel2 + MyComprobanteContable_Query.Nivel3; MyBalanceComprobacion_Record.nivel4 = MyBalanceComprobacion_Record.nivel3 + MyComprobanteContable_Query.Nivel4; break; case 6: MyBalanceComprobacion_Record.nivel1 = MyComprobanteContable_Query.Nivel1; MyBalanceComprobacion_Record.nivel2 = MyBalanceComprobacion_Record.nivel1 + MyComprobanteContable_Query.Nivel2; MyBalanceComprobacion_Record.nivel3 = MyBalanceComprobacion_Record.nivel2 + MyComprobanteContable_Query.Nivel3; MyBalanceComprobacion_Record.nivel4 = MyBalanceComprobacion_Record.nivel3 + MyComprobanteContable_Query.Nivel4; MyBalanceComprobacion_Record.nivel5 = MyBalanceComprobacion_Record.nivel4 + MyComprobanteContable_Query.Nivel5; break; case 7: MyBalanceComprobacion_Record.nivel1 = MyComprobanteContable_Query.Nivel1; MyBalanceComprobacion_Record.nivel2 = MyBalanceComprobacion_Record.nivel1 + MyComprobanteContable_Query.Nivel2; MyBalanceComprobacion_Record.nivel3 = MyBalanceComprobacion_Record.nivel2 + MyComprobanteContable_Query.Nivel3; MyBalanceComprobacion_Record.nivel4 = MyBalanceComprobacion_Record.nivel3 + MyComprobanteContable_Query.Nivel4; MyBalanceComprobacion_Record.nivel5 = MyBalanceComprobacion_Record.nivel4 + MyComprobanteContable_Query.Nivel5; MyBalanceComprobacion_Record.nivel6 = MyBalanceComprobacion_Record.nivel5 + MyComprobanteContable_Query.Nivel6; break; } MyBalanceComprobacion_Lista.Add(MyBalanceComprobacion_Record); // -------------------------------------------------------------------------------------- // ... para reportar el progreso al usuario; la página ejecuta un ws que lee el valor de // estas session variables nRegistroActual += 1; nProgreesPercentaje = nRegistroActual * 100 / nCantidadRegistros; Session["Progress_Percentage"] = nProgreesPercentaje; Session["Progress_SelectedRecs"] = (int)Session["Progress_SelectedRecs"] + 1; } // --------------------------------------------------------------------------------- // recorremos la lista para determinar saldo anterior, debe, haber y saldo actual // ----------------------------------------------------------------- // determinamos la cantidad de registros para el progress al usuario nCantidadRegistros = MyBalanceComprobacion_Lista.Count(); // ----------------------------------------------------------------- nRegistroActual = 0; Session["Progress_Percentage"] = 0; int nCiaContabAnterior = -999999; int nMesFiscal = 0; int nAnoFiscal = 0; int nMesCalendario = 0; int nAnoCalendario = 0; string sNombreMes = ""; System.DateTime dFechaSaldoInicial; Session["Progress_SelectedRecs"] = 0; foreach (BalanceComprobacion_Item MyBalanceComprobacion_Record2 in MyBalanceComprobacion_Lista.OrderBy(b => b.Cia)) { if (MyBalanceComprobacion_Record2.Cia != nCiaContabAnterior) { // buscamos el mes y año fiscal solo cuando cambian las compañías MyGetMesFiscalContable = new GetMesFiscalContable(dFechaInicialPeriodoIndicado, MyBalanceComprobacion_Record2.Cia); sErrorMessage = ""; MyGetMesFiscalContable.dbContabDataContext = ContabDB; if (!MyGetMesFiscalContable.DeterminarMesFiscal(ref sErrorMessage)) { ContabDB.Dispose(); ErrMessage_Span.InnerHtml = sErrorMessage; ErrMessage_Span.Style["display"] = "block"; return; } nMesFiscal = MyGetMesFiscalContable.MesFiscal; nAnoFiscal = MyGetMesFiscalContable.AnoFiscal; nMesCalendario = MyGetMesFiscalContable.MesCalendario; nAnoCalendario = MyGetMesFiscalContable.AnoCalendario; sNombreMes = MyGetMesFiscalContable.NombreMes; dFechaSaldoInicial = MyGetMesFiscalContable.FechaSaldo; nCiaContabAnterior = MyBalanceComprobacion_Record2.Cia; } // determinamos el saldo anterior de cada cuenta (GetSaldoContable es una clase que está en: old_app_code/Generales2.cs) GetSaldoContable MyGetSaldoContable = new GetSaldoContable(MyBalanceComprobacion_Record2.CuentaContableID, nMesFiscal, nAnoFiscal, dFechaInicialPeriodoIndicado, MyBalanceComprobacion_Record2.Moneda, MyBalanceComprobacion_Record2.Cia, bReconvertirCifrasAntes_01Oct2021, monedaNacional.Moneda); MyGetSaldoContable.bLeerSaldoCuenta(); decimal nSaldoAnteriorContable = MyGetSaldoContable.SaldoAnterior; MyBalanceComprobacion_Record2.SaldoAnterior = nSaldoAnteriorContable; // este método lee los movimientos para la cuenta, la moneda y el período var result = determinarMovimientoCuentaContable.leerMovimientoCuentaContable(MyBalanceComprobacion_Record2.CuentaContableID, MyBalanceComprobacion_Record2.Moneda); MyBalanceComprobacion_Record2.Debe = result.sumDebe; MyBalanceComprobacion_Record2.Haber = result.sumHaber; MyBalanceComprobacion_Record2.CantidadMovimientos = result.recCount; // -------------------------------------------------------------------------------------------------------------------- // por último, leemos la descripción del 'nivel previo' de la cuenta string selectDescripcionNivelPrevio = "Select Descripcion From CuentasContables Where Cuenta = {0} And Cia = {1}"; object[] parameters = { MyBalanceComprobacion_Record2.NivelPrevioCuentaContable, MyBalanceComprobacion_Record2.Cia }; string sCuentaContable_NivelPrevio_Descripcion = dbContext.ExecuteStoreQuery <string>(selectDescripcionNivelPrevio, parameters).FirstOrDefault(); MyBalanceComprobacion_Record2.NivelPrevioCuentaContable_Nombre = sCuentaContable_NivelPrevio_Descripcion; MyBalanceComprobacion_Record2.SaldoActual = MyBalanceComprobacion_Record2.SaldoAnterior + MyBalanceComprobacion_Record2.Debe - MyBalanceComprobacion_Record2.Haber; // -------------------------------------------------------------------------------------- // para mostrar el progreso al usuario nRegistroActual += 1; nProgreesPercentaje = nRegistroActual * 100 / nCantidadRegistros; Session["Progress_Percentage"] = nProgreesPercentaje; Session["Progress_SelectedRecs"] = (int)Session["Progress_SelectedRecs"] + 1; } // tenemos los niveles 'previos' de cada cuenta; vamos a crear una lista con las descripciones de cada cuenta, para luego // leer las mismas y completar los niveles previos en la lista. Para cada nivel, ej: 0101002, quedará así: 0101002 - <su descripción> ... var queryCuentasContables = dbContext.CuentasContables.Where(c => c.TotDet == "T" && c.Cia == ciaContabSeleccionada).Select(c => new { c.Cuenta, c.Descripcion }); List <Cuenta_Nombre> listaCuentasYNombres = new List <Cuenta_Nombre>(); foreach (var cuenta in queryCuentasContables) { listaCuentasYNombres.Add(new Cuenta_Nombre { cuenta = cuenta.Cuenta, descripcion = cuenta.Descripcion }); } // ahora recorremos la lista y buscamos la descripción de cada cuenta contable foreach (BalanceComprobacion_Item item in MyBalanceComprobacion_Lista) { if (item.nivel1 != null) { if (listaCuentasYNombres.Where(c => c.cuenta == item.nivel1).Count() > 0) { item.nivel1 += " - " + listaCuentasYNombres.Where(c => c.cuenta == item.nivel1).First().descripcion; } } if (item.nivel2 != null) { if (listaCuentasYNombres.Where(c => c.cuenta == item.nivel2).Count() > 0) { item.nivel2 += " - " + listaCuentasYNombres.Where(c => c.cuenta == item.nivel2).First().descripcion; } } if (item.nivel3 != null) { if (listaCuentasYNombres.Where(c => c.cuenta == item.nivel3).Count() > 0) { item.nivel3 += " - " + listaCuentasYNombres.Where(c => c.cuenta == item.nivel3).First().descripcion; } } if (item.nivel4 != null) { if (listaCuentasYNombres.Where(c => c.cuenta == item.nivel4).Count() > 0) { item.nivel4 += " - " + listaCuentasYNombres.Where(c => c.cuenta == item.nivel4).First().descripcion; } } if (item.nivel5 != null) { if (listaCuentasYNombres.Where(c => c.cuenta == item.nivel5).Count() > 0) { item.nivel5 += " - " + listaCuentasYNombres.Where(c => c.cuenta == item.nivel5).First().descripcion; } } if (item.nivel6 != null) { if (listaCuentasYNombres.Where(c => c.cuenta == item.nivel6).Count() > 0) { item.nivel6 += " - " + listaCuentasYNombres.Where(c => c.cuenta == item.nivel6).First().descripcion; } } } // agregamos el contenido de la lista a la tabla Contab_BalanceComprobacion contabBalanceComprobacionItem; foreach (BalanceComprobacion_Item item in MyBalanceComprobacion_Lista) { contabBalanceComprobacionItem = new Contab_BalanceComprobacion() { CuentaContableID = item.CuentaContableID, Moneda = item.Moneda, CuentaContable_NivelPrevio = item.NivelPrevioCuentaContable, CuentaContable_NivelPrevio_Descripcion = item.NivelPrevioCuentaContable_Nombre, nivel1 = item.nivel1, nivel2 = item.nivel2, nivel3 = item.nivel3, nivel4 = item.nivel4, nivel5 = item.nivel5, nivel6 = item.nivel6, SaldoAnterior = item.SaldoAnterior, Debe = item.Debe, Haber = item.Haber, SaldoActual = item.SaldoActual, CantidadMovimientos = item.CantidadMovimientos, NombreUsuario = nombreUsuario }; dbContext.Contab_BalanceComprobacion.AddObject(contabBalanceComprobacionItem); } try { dbContext.SaveChanges(); } catch (Exception ex) { errorMessage = ex.Message; if (ex.InnerException != null) { errorMessage += "<br />" + ex.InnerException.Message; } Session["Thread_ErrorMessage"] = "Ha ocurrido un error al intentar ejecutar una operación de " + "acceso a la base de datos. <br /> El mensaje específico de error es: " + errorMessage + "<br />"; Session["Progress_Completed"] = 1; Session["Progress_Percentage"] = 0; return; } // ------------------------------------------------------------------------------------------ // por último, eliminamos las cuentas seleccionadas de acuerdo al criterio indicado en las opciones if (!(bool)Session["MostrarCuentasSinSaldoYSinMvtos"]) { dbContext.ExecuteStoreCommand("Delete From Contab_BalanceComprobacion Where SaldoAnterior = 0 And CantidadMovimientos = 0 And NombreUsuario = {0}", nombreUsuario); } if (!(bool)Session["MostrarCuentasConSaldoYSinMvtos"]) { dbContext.ExecuteStoreCommand("Delete From Contab_BalanceComprobacion Where SaldoAnterior <> 0 And CantidadMovimientos = 0 And NombreUsuario = {0}", nombreUsuario); } if (!(bool)Session["MostrarCuentasSaldosEnCero"]) { dbContext.ExecuteStoreCommand("Delete From Contab_BalanceComprobacion Where SaldoAnterior = 0 And SaldoActual = 0 And NombreUsuario = {0}", nombreUsuario); } if (!(bool)Session["MostrarCuentasSaldoFinalEnCero"]) { dbContext.ExecuteStoreCommand("Delete From Contab_BalanceComprobacion Where SaldoActual = 0 And NombreUsuario = {0}", nombreUsuario); } dbContext.Dispose(); // ----------------------------------------------------- // por último, inicializamos las variables que se usan // para mostrar el progreso de la tarea Session["Progress_Completed"] = 1; Session["Progress_Percentage"] = 0; // ----------------------------------------------------- }
private void RefreshAndBindInfo() { if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (Session["FiltroForma"] == null) { CustomValidator1.IsValid = false; CustomValidator1.ErrorMessage = "Aparentemente, Ud. no ha indicado un filtro aún.<br />Por favor indique y aplique un filtro antes " + "de intentar mostrar el resultado de la consulta."; return; } // nótese como hacemos también el databinding de los dos combos, cada vez que el usuario cambia el filtro; la // razón es que el contenido de ambos combos depende del resultado del query ... this.MonedasFilter_DropDownList.DataBind(); this.CompaniasFilter_DropDownList.DataBind(); // --------------------------------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión *solo* a esta moneda var monedaNacional_result = Reconversion.Get_MonedaNacional(); if (monedaNacional_result.error) { CustomValidator1.IsValid = false; CustomValidator1.ErrorMessage = monedaNacional_result.message; return; } Monedas monedaNacional = monedaNacional_result.moneda; // --------------------------------------------------------------------------------------------------------------------------------------------- ContabContext contabContext = new ContabContext(); string filter = ConstruirFiltro(contabContext); // el usuario indica en el filtro si desea reconvertir cifras anteriores al 1/Oct/2.021 bool bReconvertirCifrasAntes_01Oct2021 = (bool)Session["ReconvertirCifrasAntes_01Oct2021"]; int moneda = (int)Session["monedaSeleccionada"]; // las fechas vienen como Dates en el Session; en realidad como Objects; por eso se deben convertir a Dates DateTime fechaInicialPeriodo = (DateTime)Session["fechaInicialPeriodo"]; DateTime fechaFinalPeriodo = (DateTime)Session["fechaFinalPeriodo"]; string sFechaInicialPeriodo = fechaInicialPeriodo.ToString("yyyy-MM-dd"); string sFechaFinalPeriodo = fechaFinalPeriodo.ToString("yyyy-MM-dd"); string query = ""; // aplicamos la reconversión *solo* cuando: el usuario lo indicó, la moneda es Bs y la la fecha de inicio es anterior al 1/Oct if (!bReconvertirCifrasAntes_01Oct2021 || (moneda != monedaNacional.Moneda) || fechaInicialPeriodo >= new DateTime(2021, 10, 1)) { // no se va a reconvertir: hacemos el query en forma usual query = "Select a.NumeroAutomatico as numeroAutomatico, a.Numero as numero, d.Partida, c.Cuenta as cuentaContable, " + "c.Descripcion as cuentaContableDescripcion, a.Fecha as fecha, d.Descripcion as descripcion, " + "d.Referencia as referencia, a.ProvieneDe as provieneDe, " + "d.Debe as debe, d.Haber as haber, a.Usuario as usuario, " + "m.Simbolo as monedaSimbolo, mo.Simbolo as monedaOriginalSimbolo, " + "d.Debe as debe, d.Haber as haber, " + "cc.DescripcionCorta as centrosCostoDescripcion, comp.Abreviatura as companiaAbreviatura " + "From dAsientos d Inner Join Asientos a On d.NumeroAutomatico = a.NumeroAutomatico " + "Inner Join CuentasContables c On d.CuentaContableID = c.ID " + "Inner Join Monedas m On a.Moneda = m.Moneda " + "Inner Join Monedas mo On a.MonedaOriginal = mo.Moneda " + "Inner Join Companias comp On a.Cia = comp.Numero " + "Left Outer Join CentrosCosto cc On d.CentroCosto = cc.CentroCosto " + $"Where (a.Fecha Between '{sFechaInicialPeriodo}' And '{sFechaFinalPeriodo}') And " + $"{filter} " + " And (d.Referencia <> 'Reconversión 2021') " + "Order By a.Fecha, a.Numero"; } else { // se va a reconvertir: agregamos un Union al query para lograr la reconversión de las cifras anteriores a 1/Oct/21 // este es el período *hasta* el 1ro/Oct: reconvertimos query = "Select a.NumeroAutomatico as numeroAutomatico, a.Numero as numero, d.Partida, c.Cuenta as cuentaContable, " + "c.Descripcion as cuentaContableDescripcion, a.Fecha as fecha, d.Descripcion as descripcion, " + "d.Referencia as referencia, a.ProvieneDe as provieneDe, " + "Round((d.Debe / 1000000), 2) as debe, Round((d.Haber / 1000000), 2) as haber, " + "a.Usuario as usuario, " + "m.Simbolo as monedaSimbolo, mo.Simbolo as monedaOriginalSimbolo, " + "d.Debe as debe, d.Haber as haber, " + "cc.DescripcionCorta as centrosCostoDescripcion, comp.Abreviatura as companiaAbreviatura " + "From dAsientos d Inner Join Asientos a On d.NumeroAutomatico = a.NumeroAutomatico " + "Inner Join CuentasContables c On d.CuentaContableID = c.ID " + "Inner Join Monedas m On a.Moneda = m.Moneda " + "Inner Join Monedas mo On a.MonedaOriginal = mo.Moneda " + "Inner Join Companias comp On a.Cia = comp.Numero " + "Left Outer Join CentrosCosto cc On d.CentroCosto = cc.CentroCosto " + $"Where (a.Fecha Between '{sFechaInicialPeriodo}' And '2021-09-30') And " + $"{filter} " + "Union " + // este es el período *desde* el 1ro/Oct: no reconvertimos "Select a.NumeroAutomatico as numeroAutomatico, a.Numero as numero, d.Partida, c.Cuenta as cuentaContable, " + "c.Descripcion as cuentaContableDescripcion, a.Fecha as fecha, d.Descripcion as descripcion, " + "d.Referencia as referencia, a.ProvieneDe as provieneDe, " + "d.Debe as debe, d.Haber as haber, a.Usuario as usuario, " + "m.Simbolo as monedaSimbolo, mo.Simbolo as monedaOriginalSimbolo, " + "d.Debe as debe, d.Haber as haber, " + "cc.DescripcionCorta as centrosCostoDescripcion, comp.Abreviatura as companiaAbreviatura " + "From dAsientos d Inner Join Asientos a On d.NumeroAutomatico = a.NumeroAutomatico " + "Inner Join CuentasContables c On d.CuentaContableID = c.ID " + "Inner Join Monedas m On a.Moneda = m.Moneda " + "Inner Join Monedas mo On a.MonedaOriginal = mo.Moneda " + "Inner Join Companias comp On a.Cia = comp.Numero " + "Left Outer Join CentrosCosto cc On d.CentroCosto = cc.CentroCosto " + $"Where (a.Fecha Between '2021-10-1' And '{sFechaFinalPeriodo}') And " + $"{filter} " + " And (d.Referencia <> 'Reconversión 2021') " + "Order By a.Fecha, a.Numero"; } // cambiamos los nombres de las tablas pues se abrevian en el query query = query.Replace("dAsientos.", "d."); query = query.Replace("Asientos.", "a."); query = query.Replace("CuentasContables.", "c."); query = query.Replace("CentrosCosto.", "cc."); //var partidas = contabContext.dAsientos.SqlQuery(query); this.SqlDataSource1.SelectCommand = query; this.MovimientosContables_GridView.DataBind(); }
private void CrearInfoReport( string sqlServerWhereString, short mesConsulta, short anoConsulta, bool excluirDepAnosAnteriores, bool aplicarInfoDesincorporados, bool bReconvertirCifrasAntes_01Oct2021) { // en este Sub agregamos los registros a la tabla 'temporal' en la base de datos para que la // página que sigue los muestre al usuario en un DataGridView if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } // convertimos el mes y año de la consulta en una fecha (siempre último de cada mes) DateTime fechaConsulta = new DateTime(anoConsulta, mesConsulta, 1).AddMonths(1).AddDays(-1); DateTime fechaInicioAno = new DateTime(anoConsulta, 1, 31); dbContab_ActFijos_Entities activosFijos_dbcontext = new dbContab_ActFijos_Entities(); try { // ---------------------------------------------------------------------------------------- // eliminamos los registros anteriores de la tabla 'temporal' string sqlTransactCommand = "Delete From tTempActivosFijos_ConsultaDepreciacion Where NombreUsuario = {0}"; activosFijos_dbcontext.ExecuteStoreCommand(sqlTransactCommand, new object[] { User.Identity.Name }); } catch (Exception ex) { activosFijos_dbcontext.Dispose(); ErrMessage_Span.InnerHtml = "Ha ocurrido un error al intentar ejecutar una operación de acceso a la base de datos. <br /> " + "El mensaje específico de error es: " + ex.Message + "<br /><br />"; ErrMessage_Span.Style["display"] = "block"; return; } // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { ErrMessage_Span.InnerHtml = monedaNacional_return.message; ErrMessage_Span.Style["display"] = "block"; return; } Monedas monedaNacional = monedaNacional_return.moneda; // ---------------------------------------------------------------------------------------------------------------------- int cantidadRegistrosAgregados = 0; // nótese como seleccionamos solo los que se deprecien *luego* de la fecha de la consulta ... var query = from a in activosFijos_dbcontext.InventarioActivosFijos. Include("Compania"). Include("tDepartamento"). Include("TiposDeProducto"). Include("Moneda1"). Where(sqlServerWhereString) // en escencia, eliminamos los que aún no se comienzan a depreciar ... where (a.DepreciarDesdeAno < anoConsulta) || (a.DepreciarDesdeAno == anoConsulta && a.DepreciarDesdeMes <= mesConsulta) select a; tTempActivosFijos_ConsultaDepreciacion infoDepreciacion; // para cada activo leído, convertimos su inicio y fin de depreciación en fechas (siempre último de cada mes) DateTime fechaInicioDepreciacion; DateTime fechaFinDepreciacion; // solo para activos fijos *desincorporados* y cuando el usuario *marca* la opción que permite aplicar este mecanismo, // recalculamos los valores para: vida útil en meses del activo (CantidadMesesADepreciar) y monto total a depreciar (MontoADepreciar) short cantidadMesesADepreciar = 0; decimal montoADepreciar = 0; decimal montoDepreciacionMensual = 0; int ciaContabAnterior = -99999; DateTime fechaInicioAnoFiscal = new DateTime(); string errorMessage = ""; foreach (var a in query.OrderBy(i => i.Cia)) { cantidadMesesADepreciar = a.CantidadMesesADepreciar; // nóta: hemos encontrado que el usuario puede equivocarse aquí; mejor calculamos montoADepreciar = a.MontoADepreciar; montoDepreciacionMensual = a.MontoDepreciacionMensual; // -------------------------------------------------------------------------------------------------------------------------------------- // si el usuario indica que quiere reconvertir activos anteriores al mes Oct/2.021, aplicamos la reconversión if (bReconvertirCifrasAntes_01Oct2021 && (a.FechaCompra < new DateTime(2021, 10, 1)) && (a.Moneda1.Moneda1 == monedaNacional.Moneda)) { montoADepreciar = Math.Round((montoADepreciar / 1000000), 2); montoDepreciacionMensual = Math.Round((montoDepreciacionMensual / 1000000), 2); } try { // determinamos la fecha de inicio de depreciación, como el 1er. día del mes 'a depreciar'; de esta forma, parece que los // activos cuya depreciación se inicia en el año de la consulta, se calcula de forma correcta ... fechaInicioDepreciacion = new DateTime(a.DepreciarDesdeAno, a.DepreciarDesdeMes, 1); fechaFinDepreciacion = new DateTime(a.DepreciarHastaAno, a.DepreciarHastaMes, 1).AddMonths(1).AddDays(-1); cantidadMesesADepreciar = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); // nótese que aquí recalculamos ... } catch (Exception ex) { errorMessage = ex.Message; if (ex.InnerException != null) { errorMessage += "<br />" + ex.InnerException.Message; } ErrMessage_Span.InnerHtml = "Ha ocurrido un error mientras se efectuaba el proceso para el activo '" + a.Producto + "' - " + a.Descripcion + " (en la Cia Contab " + a.Compania.Abreviatura + ").<br />" + "Por favor revise los datos de registro de este activo y corríjalos de ser necesario. " + "Luego regrese y reintente ejecutar este proceso.<br /><br />" + "El mensaje específico de error es: " + errorMessage; ErrMessage_Span.Style["display"] = "block"; return; } if (aplicarInfoDesincorporados) { if (a.DesincorporadoFlag != null && a.DesincorporadoFlag.Value) { // cuando un activo es desincorporado, debe ser depreciado hasta el mes anterior a la desincorporación ... if (a.FechaDesincorporacion != null) { // nos aseguramos que la fecha de desincorporación sea *anterior* a la fecha de fin de depreciación ... if ((a.FechaDesincorporacion.Value.Year < a.DepreciarHastaAno) || (a.FechaDesincorporacion.Value.Year == a.DepreciarHastaAno && a.FechaDesincorporacion.Value.Month < a.DepreciarHastaMes)) { // desincorporados: depreciamos hasta el mes *anterior* a la desincorporación ... DateTime fechaDepreciarHasta = a.FechaDesincorporacion.Value.AddMonths(-1); // al igual que arriba, calculamos el último día del mes para la fecha anterior ... fechaFinDepreciacion = new DateTime(fechaDepreciarHasta.Year, fechaDepreciarHasta.Month, 1).AddMonths(1).AddDays(-1); // ahora recalculamos los valores indicados arriba, y que deben ser recalculados para activos desincorporados // (nótese que un activo desincorporado es, en efecto, depreciado por una cantidad *menor* de meses que los originalmente anticipados) cantidadMesesADepreciar = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); montoADepreciar = cantidadMesesADepreciar * a.MontoDepreciacionMensual; } } } } // en lo sucesivo, calculamos cantidades de meses ... int cantidadMesesAcumulados; int cantidadMesesEnElAno; // calculamos la cantidad de meses de vida del activo; // si el activo ha culminado su vida útil, la cantidad de meses de vida es su vida completa; // de otra forma, calculamos la cantidad de meses desde su inicio hasta la fecha de consulta ... if (fechaFinDepreciacion < fechaConsulta) { cantidadMesesAcumulados = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); } else { cantidadMesesAcumulados = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaConsulta); } // ==================================================================================================================================== // ahora determinamos la cantidad de meses en el año en curso // TODO: nótese como esta cantidad de meses depende del año fiscal de la empresa. El año puede ser igual al // año calendario, pero también puede ser diferente; ejemplo: Marzo a Febrero ... // // obtenemos la fecha inicial del año fiscal solo cuando cambia la cia contab; nota: en teoría, esta consulta, al menos por ahora, // puede ser obtenida para más de una cia contab if (a.Cia != ciaContabAnterior) { if (!ObtenerFechaInicioAnoFiscal(fechaConsulta, a.Cia, out fechaInicioAnoFiscal, out errorMessage)) { ErrMessage_Span.InnerHtml = "Ha ocurrido un error mientras se ejecutaba el proceso para esta consulta. <br /><br />" + "El mensaje específico de error es: " + errorMessage; ErrMessage_Span.Style["display"] = "block"; return; } ciaContabAnterior = a.Cia; } // ------------------------------------------------------------------------------ // TODO: sustituir ahora fechaInicioAno por fechaInicioAnoFiscal // nota: recuérdese que, al determinar la fecha de inicio del año fiscal, nos aseguramos que fuera siempre // *anterior* a la fecha de la consulta ... DateTime fechaInicioAnoFiscal1erDiaMes = new DateTime(fechaInicioAnoFiscal.Year, fechaInicioAnoFiscal.Month, 1); // porque se calculó el 31 ... if (fechaFinDepreciacion < fechaInicioAnoFiscal1erDiaMes) { // el activo se depreció en años (fiscales) anteriores cantidadMesesEnElAno = 0; } else // tomamos en cuenta que el activo pudo haberse comprado *luego* del inicio del año ... if (fechaInicioDepreciacion > fechaInicioAnoFiscal1erDiaMes) { if (fechaFinDepreciacion >= fechaConsulta) { // el activo se deprecia hasta después de la fecha de la consulta; la cantidad de meses en el año fiscal es simple: // desde inicio año fiscal hasta fecha consulta ... cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaConsulta); } else { // el activo se deprecia en el período que va: desde el inicio del año fiscal hasta la fecha de la consulta cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); } } else if (fechaFinDepreciacion >= fechaConsulta) { // el activo se deprecia hasta después de la fecha de la consulta; la cantidad de meses en el año fiscal es simple: // desde inicio año fiscal hasta fecha consulta ... cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioAnoFiscal1erDiaMes, fechaConsulta); } else { // el activo se deprecia en el período que va: desde el inicio del año fiscal hasta la fecha de la consulta cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioAnoFiscal1erDiaMes, fechaFinDepreciacion); } // ==================================================================================================================================== infoDepreciacion = new tTempActivosFijos_ConsultaDepreciacion(); // guardamos estos *cuatro* items en la tabla temporal, pues pueden cambiar sus valores originales cuando un // activo es desincorporado ... infoDepreciacion.CantidadMesesADepreciar = cantidadMesesADepreciar; infoDepreciacion.MontoADepreciar = montoADepreciar; infoDepreciacion.DepreciarHastaMes = (short)fechaFinDepreciacion.Month; infoDepreciacion.DepreciarHastaAno = (short)fechaFinDepreciacion.Year; infoDepreciacion.ActivoFijoID = a.ClaveUnica; if (fechaFinDepreciacion < fechaConsulta) { infoDepreciacion.DepreciacionMensual = 0; } else { infoDepreciacion.DepreciacionMensual = montoDepreciacionMensual; } infoDepreciacion.DepAcum_CantMeses = Convert.ToInt16(cantidadMesesAcumulados); infoDepreciacion.DepAcum_CantMeses_AnoActual = Convert.ToInt16(cantidadMesesEnElAno); infoDepreciacion.DepAcum_AnoActual = montoDepreciacionMensual * cantidadMesesEnElAno; infoDepreciacion.DepAcum_Total = montoDepreciacionMensual * cantidadMesesAcumulados; infoDepreciacion.NombreUsuario = User.Identity.Name; // el usuario puede indicar que desea excluir los depreciados en años anteriores if (excluirDepAnosAnteriores && cantidadMesesEnElAno == 0) { continue; } activosFijos_dbcontext.tTempActivosFijos_ConsultaDepreciacion.AddObject(infoDepreciacion); cantidadRegistrosAgregados++; } try { activosFijos_dbcontext.SaveChanges(); } catch (Exception ex) { ErrMessage_Span.InnerHtml = "Ha ocurrido un error al intentar ejecutar una operación de acceso a la base de datos. <br /> " + "El mensaje específico de error es: " + ex.Message + "<br /><br />"; ErrMessage_Span.Style["display"] = "block"; return; } finally { // determinamos la cantidad de items agregados para el usuario Int32 numRecs = activosFijos_dbcontext.tTempActivosFijos_ConsultaDepreciacion.Count(u => u.NombreUsuario == User.Identity.Name); activosFijos_dbcontext.Dispose(); // para mostrar la cantidad de registros seleccionados this.selectedRecs_p.InnerHtml = $" {numRecs.ToString()} registros seleccionados ..."; this.selectedRecs_div.Style["display"] = "block"; } }
protected void Page_Load(object sender, EventArgs e) { if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (!Page.IsPostBack) { switch (Request.QueryString["rpt"].ToString()) { case "activosFijosDepreciacion": { if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (Request.QueryString["tit"] == null || Request.QueryString["subtit"] == null || Request.QueryString["mes"] == null || Request.QueryString["ano"] == null || Request.QueryString["soloTotales"] == null) { ErrMessage_Cell.InnerHtml = "Aparentemente, Ud. no ha seleccionado aún información para la obtención de este reporte.<br /><br />" + "Probablemente, Ud. no ha definido y aplicado un filtro que permita seleccionar información apropiada para la obtención " + "de este reporte."; break; } // nótese como mantenemos los items mes y año como texto; no necesitamos que sean números en el reporte ... string titutlo = Request.QueryString["tit"].ToString(); string subTitulo = Request.QueryString["subtit"].ToString(); string mes = Request.QueryString["mes"].ToString(); string ano = Request.QueryString["ano"].ToString(); bool soloTotales = Convert.ToBoolean(Request.QueryString["soloTotales"].ToString()); // string que muestra el período (en meses) que va desde el inicio del año fiscal hasta el mes de la consulta; ej: Mar-Ago ... string periodo = ""; if (Request.QueryString["periodo"] != null) { periodo = Request.QueryString["periodo"].ToString(); } // ---------------------------------------------------------------------------------------------------------------------- // agregamos este flag luego de la reconversión del 1-Oct-21 // la idea es que el usuario pueda decidir si reconvertir montos bool bReconvertirCifrasAntes_01Oct2021 = false; if (Session["ReconvertirCifrasAntes_01Oct2021"] != null) { bReconvertirCifrasAntes_01Oct2021 = (bool)Session["ReconvertirCifrasAntes_01Oct2021"]; } // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { ErrMessage_Cell.InnerHtml = monedaNacional_return.message; break; } Monedas monedaNacional = monedaNacional_return.moneda; // ---------------------------------------------------------------------------------------------------------------------- string connectionString = WebConfigurationManager.ConnectionStrings["dbContabConnectionString"].ConnectionString; string query = "Select * From vtTempActivosFijos_ConsultaDepreciacion Where NombreUsuario = @NombreUsuario"; SqlCommand sqlCommand = new SqlCommand(query); sqlCommand.Parameters.AddWithValue("@NombreUsuario", User.Identity.Name); SqlConnection sqlConnnection = new SqlConnection(connectionString); sqlCommand.Connection = sqlConnnection; SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand); DataSet dataSet = new DataSet(); try { sqlConnnection.Open(); sqlDataAdapter.Fill(dataSet, "vtTempActivosFijos_ConsultaDepreciacion"); if (dataSet.Tables[0].Rows.Count == 0) { ErrMessage_Cell.InnerHtml = "No existe información para mostrar el reporte que Ud. ha requerido. <br /><br /> Probablemente Ud. no ha aplicado un filtro y seleccionado información aún."; return; } } catch (Exception ex) { string errorMessage = ex.Message; if (ex.InnerException != null) { errorMessage += "<br /><br />" + ex.InnerException.Message; } ErrMessage_Cell.InnerHtml = "Hemos obtenido un error al intentar efectuar una operación de base de datos. <br />" + "El mensaje específico del error es: <br /><br />" + errorMessage; return; } //finally //{ // sqlConnnection.Close(); //} // ahora preparamos una lista para usarla como DataSource del report ... List <ActivosFijos_Report_ConsultaDepreciacion> myList = new List <ActivosFijos_Report_ConsultaDepreciacion>(); ActivosFijos_Report_ConsultaDepreciacion infoDepreciacion; for (int i = 0; i < dataSet.Tables[0].Rows.Count; i++) { infoDepreciacion = new ActivosFijos_Report_ConsultaDepreciacion(); infoDepreciacion.NombreCiaContab = dataSet.Tables[0].Rows[i]["NombreCiaContab"].ToString(); infoDepreciacion.AbreviaturaCiaContab = dataSet.Tables[0].Rows[i]["AbreviaturaCiaContab"].ToString(); infoDepreciacion.NombreDepartamento = dataSet.Tables[0].Rows[i]["NombreDepartamento"].ToString(); infoDepreciacion.Moneda = Convert.ToInt32(dataSet.Tables[0].Rows[i]["Moneda"]); infoDepreciacion.DescripcionMoneda = dataSet.Tables[0].Rows[i]["DescripcionMoneda"].ToString(); infoDepreciacion.SimboloMoneda = dataSet.Tables[0].Rows[i]["SimboloMoneda"].ToString(); infoDepreciacion.NombreTipoProducto = dataSet.Tables[0].Rows[i]["NombreTipoProducto"].ToString(); infoDepreciacion.Producto = dataSet.Tables[0].Rows[i]["Producto"].ToString(); infoDepreciacion.DescripcionProducto = dataSet.Tables[0].Rows[i]["DescripcionProducto"].ToString(); infoDepreciacion.FechaCompra = Convert.ToDateTime(dataSet.Tables[0].Rows[i]["FechaCompra"]); if (DateTime.TryParse(dataSet.Tables[0].Rows[i]["FechaDesincorporacion"].ToString(), out var temp)) { infoDepreciacion.FechaDesincorporacion = temp; } infoDepreciacion.DepreciarDesde = dataSet.Tables[0].Rows[i]["DepreciarDesde"].ToString(); infoDepreciacion.DepreciarDesdeMes = Convert.ToInt16(dataSet.Tables[0].Rows[i]["DepreciarDesdeMes"]); infoDepreciacion.DepreciarDesdeAno = Convert.ToInt16(dataSet.Tables[0].Rows[i]["DepreciarDesdeAno"]); infoDepreciacion.DepreciarHasta = dataSet.Tables[0].Rows[i]["DepreciarHasta"].ToString(); infoDepreciacion.DepreciarHastaMes = Convert.ToInt16(dataSet.Tables[0].Rows[i]["DepreciarHastaMes"]); infoDepreciacion.DepreciarHastaAno = Convert.ToInt16(dataSet.Tables[0].Rows[i]["DepreciarHastaAno"]); infoDepreciacion.CantidadMesesADepreciar = Convert.ToInt16(dataSet.Tables[0].Rows[i]["CantidadMesesADepreciar"]); infoDepreciacion.DepAcum_CantMeses = Convert.ToInt16(dataSet.Tables[0].Rows[i]["DepAcum_CantMeses"]); infoDepreciacion.DepAcum_CantMeses_AnoActual = Convert.ToInt16(dataSet.Tables[0].Rows[i]["DepAcum_CantMeses_AnoActual"]); if (Int16.TryParse(dataSet.Tables[0].Rows[i]["RestaPorDepreciar_Meses"].ToString(), out var temp1)) { infoDepreciacion.RestaPorDepreciar_Meses = temp1; } infoDepreciacion.CostoTotal = Convert.ToDecimal(dataSet.Tables[0].Rows[i]["CostoTotal"]); infoDepreciacion.MontoADepreciar = Convert.ToDecimal(dataSet.Tables[0].Rows[i]["MontoADepreciar"]); infoDepreciacion.DepreciacionMensual = Convert.ToDecimal(dataSet.Tables[0].Rows[i]["DepreciacionMensual"]); infoDepreciacion.DepAcum_AnoActual = Convert.ToDecimal(dataSet.Tables[0].Rows[i]["DepAcum_AnoActual"]); infoDepreciacion.DepAcum_Total = Convert.ToDecimal(dataSet.Tables[0].Rows[i]["DepAcum_Total"]); if (Decimal.TryParse(dataSet.Tables[0].Rows[i]["RestaPorDepreciar"].ToString(), out var temp2)) { infoDepreciacion.RestaPorDepreciar = temp2; } infoDepreciacion.NombreUsuario = dataSet.Tables[0].Rows[i]["NombreUsuario"].ToString(); myList.Add(infoDepreciacion); } // si el usuario indicó que quería reconvertir montos anteriores a Oct/2021, lo hacemos ahora if (bReconvertirCifrasAntes_01Oct2021) { foreach (var item in myList) { if (item.Moneda == monedaNacional.Moneda && item.FechaCompra < new DateTime(2021, 10, 1)) { item.CostoTotal = Math.Round((item.CostoTotal / 1000000), 2); } } } this.ReportViewer1.LocalReport.ReportPath = "ActivosFijos/Consultas/DepreciacionMensual/ConsultaDepreciacion.rdlc"; ReportDataSource myReportDataSource = new ReportDataSource(); myReportDataSource.Name = "DataSet1"; myReportDataSource.Value = myList; // dataSet.Tables["vtTempActivosFijos_ConsultaDepreciacion"]; this.ReportViewer1.LocalReport.DataSources.Add(myReportDataSource); this.ReportViewer1.LocalReport.Refresh(); List <ReportParameter> reportParameterCollection = new List <ReportParameter>(); reportParameterCollection.Add(new ReportParameter("tituloReporte", titutlo)); reportParameterCollection.Add(new ReportParameter("subTituloReporte", subTitulo)); reportParameterCollection.Add(new ReportParameter("mes", mes)); reportParameterCollection.Add(new ReportParameter("ano", ano)); reportParameterCollection.Add(new ReportParameter("soloTotales", soloTotales.ToString())); reportParameterCollection.Add(new ReportParameter("periodo", periodo)); this.ReportViewer1.LocalReport.SetParameters(reportParameterCollection); break; } case "movimientosbancarios": { if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (Request.QueryString["tit"] == null || Request.QueryString["subtit"] == null || Request.QueryString["filter"] == null) { ErrMessage_Cell.InnerHtml = "Aparentemente, Ud. no ha seleccionado aún información para la obtención de este reporte.<br /><br />" + "Probablemente, Ud. no ha definido y aplicado un filtro que permita seleccionar información apropiada para la obtención " + "de este reporte."; break; } string titutlo = Request.QueryString["tit"].ToString(); string subTitulo = Request.QueryString["subtit"].ToString(); string filter = Request.QueryString["filter"].ToString(); BancosEntities bancosContext = new BancosEntities(); var query = bancosContext.MovimientosBancarios. Include("Chequera"). Include("Chequera.CuentasBancaria"). Include("Chequera.CuentasBancaria.Compania"). Include("Chequera.CuentasBancaria.Moneda1"). Include("Chequera.CuentasBancaria.Agencia1"). Include("Chequera.CuentasBancaria.Agencia1.Banco1"). Where(filter); if (query.Count() == 0) { ErrMessage_Cell.InnerHtml = "No existe información para mostrar el reporte " + "que Ud. ha requerido. <br /><br /> Probablemente Ud. no ha aplicado un " + "filtro y seleccionado información aún."; return; } // ahora preparamos una lista para usarla como DataSource del report ... List <Bancos_Report_ConsultaMovimientoBancario> myList = new List <Bancos_Report_ConsultaMovimientoBancario>(); Bancos_Report_ConsultaMovimientoBancario infoMovimientoBancario; foreach (MovimientosBancario movimiento in query) { infoMovimientoBancario = new Bancos_Report_ConsultaMovimientoBancario(); infoMovimientoBancario.NombreMoneda = movimiento.Chequera.CuentasBancaria.Moneda1.Descripcion; infoMovimientoBancario.NombreCiaContab = movimiento.Chequera.CuentasBancaria.Compania.Nombre; infoMovimientoBancario.Transaccion = movimiento.Transaccion; infoMovimientoBancario.Tipo = movimiento.Tipo; infoMovimientoBancario.Fecha = movimiento.Fecha; infoMovimientoBancario.NombreBanco = movimiento.Chequera.CuentasBancaria.Agencia1.Banco1.Nombre; infoMovimientoBancario.CuentaBancaria = movimiento.Chequera.CuentasBancaria.CuentaBancaria; infoMovimientoBancario.Beneficiario = movimiento.Beneficiario; infoMovimientoBancario.Concepto = movimiento.Concepto; infoMovimientoBancario.Monto = movimiento.Monto; infoMovimientoBancario.FechaEntregado = movimiento.FechaEntregado; myList.Add(infoMovimientoBancario); } this.ReportViewer1.LocalReport.ReportPath = "Bancos/ConsultasBancos/MovimientosBancarios/ConsultaMovimientosBancarios.rdlc"; ReportDataSource myReportDataSource = new ReportDataSource(); myReportDataSource.Name = "DataSet1"; myReportDataSource.Value = myList; this.ReportViewer1.LocalReport.DataSources.Add(myReportDataSource); this.ReportViewer1.LocalReport.Refresh(); ReportParameter titulo_ReportParameter = new ReportParameter("tituloReporte", titutlo); ReportParameter subTitulo_ReportParameter = new ReportParameter("subTituloReporte", subTitulo); ReportParameter[] MyReportParameters = { titulo_ReportParameter, subTitulo_ReportParameter }; this.ReportViewer1.LocalReport.SetParameters(MyReportParameters); break; } case "pagos": { if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } if (Request.QueryString["tit"] == null || Request.QueryString["subtit"] == null || Request.QueryString["filter"] == null) { ErrMessage_Cell.InnerHtml = "Aparentemente, Ud. no ha seleccionado aún información para la obtención de este reporte.<br /><br />" + "Probablemente, Ud. no ha definido y aplicado un filtro que permita seleccionar información apropiada para la obtención " + "de este reporte."; break; } string titutlo = Request.QueryString["tit"].ToString(); string subTitulo = Request.QueryString["subtit"].ToString(); string filter = Request.QueryString["filter"].ToString(); BancosEntities bancosContext = new BancosEntities(); var query = bancosContext.Pagos. Include("Proveedore"). Include("Compania"). Include("Moneda1"). Where(filter); if (query.Count() == 0) { ErrMessage_Cell.InnerHtml = "No existe información para mostrar el reporte " + "que Ud. ha requerido. <br /><br /> Probablemente Ud. no ha aplicado un " + "filtro y seleccionado información aún."; return; } // ahora preparamos una lista para usarla como DataSource del report ... List <Bancos_Report_ConsultaPago> myList = new List <Bancos_Report_ConsultaPago>(); Bancos_Report_ConsultaPago infoPago; foreach (Pago pago in query) { infoPago = new Bancos_Report_ConsultaPago(); infoPago.NombreMoneda = pago.Moneda1.Descripcion; infoPago.NombreCiaContab = pago.Compania.Nombre; infoPago.Fecha = pago.Fecha; infoPago.NombreCompania = pago.Proveedore.Abreviatura; infoPago.NumeroPago = pago.NumeroPago; infoPago.MiSu = pago.MiSuFlag == 1 ? "Mi" : "Su"; infoPago.Concepto = pago.Concepto; infoPago.Monto = pago.Monto != null ? pago.Monto.Value : 0; myList.Add(infoPago); } this.ReportViewer1.LocalReport.ReportPath = "Bancos/Consultas facturas/Pagos/ConsultaPagos.rdlc"; ReportDataSource myReportDataSource = new ReportDataSource(); myReportDataSource.Name = "DataSet1"; myReportDataSource.Value = myList; this.ReportViewer1.LocalReport.DataSources.Add(myReportDataSource); this.ReportViewer1.LocalReport.Refresh(); ReportParameter titulo_ReportParameter = new ReportParameter("tituloReporte", titutlo); ReportParameter subTitulo_ReportParameter = new ReportParameter("subTituloReporte", subTitulo); ReportParameter[] MyReportParameters = { titulo_ReportParameter, subTitulo_ReportParameter }; this.ReportViewer1.LocalReport.SetParameters(MyReportParameters); break; } } } }