/// <summary>
/// Obtiene un Operador que es Usuario
/// </summary>
/// <param name="usuarioId"></param>
/// <param name="organizacionId"> </param>
/// <param name="basculista"></param>
/// <returns></returns>
internal OperadorInfo ObtenerPorUsuarioIdRol(int usuarioId, int organizacionId, Roles basculista)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxOperadorDAL.ObtenerParametrosPorUsuarioIdRol(usuarioId, organizacionId, basculista);
DataSet ds = Retrieve("Operador_ObtenerPorUsuarioIdRol", parameters);
OperadorInfo result = null;
if (ValidateDataSet(ds))
{
result = MapOperadorDAL.ObtenerPorUsuarioIdRol(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 un registro de Operador
/// </summary>
/// <param name="descripcion">Descripción de la Operador</param>
/// <returns></returns>
internal OperadorInfo ObtenerPorDescripcion(string descripcion)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxOperadorDAL.ObtenerParametrosPorDescripcion(descripcion);
DataSet ds = Retrieve("Operador_ObtenerPorDescripcion", parameters);
OperadorInfo result = null;
if (ValidateDataSet(ds))
{
result = MapOperadorDAL.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 un Folio por Id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
internal OperadorInfo ObtenerBasculistaPorId(long id)
{
OperadorInfo result = null;
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxOperadorDAL.ObtenerBasculistaPorId(id);
DataSet ds = Retrieve("Operador_ObtenerPorRolIDUsuarioID", parameters);
if (ValidateDataSet(ds))
{
result = MapOperadorDAL.ObtenerBasculistaPorId(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>
/// Metodo para Crear un registro de Operador
/// </summary>
/// <param name="info">Valores de la entidad que será creada</param>
internal int Crear(OperadorInfo info)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxOperadorDAL.ObtenerParametrosCrear(info);
int result = Create("Operador_Crear", parameters);
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 parametros para actualizar
/// </summary>
/// <param name="info">Valores de la entidad</param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosActualizar(OperadorInfo info)
{
try
{
Logger.Info();
int?usuarioId = (info.Usuario != null) ? info.Usuario.UsuarioID : (int?)null;
var parametros =
new Dictionary <string, object>
{
{ "@OperadorID", info.OperadorID },
{ "@Nombre", info.Nombre },
{ "@ApellidoPaterno", info.ApellidoPaterno },
{ "@ApellidoMaterno", info.ApellidoMaterno },
{ "@CodigoSAP", info.CodigoSAP },
{ "@RolID", info.Rol.RolID },
{ "@UsuarioID", usuarioId },
{ "@OrganizacionID", info.Organizacion.OrganizacionID },
{ "@Activo", info.Activo },
{ "@UsuarioModificacionID", info.UsuarioModificacionID },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para Guardar/Modificar una entidad Operador
/// </summary>
/// <param name="info"></param>
internal int Guardar(OperadorInfo info)
{
try
{
Logger.Info();
var operadorDAL = new OperadorDAL();
int result = info.OperadorID;
if (info.OperadorID == 0)
{
result = operadorDAL.Crear(info);
}
else
{
operadorDAL.Actualizar(info);
}
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un el operador detector del corral seleccionado
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static OperadorInfo ObtenerDetectorCorral(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
OperadorInfo entidad =
(from info in dt.AsEnumerable()
select
new OperadorInfo
{
OperadorID = info.Field <int>("OperadorID"),
Nombre = info.Field <string>("Nombre"),
ApellidoPaterno = info.Field <string>("ApellidoPaterno"),
ApellidoMaterno = info.Field <string>("ApellidoMaterno"),
CodigoSAP = info.Field <string>("CodigoSAP"),
Rol = new RolInfo {
RolID = info.Field <int>("RolID")
},
Organizacion = new OrganizacionInfo {
OrganizacionID = info.Field <int>("OrganizacionID")
},
Activo = info.Field <bool>("Activo").BoolAEnum(),
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
internal OperadorInfo ObtenerDetectorCorral(int organizacionId, int corralID, int operadorId)
{
OperadorInfo operadorInfo = null;
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxOperadorDAL.ObtenerParametroObtenerDetectorCorral(organizacionId, corralID, operadorId);
DataSet ds = Retrieve("DeteccionGanado_ObtenerDetectorCorral", parameters);
if (ValidateDataSet(ds))
{
operadorInfo = MapOperadorDAL.ObtenerPorUsuarioID(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(operadorInfo);
}
/// <summary>
/// Obtiene un operador por Id
/// </summary>
/// <param name="operadorID"></param>
/// <returns></returns>
internal OperadorInfo ObtenerPorID(int operadorID)
{
OperadorInfo operadorInfo = null;
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxOperadorDAL.ObtenerParametroPorID(operadorID);
DataSet ds = Retrieve("Operador_ObtenerPorID", parameters);
if (ValidateDataSet(ds))
{
operadorInfo = MapOperadorDAL.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(operadorInfo);
}
/// <summary>
/// Constructor para editar una entidad CorralDetector Existente
/// </summary>
/// <param name="operadorInfo"></param>
public CorralDetectorEdicion(OperadorInfo operadorInfo)
{
InitializeComponent();
operadorInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
Contexto.Operador = operadorInfo;
GeneraAyudaOperador();
skAyudaOperador.IsEnabled = false;
}
private void GenerarMovimientosAnimalesVendidosIntensivo(List <AnimalInfo> animalesMuertos, SalidaIndividualInfo salidaIndividualInfo)
{
var animalMovimientoBL = new AnimalMovimientoBL();
var operadorBL = new OperadorBL();
var animalBL = new AnimalBL();
var listaAnimalesMuertos = new List <AnimalInfo>();
int pesoPromedio = (int)(salidaIndividualInfo.PesoBruto - salidaIndividualInfo.Peso) /
salidaIndividualInfo.NumeroDeCabezas;
foreach (var animalMuerto in animalesMuertos)
{
var animalInfo = animalBL.ObtenerAnimalAnimalID(animalMuerto.AnimalID);
AnimalMovimientoInfo ultimoMovimientoAnimal = null;
List <AnimalMovimientoInfo> ultimosMovimiento = animalMovimientoBL.ObtenerUltimoMovimientoAnimal(new List <AnimalInfo> {
animalInfo
});
if (ultimosMovimiento != null && ultimosMovimiento.Any())
{
ultimoMovimientoAnimal =
ultimosMovimiento.OrderByDescending(ani => ani.AnimalMovimientoID).FirstOrDefault();
}
/* Insertamos el movimiento de Muerte */
/* Se genera el animal Movimiento para almacenarlo*/
if (ultimoMovimientoAnimal != null)
{
OperadorInfo operador = operadorBL.ObtenerPorUsuarioId(salidaIndividualInfo.Usuario, salidaIndividualInfo.Organizacion);
var animalMovimientoInfo = new AnimalMovimientoInfo
{
AnimalID = animalInfo.AnimalID,
OrganizacionID = ultimoMovimientoAnimal.OrganizacionID,
CorralID = ultimoMovimientoAnimal.CorralID,
LoteID = ultimoMovimientoAnimal.LoteID,
Peso = pesoPromedio,
Temperatura = 0,
TipoMovimientoID = (int)TipoMovimiento.SalidaPorVenta,
TrampaID = ultimoMovimientoAnimal.TrampaID,
OperadorID = operador != null ? operador.OperadorID : 0,
Observaciones = string.Empty,
Activo = EstatusEnum.Activo,
UsuarioCreacionID = salidaIndividualInfo.Usuario
};
/* Se almacena el animalMovimiento */
animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);
animalInfo.UsuarioModificacionID = salidaIndividualInfo.Usuario;
/* Se da de baja el animal */
animalBL.InactivarAnimal(animalInfo);
/* Enviar al historico el animal inactivo */
listaAnimalesMuertos.Add(animalInfo);
}
}
if (listaAnimalesMuertos.Any())
{
animalBL.EnviarAHistorico(listaAnimalesMuertos);
}
}
/// <summary>
/// Constructor para editar una entidad Operador Existente
/// </summary>
/// <param name="operadorInfo"></param>
public OperadorEdicion(OperadorInfo operadorInfo)
{
InitializeComponent();
CargaRoles();
operadorInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
operadorInfo.Usuario = operadorInfo.Usuario ?? new UsuarioInfo();
esEdicion = true;
Contexto = operadorInfo;
CargarAyudas();
}
private OperadorInfo ObtenerOperador(int usuarioId, int organizacionID)
{
OperadorPL operadorPl = new OperadorPL();
OperadorInfo operador = operadorPl.ObtenerPorUsuarioId(usuarioId, organizacionID);
if (operador == null)
{
operador = new OperadorInfo();
}
return(operador);
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
Contexto =
new OperadorInfo
{
Nombre = string.Empty,
Organizacion = new OrganizacionInfo(),
Usuario = new UsuarioInfo(),
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
Activo = EstatusEnum.Activo,
Empleado = new EmpleadoInfo(),
};
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
Contexto =
new OperadorInfo
{
Nombre = string.Empty,
Rol = new RolInfo(),
Organizacion = new OrganizacionInfo
{
TipoOrganizacion = new TipoOrganizacionInfo()
},
Activo = EstatusEnum.Activo,
};
}
/// <summary>
/// Obtiene un operador por Id solo los roles que pertenecen a sanidad
/// </summary>
/// <param name="filtro"></param>
/// <returns></returns>
internal OperadorInfo ObtenerSoloRolSanidadPorID(OperadorInfo filtro)
{
try
{
Logger.Info();
var roles = new List <RolInfo>
{
new RolInfo {
RolID = Roles.SupervisorSanidad.GetHashCode()
},
new RolInfo {
RolID = Roles.JefeSanidad.GetHashCode()
},
};
IList <OperadorInfo> operadores = new List <OperadorInfo>();
OperadorInfo operadorInfo = ObtenerPorID(filtro.OperadorID);
if (operadorInfo != null)
{
operadores.Add(operadorInfo);
}
var condicion = (from o in operadores
join r in roles on o.Rol.RolID equals r.RolID
where o.Activo == filtro.Activo &&
o.Organizacion.OrganizacionID == filtro.Organizacion.OrganizacionID
select o).FirstOrDefault();
OperadorInfo result = condicion;
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);
}
}
public void ObtenerOperadorPorId()
{
var operadorPL = new OperadorPL();
OperadorInfo operador = operadorPL.ObtenerPorID(1);
Assert.IsNotNull(operador);
Assert.IsNotNull(operador.Organizacion);
Assert.IsNotNull(operador.Rol);
Assert.IsNotNull(operador.Usuario);
Assert.IsNotNull(operador.Usuario.Organizacion);
Assert.IsTrue(operador.Organizacion.Descripcion.Length > 0);
Assert.IsTrue(operador.Rol.Descripcion.Length > 0);
Assert.IsTrue(operador.Usuario.Nombre.Length > 0);
Assert.IsTrue(operador.Usuario.Organizacion.Descripcion.Length > 0);
}
/// <summary>
/// Se inicializa el contesto
/// </summary>
private bool InicializaContexto()
{
bool resultado = false;
var organizacionID = AuxConfiguracion.ObtenerOrganizacionUsuario();
OperadorInfo operadorInfo = ObtenerOperador(organizacionID);
BasculaMultipesajeContext = new BasculaMultipesajeInfo();
if (operadorInfo.Usuario == null)
{
operadorInfo.Usuario = new UsuarioInfo();
}
if (validarOperador(operadorInfo))
{
BasculaMultipesajeContext = new BasculaMultipesajeInfo()
{
FechaCreacion = DateTime.Now,
OrganizacionInfo = new OrganizacionInfo()
{
OrganizacionID = organizacionID
},
QuienRecibe = operadorInfo == null ? new OperadorInfo()
{
Usuario = new UsuarioInfo()
} : operadorInfo,
FolioMultipesaje = new FolioMultipesajeInfo(),
};
AsignarUsuarioLogueado();
SkAyudaFolio.ObjetoNegocio = new BasculaMultipesajePL(organizacionID);
SkAyudaQuienRecibe.ObjetoNegocio = new OperadorPL();
nombreImpresora = ConfigurationManager.AppSettings["nombreImpresora"].Trim();
folioDespuesDeGuardar = 0;
resultado = true;
}
else
{
HabilitarCampos(false);
HabilitarDeshabilitarBotonGuardar(false);
HabilitarDeshabilitarPesoBotones(false, false, false);
btnCancelar.IsEnabled = false;
btnImprimirTicket.IsEnabled = false;
}
return(resultado);
}
/// <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 void ObtenerSoloRolSanidadPorPagina()
{
var pl = new OperadorPL();
var pagina = new PaginacionInfo
{
Inicio = 1,
Limite = 15
};
var operador = new OperadorInfo {
Organizacion = new OrganizacionInfo {
OrganizacionID = 4
}
};
ResultadoInfo <OperadorInfo> listaPaginada = pl.ObtenerSoloRolSanidadPorPagina(pagina, operador);
Assert.AreNotEqual(listaPaginada, null);
}
public void ObtenerSoloRolSanidadPorID()
{
var operadorPL = new OperadorPL();
var filtro = new OperadorInfo
{
OperadorID = 12,
Organizacion = new OrganizacionInfo {
OrganizacionID = 4
}
};
OperadorInfo operador = operadorPL.ObtenerSoloRolSanidadPorID(filtro);
Assert.IsNotNull(operador);
filtro.OperadorID = 1;
operador = operadorPL.ObtenerSoloRolSanidadPorID(filtro);
Assert.IsNull(operador);
}
/// <summary>
/// Metodo para Guardar/Modificar una entidad Operador
/// </summary>
/// <param name="info">Representa la entidad que se va a grabar</param>
public int Guardar(OperadorInfo info)
{
try
{
Logger.Info();
var operadorBL = new OperadorBL();
int result = operadorBL.Guardar(info);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un Operador
/// </summary>
/// <param name="operadorInfo"></param>
/// <returns></returns>
internal OperadorInfo ObtenerPorOperadorOrganizacion(OperadorInfo operadorInfo)
{
try
{
Logger.Info();
var operadorDAL = new OperadorDAL();
OperadorInfo result = operadorDAL.ObtenerPorOperadorOrganizacion(operadorInfo);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un Operador que es Usuario
/// </summary>
/// <param name="usuarioId"></param>
/// <param name="organizacionId"> </param>
/// <param name="basculista"></param>
/// <returns></returns>
public OperadorInfo ObtenerPorUsuarioIdRol(int usuarioId, int organizacionId, Roles basculista)
{
try
{
Logger.Info();
var operadorBL = new OperadorBL();
OperadorInfo result = operadorBL.ObtenerPorUsuarioIdRol(usuarioId, organizacionId, basculista);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una entidad por su descripción
/// </summary>
/// <param name="descripcion"></param>
/// <returns></returns>
public OperadorInfo ObtenerPorDescripcion(string descripcion)
{
try
{
Logger.Info();
var operadorBL = new OperadorBL();
OperadorInfo result = operadorBL.ObtenerPorDescripcion(descripcion);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public OperadorInfo ObtenerDetectorCorral(int organizacionId, int corralID, int operadorId)
{
try
{
Logger.Info();
var operadorBL = new OperadorBL();
OperadorInfo result = operadorBL.ObtenerDetectorCorral(organizacionId, corralID, operadorId);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene el Operador del corral indicado
/// </summary>
/// <param name="codigoCorral"></param>
/// <param name="organizacionId"></param>
/// <returns></returns>
public OperadorInfo ObtenerLectorPorCodigoCorral(string codigoCorral, int organizacionId)
{
try
{
Logger.Info();
var operadorBL = new OperadorBL();
OperadorInfo result = operadorBL.ObtenerLectorPorCodigoCorral(codigoCorral, organizacionId);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un operador por Id
/// </summary>
/// <param name="filtro"></param>
/// <returns></returns>
public OperadorInfo ObtenerSoloRolBasculistaID(OperadorInfo filtro)
{
try
{
Logger.Info();
var operadorBL = new OperadorBL();
OperadorInfo operadorInfo = operadorBL.ObtenerSoloRolBasculistaPorID(filtro);
return(operadorInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private bool validarOperador(OperadorInfo operadorInfo)
{
bool resultado = false;
if (operadorInfo.EstatusUsuario == EstatusEnum.Inactivo)
{
MostrarMensaje(Properties.Resources.Login_ErrorUsuarioLocal, MessageImage.Warning);
}
else
{
if (operadorInfo.OperadorID == 0)
{
MostrarMensaje(Properties.Resources.General_OperadorNoAsignado, MessageImage.Warning);
}
else
{
if (operadorInfo.Activo == EstatusEnum.Inactivo)
{
MostrarMensaje(Properties.Resources.General_OperadorNoActivo, MessageImage.Warning);
}
else
{
if (operadorInfo.Rol == null || operadorInfo.Rol.RolID == 0)
{
MostrarMensaje(Properties.Resources.General_OperadorRolNoAsignado, MessageImage.Warning);
}
else
{
if (operadorInfo.Rol.Activo == EstatusEnum.Inactivo)
{
MostrarMensaje(Properties.Resources.General_OperadorRolNoActivo, MessageImage.Warning);
}
else
{
resultado = true;
}
}
}
}
}
return(resultado);
}
/// <summary>
/// Obtiene un Operador
/// </summary>
/// <param name="operadorInfo"></param>
/// <returns></returns>
public OperadorInfo ObtenerPorOperador(OperadorInfo operadorInfo)
{
OperadorInfo resultado;
try
{
Logger.Info();
var operadorBL = new OperadorBL();
resultado = operadorBL.ObtenerPorOperador(operadorInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
