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!");
}
