public IActionResult DarPermisos(UsuarioViewModel modelo)
{
if(ModelState.IsValid)
{
foreach (var rol in modelo.Roles)
{
string mensaje = "";
bool accionRealizada =true;
if (_gestionDeUsuarios.UsuarioEnRol(modelo.NombreDeUsuario,rol.RolId))
{
if (!rol.Asignado)
{
accionRealizada = _gestionDeUsuarios.QuitarUsuarioDeRol(rol.Nombre, modelo.NombreDeUsuario, out mensaje);
}
}
else
{
if (rol.Asignado)
{
accionRealizada = _gestionDeUsuarios.AgregarUsuarioARol(rol.Nombre, modelo.NombreDeUsuario, out mensaje);
}
}
if (!accionRealizada) throw new System.Exception(mensaje);
}
return RedirectToAction("Index");
}
return View(modelo);
}
public ActionResult Registrar(UsuarioViewModel usuario)
{
Hash hash = new Hash(SHA512.Create());
if (ModelState.IsValid)
{
usuario.Senha = hash.CriptografarSenha(usuario.Senha);
_unityOfWork.Usuarios.Inserir(usuario.ParaUsuarioModel());
ViewBag.Mensagem = "Usuario registrado com sucesso!";
return RedirectToAction("LogIn");
}
else
{
ViewBag.Mensagem = "Erro ao salvar usuario";
}
return View();
}
public ActionResult NovoUsuario(UsuarioViewModel usuarioViewModel)
{
var novoUsuario = new UsuarioRN();
var cadastro = novoUsuario.NovoUsuario(usuarioViewModel);
if (cadastro == false)
{
var resultadoNegativo = new
{
Cor = "Red",
Mensagem = "Atenção - Já existe usuário com o nome escolhido."
};
return(Json(resultadoNegativo, JsonRequestBehavior.AllowGet));
}
var resultadoPositivo = new
{
Cor = "Green",
Mensagem = "Atenção - Cadastro efetuado com sucesso."
};
return(Json(resultadoPositivo, JsonRequestBehavior.AllowGet));
}
public IActionResult Detalle(int Id)
{
try
{
UsuarioDTO usuarioDTO = this._usuarioService.getUsuario((int)Id);
if (usuarioDTO != null)
{
UsuarioViewModel colorViewModel = this._mapper.Map <UsuarioDTO, UsuarioViewModel>(usuarioDTO);
return(View(colorViewModel));
}
else
{
ViewBag.error = "Ocurrio un error al intentar obtener el registro solicitado.";
return(View("index")); //deberia mostrar un msg de notificacion
}
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View("index")); //deberia mostrar un msg de notificacion
}
}
public void SignIn(UsuarioViewModel User, string providerKey = null, bool isPersistent = false)
{
var claims = new List <Claim>();
// create required claims
claims.Add(new Claim(ClaimTypes.NameIdentifier, User.UserId.ToString()));
claims.Add(new Claim(ClaimTypes.Name, User.UserName));
var jsonUserMonitoreo = JsonConvert.SerializeObject(User);
// custom – my serialized AppUserState object
claims.Add(new Claim("UsuarioApp", jsonUserMonitoreo));
var identity = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignIn(new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = isPersistent,
ExpiresUtc = DateTime.UtcNow.AddDays(7)
}, identity);
}
static void Main(string[] args)
{
int opçãoDeslogado = 0;
do
{
//Menu Deslogado
MenuUtil.MenuDeslogado();
opçãoDeslogado = int.Parse(Console.ReadLine());
switch (opçãoDeslogado)
{
case 1:
//Cadastrar Usuario
UsuarioViewController.CadastrarUsuario();
break;
case 2:
//Efetuar Login
UsuarioViewModel usuarioRetornado = UsuarioViewController.EfetuarLogin();
Console.WriteLine($"Bem-Vindo {usuarioRetornado.Nome}");
break;
case 3:
//Listar usuarios cadastrados
UsuarioViewController.ListarUsuario();
break;
case 9:
//Sair
break;
default:
Console.WriteLine("Opção Inválida");
break;
}
}while (opçãoDeslogado != 0);
}
public bool LoginUser(UsuarioViewModel usuario)
{
var userStore = new UserStore <IdentityUser>(new ClinicaVeterinariaDB());
var userManager = new UserManager <IdentityUser>(userStore);
var user = userManager.Find(usuario.Email, usuario.Senha);
if (user != null)
{
var identity = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
var authManager = HttpContext.Current.GetOwinContext().Authentication;
authManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, identity);
return(true);
}
else
{
return(false);
}
}
public async Task <IActionResult> PutUsuario(int id, [FromBody] UsuarioViewModel usuario)
{
if (usuario == null || id != usuario.Id)
{
return(BadRequest());
}
int val = await _usuarioService.Update(usuario);
if (val == 0)
{
return(StatusCode(304));
}
else if (val == -1)
{
return(StatusCode(412, "DbUpdateConcurrencyException"));
}
else
{
return(Accepted(usuario));
}
}
public JsonResult BuscarTiendaXNombreDeTienda(string nombreDeTienda)
{
TiendaViewModel tiendaBuscadaViewModel = new TiendaViewModel();
UsuarioViewModel usuarioViewModel = LLamarApiBuscarUsuarioXUsuario(User.Identity.Name);
if (ModelState.IsValid)
{
if (usuarioViewModel != null)
{
using (var cliente = new HttpClient())
{
cliente.BaseAddress = new Uri("http://localhost:51339/");
var responseTask = cliente.GetAsync("api/TiendaAPI/Get_BuscarTiendaDeUsuarioXNombre?nombreTienda=" + nombreDeTienda + "&idUsuarioOperador=" + usuarioViewModel.Id.ToString());
responseTask.Wait();
var result = responseTask.Result;
if (result.IsSuccessStatusCode)
{
var readTask = result.Content.ReadAsAsync <TiendaViewModel>();
readTask.Wait();
tiendaBuscadaViewModel = readTask.Result;
}
else //web api sent error response
{
var x = result.Content.ReadAsStringAsync();
x.Wait(); //x.Result tiene el resultado
ModelState.AddModelError(string.Empty, x.Result); //Falta agregar el ModelState.Summary en la GUI
}
}
}
}
//La GUI evalua el objeto json regresado, lo interpreta
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetNoStore();
return(Json(tiendaBuscadaViewModel.MostrarEnTiposPrimitivos(), JsonRequestBehavior.AllowGet));
}
public static string GenerateToken(UsuarioViewModel user)
{
var tokenHandler = new JwtSecurityTokenHandler();
var tokenDescriptor = new SecurityTokenDescriptor
{
Audience = TokenConfig.ValidoEm,
Issuer = TokenConfig.Emissor,
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.UserName.ToString()),
new Claim(ClaimTypes.Role, user.Role.ToString())
}),
NotBefore = DateTime.Now,
Expires = DateTime.Now.AddMinutes(TokenConfig.ExpiracaoEmMinutos),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(TokenConfig.ObterChave()), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
public void UsuarioViewModelPropertiesShouldBeSetAndRetrievedCorrectly()
{
var usuario = new UsuarioViewModel
{
Email = Email,
FlagGerente = FlagGerente,
FlagGerenteFinanceiro = FlagGerenteFinanceiro,
Gerente = Gerente,
GerenteFinanceiro = GerenteFinanceiro,
GerenteFinanceiroId = GerenteFinanceiroId,
GerenteId = GerenteId,
Id = Id,
Nome = Nome,
Senha = Senha,
Sobrenome = Sobrenome,
GerenteFinanceiroSelectList = GerenteFinanceiroSelectList,
GerenteSelectList = GerenteSelectList,
PrestacaoEmitente = PrestacaoEmitente,
ButtonText = ButtonText,
Action = Action
};
Assert.AreEqual(usuario.Email, Email);
Assert.AreEqual(usuario.FlagGerente, FlagGerente);
Assert.AreEqual(usuario.FlagGerenteFinanceiro, FlagGerenteFinanceiro);
Assert.AreEqual(usuario.Gerente, Gerente);
Assert.AreEqual(usuario.GerenteFinanceiro, GerenteFinanceiro);
Assert.AreEqual(usuario.GerenteFinanceiroId, GerenteFinanceiroId);
Assert.AreEqual(usuario.GerenteId, GerenteId);
Assert.AreEqual(usuario.Id, Id);
Assert.AreEqual(usuario.Nome, Nome);
Assert.AreEqual(usuario.Senha, Senha);
Assert.AreEqual(usuario.Sobrenome, Sobrenome);
Assert.AreEqual(usuario.GerenteFinanceiroSelectList, GerenteFinanceiroSelectList);
Assert.AreEqual(usuario.GerenteSelectList, GerenteSelectList);
Assert.AreEqual(usuario.PrestacaoEmitente, PrestacaoEmitente);
Assert.AreEqual(usuario.ButtonText, ButtonText);
Assert.AreEqual(usuario.Action, Action);
}
private void ingresarAdministrador(UsuarioViewModel model)
{
//Crea conexion
ELearningEntities context = new ELearningEntities();
//Obtiene id del usuario
string _idAdministrador = obtenerIdUsuario(model);
Administrador admin = new Administrador()
{
Apellido = model.Apellidos,
idAdmin = 0,
idAdministrador = _idAdministrador,
Nombre = model.Nombre,
Pais = model.Pais,
ZonaHoraria = model.ZonaHoraria,
Fotografia = string.Empty
};
//Guarda Administrador y guarda cambios
context.Administrador.Add(admin);
context.SaveChanges();
}
private async Task <UsuarioViewModel> ConvertInputModelToModelUsuario()
{
if (Input.Cnae.Contains("47.74-1-00"))
{
BloqueioAutomatico = false;
}
else
{
BloqueioAutomatico = true;
}
var usuarioViewModel = new UsuarioViewModel
{
NomeCompleto = Input.NomeCompleto,
BloqueioManual = false,
BloqueioAutomatico = BloqueioAutomatico,
DescontoCliente = 0,
Exibir = true
};
return(usuarioViewModel);
}
public JsonResult ActualizarTiendaDeUsuario(TiendaViewModel tiendaViewModel)
{
string respuesta = "";
if (ModelState.IsValid)
{
UsuarioViewModel usuarioViewModel = LLamarApiBuscarUsuarioXUsuario(User.Identity.Name);
tiendaViewModel.IdUsuarioAlta = usuarioViewModel.Id;
tiendaViewModel.IdUsuarioModifico = usuarioViewModel.Id;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://localhost:51339/");
//HTTP PUT
var putTask = client.PutAsJsonAsync <TiendaViewModel>("api/TiendaAPI/Put_ActualizarTiendaDeUsuario", tiendaViewModel);
putTask.Wait();
var result = putTask.Result;
if (result.IsSuccessStatusCode)
{
respuesta = "ok";
}
else
{
var x = result.Content.ReadAsStringAsync();
x.Wait(); // x.Result tiene el resultado
respuesta = x.Result;
}
}
}
else
{
respuesta = "No se pudo enlazar los datos para actualizar";
}
return(Json(respuesta, JsonRequestBehavior.AllowGet));
}
public ActionResult Edit(UsuarioViewModel usuarioViewModel)
{
USUARIOS usu = this.Convertir(usuarioViewModel);
{
try
{
using (UnidadDeTrabajo <USUARIOS> unidad = new UnidadDeTrabajo <USUARIOS>(new BDContext()))
{
unidad.genericDAL.Update(usu);
unidad.Complete();
}
TempData["mensaje"] = "Registro modificado satisfactoriamente";
return(RedirectToAction("Index"));
}
catch (Exception)
{
TempData["mensaje"] = "Error al modificar el registro";
return(RedirectToAction("Edit"));
}
}
}
public ActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
ClienteRepositorio cliente = new ClienteRepositorio();
UsuarioViewModel NovoUsuario = new UsuarioViewModel()
{
Nome = model.Nome,
Login = model.Email,
Senha = model.Password
};
cliente.Inserir(NovoUsuario);
return(RedirectToAction("Login", "Account"));
}
else
{
return(View());
}
}
public async Task <List <UsuarioViewModel> > UsuariosComuns()
{
var model = new List <UsuarioViewModel>();
var listaUsuarios = await _userManager.GetUsersInRoleAsync("usuario");
foreach (var user in listaUsuarios)
{
var userViewModel = new UsuarioViewModel
{
Id = user.Id,
Nome = user.Nome,
DataCadastro = user.DataCadastro,
Email = user.Email,
LockoutEnabled = user.LockoutEnabled
};
model.Add(userViewModel);
}
return(model);
}
public ActionResult SalvarUsuario(UsuarioViewModel model)
{
var resultado = "OK";
var mensagens = new List <string>();
var idSalvo = string.Empty;
if (!ModelState.IsValid)
{
resultado = "AVISO";
mensagens = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage).ToList();
}
else
{
try
{
if (model.Senha == _senhaPadrao)
{
model.Senha = "";
}
var vm = Mapper.Map <UsuarioModel>(model);
var id = vm.Salvar();
if (id > 0)
{
idSalvo = id.ToString();
}
else
{
resultado = "ERRO";
}
}
catch (Exception ex)
{
resultado = "ERRO";
}
}
return(Json(new { Resultado = resultado, Mensagens = mensagens, IdSalvo = idSalvo }));
}
public void AddUsuarioAgente(UsuarioViewModel uservm)
{
var plan = _db.Plans.Where(x => x.Nombre == "GOLD").FirstOrDefault();
Usuario user = new Usuario();
user.Nombre = uservm.Nombre;
user.ApellidoP = uservm.ApellidoP;
user.ApellidoM = uservm.ApellidoM;
user.Email = uservm.Email;
user.Password = uservm.Password;
user.FechaNacimiento = null;
user.Sexo = null;
user.TipoUsuario = "AGENTE";
user.FechaRegistro = DateTime.Now;
user.PlanId = plan.Id;
user.FechaInicioPlan = user.FechaRegistro;
user.FechaFinPlan = user.FechaInicioPlan.AddYears(50);
_db.Usuarios.Add(user);
_db.SaveChanges();
}
public async Task <IHttpActionResult> Edit(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var _usuarioDomain = await Task.FromResult(Mapper.Map <UsuarioViewModel, Usuario>(usuario));
if (_usuarioDomain == null)
{
return(NotFound());
}
else
{
_usuarioDomain.Senha = Shared.Senha.Encriptar(_usuarioDomain.Senha);
_usuarioApp.Update(_usuarioDomain);
return(Ok());
}
}
else
{
return(BadRequest());
}
}
public ActionResult Edit(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Usuario usuario = GerenciadorUsuario.FindById(id);
if (usuario == null)
{
return(HttpNotFound());
}
var uvm = new UsuarioViewModel();
uvm.Id = usuario.Id;
uvm.Nome = usuario.UserName;
uvm.Email = usuario.Email;
return(View(uvm));
}
public UsuarioViewModel Inserir(UsuarioViewModel usuario)
{
List <UsuarioViewModel> listaDeUsuarios = Listar();
int contador = 0;
if (listaDeUsuarios != null)
{
contador = listaDeUsuarios.Count;
}
usuario.Id = 1;
usuario.DataCriacao = DateTime.Now;
//Gera um arquivo CSV
StreamWriter sw = new StreamWriter("usuario.csv", true);
sw.WriteLine($"{usuario.Id};{usuario.Nome};{usuario.Email};{usuario.Senha};{usuario.DataCriacao}");
sw.Close();
return(usuario);
}
public ActionResult Login(UsuarioViewModel viewModel)
{
if (ModelState.IsValid)
{
var userStore = new UserStore <IdentityUser>(new MascaraIdentityDbContext());
var userManager = new UserManager <IdentityUser>(userStore);
var usuario = userManager.Find(viewModel.Email, viewModel.Senha);
if (usuario == null)
{
ModelState.AddModelError("erro_identity", "Usuário e/ou senha incorretos");
return(View(viewModel));
}
var autManager = HttpContext.GetOwinContext().Authentication;
var identity = userManager.CreateIdentity(usuario, DefaultAuthenticationTypes.ApplicationCookie);
autManager.SignIn(new Microsoft.Owin.Security.AuthenticationProperties
{
IsPersistent = false
}, identity);
return(RedirectToAction("Index", "Home"));
}
return(View(viewModel));
}
public ActionResult Edit(UsuarioViewModel usuarioViewModel)
{
try
{
usuarioViewModel = _usuarioAppService.GetById(usuarioViewModel.Id);
errors = _usuarioAppService.Update(usuarioViewModel);
Usuario usuario = AutoMapper.Mapper.Map <UsuarioViewModel, Usuario>(usuarioViewModel);
if (usuarioViewModel != null)
{
TempData["usuarioIndex"] = usuario;
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Login"));
}
}
catch (Exception e)
{
return(View(usuarioViewModel));
}
}
public async Task ProcessarCadastro(UsuarioViewModel obj, Guid?idGuid = null)
{
try
{
Guid id = idGuid ?? Guid.Parse(User.Identity.GetUserId());
var domain = await ctx.Usuario
.Include(i => i.CONTATO)
.Include(i => i.ENDERECO)
.FirstOrDefaultAsync(w => w.ID_USUARIO == id);
if (domain == null)
{
var newobj = new USUARIO(id, obj.NOME, new CPF(obj.CPF), new RG(obj.RgUF, obj.RgNR), obj.DT_NASCIMENTO);
newobj.AdicionarContato(new Telefone(obj.ContatoFIXO), new Telefone(obj.ContatoCELULAR), new Email(User.Identity.GetUserName()));
newobj.AdicionarEndereco(obj.EnderecoUF, obj.EnderecoCEP, obj.EnderecoLOGRADOURO, obj.EnderecoCOMPLEMENTO, obj.EnderecoBAIRRO, obj.EnderecoCIDADE);
ctx.Usuario.Add(newobj);
}
else
{
domain.AtualizaDados(obj.NOME, new CPF(obj.CPF), new RG(obj.RgUF, obj.RgNR), obj.DT_NASCIMENTO);
domain.CONTATO.AtualizarValor(new Telefone(obj.ContatoFIXO), new Telefone(obj.ContatoCELULAR));
domain.ENDERECO.AtualizaValores(obj.EnderecoUF, obj.EnderecoCEP, obj.EnderecoLOGRADOURO, obj.EnderecoCOMPLEMENTO, obj.EnderecoBAIRRO, obj.EnderecoCIDADE);
ctx.Entry(domain).State = EntityState.Modified;
ctx.Entry(domain.CONTATO).State = EntityState.Modified;
ctx.Entry(domain.ENDERECO).State = EntityState.Modified;
}
await ctx.SaveChangesAsync();
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.TratarMensagem());
}
}
public ActionResult Create([Bind] UsuarioViewModel usuario)
{
try
{
if (ModelState.IsValid)
{
repository.CriarUsuario(
new Domain.Usuario
{
Nome = usuario.Nome,
Sobrenome = usuario.Sobrenome,
DataNascimento = usuario.DataNascimento
});
return(RedirectToAction("Index"));
}
return(View(usuario));
}
catch
{
return(View());
}
}
/// <summary>
/// Añade un rol al usuario
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public ActionResult AddRoles(string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var user = userManager.Users.ToList().Find(u => u.Id == userId);
var allRoles = roleManager.Roles.ToList();
if (user == null)
{
return(HttpNotFound());
}
UsuarioViewModel usuarioViewModel = new UsuarioViewModel
{
Email = user.Email,
Name = user.UserName,
UsuarioId = user.Id,
Roles = (from ur in user.Roles
let rol = allRoles.Where(s => s.Id == ur.RoleId).FirstOrDefault()
select new RoleViewModel {
RoleId = rol.Id, Nombre = rol.Name
}).ToList()
};
allRoles.OrderBy(s => s.Name).ToList();
allRoles.Insert(0, new IdentityRole {
Id = "-1", Name = "[Seleccione un roll...]"
});
ViewBag.RoleId = new SelectList(allRoles, "Id", "Name");
return(View(usuarioViewModel));
}
public ActionResult Deletar(Guid id)
{
if (id == Guid.Empty)
{
TempData["Erro"] = "Informe o id do usuário";
return(RedirectToAction("Index"));
}
using (UsuarioRepositorio _repUsuario = new UsuarioRepositorio())
{
UsuarioViewModel vmUsuario = Mapper.Map <UsuarioDomain, UsuarioViewModel>(_repUsuario.BuscarPorId(id));
if (vmUsuario == null)
{
TempData["Erro"] = "Usuário não encontrado";
return(RedirectToAction("Index"));
}
else
{
return(View(vmUsuario));
}
}
}
public IActionResult ConfirmMail([FromBody] UsuarioViewModel vm)
{
if (vm == null)
{
return(BadRequest(ModelState));
}
if (!_usuariosBussiness.ExistsEntity(vm.Id))
{
return(NotFound());
}
vm.Estado = true;
if (!_usuariosBussiness.UpdateEntity(vm))
{
ModelState.AddModelError("", $"No se pudo confirmar el correo {vm.Correo}");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
try {
WebSecurity.CreateUserAndAccount(model.UserName, model.Password);
WebSecurity.Login(model.UserName, model.Password);
UsuarioViewModel user = new UsuarioViewModel();
user.User = model.UserName;
user.Nome = model.Nome;
user.CPF = model.CPF;
new UsuarioController().CreateUser(user);
return(RedirectToAction("Index", "Home"));
} catch (MembershipCreateUserException e) {
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public Usuario Post([FromBody] UsuarioViewModel usuarioViewModel)
{
var usuario = _dataService.ObterUsuarioPorEmail(usuarioViewModel.Email);
if (!(usuario is null))
{
if (usuario.VerificarSenha(usuarioViewModel.Senha))
{
if (usuario.Status == 1)
{
return(usuario);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
UsuarioViewModel UsuarioLogado = null;
using (var repositorio = new UsuarioRepositorio())
{
var usuario = new UsuarioViewModel()
{
Login = model.Email,
Senha = model.Password
};
UsuarioLogado = repositorio.Autenticar(usuario);
}
if (UsuarioLogado.ID != Guid.Empty)
{
string role = (UsuarioLogado.IsAdministrador ? "Admin" : "Cliente");
var authTicket = new FormsAuthenticationTicket(1, UsuarioLogado.Login, DateTime.Now, DateTime.Now.AddMinutes(20), false, role);
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
HttpContext.Response.Cookies.Add(authCookie);
Session["UsuarioLogado"] = UsuarioLogado;
return(RedirectToLocal(returnUrl));
}
else
{
ModelState.AddModelError("Erro", "Usuario inválido!");
}
}
return(View());
}
public IActionResult DarPermisos(string nombreDeUsuario)
{
var usuario = _gestionDeUsuarios.ObtenerUsuario(nombreDeUsuario);
UsuarioViewModel modelo = new UsuarioViewModel
{
Apellidos = usuario.Apellidos,
Email = usuario.email,
Nombre = usuario.Nombre,
NombreDeUsuario = usuario.NombreDeUsuario,
Roles = new List<RolViewModel>()
};
foreach (var rol in _gestionDeUsuarios.ObtenerRoles(modelo.NombreDeUsuario)) //Añadimos Roles Asignados
{
modelo.Roles.Add(new RolViewModel { RolId = rol.Id,Nombre=rol.Name,Asignado=true});
}
foreach (var rol in _gestionDeUsuarios.ObtenerRolesNoAsignados(modelo.NombreDeUsuario)) //Añadimos Roles No Asignados
{
modelo.Roles.Add(new RolViewModel { RolId = rol.Id, Nombre = rol.Name, Asignado = false });
}
ViewBag.Roles = _gestionDeUsuarios.ObtenerRoles();
return View(modelo);
}
// GET: /<controller>/
public IActionResult Index()
{
List<UsuarioViewModel> modelo = new List<UsuarioViewModel>();
IEnumerable<Usuario> usuarios = new List<Usuario>();
usuarios = _gestionDeUsuarios.ObtenerUsuarios();
UsuarioViewModel usuario = new UsuarioViewModel();
foreach (var item in usuarios)
{
usuario = new UsuarioViewModel
{
Nombre = item.Nombre,
NombreDeUsuario = item.NombreDeUsuario,
Email = item.email,
Apellidos = item.Apellidos,
Roles = new List<RolViewModel>()
};
modelo.Add(usuario);
}
foreach (var item in modelo)
{
var listaRoles = _gestionDeUsuarios.ObtenerRoles(item.NombreDeUsuario);
foreach (var rol in listaRoles)
{
item.Roles.Add(new RolViewModel { RolId = rol.Id, Nombre = rol.Name, Asignado = true});
}
}
return View(modelo);
}
public ActionResult ObterUsuarioViaAD(string login)
{
var dominio = AppSettings.Get("Dominio");
var usuario = usuarioAppService.ObterUsuarioViaAD(login, dominio);
if (usuario == null)
{
usuario = new UsuarioViewModel();
}
return Json(usuario, JsonRequestBehavior.AllowGet);
}
public ActionResult Gravar(UsuarioViewModel usuario)
{
var gravarResult = usuarioAppService.Gravar(usuario);
object retorno;
if (gravarResult.IsValid)
{
retorno = new
{
Mensagem = "Registro Gravado com Sucesso",
Erro = false
};
}
else
{
retorno = new
{
Mensagem = RenderizeErros(gravarResult),
Erro = true
};
}
return Json(retorno, JsonRequestBehavior.AllowGet);
}
public ActionResult CreateUsuario()
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
UsuarioViewModel model = new UsuarioViewModel();
return View(model);
}
public ActionResult Index(UsuarioViewModel usuario)
{
var resultado = this.usuarioAppService.Autenticar(usuario);
if (resultado.ValidationResult.IsValid == false)
{
var aviso = new Aviso
{
TipoMensagem = Aviso.Tipo.Erro,
TituloMensagem = "Problemas com o formulário:"
};
resultado.ValidationResult.Erros.ForEach(x => aviso.Mensagens.Add(x.Message));
TempData["Aviso"] = aviso;
return View("Index");
}
AuthUser(resultado);
return RedirectToAction("Index", "Home");
}
public ActionResult EditUsuario(Guid id)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
UsuarioViewModel model = new UsuarioViewModel();
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
Usuario usuario = (from d in db.Usuario
where d.IdUsuario == id
select d).FirstOrDefault();
string decryptedPassword = Encrypt.Encriptar(usuario.ClaveUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
if (usuario != null)
{
model.ConfirmPasswordUsuario = decryptedPassword;
model.EmailUsuario = usuario.Email;
model.Estado = usuario.IdEstadoUsuario;
model.Id = usuario.IdUsuario;
model.IdTipoUsuario = usuario.IdTipoUsuario;
model.Nombre = usuario.Nombre;
model.PasswordUsuario = decryptedPassword;
}
}
return View(model);
}
public ActionResult EditUsuario(UsuarioViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
return View(model);
}
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario usuario = (from d in db.Usuario
where d.IdUsuario == model.Id
select d).FirstOrDefault();
usuario.ClaveUsuario = encryptedPassword;
usuario.CodigoUsuario = model.EmailUsuario;
usuario.Email = model.EmailUsuario;
usuario.IdTipoUsuario = model.IdTipoUsuario;
usuario.PrimeraVez = true;
usuario.Nombre = model.Nombre;
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Usuario para " + model.Nombre,
105000001,
"Actualizar");
}
return RedirectToAction("Usuarios");
}
public JsonResult Inserir(UsuarioViewModel usuario)
{
return this.Json(this.usuarioAppService.Create(usuario));
}
public ActionResult CreateUsuario(UsuarioViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
return View(model);
}
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario usuario = new Usuario
{
ClaveUsuario = encryptedPassword,
Email = model.EmailUsuario,
CodigoUsuario = string.Empty,
FechaCambioEstatus = DateTime.UtcNow,
FechaUltimaConexion = DateTime.UtcNow,
IdEstadoUsuario = (int)eEstadoUsuario.Activo,
IdTipoUsuario = model.IdTipoUsuario,
IdUsuario = Guid.NewGuid(),
Nombre = model.Nombre,
Pregunta1 = string.Empty,
Pregunta2 = string.Empty,
Pregunta3 = string.Empty,
PrimeraVez = true,
Respuesta1 = string.Empty,
Respuesta2 = string.Empty,
Respuesta3 = string.Empty
};
db.Usuario.Add(usuario);
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Usuario para " + model.Nombre,
105000001,
"Agregar");
}
return RedirectToAction("Usuarios");
}