/// <summary> /// Obtiene el flujo de datos /// para la generacion de la reimpresion /// de la poliza de consumo de producto /// </summary> /// <param name="almacenInfo"></param> /// <param name="polizaClave"></param> /// <returns></returns> private MemoryStream ReimprimirPolizaConsumoProducto(AlmacenInfo almacenInfo, TipoPolizaInfo polizaClave) { MemoryStream pdf = null; //var polizaBL = new PolizaBL(); //IList<PolizaInfo> polizasConsumoProducto = polizaBL.ObtenerPoliza(TipoPoliza.ConsumoProducto, // almacenInfo.Organizacion.OrganizacionID, // DateTime.Today, // 1.ToString(), // polizaClave.ClavePoliza, 1); //if (polizasConsumoProducto != null && polizasConsumoProducto.Any()) //{ var almacenMovimientoInventarioBL = new AlmacenMovimientoBL(); List <ContenedorAlmacenMovimientoCierreDia> contenedorMovimientoCierreDia = almacenMovimientoInventarioBL.ObtenerMovimientosInventario(almacenInfo.AlmacenID, almacenInfo.Organizacion.OrganizacionID); if (contenedorMovimientoCierreDia != null && contenedorMovimientoCierreDia.Any()) { var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.ConsumoProducto); IList <PolizaInfo> polizaConsumo = poliza.GeneraPoliza(contenedorMovimientoCierreDia); if (polizaConsumo != null && polizaConsumo.Any()) { //poliza.GuardarArchivoXML(polizaConsumo, almacenInfo.Organizacion.OrganizacionID); //pdf = poliza.ImprimePoliza(contenedorMovimientoCierreDia, polizaConsumo); } } //} return(pdf); }
/// <summary> /// Obtiene un flujo de datos /// para la generacion de la reimpresion /// de la poliza de Salida de Traspaso /// </summary> /// <param name="produccionFormula"></param> /// <param name="polizaClave"></param> /// <returns></returns> private MemoryStream ReimpresionPolizaProduccionAlimento(ProduccionFormulaInfo produccionFormula, TipoPolizaInfo polizaClave) { var polizaBL = new PolizaBL(); IList <PolizaInfo> polizasProduccionAlimento = polizaBL.ObtenerPoliza(TipoPoliza.ProduccionAlimento, produccionFormula.Organizacion.OrganizacionID, produccionFormula.FechaProduccion, produccionFormula.FolioFormula.ToString(CultureInfo.InvariantCulture), polizaClave.ClavePoliza, 1); MemoryStream stream = null; if (polizasProduccionAlimento != null) { var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.ProduccionAlimento); var produccionFormulaBL = new ProduccionFormulaBL(); using (var almacenDAL = new AlmacenDAL()) { var almacenMovimientoBL = new AlmacenMovimientoBL(); ProduccionFormulaInfo produccion = produccionFormulaBL.ObtenerPorIDCompleto(produccionFormula.ProduccionFormulaId); if (produccion != null) { AlmacenInfo almacenPlantaAlimento = almacenDAL.ObtenerAlmacenOrganizacionTipo(produccionFormula.Organizacion.OrganizacionID, TipoAlmacenEnum.PlantaDeAlimentos); AlmacenMovimientoInfo almacenMovimiento = almacenMovimientoBL.ObtenerPorIDCompleto(produccion.AlmacenMovimientoSalidaID); var produccionFormulaDetalles = new List <ProduccionFormulaDetalleInfo>(); if (almacenMovimiento != null) { foreach (var detalle in produccion.ProduccionFormulaDetalle) { var movimiento = almacenMovimiento.ListaAlmacenMovimientoDetalle.FirstOrDefault( alm => alm.Producto.ProductoId == detalle.Producto.ProductoId && alm.AlmacenInventarioLoteId == detalle.AlmacenInventarioLoteID); if (movimiento == null) { continue; } detalle.CantidadProducto = movimiento.Cantidad; detalle.PrecioPromedio = movimiento.Precio; produccionFormulaDetalles.Add(detalle); } } if (almacenPlantaAlimento == null) { return(null); } produccion.ProduccionFormulaDetalle = produccionFormulaDetalles; produccion.Almacen = almacenPlantaAlimento; polizasProduccionAlimento = poliza.GeneraPoliza(produccion); stream = poliza.ImprimePoliza(produccion, polizasProduccionAlimento); } } } return(stream); }
/// <summary> /// Obtiene un flujo de datos /// para la generacion de la reimpresion /// de la poliza de Salida de Traspaso /// </summary> /// <param name="folioSolicitud"></param> /// <param name="polizaClave"></param> /// <returns></returns> private MemoryStream ReimpresionPolizaSalidaConsumo(FolioSolicitudInfo folioSolicitud, TipoPolizaInfo polizaClave) { var polizaBL = new PolizaBL(); IList <PolizaInfo> polizasSalidaConsumo = polizaBL.ObtenerPoliza(TipoPoliza.SalidaConsumo, folioSolicitud.OrganizacionID, folioSolicitud.FechaEntrega.HasValue ? folioSolicitud.FechaEntrega.Value : DateTime.MinValue, folioSolicitud.FolioSolicitud.ToString(CultureInfo.InvariantCulture), polizaClave.ClavePoliza, 1); MemoryStream stream = null; if (polizasSalidaConsumo != null) { var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaConsumo); var solicitudProductoDAL = new SolicitudProductoDAL(); using (var almacenDAL = new AlmacenDAL()) { var almacenMovimientoBL = new AlmacenMovimientoBL(); SolicitudProductoInfo solicitud = solicitudProductoDAL.ObtenerPorID(folioSolicitud.FolioID); if (solicitud != null) { AlmacenInfo almacenGeneral = almacenDAL.ObtenerAlmacenGeneralOrganizacion(folioSolicitud.OrganizacionID); AlmacenMovimientoInfo almacenMovimiento = almacenMovimientoBL.ObtenerPorIDCompleto(solicitud.AlmacenMovimientoID.HasValue ? solicitud.AlmacenMovimientoID.Value : 0); if (almacenMovimiento != null) { foreach (var detalle in solicitud.Detalle) { var movimiento = almacenMovimiento.ListaAlmacenMovimientoDetalle.FirstOrDefault( alm => alm.Producto.ProductoId == detalle.Producto.ProductoId); if (movimiento == null) { continue; } detalle.PrecioPromedio = movimiento.Precio; } } if (almacenGeneral == null) { return(null); } solicitud.AlmacenGeneralID = almacenGeneral.AlmacenID; polizasSalidaConsumo = poliza.GeneraPoliza(solicitud); stream = poliza.ImprimePoliza(solicitud, polizasSalidaConsumo); } } } return(stream); }
private long GuardarMovimientos(RecepcionProductoInfo recepcionProducto) { long almacenMovimientoId = 0; try { var almacenMovimientoBl = new AlmacenMovimientoBL(); AlmacenMovimientoInfo almacenMovimiento = new AlmacenMovimientoInfo(); almacenMovimiento.AlmacenID = recepcionProducto.Almacen.AlmacenID; almacenMovimiento.TipoMovimientoID = (int)TipoMovimiento.RecepcionProducto; almacenMovimiento.Observaciones = recepcionProducto.Observaciones; almacenMovimiento.Status = (int)EstatusInventario.Aplicado; almacenMovimiento.ProveedorId = recepcionProducto.Proveedor.ProveedorID; almacenMovimiento.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID; almacenMovimientoId = almacenMovimientoBl.Crear(almacenMovimiento); if (almacenMovimientoId > 0) { var almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL(); foreach (var recepcionProductoDetalle in recepcionProducto.ListaRecepcionProductoDetalle) { var almacenMovimientoDetalle = new AlmacenMovimientoDetalle(); almacenMovimientoDetalle.AlmacenMovimientoID = almacenMovimientoId; almacenMovimientoDetalle.ProductoID = recepcionProductoDetalle.Producto.ProductoId; almacenMovimientoDetalle.Importe = recepcionProductoDetalle.Importe; almacenMovimientoDetalle.Cantidad = recepcionProductoDetalle.Cantidad; almacenMovimientoDetalle.Precio = almacenMovimientoDetalle.Importe / almacenMovimientoDetalle.Cantidad; almacenMovimientoDetalle.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID; almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalle); } } } catch (Exception ex) { Logger.Error(ex); } return(almacenMovimientoId); }
/// <summary> /// Se guardan las respuesta a las solicitudes de materia prima /// </summary> /// <param name="respuestaSolicitudes"></param> /// <param name="organizacionID"></param> /// <param name="tipoAutorizacionID"></param> /// <param name="usuarioID"></param> /// <returns></returns> public ResultadoValidacion GuardarRespuestasSolicitudes(List <AutorizacionMovimientosInfo> respuestaSolicitudes, int organizacionID, int tipoAutorizacionID, int usuarioID) { var result = new ResultadoValidacion(); var mensaje = new StringBuilder(); try { Logger.Info(); var solicitudDAL = new SolicitudAutorizacionDAL(); var almacenMovimientoBl = new AlmacenMovimientoBL(); using (var transaction = new TransactionScope()) { List <DiferenciasDeInventariosInfo> listaMovimientosPendientes = solicitudDAL.ObtenerMovimientosAutorizacion(respuestaSolicitudes); if (listaMovimientosPendientes != null && listaMovimientosPendientes.Any()) { foreach (var movimiento in listaMovimientosPendientes) { if (movimiento.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.SalidaPorAjuste.GetHashCode()) { if (movimiento.AlmacenMovimientoDetalle.Cantidad > movimiento.AlmacenInventarioLote.Cantidad) { AutorizacionMovimientosInfo autorizacionCancelar = respuestaSolicitudes.FirstOrDefault( aut => aut.AlmacenMovimientoID == movimiento.AlmacenMovimiento.AlmacenMovimientoID); if (autorizacionCancelar != null) { autorizacionCancelar.EstatusID = Estatus.AMPRechaza.GetHashCode(); autorizacionCancelar.Observaciones = ResourceServices.SolicitudAutorizacionBL_RechazoAutomatico; mensaje.Append(string.Format(", {0}:{1}", movimiento.Producto.ProductoDescripcion, movimiento.AlmacenMovimientoDetalle.Cantidad)); } } } } } bool guardado = solicitudDAL.GuardarRespuestasSolicitudes(respuestaSolicitudes, organizacionID, tipoAutorizacionID, usuarioID); if (guardado && tipoAutorizacionID == (int)TipoAutorizacionEnum.AjustedeInventario) { for (int i = 0; i < respuestaSolicitudes.Count; i++) { if (respuestaSolicitudes[i].EstatusID == (int)Estatus.AMPAutoriz) { respuestaSolicitudes[i].EstatusInventarioID = (int)Estatus.DifInvAutorizado; } else { respuestaSolicitudes[i].EstatusInventarioID = (int)Estatus.DifInvRechazado; } } // Se realiza el proceso de afectar el inventario para los movimientos autorizados List <DiferenciasDeInventariosInfo> listaAjustesPendientes; var diferenciasDeInventarioBl = new DiferenciasDeInventarioBL(); listaAjustesPendientes = solicitudDAL.GuardarAjusteInventario(respuestaSolicitudes, organizacionID); if (listaAjustesPendientes != null) { foreach (var diferenciasDeInventariosInfoPar in listaAjustesPendientes) { diferenciasDeInventariosInfoPar.DescripcionAjuste = diferenciasDeInventariosInfoPar.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.SalidaPorAjuste.GetHashCode() ? TipoAjusteEnum.Merma.ToString() : TipoAjusteEnum.Superávit.ToString(); diferenciasDeInventariosInfoPar.DiferenciaInventario = diferenciasDeInventariosInfoPar.AlmacenMovimientoDetalle.Cantidad; diferenciasDeInventariosInfoPar.AlmacenMovimiento.UsuarioModificacionID = usuarioID; diferenciasDeInventariosInfoPar.AlmacenMovimientoDetalle.UsuarioModificacionID = usuarioID; diferenciasDeInventariosInfoPar.AlmacenInventarioLote.UsuarioModificacionId = usuarioID; diferenciasDeInventariosInfoPar.AlmacenMovimiento.Status = Estatus.DifInvAplicado.GetHashCode(); diferenciasDeInventariosInfoPar.TieneConfiguracion = true; //Se cambia el status por aplicado almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfoPar.AlmacenMovimiento); //Actualiza inventario y lote diferenciasDeInventarioBl.ActualizarInventarioYLote(diferenciasDeInventariosInfoPar, usuarioID); } #region POLIZA List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste = listaAjustesPendientes.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()) { var 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; } var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza); var grupo = new List <PolizaEntradaSalidaPorAjusteModel> { agrupado[indexAjustes] }; var 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) { result.Mensaje = ex.Message; result.Resultado = false; result.CodigoMensaje = 2; return(result); } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } if (mensaje.Length == 0) { result.Resultado = true; } else { result.Mensaje = String.Format(ResourceServices.SolicitudAutorizacionBL_AutorizacionRechazadas, mensaje); result.Resultado = false; result.CodigoMensaje = 1; } return(result); }
/// <summary> /// guardar cierre dia inventario /// </summary> /// <param name="datosGrid"></param> /// <param name="almacenCierreDiaInventario"></param> /// <returns></returns> public int GuardarCierreDiaInventario(IList <AlmacenCierreDiaInventarioInfo> datosGrid, AlmacenCierreDiaInventarioInfo almacenCierreDiaInventario) { try { int result = 0; int usuarioCreacionID = almacenCierreDiaInventario.UsuarioCreacionId; var almacenCierreFolio = new AlmacenCierreDiaInventarioInfo { Almacen = almacenCierreDiaInventario.Almacen, TipoMovimiento = TipoMovimiento.InventarioFisico.GetHashCode(), FolioAlmacen = almacenCierreDiaInventario.FolioAlmacen, Observaciones = almacenCierreDiaInventario.Observaciones, Estatus = EstatusInventario.Pendiente.GetHashCode(), UsuarioCreacionId = usuarioCreacionID, }; int organizacionID = almacenCierreDiaInventario.OrganizacionId; List <AnimalMovimientoInfo> animalesNoReimplantados = null; List <ProgramacionReinplanteInfo> corralesProgramados = null; List <LoteInfo> lotesDestino = null; List <LoteInfo> lotesOrigen = null; var animalMovimientoBL = new AnimalMovimientoBL(); var loteBL = new LoteBL(); if (almacenCierreFolio.Almacen != null && almacenCierreFolio.Almacen.TipoAlmacen.TipoAlmacenID == TipoAlmacenEnum.ReimplanteGanado.GetHashCode()) { var reimplanteBL = new ReimplanteBL(); corralesProgramados = reimplanteBL.ObtenerCorralesParaAjuste(organizacionID); if (corralesProgramados != null && corralesProgramados.Any()) { corralesProgramados.ForEach(dato => { dato.OrganizacionID = organizacionID; dato.UsuarioModificacionID = usuarioCreacionID; }); List <LoteInfo> lotes = corralesProgramados.Select(id => new LoteInfo { LoteID = id.LoteID }).ToList(); animalesNoReimplantados = animalMovimientoBL.ObtenerAnimalesNoReimplantadosXML(organizacionID, lotes); if (animalesNoReimplantados != null && animalesNoReimplantados.Any()) { animalesNoReimplantados.ForEach(dato => { dato.TipoMovimientoID = TipoMovimiento.EntradaPorAjusteAnimal.GetHashCode(); dato.UsuarioCreacionID = usuarioCreacionID; }); lotesDestino = animalesNoReimplantados.Select(lote => new LoteInfo { LoteID = lote.LoteID }).ToList(); lotesOrigen = animalesNoReimplantados.Select(lote => new LoteInfo { LoteID = lote.LoteIDOrigen }).ToList(); IEnumerable <LoteInfo> lotesEnumerable = loteBL.ObtenerPorLoteXML(lotesDestino); if (lotesEnumerable != null) { lotesDestino = lotesEnumerable.ToList(); } lotesEnumerable = loteBL.ObtenerPorLoteXML(lotesOrigen); if (lotesEnumerable != null) { lotesOrigen = lotesEnumerable.ToList(); } List <AnimalMovimientoInfo> animalesPorLoteDestino = animalesNoReimplantados .Select(ani => new AnimalMovimientoInfo { LoteID = ani.LoteID }).ToList(); List <AnimalMovimientoInfo> animalesPorLoteOrigen = animalesNoReimplantados .Select(ani => new AnimalMovimientoInfo { LoteID = ani.LoteID }).ToList(); lotesDestino.ForEach(id => { int cabezas = animalesPorLoteDestino.Count(loteID => loteID.LoteID == id.LoteID); id.Cabezas += cabezas; id.CabezasInicio += cabezas; id.UsuarioModificacionID = usuarioCreacionID; }); lotesOrigen.ForEach(id => { int cabezas = animalesPorLoteOrigen.Count(loteID => loteID.LoteID == id.LoteID); id.Cabezas -= cabezas; id.UsuarioModificacionID = usuarioCreacionID; }); } } } var transactionOption = new TransactionOptions(); transactionOption.IsolationLevel = IsolationLevel.ReadUncommitted; using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption)) { Logger.Info(); var cierreDiaInventarioDAL = new CierreDiaInventarioDAL(); var programacionReimplanteBl = new ProgramacionReimplanteBL(); #region AjusteDeCorralesReimplante if (animalesNoReimplantados != null && animalesNoReimplantados.Any()) { animalMovimientoBL.GuardarAnimalMovimientoXML(animalesNoReimplantados); ////Se actualizan las cabezas que tiene el lote loteBL.ActualizaNoCabezasEnLoteXML(lotesDestino, lotesOrigen); //Se elimina la programacin reimplante del lote programacionReimplanteBl.EliminarProgramacionReimplanteXML(corralesProgramados); } if (almacenCierreFolio.Almacen != null && almacenCierreFolio.Almacen.TipoAlmacen.TipoAlmacenID == TipoAlmacenEnum.ReimplanteGanado.GetHashCode()) { programacionReimplanteBl.CerrarProgramacionReimplante(organizacionID, usuarioCreacionID); } #endregion AjusteDeCorralesReimplante #region GuardarCierreDeDia AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento = cierreDiaInventarioDAL.GuardarAlmacenMovimiento(almacenCierreFolio); almacenCierreFolio.UsuarioCreacionId = resultadoAlmacenMovimiento.UsuarioCreacionId; almacenCierreFolio.AlmacenMovimientoID = resultadoAlmacenMovimiento.AlmacenMovimientoID; result = cierreDiaInventarioDAL.GuardarProductosCierreDiaInventario(datosGrid, almacenCierreFolio); #endregion GuardarCierreDeDia #region POLIZA var almacenMovimientoInventarioBL = new AlmacenMovimientoBL(); List <ContenedorAlmacenMovimientoCierreDia> contenedorMovimientoCierreDia = almacenMovimientoInventarioBL.ObtenerMovimientosInventario(almacenCierreDiaInventario.Almacen.AlmacenID, almacenCierreDiaInventario.OrganizacionId); if (contenedorMovimientoCierreDia != null && contenedorMovimientoCierreDia.Any()) { contenedorMovimientoCierreDia.ForEach( x => x.FolioAlmacen = almacenCierreDiaInventario.FolioAlmacen); contenedorMovimientoCierreDia = contenedorMovimientoCierreDia.Join(datosGrid, contenedor => contenedor.Producto.ProductoId, grid => grid.ProductoID, (con, grd) => con).ToList(); var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.ConsumoProducto); List <DateTime> foliosFechas = contenedorMovimientoCierreDia.Select( x => Convert.ToDateTime(x.AlmacenMovimiento.FechaMovimiento.ToShortDateString())). Distinct().OrderBy( fecha => fecha).ToList(); List <ContenedorAlmacenMovimientoCierreDia> movimientosPorDia; var cierreDiaFechas = new List <ContenedorAlmacenMovimientoCierreDia>(); for (var indexFecha = 0; indexFecha < foliosFechas.Count; indexFecha++) { movimientosPorDia = contenedorMovimientoCierreDia.Where( x => Convert.ToDateTime(x.AlmacenMovimiento.FechaMovimiento.ToShortDateString()).Equals( foliosFechas[indexFecha])).ToList(); IList <PolizaInfo> polizaConsumo = poliza.GeneraPoliza(movimientosPorDia); if (polizaConsumo != null && polizaConsumo.Any()) { var polizaBL = new PolizaBL(); polizaConsumo.ToList().ForEach(datos => { datos.UsuarioCreacionID = almacenCierreDiaInventario.UsuarioCreacionId; datos.OrganizacionID = almacenCierreDiaInventario.OrganizacionId; datos.ArchivoEnviadoServidor = 1; }); polizaBL.GuardarServicioPI(polizaConsumo, TipoPoliza.ConsumoProducto); cierreDiaFechas.AddRange(movimientosPorDia); } } var almacenMovimientoBL = new AlmacenMovimientoBL(); cierreDiaFechas.ForEach( datos => datos.Almacen.UsuarioModificacionID = almacenCierreDiaInventario.UsuarioCreacionId); almacenMovimientoBL.ActualizarGeneracionPoliza(cierreDiaFechas); } #endregion POLIZA transaction.Complete(); } return(result); } catch (ExcepcionServicio ex) { Logger.Error(ex); throw; } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
private long GenerarMovimientoEntradaCancelacion(AlmacenMovimientoInfo info, UsuarioInfo usuario) { var almacenInventarioBL = new AlmacenInventarioBL(); var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); AlmacenMovimientoDetalle detalle = info.ListaAlmacenMovimientoDetalle.FirstOrDefault(); if (detalle == null) { return(0); } //decimal cantidadTraspaso = detalle.Cantidad; List <AlmacenInventarioInfo> inventariosDestino = almacenInventarioBL.ObtienePorAlmacenId(info.Almacen); AlmacenInventarioInfo almacenInventarioDestino = null; if (inventariosDestino != null && inventariosDestino.Any()) { almacenInventarioDestino = inventariosDestino.FirstOrDefault(inv => inv.ProductoID == detalle.Producto.ProductoId); if (almacenInventarioDestino != null) { almacenInventarioDestino.Cantidad = almacenInventarioDestino.Cantidad + detalle.Cantidad; almacenInventarioDestino.Importe = almacenInventarioDestino.Importe + detalle.Importe; almacenInventarioDestino.PrecioPromedio = almacenInventarioDestino.Importe / almacenInventarioDestino.Cantidad; almacenInventarioDestino.UsuarioModificacionID = usuario.UsuarioID; almacenInventarioBL.Actualizar(almacenInventarioDestino); } } if (detalle.AlmacenInventarioLoteId != 0) { AlmacenInventarioLoteInfo loteDestino = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(detalle.AlmacenInventarioLoteId); if (loteDestino != null) { loteDestino.Cantidad = loteDestino.Cantidad + detalle.Cantidad; loteDestino.Importe = loteDestino.Importe + detalle.Importe; loteDestino.PrecioPromedio = loteDestino.Importe / loteDestino.Cantidad; loteDestino.UsuarioModificacionId = usuario.UsuarioID; almacenInventarioLoteBL.Actualizar(loteDestino); } } var almacenMovimientoDestino = new AlmacenMovimientoInfo { AlmacenID = info.Almacen.AlmacenID, TipoMovimientoID = TipoMovimiento.EntradaAlmacen.GetHashCode(), ProveedorId = info.ProveedorId, Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = usuario.UsuarioID, }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoDestino); if (almacenInventarioDestino != null) { var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, AlmacenInventarioLoteId = detalle.AlmacenInventarioLoteId, //ContratoId = detalle.ContratoId, Piezas = 0, ProductoID = detalle.Producto.ProductoId, Precio = detalle.Precio, Cantidad = detalle.Cantidad, Importe = detalle.Importe, UsuarioCreacionID = usuario.UsuarioID }; almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo); } return(almacenMovimientoID); }
/// <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); }
private long GenerarMovimientoSalida(TraspasoMpPaMedInfo info) { var almacenInventarioBL = new AlmacenInventarioBL(); var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); decimal cantidadTraspaso = info.CantidadTraspasarOrigen; List <AlmacenInventarioInfo> inventariosOrigen = almacenInventarioBL.ObtienePorAlmacenId(info.AlmacenOrigen); AlmacenInventarioInfo almacenInventarioOrigen = null; decimal precioPromedio = 0; decimal importe = 0; if (inventariosOrigen != null && inventariosOrigen.Any()) { almacenInventarioOrigen = inventariosOrigen.FirstOrDefault(inv => inv.ProductoID == info.ProductoOrigen.ProductoId); if (almacenInventarioOrigen != null) { almacenInventarioOrigen.Cantidad = almacenInventarioOrigen.Cantidad - cantidadTraspaso; almacenInventarioOrigen.Importe = almacenInventarioOrigen.Importe - Math.Round(cantidadTraspaso * almacenInventarioOrigen.PrecioPromedio, 2); if (almacenInventarioOrigen.Importe < 0) { almacenInventarioOrigen.Importe = 0; } if (almacenInventarioOrigen.Cantidad > 0) { almacenInventarioOrigen.PrecioPromedio = almacenInventarioOrigen.Importe / almacenInventarioOrigen.Cantidad; } almacenInventarioOrigen.UsuarioModificacionID = info.Usuario.UsuarioID; almacenInventarioBL.Actualizar(almacenInventarioOrigen); precioPromedio = almacenInventarioOrigen.PrecioPromedio; importe = precioPromedio * cantidadTraspaso; } } if (info.LoteMpOrigen.AlmacenInventarioLoteId != 0) { AlmacenInventarioLoteInfo loteOrigen = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(info.LoteMpOrigen.AlmacenInventarioLoteId); if (loteOrigen != null) { loteOrigen.Cantidad = loteOrigen.Cantidad - cantidadTraspaso; loteOrigen.Importe = loteOrigen.Importe - Math.Round(cantidadTraspaso * loteOrigen.PrecioPromedio, 2); if (loteOrigen.Importe < 0) { loteOrigen.Importe = 0; } if (loteOrigen.Cantidad > 0) { loteOrigen.PrecioPromedio = loteOrigen.Importe / loteOrigen.Cantidad; } loteOrigen.UsuarioModificacionId = info.Usuario.UsuarioID; almacenInventarioLoteBL.Actualizar(loteOrigen); precioPromedio = loteOrigen.PrecioPromedio; importe = precioPromedio * cantidadTraspaso; } } var almacenMovimientoOrigen = new AlmacenMovimientoInfo { AlmacenID = info.AlmacenOrigen.AlmacenID, TipoMovimientoID = TipoMovimiento.ProductoSalidaTraspaso.GetHashCode(), ProveedorId = info.ProveedorOrigen.ProveedorID, Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = info.Usuario.UsuarioID, Observaciones = info.JustificacionDestino }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoOrigen); if (almacenInventarioOrigen != null) { var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, AlmacenInventarioLoteId = info.LoteMpOrigen.AlmacenInventarioLoteId, Piezas = 0, ProductoID = info.ProductoOrigen.ProductoId, Precio = precioPromedio, Cantidad = cantidadTraspaso, Importe = importe, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo); } info.ImporteTraspaso = importe; return(almacenMovimientoID); }
/// <summary> /// Metodo para Cancelar un traspaso de MP /// </summary> /// <param name="info"></param> public Dictionary <long, MemoryStream> CancelarTraspaso(TraspasoMpPaMedInfo info) { try { var resultado = new Dictionary <long, MemoryStream>(); Logger.Info(); var traspasoMateriaPrimaDAL = new TraspasoMateriaPrimaDAL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var cancelacionMovimientoBL = new CancelacionMovimientoBL(); TraspasoMateriaPrimaInfo traspasoCancelar = traspasoMateriaPrimaDAL.ObtenerPorID(info.TraspasoMateriaPrimaID); if (traspasoCancelar == null) { return(null); } AlmacenMovimientoInfo movimientoOrigen = almacenMovimientoBL.ObtenerPorIDCompleto( traspasoCancelar.AlmacenMovimientoOrigen.AlmacenMovimientoID); AlmacenMovimientoInfo movimientoDestino = almacenMovimientoBL.ObtenerPorIDCompleto( traspasoCancelar.AlmacenMovimientoDestino.AlmacenMovimientoID); AlmacenInfo almacenOrigenAux = info.AlmacenOrigen; AlmacenInfo almacenDestinoAux = info.AlmacenDestino; AlmacenMovimientoDetalle detalleOrigen = movimientoOrigen.ListaAlmacenMovimientoDetalle.FirstOrDefault(); AlmacenMovimientoDetalle detalleDestino = movimientoDestino.ListaAlmacenMovimientoDetalle.FirstOrDefault(); if (detalleOrigen == null || detalleDestino == null) { return(null); } info.CantidadTraspasarOrigen = detalleOrigen.Cantidad; info.CantidadTraspasarDestino = detalleDestino.Cantidad; info.PrecioTraspasoOrigen = detalleOrigen.Precio; info.PrecioTraspasoDestino = detalleDestino.Precio; info.ImporteTraspaso = detalleDestino.Importe; info.AlmacenDestino = almacenOrigenAux; info.AlmacenOrigen = almacenDestinoAux; using (var transaction = new TransactionScope()) { long almacenMovimientoEntradaID = 0; long almacenMovimientoSalidaID = 0; if (movimientoDestino != null) { almacenMovimientoEntradaID = GenerarMovimientoEntradaCancelacion(movimientoDestino, info.Usuario); almacenMovimientoSalidaID = GenerarMovimientoSalidaCancelacion(movimientoOrigen, info.Usuario); } var cancelacionMovimientoEntrada = new CancelacionMovimientoInfo { TipoCancelacion = new TipoCancelacionInfo { TipoCancelacionId = TipoCancelacionEnum.TraspasoMpPaMed.GetHashCode() }, Pedido = new PedidoInfo(), AlmacenMovimientoOrigen = new AlmacenMovimientoInfo { AlmacenMovimientoID = almacenMovimientoEntradaID }, AlmacenMovimientoCancelado = new AlmacenMovimientoInfo { AlmacenMovimientoID = movimientoOrigen.AlmacenMovimientoID }, Activo = EstatusEnum.Activo, Justificacion = traspasoCancelar.Justificacion, UsuarioCreacionID = info.Usuario.UsuarioID }; CancelacionMovimientoInfo movimientoCancelado = cancelacionMovimientoBL.Guardar(cancelacionMovimientoEntrada); if (movimientoDestino != null) { var cancelacionMovimientoSalida = new CancelacionMovimientoInfo { TipoCancelacion = new TipoCancelacionInfo { TipoCancelacionId = TipoCancelacionEnum.TraspasoMpPaMed.GetHashCode() }, Pedido = new PedidoInfo(), AlmacenMovimientoOrigen = new AlmacenMovimientoInfo { AlmacenMovimientoID = almacenMovimientoSalidaID }, AlmacenMovimientoCancelado = new AlmacenMovimientoInfo { AlmacenMovimientoID = movimientoDestino.AlmacenMovimientoID }, Activo = EstatusEnum.Activo, Justificacion = traspasoCancelar.Justificacion, UsuarioCreacionID = info.Usuario.UsuarioID }; cancelacionMovimientoBL.Guardar(cancelacionMovimientoSalida); } traspasoCancelar.Activo = EstatusEnum.Inactivo; traspasoCancelar.UsuarioModificacionID = info.Usuario.UsuarioID; traspasoMateriaPrimaDAL.Actualizar(traspasoCancelar); movimientoOrigen.UsuarioModificacionID = info.Usuario.UsuarioID; if (movimientoDestino != null) { movimientoDestino.UsuarioModificacionID = info.Usuario.UsuarioID; } movimientoOrigen.Status = Estatus.CanceladoInv.GetHashCode(); if (movimientoDestino != null) { movimientoDestino.Status = Estatus.CanceladoInv.GetHashCode(); } almacenMovimientoBL.ActualizarEstatus(movimientoOrigen); almacenMovimientoBL.ActualizarEstatus(movimientoDestino); AlmacenMovimientoInfo movimientoCancelacion = almacenMovimientoBL.ObtenerPorIDCompleto(almacenMovimientoEntradaID); if (movimientoCancelacion == null) { return(null); } info.FolioTraspaso = traspasoCancelar.FolioTraspaso; info.FechaTraspaso = movimientoCancelado.FechaCancelacion; info.AlmacenMovimientoID = movimientoDestino.AlmacenMovimientoID; MemoryStream pdfPoliza = null; if (info.AlmacenOrigen.AlmacenID != info.AlmacenDestino.AlmacenID) { info.EsCancelacion = true; var productoBL = new ProductoBL(); info.ProductoOrigen = productoBL.ObtenerPorID(info.ProductoOrigen); info.ProductoDestino = info.ProductoOrigen; PolizaAbstract poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaTraspaso); IList <PolizaInfo> listaPolizas = poliza.GeneraPoliza(info); pdfPoliza = poliza.ImprimePoliza(info, listaPolizas); if (listaPolizas != null && listaPolizas.Any()) { listaPolizas.ToList().ForEach(datos => { datos.OrganizacionID = info.Usuario.Organizacion.OrganizacionID; datos.UsuarioCreacionID = info.Usuario.UsuarioID; datos.Activo = EstatusEnum.Activo; datos.ArchivoEnviadoServidor = 1; }); var polizaDAL = new PolizaDAL(); polizaDAL.CrearServicioPI(listaPolizas, TipoPoliza.EntradaTraspaso); } } transaction.Complete(); resultado.Add(info.FolioTraspaso, pdfPoliza); return(resultado); } } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Genera los movimientos de almacen /// </summary> /// <param name="cargaInventario"></param> /// <param name="almacenInventarioLote"></param> /// <returns></returns> private void GenerarMovimientosAlmacen(CargaMPPAModel cargaInventario, AlmacenInventarioLoteInfo almacenInventarioLote) { var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); var almacenMovimiento = new AlmacenMovimientoInfo { AlmacenID = cargaInventario.Almacen.AlmacenID, TipoMovimientoID = TipoMovimiento.EntradaPorAjuste.GetHashCode(), Observaciones = string.Format("Carga Inicial {0}", DateTime.Now.Date), Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = 1 }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimiento); almacenMovimiento.AlmacenMovimientoID = almacenMovimientoID; var almacenMovimientoDetalle = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID, AlmacenInventarioLoteId = almacenInventarioLote.AlmacenInventarioLoteId, Piezas = cargaInventario.Piezas, ProductoID = cargaInventario.Producto.ProductoId, Cantidad = cargaInventario.CantidadTamanioLote, Importe = cargaInventario.ImporteTamanioLote, Precio = cargaInventario.ImporteTamanioLote / cargaInventario.CantidadTamanioLote, UsuarioCreacionID = 1 }; long almacenMovimientoDetalleID = almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalle); almacenMovimientoDetalle.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID; decimal diferenciaInventario = cargaInventario.CantidadTamanioLote - cargaInventario.CantidadActual; decimal importeDiferencia = cargaInventario.ImporteTamanioLote - cargaInventario.ImporteActual; if (diferenciaInventario > 0) { almacenMovimiento = new AlmacenMovimientoInfo { AlmacenID = cargaInventario.Almacen.AlmacenID, TipoMovimientoID = TipoMovimiento.SalidaPorAjuste.GetHashCode(), Observaciones = string.Format("Carga Inicial {0}", DateTime.Now.Date), Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = 1 }; almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimiento); almacenMovimiento.AlmacenMovimientoID = almacenMovimientoID; almacenMovimientoDetalle = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID, AlmacenInventarioLoteId = almacenInventarioLote.AlmacenInventarioLoteId, Piezas = cargaInventario.Piezas, ProductoID = cargaInventario.Producto.ProductoId, Cantidad = diferenciaInventario, Importe = importeDiferencia, Precio = importeDiferencia / diferenciaInventario, UsuarioCreacionID = 1 }; almacenMovimientoDetalleID = almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalle); almacenMovimientoDetalle.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID; } }
internal PremezclaDistribucionInfo GuardarPremezclaDistribucion(DistribucionDeIngredientesInfo distribucionIngredientes) { PremezclaDistribucionInfo distribucion = null; try { var almacenMovimientoBl = new AlmacenMovimientoBL(); var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var almacenInventarioBl = new AlmacenInventarioBL(); var almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL(); var premezclaDistribucionDal = new PremezclaDistribucionDAL(); var premezclaDistribucionDetalleDal = new PremezclaDistribucionDetalleDAL(); var premezclaDistribucionCostoDal = new PremezclaDistribucionCostoDAL(); long almacenMovimientoId = 0; // Afectamos el inventario. using (var transaction = new TransactionScope()) { distribucion = premezclaDistribucionDal.GuardarPremezclaDistribucion(new PremezclaDistribucionInfo { ProveedorId = distribucionIngredientes.Proveedor.ProveedorID, Iva = distribucionIngredientes.Iva, ProductoId = distribucionIngredientes.Producto.ProductoId, CantidadExistente = distribucionIngredientes.CantidadTotal, CostoUnitario = distribucionIngredientes.CostoUnitario, UsuarioCreacionId = distribucionIngredientes.UsuarioId, }); distribucionIngredientes.PremezclaDistribucionID = distribucion.PremezclaDistribucionId; distribucion.ListaPremezclaDistribucionCosto = premezclaDistribucionCostoDal.GuardarPremezclaDistribucionCosto(distribucionIngredientes); /* Se calcula el costo extra y se proratea entre las organizaciones*/ //decimal costoDeCostosPorOrganizacion = 0; decimal importeCostoTotal = 0; if (distribucionIngredientes.ListaOrganizaciones.Any()) { importeCostoTotal = distribucionIngredientes.ListaPremezclaDistribucionCosto.Sum(c => c.Importe); } foreach (var distribucionorganizaciones in distribucionIngredientes.ListaOrganizaciones) { decimal porcentajeSurtido = distribucionIngredientes.CantidadTotal > 0 ? (decimal)distribucionorganizaciones.CantidadSurtir / (decimal)distribucionIngredientes.CantidadTotal : 0; if (distribucionorganizaciones.Lote.AlmacenInventarioLoteId != 0) { // Se Genera un movimiento de almacen ////Insertar en almacenmovimiento var almacenMovimientoInfo = new AlmacenMovimientoInfo { ProveedorId = distribucionIngredientes.Proveedor.ProveedorID, AlmacenID = distribucionorganizaciones.Lote.AlmacenInventario.Almacen.AlmacenID, TipoMovimientoID = TipoMovimiento.EntradaAlmacen.GetHashCode(), Observaciones = "", Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = distribucionIngredientes.UsuarioId }; almacenMovimientoId = almacenMovimientoBl.Crear(almacenMovimientoInfo); //Se crea el Almacen Movimiento Costo GuardarCosto(distribucionIngredientes, almacenMovimientoId, distribucionorganizaciones); // Se modifica el Almacen Inventario distribucionorganizaciones.Lote.AlmacenInventario.Cantidad = distribucionorganizaciones.Lote.AlmacenInventario.Cantidad + distribucionorganizaciones.CantidadSurtir; distribucionorganizaciones.Lote.AlmacenInventario.Importe = distribucionorganizaciones.Lote.AlmacenInventario.Importe + distribucionorganizaciones.CostoTotal + (importeCostoTotal * porcentajeSurtido); distribucionorganizaciones.Lote.AlmacenInventario.PrecioPromedio = distribucionorganizaciones.Lote.AlmacenInventario.Importe / distribucionorganizaciones.Lote.AlmacenInventario.Cantidad; distribucionorganizaciones.Lote.AlmacenInventario.UsuarioModificacionID = distribucionIngredientes.UsuarioId; almacenInventarioBl.Actualizar(distribucionorganizaciones.Lote.AlmacenInventario); // Se modifica el Almacen Inventario Lote distribucionorganizaciones.Lote.Cantidad = distribucionorganizaciones.Lote.Cantidad + distribucionorganizaciones.CantidadSurtir; distribucionorganizaciones.Lote.Importe = distribucionorganizaciones.Lote.Importe + distribucionorganizaciones.CostoTotal + (importeCostoTotal * porcentajeSurtido); distribucionorganizaciones.Lote.PrecioPromedio = distribucionorganizaciones.Lote.Importe / distribucionorganizaciones.Lote.Cantidad; distribucionorganizaciones.Lote.UsuarioModificacionId = distribucionIngredientes.UsuarioId; almacenInventarioLoteBl.Actualizar(distribucionorganizaciones.Lote); // Se genera el Almacen Movimiento Detalle almacenMovimientoDetalleBl.Crear(new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoId, AlmacenInventarioLoteId = distribucionorganizaciones.Lote.AlmacenInventarioLoteId, Piezas = 0, ProductoID = distribucionorganizaciones.Lote.AlmacenInventario.ProductoID, Precio = distribucionorganizaciones.CostoUnitario, Cantidad = distribucionorganizaciones.CantidadSurtir, Importe = distribucionorganizaciones.CostoTotal, UsuarioCreacionID = distribucionIngredientes.UsuarioId, FechaCreacion = DateTime.Now }); var premezclaDistribucionDetalle = premezclaDistribucionDetalleDal.GuardarPremezclaDistribucionDetalle(new PremezclaDistribucionDetalleInfo { AlmacenMovimientoId = almacenMovimientoId, PremezclaDistribucionId = distribucion.PremezclaDistribucionId, CantidadASurtir = distribucionorganizaciones.CantidadSurtir, OrganizacionId = distribucionorganizaciones.Organizacion.OrganizacionID, UsuarioCreacionId = distribucionIngredientes.UsuarioId }); distribucion.ListaPremezclaDistribucionDetalle.Add(premezclaDistribucionDetalle); foreach (var distribucionOrg in distribucionIngredientes .ListaOrganizaciones.Where(distribucionOrg => distribucionOrg.Organizacion.OrganizacionID == premezclaDistribucionDetalle.OrganizacionId)) { distribucionOrg.AlmaceMovimiento = new AlmacenMovimientoInfo { AlmacenMovimientoID = premezclaDistribucionDetalle.AlmacenMovimientoId }; } } } #region POLIZA distribucionIngredientes.AlmaceMovimientoID = almacenMovimientoId; var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PolizaPremezcla); distribucionIngredientes.FechaEntrada = DateTime.Now; IList <PolizaInfo> polizas = poliza.GeneraPoliza(distribucionIngredientes); if (polizas != null && polizas.Any()) { var polizaBL = new PolizaBL(); int organizacionID = distribucionIngredientes.ListaOrganizaciones[0].Organizacion.OrganizacionID; int usuarioCreacionID = distribucionIngredientes.UsuarioId; polizas.ToList().ForEach(datos => { datos.OrganizacionID = organizacionID; datos.UsuarioCreacionID = usuarioCreacionID; datos.ArchivoEnviadoServidor = 1; }); polizaBL.GuardarServicioPI(polizas, TipoPoliza.PolizaPremezcla); } #endregion POLIZA transaction.Complete(); } return(distribucion); } catch (ExcepcionServicio ex) { Logger.Error(ex); throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Actualiza la recepcion de materia prima /// </summary> /// <param name="listaSurtido"></param> /// <param name="pedido"></param> /// <returns></returns> internal bool ActualizarRecepcionMateriaPrima(List <SurtidoPedidoInfo> listaSurtido, PedidoInfo pedido) { bool resultado; try { Logger.Info(); var almacenInventarioBl = new AlmacenInventarioBL(); var almacenInventarioLoteBl = new AlmacenInventarioLoteBL(); var almacenBl = new AlmacenBL(); var proveedorChofeBl = new ProveedorChoferBL(); int proveedorId = 0; var pesajeMateriaPrimaBl = new PesajeMateriaPrimaBL(); int organizacionID; PolizaAbstract poliza; IList <PolizaInfo> polizas; IList <ResultadoPolizaModel> resultadoPolizaModel; var contenedorAlmacenesMovimientos = new List <ContenedorAlmacenMovimientoCierreDia>(); ContenedorAlmacenMovimientoCierreDia contenedorAlmacenMovimiento; var surtidoGenerarPoliza = new List <SurtidoPedidoInfo>(); using (var transaction = new TransactionScope()) { ProgramacionMateriaPrimaInfo programacionMateriaPrima; var programacionMateriaPrimaBL = new ProgramacionMateriaPrimaBL(); foreach (var surtidoTmp in listaSurtido) { if (surtidoTmp.Seleccionado) { programacionMateriaPrima = programacionMateriaPrimaBL. ObtenerPorProgramacionMateriaPrimaTicket( surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId, surtidoTmp.PesajeMateriaPrima.Ticket); if (programacionMateriaPrima != null) { continue; } surtidoGenerarPoliza.Add(surtidoTmp); var pesaje = pesajeMateriaPrimaBl.ObtenerPorId(surtidoTmp.PesajeMateriaPrima); // Se consulta el proveedor del Proveedor chofer seleccionado para el pesaje. var proveedorChofeInfo = proveedorChofeBl.ObtenerProveedorChoferPorId( surtidoTmp.PesajeMateriaPrima.ProveedorChoferID); if (proveedorChofeInfo != null) { proveedorId = proveedorChofeInfo.Proveedor.ProveedorID; } //SE OBTIENEN LOS DATOS DEL LOTE DESTINO var almacenInventarioLoteDestino = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( surtidoTmp.PedidoDetalle.InventarioLoteDestino.AlmacenInventarioLoteId); //SE OBTIENEN LOS DATOS DEL LOTE ORIGEN var almacenInventarioLoteOrigen = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId( surtidoTmp.ProgramacionMateriaPrima.InventarioLoteOrigen .AlmacenInventarioLoteId); #region INVENTARIO ORIGEN // GENERA MOVIMIENTO DE INVENTARIO var almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo { AlmacenID = almacenInventarioLoteOrigen .AlmacenInventario. AlmacenID, TipoMovimientoID = (int) TipoMovimiento. PaseProceso, Observaciones = "", Status = (int)EstatusInventario.Aplicado, AnimalMovimientoID = 0, ProveedorId = proveedorId, UsuarioCreacionID = pedido. UsuarioModificacion. UsuarioID }); // SE LE ASIGNA EL MOVIMIENTO GENERADO AL PESAJE pesaje.AlmacenMovimientoOrigenId = almacenMovimiento.AlmacenMovimientoID; contenedorAlmacenMovimiento = new ContenedorAlmacenMovimientoCierreDia { AlmacenMovimiento = new AlmacenMovimientoInfo { AlmacenMovimientoID = almacenMovimiento. AlmacenMovimientoID } }; contenedorAlmacenesMovimientos.Add(contenedorAlmacenMovimiento); // GENERA EL DETALLE DEL MOVIMIENTO almacenBl.GuardarAlmacenMovimientoDetalleProducto( new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID, ProductoID = surtidoTmp.Producto.ProductoId, Precio = almacenInventarioLoteOrigen.PrecioPromedio, Cantidad = surtidoTmp.CantidadEntregada, Importe = almacenInventarioLoteOrigen.PrecioPromedio * surtidoTmp.CantidadEntregada, AlmacenInventarioLoteId = almacenInventarioLoteOrigen.AlmacenInventarioLoteId, ContratoId = 0, Piezas = surtidoTmp.PesajeMateriaPrima.Piezas, UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID }); // GENERA LA SALIDA DEL INVENTARIO LOTE almacenInventarioLoteOrigen.Cantidad -= surtidoTmp.CantidadEntregada; almacenInventarioLoteOrigen.Piezas -= surtidoTmp.PesajeMateriaPrima.Piezas; almacenInventarioLoteOrigen.Importe = almacenInventarioLoteOrigen.PrecioPromedio * almacenInventarioLoteOrigen.Cantidad; almacenInventarioLoteOrigen.UsuarioModificacionId = pedido.UsuarioModificacion.UsuarioID; almacenInventarioLoteBl.Actualizar(almacenInventarioLoteOrigen); // GENERA LA SALIDA DEL ALMACEN INVENTARIO var almacenInventarioInfo = almacenInventarioBl.ObtenerAlmacenInventarioPorId( almacenInventarioLoteOrigen.AlmacenInventario.AlmacenInventarioID); almacenInventarioInfo.Cantidad = almacenInventarioInfo.Cantidad - surtidoTmp.CantidadEntregada; almacenInventarioInfo.Importe = almacenInventarioInfo.PrecioPromedio * almacenInventarioInfo.Cantidad; almacenInventarioInfo.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID; almacenInventarioBl.Actualizar(almacenInventarioInfo); #endregion #region INVENTARIO DESTINO //Obtener costos de flete var fleteInternoPl = new FleteInternoPL(); var listadoCostos = fleteInternoPl.ObtenerCostosPorFleteConfiguracion(new FleteInternoInfo { Organizacion = new OrganizacionInfo { OrganizacionID = pedido.Organizacion.OrganizacionID }, AlmacenOrigen = new AlmacenInfo { AlmacenID = almacenInventarioLoteOrigen.AlmacenInventario.AlmacenID }, Producto = new ProductoInfo { ProductoId = surtidoTmp.Producto.ProductoId } }, new ProveedorInfo { ProveedorID = surtidoTmp.Proveedor.ProveedorID }); decimal importeCostos = 0; if (listadoCostos != null) { foreach (var fleteInternoCostoInfo in listadoCostos) { if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode()) { importeCostos += fleteInternoCostoInfo.Tarifa; } else { importeCostos += (surtidoTmp.CantidadEntregada / 1000) * fleteInternoCostoInfo.Tarifa; } } //importeCostos = listadoCostos.Sum(fleteInternoCostoInfo => fleteInternoCostoInfo.Tarifa); } almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo { AlmacenID = almacenInventarioLoteDestino .AlmacenInventario. AlmacenID, TipoMovimientoID = (int) TipoMovimiento. RecepcionAProceso, Observaciones = pedido.Observaciones, Status = (int)EstatusInventario.Aplicado, AnimalMovimientoID = 0, ProveedorId = proveedorId, UsuarioCreacionID = pedido. UsuarioModificacion. UsuarioID }); // SE LE ASIGNA EL MOVIMIENTO AL PESAJE pesaje.AlmacenMovimientoDestinoId = almacenMovimiento.AlmacenMovimientoID; // GENERA LA ENTRADA DEL INVENTARIO LOTE almacenInventarioLoteDestino.Piezas += surtidoTmp.PesajeMateriaPrima.Piezas; decimal importe = surtidoTmp.CantidadEntregada * almacenInventarioLoteOrigen.PrecioPromedio; almacenInventarioLoteDestino.Importe += importe; almacenInventarioLoteDestino.Cantidad += surtidoTmp.CantidadEntregada; almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe / almacenInventarioLoteDestino.Cantidad; almacenInventarioLoteDestino.UsuarioModificacionId = pedido.UsuarioModificacion.UsuarioID; // //Se agregan los costos al importe del lote //importeCostos = importeCostos * surtidoTmp.CantidadEntregada; almacenInventarioLoteDestino.Importe = almacenInventarioLoteDestino.Importe + importeCostos; almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe / almacenInventarioLoteDestino.Cantidad; // almacenInventarioLoteBl.Actualizar(almacenInventarioLoteDestino); // GENERA EL DETALLE DEL MOVIMIENTO almacenBl.GuardarAlmacenMovimientoDetalleProducto( new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID, ProductoID = surtidoTmp.Producto.ProductoId, Precio = almacenInventarioLoteOrigen.PrecioPromedio, Cantidad = surtidoTmp.CantidadEntregada, Importe = importe, AlmacenInventarioLoteId = almacenInventarioLoteDestino.AlmacenInventarioLoteId, ContratoId = 0, Piezas = surtidoTmp.PesajeMateriaPrima.Piezas, UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID }); //Guarda almacen movimiento costo if (listadoCostos != null) { foreach (var fleteInternoCostoInfo in listadoCostos) { var almacenMovimientoCosto = new AlmacenMovimientoCostoBL(); decimal importeCostoFlete = 0; if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode()) { importeCostoFlete = fleteInternoCostoInfo.Tarifa; } else { importeCostoFlete = (surtidoTmp.CantidadEntregada / 1000) * fleteInternoCostoInfo.Tarifa; } almacenMovimientoCosto.Crear(new AlmacenMovimientoCostoInfo { AlmacenMovimientoId = almacenMovimiento.AlmacenMovimientoID, ProveedorId = surtidoTmp.Proveedor.ProveedorID, CostoId = fleteInternoCostoInfo.Costo.CostoID, Importe = importeCostoFlete, Cantidad = surtidoTmp.CantidadEntregada, Activo = EstatusEnum.Activo, UsuarioCreacionId = pedido.UsuarioModificacion.UsuarioID }); } } // programacionMateriaPrimaBL.ActualizarAlmacenMovimiento( surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId, almacenMovimiento.AlmacenMovimientoID); // GENERA LA ENTRADA DEL ALMACEN INVENTARIO almacenInventarioInfo = almacenInventarioBl.ObtenerAlmacenInventarioPorId( almacenInventarioLoteDestino.AlmacenInventario.AlmacenInventarioID); List <AlmacenInventarioLoteInfo> listaAlmacenInventarioLote = almacenInventarioLoteBl.ObtenerPorAlmacenInventarioID(almacenInventarioInfo); var almacenInventario = new AlmacenInventarioInfo(); almacenInventario.AlmacenInventarioID = almacenInventarioInfo.AlmacenInventarioID; // SE SUMAN LAS CANTIDADES E IMPORTES QUE TIENE EL ALMACEN foreach (var almacenInventarioLoteInfo in listaAlmacenInventarioLote) { almacenInventario.Cantidad += almacenInventarioLoteInfo.Cantidad; almacenInventario.Importe += almacenInventarioLoteInfo.Importe; } almacenInventario.PrecioPromedio = almacenInventario.Importe / almacenInventario.Cantidad; almacenInventario.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID; almacenInventario.ProductoID = surtidoTmp.Producto.ProductoId; almacenInventario.AlmacenID = almacenInventarioLoteDestino.AlmacenInventario.AlmacenID; almacenInventarioBl.ActualizarPorProductoId(almacenInventario); #endregion // SE ACTUALIZA EL PESAJE DE MATERIA PRIMA pesaje.EstatusID = (int)Estatus.PedidoCompletado; pesaje.Activo = false; pesaje.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID; pesajeMateriaPrimaBl.ActualizarPesajePorId(pesaje); } } #region POLIZA organizacionID = pedido.Organizacion.OrganizacionID; string lotes = ObtenerXMLLote(listaSurtido); var pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL(); List <PolizaPaseProcesoModel> datosPoliza = pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProceso(pedido.FolioPedido, organizacionID, lotes); if (datosPoliza != null) { datosPoliza = (from dp in datosPoliza from ls in surtidoGenerarPoliza where dp.Proveedor.ProveedorID == ls.Proveedor.ProveedorID && dp.Producto.ProductoId == ls.Producto.ProductoId && dp.PesajeMateriaPrima.Ticket == ls.PesajeMateriaPrima.Ticket select dp).ToList(); } if (datosPoliza != null && datosPoliza.Any()) { poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso); IList <PolizaPaseProcesoModel> polizasPaseProcesoModel; resultadoPolizaModel = new List <ResultadoPolizaModel>(); datosPoliza = datosPoliza.GroupBy(prod => new { prod.Producto, prod.ProveedorChofer, prod.PesajeMateriaPrima.Ticket }) .Select(grupo => new PolizaPaseProcesoModel { Organizacion = grupo.Select(org => org.Organizacion).FirstOrDefault(), Almacen = grupo.Select(alm => alm.Almacen).FirstOrDefault(), Producto = grupo.Key.Producto, Proveedor = grupo.Select(prov => prov.Proveedor).FirstOrDefault(), AlmacenMovimiento = grupo.Select(alm => alm.AlmacenMovimiento).FirstOrDefault(), AlmacenMovimientoDetalle = grupo.Select(alm => alm.AlmacenMovimientoDetalle).FirstOrDefault(), AlmacenInventarioLote = grupo.Select(alm => alm.AlmacenInventarioLote).FirstOrDefault(), FleteInterno = grupo.Select(flete => flete.FleteInterno).FirstOrDefault(), FleteInternoCosto = grupo.Select(flete => flete.FleteInternoCosto).FirstOrDefault(), Pedido = grupo.Select(ped => ped.Pedido).FirstOrDefault(), ProveedorChofer = grupo.Key.ProveedorChofer, PesajeMateriaPrima = grupo.Select(pesaje => pesaje.PesajeMateriaPrima).FirstOrDefault(), ProgramacionMateriaPrima = grupo.Select(prog => prog.ProgramacionMateriaPrima).FirstOrDefault(), ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).FirstOrDefault(), }).ToList(); IList <PolizaInfo> polizaExistente; var polizaBL = new PolizaBL(); for (var indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++) { polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> { datosPoliza[indexPoliza] }; polizas = poliza.GeneraPoliza(polizasPaseProcesoModel); if (polizas != null) { var resultadoPoliza = new ResultadoPolizaModel { Polizas = polizas }; polizas.ToList().ForEach(datos => { datos.OrganizacionID = organizacionID; datos.UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID; datos.ArchivoEnviadoServidor = 1; }); polizaExistente = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso, organizacionID, pedido.FechaPedido, string.Format("{0}-{1}", pedido.FolioPedido, datosPoliza[indexPoliza]. PesajeMateriaPrima.Ticket), "PP", 1); if (polizaExistente != null && polizaExistente.Any()) { List <PolizaInfo> excluir = (from existente in polizaExistente join guardar in polizas on existente.Concepto equals guardar.Concepto select guardar).ToList(); polizas = polizas.Except(excluir).ToList(); } if (polizas.Any()) { polizaBL.GuardarServicioPI(polizas, TipoPoliza.PaseProceso); resultadoPolizaModel.Add(resultadoPoliza); } } } var almacenMovimientoBL = new AlmacenMovimientoBL(); contenedorAlmacenesMovimientos.ForEach(alm => alm.Almacen = new AlmacenInfo { UsuarioModificacionID = pedido. UsuarioModificacion. UsuarioID }); almacenMovimientoBL.ActualizarGeneracionPoliza(contenedorAlmacenesMovimientos); } #endregion POLIZA transaction.Complete(); resultado = true; } } catch (ExcepcionGenerica exg) { resultado = false; Logger.Error(exg); } catch (Exception ex) { resultado = false; Logger.Error(ex); } return(resultado); }
/// <summary> /// Registra el envio de alimento de una organizacion a otra /// </summary> /// <param name="envioAlimento">Información del envio de alimento a guardar</param> /// <returns>Regresa una confirmación de registro del envio de alimento</returns> internal EnvioAlimentoInfo RegistrarEnvioAlimento(EnvioAlimentoInfo envioAlimento) { EnvioAlimentoInfo confirmacion = new EnvioAlimentoInfo(); try { Logger.Info(); AlmacenMovimientoBL almacenMovimientoBL = new AlmacenMovimientoBL(); EnvioAlimentoDAL salidaAlimentoDAL = new EnvioAlimentoDAL(); AlmacenMovimientoDetalleBL almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL(); AlmacenMovimientoDetalle detalleMovimiento = new AlmacenMovimientoDetalle(); AlmacenInventarioBL inventario = new AlmacenInventarioBL(); AlmacenInventarioLoteBL loteBl = new AlmacenInventarioLoteBL(); AlmacenMovimientoInfo almacenMovimiento = new AlmacenMovimientoInfo(); almacenMovimiento.AlmacenID = envioAlimento.Almacen.AlmacenID; almacenMovimiento.TipoMovimientoID = TipoMovimiento.ProductoSalidaTraspaso.GetHashCode(); almacenMovimiento.Status = Estatus.AplicadoInv.GetHashCode(); almacenMovimiento.UsuarioCreacionID = envioAlimento.UsuarioCreacionID; almacenMovimiento.UsuarioModificacionID = envioAlimento.UsuarioCreacionID; almacenMovimiento.EsEnvioAlimento = true; almacenMovimiento.OrganizacionID = envioAlimento.Origen.OrganizacionID; PolizaAbstract poliza = null; IList <PolizaInfo> listaPolizas = null; using (var transaccion = new TransactionScope()) { //registrar en TB AlmacenMovimiento long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimiento); almacenMovimiento.AlmacenMovimientoID = almacenMovimientoID; envioAlimento.AlmacenMovimientoId = almacenMovimientoID; if (envioAlimento.AlmacenMovimientoId == 0) { return new EnvioAlimentoInfo { EnvioId = 0 } } ; //registrar en TB AlmacenMovimientoDetalle detalleMovimiento.AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID; almacenMovimiento = almacenMovimientoBL.ObtenerPorId(almacenMovimiento.AlmacenMovimientoID); if (almacenMovimiento.AlmacenMovimientoID == 0) { return new EnvioAlimentoInfo { EnvioId = 0 } } ; envioAlimento.Folio = almacenMovimiento.FolioMovimiento; detalleMovimiento.Producto = envioAlimento.Producto; if (detalleMovimiento.Producto.ManejaLote) { detalleMovimiento.AlmacenInventarioLoteId = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().AlmacenInventarioLoteId; detalleMovimiento.Precio = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio; } else { detalleMovimiento.Precio = envioAlimento.AlmacenInventario.PrecioPromedio; } detalleMovimiento.ProductoID = envioAlimento.Producto.ProductoId; detalleMovimiento.Cantidad = envioAlimento.Cantidad; detalleMovimiento.Importe = envioAlimento.Importe; detalleMovimiento.UsuarioCreacionID = envioAlimento.UsuarioCreacionID; detalleMovimiento.Piezas = envioAlimento.Piezas; int almacenMovimientoDetalleid = almacenMovimientoDetalleBl.Crear(detalleMovimiento); if (almacenMovimientoDetalleid == 0) { return new EnvioAlimentoInfo { EnvioId = 0 } } ; //registrar en TB EnvioProducto confirmacion = salidaAlimentoDAL.RegistrarEnvioAlimento(envioAlimento); if (confirmacion.EnvioId == 0) { return new EnvioAlimentoInfo { EnvioId = 0 } } ; envioAlimento.EnvioId = confirmacion.EnvioId; envioAlimento.FechaEnvio = confirmacion.FechaEnvio; envioAlimento.AlmacenInventario.Cantidad -= envioAlimento.Cantidad; envioAlimento.AlmacenInventario.Importe -= envioAlimento.Importe; decimal precioPromedioInicial = 0M; if (envioAlimento.Producto.ManejaLote) { precioPromedioInicial = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio; } else { precioPromedioInicial = envioAlimento.AlmacenInventario.PrecioPromedio; } if (envioAlimento.AlmacenInventario.Cantidad == 0) { envioAlimento.AlmacenInventario.PrecioPromedio = 0M; } if (envioAlimento.AlmacenInventario.Cantidad < 0) { envioAlimento.AlmacenInventario.Cantidad = 0; } if (envioAlimento.AlmacenInventario.Importe < 0) { envioAlimento.AlmacenInventario.Importe = 0; } if (envioAlimento.AlmacenInventario.Cantidad > 0 && envioAlimento.AlmacenInventario.Importe > 0) { envioAlimento.AlmacenInventario.PrecioPromedio = envioAlimento.AlmacenInventario.Importe / envioAlimento.AlmacenInventario.Cantidad; } envioAlimento.AlmacenInventario.UsuarioModificacionID = envioAlimento.UsuarioCreacionID; inventario.ActualizarPorProductoId(envioAlimento.AlmacenInventario); if (envioAlimento.Producto.ManejaLote) { FechaInfo fechaInfo = new FechaBL().ObtenerFechaActual(); envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad -= envioAlimento.Cantidad; envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe -= envioAlimento.Importe; if (envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad <= 0) { envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio = 0M; envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad = 0; envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe = 0; envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().FechaInicio = fechaInfo.FechaActual; } if (envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe > 0 && envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad > 0) { envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe / envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad; } else { envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Activo = EstatusEnum.Inactivo; envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().FechaFin = fechaInfo.FechaActual; } if (envioAlimento.Producto.SubfamiliaId == SubFamiliasEnum.Forrajes.GetHashCode()) { envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Piezas -= envioAlimento.Piezas; if (envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Piezas < 0) { envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Piezas = 0; } } envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().UsuarioModificacionId = envioAlimento.UsuarioCreacionID; loteBl.ActualizarEnvioAlimento(envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault()); } if (salidaAlimentoDAL.RegistrarRecepcionProductoEnc(envioAlimento, TipoMovimiento.ProductoSalidaTraspaso) == 0) { return new EnvioAlimentoInfo { EnvioId = 0 } } ; if (salidaAlimentoDAL.RegistrarRecepcionProductoDet(envioAlimento, TipoMovimiento.ProductoSalidaTraspaso) == 0) { return new EnvioAlimentoInfo { EnvioId = 0 } } ; poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaTraspaso); SolicitudProductoInfo oSolicitud = new SolicitudProductoInfo(); oSolicitud.FolioSolicitud = envioAlimento.Folio; oSolicitud.OrganizacionID = envioAlimento.Origen.OrganizacionID; oSolicitud.AlmacenGeneralID = envioAlimento.Almacen.AlmacenID; oSolicitud.Almacen = new AlmacenBL().ObtenerAlmacenPorOrganizacion(envioAlimento.Destino.OrganizacionID).FirstOrDefault(); oSolicitud.FechaEntrega = envioAlimento.FechaEnvio; oSolicitud.UsuarioCreacionID = envioAlimento.UsuarioCreacionID; oSolicitud.Detalle = new List <SolicitudProductoDetalleInfo>(); SolicitudProductoDetalleInfo detalle = new SolicitudProductoDetalleInfo() { Cantidad = envioAlimento.Cantidad, PrecioPromedio = envioAlimento.Producto.ManejaLote ? envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio: envioAlimento.AlmacenInventario.PrecioPromedio, Producto = envioAlimento.Producto }; detalle.PrecioPromedio = decimal.Round(detalle.PrecioPromedio, 2); if (detalle.PrecioPromedio == 0) { detalle.PrecioPromedio = precioPromedioInicial; } oSolicitud.Detalle.Add(detalle); listaPolizas = poliza.GeneraPoliza(oSolicitud); var polizaDAL = new PolizaDAL(); if (listaPolizas != null && listaPolizas.Any()) { string Referencia = "03 " + envioAlimento.Folio.ToString() + new Random().Next(10, 20).ToString() + new Random().Next(30, 40) + DateTime.Now.Millisecond.ToString() + listaPolizas.ToList().FirstOrDefault().ClaseDocumento; listaPolizas.ToList().ForEach(datos => { datos.NumeroReferencia = envioAlimento.Folio.ToString(); datos.OrganizacionID = oSolicitud.OrganizacionID; datos.UsuarioCreacionID = envioAlimento.UsuarioCreacionID; datos.Activo = EstatusEnum.Activo; datos.ArchivoEnviadoServidor = 1; datos.Referencia3 = Referencia; }); ParametroOrganizacionInfo oParametroOrg = new ParametroOrganizacionBL().ObtenerPorOrganizacionIDClaveParametro(oSolicitud.OrganizacionID, ParametrosEnum.CuentaInventarioTransito.ToString()); if (oParametroOrg != null) { listaPolizas[listaPolizas.ToList().FindIndex(datos => datos.NumeroLinea.Trim() == "1")].Cuenta = oParametroOrg.Valor; } envioAlimento.Poliza = poliza.ImprimePoliza(oSolicitud, listaPolizas); polizaDAL.CrearServicioPI(listaPolizas, TipoPoliza.SalidaTraspaso); transaccion.Complete(); } } return(envioAlimento); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Guarda los datos para un gasto materia prima /// </summary> /// <param name="gasto"></param> /// <returns></returns> internal long Guardar(GastoMateriaPrimaInfo gasto) { long folioGasto = 0; try { Logger.Info(); IList <PolizaInfo> polizas; PolizaAbstract poliza; using (var transaction = new TransactionScope()) { var tipoOrg = gasto.Organizacion.TipoOrganizacion.TipoOrganizacionID; var gastoMateriaPrimaDal = new GastoMateriaPrimaDAL(); if (gasto.GuardaAretes) { gastoMateriaPrimaDal.GuardarAretes(gasto); } if (tipoOrg == TipoOrganizacion.Centro.GetHashCode() || tipoOrg == TipoOrganizacion.Cadis.GetHashCode() || tipoOrg == TipoOrganizacion.Descanso.GetHashCode()) { #region CENTROS gasto.TipoFolio = TipoFolio.GastoMateriaPrima; gasto.AlmacenMovimientoID = null; folioGasto = gastoMateriaPrimaDal.Guardar(gasto); #endregion CENTROS } else { #region SIAP #region MOVIMIENTOS var listaAlmacenDetalle = new List <AlmacenMovimientoDetalle>(); var almacenMovimiento = new AlmacenMovimientoInfo { AlmacenID = gasto.AlmacenID, TipoMovimientoID = gasto.TipoMovimiento.TipoMovimientoID, ProveedorId = gasto.Proveedor.ProveedorID, Observaciones = gasto.Observaciones, Status = (int)EstatusInventario.Aplicado, UsuarioCreacionID = gasto.UsuarioCreacionID }; var almacenMovimientoBl = new AlmacenMovimientoBL(); var almacenMovimientoID = almacenMovimientoBl.Crear(almacenMovimiento); gasto.AlmacenMovimientoID = almacenMovimientoID; var almacenMovimientoDetalle = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, ProductoID = gasto.Producto.ProductoId, UsuarioCreacionID = gasto.UsuarioCreacionID, Importe = gasto.Importe, Cantidad = 0, Precio = 0 }; if (gasto.UnidadMedida) { almacenMovimientoDetalle.Cantidad = gasto.Kilogramos; if (gasto.Kilogramos > 0) { almacenMovimientoDetalle.Precio = gasto.Importe / gasto.Kilogramos; } else { almacenMovimientoDetalle.Precio = 0; } } gasto.TipoFolio = TipoFolio.GastoMateriaPrima; int gastoMateriaPrimaID = gastoMateriaPrimaDal.Guardar(gasto); //Actualizamos en AlmacenInventarioLote if (gasto.AlmacenInventarioLote.AlmacenInventarioLoteId != 0) { almacenMovimientoDetalle.AlmacenInventarioLoteId = gasto.AlmacenInventarioLote.AlmacenInventarioLoteId; var almacenInventarioLote = new AlmacenInventarioLoteDAL(); var almacenInventarioLoteInfo = new AlmacenInventarioLoteInfo(); almacenInventarioLoteInfo = almacenInventarioLote.ObtenerAlmacenInventarioLotePorId( gasto.AlmacenInventarioLote.AlmacenInventarioLoteId); almacenInventarioLoteInfo.UsuarioModificacionId = gasto.UsuarioCreacionID; if (gasto.TipoMovimiento.TipoMovimientoID == (int)TipoMovimiento.EntradaPorAjuste) { almacenInventarioLoteInfo.Importe += gasto.Importe; almacenInventarioLoteInfo.Cantidad += gasto.Kilogramos; } else // Salida por Ajuste { almacenInventarioLoteInfo.Importe -= gasto.Importe; almacenInventarioLoteInfo.Cantidad -= gasto.Kilogramos; } if (almacenInventarioLoteInfo.Cantidad == 0) { almacenInventarioLoteInfo.PrecioPromedio = 0; } else { almacenInventarioLoteInfo.PrecioPromedio = almacenInventarioLoteInfo.Importe / almacenInventarioLoteInfo.Cantidad; } almacenInventarioLote.Actualizar(almacenInventarioLoteInfo); } // Actualizamos en AlmacenInventario var almacenInventario = new AlmacenInventarioDAL(); var almacenInventarioInfo = new AlmacenInventarioInfo { AlmacenID = gasto.AlmacenID, ProductoID = gasto.Producto.ProductoId }; almacenInventarioInfo = almacenInventario.ObtenerPorAlmacenIdProductoId(almacenInventarioInfo); if (gasto.TipoMovimiento.TipoMovimientoID == (int)TipoMovimiento.EntradaPorAjuste) { almacenInventarioInfo.Importe += gasto.Importe; almacenInventarioInfo.Cantidad += gasto.Kilogramos; gasto.EsEntrada = true; } else // Salida por Ajuste { almacenInventarioInfo.Importe -= gasto.Importe; almacenInventarioInfo.Cantidad -= gasto.Kilogramos; } almacenInventarioInfo.UsuarioModificacionID = gasto.UsuarioCreacionID; if (almacenInventarioInfo.Cantidad == 0) { almacenInventarioInfo.PrecioPromedio = 0; } else { almacenInventarioInfo.PrecioPromedio = almacenInventarioInfo.Importe / almacenInventarioInfo.Cantidad; } almacenInventario.Actualizar(almacenInventarioInfo); listaAlmacenDetalle.Add(almacenMovimientoDetalle); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); almacenMovimientoDetalleBL.GuardarAlmacenMovimientoDetalle(listaAlmacenDetalle, almacenMovimientoID); #endregion MOVIMIENTOS #region POLIZA GastoMateriaPrimaInfo gastoMateriaGuardado = gastoMateriaPrimaDal.ObtenerPorID(gastoMateriaPrimaID); gasto.Fecha = gastoMateriaGuardado.Fecha; gasto.FolioGasto = gastoMateriaGuardado.FolioGasto; folioGasto = gastoMateriaGuardado.FolioGasto; poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.GastosMateriaPrima); polizas = poliza.GeneraPoliza(gasto); if (polizas != null && polizas.Any()) { polizas.ToList().ForEach(datos => { datos.OrganizacionID = gasto.Organizacion.OrganizacionID; datos.UsuarioCreacionID = gasto.UsuarioCreacionID; datos.ArchivoEnviadoServidor = 1; }); var polizaBL = new PolizaBL(); if (gasto.EsEntrada) { polizaBL.GuardarServicioPI(polizas, TipoPoliza.EntradaAjuste); } else { polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaAjuste); } } #endregion POLIZA #endregion SIAP } transaction.Complete(); } return(folioGasto); } catch (ExcepcionServicio ex) { Logger.Error(ex); throw; } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <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; } } }
private long GenerarMovimientoEntrada(TraspasoMpPaMedInfo info) { var almacenInventarioBL = new AlmacenInventarioBL(); var almacenInventarioLoteBL = new AlmacenInventarioLoteBL(); var almacenMovimientoBL = new AlmacenMovimientoBL(); var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL(); decimal cantidadTraspaso = info.CantidadTraspasarDestino; decimal precioPromedio = 0; List <AlmacenInventarioInfo> inventariosDestino = almacenInventarioBL.ObtienePorAlmacenId(info.AlmacenDestino); if (inventariosDestino != null && inventariosDestino.Any()) { AlmacenInventarioInfo almacenInventarioDestino = inventariosDestino.FirstOrDefault(inv => inv.ProductoID == info.ProductoDestino.ProductoId); if (almacenInventarioDestino != null) { almacenInventarioDestino.Cantidad = almacenInventarioDestino.Cantidad + cantidadTraspaso; almacenInventarioDestino.Importe = almacenInventarioDestino.Importe + info.ImporteTraspaso; almacenInventarioDestino.PrecioPromedio = almacenInventarioDestino.Importe / almacenInventarioDestino.Cantidad; almacenInventarioDestino.UsuarioModificacionID = info.Usuario.UsuarioID; almacenInventarioBL.Actualizar(almacenInventarioDestino); } else { //Crear el Inventario var almacenInventarioGuardar = new AlmacenInventarioInfo { AlmacenID = info.AlmacenDestino.AlmacenID, ProductoID = info.ProductoDestino.ProductoId, Cantidad = cantidadTraspaso, Importe = info.ImporteTraspaso, PrecioPromedio = info.ImporteTraspaso / cantidadTraspaso, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenInventarioBL.Crear(almacenInventarioGuardar); } } else { //Crear el Inventario var almacenInventarioGuardar = new AlmacenInventarioInfo { AlmacenID = info.AlmacenDestino.AlmacenID, ProductoID = info.ProductoDestino.ProductoId, Cantidad = cantidadTraspaso, Importe = info.ImporteTraspaso, PrecioPromedio = info.ImporteTraspaso / cantidadTraspaso, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenInventarioBL.Crear(almacenInventarioGuardar); } if (info.LoteMpDestino.AlmacenInventarioLoteId != 0) { AlmacenInventarioLoteInfo loteDestino = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(info.LoteMpDestino.AlmacenInventarioLoteId); if (loteDestino != null) { loteDestino.Cantidad = loteDestino.Cantidad + cantidadTraspaso; loteDestino.Importe = loteDestino.Importe + info.ImporteTraspaso; loteDestino.PrecioPromedio = loteDestino.Importe / loteDestino.Cantidad; loteDestino.UsuarioModificacionId = info.Usuario.UsuarioID; almacenInventarioLoteBL.Actualizar(loteDestino); } } var almacenMovimientoDestino = new AlmacenMovimientoInfo { AlmacenID = info.AlmacenDestino.AlmacenID, TipoMovimientoID = TipoMovimiento.EntradaAlmacen.GetHashCode(), ProveedorId = info.ProveedorDestino.ProveedorID, Status = Estatus.AplicadoInv.GetHashCode(), UsuarioCreacionID = info.Usuario.UsuarioID, Observaciones = info.JustificacionDestino }; long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoDestino); precioPromedio = info.ImporteTraspaso / info.CantidadTraspasarDestino; var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle { AlmacenMovimientoID = almacenMovimientoID, //ContratoId = info.ContratoDestino.ContratoId, AlmacenInventarioLoteId = info.LoteMpDestino.AlmacenInventarioLoteId, Piezas = 0, ProductoID = info.ProductoDestino.ProductoId, Precio = precioPromedio, Cantidad = cantidadTraspaso, Importe = info.ImporteTraspaso, UsuarioCreacionID = info.Usuario.UsuarioID }; almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo); return(almacenMovimientoID); }