/// <summary>
/// Obtiene un flujo de datos
/// con la poliza de compra
/// </summary>
/// <param name="contenedorEntradaMateriaPrima"></param>
/// <param name="polizaClave"></param>
/// <returns></returns>
private MemoryStream ReimpresionPolizaCompra(ContenedorEntradaMateriaPrimaInfo contenedorEntradaMateriaPrima
, TipoPolizaInfo polizaClave)
{
var polizaBL = new PolizaBL();
IList <PolizaInfo> polizasVenta = polizaBL.ObtenerPoliza(TipoPoliza.EntradaCompra,
contenedorEntradaMateriaPrima.Contrato.Organizacion.
OrganizacionID,
contenedorEntradaMateriaPrima.Contrato.Fecha
,
contenedorEntradaMateriaPrima.Contrato.Folio.
ToString(),
polizaClave.ClavePoliza, 1);
MemoryStream stream = null;
if (polizasVenta != null)
{
var entradaProductoBL = new EntradaProductoBL();
contenedorEntradaMateriaPrima =
entradaProductoBL.ObtenerPorFolioEntradaContrato(contenedorEntradaMateriaPrima.Contrato.Folio,
contenedorEntradaMateriaPrima.Contrato.ContratoId,
contenedorEntradaMateriaPrima.Contrato.Organizacion.OrganizacionID);
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaCompra);
polizasVenta = poliza.GeneraPoliza(contenedorEntradaMateriaPrima);
stream = poliza.ImprimePoliza(contenedorEntradaMateriaPrima, polizasVenta);
}
return(stream);
}
/// <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);
}
/// <summary>
/// Obtiene los valores para la reimpresion de
/// la poliza de salida por venta
/// </summary>
/// <param name="ventaGanado"></param>
/// <param name="polizaClave"> </param>
private MemoryStream ReimprimirPolizaVenta(VentaGanadoInfo ventaGanado, TipoPolizaInfo polizaClave)
{
var polizaBL = new PolizaBL();
int organizacionID = ventaGanado.Lote.OrganizacionID;
var ventaGanadoBL = new VentaGanadoBL();
List <ContenedorVentaGanado> ventasGanado =
ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(ventaGanado.FolioTicket, organizacionID);
MemoryStream pdf = null;
var tipoPoliza = TipoPoliza.SalidaVenta;
IList <PolizaInfo> polizasVenta = polizaBL.ObtenerPoliza(tipoPoliza, organizacionID,
ventaGanado.FechaVenta
, ventaGanado.FolioTicket.ToString(),
polizaClave.ClavePoliza, 1);
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
var polizaGenerada = false;
if (polizasVenta == null)
{
if (ventasGanado != null && ventasGanado.Any())
{
var animalCostoBL = new AnimalCostoBL();
var detalleVentas = new List <VentaGanadoDetalleInfo>();
ventasGanado.ForEach(det => detalleVentas.Add(det.VentaGanadoDetalle));
List <AnimalInfo> animalesGenerarPoliza = detalleVentas.Select(ani => new AnimalInfo
{
AnimalID = ani.Animal.AnimalID,
OrganizacionIDEntrada = organizacionID
}).ToList();
List <AnimalCostoInfo> animalCosto = animalCostoBL.ObtenerCostosAnimal(animalesGenerarPoliza);
if (animalCosto != null &&
!animalCosto.Any(id => id.CostoID == 1 && id.Importe == 0))
{
polizasVenta = poliza.GeneraPoliza(ventasGanado);
polizasVenta.ToList().ForEach(org => org.OrganizacionID = organizacionID);
polizaBL.GuardarServicioPI(polizasVenta, tipoPoliza);
polizaGenerada = true;
}
}
}
if (polizasVenta != null && polizasVenta.Any())
{
if (ventasGanado != null && ventasGanado.Any())
{
if (!polizaGenerada)
{
polizasVenta = poliza.GeneraPoliza(ventasGanado);
}
pdf = poliza.ImprimePoliza(ventasGanado, polizasVenta);
}
}
return(pdf);
}
/// <summary>
/// Obtiene un flujo de datos
/// para la generacion de la reimpresion
/// de la poliza de venta de producto
/// </summary>
/// <param name="salidaProductoInfo"></param>
/// <param name="polizaClave"></param>
/// <returns></returns>
private MemoryStream ReimpresionSalidaVentaProducto(SalidaProductoInfo salidaProductoInfo, TipoPolizaInfo polizaClave)
{
MemoryStream pdf = null;
var polizaBL = new PolizaBL();
IList <PolizaInfo> polizasSalidaProducto = polizaBL.ObtenerPoliza(TipoPoliza.SalidaVentaProducto,
salidaProductoInfo.Organizacion.OrganizacionID
, salidaProductoInfo.FechaSalida,
salidaProductoInfo.FolioSalida.ToString(),
polizaClave.ClavePoliza, 1);
if (polizasSalidaProducto != null && polizasSalidaProducto.Any())
{
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVentaProducto);
polizasSalidaProducto = poliza.GeneraPoliza(salidaProductoInfo);
if (polizasSalidaProducto != null && polizasSalidaProducto.Any())
{
pdf = poliza.ImprimePoliza(salidaProductoInfo, polizasSalidaProducto);
}
}
return(pdf);
}
/// <summary>
/// Actualiza la recepcion de materia prima
/// </summary>
/// <param name="listaSurtido"></param>
/// <param name="pedido"></param>
/// <returns></returns>
internal bool ActualizarRecepcionMateriaPrima(List <SurtidoPedidoInfo> listaSurtido, PedidoInfo pedido)
{
bool resultado;
try
{
Logger.Info();
var almacenInventarioBl = new AlmacenInventarioBL();
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenBl = new AlmacenBL();
var proveedorChofeBl = new ProveedorChoferBL();
int proveedorId = 0;
var pesajeMateriaPrimaBl = new PesajeMateriaPrimaBL();
int organizacionID;
PolizaAbstract poliza;
IList <PolizaInfo> polizas;
IList <ResultadoPolizaModel> resultadoPolizaModel;
var contenedorAlmacenesMovimientos = new List <ContenedorAlmacenMovimientoCierreDia>();
ContenedorAlmacenMovimientoCierreDia contenedorAlmacenMovimiento;
var surtidoGenerarPoliza = new List <SurtidoPedidoInfo>();
using (var transaction = new TransactionScope())
{
ProgramacionMateriaPrimaInfo programacionMateriaPrima;
var programacionMateriaPrimaBL = new ProgramacionMateriaPrimaBL();
foreach (var surtidoTmp in listaSurtido)
{
if (surtidoTmp.Seleccionado)
{
programacionMateriaPrima = programacionMateriaPrimaBL.
ObtenerPorProgramacionMateriaPrimaTicket(
surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId,
surtidoTmp.PesajeMateriaPrima.Ticket);
if (programacionMateriaPrima != null)
{
continue;
}
surtidoGenerarPoliza.Add(surtidoTmp);
var pesaje = pesajeMateriaPrimaBl.ObtenerPorId(surtidoTmp.PesajeMateriaPrima);
// Se consulta el proveedor del Proveedor chofer seleccionado para el pesaje.
var proveedorChofeInfo = proveedorChofeBl.ObtenerProveedorChoferPorId(
surtidoTmp.PesajeMateriaPrima.ProveedorChoferID);
if (proveedorChofeInfo != null)
{
proveedorId = proveedorChofeInfo.Proveedor.ProveedorID;
}
//SE OBTIENEN LOS DATOS DEL LOTE DESTINO
var almacenInventarioLoteDestino =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
surtidoTmp.PedidoDetalle.InventarioLoteDestino.AlmacenInventarioLoteId);
//SE OBTIENEN LOS DATOS DEL LOTE ORIGEN
var almacenInventarioLoteOrigen =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
surtidoTmp.ProgramacionMateriaPrima.InventarioLoteOrigen
.AlmacenInventarioLoteId);
#region INVENTARIO ORIGEN
// GENERA MOVIMIENTO DE INVENTARIO
var almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo
{
AlmacenID =
almacenInventarioLoteOrigen
.AlmacenInventario.
AlmacenID,
TipoMovimientoID =
(int)
TipoMovimiento.
PaseProceso,
Observaciones = "",
Status = (int)EstatusInventario.Aplicado,
AnimalMovimientoID = 0,
ProveedorId = proveedorId,
UsuarioCreacionID =
pedido.
UsuarioModificacion.
UsuarioID
});
// SE LE ASIGNA EL MOVIMIENTO GENERADO AL PESAJE
pesaje.AlmacenMovimientoOrigenId = almacenMovimiento.AlmacenMovimientoID;
contenedorAlmacenMovimiento = new ContenedorAlmacenMovimientoCierreDia
{
AlmacenMovimiento = new AlmacenMovimientoInfo
{
AlmacenMovimientoID =
almacenMovimiento.
AlmacenMovimientoID
}
};
contenedorAlmacenesMovimientos.Add(contenedorAlmacenMovimiento);
// GENERA EL DETALLE DEL MOVIMIENTO
almacenBl.GuardarAlmacenMovimientoDetalleProducto(
new AlmacenMovimientoDetalle
{
AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID,
ProductoID = surtidoTmp.Producto.ProductoId,
Precio = almacenInventarioLoteOrigen.PrecioPromedio,
Cantidad = surtidoTmp.CantidadEntregada,
Importe =
almacenInventarioLoteOrigen.PrecioPromedio * surtidoTmp.CantidadEntregada,
AlmacenInventarioLoteId =
almacenInventarioLoteOrigen.AlmacenInventarioLoteId,
ContratoId = 0,
Piezas = surtidoTmp.PesajeMateriaPrima.Piezas,
UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID
});
// GENERA LA SALIDA DEL INVENTARIO LOTE
almacenInventarioLoteOrigen.Cantidad -= surtidoTmp.CantidadEntregada;
almacenInventarioLoteOrigen.Piezas -= surtidoTmp.PesajeMateriaPrima.Piezas;
almacenInventarioLoteOrigen.Importe = almacenInventarioLoteOrigen.PrecioPromedio *
almacenInventarioLoteOrigen.Cantidad;
almacenInventarioLoteOrigen.UsuarioModificacionId =
pedido.UsuarioModificacion.UsuarioID;
almacenInventarioLoteBl.Actualizar(almacenInventarioLoteOrigen);
// GENERA LA SALIDA DEL ALMACEN INVENTARIO
var almacenInventarioInfo =
almacenInventarioBl.ObtenerAlmacenInventarioPorId(
almacenInventarioLoteOrigen.AlmacenInventario.AlmacenInventarioID);
almacenInventarioInfo.Cantidad = almacenInventarioInfo.Cantidad -
surtidoTmp.CantidadEntregada;
almacenInventarioInfo.Importe = almacenInventarioInfo.PrecioPromedio *
almacenInventarioInfo.Cantidad;
almacenInventarioInfo.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
almacenInventarioBl.Actualizar(almacenInventarioInfo);
#endregion
#region INVENTARIO DESTINO
//Obtener costos de flete
var fleteInternoPl = new FleteInternoPL();
var listadoCostos = fleteInternoPl.ObtenerCostosPorFleteConfiguracion(new FleteInternoInfo
{
Organizacion =
new OrganizacionInfo {
OrganizacionID = pedido.Organizacion.OrganizacionID
},
AlmacenOrigen = new AlmacenInfo {
AlmacenID = almacenInventarioLoteOrigen.AlmacenInventario.AlmacenID
},
Producto = new ProductoInfo {
ProductoId = surtidoTmp.Producto.ProductoId
}
}, new ProveedorInfo {
ProveedorID = surtidoTmp.Proveedor.ProveedorID
});
decimal importeCostos = 0;
if (listadoCostos != null)
{
foreach (var fleteInternoCostoInfo in listadoCostos)
{
if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode())
{
importeCostos += fleteInternoCostoInfo.Tarifa;
}
else
{
importeCostos += (surtidoTmp.CantidadEntregada / 1000) *
fleteInternoCostoInfo.Tarifa;
}
}
//importeCostos = listadoCostos.Sum(fleteInternoCostoInfo => fleteInternoCostoInfo.Tarifa);
}
almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo
{
AlmacenID =
almacenInventarioLoteDestino
.AlmacenInventario.
AlmacenID,
TipoMovimientoID =
(int)
TipoMovimiento.
RecepcionAProceso,
Observaciones =
pedido.Observaciones,
Status = (int)EstatusInventario.Aplicado,
AnimalMovimientoID = 0,
ProveedorId = proveedorId,
UsuarioCreacionID =
pedido.
UsuarioModificacion.
UsuarioID
});
// SE LE ASIGNA EL MOVIMIENTO AL PESAJE
pesaje.AlmacenMovimientoDestinoId = almacenMovimiento.AlmacenMovimientoID;
// GENERA LA ENTRADA DEL INVENTARIO LOTE
almacenInventarioLoteDestino.Piezas += surtidoTmp.PesajeMateriaPrima.Piezas;
decimal importe = surtidoTmp.CantidadEntregada *
almacenInventarioLoteOrigen.PrecioPromedio;
almacenInventarioLoteDestino.Importe += importe;
almacenInventarioLoteDestino.Cantidad += surtidoTmp.CantidadEntregada;
almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe /
almacenInventarioLoteDestino.Cantidad;
almacenInventarioLoteDestino.UsuarioModificacionId =
pedido.UsuarioModificacion.UsuarioID;
//
//Se agregan los costos al importe del lote
//importeCostos = importeCostos * surtidoTmp.CantidadEntregada;
almacenInventarioLoteDestino.Importe = almacenInventarioLoteDestino.Importe + importeCostos;
almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe /
almacenInventarioLoteDestino.Cantidad;
//
almacenInventarioLoteBl.Actualizar(almacenInventarioLoteDestino);
// GENERA EL DETALLE DEL MOVIMIENTO
almacenBl.GuardarAlmacenMovimientoDetalleProducto(
new AlmacenMovimientoDetalle
{
AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID,
ProductoID = surtidoTmp.Producto.ProductoId,
Precio = almacenInventarioLoteOrigen.PrecioPromedio,
Cantidad = surtidoTmp.CantidadEntregada,
Importe = importe,
AlmacenInventarioLoteId =
almacenInventarioLoteDestino.AlmacenInventarioLoteId,
ContratoId = 0,
Piezas = surtidoTmp.PesajeMateriaPrima.Piezas,
UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID
});
//Guarda almacen movimiento costo
if (listadoCostos != null)
{
foreach (var fleteInternoCostoInfo in listadoCostos)
{
var almacenMovimientoCosto = new AlmacenMovimientoCostoBL();
decimal importeCostoFlete = 0;
if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode())
{
importeCostoFlete = fleteInternoCostoInfo.Tarifa;
}
else
{
importeCostoFlete = (surtidoTmp.CantidadEntregada / 1000) *
fleteInternoCostoInfo.Tarifa;
}
almacenMovimientoCosto.Crear(new AlmacenMovimientoCostoInfo
{
AlmacenMovimientoId = almacenMovimiento.AlmacenMovimientoID,
ProveedorId = surtidoTmp.Proveedor.ProveedorID,
CostoId = fleteInternoCostoInfo.Costo.CostoID,
Importe = importeCostoFlete,
Cantidad = surtidoTmp.CantidadEntregada,
Activo = EstatusEnum.Activo,
UsuarioCreacionId = pedido.UsuarioModificacion.UsuarioID
});
}
}
//
programacionMateriaPrimaBL.ActualizarAlmacenMovimiento(
surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId,
almacenMovimiento.AlmacenMovimientoID);
// GENERA LA ENTRADA DEL ALMACEN INVENTARIO
almacenInventarioInfo =
almacenInventarioBl.ObtenerAlmacenInventarioPorId(
almacenInventarioLoteDestino.AlmacenInventario.AlmacenInventarioID);
List <AlmacenInventarioLoteInfo> listaAlmacenInventarioLote =
almacenInventarioLoteBl.ObtenerPorAlmacenInventarioID(almacenInventarioInfo);
var almacenInventario = new AlmacenInventarioInfo();
almacenInventario.AlmacenInventarioID = almacenInventarioInfo.AlmacenInventarioID;
// SE SUMAN LAS CANTIDADES E IMPORTES QUE TIENE EL ALMACEN
foreach (var almacenInventarioLoteInfo in listaAlmacenInventarioLote)
{
almacenInventario.Cantidad += almacenInventarioLoteInfo.Cantidad;
almacenInventario.Importe += almacenInventarioLoteInfo.Importe;
}
almacenInventario.PrecioPromedio = almacenInventario.Importe /
almacenInventario.Cantidad;
almacenInventario.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
almacenInventario.ProductoID = surtidoTmp.Producto.ProductoId;
almacenInventario.AlmacenID =
almacenInventarioLoteDestino.AlmacenInventario.AlmacenID;
almacenInventarioBl.ActualizarPorProductoId(almacenInventario);
#endregion
// SE ACTUALIZA EL PESAJE DE MATERIA PRIMA
pesaje.EstatusID = (int)Estatus.PedidoCompletado;
pesaje.Activo = false;
pesaje.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
pesajeMateriaPrimaBl.ActualizarPesajePorId(pesaje);
}
}
#region POLIZA
organizacionID = pedido.Organizacion.OrganizacionID;
string lotes = ObtenerXMLLote(listaSurtido);
var pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL();
List <PolizaPaseProcesoModel> datosPoliza =
pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProceso(pedido.FolioPedido, organizacionID,
lotes);
if (datosPoliza != null)
{
datosPoliza = (from dp in datosPoliza
from ls in surtidoGenerarPoliza
where dp.Proveedor.ProveedorID == ls.Proveedor.ProveedorID &&
dp.Producto.ProductoId == ls.Producto.ProductoId &&
dp.PesajeMateriaPrima.Ticket == ls.PesajeMateriaPrima.Ticket
select dp).ToList();
}
if (datosPoliza != null && datosPoliza.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso);
IList <PolizaPaseProcesoModel> polizasPaseProcesoModel;
resultadoPolizaModel = new List <ResultadoPolizaModel>();
datosPoliza =
datosPoliza.GroupBy(prod => new { prod.Producto, prod.ProveedorChofer, prod.PesajeMateriaPrima.Ticket })
.Select(grupo => new PolizaPaseProcesoModel
{
Organizacion = grupo.Select(org => org.Organizacion).FirstOrDefault(),
Almacen = grupo.Select(alm => alm.Almacen).FirstOrDefault(),
Producto = grupo.Key.Producto,
Proveedor = grupo.Select(prov => prov.Proveedor).FirstOrDefault(),
AlmacenMovimiento = grupo.Select(alm => alm.AlmacenMovimiento).FirstOrDefault(),
AlmacenMovimientoDetalle = grupo.Select(alm => alm.AlmacenMovimientoDetalle).FirstOrDefault(),
AlmacenInventarioLote = grupo.Select(alm => alm.AlmacenInventarioLote).FirstOrDefault(),
FleteInterno = grupo.Select(flete => flete.FleteInterno).FirstOrDefault(),
FleteInternoCosto = grupo.Select(flete => flete.FleteInternoCosto).FirstOrDefault(),
Pedido = grupo.Select(ped => ped.Pedido).FirstOrDefault(),
ProveedorChofer = grupo.Key.ProveedorChofer,
PesajeMateriaPrima = grupo.Select(pesaje => pesaje.PesajeMateriaPrima).FirstOrDefault(),
ProgramacionMateriaPrima = grupo.Select(prog => prog.ProgramacionMateriaPrima).FirstOrDefault(),
ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).FirstOrDefault(),
}).ToList();
IList <PolizaInfo> polizaExistente;
var polizaBL = new PolizaBL();
for (var indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++)
{
polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> {
datosPoliza[indexPoliza]
};
polizas = poliza.GeneraPoliza(polizasPaseProcesoModel);
if (polizas != null)
{
var resultadoPoliza = new ResultadoPolizaModel
{
Polizas = polizas
};
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID = organizacionID;
datos.UsuarioCreacionID =
pedido.UsuarioModificacion.UsuarioID;
datos.ArchivoEnviadoServidor = 1;
});
polizaExistente = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso, organizacionID,
pedido.FechaPedido,
string.Format("{0}-{1}", pedido.FolioPedido,
datosPoliza[indexPoliza].
PesajeMateriaPrima.Ticket),
"PP", 1);
if (polizaExistente != null && polizaExistente.Any())
{
List <PolizaInfo> excluir = (from existente in polizaExistente
join guardar in polizas on existente.Concepto equals guardar.Concepto
select guardar).ToList();
polizas = polizas.Except(excluir).ToList();
}
if (polizas.Any())
{
polizaBL.GuardarServicioPI(polizas, TipoPoliza.PaseProceso);
resultadoPolizaModel.Add(resultadoPoliza);
}
}
}
var almacenMovimientoBL = new AlmacenMovimientoBL();
contenedorAlmacenesMovimientos.ForEach(alm => alm.Almacen = new AlmacenInfo
{
UsuarioModificacionID =
pedido.
UsuarioModificacion.
UsuarioID
});
almacenMovimientoBL.ActualizarGeneracionPoliza(contenedorAlmacenesMovimientos);
}
#endregion POLIZA
transaction.Complete();
resultado = true;
}
}
catch (ExcepcionGenerica exg)
{
resultado = false;
Logger.Error(exg);
}
catch (Exception ex)
{
resultado = false;
Logger.Error(ex);
}
return(resultado);
}
/// <summary>
/// Se 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>
/// Obtiene los valores para la reimpresion de
/// la poliza de entrada de ganado
/// </summary>
/// <param name="entradaGanado"></param>
/// <param name="polizaClave"> </param>
private MemoryStream ReimprimirPolizaEntrada(EntradaGanadoInfo entradaGanado, TipoPolizaInfo polizaClave)
{
EntradaGanadoCosteoInfo entradaGanadoCosteo;
var esGanadera = false;
var entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();
if (entradaGanado.TipoOrigen == TipoOrganizacion.Ganadera.GetHashCode())
{
var interfaceSalidaTraspasoBL = new InterfaceSalidaTraspasoBL();
entradaGanadoCosteo =
interfaceSalidaTraspasoBL.ObtenerDatosInterfaceSalidaTraspaso(entradaGanado.OrganizacionID, entradaGanado.FolioOrigen);
esGanadera = true;
EntradaGanadoCosteoInfo entradaGanadoCosteoComplementoCostos
= entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaGanado.EntradaGanadoID);
entradaGanadoCosteo.ListaCostoEntrada.AddRange(entradaGanadoCosteoComplementoCostos.ListaCostoEntrada.Where(id => id.Costo.CostoID != 1));
}
else
{
entradaGanadoCosteo = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaGanado.EntradaGanadoID);
}
MemoryStream pdf = null;
if (entradaGanadoCosteo != null)
{
if (!esGanadera)
{
var cuentaPL = new CuentaBL();
const string CUENTA_INVENTARIO = "CTAINVTRAN";
entradaGanadoCosteo.ListaCostoEntrada.ForEach(costo =>
{
if (!string.IsNullOrWhiteSpace(costo.DescripcionCuenta))
{
return;
}
var claveContable = cuentaPL.ObtenerPorClaveCuentaOrganizacion(CUENTA_INVENTARIO,
entradaGanado.OrganizacionOrigenID);
if (claveContable != null)
{
costo.DescripcionCuenta = claveContable.Descripcion;
}
});
}
var contenedorCosteoEntrada = new ContenedorCosteoEntradaGanadoInfo
{
EntradaGanado = entradaGanado,
EntradaGanadoCosteo = entradaGanadoCosteo
};
PolizaAbstract poliza;
var tipoPoliza = esGanadera ? TipoPoliza.EntradaGanadoDurango : TipoPoliza.EntradaGanado;
if (esGanadera)
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
}
else
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
}
var polizaBL = new PolizaBL();
int organizacionID = entradaGanado.OrganizacionID;
IList <PolizaInfo> polizasEntrada = polizaBL.ObtenerPoliza(tipoPoliza, organizacionID,
entradaGanado.FechaEntrada,
entradaGanado.FolioEntrada.ToString(),
polizaClave.ClavePoliza, 1);
if (polizasEntrada != null)
{
polizasEntrada = poliza.GeneraPoliza(contenedorCosteoEntrada);
pdf = poliza.ImprimePoliza(contenedorCosteoEntrada, polizasEntrada);
}
}
return(pdf);
}
/// <summary>
/// Obtiene los valores para la reimpresion de
/// la poliza de Salida por Muerte
/// </summary>
/// <param name="animal"></param>
/// <param name="fecha"></param>
/// <param name="polizaClave"> </param>
private MemoryStream ReimprimirPolizaMuerte(AnimalInfo animal, DateTime fecha
, TipoPolizaInfo polizaClave)
{
MemoryStream pdf = null;
var animalCostoBL = new AnimalCostoBL();
var animalesGenerarPoliza = new List <AnimalInfo> {
animal
};
List <AnimalCostoInfo> animalCosto = animalCostoBL.ObtenerCostosAnimal(animalesGenerarPoliza);
var animalCostoAgrupado = (from costo in animalCosto
group costo by new { costo.AnimalID, costo.CostoID }
into agrupado
select new AnimalCostoInfo
{
AnimalID = agrupado.Key.AnimalID,
CostoID = agrupado.Key.CostoID,
Importe = agrupado.Sum(cos => cos.Importe),
FolioReferencia =
agrupado.Select(cos => cos.FolioReferencia).FirstOrDefault(),
FechaCosto = agrupado.Select(cos => cos.FechaCosto).FirstOrDefault()
}).ToList();
animalCosto = animalCostoAgrupado;
if (animalCosto.Any())
{
int organizacionID = animal.OrganizacionIDEntrada;
int usuarioID = animal.UsuarioCreacionID;
animalCosto.ForEach(org =>
{
org.OrganizacionID = organizacionID;
org.UsuarioCreacionID = usuarioID;
});
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerte);
var polizaBL = new PolizaBL();
for (int indexAnimal = 0; indexAnimal < animalesGenerarPoliza.Count; indexAnimal++)
{
IList <PolizaInfo> polizaSalidaMuerte = polizaBL.ObtenerPoliza(TipoPoliza.SalidaMuerte,
organizacionID,
fecha,
animalesGenerarPoliza[indexAnimal].
AnimalID.ToString(),
polizaClave.ClavePoliza, 1);
animalCosto =
animalCosto.Where(id => id.AnimalID == animalesGenerarPoliza[indexAnimal].AnimalID).ToList();
if (animalCosto.Any())
{
animalCosto.ForEach(ani => ani.Arete = animalesGenerarPoliza[indexAnimal].Arete);
}
if (polizaSalidaMuerte == null)
{
if (animalCosto.Any(id => id.CostoID == 1))
{
organizacionID = animal.OrganizacionIDEntrada;
polizaSalidaMuerte = poliza.GeneraPoliza(animalCosto);
polizaSalidaMuerte.ToList().ForEach(datos =>
{
datos.OrganizacionID = organizacionID;
datos.UsuarioCreacionID = usuarioID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizaSalidaMuerte, TipoPoliza.SalidaMuerte);
}
}
else
{
polizaSalidaMuerte = poliza.GeneraPoliza(animalCosto);
}
if ((polizaSalidaMuerte != null && polizaSalidaMuerte.Any()) &&
animalCosto.Any(id => id.CostoID == 1))
{
pdf = poliza.ImprimePoliza(animalCosto, polizaSalidaMuerte);
}
}
}
return(pdf);
}
internal MemoryStream Guardar(MuertesEnTransitoInfo muerteEnTransito, List <AnimalInfo> animales)
{
MemoryStream retorno = null;
try
{
Logger.Info();
PolizaAbstract poliza;
IList <PolizaInfo> polizaMuerteEnTransito;
var entradaGanadoMuerteLista = new List <EntradaGanadoMuerteInfo>();
using (var transaction = new TransactionScope())
{
var fecha = DateTime.Now;
int organizacionID = muerteEnTransito.OrganizacionID;
int usuarioCreacionID = muerteEnTransito.UsuarioCreacionID;
int pesoAnimal = 0;
int corralID = 0;
int loteID = 0;
var datosInterface = false;
List <InterfaceSalidaAnimalInfo> interfaceSalidaAnimal = null;
var entradaGanadoBL = new EntradaGanadoBL();
EntradaGanadoInfo entradaGanado = entradaGanadoBL.ObtenerPorID(muerteEnTransito.EntradaGanadoID);
if (entradaGanado != null)
{
loteID = entradaGanado.LoteID;
corralID = entradaGanado.CorralID;
if (entradaGanado.FolioOrigen > 0)
{
var interfaceSalidaBL = new InterfaceSalidaAnimalBL();
interfaceSalidaAnimal =
interfaceSalidaBL.ObtenerInterfazSalidaAnimal(entradaGanado.FolioOrigen,
entradaGanado.OrganizacionOrigenID);
if (interfaceSalidaAnimal == null || interfaceSalidaAnimal.Count <= 0)
{
fecha = entradaGanado.FechaEntrada;
pesoAnimal = Convert.ToInt32((entradaGanado.PesoBruto - entradaGanado.PesoTara) /
entradaGanado.CabezasRecibidas);
}
else
{
datosInterface = true;
}
}
else
{
pesoAnimal = Convert.ToInt32((entradaGanado.PesoBruto - entradaGanado.PesoTara) /
entradaGanado.CabezasRecibidas);
}
}
// Generamos el Folio
FolioBL folioBL = new FolioBL();
var folioMuerte = folioBL.ObtenerFolio(organizacionID, TipoFolio.MuertesEnTransito);
foreach (var animal in animales)
{
if (datosInterface)
{
pesoAnimal = interfaceSalidaAnimal.Where(
are => are.Arete.Equals(animal.Arete)).Select(
peso => Convert.ToInt32(peso.PesoCompra)).FirstOrDefault();
}
if (datosInterface)
{
fecha =
interfaceSalidaAnimal.Where(arete => arete.Arete.Equals(animal.Arete)).Select(
fechaItz => fechaItz.FechaCompra).FirstOrDefault();
}
if (fecha == new DateTime(1, 1, 1))
{
fecha = DateTime.Now;
}
animal.OrganizacionIDEntrada = organizacionID;
animal.FolioEntrada = muerteEnTransito.FolioEntrada;
animal.UsuarioCreacionID = usuarioCreacionID;
animal.ClasificacionGanadoID = 1;
animal.CalidadGanadoID = 1;
animal.TipoGanadoID = 1;
animal.FechaCompra = fecha;
animal.PesoCompra = pesoAnimal;
animal.Activo = false;
}
//Guardamos los Animales
var animalBL = new AnimalBL();
animalBL.GuardarAnimal(animales);
//Obtenemos los animales almacenados con su
animales = animalBL.ObtenerPorArete(animales);
foreach (AnimalInfo animal in animales)
{
animal.UsuarioCreacionID = usuarioCreacionID;
}
//Genera los costos por animal
animales = animalBL.ProcesoGenerarCostos(animales);
foreach (AnimalInfo animal in animales)
{
var entradaGanadoMuerte = new EntradaGanadoMuerteInfo
{
EntradaGanado =
new EntradaGanadoInfo
{
EntradaGanadoID =
muerteEnTransito.EntradaGanadoID,
},
Animal = new AnimalInfo {
Arete = animal.Arete
},
FolioMuerte = folioMuerte,
Activo = EstatusEnum.Activo,
UsuarioCreacionID = usuarioCreacionID,
Peso = animal.PesoCompra,
EntradaGanadMuerteDetalle = new List <EntradaGanadoMuerteDetalleInfo>(),
ProveedorFletes = new ProveedorInfo()
{
CodigoSAP = muerteEnTransito.CodigoProveedor
},
Cliente = new ClienteInfo()
{
CodigoSAP = muerteEnTransito.Cliente.CodigoSAP, Descripcion = muerteEnTransito.Cliente.Descripcion
},
OrganizacionDestinoID = entradaGanado.OrganizacionID
};
if (animal.ListaCostosAnimal != null)
{
entradaGanadoMuerte.EntradaGanadMuerteDetalle =
animal.ListaCostosAnimal.Select(im => new EntradaGanadoMuerteDetalleInfo
{
Costo = new CostoInfo
{
CostoID = im.CostoID
},
Importe = im.Importe,
EntradaGanadoMuerte = entradaGanadoMuerte
}).ToList();
}
entradaGanadoMuerteLista.Add(entradaGanadoMuerte);
}
if (interfaceSalidaAnimal != null && interfaceSalidaAnimal.Count > 0 && animales != null && animales.Count > 0)
{
var interfaceSalidaBL = new InterfaceSalidaAnimalBL();
foreach (AnimalInfo animal in animales)
{
InterfaceSalidaAnimalInfo interfaceSalidaAnimalIndividual = interfaceSalidaAnimal.FirstOrDefault(animalInfo => animalInfo.Arete.Equals(animal.Arete));
interfaceSalidaBL.GuardarAnimalID(interfaceSalidaAnimalIndividual, animal.AnimalID);
}
}
//Asignamos el AnimalID en la lista de muertes ante sde guardar.
foreach (EntradaGanadoMuerteInfo muerte in entradaGanadoMuerteLista)
{
muerte.Animal.AnimalID = animales.Where(animal => animal.Arete.Equals(muerte.Animal.Arete))
.Select(animal => animal.AnimalID).FirstOrDefault();
muerte.Peso = animales.Where(animal => animal.Arete.Equals(muerte.Animal.Arete))
.Select(animal => animal.PesoCompra).FirstOrDefault();
}
//Guardamos las muertes en transito
var muertesEnTransitoDal = new MuertesEnTransitoDAL();
muertesEnTransitoDal.Guardar(entradaGanadoMuerteLista, muerteEnTransito.Cliente);
//Creamos los movimientos para el animal
if (animales != null && animales.Any())
{
fecha = DateTime.Now;
var animalMovimientoBL = new AnimalMovimientoBL();
List <AnimalMovimientoInfo> movimientosAnimal = animales.Select(ani =>
new AnimalMovimientoInfo
{
AnimalID = ani.AnimalID,
Activo = EstatusEnum.Activo,
CorralID = corralID,
LoteID = loteID,
FechaMovimiento = fecha,
OrganizacionID = organizacionID,
TipoMovimientoID = TipoMovimiento.MuerteTransito.GetHashCode(),
OperadorID = 1,
TrampaID = 1,
Peso = ani.PesoCompra,
UsuarioCreacionID = usuarioCreacionID,
}).ToList();
animalMovimientoBL.GuardarAnimalMovimientoXML(movimientosAnimal);
}
//Afectamos el lote correspondiente.
var loteBl = new LoteBL();
var loteInfo = loteBl.ObtenerPorID(muerteEnTransito.LoteID);
loteInfo.UsuarioModificacionID = muerteEnTransito.UsuarioCreacionID;
loteInfo.Cabezas -= muerteEnTransito.MuertesTransito;
var filtro = new FiltroActualizarCabezasLote
{
CabezasProcesadas = muerteEnTransito.MuertesTransito,
LoteIDDestino = 0,
LoteIDOrigen = loteInfo.LoteID,
UsuarioModificacionID = usuarioCreacionID
};
var cabezasActualizadas = loteBl.ActualizarCabezasProcesadas(filtro);
//Executamos el SP CorteGanado_CierrePartidaPesoOrigenLLegada(Antes-->CorteGanado_PesoCompraDirecta), si se inactiva el lote.
if (cabezasActualizadas.CabezasOrigen <= 0)
{
//muertesEnTransitoDal.CorteGanado_PesoCompraDirecta(muerteEnTransito.OrganizacionID, muerteEnTransito.CorralID, muerteEnTransito.LoteID);
var corteGanadoBl = new CorteGanadoBL();
corteGanadoBl.ObtenerPesosOrigenLlegada(muerteEnTransito.OrganizacionID,
muerteEnTransito.CorralID,
muerteEnTransito.LoteID);
}
#region Poliza
//VentaGanadoBL ventaGanadoBL = new VentaGanadoBL();
//List<EntradaGanadoMuerteInfo> ventasGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(folio, organizacionID);
//if (ventasGanado != null && ventasGanado.Any())
if (entradaGanadoMuerteLista != null && entradaGanadoMuerteLista.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PolizaMuerteTransito);
polizaMuerteEnTransito = poliza.GeneraPoliza(entradaGanadoMuerteLista);
if (polizaMuerteEnTransito != null && polizaMuerteEnTransito.Any())
{
polizaMuerteEnTransito.ToList().ForEach(
org =>
{
org.OrganizacionID = organizacionID;
org.UsuarioCreacionID = usuarioCreacionID;
org.ArchivoEnviadoServidor = 1;
});
entradaGanadoMuerteLista.ToList().ForEach(org =>
{
org.EntradaGanado.Lote = entradaGanado.Lote;
org.EntradaGanado.CodigoCorral = entradaGanado.CodigoCorral;
});
retorno = poliza.ImprimePoliza(entradaGanadoMuerteLista, polizaMuerteEnTransito);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaMuerteEnTransito, TipoPoliza.PolizaMuerteTransito);
}
}
// Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaMuertesEnTransito(folioMuerte, organizacionID);
#endregion Poliza
animalBL.EnviarAHistorico(animales);
transaction.Complete();
}
return(retorno);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para actualizar los ajustes de inventario contenidos en el grid
/// </summary>
/// <param name="articulosDiferenciasInventario"></param>
/// <param name="almacenMovimientoInfo"></param>
/// <returns></returns>
public IList <ResultadoPolizaModel> GuardarAjusteDeInventario(List <AjusteDeInventarioDiferenciasInventarioInfo> articulosDiferenciasInventario, AlmacenMovimientoInfo almacenMovimientoInfo)
{
try
{
var resultadosPolizaModel = new List <ResultadoPolizaModel>();
PolizaAbstract poliza = null;
var cierreDiaInventarioDAL = new CierreDiaInventarioDAL();
var almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL();
var articulosEntrada = new List <AjusteDeInventarioDiferenciasInventarioInfo>();
var articulosSalida = new List <AjusteDeInventarioDiferenciasInventarioInfo>();
using (var transaction = new TransactionScope())
{
Logger.Info();
if (articulosDiferenciasInventario != null)
{
var seleccionados =
articulosDiferenciasInventario.Any(articulosComprobar => articulosComprobar.Seleccionado);
if (seleccionados)
{
foreach (var articulos in articulosDiferenciasInventario.Where(art => art.Seleccionado))
{
ActualizarArticulosDiferencias(articulos, almacenMovimientoInfo);
}
almacenMovimientoInfo.Status = (int)EstatusInventario.Aplicado;
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
articulosEntrada =
articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad > 0)).
ToList();
articulosSalida =
articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad < 0)).
ToList();
//Generar los Movimientos de Entrada y Salida
#region Movimientos Entrada
if (articulosEntrada.Any())
{
var movimientoEntrada = new AlmacenCierreDiaInventarioInfo
{
Almacen = almacenMovimientoInfo.Almacen,
TipoMovimiento =
TipoMovimiento.EntradaPorAjuste.GetHashCode(),
Observaciones = almacenMovimientoInfo.Observaciones,
Estatus = EstatusInventario.Autorizado.GetHashCode(),
UsuarioCreacionId =
almacenMovimientoInfo.UsuarioModificacionID
};
var movimientosEntrada = (from detalle in articulosEntrada
select new AlmacenMovimientoDetalle
{
ProductoID = detalle.ProductoID,
Precio = detalle.Precio,
Cantidad = Math.Abs(detalle.Cantidad),
Importe =
Math.Round(
Convert.ToDecimal(
Math.Abs(detalle.Cantidad)) *
detalle.Precio, 2),
UsuarioCreacionID =
almacenMovimientoInfo.UsuarioModificacionID
}).ToList();
AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoEntrada);
almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosEntrada,
resultadoAlmacenMovimiento.
AlmacenMovimientoID);
}
#endregion Movimientos Entrada
#region Movimientos Salida
if (articulosSalida.Any())
{
var movimientoSalida = new AlmacenCierreDiaInventarioInfo
{
Almacen = almacenMovimientoInfo.Almacen,
TipoMovimiento =
TipoMovimiento.SalidaPorAjuste.GetHashCode(),
Observaciones = almacenMovimientoInfo.Observaciones,
Estatus = EstatusInventario.Autorizado.GetHashCode(),
UsuarioCreacionId =
almacenMovimientoInfo.UsuarioModificacionID
};
var movimientosSalida = (from detalle in articulosSalida
select new AlmacenMovimientoDetalle
{
ProductoID = detalle.ProductoID,
Precio = detalle.Precio,
Cantidad = Math.Abs(detalle.Cantidad),
Importe =
Math.Round(
Convert.ToDecimal(
Math.Abs(detalle.Cantidad)) *
detalle.Precio, 2),
UsuarioCreacionID =
almacenMovimientoInfo.UsuarioModificacionID
}).ToList();
AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoSalida);
almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosSalida,
resultadoAlmacenMovimiento.
AlmacenMovimientoID);
}
#endregion Movimientos Entrada
}
else
{
almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado;
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
}
#region POLIZA
#region PolizaSalida
MemoryStream stream;
if (articulosSalida.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaAjuste);
List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
articulosSalida.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
{
Importe = Math.Abs(ajuste.Importe),
Cantidad = Math.Abs(ajuste.Cantidad),
TipoAjuste = TipoAjusteEnum.Merma,
Precio = ajuste.Precio,
AlmacenInventarioID =
ajuste.AlmacenInventarioID,
AlmacenMovimientoDetalleID =
ajuste.AlmacenMovimientoDetalleID,
ProductoID = ajuste.ProductoID,
CantidadInventarioFisico =
ajuste.CantidadInventarioFisico,
CantidadInventarioTeorico =
ajuste.CantidadInventarioTeorico,
Observaciones =
almacenMovimientoInfo.Observaciones
}).ToList();
if (salidasPorAjuste.Any())
{
IList <PolizaInfo> polizasSalida = poliza.GeneraPoliza(salidasPorAjuste);
if (polizasSalida != null)
{
stream = poliza.ImprimePoliza(salidasPorAjuste, polizasSalida);
var polizaBL = new PolizaBL();
polizasSalida.ToList().ForEach(datos =>
{
datos.UsuarioCreacionID =
almacenMovimientoInfo.
UsuarioModificacionID;
datos.OrganizacionID =
almacenMovimientoInfo.OrganizacionID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizasSalida, TipoPoliza.SalidaAjuste);
var resultadoPolizaModel = new ResultadoPolizaModel
{
Polizas = polizasSalida,
PDFs =
new Dictionary <TipoPoliza, MemoryStream>
{
{ TipoPoliza.SalidaAjuste, stream }
}
};
resultadosPolizaModel.Add(resultadoPolizaModel);
}
}
}
#endregion PolizaSalida
#region PolizaEntrada
if (articulosEntrada.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaAjuste);
List <PolizaEntradaSalidaPorAjusteModel> entradasPorAjuste =
articulosEntrada.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
{
Importe = Math.Abs(ajuste.Importe),
Cantidad = Math.Abs(ajuste.Cantidad),
TipoAjuste = TipoAjusteEnum.Merma,
Precio = ajuste.Precio,
AlmacenInventarioID =
ajuste.AlmacenInventarioID,
AlmacenMovimientoDetalleID =
ajuste.AlmacenMovimientoDetalleID,
ProductoID = ajuste.ProductoID,
CantidadInventarioFisico =
ajuste.CantidadInventarioFisico,
CantidadInventarioTeorico =
ajuste.CantidadInventarioTeorico,
Observaciones =
almacenMovimientoInfo.Observaciones
}).ToList();
if (entradasPorAjuste.Any())
{
IList <PolizaInfo> polizasEntrada = poliza.GeneraPoliza(entradasPorAjuste);
if (polizasEntrada != null)
{
stream = poliza.ImprimePoliza(entradasPorAjuste, polizasEntrada);
var polizaBL = new PolizaBL();
polizasEntrada.ToList().ForEach(datos =>
{
datos.UsuarioCreacionID =
almacenMovimientoInfo.
UsuarioModificacionID;
datos.OrganizacionID =
almacenMovimientoInfo.OrganizacionID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizasEntrada, TipoPoliza.EntradaAjuste);
var resultadoPolizaModel = new ResultadoPolizaModel
{
Polizas = polizasEntrada,
PDFs =
new Dictionary <TipoPoliza, MemoryStream>
{
{ TipoPoliza.EntradaAjuste, stream }
}
};
resultadosPolizaModel.Add(resultadoPolizaModel);
}
}
}
#endregion PolizaEntrada
#endregion POLIZA
}
else
{
almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado;
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
}
transaction.Complete();
}
return(resultadosPolizaModel);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica ex)
{
Logger.Error(ex);
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
return(null);
}
}
/// <summary>
/// Guarda los ajustes
/// </summary>
/// <param name="listaDiferenciasInventario"></param>
/// <param name="usuarioInfo"></param>
internal IList <MemoryStream> Guardar(List <DiferenciasDeInventariosInfo> listaDiferenciasInventario, UsuarioInfo usuarioInfo)
{
int usuarioId = usuarioInfo.UsuarioID;
PolizaAbstract poliza = null;
IList <PolizaInfo> polizas = null;
int organizacionID;
//var contratoCreado = new ContratoInfo();
IList <MemoryStream> streams = null;
try
{
using (var transaction = new TransactionScope())
{
var almacenMovimientoBl = new AlmacenMovimientoBL();
var almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL();
organizacionID = usuarioInfo.OrganizacionID;
foreach (var diferenciasDeInventariosInfo in listaDiferenciasInventario)
{
if (diferenciasDeInventariosInfo.DescripcionAjuste.Equals(TipoAjusteEnum.CerrarLote.ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenInventarioLoteInfo = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
diferenciasDeInventariosInfo.AlmacenInventarioLote.AlmacenInventarioLoteId);
if (almacenInventarioLoteInfo != null)
{
almacenInventarioLoteInfo.UsuarioModificacionId = usuarioInfo.UsuarioID;
//Kilogramos teoricos en 0 se desactiva el lote
if (diferenciasDeInventariosInfo.KilogramosFisicos == 0)
{
//Desactivar lote
almacenInventarioLoteBl.DesactivarLote(almacenInventarioLoteInfo);
}
}
continue;
}
diferenciasDeInventariosInfo.DiferenciaInventario =
Math.Abs(diferenciasDeInventariosInfo.KilogramosFisicos -
diferenciasDeInventariosInfo.KilogramosTeoricos);
////Se le quita el signo para que no guarde en negativos
//diferenciasDeInventariosInfo.KilogramosTeoricos =
// Math.Abs(diferenciasDeInventariosInfo.KilogramosTeoricos);
//organizacionID = diferenciasDeInventariosInfo.AlmacenMovimiento.OrganizacionID;
//Si no esta guardado se actualiza
if (!diferenciasDeInventariosInfo.Guardado)
{
AlmacenMovimientoInfo almacen = new AlmacenMovimientoInfo();
//Estatus aplicado guarda y actualiza inventario
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvAplicado.GetHashCode())
{
//Insertar movimiento
diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID =
diferenciasDeInventariosInfo.Almacen.AlmacenID;
var almacenMovimientoId =
almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Insertar detalle
var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
{
AlmacenMovimientoID = almacenMovimientoId,
AlmacenInventarioLoteId =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.
AlmacenInventarioLoteId,
Piezas = 0,
ProductoID =
diferenciasDeInventariosInfo.Producto.
ProductoId,
Precio =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
Cantidad =
diferenciasDeInventariosInfo.
DiferenciaInventario,
Importe =
diferenciasDeInventariosInfo.
DiferenciaInventario *
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
UsuarioCreacionID = usuarioInfo.UsuarioID
};
long almacenMovimientoDetalleID =
almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo);
//SE AGREGA DETALLE
almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID;
//var almacenmovimientoBl1 = new AlmacenMovimientoDetalleBL();
//var d =
// almacenmovimientoBl1.ObtenerPorAlmacenMovimientoDetalleId(almacenMovimientoDetalleInfo);
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
//Actualizamos inventario y lote
ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID);
}
//Si es pendiente solo guarda el movimiento y detalle
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvPendiente.GetHashCode())
{
//Insertar movimiento
diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID =
diferenciasDeInventariosInfo.Almacen.AlmacenID;
var almacenMovimientoId =
almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Insertar detalle
var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle()
{
AlmacenMovimientoID = almacenMovimientoId,
AlmacenInventarioLoteId =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.
AlmacenInventarioLoteId,
Piezas = 0,
ProductoID =
diferenciasDeInventariosInfo.Producto.
ProductoId,
Precio =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
Cantidad =
diferenciasDeInventariosInfo.
DiferenciaInventario,
Importe =
diferenciasDeInventariosInfo.
DiferenciaInventario *
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
UsuarioCreacionID = usuarioInfo.UsuarioID
};
long almacenMovimientoDetalleID =
almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo);
//Se valida si requiere autorizacion
if (diferenciasDeInventariosInfo.RequiereAutorizacion)
{
var almacenBl = new AlmacenBL();
AlmacenMovimientoInfo almacenMovimientoInfo = new AlmacenMovimientoInfo
{
AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID,
AlmacenMovimientoID = almacenMovimientoId
};
almacen = almacenBl.ObtenerAlmacenMovimiento(almacenMovimientoInfo);
var autorizacionMateriaPrimaInfo = new AutorizacionMateriaPrimaInfo
{
OrganizacionID = usuarioInfo.OrganizacionID,
TipoAutorizacionID = TipoAutorizacionEnum.AjustedeInventario.GetHashCode(),
Folio = almacen.FolioMovimiento,
Justificacion = almacen.Observaciones,
Lote = diferenciasDeInventariosInfo.AlmacenInventarioLote.Lote,
Precio = almacenMovimientoDetalleInfo.Precio,
Cantidad = almacenMovimientoDetalleInfo.Cantidad,
ProductoID = almacenMovimientoDetalleInfo.ProductoID,
AlmacenID = almacen.AlmacenID,
EstatusID = Estatus.AMPPendien.GetHashCode(),
UsuarioCreacion = usuarioInfo.UsuarioID,
Activo = EstatusEnum.Activo.GetHashCode()
};
var almacenInventarioLoteBL = new AlmacenInventarioLoteBL();
almacenInventarioLoteBL.GuardarAutorizacionMateriaPrima(
autorizacionMateriaPrimaInfo);
}
//SE AGREGA DETALLE
almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID;
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
}
}
else
{
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvAplicado.GetHashCode())
{
//Actualizar estatus a regitro
//Agregar observaciones
almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Actualizar detalle movimiento
var almacenMovimientoDetalleInfo =
almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId(
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle);
almacenMovimientoDetalleInfo.Cantidad =
diferenciasDeInventariosInfo.DiferenciaInventario;
almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad *
almacenMovimientoDetalleInfo.Precio;
almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID;
almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle(
almacenMovimientoDetalleInfo);
//Actualizamos inventario y lote
ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID);
//SE AGREGA DETALLE
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
}
//Guardado con estatus pendiente se actualiza almacen movimiento y almacen movimiento detalle
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvPendiente.GetHashCode())
{
//Actualizar almacen movimiento
almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Actualizar movimiento detalle
//Verificar si se ocupa obtenerlo
var almacenMovimientoDetalleInfo =
almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId(
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle);
almacenMovimientoDetalleInfo.Cantidad =
diferenciasDeInventariosInfo.DiferenciaInventario;
almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad *
almacenMovimientoDetalleInfo.Precio;
//Pendiente usuario modificacion
almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID;
almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle(
almacenMovimientoDetalleInfo);
//SE AGREGA DETALLE
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
}
}
}
#region POLIZA
var listaDiferenciasInventarioAplicados =
listaDiferenciasInventario.Where(dif => dif.AlmacenMovimiento.Status == Estatus.DifInvAplicado.GetHashCode()).ToList();
List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
listaDiferenciasInventarioAplicados.Where(dif => !dif.DescripcionAjuste.Trim().Equals(TipoAjusteEnum.CerrarLote.ToString().Trim(), StringComparison.InvariantCultureIgnoreCase)).Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
{
Importe =
ajuste.DiferenciaInventario *
ajuste.AlmacenInventarioLote.
PrecioPromedio,
Cantidad = ajuste.DiferenciaInventario,
TipoAjuste =
ajuste.DescripcionAjuste.Equals(
TipoAjusteEnum.Merma.ToString(),
StringComparison.
CurrentCultureIgnoreCase)
? TipoAjusteEnum.Merma
: TipoAjusteEnum.Superávit,
Precio = ajuste.AlmacenInventarioLote.
PrecioPromedio,
AlmacenInventarioID =
ajuste.AlmacenInventarioLote.
AlmacenInventario.AlmacenInventarioID,
AlmacenMovimientoDetalleID =
ajuste.AlmacenMovimientoDetalle.
AlmacenMovimientoDetalleID,
ProductoID = ajuste.Producto.ProductoId,
CantidadInventarioFisico =
ajuste.KilogramosFisicos,
CantidadInventarioTeorico =
ajuste.KilogramosTeoricos,
Observaciones =
ajuste.AlmacenMovimiento.Observaciones
}).ToList();
var agrupado =
salidasPorAjuste.GroupBy(tipo => new { tipo.TipoAjuste, tipo.AlmacenMovimientoDetalleID }).Select(
ajuste => new PolizaEntradaSalidaPorAjusteModel
{
TipoAjuste = ajuste.Key.TipoAjuste,
AlmacenInventarioID = ajuste.First().AlmacenInventarioID,
AlmacenMovimientoDetalleID = ajuste.Key.AlmacenMovimientoDetalleID,
Cantidad = ajuste.First().Cantidad,
CantidadInventarioFisico = ajuste.First().CantidadInventarioFisico,
CantidadInventarioTeorico = ajuste.First().CantidadInventarioTeorico,
Importe = ajuste.First().Importe,
Observaciones = ajuste.First().Observaciones,
Precio = ajuste.First().Precio,
PrecioInventarioFisico = ajuste.First().PrecioInventarioFisico,
PrecioInventarioTeorico = ajuste.First().PrecioInventarioTeorico,
ProductoID = ajuste.First().ProductoID
}).ToList();
if (agrupado != null && agrupado.Any())
{
streams = new List <MemoryStream>();
for (int indexAjustes = 0; indexAjustes < agrupado.Count; indexAjustes++)
{
var tipoPoliza = TipoPoliza.SalidaAjuste;
switch (agrupado[indexAjustes].TipoAjuste)
{
case TipoAjusteEnum.Superávit:
tipoPoliza = TipoPoliza.EntradaAjuste;
break;
}
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
var grupo = new List <PolizaEntradaSalidaPorAjusteModel>
{
agrupado[indexAjustes]
};
polizas = poliza.GeneraPoliza(grupo);
if (polizas != null && polizas.Any())
{
MemoryStream stream = poliza.ImprimePoliza(grupo, polizas);
if (stream != null)
{
streams.Add(stream);
}
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID = organizacionID;
datos.UsuarioCreacionID = usuarioId;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, tipoPoliza);
}
}
}
#endregion POLIZA
transaction.Complete();
}
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(streams);
}
/// <summary>
/// Obtiene un flujo de datos
/// para la generacion de la reimpresion
/// de la poliza de pase a proceso
/// </summary>
/// <param name="pedidoInfo"></param>
/// <param name="polizaClave"></param>
/// <returns></returns>
private IList <ResultadoPolizaModel> ReimpresionPolizaPaseProceso(PedidoInfo pedidoInfo, TipoPolizaInfo polizaClave)
{
var polizaBL = new PolizaBL();
IList <PolizaInfo> polizasVenta = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso,
pedidoInfo.Organizacion.OrganizacionID,
pedidoInfo.FechaPedido,
pedidoInfo.FolioPedido.ToString(),
polizaClave.ClavePoliza, 1);
IList <ResultadoPolizaModel> resultadoPolizaModel = null;
if (polizasVenta != null)
{
List <int> foliosPedidos = new List <int>();
foreach (var polizaventas in polizasVenta)
{
//PP-348-1 22,350 COSTOS
int indiceFolio = 1;
var conceptos = polizaventas.Concepto.Split('-');
int folio;
int.TryParse(conceptos[indiceFolio], out folio);
if (folio > 0)
{
foliosPedidos.Add(folio);
}
}
foliosPedidos = foliosPedidos.Distinct().ToList();
resultadoPolizaModel = new List <ResultadoPolizaModel>();
foreach (var folio in foliosPedidos)
{
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso);
var pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL();
List <PolizaPaseProcesoModel> datosPoliza =
pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProcesoReimpresion(folio,
pedidoInfo.Organizacion.
OrganizacionID);
if (datosPoliza != null && datosPoliza.Any())
{
IList <PolizaPaseProcesoModel> polizasPaseProcesoModel;
datosPoliza =
datosPoliza.GroupBy(
prod => new { prod.Producto.ProductoId, prod.ProveedorChofer.ProveedorChoferID, prod.PesajeMateriaPrima.Ticket })
.Select(grupo => new PolizaPaseProcesoModel
{
Organizacion =
grupo.Select(org => org.Organizacion).FirstOrDefault(),
Almacen = grupo.Select(alm => alm.Almacen).FirstOrDefault(),
Producto = grupo.Select(pro => pro.Producto).FirstOrDefault(),
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.Select(prov => prov.ProveedorChofer).FirstOrDefault(),
PesajeMateriaPrima =
grupo.Select(pesaje => pesaje.PesajeMateriaPrima).
FirstOrDefault(),
ProgramacionMateriaPrima =
grupo.Select(prog => prog.ProgramacionMateriaPrima).
FirstOrDefault(),
ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).
FirstOrDefault(),
}).OrderBy(ticket => ticket.PesajeMateriaPrima.Ticket).ToList();
for (int indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++)
{
polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> {
datosPoliza[indexPoliza]
};
polizasVenta = poliza.GeneraPoliza(polizasPaseProcesoModel);
MemoryStream stream = poliza.ImprimePoliza(polizasPaseProcesoModel, polizasVenta);
PolizaPaseProcesoModel polizaActual = polizasPaseProcesoModel.FirstOrDefault();
string nomenclaturaArchivo = string.Empty;
if (polizaActual != null)
{
nomenclaturaArchivo = String.Format("{0}-{1}", polizaActual.Pedido.FolioPedido,
polizaActual.PesajeMateriaPrima.Ticket);
}
var resultadoPoliza = new ResultadoPolizaModel
{
NomenclaturaArchivo = nomenclaturaArchivo,
PDF = stream
};
//polizasVenta.ToList().ForEach(datos =>
// {
// datos.OrganizacionID = 1;
// datos.UsuarioCreacionID = 1;
// });
//polizaBL.Guardar(polizasVenta, TipoPoliza.PaseProceso);
resultadoPolizaModel.Add(resultadoPoliza);
}
}
}
}
return(resultadoPolizaModel);
}
/// <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>
/// Termina la salida del producto
/// </summary>
/// <param name="salida"></param>
/// <returns></returns>
internal MemoryStream TerminarSalidaProducto(SalidaProductoInfo salida)
{
try
{
Logger.Info();
bool generaFactura = salida.GeneraFactura;
MemoryStream resultado = null;
var almacenBl = new AlmacenBL();
var almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL();
var almacenMovimiento = new AlmacenMovimientoInfo();
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenInventarioBl = new AlmacenInventarioBL();
var salidaProductoDal = new SalidaProductoDAL();
PolizaAbstract poliza = null;
IList <PolizaInfo> polizas = null;
using (var transaction = new TransactionScope())
{
almacenMovimiento.AlmacenID = salida.Almacen.AlmacenID;
almacenMovimiento.TipoMovimientoID = salida.TipoMovimiento.TipoMovimientoID;
almacenMovimiento.UsuarioCreacionID = salida.UsuarioModificacionId;
almacenMovimiento.Status = (int)EstatusInventario.Aplicado;
AlmacenMovimientoInfo almacenMovimientoGenerado =
almacenBl.GuardarAlmacenMovimiento(almacenMovimiento);
if (almacenMovimientoGenerado != null)
{
AlmacenInventarioLoteInfo almacenInventarioLote =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
salida.AlmacenInventarioLote.AlmacenInventarioLoteId);
var listaAlmacenInventarioDetalle = new List <AlmacenMovimientoDetalle>();
var movimientoDetalle = new AlmacenMovimientoDetalle
{
AlmacenMovimientoID =
almacenMovimientoGenerado.AlmacenMovimientoID,
AlmacenInventarioLoteId =
salida.AlmacenInventarioLote.AlmacenInventarioLoteId,
Precio = almacenInventarioLote.PrecioPromedio,
ProductoID = salida.Producto.ProductoId,
Cantidad = salida.PesoBruto - salida.PesoTara,
Piezas = salida.Piezas,
Importe =
(salida.PesoBruto - salida.PesoTara) *
almacenInventarioLote.PrecioPromedio,
UsuarioCreacionID = salida.UsuarioModificacionId
};
listaAlmacenInventarioDetalle.Add(movimientoDetalle);
almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(listaAlmacenInventarioDetalle,
almacenMovimientoGenerado.
AlmacenMovimientoID);
if (almacenInventarioLote != null)
{
almacenInventarioLote.Cantidad = almacenInventarioLote.Cantidad -
(salida.PesoBruto - salida.PesoTara);
almacenInventarioLote.Importe = almacenInventarioLote.PrecioPromedio *
almacenInventarioLote.Cantidad;
almacenInventarioLote.UsuarioModificacionId = salida.UsuarioModificacionId;
almacenInventarioLoteBl.Actualizar(almacenInventarioLote);
AlmacenInfo almacen = almacenBl.ObtenerPorID(almacenMovimiento.AlmacenID);
List <AlmacenInventarioInfo> listaAlmacenlmacenInventario =
almacenInventarioBl.ObtienePorAlmacenId(almacen);
if (listaAlmacenlmacenInventario != null)
{
AlmacenInventarioInfo inventarioProducto = listaAlmacenlmacenInventario.FirstOrDefault(
registro => registro.ProductoID == salida.Producto.ProductoId);
if (inventarioProducto != null)
{
inventarioProducto.Cantidad = inventarioProducto.Cantidad -
(salida.PesoBruto - salida.PesoTara);
inventarioProducto.Importe = (inventarioProducto.PrecioPromedio *
inventarioProducto.Cantidad);
//Actualiza inventario
inventarioProducto.UsuarioModificacionID = salida.UsuarioModificacionId;
inventarioProducto.ProductoID = salida.Producto.ProductoId;
inventarioProducto.AlmacenID = almacen.AlmacenID;
almacenInventarioBl.ActualizarPorProductoId(inventarioProducto);
salida.GeneraFactura = generaFactura;
salidaProductoDal.TerminarSalidaProducto(salida, almacenMovimientoGenerado);
#region POLIZA
poliza =
FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(
TipoPoliza.SalidaVentaProducto);
salida.Importe = (salida.PesoBruto - salida.PesoTara) * salida.Precio;
salida = ObtenerFolioPorReimpresion(salida);
polizas = poliza.GeneraPoliza(salida);
if (polizas != null)
{
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID =
salida.Organizacion.OrganizacionID;
datos.UsuarioCreacionID =
salida.UsuarioCreacionId;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaVentaProducto);
if (salida.Almacen == null)
{
salida.Almacen = new AlmacenInfo();
}
salida.Almacen.Organizacion = new OrganizacionInfo
{
OrganizacionID =
salida.Organizacion.OrganizacionID
};
resultado = poliza.ImprimePoliza(salida, polizas);
}
#endregion POLIZA
if (generaFactura)
{
#region FACTURA
if (salida.TipoMovimiento.TipoMovimientoID ==
TipoMovimiento.ProductoSalidaVenta.GetHashCode())
{
//Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaVentaDeMateriaPrima(salida);
}
#endregion
}
transaction.Complete();
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
return(resultado);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionDesconocida)
{
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// guardar 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);
}
}
/// <summary>
/// Metodo que da salida por venta al ganado intensivo cuano se selcciona tipoventa Externo
/// </summary>
/// <param name="salidaIndividual"></param>
/// <returns></returns>
internal MemoryStream GuardarSalidaGanadoVentaIntensiva(SalidaIndividualInfo salidaIndividual)
{
MemoryStream retorno = null;
try
{
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaVenta;
TicketInfo Ticket = new TicketInfo();
CorralInfo corralInfo = new CorralInfo();
CorralBL corralB = new CorralBL();
GanadoIntensivoBL salidaGanadoCosto = new GanadoIntensivoBL();
GanadoIntensivoInfo salidaGanadoInfo = new GanadoIntensivoInfo();
corralInfo = corralB.ObtenerCorralActivoPorCodigo(salidaIndividual.Organizacion, salidaIndividual.Corral);
corralInfo.Organizacion = new OrganizacionInfo();
corralInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
salidaGanadoInfo = salidaGanadoCosto.ObtenerMuerteGanadoIntensivo(corralInfo);
salidaGanadoInfo.Organizacion = new OrganizacionInfo();
salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
salidaGanadoInfo.Observaciones = "";
Ticket.FolioTicket = salidaIndividual.FolioTicket;
Ticket.Organizacion = salidaIndividual.Organizacion;
var ventaGanadoBL = new VentaGanadoBL();
VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);
var loteBL = new LoteBL();
CorralBL corralBl = new CorralBL();
LoteInfo lote = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
int iCabezasTotalLote = lote.Cabezas;
lote.Cabezas -= salidaIndividual.NumeroDeCabezas;
//lote.Corral = corralBl.ObtenerCorralPorLoteID(lote.LoteID, salidaIndividual.Organizacion);
//lote.Corral = corralBl.ObtenerCorralPorCodigo()
using (var scope = new TransactionScope())
{
Logger.Info();
var salidaIndividualDAL = new SalidaIndividualDAL();
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = lote.LoteID,
LoteIDDestino = 0,
CabezasProcesadas = salidaIndividual.NumeroDeCabezas,
UsuarioModificacionID = salidaIndividual.Usuario
};
loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);
salidaGanadoInfo.ListaGanadoIntensivoCosto = new List <GanadoIntensivoCostoInfo>();
foreach (
var entradaCosteo in
salidaGanadoInfo.EntradaGanadoCosteo.ListaCostoEntrada.OrderBy(id => id.Costo.CostoID))
{
var costoInt = new GanadoIntensivoCostoInfo();
costoInt.Costos = new CostoInfo();
costoInt.Costos = entradaCosteo.Costo;
costoInt.Costos.ImporteCosto = (entradaCosteo.Importe /
salidaGanadoInfo.EntradaGanado.CabezasRecibidas) *
salidaIndividual.NumeroDeCabezas;
costoInt.Importe = costoInt.Costos.ImporteCosto;
salidaGanadoInfo.ListaGanadoIntensivoCosto.Add(costoInt);
}
salidaGanadoInfo.TipoMovimientoID = TipoMovimiento.SalidaVentaIntensivo;
//salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
salidaGanadoInfo.TotalCabezas = salidaIndividual.NumeroDeCabezas;
salidaGanadoInfo.FolioTicket = salidaIndividual.FolioTicket;
salidaGanadoInfo.TipoFolio = TipoFolio.VentaGanadoIntensivo;
salidaGanadoInfo.PesoBruto = salidaIndividual.PesoBruto;
salidaGanadoInfo.UsuarioCreacionID = salidaIndividual.Usuario;
salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
salidaGanadoInfo.CabezasText = salidaIndividual.NumeroDeCabezas.ToString();
salidaGanadoCosto.Guardar(salidaGanadoInfo);
#region Poliza
List <ContenedorVentaGanado> ventasGanado =
ventaGanadoBL.ObtenerVentaGanadoIntensivoPorTicketPoliza(Ticket);
if (ventasGanado != null && ventasGanado.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVentaIntensiva);
for (int i = 0; i < ventasGanado.Count; i++)
{
ventasGanado[i].EntradaGandoId = salidaGanadoInfo.EntradaGanado.EntradaGanadoID;
ventasGanado[i].OrganizacionId = Ticket.Organizacion;
ventasGanado[i].Lote = lote;
}
polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
{
polizaSalidaVenta.ToList().ForEach(
org =>
{
org.OrganizacionID = Ticket.Organizacion;
org.UsuarioCreacionID = salidaIndividual.Usuario;
org.ArchivoEnviadoServidor = 1;
});
retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVentaIntensiva);
}
}
// Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaVentaDeGanadoIntensivo(Ticket.FolioTicket, Ticket.Organizacion);
#endregion Poliza
scope.Complete();
}
return(retorno);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que le da salida por venta al ganado
/// </summary>
/// <param name="salidaIndividual"></param>
/// <returns></returns>
internal MemoryStream GuardarSalidaIndividualGanadoVenta(SalidaIndividualInfo salidaIndividual)
{
MemoryStream retorno = null;
try
{
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaVenta;
TicketInfo Ticket = new TicketInfo();
Ticket.FolioTicket = salidaIndividual.FolioTicket;
Ticket.Organizacion = salidaIndividual.Organizacion;
Ticket.TipoVenta = salidaIndividual.TipoVenta;
var ventaGanadoBL = new VentaGanadoBL();
VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);
var loteBL = new LoteBL();
LoteInfo lote = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
lote.Cabezas -= salidaIndividual.NumeroDeCabezas;
AnimalBL animalBl = new AnimalBL();
using (var scope = new TransactionScope())
{
Logger.Info();
var salidaIndividualDAL = new SalidaIndividualDAL();
VentaGanadoDetalleBL ventaGanadoDetalleBl = new VentaGanadoDetalleBL();
List <VentaGanadoDetalleInfo> listaVentaGanadoDetalle = ventaGanadoDetalleBl.ObtenerVentaGanadoPorTicket(salidaPorVentaGanado.VentaGanadoID);
List <AnimalCostoInfo> animalCosto = new List <AnimalCostoInfo>();
AnimalCostoBL animalCostoBl = new AnimalCostoBL();
List <AnimalInfo> animalesConsulta = new List <AnimalInfo>();
List <AnimalInfo> animalesProcesar = new List <AnimalInfo>();
foreach (VentaGanadoDetalleInfo ventaGanado in listaVentaGanadoDetalle)
{
animalesConsulta = new List <AnimalInfo>();
ventaGanado.Animal = animalBl.ObtenerAnimalPorArete(ventaGanado.Arete, Ticket.Organizacion);
if (ventaGanado.Animal == null)
{
ventaGanado.Animal = animalBl.ObtenerAnimalPorAreteTestigo(ventaGanado.AreteMetalico, Ticket.Organizacion);
}
animalesConsulta.Add(ventaGanado.Animal);
animalCosto = animalCostoBl.ObtenerCostosAnimal(animalesConsulta);
if (!animalCosto.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
{
animalesProcesar.Add(ventaGanado.Animal);
}
}
if (animalesProcesar != null && animalesProcesar.Count > 0)
{
animalBl.ProcesoGenerarCostos(animalesProcesar);
}
salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
salidaIndividualDAL.GuardarCostosHistoricos(salidaIndividual);
salidaIndividualDAL.GuardarConsumoHistoricos(salidaIndividual);
salidaIndividualDAL.GuardarAnimalHistoricos(salidaIndividual);
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = lote.LoteID,
LoteIDDestino = 0,
CabezasProcesadas = salidaIndividual.NumeroDeCabezas,
UsuarioModificacionID = salidaIndividual.Usuario
};
loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);
//loteBL.ActualizaNoCabezasEnLote(lote, lote);
#region Poliza
List <ContenedorVentaGanado> ventasGanado =
ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(Ticket.FolioTicket, Ticket.Organizacion);
if (ventasGanado != null && ventasGanado.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVenta);
polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
{
polizaSalidaVenta.ToList().ForEach(
org =>
{
org.OrganizacionID = Ticket.Organizacion;
org.UsuarioCreacionID = salidaIndividual.Usuario;
org.ArchivoEnviadoServidor = 1;
});
retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVenta);
}
}
// Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaVentaDeGanado(Ticket.FolioTicket, Ticket.Organizacion);
#endregion Poliza
scope.Complete();
}
return(retorno);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
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);
}
}
private IList <ResultadoPolizaModel> GenerarPolizaCierreDiaPA(CierreDiaInventarioPAInfo cierreDiaInventarioPA, List <EstatusInfo> listaEstatusInventario, bool imprimePoliza)
{
EstatusInfo estatusAplicado =
listaEstatusInventario.FirstOrDefault(
esta => esta.DescripcionCorta.Trim().Equals(ConstantesBL.MovimientoAplicado.Trim()));
if (estatusAplicado == null)
{
return(null);
}
var filtros = new FiltroAlmacenMovimientoInfo
{
AlmacenID = cierreDiaInventarioPA.AlmacenID,
OrganizacionID = cierreDiaInventarioPA.OrganizacionID,
TipoMovimientoID = TipoMovimiento.InventarioFisico.GetHashCode(),
EstatusID = estatusAplicado.EstatusId,
FolioMovimiento = cierreDiaInventarioPA.FolioMovimiento
};
var almacenMovimientoDAL = new AlmacenMovimientoDAL();
List <ContenedorAlmacenMovimientoCierreDia> movimientos = almacenMovimientoDAL.ObtenerMovimientosInventarioFiltros(filtros);
if (movimientos == null || !movimientos.Any())
{
return(null);
}
var resultadosPolizaModel = new List <ResultadoPolizaModel>();
var listaDatosPolizaEntrada = new List <PolizaEntradaSalidaPorAjusteModel>();
var listaDatosPolizaSalida = new List <PolizaEntradaSalidaPorAjusteModel>();
foreach (var detalles in cierreDiaInventarioPA.ListaCierreDiaInventarioPADetalle.Where(det => (det.InventarioFisico - det.InventarioTeorico > 0)))
{
ContenedorAlmacenMovimientoCierreDia almacenMovimientoDetalle;
if (detalles.ManejaLote)
{
almacenMovimientoDetalle =
movimientos.FirstOrDefault(
mov => mov.Producto.ProductoId == detalles.ProductoID &&
mov.AlmacenMovimientoDetalle.AlmacenInventarioLoteId ==
detalles.AlmacenInventarioLoteID);
}
else
{
almacenMovimientoDetalle =
movimientos.FirstOrDefault(
mov => mov.Producto.ProductoId == detalles.ProductoID);
}
if (almacenMovimientoDetalle == null)
{
continue;
}
int cantidadEntrada = Math.Abs(detalles.InventarioFisico - detalles.InventarioTeorico);
var polizaDetalle = new PolizaEntradaSalidaPorAjusteModel
{
Importe = detalles.CostoUnitario * cantidadEntrada,
Cantidad = cantidadEntrada,
Precio = almacenMovimientoDetalle.AlmacenMovimientoDetalle.Precio,
AlmacenMovimientoDetalleID =
almacenMovimientoDetalle.AlmacenMovimientoDetalle.AlmacenMovimientoDetalleID,
ProductoID = detalles.ProductoID,
CantidadInventarioFisico = detalles.InventarioFisico,
CantidadInventarioTeorico = detalles.InventarioTeorico,
Observaciones = almacenMovimientoDetalle.AlmacenMovimiento.Observaciones,
Lote = detalles.Lote
};
listaDatosPolizaEntrada.Add(polizaDetalle);
}
foreach (var detalles in cierreDiaInventarioPA.ListaCierreDiaInventarioPADetalle.Where(det => (det.InventarioFisico - det.InventarioTeorico < 0)))
{
ContenedorAlmacenMovimientoCierreDia almacenMovimientoDetalle;
if (detalles.ManejaLote)
{
almacenMovimientoDetalle =
movimientos.FirstOrDefault(
mov => mov.Producto.ProductoId == detalles.ProductoID &&
mov.AlmacenMovimientoDetalle.AlmacenInventarioLoteId ==
detalles.AlmacenInventarioLoteID);
}
else
{
almacenMovimientoDetalle =
movimientos.FirstOrDefault(
mov => mov.Producto.ProductoId == detalles.ProductoID);
}
if (almacenMovimientoDetalle == null)
{
continue;
}
int cantidadSalida = Math.Abs(detalles.InventarioFisico - detalles.InventarioTeorico);
var polizaDetalle = new PolizaEntradaSalidaPorAjusteModel
{
Importe = detalles.CostoUnitario * cantidadSalida,
Cantidad = cantidadSalida,
Precio = almacenMovimientoDetalle.AlmacenMovimientoDetalle.Precio,
AlmacenMovimientoDetalleID =
almacenMovimientoDetalle.AlmacenMovimientoDetalle.AlmacenMovimientoDetalleID,
ProductoID = detalles.ProductoID,
CantidadInventarioFisico = detalles.InventarioFisico,
CantidadInventarioTeorico = detalles.InventarioTeorico,
Observaciones = almacenMovimientoDetalle.AlmacenMovimiento.Observaciones,
Lote = detalles.Lote
};
listaDatosPolizaSalida.Add(polizaDetalle);
}
if (listaDatosPolizaSalida.Any())
{
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaAjuste);
IList <PolizaInfo> polizas = poliza.GeneraPoliza(listaDatosPolizaSalida);
if (polizas != null)
{
MemoryStream stream = null;
if (imprimePoliza)
{
stream = poliza.ImprimePoliza(listaDatosPolizaSalida, polizas);
}
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.UsuarioCreacionID =
cierreDiaInventarioPA.UsuarioCreacionID;
datos.OrganizacionID = cierreDiaInventarioPA.OrganizacionID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaAjuste);
var resultadoPolizaModel = new ResultadoPolizaModel
{
Polizas = polizas,
PDFs =
new Dictionary <TipoPoliza, MemoryStream>
{
{ TipoPoliza.SalidaAjuste, stream }
}
};
resultadosPolizaModel.Add(resultadoPolizaModel);
}
}
if (listaDatosPolizaEntrada.Any())
{
var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaAjuste);
IList <PolizaInfo> polizas = poliza.GeneraPoliza(listaDatosPolizaEntrada);
if (polizas != null)
{
MemoryStream stream = null;
if (imprimePoliza)
{
stream = poliza.ImprimePoliza(listaDatosPolizaEntrada, polizas);
}
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.UsuarioCreacionID =
cierreDiaInventarioPA.UsuarioCreacionID;
datos.OrganizacionID = cierreDiaInventarioPA.OrganizacionID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, TipoPoliza.EntradaAjuste);
var resultadoPolizaModel = new ResultadoPolizaModel
{
Polizas = polizas,
PDFs =
new Dictionary <TipoPoliza, MemoryStream> {
{ TipoPoliza.EntradaAjuste, stream }
}
};
resultadosPolizaModel.Add(resultadoPolizaModel);
}
}
return(resultadosPolizaModel);
}
/// <summary>
/// Guarda una lista de interface salida traspaso.
/// </summary>
/// <param name="interfaceSalidaTraspaso"></param>
internal Dictionary <long, decimal> CrearLista(InterfaceSalidaTraspasoInfo interfaceSalidaTraspaso)
{
decimal costoGanado = 0;
try
{
var interfaceSalidaTraspasoDal = new InterfaceSalidaTraspasoDAL();
using (var scope = new TransactionScope())
{
interfaceSalidaTraspaso.TraspasoGanado =
interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Select(det => det.TraspasoGanado).
FirstOrDefault();
interfaceSalidaTraspaso.SacrificioGanado =
interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Select(det => det.SacrificioGanado).
FirstOrDefault();
InterfaceSalidaTraspasoInfo interfaceSalidaTraspasoGuardado;
if (interfaceSalidaTraspaso.InterfaceSalidaTraspasoId > 0)
{
Actualizar(interfaceSalidaTraspaso);
interfaceSalidaTraspasoGuardado = interfaceSalidaTraspaso;
}
else
{
var folioBL = new FolioBL();
interfaceSalidaTraspaso.FolioTraspaso = folioBL.ObtenerFolio(interfaceSalidaTraspaso.OrganizacionId
, TipoFolio.TraspasoGanado);
interfaceSalidaTraspasoGuardado = Crear(interfaceSalidaTraspaso);
}
var loteBL = new LoteBL();
if (interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Any())
{
interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.ForEach(
det =>
det.InterfaceSalidaTraspasoID = interfaceSalidaTraspasoGuardado.InterfaceSalidaTraspasoId);
interfaceSalidaTraspasoDal.CrearLista(interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle);
List <LoteInfo> lotes = interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle
.Select(lote => new LoteInfo
{
LoteID = lote.Lote.LoteID,
Cabezas = lote.Cabezas,
UsuarioModificacionID = lote.UsuarioCreacionID
}).ToList();
loteBL.AcutalizaCabezasLoteXML(lotes);
List <LoteInfo> lotesCabezas = lotes.GroupBy(lote => lote.LoteID).Select(x => new LoteInfo
{
LoteID = x.Key,
Cabezas = x.Sum(cab => cab.Cabezas),
UsuarioModificacionID = x.Select(usu => usu.UsuarioModificacionID).FirstOrDefault()
}).ToList();
List <LoteInfo> lotesDesactivar =
(from ist in interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle
from lote in lotesCabezas
where ist.Lote.Cabezas - lote.Cabezas == 0
select lote).ToList();
if (lotesDesactivar.Any())
{
loteBL.DesactivarLoteXML(lotesDesactivar);
}
}
#region POLIZA
if (interfaceSalidaTraspasoGuardado.PesoBruto > 0 && interfaceSalidaTraspasoGuardado.PesoTara > 0)
{
var polizaBL = new PolizaBL();
int organizacionID = interfaceSalidaTraspasoGuardado.OrganizacionId;
DateTime fechaEnvio = interfaceSalidaTraspasoGuardado.FechaEnvio;
long folio = interfaceSalidaTraspasoGuardado.FolioTraspaso;
IList <PolizaInfo> polizasGanado =
polizaBL.ObtenerPolizaConDocumentoSAPPendientes(TipoPoliza.SalidaGanado, organizacionID, fechaEnvio);
if (polizasGanado != null)
{
polizasGanado = polizasGanado.Where(con => con.Concepto.StartsWith(string.Format("ST-{0} ", folio))).ToList();
}
if (polizasGanado == null || !polizasGanado.Any())
{
InterfaceSalidaTraspasoInfo interfaceSalidaTraspasoSacarDetalle =
ObtenerInterfaceSalidaTraspasoPorFolioOrganizacion(interfaceSalidaTraspasoGuardado);
if (interfaceSalidaTraspasoSacarDetalle != null)
{
interfaceSalidaTraspasoGuardado.ListaInterfaceSalidaTraspasoDetalle =
interfaceSalidaTraspasoSacarDetalle.ListaInterfaceSalidaTraspasoDetalle;
}
List <LoteInfo> lotesAnimal = interfaceSalidaTraspasoGuardado.ListaInterfaceSalidaTraspasoDetalle
.Select(lote => new LoteInfo
{
LoteID = lote.Lote.LoteID
}).ToList();
var animalBL = new AnimalBL();
List <AnimalInfo> animales
= animalBL.ObtenerAnimalesPorLoteXML(lotesAnimal, interfaceSalidaTraspaso.OrganizacionId);
int cabezas = interfaceSalidaTraspasoGuardado.ListaInterfaceSalidaTraspasoDetalle
.Sum(cab => cab.Cabezas);
if (cabezas > animales.Count)
{
throw new ExcepcionServicio("No existe suficiente inventario para realizar el traspaso.");
}
var polizaSalidaGanado =
FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaGanado);
polizasGanado = polizaSalidaGanado.GeneraPoliza(interfaceSalidaTraspasoGuardado);
if (polizasGanado != null && polizasGanado.Any())
{
polizasGanado.ToList().ForEach(datos =>
{
datos.OrganizacionID =
interfaceSalidaTraspaso.OrganizacionId;
datos.UsuarioCreacionID =
interfaceSalidaTraspaso.UsuarioModificacionID ??
0;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizasGanado, TipoPoliza.SalidaGanado);
}
}
if (polizasGanado != null)
{
costoGanado =
polizasGanado.Where(imp => imp.Importe.IndexOf('-') < 0).Sum(
imp => Convert.ToDecimal(imp.Importe));
}
}
#endregion POLIZA
scope.Complete();
}
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(new Dictionary <long, decimal> {
{ interfaceSalidaTraspaso.FolioTraspaso, costoGanado }
});
}
/// <summary>
/// Guardar muerte de ganado intenvio
/// </summary>
/// <param name="ganadoIntensivo"></param>
/// <returns></returns>
public GanadoIntensivoInfo MuerteGanadoIntensivo_Guardar(GanadoIntensivoInfo ganadoIntensivo)
{
try
{
int result;
Logger.Info();
MemoryStream polizaPDF = null;
GanadoIntensivoInfo resultado = new GanadoIntensivoInfo();
using (var transaction = new TransactionScope())
{
var loteBL = new LoteBL();
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaMuerteIntensiva;
result = Guardar(ganadoIntensivo);
resultado.FolioTicket = result;
ganadoIntensivo.FolioTicket = result;
var filtroActualizarCabezasLote = new FiltroActualizarCabezasLote
{
CabezasProcesadas = ganadoIntensivo.Cabezas,
LoteIDOrigen = ganadoIntensivo.Lote.LoteID,
UsuarioModificacionID = ganadoIntensivo.UsuarioCreacionID,
LoteIDDestino = 0
};
loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);
#region Poliza
if (ganadoIntensivo != null)
{
if (ganadoIntensivo.ListaGanadoIntensivoCosto != null &&
ganadoIntensivo.ListaGanadoIntensivoCosto.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerteIntensiva);
polizaSalidaMuerteIntensiva = poliza.GeneraPoliza(ganadoIntensivo);
if (polizaSalidaMuerteIntensiva != null && polizaSalidaMuerteIntensiva.Any())
{
polizaSalidaMuerteIntensiva.ToList().ForEach(
org =>
{
org.OrganizacionID = ganadoIntensivo.Organizacion.OrganizacionID;
org.UsuarioCreacionID = ganadoIntensivo.UsuarioCreacionID;
org.ArchivoEnviadoServidor = 1;
});
polizaPDF = poliza.ImprimePoliza(ganadoIntensivo, polizaSalidaMuerteIntensiva);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaMuerteIntensiva, TipoPoliza.SalidaMuerteIntensiva);
resultado.stream = polizaPDF;
}
}
}
#endregion Poliza
transaction.Complete();
}
return(resultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Guarda la salida por muerte en necropsia
/// </summary>
/// <param name="muerte"></param>
/// <returns></returns>
internal int GuardarSalidaPorMuerteNecropsia(MuerteInfo muerte)
{
int retValue;
try
{
Logger.Info();
var animalBL = new AnimalBL();
var animalMovimientoBL = new AnimalMovimientoBL();
var corralBL = new CorralBL();
var loteBL = new LoteBL();
var trampaBL = new TrampaBL();
var entradaGanadoBL = new EntradaGanadoBL();
var animalMovimientoInfo = new AnimalMovimientoInfo();
var corralInfo = new CorralInfo();
var muerteDAL = new MuerteDAL();
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaMuerte;
AnimalInfo animalInfo = null;
using (var transaccion = new TransactionScope())
{
//Se obtiene la info del Corral
if (muerte.CorralId > 0)
{
corralInfo = corralBL.ObtenerPorId(muerte.CorralId);
}
else if (muerte.CorralCodigo != "")
{
corralInfo = corralBL.ObtenerCorralPorCodigo(muerte.OrganizacionId,
muerte.CorralCodigo);
}
//Se obtiene la info del Lote
LoteInfo loteInfo;
if (muerte.LoteId > 0)
{
loteInfo = loteBL.ObtenerPorID(muerte.LoteId);
}
else
{
loteInfo = loteBL.DeteccionObtenerPorCorral(muerte.OrganizacionId, corralInfo.CorralID);
}
/* Se valida el Grupo del corral */
switch (corralInfo.GrupoCorral)
{
case (int)GrupoCorralEnum.Recepcion:
/* almacena el animal en el Inventario */
animalInfo = new AnimalInfo
{
Arete = muerte.Arete,
AreteMetalico = muerte.AreteMetalico,
FechaCompra = DateTime.Now,
TipoGanadoID = 1,
CalidadGanadoID = 1, //***
ClasificacionGanadoID = 1, //***
PesoCompra = 0,
PesoLlegada = 0, //***
FolioEntrada = 1,
OrganizacionIDEntrada = muerte.OrganizacionId,
Paletas = 0,
Venta = false,
Cronico = false,
Activo = true,
UsuarioCreacionID = muerte.UsuarioCreacionID
};
var interfazAnimalBl = new InterfaceSalidaAnimalBL();
var interfaceSalidoAnimalInfo =
interfazAnimalBl.ObtenerNumeroAreteIndividual(muerte.Arete, muerte.OrganizacionId);
int folioEntradaInterfaz = 0;
if (interfaceSalidoAnimalInfo != null)
{
animalInfo.FechaCompra = interfaceSalidoAnimalInfo.FechaCompra;
animalInfo.PesoCompra = (int)interfaceSalidoAnimalInfo.PesoCompra;
animalInfo.TipoGanadoID = interfaceSalidoAnimalInfo.TipoGanado.TipoGanadoID;
folioEntradaInterfaz = interfaceSalidoAnimalInfo.Partida;
}
EntradaGanadoInfo entradaGanadoInterfaz =
entradaGanadoBL.ObtenerEntradasGanadoCosteado(folioEntradaInterfaz, muerte.OrganizacionId);
/* Obtener la entrada de ganado del Corral-Lote para conocer el origen */
EntradaGanadoInfo entradaGanadoInfo = entradaGanadoBL.ObtenerEntradaPorLote(loteInfo);
if (entradaGanadoInfo != null)
{
if (entradaGanadoInterfaz != null)
{
if (entradaGanadoInfo.EmbarqueID == entradaGanadoInterfaz.EmbarqueID)
{
animalInfo.FolioEntrada = entradaGanadoInterfaz.FolioEntrada;
}
}
if (animalInfo.FolioEntrada == 1)
{
if (!entradaGanadoInfo.EsRuteo)
{
animalInfo.FolioEntrada = entradaGanadoInfo.FolioEntrada;
}
else
{
List <CabezasPartidasModel> partidasRuteo =
entradaGanadoBL.ObtenerCabezasEntradasRuteo(entradaGanadoInfo.EmbarqueID);
if (partidasRuteo != null && partidasRuteo.Any())
{
CabezasPartidasModel partidaConPendientes =
partidasRuteo.OrderByDescending(part => part.CabezasPendientes).
FirstOrDefault();
if (partidaConPendientes != null)
{
animalInfo.FolioEntrada = partidaConPendientes.FolioEntrada;
}
}
}
}
//if (entradaGanadoInfo.TipoOrganizacionOrigenId != (int)TipoOrganizacion.CompraDirecta)
//{
//}
//animalInfo.FolioEntrada = entradaGanadoInfo.FolioEntrada;
}
/* Se almacena el animalMovimiento */
animalInfo = animalBL.GuardarAnimal(animalInfo);
break;
default:
if (muerte.AnimalId > 0)
{
animalInfo = animalBL.ObtenerAnimalAnimalID(muerte.AnimalId);
/* Se busca el animal En Salida Animal */
AnimalSalidaInfo animalSalidaInfo =
animalBL.ObtenerAnimalSalidaAnimalID(animalInfo.AnimalID);
if (animalSalidaInfo != null)
{
/* Se valida si no esta en una corraleta de sacrificio */
CorralInfo corraleta = corralBL.ObtenerPorId(animalSalidaInfo.CorraletaId);
if (corraleta != null &&
corraleta.TipoCorral.TipoCorralID == (int)TipoCorral.CorraletaSacrificio)
{
/* Se disminuyen las cabezas del lote en todas las ordenes de sacrificio */
var ordenSacrificioBL = new OrdenSacrificioBL();
ordenSacrificioBL.DecrementarAnimalMuerto(muerte.AnimalId);
/* Eliminar AnimalSalida */
animalBL.EliminarAnimalSalida(animalInfo.AnimalID, loteInfo.LoteID);
}
}
}
else
{
var listaAnimales = animalBL.ObtenerAnimalesPorCorral(corralInfo, muerte.OrganizacionId);
if (listaAnimales != null) //&& listaAnimales.Any())
{
//animalInfo = listaAnimales.FirstOrDefault(registro => registro.UsuarioCreacionID == 1);
animalInfo = listaAnimales.FirstOrDefault(registro => registro.UsuarioCreacionID == 1);
if (animalInfo == null)
{
animalInfo = listaAnimales.OrderBy(ani => ani.AnimalID).FirstOrDefault();
}
}
}
break;
}
if (animalInfo != null)
{
animalInfo.UsuarioCreacionID = muerte.UsuarioCreacionID;
animalInfo.UsuarioModificacionID = muerte.UsuarioCreacionID;
if (muerte.AnimalId == 0)
{
muerte.AnimalId = animalInfo.AnimalID;
}
}
/* Se actualiza la muerte con salida por necropsia */
muerteDAL.GuardarSalidaPorMuerteNecropsia(muerte);
if (animalInfo != null)
{
if (muerte.Peso == 0)
{
List <AnimalMovimientoInfo> ultimosMovimiento = animalMovimientoBL.ObtenerUltimoMovimientoAnimal(new List <AnimalInfo> {
animalInfo
});
if (ultimosMovimiento != null && ultimosMovimiento.Any())
{
AnimalMovimientoInfo ultimoMovimientoAnimal =
ultimosMovimiento.OrderByDescending(ani => ani.AnimalMovimientoID).FirstOrDefault();
if (ultimoMovimientoAnimal != null)
{
muerte.Peso = ultimoMovimientoAnimal.Peso;
}
}
}
/* Insertamos el movimiento de Muerte */
var trampaInfo = trampaBL.ObtenerPorHostName(TrampaGlobal.TrampaNecropsia.ToString());
if (trampaInfo != null)
{
animalMovimientoInfo.TrampaID = trampaInfo.TrampaID;
}
/* Se genera el animal Movimiento para almacenarlo*/
animalMovimientoInfo = new AnimalMovimientoInfo
{
AnimalID = animalInfo.AnimalID,
OrganizacionID = muerte.OrganizacionId,
CorralID = loteInfo.CorralID,
LoteID = loteInfo.LoteID,
Peso = muerte.Peso,
Temperatura = 0,
TipoMovimientoID = (int)TipoMovimiento.Muerte,
TrampaID = trampaInfo != null ? trampaInfo.TrampaID : 1,
OperadorID = muerte.OperadorNecropsiaId,
Observaciones = muerte.Observaciones,
Activo = EstatusEnum.Activo,
UsuarioCreacionID = muerte.UsuarioCreacionID
};
//Proceso para Guardar Costos
AnimalCostoBL animalCostoBl = new AnimalCostoBL();
List <AnimalInfo> animales = new List <AnimalInfo>();
animales.Add(animalInfo);
List <AnimalCostoInfo> listaCostos = animalCostoBl.ObtenerCostosAnimal(animales);
if (listaCostos == null || listaCostos.Count <= 0)
{
animales = animalBL.ProcesoGenerarCostos(animales);
}
else
{
if (!listaCostos.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
{
animales = animalBL.ProcesoGenerarCostos(animales);
}
}
//Proceso Armar Poliza
if (animales != null && animales.Count > 0)
{
if (animales.FirstOrDefault().ListaCostosAnimal != null && animales.FirstOrDefault().ListaCostosAnimal.Count > 0)
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerte);
List <AnimalCostoInfo> listaCostosAnimal = animales.FirstOrDefault().ListaCostosAnimal;
foreach (AnimalCostoInfo animalCosto in listaCostosAnimal)
{
animalCosto.OrganizacionID = muerte.OrganizacionId;
}
polizaSalidaMuerte = poliza.GeneraPoliza(listaCostosAnimal);
if (polizaSalidaMuerte != null && polizaSalidaMuerte.Any())
{
polizaSalidaMuerte.ToList().ForEach(
org =>
{
org.OrganizacionID = muerte.OrganizacionId;
org.UsuarioCreacionID = muerte.UsuarioCreacionID;
org.ArchivoEnviadoServidor = 1;
});
//retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaMuerte);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaMuerte, TipoPoliza.SalidaMuerte);
}
}
}
/* Se almacena el animalMovimiento */
animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);
/* Se da de baja el animal */
animalBL.InactivarAnimal(animalInfo);
/* Enviar al historico el animal inactivo */
var animalMuerto = new List <AnimalInfo> {
animalInfo
};
animalBL.EnviarAHistorico(animalMuerto);
}
/* Decrementar la cabeza del lote */
loteInfo.Cabezas = loteInfo.Cabezas - 1;
loteInfo.UsuarioModificacionID = muerte.UsuarioCreacionID;
var filtro = new FiltroActualizarCabezasLote
{
CabezasProcesadas = 1,
LoteIDDestino = 0,
LoteIDOrigen = loteInfo.LoteID,
UsuarioModificacionID = muerte.UsuarioCreacionID
};
CabezasActualizadasInfo resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro);
//Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada
if (resultadoCabezas.CabezasOrigen <= 0)
{
if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion)
{
/* Si el corral es de Recepcion */
var corteGanadoPl = new CorteGanadoBL();
corteGanadoPl.ObtenerPesosOrigenLlegada(muerte.OrganizacionId,
loteInfo.CorralID,
loteInfo.LoteID);
}
}
transaccion.Complete();
retValue = 1;
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(retValue);
}
/// <summary>
/// Guarda una recepcion de producto
/// </summary>
/// <param name="recepcionProducto"></param>
/// <returns></returns>
internal MemoryStream Guardar(RecepcionProductoInfo recepcionProducto)
{
try
{
MemoryStream pdf = null;
PolizaAbstract poliza = null;
IList <PolizaInfo> polizas = null;
int organizacionID = 0;
var recepcionProductoDal = new RecepcionProductoDAL();
using (var transaction = new TransactionScope())
{
int usuarioID = 0;
if (GuardarInventario(recepcionProducto))
{
long almacenMovimiento = GuardarMovimientos(recepcionProducto);
recepcionProducto.AlmacenMovimientoId = almacenMovimiento;
var recepcionGuardada = recepcionProductoDal.Guardar(recepcionProducto);
if (recepcionGuardada != null)
{
foreach (var recepcionProductoDetalleInfo in recepcionProducto.ListaRecepcionProductoDetalle
)
{
recepcionProductoDetalleInfo.RecepcionProductoId = recepcionGuardada.RecepcionProductoId;
recepcionProductoDetalleInfo.UsuarioCreacion = new UsuarioInfo()
{
UsuarioID =
recepcionProducto.
UsuarioCreacion.UsuarioID
};
usuarioID = recepcionProducto.UsuarioCreacion.UsuarioID;
organizacionID = recepcionProducto.Proveedor.OrganizacionID;
recepcionProductoDetalleInfo.Activo = EstatusEnum.Activo;
}
var recepcionProductoDetalleBl = new RecepcionProductoDetalleBL();
recepcionProductoDetalleBl.Guardar(recepcionProducto.ListaRecepcionProductoDetalle);
#region POLIZA
poliza =
FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaCompraMateriaPrima);
recepcionProducto.FolioRecepcion = recepcionGuardada.FolioRecepcion;
recepcionProducto.FechaRecepcion = recepcionGuardada.FechaRecepcion;
polizas = poliza.GeneraPoliza(recepcionProducto);
if (polizas != null)
{
if (organizacionID == 0)
{
organizacionID = recepcionProducto.Almacen.Organizacion.OrganizacionID;
}
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID = organizacionID;
datos.UsuarioCreacionID = usuarioID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, TipoPoliza.EntradaCompraMateriaPrima);
pdf = poliza.ImprimePoliza(recepcionProducto, polizas);
}
#endregion POLIZA
transaction.Complete();
}
}
}
return(pdf);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}