Esempio n. 1
0
        public decimal DamePrecioListaClienteMayorista(int idCliente)
        {
            ServicioClientes servClientes = new ServicioClientes();
            ServicioGenerico servGenerico = new ServicioGenerico();
            decimal          precioReturn = -1;

            string codListaMayorista = servGenerico.ParametroObtenerValor("LISTA_MAYORISTA");

            ListaPrecio listaMayorista = this.ObtenerObjeto <ListaPrecio>("Codigo", codListaMayorista);

            if (listaMayorista != null)
            {
                //List<ClienteLista> lista = this.Listar<ClienteLista>("IdCliente", idCliente).ToList<ClienteLista>();
                List <ClienteLista> lista = servClientes.ClienteListaObtenerVigentesCache()
                                            .Where(item => item.IdCliente == idCliente)
                                            .ToList <ClienteLista>();

                if (lista != null)
                {
                    ClienteLista cliLista = lista.Find(item => item.ListaPrecio == listaMayorista);
                    if (cliLista != null)
                    {
                        precioReturn = cliLista.ListaPrecioCliente.Precio;
                    }
                }
            }
            return(precioReturn);
        }
Esempio n. 2
0
        public decimal DamePrecioListaCliente(List <ClienteLista> listaCliente, Producto producto)
        {
            ServicioClientes servClientes  = new ServicioClientes();
            decimal          precioReturn  = -1;
            ListaPrecio      listaProducto = producto.ListaPrecio;

            if (listaProducto != null && listaCliente != null)
            {
                ClienteLista cliLista = listaCliente.Find(item => item.ListaPrecio == listaProducto);
                if (cliLista != null)
                {
                    precioReturn = cliLista.ListaPrecioCliente.Precio;
                }
            }
            return(precioReturn);
        }
Esempio n. 3
0
        public decimal DamePrecioListaCliente(int idCliente, Producto producto)
        {
            ServicioClientes servClientes  = new ServicioClientes();
            decimal          precioReturn  = -1;
            ListaPrecio      listaProducto = producto.ListaPrecio;

            if (listaProducto != null)
            {
                //List<ClienteLista> lista = this.Listar<ClienteLista>("IdCliente", idCliente).ToList<ClienteLista>();
                List <ClienteLista> lista = servClientes.ClienteListaObtenerVigentesCache()
                                            .Where(item => item.IdCliente == idCliente)
                                            .ToList <ClienteLista>();

                if (lista != null)
                {
                    ClienteLista cliLista = lista.Find(item => item.ListaPrecio == listaProducto);
                    if (cliLista != null)
                    {
                        precioReturn = cliLista.ListaPrecioCliente.Precio;
                    }
                }
            }
            return(precioReturn);
        }
Esempio n. 4
0
        public void PedidoItemGrabarSinTotalPedido(PedidoItem datosGraba)
        {
            ServicioGenerico   servGenerico            = new ServicioGenerico();
            ServiciosProductos servProducto            = new ServiciosProductos();
            ServicioClientes   servClientes            = new ServicioClientes();
            RepositoryGenerico <PedidoItem> repository = new RepositoryGenerico <PedidoItem>();
            PedidoRepository repositoryPedido          = new PedidoRepository();

            try
            {
                if (datosGraba.Producto.Id == -1)
                {
                    throw new ApplicationException("Falta indicar Producto.");
                }

                Pedido pedido = this.PedidoObtener(datosGraba.IdPedido);

                List <ClienteLista> listaCliente = servClientes.ClienteListaObtenerVigentesCache()
                                                   .Where(item => item.IdCliente == pedido.Cliente.Id)
                                                   .ToList <ClienteLista>();

                PedidoItem itemProducto = repositoryPedido.ObtenerItemPorProducto(datosGraba.IdPedido, datosGraba.Producto.Codigo);

                PedidoItem dato = null;
                if (itemProducto == null)
                {
                    dato = new PedidoItem();
                }
                else
                {
                    dato = repository.Obtener(itemProducto.Id);
                }

                decimal precioProcesado = 0;
                if (datosGraba.Producto.StockPropio)
                {
                    decimal cotizacionDolar = servProducto.CotizacionDolarVigente().Cotizacion;
                    precioProcesado = servProducto.ProcesarStockPropio(listaCliente, "", datosGraba.Producto).PrecioUnitarioProcesado;
                    if (pedido.Moneda != "USD")
                    {
                        precioProcesado = Decimal.Round(precioProcesado * cotizacionDolar, 2);
                    }
                }
                else
                {
                    if (datosGraba.Id == -1)
                    {
                        precioProcesado     = datosGraba.Producto.PrecioUnitarioFinal;
                        datosGraba.Producto = servProducto.ProductoMayoristaGrabar(datosGraba.Producto);
                    }
                    else
                    {
                        precioProcesado = dato.Precio;
                    }
                }
                dato.Precio = precioProcesado;

                dato.IdPedido       = datosGraba.IdPedido;
                dato.Producto       = datosGraba.Producto;
                dato.EstadoItem     = datosGraba.EstadoItem;
                dato.Porcentaje     = 0;
                dato.Observaciones  = datosGraba.Observaciones;
                dato.MostrarMedidas = datosGraba.MostrarMedidas;

                // PrecioUnitario => (Peso * PrecioGramo)
                decimal precioUnitario = 0;
                if (dato.Producto.PrecioPorPeso)
                {
                    precioUnitario = dato.Producto.Peso * dato.Precio;
                }
                else
                {
                    precioUnitario = dato.Precio;
                }

                repository.Actualizar(dato);


                if (datosGraba.Producto.StockPropio)
                {
                    this.PedidoItemProductoGrabar(dato, datosGraba.ItemProductos);
                }
                else
                {
                    this.PedidoItemProductoMayoristaGrabar(dato, datosGraba.ItemProductos);
                }

                int _cantidad = 0;
                dato.ItemProductos.ToList <PedidoItemProducto>()
                .ForEach(delegate(PedidoItemProducto item)
                {
                    _cantidad += item.Cantidad;
                });
                dato.Cantidad = _cantidad;

                //TODO: este sin stock debe ser el del PedidoItemProducto
                if (dato.SinStock)
                {
                    ServiciosProductos servProductos = new ServiciosProductos();
                    dato.Producto = servProductos.ProductoSinStock(dato.Producto.Id);
                    dato.Subtotal = 0;
                }
                else
                {
                    dato.Subtotal = (precioUnitario * dato.Cantidad);
                }

                repository.Actualizar(dato);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Esempio n. 5
0
        public ProductoList ProductoListarCarrito(bool conStock, int idSubcategoria, string textoBuscar, int idCliente, int numeroPagina, int cantidadRegistros)
        {
            ServiciosPedido  servPedido   = new ServiciosPedido();
            ServicioGenerico servGenerico = new ServicioGenerico();

            ProductoRepository repository  = new ProductoRepository();
            List <Producto>    listProds   = new List <Producto>();
            List <PedidoItem>  pedidoItems = new List <PedidoItem>();

            /* MONEDA_VENTA => Se parametriza desde el ABM de Cotizaciones
             * valores posibles
             * * PESO_ARGENTINO
             * * DOLAR_EEUU
             */

            /*Parametros del sistema*/
            string monedaVenta = servGenerico.ParametroObtenerValor("MONEDA_VENTA");
            string url_host    = servGenerico.ParametroObtenerValor("URL_HOST");
            string myIdCliente = servGenerico.ParametroObtenerValor("TRADING_ID_CLIENTE");

            List <ClienteLista> listaCliente = null;

            if (idCliente > 0)
            {
                ServicioClientes servClientes = new ServicioClientes();
                listaCliente = servClientes.ClienteListaObtenerVigentesCache()
                               .Where(item => item.IdCliente == idCliente)
                               .ToList <ClienteLista>();
                //Pedido pedido = servPedido.PedidoObtenerClienteIngresado(idCliente, -1, -1);
            }
            else
            {
                //cuando se muestra el carrito a usuarios no registrados se fuerza PESO_ARGENTINO
                monedaVenta = "PESO_ARGENTINO";
            }

            decimal cotizacionDolar = this.CotizacionDolarVigente().Cotizacion;

            List <Producto> listProdsFull = new List <Producto>();

            if (idSubcategoria != -1)
            {
                //1ro se obtienen y listan los productos del MONORISTA

                if (textoBuscar.Contains("ETIQUETA=NOVEDAD"))
                {
                    listProdsFull.AddRange(this.ProductoObtenerVigentesCache(idSubcategoria)
                                           .FindAll(item => item.Stock > 0 && item.Etiquetas.Contains("NOVEDAD"))
                                           .OrderBy(item => item.Orden)
                                           .ToList <Producto>());
                }
                else
                {
                    List <Producto> listAux = this.ProductoObtenerVigentesCache(idSubcategoria);
                    listProdsFull.AddRange(listAux
                                           .FindAll(item => item.Stock > 0)
                                           .OrderBy(item => item.Orden)
                                           .ToList <Producto>());
                }

                //despues se buscan los del mayorista
                SubcategoriaMerge subcateMerge = this.ObtenerSubcategoriaMerge(idSubcategoria);
                if (subcateMerge != null && subcateMerge.IdSubcategoriaMayorista > 0)
                {
                    idSubcategoria = subcateMerge.IdSubcategoriaMayorista;
                    textoBuscar    = subcateMerge.Etiqueta;
                }
            }
            else
            {
                listProdsFull.AddRange(repository.BuscarProductos(textoBuscar, conStock, true, 1, 100));
            }

            //2ro se obtienen y listan los productos del MAYORISTA
            listProdsFull.AddRange(this.ProductoObtenerDelMayorista(conStock, idSubcategoria, textoBuscar, myIdCliente.ConvertirInt()));

            int totalFilas = listProdsFull.Count;

            bool paginar = (numeroPagina != -1 && cantidadRegistros != -1);

            if (paginar)
            {
                int nro_fila = 1;
                listProdsFull
                .ForEach(delegate(Producto item)
                {
                    item.NroFila = nro_fila;
                    nro_fila++;
                });
                int filaDesde = (numeroPagina - 1) * cantidadRegistros;
                int filaHasta = filaDesde + cantidadRegistros;
                listProds = listProdsFull.FindAll(item => item.NroFila > filaDesde && item.NroFila <= filaHasta);
            }
            else
            {
                listProds = listProdsFull;
            }


            listProds.ForEach(delegate(Producto prod)
            {
                if (prod.StockPropio)
                {
                    prod = ProcesarStockPropio(listaCliente, url_host, prod);
                }
                else
                {
                    prod = ProcesarStockMayorista(idCliente, prod);
                }

                prod.MonedaVenta = monedaVenta == "DOLAR_EEUU" ? "USD" : "$";
                if (monedaVenta != "DOLAR_EEUU")
                {
                    prod.PrecioUnitarioFinal = Decimal.Round(prod.PrecioUnitarioProcesado * cotizacionDolar, 2);
                }
                else
                {
                    prod.PrecioUnitarioFinal = Decimal.Round(prod.PrecioUnitarioProcesado, 2);
                }


                prod.CantidadPedido = 0;
                prod.ProductoPedido = false;
            });

            ProductoList listReturn = new ProductoList();

            listReturn.TotalFilas = totalFilas;
            listReturn.Productos  = listProds;
            return(listReturn);
        }