private void PedidoItemProductoMayoristaGrabar(PedidoItem datoGraba, IList <PedidoItemProducto> pitemProdGraba)
{
ServiciosProductos servProductos = new ServiciosProductos();
if (datoGraba.ItemProductos == null)
{
datoGraba.ItemProductos = new List <PedidoItemProducto>();
}
List <PedidoItemProducto> pitemProd = datoGraba.ItemProductos.ToList <PedidoItemProducto>();
List <ProductoStock> listProdStock = servProductos.ProductoStockListar(datoGraba.Producto.Codigo);
if (pitemProd != null && pitemProd.Count > 0)
{
//si los items ya estan en el pedido se actualizan las cantidades
pitemProd.ForEach(delegate(PedidoItemProducto pip)
{
PedidoItemProducto itemPP = pitemProdGraba.ToList <PedidoItemProducto>().Find(x => x.Medida.Descripcion.Equals(pip.Medida.Descripcion));
pip.Cantidad = itemPP.Cantidad;
});
}
else
{
pitemProdGraba.ToList <PedidoItemProducto>()
.ForEach(delegate(PedidoItemProducto itemPP)
{
ProductoStock prodStock = listProdStock.Find(ps => ps.Medida.Descripcion.Equals(itemPP.Medida.Descripcion));
itemPP.IdPedidoItem = datoGraba.Id;
itemPP.IdProductoStock = prodStock.Id;
itemPP.Medida = prodStock.Medida;
datoGraba.ItemProductos.Add(itemPP);
});
}
}
public DocumentoVenta DocumentoVentaItemEliminar(DocumentoVentaItem docItem)
{
RepositoryGenerico <DocumentoVentaItem> repository = new RepositoryGenerico <DocumentoVentaItem>();
ServiciosProductos servProductos = new ServiciosProductos();
DocumentoVentaItem dato = repository.Obtener(docItem.Id);
repository.Eliminar(dato);
DocumentoVenta docVenta = this.DocumentoVentaObtener(docItem.IdVenta);
if (docItem.IdPedidoItemProducto <= 0 && docItem.IdProductoStock > 0)
{
bool?_descuentaStock = null;
if (docVenta.TipoComprobante.Id == (int)TIPOS_COMPROBANTE.NOTA_DE_PEDIDO_)
{
_descuentaStock = false;
}
else if (docVenta.TipoComprobante.Id == (int)TIPOS_COMPROBANTE.NOTA_DE_CREDITO_)
{
_descuentaStock = true;
}
if (_descuentaStock.HasValue)
{
servProductos.ProductoStockActualizarStock(docItem.IdProductoStock, docItem.Cantidad, _descuentaStock.Value);
}
}
return(this.CalcularTotales(docVenta));
}
public DocumentoVenta DocumentoVentaAnular(DocumentoVenta datosGraba)
{
ServiciosProductos servProductos = new ServiciosProductos();
VentaRepository repository = new VentaRepository();
DocumentoVenta dato = this.DocumentoVentaObtener(datosGraba.Id);
dato.Anulado = datosGraba.Anulado;
repository.Actualizar(dato);
dato.Items.ToList <DocumentoVentaItem>()
.ForEach(delegate(DocumentoVentaItem docItem)
{
if (docItem.IdProductoStock > 0 && docItem.IdPedidoItemProducto <= 0)
{
bool?_descuentaStock = null;
if (dato.TipoComprobante.Id == (int)TIPOS_COMPROBANTE.NOTA_DE_PEDIDO_)
{
_descuentaStock = datosGraba.Anulado ? false : true;
}
else if (dato.TipoComprobante.Id == (int)TIPOS_COMPROBANTE.NOTA_DE_CREDITO_)
{
_descuentaStock = datosGraba.Anulado ? true : false;
}
if (_descuentaStock.HasValue)
{
servProductos.ProductoStockActualizarStock(docItem.IdProductoStock, docItem.Cantidad, _descuentaStock.Value);
}
}
});
return(dato);
}
/// <summary>
/// procesa los pedidos del minorista, cuidado que tiene los id de Producto del minorista o revendedor NO SON LOS DE Trading
/// </summary>
/// <param name="datos"></param>
/// <returns></returns>
public Pedido PedidoProcesarMinorista(PedidoDTO datos)
{
ServiciosProductos servProductos = new ServiciosProductos();
try
{
//creamos nuevo pedido como ingresado
Pedido nuevoPedido = this.PedidoCrear(datos.IdCliente);
datos.Items.ForEach(delegate(PedidoItemDTO item)
{
PedidoItem itemGraba = new PedidoItem();
itemGraba.IdPedido = nuevoPedido.Id;
//siempre hay que buscar por codigo porque estos items
itemGraba.Producto = this.ObtenerObjeto <Producto>("Codigo", item.CodigoProducto);
itemGraba.Cantidad = item.Cantidad;
itemGraba.Observaciones = item.Observaciones;
List <ProductoStock> listProdStock = itemGraba.Producto.ProductoStock.ToList <ProductoStock>();
if (item.ItemProductos.Count == 0)
{
// si entra por aca es porque son pedidos viejos
bool esTalleUnico = (listProdStock.Count == 1);
listProdStock.ForEach(delegate(ProductoStock ps)
{
PedidoItemProducto itemPP = new PedidoItemProducto();
itemPP.IdPedidoItem = -1;
itemPP.IdProductoStock = ps.Id;
itemPP.Medida = ps.Medida;
itemPP.Cantidad = esTalleUnico ? itemGraba.Cantidad : 0; // si es Talle Unico actualizamos cantidad, si no la dejamos en 0
itemGraba.ItemProductos.Add(itemPP);
});
}
else
{
item.ItemProductos.ToList <PedidoItemProductoDTO>()
.ForEach(delegate(PedidoItemProductoDTO itemDTO)
{
ProductoStock prodStock = listProdStock.Find(ps => ps.Medida.Descripcion.Equals(itemDTO.Medida.Descripcion));
PedidoItemProducto itemPP = new PedidoItemProducto();
itemPP.IdPedidoItem = -1;
itemPP.IdProductoStock = prodStock.Id;
itemPP.Medida = prodStock.Medida;
itemPP.Cantidad = itemDTO.Cantidad;
itemGraba.ItemProductos.Add(itemPP);
});
}
this.PedidoItemGrabarSinTotalPedido(itemGraba);
});
nuevoPedido = this.PedidoGrabarTotal(nuevoPedido.Id);
nuevoPedido.Items = this.Listar <PedidoItem>("IdPedido", nuevoPedido.Id).ToList <PedidoItem>();
//finalizamos el pedido con los id y numero del minorista
nuevoPedido.IdPedidoMinorista = datos.IdPedidoMinorista;
nuevoPedido.NumeroPedidoMinorista = datos.NumeroPedidoMinorista;
MensajeResponse resp = this.PedidoAvanzar(nuevoPedido, true);
if (resp.Estado == (int)ESTADOS_RESPONSE.ERROR_)
{
//provisoriamente forzamos el SOLICITADO
PedidoRepository repository = new PedidoRepository();
Pedido ultimo = repository.ObtenerUltimoPedido();
nuevoPedido.Numero = (ultimo != null) ? (ultimo.Numero + 1) : 1;
nuevoPedido.Fecha = DateTime.Now;
nuevoPedido.Estado = this.ObtenerObjeto <Estado>((int)ESTADOS.SOLICITADO_);
nuevoPedido.IdPedidoMinorista = datos.IdPedidoMinorista;
nuevoPedido.NumeroPedidoMinorista = datos.NumeroPedidoMinorista;
repository.PedidoReservarStock(nuevoPedido.Id);
CacheManager.RemoveToCache(gobalKeyCache);
//Version OK pra cuando este funcionando todo ok
//nuevoPedido.Observaciones = string.Format("Falta de Stock - Numero Pedido: {0}", datos.NumeroPedidoMinorista);
//nuevoPedido.Estado = this.ObtenerObjeto<Estado>((int)ESTADOS.CANCELADO_);
return(this.PedidoGrabar(nuevoPedido));
}
else
{
return(this.PedidoObtener(nuevoPedido.Id));
}
}
catch (Exception ex)
{
throw new ApplicationException(string.Format("{0}\n{1}", ex.Message));
}
}
public async Task <Pedido> PedidoProveedor(int idPedido)
{
ServicioGenerico servicio = new ServicioGenerico();
ServiciosProductos servProductos = new ServiciosProductos();
string urlMayorista = servicio.ParametroObtenerValor("URL_MAYORISTA");
string myIdCliente = servicio.ParametroObtenerValor("TRADING_ID_CLIENTE");
if (string.IsNullOrEmpty(urlMayorista))
{
throw new ApplicationException("No está vinculado ningún proveedor mayorista");
}
if (string.IsNullOrEmpty(myIdCliente))
{
throw new ApplicationException("No tiene asingdo IdCliente en el proveedor mayorista");
}
RepositoryGenerico <Pedido> repository = new RepositoryGenerico <Pedido>();
Pedido pedido = repository.Obtener(idPedido);
if (pedido == null)
{
throw new ApplicationException("No existe pedido");
}
//PEdido se se enviara al proveedor
PedidoDTO pedidoProveedor = new PedidoDTO();
pedido.Items = this.Listar <PedidoItem>("IdPedido", idPedido).ToList <PedidoItem>();
//agregamos los productos de nuestro cliente en al app del mayorista
pedido.Items
.FindAll(item => item.Producto.StockPropio == false)
.ForEach(delegate(PedidoItem item)
{
int cantidadProducto = item.Cantidad;
PedidoItemDTO itemProveedor = new PedidoItemDTO();
itemProveedor.Id = -1;
itemProveedor.CodigoProducto = item.Producto.Codigo;
if (item.ItemProductos.Count == 0)
{
itemProveedor.Cantidad = item.Cantidad;
itemProveedor.Observaciones = string.Format("Cant: {0} - Obs: {1}", item.Cantidad, item.Observaciones);
}
else
{
item.ItemProductos.ToList <PedidoItemProducto>()
.ForEach(delegate(PedidoItemProducto pip)
{
PedidoItemProductoDTO pipProv = new PedidoItemProductoDTO()
{
Cantidad = pip.Cantidad,
Medida = pip.Medida
};
itemProveedor.ItemProductos.Add(pipProv);
});
}
pedidoProveedor.Items.Add(itemProveedor);
});
pedidoProveedor.IdCliente = myIdCliente.ConvertirInt();
//enviamos el id y numero del pedido para mantener trazabilidad
pedidoProveedor.IdPedidoMinorista = pedido.Id;
pedidoProveedor.NumeroPedidoMinorista = pedido.Numero;
Pedido nuevoPedidoGenerado = new Pedido();
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(urlMayorista);
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(pedidoProveedor), Encoding.UTF8);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpResponseMessage Res = await httpClient.PostAsync("api/Pedido/Minorista", httpContent);
if (Res.IsSuccessStatusCode)
{
var pedidoResponse = Res.Content.ReadAsStringAsync().Result;
nuevoPedidoGenerado = JsonConvert.DeserializeObject <Pedido>(pedidoResponse);
}
else
{
throw new ApplicationException("Error");
}
}
if (nuevoPedidoGenerado.VerificarStock)
{
List <PedidoItem> itemsVerificar = nuevoPedidoGenerado.Items.ToList <PedidoItem>();
pedido.Items.ToList <PedidoItem>()
.ForEach(delegate(PedidoItem pit)
{
PedidoItem piVerificar = itemsVerificar.Find(x => x.Producto.Codigo == pit.Producto.Codigo);
if (piVerificar != null)
{
List <PedidoItemProducto> pitNuevoPedido = piVerificar.ItemProductos.ToList <PedidoItemProducto>();
if (pit.ItemProductos.Count > 0)
{
pit.ItemProductos.ToList <PedidoItemProducto>()
.ForEach(delegate(PedidoItemProducto pip)
{
pip.StockDisponible = pitNuevoPedido.Find(x => x.Medida.Descripcion == pip.Medida.Descripcion).StockDisponible;
});
}
}
});
}
/** ATENCION!!! SI EL PEDIDO VIENE CON VerificarStock TRUE => NO SE DEBE MODIFICAR EL ESTADO NI LOS NUMEROS DEL PROVEEDRO **/
//para la trazabilidad, guardo el id y el numero del pedido en el proveedor
pedido.IdPedidoProveedor = nuevoPedidoGenerado.Id;
pedido.NumeroPedidoProveedor = nuevoPedidoGenerado.Numero;
pedido.Estado = this.ObtenerObjeto <Estado>((int)ESTADOS.PROVEEDOR_);
repository.Actualizar(pedido);
return(this.PedidoObtener(pedido.Id));
}
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;
}
}
public DocumentoVenta DocumentoVentaFacturarPedido(DocumentoVenta dato)
{
ServiciosProductos servProductos = new ServiciosProductos();
ServiciosPedido servPedido = new ServiciosPedido();
VentaRepository repository = new VentaRepository();
if (dato.Items == null)
{
dato.Items = new List <DocumentoVentaItem>();
}
Pedido pedido = servPedido.PedidoObtener(dato.IdPedido);
pedido.Items.ToList <PedidoItem>()
.OrderBy(item => item.Producto.Ubicacion).ToList <PedidoItem>()
.ForEach(delegate(PedidoItem pi)
{
decimal _precioUnitario = 0;
if (pi.Producto.PrecioPorPeso)
{
_precioUnitario = pi.Precio * pi.Producto.Peso;
}
else
{
_precioUnitario = pi.Precio;
}
if (pi.Cantidad == 0)
{
// si la cantidad esta en 0 lo mismo se genera el item de la factura en 0
// para mantener la numeracion de los items
string _descripcion = string.Format("{0} {1} - Código: {2} ",
pi.Producto.DescripcionCategoria,
pi.Producto.DescripcionSubcategoria,
pi.Producto.Codigo.ToString());
DocumentoVentaItem dvItem = new DocumentoVentaItem()
{
Id = -1,
IdVenta = dato.Id,
NroItem = dato.Items.Count + 1,
Descripcion = _descripcion,
IdProductoStock = pi.Producto.ProductoStock[0].Id,
IdPedidoItemProducto = -1,
Cantidad = 0,
PrecioUnitario = _precioUnitario,
Precio = 0
};
dato.Items.Add(dvItem);
}
else
{
pi.ItemProductos.ToList <PedidoItemProducto>()
.ForEach(delegate(PedidoItemProducto pip)
{
if (pip.Cantidad > 0)
{
string _descripcion = string.Format("{0} {1} - Código: {2} - {3}",
pi.Producto.DescripcionCategoria,
pi.Producto.DescripcionSubcategoria,
pi.Producto.Codigo.ToString(),
pip.Medida.Observaciones);
DocumentoVentaItem dvItem = new DocumentoVentaItem()
{
Id = -1,
IdVenta = dato.Id,
NroItem = dato.Items.Count + 1,
Descripcion = _descripcion,
IdProductoStock = pip.IdProductoStock,
IdPedidoItemProducto = pip.Id,
Cantidad = pip.Cantidad,
PrecioUnitario = _precioUnitario,
Precio = pip.Cantidad * _precioUnitario
};
dato.Items.Add(dvItem);
}
});
}
});
if (pedido.Cliente.ComisionApp > 0 && pedido.NumeroPedidoMinorista > 0)
{
DocumentoVentaItem dvItem = new DocumentoVentaItem()
{
Id = -1,
IdVenta = dato.Id,
NroItem = dato.Items.Count + 1,
Descripcion = string.Format("Comisión APP Tienda WEB {0}%", pedido.Cliente.ComisionApp),
IdProductoStock = -1,
IdPedidoItemProducto = -1,
Cantidad = 1,
PrecioUnitario = (pedido.Total * pedido.Cliente.ComisionApp) / 100,
Precio = (pedido.Total * pedido.Cliente.ComisionApp) / 100
};
dato.Items.Add(dvItem);
}
if (pedido.Cliente.DescuentoOculto > 0)
{
decimal descuento = ((pedido.Total * pedido.Cliente.DescuentoOculto) / 100) * -1;
DocumentoVentaItem dvItem = new DocumentoVentaItem()
{
Id = -1,
IdVenta = dato.Id,
NroItem = dato.Items.Count + 1,
Descripcion = string.Format("Descuento cliente {0}% [NO SE IMPRIME]", pedido.Cliente.DescuentoOculto),
IdProductoStock = -1,
IdPedidoItemProducto = -1,
Cantidad = 1,
PrecioUnitario = descuento,
Precio = descuento
};
dato.Items.Add(dvItem);
}
/************************/
pedido.Estado = this.ObtenerObjeto <Estado>((int)ESTADOS.FACTURADO_);
servPedido.PedidoGrabar(pedido);
/************************/
//hay que grabar para que se actualice el numero de pedido que se esta facturando..
dato.NumeroPedido = pedido.Numero;
dato = this.DocumentoVentaGrabar(dato);
return(dato);
}
public DocumentoVenta DocumentoVentaFacturarProducto(Producto producto)
{
ServiciosProductos servProductos = new ServiciosProductos();
DocumentoVenta dato = this.DocumentoVentaObtener(producto.IdDocumentoVenta);
producto.ProductoStock.ToList <ProductoStock>()
.ForEach(delegate(ProductoStock ps)
{
if (ps.CantidadPedido > 0)
{
Producto prodDescripcion = this.ObtenerObjeto <Producto>(producto.Id);
string descripcion = string.Format("{0} {1} - Código: {2} - {3}",
prodDescripcion.DescripcionCategoria,
prodDescripcion.DescripcionSubcategoria,
producto.Codigo.ToString(),
ps.Medida.Observaciones);
decimal precioUnitario = 0;
if (producto.PrecioPorPeso)
{
precioUnitario = producto.PrecioUnitarioFinal * producto.Peso;
}
else
{
precioUnitario = producto.PrecioUnitarioFinal;
}
DocumentoVentaItem dvItem = new DocumentoVentaItem()
{
Id = -1,
IdVenta = dato.Id,
NroItem = dato.Items.Count + 1,
Descripcion = descripcion,
IdProductoStock = ps.Id,
Cantidad = ps.CantidadPedido,
PrecioUnitario = precioUnitario,
Precio = ps.CantidadPedido * precioUnitario
};
dato.Items.Add(dvItem);
}
});
dato = this.DocumentoVentaGrabar(dato);
//para actualizar, vuelvo a ciclar por las dudas que la actualización que de error al Grabar
bool?_descuentaStock = null;
if (dato.TipoComprobante.Id == (int)TIPOS_COMPROBANTE.NOTA_DE_PEDIDO_)
{
_descuentaStock = true;
}
else if (dato.TipoComprobante.Id == (int)TIPOS_COMPROBANTE.NOTA_DE_CREDITO_)
{
_descuentaStock = false;
}
if (_descuentaStock.HasValue)
{
producto.ProductoStock.ToList <ProductoStock>()
.ForEach(delegate(ProductoStock ps)
{
if (ps.CantidadPedido > 0)
{
servProductos.ProductoStockActualizarStock(ps.Id, ps.CantidadPedido, _descuentaStock.Value);
}
});
}
return(dato);
}