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