예제 #1
0
        static void Main(string[] args)
        {
            var alunoRepository = new AlunoRepository();
            var turmaRepository = new TurmaRepository();

            var alunoBusiness = new AlunoBusiness(alunoRepository);
            var turmaBusiness = new TurmaBusiness(turmaRepository);

            var alunoService = new AlunoService(alunoBusiness);
            var turmaService = new TurmaService(turmaBusiness);

            var alunos = alunoService.Insert(new Aluno {
                Id = 1, Nome = "AAAA"
            });
            var turmas = turmaService.Insert(new Turma
            {
                Numero  = "101",
                Periodo = Domain.ValueObj.Periodo.noite,
                Alunos  = new List <Aluno>()
                {
                    new Aluno {
                        Id = 1, Nome = "AAAA"
                    },
                    new Aluno {
                        Id = 1, Nome = "BBBB"
                    },
                    new Aluno {
                        Id = 1, Nome = "CCCC"
                    }
                }
            });

            Console.WriteLine($"{alunos.Any()} {alunos.Count()} {alunos[0].Nome}");
            Console.WriteLine($"{turmas.Any()} {turmas.Count()} {turmas[0].Numero}");
        }
예제 #2
0
        public void TestaBusca()
        {
            TurmaService turmaService = new TurmaService();

            var listaTurmas = turmaService.Select();

            Assert.True(listaTurmas.Count > 0);
        }
예제 #3
0
        static void Main(string[] args)
        {
            var turmas = TurmaService.ObterTurmas();

            // Quantidade de alunos em todas as turmas
            var quatidadeAlunos = turmas.SelectMany(turma => turma.Alunos).Count();

            //ou
            //Console.WriteLine(turmas.Sum(t => t.Alunos.Count));
            Console.WriteLine($"1) Quantidade de alunos em todas as turmas: {quatidadeAlunos}");

            // Maior Nota entre todos os alunos
            var maiorNota = turmas.SelectMany(turma => turma.Alunos).Max(aluno => aluno.Nota);

            //ou
            //Console.WriteLine(turmas.Max(t => t.Alunos.Max(a => a.Nota)));
            Console.WriteLine($"2) Maior Nota entre todos os alunos: {maiorNota}");

            // Quantidade de alunos do sexo masculino
            var alunosM = turmas.SelectMany(turma => turma.Alunos).Where(aluno => aluno.Sexo.Equals("M")).Count();

            Console.WriteLine($"3) Quantidade de alunos do sexo masculino: {alunosM}");

            // Media de nota por turma
            var mediaNotaAlunoPorTurma = (from turma in turmas
                                          select new
            {
                turma.NomeTurma,
                Media = turma.Alunos.Average(x => x.Nota)
            }
                                          );

            Console.WriteLine($"4) Média nota por turma:");
            foreach (var turma in mediaNotaAlunoPorTurma)
            {
                Console.WriteLine($"\tTurma: {turma.NomeTurma} - Média: {turma.Media}");
            }

            Console.WriteLine($"5) Média de nota por turma: {String.Join("; ", mediaNotaAlunoPorTurma.Select(x => x.Media))}");

            var maiorTurma = turmas.Aggregate((curMin, x) => curMin.Alunos.Count() > x.Alunos.Count() ? curMin : x);

            Console.WriteLine($"6) Turma que tem o maior número de alunos: {maiorTurma.NomeTurma} - Quantidade de alunos: {maiorTurma.Alunos.Count()}");

            var quantidadeMulheres = (from turma in turmas
                                      from aluna in turma.Alunos
                                      where aluna.Sexo.Equals("F")
                                      group aluna by aluna.Id into grupo
                                      where grupo.Count() > 1
                                      select grupo).Count();

            //ou
            //var quantidadeMulheres = turmas.SelectMany(t => t.Alunos).Where(a => a.Sexo == "F")
            //.GroupBy(a => a.Id).Where(g => g.Count() > 1).Count();
            Console.WriteLine($"7) Quantidade de alunas que estão em mais de uma turma: {quantidadeMulheres}");
        }
예제 #4
0
        public void Deveria_Chamar_Servico_de_Buscar_Turma_Test()
        {
            //arrange
            TurmaRepository
            .Setup(x => x.GetById(It.IsAny <int>()))
            .Returns(ObjectBuilder.CreateTurma());

            //act
            TurmaService.GetById(1);

            //assert
            TurmaRepository.Verify(x => x.GetById(It.IsAny <int>()), Times.Once());
        }
예제 #5
0
        public void Persistir_Turma_Service_Test()
        {
            var repo    = Injection.Get <ITurmaRepository>();
            var uow     = Injection.Get <IUnitOfWork>();
            var service = new TurmaService(repo, uow);

            service.Add(new TurmaDTO(ObjectBuilder.CreateTurma()));

            var turmas = service.GetAll();

            Assert.IsTrue(turmas.Count > 1);
            Assert.IsTrue((uow as Infrastructure.DAO.ORM.Common.EntityFrameworkUnitOfWork).Test() == (repo as NDDigital.DiarioAcademia.Infraestrutura.Orm.Repositories.TurmaRepositoryEF).Test());
        }
예제 #6
0
        public void TestaInclusao()
        {
            TurmaService turmaService = new TurmaService();

            COBOL.Entidades.Turma turma = new COBOL.Entidades.Turma
            {
                CodigoDaTurma = 1,
                DataInicio    = DateTime.Now
            };

            var retorno = turmaService.Insert(turma);

            Assert.True(retorno != null);
        }
예제 #7
0
        public void Deveria_Chamar_Servico_de_Remover_Turma_Test()
        {
            //arrange
            TurmaRepository
            .Setup(x => x.Delete(It.IsAny <int>()));

            //act
            TurmaService.Delete(1);

            UnitOfWork.Setup(x => x.Commit());

            //assert
            TurmaRepository.Verify(x => x.Delete(It.IsAny <int>()), Times.Once());

            UnitOfWork.Verify(x => x.Commit(), Times.Once());
        }
예제 #8
0
        static void Main(string[] args)
        {
            var turmas = TurmaService.ObterTurmas();

            // Quantidade de alunos em todas as turmas
            var quatidadeTotalAlunos = -1;

            Console.WriteLine($"1) Quantidade de alunos em todas as turmas: {quatidadeTotalAlunos}");

            // Quantidade de alunos distintos entre todas as turmas
            var quatidadeDistintoslunos = -1;

            Console.WriteLine($"2) Quantidade de alunos distintos entre todas as turmas: {quatidadeDistintoslunos}");

            // Maior nota entre todos os alunos
            var maiorNota = -1;

            Console.WriteLine($"3) Maior nota entre todos os alunos: {maiorNota}");

            // Quantidade de alunos do sexo masculino
            var quantidadeAlunosM = -1;

            Console.WriteLine($"4) Quantidade de alunos do sexo masculino: {quantidadeAlunosM}");

            // Media de nota por turma
            var mediaNotaAlunoPorTurma = new int[] { -1, -1 };

            Console.WriteLine($"5) Média nota por turma:");
            foreach (var turma in mediaNotaAlunoPorTurma)
            {
                //Console.WriteLine($"\tTurma: {turma.NomeTurma} - Média: {turma.Media}");
            }

            // Nome da turma com maior número de alunos
            var maiorTurma = new Turma()
            {
                NomeTurma = "", Alunos = new List <Aluno>()
            };

            Console.WriteLine($"6) Turma que tem o maior número de alunos: {maiorTurma.NomeTurma} - Quantidade de alunos: {maiorTurma.Alunos.Count()}");

            // Quantidade de alunas mulheres que fazem parte de mais de uma turma
            var quantidadeMulheres = -1;

            Console.WriteLine($"7) Quantidade de alunas que fazem parte de mais de uma turma: {quantidadeMulheres}");
        }
예제 #9
0
        public void Deveria_Chamar_Servico_de_Persistir_Turma_Test()
        {
            //arrange
            var turma = ObjectBuilder.CreateTurma();

            TurmaRepository
            .Setup(x => x.Add(It.IsAny <Turma>()));

            UnitOfWork.Setup(x => x.Commit());

            //act
            TurmaService.Add(new TurmaDTO(turma));

            //assert
            TurmaRepository.Verify(x => x.Add(It.IsAny <Turma>()), Times.Once());

            UnitOfWork.Verify(x => x.Commit(), Times.Once());
        }
예제 #10
0
        public void Deveria_Chamar_Servico_de_Buscar_Todas_Turmas_Test()
        {
            //arrange
            var turmas = new List <Turma>()
            {
                ObjectBuilder.CreateTurma()
            };

            TurmaRepository
            .Setup(x => x.GetAll())
            .Returns(turmas);

            //act
            TurmaService.GetAll();

            //assert
            TurmaRepository.Verify(x => x.GetAll(), Times.Once());
        }
 public object ListPaginada(int pagina, int qtdPagina)
 {
     try
     {
         var resultado = new TurmaService().ListPaginada(pagina, qtdPagina);
         if (resultado != null)
         {
             return(Ok(resultado));
         }
         else
         {
             return(BadRequest());
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 public object Update([FromBody] Turma dados)
 {
     try
     {
         var resultado = new TurmaService().Update(dados);
         if (resultado != null)
         {
             return(Ok(resultado));
         }
         else
         {
             return(BadRequest());
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 public object GetById(int id)
 {
     try
     {
         var resultado = new TurmaService().GetById(id);
         if (resultado != null)
         {
             return(Ok(resultado));
         }
         else
         {
             return(BadRequest());
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
예제 #14
0
        public void Deveria_Chamar_Servico_de_Editar_Turma_Test()
        {
            //arrange
            var turma = ObjectBuilder.CreateTurma();

            turma.Ano = 2016;

            TurmaRepository
            .Setup(x => x.Update(turma));

            TurmaRepository
            .Setup(x => x.GetById(It.IsAny <int>()))
            .Returns(turma);

            UnitOfWork.Setup(x => x.Commit());

            //act
            TurmaService.Update(new TurmaDTO(turma));

            //assert
            TurmaRepository.Verify(x => x.Update(turma), Times.Once());

            UnitOfWork.Verify(x => x.Commit(), Times.Once());
        }
예제 #15
0
 public TurmaController()
 {
     TurmaService     = TurmaService.GetInstance();
     EscolaRepository = EscolaRepository.GetInstance();
 }
예제 #16
0
 public OrcamentoTemplate(ProspeccaoService prospeccao, EmpresaService empresaService, TurmaService turmaService)
 {
     _prospeccaoService = prospeccao;
     _empresaService    = empresaService;
     _turmaService      = turmaService;
 }
예제 #17
0
 public TurmaController()
 {
     _turmaService = new TurmaService(TurmaRepository, Uow);
 }
예제 #18
0
 public TurmaController(TurmaService service)
 {
     _service = service;
 }
 public AlunosController(AlunoService alunoService, TurmaService turmaService)
 {
     _alunoService = alunoService;
     _turmaService = turmaService;
 }
예제 #20
0
 public TurmasController(TurmaService turmaService)
 {
     _turmaService = turmaService;
 }
예제 #21
0
 public TurmaController(TurmaService servico)
 {
     _servico = servico;
 }