private void ExcluirAlunoDaTurma(DropDownList comboTurma)
        {
            //Obtém a linha da grid onde a dropdownlist (combo) de oferta, está contida
            var linhadaGrid = (GridViewRow)comboTurma.NamingContainer;

            if (linhadaGrid.RowType == DataControlRowType.Header)
            {
                linhadaGrid.TableSection = TableRowSection.TableHeader;
            }

            if (linhadaGrid != null)
            {
                var hdfIdMatriculaOferta = (HiddenField)linhadaGrid.FindControl("hdfIdMatriculaOferta");

                int IdMatriculaOferta;
                var manterMatriculaOferta = new ManterMatriculaOferta();
                classes.MatriculaOferta matriculaOferta = null;
                if (int.TryParse(hdfIdMatriculaOferta.Value, out IdMatriculaOferta))
                {
                    matriculaOferta = manterMatriculaOferta.ObterMatriculaOfertaPorID(IdMatriculaOferta);
                }

                if (matriculaOferta != null && matriculaOferta.MatriculaTurma != null &&
                    matriculaOferta.MatriculaTurma.Count > 0)
                {
                    matriculaOferta.MatriculaTurma.Clear();
                    AtualizarStatusDaOferta(matriculaOferta.StatusMatricula, matriculaOferta, ref manterMatriculaOferta);
                }
            }
        }
        private void PreencherDropDownTurma(DropDownList ddlTurma, classes.MatriculaOferta matriculaOferta)
        {
            var usuarioLogado = new ManterUsuario().ObterUsuarioLogado();

            // Preencher dropdown de turmas de acordo com a seleção do usuário e com as permissões de visualização.
            if (usuarioLogado.IsAdministrador())
            {
                WebFormHelper.PreencherLista(matriculaOferta.Oferta.ListaTurma, ddlTurma, false, true);
            }
            else if (matriculaOferta.Oferta.SolucaoEducacional.Ativo &&
                     matriculaOferta.Oferta.SolucaoEducacional.UFGestor.ID == usuarioLogado.UF.ID)
            {
                WebFormHelper.PreencherLista(matriculaOferta.Oferta.ListaTurma, ddlTurma, false, true);
            }
        }
        private void AtualizarStatusDaOferta(enumStatusMatricula statusMatriculaOferta,
                                             classes.MatriculaOferta matriculaOferta, ref ManterMatriculaOferta manterMatriculaOferta,
                                             DateTime?dataConclusao = null, double?notaFinal = null, bool atualizarMatriculas = true,
                                             bool fazerMerge        = false)
        {
            if (manterMatriculaOferta == null)
            {
                // O objetivo que for salvo pelo Manter não deve vir de outra sessão (outro Manter/BM)
                manterMatriculaOferta = new ManterMatriculaOferta();
                matriculaOferta       = manterMatriculaOferta.ObterMatriculaOfertaPorID(matriculaOferta.ID);
            }

            if (matriculaOferta == null)
            {
                return;
            }

            //Atualiza o status da Oferta
            matriculaOferta.StatusMatricula = statusMatriculaOferta;

            if (dataConclusao != null || notaFinal != null)
            {
                foreach (var mt in matriculaOferta.MatriculaTurma)
                {
                    // Obter a turma novamente, pois o lazy tá pirando nessa parte.
                    var turma = new ManterTurma().ObterTurmaPorID(mt.Turma.ID);

                    // Só altera caso a data da turma seja menor ou igual à data de conclusão informada.
                    if (dataConclusao.HasValue &&
                        (turma.DataInicio <= dataConclusao))
                    {
                        mt.DataTermino = dataConclusao;
                    }

                    if (notaFinal.HasValue)
                    {
                        mt.MediaFinal = notaFinal;
                    }
                }
            }

            manterMatriculaOferta.AtualizarMatriculaOferta(matriculaOferta, false, fazerMerge);

            new BP.ManterItemTrilhaParticipacao().AtualizarStatusParticipacoesTrilhas(matriculaOferta);
        }
        private void MatricularAlunoNaTurma(DropDownList comboTurma)
        {
            //Obtém a linha da grid onde a dropdownlist (combo) de oferta, está contida
            var linhadaGrid = (GridViewRow)comboTurma.NamingContainer;

            if (linhadaGrid != null)
            {
                var hdfIdMatriculaOferta = (HiddenField)linhadaGrid.FindControl("hdfIdMatriculaOferta");

                int IdMatriculaOferta;
                classes.MatriculaOferta matriculaOferta = null;
                if (int.TryParse(hdfIdMatriculaOferta.Value, out IdMatriculaOferta))
                {
                    matriculaOferta = new ManterMatriculaOferta().ObterMatriculaOfertaPorID(IdMatriculaOferta);
                }

                if (matriculaOferta != null)
                {
                    var matriculaTurma = ObterObjetoMatriculaTurma(comboTurma, matriculaOferta);

                    var manterMatriculaOferta = new ManterMatriculaOferta();

                    if (matriculaOferta.MatriculaTurma.Count == 0)
                    {
                        matriculaOferta.MatriculaTurma.Add(matriculaTurma);
                    }
                    else
                    {
                        matriculaOferta.MatriculaTurma[0] = matriculaTurma;
                    }

                    manterMatriculaOferta.AtualizarMatriculaOferta(matriculaOferta, false);


                    WebFormHelper.ExibirMensagem(enumTipoMensagem.Sucesso,
                                                 string.Format("O usuário '{0}' foi matriculado na turma '{1}'",
                                                               matriculaOferta.Usuario.Nome, matriculaTurma.Turma.Nome));
                }
            }
        }
        private void SetarListaComStatusDeMatricula(classes.MatriculaOferta matriculaOferta)
        {
            if ((ListaStatusMatricula == null || !ListaStatusMatricula.Any()))
            {
                var categoriaConteudo = new ManterSolucaoEducacional().ObterSolucaoEducacionalPorId(matriculaOferta.Oferta.SolucaoEducacional.ID).CategoriaConteudo;

                var listaStatusMatricula = (new ManterStatusMatricula()).ObterStatusMatriculaPorCategoriaConteudo(categoriaConteudo)
                                           .Where(p => p.ID != (int)enumStatusMatricula.Reprovado).ToList();

                var manterStatusMatricula = new ManterStatusMatricula();

                var status = manterStatusMatricula.ObterStatusMatriculaPorCategoriaConteudo(categoriaConteudo)
                             .Where(p => p.ID != (int)enumStatusMatricula.Reprovado);

                var usuarioLogado = new ManterUsuario().ObterUsuarioLogado();

                // Filtrar Status pela visualização do usuário.
                status = status.Where(x => x.PermiteVisualizacao(usuarioLogado));

                ListaStatusMatricula = status.ToList();
            }
        }
        public classes.MatriculaTurma ObterObjetoMatriculaTurma(DropDownList comboTurma, classes.MatriculaOferta matriculaOferta)
        {
            classes.MatriculaTurma matriculaTurma = null;
            if (matriculaOferta.MatriculaTurma != null && matriculaOferta.MatriculaTurma.Count > 0)
            {
                matriculaTurma = matriculaOferta.MatriculaTurma.FirstOrDefault();
            }

            //Se o usuário não estiver matriculado em nenhuma turma, preenche o objeto matricula turma com os dados da oferta.
            if (matriculaTurma == null)
            {
                int IdTurma = 0;
                int.TryParse(comboTurma.SelectedItem.Value, out IdTurma);

                matriculaTurma = new classes.MatriculaTurma
                {
                    MatriculaOferta = matriculaOferta,
                    Turma           = IdTurma > 0 ? new ManterTurma().ObterTurmaPorID(IdTurma) : null,
                    DataMatricula   = DateTime.Now
                };

                matriculaTurma.DataLimite = matriculaTurma.CalcularDataLimite();
            }
            else
            {
                //Troca a turma, pois o usuário informou uma nova turma
                int idTurmaEscolhidaNaCombo;

                if (int.TryParse(comboTurma.SelectedItem.Value, out idTurmaEscolhidaNaCombo) && !matriculaTurma.ID.Equals(idTurmaEscolhidaNaCombo))
                {
                    matriculaTurma.TurmaAnterior = matriculaTurma.Turma;

                    /* Troca a Turma do usuário (ou seja, matricula o aluno em uma nova turma),
                     * pois ele escolheu uma nova turma na combo.*/

                    matriculaTurma.Turma = new ManterTurma().ObterTurmaPorID(idTurmaEscolhidaNaCombo);
                }
            }

            return(matriculaTurma);
        }
        private void TratarComboStatusOferta(DropDownList ddlStatusOferta, classes.MatriculaOferta matriculaOferta, Label statusOferta = null)
        {
            var permiteAlteracao = matriculaOferta.Oferta.AlteraPeloGestorUC;

            // Caso esteja em modo de avaliação, só adiciona o Status atual da matrícula e esconde o dropdown.
            if (!InModoDeAvaliacao && (permiteAlteracao == true || _manterUsuario.PerfilAdministrador()))
            {
                if (ddlStatusOferta != null)
                {
                    var categoriaConteudo = new ManterSolucaoEducacional().ObterSolucaoEducacionalPorId(matriculaOferta.Oferta.SolucaoEducacional.ID).CategoriaConteudo;

                    var listaStatusMatricula = (new ManterStatusMatricula()).ObterStatusMatriculaPorCategoriaConteudo(categoriaConteudo)
                                               .Where(p => p.ID != (int)enumStatusMatricula.Reprovado).ToList();

                    // Obter lista usando AutoMapper para não alterar a lista original com a adição
                    // do status "Cancelado\Turma" abaixo.
                    Mapper.Map(ListaStatusMatricula, listaStatusMatricula);

                    if (matriculaOferta.StatusMatricula == enumStatusMatricula.CanceladoTurma)
                    {
                        var cancelado =
                            new ManterStatusMatricula().ObterStatusMatriculaPorID(
                                (int)enumStatusMatricula.CanceladoTurma);

                        listaStatusMatricula.Add(cancelado);

                        listaStatusMatricula = listaStatusMatricula.OrderBy(x => x.Nome).ToList();
                    }

                    // Caso o status atual não exista na lista de status disponíveis, insere ele na lista.
                    if (!listaStatusMatricula.Select(x => x.ID).Contains((int)matriculaOferta.StatusMatricula))
                    {
                        var statusAtual =
                            new ManterStatusMatricula().ObterStatusMatriculaPorID((int)matriculaOferta.StatusMatricula);

                        listaStatusMatricula.Add(statusAtual);

                        // Reordenar a lista.
                        listaStatusMatricula = listaStatusMatricula.OrderBy(x => x.Nome).ToList();
                    }

                    WebFormHelper.PreencherLista(listaStatusMatricula, ddlStatusOferta);

                    // Desabilitar a opção de cancelamento.
                    if (matriculaOferta.StatusMatricula == enumStatusMatricula.CanceladoTurma)
                    {
                        ddlStatusOferta.Items.FindByValue(((int)enumStatusMatricula.CanceladoTurma).ToString()).Attributes.Add("disabled", "disabled");
                    }

                    var idStatusMatricula = (int)matriculaOferta.StatusMatricula;

                    WebFormHelper.SetarValorNaCombo(idStatusMatricula.ToString(), ddlStatusOferta);
                }
            }
            else
            {
                ddlStatusOferta.Visible = false;

                if (statusOferta != null)
                {
                    statusOferta.Visible = true;
                    statusOferta.Text    = matriculaOferta.StatusMatriculaFormatado;
                }
            }
        }
        protected void ddlStatusOferta_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (InModoDeAvaliacao)
            {
                WebFormHelper.ExibirMensagem(enumTipoMensagem.Erro, "Não é possível alterar o Status desta matrícula diretamente. Ela precisa passar pela avaliação de um Consultor Educacional e ser aprovada por um Gestor.");
                return;
            }

            var comboStatusOferta = (DropDownList)sender;

            if (comboStatusOferta != null && comboStatusOferta.SelectedItem != null &&
                !string.IsNullOrWhiteSpace(comboStatusOferta.SelectedItem.Value))
            {
                try
                {
                    //Obtém a linha da grid onde a dropdownlist (combo) de oferta, está contida
                    var linhadaGrid = (GridViewRow)comboStatusOferta.NamingContainer;

                    if (linhadaGrid == null)
                    {
                        return;
                    }

                    var ddlStatusOferta = (DropDownList)linhadaGrid.FindControl("ddlStatusOferta");

                    if (ddlStatusOferta == null)
                    {
                        return;
                    }

                    var hdfIdMatriculaOferta  = (HiddenField)linhadaGrid.FindControl("hdfIdMatriculaOferta");
                    var manterMatriculaOferta = new ManterMatriculaOferta();
                    var ddlTurma = (DropDownList)linhadaGrid.FindControl("ddlTurma");

                    var statusMatriculaOferta = (enumStatusMatricula)Enum.Parse(typeof(enumStatusMatricula), ddlStatusOferta.SelectedItem.Value);

                    int IdMatriculaOferta;
                    classes.MatriculaOferta matriculaOferta = null;
                    if (int.TryParse(hdfIdMatriculaOferta.Value, out IdMatriculaOferta))
                    {
                        matriculaOferta = manterMatriculaOferta.ObterMatriculaOfertaPorID(IdMatriculaOferta);
                    }

                    var usuarioLogado  = new ManterUsuario().ObterUsuarioLogado();
                    var matriculaTurma = matriculaOferta.MatriculaTurma.FirstOrDefault();

                    if (statusMatriculaOferta.Equals(enumStatusMatricula.CanceladoGestor) && !usuarioLogado.IsGestor())
                    {
                        throw new AcademicoException("Apenas o gestor UC pode alterar para este perfil");
                    }

                    if (statusMatriculaOferta.Equals(enumStatusMatricula.CanceladoAdm) && !usuarioLogado.IsAdministrador())
                    {
                        throw new AcademicoException("Apenas o Administrador pode alterar para este perfil");
                    }

                    if (statusMatriculaOferta.Equals(enumStatusMatricula.Inscrito))
                    {
                        if (string.IsNullOrEmpty(ddlTurma.SelectedValue) || int.Parse(ddlTurma.SelectedValue) <= 0)
                        {
                            throw new AcademicoException("Selecione uma turma para alterar a inscrição");
                        }

                        try
                        {
                            new ManterSolucaoEducacional().ValidarPreRequisitosDaMatricula(matriculaOferta);
                        }
                        catch (Exception)
                        {
                            AtualizarStatusDaOferta(enumStatusMatricula.Inscrito, matriculaOferta, ref manterMatriculaOferta);
                            throw;
                        }
                    }

                    if (statusMatriculaOferta.Equals(enumStatusMatricula.CanceladoAluno))
                    {
                        //O usuário do admin, pode ver o status do Cancelado/Aluno, mas nunca pode setar esse status
                        WebFormHelper.ExibirMensagem(enumTipoMensagem.Atencao,
                                                     "Apenas o aluno pode atribuir o status de cancelado pelo aluno");
                    }
                    else
                    {
                        if (matriculaTurma == null)
                        {
                            WebFormHelper.ExibirMensagem(enumTipoMensagem.Erro, "O aluno precisa estar vinculado a uma turma.");
                            return;
                        }

                        if (matriculaOferta.StatusMatricula != enumStatusMatricula.Inscrito && statusMatriculaOferta == enumStatusMatricula.Inscrito)
                        {
                            ExibirModalConfirmacaoStatusInscrito(matriculaTurma);
                        }
                        else
                        {
                            ExibirModalDataConclusao(matriculaTurma, statusMatriculaOferta);
                        }
                    }

                    // Atualizar lista de status disponíveis, pois pode sofrer alteração caso haja
                    // o status de Cancelado\Turma, que possui um comportamento especial.
                    SetarListaComStatusDeMatricula(matriculaOferta);

                    // Trata a exibição da listagem de Status novamente, para manter os mesmos Status,
                    // com as mesmas formas.
                    TratarComboStatusOferta(ddlStatusOferta, matriculaOferta);
                }
                catch (AcademicoException ex)
                {
                    WebFormHelper.ExibirMensagem(enumTipoMensagem.Erro, ex.Message);
                }
                catch
                {
                    WebFormHelper.ExibirMensagem(enumTipoMensagem.Erro, "Erro Interno no servidor.");
                }
            }
        }