/// <summary> /// Obtiene el listado de lotes que tiene programados para el surtido /// </summary> /// <param name="pedidoDetalle"></param> /// <returns></returns> internal List <ProgramacionMateriaPrimaInfo> ObtenerProgramacionMateriaPrima(PedidoDetalleInfo pedidoDetalle) { try { Logger.Info(); var programacionMateriaPrimaDal = new ProgramacionMateriaPrimaDAL(); var listaProgramacion = programacionMateriaPrimaDal.ObtenerProgramacionMateriaPrima(pedidoDetalle); if (listaProgramacion != null) { var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var almacenBl = new AlmacenBL(); var pesaje = new PesajeMateriaPrimaBL(); foreach (ProgramacionMateriaPrimaInfo programacionMateria in listaProgramacion) { programacionMateria.InventarioLoteOrigen = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( programacionMateria.InventarioLoteOrigen.AlmacenInventarioLoteId); programacionMateria.Almacen = almacenBl.ObtenerPorID(programacionMateria.Almacen.AlmacenID); programacionMateria.PesajeMateriaPrima = pesaje.ObtenerPesajesPorProgramacionMateriaPrimaId( programacionMateria.ProgramacionMateriaPrimaId); } } return(listaProgramacion); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene los pedidos Programados y parciales /// </summary> /// <param name="pedido"></param> /// <returns></returns> internal List <PedidoDetalleInfo> ObtenerDetallePedido(PedidoInfo pedido) { try { Logger.Info(); var pedidoDal = new PedidoDetalleDAL(); var pedidoDetalle = pedidoDal.ObtenerDetallePedido(pedido); if (pedidoDetalle != null) { var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var programacionMateriaPrimaBl = new ProgramacionMateriaPrimaBL(); var productoBl = new ProductoBL(); foreach (PedidoDetalleInfo pedidoDetalleInfo in pedidoDetalle) { pedidoDetalleInfo.InventarioLoteDestino = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( pedidoDetalleInfo.InventarioLoteDestino.AlmacenInventarioLoteId); pedidoDetalleInfo.ProgramacionMateriaPrima = programacionMateriaPrimaBl.ObtenerProgramacionMateriaPrima(pedidoDetalleInfo); pedidoDetalleInfo.Producto = productoBl.ObtenerPorID(pedidoDetalleInfo.Producto); } } return(pedidoDetalle); } catch (ExcepcionGenerica exg) { Logger.Error(exg); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), exg); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene una salida de producto por id /// </summary> /// <param name="salidaProducto"></param> /// <returns></returns> internal SalidaProductoInfo ObtenerPorSalidaProductoId(SalidaProductoInfo salidaProducto) { try { var salidaProductoDal = new SalidaProductoDAL(); salidaProducto = salidaProductoDal.ObtenerPorSalidaProductoId(salidaProducto); if (salidaProducto != null) { if (salidaProducto.Organizacion.OrganizacionID > 0) { var organizacionBl = new OrganizacionBL(); salidaProducto.Organizacion = organizacionBl.ObtenerPorID(salidaProducto.Organizacion.OrganizacionID); } if (salidaProducto.OrganizacionDestino.OrganizacionID > 0) { var organizacionBl = new OrganizacionBL(); salidaProducto.Organizacion = organizacionBl.ObtenerPorID(salidaProducto.OrganizacionDestino.OrganizacionID); } if (salidaProducto.Almacen.AlmacenID > 0) { var almacenBl = new AlmacenBL(); salidaProducto.Almacen = almacenBl.ObtenerPorID(salidaProducto.Almacen.AlmacenID); } if (salidaProducto.AlmacenInventarioLote.AlmacenInventarioLoteId > 0) { var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); salidaProducto.AlmacenInventarioLote = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( salidaProducto.AlmacenInventarioLote.AlmacenInventarioLoteId); } if (salidaProducto.Cliente.ClienteID > 0) { var clienteBl = new ClienteBL(); salidaProducto.Cliente = clienteBl.ObtenerPorID(salidaProducto.Cliente.ClienteID); } if (salidaProducto.CuentaSAP.CuentaSAPID > 0) { var cuentaSapBl = new CuentaSAPBL(); salidaProducto.CuentaSAP = cuentaSapBl.ObtenerPorID(salidaProducto.CuentaSAP.CuentaSAPID); } if (salidaProducto.TipoMovimiento.TipoMovimientoID > 0) { var tipoMovimientoBl = new TipoMovimientoBL(); salidaProducto.TipoMovimiento = tipoMovimientoBl.ObtenerPorID(salidaProducto.TipoMovimiento.TipoMovimientoID); } } } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(salidaProducto); }
/// <summary> /// Termina la salida del producto /// </summary> /// <param name="salida"></param> /// <returns></returns> internal MemoryStream TerminarSalidaProducto(SalidaProductoInfo salida) { try { Logger.Info(); bool generaFactura = salida.GeneraFactura; MemoryStream resultado = null; var almacenBl = new AlmacenBL(); var almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL(); var almacenMovimiento = new AlmacenMovimientoInfo(); var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var almacenInventarioBl = new AlmacenInventarioBL(); var salidaProductoDal = new SalidaProductoDAL(); PolizaAbstract poliza = null; IList <PolizaInfo> polizas = null; using (var transaction = new TransactionScope()) { almacenMovimiento.AlmacenID = salida.Almacen.AlmacenID; almacenMovimiento.TipoMovimientoID = salida.TipoMovimiento.TipoMovimientoID; almacenMovimiento.UsuarioCreacionID = salida.UsuarioModificacionId; almacenMovimiento.Status = (int)EstatusInventario.Aplicado; AlmacenMovimientoInfo almacenMovimientoGenerado = almacenBl.GuardarAlmacenMovimiento(almacenMovimiento); if (almacenMovimientoGenerado != null) { AlmacenInventarioLoteInfo almacenInventarioLote = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( salida.AlmacenInventarioLote.AlmacenInventarioLoteId); var listaAlmacenInventarioDetalle = new List <AlmacenMovimientoDetalle>(); var movimientoDetalle = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoGenerado.AlmacenMovimientoID, AlmacenInventarioLoteId = salida.AlmacenInventarioLote.AlmacenInventarioLoteId, Precio = almacenInventarioLote.PrecioPromedio, ProductoID = salida.Producto.ProductoId, Cantidad = salida.PesoBruto - salida.PesoTara, Piezas = salida.Piezas, Importe = (salida.PesoBruto - salida.PesoTara) * almacenInventarioLote.PrecioPromedio, UsuarioCreacionID = salida.UsuarioModificacionId }; listaAlmacenInventarioDetalle.Add(movimientoDetalle); almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(listaAlmacenInventarioDetalle, almacenMovimientoGenerado. AlmacenMovimientoID); if (almacenInventarioLote != null) { almacenInventarioLote.Cantidad = almacenInventarioLote.Cantidad - (salida.PesoBruto - salida.PesoTara); almacenInventarioLote.Importe = almacenInventarioLote.PrecioPromedio * almacenInventarioLote.Cantidad; almacenInventarioLote.UsuarioModificacionId = salida.UsuarioModificacionId; almacenInventarioLoteBl.Actualizar(almacenInventarioLote); AlmacenInfo almacen = almacenBl.ObtenerPorID(almacenMovimiento.AlmacenID); List <AlmacenInventarioInfo> listaAlmacenlmacenInventario = almacenInventarioBl.ObtienePorAlmacenId(almacen); if (listaAlmacenlmacenInventario != null) { AlmacenInventarioInfo inventarioProducto = listaAlmacenlmacenInventario.FirstOrDefault( registro => registro.ProductoID == salida.Producto.ProductoId); if (inventarioProducto != null) { inventarioProducto.Cantidad = inventarioProducto.Cantidad - (salida.PesoBruto - salida.PesoTara); inventarioProducto.Importe = (inventarioProducto.PrecioPromedio * inventarioProducto.Cantidad); //Actualiza inventario inventarioProducto.UsuarioModificacionID = salida.UsuarioModificacionId; inventarioProducto.ProductoID = salida.Producto.ProductoId; inventarioProducto.AlmacenID = almacen.AlmacenID; almacenInventarioBl.ActualizarPorProductoId(inventarioProducto); salida.GeneraFactura = generaFactura; salidaProductoDal.TerminarSalidaProducto(salida, almacenMovimientoGenerado); #region POLIZA poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza( TipoPoliza.SalidaVentaProducto); salida.Importe = (salida.PesoBruto - salida.PesoTara) * salida.Precio; salida = ObtenerFolioPorReimpresion(salida); polizas = poliza.GeneraPoliza(salida); if (polizas != null) { var polizaBL = new PolizaBL(); polizas.ToList().ForEach(datos => { datos.OrganizacionID = salida.Organizacion.OrganizacionID; datos.UsuarioCreacionID = salida.UsuarioCreacionId; datos.ArchivoEnviadoServidor = 1; }); polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaVentaProducto); if (salida.Almacen == null) { salida.Almacen = new AlmacenInfo(); } salida.Almacen.Organizacion = new OrganizacionInfo { OrganizacionID = salida.Organizacion.OrganizacionID }; resultado = poliza.ImprimePoliza(salida, polizas); } #endregion POLIZA if (generaFactura) { #region FACTURA if (salida.TipoMovimiento.TipoMovimientoID == TipoMovimiento.ProductoSalidaVenta.GetHashCode()) { //Genera el xml y lo guarda en la ruta especificada en la configuración var facturaBl = new FacturaBL(); facturaBl.GenerarDatosFacturaVentaDeMateriaPrima(salida); } #endregion } transaction.Complete(); } else { throw new ExcepcionDesconocida( Properties.ResourceServices.InventarioNormal_ErrorMovimientos); } } else { throw new ExcepcionDesconocida( Properties.ResourceServices.InventarioNormal_ErrorMovimientos); } } else { throw new ExcepcionDesconocida( Properties.ResourceServices.InventarioNormal_ErrorMovimientos); } } else { throw new ExcepcionDesconocida( Properties.ResourceServices.InventarioNormal_ErrorMovimientos); } } return(resultado); } catch (ExcepcionServicio ex) { Logger.Error(ex); throw; } catch (ExcepcionDesconocida) { throw; } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
private long GenerarMovimientoEntrada(TraspasoMpPaMedInfo info) { var almacenInventarioBL = new AlmacenInventarioBL(); var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); decimal cantidadTraspaso = info.CantidadTraspasarDestino; decimal precioPromedio = 0; List <AlmacenInventarioInfo> inventariosDestino = almacenInventarioBL.ObtienePorAlmacenId(info.AlmacenDestino); if (inventariosDestino != null && inventariosDestino.Any()) { AlmacenInventarioInfo almacenInventarioDestino = inventariosDestino.FirstOrDefault(inv => inv.ProductoID == info.ProductoDestino.ProductoId); if (almacenInventarioDestino != null) { almacenInventarioDestino.Cantidad = almacenInventarioDestino.Cantidad + cantidadTraspaso; almacenInventarioDestino.Importe = almacenInventarioDestino.Importe + info.ImporteTraspaso; almacenInventarioDestino.PrecioPromedio = almacenInventarioDestino.Importe / almacenInventarioDestino.Cantidad; almacenInventarioDestino.UsuarioModificacionID = info.Usuario.UsuarioID; almacenInventarioBL.Actualizar(almacenInventarioDestino); } else { //Crear el Inventario var almacenInventarioGuardar = new AlmacenInventarioInfo { AlmacenID = info.AlmacenDestino.AlmacenID, ProductoID = info.ProductoDestino.ProductoId, Cantidad = cantidadTraspaso, Importe = info.ImporteTraspaso, PrecioPromedio = info.ImporteTraspaso / cantidadTraspaso, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenInventarioBL.Crear(almacenInventarioGuardar); } } else { //Crear el Inventario var almacenInventarioGuardar = new AlmacenInventarioInfo { AlmacenID = info.AlmacenDestino.AlmacenID, ProductoID = info.ProductoDestino.ProductoId, Cantidad = cantidadTraspaso, Importe = info.ImporteTraspaso, PrecioPromedio = info.ImporteTraspaso / cantidadTraspaso, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenInventarioBL.Crear(almacenInventarioGuardar); } if (info.LoteMpDestino.AlmacenInventarioLoteId != 0) { AlmacenInventarioLoteInfo loteDestino = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(info.LoteMpDestino.AlmacenInventarioLoteId); if (loteDestino != null) { loteDestino.Cantidad = loteDestino.Cantidad + cantidadTraspaso; loteDestino.Importe = loteDestino.Importe + info.ImporteTraspaso; loteDestino.PrecioPromedio = loteDestino.Importe / loteDestino.Cantidad; loteDestino.UsuarioModificacionId = info.Usuario.UsuarioID; almacenInventarioLoteBL.Actualizar(loteDestino); } } var almacenMovimientoDestino = new AlmacenMovimientoInfo { AlmacenID = info.AlmacenDestino.AlmacenID, TipoMovimientoID = TipoMovimiento.EntradaAlmacen.GetHashCode(), ProveedorId = info.ProveedorDestino.ProveedorID, Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = info.Usuario.UsuarioID, Observaciones = info.JustificacionDestino }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoDestino); precioPromedio = info.ImporteTraspaso / info.CantidadTraspasarDestino; var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, //ContratoId = info.ContratoDestino.ContratoId, AlmacenInventarioLoteId = info.LoteMpDestino.AlmacenInventarioLoteId, Piezas = 0, ProductoID = info.ProductoDestino.ProductoId, Precio = precioPromedio, Cantidad = cantidadTraspaso, Importe = info.ImporteTraspaso, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo); return(almacenMovimientoID); }
private long GenerarMovimientoEntradaCancelacion(AlmacenMovimientoInfo info, UsuarioInfo usuario) { var almacenInventarioBL = new AlmacenInventarioBL(); var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); AlmacenMovimientoDetalle detalle = info.ListaAlmacenMovimientoDetalle.FirstOrDefault(); if (detalle == null) { return(0); } //decimal cantidadTraspaso = detalle.Cantidad; List <AlmacenInventarioInfo> inventariosDestino = almacenInventarioBL.ObtienePorAlmacenId(info.Almacen); AlmacenInventarioInfo almacenInventarioDestino = null; if (inventariosDestino != null && inventariosDestino.Any()) { almacenInventarioDestino = inventariosDestino.FirstOrDefault(inv => inv.ProductoID == detalle.Producto.ProductoId); if (almacenInventarioDestino != null) { almacenInventarioDestino.Cantidad = almacenInventarioDestino.Cantidad + detalle.Cantidad; almacenInventarioDestino.Importe = almacenInventarioDestino.Importe + detalle.Importe; almacenInventarioDestino.PrecioPromedio = almacenInventarioDestino.Importe / almacenInventarioDestino.Cantidad; almacenInventarioDestino.UsuarioModificacionID = usuario.UsuarioID; almacenInventarioBL.Actualizar(almacenInventarioDestino); } } if (detalle.AlmacenInventarioLoteId != 0) { AlmacenInventarioLoteInfo loteDestino = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(detalle.AlmacenInventarioLoteId); if (loteDestino != null) { loteDestino.Cantidad = loteDestino.Cantidad + detalle.Cantidad; loteDestino.Importe = loteDestino.Importe + detalle.Importe; loteDestino.PrecioPromedio = loteDestino.Importe / loteDestino.Cantidad; loteDestino.UsuarioModificacionId = usuario.UsuarioID; almacenInventarioLoteBL.Actualizar(loteDestino); } } var almacenMovimientoDestino = new AlmacenMovimientoInfo { AlmacenID = info.Almacen.AlmacenID, TipoMovimientoID = TipoMovimiento.EntradaAlmacen.GetHashCode(), ProveedorId = info.ProveedorId, Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = usuario.UsuarioID, }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoDestino); if (almacenInventarioDestino != null) { var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, AlmacenInventarioLoteId = detalle.AlmacenInventarioLoteId, //ContratoId = detalle.ContratoId, Piezas = 0, ProductoID = detalle.Producto.ProductoId, Precio = detalle.Precio, Cantidad = detalle.Cantidad, Importe = detalle.Importe, UsuarioCreacionID = usuario.UsuarioID }; almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo); } return(almacenMovimientoID); }
private long GenerarMovimientoSalida(TraspasoMpPaMedInfo info) { var almacenInventarioBL = new AlmacenInventarioBL(); var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); decimal cantidadTraspaso = info.CantidadTraspasarOrigen; List <AlmacenInventarioInfo> inventariosOrigen = almacenInventarioBL.ObtienePorAlmacenId(info.AlmacenOrigen); AlmacenInventarioInfo almacenInventarioOrigen = null; decimal precioPromedio = 0; decimal importe = 0; if (inventariosOrigen != null && inventariosOrigen.Any()) { almacenInventarioOrigen = inventariosOrigen.FirstOrDefault(inv => inv.ProductoID == info.ProductoOrigen.ProductoId); if (almacenInventarioOrigen != null) { almacenInventarioOrigen.Cantidad = almacenInventarioOrigen.Cantidad - cantidadTraspaso; almacenInventarioOrigen.Importe = almacenInventarioOrigen.Importe - Math.Round(cantidadTraspaso * almacenInventarioOrigen.PrecioPromedio, 2); if (almacenInventarioOrigen.Importe < 0) { almacenInventarioOrigen.Importe = 0; } if (almacenInventarioOrigen.Cantidad > 0) { almacenInventarioOrigen.PrecioPromedio = almacenInventarioOrigen.Importe / almacenInventarioOrigen.Cantidad; } almacenInventarioOrigen.UsuarioModificacionID = info.Usuario.UsuarioID; almacenInventarioBL.Actualizar(almacenInventarioOrigen); precioPromedio = almacenInventarioOrigen.PrecioPromedio; importe = precioPromedio * cantidadTraspaso; } } if (info.LoteMpOrigen.AlmacenInventarioLoteId != 0) { AlmacenInventarioLoteInfo loteOrigen = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(info.LoteMpOrigen.AlmacenInventarioLoteId); if (loteOrigen != null) { loteOrigen.Cantidad = loteOrigen.Cantidad - cantidadTraspaso; loteOrigen.Importe = loteOrigen.Importe - Math.Round(cantidadTraspaso * loteOrigen.PrecioPromedio, 2); if (loteOrigen.Importe < 0) { loteOrigen.Importe = 0; } if (loteOrigen.Cantidad > 0) { loteOrigen.PrecioPromedio = loteOrigen.Importe / loteOrigen.Cantidad; } loteOrigen.UsuarioModificacionId = info.Usuario.UsuarioID; almacenInventarioLoteBL.Actualizar(loteOrigen); precioPromedio = loteOrigen.PrecioPromedio; importe = precioPromedio * cantidadTraspaso; } } var almacenMovimientoOrigen = new AlmacenMovimientoInfo { AlmacenID = info.AlmacenOrigen.AlmacenID, TipoMovimientoID = TipoMovimiento.ProductoSalidaTraspaso.GetHashCode(), ProveedorId = info.ProveedorOrigen.ProveedorID, Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = info.Usuario.UsuarioID, Observaciones = info.JustificacionDestino }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoOrigen); if (almacenInventarioOrigen != null) { var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, AlmacenInventarioLoteId = info.LoteMpOrigen.AlmacenInventarioLoteId, Piezas = 0, ProductoID = info.ProductoOrigen.ProductoId, Precio = precioPromedio, Cantidad = cantidadTraspaso, Importe = importe, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo); } info.ImporteTraspaso = importe; return(almacenMovimientoID); }
/// <summary> /// Actualiza la recepcion de materia prima /// </summary> /// <param name="listaSurtido"></param> /// <param name="pedido"></param> /// <returns></returns> internal bool ActualizarRecepcionMateriaPrima(List <SurtidoPedidoInfo> listaSurtido, PedidoInfo pedido) { bool resultado; try { Logger.Info(); var almacenInventarioBl = new AlmacenInventarioBL(); var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var almacenBl = new AlmacenBL(); var proveedorChofeBl = new ProveedorChoferBL(); int proveedorId = 0; var pesajeMateriaPrimaBl = new PesajeMateriaPrimaBL(); int organizacionID; PolizaAbstract poliza; IList <PolizaInfo> polizas; IList <ResultadoPolizaModel> resultadoPolizaModel; var contenedorAlmacenesMovimientos = new List <ContenedorAlmacenMovimientoCierreDia>(); ContenedorAlmacenMovimientoCierreDia contenedorAlmacenMovimiento; var surtidoGenerarPoliza = new List <SurtidoPedidoInfo>(); using (var transaction = new TransactionScope()) { ProgramacionMateriaPrimaInfo programacionMateriaPrima; var programacionMateriaPrimaBL = new ProgramacionMateriaPrimaBL(); foreach (var surtidoTmp in listaSurtido) { if (surtidoTmp.Seleccionado) { programacionMateriaPrima = programacionMateriaPrimaBL. ObtenerPorProgramacionMateriaPrimaTicket( surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId, surtidoTmp.PesajeMateriaPrima.Ticket); if (programacionMateriaPrima != null) { continue; } surtidoGenerarPoliza.Add(surtidoTmp); var pesaje = pesajeMateriaPrimaBl.ObtenerPorId(surtidoTmp.PesajeMateriaPrima); // Se consulta el proveedor del Proveedor chofer seleccionado para el pesaje. var proveedorChofeInfo = proveedorChofeBl.ObtenerProveedorChoferPorId( surtidoTmp.PesajeMateriaPrima.ProveedorChoferID); if (proveedorChofeInfo != null) { proveedorId = proveedorChofeInfo.Proveedor.ProveedorID; } //SE OBTIENEN LOS DATOS DEL LOTE DESTINO var almacenInventarioLoteDestino = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( surtidoTmp.PedidoDetalle.InventarioLoteDestino.AlmacenInventarioLoteId); //SE OBTIENEN LOS DATOS DEL LOTE ORIGEN var almacenInventarioLoteOrigen = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( surtidoTmp.ProgramacionMateriaPrima.InventarioLoteOrigen .AlmacenInventarioLoteId); #region INVENTARIO ORIGEN // GENERA MOVIMIENTO DE INVENTARIO var almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo { AlmacenID = almacenInventarioLoteOrigen .AlmacenInventario. AlmacenID, TipoMovimientoID = (int) TipoMovimiento. PaseProceso, Observaciones = "", Status = (int)EstatusInventario.Aplicado, AnimalMovimientoID = 0, ProveedorId = proveedorId, UsuarioCreacionID = pedido. UsuarioModificacion. UsuarioID }); // SE LE ASIGNA EL MOVIMIENTO GENERADO AL PESAJE pesaje.AlmacenMovimientoOrigenId = almacenMovimiento.AlmacenMovimientoID; contenedorAlmacenMovimiento = new ContenedorAlmacenMovimientoCierreDia { AlmacenMovimiento = new AlmacenMovimientoInfo { AlmacenMovimientoID = almacenMovimiento. AlmacenMovimientoID } }; contenedorAlmacenesMovimientos.Add(contenedorAlmacenMovimiento); // GENERA EL DETALLE DEL MOVIMIENTO almacenBl.GuardarAlmacenMovimientoDetalleProducto( new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID, ProductoID = surtidoTmp.Producto.ProductoId, Precio = almacenInventarioLoteOrigen.PrecioPromedio, Cantidad = surtidoTmp.CantidadEntregada, Importe = almacenInventarioLoteOrigen.PrecioPromedio * surtidoTmp.CantidadEntregada, AlmacenInventarioLoteId = almacenInventarioLoteOrigen.AlmacenInventarioLoteId, ContratoId = 0, Piezas = surtidoTmp.PesajeMateriaPrima.Piezas, UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID }); // GENERA LA SALIDA DEL INVENTARIO LOTE almacenInventarioLoteOrigen.Cantidad -= surtidoTmp.CantidadEntregada; almacenInventarioLoteOrigen.Piezas -= surtidoTmp.PesajeMateriaPrima.Piezas; almacenInventarioLoteOrigen.Importe = almacenInventarioLoteOrigen.PrecioPromedio * almacenInventarioLoteOrigen.Cantidad; almacenInventarioLoteOrigen.UsuarioModificacionId = pedido.UsuarioModificacion.UsuarioID; almacenInventarioLoteBl.Actualizar(almacenInventarioLoteOrigen); // GENERA LA SALIDA DEL ALMACEN INVENTARIO var almacenInventarioInfo = almacenInventarioBl.ObtenerAlmacenInventarioPorId( almacenInventarioLoteOrigen.AlmacenInventario.AlmacenInventarioID); almacenInventarioInfo.Cantidad = almacenInventarioInfo.Cantidad - surtidoTmp.CantidadEntregada; almacenInventarioInfo.Importe = almacenInventarioInfo.PrecioPromedio * almacenInventarioInfo.Cantidad; almacenInventarioInfo.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID; almacenInventarioBl.Actualizar(almacenInventarioInfo); #endregion #region INVENTARIO DESTINO //Obtener costos de flete var fleteInternoPl = new FleteInternoPL(); var listadoCostos = fleteInternoPl.ObtenerCostosPorFleteConfiguracion(new FleteInternoInfo { Organizacion = new OrganizacionInfo { OrganizacionID = pedido.Organizacion.OrganizacionID }, AlmacenOrigen = new AlmacenInfo { AlmacenID = almacenInventarioLoteOrigen.AlmacenInventario.AlmacenID }, Producto = new ProductoInfo { ProductoId = surtidoTmp.Producto.ProductoId } }, new ProveedorInfo { ProveedorID = surtidoTmp.Proveedor.ProveedorID }); decimal importeCostos = 0; if (listadoCostos != null) { foreach (var fleteInternoCostoInfo in listadoCostos) { if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode()) { importeCostos += fleteInternoCostoInfo.Tarifa; } else { importeCostos += (surtidoTmp.CantidadEntregada / 1000) * fleteInternoCostoInfo.Tarifa; } } //importeCostos = listadoCostos.Sum(fleteInternoCostoInfo => fleteInternoCostoInfo.Tarifa); } almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo { AlmacenID = almacenInventarioLoteDestino .AlmacenInventario. AlmacenID, TipoMovimientoID = (int) TipoMovimiento. RecepcionAProceso, Observaciones = pedido.Observaciones, Status = (int)EstatusInventario.Aplicado, AnimalMovimientoID = 0, ProveedorId = proveedorId, UsuarioCreacionID = pedido. UsuarioModificacion. UsuarioID }); // SE LE ASIGNA EL MOVIMIENTO AL PESAJE pesaje.AlmacenMovimientoDestinoId = almacenMovimiento.AlmacenMovimientoID; // GENERA LA ENTRADA DEL INVENTARIO LOTE almacenInventarioLoteDestino.Piezas += surtidoTmp.PesajeMateriaPrima.Piezas; decimal importe = surtidoTmp.CantidadEntregada * almacenInventarioLoteOrigen.PrecioPromedio; almacenInventarioLoteDestino.Importe += importe; almacenInventarioLoteDestino.Cantidad += surtidoTmp.CantidadEntregada; almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe / almacenInventarioLoteDestino.Cantidad; almacenInventarioLoteDestino.UsuarioModificacionId = pedido.UsuarioModificacion.UsuarioID; // //Se agregan los costos al importe del lote //importeCostos = importeCostos * surtidoTmp.CantidadEntregada; almacenInventarioLoteDestino.Importe = almacenInventarioLoteDestino.Importe + importeCostos; almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe / almacenInventarioLoteDestino.Cantidad; // almacenInventarioLoteBl.Actualizar(almacenInventarioLoteDestino); // GENERA EL DETALLE DEL MOVIMIENTO almacenBl.GuardarAlmacenMovimientoDetalleProducto( new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID, ProductoID = surtidoTmp.Producto.ProductoId, Precio = almacenInventarioLoteOrigen.PrecioPromedio, Cantidad = surtidoTmp.CantidadEntregada, Importe = importe, AlmacenInventarioLoteId = almacenInventarioLoteDestino.AlmacenInventarioLoteId, ContratoId = 0, Piezas = surtidoTmp.PesajeMateriaPrima.Piezas, UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID }); //Guarda almacen movimiento costo if (listadoCostos != null) { foreach (var fleteInternoCostoInfo in listadoCostos) { var almacenMovimientoCosto = new AlmacenMovimientoCostoBL(); decimal importeCostoFlete = 0; if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode()) { importeCostoFlete = fleteInternoCostoInfo.Tarifa; } else { importeCostoFlete = (surtidoTmp.CantidadEntregada / 1000) * fleteInternoCostoInfo.Tarifa; } almacenMovimientoCosto.Crear(new AlmacenMovimientoCostoInfo { AlmacenMovimientoId = almacenMovimiento.AlmacenMovimientoID, ProveedorId = surtidoTmp.Proveedor.ProveedorID, CostoId = fleteInternoCostoInfo.Costo.CostoID, Importe = importeCostoFlete, Cantidad = surtidoTmp.CantidadEntregada, Activo = EstatusEnum.Activo, UsuarioCreacionId = pedido.UsuarioModificacion.UsuarioID }); } } // programacionMateriaPrimaBL.ActualizarAlmacenMovimiento( surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId, almacenMovimiento.AlmacenMovimientoID); // GENERA LA ENTRADA DEL ALMACEN INVENTARIO almacenInventarioInfo = almacenInventarioBl.ObtenerAlmacenInventarioPorId( almacenInventarioLoteDestino.AlmacenInventario.AlmacenInventarioID); List <AlmacenInventarioLoteInfo> listaAlmacenInventarioLote = almacenInventarioLoteBl.ObtenerPorAlmacenInventarioID(almacenInventarioInfo); var almacenInventario = new AlmacenInventarioInfo(); almacenInventario.AlmacenInventarioID = almacenInventarioInfo.AlmacenInventarioID; // SE SUMAN LAS CANTIDADES E IMPORTES QUE TIENE EL ALMACEN foreach (var almacenInventarioLoteInfo in listaAlmacenInventarioLote) { almacenInventario.Cantidad += almacenInventarioLoteInfo.Cantidad; almacenInventario.Importe += almacenInventarioLoteInfo.Importe; } almacenInventario.PrecioPromedio = almacenInventario.Importe / almacenInventario.Cantidad; almacenInventario.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID; almacenInventario.ProductoID = surtidoTmp.Producto.ProductoId; almacenInventario.AlmacenID = almacenInventarioLoteDestino.AlmacenInventario.AlmacenID; almacenInventarioBl.ActualizarPorProductoId(almacenInventario); #endregion // SE ACTUALIZA EL PESAJE DE MATERIA PRIMA pesaje.EstatusID = (int)Estatus.PedidoCompletado; pesaje.Activo = false; pesaje.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID; pesajeMateriaPrimaBl.ActualizarPesajePorId(pesaje); } } #region POLIZA organizacionID = pedido.Organizacion.OrganizacionID; string lotes = ObtenerXMLLote(listaSurtido); var pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL(); List <PolizaPaseProcesoModel> datosPoliza = pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProceso(pedido.FolioPedido, organizacionID, lotes); if (datosPoliza != null) { datosPoliza = (from dp in datosPoliza from ls in surtidoGenerarPoliza where dp.Proveedor.ProveedorID == ls.Proveedor.ProveedorID && dp.Producto.ProductoId == ls.Producto.ProductoId && dp.PesajeMateriaPrima.Ticket == ls.PesajeMateriaPrima.Ticket select dp).ToList(); } if (datosPoliza != null && datosPoliza.Any()) { poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso); IList <PolizaPaseProcesoModel> polizasPaseProcesoModel; resultadoPolizaModel = new List <ResultadoPolizaModel>(); datosPoliza = datosPoliza.GroupBy(prod => new { prod.Producto, prod.ProveedorChofer, prod.PesajeMateriaPrima.Ticket }) .Select(grupo => new PolizaPaseProcesoModel { Organizacion = grupo.Select(org => org.Organizacion).FirstOrDefault(), Almacen = grupo.Select(alm => alm.Almacen).FirstOrDefault(), Producto = grupo.Key.Producto, Proveedor = grupo.Select(prov => prov.Proveedor).FirstOrDefault(), AlmacenMovimiento = grupo.Select(alm => alm.AlmacenMovimiento).FirstOrDefault(), AlmacenMovimientoDetalle = grupo.Select(alm => alm.AlmacenMovimientoDetalle).FirstOrDefault(), AlmacenInventarioLote = grupo.Select(alm => alm.AlmacenInventarioLote).FirstOrDefault(), FleteInterno = grupo.Select(flete => flete.FleteInterno).FirstOrDefault(), FleteInternoCosto = grupo.Select(flete => flete.FleteInternoCosto).FirstOrDefault(), Pedido = grupo.Select(ped => ped.Pedido).FirstOrDefault(), ProveedorChofer = grupo.Key.ProveedorChofer, PesajeMateriaPrima = grupo.Select(pesaje => pesaje.PesajeMateriaPrima).FirstOrDefault(), ProgramacionMateriaPrima = grupo.Select(prog => prog.ProgramacionMateriaPrima).FirstOrDefault(), ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).FirstOrDefault(), }).ToList(); IList <PolizaInfo> polizaExistente; var polizaBL = new PolizaBL(); for (var indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++) { polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> { datosPoliza[indexPoliza] }; polizas = poliza.GeneraPoliza(polizasPaseProcesoModel); if (polizas != null) { var resultadoPoliza = new ResultadoPolizaModel { Polizas = polizas }; polizas.ToList().ForEach(datos => { datos.OrganizacionID = organizacionID; datos.UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID; datos.ArchivoEnviadoServidor = 1; }); polizaExistente = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso, organizacionID, pedido.FechaPedido, string.Format("{0}-{1}", pedido.FolioPedido, datosPoliza[indexPoliza]. PesajeMateriaPrima.Ticket), "PP", 1); if (polizaExistente != null && polizaExistente.Any()) { List <PolizaInfo> excluir = (from existente in polizaExistente join guardar in polizas on existente.Concepto equals guardar.Concepto select guardar).ToList(); polizas = polizas.Except(excluir).ToList(); } if (polizas.Any()) { polizaBL.GuardarServicioPI(polizas, TipoPoliza.PaseProceso); resultadoPolizaModel.Add(resultadoPoliza); } } } var almacenMovimientoBL = new AlmacenMovimientoBL(); contenedorAlmacenesMovimientos.ForEach(alm => alm.Almacen = new AlmacenInfo { UsuarioModificacionID = pedido. UsuarioModificacion. UsuarioID }); almacenMovimientoBL.ActualizarGeneracionPoliza(contenedorAlmacenesMovimientos); } #endregion POLIZA transaction.Complete(); resultado = true; } } catch (ExcepcionGenerica exg) { resultado = false; Logger.Error(exg); } catch (Exception ex) { resultado = false; Logger.Error(ex); } return(resultado); }
/// <summary> /// Se actualiza inventario y lote /// </summary> /// <param name="diferenciasDeInventariosInfo"></param> /// <param name="usuarioId"></param> internal void ActualizarInventarioYLote(DiferenciasDeInventariosInfo diferenciasDeInventariosInfo, int usuarioId) { var almacenInventarioBl = new AlmacenInventarioBL(); var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); //Actualiza inventario //Obtenemos el inventario de acuerdo al almacen y producto obtenido var inventarioInfo = almacenInventarioBl.ObtenerPorAlmacenIdProductoId(new AlmacenInventarioInfo() { AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID, ProductoID = diferenciasDeInventariosInfo.Producto.ProductoId }); if (inventarioInfo != null) { if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.SalidaPorAjuste.GetHashCode()) { inventarioInfo.Cantidad = inventarioInfo.Cantidad - diferenciasDeInventariosInfo.DiferenciaInventario; inventarioInfo.Importe = inventarioInfo.PrecioPromedio * inventarioInfo.Cantidad; } if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.EntradaPorAjuste.GetHashCode()) { inventarioInfo.Cantidad = inventarioInfo.Cantidad + diferenciasDeInventariosInfo.DiferenciaInventario; inventarioInfo.Importe = inventarioInfo.PrecioPromedio * inventarioInfo.Cantidad; } inventarioInfo.UsuarioModificacionID = usuarioId; //Actualiza inventario almacenInventarioBl.Actualizar(inventarioInfo); } //Actualiza inventario lote var almacenInventarioLoteInfo = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( diferenciasDeInventariosInfo.AlmacenInventarioLote.AlmacenInventarioLoteId); if (almacenInventarioLoteInfo != null) { if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.SalidaPorAjuste.GetHashCode()) { almacenInventarioLoteInfo.Cantidad = almacenInventarioLoteInfo.Cantidad - diferenciasDeInventariosInfo.DiferenciaInventario; almacenInventarioLoteInfo.Importe = almacenInventarioLoteInfo.PrecioPromedio * almacenInventarioLoteInfo.Cantidad; } if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.EntradaPorAjuste.GetHashCode()) { almacenInventarioLoteInfo.Cantidad = almacenInventarioLoteInfo.Cantidad + diferenciasDeInventariosInfo.DiferenciaInventario; almacenInventarioLoteInfo.Importe = almacenInventarioLoteInfo.PrecioPromedio * almacenInventarioLoteInfo.Cantidad; } almacenInventarioLoteInfo.UsuarioModificacionId = usuarioId; //Actualiza inventario almacenInventarioLoteBl.Actualizar(almacenInventarioLoteInfo); //Kilogramos teoricos en 0 se desactiva el lote //if (diferenciasDeInventariosInfo.KilogramosFisicos == 0) //{ // //Desactivar lote // almacenInventarioLoteBl.DesactivarLote(almacenInventarioLoteInfo); //} } }
/// <summary> /// Guarda los ajustes /// </summary> /// <param name="listaDiferenciasInventario"></param> /// <param name="usuarioInfo"></param> internal IList <MemoryStream> Guardar(List <DiferenciasDeInventariosInfo> listaDiferenciasInventario, UsuarioInfo usuarioInfo) { int usuarioId = usuarioInfo.UsuarioID; PolizaAbstract poliza = null; IList <PolizaInfo> polizas = null; int organizacionID; //var contratoCreado = new ContratoInfo(); IList <MemoryStream> streams = null; try { using (var transaction = new TransactionScope()) { var almacenMovimientoBl = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL(); organizacionID = usuarioInfo.OrganizacionID; foreach (var diferenciasDeInventariosInfo in listaDiferenciasInventario) { if (diferenciasDeInventariosInfo.DescripcionAjuste.Equals(TipoAjusteEnum.CerrarLote.ToString(), StringComparison.InvariantCultureIgnoreCase)) { var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var almacenInventarioLoteInfo = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( diferenciasDeInventariosInfo.AlmacenInventarioLote.AlmacenInventarioLoteId); if (almacenInventarioLoteInfo != null) { almacenInventarioLoteInfo.UsuarioModificacionId = usuarioInfo.UsuarioID; //Kilogramos teoricos en 0 se desactiva el lote if (diferenciasDeInventariosInfo.KilogramosFisicos == 0) { //Desactivar lote almacenInventarioLoteBl.DesactivarLote(almacenInventarioLoteInfo); } } continue; } diferenciasDeInventariosInfo.DiferenciaInventario = Math.Abs(diferenciasDeInventariosInfo.KilogramosFisicos - diferenciasDeInventariosInfo.KilogramosTeoricos); ////Se le quita el signo para que no guarde en negativos //diferenciasDeInventariosInfo.KilogramosTeoricos = // Math.Abs(diferenciasDeInventariosInfo.KilogramosTeoricos); //organizacionID = diferenciasDeInventariosInfo.AlmacenMovimiento.OrganizacionID; //Si no esta guardado se actualiza if (!diferenciasDeInventariosInfo.Guardado) { AlmacenMovimientoInfo almacen = new AlmacenMovimientoInfo(); //Estatus aplicado guarda y actualiza inventario if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status == Estatus.DifInvAplicado.GetHashCode()) { //Insertar movimiento diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID; var almacenMovimientoId = almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento); //Insertar detalle var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoId, AlmacenInventarioLoteId = diferenciasDeInventariosInfo. AlmacenInventarioLote. AlmacenInventarioLoteId, Piezas = 0, ProductoID = diferenciasDeInventariosInfo.Producto. ProductoId, Precio = diferenciasDeInventariosInfo. AlmacenInventarioLote.PrecioPromedio, Cantidad = diferenciasDeInventariosInfo. DiferenciaInventario, Importe = diferenciasDeInventariosInfo. DiferenciaInventario * diferenciasDeInventariosInfo. AlmacenInventarioLote.PrecioPromedio, UsuarioCreacionID = usuarioInfo.UsuarioID }; long almacenMovimientoDetalleID = almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo); //SE AGREGA DETALLE almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID; //var almacenmovimientoBl1 = new AlmacenMovimientoDetalleBL(); //var d = // almacenmovimientoBl1.ObtenerPorAlmacenMovimientoDetalleId(almacenMovimientoDetalleInfo); diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo; //SE AGREGA DETALLE //Actualizamos inventario y lote ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID); } //Si es pendiente solo guarda el movimiento y detalle if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status == Estatus.DifInvPendiente.GetHashCode()) { //Insertar movimiento diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID; var almacenMovimientoId = almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento); //Insertar detalle var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle() { AlmacenMovimientoID = almacenMovimientoId, AlmacenInventarioLoteId = diferenciasDeInventariosInfo. AlmacenInventarioLote. AlmacenInventarioLoteId, Piezas = 0, ProductoID = diferenciasDeInventariosInfo.Producto. ProductoId, Precio = diferenciasDeInventariosInfo. AlmacenInventarioLote.PrecioPromedio, Cantidad = diferenciasDeInventariosInfo. DiferenciaInventario, Importe = diferenciasDeInventariosInfo. DiferenciaInventario * diferenciasDeInventariosInfo. AlmacenInventarioLote.PrecioPromedio, UsuarioCreacionID = usuarioInfo.UsuarioID }; long almacenMovimientoDetalleID = almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo); //Se valida si requiere autorizacion if (diferenciasDeInventariosInfo.RequiereAutorizacion) { var almacenBl = new AlmacenBL(); AlmacenMovimientoInfo almacenMovimientoInfo = new AlmacenMovimientoInfo { AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID, AlmacenMovimientoID = almacenMovimientoId }; almacen = almacenBl.ObtenerAlmacenMovimiento(almacenMovimientoInfo); var autorizacionMateriaPrimaInfo = new AutorizacionMateriaPrimaInfo { OrganizacionID = usuarioInfo.OrganizacionID, TipoAutorizacionID = TipoAutorizacionEnum.AjustedeInventario.GetHashCode(), Folio = almacen.FolioMovimiento, Justificacion = almacen.Observaciones, Lote = diferenciasDeInventariosInfo.AlmacenInventarioLote.Lote, Precio = almacenMovimientoDetalleInfo.Precio, Cantidad = almacenMovimientoDetalleInfo.Cantidad, ProductoID = almacenMovimientoDetalleInfo.ProductoID, AlmacenID = almacen.AlmacenID, EstatusID = Estatus.AMPPendien.GetHashCode(), UsuarioCreacion = usuarioInfo.UsuarioID, Activo = EstatusEnum.Activo.GetHashCode() }; var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); almacenInventarioLoteBL.GuardarAutorizacionMateriaPrima( autorizacionMateriaPrimaInfo); } //SE AGREGA DETALLE almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID; diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo; //SE AGREGA DETALLE } } else { if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status == Estatus.DifInvAplicado.GetHashCode()) { //Actualizar estatus a regitro //Agregar observaciones almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento); //Actualizar detalle movimiento var almacenMovimientoDetalleInfo = almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId( diferenciasDeInventariosInfo.AlmacenMovimientoDetalle); almacenMovimientoDetalleInfo.Cantidad = diferenciasDeInventariosInfo.DiferenciaInventario; almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad * almacenMovimientoDetalleInfo.Precio; almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID; almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle( almacenMovimientoDetalleInfo); //Actualizamos inventario y lote ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID); //SE AGREGA DETALLE diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo; //SE AGREGA DETALLE } //Guardado con estatus pendiente se actualiza almacen movimiento y almacen movimiento detalle if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status == Estatus.DifInvPendiente.GetHashCode()) { //Actualizar almacen movimiento almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento); //Actualizar movimiento detalle //Verificar si se ocupa obtenerlo var almacenMovimientoDetalleInfo = almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId( diferenciasDeInventariosInfo.AlmacenMovimientoDetalle); almacenMovimientoDetalleInfo.Cantidad = diferenciasDeInventariosInfo.DiferenciaInventario; almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad * almacenMovimientoDetalleInfo.Precio; //Pendiente usuario modificacion almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID; almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle( almacenMovimientoDetalleInfo); //SE AGREGA DETALLE diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo; //SE AGREGA DETALLE } } } #region POLIZA var listaDiferenciasInventarioAplicados = listaDiferenciasInventario.Where(dif => dif.AlmacenMovimiento.Status == Estatus.DifInvAplicado.GetHashCode()).ToList(); List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste = listaDiferenciasInventarioAplicados.Where(dif => !dif.DescripcionAjuste.Trim().Equals(TipoAjusteEnum.CerrarLote.ToString().Trim(), StringComparison.InvariantCultureIgnoreCase)).Select(ajuste => new PolizaEntradaSalidaPorAjusteModel { Importe = ajuste.DiferenciaInventario * ajuste.AlmacenInventarioLote. PrecioPromedio, Cantidad = ajuste.DiferenciaInventario, TipoAjuste = ajuste.DescripcionAjuste.Equals( TipoAjusteEnum.Merma.ToString(), StringComparison. CurrentCultureIgnoreCase) ? TipoAjusteEnum.Merma : TipoAjusteEnum.Superávit, Precio = ajuste.AlmacenInventarioLote. PrecioPromedio, AlmacenInventarioID = ajuste.AlmacenInventarioLote. AlmacenInventario.AlmacenInventarioID, AlmacenMovimientoDetalleID = ajuste.AlmacenMovimientoDetalle. AlmacenMovimientoDetalleID, ProductoID = ajuste.Producto.ProductoId, CantidadInventarioFisico = ajuste.KilogramosFisicos, CantidadInventarioTeorico = ajuste.KilogramosTeoricos, Observaciones = ajuste.AlmacenMovimiento.Observaciones }).ToList(); var agrupado = salidasPorAjuste.GroupBy(tipo => new { tipo.TipoAjuste, tipo.AlmacenMovimientoDetalleID }).Select( ajuste => new PolizaEntradaSalidaPorAjusteModel { TipoAjuste = ajuste.Key.TipoAjuste, AlmacenInventarioID = ajuste.First().AlmacenInventarioID, AlmacenMovimientoDetalleID = ajuste.Key.AlmacenMovimientoDetalleID, Cantidad = ajuste.First().Cantidad, CantidadInventarioFisico = ajuste.First().CantidadInventarioFisico, CantidadInventarioTeorico = ajuste.First().CantidadInventarioTeorico, Importe = ajuste.First().Importe, Observaciones = ajuste.First().Observaciones, Precio = ajuste.First().Precio, PrecioInventarioFisico = ajuste.First().PrecioInventarioFisico, PrecioInventarioTeorico = ajuste.First().PrecioInventarioTeorico, ProductoID = ajuste.First().ProductoID }).ToList(); if (agrupado != null && agrupado.Any()) { streams = new List <MemoryStream>(); for (int indexAjustes = 0; indexAjustes < agrupado.Count; indexAjustes++) { var tipoPoliza = TipoPoliza.SalidaAjuste; switch (agrupado[indexAjustes].TipoAjuste) { case TipoAjusteEnum.Superávit: tipoPoliza = TipoPoliza.EntradaAjuste; break; } poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza); var grupo = new List <PolizaEntradaSalidaPorAjusteModel> { agrupado[indexAjustes] }; polizas = poliza.GeneraPoliza(grupo); if (polizas != null && polizas.Any()) { MemoryStream stream = poliza.ImprimePoliza(grupo, polizas); if (stream != null) { streams.Add(stream); } var polizaBL = new PolizaBL(); polizas.ToList().ForEach(datos => { datos.OrganizacionID = organizacionID; datos.UsuarioCreacionID = usuarioId; datos.ArchivoEnviadoServidor = 1; }); polizaBL.GuardarServicioPI(polizas, tipoPoliza); } } } #endregion POLIZA transaction.Complete(); } } catch (ExcepcionServicio ex) { Logger.Error(ex); throw; } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(streams); }
/// <summary> /// Crea el nuevo lote para la organizacion producto tipo almacen seleccionados /// </summary> /// <param name="parametro"></param> /// <returns></returns> internal AlmacenInventarioLoteInfo CrearLotePorOrganizacionTipoAlmacenProducto(ParametrosOrganizacionTipoAlmacenProductoActivo parametro) { try { var almacenBl = new AlmacenBL(); var almacenInventarioBl = new AlmacenInventarioBL(); var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); AlmacenInventarioLoteInfo almacenInventarioLote = null; var almacenInventario = almacenBl.ObtenerAlmacenInventarioPorOrganizacionTipoAlmacen(new ParametrosOrganizacionTipoAlmacenProductoActivo { OrganizacionId = parametro.OrganizacionId, TipoAlmacenId = parametro.TipoAlmacenId, Activo = parametro.Activo, ProductoId = parametro.ProductoId }); // Si el producto no se encuentra en el almacen inventario, lo insertamos if (almacenInventario == null) { var listaAlmacenOrganizacion = almacenBl.ObtenerAlmacenPorOrganizacion(parametro.OrganizacionId); if (listaAlmacenOrganizacion != null) { // Obtenemos el almacen y validamos que sea del mismo tipo Almacen foreach (AlmacenInfo almacenInfo in listaAlmacenOrganizacion) { // Aqui se valida que el almacen sea del tipo seleccionado if (almacenInfo.TipoAlmacen.TipoAlmacenID == parametro.TipoAlmacenId) { almacenInventario = new AlmacenInventarioInfo { AlmacenInventarioID = almacenInventarioBl.Crear(new AlmacenInventarioInfo { AlmacenID = almacenInfo.AlmacenID, ProductoID = parametro.ProductoId, UsuarioCreacionID = parametro.UsuarioId }), AlmacenID = almacenInfo.AlmacenID }; break; } } } } if (almacenInventario != null) { int loteIdCreado = almacenInventarioLoteBl.Crear(new AlmacenInventarioLoteInfo { AlmacenInventarioLoteId = 0, AlmacenInventario = new AlmacenInventarioInfo { AlmacenInventarioID = almacenInventario.AlmacenInventarioID }, Cantidad = 0, PrecioPromedio = 0, Piezas = 0, Importe = 0, Activo = (EstatusEnum)parametro.Activo, UsuarioCreacionId = parametro.UsuarioId, }, new AlmacenInventarioInfo { AlmacenID = almacenInventario.AlmacenID, ProductoID = parametro.ProductoId }); almacenInventarioLote = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(loteIdCreado); } return(almacenInventarioLote); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }