ComparativosMensuales.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;
using sage.ew.db;
using sage.ew.global;
using sage.ew.txtbox.UserControls;
using sage.ew.ewbase;

namespace sage.ew.listados
{
    public abstract class ComparativosMensuales : Clases.Listados
    {
        #region Variables

        protected bool TrabajaConEjercicioPartido = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_parti"));

        protected string _cTituloListado = string.Empty;

        protected string _cOpcFechas = string.Empty;

        protected string _cOpcSumaDe = string.Empty;

        protected bool _lAcumulandoImporte = false;

        protected bool _lfacturas = false;

        //Defino variables para la sentencia PIVOT
        protected string _cTituloAgrupacion = string.Empty;
        protected string _cColumnasPivot = string.Empty;
        protected string _cInPivot = string.Empty;
        protected string _cAgrupacion = string.Empty;  //Operación a realizar con la fecha para particionar

        protected string _cColumnaDetalle = string.Empty;
        protected string _cColumnaDetalleNull = string.Empty;
        protected string _cCodigoParaLeftJoin = string.Empty;
        protected string _cTablaNombre = string.Empty;
        protected string _cCampoGroupBy = string.Empty;

        #endregion Variables

        public enum eTipoComparativa
        {
            Indeterminado = 0,
            Ventas = 1,
            Compras = 2,
            Contabilidad = 3
        }

        protected enum _eAgruparPor
        {
            dia,
            semana,
            mes,
            trimestre,
            semestre,
            año,
            nada
        };
        protected _eAgruparPor _eOpcAgruparPor = _eAgruparPor.mes;

        private readonly eTipoComparativa tipoDeComparativa = eTipoComparativa.Indeterminado;

        protected Dictionary<string, string> FiltrosParaEjercicios
        {
            get { return dicFiltrosParaEjercicios; }
            set { dicFiltrosParaEjercicios = value; }
        }
        private Dictionary<string, string> dicFiltrosParaEjercicios = new Dictionary<string, string>();

        public bool _Mostrar_Beneficio_TPC
        {
            get { return _lMostrar_Beneficio_TPC; }
            set { _lMostrar_Beneficio_TPC = value; }
        }
        private bool _lMostrar_Beneficio_TPC = false;

        #region Constructores

        private ComparativosMensuales()
            : base()
        {
            InitComparativa();
        }

        public ComparativosMensuales(eTipoComparativa teTipoComparativo)
            : base()
        {
            tipoDeComparativa = teTipoComparativo;

            InitComparativa();
        }

        public ComparativosMensuales(eTipoComparativa teTipoComparativo, object[] toObjects)
            : base(toObjects)
        {
            tipoDeComparativa = teTipoComparativo;

            InitComparativa();
        }

        #endregion Constructores

        #region Métodos abstractos

        protected abstract void InitComparativa();

        #endregion Métodos abstractos

        protected virtual void DeterminarTipoAgrupacion()
        {
            //{ día, semana, mes, trimestre, semestre, año }
            int lnAgrupacion = _Opcion_Entero("ndiasemanamestrime");
            switch (lnAgrupacion)
            {
                case 0: //Dia
                    _eOpcAgruparPor = _eAgruparPor.dia;
                    break;

                case 1: //Semana
                    _eOpcAgruparPor = _eAgruparPor.semana;
                    break;

                case 2: //Mes
                default:
                    _eOpcAgruparPor = _eAgruparPor.mes;
                    break;

                case 3: //Trimestre
                    _eOpcAgruparPor = _eAgruparPor.trimestre;
                    break;

                case 4: //Semestre
                    _eOpcAgruparPor = _eAgruparPor.semestre;
                    break;

                case 5: //Año
                    _eOpcAgruparPor = _eAgruparPor.año;
                    break;

                case 6: //Sin escala de tiempo (1 solo bloque)
                    _eOpcAgruparPor = _eAgruparPor.nada;
                    break;
            }
        }

        protected virtual void DeterminarOpcionDeSuma()
        {
            _lAcumulandoImporte = false; //Bug 109054

            //Control que contiene si hemos de agrupar unidades o importe
            int lnUnidades = _Opcion_Entero("nunidadesimporte");
            switch (lnUnidades)
            {
                case 0:
                    _cOpcSumaDe = "unidades";
                    break;
                case 1:
                default:
                    _lAcumulandoImporte = true; //Bug 109054

                    if (_DivisaConfig._DivisaEspecifica)
                        _cOpcSumaDe = "importediv";
                    else
                        _cOpcSumaDe = "importe";

                    if (esUnaComparativaDeVentas() && _AplicarIVAIncluido)
                    {
                        if (_DivisaConfig._DivisaEspecifica)
                            _cOpcSumaDe = "impdiviva";
                        else
                            _cOpcSumaDe = "importeiva";
                    }
                    break;

                case 2:
                    _cOpcSumaDe = "cajas";  //PE-84136: opcion de suma de cajas
                    break;
                case 3:
                    _cOpcSumaDe = "peso";   //PE-84136: opcion de suma de peso
                    break;
            }
        }

        protected virtual string ObtenerCodigoListadoDeNavegacion()
        {
            return ""; //Sobreecribir el las clases derivada
        }

        private bool esUnaComparativaDeVentas()
        {
            return tipoDeComparativa == eTipoComparativa.Ventas;
        }

        protected bool usarEscalaDeTiempo()
        {
            return _eOpcAgruparPor != _eAgruparPor.nada;
        }

        protected virtual void DeterminarOpcionDeFecha()
        {
            int lnTipoFecha = -1;
            lnTipoFecha = _Opcion_Entero("nalbaranesfacturas"); //PE-90076 NO CAMBIAR EL NOMBRE SIN CONSULTAR
            switch (lnTipoFecha)
            {
                case 1:
                    _cOpcFechas = "fecha_fac";
                    _lfacturas = true;          // PE-90199. Agrupar per facturats
                    break;
                case 0:
                default:
                    _cOpcFechas = "fecha";
                    _lfacturas = false;         // PE-90199. No agrupar per facturats
                    break;
            }

        }

        protected void _GarantizarAlmenosUnRegistro(ref DataTable tdtResultados)
        {
            //Si no hay datos debo devolver un datatable a 0's
            if (tdtResultados.Rows.Count == 0)
            {
                foreach (string lcEjer in _Ejercicios)
                {
                    DataRow ldrEmptyRow = tdtResultados.NewRow();
                    if (tdtResultados.Columns.Contains("EJERCICIO"))
                        ldrEmptyRow["EJERCICIO"] = lcEjer;
                    else
                    {
                        try { ldrEmptyRow[0] = lcEjer; } //pruebo de asignar en la primera fila
                        catch (Exception loEx) { DB.Registrar_Error(loEx); }
                    }
                    tdtResultados.Rows.Add(ldrEmptyRow);
                }
            }
        }

        protected virtual string ObtenerColumnasBaseParaPivot()
        {
            return "[EJERCICIO], ";
        }

        protected virtual string ObtenerColumnasDetalleAdicional()
        {
            return ""; //Por si se requierne columnas adicionales
        }

        protected void CalcularParametrosAgrupacion(string tcAliasDatos)
        {
            //Defino columnas y pivote en funcion de la agrupación
            switch (_eOpcAgruparPor)
            {
                #region dia
                case _eAgruparPor.dia:
                    _cTituloAgrupacion = " dia ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot();
                    _cInPivot = _cTituloAgrupacion + " IN ( ";

                    //Por cada mes
                    for (int lnMes = 1; lnMes <= 12; lnMes++)
                    {
                        int lnNumeroDiasMes = 0;
                        int lnIndexColumna = 0;

                        //Determino el nombre del més
                        string lcNombreMes = CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(lnMes);

                        //Determino el número de días
                        switch (lnMes)
                        {
                            case 1:
                            case 3:
                            case 5:
                            case 7:
                            case 8:
                            case 10:
                            case 12:
                                lnNumeroDiasMes = 31;
                                break;
                            case 2:
                                lnNumeroDiasMes = 29;
                                break;
                            case 4:
                            case 6:
                            case 9:
                            case 11:
                                lnNumeroDiasMes = 30;
                                break;
                            default:
                                break;
                        }

                        for (int lnIndex = 1; lnIndex <= lnNumeroDiasMes; lnIndex++)
                        {
                            lnIndexColumna = lnMes * 100 + lnIndex; //Mes x 100 + dia para generar número único
                            _cColumnasPivot += "[" + lnIndexColumna.ToString() + "] AS '" + lcNombreMes + ", " + lnIndex.ToString() + "'";
                            _cInPivot += "[" + lnIndexColumna.ToString() + "]";
                            if (lnMes == 12 && lnIndex == 31)
                            {
                                _cColumnasPivot += " ";
                                _cInPivot += ") ";
                            }
                            else
                            {
                                _cColumnasPivot += ", ";
                                _cInPivot += ", ";
                            }
                        }
                    }
                    _cAgrupacion = _cColumnaDetalle + "DATEPART(m, " + tcAliasDatos + _cOpcFechas + ") * 100 + DATEPART ( d , " + tcAliasDatos + _cOpcFechas + ") as " + _cTituloAgrupacion;

                    break;
                #endregion dia

                #region semana
                case _eAgruparPor.semana:
                    var numMaxSemanas = 52;

                    foreach (var ejercicio in _Ejercicios)
                    {
                        var semanas = ObtenerNumeroSemanasEjercicio(ejercicio);
                        if (semanas > numMaxSemanas)
                            numMaxSemanas = semanas;
                    }

                    _cTituloAgrupacion = " semana ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot();
                    _cInPivot = _cTituloAgrupacion + " IN ( ";
                    for (int lnIndex = 1; lnIndex <= numMaxSemanas; lnIndex++)
                    {
                        _cColumnasPivot += "[" + lnIndex.ToString() + "] AS 'Semana " + lnIndex.ToString() + "'";
                        _cInPivot += "[" + lnIndex.ToString() + "]";
                        if (lnIndex == numMaxSemanas)
                        {
                            _cColumnasPivot += " ";
                            _cInPivot += ") ";
                        }
                        else
                        {
                            _cColumnasPivot += ", ";
                            _cInPivot += ", ";
                        }
                    }
                    _cAgrupacion = ObtenerColumnasDetalleAdicional() + "DATEPART ( wk , " + tcAliasDatos + _cOpcFechas + ") as " + _cTituloAgrupacion;
                    break;
                #endregion semana

                case _eAgruparPor.trimestre:
                    _cTituloAgrupacion = " trimestre ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot() + "[1] AS T1, [2] AS T2, [3] AS T3, [4] AS T4 ";
                    _cInPivot = _cTituloAgrupacion + " IN ( [1] , [2], [3], [4]) ";
                    _cAgrupacion = ObtenerColumnasDetalleAdicional() + " DATEPART ( qq ," + tcAliasDatos + _cOpcFechas + ") as " + _cTituloAgrupacion;
                    break;

                case _eAgruparPor.semestre:
                    _cTituloAgrupacion = " semestre ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot() + "[1] AS SEM1, [2] AS SEM2 ";
                    _cInPivot = _cTituloAgrupacion + " IN ( [1] , [2]) ";
                    _cAgrupacion = ObtenerColumnasDetalleAdicional() + " FLOOR ((MONTH(" + tcAliasDatos + _cOpcFechas + ") - 1) / 6) + 1 as " + _cTituloAgrupacion;
                    break;

                case _eAgruparPor.año:
                    _cTituloAgrupacion = " año ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot() + "[1] AS AÑO ";
                    _cInPivot = _cTituloAgrupacion + " IN ( [1] ) ";
                    _cAgrupacion = ObtenerColumnasDetalleAdicional() + " '1' as " + _cTituloAgrupacion;
                    break;

                case _eAgruparPor.nada:
                    _cTituloAgrupacion = " saldo ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot() + "[1] AS SALDO ";
                    _cInPivot = _cTituloAgrupacion + " IN ( [1] ) ";
                    _cAgrupacion = ObtenerColumnasDetalleAdicional() + " '1' as " + _cTituloAgrupacion;
                    break;

                case _eAgruparPor.mes:
                default:
                    _cTituloAgrupacion = " meses ";
                    _cColumnasPivot = ObtenerColumnasBaseParaPivot() + "[1] AS Enero, [2] AS Febrero, [3] AS Marzo, [4] AS Abril, [5] AS Mayo, [6] AS Junio, [7] AS Julio, " +
                        "[8] AS Agosto, [9] AS Septiembre , [10] AS Octubre, [11] AS Noviembre, [12] AS Diciembre ";
                    _cInPivot = _cTituloAgrupacion + " IN ( [1] , [2], [3], [4], [5] , [6], [7], [8],[9] , [10], [11], [12]) ";
                    _cAgrupacion = ObtenerColumnasDetalleAdicional() + " MONTH(" + tcAliasDatos + _cOpcFechas + ") as " + _cTituloAgrupacion;
                    break;
            }
        }

        protected int ObtenerNumeroSemanasEjercicio(string ejercicio)
        {
            DateTime fecha = new DateTime(Convert.ToInt32(ejercicio), 12, 31);
            CultureInfo cultura = CultureInfo.InvariantCulture;
            Calendar calendario = cultura.Calendar;
            int cantidadSemanas = calendario.GetWeekOfYear(fecha, cultura.DateTimeFormat.CalendarWeekRule, cultura.DateTimeFormat.FirstDayOfWeek);
            return cantidadSemanas;
        }

        #region Métodos override

        public override List<string> _ReportColumns
        {
            get
            {
                List<string> ldReportColumns = new List<string>();

                foreach (DataColumn loCol in _Resultados.Columns)
                {
                    if (loCol.ColumnName.ToLower() != "bold")
                        ldReportColumns.Add(loCol.ColumnName);
                }
                return ldReportColumns;
            }
        }

        public override void _SetColumnMasks()
        {
            base._SetColumnMasks();

            string lcColumnName = string.Empty;
            List<string> llTPC = new List<string> { "%" };

            foreach (DataColumn ldc in _Resultados.Columns)
            {
                lcColumnName = ldc.ColumnName.ToLower().Trim();
                string lcMascara = "";

                //Si es un %
                if (llTPC.Any(s => lcColumnName.Contains(s)))
                {
                    lcMascara = _Mascara_TPC;
                }
                else
                {
                    //Verifico por tipo de datos ya que los títulos varia en función del ejercicio
                    string lcTipoCampo = ldc.DataType.Name.ToString();

                    if ((lcTipoCampo == "Int32") || (lcTipoCampo == "Double") || (lcTipoCampo == "Decimal"))
                    {
                        switch (_cOpcSumaDe)
                        {
                            case "unidades":
                                lcMascara = _Mascara_Unidades;
                                break;

                            case "importe":
                            case "importeiva":
                            default:
                                lcMascara = _Mascara_Importe;
                                break;

                            case "importediv":
                            case "impdiviva":
                            case "(ASIENTO.DEBE - ASIENTO.HABER)":
                                lcMascara = _DivisaConfig._DivisaMascaraImporte;
                                break;

                            case "cajas":
                                lcMascara = _Mascara_Cajas;
                                break;

                            case "peso":
                                lcMascara = _Mascara_Peso;
                                break;
                        }
                    }
                }

                //Paso a asignar la máscara
                if (!ldc.ExtendedProperties.ContainsKey("Mascara"))
                    ldc.ExtendedProperties.Add("Mascara", lcMascara);
            }
        }

        public override void _ConvertVisualFiltersOptionsToObjects(Dictionary<string, object> toFiltrosVisuals = null, Dictionary<string, object> toOpcionesVisuals = null)
        {
            base._ConvertVisualFiltersOptionsToObjects(toFiltrosVisuals, toOpcionesVisuals);

            //Ejericicios (va por datatable)
            if (toFiltrosVisuals.Keys.Contains("txtEjercicioDesdeHasta"))
            {
                txtEjercicioDesdeHasta loControlFiltro = new txtEjercicioDesdeHasta();
                loControlFiltro = (txtEjercicioDesdeHasta)toFiltrosVisuals["txtEjercicioDesdeHasta"];


                //Si no esta marcado el checkbox de Todos (=> caso en el que no se filtra) 
                if (!loControlFiltro._Todos)
                {
                    //Si tengo elementos en la lista
                    if (loControlFiltro._Lista != null && loControlFiltro._Lista.Count > 0)
                    {
                        _Ejercicios = new string[loControlFiltro._Lista.Count];
                        _Ejercicios = loControlFiltro._Lista.ToArray<string>();
                    }
                    else //Usamos la combinación Desde - Hasta
                    {
                        if (loControlFiltro._Desde == loControlFiltro._Hasta) _Ejercicios = new string[1] { loControlFiltro._Desde };
                        else
                        {
                            bool llRowArray = false;
                            DataRow[] loRowArray = new DataRow[0];

                            bool llDesde = !string.IsNullOrWhiteSpace(loControlFiltro._Desde); //Determino si tengo valor _Desde
                            bool llHasta = !string.IsNullOrWhiteSpace(loControlFiltro._Hasta); //Determino si tengo valor _Hasta

                            //Si tengo los 2 valores
                            if (llDesde && llHasta)
                            {
                                llRowArray = true;
                                loRowArray = loControlFiltro._oFiltroDesde._DataTable.Select("ano>='" + loControlFiltro._Desde + "' AND ano<='" + loControlFiltro._Hasta + "'");
                            }
                            else
                            {
                                //Solo tengo valor Desde
                                if (llDesde && !llHasta)
                                {
                                    llRowArray = true;
                                    loRowArray = loControlFiltro._oFiltroDesde._DataTable.Select("ano>='" + loControlFiltro._Desde + "'");
                                }
                                //Solo tengo valor Hasta
                                if (!llDesde && llHasta)
                                {
                                    llRowArray = true;
                                    loRowArray = loControlFiltro._oFiltroDesde._DataTable.Select("ano<='" + loControlFiltro._Hasta + "'");
                                }
                            }

                            if (llRowArray)
                            {
                                _Ejercicios = new string[loRowArray.Count()];
                                int lnIndex = 0;
                                foreach (DataRow loRow in loRowArray)
                                {
                                    _Ejercicios[lnIndex] = loRow[0].ToString().TrimEnd();
                                    lnIndex++;
                                }
                            }
                        }
                    }
                }
                else //Los quiero todos
                {
                    _Ejercicios = new string[loControlFiltro._oFiltroDesde._DataTable.Rows.Count];
                    int lnIndex = 0;

                    foreach (DataRow loRow in loControlFiltro._oFiltroDesde._DataTable.Rows)
                    {
                        _Ejercicios[lnIndex] = loRow[0].ToString().TrimEnd();
                        lnIndex++;
                    }
                }
            }
        }

        protected override void _SetDefaultConfig(Dictionary<string, object> _Filtros, Dictionary<string, object> _Opciones)
        {
            base._SetDefaultConfig(_Filtros, _Opciones);
        }

        public override void _SetEjercicios()
        {
            //Sobreescribo el método pq este listado ya es multiejercicio 'puro' y el tratamiento genérico no lo contemplo y lo estropeaba
        }

        public override void _Navigate(string tcKeyNavigate, DataRow trRowList, Dictionary<string, object> tdicParams)
        {
            //Instancio una clase de cambio de ejercicio y lo cambio
            functions.Clases.CambioEjercicio loEjer = new functions.Clases.CambioEjercicio();
            loEjer._Cambiar(tcKeyNavigate);

            //Genero un botón de listados
            botones.Clases.btListados loBotonListados = new botones.Clases.btListados();

            //Establecer destinos de navegación para gráficas en función de orígen
            loBotonListados._NombreListado = ObtenerCodigoListadoDeNavegacion();

            loBotonListados._ShowDialog = true;

            // PE-100412 propago el parámetro de navegación directa del listado
            loBotonListados._NavegacionDirecta = _NavegacionDirecta;

            //Miro si he recibido parámetros y si estos contienen el diccionario de filtros
            if (tdicParams != null && tdicParams.ContainsKey("NavigateFromFiltros"))
            {
                //Me vuelco el diccionario en uno nuevo para no alterar el original y facilitar el acceso
                Dictionary<string, object> ldicFiltrosToButton = new Dictionary<string, object>(tdicParams["NavigateFromFiltros"] as Dictionary<string, object>);

                //Tratamiento especial de la fecha
                //Elimino del diccionario la fecha original ya que la que debo mandar al listado me la proporciona el DataRow y no el Formulario orígen
                if (ldicFiltrosToButton.ContainsKey("txtFechaDesdeHasta")) ldicFiltrosToButton.Remove("txtFechaDesdeHasta");

                //Tratamiento especial de la fecha
                if (trRowList != null && //Tengo fila origen
                    !String.IsNullOrEmpty(tcKeyNavigate)) //Tengo año 
                {
                    //Creo un nuevo filtro de fechas
                    txtFechaDesdeHasta loFiltroFecha = new txtFechaDesdeHasta();

                    //Calculo las fechas a partir del Row
                    DateTime ldFechaIni = DateTime.Today;
                    DateTime ldFechaFin = DateTime.Today;
                    CalcularFechas(tcKeyNavigate, trRowList, out ldFechaIni, out ldFechaFin);
                    loFiltroFecha._Desde = ldFechaIni.ToString(EW_GLOBAL._CustomFormatDate);
                    loFiltroFecha._Hasta = ldFechaFin.ToString(EW_GLOBAL._CustomFormatDate);

                    ldicFiltrosToButton.Add("txtFechaDesdeHasta", loFiltroFecha);
                }

                //Reconvieto los txtFiltroBase a ConfiguradoresVisuales
                var lisFiltros = ldicFiltrosToButton.Where(loEle => loEle.Value is txtFiltroBase).ToList();

                foreach (var loFiltro in lisFiltros)
                {
                    ldicFiltrosToButton[loFiltro.Key] = ((txtFiltroBase)loFiltro.Value)._ToConfiguradorFiltroVisual(); //Reconvierto el filtro visual en su version Configurador
                }

                //PE-95018 Opción se IVA INCLUIDO
                //Bug 108852 Combo de divisa
                //Miro si he recibido parámetros y si estos contienen el diccionario de opciones
                if (tdicParams != null && tdicParams.ContainsKey("NavigateFromOpciones"))
                {
                    //Recupero el diccionario de opciones en uno temporal para poder operar con el contenido
                    Dictionary<string, object> ldicTmpOpcsToButton = new Dictionary<string, object>(tdicParams["NavigateFromOpciones"] as Dictionary<string, object>);

                    if (ldicTmpOpcsToButton.ContainsKey("txtSelIva"))
                        ldicFiltrosToButton.Add("txtSelIva", ldicTmpOpcsToButton["txtSelIva"]); //Le paso el control

                    if (ldicTmpOpcsToButton.ContainsKey("cmbdivisa")) //Bug 108852 Combo de divisa
                        ldicFiltrosToButton.Add("cmbdivisa", ldicTmpOpcsToButton["cmbdivisa"]); //Le paso el control
                }

                //Asigno el diccionario de valores por defecto
                loBotonListados._DefaultValues = ldicFiltrosToButton;
            }

            loBotonListados.PerformClick();

            loEjer._Restablecer();
        }

        #endregion Métodos override

        #region Métodos auxiliares

        protected static DateTime FirstDateOfWeekISO8601(int tnYear, int tnWeekOfYear)
        {
            DateTime ld1Enero = new DateTime(tnYear, 1, 1);
            int daysOffset = DayOfWeek.Thursday - ld1Enero.DayOfWeek;

            DateTime ldPrimerJueves = ld1Enero.AddDays(daysOffset);
            var loCalendario = CultureInfo.CurrentCulture.Calendar;
            int lnFirstWeek = loCalendario.GetWeekOfYear(ldPrimerJueves, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);

            var lnWeekNum = tnWeekOfYear;
            if (lnFirstWeek <= 1)
            {
                lnWeekNum -= 1;
            }
            var result = ldPrimerJueves.AddDays(lnWeekNum * 7);
            return result.AddDays(-3);
        }

        protected DateTime FirstDateOfWeek(int year, int weekNum)
        {
            DateTime jan1 = new DateTime(year, 1, 1);

            var diaDeLaSemana = jan1.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)jan1.DayOfWeek;
            int daysOffset = (int)DayOfWeek.Monday - diaDeLaSemana;
            DateTime firstMonday = jan1.AddDays(daysOffset); //El dia 1 ha de estar en la semana 1 => el dilluns pot estar al any anterior

            DateTime result;
            if (weekNum == 1)
                result = jan1;
            else
            {
                weekNum -= 1;
                result = firstMonday.AddDays(weekNum * 7);
            }

            return result;
        }

        protected void CalcularFechas(string tcEjercicio, DataRow trRow, out DateTime tdFechaIni, out DateTime tdFechaFin)
        {
            int lnEjercico = Convert.ToInt32(tcEjercicio);
            int lnMes = 1;
            Calendar loCalendar = CultureInfo.CurrentCulture.Calendar;
            string lcFechaRow = Convert.ToString(trRow.Field<string>(_cTituloListado));

            switch (_eOpcAgruparPor)
            {
                #region Dia

                case _eAgruparPor.dia:
                    try
                    {
                        string[] lcDataPart = lcFechaRow.Split(',');
                        if (lcDataPart.Count() > 1) // 2 partes => fecha normal
                        {
                            lnMes = DateTime.ParseExact(lcDataPart[0], "MMMM", CultureInfo.CurrentCulture).Month;
                            int lnDia = Convert.ToInt32(lcDataPart[1].Trim());
                            tdFechaIni = tdFechaFin = new DateTime(lnEjercico, lnMes, lnDia);
                        }
                        else
                        {
                            tdFechaIni = new DateTime(lnEjercico, 1, 1);
                            tdFechaFin = new DateTime(lnEjercico, 12, 31);
                        }
                    }
                    catch //No me ha llegado un dia => Total
                    {
                        tdFechaIni = new DateTime(lnEjercico, 1, 1);
                        tdFechaFin = new DateTime(lnEjercico, 12, 31);
                    }
                    break;

                #endregion Dia

                #region Semana

                case _eAgruparPor.semana:

                    if (lcFechaRow.StartsWith("Semana"))
                    {

                    }
                    try
                    {
                        int lnNumSemana = Convert.ToInt32(lcFechaRow.Replace("Semana ", "").Trim());
                        //tdFechaIni = FirstDateOfWeekISO8601(lnEjercico, lnNumSemana);
                        tdFechaIni = FirstDateOfWeek(lnEjercico, lnNumSemana);
                        tdFechaFin = FirstDateOfWeek(lnEjercico, lnNumSemana + 1).AddDays(-1);
                    }
                    catch //No me ha llegado una seman => Total
                    {
                        tdFechaIni = new DateTime(lnEjercico, 1, 1);
                        tdFechaFin = new DateTime(lnEjercico, 12, 31);
                    }


                    break;

                #endregion Semana

                #region Mes

                case _eAgruparPor.mes:
                    try
                    {
                        lnMes = DateTime.ParseExact(lcFechaRow, "MMMM", CultureInfo.CurrentCulture).Month;
                        tdFechaIni = new DateTime(lnEjercico, lnMes, 1);
                        tdFechaFin = new DateTime(lnEjercico, lnMes, loCalendar.GetDaysInMonth(lnEjercico, lnMes));
                    }
                    catch //No me ha llegado un mes => Total
                    {
                        tdFechaIni = new DateTime(lnEjercico, 1, 1);
                        tdFechaFin = new DateTime(lnEjercico, 12, 31);
                    }
                    break;

                #endregion Mes

                #region Trimestre

                case _eAgruparPor.trimestre:

                    switch (lcFechaRow)
                    {
                        case "T1":
                            tdFechaIni = new DateTime(lnEjercico, 1, 1);
                            tdFechaFin = new DateTime(lnEjercico, 3, loCalendar.GetDaysInMonth(lnEjercico, 3));
                            break;
                        case "T2":
                            tdFechaIni = new DateTime(lnEjercico, 4, 1);
                            tdFechaFin = new DateTime(lnEjercico, 6, loCalendar.GetDaysInMonth(lnEjercico, 6));
                            break;
                        case "T3":
                            tdFechaIni = new DateTime(lnEjercico, 7, 1);
                            tdFechaFin = new DateTime(lnEjercico, 9, loCalendar.GetDaysInMonth(lnEjercico, 9));
                            break;
                        case "T4":
                            tdFechaIni = new DateTime(lnEjercico, 10, 1);
                            tdFechaFin = new DateTime(lnEjercico, 12, loCalendar.GetDaysInMonth(lnEjercico, 12));
                            break;
                        default:
                            tdFechaIni = new DateTime(lnEjercico, 1, 1);
                            tdFechaFin = new DateTime(lnEjercico, 12, 31);
                            break;
                    }
                    break;

                #endregion Trimestre

                #region Semestre

                case _eAgruparPor.semestre:
                    switch (lcFechaRow)
                    {
                        case "SEM1":
                            tdFechaIni = new DateTime(lnEjercico, 1, 1);
                            tdFechaFin = new DateTime(lnEjercico, 6, loCalendar.GetDaysInMonth(lnEjercico, 6));
                            break;
                        case "SEM2":
                            tdFechaIni = new DateTime(lnEjercico, 7, 1);
                            tdFechaFin = new DateTime(lnEjercico, 12, loCalendar.GetDaysInMonth(lnEjercico, 12));
                            break;

                        default:
                            tdFechaIni = new DateTime(lnEjercico, 1, 1);
                            tdFechaFin = new DateTime(lnEjercico, 12, 31);
                            break;
                    }
                    break;

                #endregion Semestre

                #region Año

                case _eAgruparPor.año:
                    tdFechaIni = new DateTime(lnEjercico, 1, 1);
                    tdFechaFin = new DateTime(lnEjercico, 12, 31);
                    break;

                #endregion Año

                default:
                    tdFechaIni = new DateTime(lnEjercico, 1, 1);
                    tdFechaFin = new DateTime(lnEjercico, 12, 31);
                    break;
            }
        }

        public Dictionary<string, string> _FiltroFechaPorEjercicio(Dictionary<string, object> toFiltros, string teFiltro, string tcAlias, string tcCampo, string[] taEjecicios, _Operador_Condicional teOperador = _Operador_Condicional.And)
        {
            bool llFechaDesde = false;
            bool llFechaHasta = false;
            bool llFechaUnica = false;
            DateTime? ldFechaDesde = null;
            DateTime? ldFechaHasta = null;
            DateTime? ldFechaUnica = null;
            string lcAlias = string.Empty;
            object loParametro = null;

            Periodos periodosInstalacion = Periodos.Instancia;

            tcAlias = tcAlias.Trim();
            tcCampo = tcCampo.Trim();

            // Puede que nos interese realizar un filtro sin alicar el ALIAS
            if (string.IsNullOrWhiteSpace(tcAlias))
            {
                lcAlias = "";
            }
            else
            {
                lcAlias = tcAlias + ".";
            }


            //Creo el diccionario de retorno
            Dictionary<string, string> FiltroFechasPorEjercicio = new Dictionary<string, string>();

            //Si no hay ejercicios acabo
            if (taEjecicios == null || taEjecicios.Count() == 0)
                return FiltroFechasPorEjercicio;

            foreach (var ejercio in taEjecicios)
            {
                FiltroFechasPorEjercicio.Add(ejercio, ""); //Creo una entrada por cada ejercicio
            }
            bool ejercicioUnico = taEjecicios.Count() == 1;

            // Filtro Lista
            toFiltros.TryGetValue((teFiltro + "Lista"), out loParametro);
            if (loParametro != null)
            {
                List<string> loLista;
                if (loParametro is string)
                    loLista = new List<String>(loParametro.ToString().Split(','));
                else
                    loLista = (List<string>)loParametro;

                //Convierto a lista de objetos DateTime
                List<DateTime> listaFechas = new List<DateTime>();
                loLista.ForEach(loEle => listaFechas.Add(Convert.ToDateTime(loEle)));

                DateTime periodoIni = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));
                DateTime periodoFin = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodofin"));
                int ejercicioActual = Convert.ToInt32(EW_GLOBAL._GetVariable("wc_any").ToString());

                int diaPeriodoIni = periodoIni.Day;
                int mesPeriodoIni = periodoIni.Month;
                int anyPeriodoIni = periodoIni.Year;
                int correccionIni = ejercicioActual - anyPeriodoIni; //Determino un factor de correccion por si estamos en ejercicio partido

                int diaPeriodoFin = periodoFin.Day;
                int mesPeriodoFin = periodoFin.Month;
                int anyPeriodoFin = periodoFin.Year;
                int correccionFin = ejercicioActual - anyPeriodoFin; //Determino un factor de correccion por si estamos en ejercicio partido

                foreach (var ejercicio in taEjecicios)
                {
                    string lcFiltroFecha = string.Empty;

                    //Fabrico un rango de fechas
                    DateTime fechaIni = new DateTime(Convert.ToInt32(ejercicio) - correccionIni, mesPeriodoIni, diaPeriodoIni);
                    DateTime fechaFin = new DateTime(Convert.ToInt32(ejercicio) - correccionFin, mesPeriodoFin, diaPeriodoFin);

                    //Obtengo las fechas que cumplen
                    var fechasEnRango = listaFechas.Where(d => d.CompareTo(fechaIni) >= 0 && d.CompareTo(fechaFin) <= 0).ToList();
                    if (ejercicioUnico) //Si el ejercicio es único respeto lo del cliente tal cual
                        fechasEnRango = listaFechas;

                    if (fechasEnRango.Any())
                    {
                        lcFiltroFecha = lcAlias + tcCampo + " IN (";

                        int lnInd = 0;
                        foreach (DateTime fechaEnRango in fechasEnRango)
                        {
                            lnInd++;
                            lcFiltroFecha += DB.SQLString(fechaEnRango);

                            if (fechasEnRango.Count == lnInd)
                                lcFiltroFecha += ")";
                            else
                                lcFiltroFecha += ",";
                        }
                    }
                    else
                    {
                        lcFiltroFecha = " 1=2 "; //No me ha dado ninguna fecha para ese ejercicio => Descarto todos los datos
                    }
                    FiltroFechasPorEjercicio[ejercicio] = lcFiltroFecha;
                }
                // fi 83330
            }
            else
            {
                // Fecha desde
                toFiltros.TryGetValue(teFiltro + "Desde", out loParametro);
                if (loParametro != null)
                {
                    ldFechaDesde = Convert.ToDateTime(loParametro);
                    llFechaDesde = true;
                }
                loParametro = null;

                // Fecha hasta
                toFiltros.TryGetValue(teFiltro + "Hasta", out loParametro);
                if (loParametro != null)
                {
                    ldFechaHasta = Convert.ToDateTime(loParametro);
                    loParametro = null;
                    llFechaHasta = true;
                }

                // Filtro único
                toFiltros.TryGetValue((teFiltro + "Unico"), out loParametro);
                if (loParametro != null && !string.IsNullOrWhiteSpace(loParametro.ToString()))
                {
                    ldFechaUnica = Convert.ToDateTime(loParametro);
                    loParametro = null;
                    llFechaUnica = true;
                }
                else
                {
                    // Para mejorar rendimiento (unico es mejor que rango) => Miro si el desde y el hasta son iguales
                    if (llFechaDesde && llFechaHasta && ldFechaDesde == ldFechaHasta)
                    {
                        ldFechaUnica = ldFechaDesde;
                        llFechaUnica = true;
                    }
                    else
                    {
                        if (EnWidget && teFiltro == _Tipo_Filtro_Fecha.Fecha.ToString())
                        {
                            //Solo para listados contenidos en un widget, se aplicara para el filtro principal de fecha el periodo inicial/final
                            if (ldFechaDesde == null)
                            {
                                ldFechaDesde = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));
                                llFechaDesde = true;
                            }
                            if (ldFechaHasta == null)
                            {
                                ldFechaHasta = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodofin"));
                                llFechaHasta = true;
                            }
                            llFechaUnica = false;
                        }
                    }
                }

                if (llFechaUnica)
                {
                    //No admito el filtrado único a excepción del año real
                    foreach (var ejercicio in taEjecicios)
                    {
                        var periodo = periodosInstalacion.GetPeriodo(ejercicio);
                        if (periodo != null)
                        {
                            if (periodo.PerteneceAlPeriodo(ldFechaUnica.Value))
                                FiltroFechasPorEjercicio[ejercicio] = lcAlias + tcCampo + " = " + DB.SQLString(ldFechaUnica);
                            else
                                FiltroFechasPorEjercicio[ejercicio] = " 1=2 "; //Invalido el filtro, nadie de ese ejercicio lo va a cumplir
                        }
                    }
                }
                else
                {
                    if (llFechaDesde || llFechaHasta) // Si tengo inicial o final
                    {
                        foreach (var ejercicio in taEjecicios)
                        {
                            string lcFiltroFecha = string.Empty;
                            PeriodoItem current = periodosInstalacion.GetPeriodo(ejercicio);
                            if (llFechaDesde)
                            {
                                if (current.PerteneceAlPeriodo(ldFechaDesde.Value) || ejercicioUnico) //Si el ejercicio es único asigno los valores del usuario
                                    lcFiltroFecha += lcAlias + tcCampo + " >= " + DB.SQLString(ldFechaDesde); //Si es la fecha inicial la asigno
                                else
                                    lcFiltroFecha += lcAlias + tcCampo + " >= " + DB.SQLString(current.PeriodoIni); //Sino asigno inicio período
                            }
                            if (llFechaHasta)
                            {
                                if (llFechaDesde) //Continuación del string de filtro
                                    lcFiltroFecha += " AND ";

                                if (current.PerteneceAlPeriodo(ldFechaHasta.Value) || ejercicioUnico) //Si el ejercicio es único asigno los valores del usuario
                                    lcFiltroFecha += lcAlias + tcCampo + " <= " + DB.SQLString(ldFechaHasta);
                                else
                                    lcFiltroFecha += lcAlias + tcCampo + " <= " + DB.SQLString(current.PeriodoFin);  //Sino asigno fin período
                            }
                            FiltroFechasPorEjercicio[ejercicio] = lcFiltroFecha;
                        }
                    }
                    else //No soy Unico, ni desde, ni hasta, ni lista => Genero periodos genéricos
                    {
                        if (ejercicioUnico)
                        {
                            FiltroFechasPorEjercicio[taEjecicios[0]] = ""; //Filtro vacio para ejercicio único en modalidad TODOS
                        }
                        else
                        {
                            foreach (var ejercicio in taEjecicios)
                            {
                                var periodo = periodosInstalacion.GetPeriodo(ejercicio);
                                if (periodo != null)
                                {
                                    FiltroFechasPorEjercicio[ejercicio] = periodo.ToFilterString(lcAlias, tcCampo);
                                }
                            }
                        }
                    }
                }
            }

            //Añado los operadores a cada filtro
            foreach (var ejercicio in taEjecicios)
            {
                FiltroFechasPorEjercicio[ejercicio] = FiltroFechaPorEjercicio_AddOperator(teOperador, FiltroFechasPorEjercicio[ejercicio]);
            }

            //Devuelvo el diccionario
            return FiltroFechasPorEjercicio;
        }

        private string FiltroFechaPorEjercicio_AddOperator(_Operador_Condicional teOperador, string lcFiltroFecha)
        {
            if (!string.IsNullOrWhiteSpace(lcFiltroFecha))
            {
                switch (teOperador)
                {
                    case _Operador_Condicional.And:
                        lcFiltroFecha = " And " + lcFiltroFecha;
                        break;

                    case _Operador_Condicional.Or:
                        lcFiltroFecha = " Or " + lcFiltroFecha;
                        break;

                    case _Operador_Condicional.None:
                        break;

                    default:
                        break;
                }
            }
            return lcFiltroFecha;
        }

        //private List<PeriodoItem> CargarDatosDePeriodos()
        //{
        //    List<PeriodoItem> periodos = new List<PeriodoItem>();
        //    DataTable dtPeriodos = new DataTable();
        //    if (DB.SQLExec("SELECT [any] AS ejer, periodoini, periodofin, anterior FROM " + DB.SQLDatabase("COMUNES", "EJERCICI"), ref dtPeriodos))
        //    {
        //        dtPeriodos.AsEnumerable().Cast<DataRow>()
        //                  .ToList().ForEach(loRow => periodos.Add(new PeriodoItem(loRow.Field<string>("ejer"),
        //                                                                      loRow.Field<DateTime>("periodoini"),
        //                                                                      loRow.Field<DateTime>("periodofin"),
        //                                                                      loRow.Field<string>("anterior"))));
        //    }
        //    return periodos;
        //}

        protected void ReordenarColumnasEjercicioPartido(ref DataTable tdtDatos)
        {
            if (TrabajaConEjercicioPartido)
            {
                DateTime periodoIni = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));

                switch (_eOpcAgruparPor)
                {
                    case _eAgruparPor.dia:

                        //Congiguro los valores para determinar el desplazamiento
                        DateTime expectedIni = new DateTime(year: periodoIni.Year, month: 1, day: 1); //De entrada esperamos año natural

                        //Calculo la diferencia => Ojo con febrero
                        TimeSpan diferencia = periodoIni - expectedIni;
                        if (diferencia.Days >= 60) //Incluye febrero que esta contado a 29 días para poder unir años bisiesto con normales (UNION ALL requiere mismo número de columnas)
                            diferencia = diferencia = periodoIni - expectedIni.AddDays(-1);

                        for (int i = 1; i <= diferencia.Days; i++)
                        {
                            //Tal como la mueva, la 2 pasa a ser la 1 => indice fijo
                            tdtDatos.Columns[1].SetOrdinal(tdtDatos.Columns.Count - 1); //La paso al final
                        }
                        break;

                    case _eAgruparPor.semana:
                        break;
                    case _eAgruparPor.mes: //CCR 143805

                        int primerMes = periodoIni.Month;
                        for (int i = 1; i < primerMes; i++)
                        {
                            //Tal como la mueva, la 2 pasa a ser la 1 => indice fijo
                            tdtDatos.Columns[1].SetOrdinal(tdtDatos.Columns.Count - 1); //La paso al final
                        }

                        break;
                    case _eAgruparPor.trimestre:
                        break;
                    case _eAgruparPor.semestre:
                        break;

                    //No hay que hacer nada
                    case _eAgruparPor.año:
                    case _eAgruparPor.nada:
                    default:
                        break;
                }
            }
        }

        #endregion Métodos auxiliares

        //public class Periodos
        //{
        //    /// <summary>
        //    /// Colecciñon de períodos
        //    /// </summary>
        //    private IEnumerable<PeriodoItem> _periodos;

        //    /// <summary>
        //    /// Constructor de la clase 
        //    /// </summary>
        //    public Periodos()
        //    {
        //        CargarDatosDePeriodos();
        //    }

        //    /// <summary>
        //    /// Método auxiliar para la carga de períodos
        //    /// </summary>
        //    private void CargarDatosDePeriodos()
        //    {
        //        List<PeriodoItem> periodos = new List<PeriodoItem>();
        //        DataTable dtPeriodos = new DataTable();
        //        if (DB.SQLExec("SELECT [any] AS ejer, periodoini, periodofin, anterior FROM " + DB.SQLDatabase("COMUNES", "EJERCICI"), ref dtPeriodos))
        //        {
        //            dtPeriodos.AsEnumerable().Cast<DataRow>()
        //                      .ToList().ForEach(loRow => periodos.Add(new PeriodoItem(loRow.Field<string>("ejer"),
        //                                                                              loRow.Field<DateTime>("periodoini"),
        //                                                                              loRow.Field<DateTime>("periodofin"),
        //                                                                              loRow.Field<string>("anterior"))));
        //        }
        //        _periodos = periodos;
        //    }

        //    /// <summary>
        //    /// Obtiene el período correspondiente al ejercicio pasado como parámetro
        //    /// </summary>
        //    /// <param name="tcEjercicio">Ejercicio del que obtener el período</param>
        //    /// <returns></returns>
        //    public PeriodoItem GetPeriodo(string tcEjercicio)
        //    {
        //        return _periodos.Where(p => p.Ejercicio == tcEjercicio.TrimEnd()).FirstOrDefault();
        //    }

        //    /// <summary>
        //    /// Método que determina si existe el ejercicio anterior al indicado
        //    /// </summary>
        //    /// <param name="tcEjercicio"></param>
        //    /// <returns></returns>
        //    public bool ExisteEjercicioAnteriorAl(string tcEjercicio)
        //    {
        //        var periodo = GetPeriodo(tcEjercicio); //Obtengo periodo recibido por parametro
        //        if (periodo != null)
        //        {
        //            return _periodos.Count(p => p.Ejercicio == periodo.Anterior) > 0;
        //        }
        //        else
        //        {
        //            return false;
        //        }
        //    }
        //}

        //public class PeriodoItem
        //{
        //    /// <summary>
        //    /// Ejercicio
        //    /// </summary>
        //    public string Ejercicio { get; set; }
        //    /// <summary>
        //    /// Fecha de inicio de período
        //    /// </summary>
        //    public DateTime PeriodoIni { get; set; }
        //    /// <summary>
        //    /// Fecha de fin de período
        //    /// </summary>
        //    public DateTime PeriodoFin { get; set; }
        //    /// <summary>
        //    /// Ejercicio anterior
        //    /// </summary>
        //    public string Anterior { get; set; }

        //    /// <summary>
        //    /// Constructor
        //    /// </summary>
        //    /// <param name="tcEjecicio"></param>
        //    /// <param name="tdPeriodoIni"></param>
        //    /// <param name="tdPeriodoFin"></param>
        //    public PeriodoItem(string tcEjecicio, DateTime tdPeriodoIni, DateTime tdPeriodoFin, string tcAnterior)
        //    {
        //        Ejercicio = tcEjecicio.TrimEnd();
        //        PeriodoIni = tdPeriodoIni;
        //        PeriodoFin = tdPeriodoFin;
        //        Anterior = tcAnterior.TrimEnd();
        //    }

        //    public string ToString(string tcAlias, string tcCampo)
        //    {
        //        string lcPeriodo = tcAlias + tcCampo + " >= " + DB.SQLString(PeriodoIni) +
        //                           " AND " + tcAlias + tcCampo + " <= " + DB.SQLString(PeriodoFin);
        //        return lcPeriodo;
        //    }

        //    /// <summary>
        //    /// Método que determina si una fecha pertenece al período
        //    /// </summary>
        //    /// <param name="tdFecha"></param>
        //    /// <returns></returns>
        //    public bool PerteneceAlPeriodo(DateTime tdFecha)
        //    {
        //        return (tdFecha.CompareTo(PeriodoIni) >= 0 && tdFecha.CompareTo(PeriodoFin) <= 0);
        //    }
        //}
    }
}