public FormMenu(int _perfil, string Nick)
{
InitializeComponent();
_tipoPerfil = new TipoPerfil();
_tipoPerfil.IdPerfil = _perfil;
usuario = new Usuario();
}
public async Task <WrapperSimpleTypesDTO> EliminarPlan(Planes planParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaEliminar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
bool esPlanDefault = await planRepository.BuscarSiPlanEsDefault(planParaEliminar);
if (esPlanDefault)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoPlanNuevo = planParaEliminar.Consecutivo
};
noticiasRepo.EliminarNotificacionesDeUnPlan(notificacion);
PlanesContenidos planContenido = new PlanesContenidos
{
CodigoPlan = planParaEliminar.Consecutivo
};
planRepository.EliminarMultiplesPlanesContenidos(planContenido);
planRepository.EliminarPlan(planParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = planParaEliminar.CodigoArchivo
};
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarPlan = new WrapperSimpleTypesDTO();
wrapperEliminarPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPlan.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPlan.Exitoso = true;
}
return(wrapperEliminarPlan);
}
}
public frmBuscarOtrosPerfiles(Form formPerfilPersonal, TipoPerfil tipoPerfil)
{
InitializeComponent();
estadoComponentes(Estado.Inicial);
var_tipoPerfil = tipoPerfil;
var_perfilPersonal = formPerfilPersonal;
}
public override async void Init(object initData)
{
base.Init(initData);
ControlPerfil control = initData as ControlPerfil;
Persona = control.PersonaParaVer;
_tipoPerfil = control.TipoPerfilControl;
_viejoCorreo = Persona.Usuarios.Email;
try
{
if (EsMiPersonaOPrimerRegistro)
{
PaisesDTO paises = new PaisesDTO
{
IdiomaBase = App.IdiomaPersona
};
Paises = new ObservableCollection <PaisesDTO>(await _administracionServices.ListarPaisesPorIdioma(paises) ?? new List <PaisesDTO>());
}
else
{
Paises = new ObservableCollection <PaisesDTO> {
Persona.Paises
};
}
}
catch (Exception)
{
}
}
private string pathByTypeProfile(TipoPerfil typeProfile)
{
switch (typeProfile)
{
case TipoPerfil.SinTipoPerfil:
return("Authenticate/");
case TipoPerfil.Candidato:
return("Home/");
case TipoPerfil.Grupo:
return("Home/");
case TipoPerfil.Representante:
return("Home/");
case TipoPerfil.Anunciante:
return("Advertisements/");
case TipoPerfil.Administrador:
return("Administration/");
default:
return("Authenticate/");
}
}
public async Task SuscribeToNotifications(int consecutivoPersona, TipoPerfil tipoPerfil)
{
if (_hubConnection != null && _hubConnection.State == ConnectionState.Connected)
{
await _policy.ExecuteAsync(async() => await _hubProxy.Invoke <string>("SuscribeToNotifications", consecutivoPersona, (int)tipoPerfil));
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
bool isLogin = false;
object usuario = filterContext.HttpContext.Session["usuarioLogado"];
if (usuario != null && usuario is Usuario)
{
if (Roles != null && Roles.Length > 0)
{
TipoPerfil tipoPerfil = (TipoPerfil)(usuario as Usuario).TipoPerfil;
int indexOf = Array.IndexOf(Roles, tipoPerfil);
if (indexOf > -1)
{
isLogin = true;
}
}
else
{
isLogin = true;
}
}
if (!isLogin)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(
new { controller = "Login", action = "Index" }));
}
}
public async Task <WrapperSimpleTypesDTO> DesasignarPlanDefault(Planes planParaDesasignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaDesasignar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
Planes planExistente = await planRepository.DesasignarPlanDefault(planParaDesasignar);
WrapperSimpleTypesDTO wrapperDesasignarPlanDefault = new WrapperSimpleTypesDTO();
wrapperDesasignarPlanDefault.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperDesasignarPlanDefault.NumeroRegistrosAfectados > 0)
{
wrapperDesasignarPlanDefault.Exitoso = true;
}
return(wrapperDesasignarPlanDefault);
}
}
public FrmClientes(int _perfil)
{
InitializeComponent();
tipoPerfil = new TipoPerfil();
tipoPerfil.IdPerfil = _perfil;
_cliente = new Clientes();
_provincia = new Provincia();
}
public FrmArticulos(int _perfil)
{
InitializeComponent();
tipoPerfil = new TipoPerfil();
tipoPerfil.IdPerfil = _perfil;
articulo = new Articulos();
proveedor = new Proveedor();
}//constructor
public async Task <int> NumeroPlanesDefault(TipoPerfil tipoPerfil)
{
int si = (int)SiNoEnum.Si;
int codigoTipoPerfil = (int)tipoPerfil;
int numeroDePlanesDefault = await _context.Planes.Where(x => x.PlanDefault == si && x.CodigoTipoPerfil == codigoTipoPerfil).Select(x => x.Consecutivo).CountAsync();
return(numeroDePlanesDefault);
}
public async Task <int?> BuscarCodigoPlanDefault(TipoPerfil tipoPerfil)
{
int si = (int)SiNoEnum.Si;
int codigoTipoPerfil = (int)tipoPerfil;
int?codigoPlanDefault = await _context.Planes.Where(x => x.PlanDefault == si && x.CodigoTipoPerfil == codigoTipoPerfil).Select(x => x.Consecutivo).FirstOrDefaultAsync();
return(codigoPlanDefault);
}
public frmProveedores(int _perfil)
{
InitializeComponent();
_tipoPerfil = new TipoPerfil();
_tipoPerfil.IdPerfil = _perfil;
conexion = new Conectar();
_proveedor = new Proveedor();
_provincia = new Provincia();
}
public frmSolicitarHL(Form formPerfilPersonal, TipoPerfil tipoPerfil, ServicioJava.usuario _user)
{
var_usuario = _user;
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
InitializeComponent();
estadoComponentes(Estado.Inicial);
limpiarComponentes();
}
public FrmCompras(int _perfil)
{
InitializeComponent();
tipoPerfil = new TipoPerfil();
tipoPerfil.IdPerfil = _perfil;
ordenCompra = new OrdenDeCompra();
_estadoCompra = new EstadoOrdenCompra();
_detalle = new Detalle();
}//constructor
public frmSolicitarCambioTurno(Form formPerfilPersonal, TipoPerfil tipoPerfil)
{
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
InitializeComponent();
limpiarComponentes();
estadoComponentes(Estado.Inicial);
lblFlechita.Visible = false;
}
public async Task SuscribeToNotifications(string userId, string tipoPerfil)
{
if (string.IsNullOrWhiteSpace(userId))
{
throw new ArgumentNullException("userId no puede estar vacio!,");
}
if (string.IsNullOrWhiteSpace(tipoPerfil))
{
throw new ArgumentNullException("tipoPerfil no puede estar vacio!,");
}
TipoPerfil tipoPerfilEnum = tipoPerfil.ToEnum <TipoPerfil>();
CategoriasBusiness categoriaBusiness = new CategoriasBusiness();
List <int> listaCategorias = null;
// Se consultan las categorias de la persona conectandose
switch (tipoPerfilEnum)
{
case TipoPerfil.Candidato:
listaCategorias = await categoriaBusiness.ListarCodigoCategoriasDeUnCandidato(Convert.ToInt32(userId));
break;
case TipoPerfil.Grupo:
listaCategorias = await categoriaBusiness.ListarCodigoCategoriasDeUnGrupo(Convert.ToInt32(userId));
break;
case TipoPerfil.Representante:
listaCategorias = await categoriaBusiness.ListarCodigoCategoriasDeUnRepresentante(Convert.ToInt32(userId));
break;
}
// Se valida que no halla error al consultar
if (listaCategorias == null)
{
throw new InvalidOperationException("Fallo al consultar las categorias!.");
}
// Verifico que tengo categorias a las que me suscribire por cambios
if (listaCategorias.Count > 0)
{
// Por cada categoria verifico que ya no este suscrito, si lo estoy la remuevo (Evito escuchar doble)
// Y procedo a suscribirme
foreach (var categorias in listaCategorias)
{
await Groups.Remove(Context.ConnectionId, _prefixNotificationsGroupName + categorias);
await Groups.Add(Context.ConnectionId, _prefixNotificationsGroupName + categorias);
}
}
}
public Perfil(TipoPerfil tipo, double Comprimento, double Altura, double Largura, double Espessura)
{
this.Tipo = tipo;
this.Comprimento = Comprimento;
this.Altura = Altura;
if (tipo == TipoPerfil.Tubo_Redondo)
{
this.Diametro = Altura;
this.Espessura = Espessura;
}
this.Largura = Largura;
this.Espessura = Espessura;
}
public frmVisualizarHorarios(Form formPerfilPersonal, TipoPerfil tipoPerfil)
{
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
InitializeComponent();
this.dgvDistPersonal.AutoGenerateColumns = false;
this.txtCodigo.Enabled = false;
this.txtNombre.Enabled = false;
this.lblNombre.Enabled = false;
this.label1.Enabled = false;
}
/*public frmRegInasistencias(frmPerfilBibliotecario formPerfBiblio)
* {
* var_perfilBibliotecario = formPerfBiblio;
* InitializeComponent();
*
* //cargamos el combo box de tipo inasistencia
* //servicio
* //DBController.listarInasistencia(); //<--- en el combobox showparam ...
*
* }*/
public frmRegInasistencias(Form formPerfilPersonal, TipoPerfil tipoPerfil, ServicioJava.usuario _USER)
{
var_usuario = _USER;
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
InitializeComponent();
limpiarComponentes();
estadoForm = Estado.Inicial;
estadoComponentes(estadoForm);
//cargamos los tipos de inasistencia en el combo box
cmbTipo_Inasistencia.DataSource = servTA.listarTipoInasistencia();
cmbTipo_Inasistencia.DisplayMember = "Nombre";
cmbTipo_Inasistencia.ValueMember = "Id";
}
public frmConfigurar(Form formPerfilPersonal, TipoPerfil tipoPerfil, ServicioJava.usuario _user, ServicioJava.personalBiblioteca _datosUsuario)
{
var_usuario = _user;
var_datosUsuario = _datosUsuario;
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
//Para mostrar los datos
InitializeComponent();
txtNombre.Text = var_usuario.nombre;
txtApellido.Text = var_usuario.apellido;
txtCorreo.Text = var_usuario.email;
txtCodigo.Text = var_datosUsuario.codigo;
dtpFecha.Value = var_datosUsuario.fecha_ingreso;
if (var_datosUsuario.foto != null)
{
MemoryStream ms1 = new MemoryStream(var_datosUsuario.foto);
pbPortada.Image = new Bitmap(ms1);
}
switch (var_tipoPerfil)
{
case TipoPerfil.PerfilBibliotecario:
txtPuesto.Text = "Bibliotecario";
break;
case TipoPerfil.PerfilGestor:
txtPuesto.Text = "Gestor";
break;
case TipoPerfil.PerfilPracticante:
txtPuesto.Text = "Practicante";
break;
case TipoPerfil.PerfilAuxiliar:
txtPuesto.Text = "Auxiliar";
break;
default:
break;
}
txtCantidadHE.Text = var_datosUsuario.totalHorasExtra.ToString();
txtBiblioteca.Text = var_datosUsuario.biblioteca.nombre;
estadoComponentes(Estado.Inicial);
}
public RespondModel Guardar(TipoPerfil tipoPerfil)
{
var rm = new RespondModel();
string mensaje = "";
try
{
using (var db = new DataContext())
{
if (tipoPerfil.Id > 0)
{
db.Entry(tipoPerfil).State = System.Data.Entity.EntityState.Modified;
mensaje = "Registro actualizado exitosamente";
}
else
{
db.Entry(tipoPerfil).State = System.Data.Entity.EntityState.Added;
mensaje = "Registro agregado exitosamente";
}
db.SaveChanges();
rm.SetResponse(true, mensaje);
}
}
catch (DbEntityValidationException ex)
{
foreach (var eve in ex.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
rm.SetResponse(false, ex.Message);
}
catch (Exception ex)
{
rm.SetResponse(false, ex.Message);
}
return(rm);
}
public frmRespuestaValidaciones(Form formPerfilPersonal, TipoPerfil tipoPerfil,
ServicioJava.usuario _user)
{
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
InitializeComponent();
//autogenrates columns = false...
dgvRespValida_HE.AutoGenerateColumns = false;
dgvVal_HoLibre.AutoGenerateColumns = false;
dgvVal_Inasis.AutoGenerateColumns = false;
dgvVal_CamTur.AutoGenerateColumns = false;
//se carga con las validaciones
dgvVal_HoLibre.DataSource = servTA.listarTodasHorasLibre(_user.id);
dgvVal_Inasis.DataSource = servTA.listarInasistencias(_user.id);
dgvRespValida_HE.DataSource = servTA.listarHorasExtra(_user.id);
//......
}
public frmRespuestaCapacitaciones(Form formPerfilPersonal, TipoPerfil tipoPerfil,
ServicioJava.usuario _user)
{
var_perfilPersonal = formPerfilPersonal;
var_tipoPerfil = tipoPerfil;
var_usuario = _user;
InitializeComponent();
//autogenrates columns = false...
dgvRespCapac.AutoGenerateColumns = false;
dgvAceptadas.AutoGenerateColumns = false;
//Cargar data
//dgvRespCapac.DataSource = Program.DBController.listarCapacitaciones();//lsita todas
//pasamos a las variables de listas
try
{
_lstaCapaPend = new BindingList <ServicioJava.capacitacion>(
Program.DBController.listarCapacitacionesPersonalxEstado(var_usuario.id, -1));
//aca lista todas de este usuario q aun estan por confirmar
dgvRespCapac.DataSource = _lstaCapaPend;
}
catch (Exception ex)
{
}
try
{
_lstaCapaAcep = new BindingList <ServicioJava.capacitacion>(
Program.DBController.listarCapacitacionesPersonalxEstado(var_usuario.id, 1));
//luego debe lsitar al listar capas aceptadas por este personal
dgvAceptadas.DataSource = _lstaCapaAcep;
}
catch (Exception ex)
{
}
}
public static string RecuperarNombreTipoPerfil(TipoPerfil tipoPerfil)
{
string tipoPerfilNombre = string.Empty;
switch (tipoPerfil)
{
case TipoPerfil.Candidato:
tipoPerfilNombre = SportsGoResources.Deportistas;
break;
case TipoPerfil.Grupo:
tipoPerfilNombre = SportsGoResources.Grupos;
break;
case TipoPerfil.Representante:
tipoPerfilNombre = SportsGoResources.Representantes;
break;
}
return(tipoPerfilNombre);
}
public static void Main(string[] args)
{
TipoPerfil tipoPerfil = (TipoPerfil)10;
for (TipoPerfil i = TipoPerfil.Diretor; i < TipoPerfil.Estagiario; i++)
{
Console.WriteLine(i);
}
Console.WriteLine(tipoPerfil);
Console.WriteLine((int)tipoPerfil);
foreach (string name in Enum.GetNames(typeof(TipoPerfil)))
{
Console.WriteLine(name);
}
TipoPerfil tipoPerfilParsed = (TipoPerfil)Enum.Parse(typeof(TipoPerfil), "Diretor");
Console.WriteLine($"Parsed: {tipoPerfilParsed}");
switch (tipoPerfil)
{
case TipoPerfil.Diretor:
break;
case TipoPerfil.Desenvolvedor:
Console.WriteLine("Sofredor...");
break;
case TipoPerfil.Faxineiro:
break;
case TipoPerfil.Estagiario:
Console.WriteLine("Caras legais...");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void Seed(TcUnipContext context)
{
var listBD = context.TipoPerfil.ToList();
if (!listBD.Any())
{
var arraySalvar = new TipoPerfil[]
{
new TipoPerfil {
Id = 1, Tipo = "Administrador", Permissao = "ADMINISTRACAO"
},
new TipoPerfil {
Id = 2, Tipo = "Recepcionista", Permissao = "RECEPCAO"
},
new TipoPerfil {
Id = 3, Tipo = "Profissional", Permissao = "PROFISSIONAL"
}
};
var listSalvar = new List <TipoPerfil>();
foreach (var item in arraySalvar)
{
if (listBD.Find(c => c.Id == item.Id &&
c.Tipo == item.Tipo &&
c.Permissao == item.Permissao) == null)
{
listSalvar.Add(item);
}
}
if (listSalvar.Count > 0)
{
context.TipoPerfil.AddOrUpdate(listSalvar.ToArray());
context.SaveChanges();
}
}
}
Task <List <TipoPerfil> > IPerfilRepository.ListarTipoPerfil()
{
var listaEntidades = new List <TipoPerfil>();
var parameters = new List <OracleParameter>
{
new OracleParameter("P_CU_SALIDA", OracleDbType.RefCursor, ParameterDirection.Output)
};
using (var dr = (OracleDataReader)_connectionBase.ExecuteByStoredProcedure("RAC_ADMINIST_SEGURIDAD.SEL_TIPO_PERFIL", parameters, ConnectionBase.enuTypeDataBase.OracleConciliacion))
{
while (dr.Read())
{
var entities = new TipoPerfil
{
IdTipoPerfil = Convert.ToInt32(dr["id_tipo_perfil"]),
VcDescripcion = Convert.ToString(dr["vc_descripcion"])
};
listaEntidades.Add(entities);
}
}
return(Task.FromResult <List <TipoPerfil> >(listaEntidades));
}
internal async Task <WrapperSimpleTypesDTO> CambiarPlanUsuarioADefaultPerfilPorVencimiento(PlanesUsuariosDTO planesUsuariosVencidoParaCambiar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
Planes planParaBuscar = new Planes
{
Consecutivo = planesUsuariosVencidoParaCambiar.CodigoPlan
};
int?codigoPerfil = await planesRepo.BuscarCodigoTipoPerfilDeUnPlan(planParaBuscar);
if (!codigoPerfil.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo de perfil!. BUUUUG");
}
TipoPerfil tipoPerfil = codigoPerfil.Value.ToEnum <TipoPerfil>();
int? codigoPlanDefault = await planesRepo.BuscarCodigoPlanDefault(tipoPerfil);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo del plan default para este perfil!. BUUUUG");
}
PlanesUsuarios planParaCambiar = new PlanesUsuarios
{
Consecutivo = planesUsuariosVencidoParaCambiar.Consecutivo,
CodigoPlanDeseado = codigoPlanDefault.Value
};
WrapperSimpleTypesDTO wrapper = await CambiarDePlanUsuario(planParaCambiar);
return(wrapper);
}
}
public async Task DeveCriarEventoEValidarParticularidadesSME_LiberacaoExcepcional(TipoPerfil tipoPerfil, bool sucesso)
{
//ARRANGE
var tipoEvento = new EventoTipo
{
Id = 1,
Codigo = (int)TipoEvento.LiberacaoExcepcional,
TipoData = EventoTipoData.InicioFim,
LocalOcorrencia = EventoLocalOcorrencia.UE
};
repositorioEventoTipo.Setup(c => c.ObterPorId(It.IsAny <long>()))
.Returns(tipoEvento);
var tipoCalendario = new TipoCalendario
{
Id = 1
};
repositorioTipoCalendario.Setup(c => c.ObterPorId(It.IsAny <long>()))
.Returns(tipoCalendario);
var listaPeriodoEscolar = new List <PeriodoEscolar>()
{
new PeriodoEscolar()
{
PeriodoInicio = DateTime.Today, PeriodoFim = DateTime.Today.AddDays(7)
}
};
repositorioPeriodoEscolar.Setup(a => a.ObterPorTipoCalendario(tipoCalendario.Id)).Returns(listaPeriodoEscolar);
var usuario = new Usuario();
var perfil = new PrioridadePerfil
{
CodigoPerfil = Guid.Parse("23A1E074-37D6-E911-ABD6-F81654FE895D"),
Tipo = tipoPerfil
};
usuario.DefinirPerfis(new List <PrioridadePerfil>
{
perfil
});
servicoUsuario.Setup(c => c.ObterUsuarioLogado())
.Returns(Task.FromResult(usuario));
var evento = new Evento
{
TipoCalendarioId = tipoCalendario.Id,
DreId = "1",
UeId = "2",
TipoEvento = tipoEvento,
DataInicio = DateTime.Now,
DataFim = DateTime.Now.AddDays(2),
Letivo = EventoLetivo.Sim
};
var ue = new AbrangenciaUeRetorno();
repositorioAbrangencia.Setup(a => a.ObterUe(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>())).Returns(Task.FromResult(ue));
//ASSERT
try
{
await servicoEvento.Salvar(evento, true);
Assert.True(true);
}
catch (Exception)
{
if (sucesso)
{
Assert.True(false);
}
}
}