public IHttpActionResult PrimeiroAcesso(UsuarioDTO usuario)
        {
            if (usuario == null)
            {
                return(BadRequest("Usuário não informado!"));
            }
            usuario.Login = usuario.Login.ToLower();
            bool        usuarioExiste = usuariosService.UsuarioExiste(usuario.Login);
            Funcionario funcionario;

            if (!usuarioExiste)
            {
                if (!funcionariosService.FuncionarioExiste(usuario.MatriculaFuncionario, usuario.CodigoEmpresa))
                {
                    return(BadRequest($"Matrícula {usuario.MatriculaFuncionario} não cadastrada!"));
                }

                funcionario       = funcionariosService.GetFuncionario(usuario.MatriculaFuncionario, usuario.CodigoEmpresa);
                funcionario.Email = usuario.Email;
                funcionariosService.AddOrUpdateFuncionario(funcionario);

                Usuario novoUsuario = new Usuario
                {
                    Login         = usuario.Login,
                    FuncionarioId = funcionario.Id,
                    Nome          = funcionario.Nome,
                    Perfil        = Perfil.ELEITOR,
                    Senha         = CryptoGraph.Encrypt(usuario.Senha)
                };
                usuariosService.AddOrUpdateUsuario(novoUsuario);

                return(Ok());
            }

            if (!funcionariosService.FuncionarioExiste(usuario.MatriculaFuncionario, usuario.CodigoEmpresa))
            {
                return(BadRequest($"Matrícula {usuario.MatriculaFuncionario} não cadastrada!"));
            }

            funcionario       = funcionariosService.GetFuncionario(usuario.MatriculaFuncionario, usuario.CodigoEmpresa);
            funcionario.Email = usuario.Email;
            funcionariosService.AddOrUpdateFuncionario(funcionario);

            Usuario usuarioDB = usuariosService.GetUsuario(usuario.Login);

            usuarioDB.Senha = CryptoGraph.Encrypt(usuario.Senha);
            usuariosService.AddOrUpdateUsuario(usuarioDB);
            return(Ok());
        }
Beispiel #2
0
        public IHttpActionResult Post(VotoBranco voto)
        {
            try
            {
                voto.FuncionarioIdEleitor = usuariosService.GetUsuario(User.Identity.Name).FuncionarioId.Value;

                if (votosService.VotoExiste(voto.FuncionarioIdEleitor, voto.CodigoEleicao))
                {
                    return(Content(HttpStatusCode.BadRequest, "Voto já registrado!"));
                }

                return(Ok(votosService.RegistrarVotoBranco(voto)));
            }
            catch (FuncionarioNaoEncontradoException)
            {
                return(Content(HttpStatusCode.BadRequest, "Matrícula do funcionário eleitor não encontrada!"));
            }
            catch (DbUpdateException e)
            {
                return(Content(HttpStatusCode.InternalServerError, e.Message));
            }
            catch
            {
                return(Content(HttpStatusCode.InternalServerError, "Ocorreu um erro desconhecido. Por favor, entre em contato com o suporte."));
            }
        }
 public IHttpActionResult GetCandidatosAtualVoto(int codEleicao)
 {
     try
     {
         Eleicao e       = eleicoesService.GetEleicao(codEleicao);
         Usuario usuario = usuariosService.GetUsuario(User.Identity.Name);
         return(Ok(candidatosService.GetCandidatosParaVoto(e, usuario)));
     }
     catch (EleicaoNaoEncontradaException)
     {
         return(Content(HttpStatusCode.NotFound, "Código de Eleição não encontrado!"));
     }
     catch (ForaEtapaVotacaoException)
     {
         return(Content(HttpStatusCode.BadRequest, "A eleição não está em processo de votação no momento!"));
     }
     catch (VotoJaRealizadoException)
     {
         return(Content(HttpStatusCode.Forbidden, "Você já realizou seu voto. Não é possível anular ou alterar!"));
     }
     catch
     {
         return(Content(HttpStatusCode.InternalServerError, "Ocorreu um erro desconhecido. Por favor, entre em contato com o suporte."));
     }
 }
 public IHttpActionResult Get(string login)
 {
     try {
         return(Ok(new UsuarioDTO(usuariosService.GetUsuario(login))));
     } catch (UsuarioNaoEncontradoException)
     {
         return(Content(HttpStatusCode.NotFound, "Usuário não cadastrado!"));
     } catch
     {
         return(Content(HttpStatusCode.InternalServerError, "Ocorreu um erro desconhecido. Por favor, entre em contato com o suporte."));
     }
 }
Beispiel #5
0
        public IHttpActionResult PostVoto(Voto voto)
        {
            try
            {
                if (votosService.VotoExiste(voto.FuncionarioIdEleitor, voto.CodigoEleicao))
                {
                    return(Content(HttpStatusCode.BadRequest, "Voto já registrado!"));
                }

                voto.FuncionarioIdEleitor = usuariosService.GetUsuario(User.Identity.Name).FuncionarioId.Value;
                return(Content(HttpStatusCode.Created, new VotoDTO(votosService.RegistraVoto(voto))));
            } catch (CandidatoNaoEncontradoException)
            {
                return(Content(HttpStatusCode.BadRequest, "O funcionário informado não se candidatou nessa eleição!"));
            } catch (FuncionarioNaoEncontradoException)
            {
                return(Content(HttpStatusCode.BadRequest, "Matrícula do funcionário eleitor não encontrada!"));
            } catch
            {
                return(Content(HttpStatusCode.InternalServerError, "Ocorreu um erro desconhecido. Por favor, entre em contato com o suporte."));
            }
        }
        public static string GenerateToken(string username, int expireMinutes = 300, params string[] roles)
        {
            UsuariosService usuariosService = new UsuariosService();
            var             symmetricKey    = Convert.FromBase64String(Secret);
            var             tokenHandler    = new JwtSecurityTokenHandler();

            Usuario    usuario  = usuariosService.GetUsuario(username);
            List <int> empresas = usuario.Empresas?.Select(x => x.Codigo).ToList() ?? new List <int>();

            if (usuario.Funcionario != null && !empresas.Contains(usuario.Funcionario.CodigoEmpresa))
            {
                empresas.Add(usuario.Funcionario.CodigoEmpresa);
            }

            var          now    = DateTime.UtcNow;
            List <Claim> claims = new List <Claim>
            {
                new Claim(ClaimTypes.Name, username)
            };

            claims.AddRange(roles.Select(r => new Claim(ClaimTypes.Role, r)));
            claims.AddRange(empresas.Select(e => new Claim("company", e.ToString())));
            if (usuario.FuncionarioId.HasValue)
            {
                claims.Add(new Claim(ClaimTypes.NameIdentifier, usuario.FuncionarioId.Value.ToString()));
            }
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject            = new ClaimsIdentity(claims),
                Expires            = now.AddMinutes(Convert.ToInt32(expireMinutes)),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(symmetricKey), SecurityAlgorithms.HmacSha256Signature)
            };

            var stoken = tokenHandler.CreateToken(tokenDescriptor);
            var token  = tokenHandler.WriteToken(stoken);

            return(token);
        }
        public async Task <HttpResponseMessage> ImportacaoFuncionarios(int codEleicao)
        {
            // Verifica se request contém multipart/form-data.
            if (!Request.Content.IsMimeMultipartContent())
            {
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
            }

            //Diretório App_Data, para salvar o arquivo temporariamente
            string root     = HttpContext.Current.Server.MapPath("~/App_Data");
            var    provider = new MultipartFormDataStreamProvider(root);

            // Lê o arquivo da requisição assincronamente
            await Request.Content.ReadAsMultipartAsync(provider);

            ImportacaoOleDB imp = new ImportacaoOleDB(provider.FileData[0].LocalFileName, usuariosService.GetUsuario(User.Identity.Name));

            try
            {
                imp.ExecutarImportacaoGestores();
                List <InconsistenciaFuncionarioDTO> inconsistencias = imp.ExecutarImportacaoFuncionarios(codEleicao);
                File.Delete(provider.FileData[0].LocalFileName);
                //if (inconsistencias != null && inconsistencias.Count > 0) return Request.CreateResponse(HttpStatusCode.Accepted, inconsistencias);
            } catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e.Message));
            }

            return(Request.CreateResponse(HttpStatusCode.OK));
        }
 private Usuario GetUsuario()
 {
     return(usuariosService.GetUsuario(User.Identity.Name));
 }