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