public async Task<IActionResult> ExcluirInstituicaoConfirmed(int id)
{
try
{
UsuarioADE usuario = await ObterUsuarioLogado();
var instituicao = await _servicoInstituicao.BuscarPorId(id);
await _servicoInstituicao.RemoverAsync(usuario, instituicao);
}
catch(Exception ex)
{
await LogError(ex.Message, ex.Source + "-" + ex.TargetSite.Name, EnumTipoLog.DelecaoInstituicao);
ModelState.AddModelError("Falha", "Ocorreu um erro ao excluir a instituição, contate o suporte para maior exclarecimento");
}
return RedirectToAction(nameof(Index));
}
public async Task <PaginatedList <InformacaoCursoVM> > ParseInformacaoCursoVM(UsuarioADE usuario, int?idInstituicao, int?pageNumber)
{
_cursoServices = new ServicoCurso(ref unitOfWork);
_servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
_servicoDocumento = new ServicoDocumento(ref unitOfWork);
List <Curso> ListaCursos = await _cursoServices.Filtrar(x => x.IdInstituicao == 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 _servicoDocumento.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, pageSize);
return(lista);
}
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> 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 <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)
{
UsuarioADE usuario = await ObterUsuarioComDadosPessoais();
UsuarioHomeViewModel model;
try
{
if (usuario.Id != "N/A")
{
usuario.IdInstituicaoNavigation = await _servicoInstituicao.BuscarPorId(usuario.IdInstituicao);
model = new UsuarioHomeViewModel()
{
Usuario = usuario,
GeracoesDocumento = await _servicoHistoricoGeracaoDocumento.RecuperarHistoricoDoUsuario(usuario.Id),
QuantidadeDocumentosGerados = await ObterProgressoDownloads(usuario),
ContagemRequisitoDoUsuario = await ObterRequisitoUsuarioComRequisito(usuario.Id),
ContagemDocumentosCurso = await _servicoDocumento.ContarPorCurso(usuario.IdCurso)
};
if (!usuario.PossuiCurso())
{
model.PrimeiroCurso = true;
}
}
else
{
model = new UsuarioHomeViewModel()
{
Usuario = await ObterUsuarioLogado(),
GeracoesDocumento = null,
QuantidadeDocumentosGerados = 0,
ContagemRequisitoDoUsuario = 0,
ContagemDocumentosCurso = 0
};
}
}
catch (System.Exception ex)
{
model = new UsuarioHomeViewModel()
{
Usuario = await ObterUsuarioLogado(),
GeracoesDocumento = null,
QuantidadeDocumentosGerados = 0,
ContagemRequisitoDoUsuario = 0,
ContagemDocumentosCurso = 0
};
}
if (Partial)
{
return(PartialView("_Index", model));
}
return(View(model));
}
public async Task <SelecaoViewModel> ParseListagemViewModelAsync(int idCurso, UsuarioADE usuario, int?pageNumber, string AssinaturaDocumento = "", string TipoDocumento = "", string Etapa = "")
{
SelecaoViewModel model = new SelecaoViewModel();
idCurso = idCurso == 0 ? usuario.IdCurso : idCurso;
model.Documentos = await _documentoServices.ListarPorCurso(usuario.IdCurso);
model.Curso = await _cursoServices.BuscarPorId(idCurso);
model.Curso.Instituicao = await _servicoInstituicao.BuscarPorId(model.Curso.IdInstituicao);
model.Cursos = await ObterListaCursos(usuario, pageNumber);
model.HistoricoGeracaoDocumento = await _historicoGeracaoServices.RecuperarHistoricoDoUsuario(usuario.Id);
model.InformacaoCurso = await _informacaoCursoServices.RecuperarInformacao(idCurso);
model.DocumentoViewModel = new DocumentoViewModel();
model.Paginated = PaginatedList <Documento> .Create(model.Documentos.AsQueryable(), pageNumber ?? 1, 8);
return(model);
}
private async Task <InformacaoInstituicao> ParseVisualizacaoInstituicaoView(int idInstituicao)
{
UsuarioADE usuario = await ObterUsuarioComDadosPessoais();
Instituicao instituicao;
unitOfWork = unitOfWork ?? new UnitOfWork(context);
_servicoCurso = new ServicoCurso(ref unitOfWork);
_servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
if (usuario.IdInstituicao > 0 && idInstituicao == 0)
{
instituicao = await _servicoInstituicao.BuscarPorId(usuario.IdInstituicao);
}
else
{
instituicao = await _servicoInstituicao.BuscarPorId(idInstituicao);
}
instituicao.Cursos = await _servicoCurso.Filtrar(x => x.IdInstituicao == instituicao.Identificador);
InformacaoInstituicao InfoInstituicao = await ObterInformacaoInstituicao(instituicao, usuario, unitOfWork);
return(InfoInstituicao);
}
private async Task <InstituicaoViewModel> ParseInstituicaoView(int?pageNumber)
{
UsuarioADE usuario = await ObterUsuarioComDadosPessoais();
InstituicaoViewModel model = new InstituicaoViewModel()
{
Usuario = usuario,
PaginaInstituicoes = await ObterPaginaInstituicao(pageNumber, usuario, unitOfWork),
Instituicoes = await _servicoInstituicao.ListarAsync()
};
if (!usuario.PossuiInstituicao())
{
model.PrimeiraInstituicao = true;
}
else
{
usuario.IdInstituicaoNavigation = await _servicoInstituicao.BuscarPorId(usuario.IdInstituicao);
}
return(model);
}
public async Task <PaginatedList <InformacaoCursoVM> > ParseInformacaoCursoVM(UsuarioADE usuario, int?idInstituicao, int?pageNumber, UnitOfWork unitOfWork)
{
try
{
unitOfWork = unitOfWork ?? new UnitOfWork(context);
_servicoCurso = new ServicoCurso(ref unitOfWork);
_servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
_servicoDocumento = new ServicoDocumento(ref unitOfWork);
List <Curso> ListaCursos = await _servicoCurso.Filtrar(x => x.IdInstituicao == 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 _servicoDocumento.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, 10);
return(lista);
}
catch (System.Exception ex)
{
await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.ErroInterno);
return(null);
}
}
public async Task <IActionResult> Index(bool Partial = false)
{
unitOfWork = unitOfWork ?? new UnitOfWork(context);
UsuarioADE usuario = await ObterUsuarioComDadosPessoais();
_servicoRequisitoUsuario = new ServicoRequisitoUsuario(ref unitOfWork);
_servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
usuario.IdInstituicaoNavigation = await _servicoInstituicao.BuscarPorId(usuario.IdInstituicao);
MeusDadosViewModel model = new MeusDadosViewModel()
{
Usuario = usuario,
RequisitoDoUsuario = await ObterPaginaRequisitoUsuario(1, usuario.Id, unitOfWork)
};
if (Partial)
{
return(PartialView("_Index", model));
}
return(View(model));
}
public async Task <IActionResult> VisualizarEntidade(int id)
{
try
{
Curso curso = await _servicoCurso.BuscarPorId(id);
curso.Instituicao = await _servicoInstituicao.BuscarPorId(curso.IdInstituicao);
VisualizarEntidadeViewmodel <Curso> model = new VisualizarEntidadeViewmodel <Curso>()
{
Entidade = curso,
ListaAlteracoes = await _servicoAlteracoes.Filtrar(x => x.Entidade == EnumEntidadesSistema.Curso && x.IdentificadorEntidade == id)
};
return(View(model));
}
catch (Exception ex)
{
await LogError(ex.Message, ex.Source + "-" + ex.TargetSite.Name, EnumTipoLog.ErroInterno);
ModelState.AddModelError("Falha", "Ocorreu um montar a visualização de entidade, contate o suporte para maior exclarecimento" + ex.Message);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> ObterResultadoPesquisaCurso(string NomeCurso)
{
UsuarioADE usuario = await ObterUsuarioLogado();
_cursoServices = new ServicoCurso(ref unitOfWork);
_servicoDocumento = new ServicoDocumento(ref unitOfWork);
ServicoInstituicao _servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
Instituicao instituicaoDoUsuario = await _servicoInstituicao.BuscarPorId(usuario.IdInstituicao);
try
{
List <Curso> ListaCursos = await _cursoServices.Filtrar(x => x.NomeCurso.Contains(NomeCurso));
List <InformacaoCursoVM> model = new List <InformacaoCursoVM>();
foreach (Curso curso in ListaCursos)
{
int quantidadeDocumentos = 0;
int quantidadeAlunos = 0;
try
{
quantidadeDocumentos = await _servicoDocumento.CountByCurso(curso.Identificador);
}
catch (Exception ex)
{
await LogError($"Erro ao obter contagem de documentos para o curso {curso.ToString()} : {ex.Message}", ex.Source, Dominio.Models.Enums.EnumTipoLog.ErroInterno);
}
try
{
quantidadeAlunos = await CountUsuarioByCurso(curso.Identificador);
}
catch (Exception ex)
{
await LogError($"Erro ao obter contagem de usuários para o curso {curso.ToString()} : {ex.Message}", ex.Source, Dominio.Models.Enums.EnumTipoLog.ErroInterno);
}
curso.Instituicao = await _servicoInstituicao.BuscarPorId(curso.IdInstituicao);
InformacaoCursoVM InfoCurso = new InformacaoCursoVM(curso, quantidadeAlunos, quantidadeDocumentos);
if (curso.Identificador == usuario.IdCurso)
{
InfoCurso.CursoDoUsuario = true;
}
model.Add(InfoCurso);
}
if (ListaCursos.Count > 0)
{
PaginatedList <InformacaoCursoVM> lista = PaginatedList <InformacaoCursoVM> .Create(model.AsQueryable(), 1, pageSize);
return(PartialView("_SelecaoCurso_CursoOption", lista));
}
else
{
throw new Exception($"O resultado da pesquisa por curso está vazio : {NomeCurso}");
}
}
catch (Exception ex)
{
ModelState.AddModelError("Falha", $"Ocorreu um erro ao buscar cursos compatíveis com a pesquisa : {NomeCurso}");
await LogError(ex.Message, "ObterResultadoPesquisaCurso", Dominio.Models.Enums.EnumTipoLog.ErroInterno);
return(Json("{\"Erro\": \"Pesquisa não retornou nenhum curso\"}"));
}
}