private string ConstruirPeriodoTranscurridoAnoFiscal() { // regresamos el período transcurrido (en meses) desde el inicio del año fiscal de la compañía seleccionada (siempre hay una y no más de una), // y la fecha de la consulta; por ejemplo: Mar-Ago, para una compañia que comienza su año fiscal en Marzo y la consulta se pide para Agosto ... // nótese lo que hacemos para obtener la compañía seleccionada para la consulta; no podemos recibir este valor desde el asp.net control, pues // estamos en el encabezado de la tabla y no en un row ... string nombre1erMesAnoFiscal; string nombreMesConsulta; using (dbContab_ActFijos_Entities ctx = new dbContab_ActFijos_Entities()) { int?ciaContabSeleccionada = ctx.tTempActivosFijos_ConsultaDepreciacion.Where(a => a.NombreUsuario == User.Identity.Name). Select(a => a.InventarioActivosFijo.Cia). FirstOrDefault(); if (ciaContabSeleccionada == null) { return(""); } // leemos el mes calendario que corresponde al 1er. mes fiscal de la compañía nombre1erMesAnoFiscal = ctx.MesesDelAnoFiscals.Where(m => m.Cia == ciaContabSeleccionada && m.MesFiscal == 1). Select(m => m.NombreMes). FirstOrDefault(); if (string.IsNullOrEmpty(nombre1erMesAnoFiscal)) { return(""); } // aquí debe venir el nombre del mes de la consulta (que indicó el usuario en el filtro) if (Session["ActFijos_Consulta_NombreMes"] == null) { return(""); } if (string.IsNullOrEmpty(Session["ActFijos_Consulta_NombreMes"].ToString())) { return(""); } nombreMesConsulta = Session["ActFijos_Consulta_NombreMes"].ToString(); } return("(" + nombre1erMesAnoFiscal.Substring(0, 3) + "-" + nombreMesConsulta.Substring(0, 3) + ")"); }
protected void AplicarFiltro_Button_Click(object sender, EventArgs e) { // nótese como excluímos el item dPagos.FechaPago, que tratamos en forma separada más adelante BuildSqlCriteria MyConstruirCriterioSql = new BuildSqlCriteria(); MyConstruirCriterioSql.LinqToEntities = true; // para que regrese un filtro apropiado para linq to entities ... MyConstruirCriterioSql.ContruirFiltro(this.Controls); string sSqlSelectString = MyConstruirCriterioSql.CriterioSql; MyConstruirCriterioSql = null; // las fechas no tienen un nombre adecuado para que la clase anterior las incluya al filtro; preferimos hacerlo aquí, de esta forma if (!String.IsNullOrEmpty(this.fCompra_desde.Text)) { if (!String.IsNullOrEmpty(this.fCompra_hasta.Text)) { // el usuario usó ambas fechas para indicar un período sSqlSelectString = sSqlSelectString + " And (it.FechaCompra Between DateTime'" + Convert.ToDateTime(this.fCompra_desde.Text).ToString("yyyy-MM-dd H:m:s") + "'"; sSqlSelectString = sSqlSelectString + " And DateTime'" + Convert.ToDateTime(this.fCompra_hasta.Text).ToString("yyyy-MM-dd H:m:s") + "')"; } else { // el usuario usó solo la fecha de inicio para buscar solo para esa fecha sSqlSelectString = sSqlSelectString + " And (it.FechaCompra = DateTime'" + Convert.ToDateTime(this.fCompra_desde.Text).ToString("yyyy-MM-dd H:m:s") + "'"; } } if (!String.IsNullOrEmpty(this.fDesincorporacion_desde.Text)) { if (!String.IsNullOrEmpty(this.fDesincorporacion_hasta.Text)) { // el usuario usó ambas fechas para indicar un período sSqlSelectString = sSqlSelectString + " And (it.FechaDesincorporacion Between DateTime'" + Convert.ToDateTime(this.fDesincorporacion_desde.Text).ToString("yyyy-MM-dd H:m:s") + "'"; sSqlSelectString = sSqlSelectString + " And DateTime'" + Convert.ToDateTime(this.fDesincorporacion_hasta.Text).ToString("yyyy-MM-dd H:m:s") + "')"; } else { // el usuario usó solo la fecha de inicio para buscar solo para esa fecha sSqlSelectString = sSqlSelectString + " And (it.FechaDesincorporacion = DateTime'" + Convert.ToDateTime(this.fDesincorporacion_desde.Text).ToString("yyyy-MM-dd H:m:s") + "'"; } } // --------------------------------------------------------------------------------------------------------------------- // si el usuario seleccionó uno o varios atributos, agregamos el criterio en forma separada aquí ... var selectedItems = from ListItem i in this.lst_Atributos.Items where i.Selected select i; string filtroAtributos = ""; foreach (var selectedItem in selectedItems) { // buscamos el registro en la tabla AtributosAsignados y construimos el criterio if (filtroAtributos == "") { filtroAtributos = "it.AtributoID IN {" + selectedItem.Value.ToString(); } else { filtroAtributos += ", " + selectedItem.Value.ToString(); } } // si el usuario seleccionó atributos, buscamos los ID de activos fijos en la tabla AtributosAsignados ... if (filtroAtributos != "") { filtroAtributos += "}"; dbContab_ActFijos_Entities actFijos_context = new dbContab_ActFijos_Entities(); string filtroAtributosActivosFijos = ""; var queryAtributosAsignados = (from a in actFijos_context.AtributosAsignados.Where(filtroAtributos) select a.ActivoFijoID).Distinct(); foreach (int a in queryAtributosAsignados) { if (filtroAtributosActivosFijos == "") { filtroAtributosActivosFijos = "it.ClaveUnica IN {" + a.ToString(); } else { filtroAtributosActivosFijos += ", " + a.ToString(); } } if (filtroAtributosActivosFijos != "") { filtroAtributosActivosFijos += "}"; sSqlSelectString += " And (" + filtroAtributosActivosFijos + ")"; } } // --------------------------------------------------------------------------------------------------------------------- Session["FiltroForma"] = sSqlSelectString; // ------------------------------------------------------------------------------------------------ // guardamos las fechas del período para posterior referencia Session["ActFijos_Consulta_Mes"] = Convert.ToInt16(this.drpdwn_MesConsulta.SelectedValue); Session["ActFijos_Consulta_Ano"] = Convert.ToInt16(this.txt_AnoConsulta.Text); Session["ActFijos_ExcluirDepreciadosAnosAnteriores"] = Convert.ToBoolean(this.ckh_ExcluirDepreciadosAnosAnteriores.Checked); Session["ActFijos_AplicarInfoDesincorporacion"] = Convert.ToBoolean(this.chk_AplicarInfoDesincorporacion.Checked); // mostramos el nombre del mes de la consulta en el encabezado de la lista que ve el usuario Session["ActFijos_Consulta_NombreMes"] = this.drpdwn_MesConsulta.SelectedItem.Text; Session["ReconvertirCifrasAntes_01Oct2021"] = this.ReconvertirCifrasAntes_01Oct2021_CheckBox.Checked; // ------------------------------------------------------------------------------------------------------------------------- // para guardar el contenido de los controles de la página para recuperar el state cuando se abra la proxima vez KeepPageState MyKeepPageState = new KeepPageState(Membership.GetUser().UserName, this.GetType().Name.ToString()); MyKeepPageState.SavePageStateInFile(this.Controls); MyKeepPageState = null; // ------------------------------------------------------------------------------------------------------ // nótese lo que hacemos aquí para que RegisterStartupScript funcione cuando ejecutamos en Chrome ... ScriptManager.RegisterStartupScript(this, this.GetType(), "CloseWindowScript", "<script language='javascript'>window.opener.RefreshPage(); window.close();</script>", false); }
private void CrearInfoReport( string sqlServerWhereString, short mesConsulta, short anoConsulta, bool excluirDepAnosAnteriores, bool aplicarInfoDesincorporados, bool bReconvertirCifrasAntes_01Oct2021) { // en este Sub agregamos los registros a la tabla 'temporal' en la base de datos para que la // página que sigue los muestre al usuario en un DataGridView if (!User.Identity.IsAuthenticated) { FormsAuthentication.SignOut(); return; } // convertimos el mes y año de la consulta en una fecha (siempre último de cada mes) DateTime fechaConsulta = new DateTime(anoConsulta, mesConsulta, 1).AddMonths(1).AddDays(-1); DateTime fechaInicioAno = new DateTime(anoConsulta, 1, 31); dbContab_ActFijos_Entities activosFijos_dbcontext = new dbContab_ActFijos_Entities(); try { // ---------------------------------------------------------------------------------------- // eliminamos los registros anteriores de la tabla 'temporal' string sqlTransactCommand = "Delete From tTempActivosFijos_ConsultaDepreciacion Where NombreUsuario = {0}"; activosFijos_dbcontext.ExecuteStoreCommand(sqlTransactCommand, new object[] { User.Identity.Name }); } catch (Exception ex) { activosFijos_dbcontext.Dispose(); ErrMessage_Span.InnerHtml = "Ha ocurrido un error al intentar ejecutar una operación de acceso a la base de datos. <br /> " + "El mensaje específico de error es: " + ex.Message + "<br /><br />"; ErrMessage_Span.Style["display"] = "block"; return; } // ---------------------------------------------------------------------------------------------------------------------- // leemos la tabla de monedas para 'saber' cual es la moneda Bs. Nota: la idea es aplicar las opciones de reconversión // *solo* a esta moneda var monedaNacional_return = Reconversion.Get_MonedaNacional(); if (monedaNacional_return.error) { ErrMessage_Span.InnerHtml = monedaNacional_return.message; ErrMessage_Span.Style["display"] = "block"; return; } Monedas monedaNacional = monedaNacional_return.moneda; // ---------------------------------------------------------------------------------------------------------------------- int cantidadRegistrosAgregados = 0; // nótese como seleccionamos solo los que se deprecien *luego* de la fecha de la consulta ... var query = from a in activosFijos_dbcontext.InventarioActivosFijos. Include("Compania"). Include("tDepartamento"). Include("TiposDeProducto"). Include("Moneda1"). Where(sqlServerWhereString) // en escencia, eliminamos los que aún no se comienzan a depreciar ... where (a.DepreciarDesdeAno < anoConsulta) || (a.DepreciarDesdeAno == anoConsulta && a.DepreciarDesdeMes <= mesConsulta) select a; tTempActivosFijos_ConsultaDepreciacion infoDepreciacion; // para cada activo leído, convertimos su inicio y fin de depreciación en fechas (siempre último de cada mes) DateTime fechaInicioDepreciacion; DateTime fechaFinDepreciacion; // solo para activos fijos *desincorporados* y cuando el usuario *marca* la opción que permite aplicar este mecanismo, // recalculamos los valores para: vida útil en meses del activo (CantidadMesesADepreciar) y monto total a depreciar (MontoADepreciar) short cantidadMesesADepreciar = 0; decimal montoADepreciar = 0; decimal montoDepreciacionMensual = 0; int ciaContabAnterior = -99999; DateTime fechaInicioAnoFiscal = new DateTime(); string errorMessage = ""; foreach (var a in query.OrderBy(i => i.Cia)) { cantidadMesesADepreciar = a.CantidadMesesADepreciar; // nóta: hemos encontrado que el usuario puede equivocarse aquí; mejor calculamos montoADepreciar = a.MontoADepreciar; montoDepreciacionMensual = a.MontoDepreciacionMensual; // -------------------------------------------------------------------------------------------------------------------------------------- // si el usuario indica que quiere reconvertir activos anteriores al mes Oct/2.021, aplicamos la reconversión if (bReconvertirCifrasAntes_01Oct2021 && (a.FechaCompra < new DateTime(2021, 10, 1)) && (a.Moneda1.Moneda1 == monedaNacional.Moneda)) { montoADepreciar = Math.Round((montoADepreciar / 1000000), 2); montoDepreciacionMensual = Math.Round((montoDepreciacionMensual / 1000000), 2); } try { // determinamos la fecha de inicio de depreciación, como el 1er. día del mes 'a depreciar'; de esta forma, parece que los // activos cuya depreciación se inicia en el año de la consulta, se calcula de forma correcta ... fechaInicioDepreciacion = new DateTime(a.DepreciarDesdeAno, a.DepreciarDesdeMes, 1); fechaFinDepreciacion = new DateTime(a.DepreciarHastaAno, a.DepreciarHastaMes, 1).AddMonths(1).AddDays(-1); cantidadMesesADepreciar = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); // nótese que aquí recalculamos ... } catch (Exception ex) { errorMessage = ex.Message; if (ex.InnerException != null) { errorMessage += "<br />" + ex.InnerException.Message; } ErrMessage_Span.InnerHtml = "Ha ocurrido un error mientras se efectuaba el proceso para el activo '" + a.Producto + "' - " + a.Descripcion + " (en la Cia Contab " + a.Compania.Abreviatura + ").<br />" + "Por favor revise los datos de registro de este activo y corríjalos de ser necesario. " + "Luego regrese y reintente ejecutar este proceso.<br /><br />" + "El mensaje específico de error es: " + errorMessage; ErrMessage_Span.Style["display"] = "block"; return; } if (aplicarInfoDesincorporados) { if (a.DesincorporadoFlag != null && a.DesincorporadoFlag.Value) { // cuando un activo es desincorporado, debe ser depreciado hasta el mes anterior a la desincorporación ... if (a.FechaDesincorporacion != null) { // nos aseguramos que la fecha de desincorporación sea *anterior* a la fecha de fin de depreciación ... if ((a.FechaDesincorporacion.Value.Year < a.DepreciarHastaAno) || (a.FechaDesincorporacion.Value.Year == a.DepreciarHastaAno && a.FechaDesincorporacion.Value.Month < a.DepreciarHastaMes)) { // desincorporados: depreciamos hasta el mes *anterior* a la desincorporación ... DateTime fechaDepreciarHasta = a.FechaDesincorporacion.Value.AddMonths(-1); // al igual que arriba, calculamos el último día del mes para la fecha anterior ... fechaFinDepreciacion = new DateTime(fechaDepreciarHasta.Year, fechaDepreciarHasta.Month, 1).AddMonths(1).AddDays(-1); // ahora recalculamos los valores indicados arriba, y que deben ser recalculados para activos desincorporados // (nótese que un activo desincorporado es, en efecto, depreciado por una cantidad *menor* de meses que los originalmente anticipados) cantidadMesesADepreciar = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); montoADepreciar = cantidadMesesADepreciar * a.MontoDepreciacionMensual; } } } } // en lo sucesivo, calculamos cantidades de meses ... int cantidadMesesAcumulados; int cantidadMesesEnElAno; // calculamos la cantidad de meses de vida del activo; // si el activo ha culminado su vida útil, la cantidad de meses de vida es su vida completa; // de otra forma, calculamos la cantidad de meses desde su inicio hasta la fecha de consulta ... if (fechaFinDepreciacion < fechaConsulta) { cantidadMesesAcumulados = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); } else { cantidadMesesAcumulados = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaConsulta); } // ==================================================================================================================================== // ahora determinamos la cantidad de meses en el año en curso // TODO: nótese como esta cantidad de meses depende del año fiscal de la empresa. El año puede ser igual al // año calendario, pero también puede ser diferente; ejemplo: Marzo a Febrero ... // // obtenemos la fecha inicial del año fiscal solo cuando cambia la cia contab; nota: en teoría, esta consulta, al menos por ahora, // puede ser obtenida para más de una cia contab if (a.Cia != ciaContabAnterior) { if (!ObtenerFechaInicioAnoFiscal(fechaConsulta, a.Cia, out fechaInicioAnoFiscal, out errorMessage)) { ErrMessage_Span.InnerHtml = "Ha ocurrido un error mientras se ejecutaba el proceso para esta consulta. <br /><br />" + "El mensaje específico de error es: " + errorMessage; ErrMessage_Span.Style["display"] = "block"; return; } ciaContabAnterior = a.Cia; } // ------------------------------------------------------------------------------ // TODO: sustituir ahora fechaInicioAno por fechaInicioAnoFiscal // nota: recuérdese que, al determinar la fecha de inicio del año fiscal, nos aseguramos que fuera siempre // *anterior* a la fecha de la consulta ... DateTime fechaInicioAnoFiscal1erDiaMes = new DateTime(fechaInicioAnoFiscal.Year, fechaInicioAnoFiscal.Month, 1); // porque se calculó el 31 ... if (fechaFinDepreciacion < fechaInicioAnoFiscal1erDiaMes) { // el activo se depreció en años (fiscales) anteriores cantidadMesesEnElAno = 0; } else // tomamos en cuenta que el activo pudo haberse comprado *luego* del inicio del año ... if (fechaInicioDepreciacion > fechaInicioAnoFiscal1erDiaMes) { if (fechaFinDepreciacion >= fechaConsulta) { // el activo se deprecia hasta después de la fecha de la consulta; la cantidad de meses en el año fiscal es simple: // desde inicio año fiscal hasta fecha consulta ... cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaConsulta); } else { // el activo se deprecia en el período que va: desde el inicio del año fiscal hasta la fecha de la consulta cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioDepreciacion, fechaFinDepreciacion); } } else if (fechaFinDepreciacion >= fechaConsulta) { // el activo se deprecia hasta después de la fecha de la consulta; la cantidad de meses en el año fiscal es simple: // desde inicio año fiscal hasta fecha consulta ... cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioAnoFiscal1erDiaMes, fechaConsulta); } else { // el activo se deprecia en el período que va: desde el inicio del año fiscal hasta la fecha de la consulta cantidadMesesEnElAno = CantidadMesesEntreFechas(fechaInicioAnoFiscal1erDiaMes, fechaFinDepreciacion); } // ==================================================================================================================================== infoDepreciacion = new tTempActivosFijos_ConsultaDepreciacion(); // guardamos estos *cuatro* items en la tabla temporal, pues pueden cambiar sus valores originales cuando un // activo es desincorporado ... infoDepreciacion.CantidadMesesADepreciar = cantidadMesesADepreciar; infoDepreciacion.MontoADepreciar = montoADepreciar; infoDepreciacion.DepreciarHastaMes = (short)fechaFinDepreciacion.Month; infoDepreciacion.DepreciarHastaAno = (short)fechaFinDepreciacion.Year; infoDepreciacion.ActivoFijoID = a.ClaveUnica; if (fechaFinDepreciacion < fechaConsulta) { infoDepreciacion.DepreciacionMensual = 0; } else { infoDepreciacion.DepreciacionMensual = montoDepreciacionMensual; } infoDepreciacion.DepAcum_CantMeses = Convert.ToInt16(cantidadMesesAcumulados); infoDepreciacion.DepAcum_CantMeses_AnoActual = Convert.ToInt16(cantidadMesesEnElAno); infoDepreciacion.DepAcum_AnoActual = montoDepreciacionMensual * cantidadMesesEnElAno; infoDepreciacion.DepAcum_Total = montoDepreciacionMensual * cantidadMesesAcumulados; infoDepreciacion.NombreUsuario = User.Identity.Name; // el usuario puede indicar que desea excluir los depreciados en años anteriores if (excluirDepAnosAnteriores && cantidadMesesEnElAno == 0) { continue; } activosFijos_dbcontext.tTempActivosFijos_ConsultaDepreciacion.AddObject(infoDepreciacion); cantidadRegistrosAgregados++; } try { activosFijos_dbcontext.SaveChanges(); } catch (Exception ex) { ErrMessage_Span.InnerHtml = "Ha ocurrido un error al intentar ejecutar una operación de acceso a la base de datos. <br /> " + "El mensaje específico de error es: " + ex.Message + "<br /><br />"; ErrMessage_Span.Style["display"] = "block"; return; } finally { // determinamos la cantidad de items agregados para el usuario Int32 numRecs = activosFijos_dbcontext.tTempActivosFijos_ConsultaDepreciacion.Count(u => u.NombreUsuario == User.Identity.Name); activosFijos_dbcontext.Dispose(); // para mostrar la cantidad de registros seleccionados this.selectedRecs_p.InnerHtml = $" {numRecs.ToString()} registros seleccionados ..."; this.selectedRecs_div.Style["display"] = "block"; } }
protected void ReconversionMonetaria_Button_Click(object sender, EventArgs e) { dbContab_ActFijos_Entities actFijos_Context = new dbContab_ActFijos_Entities(); // si existen valores en la tabla 'backup', indicamos y terminamos, para evitar ejecutar dos veces sucesivas ... if (actFijos_Context.InventarioActivosFijos_AntesReconversionMonetaria.Count() > 0) { ErrMessage_Span.InnerHtml = "Aparentemente, este proceso ha sido ejecutado antes, pues existen registros en la tabla 'backup'. <br /> " + "Ud. debe recuperar los montos desde estos registros (backup) y luego eliminalos de esta tabla. <br /> " + "Solo entonces este proceso puede ser ejecutado nuevamente."; ErrMessage_Span.Style["display"] = "block"; return; } var query = from a in actFijos_Context.InventarioActivosFijos where a.FechaCompra < new DateTime(2008, 1, 1) select a; InventarioActivosFijos_AntesReconversionMonetaria backUpEntity; int cantidadRegistrosProcesados = 0; foreach (InventarioActivosFijo af in query) { // creamos un registro 'backup' backUpEntity = new InventarioActivosFijos_AntesReconversionMonetaria(); backUpEntity.ActivoFijo_ID = af.ClaveUnica; backUpEntity.CostoTotal = af.CostoTotal; backUpEntity.MontoADepreciar = af.MontoADepreciar; backUpEntity.MontoDepreciacionMensual = af.MontoDepreciacionMensual; backUpEntity.ValorResidual = af.ValorResidual; actFijos_Context.InventarioActivosFijos_AntesReconversionMonetaria.AddObject(backUpEntity); // dividimos y redondeamos cada monto para obtener Bs.F. af.CostoTotal = Math.Round((af.CostoTotal / 1000), 2, MidpointRounding.AwayFromZero); af.MontoADepreciar = Math.Round((af.MontoADepreciar / 1000), 2, MidpointRounding.AwayFromZero); af.MontoDepreciacionMensual = Math.Round((af.MontoDepreciacionMensual / 1000), 2, MidpointRounding.AwayFromZero); af.ValorResidual = Math.Round((af.ValorResidual / 1000), 2, MidpointRounding.AwayFromZero); cantidadRegistrosProcesados++; } try { actFijos_Context.SaveChanges(); } catch (Exception ex) { string errMessage = ex.Message; if (ex.InnerException != null) { errMessage += "<br /><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: " + errMessage + "<br />"; ErrMessage_Span.Style["display"] = "block"; return; } finally { actFijos_Context.Dispose(); } Message_Span.InnerHtml = "Ok, el proceso ha sido ejecutado en forma satisfactoria.<br />" + "En total, se han corregido (convetido a Bs.F.) " + cantidadRegistrosProcesados.ToString() + " activos."; Message_Span.Style["display"] = "block"; }