/// <summary>
/// Método para cargar el combo tipos de organización
/// </summary>
private void CargarComboMarcas(CamionInfo camionInfo)
{
try{
var tipoMarcasPL = new MarcasPL();
IList <MarcasInfo> listaMarcas = tipoMarcasPL.ObtenerMarcas(EstatusEnum.Activo, EstatusEnum.Activo);
if (listaMarcas != null)
{
var tipoMarca = new MarcasInfo
{
MarcaId = (camionInfo.MarcaID == null) ? 0 : (int)camionInfo.MarcaID,
Descripcion = camionInfo.MarcaDescripcion,
};
if (tipoMarca.MarcaId == 0)
{
tipoMarca.Descripcion = Properties.Resources.Camion_MarcaSeleccionar;
listaMarcas.Insert(0, tipoMarca);
}
cmbMarca.ItemsSource = listaMarcas;
cmbMarca.SelectedItem = tipoMarca;
}
else
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Camion_MarcasVacias, MessageBoxButton.OK, MessageImage.Error);
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Camion_ErrorEditar, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Control ayuda camion
/// </summary>
private void AgregarAyudaCamion()
{
camion = new CamionInfo
{
CamionID = 0,
Proveedor = new ProveedorInfo()
{
ProveedorID = proveedor.ProveedorID
}
};
skAyudaCamion = new SKAyuda <CamionInfo>(200, false, camion
, "PropiedadClaveBasculaMateriaPrima"
, "PropiedadDescripcionBasculaMateriaPrima",
"", false, 80, 9, true)
{
AyudaPL = new CamionPL(),
MensajeClaveInexistente = Properties.Resources.BasculaDeMateriaPrima_AyudaCamionInvalido,
MensajeBusquedaCerrar = Properties.Resources.BasculaDeMateriaPrima_AyudaCamionSalirSinSeleccionar,
MensajeBusqueda = Properties.Resources.AyudaProveedorPlacasCamion_Busqueda,
MensajeAgregar = Properties.Resources.BasculaDeMateriaPrima_AyudaCamionSeleccionar,
TituloEtiqueta = Properties.Resources.AyudaProveedorPlacasCamion_LeyendaBusqueda,
TituloPantalla = Properties.Resources.AyudaProveedorPlacasCamion_Busqueda_Titulo,
};
skAyudaCamion.ObtenerDatos += ObtenerDatosCamion;
SplAyudaCamion.Children.Clear();
SplAyudaCamion.Children.Add(skAyudaCamion);
}
/// <summary>
/// Obtiene un camion por placa
/// </summary>
/// <param name="placaCamion"></param>
/// <returns></returns>
internal CamionInfo ObtenerPorPlaca(string placaCamion)
{
CamionInfo result = null;
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxCamionDAL.ObtenerParametroPorPlaca(placaCamion);
DataSet ds = Retrieve("Camion_ObtenerPorPlaca", parameters);
if (ValidateDataSet(ds))
{
result = MapCamionDAL.ObtenerPorPlaca(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);
}
/// <summary>
/// Obtiene un Camion
/// </summary>
/// <returns> </returns>
internal CamionInfo ObtenerPorInfo(CamionInfo camion, IList <IDictionary <IList <string>, object> > dependencias)
{
CamionInfo result = null;
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxCamionDAL.ObtenerParametroPorInfoDependencias(camion, dependencias);
DataSet ds = Retrieve("Camion_ObtenerPorCamionIdProveedorId", parameters);
if (ValidateDataSet(ds))
{
result = MapCamionDAL.ObtenerPorInfoDependencias(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);
}
/// <summary>
/// Obtiene un lista paginada
/// </summary>
/// <param name="pagina"></param>
/// <param name="filtro"></param>
/// <returns></returns>
internal ResultadoInfo <CamionInfo> ObtenerPorPagina(PaginacionInfo pagina, CamionInfo filtro)
{
ResultadoInfo <CamionInfo> lista = null;
try
{
Dictionary <string, object> parameters = AuxCamionDAL.ObtenerParametrosPorPagina(pagina, filtro);
DataSet ds = Retrieve("Camion_ObtenerPorPagina", parameters);
if (ValidateDataSet(ds))
{
lista = MapCamionDAL.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>
/// Metodo que guarda un camion
/// </summary>
/// <param name="info"></param>
internal void Guardar(CamionInfo info)
{
try
{
Logger.Info();
var camionDAL = new CamionDAL();
if (string.IsNullOrEmpty(info.ObservacionesEnviar))
{
info.ObservacionesEnviar = info.ObservacionesObtener;
}
if (info.CamionID != 0)
{
camionDAL.Actualizar(info);
}
else
{
camionDAL.Crear(info);
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Devuelve true si el camion no tiene FechaSalida y no esta Activo (0)
/// </summary>
/// <param name="camion"></param>
/// <returns></returns>
internal bool ObtenerDisponibilidadCamion(CamionInfo camion)
{
var resultado = false;
try
{
Dictionary <string, object> parameters = AuxRegistroVigilanciaDAL.ObtenerDisponibilidadCamion(camion);
DataSet ds = Retrieve("RegistroVigilancia_ObtenerDisponibilidadCamion", parameters);
if (ValidateDataSet(ds))
{
resultado = MapRegistroVigilanciaDAL.ObtenerDisponibilidadCamion(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>
/// Método que obtiene un registro
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static CamionInfo ObtenerPorDescripcion(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
CamionInfo entidad =
(from info in dt.AsEnumerable()
select
new CamionInfo
{
CamionID = info.Field <int>("CamionID"),
Proveedor =
new ProveedorInfo
{
ProveedorID = info.Field <int>("ProveedorID"),
Descripcion = info.Field <string>("Proveedor"),
CodigoSAP = info.Field <string>("CodigoSAP")
},
PlacaCamion = info.Field <string>("PlacaCamion"),
Economico = info.Field <string>("NumEconomico"),
Activo = info.Field <bool>("Activo").BoolAEnum(),
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene parametros para actualizar
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosActualizar(CamionInfo info)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@CamionID", info.CamionID },
{ "@ProveedorID", info.Proveedor.ProveedorID },
{ "@PlacaCamion", info.PlacaCamion },
{ "@Activo", info.Activo },
{ "@UsuarioModificacionID", info.UsuarioModificacionID },
{ "@NumEconomico", info.Economico },
{ "@MarcaID", info.MarcaID },
{ "@Modelo", info.Modelo },
{ "@Color", info.Color },
{ "@Boletinado", info.Boletinado },
{ "@Observaciones", info.ObservacionesEnviar },
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
ProveedorInfo proveedorInfo = (skAyudaProveedor != null && !skAyudaProveedor.IsEnabled) ? Contexto.Proveedor : new ProveedorInfo();
Contexto = new CamionInfo
{
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
Proveedor = proveedorInfo
};
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
Contexto = new CamionInfo
{
PlacaCamion = string.Empty,
Proveedor = new ProveedorInfo
{
TipoProveedor = new TipoProveedorInfo()
},
Activo = EstatusEnum.Activo
};
}
public static List <CamionInfo> ObtenerPlacas(string placaDescripcion, CamionInfo camionInfo)
{
try
{
var camionPl = new CamionPL();
var listaCamiones = new List <CamionInfo>();
List <CamionInfo> listaCamionInfo = camionPl.ObtenerPorProveedorID(camionInfo.Proveedor.ProveedorID);
if (listaCamionInfo != null)
{
foreach (CamionInfo camion in listaCamionInfo)
{
if (placaDescripcion != string.Empty)
{
if (camion.PlacaCamion.Contains(placaDescripcion.ToUpper()))
{
listaCamiones.Add(camion);
}
}
else
{
if (camionInfo.CamionID == 0)
{
listaCamiones.Add(camion);
}
else if (camion.CamionID == camionInfo.CamionID)
{
listaCamiones.Add(camion);
break;
}
}
}
}
else
{
listaCamiones = null;
}
if (listaCamiones != null)
{
listaCamiones = listaCamiones.OrderBy(x => x.CamionID).ToList();
}
return(listaCamiones);
}
catch (Exception e)
{
Logger.Error(e);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), e);
}
}
/// <summary>
/// Constructor para editar una entidad Camion Existente
/// </summary>
/// <param name="camionInfo"></param>
public CamionEdicion(CamionInfo camionInfo)
{
InitializeComponent();
CargarAyudas();
camionInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
CargarComboMarcas(camionInfo);
Contexto = camionInfo;
if (camionInfo.MarcaID == null && camionInfo.MarcaDescripcion == string.Empty)
{
Contexto.MarcaID = 0;
Contexto.MarcaDescripcion = Properties.Resources.Camion_MarcaSeleccionar;
}
HabilitarComboObservaciones();
}
public static List <CamionInfo> ObtenerTractosPorProveedorID(CamionInfo camionInfo)
{
try
{
var programacionEmbarquePL = new ProgramacionEmbarquePL();
List <CamionInfo> listadoCamiones = programacionEmbarquePL.ObtenerTractosPorProveedorID(camionInfo);
return(listadoCamiones);
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
public void CamionObtenerPorIdSinDatos()
{
var pl = new CamionPL();
CamionInfo info;
try
{
info = pl.ObtenerPorID(0);
}
catch (Exception)
{
info = new CamionInfo();
}
Assert.AreEqual(info, null);
}
/// <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 CamionInfo ObtenerTractosPorDescripcion(CamionInfo camionInfo)
{
try
{
var programacionEmbarquePL = new ProgramacionEmbarquePL();
CamionInfo camionResultado = programacionEmbarquePL.ObtenerTractosPorDescripcion(camionInfo);
if (camionResultado != null && camionResultado.Proveedor.ProveedorID != camionInfo.Proveedor.ProveedorID)
{
camionResultado = new CamionInfo();
}
return(camionResultado);
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
/// <summary>
/// Método que obtiene los tractos de acuerdo por placa.
/// </summary>
/// <param name="camionInfo"> Objeto de tipo camión contenedor de la placa a buscar </param>
/// <returns></returns>
public CamionInfo ObtenerTractosPorDescripcion(CamionInfo camionInfo)
{
try
{
Logger.Info();
var camionPL = new CamionPL();
CamionInfo camionResultado = camionPL.ObtenerPorDescripcion(camionInfo.PlacaCamion);
return(camionResultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que obtiene los tractos de acuerdo al proveedor seleccionado.
/// </summary>
/// <param name="camionInfo"> Objeto que contiene el proveedor seleccionado </param>
/// <returns>Listado de los camiones encontrados </returns>
public List <CamionInfo> ObtenerTractosPorProveedorID(CamionInfo camionInfo)
{
try
{
Logger.Info();
var camionPL = new CamionPL();
List <CamionInfo> listadoCamiones = camionPL.ObtenerPorProveedorID(camionInfo.Proveedor.ProveedorID);
return(listadoCamiones);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un camion por su clave
/// </summary>
/// <param name="filtro"></param>
/// <returns></returns>
internal CamionInfo ObtenerPorCamion(CamionInfo filtro)
{
try
{
Logger.Info();
var camionDAL = new CamionDAL();
CamionInfo result = camionDAL.ObtenerPorCamion(filtro);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene los parametros para consultar Disponibilidad de Camion por placas
/// </summary>
/// <param name="camion"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerDisponibilidadCamion(CamionInfo camion)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@Camion", camion.PlacaCamion }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Obtiene Parametros por Id
/// </summary>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametroPorId(CamionInfo camionInfo)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@CamionID", camionInfo.CamionID }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Obtiene la lista para mostrar en el grid
/// </summary>
private void ObtenerListaCamion(int inicio, int limite)
{
try
{
if (ucPaginacion.ContextoAnterior != null)
{
bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
if (!contextosIguales)
{
ucPaginacion.Inicio = 1;
inicio = 1;
}
}
var camionPL = new CamionPL();
CamionInfo filtros = ObtenerFiltros();
var pagina = new PaginacionInfo {
Inicio = inicio, Limite = limite
};
ResultadoInfo <CamionInfo> resultadoInfo = camionPL.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 <Camion>();
}
}
catch (ExcepcionGenerica)
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Camion_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Camion_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Valida que el las placas del camion ingresado no esté activo y tenga fecha de salida
/// </summary>
/// <param name="camion"></param>
/// <returns></returns>
public bool ObtenerDisponibilidadCamion(CamionInfo camion)
{
bool resultado;
try
{
Logger.Info();
var registroVigilaciaBl = new RegistroVigilanciaBL();
resultado = registroVigilaciaBl.ObtenerDisponibilidadCamion(camion);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
/// <summary>
/// Obtiene un Camion
/// </summary>
/// <returns> </returns>
internal CamionInfo ObtenerPorInfo(CamionInfo camion, IList <IDictionary <IList <string>, object> > dependencias)
{
CamionInfo info;
try
{
Logger.Info();
var camionDAL = new CamionDAL();
info = camionDAL.ObtenerPorInfo(camion, 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 <CamionInfo> ObtenerPorPagina(PaginacionInfo pagina, CamionInfo filtro, IList <IDictionary <IList <string>, object> > Dependencias)
{
ResultadoInfo <CamionInfo> result;
try
{
Logger.Info();
var camionDAL = new CamionDAL();
result = camionDAL.ObtenerPorPagina(pagina, filtro, Dependencias);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene un camion por proveedorID y camionID
/// </summary>
/// <param name="camionInfo"></param>
/// <returns></returns>
internal CamionInfo ObtenerPorProveedorIdCamionId(CamionInfo camionInfo)
{
CamionInfo info;
try
{
Logger.Info();
var camionDAL = new CamionDAL();
info = camionDAL.ObtenerPorProveedorIdCamionId(camionInfo);
}
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 <CamionInfo> ObtenerPorPagina(PaginacionInfo pagina, CamionInfo filtro)
{
ResultadoInfo <CamionInfo> result;
try
{
Logger.Info();
var camionDAL = new CamionDAL();
result = camionDAL.ObtenerPorPagina(pagina, filtro);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Metodo que actualiza un Camion
/// </summary>
/// <param name="info"></param>
internal void Actualizar(CamionInfo info)
{
try
{
Dictionary <string, object> parameters = AuxCamionDAL.ObtenerParametrosActualizar(info);
Update("Camion_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);
}
}
/// <summary>
/// Metodo que valida los datos para guardar
/// </summary>
/// <returns></returns>
private bool ValidaGuardar()
{
bool resultado = true;
string mensaje = string.Empty;
try
{
if (string.IsNullOrWhiteSpace(txtDescripcion.Text))
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgDescripcionRequerida;
txtDescripcion.Focus();
}
else if (string.IsNullOrWhiteSpace(txtEconomico.Text) || txtEconomico.Text == "0")
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgEconomicoNoValido;
txtEconomico.Focus();
}
else if (Contexto.MarcaID == 0)
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgMarcaNoValido;
cmbMarca.Focus();
}
else if (string.IsNullOrWhiteSpace(txtModelo.Text) || txtModelo.Text == "0")
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgModeloNoValido;
txtModelo.Focus();
}
else if (string.IsNullOrWhiteSpace(skAyudaProveedor.Clave) || string.IsNullOrWhiteSpace(skAyudaProveedor.Descripcion))
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgProveedorNoValido;
skAyudaProveedor.AsignarFoco();
}
else if (string.IsNullOrWhiteSpace(txtColor.Text))
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgColorNoValido;
txtColor.Focus();
}
else if (Contexto.Boletinado && string.IsNullOrWhiteSpace(Contexto.ObservacionesEnviar))
{
if (string.IsNullOrWhiteSpace(Contexto.ObservacionesObtener))
{
resultado = false;
mensaje = Properties.Resources.CamionEdicion_MsgObservacionesNoValido;
txtObservacionesEnviar.Focus();
}
}
else
{
int camionId = Extensor.ValorEntero(txtCamionId.Text);
string descripcion = txtDescripcion.Text;
var camionPL = new CamionPL();
CamionInfo camionBusqueda = camionPL.ObtenerPorDescripcion(descripcion);
if (camionBusqueda != null && (camionId == 0 || camionId != camionBusqueda.CamionID))
{
resultado = false;
mensaje = string.Format(Properties.Resources.CamionEdicion_MsgDescripcionExistente,
camionBusqueda.CamionID);
txtDescripcion.Focus();
}
}
}
catch (Exception ex)
{
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
if (!string.IsNullOrWhiteSpace(mensaje))
{
SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
}
return(resultado);
}
