/// <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> /// Establece los datos y el detalle del pedido /// </summary> /// <param name="pedido"></param> private void EstableceDetallePedido(PedidoInfo pedido) { var pedidoDetalleDl = new PedidoDetalleBL(); var organizacionBl = new OrganizacionBL(); var almacenBl = new AlmacenBL(); var usuarioBl = new UsuarioBL(); var almacen = pedido.Almacen; var organizacion = pedido.Organizacion; var usuarioCreacion = pedido.UsuarioCreacion; var usuarioModificacion = pedido.UsuarioModificacion; if (almacen != null && almacen.AlmacenID > 0) { pedido.Almacen = almacenBl.ObtenerPorID(almacen.AlmacenID); } if (organizacion != null && organizacion.OrganizacionID > 0) { pedido.Organizacion = organizacionBl.ObtenerPorID(organizacion.OrganizacionID); } if (usuarioCreacion != null && usuarioCreacion.UsuarioID > 0) { pedido.UsuarioCreacion = usuarioBl.ObtenerPorID(usuarioCreacion.UsuarioID); } if (usuarioModificacion != null && usuarioModificacion.UsuarioID > 0) { pedido.UsuarioModificacion = usuarioBl.ObtenerPorID(usuarioModificacion.UsuarioID); } pedido.DetallePedido = pedidoDetalleDl.ObtenerDetallePedido(pedido); }
/// <summary> /// Se valida la existencia de los productos en el inventario /// </summary> /// <param name="tratamientos"></param> /// <param name="almacenID"></param> /// <returns></returns> internal ResultadoValidacion ComprobarExistenciaTratamientos(IList <TratamientoInfo> tratamientos, int almacenID) { var resultado = new ResultadoValidacion { Resultado = true, Mensaje = "OK", TipoResultadoValidacion = TipoResultadoValidacion.Default }; //Se obtiene la lista de tratamientos seleccionados IList <TratamientoInfo> listaTratamientosSeleccionados = tratamientos.Where(item => item.Seleccionado && item.Habilitado).ToList(); var almacenInventario = new AlmacenBL(); if (listaTratamientosSeleccionados.Count > 0) { foreach (var item in listaTratamientosSeleccionados) { if (item.Productos == null) { item.Productos = ObtenerProductosDelTratamiento(item); } foreach (var itemProducto in item.Productos) { //Se obtiene la cantida de inventario del producto en el almacen var productoAlmacen = almacenInventario.ObtenerCantidadProductoEnInventario( itemProducto, almacenID); if (productoAlmacen == null) { //No existe inventario del producto resultado.Resultado = false; resultado.TipoResultadoValidacion = TipoResultadoValidacion.ProductoInexistente; resultado.Mensaje = itemProducto.ProductoDescripcion.Trim(); return(resultado); } if (!(productoAlmacen.Cantidad < itemProducto.Dosis)) { continue; } //No existe suficiente inventario del producto resultado.Resultado = false; resultado.TipoResultadoValidacion = TipoResultadoValidacion.InventarioInsuficiente; resultado.Mensaje = itemProducto.ProductoDescripcion.Trim(); return(resultado); } } } else { //No han seleccionado tratamientos resultado.Resultado = false; resultado.TipoResultadoValidacion = TipoResultadoValidacion.TratamientosNoSeleccionados; return(resultado); } return(resultado); }
/// <summary> /// Se eliminan los registros no seleccionados en AlmacenMovimientoDetalle /// </summary> /// <param name="articulo"></param> /// <param name="almacenMovimientoInfo"></param> public void EliminarAlmacenMovimientoDetalle(AjusteDeInventarioDiferenciasInventarioInfo articulo, AlmacenMovimientoInfo almacenMovimientoInfo) { var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoDetalleID = articulo.AlmacenMovimientoDetalleID }; var almacenBL = new AlmacenBL(); almacenBL.EliminaAlmacenMovimientoDetalle(almacenMovimientoDetalleInfo); }
/// <summary> /// Se actualizan los registros seleccionados en AlmacenInventario /// </summary> /// <param name="articulo"></param> /// <param name="almacenMovimientoInfo"></param> public void ActualizarArticulosDiferencias(AjusteDeInventarioDiferenciasInventarioInfo articulo, AlmacenMovimientoInfo almacenMovimientoInfo) { var cantidad = articulo.CantidadInventarioTeorico + articulo.Cantidad; var almacenInventarioInfo = new AlmacenInventarioInfo { Cantidad = cantidad, Importe = cantidad * articulo.PrecioInventarioTeorico, UsuarioModificacionID = almacenMovimientoInfo.UsuarioModificacionID, AlmacenInventarioID = articulo.AlmacenInventarioID }; var almacenBL = new AlmacenBL(); almacenBL.ActualizarAlmacenInventario(almacenInventarioInfo); }
/// <summary> /// Obtiene el almacen en base al id /// </summary> /// <param name="almacenInventarioId"></param> /// <returns></returns> internal AlmacenInventarioInfo ObtenerAlmacenInventarioPorId(int almacenInventarioId) { AlmacenInventarioInfo almacen = null; try { var almacenDAL = new AlmacenInventarioDAL(); var almacenBl = new AlmacenBL(); almacen = almacenDAL.ObtenerAlmacenInventarioPorId(almacenInventarioId); if (almacen != null) { almacen.Almacen = almacenBl.ObtenerPorID(almacen.AlmacenID); } } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(almacen); }
/// <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); } }
/// <summary> /// guardar corte por transferencia /// </summary> /// <param name="guardarAnimalCorte"></param> /// <param name="listaTratamientos"></param> /// <returns></returns> internal CorteTransferenciaGanadoGuardarInfo GuardarCorteTransferencia(CorteTransferenciaGanadoGuardarInfo guardarAnimalCorte, IList <TratamientoInfo> listaTratamientos) { try { using (var transaction = new TransactionScope()) { Logger.Info(); //var corteTransferenciaGanado = new CorteTransferenciaGanadoDAL(); var animalBl = new AnimalBL(); var animalMovimientoBL = new AnimalMovimientoBL(); var corralBl = new CorralBL(); var interfaceSalidaAnimalBl = new InterfaceSalidaAnimalBL(); var interfaceSalidoAnimalInfo = interfaceSalidaAnimalBl.ObtenerNumeroAreteIndividual( guardarAnimalCorte.AnimalCorteTransferenciaInfo.Arete, guardarAnimalCorte.OrganizacionId); if (guardarAnimalCorte.AnimalActualInfo != null) { guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra = guardarAnimalCorte.AnimalActualInfo.FechaCompra; } else { if (interfaceSalidoAnimalInfo != null) { guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra = interfaceSalidoAnimalInfo.FechaCompra; } } var resultoAnimalInfo = animalBl.GuardarAnimal(guardarAnimalCorte.AnimalCorteTransferenciaInfo); guardarAnimalCorte.AnimalCorteTransferenciaInfo = resultoAnimalInfo; guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalID = guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID; var loteBl = new LoteBL(); var resultadoLote = -1; var resultadoLoteOrigen = loteBl.ObtenerPorID(guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID); var resultadoLoteBL = loteBl.ObtenerLotesActivos( guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.OrganizacionID, Convert.ToInt32(guardarAnimalCorte.CorralInfoGen.CorralID)); if (resultadoLoteBL == null) { //var corralInfo = new CorralInfo //{ // Codigo = guardarAnimalCorte.TxtCorralDestino, // TipoCorral = new TipoCorralInfo { TipoCorralID = (int)TipoCorral.Improductivos }, // Organizacion = new OrganizacionInfo { OrganizacionID = guardarAnimalCorte.OrganizacionId } //}; CorralInfo resultadoCorralPl = corralBl.ObtenerPorId(guardarAnimalCorte.CorralDestinoID); if (resultadoCorralPl != null) { var loteCrear = new LoteBL(); var tipoProcesoBl = new TipoProcesoBL(); var tipoProcesoResult = tipoProcesoBl.ObtenerPorOrganizacion(guardarAnimalCorte.OrganizacionId); var loteInfoLote = new LoteInfo { Activo = EstatusEnum.Activo, Cabezas = Convert.ToInt32(0), CabezasInicio = Convert.ToInt32(0), CorralID = resultadoCorralPl.CorralID, DisponibilidadManual = false, OrganizacionID = guardarAnimalCorte.AnimalMovimientoOrigenInfo.OrganizacionID, TipoCorralID = resultadoCorralPl.TipoCorral.TipoCorralID, TipoProcesoID = tipoProcesoResult, UsuarioCreacionID = resultadoCorralPl.UsuarioCreacionID, }; resultadoLote = loteCrear.GuardaLote(loteInfoLote); guardarAnimalCorte.LoteDestinoInfo = loteCrear.ObtenerPorID(resultadoLote); } } else { guardarAnimalCorte.LoteDestinoInfo = resultadoLoteBL; } //Se manda a guardar movimiento de salida de enfermeria //var animalSalidaInfo = new AnimalSalidaInfo(); //animalSalidaInfo = animalBl.ObtenerAnimalSalidaAnimalID(guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID); //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID = animalSalidaInfo.CorralId; //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = animalSalidaInfo.LoteId; //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID = (int)TipoMovimiento.SalidaEnfermeria; //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo = animalMovimientoBL.GuardarAnimalMovimiento(guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo); //Se manda a guardar movimiento de corte por transferencia guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID = guardarAnimalCorte.CorralInfoGen.CorralID; guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = resultadoLoteBL != null ? resultadoLoteBL.LoteID : resultadoLote; guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID = (int)TipoMovimiento.CortePorTransferencia; guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo = animalMovimientoBL.GuardarAnimalMovimiento( guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo); if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null && guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalMovimientoID > 0) { if (resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null) { guardarAnimalCorte.CorralGlobal = guardarAnimalCorte.AnimalMovimientoOrigenInfo.CorralID; guardarAnimalCorte.LoteDestinoInfo.Cabezas = guardarAnimalCorte.LoteDestinoInfo.Cabezas + 1; guardarAnimalCorte.LoteDestinoInfo.CabezasInicio = guardarAnimalCorte.LoteDestinoInfo.CabezasInicio + 1; resultadoLoteOrigen.Cabezas = resultadoLoteOrigen.Cabezas - 1; var filtroActualizaCabezas = new FiltroActualizarCabezasLote { LoteIDOrigen = resultadoLoteOrigen.LoteID, LoteIDDestino = guardarAnimalCorte.LoteDestinoInfo.LoteID, CabezasProcesadas = 1, UsuarioModificacionID = guardarAnimalCorte.UsuarioCreacionID }; var cabezas = loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas); //TODO nuevo metodo //loteBl.ActualizaNoCabezasEnLote(guardarAnimalCorte.LoteDestinoInfo, resultadoLoteOrigen); loteBl.ActualizarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo); loteBl.ActualizarFechaSalidaEnLote(resultadoLoteOrigen); //if (resultadoLoteOrigen.Cabezas == 0) //{ // resultadoLoteOrigen.Activo = (int)EstatusEnum.Inactivo; // loteBl.ActualizaActivoEnLote(resultadoLoteOrigen); //} // ObtenerTotalCabezas(loteCorralOrigen); } if (ObtenerTotalCabezas(guardarAnimalCorte.AnimalMovimientoOrigenInfo)) { corralBl.TraspasarAnimalSalidaEnfermeria( guardarAnimalCorte.AnimalSalidaGuardarInfo.CorraletaId, guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID); //loteDAL.EliminarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo); } } if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null) { var almacenMovimientoInfo = new AlmacenMovimientoInfo { AlmacenID = guardarAnimalCorte.AlmacenID, AnimalMovimientoID = guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo .AnimalMovimientoID, TipoMovimientoID = (int)TipoMovimiento.SalidaPorConsumo, Status = (int)EstatusInventario.Aplicado, Observaciones = "", UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID, AnimalID = guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo .AnimalID, //Verificar CostoID = (int)Costo.MedicamentoDeImplante, }; var almacenBL = new AlmacenBL(); almacenBL.GuardarDescontarTratamientos( listaTratamientos.Where(item => item.Seleccionado && item.Habilitado).ToList(), almacenMovimientoInfo); } var loteProyeccionBL = new LoteProyeccionBL(); LoteProyeccionInfo proyeccionDestino = loteProyeccionBL.ObtenerPorLote(guardarAnimalCorte.LoteDestinoInfo); //guardarAnimalCorte.LoteDestinoInfo.LoteID if (proyeccionDestino == null) { LoteProyeccionInfo proyeccionOrigen = loteProyeccionBL.ObtenerPorLote(resultadoLoteOrigen); if (proyeccionOrigen != null && resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null) { proyeccionOrigen.LoteProyeccionID = 0; int diasEngordaOrigen = proyeccionOrigen.DiasEngorda; DateTime fechaInicioLote = resultadoLoteOrigen.FechaInicio; int diasEngordaReales = new TimeSpan(DateTime.Now.Ticks - fechaInicioLote.Ticks).Days; if ((diasEngordaOrigen - diasEngordaReales) <= 0) { proyeccionOrigen.DiasEngorda = 0; } else { proyeccionOrigen.DiasEngorda = diasEngordaOrigen - diasEngordaReales; } proyeccionOrigen.LoteID = guardarAnimalCorte.LoteDestinoInfo.LoteID; proyeccionOrigen.UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID; loteProyeccionBL.Guardar(proyeccionOrigen); var loteDAL = new LoteDAL(); var filtroDisponibilidad = new FiltroDisponilidadInfo { UsuarioId = guardarAnimalCorte.UsuarioCreacionID, ListaLoteDisponibilidad = new List <DisponibilidadLoteInfo> { new DisponibilidadLoteInfo { LoteId = guardarAnimalCorte.LoteDestinoInfo.LoteID, FechaDisponibilidad = resultadoLoteOrigen.FechaDisponibilidad, DisponibilidadManual = resultadoLoteOrigen.DisponibilidadManual } } }; loteDAL.ActualizarLoteDisponibilidad(filtroDisponibilidad); } } transaction.Complete(); return(guardarAnimalCorte); } } catch (ExcepcionGenerica) { return(null); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <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); } }
/// <summary> /// Se actualiza en AlmacenMovimiento /// </summary> /// <param name="almacenMovimientoInfo"></param> public void ActualizarAlmacenMovimiento(AlmacenMovimientoInfo almacenMovimientoInfo) { var almacenBL = new AlmacenBL(); almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo); }
/// <summary> /// Metodo para actualizar los ajustes de inventario contenidos en el grid /// </summary> /// <param name="articulosDiferenciasInventario"></param> /// <param name="almacenMovimientoInfo"></param> /// <returns></returns> public IList <ResultadoPolizaModel> GuardarAjusteDeInventario(List <AjusteDeInventarioDiferenciasInventarioInfo> articulosDiferenciasInventario, AlmacenMovimientoInfo almacenMovimientoInfo) { try { var resultadosPolizaModel = new List <ResultadoPolizaModel>(); PolizaAbstract poliza = null; var cierreDiaInventarioDAL = new CierreDiaInventarioDAL(); var almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL(); var articulosEntrada = new List <AjusteDeInventarioDiferenciasInventarioInfo>(); var articulosSalida = new List <AjusteDeInventarioDiferenciasInventarioInfo>(); using (var transaction = new TransactionScope()) { Logger.Info(); if (articulosDiferenciasInventario != null) { var seleccionados = articulosDiferenciasInventario.Any(articulosComprobar => articulosComprobar.Seleccionado); if (seleccionados) { foreach (var articulos in articulosDiferenciasInventario.Where(art => art.Seleccionado)) { ActualizarArticulosDiferencias(articulos, almacenMovimientoInfo); } almacenMovimientoInfo.Status = (int)EstatusInventario.Aplicado; var almacenBL = new AlmacenBL(); almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo); articulosEntrada = articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad > 0)). ToList(); articulosSalida = articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad < 0)). ToList(); //Generar los Movimientos de Entrada y Salida #region Movimientos Entrada if (articulosEntrada.Any()) { var movimientoEntrada = new AlmacenCierreDiaInventarioInfo { Almacen = almacenMovimientoInfo.Almacen, TipoMovimiento = TipoMovimiento.EntradaPorAjuste.GetHashCode(), Observaciones = almacenMovimientoInfo.Observaciones, Estatus = EstatusInventario.Autorizado.GetHashCode(), UsuarioCreacionId = almacenMovimientoInfo.UsuarioModificacionID }; var movimientosEntrada = (from detalle in articulosEntrada select new AlmacenMovimientoDetalle { ProductoID = detalle.ProductoID, Precio = detalle.Precio, Cantidad = Math.Abs(detalle.Cantidad), Importe = Math.Round( Convert.ToDecimal( Math.Abs(detalle.Cantidad)) * detalle.Precio, 2), UsuarioCreacionID = almacenMovimientoInfo.UsuarioModificacionID }).ToList(); AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento = cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoEntrada); almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosEntrada, resultadoAlmacenMovimiento. AlmacenMovimientoID); } #endregion Movimientos Entrada #region Movimientos Salida if (articulosSalida.Any()) { var movimientoSalida = new AlmacenCierreDiaInventarioInfo { Almacen = almacenMovimientoInfo.Almacen, TipoMovimiento = TipoMovimiento.SalidaPorAjuste.GetHashCode(), Observaciones = almacenMovimientoInfo.Observaciones, Estatus = EstatusInventario.Autorizado.GetHashCode(), UsuarioCreacionId = almacenMovimientoInfo.UsuarioModificacionID }; var movimientosSalida = (from detalle in articulosSalida select new AlmacenMovimientoDetalle { ProductoID = detalle.ProductoID, Precio = detalle.Precio, Cantidad = Math.Abs(detalle.Cantidad), Importe = Math.Round( Convert.ToDecimal( Math.Abs(detalle.Cantidad)) * detalle.Precio, 2), UsuarioCreacionID = almacenMovimientoInfo.UsuarioModificacionID }).ToList(); AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento = cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoSalida); almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosSalida, resultadoAlmacenMovimiento. AlmacenMovimientoID); } #endregion Movimientos Entrada } else { almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado; var almacenBL = new AlmacenBL(); almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo); } #region POLIZA #region PolizaSalida MemoryStream stream; if (articulosSalida.Any()) { poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaAjuste); List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste = articulosSalida.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel { Importe = Math.Abs(ajuste.Importe), Cantidad = Math.Abs(ajuste.Cantidad), TipoAjuste = TipoAjusteEnum.Merma, Precio = ajuste.Precio, AlmacenInventarioID = ajuste.AlmacenInventarioID, AlmacenMovimientoDetalleID = ajuste.AlmacenMovimientoDetalleID, ProductoID = ajuste.ProductoID, CantidadInventarioFisico = ajuste.CantidadInventarioFisico, CantidadInventarioTeorico = ajuste.CantidadInventarioTeorico, Observaciones = almacenMovimientoInfo.Observaciones }).ToList(); if (salidasPorAjuste.Any()) { IList <PolizaInfo> polizasSalida = poliza.GeneraPoliza(salidasPorAjuste); if (polizasSalida != null) { stream = poliza.ImprimePoliza(salidasPorAjuste, polizasSalida); var polizaBL = new PolizaBL(); polizasSalida.ToList().ForEach(datos => { datos.UsuarioCreacionID = almacenMovimientoInfo. UsuarioModificacionID; datos.OrganizacionID = almacenMovimientoInfo.OrganizacionID; datos.ArchivoEnviadoServidor = 1; }); polizaBL.GuardarServicioPI(polizasSalida, TipoPoliza.SalidaAjuste); var resultadoPolizaModel = new ResultadoPolizaModel { Polizas = polizasSalida, PDFs = new Dictionary <TipoPoliza, MemoryStream> { { TipoPoliza.SalidaAjuste, stream } } }; resultadosPolizaModel.Add(resultadoPolizaModel); } } } #endregion PolizaSalida #region PolizaEntrada if (articulosEntrada.Any()) { poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaAjuste); List <PolizaEntradaSalidaPorAjusteModel> entradasPorAjuste = articulosEntrada.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel { Importe = Math.Abs(ajuste.Importe), Cantidad = Math.Abs(ajuste.Cantidad), TipoAjuste = TipoAjusteEnum.Merma, Precio = ajuste.Precio, AlmacenInventarioID = ajuste.AlmacenInventarioID, AlmacenMovimientoDetalleID = ajuste.AlmacenMovimientoDetalleID, ProductoID = ajuste.ProductoID, CantidadInventarioFisico = ajuste.CantidadInventarioFisico, CantidadInventarioTeorico = ajuste.CantidadInventarioTeorico, Observaciones = almacenMovimientoInfo.Observaciones }).ToList(); if (entradasPorAjuste.Any()) { IList <PolizaInfo> polizasEntrada = poliza.GeneraPoliza(entradasPorAjuste); if (polizasEntrada != null) { stream = poliza.ImprimePoliza(entradasPorAjuste, polizasEntrada); var polizaBL = new PolizaBL(); polizasEntrada.ToList().ForEach(datos => { datos.UsuarioCreacionID = almacenMovimientoInfo. UsuarioModificacionID; datos.OrganizacionID = almacenMovimientoInfo.OrganizacionID; datos.ArchivoEnviadoServidor = 1; }); polizaBL.GuardarServicioPI(polizasEntrada, TipoPoliza.EntradaAjuste); var resultadoPolizaModel = new ResultadoPolizaModel { Polizas = polizasEntrada, PDFs = new Dictionary <TipoPoliza, MemoryStream> { { TipoPoliza.EntradaAjuste, stream } } }; resultadosPolizaModel.Add(resultadoPolizaModel); } } } #endregion PolizaEntrada #endregion POLIZA } else { almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado; var almacenBL = new AlmacenBL(); almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo); } transaction.Complete(); } return(resultadosPolizaModel); } catch (ExcepcionServicio ex) { Logger.Error(ex); throw; } catch (ExcepcionGenerica ex) { Logger.Error(ex); throw; } catch (Exception ex) { Logger.Error(ex); return(null); } }
/// <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> /// 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> /// 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> /// Guardar entrada enfermeria /// </summary> internal EntradaGanadoEnfermeriaInfo GuardarEntradaEnfermeria(EntradaGanadoEnfermeriaInfo entradaGanadoEnfermeria) { entradaGanadoEnfermeria.Resultado = false; try { var resultadoCabezas = new CabezasActualizadasInfo(); var transactionOption = new TransactionOptions(); transactionOption.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted; using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption)) { var animalDal = new AnimalDAL(); var animalMovimientoBL = new AnimalMovimientoBL(); var corralBL = new CorralBL(); var loteBL = new LoteBL(); bool actualizaAreteDeteccion = entradaGanadoEnfermeria.Deteccion.ActualizarAreteDeteccion; bool animalRecaido = entradaGanadoEnfermeria.AnimalRecaido; if (entradaGanadoEnfermeria.CambiarTipoGanado && entradaGanadoEnfermeria.Deteccion.Animal.AnimalID > 0 && entradaGanadoEnfermeria.Deteccion.Animal.TipoGanadoID != entradaGanadoEnfermeria.Animal.TipoGanadoID) { entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID; entradaGanadoEnfermeria.Animal.UsuarioModificacionID = entradaGanadoEnfermeria.UsuarioId; } if (entradaGanadoEnfermeria.Animal.AnimalID == 0) { entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID; entradaGanadoEnfermeria.Animal.AplicaBitacora = entradaGanadoEnfermeria.Deteccion.Animal.AplicaBitacora; } AnimalInfo animalInfo = animalDal.GuardarAnimal(entradaGanadoEnfermeria.Animal); if (actualizaAreteDeteccion) { //Si el flag esta activo se actualiza el arete en la deteccion de ganado cuando solo traen fotos var deteccionBl = new DeteccionBL(); deteccionBl.ActualizarDeteccionConFoto(entradaGanadoEnfermeria.Deteccion); } /* Si esta activo el flag de recaido generar la deteccion */ if (animalRecaido) { entradaGanadoEnfermeria.Deteccion.DeteccionID = GenerarDeteccionAnimalGenerica(entradaGanadoEnfermeria); } if (animalInfo != null && animalInfo.AnimalID > 0) { entradaGanadoEnfermeria.Animal = animalInfo; entradaGanadoEnfermeria.Movimiento.AnimalID = animalInfo.AnimalID; if (entradaGanadoEnfermeria.LoteDestino.LoteID == 0) { entradaGanadoEnfermeria.LoteDestino.LoteID = loteBL.GuardaLote(entradaGanadoEnfermeria.LoteDestino); entradaGanadoEnfermeria.Movimiento.LoteID = entradaGanadoEnfermeria.LoteDestino.LoteID; } //Se almacena el movimiento AnimalMovimientoInfo animalMovimientoInfo = animalMovimientoBL.GuardarAnimalMovimiento(entradaGanadoEnfermeria.Movimiento); if (animalMovimientoInfo != null && animalMovimientoInfo.AnimalMovimientoID > 0) { if (entradaGanadoEnfermeria.Tratamientos.Any(registro => registro.Seleccionado)) { var almacenpl = new AlmacenBL(); entradaGanadoEnfermeria.AlmacenMovimiento.AnimalMovimientoID = animalMovimientoInfo.AnimalMovimientoID; entradaGanadoEnfermeria.AlmacenMovimiento.AnimalID = animalInfo.AnimalID; almacenpl.GuardarDescontarTratamientos(entradaGanadoEnfermeria.Tratamientos, entradaGanadoEnfermeria.AlmacenMovimiento); } entradaGanadoEnfermeria.Deteccion.AnimalMovimiento = animalMovimientoInfo; GurdarDeteccion(entradaGanadoEnfermeria.Deteccion, entradaGanadoEnfermeria.ListaProblemas); /* Se desactiva la deteccion */ var deteccion = new DeteccionInfo { DeteccionID = entradaGanadoEnfermeria.Deteccion.DeteccionID, UsuarioCreacionID = entradaGanadoEnfermeria.UsuarioId, Arete = entradaGanadoEnfermeria.Animal.Arete }; EliminarDeteccion(deteccion); #region LOTE //Se decrementan las cabezas del lote if (entradaGanadoEnfermeria.LoteDestino.LoteID != entradaGanadoEnfermeria.LoteOrigen.LoteID) { entradaGanadoEnfermeria.LoteDestino = loteBL.ObtenerPorID(entradaGanadoEnfermeria.LoteDestino.LoteID); var animalBL = new AnimalBL(); List <AnimalInfo> animalesDestino = animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID, entradaGanadoEnfermeria.LoteDestino.LoteID); if (animalesDestino != null && animalesDestino.Any()) { entradaGanadoEnfermeria.LoteDestino.Cabezas = animalesDestino.Count; } //Una vez insertado el lote y el animal se incrementan las cabezas de lote entradaGanadoEnfermeria.LoteDestino.Cabezas = entradaGanadoEnfermeria.LoteDestino.Cabezas + 1; if (entradaGanadoEnfermeria.LoteDestino.Cabezas > entradaGanadoEnfermeria.LoteDestino.CabezasInicio) { entradaGanadoEnfermeria.LoteDestino.CabezasInicio = entradaGanadoEnfermeria.LoteDestino.CabezasInicio + 1; } entradaGanadoEnfermeria.LoteDestino.UsuarioModificacionID = entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID; // ------ // entradaGanadoEnfermeria.LoteOrigen.Cabezas = entradaGanadoEnfermeria.LoteOrigen.Cabezas - 1; List <AnimalInfo> animales = animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID, entradaGanadoEnfermeria.LoteOrigen.LoteID); if (animales != null && animales.Any()) { entradaGanadoEnfermeria.LoteOrigen.Cabezas = animales.Count; } //Se actualizan las cabezas que tiene el lote var filtro = new FiltroActualizarCabezasLote { CabezasProcesadas = 1, LoteIDDestino = entradaGanadoEnfermeria.LoteDestino.LoteID, LoteIDOrigen = entradaGanadoEnfermeria.LoteOrigen.LoteID, UsuarioModificacionID = entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID }; resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro); } #endregion LOTE //Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada if (resultadoCabezas.CabezasOrigen <= 0) { //Se obtiene el Corral para ver Si es de Recepcion CorralInfo corralInfo = corralBL.ObtenerCorralPorCodigo(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID, entradaGanadoEnfermeria.LoteOrigen.Corral.Codigo); if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion) { /* Si el corral es de Recepcion */ var corteGanadoPl = new CorteGanadoBL(); corteGanadoPl.ObtenerPesosOrigenLlegada(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID, entradaGanadoEnfermeria.LoteOrigen.CorralID, entradaGanadoEnfermeria.LoteOrigen.LoteID); } } transaction.Complete(); entradaGanadoEnfermeria.Resultado = true; } } } } catch (ExcepcionGenerica ex) { Logger.Error(ex); entradaGanadoEnfermeria.Resultado = false; } catch (Exception ex) { Logger.Error(ex); entradaGanadoEnfermeria.Resultado = false; throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(entradaGanadoEnfermeria); }
/// <summary> /// Asigna los costos de los subproductos al costo /// ya generado /// </summary> /// <param name="lista"></param> /// <param name="productoId"></param> /// <param name="organizacionID"> </param> private void AsignarCostosSubProductos(List <ReporteInventarioMateriaPrimaInfo> lista, int productoId, int organizacionID) { var productoBL = new ProductoBL(); var producto = new ProductoInfo { ProductoId = productoId }; producto = productoBL.ObtenerPorID(producto); if (producto != null) { switch ((FamiliasEnum)producto.Familia.FamiliaID) { case FamiliasEnum.Premezclas: var organizacion = new OrganizacionInfo { OrganizacionID = organizacionID, Activo = EstatusEnum.Activo }; var almacenBL = new AlmacenBL(); var tiposAlmacen = new List <TipoAlmacenEnum> { TipoAlmacenEnum.MateriasPrimas }; List <AlmacenInfo> almacenes = almacenBL.ObtenerAlmacenPorTiposAlmacen(tiposAlmacen, organizacion); var almacenMovimientoBL = new AlmacenMovimientoBL(); IEnumerable <AlmacenMovimientoSubProductosModel> productosPremezcla = lista.Select(x => new AlmacenMovimientoSubProductosModel { FechaMovimiento = x.FechaMovimiento, ProductoID = productoId }); productosPremezcla = almacenMovimientoBL.ObtenerMovimientosSubProductos(productosPremezcla); if (productosPremezcla != null) { var premezclaDetalleBL = new PremezclaBL(); List <PremezclaInfo> premezclas = premezclaDetalleBL.ObtenerPorOrganizacionDetalle(organizacion); PremezclaInfo premezcla; List <ReporteInventarioMateriaPrimaInfo> entradasMateriaPrima = lista.Where(entrada => entrada.CostoId > 0).ToList(); if (entradasMateriaPrima != null) { ReporteInventarioMateriaPrimaInfo entradaMateriaPrima; for (var index = 0; index < entradasMateriaPrima.Count; index++) { premezcla = premezclas.FirstOrDefault( id => id.Producto.ProductoId == productoId); if (premezcla != null) { entradaMateriaPrima = entradasMateriaPrima[index]; int almacenID = productosPremezcla.Where( almMov => almMov.AlmacenMovimientoID == entradaMateriaPrima.AlmacenMovimientoID). Select(id => id.AlmacenID).FirstOrDefault(); if (almacenes.Any(id => id.AlmacenID == almacenID)) { AlmacenMovimientoSubProductosModel almacenMovimientoSubProductosModel = productosPremezcla.FirstOrDefault( prod => prod.ProductoID == premezcla.Producto.ProductoId && prod.FechaMovimiento.ToShortDateString().Equals( entradaMateriaPrima.FechaMovimiento.ToShortDateString())); if (almacenMovimientoSubProductosModel != null) { IEnumerable <AlmacenMovimientoSubProductosModel> subProductos = productosPremezcla .Join(premezcla.ListaPremezclaDetalleInfos, pp => pp.ProductoID, pd => pd.Producto.ProductoId, (pp, pd) => pp).Where( fechaInicio => fechaInicio.AlmacenMovimientoID == (almacenMovimientoSubProductosModel.AlmacenMovimientoID + 1) && fechaInicio.FechaMovimiento.ToShortDateString().Equals( entradaMateriaPrima.FechaMovimiento.ToShortDateString())); if (subProductos != null && subProductos.Any()) { entradaMateriaPrima.ImporteSubProductos = subProductos.Sum(imp => imp.Importe); } } } } } } } break; } } }
internal bool GuardarInventario(RecepcionProductoInfo recepcionProducto) { try { AlmacenBL almacenBl = new AlmacenBL(); AlmacenInventarioBL almacenInventarioBl = new AlmacenInventarioBL(); foreach (var recepcionProductodetalle in recepcionProducto.ListaRecepcionProductoDetalle) { AlmacenInfo almacen = almacenBl.ObtenerPorID(recepcionProducto.Almacen.AlmacenID); List <AlmacenInventarioInfo> listaAlmacenlmacenInventario = almacenInventarioBl.ObtienePorAlmacenId(almacen); if (listaAlmacenlmacenInventario != null) { List <AlmacenInventarioInfo> almacenInventarioListaResultado = listaAlmacenlmacenInventario.Where( registro => registro.ProductoID == recepcionProductodetalle.Producto.ProductoId) .ToList(); if (almacenInventarioListaResultado.Count > 0) { var almacenInventario = almacenInventarioListaResultado[0]; almacenInventario.Cantidad = almacenInventario.Cantidad + recepcionProductodetalle.Cantidad; almacenInventario.Importe = almacenInventario.Importe + recepcionProductodetalle.Importe; almacenInventario.PrecioPromedio = almacenInventario.Importe / almacenInventario.Cantidad; almacenInventario.UsuarioModificacionID = recepcionProducto.UsuarioCreacion.UsuarioID; almacenInventarioBl.Actualizar(almacenInventario); } else { var almacenInventarioNuevo = new AlmacenInventarioInfo(); almacenInventarioNuevo.Almacen = recepcionProducto.Almacen; almacenInventarioNuevo.AlmacenID = recepcionProducto.Almacen.AlmacenID; almacenInventarioNuevo.Producto = recepcionProductodetalle.Producto; almacenInventarioNuevo.ProductoID = recepcionProductodetalle.Producto.ProductoId; almacenInventarioNuevo.Cantidad = recepcionProductodetalle.Cantidad; almacenInventarioNuevo.Importe = recepcionProductodetalle.Importe; almacenInventarioNuevo.PrecioPromedio = almacenInventarioNuevo.Importe / almacenInventarioNuevo.Cantidad; almacenInventarioNuevo.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID; almacenInventarioBl.Crear(almacenInventarioNuevo); } } else { var almacenInventarioNuevo = new AlmacenInventarioInfo(); almacenInventarioNuevo.Almacen = recepcionProducto.Almacen; almacenInventarioNuevo.AlmacenID = recepcionProducto.Almacen.AlmacenID; almacenInventarioNuevo.Producto = recepcionProductodetalle.Producto; almacenInventarioNuevo.ProductoID = recepcionProductodetalle.Producto.ProductoId; almacenInventarioNuevo.Cantidad = recepcionProductodetalle.Cantidad; almacenInventarioNuevo.Importe = recepcionProductodetalle.Importe; almacenInventarioNuevo.PrecioPromedio = almacenInventarioNuevo.Importe / almacenInventarioNuevo.Cantidad; almacenInventarioNuevo.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID; almacenInventarioBl.Crear(almacenInventarioNuevo); } } return(true); } catch (Exception ex) { Logger.Error(ex); } return(false); }