Ejemplo n.º 1
0
        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";
        }
Ejemplo n.º 2
0
        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;
            // -----------------------------------------------------
        }
Ejemplo n.º 5
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();
        }
Ejemplo n.º 6
0
        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";
            }
        }
Ejemplo n.º 7
0
        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;
                }
                }
            }
        }