public void Add(TurmaDTO turmaDto)
{
Turma turma = new Turma(turmaDto.Ano);
_turmaRepository.Add(turma);
_unitOfWork.Commit();
}
public PresencaTests()
{
Aula aula = ObjectMother.CriaUmaAula();
aula.Data = new DateTime(2000, 10, 5);
Turma turma = new Turma(2012);
presenca = new Presenca(aula, new Aluno("Marco Antônio", turma), "F");
}
public Turma criaTurma(String codigo, Disciplina disciplina, Professor professor, Periodo periodo, Turno turno)
{
Turma turma = new Turma();
turma.codigo = codigo;
turma.disciplina = disciplina;
turma.periodo = periodo;
turma.turno = turno;
turma.professor = professor;
return turma;
}
public Requisicao GetRequisicaoByAula(Turma turma, Entities.Calendario cal)
{
try
{
return dao.GetRequisicaoByTurma(turma, cal);
}
catch (DataAccessException )
{
throw;
}
}
public void associaTurmaAlunos(Turma turma, List<Aluno> alunos)
{
repositorio.context.turmas.Attach(turma);
foreach (Aluno aluno in alunos)
{
turma.alunos.Add(aluno);
}
repositorio.context.Entry(turma).State = EntityState.Modified;
repositorio.salva();
}
public void associaTurmaAvaliacoes(Turma turma, List<Avaliacao> avaliacoes)
{
repositorio.context.turmas.Attach(turma);
foreach (Avaliacao avaliacao in avaliacoes)
{
turma.avaliacoes.Add(avaliacao);
}
repositorio.context.Entry(turma).State = EntityState.Modified;
repositorio.salva();
}
public static void Salvar(TurmaView turma)
{
using (var context = new DatabaseEntities())
{
var item = new Turma()
{
Descricao = turma.Descricao,
DataCriacao = turma.DataCriacao,
Nome = turma.Nome,
IdEstado = 1,
};
context.Turma.Add(item);
context.SaveChanges();
}
}
public void AtualizaTurma(Turma turma)
{
DbCommand cmd = baseDados.GetStoredProcCommand("TurmasUpdate");
baseDados.AddInParameter(cmd, "@TurmaId", DbType.Guid, turma.Id);
baseDados.AddInParameter(cmd, "@Numero", DbType.Int32, turma.Numero);
baseDados.AddInParameter(cmd, "@CalendarioId", DbType.Guid, turma.Calendario.Id);
baseDados.AddInParameter(cmd, "@DisciplinaCod", DbType.String, turma.Disciplina.Cod);
baseDados.AddInParameter(cmd, "@DataHora", DbType.String, turma.DataHora);
baseDados.AddInParameter(cmd, "@ProfessorId", DbType.Guid, turma.Professor.Id);
baseDados.AddInParameter(cmd, "@Curso", DbType.String, turma.Curso.Codigo);
try
{
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public async Task <IComandoResultado> ManipuladorAsync(CriarAgendaTurmaComando comando)
{
//Criar Entidades
var sala = new Sala(comando.IdSala);
var diaSemana = new DiaSemana(comando.IdDiaSemana);
var turma = new Turma(comando.IdTurma);
var agenda = new Agenda(comando.Id, comando.Hora, turma, diaSemana, sala);
//verificar turma existente
if (await _repositorio.CheckAgendamentoAsync(agenda))
{
AddNotification("Turma", "Já existe um agendamento cadastrado para os dados informado");
}
//Validar Comando
comando.Valido();
AddNotifications(diaSemana.Notifications);
AddNotifications(turma.Notifications);
AddNotifications(agenda.Notifications);
if (Invalid)
{
return(new ComandoResultado(
false,
"Por favor, corrija os campos abaixo",
Notifications));
}
//Persistir os dados
await _repositorio.SalvarAsync(agenda);
// Retornar o resultado para tela
return(new ComandoResultado(true, "Turma agendada com sucesso", new
{
Id = 0,
Nome = "",
Status = true
}));
}
public async Task <IActionResult> Create([Bind("Id", "IdCurso", "Modulo", "Sigla", "Ano", "Semestre")] Turma turma)
{
try
{
if (ModelState.IsValid)
{
_context.Add(turma);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
var cursos = _context.Cursos.OrderBy(i => i.Nome).ToList();
cursos.Insert(0, new Curso()
{
Id = 0, Nome = "Selecione o Curso"
});
ViewBag.Cursos = cursos;
ViewBag.Semestre = new[]
{
new SelectListItem()
{
Value = "", Text = "Selecione o Semestre"
},
new SelectListItem()
{
Value = "Primeiro", Text = "Primeiro"
},
new SelectListItem()
{
Value = "Segundo", Text = "Segundo"
}
};
return(View(turma));
}
public void CadastrarTurma()
{
try
{
Console.WriteLine("\n CADASTRO DA TURMA");
var turma = new Turma();
Console.WriteLine("\n Por favor, informe o nome da turma");
turma.Nome = Console.ReadLine();
Console.WriteLine("\nPor favor, informe a data de inicio da turma");
turma.DataInicio = DateTime.Parse(Console.ReadLine());
Console.WriteLine("\nPor favor, Informe a data do fim da turma");
turma.DataFim = DateTime.Parse(Console.ReadLine());
var turmaRepository = new TurmaRepository();
turmaRepository.ConnectionString = connectionString;
turmaRepository.Inserir(turma);
Console.WriteLine("\n TURMA CADASTRADA COM SUCESSO!");
}
catch (SqlException e)
{
Console.WriteLine("\n CADASTRO NÃO REALIZADO!");
Console.WriteLine("\nCÓDIGO DO ERRO: " + e.Number);
if (e.Number == 8152)
{
Console.WriteLine("\n LIMITE DE CARACTERES EXCEDIDO.");
}
}
catch (Exception e)
{
Console.WriteLine("\nERRO: " + e.Message);
}
}
private void carregarAlunos(Aluno aln)
{
try
{
comboBox3.Items.Clear();
Aluno aluno = new Aluno();
Turma t = new Turma();
t.CodigoTurma = 0;
aluno.Turma = t;
aluno.Matricula = "";
aluno.Nome = "";
listaAlunos = servico.ListarAluno(aln).ToList();
foreach (Aluno a in listaAlunos)
{
comboBox3.Items.Add(a.Nome);
}
}catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private async Task <IEnumerable <DisciplinaDto> > ObterComponentesTurma(Turma turma)
{
var componentesTurma = new List <DisciplinaDto>();
var componentesCurriculares = await consultasDisciplina.ObterDisciplinasPorTurma(turma.CodigoTurma, false);
if (componentesCurriculares == null)
{
throw new NegocioException("Não localizado disciplinas para a turma no EOL!");
}
componentesTurma.AddRange(componentesCurriculares.Where(c => !c.Regencia));
foreach (var componenteCurricular in componentesCurriculares.Where(c => c.Regencia))
{
// Adiciona lista de componentes relacionados a regencia
componentesTurma.AddRange(
consultasDisciplina.MapearParaDto(
await consultasDisciplina.ObterComponentesRegencia(turma, componenteCurricular.CodigoComponenteCurricular)));
}
return(componentesTurma);
}
public ActionResult AdicionarNovaTurma(Turma nova, int[] idDisciplina, int[] idProfessor)
{
TempData["Message"] = new MTurma().Add(nova) ? "Nova Turma Cadastrada" : "Algo Errado Ocorreu";
MAula mAula = new MAula();
for (int i = 0; i < idDisciplina.Length; i++)
{
Aula aula = new Aula();
aula.idDisciplina = idDisciplina[i];
aula.idProfessor = idProfessor[i];
aula.idTurma = nova.idTurma;
mAula.Add(aula);
}
//GerenciarMedViewModel dados = new GerenciarMedViewModel();
/*dados.problemasCadastrados = new MProblemaXMed().RetornaProblemasCadastrados((int)nova.idMed);
* dados.turmasCadastradas = new MTurma().Bring(c => c.idMed == nova.idMed);
* dados.med = new MMed().BringOne(c => c.idMed == nova.idMed);*/
return(RedirectToAction("GerenciarMed", new { id = nova.idMed }));
}
public void InsereTurma(Turma turma)
{
DbCommand cmd = baseDados.GetStoredProcCommand("TurmasInsere");
baseDados.AddInParameter(cmd, "@TurmaId", DbType.Guid, turma.Id);
baseDados.AddInParameter(cmd, "@Numero", DbType.Int32, turma.Numero);
baseDados.AddInParameter(cmd, "@CalendarioId", DbType.Guid, turma.Calendario.Id);
baseDados.AddInParameter(cmd, "@DisciplinaCod", DbType.String, turma.Disciplina.Cod);
baseDados.AddInParameter(cmd, "@DataHora", DbType.String, turma.DataHora);
baseDados.AddInParameter(cmd, "@ProfessorId", DbType.Guid, turma.Professor.Id);
baseDados.AddInParameter(cmd, "@Curso", DbType.String, turma.Curso.Codigo);
baseDados.AddInParameter(cmd, "@Sala", DbType.String, turma.Sala);
try
{
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public void Seed()
{
if (_context.Turma.Any() || _context.Aluno.Any() || _context.Comprovante.Any() || _context.TipoComprovante.Any())
{
return;
}
Turma t1 = new Turma(1, "Sistemas de Informação");
Aluno a1 = new Aluno(19157001, "Joao", t1);
TipoComprovante tc1 = new TipoComprovante(1, "Palestra");
Comprovante c1 = new Comprovante(1, "Palestra IoT", new DateTime(2020, 10, 18), new DateTime(2020, 10, 18), 3, a1, tc1);
_context.Turma.Add(t1);
_context.Aluno.Add(a1);
_context.TipoComprovante.Add(tc1);
_context.Comprovante.Add(c1);
_context.SaveChanges();
}
public void Atualizar(Turma objEntrada)
{
if (String.IsNullOrEmpty(objEntrada.Nome))
{
throw new ConsistenciaException("Por favor, digite o nome da Turma.");
}
MySqlCommand cmd = new MySqlCommand(@"update turma
set Nome = @Nome
where idTurma = @idTurma
");
cmd.Parameters.Add(new MySqlParameter("Nome", objEntrada.Nome));
cmd.Parameters.Add(new MySqlParameter("idTurma", objEntrada.idTurma));
Conexao c = new Conexao();
c.Abrir();
c.Executar(cmd);
c.Fechar();
}
private void CarregaTurmas()
{
ddlTurma.Items.Clear();
ListItem itemDefault = new ListItem("(--Selecione--)", "0");
itemDefault.Selected = true;
ddlTurma.Items.Add(itemDefault);
if (ddlAnoLetivo.Text != "")
{
IList <Turma> lista = new Turma().SelecionarPorAnoLetivo(Convert.ToInt32(ddlAnoLetivo.Text));
foreach (Turma turma in lista)
{
ListItem item = new ListItem();
item.Value = turma.Codigo.ToString();
item.Text = turma.ToString();
item.Selected = false;
ddlTurma.Items.Add(item);
}
}
ddlTurma.DataBind();
}
public ICommandResult Handle(AdicionarTurmaCommand command)
{
command.Validar();
if (!command.IsValid)
{
return(new GenericCommandResult(false, "Dados inválidos!", command.Notifications));
}
var instituicao = InstituicaoRepositorio.Buscar(command.IdInstituicao);
if (instituicao.Turmas.Find(t => t.Nome == command.Nome) != null)
{
return(new GenericCommandResult(false, "Essa instituição já tem uma turma com esse nome. Escolha outro!", command.Nome));
}
var turma = new Turma(command.Nome, instituicao.Id);
TurmaRepositorio.Adicionar(turma);
return(new GenericCommandResult(true, "Turma cadastrada com sucesso!", command.Nome));
}
private void button1_Click(object sender, EventArgs e)
{
try
{
Turma turma = new Turma();
turma.IdTurma = listaT.ElementAt(comboidturma.SelectedIndex).IdTurma;
turma.IdTurmaNova = Convert.ToInt32(tbidnova.Text);
turma.NomeTurma = tbturma.Text;
turma.TurnoTurma = comboturno.Text;
fachada.atualizarTurma(turma);
RepositorioTurma r = new RepositorioTurma();
if (r.verificausuario == false)
{
MessageBox.Show("Turma Alterado com Sucesso");
}
}
catch (Exception ex)
{
MessageBox.Show("Erro na Atualização da Turma" + ex + "");
}
}
public IActionResult Atualizar([FromForm] Turma turma)
{
if (ModelState.IsValid)
{
_turmaAppService.AtualizarTurma(turma);
TempData["MSG_SUCESSO"] = $"{turma.Descricao} atualizada com sucesso!";
return(RedirectToAction(nameof(Turma)));
}
ViewBag.Serie = new SelectList(Enum.GetValues(typeof(eSerie)), turma.Serie);
ViewBag.Turno = new SelectList(Enum.GetValues(typeof(eTurno)), turma.Turno);
turma.EscolaTurma = _escolaAppService.GetEscola(turma.EscolaId);
turma.EscolaId = _escolaAppService.GetEscola(turma.EscolaId).Id;
ViewBag.Alunos = _alunoAppService.GetAlunosPorTurma(turma.Id);
return(View(turma));
}
public async Task <IEnumerable <ComponenteCurricularPorTurma> > Handle(ObterComponentesCurricularesRegenciaQuery request, CancellationToken cancellationToken)
{
Turma turma = request.Turma;
if (request.Usuario.EhProfessorCj())
{
return(await ObterComponentesCJ(turma.ModalidadeCodigo, turma.Codigo, turma.Ue.Codigo, request.CdComponenteCurricular, request.Usuario.CodigoRf));
}
else
{
var componentesCurriculares = await mediator.Send(new
ObterComponentesCurricularesPorCodigoTurmaLoginEPerfilQuery()
{
CodigoTurma = turma.Codigo,
Usuario = request.Usuario
});
return(componentesCurriculares.Where(c => c.Regencia));
}
}
public async Task Create(Turma turma)
{
try
{
using (var connection = CreateOracleConnection())
{
var parametros = new {
id = Guid.NewGuid().ToString(),
serie = turma.Serie,
ano = turma.Ano
};
await connection.QueryAsync(@"INSERT INTO RM83652.TURMA (ID, SERIE, ANO)
VALUES(:id, :serie, :ano)", parametros);
}
}
catch (Exception ex)
{
throw new Exception("Erro durante a criação da turma", ex);
}
}
// método get de mátricula, relaciona a turma e retorna o conjunto de alunos
// para ser associados à turma através de uma ViewModel
public ActionResult MatricularViaSala(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MeuContexto contexto = new MeuContexto();
Turma turma = contexto.Turmas.Find(id);
if (turma == null)
{
return(HttpNotFound());
}
var model = new MatriculaViaTurmaViewModel();
model.alunosParaMatricular = contexto.Alunos.ToList();
model.turma = turma;
return(View(model));
}
/// <summary>
/// Altera um usuario
/// </summary>
/// <param name="usuario">Objeto a ser alterado</param>
public void Editar(Turma turma)
{
try
{
Turma turmaEdit = BuscarPorId(turma.IdTurma);
if (turmaEdit == null)
{
throw new Exception("Usuario nao encontrad");
}
turmaEdit.Descricao = turma.Descricao;
_context.Turmas.Update(turmaEdit);
_context.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Index()
{
if (_serviceUsuario.ValidaUsuarioNoCache())
{
var model = new Turma
{
ListaUnidade = dAOTurma.ReturnTurmaUnidadesLista(),
ListaModalidade = dAOTurma.ReturnTurmaModalidadesLista(),
ListaColaborador = dAOTurma.ReturnTurmaColaboradorLista(),
ListaTurma = dAOTurma.ReturnTurmaLista(),
DiasDaSemana = Enum.GetValues(typeof(EnumDays.DaysOfWeek)),
TipoClientes = Enum.GetValues(typeof(EnumClients.Clients))
};
return(View(model));
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public IActionResult Put(int id, Turma turma)
{
try
{
var turmaTemp = _turmaRepository.BuscarID(id);
if (turmaTemp == null)
{
return(NotFound());
}
turma.IdTurma = id;
_turmaRepository.Editar(turma);
return(Ok(turma));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void validarAtualizarTurma(Turma turma)
{
if (turma.IdTurma <= 0)
{
throw new Exception("Campo da ID Turma Inválido para Alterar");
}
if (turma.IdTurmaNova <= 0)
{
throw new Exception("Campo da ID Nova Turma Inválido para Alterar");
}
if (turma.NomeTurma == null || turma.NomeTurma.Trim().Equals(""))
{
throw new Exception("Campo do Nome Turma Inválido para Alterar");
}
if (turma.TurnoTurma == null || turma.TurnoTurma.Trim().Equals(""))
{
throw new Exception("Campo Turno da Turma Inválido para Alterar");
}
this.repositorioTurma.VerificaturmaExistenteatualizar(turma);
}
public void Editar(Turma turma)
{
try
{
Turma turmaTemp = BuscarPorId(turma.IdTurma);
if (turmaTemp == null)
{
throw new Exception("Turma não encontrada");
}
turmaTemp.IdUsuario = turma.IdUsuario;
_ctx.Turmas.Update(turmaTemp);
_ctx.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private void button4_Click(object sender, EventArgs e)
{
List <Disciplina_Turma> listaDT;
try
{
Aluno aluno = new Aluno();
Disciplina_Turma dt = new Disciplina_Turma();
Avaliacao avaliacao = new Avaliacao();
Disciplina disc = new Disciplina();
Turma t = new Turma();
int indexA = comboBox3.SelectedIndex;
int indexT = comboBoxTurma.SelectedIndex;
aluno.Matricula = listaAlunos[indexA].Matricula;
avaliacao.Nota = Double.Parse(textBox1.Text);
int indexD = comboBox2.SelectedIndex;
avaliacao.Descricao = comboBox2.Items[indexD].ToString();
avaliacao.Aluno = aluno;
t.CodigoTurma = listaTurmas[indexT - 1].CodigoTurma;
dt.Turma = t;
int indexDisc = comboBox1.SelectedIndex;
disc = listaDisciplinas[indexDisc].Disciplina;
dt.Disciplina = disc;
listaDT = servico.ListarDisciplinaTurma(dt).ToList();
dt.CodigoDisciplinaTurma = listaDT[0].CodigoDisciplinaTurma;
avaliacao.Disciplina_turma = dt;
servico.InserirAvaliacao(avaliacao);
comboBox2.Items.Clear();
comboBox3.Items.Clear();
comboBox1.Items.Clear();
comboBoxTurma.Items.Clear();
textBox1.Clear();
MessageBox.Show("Nota inserida.");
this.Dispose();
}catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public List <Aluno> Listar(Aluno objEntrada)
{
MySqlCommand cmd = null;
cmd = new MySqlCommand(@"
select aluno.idAluno,
aluno.Nome,
aluno.Matricula,
turma.Nome
from aluno
inner join turma
on turma.idTurma = aluno.idTurma");
cmd.Parameters.Add(new MySqlParameter("Matricula", objEntrada.Matricula));
Conexao c = new Conexao();
c.Abrir();
MySqlDataReader reader = c.Pesquisar(cmd);
List <Aluno> lstRetorno = new List <Aluno>();
while (reader.Read())
{
Aluno aluno = new Aluno();
Turma turma = new Turma();
aluno.idAluno = reader.GetInt32(0);
aluno.Nome = reader.GetString(1);
aluno.Matricula = reader.GetInt32(2);
turma.Nome = reader.GetString(3);
aluno.idTurma = turma;
lstRetorno.Add(aluno);
}
c.Fechar();
return(lstRetorno);
}
public bool alterar(Turma p_objTurma)
{
if (p_objTurma.codigo == string.Empty)
{
throw new Exception("Campo codigo obrigatorio");
}
if (p_objTurma.turno == string.Empty)
{
throw new Exception("Campo turno obrigatorio");
}
if (p_objTurma.qntDeAlunos == int.MinValue)
{
throw new Exception("Campo quantidade de alunos obrigatorio");
}
if (p_objTurma.idCurso == int.MinValue)
{
throw new Exception("Campo curso obrigatorio");
}
if (p_objTurma.dataInicio == DateTime.MinValue)
{
throw new Exception("Campo data inicio obrigatorio");
}
if (p_objTurma.dataFim == DateTime.MinValue)
{
throw new Exception("Campo data fim obrigatorio");
}
if (p_objTurma.diaDaSemana == string.Empty)
{
throw new Exception("Campo turno obrigatorio");
}
BDTurma objDados = new BDTurma();
return(objDados.Alterar(p_objTurma));
}
public async Task Should_Modify_Entity_With_Valid_Data()
{
var ctx = new Mock <AppContext>();
var entity = new Turma
{
Id = 1,
Nome = "Turma Teste 1",
QtdAlunos = 10,
EscolaId = 1
};
var repository = new Mock <TurmaRepository>(ctx.Object);
repository.Setup(repo => repo
.UpdateAsync(1, It.IsAny <SaveTurmaDTO>()))
.Callback <int, SaveTurmaDTO>((b, c) =>
{
entity = new Turma
{
Id = 1,
Nome = c.Nome,
QtdAlunos = c.QtdAlunos,
EscolaId = c.EscolaId
};
});
var unitOfWork = new Mock <UnitOfWork>(ctx.Object);
unitOfWork.Setup(uow => uow.Turmas).Returns(repository.Object);
await unitOfWork.Object.Turmas.UpdateAsync(1, new SaveTurmaDTO
{
Nome = "Turma Teste Alterado",
QtdAlunos = 10,
EscolaId = 1
});
Assert.AreEqual("Turma Teste Alterado", entity.Nome);
}
public void CarregarListView()
{
try
{
listViewAluno.Items.Clear();
Aluno alunoFiltro = new Aluno();
// MATRÍCULA ALUNO
alunoFiltro.Matricula = textBoxMatricula.Text;
// DESCRIÇÃO TIPO DE USUÁRIO
alunoFiltro.Nome = textBoxNome.Text;
Turma t = new Turma();
t.CodigoTurma = 0;
alunoFiltro.Turma = t;
listaAluno = servico.ListarAluno(alunoFiltro).ToList();
if (listaAluno.Count > 0)
{
foreach (Aluno aluno in listaAluno)
{
ListViewItem linha = listViewAluno.Items.Add(aluno.Matricula);
linha.SubItems.Add(aluno.Nome);
linha.SubItems.Add(aluno.DataNasc.ToShortDateString());
linha.SubItems.Add(aluno.Sexo);
linha.SubItems.Add(aluno.Telefone);
linha.SubItems.Add(aluno.Turma.DescricaoTurma);
}
}
else
{
MessageBox.Show("Sem resultados.");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnCadastrar_Click(object sender, EventArgs e)
{
Turma turma = new Turma();
MySqlDataReader reader = turma.Listar();
//SE READER FOR DIFERENTE DE NULO
if (reader.HasRows)
{
dataGridViewTurma.Rows.Clear();
while (reader.Read())
{
{
int n = dataGridViewTurma.Rows.Add();
dataGridViewTurma.Rows[n].Cells["columnId"].Value = reader["idTurma"];
dataGridViewTurma.Rows[n].Cells["columnTurma"].Value = reader["nomeTurma"];
dataGridViewTurma.Rows[n].Cells["columnCurso"].Value = reader["nomeCurso"];
dataGridViewTurma.Rows[n].Cells["columnTurno"].Value = reader["turno"];
}
}
}
}
public async Task <IActionResult> PutTurma(Turma turma)
{
_context.Entry(turma).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TurmaExists(turma.IdTurma))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private FrequenciaDto ObterRegistroFrequencia(long aulaId, Aula aula, Turma turma)
{
var registroFrequencia = servicoFrequencia.ObterRegistroFrequenciaPorAulaId(aulaId);
if (registroFrequencia == null)
{
registroFrequencia = new RegistroFrequencia(aula);
}
var registroFrequenciaDto = new FrequenciaDto(aulaId)
{
AlteradoEm = registroFrequencia.AlteradoEm,
AlteradoPor = registroFrequencia.AlteradoPor,
AlteradoRF = registroFrequencia.AlteradoRF,
CriadoEm = registroFrequencia.CriadoEm,
CriadoPor = registroFrequencia.CriadoPor,
CriadoRF = registroFrequencia.CriadoRF,
Id = registroFrequencia.Id,
Desabilitado = !aula.PermiteRegistroFrequencia(turma)
};
return(registroFrequenciaDto);
}
//deleta uma turma
public void Remover(Guid id)
{
try
{
//busca uma turma pelo id
Turma turmaTemp = BuscarPorId(id);
//verifica se a turma existe no sistema, caso nao exista gera um exception
if (turmaTemp == null)
{
throw new Exception("A Turma inserida não foi encontrada no sistema. Verifique se foi digitado da maneira correta e tente novamente.");
}
//remove turma no contexto atual
_ctx.Turma.Remove(turmaTemp);
//salva as alteraçoes
_ctx.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Alterar(Turma turma)
{
try
{
Turma turmaAux = new Turma();
turmaAux.ID = turma.ID;
List<Turma> resultado = this.Consultar(turmaAux, TipoPesquisa.E);
if (resultado == null || resultado.Count == 0)
throw new TurmaNaoAlteradaExcecao();
turmaAux = resultado[0];
turmaAux.Nome = turma.Nome;
turmaAux.Status = turma.Status;
Confirmar();
}
catch (Exception)
{
throw new TurmaNaoAlteradaExcecao();
}
}
public ICollection<Nota> consultarNotasAlunoTurma(Aluno alunoParam, Turma turmaParam)
{
return repositorio.consultarNotasAlunoTurma(alunoParam, turmaParam);
}
public List<Turma> Consultar(Turma turma, TipoPesquisa tipoPesquisa)
{
List<Turma> resultado = Consultar();
switch (tipoPesquisa)
{
#region Case E
case TipoPesquisa.E:
{
if (turma.ID != 0)
{
resultado = ((from t in resultado
where
t.ID == turma.ID
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (!string.IsNullOrEmpty(turma.Nome))
{
resultado = ((from t in resultado
where
t.Nome.Contains(turma.Nome)
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (turma.Status.HasValue)
{
resultado = ((from t in resultado
where
t.Status.HasValue && t.Status.Value == turma.Status.Value
select t).ToList());
resultado = resultado.Distinct().ToList();
}
break;
}
#endregion
#region Case Ou
case TipoPesquisa.Ou:
{
if (turma.ID != 0)
{
resultado.AddRange((from t in Consultar()
where
t.ID == turma.ID
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (!string.IsNullOrEmpty(turma.Nome))
{
resultado.AddRange((from t in Consultar()
where
t.Nome.Contains(turma.Nome)
select t).ToList());
resultado = resultado.Distinct().ToList();
}
if (turma.Status.HasValue)
{
resultado.AddRange((from t in Consultar()
where
t.Status.HasValue && t.Status.Value == turma.Status.Value
select t).ToList());
resultado = resultado.Distinct().ToList();
}
break;
}
#endregion
default:
break;
}
return resultado;
}
public void Incluir(Turma turma)
{
try
{
db.Turma.InsertOnSubmit(turma);
}
catch (Exception)
{
throw new TurmaNaoIncluidaExcecao();
}
}
public void Excluir(Turma turma)
{
try
{
Turma turmaAux = new Turma();
turmaAux.ID = turma.ID;
List<Turma> resultado = this.Consultar(turmaAux, TipoPesquisa.E);
if (resultado == null || resultado.Count == 0)
throw new TurmaNaoExcluidaExcecao();
turmaAux = resultado[0];
db.Turma.DeleteOnSubmit(turmaAux);
}
catch (Exception)
{
throw new TurmaNaoExcluidaExcecao();
}
}
public void InsereTurma(Turma turma, Calendario cal)
{
InsereTurma(turma);
ConfigBO configuracoes = new ConfigBO();
if (configuracoes.IsAulasDistribuidas(cal))
{
AulaBO controleAulas = new AulaBO();
controleAulas.CriarAulas(cal,turma);
}
}
public void CriarAulas(Calendario cal, Turma t)
{
try
{
//ordena lista da datas
cal.Datas.Sort();
//Recebe a lista das turmas
TurmaBO contadorroleTurmas = new TurmaBO();
IList<Entities.Turma> listaTurmas = contadorroleTurmas.GetTurmas(cal);
Util.DataHelper dheper = new BusinessData.Util.DataHelper();
//Recebe a lista das atividades
CategoriaAtividadeBO contadorroleAtividades = new CategoriaAtividadeBO();
IList<CategoriaAtividade> listaAtividades = contadorroleAtividades.GetCategoriaAtividade();
if (listaAtividades.Count == 0)
{
throw new IndexOutOfRangeException();
}
CategoriaAtividade cat = listaAtividades[0];
foreach (CategoriaAtividade categoria in listaAtividades)
{
if (categoria.Descricao.Equals("Aula"))
cat = categoria;
}
AulaBO contadorroleAulas = new AulaBO();
Aula aulaAux;
string horario = t.DataHora;
//dado um horario pucrs(2ab,4cd), exclui os horarios e guarda os dias em array de inteiros
string diasPucrs = Regex.Replace(horario, "[a-zA-Z]", String.Empty);
int tamanho = diasPucrs.Length;
int[] dias = new int[tamanho];
for (int i = 0; i < tamanho; i++)
{
dias[i] = Convert.ToInt32(diasPucrs.Substring(i, 1));
}
string[] horariosPucrs = horario.Split(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }, StringSplitOptions.RemoveEmptyEntries);
DateTime aux = cal.InicioG1;
while (aux <= cal.FimG2)
{
for (int i = 0; i < dias.Length; i++)
{
if ((int)(aux.DayOfWeek) == (dias[i] - 1))
{
aulaAux = Aula.newAula(t, horariosPucrs[i], aux, string.Empty, cat);
this.InsereAula(aulaAux);
}
}
aux = aux.AddDays(1);
}
}
catch (DataAccessException ex)
{
throw ex;
}
}
public ICollection<Nota> consultarNotasTurma(Turma turmaParam)
{
return repositorio.consultarNotasTurma(turmaParam);
}
public void UpdateTurma(Turma turma)
{
if (usr.IsAdmin())
{
try
{
dao.AtualizaTurma(turma);
//MembershipUser user = Membership.GetUser();
//LogEntry log = new LogEntry();
//log.Message = "Turma: " + turma.Numero + "; Disciplina: " + turma.Disciplina + "; Semestre: " + turma.Calendario.Ano + "/" + turma.Calendario.Semestre + "; Id: "+ turma.Id +"; Administrador: " + user.UserName;
//log.TimeStamp = DateTime.Now;
//log.Severity = TraceEventType.Information;
//log.Title = "Update Turma";
//log.MachineName = Dns.GetHostName();
//Logger.Write(log);
}
catch (DataAccess.DataAccessException )
{
throw;
}
}
else
{
throw new SecurityException("Acesso Negado.");
}
}
private Turma MockTurma()
{
Turma turma = new Turma();
turma.turmaId = 1;
turma.codigo = "turma0";
turma.turmaId = 1;
turma.periodoId = 1;
turma.periodo = MockPeriodo();
turma.professorId = 1;
turma.disciplinaId = 1;
turma.disciplina = MockDisciplina();
return turma;
}