/// <summary>
/// Obtiene el listado de lotes que tiene programados para el surtido
/// </summary>
/// <param name="pedidoDetalle"></param>
/// <returns></returns>
internal List <ProgramacionMateriaPrimaInfo> ObtenerProgramacionMateriaPrima(PedidoDetalleInfo pedidoDetalle)
{
try
{
Logger.Info();
var programacionMateriaPrimaDal = new ProgramacionMateriaPrimaDAL();
var listaProgramacion = programacionMateriaPrimaDal.ObtenerProgramacionMateriaPrima(pedidoDetalle);
if (listaProgramacion != null)
{
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenBl = new AlmacenBL();
var pesaje = new PesajeMateriaPrimaBL();
foreach (ProgramacionMateriaPrimaInfo programacionMateria in listaProgramacion)
{
programacionMateria.InventarioLoteOrigen =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
programacionMateria.InventarioLoteOrigen.AlmacenInventarioLoteId);
programacionMateria.Almacen = almacenBl.ObtenerPorID(programacionMateria.Almacen.AlmacenID);
programacionMateria.PesajeMateriaPrima =
pesaje.ObtenerPesajesPorProgramacionMateriaPrimaId(
programacionMateria.ProgramacionMateriaPrimaId);
}
}
return(listaProgramacion);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Establece los datos y el detalle del pedido
/// </summary>
/// <param name="pedido"></param>
private void EstableceDetallePedido(PedidoInfo pedido)
{
var pedidoDetalleDl = new PedidoDetalleBL();
var organizacionBl = new OrganizacionBL();
var almacenBl = new AlmacenBL();
var usuarioBl = new UsuarioBL();
var almacen = pedido.Almacen;
var organizacion = pedido.Organizacion;
var usuarioCreacion = pedido.UsuarioCreacion;
var usuarioModificacion = pedido.UsuarioModificacion;
if (almacen != null && almacen.AlmacenID > 0)
{
pedido.Almacen = almacenBl.ObtenerPorID(almacen.AlmacenID);
}
if (organizacion != null && organizacion.OrganizacionID > 0)
{
pedido.Organizacion = organizacionBl.ObtenerPorID(organizacion.OrganizacionID);
}
if (usuarioCreacion != null && usuarioCreacion.UsuarioID > 0)
{
pedido.UsuarioCreacion = usuarioBl.ObtenerPorID(usuarioCreacion.UsuarioID);
}
if (usuarioModificacion != null && usuarioModificacion.UsuarioID > 0)
{
pedido.UsuarioModificacion = usuarioBl.ObtenerPorID(usuarioModificacion.UsuarioID);
}
pedido.DetallePedido = pedidoDetalleDl.ObtenerDetallePedido(pedido);
}
/// <summary>
/// Se valida la existencia de los productos en el inventario
/// </summary>
/// <param name="tratamientos"></param>
/// <param name="almacenID"></param>
/// <returns></returns>
internal ResultadoValidacion ComprobarExistenciaTratamientos(IList <TratamientoInfo> tratamientos, int almacenID)
{
var resultado = new ResultadoValidacion
{
Resultado = true,
Mensaje = "OK",
TipoResultadoValidacion = TipoResultadoValidacion.Default
};
//Se obtiene la lista de tratamientos seleccionados
IList <TratamientoInfo> listaTratamientosSeleccionados =
tratamientos.Where(item => item.Seleccionado && item.Habilitado).ToList();
var almacenInventario = new AlmacenBL();
if (listaTratamientosSeleccionados.Count > 0)
{
foreach (var item in listaTratamientosSeleccionados)
{
if (item.Productos == null)
{
item.Productos = ObtenerProductosDelTratamiento(item);
}
foreach (var itemProducto in item.Productos)
{
//Se obtiene la cantida de inventario del producto en el almacen
var productoAlmacen = almacenInventario.ObtenerCantidadProductoEnInventario(
itemProducto,
almacenID);
if (productoAlmacen == null)
{
//No existe inventario del producto
resultado.Resultado = false;
resultado.TipoResultadoValidacion = TipoResultadoValidacion.ProductoInexistente;
resultado.Mensaje = itemProducto.ProductoDescripcion.Trim();
return(resultado);
}
if (!(productoAlmacen.Cantidad < itemProducto.Dosis))
{
continue;
}
//No existe suficiente inventario del producto
resultado.Resultado = false;
resultado.TipoResultadoValidacion = TipoResultadoValidacion.InventarioInsuficiente;
resultado.Mensaje = itemProducto.ProductoDescripcion.Trim();
return(resultado);
}
}
}
else
{
//No han seleccionado tratamientos
resultado.Resultado = false;
resultado.TipoResultadoValidacion = TipoResultadoValidacion.TratamientosNoSeleccionados;
return(resultado);
}
return(resultado);
}
/// <summary>
/// Se eliminan los registros no seleccionados en AlmacenMovimientoDetalle
/// </summary>
/// <param name="articulo"></param>
/// <param name="almacenMovimientoInfo"></param>
public void EliminarAlmacenMovimientoDetalle(AjusteDeInventarioDiferenciasInventarioInfo articulo, AlmacenMovimientoInfo almacenMovimientoInfo)
{
var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
{
AlmacenMovimientoDetalleID = articulo.AlmacenMovimientoDetalleID
};
var almacenBL = new AlmacenBL();
almacenBL.EliminaAlmacenMovimientoDetalle(almacenMovimientoDetalleInfo);
}
/// <summary>
/// Se actualizan los registros seleccionados en AlmacenInventario
/// </summary>
/// <param name="articulo"></param>
/// <param name="almacenMovimientoInfo"></param>
public void ActualizarArticulosDiferencias(AjusteDeInventarioDiferenciasInventarioInfo articulo, AlmacenMovimientoInfo almacenMovimientoInfo)
{
var cantidad = articulo.CantidadInventarioTeorico + articulo.Cantidad;
var almacenInventarioInfo = new AlmacenInventarioInfo
{
Cantidad = cantidad,
Importe = cantidad * articulo.PrecioInventarioTeorico,
UsuarioModificacionID = almacenMovimientoInfo.UsuarioModificacionID,
AlmacenInventarioID = articulo.AlmacenInventarioID
};
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenInventario(almacenInventarioInfo);
}
/// <summary>
/// Obtiene el almacen en base al id
/// </summary>
/// <param name="almacenInventarioId"></param>
/// <returns></returns>
internal AlmacenInventarioInfo ObtenerAlmacenInventarioPorId(int almacenInventarioId)
{
AlmacenInventarioInfo almacen = null;
try
{
var almacenDAL = new AlmacenInventarioDAL();
var almacenBl = new AlmacenBL();
almacen = almacenDAL.ObtenerAlmacenInventarioPorId(almacenInventarioId);
if (almacen != null)
{
almacen.Almacen = almacenBl.ObtenerPorID(almacen.AlmacenID);
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(almacen);
}
/// <summary>
/// Termina la salida del producto
/// </summary>
/// <param name="salida"></param>
/// <returns></returns>
internal MemoryStream TerminarSalidaProducto(SalidaProductoInfo salida)
{
try
{
Logger.Info();
bool generaFactura = salida.GeneraFactura;
MemoryStream resultado = null;
var almacenBl = new AlmacenBL();
var almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL();
var almacenMovimiento = new AlmacenMovimientoInfo();
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenInventarioBl = new AlmacenInventarioBL();
var salidaProductoDal = new SalidaProductoDAL();
PolizaAbstract poliza = null;
IList <PolizaInfo> polizas = null;
using (var transaction = new TransactionScope())
{
almacenMovimiento.AlmacenID = salida.Almacen.AlmacenID;
almacenMovimiento.TipoMovimientoID = salida.TipoMovimiento.TipoMovimientoID;
almacenMovimiento.UsuarioCreacionID = salida.UsuarioModificacionId;
almacenMovimiento.Status = (int)EstatusInventario.Aplicado;
AlmacenMovimientoInfo almacenMovimientoGenerado =
almacenBl.GuardarAlmacenMovimiento(almacenMovimiento);
if (almacenMovimientoGenerado != null)
{
AlmacenInventarioLoteInfo almacenInventarioLote =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
salida.AlmacenInventarioLote.AlmacenInventarioLoteId);
var listaAlmacenInventarioDetalle = new List <AlmacenMovimientoDetalle>();
var movimientoDetalle = new AlmacenMovimientoDetalle
{
AlmacenMovimientoID =
almacenMovimientoGenerado.AlmacenMovimientoID,
AlmacenInventarioLoteId =
salida.AlmacenInventarioLote.AlmacenInventarioLoteId,
Precio = almacenInventarioLote.PrecioPromedio,
ProductoID = salida.Producto.ProductoId,
Cantidad = salida.PesoBruto - salida.PesoTara,
Piezas = salida.Piezas,
Importe =
(salida.PesoBruto - salida.PesoTara) *
almacenInventarioLote.PrecioPromedio,
UsuarioCreacionID = salida.UsuarioModificacionId
};
listaAlmacenInventarioDetalle.Add(movimientoDetalle);
almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(listaAlmacenInventarioDetalle,
almacenMovimientoGenerado.
AlmacenMovimientoID);
if (almacenInventarioLote != null)
{
almacenInventarioLote.Cantidad = almacenInventarioLote.Cantidad -
(salida.PesoBruto - salida.PesoTara);
almacenInventarioLote.Importe = almacenInventarioLote.PrecioPromedio *
almacenInventarioLote.Cantidad;
almacenInventarioLote.UsuarioModificacionId = salida.UsuarioModificacionId;
almacenInventarioLoteBl.Actualizar(almacenInventarioLote);
AlmacenInfo almacen = almacenBl.ObtenerPorID(almacenMovimiento.AlmacenID);
List <AlmacenInventarioInfo> listaAlmacenlmacenInventario =
almacenInventarioBl.ObtienePorAlmacenId(almacen);
if (listaAlmacenlmacenInventario != null)
{
AlmacenInventarioInfo inventarioProducto = listaAlmacenlmacenInventario.FirstOrDefault(
registro => registro.ProductoID == salida.Producto.ProductoId);
if (inventarioProducto != null)
{
inventarioProducto.Cantidad = inventarioProducto.Cantidad -
(salida.PesoBruto - salida.PesoTara);
inventarioProducto.Importe = (inventarioProducto.PrecioPromedio *
inventarioProducto.Cantidad);
//Actualiza inventario
inventarioProducto.UsuarioModificacionID = salida.UsuarioModificacionId;
inventarioProducto.ProductoID = salida.Producto.ProductoId;
inventarioProducto.AlmacenID = almacen.AlmacenID;
almacenInventarioBl.ActualizarPorProductoId(inventarioProducto);
salida.GeneraFactura = generaFactura;
salidaProductoDal.TerminarSalidaProducto(salida, almacenMovimientoGenerado);
#region POLIZA
poliza =
FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(
TipoPoliza.SalidaVentaProducto);
salida.Importe = (salida.PesoBruto - salida.PesoTara) * salida.Precio;
salida = ObtenerFolioPorReimpresion(salida);
polizas = poliza.GeneraPoliza(salida);
if (polizas != null)
{
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID =
salida.Organizacion.OrganizacionID;
datos.UsuarioCreacionID =
salida.UsuarioCreacionId;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaVentaProducto);
if (salida.Almacen == null)
{
salida.Almacen = new AlmacenInfo();
}
salida.Almacen.Organizacion = new OrganizacionInfo
{
OrganizacionID =
salida.Organizacion.OrganizacionID
};
resultado = poliza.ImprimePoliza(salida, polizas);
}
#endregion POLIZA
if (generaFactura)
{
#region FACTURA
if (salida.TipoMovimiento.TipoMovimientoID ==
TipoMovimiento.ProductoSalidaVenta.GetHashCode())
{
//Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaVentaDeMateriaPrima(salida);
}
#endregion
}
transaction.Complete();
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
else
{
throw new ExcepcionDesconocida(
Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
}
}
return(resultado);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionDesconocida)
{
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// guardar corte por transferencia
/// </summary>
/// <param name="guardarAnimalCorte"></param>
/// <param name="listaTratamientos"></param>
/// <returns></returns>
internal CorteTransferenciaGanadoGuardarInfo GuardarCorteTransferencia(CorteTransferenciaGanadoGuardarInfo guardarAnimalCorte, IList <TratamientoInfo> listaTratamientos)
{
try
{
using (var transaction = new TransactionScope())
{
Logger.Info();
//var corteTransferenciaGanado = new CorteTransferenciaGanadoDAL();
var animalBl = new AnimalBL();
var animalMovimientoBL = new AnimalMovimientoBL();
var corralBl = new CorralBL();
var interfaceSalidaAnimalBl = new InterfaceSalidaAnimalBL();
var interfaceSalidoAnimalInfo =
interfaceSalidaAnimalBl.ObtenerNumeroAreteIndividual(
guardarAnimalCorte.AnimalCorteTransferenciaInfo.Arete, guardarAnimalCorte.OrganizacionId);
if (guardarAnimalCorte.AnimalActualInfo != null)
{
guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra =
guardarAnimalCorte.AnimalActualInfo.FechaCompra;
}
else
{
if (interfaceSalidoAnimalInfo != null)
{
guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra =
interfaceSalidoAnimalInfo.FechaCompra;
}
}
var resultoAnimalInfo = animalBl.GuardarAnimal(guardarAnimalCorte.AnimalCorteTransferenciaInfo);
guardarAnimalCorte.AnimalCorteTransferenciaInfo = resultoAnimalInfo;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalID =
guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID;
var loteBl = new LoteBL();
var resultadoLote = -1;
var resultadoLoteOrigen = loteBl.ObtenerPorID(guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID);
var resultadoLoteBL =
loteBl.ObtenerLotesActivos(
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.OrganizacionID,
Convert.ToInt32(guardarAnimalCorte.CorralInfoGen.CorralID));
if (resultadoLoteBL == null)
{
//var corralInfo = new CorralInfo
//{
// Codigo = guardarAnimalCorte.TxtCorralDestino,
// TipoCorral = new TipoCorralInfo { TipoCorralID = (int)TipoCorral.Improductivos },
// Organizacion = new OrganizacionInfo { OrganizacionID = guardarAnimalCorte.OrganizacionId }
//};
CorralInfo resultadoCorralPl = corralBl.ObtenerPorId(guardarAnimalCorte.CorralDestinoID);
if (resultadoCorralPl != null)
{
var loteCrear = new LoteBL();
var tipoProcesoBl = new TipoProcesoBL();
var tipoProcesoResult =
tipoProcesoBl.ObtenerPorOrganizacion(guardarAnimalCorte.OrganizacionId);
var loteInfoLote = new LoteInfo
{
Activo = EstatusEnum.Activo,
Cabezas = Convert.ToInt32(0),
CabezasInicio = Convert.ToInt32(0),
CorralID = resultadoCorralPl.CorralID,
DisponibilidadManual = false,
OrganizacionID =
guardarAnimalCorte.AnimalMovimientoOrigenInfo.OrganizacionID,
TipoCorralID = resultadoCorralPl.TipoCorral.TipoCorralID,
TipoProcesoID = tipoProcesoResult,
UsuarioCreacionID = resultadoCorralPl.UsuarioCreacionID,
};
resultadoLote = loteCrear.GuardaLote(loteInfoLote);
guardarAnimalCorte.LoteDestinoInfo = loteCrear.ObtenerPorID(resultadoLote);
}
}
else
{
guardarAnimalCorte.LoteDestinoInfo = resultadoLoteBL;
}
//Se manda a guardar movimiento de salida de enfermeria
//var animalSalidaInfo = new AnimalSalidaInfo();
//animalSalidaInfo = animalBl.ObtenerAnimalSalidaAnimalID(guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID);
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID = animalSalidaInfo.CorralId;
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = animalSalidaInfo.LoteId;
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID = (int)TipoMovimiento.SalidaEnfermeria;
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo = animalMovimientoBL.GuardarAnimalMovimiento(guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo);
//Se manda a guardar movimiento de corte por transferencia
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID =
guardarAnimalCorte.CorralInfoGen.CorralID;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = resultadoLoteBL != null
? resultadoLoteBL.LoteID
: resultadoLote;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID =
(int)TipoMovimiento.CortePorTransferencia;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo =
animalMovimientoBL.GuardarAnimalMovimiento(
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo);
if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null &&
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalMovimientoID > 0)
{
if (resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null)
{
guardarAnimalCorte.CorralGlobal = guardarAnimalCorte.AnimalMovimientoOrigenInfo.CorralID;
guardarAnimalCorte.LoteDestinoInfo.Cabezas = guardarAnimalCorte.LoteDestinoInfo.Cabezas + 1;
guardarAnimalCorte.LoteDestinoInfo.CabezasInicio =
guardarAnimalCorte.LoteDestinoInfo.CabezasInicio + 1;
resultadoLoteOrigen.Cabezas = resultadoLoteOrigen.Cabezas - 1;
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = resultadoLoteOrigen.LoteID,
LoteIDDestino = guardarAnimalCorte.LoteDestinoInfo.LoteID,
CabezasProcesadas = 1,
UsuarioModificacionID =
guardarAnimalCorte.UsuarioCreacionID
};
var cabezas = loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
//TODO nuevo metodo
//loteBl.ActualizaNoCabezasEnLote(guardarAnimalCorte.LoteDestinoInfo, resultadoLoteOrigen);
loteBl.ActualizarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo);
loteBl.ActualizarFechaSalidaEnLote(resultadoLoteOrigen);
//if (resultadoLoteOrigen.Cabezas == 0)
//{
// resultadoLoteOrigen.Activo = (int)EstatusEnum.Inactivo;
// loteBl.ActualizaActivoEnLote(resultadoLoteOrigen);
//}
// ObtenerTotalCabezas(loteCorralOrigen);
}
if (ObtenerTotalCabezas(guardarAnimalCorte.AnimalMovimientoOrigenInfo))
{
corralBl.TraspasarAnimalSalidaEnfermeria(
guardarAnimalCorte.AnimalSalidaGuardarInfo.CorraletaId,
guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID);
//loteDAL.EliminarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo);
}
}
if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null)
{
var almacenMovimientoInfo = new AlmacenMovimientoInfo
{
AlmacenID = guardarAnimalCorte.AlmacenID,
AnimalMovimientoID =
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo
.AnimalMovimientoID,
TipoMovimientoID = (int)TipoMovimiento.SalidaPorConsumo,
Status = (int)EstatusInventario.Aplicado,
Observaciones = "",
UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID,
AnimalID =
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo
.AnimalID,
//Verificar
CostoID = (int)Costo.MedicamentoDeImplante,
};
var almacenBL = new AlmacenBL();
almacenBL.GuardarDescontarTratamientos(
listaTratamientos.Where(item => item.Seleccionado && item.Habilitado).ToList(),
almacenMovimientoInfo);
}
var loteProyeccionBL = new LoteProyeccionBL();
LoteProyeccionInfo proyeccionDestino =
loteProyeccionBL.ObtenerPorLote(guardarAnimalCorte.LoteDestinoInfo);
//guardarAnimalCorte.LoteDestinoInfo.LoteID
if (proyeccionDestino == null)
{
LoteProyeccionInfo proyeccionOrigen = loteProyeccionBL.ObtenerPorLote(resultadoLoteOrigen);
if (proyeccionOrigen != null && resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null)
{
proyeccionOrigen.LoteProyeccionID = 0;
int diasEngordaOrigen = proyeccionOrigen.DiasEngorda;
DateTime fechaInicioLote = resultadoLoteOrigen.FechaInicio;
int diasEngordaReales =
new TimeSpan(DateTime.Now.Ticks - fechaInicioLote.Ticks).Days;
if ((diasEngordaOrigen - diasEngordaReales) <= 0)
{
proyeccionOrigen.DiasEngorda = 0;
}
else
{
proyeccionOrigen.DiasEngorda = diasEngordaOrigen - diasEngordaReales;
}
proyeccionOrigen.LoteID = guardarAnimalCorte.LoteDestinoInfo.LoteID;
proyeccionOrigen.UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID;
loteProyeccionBL.Guardar(proyeccionOrigen);
var loteDAL = new LoteDAL();
var filtroDisponibilidad = new FiltroDisponilidadInfo
{
UsuarioId = guardarAnimalCorte.UsuarioCreacionID,
ListaLoteDisponibilidad =
new List <DisponibilidadLoteInfo>
{
new DisponibilidadLoteInfo
{
LoteId = guardarAnimalCorte.LoteDestinoInfo.LoteID,
FechaDisponibilidad =
resultadoLoteOrigen.FechaDisponibilidad,
DisponibilidadManual =
resultadoLoteOrigen.DisponibilidadManual
}
}
};
loteDAL.ActualizarLoteDisponibilidad(filtroDisponibilidad);
}
}
transaction.Complete();
return(guardarAnimalCorte);
}
}
catch (ExcepcionGenerica)
{
return(null);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Crea el nuevo lote para la organizacion producto tipo almacen seleccionados
/// </summary>
/// <param name="parametro"></param>
/// <returns></returns>
internal AlmacenInventarioLoteInfo CrearLotePorOrganizacionTipoAlmacenProducto(ParametrosOrganizacionTipoAlmacenProductoActivo parametro)
{
try
{
var almacenBl = new AlmacenBL();
var almacenInventarioBl = new AlmacenInventarioBL();
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
AlmacenInventarioLoteInfo almacenInventarioLote = null;
var almacenInventario =
almacenBl.ObtenerAlmacenInventarioPorOrganizacionTipoAlmacen(new ParametrosOrganizacionTipoAlmacenProductoActivo
{
OrganizacionId = parametro.OrganizacionId,
TipoAlmacenId = parametro.TipoAlmacenId,
Activo = parametro.Activo,
ProductoId = parametro.ProductoId
});
// Si el producto no se encuentra en el almacen inventario, lo insertamos
if (almacenInventario == null)
{
var listaAlmacenOrganizacion = almacenBl.ObtenerAlmacenPorOrganizacion(parametro.OrganizacionId);
if (listaAlmacenOrganizacion != null)
{
// Obtenemos el almacen y validamos que sea del mismo tipo Almacen
foreach (AlmacenInfo almacenInfo in listaAlmacenOrganizacion)
{
// Aqui se valida que el almacen sea del tipo seleccionado
if (almacenInfo.TipoAlmacen.TipoAlmacenID == parametro.TipoAlmacenId)
{
almacenInventario = new AlmacenInventarioInfo
{
AlmacenInventarioID =
almacenInventarioBl.Crear(new AlmacenInventarioInfo
{
AlmacenID = almacenInfo.AlmacenID,
ProductoID = parametro.ProductoId,
UsuarioCreacionID = parametro.UsuarioId
}),
AlmacenID = almacenInfo.AlmacenID
};
break;
}
}
}
}
if (almacenInventario != null)
{
int loteIdCreado = almacenInventarioLoteBl.Crear(new AlmacenInventarioLoteInfo
{
AlmacenInventarioLoteId = 0,
AlmacenInventario =
new AlmacenInventarioInfo
{
AlmacenInventarioID = almacenInventario.AlmacenInventarioID
},
Cantidad = 0,
PrecioPromedio = 0,
Piezas = 0,
Importe = 0,
Activo = (EstatusEnum)parametro.Activo,
UsuarioCreacionId = parametro.UsuarioId,
}, new AlmacenInventarioInfo
{
AlmacenID = almacenInventario.AlmacenID,
ProductoID = parametro.ProductoId
});
almacenInventarioLote =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(loteIdCreado);
}
return(almacenInventarioLote);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Se actualiza en AlmacenMovimiento
/// </summary>
/// <param name="almacenMovimientoInfo"></param>
public void ActualizarAlmacenMovimiento(AlmacenMovimientoInfo almacenMovimientoInfo)
{
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
}
/// <summary>
/// Metodo para actualizar los ajustes de inventario contenidos en el grid
/// </summary>
/// <param name="articulosDiferenciasInventario"></param>
/// <param name="almacenMovimientoInfo"></param>
/// <returns></returns>
public IList <ResultadoPolizaModel> GuardarAjusteDeInventario(List <AjusteDeInventarioDiferenciasInventarioInfo> articulosDiferenciasInventario, AlmacenMovimientoInfo almacenMovimientoInfo)
{
try
{
var resultadosPolizaModel = new List <ResultadoPolizaModel>();
PolizaAbstract poliza = null;
var cierreDiaInventarioDAL = new CierreDiaInventarioDAL();
var almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL();
var articulosEntrada = new List <AjusteDeInventarioDiferenciasInventarioInfo>();
var articulosSalida = new List <AjusteDeInventarioDiferenciasInventarioInfo>();
using (var transaction = new TransactionScope())
{
Logger.Info();
if (articulosDiferenciasInventario != null)
{
var seleccionados =
articulosDiferenciasInventario.Any(articulosComprobar => articulosComprobar.Seleccionado);
if (seleccionados)
{
foreach (var articulos in articulosDiferenciasInventario.Where(art => art.Seleccionado))
{
ActualizarArticulosDiferencias(articulos, almacenMovimientoInfo);
}
almacenMovimientoInfo.Status = (int)EstatusInventario.Aplicado;
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
articulosEntrada =
articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad > 0)).
ToList();
articulosSalida =
articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad < 0)).
ToList();
//Generar los Movimientos de Entrada y Salida
#region Movimientos Entrada
if (articulosEntrada.Any())
{
var movimientoEntrada = new AlmacenCierreDiaInventarioInfo
{
Almacen = almacenMovimientoInfo.Almacen,
TipoMovimiento =
TipoMovimiento.EntradaPorAjuste.GetHashCode(),
Observaciones = almacenMovimientoInfo.Observaciones,
Estatus = EstatusInventario.Autorizado.GetHashCode(),
UsuarioCreacionId =
almacenMovimientoInfo.UsuarioModificacionID
};
var movimientosEntrada = (from detalle in articulosEntrada
select new AlmacenMovimientoDetalle
{
ProductoID = detalle.ProductoID,
Precio = detalle.Precio,
Cantidad = Math.Abs(detalle.Cantidad),
Importe =
Math.Round(
Convert.ToDecimal(
Math.Abs(detalle.Cantidad)) *
detalle.Precio, 2),
UsuarioCreacionID =
almacenMovimientoInfo.UsuarioModificacionID
}).ToList();
AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoEntrada);
almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosEntrada,
resultadoAlmacenMovimiento.
AlmacenMovimientoID);
}
#endregion Movimientos Entrada
#region Movimientos Salida
if (articulosSalida.Any())
{
var movimientoSalida = new AlmacenCierreDiaInventarioInfo
{
Almacen = almacenMovimientoInfo.Almacen,
TipoMovimiento =
TipoMovimiento.SalidaPorAjuste.GetHashCode(),
Observaciones = almacenMovimientoInfo.Observaciones,
Estatus = EstatusInventario.Autorizado.GetHashCode(),
UsuarioCreacionId =
almacenMovimientoInfo.UsuarioModificacionID
};
var movimientosSalida = (from detalle in articulosSalida
select new AlmacenMovimientoDetalle
{
ProductoID = detalle.ProductoID,
Precio = detalle.Precio,
Cantidad = Math.Abs(detalle.Cantidad),
Importe =
Math.Round(
Convert.ToDecimal(
Math.Abs(detalle.Cantidad)) *
detalle.Precio, 2),
UsuarioCreacionID =
almacenMovimientoInfo.UsuarioModificacionID
}).ToList();
AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoSalida);
almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosSalida,
resultadoAlmacenMovimiento.
AlmacenMovimientoID);
}
#endregion Movimientos Entrada
}
else
{
almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado;
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
}
#region POLIZA
#region PolizaSalida
MemoryStream stream;
if (articulosSalida.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaAjuste);
List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
articulosSalida.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
{
Importe = Math.Abs(ajuste.Importe),
Cantidad = Math.Abs(ajuste.Cantidad),
TipoAjuste = TipoAjusteEnum.Merma,
Precio = ajuste.Precio,
AlmacenInventarioID =
ajuste.AlmacenInventarioID,
AlmacenMovimientoDetalleID =
ajuste.AlmacenMovimientoDetalleID,
ProductoID = ajuste.ProductoID,
CantidadInventarioFisico =
ajuste.CantidadInventarioFisico,
CantidadInventarioTeorico =
ajuste.CantidadInventarioTeorico,
Observaciones =
almacenMovimientoInfo.Observaciones
}).ToList();
if (salidasPorAjuste.Any())
{
IList <PolizaInfo> polizasSalida = poliza.GeneraPoliza(salidasPorAjuste);
if (polizasSalida != null)
{
stream = poliza.ImprimePoliza(salidasPorAjuste, polizasSalida);
var polizaBL = new PolizaBL();
polizasSalida.ToList().ForEach(datos =>
{
datos.UsuarioCreacionID =
almacenMovimientoInfo.
UsuarioModificacionID;
datos.OrganizacionID =
almacenMovimientoInfo.OrganizacionID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizasSalida, TipoPoliza.SalidaAjuste);
var resultadoPolizaModel = new ResultadoPolizaModel
{
Polizas = polizasSalida,
PDFs =
new Dictionary <TipoPoliza, MemoryStream>
{
{ TipoPoliza.SalidaAjuste, stream }
}
};
resultadosPolizaModel.Add(resultadoPolizaModel);
}
}
}
#endregion PolizaSalida
#region PolizaEntrada
if (articulosEntrada.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaAjuste);
List <PolizaEntradaSalidaPorAjusteModel> entradasPorAjuste =
articulosEntrada.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
{
Importe = Math.Abs(ajuste.Importe),
Cantidad = Math.Abs(ajuste.Cantidad),
TipoAjuste = TipoAjusteEnum.Merma,
Precio = ajuste.Precio,
AlmacenInventarioID =
ajuste.AlmacenInventarioID,
AlmacenMovimientoDetalleID =
ajuste.AlmacenMovimientoDetalleID,
ProductoID = ajuste.ProductoID,
CantidadInventarioFisico =
ajuste.CantidadInventarioFisico,
CantidadInventarioTeorico =
ajuste.CantidadInventarioTeorico,
Observaciones =
almacenMovimientoInfo.Observaciones
}).ToList();
if (entradasPorAjuste.Any())
{
IList <PolizaInfo> polizasEntrada = poliza.GeneraPoliza(entradasPorAjuste);
if (polizasEntrada != null)
{
stream = poliza.ImprimePoliza(entradasPorAjuste, polizasEntrada);
var polizaBL = new PolizaBL();
polizasEntrada.ToList().ForEach(datos =>
{
datos.UsuarioCreacionID =
almacenMovimientoInfo.
UsuarioModificacionID;
datos.OrganizacionID =
almacenMovimientoInfo.OrganizacionID;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizasEntrada, TipoPoliza.EntradaAjuste);
var resultadoPolizaModel = new ResultadoPolizaModel
{
Polizas = polizasEntrada,
PDFs =
new Dictionary <TipoPoliza, MemoryStream>
{
{ TipoPoliza.EntradaAjuste, stream }
}
};
resultadosPolizaModel.Add(resultadoPolizaModel);
}
}
}
#endregion PolizaEntrada
#endregion POLIZA
}
else
{
almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado;
var almacenBL = new AlmacenBL();
almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
}
transaction.Complete();
}
return(resultadosPolizaModel);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica ex)
{
Logger.Error(ex);
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
return(null);
}
}
/// <summary>
/// Actualiza la recepcion de materia prima
/// </summary>
/// <param name="listaSurtido"></param>
/// <param name="pedido"></param>
/// <returns></returns>
internal bool ActualizarRecepcionMateriaPrima(List <SurtidoPedidoInfo> listaSurtido, PedidoInfo pedido)
{
bool resultado;
try
{
Logger.Info();
var almacenInventarioBl = new AlmacenInventarioBL();
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenBl = new AlmacenBL();
var proveedorChofeBl = new ProveedorChoferBL();
int proveedorId = 0;
var pesajeMateriaPrimaBl = new PesajeMateriaPrimaBL();
int organizacionID;
PolizaAbstract poliza;
IList <PolizaInfo> polizas;
IList <ResultadoPolizaModel> resultadoPolizaModel;
var contenedorAlmacenesMovimientos = new List <ContenedorAlmacenMovimientoCierreDia>();
ContenedorAlmacenMovimientoCierreDia contenedorAlmacenMovimiento;
var surtidoGenerarPoliza = new List <SurtidoPedidoInfo>();
using (var transaction = new TransactionScope())
{
ProgramacionMateriaPrimaInfo programacionMateriaPrima;
var programacionMateriaPrimaBL = new ProgramacionMateriaPrimaBL();
foreach (var surtidoTmp in listaSurtido)
{
if (surtidoTmp.Seleccionado)
{
programacionMateriaPrima = programacionMateriaPrimaBL.
ObtenerPorProgramacionMateriaPrimaTicket(
surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId,
surtidoTmp.PesajeMateriaPrima.Ticket);
if (programacionMateriaPrima != null)
{
continue;
}
surtidoGenerarPoliza.Add(surtidoTmp);
var pesaje = pesajeMateriaPrimaBl.ObtenerPorId(surtidoTmp.PesajeMateriaPrima);
// Se consulta el proveedor del Proveedor chofer seleccionado para el pesaje.
var proveedorChofeInfo = proveedorChofeBl.ObtenerProveedorChoferPorId(
surtidoTmp.PesajeMateriaPrima.ProveedorChoferID);
if (proveedorChofeInfo != null)
{
proveedorId = proveedorChofeInfo.Proveedor.ProveedorID;
}
//SE OBTIENEN LOS DATOS DEL LOTE DESTINO
var almacenInventarioLoteDestino =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
surtidoTmp.PedidoDetalle.InventarioLoteDestino.AlmacenInventarioLoteId);
//SE OBTIENEN LOS DATOS DEL LOTE ORIGEN
var almacenInventarioLoteOrigen =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
surtidoTmp.ProgramacionMateriaPrima.InventarioLoteOrigen
.AlmacenInventarioLoteId);
#region INVENTARIO ORIGEN
// GENERA MOVIMIENTO DE INVENTARIO
var almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo
{
AlmacenID =
almacenInventarioLoteOrigen
.AlmacenInventario.
AlmacenID,
TipoMovimientoID =
(int)
TipoMovimiento.
PaseProceso,
Observaciones = "",
Status = (int)EstatusInventario.Aplicado,
AnimalMovimientoID = 0,
ProveedorId = proveedorId,
UsuarioCreacionID =
pedido.
UsuarioModificacion.
UsuarioID
});
// SE LE ASIGNA EL MOVIMIENTO GENERADO AL PESAJE
pesaje.AlmacenMovimientoOrigenId = almacenMovimiento.AlmacenMovimientoID;
contenedorAlmacenMovimiento = new ContenedorAlmacenMovimientoCierreDia
{
AlmacenMovimiento = new AlmacenMovimientoInfo
{
AlmacenMovimientoID =
almacenMovimiento.
AlmacenMovimientoID
}
};
contenedorAlmacenesMovimientos.Add(contenedorAlmacenMovimiento);
// GENERA EL DETALLE DEL MOVIMIENTO
almacenBl.GuardarAlmacenMovimientoDetalleProducto(
new AlmacenMovimientoDetalle
{
AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID,
ProductoID = surtidoTmp.Producto.ProductoId,
Precio = almacenInventarioLoteOrigen.PrecioPromedio,
Cantidad = surtidoTmp.CantidadEntregada,
Importe =
almacenInventarioLoteOrigen.PrecioPromedio * surtidoTmp.CantidadEntregada,
AlmacenInventarioLoteId =
almacenInventarioLoteOrigen.AlmacenInventarioLoteId,
ContratoId = 0,
Piezas = surtidoTmp.PesajeMateriaPrima.Piezas,
UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID
});
// GENERA LA SALIDA DEL INVENTARIO LOTE
almacenInventarioLoteOrigen.Cantidad -= surtidoTmp.CantidadEntregada;
almacenInventarioLoteOrigen.Piezas -= surtidoTmp.PesajeMateriaPrima.Piezas;
almacenInventarioLoteOrigen.Importe = almacenInventarioLoteOrigen.PrecioPromedio *
almacenInventarioLoteOrigen.Cantidad;
almacenInventarioLoteOrigen.UsuarioModificacionId =
pedido.UsuarioModificacion.UsuarioID;
almacenInventarioLoteBl.Actualizar(almacenInventarioLoteOrigen);
// GENERA LA SALIDA DEL ALMACEN INVENTARIO
var almacenInventarioInfo =
almacenInventarioBl.ObtenerAlmacenInventarioPorId(
almacenInventarioLoteOrigen.AlmacenInventario.AlmacenInventarioID);
almacenInventarioInfo.Cantidad = almacenInventarioInfo.Cantidad -
surtidoTmp.CantidadEntregada;
almacenInventarioInfo.Importe = almacenInventarioInfo.PrecioPromedio *
almacenInventarioInfo.Cantidad;
almacenInventarioInfo.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
almacenInventarioBl.Actualizar(almacenInventarioInfo);
#endregion
#region INVENTARIO DESTINO
//Obtener costos de flete
var fleteInternoPl = new FleteInternoPL();
var listadoCostos = fleteInternoPl.ObtenerCostosPorFleteConfiguracion(new FleteInternoInfo
{
Organizacion =
new OrganizacionInfo {
OrganizacionID = pedido.Organizacion.OrganizacionID
},
AlmacenOrigen = new AlmacenInfo {
AlmacenID = almacenInventarioLoteOrigen.AlmacenInventario.AlmacenID
},
Producto = new ProductoInfo {
ProductoId = surtidoTmp.Producto.ProductoId
}
}, new ProveedorInfo {
ProveedorID = surtidoTmp.Proveedor.ProveedorID
});
decimal importeCostos = 0;
if (listadoCostos != null)
{
foreach (var fleteInternoCostoInfo in listadoCostos)
{
if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode())
{
importeCostos += fleteInternoCostoInfo.Tarifa;
}
else
{
importeCostos += (surtidoTmp.CantidadEntregada / 1000) *
fleteInternoCostoInfo.Tarifa;
}
}
//importeCostos = listadoCostos.Sum(fleteInternoCostoInfo => fleteInternoCostoInfo.Tarifa);
}
almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo
{
AlmacenID =
almacenInventarioLoteDestino
.AlmacenInventario.
AlmacenID,
TipoMovimientoID =
(int)
TipoMovimiento.
RecepcionAProceso,
Observaciones =
pedido.Observaciones,
Status = (int)EstatusInventario.Aplicado,
AnimalMovimientoID = 0,
ProveedorId = proveedorId,
UsuarioCreacionID =
pedido.
UsuarioModificacion.
UsuarioID
});
// SE LE ASIGNA EL MOVIMIENTO AL PESAJE
pesaje.AlmacenMovimientoDestinoId = almacenMovimiento.AlmacenMovimientoID;
// GENERA LA ENTRADA DEL INVENTARIO LOTE
almacenInventarioLoteDestino.Piezas += surtidoTmp.PesajeMateriaPrima.Piezas;
decimal importe = surtidoTmp.CantidadEntregada *
almacenInventarioLoteOrigen.PrecioPromedio;
almacenInventarioLoteDestino.Importe += importe;
almacenInventarioLoteDestino.Cantidad += surtidoTmp.CantidadEntregada;
almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe /
almacenInventarioLoteDestino.Cantidad;
almacenInventarioLoteDestino.UsuarioModificacionId =
pedido.UsuarioModificacion.UsuarioID;
//
//Se agregan los costos al importe del lote
//importeCostos = importeCostos * surtidoTmp.CantidadEntregada;
almacenInventarioLoteDestino.Importe = almacenInventarioLoteDestino.Importe + importeCostos;
almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe /
almacenInventarioLoteDestino.Cantidad;
//
almacenInventarioLoteBl.Actualizar(almacenInventarioLoteDestino);
// GENERA EL DETALLE DEL MOVIMIENTO
almacenBl.GuardarAlmacenMovimientoDetalleProducto(
new AlmacenMovimientoDetalle
{
AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID,
ProductoID = surtidoTmp.Producto.ProductoId,
Precio = almacenInventarioLoteOrigen.PrecioPromedio,
Cantidad = surtidoTmp.CantidadEntregada,
Importe = importe,
AlmacenInventarioLoteId =
almacenInventarioLoteDestino.AlmacenInventarioLoteId,
ContratoId = 0,
Piezas = surtidoTmp.PesajeMateriaPrima.Piezas,
UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID
});
//Guarda almacen movimiento costo
if (listadoCostos != null)
{
foreach (var fleteInternoCostoInfo in listadoCostos)
{
var almacenMovimientoCosto = new AlmacenMovimientoCostoBL();
decimal importeCostoFlete = 0;
if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode())
{
importeCostoFlete = fleteInternoCostoInfo.Tarifa;
}
else
{
importeCostoFlete = (surtidoTmp.CantidadEntregada / 1000) *
fleteInternoCostoInfo.Tarifa;
}
almacenMovimientoCosto.Crear(new AlmacenMovimientoCostoInfo
{
AlmacenMovimientoId = almacenMovimiento.AlmacenMovimientoID,
ProveedorId = surtidoTmp.Proveedor.ProveedorID,
CostoId = fleteInternoCostoInfo.Costo.CostoID,
Importe = importeCostoFlete,
Cantidad = surtidoTmp.CantidadEntregada,
Activo = EstatusEnum.Activo,
UsuarioCreacionId = pedido.UsuarioModificacion.UsuarioID
});
}
}
//
programacionMateriaPrimaBL.ActualizarAlmacenMovimiento(
surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId,
almacenMovimiento.AlmacenMovimientoID);
// GENERA LA ENTRADA DEL ALMACEN INVENTARIO
almacenInventarioInfo =
almacenInventarioBl.ObtenerAlmacenInventarioPorId(
almacenInventarioLoteDestino.AlmacenInventario.AlmacenInventarioID);
List <AlmacenInventarioLoteInfo> listaAlmacenInventarioLote =
almacenInventarioLoteBl.ObtenerPorAlmacenInventarioID(almacenInventarioInfo);
var almacenInventario = new AlmacenInventarioInfo();
almacenInventario.AlmacenInventarioID = almacenInventarioInfo.AlmacenInventarioID;
// SE SUMAN LAS CANTIDADES E IMPORTES QUE TIENE EL ALMACEN
foreach (var almacenInventarioLoteInfo in listaAlmacenInventarioLote)
{
almacenInventario.Cantidad += almacenInventarioLoteInfo.Cantidad;
almacenInventario.Importe += almacenInventarioLoteInfo.Importe;
}
almacenInventario.PrecioPromedio = almacenInventario.Importe /
almacenInventario.Cantidad;
almacenInventario.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
almacenInventario.ProductoID = surtidoTmp.Producto.ProductoId;
almacenInventario.AlmacenID =
almacenInventarioLoteDestino.AlmacenInventario.AlmacenID;
almacenInventarioBl.ActualizarPorProductoId(almacenInventario);
#endregion
// SE ACTUALIZA EL PESAJE DE MATERIA PRIMA
pesaje.EstatusID = (int)Estatus.PedidoCompletado;
pesaje.Activo = false;
pesaje.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
pesajeMateriaPrimaBl.ActualizarPesajePorId(pesaje);
}
}
#region POLIZA
organizacionID = pedido.Organizacion.OrganizacionID;
string lotes = ObtenerXMLLote(listaSurtido);
var pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL();
List <PolizaPaseProcesoModel> datosPoliza =
pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProceso(pedido.FolioPedido, organizacionID,
lotes);
if (datosPoliza != null)
{
datosPoliza = (from dp in datosPoliza
from ls in surtidoGenerarPoliza
where dp.Proveedor.ProveedorID == ls.Proveedor.ProveedorID &&
dp.Producto.ProductoId == ls.Producto.ProductoId &&
dp.PesajeMateriaPrima.Ticket == ls.PesajeMateriaPrima.Ticket
select dp).ToList();
}
if (datosPoliza != null && datosPoliza.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso);
IList <PolizaPaseProcesoModel> polizasPaseProcesoModel;
resultadoPolizaModel = new List <ResultadoPolizaModel>();
datosPoliza =
datosPoliza.GroupBy(prod => new { prod.Producto, prod.ProveedorChofer, prod.PesajeMateriaPrima.Ticket })
.Select(grupo => new PolizaPaseProcesoModel
{
Organizacion = grupo.Select(org => org.Organizacion).FirstOrDefault(),
Almacen = grupo.Select(alm => alm.Almacen).FirstOrDefault(),
Producto = grupo.Key.Producto,
Proveedor = grupo.Select(prov => prov.Proveedor).FirstOrDefault(),
AlmacenMovimiento = grupo.Select(alm => alm.AlmacenMovimiento).FirstOrDefault(),
AlmacenMovimientoDetalle = grupo.Select(alm => alm.AlmacenMovimientoDetalle).FirstOrDefault(),
AlmacenInventarioLote = grupo.Select(alm => alm.AlmacenInventarioLote).FirstOrDefault(),
FleteInterno = grupo.Select(flete => flete.FleteInterno).FirstOrDefault(),
FleteInternoCosto = grupo.Select(flete => flete.FleteInternoCosto).FirstOrDefault(),
Pedido = grupo.Select(ped => ped.Pedido).FirstOrDefault(),
ProveedorChofer = grupo.Key.ProveedorChofer,
PesajeMateriaPrima = grupo.Select(pesaje => pesaje.PesajeMateriaPrima).FirstOrDefault(),
ProgramacionMateriaPrima = grupo.Select(prog => prog.ProgramacionMateriaPrima).FirstOrDefault(),
ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).FirstOrDefault(),
}).ToList();
IList <PolizaInfo> polizaExistente;
var polizaBL = new PolizaBL();
for (var indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++)
{
polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> {
datosPoliza[indexPoliza]
};
polizas = poliza.GeneraPoliza(polizasPaseProcesoModel);
if (polizas != null)
{
var resultadoPoliza = new ResultadoPolizaModel
{
Polizas = polizas
};
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID = organizacionID;
datos.UsuarioCreacionID =
pedido.UsuarioModificacion.UsuarioID;
datos.ArchivoEnviadoServidor = 1;
});
polizaExistente = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso, organizacionID,
pedido.FechaPedido,
string.Format("{0}-{1}", pedido.FolioPedido,
datosPoliza[indexPoliza].
PesajeMateriaPrima.Ticket),
"PP", 1);
if (polizaExistente != null && polizaExistente.Any())
{
List <PolizaInfo> excluir = (from existente in polizaExistente
join guardar in polizas on existente.Concepto equals guardar.Concepto
select guardar).ToList();
polizas = polizas.Except(excluir).ToList();
}
if (polizas.Any())
{
polizaBL.GuardarServicioPI(polizas, TipoPoliza.PaseProceso);
resultadoPolizaModel.Add(resultadoPoliza);
}
}
}
var almacenMovimientoBL = new AlmacenMovimientoBL();
contenedorAlmacenesMovimientos.ForEach(alm => alm.Almacen = new AlmacenInfo
{
UsuarioModificacionID =
pedido.
UsuarioModificacion.
UsuarioID
});
almacenMovimientoBL.ActualizarGeneracionPoliza(contenedorAlmacenesMovimientos);
}
#endregion POLIZA
transaction.Complete();
resultado = true;
}
}
catch (ExcepcionGenerica exg)
{
resultado = false;
Logger.Error(exg);
}
catch (Exception ex)
{
resultado = false;
Logger.Error(ex);
}
return(resultado);
}
/// <summary>
/// Guarda los ajustes
/// </summary>
/// <param name="listaDiferenciasInventario"></param>
/// <param name="usuarioInfo"></param>
internal IList <MemoryStream> Guardar(List <DiferenciasDeInventariosInfo> listaDiferenciasInventario, UsuarioInfo usuarioInfo)
{
int usuarioId = usuarioInfo.UsuarioID;
PolizaAbstract poliza = null;
IList <PolizaInfo> polizas = null;
int organizacionID;
//var contratoCreado = new ContratoInfo();
IList <MemoryStream> streams = null;
try
{
using (var transaction = new TransactionScope())
{
var almacenMovimientoBl = new AlmacenMovimientoBL();
var almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL();
organizacionID = usuarioInfo.OrganizacionID;
foreach (var diferenciasDeInventariosInfo in listaDiferenciasInventario)
{
if (diferenciasDeInventariosInfo.DescripcionAjuste.Equals(TipoAjusteEnum.CerrarLote.ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
var almacenInventarioLoteInfo = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
diferenciasDeInventariosInfo.AlmacenInventarioLote.AlmacenInventarioLoteId);
if (almacenInventarioLoteInfo != null)
{
almacenInventarioLoteInfo.UsuarioModificacionId = usuarioInfo.UsuarioID;
//Kilogramos teoricos en 0 se desactiva el lote
if (diferenciasDeInventariosInfo.KilogramosFisicos == 0)
{
//Desactivar lote
almacenInventarioLoteBl.DesactivarLote(almacenInventarioLoteInfo);
}
}
continue;
}
diferenciasDeInventariosInfo.DiferenciaInventario =
Math.Abs(diferenciasDeInventariosInfo.KilogramosFisicos -
diferenciasDeInventariosInfo.KilogramosTeoricos);
////Se le quita el signo para que no guarde en negativos
//diferenciasDeInventariosInfo.KilogramosTeoricos =
// Math.Abs(diferenciasDeInventariosInfo.KilogramosTeoricos);
//organizacionID = diferenciasDeInventariosInfo.AlmacenMovimiento.OrganizacionID;
//Si no esta guardado se actualiza
if (!diferenciasDeInventariosInfo.Guardado)
{
AlmacenMovimientoInfo almacen = new AlmacenMovimientoInfo();
//Estatus aplicado guarda y actualiza inventario
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvAplicado.GetHashCode())
{
//Insertar movimiento
diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID =
diferenciasDeInventariosInfo.Almacen.AlmacenID;
var almacenMovimientoId =
almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Insertar detalle
var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
{
AlmacenMovimientoID = almacenMovimientoId,
AlmacenInventarioLoteId =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.
AlmacenInventarioLoteId,
Piezas = 0,
ProductoID =
diferenciasDeInventariosInfo.Producto.
ProductoId,
Precio =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
Cantidad =
diferenciasDeInventariosInfo.
DiferenciaInventario,
Importe =
diferenciasDeInventariosInfo.
DiferenciaInventario *
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
UsuarioCreacionID = usuarioInfo.UsuarioID
};
long almacenMovimientoDetalleID =
almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo);
//SE AGREGA DETALLE
almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID;
//var almacenmovimientoBl1 = new AlmacenMovimientoDetalleBL();
//var d =
// almacenmovimientoBl1.ObtenerPorAlmacenMovimientoDetalleId(almacenMovimientoDetalleInfo);
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
//Actualizamos inventario y lote
ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID);
}
//Si es pendiente solo guarda el movimiento y detalle
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvPendiente.GetHashCode())
{
//Insertar movimiento
diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID =
diferenciasDeInventariosInfo.Almacen.AlmacenID;
var almacenMovimientoId =
almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Insertar detalle
var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle()
{
AlmacenMovimientoID = almacenMovimientoId,
AlmacenInventarioLoteId =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.
AlmacenInventarioLoteId,
Piezas = 0,
ProductoID =
diferenciasDeInventariosInfo.Producto.
ProductoId,
Precio =
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
Cantidad =
diferenciasDeInventariosInfo.
DiferenciaInventario,
Importe =
diferenciasDeInventariosInfo.
DiferenciaInventario *
diferenciasDeInventariosInfo.
AlmacenInventarioLote.PrecioPromedio,
UsuarioCreacionID = usuarioInfo.UsuarioID
};
long almacenMovimientoDetalleID =
almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo);
//Se valida si requiere autorizacion
if (diferenciasDeInventariosInfo.RequiereAutorizacion)
{
var almacenBl = new AlmacenBL();
AlmacenMovimientoInfo almacenMovimientoInfo = new AlmacenMovimientoInfo
{
AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID,
AlmacenMovimientoID = almacenMovimientoId
};
almacen = almacenBl.ObtenerAlmacenMovimiento(almacenMovimientoInfo);
var autorizacionMateriaPrimaInfo = new AutorizacionMateriaPrimaInfo
{
OrganizacionID = usuarioInfo.OrganizacionID,
TipoAutorizacionID = TipoAutorizacionEnum.AjustedeInventario.GetHashCode(),
Folio = almacen.FolioMovimiento,
Justificacion = almacen.Observaciones,
Lote = diferenciasDeInventariosInfo.AlmacenInventarioLote.Lote,
Precio = almacenMovimientoDetalleInfo.Precio,
Cantidad = almacenMovimientoDetalleInfo.Cantidad,
ProductoID = almacenMovimientoDetalleInfo.ProductoID,
AlmacenID = almacen.AlmacenID,
EstatusID = Estatus.AMPPendien.GetHashCode(),
UsuarioCreacion = usuarioInfo.UsuarioID,
Activo = EstatusEnum.Activo.GetHashCode()
};
var almacenInventarioLoteBL = new AlmacenInventarioLoteBL();
almacenInventarioLoteBL.GuardarAutorizacionMateriaPrima(
autorizacionMateriaPrimaInfo);
}
//SE AGREGA DETALLE
almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID;
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
}
}
else
{
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvAplicado.GetHashCode())
{
//Actualizar estatus a regitro
//Agregar observaciones
almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Actualizar detalle movimiento
var almacenMovimientoDetalleInfo =
almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId(
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle);
almacenMovimientoDetalleInfo.Cantidad =
diferenciasDeInventariosInfo.DiferenciaInventario;
almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad *
almacenMovimientoDetalleInfo.Precio;
almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID;
almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle(
almacenMovimientoDetalleInfo);
//Actualizamos inventario y lote
ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID);
//SE AGREGA DETALLE
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
}
//Guardado con estatus pendiente se actualiza almacen movimiento y almacen movimiento detalle
if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
Estatus.DifInvPendiente.GetHashCode())
{
//Actualizar almacen movimiento
almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento);
//Actualizar movimiento detalle
//Verificar si se ocupa obtenerlo
var almacenMovimientoDetalleInfo =
almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId(
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle);
almacenMovimientoDetalleInfo.Cantidad =
diferenciasDeInventariosInfo.DiferenciaInventario;
almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad *
almacenMovimientoDetalleInfo.Precio;
//Pendiente usuario modificacion
almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID;
almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle(
almacenMovimientoDetalleInfo);
//SE AGREGA DETALLE
diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
//SE AGREGA DETALLE
}
}
}
#region POLIZA
var listaDiferenciasInventarioAplicados =
listaDiferenciasInventario.Where(dif => dif.AlmacenMovimiento.Status == Estatus.DifInvAplicado.GetHashCode()).ToList();
List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
listaDiferenciasInventarioAplicados.Where(dif => !dif.DescripcionAjuste.Trim().Equals(TipoAjusteEnum.CerrarLote.ToString().Trim(), StringComparison.InvariantCultureIgnoreCase)).Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
{
Importe =
ajuste.DiferenciaInventario *
ajuste.AlmacenInventarioLote.
PrecioPromedio,
Cantidad = ajuste.DiferenciaInventario,
TipoAjuste =
ajuste.DescripcionAjuste.Equals(
TipoAjusteEnum.Merma.ToString(),
StringComparison.
CurrentCultureIgnoreCase)
? TipoAjusteEnum.Merma
: TipoAjusteEnum.Superávit,
Precio = ajuste.AlmacenInventarioLote.
PrecioPromedio,
AlmacenInventarioID =
ajuste.AlmacenInventarioLote.
AlmacenInventario.AlmacenInventarioID,
AlmacenMovimientoDetalleID =
ajuste.AlmacenMovimientoDetalle.
AlmacenMovimientoDetalleID,
ProductoID = ajuste.Producto.ProductoId,
CantidadInventarioFisico =
ajuste.KilogramosFisicos,
CantidadInventarioTeorico =
ajuste.KilogramosTeoricos,
Observaciones =
ajuste.AlmacenMovimiento.Observaciones
}).ToList();
var agrupado =
salidasPorAjuste.GroupBy(tipo => new { tipo.TipoAjuste, tipo.AlmacenMovimientoDetalleID }).Select(
ajuste => new PolizaEntradaSalidaPorAjusteModel
{
TipoAjuste = ajuste.Key.TipoAjuste,
AlmacenInventarioID = ajuste.First().AlmacenInventarioID,
AlmacenMovimientoDetalleID = ajuste.Key.AlmacenMovimientoDetalleID,
Cantidad = ajuste.First().Cantidad,
CantidadInventarioFisico = ajuste.First().CantidadInventarioFisico,
CantidadInventarioTeorico = ajuste.First().CantidadInventarioTeorico,
Importe = ajuste.First().Importe,
Observaciones = ajuste.First().Observaciones,
Precio = ajuste.First().Precio,
PrecioInventarioFisico = ajuste.First().PrecioInventarioFisico,
PrecioInventarioTeorico = ajuste.First().PrecioInventarioTeorico,
ProductoID = ajuste.First().ProductoID
}).ToList();
if (agrupado != null && agrupado.Any())
{
streams = new List <MemoryStream>();
for (int indexAjustes = 0; indexAjustes < agrupado.Count; indexAjustes++)
{
var tipoPoliza = TipoPoliza.SalidaAjuste;
switch (agrupado[indexAjustes].TipoAjuste)
{
case TipoAjusteEnum.Superávit:
tipoPoliza = TipoPoliza.EntradaAjuste;
break;
}
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
var grupo = new List <PolizaEntradaSalidaPorAjusteModel>
{
agrupado[indexAjustes]
};
polizas = poliza.GeneraPoliza(grupo);
if (polizas != null && polizas.Any())
{
MemoryStream stream = poliza.ImprimePoliza(grupo, polizas);
if (stream != null)
{
streams.Add(stream);
}
var polizaBL = new PolizaBL();
polizas.ToList().ForEach(datos =>
{
datos.OrganizacionID = organizacionID;
datos.UsuarioCreacionID = usuarioId;
datos.ArchivoEnviadoServidor = 1;
});
polizaBL.GuardarServicioPI(polizas, tipoPoliza);
}
}
}
#endregion POLIZA
transaction.Complete();
}
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(streams);
}
/// <summary>
/// Obtiene una salida de producto por id
/// </summary>
/// <param name="salidaProducto"></param>
/// <returns></returns>
internal SalidaProductoInfo ObtenerPorSalidaProductoId(SalidaProductoInfo salidaProducto)
{
try
{
var salidaProductoDal = new SalidaProductoDAL();
salidaProducto = salidaProductoDal.ObtenerPorSalidaProductoId(salidaProducto);
if (salidaProducto != null)
{
if (salidaProducto.Organizacion.OrganizacionID > 0)
{
var organizacionBl = new OrganizacionBL();
salidaProducto.Organizacion =
organizacionBl.ObtenerPorID(salidaProducto.Organizacion.OrganizacionID);
}
if (salidaProducto.OrganizacionDestino.OrganizacionID > 0)
{
var organizacionBl = new OrganizacionBL();
salidaProducto.Organizacion =
organizacionBl.ObtenerPorID(salidaProducto.OrganizacionDestino.OrganizacionID);
}
if (salidaProducto.Almacen.AlmacenID > 0)
{
var almacenBl = new AlmacenBL();
salidaProducto.Almacen = almacenBl.ObtenerPorID(salidaProducto.Almacen.AlmacenID);
}
if (salidaProducto.AlmacenInventarioLote.AlmacenInventarioLoteId > 0)
{
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
salidaProducto.AlmacenInventarioLote =
almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
salidaProducto.AlmacenInventarioLote.AlmacenInventarioLoteId);
}
if (salidaProducto.Cliente.ClienteID > 0)
{
var clienteBl = new ClienteBL();
salidaProducto.Cliente = clienteBl.ObtenerPorID(salidaProducto.Cliente.ClienteID);
}
if (salidaProducto.CuentaSAP.CuentaSAPID > 0)
{
var cuentaSapBl = new CuentaSAPBL();
salidaProducto.CuentaSAP = cuentaSapBl.ObtenerPorID(salidaProducto.CuentaSAP.CuentaSAPID);
}
if (salidaProducto.TipoMovimiento.TipoMovimientoID > 0)
{
var tipoMovimientoBl = new TipoMovimientoBL();
salidaProducto.TipoMovimiento =
tipoMovimientoBl.ObtenerPorID(salidaProducto.TipoMovimiento.TipoMovimientoID);
}
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(salidaProducto);
}
/// <summary>
/// Guardar entrada enfermeria
/// </summary>
internal EntradaGanadoEnfermeriaInfo GuardarEntradaEnfermeria(EntradaGanadoEnfermeriaInfo entradaGanadoEnfermeria)
{
entradaGanadoEnfermeria.Resultado = false;
try
{
var resultadoCabezas = new CabezasActualizadasInfo();
var transactionOption = new TransactionOptions();
transactionOption.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption))
{
var animalDal = new AnimalDAL();
var animalMovimientoBL = new AnimalMovimientoBL();
var corralBL = new CorralBL();
var loteBL = new LoteBL();
bool actualizaAreteDeteccion = entradaGanadoEnfermeria.Deteccion.ActualizarAreteDeteccion;
bool animalRecaido = entradaGanadoEnfermeria.AnimalRecaido;
if (entradaGanadoEnfermeria.CambiarTipoGanado &&
entradaGanadoEnfermeria.Deteccion.Animal.AnimalID > 0 &&
entradaGanadoEnfermeria.Deteccion.Animal.TipoGanadoID != entradaGanadoEnfermeria.Animal.TipoGanadoID)
{
entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID;
entradaGanadoEnfermeria.Animal.UsuarioModificacionID = entradaGanadoEnfermeria.UsuarioId;
}
if (entradaGanadoEnfermeria.Animal.AnimalID == 0)
{
entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID;
entradaGanadoEnfermeria.Animal.AplicaBitacora = entradaGanadoEnfermeria.Deteccion.Animal.AplicaBitacora;
}
AnimalInfo animalInfo = animalDal.GuardarAnimal(entradaGanadoEnfermeria.Animal);
if (actualizaAreteDeteccion)
{
//Si el flag esta activo se actualiza el arete en la deteccion de ganado cuando solo traen fotos
var deteccionBl = new DeteccionBL();
deteccionBl.ActualizarDeteccionConFoto(entradaGanadoEnfermeria.Deteccion);
}
/* Si esta activo el flag de recaido generar la deteccion */
if (animalRecaido)
{
entradaGanadoEnfermeria.Deteccion.DeteccionID = GenerarDeteccionAnimalGenerica(entradaGanadoEnfermeria);
}
if (animalInfo != null && animalInfo.AnimalID > 0)
{
entradaGanadoEnfermeria.Animal = animalInfo;
entradaGanadoEnfermeria.Movimiento.AnimalID = animalInfo.AnimalID;
if (entradaGanadoEnfermeria.LoteDestino.LoteID == 0)
{
entradaGanadoEnfermeria.LoteDestino.LoteID = loteBL.GuardaLote(entradaGanadoEnfermeria.LoteDestino);
entradaGanadoEnfermeria.Movimiento.LoteID = entradaGanadoEnfermeria.LoteDestino.LoteID;
}
//Se almacena el movimiento
AnimalMovimientoInfo animalMovimientoInfo =
animalMovimientoBL.GuardarAnimalMovimiento(entradaGanadoEnfermeria.Movimiento);
if (animalMovimientoInfo != null && animalMovimientoInfo.AnimalMovimientoID > 0)
{
if (entradaGanadoEnfermeria.Tratamientos.Any(registro => registro.Seleccionado))
{
var almacenpl = new AlmacenBL();
entradaGanadoEnfermeria.AlmacenMovimiento.AnimalMovimientoID =
animalMovimientoInfo.AnimalMovimientoID;
entradaGanadoEnfermeria.AlmacenMovimiento.AnimalID = animalInfo.AnimalID;
almacenpl.GuardarDescontarTratamientos(entradaGanadoEnfermeria.Tratamientos,
entradaGanadoEnfermeria.AlmacenMovimiento);
}
entradaGanadoEnfermeria.Deteccion.AnimalMovimiento = animalMovimientoInfo;
GurdarDeteccion(entradaGanadoEnfermeria.Deteccion, entradaGanadoEnfermeria.ListaProblemas);
/* Se desactiva la deteccion */
var deteccion = new DeteccionInfo
{
DeteccionID = entradaGanadoEnfermeria.Deteccion.DeteccionID,
UsuarioCreacionID = entradaGanadoEnfermeria.UsuarioId,
Arete = entradaGanadoEnfermeria.Animal.Arete
};
EliminarDeteccion(deteccion);
#region LOTE
//Se decrementan las cabezas del lote
if (entradaGanadoEnfermeria.LoteDestino.LoteID != entradaGanadoEnfermeria.LoteOrigen.LoteID)
{
entradaGanadoEnfermeria.LoteDestino = loteBL.ObtenerPorID(entradaGanadoEnfermeria.LoteDestino.LoteID);
var animalBL = new AnimalBL();
List <AnimalInfo> animalesDestino =
animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteDestino.LoteID);
if (animalesDestino != null && animalesDestino.Any())
{
entradaGanadoEnfermeria.LoteDestino.Cabezas = animalesDestino.Count;
}
//Una vez insertado el lote y el animal se incrementan las cabezas de lote
entradaGanadoEnfermeria.LoteDestino.Cabezas =
entradaGanadoEnfermeria.LoteDestino.Cabezas + 1;
if (entradaGanadoEnfermeria.LoteDestino.Cabezas > entradaGanadoEnfermeria.LoteDestino.CabezasInicio)
{
entradaGanadoEnfermeria.LoteDestino.CabezasInicio =
entradaGanadoEnfermeria.LoteDestino.CabezasInicio + 1;
}
entradaGanadoEnfermeria.LoteDestino.UsuarioModificacionID =
entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID;
// ------ //
entradaGanadoEnfermeria.LoteOrigen.Cabezas =
entradaGanadoEnfermeria.LoteOrigen.Cabezas - 1;
List <AnimalInfo> animales =
animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteOrigen.LoteID);
if (animales != null && animales.Any())
{
entradaGanadoEnfermeria.LoteOrigen.Cabezas = animales.Count;
}
//Se actualizan las cabezas que tiene el lote
var filtro = new FiltroActualizarCabezasLote
{
CabezasProcesadas = 1,
LoteIDDestino = entradaGanadoEnfermeria.LoteDestino.LoteID,
LoteIDOrigen = entradaGanadoEnfermeria.LoteOrigen.LoteID,
UsuarioModificacionID = entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID
};
resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro);
}
#endregion LOTE
//Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada
if (resultadoCabezas.CabezasOrigen <= 0)
{
//Se obtiene el Corral para ver Si es de Recepcion
CorralInfo corralInfo = corralBL.ObtenerCorralPorCodigo(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteOrigen.Corral.Codigo);
if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion)
{
/* Si el corral es de Recepcion */
var corteGanadoPl = new CorteGanadoBL();
corteGanadoPl.ObtenerPesosOrigenLlegada(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteOrigen.CorralID,
entradaGanadoEnfermeria.LoteOrigen.LoteID);
}
}
transaction.Complete();
entradaGanadoEnfermeria.Resultado = true;
}
}
}
}
catch (ExcepcionGenerica ex)
{
Logger.Error(ex);
entradaGanadoEnfermeria.Resultado = false;
}
catch (Exception ex)
{
Logger.Error(ex);
entradaGanadoEnfermeria.Resultado = false;
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(entradaGanadoEnfermeria);
}
/// <summary>
/// Asigna los costos de los subproductos al costo
/// ya generado
/// </summary>
/// <param name="lista"></param>
/// <param name="productoId"></param>
/// <param name="organizacionID"> </param>
private void AsignarCostosSubProductos(List <ReporteInventarioMateriaPrimaInfo> lista, int productoId, int organizacionID)
{
var productoBL = new ProductoBL();
var producto = new ProductoInfo
{
ProductoId = productoId
};
producto = productoBL.ObtenerPorID(producto);
if (producto != null)
{
switch ((FamiliasEnum)producto.Familia.FamiliaID)
{
case FamiliasEnum.Premezclas:
var organizacion = new OrganizacionInfo
{
OrganizacionID = organizacionID,
Activo = EstatusEnum.Activo
};
var almacenBL = new AlmacenBL();
var tiposAlmacen = new List <TipoAlmacenEnum> {
TipoAlmacenEnum.MateriasPrimas
};
List <AlmacenInfo> almacenes = almacenBL.ObtenerAlmacenPorTiposAlmacen(tiposAlmacen,
organizacion);
var almacenMovimientoBL = new AlmacenMovimientoBL();
IEnumerable <AlmacenMovimientoSubProductosModel> productosPremezcla =
lista.Select(x => new AlmacenMovimientoSubProductosModel
{
FechaMovimiento =
x.FechaMovimiento,
ProductoID = productoId
});
productosPremezcla = almacenMovimientoBL.ObtenerMovimientosSubProductos(productosPremezcla);
if (productosPremezcla != null)
{
var premezclaDetalleBL = new PremezclaBL();
List <PremezclaInfo> premezclas =
premezclaDetalleBL.ObtenerPorOrganizacionDetalle(organizacion);
PremezclaInfo premezcla;
List <ReporteInventarioMateriaPrimaInfo> entradasMateriaPrima =
lista.Where(entrada => entrada.CostoId > 0).ToList();
if (entradasMateriaPrima != null)
{
ReporteInventarioMateriaPrimaInfo entradaMateriaPrima;
for (var index = 0; index < entradasMateriaPrima.Count; index++)
{
premezcla =
premezclas.FirstOrDefault(
id => id.Producto.ProductoId == productoId);
if (premezcla != null)
{
entradaMateriaPrima = entradasMateriaPrima[index];
int almacenID =
productosPremezcla.Where(
almMov =>
almMov.AlmacenMovimientoID == entradaMateriaPrima.AlmacenMovimientoID).
Select(id => id.AlmacenID).FirstOrDefault();
if (almacenes.Any(id => id.AlmacenID == almacenID))
{
AlmacenMovimientoSubProductosModel almacenMovimientoSubProductosModel =
productosPremezcla.FirstOrDefault(
prod => prod.ProductoID == premezcla.Producto.ProductoId &&
prod.FechaMovimiento.ToShortDateString().Equals(
entradaMateriaPrima.FechaMovimiento.ToShortDateString()));
if (almacenMovimientoSubProductosModel != null)
{
IEnumerable <AlmacenMovimientoSubProductosModel> subProductos = productosPremezcla
.Join(premezcla.ListaPremezclaDetalleInfos,
pp => pp.ProductoID, pd => pd.Producto.ProductoId,
(pp, pd) => pp).Where(
fechaInicio =>
fechaInicio.AlmacenMovimientoID ==
(almacenMovimientoSubProductosModel.AlmacenMovimientoID +
1) &&
fechaInicio.FechaMovimiento.ToShortDateString().Equals(
entradaMateriaPrima.FechaMovimiento.ToShortDateString()));
if (subProductos != null && subProductos.Any())
{
entradaMateriaPrima.ImporteSubProductos =
subProductos.Sum(imp => imp.Importe);
}
}
}
}
}
}
}
break;
}
}
}
internal bool GuardarInventario(RecepcionProductoInfo recepcionProducto)
{
try
{
AlmacenBL almacenBl = new AlmacenBL();
AlmacenInventarioBL almacenInventarioBl = new AlmacenInventarioBL();
foreach (var recepcionProductodetalle in recepcionProducto.ListaRecepcionProductoDetalle)
{
AlmacenInfo almacen = almacenBl.ObtenerPorID(recepcionProducto.Almacen.AlmacenID);
List <AlmacenInventarioInfo> listaAlmacenlmacenInventario =
almacenInventarioBl.ObtienePorAlmacenId(almacen);
if (listaAlmacenlmacenInventario != null)
{
List <AlmacenInventarioInfo> almacenInventarioListaResultado =
listaAlmacenlmacenInventario.Where(
registro => registro.ProductoID == recepcionProductodetalle.Producto.ProductoId)
.ToList();
if (almacenInventarioListaResultado.Count > 0)
{
var almacenInventario = almacenInventarioListaResultado[0];
almacenInventario.Cantidad = almacenInventario.Cantidad +
recepcionProductodetalle.Cantidad;
almacenInventario.Importe = almacenInventario.Importe + recepcionProductodetalle.Importe;
almacenInventario.PrecioPromedio = almacenInventario.Importe / almacenInventario.Cantidad;
almacenInventario.UsuarioModificacionID = recepcionProducto.UsuarioCreacion.UsuarioID;
almacenInventarioBl.Actualizar(almacenInventario);
}
else
{
var almacenInventarioNuevo = new AlmacenInventarioInfo();
almacenInventarioNuevo.Almacen = recepcionProducto.Almacen;
almacenInventarioNuevo.AlmacenID = recepcionProducto.Almacen.AlmacenID;
almacenInventarioNuevo.Producto = recepcionProductodetalle.Producto;
almacenInventarioNuevo.ProductoID = recepcionProductodetalle.Producto.ProductoId;
almacenInventarioNuevo.Cantidad = recepcionProductodetalle.Cantidad;
almacenInventarioNuevo.Importe = recepcionProductodetalle.Importe;
almacenInventarioNuevo.PrecioPromedio = almacenInventarioNuevo.Importe /
almacenInventarioNuevo.Cantidad;
almacenInventarioNuevo.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID;
almacenInventarioBl.Crear(almacenInventarioNuevo);
}
}
else
{
var almacenInventarioNuevo = new AlmacenInventarioInfo();
almacenInventarioNuevo.Almacen = recepcionProducto.Almacen;
almacenInventarioNuevo.AlmacenID = recepcionProducto.Almacen.AlmacenID;
almacenInventarioNuevo.Producto = recepcionProductodetalle.Producto;
almacenInventarioNuevo.ProductoID = recepcionProductodetalle.Producto.ProductoId;
almacenInventarioNuevo.Cantidad = recepcionProductodetalle.Cantidad;
almacenInventarioNuevo.Importe = recepcionProductodetalle.Importe;
almacenInventarioNuevo.PrecioPromedio = almacenInventarioNuevo.Importe /
almacenInventarioNuevo.Cantidad;
almacenInventarioNuevo.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID;
almacenInventarioBl.Crear(almacenInventarioNuevo);
}
}
return(true);
}
catch (Exception ex)
{
Logger.Error(ex);
}
return(false);
}
