Example #1
0
        public ActionResult Comunicado(string id)
        {
            UsuarioDAO         dao   = new UsuarioDAO();
            SalaDAO            d     = new SalaDAO();
            ComunicadoDAO      dAO   = new ComunicadoDAO();
            Comunicado         comum = dAO.BuscaPorId(int.Parse(id));
            ComunicadoAlunoDAO c     = new ComunicadoAlunoDAO();


            Usuario usuario = dao.BuscaPorId((int)Session["usu"]);
            Sala    sala    = d.BuscaPorId(comum.CodSala);

            if (usuario.Cargo == 'A')
            {
                ComunicadoAluno aux = c.Busca(usuario.Id, comum.Id);
                aux.Visto = "S";
                c.Atualiza(aux);
            }
            Session["not"] = dAO.QtdPorUsuario(usuario.Id);

            ViewBag.Not        = Session["not"];
            ViewBag.Usu        = usuario;
            ViewBag.Sala       = sala;
            ViewBag.Professor  = dao.BuscaPorId(sala.CodProfessor);
            ViewBag.Comunicado = comum;
            ViewBag.Msg        = Session["msg"];
            Session["msg"]     = "";

            return(View());
        }
        public async Task <string> Alterar(long id, ComunicadoInserirDto comunicadoDto)
        {
            Comunicado comunicado = BuscarComunicado(id);

            ComunicadoInserirAeDto comunicadoServico = new ComunicadoInserirAeDto();

            var usuarioLogado = (await servicoUsuario.ObterUsuarioLogado())
                                ?? throw new NegocioException("Usuário logado não encontrado");

            await ValidarAbrangenciaUsuario(comunicadoDto, usuarioLogado);

            MapearAlteracao(comunicadoDto, comunicado);

            try
            {
                unitOfWork.IniciarTransacao();

                await repositorio.SalvarAsync(comunicado);

                MapearParaEntidadeServico(comunicadoServico, comunicado);

                await servicoAcompanhamentoEscolar.AlterarComunicado(comunicadoServico, id);

                unitOfWork.PersistirTransacao();
            }
            catch
            {
                unitOfWork.Rollback();
                throw;
            }

            return("Comunicado alterado com sucesso");
        }
    private void Salvar()
    {
        bool novo    = false;
        bool alterar = false;

        try
        {
            this.CarregarObjetos(Utilitarios.TipoTransacao.Salvar, gobjComunicado);

            if (hdnComunicadoId.Value == "0")
            {
                gobjComunicado = DoComunicado.Inserir(gobjComunicado);

                if (gobjComunicado.ID > 0)
                {
                    hdnComunicadoId.Value = gobjComunicado.ID.ToString();
                }

                novo = true;
            }
            else
            {
                if (DoComunicado.Alterar(gobjComunicado) > 0)
                {
                    alterar = true;
                }
            }

            Arquivos = (List <Arquivos>)Session["Arquivos"];

            foreach (Arquivos arq in Arquivos)
            {
                arq.TipoArquivoId = gobjComunicado.TipoComunicado.ID;

                if (arq.Inserir)
                {
                    DOModComunicado.RelacionarComunicadoArquivo(gobjComunicado.ID, arq.Id, System.DateTime.Now);
                }

                if (arq.Deletar)
                {
                    DOModComunicado.RemoverComunicadoArquivo(gobjComunicado.ID, arq.Id);
                }
            }

            if (novo)
            {
                Response.Redirect(string.Format("EditarComunicados.aspx?Comunicado={0}&sucesso=1", gobjComunicado.ID));
            }

            if (alterar)
            {
                Response.Redirect(string.Format("EditarComunicados.aspx?Comunicado={0}&sucesso=2", gobjComunicado.ID));
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
        public async Task <string> Handle(SolicitarAlteracaoComunicadoEscolaAquiCommand request, CancellationToken cancellationToken)
        {
            // TODO: Criar Query Handler para Obter comunicado
            Comunicado comunicado = BuscarComunicado(request.Id);

            ComunicadoInserirAeDto comunicadoServico = new ComunicadoInserirAeDto();

            var usuarioLogado = await _mediator.Send(new ObterUsuarioLogadoQuery());

            await ValidarAbrangenciaUsuario(request, usuarioLogado);

            MapearAlteracao(request, comunicado);

            try
            {
                _unitOfWork.IniciarTransacao();

                await _repositorioComunicado.SalvarAsync(comunicado);

                MapearParaEntidadeServico(comunicadoServico, comunicado);

                await _servicoAcompanhamentoEscolar.AlterarComunicado(comunicadoServico, request.Id);

                _unitOfWork.PersistirTransacao();
            }
            catch
            {
                _unitOfWork.Rollback();
                throw;
            }

            return("Comunicado alterado com sucesso");
        }
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            objUsuario = UsuarioLogado();

            if (objUsuario == null)
            {
                Response.Redirect("~/Default.aspx", true);
            }

            if ((Request.QueryString["Sucesso"] == "1"))
            {
                ((Modulos_Modulos)Master).ExibirMensagem(Resources.Textos.Mensagem_Salva_Sucesso);
            }
            else if ((Request.QueryString["Sucesso"] == "2"))
            {
                ((Modulos_Modulos)Master).ExibirMensagem(Resources.Textos.Mensagem_Atualizado_Sucesso);
            }

            comunicado            = Convert.ToInt32(Request.QueryString["comunicado"]);
            hdnComunicadoId.Value = comunicado.ToString();
            this.IniciaTela();
            CarregarObjetos(Utilitarios.TipoTransacao.Limpar);

            if (comunicado > 0)
            {
                gobjComunicado = DoComunicado.Obter(new Comunicado()
                {
                    ID = comunicado
                });
                CarregarObjetos(Utilitarios.TipoTransacao.Carregar, gobjComunicado);
            }
        }
    }
        public Comunicado Buscar(int id)
        {
            string strConexao = "SERVER=localhost; DataBase=condominio; UID=root; pwd=";

            using (MySqlConnection conn = new MySqlConnection(strConexao))
            {
                conn.Open();

                using (MySqlCommand cmd = new MySqlCommand())
                {
                    string query = $"SELECT * FROM comunicado c JOIN sindico s ON c.IdSindicoFkComunicado = s.IdSindico WHERE c.IdComunicado = {id}";

                    cmd.Connection  = conn;
                    cmd.CommandText = query;

                    MySqlDataReader reader = cmd.ExecuteReader();

                    Comunicado retorno = new Comunicado();

                    while (reader.Read())
                    {
                        retorno.IdComunicado          = (int)reader["IdComunicado"];
                        retorno.DataComunicado        = (DateTime)reader["DataComunicado"];
                        retorno.Titulo                = (string)reader["Titulo"];
                        retorno.Descricao             = (string)reader["Descricao"];
                        retorno.IdSindicoFkComunicado = (int)reader["IdSindicoFkComunicado"];
                    }

                    return(retorno);
                }
            }
        }
Example #7
0
        public Comunicado Buscar(int turma, int aluno)
        {
            try
            {
                Comunicado comunicado = null;

                DBSession session = new DBSession();
                Query     quey    = session.CreateQuery("select * from curso_comunicados where turma = @turma and aluno = @aluno order by ident desc");
                quey.SetParameter("turma", turma);
                quey.SetParameter("aluno", aluno);
                IDataReader reader = quey.ExecuteQuery();

                if (reader.Read())
                {
                    comunicado = new Comunicado(Convert.ToInt32(reader["ident"]), Convert.ToString(reader["turma"]), Convert.ToInt32(reader["aluno"]), Convert.ToInt32(reader["tipo"]), Convert.ToInt32(reader["novocurso"]), Convert.ToString(reader["dados"]));
                }
                reader.Close();
                session.Close();

                return(comunicado);
            }
            catch (Exception error)
            {
                throw error;
            }
        }
 private void Excluir()
 {
     try
     {
         var registroExcluido = false;
         try
         {
             foreach (GridViewRow item in grdDados.Rows)
             {
                 if (item.RowType == DataControlRowType.DataRow)
                 {
                     CheckBox chk = (CheckBox)item.FindControl("chkSeleciona");
                     if (chk.Checked)
                     {
                         try
                         {
                             var comunicado = new Comunicado()
                             {
                                 ID = int.Parse(item.Cells[1].Text)
                             };
                             if (DoComunicado.Excluir(comunicado) > 0)
                             {
                                 registroExcluido = true;
                             }
                             else
                             {
                                 registroExcluido = false;
                             }
                         }
                         catch (Exception ex)
                         {
                             if (ex.Message.IndexOf("conflicted", StringComparison.InvariantCultureIgnoreCase) > -1)
                             {
                                 ((Modulos_Modulos)Master).ExibirMensagem(Resources.Textos.Mensagem_Erro_FK); break;
                             }
                         }
                     }
                 }
             }
             if (registroExcluido)
             {
                 //((Modulos_Modulos)Master).ExibirMensagem(Resources.Textos.Mensagem_Exclusao_sucesso);
                 LerDados();
             }
             else
             {
                 //((Modulos_Modulos)Master).ExibirMensagem(Resources.Textos.Mensagem_Exclusao_Erro);
             }
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #9
0
 public static void Remove(Comunicado Comunicado)
 {
     using (var contexto = new SalaContext())
     {
         contexto.Remove(contexto.Comunicado.Single(a => a.Id == Comunicado.Id));
         contexto.SaveChanges();
     }
 }
Example #10
0
        private void mgListaComunicado_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            Comunicado          comunicado          = new Comunicado();
            ComunicadoComponent comunicadoComponent = new ComunicadoComponent();

            comunicado         = comunicadoComponent.ReadBy(int.Parse(mgListaComunicado.CurrentRow.Cells[0].Value.ToString()));
            txtColeccione.Text = comunicado.comunicado;
        }
Example #11
0
        public ActionResult DeleteConfirmed(int id)
        {
            Comunicado comunicado = db.Comunicados.Find(id);

            db.Comunicados.Remove(comunicado);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #12
0
 public void Atualiza(Comunicado Comunicado)
 {
     using (var contexto = new SalaContext())
     {
         contexto.Entry(Comunicado).State = EntityState.Modified;
         contexto.SaveChanges();
     }
 }
Example #13
0
 public void Adiciona(Comunicado comp)
 {
     using (var context = new SalaContext())
     {
         context.Comunicado.Add(comp);
         context.SaveChanges();
     }
 }
 private void MapearAlteracao(ComunicadoInserirDto comunicadoDto, Comunicado comunicado)
 {
     comunicado.Descricao        = comunicadoDto.Descricao;
     comunicado.Titulo           = comunicadoDto.Titulo;
     comunicado.DataExpiracao    = comunicadoDto.DataExpiracao;
     comunicado.TipoCalendarioId = comunicadoDto.TipoCalendarioId;
     comunicado.EventoId         = comunicadoDto.EventoId;
 }
Example #15
0
        public async Task Update(Comunicado entity)
        {
            if (!RunValidation(new ComunicadoValidation(), entity))
            {
                return;
            }

            await _dbComunicado.Update(entity);
        }
    public static List <Arquivo> Listar(Comunicado pObjComunicado)
    {
        try
        {
            string        strConectionString = ConfigurationManager.ConnectionStrings["BradescoRI"].ConnectionString;
            SqlConnection objConexao         = new SqlConnection(strConectionString);

            SqlCommand objComando = new SqlCommand("SPE_L_ARQUIVOS_COMUNICADO");
            objComando.Connection  = objConexao;
            objComando.CommandType = CommandType.StoredProcedure;

            if (pObjComunicado.ID > 0)
            {
                objComando.Parameters.Add("@ComunicadoId", SqlDbType.Int).Value = pObjComunicado.ID;
            }

            try
            {
                //Abre Conexao
                objConexao.Open();

                //Declara variavel de retorno
                List <Arquivo> objList = new List <Arquivo>();
                Arquivo        obj     = default(Arquivo);

                IDataReader idrReader = default(IDataReader);

                idrReader = objComando.ExecuteReader();

                while ((idrReader.Read()))
                {
                    obj = new Arquivo();
                    obj.FromIDataReader(idrReader);
                    objList.Add(obj);
                }

                return(objList);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                //Fecha a conexao se aberta
                if (objConexao.State != ConnectionState.Closed)
                {
                    objConexao.Close();
                }
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
Example #17
0
 private void metroButton1_Click(object sender, EventArgs e)
 {
     if (mgListaComunicado.Rows.Count != 0)
     {
         Comunicado          comunicado          = new Comunicado();
         ComunicadoComponent comunicadoComponent = new ComunicadoComponent();
         comunicado = comunicadoComponent.ReadBy(int.Parse(mgListaComunicado.CurrentRow.Cells[0].Value.ToString()));
         comunicadoComponent.Update(comunicado.Id);
         llenarGrilla();
     }
 }
Example #18
0
        /// <summary>
        /// evento disparado pelo botão pesquisar
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnPesquisar_Click(object sender, EventArgs e)
        {
            //verifica se as datas estão válidas e com intervalos corretos

            if (txtDataInicio.Text.Trim() == string.Empty)
            {
                pnlMensagem.ExibirMensagem("Preencha a data inicial");
            }
            else if (txtDataFim.Text.Trim() == string.Empty)
            {
                pnlMensagem.ExibirMensagem("Preencha a data final");
            }
            else if (!Utilities.IsValidDate(txtDataInicio.Text.Trim()))
            {
                pnlMensagem.ExibirMensagem("Data inicial inválida");
            }
            else if (!Utilities.IsValidDate(txtDataFim.Text.Trim()))
            {
                pnlMensagem.ExibirMensagem("Data final inválida");
            }
            else
            {
                DateTime dataInicial = DateTime.Parse(txtDataInicio.Text.Trim());
                DateTime dataFinal   = DateTime.Parse(txtDataFim.Text.Trim());
                if (dataInicial.Year < 1900 || dataInicial.Year > 2100)
                {
                    pnlMensagem.ExibirMensagem("Data inicial inválida");
                }
                else if (dataFinal.Year < 1900 || dataFinal.Year > 2100)
                {
                    pnlMensagem.ExibirMensagem("Data final inválida");
                }
                else if (dataInicial > dataFinal)
                {
                    pnlMensagem.ExibirMensagem("A data inicial não pode ser maior que a data final");
                }
                else
                {
                    //consulta os comunicados (atas)
                    var lista = Comunicado.ObterAtas(dataInicial, dataFinal);
                    //se a lista contém registros, atribui na grid
                    if (lista != null && lista.Count > 0)
                    {
                        grdAtas.DataSource = lista;
                        grdAtas.DataBind();
                        divConteudo.Visible = true;
                    }
                    else
                    {
                        divConteudo.Visible = false;
                    }
                }
            }
        }
Example #19
0
        // GET: Atividade
        public ActionResult Adiciona(Comunicado com, Atividade a, HttpPostedFileBase file)
        {
            try
            {
                a.Nome = com.Assunto;

                ComunicadoDAO       comunicadoDAO       = new ComunicadoDAO();
                ComunicadoAlunoDAO  comunicadoAlunoDAO  = new ComunicadoAlunoDAO();
                AtividadeDAO        atividadeDAO        = new AtividadeDAO();
                UsuarioAtividadeDAO usuarioAtividadeDAO = new UsuarioAtividadeDAO();

                if (file != null)
                {
                    byte[] arquivoBytes = new byte[file.InputStream.Length + 1];

                    file.InputStream.Read(arquivoBytes, 0, arquivoBytes.Length);
                    com.Arquivo     = arquivoBytes;
                    com.NomeArquivo = file.FileName;
                    com.TipoArquivo = file.ContentType;
                }

                atividadeDAO.Adiciona(a);
                comunicadoDAO.Adiciona(com);

                foreach (var A in (IList <Usuario>)Session["Alunos"])
                {
                    ComunicadoAluno c = new ComunicadoAluno
                    {
                        CodAluno      = A.Id,
                        CodComunicado = com.Id,
                        Visto         = "N"
                    };

                    UsuarioAtividade u = new UsuarioAtividade
                    {
                        CodUsuario   = A.Id,
                        CodAtividade = a.Id,
                        Nota         = 0,
                        Concluida    = "N",
                        Peso         = a.Peso
                    };

                    comunicadoAlunoDAO.Adiciona(c);
                    usuarioAtividadeDAO.Adiciona(u);
                }

                return(RedirectToAction("Sala", new RouteValueDictionary(new { controller = "Home", action = "Sala", id = com.CodSala })));
            }
            catch (Exception e)
            {
                Session["msg"] = "Erro: " + e.Message;
                return(Redirect(Request.UrlReferrer.ToString()));
            }
        }
Example #20
0
        public async Task <bool> Atualizar(Comunicado comunicado)
        {
            if (!ExecutarValidacao(new ComunicadoValidacao(), comunicado))
            {
                return(false);
            }

            await _comunicadoRepositorio.Atualizar(comunicado);

            return(true);
        }
Example #21
0
        public async Task <Comunicado> Add(Comunicado entity)
        {
            if (!RunValidation(new ComunicadoValidation(), entity))
            {
                return(null);
            }

            await _dbComunicado.Add(entity);

            return(entity);
        }
Example #22
0
        public JsonResult ComunicadoFinalizar(int tipo, int curso, string dados, string turma, int aluno)
        {
            Comunicado comunicado = new Comunicado();

            comunicado.turma     = turma;
            comunicado.aluno     = aluno;
            comunicado.tipo      = tipo;
            comunicado.novocurso = curso;
            comunicado.dados     = dados;
            comunicado.Salvar();
            string result = "Informações gravadas com sucesso";

            Aluno           al        = new AlunoDB().Buscar(aluno);
            Curso           cur       = new CursoDB().Buscar(curso);
            Curso           cur2      = new CursoDB().Buscar(Convert.ToInt32(turma));
            Curso_adiamento adiamento = new Curso_adiamentoDB().Ultimo(cur2);

            ContaEnvio  contaEnvio = new ContaEnvio(1, "Cenbrap", "*****@*****.**", "*****@*****.**", "databenq206");
            EnviarEmail e          = new EnviarEmail();
            string      para       = "*****@*****.**";
            string      assunto    = "Comunicado CENBRAP - Formulário de adiamento de turma";
            string      msg        = "";

            msg += "Comunicado CENBRAP - Envio automático do formulário de adiamento de turma<br><br>Prezado(a) Aluno(a);<br><br>A Coordenação Pedagógica do Cenbrap procederá à seguinte alteração no seu cadastro, conforme sua autorização descrita abaixo.<br><br><strong>";
            msg += "TURMA: " + cur2.titulo + " - " + cur2.titulo1;
            msg += "<br>ALUNO: " + al.nome;
            msg += "<br>E-MAIL: " + al.email;
            if (tipo == 1)
            {
                msg += "<br>OPÇÃO: Quero continuar";
                msg += "<br><span style='background-color: yellow;'>NOVA DATA PREVISTA: " + adiamento.para.ToShortDateString() + "</span>";
            }
            if (tipo == 2)
            {
                msg += "<br>OPÇÃO: Quero mudar de turma/curso";
                msg += "<br>NOVA TURMA: " + cur.titulo + " - " + cur.titulo1;
            }
            if (tipo == 3)
            {
                msg += "<br>OPÇÃO: Quero meu dinheiro de volta";
                msg += "<br>DADOS: " + dados;
            }
            if (tipo == 4)
            {
                msg += "<br>OPÇÃO: Quero converter minha matrícula em assinatura do Medtv por 18 meses";
            }
            msg += "</strong><br><Br>Qualquer dúvida, entre em contato conosco.<br>Att,<br>Márcia Barros<br>Assessoria de Comunicação";

            string r  = e.EnviaMensagemEmail(para, assunto, msg, 0, contaEnvio, false);
            string r2 = e.EnviaMensagemEmail(al.email, assunto, msg, 0, contaEnvio, false);

            return(Json(result));
        }
Example #23
0
        public static bool ComunicadoUpdate(ComunicadoViewModel entrada, out Comunicado comunicado)
        {
            comunicado = new Comunicado();

            //************ Objetos de controle de acesso *******************
            comunicado = entrada.comunicado;
            comunicado.modificadoEm      = DateTime.Now;
            comunicado.modificadoPor     = entrada.Contexto.idUsuario;
            comunicado.modificadoPorName = entrada.Contexto.nomeUsuario;
            //************ FIM Objetos de controle de acesso ***************
            return(true);
        }
        public ActionResult InserirComunicado(Comunicado registro)
        {
            if (!ModelState.IsValid)
            {
                return(View(registro));
            }

            ComunicadoController controller = new ComunicadoController();

            controller.Inserir(registro);
            return(RedirectToAction("ListarComunicado"));
        }
Example #25
0
        public void Update(Comunicado modelo)
        {
            db.Attach(modelo);
            db.Entry(modelo).Property("titulo").IsModified            = true;
            db.Entry(modelo).Property("dataInicio").IsModified        = true;
            db.Entry(modelo).Property("dataFim").IsModified           = true;
            db.Entry(modelo).Property("mensagem").IsModified          = true;
            db.Entry(modelo).Property("modificadoPor").IsModified     = true;
            db.Entry(modelo).Property("modificadoPorName").IsModified = true;
            db.Entry(modelo).Property("modificadoEm").IsModified      = true;

            db.SaveChanges();
        }
Example #26
0
        private void EnviarEmail(Comunicado comunicado)
        {
            string De      = db.Usuarios.FirstOrDefault(u => u.ID == comunicado.Usuario_de_ID).Nome;
            string Para    = db.Usuarios.FirstOrDefault(u => u.ID == comunicado.Usuario_para_ID).Nome;
            string Assunto = db.Assuntos.FirstOrDefault(u => u.ID == comunicado.AssuntoID).Tipo;

            Log("Comunicado enviado com sucesso em " + DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss"));
            Log("De: " + De);
            Log("Para: " + Para);
            Log("Assunto: " + Assunto);
            Log("Mensagem: " + comunicado.Mensagem);
            Log("-------------------------------------------");
        }
Example #27
0
        public async Task <IActionResult> Comunicado([FromBody] Comunicado comunicado)
        {
            var response = await _comunicacaoBusiness
                           .EnviarComunicadoAsync(
                new BaseRequest <Comunicado>(comunicado));

            if (!response.Success)
            {
                return(StatusCode(500, response.Message));
            }

            return(Ok());
        }
Example #28
0
        // GET: /Comunicado/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Comunicado comunicado = db.Comunicados.Find(id);

            if (comunicado == null)
            {
                return(HttpNotFound());
            }
            return(View(comunicado));
        }
Example #29
0
        public async Task <bool> Adicionar(Comunicado comunicado)
        {
            // Validar o Estado da Entidade
            var validar = ExecutarValidacao(new ComunicadoValidacao(), comunicado);

            if (!ExecutarValidacao(new ComunicadoValidacao(), comunicado))
            {
                return(false);
            }

            await _comunicadoRepositorio.Adicionar(comunicado);

            return(true);
        }
        private void MapearParaEntidade(ComunicadoInserirDto comunicadoDto, Comunicado comunicado)
        {
            comunicado.DataEnvio         = comunicadoDto.DataEnvio;
            comunicado.DataExpiracao     = comunicadoDto.DataExpiracao;
            comunicado.AlunoEspecificado = comunicadoDto.AlunosEspecificados;
            comunicado.Descricao         = comunicadoDto.Descricao;
            comunicado.Titulo            = comunicadoDto.Titulo;
            comunicado.AnoLetivo         = comunicadoDto.AnoLetivo;
            comunicado.TipoCalendarioId  = comunicadoDto.TipoCalendarioId;
            comunicado.EventoId          = comunicadoDto.EventoId;

            if (!comunicadoDto.CodigoDre.Equals("todas"))
            {
                comunicado.CodigoDre = comunicadoDto.CodigoDre;
            }

            if (!comunicadoDto.CodigoUe.Equals("todas"))
            {
                comunicado.CodigoUe = comunicadoDto.CodigoUe;
            }

            if (comunicadoDto.Turmas != null && comunicadoDto.Turmas.Any())
            {
                comunicadoDto.Turmas.ToList().ForEach(x => comunicado.AdicionarTurma(x));
            }

            if (comunicadoDto.Modalidade.HasValue)
            {
                comunicado.Modalidade = comunicadoDto.Modalidade;
            }

            if (comunicadoDto.GruposId.Any())
            {
                comunicado.Grupos = comunicadoDto.GruposId.Select(s => new ComunicadoGrupo {
                    Id = s
                }).ToList();
            }

            if (comunicadoDto.AlunosEspecificados)
            {
                comunicadoDto.Alunos.ToList().ForEach(x => comunicado.AdicionarAluno(x));
            }

            if (comunicadoDto.Semestre > 0)
            {
                comunicado.Semestre = comunicadoDto.Semestre;
            }

            comunicado.SetarTipoComunicado();
        }
 /// <summary>
 /// evento disparado pelo botão salvar
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected void btnSalvar_Click(object sender, EventArgs e)
 {
     try
     {
         //cria o objeto comunicado
         Comunicado comunicado = new Comunicado();
         //atribui os dados digitados na página
         comunicado.Titulo = txtTitulo.Text;
         comunicado.Texto = Editor1.Content;
         comunicado.Usuario = base.UsuarioLogado;
         //atribui o tipo do registro (Ata)
         comunicado.Tipo = Comunicado.TipoRegistro.AtaReuniao;
         //salva o registro
         comunicado.SaveAndFlush();
     }
     catch (Exception ex)
     {
         //grava a mensagem de erro no arquivo
         Logger.Error(ex.Message);
         base.ExibirMensagemErro();
     }
     base.ExibirMensagemSucesso(Funcionalidade.AtaDeReuniao, Operacao.Inclusao);
 }