private void Validar(Guid siteId, string id, UsuarioDto usuarioDto) { if (!id.GuidValido()) throw new FormatoInvalido("O identificador de usuario informado não é válido."); if (_repositorioUsuarios.BuscarPorId(siteId, new Guid(id)) == null) throw new RecursoNaoEncontrado("Usuario não encontrado"); if (string.IsNullOrEmpty(usuarioDto.Nome)) throw new FormatoInvalido("O nome do usuário deve ser informado."); if (string.IsNullOrEmpty(usuarioDto.Nome)) throw new FormatoInvalido("O nome do usuário deve ter no máximo 20 caracteres."); if (_repositorioUsuarios.BuscarPorNomeExcetoId(siteId, usuarioDto.Nome, new Guid(id)) != null) throw new FormatoInvalido("Já existe um usuário com o nome informado. "); if (!string.IsNullOrEmpty(usuarioDto.Senha)) throw new FormatoInvalido("A senha do usuário não deve ser informada neste contexto."); if (!usuarioDto.Tipo.TipoUsuarioValido()) throw new FormatoInvalido("O tipo do usuário não é válido ou não foi informado."); if (usuarioDto.Tipo.TipoUsuarioObrigaGrupos() && (usuarioDto.Grupos == null || usuarioDto.Grupos.Length == 0)) throw new FormatoInvalido("Um consumidor deve ser associado a pelo menos um grupo."); if (!usuarioDto.Tipo.TipoUsuarioObrigaGrupos() && usuarioDto.Grupos != null && usuarioDto.Grupos.Length > 0) throw new FormatoInvalido("Este usuário não pode possuir grupos associados."); }
public UsuarioDto Criar(Guid siteId, UsuarioDto usuarioDto) { Validar(siteId, usuarioDto); var usuario = _fabricaUsuario.Criar(siteId, Guid.NewGuid(), usuarioDto, gerarSenha:true); _repositorioUsuarios.Inserir(usuario); return _fabricaUsuarioDto.Criar(usuario); }
public virtual Usuario Criar(Guid siteId, Guid id, UsuarioDto usuarioDto, bool gerarSenha) { string senha; if (!string.IsNullOrWhiteSpace(usuarioDto.Senha) && gerarSenha) senha = _geradorDeSenha.Gerar(usuarioDto.Senha); else senha = _repositorioUsuarios.BuscarPorId(siteId, id).Senha; return new Usuario(siteId, id, usuarioDto.Nome, senha, (TipoUsuario)usuarioDto.Tipo, usuarioDto.Grupos, usuarioDto.EstaAtivo); }
public ValidationResultDto Create(UsuarioDto entityDto) { var entity = MapperHelper.Map<UsuarioDto, Usuario>(entityDto); if (entity.RolUsuarioList == null) entity.RolUsuarioList = new List<RolUsuario>(); else entity.RolUsuarioList.Clear(); entity.RolUsuarioList.Add(MapperHelper.Map<UsuarioDto, RolUsuario>(entityDto)); var validateResult = _usuarioService.Add(entity); if (!validateResult.IsValid) throw new DefaultException(validateResult.ErrorMessage); return ValidationResultDto(validateResult); }
public async Task <IActionResult> Get(Guid id) { var usuario = await _context.Usuarios.Include(x => x.TipoIdentificacion).FirstOrDefaultAsync(x => x.Id == id); if (usuario == null) { return(NotFound()); } var result = new UsuarioDto { Id = usuario.Id, NroIdentificacion = usuario.NroIdentificacion, Nombres = usuario.Nombres, Apellidos = usuario.Apellidos, Email = usuario.Email, TipoIdentificacionId = usuario.TipoIdentificacion.Id, TipoIdentificacion = usuario.TipoIdentificacion.Nombre }; return(Ok(result)); }
public UsuarioDto recuperarUsuario(int id) { UsuarioDto oUsuarioCLS = new UsuarioDto(); using (EMERGENCIA_HRAContext db = new EMERGENCIA_HRAContext()) { oUsuarioCLS = (from usuario in db.Usuario join persa in db.PersonalSalud on usuario.IdPersonalSalud equals persa.IdPersonalSalud where usuario.IdUsuario == id select new UsuarioDto { idUsuario = usuario.IdUsuario, nombreCompleto = persa.Nombres + " " + persa.Apellidos, idPersonalSalud = usuario.IdPersonalSalud, IdTipoUsuario = usuario.IdTipoUsuario, nombreUsuario = usuario.NombreUsuario }).First(); } return(oUsuarioCLS); }
public async Task <UsuarioDto> GetUsuario(int id) { var result = new UsuarioDto(); try { result = await(from u in _context.Usuarios where u.UsuarioId == id select new UsuarioDto { UsuarioId = u.UsuarioId, Alias = u.Alias, NombreUsuario = u.NombreUsuario, Acceso = u.Acceso }).FirstOrDefaultAsync(); } catch (Exception ex) { _logger.LogError(ex.Message); } return(result); }
public string Authenticate(UsuarioDto usermodel) { if (string.IsNullOrEmpty(usermodel.Username) || string.IsNullOrEmpty(usermodel.Password)) { return(null); } var user = context.Usuarios.SingleOrDefault(x => x.Username == usermodel.Username); if (user == null) { return(null); } if (!VerifyPasswordHash(usermodel.Password, user.PasswordHash, user.PasswordSalt)) { return(null); } var token = generateJwtToken(user); return(token); }
private SecurityToken ObterSecurityToken(UsuarioDto usuario, JwtSecurityTokenHandler handler) { DateTime dateCreation = DateTime.Now; DateTime dateExpiration = dateCreation + TimeSpan.FromSeconds(_authSettings.Seconds); ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(usuario.Login, "Login"), new[] { new Claim(ClaimName.UserId, Convert.ToString(usuario.Id)), new Claim(ClaimName.UserName, usuario.Nome), new Claim(ClaimName.UserPerfil, Convert.ToString((int)usuario.Perfil)), } ); return(handler.CreateToken(new SecurityTokenDescriptor { Issuer = _authSettings.Issuer, Audience = _authSettings.Audience, SigningCredentials = _signingConfiguration.SigningCredentials, Subject = identity, NotBefore = dateCreation, Expires = dateExpiration })); }
public Response Autenticar(UsuarioDto usuarioDto) { var retorno = new Response(); var validation = this.validator.Validate(usuarioDto, ruleSet: "Autenticar, ValidarHash"); if (!validation.IsValid) { foreach (var validationFailure in validation.Errors) { retorno.AddMessage(true, validationFailure.ErrorMessage); } return(retorno); } var usuario = this.context.Usuarios.SingleOrDefault(x => x.Email == usuarioDto.Email); var map = mapper.Map <UsuarioDto>(usuario); retorno.AddMessage(false, $"Usuário {usuario.Email} autenticado com sucesso!"); retorno.Data = map; return(retorno); }
public IActionResult UpdateUsuario(UsuarioDto usuarioDto) { var isvalue = puestoController.GetById(usuarioDto.PuestoID); if (isvalue != null) { if (usuarioDto != null) { var isusuario = serviceUsuario.MapUsuarioUpdate(usuarioDto); _repo.usuario.Update(isusuario); _repo.Save(); return(Ok(isusuario)); } else { return(StatusCode(StatusCodes.Status304NotModified)); } } else { return(NotFound()); } }
public async Task <IActionResult> Put([FromBody] UsuarioDto usuario) { var usuarioCerto = new Usuario() { Id = usuario.Id, Nome = usuario.Nome, Email = usuario.Email, Cpf = usuario.Cpf, Celular = usuario.Celular, Senha = usuario.Senha }; db.Entry(usuarioCerto).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException ex) { throw (ex); } return(NoContent()); }
public static string GenerateToken(UsuarioDto usuario, long expireMinutes = 20) { var symmetricKey = Convert.FromBase64String(Secret); var tokenHandler = new JwtSecurityTokenHandler(); var now = DateTime.UtcNow; var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new[] { new Claim("user", Newtonsoft.Json.JsonConvert.SerializeObject(usuario, Formatting.Indented, new JsonSerializerSettings() { ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore })) }), 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 TokenDto BuildToken(UsuarioDto pUsuarioLogin) { var claims = new[] { new Claim(JwtRegisteredClaimNames.UniqueName, pUsuarioLogin.UsuarioId), new Claim("vDataUsuario", JsonConvert.SerializeObject(pUsuarioLogin)), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) }; var claimsIdentity = new ClaimsIdentity(claims); //TODO: appsetting for Demo JWT - protect correctly this settings var secretKey = _configuration["JWT:key"]; var audienceToken = _configuration["JWT:Audience_Token"]; var issuerToken = _configuration["JWT:Issuer_Token"]; var expireTime = _configuration["JWT:Expire_Minutes"]; var securityKey = new SymmetricSecurityKey(System.Text.Encoding.Default.GetBytes(secretKey)); var signingCredentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature); var expiration = DateTime.UtcNow.AddMinutes(Convert.ToInt32(expireTime)); // create token to the user var tokenHandler = new System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler(); var jwtSecurityToken = tokenHandler.CreateJwtSecurityToken( audience: audienceToken, issuer: issuerToken, subject: claimsIdentity, notBefore: DateTime.UtcNow, expires: expiration, signingCredentials: signingCredentials); return(new TokenDto() { Token = tokenHandler.WriteToken(jwtSecurityToken), Expiration = expiration }); }
public async Task <ActionResult <UsuarioDto> > Post([FromBody] UsuarioDto tipoDto) { try { var erroDto = new UsuarioDto(); var tipoOld = await _repository.GetUsuarioByName(tipoDto.user); if (tipoOld != null) { erroDto.error = $"Ya existe un usario con el user nombre de : {tipoDto.user}, en la base de datos."; return(BadRequest(erroDto)); } if (tipoOld == null) { var itemEntity = _mapper.Map <Sucursal>(tipoDto); _baseRepository.Add(itemEntity); if (await _baseRepository.SaveChangesAsync()) { return(Ok(_mapper.Map <UsuarioDto>(itemEntity))); } } else { if (await _baseRepository.SaveChangesAsync()) { return(Ok(_mapper.Map <UsuarioDto>(tipoDto))); } } } catch (Exception ex) { return(this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message)); } return(BadRequest()); }
public async Task <bool> GuardarUsuario(UsuarioDto usuarioDto) { //verificamos dto if (usuarioDto != null) { //creamos modelo var usuario = new Usuario { Nombres = usuarioDto.Nombres, Apellidos = usuarioDto.Apellidos, Email = usuarioDto.Email, Contraseña = usuarioDto.Contraseña, Rol = usuarioDto.Rol, NumeroIdentidad = usuarioDto.NumeroIdentidad, TipoIdentidad = usuarioDto.TipoIdentidad, FechaExpedicionIdentidad = usuarioDto.FechaExpedicionIdentidad, FechaDeNacimineto = usuarioDto.FechaDeNacimineto }; //guardamos modelo var UsuarioResult = await this.repository.Crear <Usuario>(usuario); //verificamos modelo if (usuario != null) { return(true); } else { return(false); } } else { return(false); } }
public ServiceResponse <bool> Update(UsuarioDto usuario) { var result = new ServiceResponse <bool>(); try { var entity = _service.Get(usuario.IdUsuario); if (entity != null) { entity.Modify(usuario.Nome, usuario.Dt_Nascimento, usuario.Cep, usuario.Password); if (entity.Valid) { result.Result = result.Object = _service.Update(entity); if (!result.Result) { ((Notifiable)_service).Notifications .ToList() .ForEach(x => result.Messages.Add(x.Message)); } } else { entity.Notifications.ToList().ForEach(x => result.Messages.Add(x.Message)); } } else { result.Messages.Add("Não foi possivel idenficar o Usuario"); } } catch (Exception ex) { result.Messages.Add("Problema para alterar o usuario : " + ex.Message); } return(result); }
public DataTable CambiarClave(UsuarioDto user) { using (SqlConnection conn = new SqlConnection(Util.ObtenerCadenaConexion("POS_DB"))) { try { string spName = @"[dbo].[prcSegUpdPwdUsr]"; SqlCommand cmd = new SqlCommand(spName, conn); SqlParameter usuario = new SqlParameter("@p_usuario", SqlDbType.VarChar); usuario.Value = user.usuario; SqlParameter clave = new SqlParameter("@p_clave", SqlDbType.VarChar); clave.Value = user.clave; cmd.Parameters.Add(usuario); cmd.Parameters.Add(clave); DataTable tblUsuario = new DataTable(); conn.Open(); cmd.CommandType = CommandType.StoredProcedure; SqlDataAdapter da = new SqlDataAdapter(cmd); da.ReturnProviderSpecificTypes = true; da.Fill(tblUsuario); da.Dispose(); conn.Close(); return(tblUsuario); } catch (Exception) { throw; } } }
private Usuario UsuarioMapper(UsuarioDto usuarioRequisicao) { //==> SUBSTITUIR PELO USO DE AUTOMAPER=== if (usuarioRequisicao != null) { var usuario = new Usuario { Nome = usuarioRequisicao.nome, Email = usuarioRequisicao.email, Senha = usuarioRequisicao.senha }; if (usuarioRequisicao.telefones != null) { usuario.Telefones = new List <Telefone>(); usuario.Telefones.AddRange(usuarioRequisicao.telefones); } return(usuario); } else { throw new NullUserException("Dados inválidos"); } }
public async Task <UsuarioDto> EditarAsync(UsuarioDto usuarioDto) { using var dbTransaction = _repository.BeginTransaction(_validator); if (!await _validator.ValidarAsync(usuarioDto)) { return(null); } Usuario usuario = usuarioDto.ToEntity(); usuario.Prepare(); Usuario usuarioDb = await _repository.ObterPorIdAsync(usuario.Id); usuario.Login = usuarioDb.Login; usuario.Password = usuarioDb.Password; await _repository.EditarAsync(usuario); UsuarioDto dto = usuarioDb.ToDto(); await _serviceCache.SalvarAsync(dto.Id, dto); return(dto); }
public void Cadastrar(UsuarioDto usuarioDto) { if (usuarioDto == null) { throw new ArgumentException(nameof(usuarioDto)); } if (Password.VerificarSenha(usuarioDto.Senha) < PasswordScore.Strong) { throw new ArgumentException("Senha muito fraca"); } var usuario = Mapper.Map <UsuarioDto, Usuario>(usuarioDto); usuario.Salt = Utils.GetSalt(); usuario.Senha = Utils.GenerateSHA512String(usuario.Senha + usuario.Salt); usuario.Perfis = new List <Perfil>() { contexo.Perfis.Where(x => x.Id == usuarioDto.IdPerfil).FirstOrDefault() }; contexo.Usuarios.Add(usuario); contexo.SaveChanges(); }
public IActionResult Editar([FromBody] ColaboradorUpdateRequest request) { if (!ModelState.IsValid) { return(Response <ColaboradorUpdateRequest>(request)); } if (!request.Id.Equals(_usuario.Id) && !_usuario.Perfis.Contains("Admin")) { return(BadRequest(new { Sucesso = false, Mensagem = "Não é permitido alterar dados de outro usuário" })); } UsuarioDto dto = new UsuarioDto() { Id = request.Id, Nome = request.Nome, UsuarioDados = new UsuarioDadosDto() { DataNascimento = request.DataNascimento, Logradouro = request.Endereco.Logradouro, Numero = request.Endereco.Numero, Complemento = request.Endereco.Complemento, Bairro = request.Endereco.Bairro, Cidade = request.Endereco.Cidade, UF = request.Endereco.Uf, CEP = request.Endereco.Cep, TelefoneFixo = request.TelefoneFixo, TelefoneCelular = request.TelefoneCelular, Email = request.Email } }; _appService.AlterarColaborador(dto, out int statusCode, out object dados); return(StatusCode(statusCode, dados)); }
public UsuarioDomain CriarUsuario(UsuarioDto usuarioDto) { try{ byte[] passwordHash, passwordSalt; //Chamar função para criar hash com a senha em string do DTO CriarPasswordHash(usuarioDto.Senha, out passwordHash, out passwordSalt); //Passa os valores para o usuario var usuario = new UsuarioDomain { Email = usuarioDto.Email, PasswordHash = passwordHash, PasswordSalt = passwordSalt, Rfid = usuarioDto.Rfid, Digital = usuarioDto.Digital, DataAlteracao = DateTime.Now }; return(usuario); } catch (Exception e) { throw new Exception(e.Message); } }
public async Task <UsuarioListViewModel> ListarTodos() { var result = new UsuarioListViewModel(); try { var _items = await _context.Usuarios .Include(x => x.Eps) .OrderBy(x => x.RegistradoAt) .ToListAsync(); var viewModelDto = _items .Select(UsuarioDto.ProyectarDto()) .ToList(); result.Items = viewModelDto; result.HabilitarCrear = true; } catch (Exception e) { } return(result); }
public void Post(UsuarioDto usuario) { if (usuario == null) { _notification.Add("Usuário não enviado para cadastro"); return; } if (!usuario.IsValid(_notification)) { return; } if (_loginRepository.Get(usuario.Email) != null) { _notification.Add("E-mail de usuário já cadastrado"); return; } _loginRepository.OpenTransaction(); _loginRepository.Post(usuario); EnviaEmailConfirmacaoCadastro(usuario); _loginRepository.CommitTransaction(); }
public async Task <IActionResult> Create([FromBody] UsuarioDto usuario) { var validar = await _context.Usuarios.FirstOrDefaultAsync(x => x.Email == usuario.Email); if (validar != null) { return(BadRequest("El email ya existe")); } var tipoIdentificacion = await _context.TiposIdentificacion.FirstOrDefaultAsync(x => x.Id == usuario.TipoIdentificacionId); byte[] passwordHash, passwordSalt; Utilidades.Utils.CreatePasswordHash(usuario.Password, out passwordHash, out passwordSalt); var nuevoUsuario = new Usuario { Id = Guid.NewGuid(), NroIdentificacion = usuario.NroIdentificacion, Nombres = usuario.Nombres, Apellidos = usuario.Apellidos, Email = usuario.Email, TipoIdentificacion = tipoIdentificacion, PasswordHash = passwordHash, PasswordSalt = passwordSalt, FechaCreacion = DateTime.Now, FechaModificacion = DateTime.Now }; _context.Add(nuevoUsuario); await _context.SaveChangesAsync(); return(Ok()); }
public void Update(UsuarioDto user) { try { using (var connection = new SqlConnection(connectionString)) { connection.Open(); var command = "UPDATE Usuario SET Name = @Name, CPF = @NewCpf, IdCity = @IdCity WHERE cpf=@Cpf"; var sqlCommand = new SqlCommand(command, connection); sqlCommand.Parameters.AddWithValue("@NewCpf", user.NewCpf); sqlCommand.Parameters.AddWithValue("@Name", user.Name); sqlCommand.Parameters.AddWithValue("@Cpf", user.Cpf); sqlCommand.Parameters.AddWithValue("@IdCity", user.IdCity); sqlCommand.ExecuteScalar(); } } catch (Exception ex) { throw new Exception(ex.Message); } }
public IHttpActionResult VerificaLogin(UsuarioDto usuario) { try { usuario = _usuarioService.VerificaLogin(usuario); if (_notifications.Notificacoes.Count > 0) { string erros = ""; foreach (var erro in _notifications.Notificacoes) { erros = erros + " " + erro; } return(BadRequest(erros)); } else { return(Ok(usuario)); } } catch (Exception e) { return(BadRequest($"Ops! algo deu errado! Erro: {e.Message}")); } }
public IActionResult Post([FromBody] UsuarioDto usuarioRequest) { var usuarioJaCadastrado = contexto.Usuarios.FirstOrDefault(u => u.Email == usuarioRequest.Email); if (usuarioJaCadastrado != null) { return(BadRequest("Esse email já possui um cadastro.")); } var usuario = MapearDtoParaDominio(usuarioRequest); var mensagens = usuarioService.Validar(usuario); if (mensagens.Count > 0) { return(BadRequest(mensagens)); } usuarioRepository.SalvarUsuario(usuario); contexto.SaveChanges(); var usuarioResponse = MapearDominioParaResponse(usuario); return(CreatedAtRoute("GetUsuario", new { id = usuario.Id }, usuarioResponse)); }
public Usuario AlterarUsuario(UsuarioDto usuarioDto) { if (usuarioDto.UsuarioId == null) { throw new Exception("Id não usuário não informado"); } var usuario = MapperDtoToModel(usuarioDto); if (!_usuarioRepository.GetAll().Any(x => x.UsuarioId == usuarioDto.UsuarioId.Value)) { _usuarioRepository.Add(usuario); } else { usuario.UsuarioId = usuarioDto.UsuarioId.Value; _usuarioRepository.Update(usuario); } return(usuario); }
public IActionResult Post([FromBody] UsuarioDto usuarioRequest) { var usuario = MapearDtoParaDominio(usuarioRequest); var usuarioCadastrado = usuarioRepository.SalvarUsuario(usuario); var mensagem = usuarioService.Validar(usuarioCadastrado); if (mensagem.Any()) { return(BadRequest(mensagem)); } var mensagemUsuariosIguais = usuarioService.ValidarUsuariosIguais(usuarioCadastrado.Email, usuarioRepository); if (mensagemUsuariosIguais.Any()) { return(BadRequest(mensagemUsuariosIguais)); } contexto.SaveChanges(); var usuarioSemSenha = MapearDtoParaDominio(usuario); return(CreatedAtRoute("GetUsuario", new { id = usuarioSemSenha.Id }, usuarioSemSenha)); }
public IHttpActionResult Post([FromBody] UsuarioDto usuario) { try { NegocioUsuario negocioUsuario = new NegocioUsuario(); Usuario usuarioCreado = negocioUsuario.CrearUsuario(usuario); List <UsuarioActivoDto> usuarioResultante = new List <UsuarioActivoDto>(); usuarioResultante.Add(new UsuarioActivoDto { codUsuario = Convert.ToString(usuarioCreado.codUsuario), codigoActivacion = usuarioCreado.codigoActivacion, activo = usuarioCreado.activo }); return(Content(HttpStatusCode.OK, usuarioResultante)); } catch (Exception ex) { log.EscribirLogError("Error al crear Usuario", ex); return(Content(HttpStatusCode.InternalServerError, Mensajes.DescFallo)); } }
public void Modificar(Guid siteId, string id, UsuarioDto usuarioDto) { Validar(siteId, id, usuarioDto); _repositorioUsuarios.Editar(_fabricaUsuario.Criar(siteId, id.ParaGuid(), usuarioDto, gerarSenha:false)); }
public UsuarioDto GetUsuarioDtoCrear() { var estadosDisponibles = ObtenerEstados(); var usuarioDto = new UsuarioDto { Estados = estadosDisponibles, RolDtos = _rolAppService.GetActivosOrdenadosPorNombre(), Accion = MasterConstantes.AccionCrear, Estado = (int) TipoEstado.Activo, }; return usuarioDto; }
private Usuario MapearDtoParaDominio(UsuarioDto usuarioRequest) { return(new Usuario(usuarioRequest.Email, usuarioRequest.Senha, usuarioRequest.PrimeiroNome, usuarioRequest.UltimoNome, usuarioRequest.Cpf, usuarioRequest.DataNascimento)); }
public async Task <Usuario> Update(Guid id, UsuarioDto usuario) { var usuarioAtualizado = new Usuario(usuario.Nome, usuario.Email, usuario.Senha, usuario.Telefones.Select(t => new Telefone(t.Ddd, t.Numero, usuario.Id)).ToList()); return(await _usuarioRepository.Update(id, usuarioAtualizado)); }
public IEnumerable<UsuarioDto> GetUsuarioReport(UsuarioDto model) { const string storeName = "GetUsuarioReport"; var query = string.Format("{0} @RolId = {1}, @UserName = '******', @FechaDesde = '{3}', @FechaHasta = '{4}'", storeName, model.RolId, model.UserName, "10-06-2015",""); var entityList = _reporteService.EjecutarQuerySql(query); return entityList; }
public virtual Usuario Criar(Guid siteId, UsuarioDto usuarioDto, bool gerarSenha) { return Criar(siteId, usuarioDto.Id, usuarioDto, gerarSenha); }
public ValidationResultDto Remove(UsuarioDto entityDto) { var entity = MapperHelper.Map<UsuarioDto, Usuario>(entityDto); var validateResult = _usuarioService.Delete(entity); if (!validateResult.IsValid) throw new DefaultException(validateResult.ErrorMessage); return ValidationResultDto(validateResult); }
public ValidationResultDto Update(UsuarioDto entityDto) { var usuarioDomain = _usuarioService.Get(entityDto.Id); usuarioDomain = MapperHelper.Map(entityDto, usuarioDomain); usuarioDomain.RolUsuarioList.Clear(); usuarioDomain.RolUsuarioList.Add(MapperHelper.Map<UsuarioDto, RolUsuario>(entityDto)); var validateResult = _usuarioService.Update(usuarioDomain); if (!validateResult.IsValid) throw new DefaultException(validateResult.ErrorMessage); return ValidationResultDto(validateResult); }
public ValidationResultDto UpdatePassword(UsuarioDto entityDto) { var usuarioDomain = _usuarioService.Get(entityDto.Id); usuarioDomain.Password = Encriptador.Encriptar(entityDto.Password); var validateResult = _usuarioService.Update(usuarioDomain); if (!validateResult.IsValid) throw new DefaultException(validateResult.ErrorMessage); return ValidationResultDto(validateResult); }
private void entrar_click(object sender, RoutedEventArgs e) { if (!string.IsNullOrEmpty(txtlogin.Text) && !string.IsNullOrEmpty(txtsenha.Password)) { using (var proxy = new Servico.ClientesClient()) { _usuariologado = proxy.Logarusuario(txtlogin.Text, txtsenha.Password); if (_usuariologado.usua_codigo != null && _usuariologado.usua_codigo > 0) { if (_usuariologado.usua_logar) { Atualizarclientes(); Grupo = new GrupclienteDto(); Logado = Visibility.Visible; Logar = Visibility.Collapsed; TabControl1.SelectedIndex = 1; txtusuario.Text = _usuariologado.usua_nome; } else { MessageBox.Show("Usuário não tem premissão"); } } } } else MessageBox.Show("Login e senha não pode ficar em branco!"); }