public IActionResult Index()
{
AdministradorViewModel admViewModel = new AdministradorViewModel();
admViewModel.Nome = HttpContext.Session.GetString(SESSION_ADMIN);
ViewBag.Admin = HttpContext.Session.GetString(SESSION_ADMIN);
if (string.IsNullOrEmpty(HttpContext.Session.GetString(SESSION_ADMIN)))
{
var erroViewModel = new ErroViewModel();
TempData["erro"] = "Apenas administradores podem acessar essa página !";
TempData["voltar"] = "/Home/Index";
return(View("_Erro", erroViewModel));
}
admViewModel.ListaDeUsuarios = usuarioRepositorio.Listar();
admViewModel.ListaDeComentarios = comentarioRepositorio.Listar();
admViewModel.ComentariosAprovados = 0;
admViewModel.ComentariosRecusados = 0;
foreach (var item in admViewModel.ListaDeComentarios)
{
if (item.EstaAprovado)
{
admViewModel.ComentariosAprovados++;
}
else
{
admViewModel.ComentariosRecusados++;
}
}
return(View(admViewModel));
}
public async Task <IActionResult> Login(AdministradorViewModel administradorViewModel)
{
var adm = _administradorRepositorio.PegarAdministrador(administradorViewModel.Email, administradorViewModel.Senha);
if (adm == null)
{
ModelState.AddModelError(string.Empty, "Email e/ou senhas inválidos");
return(View(administradorViewModel));
}
//if (!_administradorRepositorio.AdministradorExiste(administradorViewModel.Email, administradorViewModel.Senha))
//{
// ModelState.AddModelError(string.Empty, "Email e/ou senhas inválidos");
// return View(administradorViewModel);
//}
var claims = new List <Claim>
{
new Claim(ClaimTypes.Email, administradorViewModel.Email)
};
var userIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
await HttpContext.SignInAsync(principal);
HttpContext.Session.SetString("Usuario", administradorViewModel.Email);
HttpContext.Session.SetInt32("AdministradorId", adm.AdministradorId);
ViewData["Usuario"] = HttpContext.Session.GetString("Usuario");
return(RedirectToAction("Index", "Alunos"));
}
public IActionResult Add()
{
var lista = facultadService.ListarFacultades();
var facu = new AdministradorViewModel(lista);
return(View(facu));
}
public ActionResult Create(AdministradorViewModel articulo, HttpPostedFileBase file)
{
string fileName = "", path = "";
// Verify that the user selected a file
if (file != null && file.ContentLength > 0)
{
System.Diagnostics.Debug.WriteLine("Entro en el if ");
// extract only the fielname
fileName = Path.GetFileName(file.FileName);
System.Diagnostics.Debug.WriteLine(fileName);
// store the file inside ~/App_Data/uploads folder
path = Path.Combine(Server.MapPath("~/Content/Profile"), fileName);
System.Diagnostics.Debug.WriteLine(path);
//string pathDef = path.Replace(@"\\", @"\");
file.SaveAs(path);
}
try
{
AdministradorCEN art = new AdministradorCEN();
fileName = "/Content/Profile/" + fileName;
art.New_(articulo.NUsuario, articulo.Email, articulo.FecNam, articulo.Nombre, articulo.Apellidos, fileName, articulo.Tipo, articulo.Password, articulo.Sueldo);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Cadastrar(String msg)
{
AdministradorViewModel admViewModel = new AdministradorViewModel()
{
Msg = msg
};
return(View(admViewModel));
}
// GET: FacultadController
public ActionResult Index()
{
var cookieValue = Request.Cookies["UrlFacultad"];
multyTenancyService.SeleccionarNodoFacultad(cookieValue);
var lista = userService.ListarAdministrador();
var user = new AdministradorViewModel(lista);
return(View(user));
}
public IActionResult Index()
{
ViewData["LoginN"] = HttpContext.Session.GetString("_NOME");
ViewData["LoginE"] = HttpContext.Session.GetString("_EMAIL");
AdministradorViewModel administradorViewModel = new AdministradorViewModel();
return(View(administradorViewModel));
}
public IActionResult Edit(int id)
{
var admin = userService.get(id);
var adminModel = new AdministradorViewModel()
{
Id = id,
Nombre = admin.Nombre,
Apellido = admin.Apellido,
};
return(View(adminModel));
}
public ActionResult ListaAdministradoresView()
{
if (SecurityHelper.GetAdministradorID() > 0 && SecurityHelper.GetAdministradorRol() == "Administrador General")
{
AdministradorViewModel model = new AdministradorViewModel();
model.ListaAdministradores = administradorDataAccess.GetListaAdministradores();
return(PartialView(model));
}
else
{
return(RedirectToAction("Index", "Login", new { Area = "" }));
}
}
private async Task CambiarEstado(AdministradorViewModel administrador)
{
if (administrador.Estado)
{
await this.AdministradorDataService.Desactivar(administrador.Id).ConfigureAwait(false);
}
else
{
await this.AdministradorDataService.Activar(administrador.Id).ConfigureAwait(false);
}
this.LAdministradores = (await this.AdministradorDataService.Listar().ConfigureAwait(false)).ToList();
}
public async Task <ActionResult <AdministradorViewModel> > Crear(CrearViewModel model)
{
if (model == null)
{
return(this.BadRequest());
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var fecha = DateTime.Now;
this._passwordHelper.CrearPasswordHash(model.Password, out byte[] passwordHash);
var administrador = new Administrador
{
RolId = model.RolId,
Email = model.Email.Trim().ToUpperInvariant(),
Username = model.Username.Trim().ToUpperInvariant(),
PasswordHash = passwordHash,
Estado = true,
CreatedAt = fecha,
UpdatedAt = fecha,
};
await this._context.Administradores.AddAsync(administrador).ConfigureAwait(false);
try
{
await this._context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
return(this.BadRequest("Hubo un error al guardar sus datos."));
}
var administradorModel = new AdministradorViewModel
{
Id = administrador.Id,
Email = model.Email,
Username = model.Username,
CreatedAt = administrador.CreatedAt,
UpdatedAt = administrador.UpdatedAt,
};
return(this.CreatedAtAction("Mostrar", new { id = administrador.Id }, administradorModel));
}
public IActionResult Edit(AdministradorViewModel model)
{
var cookieValue = Request.Cookies["UrlFacultad"];
multyTenancyService.SeleccionarNodoFacultad(cookieValue);
var admin = new Administrador()
{
Id = model.Id,
Nombre = model.Nombre,
Apellido = model.Apellido,
};
userService.ModifyAdministrador(admin);
return(RedirectToAction("Index"));
}
public IActionResult Comentarios()
{
ViewData["UserN"] = HttpContext.Session.GetString("USER_NOME");
ViewData["UserE"] = HttpContext.Session.GetString("USER_EMAIL");
ViewData["UserA"] = HttpContext.Session.GetString("USER_ADMIN");
ViewData["Css"] = "Comentarios";
if (ViewData["UserA"] != null)
{
if (bool.Parse((string)ViewData["UserA"]))
{
AdministradorViewModel administradorViewModel = new AdministradorViewModel();
return(View(administradorViewModel));
}
}
return(RedirectToAction("Index", "Home"));
}
public IActionResult Administrador()
{
var ninguemLogado = string.IsNullOrEmpty(ObterUsuarioTipoSession());
if (!ninguemLogado &&
(uint)TiposUsuario.ADMINISTRADOR == uint.Parse(ObterUsuarioTipoSession()))
{
var alugueis = aluguelRepository.ObterTodos();
AdministradorViewModel administradorViewModel = new AdministradorViewModel();
foreach (var aluguel in alugueis)
{
switch (aluguel.Status)
{
case (uint)StatusAluguel.APROVADO:
administradorViewModel.AlugueisAprovados++;
break;
case (uint)StatusAluguel.REPROVADO:
administradorViewModel.AlugueisReprovados++;
break;
default:
administradorViewModel.AlugueisPendentes++;
administradorViewModel.Alugueis.Add(aluguel);
break;
}
}
administradorViewModel.NomeView = "Administrador";
administradorViewModel.UsuarioEmail = ObterUsuarioSession();
return(View(administradorViewModel));
}
else
{
return(View("Erro", new RespostaViewModel()
{
NomeView = "Administrador",
Mensagem = "Você não tem permissão para acessar o Dashboard"
}));
}
}
public IActionResult Add(AdministradorViewModel model)
{
if (ModelState.IsValid)
{
var cookieValue = Request.Cookies["UrlFacultad"];
multyTenancyService.SeleccionarNodoFacultad(cookieValue);
string salt = PassSalt.Create();
string hash = PassHash.Create(model.Password, salt);
var a = new Administrador()
{
Nombre = model.Nombre,
Apellido = model.Apellido,
Usuario = model.Usuario,
Passwd = hash,
Salt = salt,
};
userService.AddAdministrador(a, model.Tipo_Administrador, model.Facultad);
return(RedirectToAction("Index"));
}
return(View(model));
}
public ActionResult Cadastrar(AdministradorViewModel admViewModel)
{
//Se validação ok
if (ModelState.IsValid)
{
//Passando os dados do view admViewModel para o modelo Login
Login login = new Login()
{
Username = admViewModel.Username,
Senha = admViewModel.Senha
};
//CadastrarADm do login repositorio, cadasto no banco na tabela Login
((LoginRepository)_unit.LoginRepository).CadastrarADM(login);
_unit.Save();
//redirecionar para a View Cadastrar
return(RedirectToAction("Cadastrar", new { msg = "Administrador cadastrado com sucesso!" }));
}
else
{
return(View(admViewModel));
}
}
public async Task <IActionResult> Login(AdministradorViewModel adminViewModel)
{
if (!_repositorio.AdministradorExiste(adminViewModel.Email, adminViewModel.Senha))
{
ModelState.AddModelError(string.Empty, "E-mail e/ou senha inválidos.");
return(View(adminViewModel));
}
var claims = new List <Claim>
{
new Claim(ClaimTypes.Email, adminViewModel.Email)
};
var userIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
await HttpContext.SignInAsync(principal);
HttpContext.Session.SetString("Usuario", adminViewModel.Email);
ViewData["Usuario"] = HttpContext.Session.GetString("Usuario");
return(RedirectToAction("Index", "Professor"));
}
public IActionResult IniciarSesion(AdministradorViewModel model)
{
var u = userService.VerificarLoginAdministradores(model.Usuario, model.Password);
if (u == null)
{
var mensaje = new AdministradorViewModel("Error de usuario y/o contraseña");
return(View("Index", mensaje));
}
else if (u.TipoCuenta == "Udelar")
{
Response.Cookies.Append("IdAdministrador", u.Id.ToString(), option);
return(RedirectToAction(nameof(MenuAdminUdelar)));
}
else
{
var urlFac = multyTenancy.SelecionarTenanAdminFacu(u.Id);
Response.Cookies.Append("UrlFacultad", urlFac, option);
Response.Cookies.Append("IdAdministrador", u.Id.ToString(), option);
return(RedirectToAction(nameof(MenuAdminFacu)));
}
}
public ActionResult Create(AdministradorViewModel model)
{
try
{
//// TODO: Add insert logic here
var administrador = new Administrador();
using (UnitOfWork unitOfWork = new UnitOfWork(new CharmosaAppContext(new DbContextOptions <CharmosaAppContext>())))
{
using (var appService = new AdministradorAppService(unitOfWork.AdministradorRepository))
{
appService.Add(administrador);
unitOfWork.Commit();
return(View());
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(View());
}
}
// GET: Admin/Create
public ActionResult Create()
{
AdministradorViewModel usu = new AdministradorViewModel();
return(View(usu));
}
public AdministradorViewModel Remover(AdministradorViewModel administradorViewModel)
{
throw new NotImplementedException();
}
public AdministradorViewModel Atualizar(AdministradorViewModel administradorViewModel)
{
throw new NotImplementedException();
}
