public ActionResult Create(UsuarioViewModel usuarioViewModel)
{
try
{
if (usuarioViewModel != null && string.IsNullOrEmpty(usuarioViewModel.Login) == false)
{
if (_iUsuarioAppService.UsuarioExistenteNoSistema(usuarioViewModel.Login) != null)
{
ModelState.AddModelError("", "O nome de usuário informado já existe no sistema.");
}
}
if (ModelState.IsValid)
{
var item = Mapper.Map <UsuarioViewModel, Usuario>(usuarioViewModel);
_iUsuarioAppService.Add(item);
return(RedirectToAction("Index"));
}
return(View(usuarioViewModel));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Create(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var usuarioDomain = Mapper.Map <UsuarioViewModel, Usuario>(usuario);
usuarioDomain.Senha = Criptografia.Codificador(usuarioDomain.Senha);
try
{
_usuarioApp.Add(usuarioDomain);
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
return(RedirectToAction("Index"));
}
return(View(usuario));
}
public ActionResult <ClienteDTO> Add([FromBody] RegistrarClienteViewModel registrarCliente)
{
try
{
var generarIdUsuario = _usuarioAppService.GenerarCodigo();
UsuarioDTO usuarioDTO = new UsuarioDTO
{
IdUsuario = generarIdUsuario,
NombreUsuario = registrarCliente.nombreUsuario,
Contraseña = registrarCliente.contraseña
};
_usuarioAppService.Add(usuarioDTO);
ClienteDTO cliente = new ClienteDTO
{
Nombre = registrarCliente.Nombre,
Direccion = registrarCliente.Direccion,
Telefono = registrarCliente.Telefono,
NombreContacto = registrarCliente.NombreContacto,
Distrito = registrarCliente.Distrito,
Estado = "A",
IdUsuario = generarIdUsuario
};
cliente.IdCliente = _clienteAppService.GenerarCodigo();
_clienteAppService.Add(cliente);
_clienteAppService.Save();
return(CreatedAtAction(nameof(Add), new { id = cliente.IdCliente }, cliente));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <bool> Create(UsuarioViewModel usuarioViewModel)
{
if (!ModelState.IsValid)
{
return(false);
}
await _usuarioAppService.Add(usuarioViewModel);
return(true);
}
public IActionResult Post([FromBody] UsuarioViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var operation = _usuarioAppService.Add(vm);
return(Ok(operation));
}
public HttpResponseMessage Register(Usuario usuario)
{
try
{
_usuarioAppService.Add(usuario);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public IHttpActionResult Cadastrar(UsuarioViewModel usuario)
{
try
{
_usuarioAppService.Add(usuario);
return(Ok());
}
catch (Exception e)
{
return(InternalServerError());
}
}
public ActionResult Create(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var usuarioDomain = Mapper.Map <UsuarioViewModel, Usuario>(usuario);
_usuarioApp.Add(usuarioDomain);
return(RedirectToAction("Index"));
}
return(View(usuario));
}
public async Task Add(string nome, string nascimento, byte sexo, string email, string senha)
{
var usuario = await _usuarioAppService.Add(new Usuario
{
Nome = nome,
Nascimento = Convert.ToDateTime(nascimento),
Email = email,
Senha = senha,
SexoId = sexo,
});
Assert.True(usuario.UsuarioId > 0);
}
public ActionResult Create(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var usuarioDomain = Mapper.Map <UsuarioViewModel, Usuario>(usuario);
UsuarioApp.Add(usuarioDomain);
Success(string.Format("<b>{0}</b> inserido com sucesso.", usuarioDomain.Nome));
return(RedirectToAction("Index"));
}
Danger("Usuário não pode ser inserido.");
return(View(usuario));
}
public async Task <IActionResult> Add([FromBody] Usuario usuario)
{
try
{
usuario = await _usuarioAppService.Add(usuario);
return(Ok(usuario));
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException?.Message ?? ex.Message));
}
}
public async Task <IActionResult> Add(Usuario usuario)
{
try
{
usuario = await _usuarioAppService.Add(usuario);
return(Ok(usuario));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult Create(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var usuaurioDomain = Mapper.Map <UsuarioViewModel, Usuario>(usuario);
_usuarioApp.Add(usuaurioDomain);
return(RedirectToAction("Index"));
}
ViewBag.PessoaFisicaId = new SelectList(_pessoaFisicaApp.GetAll(), "PessoaFisicaId", "Nome", usuario.PessoaFisicaId);
return(View(usuario));
}
public ActionResult <UsuarioDTO> Add([FromBody] UsuarioDTO usuario)
{
try
{
usuario.IdUsuario = _usuarioAppService.GenerarCodigo();
_usuarioAppService.Add(usuario);
_usuarioAppService.Save();
return(CreatedAtAction(nameof(Add), new { id = usuario.NombreUsuario }, usuario));
}
catch (Exception)
{
return(BadRequest());
}
}
public ActionResult Index()
{
int count = _usuarioService.Count();
UsuarioViewModel usuarioViewModel = new UsuarioViewModel();
usuarioViewModel.CodigoUsuario = 0;
usuarioViewModel.NomeUsuario = "teste";
_usuarioService.Add(usuarioViewModel);
count = _usuarioService.Count();
return(View());
}
public JsonResult Salvar(Usuario usuario)
{
JsonResult retorno = null;
try
{
usuario.SenhaUsuario = CriptografiaSHAI.Criptografar(usuario.SenhaUsuario);
if (!_usuarioAppService.ValidaSeExisteMatricula(usuario.LoginUsuario))
{
if (new Regex("^[\\w ]+$").IsMatch(usuario.NomeUsuario))
{
_usuarioAppService.Add(usuario);
retorno = Json(true, JsonRequestBehavior.AllowGet);
}
else
{
retorno = Json(new { Error = "Nome apenas permitido letras!" }, JsonRequestBehavior.AllowGet);
}
}
else
{
retorno = Json(new { Erro = "Número de matricula já foi cadastrada!" }, JsonRequestBehavior.AllowGet);
}
}
catch (ArgumentException argex)
{
//Logar(argex);
var data = new
{
Erro = argex.Message
};
retorno = Json(data, JsonRequestBehavior.AllowGet);
}
catch (Exception ex)
{
//Logar(ex);
var data = new
{
Erro = ex.Message
};
retorno = Json(data, JsonRequestBehavior.AllowGet);
}
return(retorno);
}
async private void AdicionarUsuario()
{
ValidarCriacaoUsuario();
var usuario = new Usuario
{
Id = 0,
Login = txbLogin.Text,
Password = txbPassword1.Text,
Email = txbEmail.Text,
Tipo = int.Parse(cbxTiposDeUsuario.Text[0].ToString())
};
await _usuarioApp.Add(usuario);
}
public async Task <HttpResponseMessage> Post([FromBody] Usuario usuario)
{
try
{
await _usuarioAppService.Add(usuario);
NotificationHub.SendMessageNew(string.Format("Cadastro de Usuario efetuado com Sucesso {0}-{1}", usuario.NomeUsuario, usuario.UsuarioId));
return(await Task.Factory.StartNew(() => new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK
}));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Adicionar([FromBody] Usuario usuario)
{
try
{
if (usuario == null)
{
return(NoContent());
}
_usuarioAppService.Add(usuario);
return(Ok());
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Create(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var usuarioDomain = _mapper.Map <UsuarioViewModel, Usuario>(usuario);
_usuarioApp.Add(usuarioDomain);
if (usuarioDomain.UsuarioId == 0)
{
Alert("O Login já está em uso!", Enums.Enum.NotificationType.warning);
return(View(usuario));
}
return(RedirectToAction("Index"));
}
return(View(usuario));
}
public ActionResult Post(UsuarioVM usuarioVM)
{
try
{
if (usuarioVM == null)
{
return(NotFound());
}
var User = _mapUsuario.Map <UsuarioVM, Usuario>(usuarioVM);
_usuarioService.Add(User);
return(RedirectToAction("Get"));
}
catch (Exception ex)
{
throw;
}
}
public async Task <IHttpActionResult> Create(UsuarioViewModel usuario)
{
if (ModelState.IsValid)
{
var _usuarioDomain = await Task.FromResult(Mapper.Map <UsuarioViewModel, Usuario>(usuario));
if (_usuarioDomain == null)
{
return(NotFound());
}
else
{
_usuarioDomain.Senha = Shared.Senha.Encriptar(_usuarioDomain.Senha);
_usuarioApp.Add(_usuarioDomain);
return(Ok());
}
}
else
{
return(BadRequest());
}
}
public ActionResult Criar(UsuarioViewmodel model)
{
#region Preparacao
//Gera as funções de acordo com as roles
List <string> TiposUsuarios = new List <string>();
if (User.IsInRole("Superadmin"))
{
TiposUsuarios.Add("Superadmin");
TiposUsuarios.Add("Administrador");
}
TiposUsuarios.Add("Secretaria");
TiposUsuarios.Add("Financeiro");
TiposUsuarios.Add("Pastor");
TiposUsuarios.Add("Conselho");
TiposUsuarios.Add("Lider");
TiposUsuarios.Add("Supervisor");
ViewBag.TiposUsuarios = new SelectList(TiposUsuarios);
#endregion
if ((model.Tipo == TipoUsuario.Superadmin || model.Tipo == TipoUsuario.Administrador) && !User.IsInRole("Superadmin"))
{
ModelState.AddModelError(string.Empty,
"Erro de Acesso negado e validação do formulário");
return(View(model));
}
//verifica se o e-mail já existe.
var existente = UserManager.FindByEmail(model.Email);
if (existente != null)
{
ModelState.AddModelError("Email", "E-mail já cadastrado no sistema com outro usuário " + existente.Nome);
return(View(model));
}
var appUser = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.Telefone,
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
var usrEntidade = new Usuario
{
Nome = model.Nome,
Telefone = model.Telefone,
Telefone2 = model.Telefone2,
Email = model.Email,
Ativo = true
};
try //Adiciona o usuário (Login)
{
UserManager.Create(appUser, model.Senha);
UserManager.AddToRoles(appUser.Id, model.Funcao.ToString());
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty,
"Erro ao criar o usuário (identity). Favor informar o suporte técnico. O Erro foi: " + ex.Message);
return(View(model));
}
try //Adiciona o usuário (aplicação)
{
usrEntidade.id_usuario = appUser.Id;
_UserAppSvc.Add(usrEntidade);
return(RedirectToAction("index"));
}
catch (Exception ex)
{
//deleta o usuário de identity recém criado
UserManager.Delete(appUser);
ModelState.AddModelError(string.Empty,
"Erro ao criar o usuário (aplicação). Favor informar o suporte técnico. O Erro foi: " + ex.Message);
return(View(model));
}
}
public ActionResult <UsuarioModel> Post([FromBody] UsuarioModel model)
{
return(_usuarioAppService.Add(model));
}
public void Post([FromBody] UsuarioViewModel usuarioViewModel)
{
_usuarioAppService.Add(usuarioViewModel);
}