public AccessTokenProvider()
{
string connectionString = ConfigurationManager.ConnectionStrings["conexao"].ToString();
usuarioRepository = new UsuarioRepository(connectionString);
usuarioApplication = new UsuarioApplication(usuarioRepository);
}
public async Task <ActionResult> RemoverTodosOsNodes(int IdUsuarioExclusaoTodos)
{
try
{
UsuarioApplication usuapp = new UsuarioApplication(this.db);
Usuario usu = usuapp.GetById(IdUsuarioExclusaoTodos);
usu.NosDoUsuario.Clear();
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Projetos removidos", TempData);
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusaoTodos }));
}
catch (UsuarioApplicationException uaex)
{
MensagemParaUsuarioViewModel.MensagemErro(uaex.Message, TempData, ModelState);
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusaoTodos }));
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
try
{
var usuario = UsuarioApplication.Get(context.UserName, context.Password);
if (usuario.Id > 0)
{
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
var claims = new List <string>();
identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName));
identity.AddClaim(new Claim("UsuarioId", usuario.Id.ToString()));
Thread.CurrentPrincipal = new GenericPrincipal(identity, claims.ToArray());
context.Validated(identity);
}
else
{
context.SetError("invalid_grant", "Usuário ou senha inválidos");
return;
}
}
catch (Exception ex)
{
context.SetError("invalid_grant", "Falha ao autenticar");
}
}
public async Task <ActionResult> AtrasoLancamento()
{
var app = new UsuarioApplication(this.db);
var modelo = await app.GetUsuariosComAtrasoNoEnvioAsync();
return(View(modelo));
}
public async Task <ActionResult> RemoverNode(int IdUsuarioExclusao, int IdNodeExclusao, bool RemoverRecursivo)
{
try
{
UsuarioApplication usu = new UsuarioApplication(this.db);
await usu.RemoverNodeAsync(IdUsuarioExclusao, IdNodeExclusao, RemoverRecursivo);
MensagemParaUsuarioViewModel.MensagemSucesso("Projeto removido", TempData);
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusao }));
}
catch (UsuarioApplicationException uaex)
{
MensagemParaUsuarioViewModel.MensagemErro(uaex.Message, TempData, ModelState);
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusao }));
}
/// <summary>
/// Este método retorna um usuario a partir do seu ID
/// </summary>
/// <param name="id">Id relativo a chave de busca para o usuario</param>
/// <returns>Retorna um usuario</returns>
public HttpResponseMessage Get(Guid id)
{
try
{
Usuario usuarioModel = null;
UsuarioRepository usuarioRepository = new UsuarioRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
UsuarioApplication usuarioApplication = new UsuarioApplication(usuarioRepository);
Uniftec.ProjetosWeb.Domain.Entities.Usuario usuario = usuarioApplication.Procurar(id);
//Realizar o adapter entre a entidade e o modelo de dados do dominio
if (usuario != null)
{
usuarioModel = new Usuario()
{
Id = usuario.Id,
PrimeiroNome = usuario.PrimeiroNome,
SegundoNome = usuario.SegundoNome,
Funcao = usuario.Funcao,
Servidores = usuario.Servidores,
Email = usuario.Email,
Senha = usuario.Senha
};
foreach (var servidor in usuario.ListaServidores)
{
usuarioModel.ListaServidores.Add(new Servidor()
{
Id = servidor.Id,
Nome = servidor.Nome,
EnderecoFisico = servidor.EnderecoFisico,
Processador = servidor.Processador,
SistemaOperacional = servidor.SistemaOperacional,
MacAddress = servidor.MacAddress,
IpAddress = servidor.IpAddress,
Sensor =
{
Id = servidor.Sensor.Id,
Temperatura = servidor.Sensor.Temperatura,
Pressao = servidor.Sensor.Pressao,
Altitude = servidor.Sensor.Altitude,
Umidade = servidor.Sensor.Umidade,
Data = servidor.Sensor.Data,
PontoOrvalho = servidor.Sensor.PontoOrvalho
}
});
}
return(Request.CreateResponse(HttpStatusCode.OK, usuarioModel));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
/// <summary>
/// Este método retorna uma listagem de todos os usuarios
/// </summary>
/// <returns>Nao possui retorno</returns>
//[Authorize] //para esse metodo ser processado ele precisa ser autenticado
public HttpResponseMessage Get()
{
try
{
List <Usuario> UsuariosModel = new List <Usuario>();
UsuarioRepository usuarioRepository = new UsuarioRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
UsuarioApplication usuarioApplication = new UsuarioApplication(usuarioRepository);
List <Uniftec.ProjetosWeb.Domain.Entities.Usuario> usuarios = usuarioApplication.ProcurarTodos();
//Realizar o adapter entre a entidade e o modelo de dados do dominio
foreach (var user in usuarios)
{
Usuario usuarioModel = new Usuario();
usuarioModel.Id = user.Id;
usuarioModel.PrimeiroNome = user.PrimeiroNome;
usuarioModel.SegundoNome = user.SegundoNome;
usuarioModel.Funcao = user.Funcao;
usuarioModel.Servidores = user.Servidores;
usuarioModel.Email = user.Email;
usuarioModel.Senha = user.Senha;
foreach (var servidor in user.ListaServidores)
{
usuarioModel.ListaServidores.Add(new Servidor()
{
Id = servidor.Id,
Nome = servidor.Nome,
EnderecoFisico = servidor.EnderecoFisico,
Processador = servidor.Processador,
SistemaOperacional = servidor.SistemaOperacional,
MacAddress = servidor.MacAddress,
IpAddress = servidor.IpAddress,
Sensor =
{
Id = servidor.Sensor.Id,
Temperatura = servidor.Sensor.Temperatura,
Pressao = servidor.Sensor.Pressao,
Altitude = servidor.Sensor.Altitude,
Umidade = servidor.Sensor.Umidade,
Data = servidor.Sensor.Data,
PontoOrvalho = servidor.Sensor.PontoOrvalho
}
});
}
UsuariosModel.Add(usuarioModel);
}
return(Request.CreateResponse(HttpStatusCode.OK, UsuariosModel));
}
catch (ApplicationException ap)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ap));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
private UsuariosController CriarUsuarioController(bool clienteValido = true, bool operadorValido = true, bool usuarioValido = true, bool usuarioExiste = true)
{
var clienteRepository = new ClienteRepositoryMock().ObterPorCpf(clienteValido).Salvar().VerificarSeExiste(!clienteValido);
var operadorRepository = new OperadorRepositoryMock().ObterPorMatricula(operadorValido).Salvar().VerificarSeExiste(!operadorValido);
var usuarioRepository = new UsuarioRepositoryMock().ObterPorLogin(usuarioValido).Salvar().VerificarSeExiste(usuarioExiste);
var usuarioApplication = new UsuarioApplication(_mapperFixture.Mapper, clienteRepository.Object, operadorRepository.Object, usuarioRepository.Object);
return(new UsuariosController(_mapperFixture.Mapper, usuarioApplication));
}
public HttpResponseMessage Put(Guid id, [FromBody] Usuario usuario)
{
try
{
//Alterar o usuario na base de dados
//Essa alteracao retorna um ID
//Id retornado para o requisitante do serviço
UsuarioRepository usuarioRepository = new UsuarioRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
UsuarioApplication usuarioApplication = new UsuarioApplication(usuarioRepository);
//Converter o model para uma entidade de dominio
Uniftec.ProjetosWeb.Domain.Entities.Usuario usuarioDomain = new Uniftec.ProjetosWeb.Domain.Entities.Usuario()
{
Id = id,
PrimeiroNome = usuario.PrimeiroNome,
SegundoNome = usuario.SegundoNome,
Funcao = usuario.Funcao,
Servidores = usuario.Servidores,
Email = usuario.Email,
Senha = usuario.Senha
};
foreach (var servidor in usuario.ListaServidores)
{
usuarioDomain.ListaServidores.Add(new Uniftec.ProjetosWeb.Domain.Entities.Servidor()
{
Id = servidor.Id,
Nome = servidor.Nome,
EnderecoFisico = servidor.EnderecoFisico,
Processador = servidor.Processador,
SistemaOperacional = servidor.SistemaOperacional,
MacAddress = servidor.MacAddress,
IpAddress = servidor.IpAddress,
Sensor =
{
Id = servidor.Sensor.Id,
Temperatura = servidor.Sensor.Temperatura,
Pressao = servidor.Sensor.Pressao,
Altitude = servidor.Sensor.Altitude,
Umidade = servidor.Sensor.Umidade,
Data = servidor.Sensor.Data,
PontoOrvalho = servidor.Sensor.PontoOrvalho
}
});
}
usuarioApplication.Alterar(usuarioDomain);
return(Request.CreateErrorResponse(HttpStatusCode.OK, Convert.ToString(id)));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public HttpResponseMessage Create(Interacao interacao)
{
try
{
interacao.Usuario.Id = UsuarioApplication.ObtemUsuarioLogadoId((User.Identity as ClaimsIdentity).Claims.ToList());
InteracaoApplication.Add(interacao);
return(ValidaRetornoApplication());
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Erro ao cadastrar a ocorrência."));
}
}
public async Task <ActionResult> EnviarTodosEmailsDeAlerta()
{
try
{
UsuarioApplication usuApp = new UsuarioApplication(this.db);
await usuApp.EnviarTodosOsAlertasAsync(true, true);
MensagemParaUsuarioViewModel.MensagemSucesso("Alertas enviados com sucesso.", TempData);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
}
return(RedirectToAction("AtrasoLancamento"));
}
public HttpResponseMessage Create(Ocorrencia ocorrencia)
{
try
{
ocorrencia.Usuario = new Usuario()
{
Id = UsuarioApplication.ObtemUsuarioLogadoId((User.Identity as ClaimsIdentity).Claims.ToList())
};
OcorrenciaApplication.Add(ocorrencia);
return(ValidaRetornoApplication());
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Erro ao cadastrar a ocorrência."));
}
}
public async Task <ActionResult> AdicionarNode(UsuarioNodeViewModel urvm)
{
CarregaNodes();
if ((urvm == null) || (urvm.IdUsuario == 0))
{
MensagemParaUsuarioViewModel.MensagemErro("Usuário não encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
if ((urvm == null) || (urvm.IdNode == 0) || (urvm.IdUsuario == 0))
{
MensagemParaUsuarioViewModel.MensagemErro("O Nó de Projeto e o usuário devem ser informados.", TempData, ModelState);
return(View(urvm));
}
if (ModelState.IsValid)
{
try
{
UsuarioApplication usu = new UsuarioApplication(this.db);
await usu.AdicionarNodeAsync(urvm);
MensagemParaUsuarioViewModel.MensagemSucesso("Projeto adicionado", TempData);
return(View(urvm));
}
catch (UsuarioApplicationException uaex)
{
MensagemParaUsuarioViewModel.MensagemErro(uaex.Message, TempData, ModelState);
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro("Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. " + err.Message, TempData, ModelState);
}
}
return(View(urvm));
}
public async Task <JsonResult> AdicionarRecursos(NodeUsuariosViewModel nuvm)
{
UsuarioApplication usuApp = new UsuarioApplication(this.db);
try
{
await usuApp.RemoverUsuariosForaDaLista(nuvm.IdNode, nuvm.IdsUsuarios, nuvm.AdicionarRecursivo);
if (nuvm.IdsUsuarios != null && nuvm.IdsUsuarios.Count > 0)
{
foreach (int usu in nuvm.IdsUsuarios)
{
await usuApp.AdicionarNodeAsync(new UsuarioNodeViewModel
{
AdicionarRecursivo = nuvm.AdicionarRecursivo,
IdNode = nuvm.IdNode,
IdUsuario = usu
});
}
return(Json(new
{
Sucesso = true,
Mensagem = "Recursos adicionados com sucesso."
}));
}
else
{
return(Json(new
{
Sucesso = true,
Mensagem = "Recursos removidos com sucesso."
}));
}
}
catch (Exception err)
{
LogServices.LogarException(err);
return(Json(new
{
Sucesso = false,
Mensagem = err.Message
}));
}
}
public HttpResponseMessage Delete(Guid id)
{
try
{
//Excluir o usuario na base de dados
//Essa exclusão retorna verdadeiro ou falso
UsuarioRepository usuarioRepository = new UsuarioRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
UsuarioApplication usuarioApplication = new UsuarioApplication(usuarioRepository);
var retorno = usuarioApplication.Excluir(id);
return(Request.CreateErrorResponse(HttpStatusCode.OK, Convert.ToString(retorno)));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public async Task <ActionResult> MeusDados([Bind(Include = "Id, Nome, Celular, EmailProfissional")] MeusDadosViewModel usuVm)
{
if ((usuVm == null) || (usuVm.Id == 0))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "O Id deve ser informado"));
}
if (ModelState.IsValid)
{
UsuarioApplication usuApp = new UsuarioApplication(db);
Usuario usu = usuApp.GetById(usuVm.Id);
if (usu == null)
{
return(HttpNotFound());
}
if (usuVm.EmailProfissional == usu.Login)
{
MensagemParaUsuarioViewModel.MensagemErro("Este e-mail não pode ser igual ao seu login.", TempData, ModelState, "EmailProfissional");
return(View(usuVm));
}
if (!string.IsNullOrWhiteSpace(usuVm.EmailProfissional))
{
if (await usuApp.VerificaExistenciaEmailAsync(usuVm.EmailProfissional, usuVm.Id))
{
MensagemParaUsuarioViewModel.MensagemErro("Esse e-mail profissional já está em uso.", TempData, ModelState, "EmailProfissional");
return(View(usuVm));
}
}
usuVm.Login = usu.Login;
var teste = Mapper.Map <MeusDadosViewModel, Usuario>(usuVm, usu);
await usuApp.SaveAsync(usu);
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Atualizado.", TempData);
}
return(View(usuVm));
}
static void Main(string[] args)
{
Usuario usuario = new Usuario
{
Nome = "Juninho",
Login = "******",
Email = "*****@*****.**",
Senha = "senha",
Posicao = "Atacante",
PosicaoSecundaria = "Meia-Atacante"
};
//UsuarioRepository dbUser = new UsuarioRepository();
//dbUser.AddUsuario(usuario);
//List<Usuario> lista;
//lista = dbUser.GetListaUsuario();
//Console.WriteLine(lista[0].Nome);
UsuarioApplication controle = new UsuarioApplication();
controle.EditUsuario(usuario);
Usuario teste = controle.GetUsuario(usuario);
//Usuario teste = dbUser.ConsultaUsuario(usuario);
if (teste.Senha == usuario.Senha)
{
Console.WriteLine(teste.Nome);
}
else
{
Console.WriteLine("Senha Incorreta");
}
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public UsuarioController(UsuarioApplication usuarioApplication)
{
_usuarioApplication = usuarioApplication;
}
public async Task <ActionResult> Edit([Bind(Include = "Id, Login, Nome, EmailProfissional, Celular, Ativo, EnviarAlertaLancamento")] UsuarioViewModel usuVm)
{
if (ModelState.IsValid)
{
try
{
usuVm.Login = usuVm.Login.Trim();
UsuarioApplication usuApp = new UsuarioApplication(db);
Usuario ent = usuApp.GetById(usuVm.Id);
if (ent == null)
{
return(HttpNotFound());
}
if (string.IsNullOrWhiteSpace(usuVm.Login))
{
MensagemParaUsuarioViewModel.MensagemErro("Usuário com login não definido.", TempData, ModelState, "Login");
return(View(usuVm));
}
if (await usuApp.VerificaExistenciaEmailAsync(usuVm.Login, usuVm.Id))
{
MensagemParaUsuarioViewModel.MensagemErro("Esse login já está em uso.", TempData, ModelState, "Login");
return(View(usuVm));
}
if (usuVm.EmailProfissional == usuVm.Login)
{
MensagemParaUsuarioViewModel.MensagemErro("Este e-mail não pode ser igual ao seu login.", TempData, ModelState, "EmailProfissional");
return(View(usuVm));
}
if (!string.IsNullOrWhiteSpace(usuVm.EmailProfissional))
{
if (await usuApp.VerificaExistenciaEmailAsync(usuVm.EmailProfissional, usuVm.Id))
{
MensagemParaUsuarioViewModel.MensagemErro("Esse e-mail profissional já está em uso.", TempData, ModelState, "EmailProfissional");
return(View(usuVm));
}
}
var teste = Mapper.Map <UsuarioViewModel, Usuario>(usuVm, ent);
await usuApp.SaveAsync(ent);
MensagemParaUsuarioViewModel.MensagemSucesso("Usuário salvo com sucesso.", TempData);
return(View(usuVm));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. " + err.Message, TempData, ModelState);
}
}
return(View(usuVm));
}
public UsuariosController(UsuarioApplication usuarioApplication, UsuarioValidator validator)
{
_usuarioApplication = usuarioApplication;
_validator = validator;
}
public UsuarioController()
{
usuarioApplication = new UsuarioApplication();
}
public UsuarioServices()
{
_app = new UsuarioApplication();
}
