/// <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);
            }
        }
Exemplo n.º 2
0
        /// <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);
        }
Exemplo n.º 3
0
        /// <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);
        }
Exemplo n.º 4
0
        /// <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);
        }
Exemplo n.º 5
0
        /// <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);
        }
Exemplo n.º 6
0
        /// <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);
        }
Exemplo n.º 7
0
        /// <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);
            }
        }
Exemplo n.º 9
0
        /// <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);
            }
        }
Exemplo n.º 10
0
        /// <summary>
        /// Se actualiza en AlmacenMovimiento
        /// </summary>
        /// <param name="almacenMovimientoInfo"></param>
        public void ActualizarAlmacenMovimiento(AlmacenMovimientoInfo almacenMovimientoInfo)
        {
            var almacenBL = new AlmacenBL();

            almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
        }
Exemplo n.º 11
0
        /// <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);
            }
        }
Exemplo n.º 12
0
        /// <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);
        }
Exemplo n.º 13
0
        /// <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);
        }
Exemplo n.º 14
0
        /// <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);
        }
Exemplo n.º 15
0
        /// <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;
                }
            }
        }
Exemplo n.º 17
0
        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);
        }