public ActionResult CadastroConviteEvento(string id, string token, string email)
        {
            var tokenConvite   = Db.TokenEnvios.ToList().SingleOrDefault(t => t.Token == token);
            var eventoConvite  = Db.Eventos.ToList().SingleOrDefault(e => e.Id == Guid.Parse(id));
            var usuarioConvite = Db.Users.ToList().SingleOrDefault(u => u.UserName == email);

            if (DateTime.Now > tokenConvite.ExpiraEm || tokenConvite == null || eventoConvite == null)
            {
                return(HttpNotFound());
            }

            if (usuarioConvite != null)
            {
                var eventoUsuario = new Evento_UsuarioViewModel()
                {
                    Id_Evento  = Guid.Parse(id),
                    Id_Usuario = usuarioConvite.Id
                };

                _evento_UsuarioAppService.Criar(eventoUsuario);

                return(View("Index", "Home"));
            }

            return(View());
        }
        public IHttpActionResult PostEvento_UsuarioViewModel(Evento_UsuarioViewModel evento_UsuarioViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            _evento_UsuarioAppService.Criar(evento_UsuarioViewModel);

            return(CreatedAtRoute("DefaultApi", new { id = evento_UsuarioViewModel.Id }, evento_UsuarioViewModel));
        }
        public IHttpActionResult GetEvento_UsuarioViewModel(Guid id)
        {
            Evento_UsuarioViewModel evento_UsuarioViewModel = _evento_UsuarioAppService.BuscarPorId(id);

            if (evento_UsuarioViewModel == null)
            {
                return(NotFound());
            }

            return(Ok(evento_UsuarioViewModel));
        }
        public IHttpActionResult PutEvento_UsuarioViewModel(Guid id, Evento_UsuarioViewModel evento_UsuarioViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != evento_UsuarioViewModel.Id || !Evento_UsuarioViewModelExists(id))
            {
                return(BadRequest());
            }

            _evento_UsuarioAppService.Atualizar(evento_UsuarioViewModel);
            return(StatusCode(HttpStatusCode.NoContent));
        }
        public async Task <IHttpActionResult> RegisterConvite(RegisterConviteBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            ITokenEnvioAppService _tokenEnvioAppService = new TokenEnvioAppService();

            var token = _tokenEnvioAppService.TrazerTodosAtivos().SingleOrDefault(t => t.Token == model.Token && t.ExpiraEm >= DateTime.Now && t.Ativo == true);

            if (token == null)
            {
                return(BadRequest("Este token já Expirou ou não existe, por favor solicitar outro convite"));
            }

            Usuario usuarioCadastrado = new Usuario()
            {
                UserName  = model.Email,
                Email     = model.Email,
                Documento = model.Documento,
                Nome      = model.Nome,
                Sobrenome = model.Sobrenome,
                Telefone1 = model.Telefone1,
                Telefone2 = model.Telefone2,
            };

            var eventoExist      = Db.Eventos.ToList().Exists(e => e.Id == Guid.Parse(model.Id_parametro) && e.Deletado == false);
            var usuarioRemetente = Db.Users.ToList().SingleOrDefault(u => u.Id == model.Id_parametro);

            if (!eventoExist && usuarioRemetente == null)
            {
                return(BadRequest("Evento ou Usuario não existe"));
            }

            if (usuarioRemetente != null)
            {
                if (usuarioRemetente.Organizador == true)
                {
                    usuarioCadastrado.CaixaEvento = true;
                }

                if (usuarioRemetente.UserPrincipal == true)
                {
                    usuarioCadastrado.Id_Usuario_Principal = usuarioRemetente.Id;
                }
            }

            if (eventoExist)
            {
                usuarioCadastrado.UserPrincipal = true;
                IdentityResult rs = await UserManager.CreateAsync(usuarioCadastrado, model.Password);

                if (!rs.Succeeded)
                {
                    return(GetErrorResult(rs));
                }
                else
                {
                    IEvento_UsuarioAppService _evento_UsuarioAppService = new Evento_UsuarioAppService();
                    IEventoAppService         _eventoAppService         = new EventoAppService();

                    EventoViewModel         evento         = _eventoAppService.BuscarPorId(Guid.Parse(model.Id_parametro));
                    Evento_UsuarioViewModel evento_usuario = new Evento_UsuarioViewModel()
                    {
                        Id_Evento  = evento.Id,
                        Id_Usuario = usuarioCadastrado.Id
                    };

                    var evento_usuarioInserido = _evento_UsuarioAppService.Criar(evento_usuario);

                    if (evento_usuarioInserido != null)
                    {
                        token.Ativo = false;
                        _tokenEnvioAppService.Atualizar(token);

                        return(Ok("Usuario Cadastrado e vinculado com Evento " + evento.Descricao));
                    }
                    else
                    {
                        return(BadRequest("Evento_usuario não foi inserido corretamente."));
                    }
                }
            }

            IdentityResult result = await UserManager.CreateAsync(usuarioCadastrado, model.Password);

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }
            else
            {
                token.Ativo = false;
                _tokenEnvioAppService.Atualizar(token);

                return(Ok("Usuario cadastrao e vinculado com sucesso"));
            }
        }