internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.AppendFormat(" h.empresa='{0}' ", Empresa);



            if (!string.IsNullOrEmpty(LotesDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("lotesdesde", LotesDesde);
                sb.Append(" h.lote >= @lotesdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.LoteDesde, LotesDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(LotesHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("loteshasta", LotesHasta);
                sb.Append(" h.lote <= @loteshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.LoteHasta, LotesHasta));
                flag = true;
            }


            if (!string.IsNullOrEmpty(Fkarticulos))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticulos", Fkarticulos);
                sb.Append(" h.fkarticulos >= @fkarticulos  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Fkarticulos, Fkarticulos));
                flag = true;
            }

            return(sb.ToString());
        }
        private string GenerarFiltrosPedidosCompras()
        {
            var sb = new StringBuilder();

            if (!string.IsNullOrEmpty(Estadoañadirpedidoscompra) && Estadoañadirpedidoscompra != "0-")
            {
                sb.Append(" AND ");

                ValoresParametros.Add("estadopedidoscompra", Estadoañadirpedidoscompra);
                sb.Append(" concat(ec.documento,'-',ec.id) = @estadopedidoscompra  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Añadirpedidoscompra, Estadosañadirpedidoscompra.Single(f => f.CampoId == Estadoañadirpedidoscompra).Descripcion));
            }


            return(sb.ToString());
        }
        private string GenerarFiltrosReservas()
        {
            var sb = new StringBuilder();

            if (!string.IsNullOrEmpty(Estadodescontarreservasstock) && Estadodescontarreservasstock != "0-")
            {
                sb.Append(" AND ");

                ValoresParametros.Add("estadoreservas", Estadodescontarreservasstock);
                sb.Append(" concat(er.documento,'-',er.id) = @estadoreservas  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Descontarreservasstock, Estadosdescontarreservasstock.Single(f => f.CampoId == Estadodescontarreservasstock).Descripcion));
            }


            return(sb.ToString());
        }
        private string GenerarFiltrosPedidosVentas()
        {
            var sb = new StringBuilder();

            if (Estadodescontarpedidostaller != "0-")
            {
                sb.Append(" AND ");

                ValoresParametros.Add("estadopedidostaller", Estadodescontarpedidostaller);
                sb.Append(" concat(ep.documento,'-',ep.id) = @estadopedidostaller  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Descontarpedidostaller, Estadosdescontarpedidostaller.Single(f => f.CampoId == Estadodescontarpedidostaller).Descripcion));
            }


            return(sb.ToString());
        }
Beispiel #5
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();

            ValoresParametros.Clear();
            Condiciones.Clear();

            if (Modulos.Count != 0)
            {
                sb.Append(" t.empresa = '" + Empresa + "' ");

                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaInforme, FechaInforme));


                if (FechaAperturaDesde.HasValue)
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("fechaaperturadesde", FechaAperturaDesde.Value);
                    sb.Append(" t.fechadocumento>=@fechaaperturadesde ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.FechaAperturaDesde, FechaAperturaDesde));
                }

                if (FechaAperturaHasta.HasValue)
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("fechaaperturahasta", FechaAperturaHasta.Value);
                    sb.Append(" t.fechadocumento<=@fechaaperturahasta ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.FechaAperturaHasta, FechaAperturaHasta));
                }

                if (FechaProxSeguiDesde.HasValue)
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("fechaproxseguidesde", FechaProxSeguiDesde.Value);
                    sb.Append(" t.fechaproximoseguimiento>=@fechaproxseguidesde ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.FechaProxSeguiDesde, FechaProxSeguiDesde));
                }

                if (FechaProxSeguiHasta.HasValue)
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("fechaproxseguihasta", FechaProxSeguiHasta.Value);
                    sb.Append(" t.fechaproximoseguimiento<=@fechaproxseguihasta ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.FechaProxSeguiHasta, FechaProxSeguiHasta));
                }

                if (!string.IsNullOrEmpty(TerceroDesde))
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("tercerodesde", TerceroDesde);
                    sb.Append("  [Cod. tercero] = @tercerodesde  ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.TerceroDesde, TerceroDesde));
                }

                if (!string.IsNullOrEmpty(TerceroHasta))
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("tercerohasta", TerceroHasta);
                    sb.Append("  [Cod. tercero] = @tercerohasta ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.TerceroHasta, TerceroHasta));
                }

                if (Cerrado == "0" || Cerrado == "1")
                {
                    sb.Append(" AND ");
                    ValoresParametros.Add("cerrado", Cerrado);
                    sb.Append(" t.cerrado = @cerrado ");
                    Condiciones.Add(string.Format("{0}: {1}", RCrm.Cerrado, Cerrado));
                }
            }
            return(sb.ToString());
        }
Beispiel #6
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" p.empresa = '" + Empresa + "' ");

            if (Series?.Any() ?? false)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                foreach (var item in Series)
                {
                    ValoresParametros.Add(item, item);
                }

                sb.Append(" p.fkseries in ( " + string.Join(", ", Series.ToArray().Select(f => "@" + f)) + " ) ");
                Condiciones.Add(string.Format("{0}: {1}", RPresupuestosCompras.SeriesListado, string.Join(", ", Series.ToArray())));
                flag = true;
            }
            if (!string.IsNullOrEmpty(Estado) && !Estado.Equals("0-"))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("estado", Estado);
                sb.Append(" p.fkestados=@estado ");
                Condiciones.Add(string.Format("{0}: {1}", RPresupuestosCompras.Estado, Estados.First(f => f.CampoId == Estado).Descripcion));
                flag = true;
            }

            if (FechaDesde.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" p.fechadocumento>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RPresupuestosCompras.FechaDesde, FechaDesde));
                flag = true;
            }

            if (FechaHasta.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" p.fechadocumento<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RPresupuestosCompras.FechaHasta, FechaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.Append(" p.fkproveedores>=@cuentadesde ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaDesde, CuentaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.Append(" p.fkproveedores<=@cuentahasta ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaHasta, CuentaHasta));
                flag = true;
            }


            if (!string.IsNullOrEmpty(Fkfamiliacliente))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliacliente", Fkfamiliacliente);
                sb.Append(" c.fkfamiliaproveedor=@fkfamiliacliente ");
                Condiciones.Add(string.Format("{0}: {1}", RProveedores.Fkfamiliaproveedor, Fkfamiliacliente));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkzonacliente))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkzonacliente", Fkzonacliente);
                sb.Append(" c.fkzonaproveedor=@fkzonacliente ");
                Condiciones.Add(string.Format("{0}: {1}", RProveedores.Fkzonaproveedor, Fkzonacliente));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Agente))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("agente", Agente);
                sb.Append(" p.fkagentes = @agente ");
                Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkcuentasagente, Agente));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Comercial))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("comercial", Comercial);
                sb.Append(" p.fkcomerciales = @comercial ");
                Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkcuentascomercial, Comercial));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkpais))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("pais", Fkpais);
                sb.Append(" di.fkpais  =@pais ");
                Condiciones.Add(string.Format("{0}: {1}", RDireccion.Fkpais, AppService.GetListPaises().SingleOrDefault(f => f.Valor == Fkpais).Descripcion));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkmonedas))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                var serviceMonedas = FService.Instance.GetService(typeof(MonedasModel), Context);

                ValoresParametros.Add("Fkmonedas", Fkmonedas);
                sb.Append(" p.fkmonedas  =@Fkmonedas ");
                Condiciones.Add(string.Format("{0}: {1}", RPresupuestosCompras.Fkmonedas, serviceMonedas.getAll().Select(f => (MonedasModel)f).SingleOrDefault(f => f.Id == int.Parse(Fkmonedas)).Descripcion));
                flag = true;
            }

            return(sb.ToString());
        }
Beispiel #7
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" c.empresa = '" + Empresa + "' ");

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.Append(" c.fkcuentas>=@cuentadesde ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaDesde, CuentaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.Append(" c.fkcuentas<=@cuentahasta ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaHasta, CuentaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaDescripcionDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentadescripciondesde", CuentaDescripcionDesde);
                sb.Append(" cu.descripcion >=  @cuentadescripciondesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RClientes.DescripcionDesde, CuentaDescripcionDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaDescripcionHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentadescripcionhasta", CuentaDescripcionHasta + "ZZZZZZ");//Truño para que que coja todos los elementos. Por ejemplo : si ponemos hasta "e", no va a coger los que empiecen por "EA" si no ponemos eso
                sb.Append(" cu.descripcion <=  @cuentadescripcionhasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RClientes.DescripcionHasta, CuentaDescripcionHasta));
                flag = true;
            }

            if (Tipocuenta != TiposCuentas.Cuentastesoreria &&
                Tipocuenta != TiposCuentas.Agentes &&
                Tipocuenta != TiposCuentas.Aseguradoras &&
                Tipocuenta != TiposCuentas.Operarios &&
                Tipocuenta != TiposCuentas.Comerciales)
            {
                if (!string.IsNullOrEmpty(Fkunidadnegocio))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }
                    AppService = new ApplicationHelper(Context);
                    ValoresParametros.Add("fkunidadnegocio", Fkunidadnegocio);
                    sb.Append(" c.fkunidadnegocio = @fkunidadnegocio ");
                    Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkunidadnegocio, AppService.GetListUnidadNegocio().SingleOrDefault(f => f.Valor == Fkunidadnegocio).Descripcion));
                    flag = true;
                }

                if (!string.IsNullOrEmpty(Fktipoempresa))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }
                    AppService = new ApplicationHelper(Context);
                    ValoresParametros.Add("fktipoempresa", Fktipoempresa);
                    sb.Append(" c.fktipoempresa = @fktipoempresa ");
                    Condiciones.Add(string.Format("{0}: {1}", RClientes.Fktipoempresa, AppService.GetListTiposEmpresas().SingleOrDefault(f => f.Valor == Fktipoempresa).Descripcion));
                    flag = true;
                }
            }

            if (Tipocuenta == TiposCuentas.Clientes || Tipocuenta == TiposCuentas.Prospectos || Tipocuenta == TiposCuentas.Proveedores)
            {
                if (!string.IsNullOrEmpty(FamiliaCliente))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }
                    var columnafamilia = Tipocuenta == TiposCuentas.Proveedores ? "fkfamiliaproveedor" : "fkfamiliacliente";
                    ValoresParametros.Add("familiacliente", FamiliaCliente);
                    sb.AppendFormat(" c.{0} = @familiacliente ", columnafamilia);

                    Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkfamiliacliente, FamiliaCliente));
                    flag = true;
                }

                if (!string.IsNullOrEmpty(ZonaCliente))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }
                    var columnazona = Tipocuenta == TiposCuentas.Proveedores ? "fkzonaproveedor" : "fkzonacliente";
                    ValoresParametros.Add("zonacliente", ZonaCliente);
                    sb.AppendFormat(" c.{0} = @zonacliente ", columnazona);
                    Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkzonacliente, ZonaCliente));
                    flag = true;
                }
            }

            if (Tipocuenta == TiposCuentas.Clientes || Tipocuenta == TiposCuentas.Prospectos)
            {
                if (!string.IsNullOrEmpty(Agente))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }

                    ValoresParametros.Add("agente", Agente);
                    sb.Append(" c.fkcuentasagente = @agente ");
                    Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkcuentasagente, Agente));
                    flag = true;
                }

                if (!string.IsNullOrEmpty(Comercial))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }

                    ValoresParametros.Add("comercial", Comercial);
                    sb.Append(" c.fkcuentascomercial = @comercial ");
                    Condiciones.Add(string.Format("{0}: {1}", RClientes.Fkcuentascomercial, Comercial));
                    flag = true;
                }
            }


            if (!string.IsNullOrEmpty(Fkpais))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("pais", Fkpais);
                sb.Append(" di.fkpais  =@pais ");
                Condiciones.Add(string.Format("{0}: {1}", RDireccion.Fkpais, AppService.GetListPaises().SingleOrDefault(f => f.Valor == Fkpais).Descripcion));
                flag = true;
                if (!string.IsNullOrEmpty(Fkprovincia))
                {
                    if (flag)
                    {
                        sb.Append(" AND ");
                    }
                    using (var serviceProvincias = new ProvinciasService(Context, MarfilEntities.ConnectToSqlServer(Context.BaseDatos)))
                    {
                        var prov = serviceProvincias.get(Fkpais + "-" + Fkprovincia) as ProvinciasModel;
                        Condiciones.Add(string.Format("{0}: {1}", RDireccion.Fkprovincia, prov.Nombre));
                    }

                    ValoresParametros.Add("provincia", Fkprovincia);
                    sb.Append(" di.fkprovincia  =@provincia ");

                    flag = true;
                }
            }

            if (Bloqueado)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("bloqueado", Bloqueado);
                sb.Append(" cu.bloqueada= '" + Bloqueado.ToString().ToLower() + "'");
                Condiciones.Add(Bloqueado
                    ? string.Format("{0}", Rcuentas.BloqueoModel)
                    : string.Format("No {0}", Rcuentas.BloqueoModel));
                flag = true;
            }

            return(sb.ToString());
        }
Beispiel #8
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" p.empresa = '" + Empresa + "' ");

            if (Series?.Any() ?? false)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                foreach (var item in Series)
                {
                    ValoresParametros.Add(item, item);
                }

                sb.Append(" p.fkseries in ( " + string.Join(", ", Series.ToArray().Select(f => "@" + f)) + " ) ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.SeriesListado, string.Join(", ", Series.ToArray())));
                flag = true;
            }

            if (Estados?.Any() ?? false)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                sb.Append(" p.fkestados in ( " + string.Join(", ", Estados.ToArray().Select(f => "'" + f + "'")) + " ) ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Estado, string.Join(", ", Estados.Select(f => ListEstados.First(j => j.CampoId == f).Descripcion))));
                flag = true;
            }

            if (FechaDesde.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" p.fechadocumento>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FechaDesde, FechaDesde));
                flag = true;
            }

            if (FechaHasta.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" p.fechadocumento<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FechaHasta, FechaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.AppendFormat(" p.{0}>=@cuentadesde ", _columnatercero);
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaDesde, CuentaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.AppendFormat(" p.{0}<=@cuentahasta ", _columnatercero);
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaHasta, CuentaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticulosdesde", FkarticulosDesde);
                sb.Append(" pl.fkarticulos >= @fkarticulosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosDesde, FkarticulosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticuloshasta", FkarticulosHasta);
                sb.Append(" pl.fkarticulos <= @fkarticuloshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosHasta, FkarticulosHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkfamiliasmateriales))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("fkfamiliasmateriales", Fkfamiliasmateriales);
                sb.Append("  exists(select mm.* from materiales as mm where mm.id=Substring(pl.fkarticulos,3,3) and mm.fkfamiliamateriales=@fkfamiliasmateriales)  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaMateriales, AppService.GetListFamiliaMateriales().SingleOrDefault(f => f.Valor == Fkfamiliasmateriales).Descripcion));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliasdesde", FkfamiliasDesde);
                sb.Append(" Substring(pl.fkarticulos,0,3) >= @fkfamiliasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaDesde, FkfamiliasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliashasta", FkfamiliasHasta);
                sb.Append(" Substring(pl.fkarticulos,0,3) <= @fkfamiliashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaHasta, FkfamiliasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialesdesde", FkmaterialesDesde);
                sb.Append(" Substring(pl.fkarticulos,3,3) >= @fkmaterialesdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.MaterialesDesde, FkmaterialesDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialeshasta", FkmaterialesHasta);
                sb.Append(" Substring(pl.fkarticulos,3,3) <= @fkmaterialeshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.MaterialesHasta, FkmaterialesHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicasdesde", FkcaracteristicasDesde);
                sb.Append(" Substring(pl.fkarticulos,6,2) >= @fkcaracteristicasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.CaracteristicasDesde, FkcaracteristicasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicashasta", FkcaracteristicasHasta);
                sb.Append(" Substring(pl.fkarticulos,6,2) <= @fkcaracteristicashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.CaracteristicasHasta, FkcaracteristicasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoresdesde", FkgrosoresDesde);
                sb.Append(" Substring(pl.fkarticulos,8,2) >= @fkgrosoresdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.GrosoresDesde, FkgrosoresDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoreshasta", FkgrosoresHasta);
                sb.Append(" Substring(pl.fkarticulos,8,2) <= @fkgrosoreshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.GrosoresHasta, FkgrosoresHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadosdesde", FkacabadosDesde);
                sb.Append(" Substring(pl.fkarticulos,10,2) >= @fkacabadosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.AcabadosDesde, FkacabadosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadoshasta", FkacabadosHasta);
                sb.Append(" Substring(pl.fkarticulos,10,2) <= @fkacabadoshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.AcabadosHasta, FkacabadosHasta));
                flag = true;
            }



            return(sb.ToString());
        }
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();
            var flag = true;
            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" p.empresa = '" + Context.Empresa + "' ");

           
            if (!string.IsNullOrEmpty(Estado) && !Estado.Equals("0-"))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("estado", Estado);
                sb.Append(" p.fkestados=@estado ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.Estado, Estados?.First(f => f.CampoId == Estado).Descripcion??string.Empty));
                flag = true;
            }
            if (FechaDesde.HasValue)
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" p.fechadocumento>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FechaDesde, FechaDesde));
                flag = true;
            }

            if (FechaHasta.HasValue)
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" p.fechadocumento<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FechaHasta, FechaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(ArticuloDesde))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("articulodesde", ArticuloDesde);
                sb.Append(" pl.fkarticulos>=@articulodesde ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FkarticulosDesde, ArticuloDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(ArticuloHasta))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("articulohasta", ArticuloHasta);
                sb.Append(" pl.fkarticulos<=@articulohasta ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FkarticulosHasta, ArticuloHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(LoteDesde))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("lotedesde", LoteDesde);
                sb.Append(" pl.lote>=@lotedesde ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.LoteDesde, LoteDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(LoteHasta))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("lotehasta", LoteHasta);
                sb.Append(" pl.lote<=@lotedesde ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.LoteHasta, LoteHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.Append(" p.fkclientes>=@cuentadesde ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaDesde, CuentaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.Append(" p.fkclientes<=@cuentahasta ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaHasta, CuentaHasta));
                flag = true;
            }


            

            return sb.ToString();
        }
Beispiel #10
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            // Condición para coger el stockhistorico que no está en stockactual
            sb.AppendFormat("s.lote is NULL AND");
            sb.AppendFormat(" h.empresa='{0}' ", Empresa);
            if (!string.IsNullOrEmpty(Fkalmacen))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkalmacen", Fkalmacen);
                sb.Append(" h.fkalmacenes = @fkalmacen  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Fkalmacen, Fkalmacen));
                flag = true;
            }


            if (!string.IsNullOrEmpty(Fkzonasalmacen))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkzonasalmacen", Fkzonasalmacen);
                sb.Append(" h.fkalmaceneszona = @fkzonasalmacen  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Fkzonas, Fkzonasalmacen));
                flag = true;
            }

            if (Tipodealmacenlote.HasValue)
            {
                int    index           = Array.IndexOf(Enum.GetValues(Tipodealmacenlote?.GetType()), Tipodealmacenlote);
                string Tipoalmacenlote = index.ToString();
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("tipoalmacenlote", Tipoalmacenlote);
                sb.Append(" h.tipoalmacenlote = @tipoalmacenlote  ");

                switch (Tipodealmacenlote)
                {
                case TipoAlmacenlote.Mercaderia:
                {
                    Tipoalmacenlote = RAlbaranesCompras.TipoAlmacenLoteMercaderia;
                    break;
                }

                case TipoAlmacenlote.Gestionado:
                {
                    Tipoalmacenlote = RAlbaranesCompras.TipoAlmacenLoteGestionado;
                    break;
                }

                case TipoAlmacenlote.Propio:
                {
                    Tipoalmacenlote = RAlbaranesCompras.TipoAlmacenLotePropio;
                    break;
                }
                }
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranesCompras.TipoAlmacenLote, Tipoalmacenlote));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticulosdesde", FkarticulosDesde);
                sb.Append(" h.fkarticulos >= @fkarticulosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosDesde, FkarticulosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticuloshasta", FkarticulosHasta);
                sb.Append(" h.fkarticulos <= @fkarticuloshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosHasta, FkarticulosHasta));
                flag = true;
            }

            if (FechaDesde.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" alb.fechadocumento>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FechaDesde, FechaDesde));
                flag = true;
            }

            if (FechaHasta.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" alb.fechadocumento<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FechaHasta, FechaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.Append(" comp.fkproveedores>=@cuentadesde ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaDesde, CuentaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.Append(" comp.fkproveedores<=@cuentahasta ");
                Condiciones.Add(string.Format("{0}: {1}", Rcuentas.CuentaHasta, CuentaHasta));
                flag = true;
            }

            return(sb.ToString());
        }
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" a.empresa = '" + Empresa + "' ");


            if (!string.IsNullOrEmpty(FkarticulosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticulosdesde", FkarticulosDesde);
                sb.Append(" a.id >= @fkarticulosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FkarticulosDesde, FkarticulosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticuloshasta", FkarticulosHasta);
                sb.Append(" a.id <= @fkarticuloshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FkarticulosHasta, FkarticulosHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkfamiliasmateriales))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("fkfamiliasmateriales", Fkfamiliasmateriales);
                sb.Append("  exists(select mm.* from materiales as mm where mm.id=Substring(a.id,3,3) and mm.fkfamiliamateriales=@fkfamiliasmateriales)  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FamiliaMateriales, AppService.GetListFamiliaMateriales().SingleOrDefault(f => f.Valor == Fkfamiliasmateriales).Descripcion));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliasdesde", FkfamiliasDesde);
                sb.Append(" Substring(a.id,0,3) >= @fkfamiliasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FamiliaDesde, FkfamiliasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliashasta", FkfamiliasHasta);
                sb.Append(" Substring(a.id,0,3) <= @fkfamiliashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.FamiliaHasta, FkfamiliasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkgruposmateriales))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("fkgruposmateriales", Fkgruposmateriales);
                sb.Append(" a.fkgruposmateriales = @fkgruposmateriales  ");
                Condiciones.Add(string.Format("{0}: {1}", RMateriales.Fkgruposmateriales, Fkgruposmateriales));
                //Condiciones.Add(string.Format("{0}: {1}", RMateriales.Fkgruposmateriales, AppService.GetListGrupoMateriales().SingleOrDefault(f => f.Valor == Fkgruposmateriales).Descripcion));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialesdesde", FkmaterialesDesde);
                sb.Append(" Substring(a.id,3,3) >= @fkmaterialesdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.MaterialesDesde, FkmaterialesDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialeshasta", FkmaterialesHasta);
                sb.Append(" Substring(a.id,3,3) <= @fkmaterialeshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.MaterialesHasta, FkmaterialesHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicasdesde", FkcaracteristicasDesde);
                sb.Append(" Substring(a.id,6,2) >= @fkcaracteristicasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.CaracteristicasDesde, FkcaracteristicasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicashasta", FkcaracteristicasHasta);
                sb.Append(" Substring(a.id,6,2) <= @fkcaracteristicashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.CaracteristicasHasta, FkcaracteristicasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoresdesde", FkgrosoresDesde);
                sb.Append(" Substring(a.id,8,2) >= @fkgrosoresdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.GrosoresDesde, FkgrosoresDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoreshasta", FkgrosoresHasta);
                sb.Append(" Substring(a.id,8,2) <= @fkgrosoreshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.GrosoresHasta, FkgrosoresHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadosdesde", FkacabadosDesde);
                sb.Append(" Substring(a.id,10,2) >= @fkacabadosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.AcabadosDesde, FkacabadosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadoshasta", FkacabadosHasta);
                sb.Append(" Substring(a.id,10,2) <= @fkacabadoshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RPedidos.AcabadosHasta, FkacabadosHasta));
                flag = true;
            }



            return(sb.ToString());
        }
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();
            var flag = true;
            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" fa.empresa = '" + Empresa + "' ");
            

            if (Series?.Any() ?? false)
            {
                if (flag)
                    sb.Append(" AND ");

                foreach (var item in Series)
                    ValoresParametros.Add(item, item);

                sb.Append(" fa.fkseries in ( " + string.Join(", ", Series.ToArray().Select(f => "@" + f)) + " ) ");
                Condiciones.Add(string.Format("{0}: {1}", RFacturas.SeriesListado, string.Join(", ", Series.ToArray())));
                flag = true;
            }
            if (!string.IsNullOrEmpty(Estado) && !Estado.Equals("0-"))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("estado", Estado);
                sb.Append(" fa.fkestados=@estado ");
                Condiciones.Add(string.Format("{0}: {1}", RFacturas.Estado, Estados?.First(f => f.CampoId == Estado).Descripcion??string.Empty));
                flag = true;
            }
            if (FechaDesde.HasValue)
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" fa.fechadocumento>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RFacturas.FechaDesde, FechaDesde));
                flag = true;
            }

            if (FechaHasta.HasValue)
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" fa.fechadocumento<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RFacturas.FechaHasta, FechaHasta));
                flag = true;
            }

            var tipocuenta = Tipo == TipoComision.Agentes ? "fkagentes" : "fkcomerciales";

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.AppendFormat(" fa.{0}>=@cuentadesde ", tipocuenta);
                Condiciones.Add(string.Format("{0}: {1}", Funciones.GetEnumByStringValueAttribute(Tipo), CuentaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.AppendFormat(" fa.{0}<=@cuentahasta ", tipocuenta);
                Condiciones.Add(string.Format("{0}: {1}", Funciones.GetEnumByStringValueAttribute(Tipo), CuentaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(SituacionComision))
            {
                if (flag)
                    sb.Append(" AND ");

                ValoresParametros.Add("situacioncomision", SituacionComision);
                sb.AppendFormat(" fa.fksituacioncomision=@situacioncomision ");
                Condiciones.Add(string.Format("{0}: {1}", RFacturas.Fksituacioncomision, SituacionComision));
                flag = true;
            }
            if (flag)
                    sb.Append(" AND ");
                sb.AppendFormat(" (fa.{0} is not null and fa.{0} <>'' )", tipocuenta);
                flag = true;
            
            return sb.ToString();
        }
Beispiel #13
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" m.empresa = '" + Empresa + "' ");

            Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaInforme, FechaInforme));

            if (!string.IsNullOrEmpty(Fkseriescontables))
            {
                sb.Append(" AND ");

                ValoresParametros.Add("fkserie", Fkseriescontables);
                sb.Append(" m.fkseriescontables = @fkserie ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.Fkseriescontables, Fkseriescontables));
            }

            if (!string.IsNullOrEmpty(DocumentoDesde))
            {
                sb.Append(" AND ");
                ValoresParametros.Add("documentodesde", DocumentoDesde);
                sb.Append(" m.referencia>=@documentodesde ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.DocumentoDesde, DocumentoDesde));
            }

            if (!string.IsNullOrEmpty(DocumentoHasta))
            {
                sb.Append(" AND ");
                ValoresParametros.Add("documentohasta", DocumentoHasta);
                sb.Append(" m.referencia<=@documentohasta ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.DocumentoHasta, DocumentoHasta));
            }

            if (FechaDesde.HasValue)
            {
                sb.Append(" AND ");
                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" m.fecha>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaDesde, FechaDesde));
            }

            if (FechaHasta.HasValue)
            {
                sb.Append(" AND ");
                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" m.fecha<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaHasta, FechaHasta));
            }

            if (!string.IsNullOrEmpty(Tipoasiento))
            {
                sb.Append(" AND ");
                ValoresParametros.Add("Tipoasiento", Tipoasiento);
                sb.Append(" m.tipoasiento = @Tipoasiento  ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.TipoAsiento, Tipoasiento));
            }

            if (!string.IsNullOrEmpty(Canalcontable))
            {
                sb.Append(" AND ");
                ValoresParametros.Add("Canalcontable", Canalcontable);
                sb.Append(" m.canalcontable = @Canalcontable ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.Canalcontable, Canalcontable));
            }

            sb.Append(")");

            if (SumaAnteriorDebe > 0 || SumaAnteriorHaber > 0)
            {
                if (SumaAnteriorDebe == null)
                {
                    SumaAnteriorDebe = 0;
                }
                if (SumaAnteriorHaber == null)
                {
                    SumaAnteriorHaber = 0;
                }

                sb.Append(" UNION ");
                ValoresParametros.Add("Sumaanteriordebe", SumaAnteriorDebe);
                ValoresParametros.Add("Sumaanteriorhaber", SumaAnteriorHaber);
                sb.Append(" (SELECT '' AS [Doc.], NULL AS[Fecha], '' AS[Cuenta Debe], '' AS[Cuenta Haber], '' AS[Descripcion], ");
                sb.Append(" 'SUMA ANTERIOR' AS [Comentario], @Sumaanteriordebe AS [Debe], @Sumaanteriorhaber AS [Haber], 0 AS [Orden])");
            }

            sb.Append(")t");

            return(sb.ToString());
        }
Beispiel #14
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" p.empresa = '" + Context.Empresa + "' ");

            if (Estado.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("estado", (int)Estado.Value);
                sb.Append(" p.estado=@estado ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Estado, Funciones.GetEnumByStringValueAttribute(Estado.Value)));
                flag = true;
            }

            if (FechaDesde.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                sb.Append(" p.fecha>=@fechadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FechaDesde, FechaDesde));
                flag = true;
            }

            if (FechaHasta.HasValue)
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" p.fecha<=@fechahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FechaHasta, FechaHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticulosdesde", FkarticulosDesde);
                sb.Append(" pl.fkarticulos >= @fkarticulosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosDesde, FkarticulosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticuloshasta", FkarticulosHasta);
                sb.Append(" pl.fkarticulos <= @fkarticuloshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosHasta, FkarticulosHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkfamiliasmateriales))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("fkfamiliasmateriales", Fkfamiliasmateriales);
                sb.Append("  exists(select mm.* from materiales as mm where mm.id=Substring(pl.fkarticulos,3,3) and mm.fkfamiliamateriales=@fkfamiliasmateriales)  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaMateriales, AppService.GetListFamiliaMateriales().SingleOrDefault(f => f.Valor == Fkfamiliasmateriales).Descripcion));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliasdesde", FkfamiliasDesde);
                sb.Append(" Substring(pl.fkarticulos,0,3) >= @fkfamiliasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaDesde, FkfamiliasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliashasta", FkfamiliasHasta);
                sb.Append(" Substring(pl.fkarticulos,0,3) <= @fkfamiliashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaHasta, FkfamiliasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialesdesde", FkmaterialesDesde);
                sb.Append(" Substring(pl.fkarticulos,3,3) >= @fkmaterialesdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.MaterialesDesde, FkmaterialesDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialeshasta", FkmaterialesHasta);
                sb.Append(" Substring(pl.fkarticulos,3,3) <= @fkmaterialeshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.MaterialesHasta, FkmaterialesHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicasdesde", FkcaracteristicasDesde);
                sb.Append(" Substring(pl.fkarticulos,6,2) >= @fkcaracteristicasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.CaracteristicasDesde, FkcaracteristicasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicashasta", FkcaracteristicasHasta);
                sb.Append(" Substring(pl.fkarticulos,6,2) <= @fkcaracteristicashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.CaracteristicasHasta, FkcaracteristicasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoresdesde", FkgrosoresDesde);
                sb.Append(" Substring(pl.fkarticulos,8,2) >= @fkgrosoresdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.GrosoresDesde, FkgrosoresDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoreshasta", FkgrosoresHasta);
                sb.Append(" Substring(pl.fkarticulos,8,2) <= @fkgrosoreshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.GrosoresHasta, FkgrosoresHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadosdesde", FkacabadosDesde);
                sb.Append(" Substring(pl.fkarticulos,10,2) >= @fkacabadosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.AcabadosDesde, FkacabadosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadoshasta", FkacabadosHasta);
                sb.Append(" Substring(pl.fkarticulos,10,2) <= @fkacabadoshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.AcabadosHasta, FkacabadosHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkzonaDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkzonasdesde", FkzonaDesde);
                sb.Append(" p.fkzonaalmacen >= @fkzonasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkzonasDesde, FkzonaDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkzonaHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkzonashasta", FkzonaHasta);
                sb.Append(" p.fkzonaalmacen <= @fkzonashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkzonasHasta, FkzonaHasta));
                flag = true;
            }

            return(sb.ToString());
        }
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.Append(" c.nivel = 0");
            sb.Append(" AND ");
            sb.Append(" c.empresa = '" + Empresa + "' ");

            Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaInforme, FechaInforme));

            if (!string.IsNullOrEmpty(Fkseriescontables))
            {
                sb.Append(" AND ");

                ValoresParametros.Add("fkserie", Fkseriescontables);
                sb.Append(" (m.fkseriescontables = @fkserie OR m.fkseriescontables IS NULL)");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.Fkseriescontables, Fkseriescontables));
            }

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                sb.Append(" AND ");
                ValoresParametros.Add("cuentadesde", CuentaDesde);
                sb.Append(" c.id>=@cuentadesde ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaDesde, CuentaDesde));
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                sb.Append(" AND ");
                ValoresParametros.Add("cuentahasta", CuentaHasta);
                sb.Append(" c.id<=@cuentahasta ");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaHasta, CuentaHasta));
            }

            if (FechaDesde.HasValue && FechaHasta.HasValue)
            {
                sb.Append(" AND ");
                ValoresParametros.Add("fechadesde", FechaDesde.Value);
                ValoresParametros.Add("fechahasta", FechaHasta.Value);
                sb.Append(" ((m.fecha>=@fechadesde AND m.fecha<=@fechahasta) OR m.fecha IS NULL)");
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaDesde, FechaDesde));
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaHasta, FechaHasta));
            }

            //if (FechaHasta.HasValue)
            //{
            //    sb.Append(" AND ");
            //    ValoresParametros.Add("fechahasta", FechaHasta.Value);
            //    sb.Append(" m.fecha<=@fechahasta ");
            //    Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaHasta, FechaHasta));
            //}

            if (!MostrarCuentasSinSaldo)
            {
                sb.Append(" AND ");
                sb.Append(" Saldo IS NOT NULL ");
            }

            sb.Append(")");

            if (SaldosAnteriores)
            {
                sb.Append(" UNION ALL");
                ValoresParametros.Add("inicioejercicio", InicioEjercicio.Value);
                sb.Append(" (SELECT (c.id + ' ' + c.descripcion) AS [Cuenta]," +
                          " NULL AS [Fecha], 'SUMA ANTERIOR' AS [Doc.]," +
                          " NULL AS [Comentario]," +
                          " SUM((CASE WHEN l.esdebe = 1 THEN l.importe ELSE 0 END)) AS [Debe]," +
                          " SUM((CASE WHEN l.esdebe = -1 THEN l.importe ELSE 0 END)) AS [Haber]," +
                          " SUM((CASE WHEN l.esdebe = 1 THEN l.importe ELSE (l.importe * -1) END)) AS [Saldo]," +
                          " 0 AS [Orden]" +
                          " FROM Cuentas AS c" +
                          " LEFT JOIN MovsLin AS l ON c.id = l.fkcuentas AND c.empresa = l.empresa " +
                          " LEFT JOIN Movs AS m ON m.id = l.fkmovs AND c.empresa = m.empresa " +
                          "inner join maes on maes.empresa = l.empresa and maes.fkejercicio = m.fkejercicio and maes.fkcuentas = c.id" +
                          " WHERE c.nivel = 0 AND c.empresa='" + Empresa + "'" +
                          " AND (m.fkseriescontables = @fkserie OR m.fkseriescontables IS NULL)");

                if (!string.IsNullOrEmpty(CuentaDesde))
                {
                    sb.Append(" AND c.id>=@cuentaDesde");
                }

                if (!string.IsNullOrEmpty(CuentaHasta))
                {
                    sb.Append(" AND c.id<=@cuentaHasta");
                }

                sb.Append(" AND ((m.Fecha>=@inicioejercicio AND m.Fecha<@fechadesde) OR m.fecha IS NULL)");
                if (!MostrarCuentasSinSaldo)
                {
                    sb.Append(" AND ");
                    sb.Append(" Saldo IS NOT NULL ");
                }
                sb.Append(" GROUP BY c.id, c.descripcion)");
            }

            sb.Append(")t");

            return(sb.ToString());
        }
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();

            ValoresParametros.Clear();
            Condiciones.Clear();

            Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaInforme, FechaInforme));


            //CuentaDesde y CuentaHasta. Hacer los @
            CuentaDesde = (CuentaDesde + "00000000000000000000000000000000000").Substring(0, 8);
            CuentaHasta = (CuentaHasta + "00000000000000000000000000000000000").Substring(0, 8);

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                ValoresParametros.Add("cuentadesde", CuentaDesde);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaDesde, CuentaDesde));
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                ValoresParametros.Add("cuentahasta", CuentaHasta);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaHasta, CuentaHasta));
            }

            sb.Append("c.empresa = '" + Empresa + "' and(m.fkejercicio = '" + Context.Ejercicio + "'  or m.fkejercicio is null) ");
            sb.Append(" AND ( ");

            var cuentaDesdeAux1 = CuentaDesde.ToString().Substring(0, 1);
            var cuentaDesdeAux2 = CuentaDesde.ToString().Substring(0, 2);
            var cuentaDesdeAux3 = CuentaDesde.ToString().Substring(0, 3);
            var cuentaDesdeAux4 = CuentaDesde.ToString().Substring(0, 4);

            if (PorGrupos)
            {
                sb.Append("((c.id='" + cuentaDesdeAux1 + "') or (c.id>='" + CuentaDesde + "' and c.id<='" + CuentaHasta + "' and c.nivel=1)) ");
            }

            if (PorSubgrupos)
            {
                if (PorGrupos)
                {
                    sb.Append(" or ");
                }

                sb.Append("((c.id='" + cuentaDesdeAux2 + "') or (c.id>='" + CuentaDesde + "' and c.id<='" + CuentaHasta + "' and c.nivel=2)) ");
            }

            if (PorMayor)
            {
                if (PorGrupos || PorSubgrupos)
                {
                    sb.Append(" or ");
                }

                sb.Append("((c.id='" + cuentaDesdeAux3 + "') or (c.id>='" + CuentaDesde + "' and c.id<='" + CuentaHasta + "' and c.nivel=3)) ");
            }

            if (PorSubmayor)
            {
                if (PorGrupos || PorSubgrupos || PorMayor)
                {
                    sb.Append(" or ");
                }

                sb.Append("((c.id='" + cuentaDesdeAux4 + "') or (c.id>='" + CuentaDesde + "' and c.id<='" + CuentaHasta + "' and c.nivel=4)) ");
            }

            if (PorSubcuenta)
            {
                if (PorGrupos || PorSubgrupos || PorMayor || PorSubmayor)
                {
                    sb.Append(" or ");
                }

                sb.Append("(c.id>='" + CuentaDesde + "' and c.id<='" + CuentaHasta + "' and c.nivel=0) ");
            }

            sb.Append(")");

            //En caso de que el usuario quiera mostrar cuentas sin saldo, se mostraran las de con saldo y la de sin saldo
            if (!MostrarCuentasSinSaldo)
            {
                sb.Append(" and (m.debe<>m.haber)");
            }

            if (!MostrarCuentasSinMovimientos)
            {
                sb.Append("AND (m.id is not null)");
            }

            return(sb.ToString());
        }
        internal override string GenerarFiltrosColumnas()
        {
            var sb   = new StringBuilder();
            var flag = true;

            ValoresParametros.Clear();
            Condiciones.Clear();
            sb.AppendFormat(" s.empresa='{0}' ", Empresa);
            if (!string.IsNullOrEmpty(Fkalmacen))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkalmacen", Fkalmacen);
                sb.Append(" s.fkalmacenes = @fkalmacen  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Fkalmacen, Fkalmacen));
                flag = true;
            }


            if (!string.IsNullOrEmpty(Fkzonasalmacen))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkzonasalmacen", Fkzonasalmacen);
                sb.Append(" s.fkalmaceneszona = @fkzonasalmacen  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.Fkzonas, Fkzonasalmacen));
                flag = true;
            }

            if (Tipodealmacenlote.HasValue)
            {
                int    index           = Array.IndexOf(Enum.GetValues(Tipodealmacenlote?.GetType()), Tipodealmacenlote);
                string Tipoalmacenlote = index.ToString();
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("tipoalmacenlote", Tipoalmacenlote);
                sb.Append(" s.tipoalmacenlote = @tipoalmacenlote  ");

                switch (Tipodealmacenlote)
                {
                case TipoAlmacenlote.Mercaderia:
                {
                    Tipoalmacenlote = RAlbaranesCompras.TipoAlmacenLoteMercaderia;
                    break;
                }

                case TipoAlmacenlote.Gestionado:
                {
                    Tipoalmacenlote = RAlbaranesCompras.TipoAlmacenLoteGestionado;
                    break;
                }

                case TipoAlmacenlote.Propio:
                {
                    Tipoalmacenlote = RAlbaranesCompras.TipoAlmacenLotePropio;
                    break;
                }
                }
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranesCompras.TipoAlmacenLote, Tipoalmacenlote));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticulosdesde", FkarticulosDesde);
                sb.Append(" s.fkarticulos >= @fkarticulosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosDesde, FkarticulosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkarticulosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkarticuloshasta", FkarticulosHasta);
                sb.Append(" s.fkarticulos <= @fkarticuloshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FkarticulosHasta, FkarticulosHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(Fkfamiliasmateriales))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }
                AppService = new ApplicationHelper(Context);
                ValoresParametros.Add("fkfamiliasmateriales", Fkfamiliasmateriales);
                sb.Append("  exists(select mm.* from materiales as mm where mm.id=Substring(s.fkarticulos,3,3) and mm.fkfamiliamateriales=@fkfamiliasmateriales)  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaMateriales, AppService.GetListFamiliaMateriales().SingleOrDefault(f => f.Valor == Fkfamiliasmateriales).Descripcion));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliasdesde", FkfamiliasDesde);
                sb.Append(" Substring(s.fkarticulos,0,3) >= @fkfamiliasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaDesde, FkfamiliasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkfamiliasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkfamiliashasta", FkfamiliasHasta);
                sb.Append(" Substring(s.fkarticulos,0,3) <= @fkfamiliashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.FamiliaHasta, FkfamiliasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialesdesde", FkmaterialesDesde);
                sb.Append(" Substring(s.fkarticulos,3,3) >= @fkmaterialesdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.MaterialesDesde, FkmaterialesDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkmaterialesHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkmaterialeshasta", FkmaterialesHasta);
                sb.Append(" Substring(s.fkarticulos,3,3) <= @fkmaterialeshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.MaterialesHasta, FkmaterialesHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicasdesde", FkcaracteristicasDesde);
                sb.Append(" Substring(s.fkarticulos,6,2) >= @fkcaracteristicasdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.CaracteristicasDesde, FkcaracteristicasDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkcaracteristicasHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkcaracteristicashasta", FkcaracteristicasHasta);
                sb.Append(" Substring(s.fkarticulos,6,2) <= @fkcaracteristicashasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.CaracteristicasHasta, FkcaracteristicasHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoresdesde", FkgrosoresDesde);
                sb.Append(" Substring(s.fkarticulos,8,2) >= @fkgrosoresdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.GrosoresDesde, FkgrosoresDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkgrosoresHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkgrosoreshasta", FkgrosoresHasta);
                sb.Append(" Substring(s.fkarticulos,8,2) <= @fkgrosoreshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.GrosoresHasta, FkgrosoresHasta));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosDesde))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadosdesde", FkacabadosDesde);
                sb.Append(" Substring(s.fkarticulos,10,2) >= @fkacabadosdesde  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.AcabadosDesde, FkacabadosDesde));
                flag = true;
            }

            if (!string.IsNullOrEmpty(FkacabadosHasta))
            {
                if (flag)
                {
                    sb.Append(" AND ");
                }

                ValoresParametros.Add("fkacabadoshasta", FkacabadosHasta);
                sb.Append(" Substring(s.fkarticulos,10,2) <= @fkacabadoshasta  ");
                Condiciones.Add(string.Format("{0}: {1}", RAlbaranes.AcabadosHasta, FkacabadosHasta));
                flag = true;
            }



            return(sb.ToString());
        }
Beispiel #18
0
        internal override string GenerarFiltrosColumnas()
        {
            var sb = new StringBuilder();

            ValoresParametros.Clear();
            Condiciones.Clear();

            Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaInforme, FechaInforme));

            sb.Append("[Empresa] = '" + Empresa + "'");

            if (Tipo == TipoVencimiento.Cobros)
            {
                ValoresParametros.Add("tipo", Tipo);
                sb.Append(" AND ([Tipo] = '0')");
            }

            if (Tipo == TipoVencimiento.Pagos)
            {
                ValoresParametros.Add("tipo", Tipo);
                sb.Append(" AND ([Tipo] = '1')");
            }

            if (!string.IsNullOrEmpty(CuentaDesde))
            {
                ValoresParametros.Add("cuentadesde", CuentaDesde);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaDesde, CuentaDesde));
                sb.Append(" AND ([Tercero]>='" + CuentaDesde + "')");
            }

            if (!string.IsNullOrEmpty(CuentaHasta))
            {
                ValoresParametros.Add("cuentahasta", CuentaHasta);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaHasta, CuentaHasta));
                sb.Append(" AND ([Tercero]<='" + CuentaHasta + "')");
            }

            if (!string.IsNullOrEmpty(CuentaDesdeTesoreria))
            {
                ValoresParametros.Add("cuentadesdetesoreria", CuentaDesdeTesoreria);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaDesdeTesoreria, CuentaDesdeTesoreria));
                sb.Append(" AND ([Cta.Tesoreria] >='" + CuentaDesdeTesoreria + "')");
            }

            if (!string.IsNullOrEmpty(CuentaHastaTesoreria))
            {
                ValoresParametros.Add("cuentahastatesoreria", CuentaHastaTesoreria);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.CuentaHastaTesoreria, CuentaHastaTesoreria));
                sb.Append(" AND ([Cta.Tesoreria] <='" + CuentaHastaTesoreria + "')");
            }

            if (!string.IsNullOrEmpty(Situacion))
            {
                ValoresParametros.Add("situacion", Situacion);
                Condiciones.Add(string.Format("{0}: {1}", RCobrosYPagos.Situación, Situacion));
                sb.Append(" AND ([Situación] ='" + Situacion + "')");
            }

            if (!string.IsNullOrEmpty(FechaDesdeFactura.ToString()))
            {
                ValoresParametros.Add("fechadesdefactura", FechaDesdeFactura);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaDesde, FechaDesdeFactura.ToString()));
                sb.Append(" AND ([Fecha Factura] >='" + FechaDesdeFactura + "')");
            }

            if (!string.IsNullOrEmpty(FechaHastaFactura.ToString()))
            {
                ValoresParametros.Add("fechahastafactura", FechaHastaFactura);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaHasta, FechaHastaFactura.ToString()));
                sb.Append(" AND ([Fecha Factura] <='" + FechaHastaFactura + "')");
            }

            if (!string.IsNullOrEmpty(FechaDesdeVencimiento.ToString()))
            {
                ValoresParametros.Add("fechadesdevencimiento", FechaDesdeVencimiento);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaDesdeVencimiento, FechaDesdeVencimiento.ToString()));
                sb.Append(" AND ([Fecha Vencimiento] >='" + FechaDesdeVencimiento + "')");
            }

            if (!string.IsNullOrEmpty(FechaHastaVencimiento.ToString()))
            {
                ValoresParametros.Add("fechahastavencimiento", FechaHastaVencimiento);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FechaHastaVencimiento, FechaHastaVencimiento.ToString()));
                sb.Append(" AND ([Fecha Vencimiento] <='" + FechaHastaVencimiento + "')");
            }

            if (!string.IsNullOrEmpty(Fkformaspago.ToString()))
            {
                ValoresParametros.Add("formapago", Fkformaspago);
                Condiciones.Add(string.Format("{0}: {1}", RMovs.FormaPago, Fkformaspago));
                sb.Append(" AND ([Forma Pago] ='" + Fkformaspago + "')");
            }

            return(sb.ToString());
        }