public ICommandResult Handler(CadastrarAlunoTurmaCommand command)
        {
            command.Validar();

            if (command.Invalid)
            {
                return(new GenericCommandResult(false, "Dados Inválidos!", command.Notifications));
            }

            var aluno = _repositorioAluno.BuscarPorId(command.IdAluno);

            if (aluno == null)
            {
                return(new GenericCommandResult(false, "Aluno não encontrado", null));
            }

            var turma = _repositorioTurma.BuscarTurmaPorId(command.IdTurma);

            if (turma == null)
            {
                return(new GenericCommandResult(false, "Turma não encontrada", null));
            }

            var alunoTurma = new AlunoTurma(command.IdAluno, command.IdTurma, command.AnotacaoProfessor);

            if (alunoTurma.Valid)
            {
                _repositorio.AdicionarAlunoATurma(alunoTurma);
            }

            return(new GenericCommandResult(true, "Aluno inserido na turma com sucesso", alunoTurma));
        }
        public IQueryResult Handle(ListarTurmasDoAlunoQuery command)
        {
            command.Validate();

            if (command.Invalid)
            {
                return(new GenericQueryResult(false, "Dados inválidos", command.Notifications));
            }

            var turmasDoAluno = _repositorio.ListarTurmasDoAluno(command.IdAluno);

            var result = turmasDoAluno.Select(tal =>
            {
                var turma = _repositorioTurma.BuscarTurmaPorId(tal.IdTurma);

                var aluno = _repositorioAluno.BuscarPorId(tal.IdAluno);

                var horarios = _repositorioHorario.BuscarHorarioPorIdTurma(turma.Id);

                return(new ListaTurmasDoAlunoResult()
                {
                    Aluno = new BuscarAlunoResult
                    {
                        Id = aluno.Id,
                        NomeUsuario = aluno.NomeUsuario,
                        Email = aluno.Email,
                        Telefone = aluno.Telefone,
                        Rg = aluno.Rg,
                        FotoAluno = aluno.FotoAluno
                    },
                    Turmas = turmasDoAluno.Select(tam =>

                                                  new ListarTurmaResult
                    {
                        Id = turma.Id,
                        Titulo = turma.Titulo,
                        Descricao = turma.Descricao,
                        Semestre = turma.Semestre.ToString(),
                        Horarios = turma.Horarios.Select(hrr =>

                                                         new ListarHorarioResult()
                        {
                            Id = hrr.Id,
                            DiaSemana = hrr.DiaSemana.ToString(),
                            HoraInicio = hrr.HoraInicio,
                            HoraTermino = hrr.HoraTermino
                        }

                                                         ).ToList()
                    }

                                                  ).ToList()
                });
            });

            return(new GenericQueryResult(true, "Turmas do aluno", result));
        }
        public IQueryResult Handle(BuscarAlunoTurmaQuery command)
        {
            command.Validate();

            if (command.Invalid)
            {
                return(new GenericQueryResult(false, "Dados inválidos", command.Notifications));
            }

            var procurarAlunoTurma = _repositorio.BuscarAlunoTurmaPorId(command.Id);

            if (procurarAlunoTurma == null)
            {
                return(new GenericQueryResult(false, "Aluno turma não encontrado", null));
            }

            var aluno = _repositorioAluno.BuscarPorId(procurarAlunoTurma.IdAluno);

            var turma = _repositorioTurma.BuscarTurmaPorId(procurarAlunoTurma.IdTurma);

            var result = new BuscarAlunoTurmaResult
            {
                Id    = procurarAlunoTurma.Id,
                Aluno = new BuscarAlunoResult
                {
                    Id          = aluno.Id,
                    NomeUsuario = aluno.NomeUsuario,
                    Email       = aluno.Email,
                    Telefone    = aluno.Telefone,
                    Rg          = aluno.Rg,
                    FotoAluno   = aluno.FotoAluno
                },
                Turma = new BuscarTurmaResult
                {
                    Id        = turma.Id,
                    Titulo    = turma.Titulo,
                    Descricao = turma.Descricao,
                    Semestre  = turma.Semestre.ToString(),
                    Horarios  = turma.Horarios.Select(hrr =>

                                                      new ListarHorarioResult()
                    {
                        Id          = hrr.Id,
                        DiaSemana   = hrr.DiaSemana.ToString(),
                        HoraInicio  = hrr.HoraInicio,
                        HoraTermino = hrr.HoraTermino
                    }

                                                      ).ToList()
                },
                Anotacao = procurarAlunoTurma.AnotacaoProfessor
            };

            return(new GenericQueryResult(true, "Dados do aluno turma", result));
        }
        public IQueryResult Handle(BuscarAlunoQuery command)
        {
            command.Validate();

            if (command.BuscarRg != null)
            {
                if (command.Invalid)
                {
                    return(new GenericQueryResult(false, "Dados inválidos", command.Notifications));
                }

                var alunoProcuradoRG = _alunoRepositorio.BuscarPorRg(command.BuscarRg);

                if (alunoProcuradoRG == null)
                {
                    return(new GenericQueryResult(false, "Aluno não encontrado", null));
                }

                var professorEmailResult = new BuscarAlunoResult
                {
                    Id          = alunoProcuradoRG.Id,
                    NomeUsuario = alunoProcuradoRG.NomeUsuario,
                    Email       = alunoProcuradoRG.Email,
                    Telefone    = alunoProcuradoRG.Telefone,
                    Rg          = alunoProcuradoRG.Rg,
                    Cpf         = alunoProcuradoRG.Cpf,
                    FotoAluno   = alunoProcuradoRG.FotoAluno,
                };

                return(new GenericQueryResult(true, "Dados do professor", professorEmailResult));
            }

            var alunoProcurado = _alunoRepositorio.BuscarPorId(command.BuscarId);

            if (alunoProcurado == null)
            {
                return(new GenericQueryResult(false, "Aluno não encontrado", null));
            }

            var alunoResult = new BuscarAlunoResult
            {
                Id          = alunoProcurado.Id,
                NomeUsuario = alunoProcurado.NomeUsuario,
                Email       = alunoProcurado.Email,
                Telefone    = alunoProcurado.Telefone,
                Rg          = alunoProcurado.Rg,
                Cpf         = alunoProcurado.Cpf,
                FotoAluno   = alunoProcurado.FotoAluno,
            };

            return(new GenericQueryResult(true, "Dados do professor", alunoResult));
        }
        public IQueryResult Handle(ListarAlunosDaTurmaQuery command)
        {
            command.Validate();

            if (command.Invalid)
            {
                return(new GenericQueryResult(false, "Dados inválidos", command.Notifications));
            }

            var alunosDaTurma = _repositorio.ListarAlunosDaTurma(command.IdTurma);

            var result = alunosDaTurma.Select(alt =>
            {
                var turma = _repositorioTurma.BuscarTurmaPorId(alt.IdTurma);

                var aluno = _repositorioAluno.BuscarPorId(alt.IdAluno);

                return(new ListarAlunosDaTurmaResult()
                {
                    Turma = new BuscarTurmaResult
                    {
                        Id = turma.Id,
                        Titulo = turma.Titulo,
                        Descricao = turma.Descricao,
                        Semestre = turma.Semestre.ToString(),
                    },
                    Alunos = alunosDaTurma.Select(atm =>

                                                  new ListarQueryResult
                    {
                        Id = aluno.Id,
                        NomeUsuario = aluno.NomeUsuario,
                        Email = aluno.Email,
                        Telefone = aluno.Telefone,
                        Rg = aluno.Rg,
                        FotoAluno = aluno.FotoAluno
                    }

                                                  ).ToList()
                });
            });

            return(new GenericQueryResult(true, "Lista dos alunos da turma", result));
        }
Esempio n. 6
0
        public ICommandResult Handler(ExcluirAlunoCommand command)
        {
            command.Validar();

            //Caso seja inválido, recebemos quando são os valores incorretos identificados por ele
            if (command.Invalid)
            {
                return(new GenericCommandResult(false, "Informe um id correto", command.Notifications));
            }

            var alunoExiste = _alunoRepositorio.BuscarPorId(command.Id);

            if (alunoExiste == null)
            {
                return(new GenericCommandResult(false, "Aluno não encontrado", null));
            }

            _alunoRepositorio.Excluir(alunoExiste);

            return(new GenericCommandResult(true, "Aluno excluído com sucesso", alunoExiste));
        }
Esempio n. 7
0
        public ICommandResult Handler(AlterarAlunoTurmaCommand command)
        {
            command.Validar();

            if (command.Invalid)
            {
                return(new GenericCommandResult(false, "Dados Inválidos!", command.Notifications));
            }

            var AlunoTurma = _repositorio.BuscarAlunoTurmaPorId(command.Id);

            if (AlunoTurma == null)
            {
                return(new GenericCommandResult(true, "Turma do Aluno não encontrada", null));
            }

            var Aluno = _repositorioAluno.BuscarPorId(command.IdAluno);

            if (Aluno == null)
            {
                return(new GenericCommandResult(false, "Aluno não encontrado", null));
            }

            var turma = _repositorioTurma.BuscarTurmaPorId(command.IdTurma);

            if (turma == null)
            {
                return(new GenericCommandResult(false, "Turma não encontrada", null));
            }

            AlunoTurma.AlterarAlunoTurma(command.IdTurma, command.IdAluno, command.AnotacaoProfessor);

            if (AlunoTurma.Valid)
            {
                _repositorio.AlterarAlunoTurma(AlunoTurma);
            }

            return(new GenericCommandResult(true, "Turma do Aluno", AlunoTurma));
        }
Esempio n. 8
0
        public ICommandResult Handler(AlterarAlunoCommand command)
        {
            command.Validar();

            if (command.Invalid)
            {
                return(new GenericCommandResult(false, "Dados Inválidos", command.Notifications));
            }

            var aluno = _alunoRepositorio.BuscarPorId(command.Id);

            if (aluno == null)
            {
                return(new GenericCommandResult(false, "Aluno Não Encontrado", command.Notifications));
            }

            if (command.Email != aluno.Email)
            {
                var emailNovoExistente = _alunoRepositorio.BuscarPorEmail(command.Email);

                if (emailNovoExistente != null)
                {
                    return(new GenericCommandResult(false, "Este e-mail já está vinculado a uma conta, informe outro email", command.Notifications));
                }
            }

            aluno.AlterarAluno(command.Nome, command.Telefone, command.Email, command.Rg, command.Cpf, command.DataNascimento, command.FotoAluno);

            if (aluno.Invalid)
            {
                return(new GenericCommandResult(false, "Dados inválidos", aluno.Notifications));
            }

            _alunoRepositorio.Alterar(aluno);

            return(new GenericCommandResult(true, "Aluno Alterado!", aluno));
        }