public void AtribuirPontosParaResposta(AtribuirNotaRequest request, Usuario usuarioLogado)
{
Resposta resposta = _respostaRepository.GetById(request.IdResposta);
if (resposta == null)
{
throw new Exception("Resposta não encontrada.");
}
int idCase = (from r in _respostaRepository.Queryable()
join e in _entregaDeLicaoRepository.Queryable() on r.IdEntregaDeLicao equals e.Id
join l in _licaoRepository.Queryable() on e.IdLicao equals l.Id
where r.Id == request.IdResposta
select l.IdCase).FirstOrDefault();
CaseDeNegocio caseDeNegocio = _caseDeNegocioService.ObterPorId(idCase);
if (!_caseDeNegocioService.UsuarioEstaAssociadoAoCaseDeNegocioComoProfessor(usuarioLogado, caseDeNegocio))
{
throw new Exception("Usuário não possui permissão para atribuir notas.");
}
resposta.PontosGanhos = request.Pontos;
_respostaRepository.Update(resposta);
}
public int Adicionar(TrofeuDTO trofeuDTO, Usuario usuarioLogado)
{
if (trofeuDTO == null || trofeuDTO.Id > 0)
{
throw new Exception("Solicitação inválida.");
}
CaseDeNegocio caseDeNegocio = _caseDeNegocioService.ObterPorId(trofeuDTO.IdCase);
if (caseDeNegocio == null)
{
throw new Exception("Case de negócio não encontrado.");
}
if (!_caseDeNegocioService.UsuarioEstaAssociadoAoCaseDeNegocioComoProfessor(usuarioLogado, caseDeNegocio))
{
throw new Exception("Usuário não possui permissão.");
}
Trofeu trofeu = new Trofeu();
trofeu.IdCase = caseDeNegocio.Id;
trofeu.CaseDeNegocio = caseDeNegocio;
trofeuDTO.PreencherEntidade(trofeu);
Adicionar(trofeu);
return(trofeu.Id);
}
public void PreencherEntidade(CaseDeNegocio caseDeNegocio)
{
caseDeNegocio.Nome = Nome;
caseDeNegocio.TextoDeApresentacao = TextoDeApresentacao;
caseDeNegocio.PermiteMontarGrupos = PermiteMontarGrupos;
caseDeNegocio.MinimoDeAlunosPorGrupo = MinimoAlunosGrupo;
caseDeNegocio.MaximoDeAlunosPorGrupo = MaximoAlunosGrupo;
}
public MontarGrupoDTO ObterDadosParaMontagemDeGrupos(Usuario usuarioLogado, int?idCase = null, int?idGrupo = null)
{
if (!idCase.HasValue && !idGrupo.HasValue)
{
throw new Exception("Solicitação invélida.");
}
var response = new MontarGrupoDTO();
CaseDeNegocio caseDeNegocio = null;
if (idGrupo.HasValue)
{
Grupo grupo = ObterPorId(idGrupo.Value);
if (grupo == null)
{
throw new Exception("Grupo inexistente.");
}
caseDeNegocio = grupo.CaseDeNegocio;
response.IdGrupo = idGrupo.Value;
response.NomeGrupo = grupo.Nome;
response.GritoDeGuerra = grupo.GritoDeGuerra;
response.PermiteAlterarMembros = GrupoJaTeveLicaoEntregue(idGrupo.Value);
response.Membros = ListarMembros(idGrupo.Value);
}
else
{
caseDeNegocio = _caseDeNegocioRepository.GetById(idCase.Value);
if (caseDeNegocio == null)
{
throw new Exception("Case de negócio não encontrado.");
}
var alunoDoCase = _alunoRepository.Obter(usuarioLogado.Id, caseDeNegocio.Id);
if (alunoDoCase != null)
{
response.Membros.Add(new MembroDoGrupoDTO(usuarioLogado, alunoDoCase));
}
response.PermiteAlterarMembros = true;
}
if (!caseDeNegocio.PermiteMontarGrupos)
{
throw new Exception("Case de negócio não permite grupos.");
}
response.IdCase = caseDeNegocio.Id;
response.MinimoPermitidoDeAlunos = caseDeNegocio.MinimoDeAlunosPorGrupo;
response.MaximoPermitidoDeAlunos = caseDeNegocio.MaximoDeAlunosPorGrupo;
return(response);
}
public CaseDetalhesDTO(CaseDeNegocio caseDeNegocio)
{
Id = caseDeNegocio.Id;
Nome = caseDeNegocio.Nome;
TextoDeApresentacao = caseDeNegocio.TextoDeApresentacao;
PermiteMontarGrupos = caseDeNegocio.PermiteMontarGrupos;
MinimoAlunosGrupo = caseDeNegocio.MinimoDeAlunosPorGrupo;
MaximoAlunosGrupo = caseDeNegocio.MaximoDeAlunosPorGrupo;
IdProfessor = caseDeNegocio.IdProfessor;
NomeProfessor = caseDeNegocio.Professor.NomeCompleto;
ChaveDeBusca = caseDeNegocio.ChaveDeBusca;
}
public void Atribuir(AtribuirTrofeuRequest request, Usuario usuario)
{
Trofeu trofeu = _trofeuRepository.GetById(request.IdTrofeu);
if (trofeu == null)
{
throw new Exception("Troféu não localizado.");
}
CaseDeNegocio caseDeNegocio = _caseDeNegocioService.ObterPorId(trofeu.IdCase);
if (!_caseDeNegocioService.UsuarioEstaAssociadoAoCaseDeNegocioComoProfessor(usuario, caseDeNegocio))
{
throw new Exception("Usuário não possui permissão para esta solicitação.");
}
EntregaDeLicao entregaDeLicao = _entregaDeLicaoRepository.GetById(request.IdEntregaDeLicao);
if (entregaDeLicao == null)
{
throw new Exception("Lição não localizada.");
}
else if (entregaDeLicao.Licao.IdCase != caseDeNegocio.Id)
{
throw new Exception("Lição não pode ser associada à este troféu.");
}
Resposta resposta = null;
if (request.IdResposta != null && request.IdResposta > 0)
{
resposta = _respostaRepository.GetById(request.IdResposta.Value);
if (resposta == null)
{
throw new Exception("Questão não localizada.");
}
else if (resposta.IdEntregaDeLicao != entregaDeLicao.Id)
{
throw new Exception("Resposta não associada à lição.");
}
}
EntregaDeTrofeu entregaDeTrofeu = new EntregaDeTrofeu(trofeu, entregaDeLicao, resposta);
Adicionar(entregaDeTrofeu);
}
public IEnumerable <LicaoDTO> Listar(int idCaseDeNegocio, Usuario usuarioLogado)
{
List <LicaoDTO> response = new List <LicaoDTO>();
CaseDeNegocio caseDeNegocio = _caseDeNegocioService.ObterPorId(idCaseDeNegocio);
bool permiteEditar = _caseDeNegocioService.PermiteUsuarioEditarCaseDeNegocio(usuarioLogado, caseDeNegocio);
bool ehAlunoInscrito = _caseDeNegocioService.UsuarioEstaInscritoNoCaseDeNegocio(usuarioLogado, caseDeNegocio);
var licoesIniciadas = _consultaEntregaDeLicaoService.ListarEntregasIniciadasPeloUsuarioNoCaseDeNegocio(caseDeNegocio.Id, usuarioLogado.Id);
// TODO:erro ao obter lições mapeadas no case de negócio. Necessário verificar mapeamento do EF Core. Pode ser algo com o proxy.
var licoes = _licaoRepository.ListarPorCaseDeNegocio(caseDeNegocio.Id);
foreach (var licao in licoes)
{
LicaoDTO licaoDTO = new LicaoDTO(licao);
PreencherDadosDePermissaoEEntrega(licaoDTO, permiteEditar, ehAlunoInscrito, licoesIniciadas);
response.Add(licaoDTO);
}
return(response);
}
public int Adicionar(LicaoDTO licaoDTO, Usuario usuarioLogado)
{
if (licaoDTO == null || licaoDTO.Id.HasValue)
{
throw new Exception("Solicitação inválida.");
}
if (licaoDTO.Questoes == null || !licaoDTO.Questoes.Any())
{
throw new Exception("É necessário ter pelo menos 1 questão.");
}
CaseDeNegocio caseDeNegocio = _caseDeNegocioService.ObterPorId(licaoDTO.IdCase);
if (caseDeNegocio == null)
{
throw new Exception("Case de negócio não encontrado.");
}
if (!_caseDeNegocioService.PermiteUsuarioEditarCaseDeNegocio(usuarioLogado, caseDeNegocio))
{
throw new Exception("Usuário não possui permissão para esta solicitação.");
}
Licao licao = new Licao();
licao.IdCase = caseDeNegocio.Id;
licao.CaseDeNegocio = caseDeNegocio;
licaoDTO.PreencherEntidade(licao);
AtualizarListaDeQuestoes(licao, licaoDTO.Questoes);
Adicionar(licao);
return(licao.Id);
}
public int Adicionar(ManterGrupoRequest request)
{
if (request == null || request.IdGrupo.HasValue)
{
throw new Exception("Solicitação inválida.");
}
if (request.IdsAlunosMembros == null || request.IdsAlunosMembros.Count < 2)
{
throw new Exception("Um grupo deve ser formado por 2 ou mais alunos.");
}
CaseDeNegocio caseDeNegocio = _caseDeNegocioRepository.GetById(request.IdCase);
if (caseDeNegocio == null)
{
throw new Exception("Case de negócio não encontrado.");
}
if (!caseDeNegocio.PermiteMontarGrupos)
{
throw new Exception("Case de negócio não permite criação de grupos.");
}
if (request.IdsAlunosMembros.Count < caseDeNegocio.MinimoDeAlunosPorGrupo ||
request.IdsAlunosMembros.Count > caseDeNegocio.MaximoDeAlunosPorGrupo)
{
throw new Exception(string.Format("Este case de negócio requer que o grupo seja formado com {0} a {1} alunos.", caseDeNegocio.MinimoDeAlunosPorGrupo, caseDeNegocio.MaximoDeAlunosPorGrupo));
}
var alunos = (from a in _alunoRepository.Queryable()
where a.IdCaseDeNegocio == caseDeNegocio.Id &&
request.IdsAlunosMembros.Contains(a.Id)
select a).ToList();
if (!request.IdsAlunosMembros.All(id => alunos.Any(a => a.Id == id)))
{
throw new Exception("Foi solicitado inclusão de aluno inexistente.");
}
bool possuiAlunoQueJaEstaEmAlgumGrupo = (from m in _membroDoGrupoRepository.Queryable()
join a in _alunoRepository.Queryable() on m.IdAluno equals a.Id
where request.IdsAlunosMembros.Contains(m.IdAluno) && a.IdCaseDeNegocio == caseDeNegocio.Id
select m).Any();
if (possuiAlunoQueJaEstaEmAlgumGrupo)
{
throw new Exception("Foi solicitado inclusão de aluno que já possui grupo.");
}
Grupo grupo = new Grupo(caseDeNegocio, request.Nome, request.GritoDeGuerra);
foreach (var aluno in alunos)
{
grupo.Membros.Add(new MembroDoGrupo(grupo, aluno));
}
Adicionar(grupo);
return(grupo.Id);
}
public void Atualizar(ManterGrupoRequest request)
{
if (request == null || !request.IdGrupo.HasValue)
{
throw new Exception("Solicitação inválida.");
}
if (request.IdsAlunosMembros == null || request.IdsAlunosMembros.Count < 2)
{
throw new Exception("Um grupo deve ser formado por 2 ou mais alunos.");
}
Grupo grupo = ObterPorId(request.IdGrupo.Value);
if (grupo == null)
{
throw new Exception("Grupo não encontrado.");
}
CaseDeNegocio caseDeNegocio = grupo.CaseDeNegocio;
if (caseDeNegocio.PermiteMontarGrupos &&
(request.IdsAlunosMembros.Count < caseDeNegocio.MinimoDeAlunosPorGrupo ||
request.IdsAlunosMembros.Count > caseDeNegocio.MaximoDeAlunosPorGrupo))
{
throw new Exception(string.Format("Este case de negócio requer que o grupo seja formado com {0} a {1} alunos.", caseDeNegocio.MinimoDeAlunosPorGrupo, caseDeNegocio.MaximoDeAlunosPorGrupo));
}
int totalAlunosInscritos = (from a in _alunoRepository.Queryable()
where a.IdCaseDeNegocio == caseDeNegocio.Id &&
request.IdsAlunosMembros.Contains(a.Id)
select a).Count();
if (totalAlunosInscritos != request.IdsAlunosMembros.Count)
{
throw new Exception("Foi solicitado inclusão de aluno inexistente.");
}
bool possuiAlunoQueJaEstaEmOutroGrupo = (from m in _membroDoGrupoRepository.Queryable()
join a in _alunoRepository.Queryable() on m.IdAluno equals a.Id
where request.IdsAlunosMembros.Contains(m.IdAluno) &&
a.IdCaseDeNegocio == caseDeNegocio.Id &&
m.IdGrupo != grupo.Id
select m).Any();
if (possuiAlunoQueJaEstaEmOutroGrupo)
{
throw new Exception("Foi solicitado inclusão de aluno que já possui grupo.");
}
if (GrupoJaTeveLicaoEntregue(grupo.Id))
{
throw new Exception("Não é permitido alterações em grupos que já tiveram lições entregues.");
}
grupo.Nome = request.Nome;
grupo.GritoDeGuerra = request.GritoDeGuerra;
AtualizarListaDeMembros(grupo, request.IdsAlunosMembros);
Atualizar(grupo);
}
