public void JaulaObtenerPorIdExistente()
{
var pl = new JaulaPL();
JaulaInfo jaula = pl.ObtenerPorID(1);
Assert.AreNotEqual(jaula, null);
}
public void JaulaObtenerPorId()
{
var pl = new JaulaPL();
JaulaInfo jaula = pl.ObtenerPorID(0);
Assert.AreEqual(jaula, null);
}
/// <summary>
/// Método para cargar el combo tipos de marcas
/// Recibe una parametro jaula info opcional
/// En caso de que jaula info sea null se mostrará
/// La opción seleccione
/// </summary>
private void CargarComboMarcas(JaulaInfo jaulaInfo = null)
{
try
{
var marcasPL = new MarcasPL();
var marcasInfo = new MarcasInfo();
IList <MarcasInfo> listaTiposMarcas = marcasPL.ObtenerMarcas(EstatusEnum.Inactivo, EstatusEnum.Activo);
if (listaTiposMarcas != null)
{
this.existenMarcas = true;
if (jaulaInfo == null)
{
marcasInfo = new MarcasInfo
{
MarcaId = 0,
Descripcion = Properties.Resources.JaulaEdicion_SeleccioneMarca
};
}
else
{
marcasInfo = new MarcasInfo
{
MarcaId = jaulaInfo.Marca == null ? 0 : jaulaInfo.Marca.MarcaId,
Descripcion = string.IsNullOrEmpty(jaulaInfo.Marca.Descripcion) ? Properties.Resources.JaulaEdicion_SeleccioneMarca : jaulaInfo.Marca.Descripcion
};
// Habilita campo de observaciones en modo de edición
// en caso de que la jaula tenga la opcion boletinado
if (jaulaInfo.Boletinado)
{
txtObservacionesRegistro.IsEnabled = true;
lblObservacionesRequerido.Visibility = Visibility.Visible;
}
}
listaTiposMarcas.Insert(0, marcasInfo);
cmbMarca.ItemsSource = listaTiposMarcas;
cmbMarca.SelectedItem = marcasInfo;
if (Contexto.Marca == null)
{
Contexto.Marca = marcasInfo;
}
else
{
Contexto.Marca.MarcaId = marcasInfo.MarcaId;
Contexto.Marca.Descripcion = marcasInfo.Descripcion;
}
}
else
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.JaulaEdicion_MsgMarcasActivas, MessageBoxButton.OK, MessageImage.Error);
this.existenMarcas = false;
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.JaulaEdicion_ErrorObtenerMarcas, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Método que obtiene un registro
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static JaulaInfo ObtenerPorDescripcion(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
JaulaInfo entidad =
(from info in dt.AsEnumerable()
select
new JaulaInfo
{
JaulaID = info.Field <int>("JaulaID"),
Proveedor =
new ProveedorInfo
{
ProveedorID = info.Field <int>("ProveedorID"),
Descripcion = info.Field <string>("Proveedor"),
CodigoSAP = info.Field <string>("CodigoSAP")
},
PlacaJaula = info.Field <string>("PlacaJaula"),
Capacidad = info.Field <int>("Capacidad"),
Secciones = info.Field <int>("Secciones"),
Activo = info.Field <bool>("Activo").BoolAEnum(),
NumEconomico = info.Field <string>("NumEconomico")
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un lista paginada
/// </summary>
/// <param name="pagina"></param>
/// <param name="filtro"></param>
/// <returns></returns>
internal ResultadoInfo <JaulaInfo> ObtenerPorPagina(PaginacionInfo pagina, JaulaInfo filtro)
{
ResultadoInfo <JaulaInfo> lista = null;
try
{
Dictionary <string, object> parameters = AuxJaulaDAL.ObtenerParametrosPorPagina(pagina, filtro);
DataSet ds = Retrieve("Jaula_ObtenerPorPagina", parameters);
if (ValidateDataSet(ds))
{
lista = MapJaulaDAL.ObtenerPorPagina(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(lista);
}
/// <summary>
/// Obtiene un registro de Jaula
/// </summary>
/// <param name="descripcion">Descripción de la Jaula</param>
/// <returns></returns>
internal JaulaInfo ObtenerPorDescripcion(string descripcion)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxJaulaDAL.ObtenerParametrosPorDescripcion(descripcion);
DataSet ds = Retrieve("Jaula_ObtenerPorDescripcion", parameters);
JaulaInfo result = null;
if (ValidateDataSet(ds))
{
result = MapJaulaDAL.ObtenerPorDescripcion(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>
/// Obtiene una entidad de JaulaInfo
/// </summary>
/// <param name="jaula"></param>
/// <param name="Dependencias"> </param>
/// <returns></returns>
internal JaulaInfo ObtenerJaula(JaulaInfo jaula, IList <IDictionary <IList <string>, object> > Dependencias)
{
JaulaInfo result = null;
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxJaulaDAL.ObtenerParametroPorJaula(jaula, Dependencias);
DataSet ds = Retrieve("Jaula_ObtenerPorPlacaJaula", parameters);
if (ValidateDataSet(ds))
{
result = MapJaulaDAL.ObtenerPorID(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(result);
}
public void JaulaCrear()
{
var random = new Random();
int randomNumber = random.Next(0, 100);
var pl = new JaulaPL();
var jaula = new JaulaInfo
{
JaulaID = 0,
PlacaJaula = string.Format("C{0:D9}", randomNumber),
UsuarioCreacionID = 1,
Proveedor = new ProveedorInfo {
ProveedorID = 1
},
Activo = EstatusEnum.Activo
};
try
{
pl.Guardar(jaula);
}
catch (Exception)
{
jaula = null;
}
Assert.AreNotEqual(jaula, null);
}
/// <summary>
/// Obtiene parametros para actualizar
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosActualizar(JaulaInfo info)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@JaulaID", info.JaulaID },
{ "@ProveedorID", info.Proveedor.ProveedorID },
{ "@PlacaJaula", info.PlacaJaula },
{ "@Capacidad", info.Capacidad },
{ "@Secciones", info.Secciones },
{ "@NumEconomico", info.NumEconomico },
{ "@MarcaID", info.Marca.MarcaId },
{ "@Modelo", info.Modelo },
{ "@Boletinado", info.Boletinado },
{ "@Observaciones", info.Observaciones },
{ "@Activo", info.Activo },
{ "@UsuarioModificacionID", info.UsuarioModificacionID }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
public void JaulaGuardarDescripcionExistente()
{
var pl = new JaulaPL();
var jaula = new JaulaInfo
{
JaulaID = 0,
PlacaJaula = "215-UM4",
Proveedor = new ProveedorInfo {
ProveedorID = 1
},
UsuarioCreacionID = 1,
Activo = EstatusEnum.Activo
};
try
{
pl.Guardar(jaula);
jaula = pl.ObtenerPorDescripcion("215-UM4");
}
catch (Exception)
{
jaula.JaulaID = 0;
}
Assert.AreEqual(jaula.JaulaID, 0);
}
/// <summary>
/// Metodo que crear un tipo de embarque
/// </summary>
/// <param name="info"></param>
internal void Guardar(JaulaInfo info)
{
try
{
Logger.Info();
var jaulaDAL = new JaulaDAL();
if (info.JaulaID != 0)
{
jaulaDAL.Actualizar(info);
}
else
{
jaulaDAL.Crear(info);
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
Contexto = new JaulaInfo
{
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
Proveedor = new ProveedorInfo
{
TipoProveedor = new TipoProveedorInfo()
},
};
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
ProveedorInfo proveedorInfo = (skAyudaProveedor != null && !skAyudaProveedor.IsEnabled) ? Contexto.Proveedor : new ProveedorInfo();
MarcasInfo marcasInfo = new MarcasInfo();
Contexto = new JaulaInfo
{
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
Proveedor = proveedorInfo,
Marca = marcasInfo
};
}
public void JaulaObtenerPorPaginaSinDatos()
{
var pl = new JaulaPL();
var pagina = new PaginacionInfo {
Inicio = 1, Limite = 15
};
var filtro = new JaulaInfo {
PlacaJaula = "."
};
ResultadoInfo <JaulaInfo> listaPaginada = pl.ObtenerPorPagina(pagina, filtro);
Assert.AreEqual(listaPaginada, null);
}
public static List <JaulaInfo> ObtenerJaulasPorProveedorID(JaulaInfo jaulaInfo)
{
try
{
var programacionEmbarquePL = new ProgramacionEmbarquePL();
List <JaulaInfo> listadoJaulas = programacionEmbarquePL.ObtenerJaulasPorProveedorID(jaulaInfo);
return(listadoJaulas);
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
/// <summary>
/// Constructor para editar una entidad Jaula Existente
/// </summary>
/// <param name="jaulaInfo"></param>
public JaulaEdicion(JaulaInfo jaulaInfo)
{
InitializeComponent();
jaulaInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
CargarAyudas();
CargarComboMarcas(jaulaInfo);
Contexto = jaulaInfo;
if (Contexto.Boletinado)
{
cmbEstatus.IsEnabled = false;
txtObservacionesRegistro.IsEnabled = true;
lblObservacionesRequerido.Visibility = Visibility.Visible;
}
}
/// <summary>
/// Evento que se ejecuta mientras se esta cerrando la ventana
/// </summary>
/// <param name="e"></param>
protected override void OnClosing(CancelEventArgs e)
{
if (confirmaSalir)
{
MessageBoxResult result = SkMessageBox.Show(this, Properties.Resources.Msg_CerrarSinGuardar, MessageBoxButton.YesNo,
MessageImage.Question);
if (result == MessageBoxResult.Yes)
{
Contexto = null;
}
else
{
e.Cancel = true;
}
}
}
public static JaulaInfo ObtenerJaulasPorDescripcion(JaulaInfo jaulaInfo)
{
try
{
var programacionEmbarquePL = new ProgramacionEmbarquePL();
JaulaInfo jaulaResultado = programacionEmbarquePL.ObtenerJaulasPorDescripcion(jaulaInfo);
if (jaulaResultado != null && jaulaResultado.Proveedor.ProveedorID != jaulaInfo.Proveedor.ProveedorID)
{
jaulaResultado = new JaulaInfo();
}
return(jaulaResultado);
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
/// <summary>
/// Método que obtiene las jaulas de acuerdo por placa.
/// </summary>
/// <param name="jaulaInfo"> Objeto de tipo jaula contenedor de la placa a buscar </param>
/// <returns></returns>
public JaulaInfo ObtenerJaulasPorDescripcion(JaulaInfo jaulaInfo)
{
try
{
Logger.Info();
var jaulaPL = new JaulaPL();
JaulaInfo jaulaResultado = jaulaPL.ObtenerPorDescripcion(jaulaInfo.PlacaJaula);
return(jaulaResultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que obtiene las jaulas de acuerdo al proveedor seleccionado.
/// </summary>
/// <param name="jaulaInfo"> Objeto que contiene el proveedor seleccionado </param>
/// <returns> Listado de jaulas encontradas </returns>
public List <JaulaInfo> ObtenerJaulasPorProveedorID(JaulaInfo jaulaInfo)
{
try
{
Logger.Info();
var jaulaPL = new JaulaPL();
List <JaulaInfo> listadoJaulas = jaulaPL.ObtenerPorProveedorID(jaulaInfo.Proveedor.ProveedorID);
return(listadoJaulas);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una entidad Jaula por su descripción
/// </summary>
/// <param name="descripcion"></param>
/// <returns></returns>
internal JaulaInfo ObtenerPorDescripcion(string descripcion)
{
try
{
Logger.Info();
var jaulaDAL = new JaulaDAL();
JaulaInfo result = jaulaDAL.ObtenerPorDescripcion(descripcion);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un diccionario con los
/// parametros para ejecutar
/// el procedimiento almacenado
/// </summary>
/// <param name="jaula"></param>
/// <param name="Dependencias"> </param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametroPorJaula(JaulaInfo jaula, IList <IDictionary <IList <string>, object> > Dependencias)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@PlacaJaula", jaula.PlacaJaula }
};
AuxDAL.ObtenerDependencias(parametros, Dependencias);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Obtiene los filtros de la consulta
/// </summary>
/// <returns></returns>
private JaulaInfo ObtenerFiltros()
{
JaulaInfo filtro;
try
{
string descripcion = txtDescripcion.Text.Trim();
filtro = new JaulaInfo
{
JaulaID = 0,
PlacaJaula = descripcion,
Proveedor = new ProveedorInfo(),
Activo = (EstatusEnum)cboEstatus.SelectedValue
};
}
catch (Exception ex)
{
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(filtro);
}
/// <summary>
/// Obtiene una Entidad de JaulaInfo
/// </summary>
/// <param name="jaula"></param>
/// <returns></returns>
internal JaulaInfo ObtenerJaula(JaulaInfo jaula)
{
JaulaInfo info;
try
{
Logger.Info();
var jaulaDAL = new JaulaDAL();
info = jaulaDAL.ObtenerJaula(jaula);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(info);
}
/// <summary>
/// Obtiene un lista paginada
/// </summary>
/// <param name="pagina"></param>
/// <param name="filtro"></param>
/// <returns></returns>
internal ResultadoInfo <JaulaInfo> ObtenerPorPagina(PaginacionInfo pagina, JaulaInfo filtro)
{
ResultadoInfo <JaulaInfo> result;
try
{
Logger.Info();
var jaulaDAL = new JaulaDAL();
result = jaulaDAL.ObtenerPorPagina(pagina, filtro);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene una Entidad de JaulaInfo
/// </summary>
/// <param name="jaula"></param>
/// <param name="Dependencias"> </param>
/// <returns></returns>
internal JaulaInfo ObtenerJaula(JaulaInfo jaula, IList <IDictionary <IList <string>, object> > Dependencias)
{
JaulaInfo info;
try
{
Logger.Info();
var jaulaDAL = new JaulaDAL();
info = jaulaDAL.ObtenerJaula(jaula, Dependencias);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(info);
}
/// <summary>
/// Obtiene un lista paginada
/// </summary>
/// <param name="pagina"></param>
/// <param name="filtro"></param>
/// <param name="Dependencias"> </param>
/// <returns></returns>
internal ResultadoInfo <JaulaInfo> ObtenerPorPagina(PaginacionInfo pagina, JaulaInfo filtro, IList <IDictionary <IList <string>, object> > Dependencias)
{
ResultadoInfo <JaulaInfo> result;
try
{
Logger.Info();
var jaulaDAL = new JaulaDAL();
result = jaulaDAL.ObtenerPorPagina(pagina, filtro, Dependencias);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene la lista para mostrar en el grid
/// </summary>
private void ObtenerListaJaula(int inicio, int limite)
{
try
{
if (ucPaginacion.ContextoAnterior != null)
{
bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
if (!contextosIguales)
{
ucPaginacion.Inicio = 1;
inicio = 1;
}
}
var jaulaPL = new JaulaPL();
JaulaInfo filtros = ObtenerFiltros();
var pagina = new PaginacionInfo {
Inicio = inicio, Limite = limite
};
ResultadoInfo <JaulaInfo> resultadoInfo = jaulaPL.ObtenerPorPagina(pagina, filtros);
if (resultadoInfo != null && resultadoInfo.Lista != null &&
resultadoInfo.Lista.Count > 0)
{
gridDatos.ItemsSource = resultadoInfo.Lista;
ucPaginacion.TotalRegistros = resultadoInfo.TotalRegistros;
}
else
{
ucPaginacion.TotalRegistros = 0;
gridDatos.ItemsSource = new List <Jaula>();
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un diccionario con los
/// parametros para ejecutar
/// el procedimiento almacenado
/// </summary>
/// <param name="jaula"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametroPorJaula(JaulaInfo jaula)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
int proveedorID = jaula.Proveedor == null ? 0 : jaula.Proveedor.ProveedorID;
parametros = new Dictionary <string, object>
{
{ "@PlacaJaula", jaula.PlacaJaula }
,
{ "@ProveedorID", proveedorID }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Metodo que actualiza un Jaula
/// </summary>
/// <param name="info"></param>
internal void Actualizar(JaulaInfo info)
{
try
{
Dictionary <string, object> parameters = AuxJaulaDAL.ObtenerParametrosActualizar(info);
Update("Jaula_Actualizar", 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);
}
}
