public async Task <IActionResult> EditarRegistroHora(RegistroDeHoras registro) { try { if (registro.Validar()) { UsuarioADE usuario = await ObterUsuarioComDadosPessoais(); registro.CargaHoraria = (float)(registro.HoraFim - registro.HoraInicio).TotalMinutes; registro.IdUsuario = usuario.Id; registro.Usuario = usuario; var registroanterior = await servicoRegistroDeHoras.BuscarPorId(registro.Identificador); registroanterior.Clonar(registro); await servicoRegistroDeHoras.AtualizarAsync(usuario, registroanterior); ViewBag.Retorno = "Seu registro de atividade foi alterado com sucesso."; } } catch (Exception ex) { await LogError($"{ex.Message}", "RegistroHoras", EnumTipoLog.AlteracaoRegistroHoras); ModelState.AddModelError("Falha", "Ocorreu um erro ao alterar o registro. - " + ex.Message); ViewBag.Retorno = "Ocorreu um erro ao alterar o registro, contate o suporte para maior exclarecimento. " + ex.Message; } return(RedirectToAction("Index")); }
public async Task <IActionResult> SetarTipoRecebimentoNotificacao(EnumTipoRecebimentoNotificacao TipoRecebimentoNotificacao) { try { UsuarioADE usuario = await ObterUsuarioLogado(); IdentityResult result = await SetarTipoRecebimentoNotificacao(usuario, TipoRecebimentoNotificacao); if (result.Succeeded) { return(Json("{\"Sucesso\": \"Tipo de recebimento de notificação alterado com sucesso.\"}")); } else { System.Text.StringBuilder Errors = new System.Text.StringBuilder(); foreach (IdentityError error in result.Errors) { Errors.Append($"{error.Code} - {error.Description}"); } await LogError(Errors.ToString(), "SetarTipoRecebimentoNotificacao", EnumTipoLog.ErroInterno); return(Json("{\"Erro\": \"Erro ao alterar o tipo de recebimento de notificação.\"}")); } } catch (Exception ex) { await LogError(ex.Message, ex.Source, EnumTipoLog.ErroInterno); return(Json("{\"Erro\": \"Erro ao alterar o tipo de recebimento de notificação.\"}")); } }
public async Task <IActionResult> TrocarCurso(int idCurso) { try { _cursoServices = new ServicoCurso(ref unitOfWork); Curso curso = await _cursoServices.BuscarPorId(idCurso); UsuarioADE usuario = await ObterUsuarioLogado(); usuario.Email = User.Identity.Name; usuario.Id = usuario.Id; usuario.UserName = usuario.UserName; usuario.IdCurso = curso.Identificador; if (usuario.IdInstituicao == curso.IdInstituicao) { await AtualizarUsuario(usuario); return(RedirectToAction("RedirecionarNovoCurso", "Instituicao", new { Area = "Principal", idCurso, idUsuario = usuario.Id })); } else { ModelState.AddModelError("Falha", "Usuário não está cadastrado nesta instituição"); ViewBag.Retorno = "Usuário não está cadastrado nesta instituição"; return(RedirectToAction("ListagemCursos", "Instituicao", new { area = "Principal", pageNumber = 1, idInstituicao = curso.IdInstituicao, ErrorMessage = ViewBag.Retorno })); } } catch (Exception ex) { ModelState.AddModelError("Falha", "Ocorreu um erro alterar o curso do usuário"); await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.AlteracaoCursoUsuario); return(RedirectToAction("Index", "Account")); } }
public override async Task LogRemocao(UsuarioADE usuario, RegistroDeHoras entity) { string Cabecalho = MensagemDelecaoRegistroHoras(usuario, entity); NotificacaoIndividual notificacao = new NotificacaoIndividual(entity.IdUsuario, entity.IdUsuario, Cabecalho, $"{usuario.UserName}, sua atividade {entity.Atividade} foi removida com sucesso. Data: {DateTime.Now.ToLocalTime()} "); await CriarNotificacaoIndividual(usuario, notificacao); }
public async Task CadastrarAsync(UsuarioADE usuario, LogAcoesEspeciais Log) { await unitOfWork.RepositorioBase <LogAcoesEspeciais>().Criar(Log); Console.WriteLine(Log.DataHoraInclusao + " | " + Log.Mensagem + " | " + Log.LocalOrigem + " | " + Log.AcoesSistema); await unitOfWork.Commit(); }
public InstituicaoViewModel(UsuarioADE usuario, List <Instituicao> instituicoes, PaginatedList <InformacaoInstituicao> PageInstituicoes, bool primeiraInstituicao) { Usuario = usuario; PaginaInstituicoes = PageInstituicoes; Instituicoes = instituicoes; PrimeiraInstituicao = primeiraInstituicao; }
public RequisitoDeUsuario(string userId, int idRequisito, string valor, UsuarioADE user) { UserId = userId; IdRequisito = idRequisito; Valor = valor; User = user; }
public async Task <IActionResult> TrocarInstituicao(int idInstituicao) { try { _servicoInstituicao = new ServicoInstituicao(ref unitOfWork); Instituicao instituicao = await _servicoInstituicao.BuscarPorId(idInstituicao); UsuarioADE usuario = await ObterUsuarioLogado(); usuario.Email = User.Identity.Name; usuario.Id = usuario.Id; usuario.UserName = usuario.UserName; usuario.IdInstituicao = instituicao.Identificador; await AtualizarUsuario(usuario); ViewBag.Retorno = $"Instituicao alterada para {instituicao.Nome}"; return(View("VisualizacaoInstituicao", await ParseVisualizacaoInstituicaoView(idInstituicao))); } catch (Exception ex) { ModelState.AddModelError("Falha", "Ocorreu um erro alterar o a Instituição do usuário"); await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.AlteracaoInstituicaoUsuario); return(RedirectToAction("Index", "Account")); } }
public async Task <UsuarioADE> ObterUsuarioComDadosPessoais(ClaimsPrincipal User) { UsuarioADE usuario = await _userManager.GetUserAsync(User); _servicoRequisitoDeUsuario = new ServicoRequisitoUsuario(ref unitOfWork); _servicoHistoricoGeracaoDocumento = new ServicoHistoricoGeracaoDocumento(ref unitOfWork); _servicoCurso = new ServicoCurso(ref unitOfWork); _servicoInstituicao = new ServicoInstituicao(ref unitOfWork); if (usuario != null) { List <RequisitoDeUsuario> ListaRequisitoUsuario = await _servicoRequisitoDeUsuario.BuscarRequisitosDoUsuario(usuario.Id); List <HistoricoGeracaoDocumento> ListaHistoricoGeracao = await _servicoHistoricoGeracaoDocumento.RecuperarHistoricoDoUsuario(usuario.Id); Curso curso = await _servicoCurso.BuscarPorId(usuario.IdCurso); Instituicao instituicao = await _servicoInstituicao.BuscarPorId(usuario.IdInstituicao); usuario.IdCursoNavigation = curso; usuario.HistoricoGeracaoDocumento = ListaHistoricoGeracao; usuario.IdInstituicaoNavigation = instituicao; return(usuario); } return(null); }
private async Task <PaginatedList <InformacaoCursoVM> > ObterListaCursos(UsuarioADE usuario, int?pageNumber) { List <Curso> ListaCursos = await _cursoServices.Filtrar(x => x.IdInstituicao == usuario.IdInstituicao); List <InformacaoCursoVM> model = new List <InformacaoCursoVM>(); foreach (Curso curso in ListaCursos) { curso.Instituicao = await _servicoInstituicao.BuscarPorId(curso.IdInstituicao); int QuantidadeAlunosCurso = await CountUsuarioByCurso(curso.Identificador); int QuantidadeDocumentosCurso = await _documentoServices.CountByCurso(curso.Identificador); InformacaoCursoVM InfoCurso = new InformacaoCursoVM(curso, QuantidadeAlunosCurso, QuantidadeDocumentosCurso); if (curso.Identificador == usuario.IdCurso) { InfoCurso.CursoDoUsuario = true; } model.Add(InfoCurso); } PaginatedList <InformacaoCursoVM> lista = PaginatedList <InformacaoCursoVM> .Create(model.AsQueryable(), pageNumber ?? 1, 6); return(lista); }
public async Task <IActionResult> ObterRequisitosDeDocumento(int idDocumento) { UsuarioADE Usuario = await ObterUsuarioLogado(); if (!Usuario.AceitouTermos) { return(PartialView("_TermosDeUso")); } Documento Documento = await _documentoServices.BuscarPorId(idDocumento); Curso Curso = await _cursoServices.BuscarPorId(Documento.IdCurso); Documento.IdCursoNavigation = Curso; List <Requisito> Requisitos = await _documentoServices.ObterRequisitosDeDocumento(idDocumento, Usuario.Id); List <InformacaoDocumento> informacaoDocumento = await _informacaoDocumentoServices.RecuperarInformacao(idDocumento); DocumentoViewModel DVM = new DocumentoViewModel(Documento, Requisitos, informacaoDocumento); if (Requisitos.Any(x => x.Bookmark == NomesRequisitos.AreasEstagio_) || Requisitos.Any(x => x.Bookmark == NomesRequisitos.TabelaAreasEstagio_)) { DVM.AreasEstagioCurso = await _servicoAreaEstagioCurso.Filtrar(x => x.IdCurso == Usuario.IdCurso); } return(PartialView("_TelaPreenchimento", DVM)); }
public async Task <IActionResult> Materiais() { try { if (UsuarioValido()) { UsuarioADE Usuario = await ObterUsuarioLogado(); if (!Usuario.PossuiInstituicao()) { return(RedirecionarPaginaInstituicao(true)); } SelecaoViewModel VModel = await this.ParseListagemViewModelAsync(Usuario.IdCurso, Usuario, 1); if (!Usuario.PossuiCurso()) { VModel.PrimeiroCurso = true; } return(PartialView("_Materiais", VModel)); } else { ModelState.AddModelError("Falha", "Usuário não está autenticado"); return(RedirectToAction("Logout", "Account")); } } catch (Exception ex) { await LogError(ex.Message, ex.Source, EnumTipoLog.ErroInterno); return(RedirectToAction("Index", "Account")); } }
public async Task <IActionResult> Exportar() { UsuarioADE usuario = await ObterUsuarioLogado(); try { Documento tabela = new Documento(); tabela.IdCursoNavigation = await _cursoServices.BuscarPorId(usuario.IdCurso); tabela.IdCursoNavigation.Instituicao = await _servicoInstituicao.BuscarPorId(tabela.IdCursoNavigation.IdInstituicao); RequisitosBasicosCabecalho requisitosFicha = await ObterRequisitosBasicosUsuario(usuario); ArquivoDownload Arquivo = await servicoRegistroDeHoras.GerarTabelaHistorico(usuario, tabela, requisitosFicha); //await _atividadeEstagioServices.VerificarTarefasEConcluir(usuario, EnumEntidadesSistema., tabela.Identificador, EnumTipoAtividadeEstagio.DownloadOuImpressao, 1); return(File(Arquivo.Bytes, Arquivo.TipoArquivo, $"Tabela de Registro de Horas - {usuario.ToString()}.docx")); } catch (Exception ex) { System.Threading.Thread.Sleep(3000); await LogError($"{ex.Message}", "RegistroHoras", EnumTipoLog.ImpressaoArquivo); } ViewBag.Retorno = "É necessário ao menos um registro para realizar a exportação do histórico."; ModelState.AddModelError("Falha", ViewBag.Retorno); return(View("Index")); }
public async Task <IActionResult> Index(bool Partial = false) { try { UsuarioADE usuario = await ObterUsuarioLogado(); if (!usuario.AceitouTermos) { return(PartialView("_TermosDeUso")); } if (Partial) { return(PartialView("_RegistroHoras", await ParseIndexVM())); } return(View(await ParseIndexVM())); } catch (Exception ex) { await LogError($"Ocorreu um erro ao obter montar a página (RegistroHoras/Index): {ex.Message}", "RegistroHoras", EnumTipoLog.CriacaoRegistroHoras); return(RedirectToAction("Account", "Login")); } }
public async Task <IActionResult> Editar(Requisito Requisito, string Mensagem) { try { if (ModelState.IsValid) { try { UsuarioADE usuario = await ObterUsuarioLogado(); await _requisitoServices.AtualizarAsync(usuario, Requisito, Mensagem); ViewBag.Retorno = "Requisito alterado com sucesso!"; await unitOfWork.Commit(); } catch (DbUpdateConcurrencyException) { if (_requisitoServices.ListarAsync().Result.Any(req => req.Identificador == Requisito.Identificador)) { ModelState.AddModelError("Falha", "Esse requisito já está sendo alterado"); } } } return(await Editar(Requisito.Identificador)); } catch (Exception ex) { await LogError(ex.Message, ex.Source + "-" + ex.TargetSite.Name, Dominio.Models.Enums.EnumTipoLog.AlteracaoRequisito); ModelState.AddModelError("Falha", "Ocorreu um erro ao alterar o requisito, contate o suporte para maior exclarecimento"); return(await Editar(Requisito.Identificador)); } }
public async Task <UsuarioADE> ObterUsuarioPorEmailOuId(string EmailOuId) { try { UsuarioADE usuario = await _userManager.FindByEmailAsync(EmailOuId); if (usuario != null) { return(usuario); } else { usuario = await _userManager.FindByIdAsync(EmailOuId); if (usuario != null) { return(usuario); } else { throw new Exception("Usuário não encontrado"); } } } catch (Exception ex) { throw ex; } }
public async Task <IActionResult> Criar(Requisito requisito) { UsuarioADE user = await ObterUsuarioLogado(); if (ModelState.IsValid) { try { await _requisitoServices.CadastrarAsync(user, requisito); return(Json("<p class='text-sucess'>Requisito criado com sucesso!</p>")); } catch (Exception ex) { await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.CriacaoRequisito); return(Json($"<p class='text-danger'>Ocorreu um erro ao criar o requisito</p><p>{ex.Message}</p>")); } } else { string Erros = "<ul>"; IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors); foreach (ModelError modelState in allErrors) { Erros += $"<li>{modelState.ErrorMessage}</li>"; } Erros += "</ul>"; return(Json(Erros)); } }
public async Task <IdentityResult> CadastrarAsync(UsuarioADE usuario, string password) { usuario.DataHoraInclusao = DateTime.Now; usuario.TipoRecebimentoNotificacao = EnumTipoRecebimentoNotificacao.Geral; ServicoRequisito servicoRequisito = new ServicoRequisito(ref unitOfWork); try { List <Requisito> requisito = await servicoRequisito.Filtrar(x => x.Identificador == 2 || x.NomeRequisito.Contains("Email")); RequisitoDeUsuario rdu = new RequisitoDeUsuario(usuario.Id, requisito.FirstOrDefault().Identificador, usuario.Email, usuario); _servicoRequisitoDeUsuario = _servicoRequisitoDeUsuario ?? new ServicoRequisitoUsuario(ref unitOfWork); await _servicoRequisitoDeUsuario.CadastrarAsync(rdu); }catch (Exception ex) { } IdentityResult result = await _userManager.CreateAsync(usuario, password); if (result.Succeeded) { await _userManager.AddToRoleAsync(usuario, EnumTipoUsuario.Membro.GetDescription()); return(result); } return(result); }
public async Task<IActionResult> Editar(Instituicao instituicao, string Mensagem) { try { if (ModelState.IsValid) { try { UsuarioADE usuario = await ObterUsuarioLogado(); instituicao.Logo = GetByteArrayFromFile(instituicao.LogoFile); await _servicoInstituicao.AtualizarAsync(usuario, instituicao, Mensagem); await unitOfWork.Commit(); ViewBag.Retorno = "Instituicao alterada com sucesso!"; } catch (DbUpdateConcurrencyException) { if (_servicoInstituicao.ListarAsync().Result.Any(e => e.Identificador == instituicao.Identificador)) return NotFound(); else throw; } return await Editar(instituicao.Identificador); } } catch (Exception ex) { await LogError(ex.Message, ex.Source + "-" + ex.TargetSite.Name, EnumTipoLog.AlteracaoInstituicao); ModelState.AddModelError("Falha", "Ocorreu um erro ao alterar a Instituição, contate o suporte para maior exclarecimento"); } return await Editar(instituicao.Identificador); }
public async Task <IdentityResult> CadastrarAdministradorAsync(UsuarioADE usuarioCriado, string password, bool existente, EnumTipoUsuario Funcao) { usuarioCriado.DataHoraInclusao = DateTime.Now; usuarioCriado.TipoRecebimentoNotificacao = EnumTipoRecebimentoNotificacao.Geral; IdentityResult result; if (existente) { result = await CadastrarAdministradorExistente(usuarioCriado, password, Funcao); await AtualizarAsync(usuarioCriado, null); } else { result = await _userManager.CreateAsync(usuarioCriado, password); if (result.Succeeded) { ServicoRequisito servicoRequisito = new ServicoRequisito(ref unitOfWork); Requisito requisito = await servicoRequisito.BuscarUm(x => x.NomeRequisito == "Email"); RequisitoDeUsuario rdu = new RequisitoDeUsuario(usuarioCriado.Id, requisito.Identificador, usuarioCriado.Email, usuarioCriado); _servicoRequisitoDeUsuario = _servicoRequisitoDeUsuario ?? new ServicoRequisitoUsuario(ref unitOfWork); await _servicoRequisitoDeUsuario.CadastrarAsync(rdu); await _userManager.AddToRoleAsync(usuarioCriado, Funcao.GetDescription()); } } return(result); }
public async Task Dismiss(UsuarioADE usuario, int IdEntity) { NotificacaoIndividual entity = await BuscarPorId(IdEntity); entity.Status = EnumStatusNotificacaoIndividual.Lido; await AtualizarAsync(usuario, entity); }
public async Task LogAcao(UsuarioADE usuario, T entity, string LocalAcao, EnumTipoLog tipoLog, TipoEvento Acao) { string Mensagem = LoggingHandler <T> .GerarMensagemTipoLog(usuario, entity, Acao); LogAcoesEspeciais Log = new LogAcoesEspeciais(Mensagem, LocalAcao, tipoLog, usuario.Id); await _servicoLogAcoesEspeciais.CadastrarAsync(usuario, Log); }
public async Task <IViewComponentResult> InvokeAsync(EnumTipoNotificacao TipoNotificacao = EnumTipoNotificacao.Ambos, object Notificacao = null) { string view = TipoNotificacao.GetDescription(); switch (TipoNotificacao) { case EnumTipoNotificacao.Geral: return(View(view, (Notificacao)Notificacao)); case EnumTipoNotificacao.Individual: return(View(view, (NotificacaoIndividual)Notificacao)); default: UsuarioADE usuario = await NotificacaoController.ObterUsuarioLogado(); NotificacaoViewmodel model = new NotificacaoViewmodel(); if (usuario.ReceberNotificacaoFocado() || usuario.ReceberNotificacaoGeral()) { model.NotificacacoesIndividuais = await NotificacaoController.ListaNotificacoesUsuario(usuario, unitOfWork); } else if (!usuario.ReceberNotificacaoFocado()) { model.NotificacacoesGerais = await NotificacaoController.NotificacoesGeraisUsuario(unitOfWork, usuario); } return(View(view, model)); } }
private async Task <PerfisViewModel> ParsePerfis(int?page, FiltroPerfil filter, string email, int start, int finish) { UsuarioADE usuario = await ObterUsuarioLogado(); PerfisViewModel model; if (!string.IsNullOrWhiteSpace(email)) { model = new PerfisViewModel() { Usuarios = await ObterUsuarios(page, email, usuario), Amigos = await _servicoListaAmigos.BuscarPorIdUsuario(usuario.Id), Paginas = Math.Abs(await _servicoUsuario.Count() / 50), PaginaAtual = page.Value, }; } else { model = new PerfisViewModel() { Usuarios = await ObterUsuarios(page, start, finish, filter, usuario), Amigos = await _servicoListaAmigos.BuscarPorIdUsuario(usuario.Id), Paginas = Math.Abs(await _servicoUsuario.Count() / 50), PaginaAtual = page.Value, }; } return(model); }
public async Task <List <Notificacao> > NotificacoesGeraisUsuario(UnitOfWork unitOfWork, UsuarioADE usuario) { _servicoAlteracaoEntidades = new ServicoAlteracaoEntidadesSistema(ref unitOfWork); _servicoVisualizacaoNotificacaoGeral = new ServicoVisualizacaoNotificacaoGeral(ref unitOfWork); List <VisualizacaoNotificacaoGeral> NotificacoesVisualizadas = await _servicoVisualizacaoNotificacaoGeral.BuscarPorIdUsuario(usuario.Id); List <AlteracaoEntidadesSistema> AlteracoesSistema = await _servicoAlteracaoEntidades.FiltrarNotificacoes(usuario, NotificacoesVisualizadas); List <Notificacao> Notificacoes = new List <Notificacao>(); foreach (AlteracaoEntidadesSistema alteracao in AlteracoesSistema) { try { IModeloADE Entidade = await _servicoAlteracaoEntidades.ObterEntidadeAlteracao(alteracao.Entidade, alteracao.IdentificadorEntidade); UsuarioADE AutorAlteracao = await ObterUsuarioPorEmailOuId(alteracao.IdAutor); alteracao.Autor = AutorAlteracao; Notificacoes.Add(new Notificacao(alteracao, Entidade)); } catch (Exception) { continue; } } return(Notificacoes); }
public async Task <IActionResult> AtualizarDados(string DadosAluno, bool Estagiando, int IdArea) { try { unitOfWork = unitOfWork ?? new UnitOfWork(context); ServicoRequisito _servicoRequisito = new ServicoRequisito(ref unitOfWork); _servicoRequisitoUsuario = new ServicoRequisitoUsuario(ref unitOfWork); List <DadosAlunoKV> dadosAluno = JsonConvert.DeserializeObject <List <DadosAlunoKV> >(DadosAluno); foreach (DadosAlunoKV dado in dadosAluno) { string id = dado.Name.Split(':')[1]; dado.Requisito = await _servicoRequisito.BuscarUm(x => x.Bookmark == id); } UsuarioADE usuario = await ObterUsuarioLogado(); if (usuario.Id != "N/A") { await _servicoRequisitoUsuario.AdicionarRequisitosDeUsuarioAsync(dadosAluno, usuario); if (IdArea != 0) { await CadastrarAreaEstagioAluno(usuario, IdArea); } usuario.Estagiando = Estagiando; await AtualizarUsuario(usuario); } return(PartialView("_FormularioRequisitosBasicos")); } catch (Exception ex) { await LogError(ex.Message, ex.Source, EnumTipoLog.AlteracaoRequisitoDeUsuario); return(Json("{\"Erro\": \"Erro ao atualizar informações\"}")); } }
public async Task <IActionResult> ObterNotificacoesDeAlteracaoDoSistema() { using (unitOfWork = new UnitOfWork(context)) { try { UsuarioADE usuario = await ObterUsuarioLogado(); if (usuario.ReceberNotificacaoGeral()) { List <Notificacao> Notificacoes = await NotificacoesGeraisUsuario(unitOfWork, usuario); string NotificacoesJson = JsonConvert.SerializeObject(Notificacoes, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); return(Json(NotificacoesJson)); } return(Json("{\"Erro\": \"Usuário não recebe notificações gerais\"}")); } catch (Exception ex) { await LogError(ex.Message, ex.Source, EnumTipoLog.ErroInterno); return(Json("{\"Erro\": \"Erro ao obter notificações\"}")); }; } }
public async Task <IActionResult> Index() { try { if (UsuarioValido()) { UsuarioADE usuario = await ObterUsuarioLogado(); RegulamentacaoCurso regulamentacao = await servicoRegulamentacaoCurso.RecuperarRegulamentacao(usuario.IdCurso); regulamentacao.IdCursoNavigation = await servicoCurso.BuscarPorId(usuario.IdCurso); regulamentacao.IdCursoNavigation.Instituicao = await servicoInstituicao.BuscarPorId(regulamentacao.IdCursoNavigation.IdInstituicao); return(View(regulamentacao)); } else { ModelState.AddModelError("Falha", "Usuário não está autenticado"); return(RedirectToAction("Logout", "Account")); } } catch (Exception ex) { await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.ErroInterno); return(RedirectToAction("Index", "Account")); } }
public async Task <IActionResult> ListagemCursos(int?pageNumber, int?idInstituicao, string ErrorMessage = null) { try { if (ErrorMessage != null) { ModelState.AddModelError("Falha", ErrorMessage); } if (User != null && User.Identity.IsAuthenticated) { UsuarioADE usuario = await ObterUsuarioLogado(); idInstituicao = idInstituicao == null ? usuario.IdInstituicao : idInstituicao; PaginatedList <InformacaoCursoVM> model = await ParseInformacaoCursoVM(usuario, idInstituicao, pageNumber); return(View("VisualizacaoCursosInstituicao", model)); } else { ModelState.AddModelError("Falha", "Usuário não está autenticado"); return(RedirectToAction("Logout", "Account")); } } catch (Exception ex) { ModelState.AddModelError("Falha", "Ocorreu um erro ao listar os cursos disponiveis"); await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.ErroInterno); return(RedirectToAction("Index", "Account")); } }
private async Task <UsuarioADE> RegistrarELogarUsuario() { string ContagemUsuarios = (await ContarUsuarios()).ToString().PadLeft(2, '0'); string NomeTemporario = $"UsuarioTemporario{ContagemUsuarios}"; string EmailTemporario = $"usuario{ContagemUsuarios}@assistentedeestagio.com.br"; var NovoUsuario = new UsuarioADE { UserName = NomeTemporario, Email = EmailTemporario, PasswordHash = DateTime.Now.Ticks.ToString(), AceitouTermos = true, Logo = IconPadrao(_hostingEnvironment) }; var result = await RegistrarUsuario(NovoUsuario); if (result.Succeeded) { await LogarUsuario(NovoUsuario, EmailTemporario); await ManterLogDeRegistro(NovoUsuario); } else { throw new Exception("Não foi possível cadastrar o usuário " + result.Errors.First()); } return(NovoUsuario); }