public async Task Add(Usuario usuario)
{
if (!ExecutarValidacao(new UsuarioValidation(), usuario))
{
return;
}
await _usuarioRepository.Add(usuario);
}
public Task <Result> Handle(InserirUsuarioCmd request, CancellationToken cancellationToken)
{
var result = new Result();
if (request.IsValid())
{
var qUsuario = usuarioRepository.Get(c => c.Email == request.Email);
if (qUsuario == null)
{
Usuario.Domain.Entities.Usuario usuario = new Usuario.Domain.Entities.Usuario();
usuario.SetUsuario(Guid.NewGuid(), request.Nome, request.Email, request.Cpf,
request.DataNascimento, request.Cidade, request.Estado);
usuarioRepository.Add(usuario);
result.message = "Usuário criado com sucesso";
}
else
{
var message = "O Usuario não existe";
result.AddError(message);
}
}
else
{
result.AddErrors(GetErrors(request).ToList());
}
return(Task.FromResult <Result>(result));
}
public async Task <IActionResult> AddEdit(string id, UsuarioAddEditVM model)
{
ModelState.Remove("IdUsuarioRegistro");
ModelState.Remove("DataHoraRegistro");
ModelState.Remove("ConfirmaSenha");
if (!ModelState.IsValid)
{
return(View(model));
}
var data = model.ToData();
if (String.IsNullOrEmpty(id))
{
data.HashSenha = model.Senha.Encrypt();
data.IdUsuarioRegistro = Convert.ToDecimal(HttpContextHelper.GetAuthUserId(HttpContext));
data.DhRegistro = Convert.ToDecimal(DateTime.Now.ToString("yyyyMMddHHmmss"));
data.StUsuario = EnumHelper.SituacaoUsuario.UA9.ToString();
_usuarioRepo.Add(data);
}
else
{
_usuarioRepo.Update(data);
}
await _uow.CommitAsync();
return(RedirectToAction("Index"));
}
public async Task <bool> Cadastrar(UsuarioViewModel usuarioVM)
{
if (await ValidarInsercao(usuarioVM))
{
var usuario = Mapper.Map <Usuario>(usuarioVM);
var responsavel = await _responsavelRepository.GetReadOnly(x => x.Telefone == usuario.Telefone);
var professor = await _professorRepository.GetReadOnly(x => x.Telefone == usuario.Telefone);
if (professor.Any())
{
usuario.Professor = true;
}
else if (responsavel.Any())
{
usuario.Responsavel = true;
}
if (usuario.Professor == true || usuario.Responsavel == true)
{
await BeginTransaction();
await Task.Run(() => _usuarioRepository.Add(usuario));
await Commit();
return(true);
}
return(false);
}
return(false);
}
public void Handle(RegistrarUsuarioCommand message)
{
var usuario = new Usuario(message.Id, message.Cpf, message.Nome, message.Email);
if (usuario.Invalid)
{
NotificarValidacoesErro(usuario.Notifications);
return;
}
var usuarioExistente = _usuarioRepository.Find(x => x.Cpf == message.Cpf);
if (usuarioExistente.Any())
{
_bus.RaiseEvent(new DomainNotification(message.MessageType, "CPF já utilizado"));
return;
}
_usuarioRepository.Add(usuario);
if (Commit())
{
_bus.RaiseEvent(new UsuarioRegistradoEvent(usuario.Id, usuario.Cpf));
}
}
public IActionResult Create([Bind("sNome,sSenha,sEmail,bAtivo,sTelefone,PaginaSelecionada")] Usuario _usuario, IFormFile sImagem)
{
if (ModelState.IsValid)
{
try
{
if (sImagem != null)
{
_usuario.sImagem = DateTime.Now.ToString("yyyyMMddHHmmss") + ".jpg";
Diverso.SaveImage(sImagem, "USUARIO", _usuario.sImagem);
}
_usuario.iCodUsuarioMovimentacao = HttpContext.Session.GetComplexData <Usuario>("UserData").ID;
_usuarioRepository.Add(_usuario);
_flashMessage.Confirmation("Operação realizada com sucesso!");
}
catch (Exception)
{
_flashMessage.Danger("Erro ao realizar a operação!");
throw;
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Paginas = _usuarioPaginaRepository.Perfil();
return(View(_usuario));
}
public Usuario CreateUserAccount(RequestPost requestPost)
{
Usuario user = null;
ResultPost StateDireccion = PostDireccionApi(requestPost.Direccion).First();
if (StateDireccion.Id != null || StateDireccion.Id != "null")
{
user = Conversion.ConverUser(requestPost);
user.IdDireccion = int.Parse(StateDireccion.Id);
_repository.Add(user);
if (user != null)
{
CuentaDTO account = Conversion.ConverAccount(requestPost, user.IdUsuario);
ResultPost StateCuenta = PostCuentaApi(account).First();
if (StateCuenta.Id != null || StateCuenta.Id != "null")
{
user.IdCuenta = int.Parse(StateCuenta.Id);
_repository.Edit(user);
}
else
{
_repository.Delete(user);
user = null;
}
}
}
return(user);
}
public Task <bool> Handle(UsuarioNovoCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var usuario = new Usuario(Guid.NewGuid(), message.Nome, message.Salario, message.Email);
if (_usuarioRepository.BuscarEmail(usuario.Email) != null)
{
Bus.EnviarEvent(new DomainNotification(message.MessageType, "E-mail já existe"));
return(Task.FromResult(false));
}
_usuarioRepository.Add(usuario);
if (Commit())
{
var msg = new UsuarioNovoEvent(usuario.Id, usuario.Nome, usuario.Email);
//Log
Bus.EnviarEvent(msg);
//Banco de Leitura
//_usuarioRepository.InserirUsuarioRead(usuario);
//Enviar Para área de segurança
_eventBus.Publish(msg, exchange: "Empresa.RHEvent", routingKey: "empresa.rhevent.novousuario");
}
return(Task.FromResult(true));
}
public async Task <IActionResult> Create([FromBody] UsuarioDto usuario)
{
var result = await ususarioRepository.Find(x => x.Email == usuario.Email);
if (result != null)
{
return(BadRequest("El email ya existe"));
}
usuario.Password = usuario.NroIdentificacion.ToString();
byte[] passwordHash, passwordSalt;
SeguridadPassword.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,
Telefono = usuario.Telefono,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Activo = usuario.Activo,
FechaCreacion = DateTime.Now,
FechaModificacion = DateTime.Now
};
await ususarioRepository.Add(nuevoUsuario);
return(Ok());
}
public void Add(CadastroPessoaViewModel obj)
{
try
{
Pessoas p = _mapper.Map <Pessoas>(obj);
int id = _pessoaRepository.CriarPessoa(p);
try
{
Usuarios user = new Usuarios
{
FkTipoUsuario = 3,
FkPessoa = id,
Email = obj.Email,
Senha = obj.Senha
};
_usuarioRepository.Add(user);
}
catch (SqlException ex)
{
if (ex.Number == 2601)
{
_pessoaRepository.Remove(id);
}
}
}
catch (Exception e)
{
throw new Exception("Error: " + e);
};
}
public Task <bool> Handle(RegistrarNovoUsuarioCommand message, CancellationToken cancellationToken)
{
#region Basic Validations
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
#endregion
var password = Encription.Encrypt(message.Password, Encription.Key256, 256);
var usuario = new Usuario(
message.Id, message.Nome, message.Idade, message.Documento, message.TipoDocumento,
message.Genero, message.Pai, message.Mae, message.Telefone, message.Celular, message.Email, password, message.UsuarioId
);
_usuarioRepository.Add(usuario);
if (Commit())
{
_bus.RaiseEvent(new RegistrarNovoUsuarioEvent(usuario.Id, message.AppsId));
}
return(Task.FromResult(true));
}
public OperationResultVo <Guid> Add(UsuarioViewModel viewModel)
{
OperationResultVo <Guid> result;
try
{
Usuario model;
// TODO validate before
Usuario existing = _repository.GetById(viewModel.Id);
if (viewModel.Id != Guid.Empty && existing != null)
{
return(new OperationResultVo <Guid>("Erro ao adicionar Usuário"));
}
model = _mapper.Map <Usuario>(viewModel);
_repository.Add(model);
viewModel.Id = model.Id;
_unitOfWork.Commit();
result = new OperationResultVo <Guid>(model.Id);
}
catch (Exception ex)
{
result = new OperationResultVo <Guid>(ex.Message);
}
return(result);
}
public ActionResult <RetornoView <Usuario> > Create([FromBody] Usuario usuario)
{
if (usuario == null)
{
return(BadRequest());
}
_usuarioRepository.Add(usuario);
if (usuario.Id > 0)
{
var resultado = new RetornoView <Usuario>()
{
data = usuario, sucesso = true
};
return(CreatedAtRoute("GetUsuario", new { id = usuario.Id }, resultado));
}
else
{
var resultado = new RetornoView <Usuario>()
{
sucesso = false
};
return(BadRequest(resultado));
}
}
public int Create(UsuarioViewModel vm)
{
var obj = Mapper.Map <UsuarioViewModel, Usuario>(vm);
BeginTransaction();
_rep.Add(obj);
return(Commit());
}
public IActionResult Create([Bind] Usuario usuario)
{
if (ModelState.IsValid)
{
_contextDAO.Add(usuario);
return(RedirectToAction("Index"));
}
return(View(usuario));
}
public Int32 CreateUser(USUARIO usuario, LOG log)
{
using (DbContextTransaction transaction = Db.Database.BeginTransaction(IsolationLevel.ReadCommitted))
{
try
{
_logRepository.Add(log);
_usuarioRepository.Add(usuario);
transaction.Commit();
return(0);
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
}
public Usuario CriarUsuario(string nome, string email, string login, string senha)
{
var usuario = Usuario.CriarNovoUsuario(nome, email, login, senha);
_repositoryRepository.Add(usuario);
_context.Commit();
return(usuario);
}
public IActionResult Crate([FromBody] Usuario usuario)
{
if (usuario == null)
{
return(BadRequest());
}
_usuarioRepositorio.Add(usuario);
return(CreatedAtRoute("GetUsuario", new { id = usuario.UsuarioId }, usuario));
}
/// <summary>
/// Criar usuário padrão para servidor.
/// Será utilizado para criar dados do Identity
/// </summary>
private void CriarUsuarioServidor()
{
var usuario = MockIdentity.GetUsuario();
if (!_repositoryUsuario.ExisteUsuario(usuario.NomeUsuario))
{
_repositoryUsuario.Add(usuario);
}
}
public IActionResult Cadastro([FromForm] Pessoa usuario)
{
if (!ModelState.IsValid)
{
ViewBag.Sucesso = "Digite todos os valores";
return(View());
}
if (_usuarioRepository.JaExiste(usuario))
{
ViewBag.Sucesso = "O usuario já existe!";
return(View());
}
_usuarioRepository.Add(usuario);
ViewBag.Sucesso = "Cadastrado com sucesso!";
return(View());
}
public async Task <Unit> Handle(AddUsuarioCommand request, CancellationToken cancellationToken)
{
var pessoa = new Usuario(Guid.NewGuid(), request.Email, request.Senha, request.PessoaId, request.Role);
_repository.Add(pessoa);
await _repository.UnitOfWork.Commit();
return(Unit.Value);
}
public void Add(Usuario item)
{
item.id = Guid.NewGuid();
item.senha = hash.Criptografar(item.senha);
item.token = hash.Criptografar(Guid.NewGuid().ToString());
item.data_criacao = item.ultimo_login = DateTime.Now;
item.data_atualizacao = null;
Usuarios.Add(item);
}
public void AddUsuario(Usuario usuario)
{
if (usuario.DataCadastro == null)
{
throw new Exception(AlertUsuarioExiste(usuario, 0));
}
if (IsCpf(usuario.Cpf))
{
throw new Exception(AlertUsuarioExiste(usuario, 3));
}
if (IsUsuarioExiste(usuario))
{
throw new Exception(AlertUsuarioExiste(usuario, 1));
}
//if (usuario.Usuario != null && usuario.UsuarioId != null)
// throw new Exception("Algo errado não está certo");
_usuarioRepository.Add(usuario);
}
// Usuarios
// Crear un nuevo usuario
public void RegistrarUsuario(string apellido, string nombre)
{
Usuario usuario = new Usuario();
usuario.Apellido = apellido;
usuario.Nombre = nombre;
_usuarioRepository.Add(usuario);
_unitOfWork.Commit();
}
public async Task <IActionResult> Add([FromBody] Usuario model)
{
await _repository.Add(model);
if (model.Notifications.Count > 0)
{
return(BadRequest(new { erro = model.Notifications }));
}
return(CreatedAtAction(nameof(GetUsuarioById), new { id = model.Id }, model));
}
public IActionResult PostUsuario([FromBody] Usuario usuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_usuarioRepository.Add(usuario);
return(CreatedAtAction("GetUsuario", new { id = usuario.Id }, usuario));
}
public async Task Add(UsuarioAddDTO usuarioAddDTO)
{
Usuario usuario = new Usuario();
usuario.Nome = usuarioAddDTO.Nome;
usuario.Login = usuarioAddDTO.Login;
usuario.Senha = criptografia.RetornarMD5(usuarioAddDTO.Senha);
usuario.Perfil = usuarioAddDTO.Perfil;
await repository.Add(usuario);
}
public HttpResponseMessage Post(Usuario usuario)
{
try
{
return(Request.CreateResponse(HttpStatusCode.OK, _usuarios.Add(usuario)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public IActionResult RequestSignup([FromBody] Usuario usuario)
{
if (usuario == null)
{
return(BadRequest());
}
usuario.Senha = _usuarioRepositorio.HashSenha(usuario.Senha);
_usuarioRepositorio.Add(usuario);
return(new ObjectResult(usuario));
}
public void Save(Usuario usuario)
{
try
{
dbUsuario.Add(usuario);
}
catch (Exception ex)
{
throw new Exception($"Erro ao salvar usuário: {ex.Message}.");
}
}
