/// <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);
}