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 <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 GerenciamentoInstituicao(
     UserManager<UsuarioADE> userManager,
     ApplicationDbContext context
     ) : base(unitOfWork = new UnitOfWork(context), userManager)
 {
     _servicoCurso = new ServicoCurso(ref unitOfWork);
     _servicoAlteracoes = new ServicoAlteracaoEntidadesSistema(ref unitOfWork);
     _servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
 }
Пример #4
0
 public RegulamentacaoController(
     UserManager <UsuarioADE> userManager,
     SignInManager <UsuarioADE> signInManager,
     ApplicationDbContext _context
     ) : base(new UnitOfWork(_context), userManager, signInManager)
 {
     unitOfWork = new UnitOfWork(_context);
     servicoRegulamentacaoCurso = new ServicoRegulamentacaoCurso(ref unitOfWork);
     servicoCurso       = new ServicoCurso(ref unitOfWork);
     servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
 }
        public async Task <PaginatedList <InformacaoInstituicao> > ObterPaginaInstituicao(int?PageNumber, UsuarioADE usuario, UnitOfWork unitOfWork = null)
        {
            unitOfWork          = unitOfWork ?? new UnitOfWork(context);
            _servicoCurso       = new ServicoCurso(ref unitOfWork);
            _servicoInstituicao = new ServicoInstituicao(ref unitOfWork);

            List <Instituicao> instituicoes = await _servicoInstituicao.ListarAsync();

            List <InformacaoInstituicao> infoInstituicoes = await ObterInformacaoInstituicao(instituicoes, usuario);

            return(PaginatedList <InformacaoInstituicao> .Create(infoInstituicoes.AsQueryable(), PageNumber ?? 1, 9));
        }
Пример #6
0
 public GerenciamentoDocumentoController(
     IHostingEnvironment env,
     UserManager <UsuarioADE> userManager,
     SignInManager <UsuarioADE> signInManager,
     ApplicationDbContext _context
     ) : base(unitOfWork = new UnitOfWork(_context), userManager, signInManager)
 {
     _documentoServices          = new ServicoDocumento(ref unitOfWork, env);
     _cursoServices              = new ServicoCurso(ref unitOfWork);
     _requisitoServices          = new ServicoRequisito(ref unitOfWork);
     _requisitoDocumentoServices = new ServicoRequisitoDeDocumento(ref unitOfWork);
     _servicoAlteracoes          = new ServicoAlteracaoEntidadesSistema(ref unitOfWork);
     _servicoInstituicao         = new ServicoInstituicao(ref unitOfWork);
 }
        private async Task <InformacaoInstituicao> ObterInformacaoInstituicao(Instituicao instituicao, UsuarioADE usuario, UnitOfWork unitOf)
        {
            unitOfWork          = unitOfWork ?? new UnitOfWork(context);
            _servicoCurso       = new ServicoCurso(ref unitOfWork);
            _servicoInstituicao = new ServicoInstituicao(ref unitOfWork);

            InformacaoInstituicao infoInstituicao = new InformacaoInstituicao()
            {
                QuantidadeCursosInstituicao = _servicoCurso.Filtrar(x => x.IdInstituicao == instituicao.Identificador).Result.Count,
                QuantidadeAlunosInstituicao = await CountUsuarioByInstituicao(instituicao.Identificador),
                Instituicao          = instituicao,
                InstituicaoDoUsuario = usuario.IdInstituicao == instituicao.Identificador ? true : false
            };

            return(infoInstituicao);
        }
 public RegistroHorasController(
     UserManager <UsuarioADE> userManager,
     IHostingEnvironment _env,
     ApplicationDbContext _context
     ) : base(new UnitOfWork(_context), userManager)
 {
     context                   = _context;
     env                       = _env;
     unitOfWork                = new UnitOfWork(context);
     _servicoInstituicao       = new ServicoInstituicao(ref unitOfWork);
     _cursoServices            = new ServicoCurso(ref unitOfWork);
     servicoRegistroDeHoras    = new ServicoRegistroDeHoras(ref unitOfWork);
     _atividadeEstagioServices = new ServicoAtividadeEstagio(ref unitOfWork);
     _servicoRequisitoUsuario  = new ServicoRequisitoUsuario(ref unitOfWork);
     _servicoRequisito         = new ServicoRequisito(ref unitOfWork);
 }
 public UserHomeController(
     UserManager <UsuarioADE> userManager,
     IHostingEnvironment _env,
     ApplicationDbContext _context
     ) : base(new UnitOfWork(_context), userManager)
 {
     context           = _context;
     env               = _env;
     unitOfWork        = new UnitOfWork(context);
     _servicoDocumento = new ServicoDocumento(ref unitOfWork, env);
     _servicoHistoricoGeracaoDocumento = new ServicoHistoricoGeracaoDocumento(ref unitOfWork);
     _servicoRequisitoUsuario          = new ServicoRequisitoUsuario(ref unitOfWork);
     _servicoCurso             = new ServicoCurso(ref unitOfWork);
     _servicoInstituicao       = new ServicoInstituicao(ref unitOfWork);
     _servicoLogAcoesEspeciais = new ServicoLogAcoesEspeciais(ref unitOfWork);
     _servicoRegistroDeHoras   = new ServicoRegistroDeHoras(ref unitOfWork);
 }
        private async Task <List <InformacaoInstituicao> > ObterInformacaoInstituicao(List <Instituicao> instituicoes, UsuarioADE usuario)
        {
            unitOfWork          = unitOfWork ?? new UnitOfWork(context);
            _servicoCurso       = new ServicoCurso(ref unitOfWork);
            _servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
            List <InformacaoInstituicao> infoInstituicoes = new List <InformacaoInstituicao>();

            foreach (Instituicao instituicao in instituicoes)
            {
                int QuantidadeCursos = _servicoCurso.Filtrar(x => x.IdInstituicao == instituicao.Identificador).Result.Count;
                int QuantidadeAlunos = await CountUsuarioByInstituicao(instituicao.Identificador);

                bool InstituicaoDoUsuario             = usuario.IdInstituicao == instituicao.Identificador ? true : false;
                InformacaoInstituicao infoInstituicao = new InformacaoInstituicao(instituicao, QuantidadeAlunos, QuantidadeCursos, InstituicaoDoUsuario);
                infoInstituicoes.Add(infoInstituicao);
            }
            return(infoInstituicoes);
        }
Пример #11
0
 public AccountController(UserManager <UsuarioADE> userManager,
                          SignInManager <UsuarioADE> signInManager,
                          IHostingEnvironment hostingEnvironment,
                          AuthMessageSender emailSender,
                          ApplicationDbContext context
                          ) : base(new UnitOfWork(context), userManager, signInManager, new ServicoRequisitoUsuario(ref unitOfWork))
 {
     _hostingEnvironment         = hostingEnvironment;
     _emailSender                = emailSender;
     this.signInManager          = signInManager;
     unitOfWork                  = new UnitOfWork(context);
     _servicoInstituicao         = new ServicoInstituicao(ref unitOfWork);
     _servicoCurso               = new ServicoCurso(ref unitOfWork);
     _servicoAreaEstagio         = new ServicoAreaEstagioCurso(ref unitOfWork);
     _servicoRequisito           = new ServicoRequisito(ref unitOfWork);
     _servicoRequisitosDeUsuario = new ServicoRequisitoUsuario(ref unitOfWork);
     TemplatePathHelper          = new TemplatePathHelper(hostingEnvironment.WebRootPath);
 }
Пример #12
0
 public ListagemDocumentosController(
     IHostingEnvironment env,
     UserManager <UsuarioADE> userManager,
     ApplicationDbContext _context
     ) : base(new UnitOfWork(_context), userManager)
 {
     context                      = _context;
     unitOfWork                   = new UnitOfWork(_context);
     _documentoServices           = new ServicoDocumento(ref unitOfWork, env);
     _servicoInstituicao          = new ServicoInstituicao(ref unitOfWork);
     _cursoServices               = new ServicoCurso(ref unitOfWork);
     _historicoGeracaoServices    = new ServicoHistoricoGeracaoDocumento(ref unitOfWork);
     _informacaoCursoServices     = new ServicoInformacaoCurso(ref unitOfWork);
     _informacaoDocumentoServices = new ServicoInformacaoDocumento(ref unitOfWork);
     _atividadeEstagioServices    = new ServicoAtividadeEstagio(ref unitOfWork);
     _servicoAreaEstagioCurso     = new ServicoAreaEstagioCurso(ref unitOfWork);
     _servicoRequisito            = new ServicoRequisito(ref unitOfWork);
 }
        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);
            }
        }
Пример #14
0
        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> ObterResultadoPesquisaInstituicao(string Nome)
        {
            try
            {
                _servicoInstituicao = new ServicoInstituicao(ref unitOfWork);
                List <Instituicao> instituicoes = await _servicoInstituicao.Filtrar(x => x.Nome == Nome);

                return(PartialView("_SelecaoInstituicao_InstituicaoOption", instituicoes));
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("Falha", "Ocorreu um erro ao buscar instituições compatíveis com a pesquisa");
                await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.ErroInterno);

                List <Instituicao> lista = new List <Instituicao>()
                {
                    new Instituicao()
                    {
                        Nome = "Não encontrado", Identificador = 1
                    }
                };
                return(PartialView("_SelecaoInstituicao_InstituicaoOption", lista));
            }
        }
        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);
        }
        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\"}"));
            }
        }
 public InstituicaoSelectViewComponent(ApplicationDbContext context)
 {
     unitOfWork         = new UnitOfWork(context);
     ServicoInstituicao = new ServicoInstituicao(ref unitOfWork);
 }