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";
}