RetencionRepercutida.cs

using sage.ew.db;
using sage.ew.global;
using sage.ew.listados.Clases;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;

namespace sage.ew.contabilidad
{
    public class RetencionRepercutida : RetencionBase
    {
        

        #region Constructor
        public RetencionRepercutida()
        {
            VerImportes0 = true;
        }
        #endregion Constructor

        # region Métodos públicos override de la clase listados

        public override string _ReportFile
        {
            get
            {
                return "retencion_repercutida.report";
            }
        }

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

                _dicDefEntidades = new Dictionary<string, ew.interficies.IDefEntidad>
                {
                    { "numfra", new DefEntidad() { _DB = "COMUNES", _Tabla = "PREVIS", _Campo = "FACTURA", _Relacion = "", _Empresa = true } },
                    { "cuenta", new DefEntidad() { _DB = "GESTION", _Tabla = "PROVEED", _Campo = "CODIGO", _Relacion = "", _Empresa = false } },
                    { "codigo_ret", new DefEntidad() { _DB = "GESTION", _Tabla = "TIPO_RET", _Campo = "CODIGO", _Relacion = "", _Empresa = false } }
                };

                ldReportColumns.Add("cuenta");
                ldReportColumns.Add("nombre");
                ldReportColumns.Add("cif");
                ldReportColumns.Add("fecha");
                ldReportColumns.Add("numfra");
                ldReportColumns.Add("base_ret");
                ldReportColumns.Add("tpc_ret");
                ldReportColumns.Add("total_ret");
                ldReportColumns.Add("codigo_ret");
                ldReportColumns.Add("nombre_ret");
                ldReportColumns.Add("g_contri");
                ldReportColumns.Add("nombre_g_contri");

                return ldReportColumns;
            }
        }

        public override void _SetColumnCaptions(Dictionary<string, string> tldTranslate = null)
        {
            Dictionary<string, string> ldTranslate = new Dictionary<string, string>();

            if (tldTranslate != null)
            {
                ldTranslate = tldTranslate;
            }

            ldTranslate.Add("nombre", "Definición cuenta");
            ldTranslate.Add("numfra", "Factura");
            ldTranslate.Add("base_ret", "Base retención");
            ldTranslate.Add("tpc_ret", "% retención");
            ldTranslate.Add("total_ret", "Total retención");

            ldTranslate.Add("codigo_ret", "Tipo retención");
            ldTranslate.Add("nombre_ret", "Nombre retención");
            ldTranslate.Add("g_contri", "Grupo de contribuyente");
            ldTranslate.Add("nombre_g_contri", "Nombre grupo de contribuyente");


            base._SetColumnCaptions(ldTranslate);
        }

        public override void _SetColumnMasks()
        {
            if (_Resultados == null)
                return;

            foreach (DataColumn ldc in _Resultados.Columns)
            {
                switch (ldc.ColumnName.ToString().Trim())
                {
                    case "base_ret":
                    case "total_ret":
                        ldc.ExtendedProperties.Add("Mascara", _Mascara_Importe);
                        break;

                    case "tpc_ret":
                        ldc.ExtendedProperties.Add("Mascara", _Mascara_TPC);
                        break;
                }
            }

            base._SetColumnMasks();
        }

        public override Dictionary<string, string> _NavigateButtonsCheck
        {
            get
            {
                if (llImprimircertificado)
                {
                    return new Dictionary<string, string>() { { "certificado", "Imprimir certificado" } };
                }
                else
                {
                    return new Dictionary<string, string>();
                }
            }
        }

        public override void _NavigateChecks(string tcKeyNavigate, DataRow[] trRowList)
        {
            botones.Clases.btImprimir btImprimir = new botones.Clases.btImprimir();
            switch (tcKeyNavigate)
            {
                case "certificado":

                    if (trRowList.Length > 0)
                    {

                        string lcNombreEmpresa = EW_GLOBAL._GetVariable("wc_EmpNombre1").ToString().Trim();
                        string lcCIFEmpresa = EW_GLOBAL._GetVariable("wc_EmpCif").ToString().Trim();
                        string lcDireccionEmpresa = EW_GLOBAL._GetVariable("wc_EmpDireccion").ToString().Trim();
                        string lcCodigoPostalEmpresa = EW_GLOBAL._GetVariable("wc_EmpCodPos").ToString().Trim();
                        string lcPoblacionEmpresa = EW_GLOBAL._GetVariable("wc_EmpPoblacion").ToString().Trim();
                        string lcProvinciaEmpresa = EW_GLOBAL._GetVariable("wc_EmpProvincia").ToString().Trim();

                        DataTable yourEmptyDataTable = new DataTable();

                        if (trRowList.Any())
                        {
                            yourEmptyDataTable = trRowList[0].Table.Clone();
                        }

                        foreach (DataRow row in trRowList)
                        {
                            if (!string.IsNullOrWhiteSpace(Convert.ToString(row[0])))
                            {
                                yourEmptyDataTable.ImportRow(row);
                            }
                        }

                        yourEmptyDataTable.Columns.Add(new DataColumn("direccion", typeof(string)));
                        yourEmptyDataTable.Columns.Add(new DataColumn("poblacion", typeof(string)));
                        yourEmptyDataTable.Columns.Add(new DataColumn("provincia", typeof(string)));

                        foreach (DataRow row in yourEmptyDataTable.Rows)
                        {
                            Dictionary<string, object> loProveedor = DB.SQLREGValor("PROVEED", "CODIGO", row["cuenta"].ToString(), "GESTION");

                            row["direccion"] = loProveedor["direccion"];
                            row["poblacion"] = loProveedor["poblacion"];
                            row["provincia"] = loProveedor["provincia"];
                        }


                        btImprimir._Report = "certificado_retenciones.report";

                        btImprimir._DataTable = yourEmptyDataTable;

                        btImprimir._Title = "Certificado de retenciones   Ejercicio " + EW_GLOBAL._GetVariable("wc_any").ToString().Trim();

                        btImprimir._AddFiltros("PrimeraCabecera", lcNombreEmpresa + " con CIF. " + lcCIFEmpresa + " y domicilio en " + lcDireccionEmpresa);
                        btImprimir._AddFiltros("SegundaCabecera", lcCodigoPostalEmpresa + " " + lcPoblacionEmpresa + " (" + lcProvinciaEmpresa + ")");

                        btImprimir._AddFiltros("PieDocumento", lcPoblacionEmpresa + ", " + DateTime.Today.ToString(EW_GLOBAL._CustomFormatDate));

                        btImprimir.PerformClick();
                        btImprimir._Report = string.Empty;
                            
                    }

                    break;
            }

            base._NavigateChecks(tcKeyNavigate, trRowList);
        }

        public override bool _Valid()
        {
            _InicializarPropiedadesFiltros();

            if (llImprimircertificado && lIncluirnperceptores)
            {
                _Error_Message = "La opción 'Incluir nº perceptores' no es compatible con la opción 'Imprimir certificado'.";
                return false;
            }

            if (llImprimircertificado && !lAgruparporcuenta)
            {
                _Error_Message = "Para imprimir el certificado, debe seleccionar la opción de 'Agrupar por cuenta'.";
                return false;
            }

            return base._Valid();
        }


        public override DataTable _DataTable()
        {
            DataTable ldtResult = new DataTable();
            DataTable ldtModiCuotas = new DataTable();      // Datatable para facturas negativas y rectificativas (utilizaremos en cuadro resumen de IVA)

            bool llOk = false;

            _InicializarPropiedadesFiltros();

            llOk = ConsultarRetencion(ref ldtResult); // Consultamos las registros de retencion

            if (llOk)
            {
                if (lAgruparporcuenta)
                {
                    _AgruparCuenta(ref ldtResult);
                }

                if (!llImprimircertificado)
                {
                    _TotalizarRetencion(ref ldtResult);
                }
            }

            if (_lNormal && ldtResult.Columns.Contains("empresa"))
            {
                ldtResult.Columns.Remove("empresa");
            }

            return ldtResult;
        }

        protected internal bool ConsultarRetencion(ref DataTable tdtResult)
        {
            //Invoco la implementación con las funciones por defecto
            return ConsultarRetencion_Impl(ref tdtResult, GetDefaultEjercicios, GetDefaultFiltroWhereRetencion);
        }

        private bool ConsultarRetencion_Impl(ref DataTable tdtResult, Func<string[]> selectorEjercicios, Func<string> whereClauseGenerator)
        {
            string lcSql = string.Empty;
            bool llOk;

            string lcWhere = whereClauseGenerator.Invoke();
            //156116: Es el whereClauseGenerator el que rellena la variable ejercicios que devuelve este selector
            string[] laEjercicios = selectorEjercicios.Invoke();


            lcSql = "SELECT retreper.empresa, retreper.cuenta, cuentas.nombre, cuentas.cif, retreper.fecha, retreper.numfra, " +
                            " retreper.codigo_ret, tipo_ret.nombre as nombre_ret, " +
                            " COALESCE(g_contri.codigo,'') as g_contri, COALESCE(g_contri.nombre,'') as nombre_g_contri, " +
                            " retreper.base as base_ret, retreper.tipo_ret as tpc_ret, retreper.retencio as total_ret " +
                            _CamposExtra() + Environment.NewLine +
                    " FROM ([multiples_ejercicios].dbo.retreper " + Environment.NewLine +
                            " LEFT JOIN [multiples_ejercicios].dbo.cuentas ON retreper.cuenta = cuentas.codigo) " + Environment.NewLine +
                            " INNER JOIN [multiples_ejercicios].dbo.asientos ON retreper.asi = asientos.asi " + Environment.NewLine +
                            " INNER JOIN [multiples_ejercicios].dbo.tipo_ret ON retreper.codigo_ret = tipo_ret.codigo " + Environment.NewLine +
                            " LEFT JOIN " + DB.SQLDatabase("COMUNES", "G_CONTRI") + " ON tipo_ret.g_contri = g_contri.codigo " + Environment.NewLine +
                    _JoinsExtra() + Environment.NewLine +
                    lcWhere + Environment.NewLine +
                    " ORDER BY retreper.numfra, retreper.fecha ";


            llOk = DB.SQLExecEjer(lcSql, ref tdtResult, laEjercicios);

            return llOk;
        }

        private string[] GetDefaultEjercicios()
        {
            return _cEjercicios;
        }

        private string GetDefaultFiltroWhereRetencion()
        {
            return _WhereFiltrosRetencion("retreper", "tipo_ret");
        }

        protected internal virtual string _CamposExtra()
        {
            return "";
        }

        protected internal virtual string _JoinsExtra()
        {
            return "";
        }

        #endregion

        #region Métodos protected override de la clase IVA

        protected override void _InicializarPropiedadesFiltros()
        {
            base._InicializarPropiedadesFiltros();

            llImprimircertificado = _Opcion_Logico("lImprimircertificad");

            // En compras siempre tenemos el filtro por fecha de asiento
            _cCampoFecha = "fecha";
        }

        protected override string _CampoIVA()
        {
            return "reper";
        }

        protected override string GetAliasTablaIva()
        {
            return "retreper";
        }

        

        # endregion Métodos protected override de la clase IVA
    }
}