/// <summary>
/// Se obtienen los datos de la solicitud de autorización para el folio
/// </summary>
/// <param name="autorizacionInfo"></param>
/// <returns></returns>
internal AutorizacionMateriaPrimaInfo ObtenerSolicitudAutorizacion(AutorizacionMateriaPrimaInfo autorizacionInfo)
{
AutorizacionMateriaPrimaInfo resultado = null;
try
{
Logger.Info();
var parameters = AuxSolicitudAutorizacionDAL.ObtenerParametrosObtenerSolicitudAutorizacion(autorizacionInfo);
DataSet ds = Retrieve("AutorizacionMateriaPrima_ObtenerPorFolioTipoAutorizacion", parameters);
if (ValidateDataSet(ds))
{
resultado = MapSolicitudAutorizacionDAL.ObtenerDatosSolicitudAutorizacionProgramacionMP(ds);
}
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
/// <summary>
/// Obtener datos de solicitud
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static AutorizacionMateriaPrimaInfo ObtenerDatosSolicitudAutorizacionProgramacionMP(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
AutorizacionMateriaPrimaInfo datosAutorizacionInfo =
(from info in dt.AsEnumerable()
select
new AutorizacionMateriaPrimaInfo
{
AutorizacionMateriaPrimaID = info.Field <int>("AutorizacionMateriaPrimaID"),
OrganizacionID = info.Field <int>("OrganizacionID"),
TipoAutorizacionID = info.Field <int>("TipoAutorizacionID"),
Folio = info.Field <long>("Folio"),
Justificacion = info.Field <string>("Justificacion"),
Lote = info.Field <int>("Lote"),
Precio = info.Field <decimal>("Precio"),
Cantidad = info.Field <decimal>("Cantidad"),
ProductoID = info.Field <int>("ProductoID"),
EstatusID = info.Field <int>("EstatusID"),
AlmacenID = info.Field <int>("AlmacenId"),
CantidadProgramada = info.Field <decimal>("CantidadProgramada"),
}).First();
return(datosAutorizacionInfo);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
internal int GuardarAutorizacionMateriaPrimaProgramacion(AutorizacionMateriaPrimaInfo autorizacionMateriaPrimaInfo, ProgramacionMateriaPrimaInfo programacionMateriaPrimaInfo)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxDiferenciasDeInventarioDAL.ObtenerParametrosAutorizacionMateriaPrima(autorizacionMateriaPrimaInfo);
var ds = Retrieve("AutorizacionMateriaPrima_Registro", parameters);
int result = 0;
if (ValidateDataSet(ds))
{
result = MapAlmacenInventarioDAL.ObtenerAutorizacionMateriaPrimaID(ds);
}
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Existe autorizacion para lote y folio seleccionado
/// </summary>
/// <returns></returns>
private bool ExisteAutorizacion()
{
bool regreso = false;
try
{
var solicitudAutorizacionPl = new SolicitudAutorizacionPL();
var autorizacionInfo = new AutorizacionMateriaPrimaInfo
{
OrganizacionID = organizacionID,
Lote = Convert.ToInt32(skAyudaLote.Clave),
TipoAutorizacionID = TipoAutorizacionEnum.UsoLote.GetHashCode(),
Folio = pedido.FolioPedido
};
AutorizacionMateriaPrimaInfo resultado = solicitudAutorizacionPl.ObtenerDatosSolicitudAutorizacionProgramacionMP(autorizacionInfo);
if (resultado != null)
{
if (resultado.EstatusID == Estatus.AMPAutoriz.GetHashCode())
{
regreso = true;
Autorizado = true;
}
else if (resultado.EstatusID == Estatus.AMPPendien.GetHashCode())
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
string.Format(Properties.Resources.SolicitudProgramacionMateriaPrima_MsjSolicitudPendiente,
pedido.FolioPedido), MessageBoxButton.OK,
MessageImage.Warning);
skAyudaLote.Focus();
}
else if (resultado.EstatusID == Estatus.AMPRechaza.GetHashCode())
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
string.Format(Properties.Resources.SolicitudProgramacionMateriaPrima_MsjSolicitudRechazado,
skAyudaLote.Clave, pedido.FolioPedido), MessageBoxButton.OK,
MessageImage.Warning);
skAyudaLote.Focus();
}
}
else
{
regreso = true;
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.SolicitudProgramacionMateriaPrima_errorEnviarSolicitud,
MessageBoxButton.OK, MessageImage.Error);
}
return(regreso);
}
/// <summary>
/// Existe solicitud autorizada para folio seleccionado
/// </summary>
private void ExisteSolicitudAutorizada()
{
bool loteProgramacion = false;
var solicitudAutorizacionPl = new SolicitudAutorizacionPL();
var autorizacionInfo = new AutorizacionMateriaPrimaInfo
{
OrganizacionID = organizacionID,
TipoAutorizacionID = TipoAutorizacionEnum.UsoLote.GetHashCode(),
Folio = pedido.FolioPedido,
EstatusID = Estatus.AMPAutoriz.GetHashCode()
};
AutorizacionMateriaPrimaInfo resultado =
solicitudAutorizacionPl.ObtenerDatosSolicitudAutorizada(autorizacionInfo);
if (resultado != null)
{
if (detallePedido.ProgramacionMateriaPrima != null && detallePedido.ProgramacionMateriaPrima.Count > 0)
{
loteProgramacion =
detallePedido.ProgramacionMateriaPrima.Any(
programacionMateriaPrimaInfo =>
programacionMateriaPrimaInfo.InventarioLoteOrigen.Lote == resultado.Lote);
}
if (!loteProgramacion)
{
skAyudaLote.Clave = resultado.Lote.ToString(CultureInfo.InvariantCulture);
skAyudaLote.Descripcion = resultado.Lote.ToString(CultureInfo.InvariantCulture);
txtCantidadProgramada.Text = Convert.ToString(resultado.CantidadProgramada);
var almacenInventarioLoteInfo = new AlmacenInventarioLoteInfo
{
ProductoId = producto.ProductoId,
OrganizacionId = pedido.Organizacion.OrganizacionID,
TipoAlmacenId = (int)TipoAlmacenEnum.MateriasPrimas,
Activo = EstatusEnum.Activo,
Lote = resultado.Lote
};
var almacenInventarioLotePL = new AlmacenInventarioLotePL();
AlmacenInventarioLoteInfo resultadoInfo =
almacenInventarioLotePL.ObtenerAlmacenInventarioLotePorFolio(almacenInventarioLoteInfo);
almacenInventarioLote = resultadoInfo;
almacenInventarioLote.ProductoId = almacenInventarioLoteInfo.ProductoId;
almacenInventarioLote.OrganizacionId = almacenInventarioLoteInfo.OrganizacionId;
almacenInventarioLote.TipoAlmacenId = almacenInventarioLoteInfo.TipoAlmacenId;
almacenInventarioLote.Activo = almacenInventarioLoteInfo.Activo;
almacenInventarioLote.Lote = almacenInventarioLoteInfo.Lote;
skAyudaLote.Info = resultadoInfo;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="autorizacionMateriaPrimaInfo"></param>
/// <param name="programacionMateriaPrimaInfo"></param>
public void GuardarAutorizacionMateriaPrimaProgramacion(AutorizacionMateriaPrimaInfo autorizacionMateriaPrimaInfo, ProgramacionMateriaPrimaInfo programacionMateriaPrimaInfo)
{
try
{
Logger.Info();
var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
almacenInventarioLoteBl.GuardarAutorizacionMateriaPrimaProgramacion(autorizacionMateriaPrimaInfo, programacionMateriaPrimaInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public AutorizacionMateriaPrimaInfo ObtenerDatosSolicitudAutorizacionProgramacionMP(AutorizacionMateriaPrimaInfo autorizacionInfo)
{
try
{
Logger.Info();
var solicitudDAL = new SolicitudAutorizacionDAL();
AutorizacionMateriaPrimaInfo result = solicitudDAL.ObtenerDatosSolicitudAutorizacionProgramacionMP(autorizacionInfo);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Guardar autorizacion materia prima
/// </summary>
/// <param name="autorizacionMateriaPrimaInfo"></param>
internal void GuardarAutorizacionMateriaPrima(AutorizacionMateriaPrimaInfo autorizacionMateriaPrimaInfo)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxDiferenciasDeInventarioDAL.ObtenerParametrosAutorizacionMateriaPrima(autorizacionMateriaPrimaInfo);
Create("AutorizacionMateriaPrima_Registro", parameters);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtener parametros de autorizacion de materia prima
/// </summary>
/// <param name="autorizacionMateriaPrimaInfo"></param>
/// <returns></returns>
public static Dictionary <string, object> ObtenerParametrosAutorizacionMateriaPrima(AutorizacionMateriaPrimaInfo autorizacionMateriaPrimaInfo)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@OrganizacionID", autorizacionMateriaPrimaInfo.OrganizacionID },
{ "@TipoAutorizacionID", autorizacionMateriaPrimaInfo.TipoAutorizacionID },
{ "@Folio", autorizacionMateriaPrimaInfo.Folio },
{ "@Justificacion", autorizacionMateriaPrimaInfo.Justificacion },
{ "@Lote", autorizacionMateriaPrimaInfo.Lote },
{ "@Precio", autorizacionMateriaPrimaInfo.Precio },
{ "@Cantidad", autorizacionMateriaPrimaInfo.Cantidad },
{ "@ProductoID", autorizacionMateriaPrimaInfo.ProductoID },
{ "@AlmacenID", autorizacionMateriaPrimaInfo.AlmacenID },
{ "@EstatusID", autorizacionMateriaPrimaInfo.EstatusID },
{ "@UsuarioCreacion", autorizacionMateriaPrimaInfo.UsuarioCreacion },
{ "@Activo", autorizacionMateriaPrimaInfo.Activo }
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtener parametros para solicitud autorizacion de programacion de MP
/// </summary>
/// <param name="autorizacionInfo"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosObtenerDatosSolicitudAutorizacionProgramacionMP(AutorizacionMateriaPrimaInfo autorizacionInfo)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@OrganizacionID", autorizacionInfo.OrganizacionID },
{ "@TipoAutorizacionID", autorizacionInfo.TipoAutorizacionID },
{ "@Folio", autorizacionInfo.Folio },
{ "@Lote", autorizacionInfo.Lote },
{ "@Activo", EstatusEnum.Activo }
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <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);
}
