public AlunosPage()
{
InitializeComponent();
lstAlunos = AlunoService.GetAlunos();
lstAluno.ItemsSource = lstAlunos;
}
public AutenticarViewModel(INavigationService navigationService)
{
alunoService = new AlunoService();
this.navigationService = navigationService;
TituloPagina = "Controle de Cursos";
}
public void AlunoServiceSuccess()
{
var alunoBusinessMock = new Mock <IAlunoBusiness>();
alunoBusinessMock.Setup(
a => a.Add(It.IsAny <Aluno>())).Returns(true);
var alunosExpectancy = new List <Aluno>
{
new Aluno()
{
Id = 1, Key = Guid.NewGuid(), Nome = "AAA"
},
new Aluno()
{
Id = 2, Key = Guid.NewGuid(), Nome = "BBB"
}
};
alunoBusinessMock.Setup(a => a.GetList()).Returns(alunosExpectancy);
var alunoService = new AlunoService(alunoBusinessMock.Object);
var alunos = alunoService.Insert(null);
Assert.NotNull(alunos);
Assert.True(alunos.Any());
for (var index = 0; index < alunos.Count; index++)
{
Assert.Equal(alunosExpectancy[index].Id, alunos[index].Id);
Assert.Equal(alunosExpectancy[index].Key, alunos[index].Key);
Assert.Equal(alunosExpectancy[index].Nome, alunos[index].Nome);
}
}
protected async override void OnAppearing()
{
var escolasEtt = await App.Database.GetEscolaAsync();
if (escolasEtt.Count > 0)
{
var escolaEtt = escolasEtt.FirstOrDefault();
var escolaDTO = JsonConvert.DeserializeObject <EscolaDTO>(escolaEtt.DTO);
EscolaName.Text = escolaDTO.Name;
EscolaImage.Source = escolaDTO.Image;
EscolaAlunosDisponiveis.Text = escolaDTO.AlunosDisponiveis;
EscolaDistancia.Text = escolaDTO.Distancia;
EscolaDistancia.Text = escolaDTO.Distancia;
EscolaTipoInclusao1.Source = escolaDTO.TipoInclusao1;
EscolaTipoInclusao2.Source = escolaDTO.TipoInclusao2;
EscolaTipoInclusao3.Source = escolaDTO.TipoInclusao3;
EscolaTipoInclusao4.Source = escolaDTO.TipoInclusao4;
_alunos = AlunoService.GetAlunosPorEscola(escolaDTO.Name);
lstAlunos.ItemsSource = _alunos;
}
base.OnAppearing();
}
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}");
}
public AlunosController()
{
AlunoRepository = Injection.Get <IAlunoRepository>();
TurmaRepository = Injection.Get <ITurmaRepository>();
Uow = Injection.Get <IUnitOfWork>();
_alunoService = new AlunoService(AlunoRepository, TurmaRepository, Uow);
}
public void TestaBusca()
{
AlunoService alunoService = new AlunoService();
var listaAlunos = alunoService.Select();
Assert.True(listaAlunos.Count > 0);
}
public ActionResult Cadastrar(AlunoViewModel alunoViewModel)
{
var alunoService = new AlunoService();
if (alunoService.ObterPeloEmail(alunoViewModel.Email) is var retorno && retorno.EstaValido)
{
ModelState.AddModelError("", $"O email {alunoViewModel.Email} já está cadastrado");
return(View());
}
public async Task <object> SendService(IBaseViewModel model = null)
{
if (!ValidarId(((AlunoAddViewModel)model).IdCurso, "Necessário selecionar um curso."))
{
return(false);
}
await AlunoService.AddAsync(Injector.Mapper.Map <Aluno>(model));
return(Injector.Notificador.IsValido());
}
// GET: Login
public ActionResult Index()
{
var alunoService = new AlunoService();
var professorService = new ProfessorService();
var viewModel = new UsuarioViewModel();
viewModel.AlunosLista = alunoService.ListarAlunos().Sucesso.ToList();
viewModel.ProfessoresLista = professorService.ListarProfessores().Sucesso.ToList();
return(View(viewModel));
}
public void Setup()
{
var aluno1 = new Aluno("40497326884", "*****@*****.**", "gabriel.estavaringo", "Gabriel Estavaringo", 10391246, "123456");
var aluno2 = new Aluno("05828690566", "*****@*****.**", "marcos.paulo", "Marcos Paulo Oliver Gomes", 98800890, "654321");
var aluno3 = new Aluno("15358646051", "*****@*****.**", "joao.silva", "João da Silva", 1360523, "123");
alunos = new List <Aluno>
{
aluno1, aluno2, aluno3
};
var repository = new Mock <AlunoRepository>(null);
repository.Setup(x =>
x.GetAsync(It.IsAny <string>()))
.ReturnsAsync((object[] ids) => alunos.Where(a => a.Cpf == ids[0].ToString()).SingleOrDefault());
repository.Setup(x =>
x.GetAsync())
.ReturnsAsync(alunos);
repository.Setup(x =>
x.GetAlunoByRa(It.IsAny <int>()))
.Returns((int ra) => alunos.Where(a => a.Ra == ra).SingleOrDefault());
repository.Setup(x =>
x.RemoveAsync(It.IsAny <string>()))
.ReturnsAsync(
(object[] ids) =>
{
var aluno = alunos.Where(a => a.Cpf == ids[0].ToString()).SingleOrDefault();
if (aluno != null)
{
alunos.Remove(aluno);
}
return(aluno);
});
repository.Setup(x =>
x.CreateAsync(It.IsAny <Aluno>()))
.ReturnsAsync(
(Aluno aluno) =>
{
if (alunos.Any(a => a.Cpf == aluno.Cpf || a.Ra == aluno.Ra))
{
return(false);
}
alunos.Add(aluno);
return(true);
});
_alunoService = new AlunoService(repository.Object);
}
private void ExecuteNovoAlunoCommand()
{
AlunoService.SalvarAluno(new Aluno
{
Key = Guid.NewGuid().ToString(),
Nome = Nome,
Curso = Curso,
Nota = Nota
});
Application.Current.MainPage.Navigation.PopAsync();
}
public void Deveria_Chamar_Servico_de_Buscar_Aluno_Test()
{
//arrange
AlunoRepository
.Setup(x => x.GetById(It.IsAny <int>()))
.Returns(ObjectBuilder.CreateAluno());
//act
AlunoService.GetById(1);
//assert
AlunoRepository.Verify(x => x.GetById(It.IsAny <int>()), Times.Once());
}
public ActionResult Entrar(UsuarioViewModel usuarioViewModel)
{
AutenticacaoUsuario usuarioParaAutenticar = new AutenticacaoUsuario();
usuarioParaAutenticar.Usuario = AutoMapper.Mapper.Map <Usuario>(usuarioViewModel);
UsuarioService usuarioService = new UsuarioService();
var usuarioCadastrado = usuarioService.Autenticar(usuarioParaAutenticar);
if (!usuarioCadastrado.EstaValido)
{
ModelState.AddModelError("", "Senha ou código(s) incorreto(s)."); //ou algum outro problema, investigar
return(View("Index"));
}
else
{
Session[Login.ChaveUsuarioSession] = usuarioCadastrado.Sucesso; // pra poder gerar o token
var professorUsuario = new ProfessorService().ObterPeloIdUsuario(usuarioCadastrado.Sucesso.Usuario.Id);
//if (true) { }
if (professorUsuario.Sucesso == null && !professorUsuario.EstaValido)
{
var alunoUsuario = new AlunoService().ObterPeloIdUsuario(usuarioCadastrado.Sucesso.Usuario.Id);
if (alunoUsuario.Sucesso == null && !alunoUsuario.EstaValido)
{
ModelState.AddModelError("", "Erro interno. O código do usuário está cadastrado mas não existe nenhum professor ou aluno com este código.");
return(View("Index"));
}
else
{
alunoUsuario.Sucesso.Codigo = usuarioCadastrado.Sucesso.Usuario.Codigo;
alunoUsuario.Sucesso.Senha = usuarioCadastrado.Sucesso.Usuario.Senha;
var autenticacaoAluno = new AutenticacaoAluno(alunoUsuario.Sucesso, usuarioCadastrado.Sucesso.Token);
Session[Login.ChaveUsuarioSession] = autenticacaoAluno;
return(RedirectToAction("Index", "Home"));
}
}
else
{
professorUsuario.Sucesso.Codigo = usuarioCadastrado.Sucesso.Usuario.Codigo;
professorUsuario.Sucesso.Senha = usuarioCadastrado.Sucesso.Usuario.Senha;
var autenticacaoProfessor = new AutenticacaoProfessor(professorUsuario.Sucesso, usuarioCadastrado.Sucesso.Token);
Session[Login.ChaveUsuarioSession] = autenticacaoProfessor;
return(RedirectToAction("Index", "Home"));
}
}
}
public Rematricular_aluno()
{
_pessoaFisica = PessoaFisicaStub.PessoaMenorDeIdade;
_responsavel = PessoaFisicaStub.PessoaMaiorDeIdade;
_aluno = new Aluno(_alunoId, _pessoaFisica, _responsavel, _matricula);
_aluno.Transferir();
_escola = new Escola(_escolaId, _escolaNome);
_escola.AdicionarSala(_salaId, _salaFaseAno, Turno.Matutino);
var mockAlunoRepository = new Mock <IAlunoRepository>();
var mockPessoaFisicaRepository = new Mock <IPessoaFisicaRepository>();
var mockEscolaRepository = new Mock <IEscolaRepository>();
var mockMatriculaService = new Mock <IMatriculaService>();
mockAlunoRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(_aluno));
mockAlunoRepository.Setup(x => x.AddAsync(It.IsAny <Aluno>()))
.Callback((Aluno a) => { _aluno = a; });
mockPessoaFisicaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns((Guid entityId) =>
{
if (entityId == _pessoaFisica.EntityId)
{
return(Task.FromResult(_pessoaFisica));
}
if (entityId == _responsavel.EntityId)
{
return(Task.FromResult(_responsavel));
}
return(Task.FromResult <PessoaFisica>(null));
});
mockEscolaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(_escola));
mockMatriculaService.Setup(x => x.GerarMatriculaAsync())
.Returns(Task.FromResult(_matricula));
_service = new AlunoService(mockAlunoRepository.Object,
mockPessoaFisicaRepository.Object,
mockEscolaRepository.Object,
mockMatriculaService.Object);
TestAsyncHelper.CallSync(() => _service.RematricularAsync(_alunoId, _responsavel.EntityId, _escolaId, _salaId).Wait());
}
static void Main(string[] args)
{
AlunoService alunoService = new AlunoService(new AlunoRepository());
var alunos = alunoService.Lista();
foreach (var aluno in alunos)
{
Console.WriteLine($"Aluno: {aluno.Nome} ::: Matrícula: {aluno.Matricula} ::: Idade: {aluno.Idade}");
}
SalaService salaService = new SalaService();
MateriaService materiaService = new MateriaService();
}
public void TestaInclusao()
{
AlunoService alunoService = new AlunoService();
COBOL.Entidades.Aluno aluno = new COBOL.Entidades.Aluno
{
CPF = 1234567,
Nome = "Aluno 1",
Logradouro = "Rua Aluno",
Telefone = 11223344
};
var retorno = alunoService.Insert(aluno);
Assert.True(retorno != null);
}
public void Deveria_Chamar_Servico_de_Remover_Aluno_Test()
{
//arrange
AlunoRepository
.Setup(x => x.Delete(It.IsAny <int>()));
//act
AlunoService.Delete(1);
UnitOfWork.Setup(x => x.Commit());
//assert
AlunoRepository.Verify(x => x.Delete(It.IsAny <int>()), Times.Once());
UnitOfWork.Verify(x => x.Commit(), Times.Once());
}
async private void CarregarObservable()
{
if (!IsBusy)
{
IsBusy = true;
Alunos.Clear();
var observable = AlunoService.CarregarAlunos();
if (observable != null)
{
foreach (var aluno in observable.Alunos)
{
Alunos.Add(aluno);
}
}
IsBusy = false;
}
}
public Matricular_aluno()
{
_matricula = _fixture.Create <int>();
_alunoId = _fixture.Create <Guid>();
_salaId = _fixture.Create <Guid>();
_salaFaseAno = _fixture.Create <string>();
_escola = EscolaStub.EscolaValida;
_pessoaFisica = PessoaFisicaStub.PessoaMenorDeIdade;
_responsavel = PessoaFisicaStub.PessoaMaiorDeIdade;
_escola.AdicionarSala(_salaId, _salaFaseAno, Turno.Matutino);
_mockAlunoRepository.Setup(x => x.AddAsync(It.IsAny <Aluno>()))
.Callback((Aluno a) => { _aluno = a; });
_mockPessoaFisicaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns((Guid entityId) =>
{
if (entityId == _pessoaFisica.EntityId)
{
return(Task.FromResult(_pessoaFisica));
}
if (entityId == _responsavel.EntityId)
{
return(Task.FromResult(_responsavel));
}
return(Task.FromResult <PessoaFisica>(null));
});
_mockEscolaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(_escola));
_mockMatriculaService.Setup(x => x.GerarMatriculaAsync())
.Returns(Task.FromResult(_matricula));
_service = new AlunoService(_mockAlunoRepository.Object,
_mockPessoaFisicaRepository.Object,
_mockEscolaRepository.Object,
_mockMatriculaService.Object);
TestAsyncHelper.CallSync(() => _service.MatricularAsync(_alunoId, _pessoaFisica.EntityId, _responsavel.EntityId, _escola.EntityId, _salaId).Wait());
}
public void Deveria_Chamar_Servico_de_Buscar_Todas_Alunos_Test()
{
//arrange
var alunos = new List <Aluno>()
{
ObjectBuilder.CreateAluno()
};
AlunoRepository
.Setup(x => x.GetAll())
.Returns(alunos);
//act
AlunoService.GetAll();
//assert
AlunoRepository.Verify(x => x.GetAll(), Times.Once());
}
public AulaDataManager()
{
var unitOfWork = Injection.Get <IUnitOfWork>();
var aulaRepository = Injection.Get <IAulaRepository>();
var alunoRepository = Injection.Get <IAlunoRepository>();
var turmaRepository = Injection.Get <ITurmaRepository>();
_aulaService = new AulaService(aulaRepository, alunoRepository, turmaRepository, unitOfWork);
_alunoService = new AlunoService(alunoRepository, turmaRepository, unitOfWork);
_turmaService = new TurmaService(turmaRepository, unitOfWork);
_control = new AulaControl(_aulaService);
}
public Quando_matricular_aluno()
{
_pessoaFisica = new PessoaFisica(_pessoaFisicaId, _nome, _cpf, _nomeSocial, _sexo, _dataNascimento);
_responsavel = new PessoaFisica(_responsavelId, _responsavelNome, _responsavelCpf, _responsavelNomeSocial, _responsavelSexo, _responsavelDataNascimento);
_escola = new Escola(_escolaId, _escolaNome);
_escola.AdicionarSala(_salaId, _salaFaseAno, Turno.Matutino);
var mockAlunoRepository = new Mock <IAlunoRepository>();
var mockPessoaFisicaRepository = new Mock <IPessoaFisicaRepository>();
var mockEscolaRepository = new Mock <IEscolaRepository>();
var mockMatriculaService = new Mock <IMatriculaService>();
mockAlunoRepository.Setup(x => x.AddAsync(It.IsAny <Aluno>()))
.Callback((Aluno a) => { _aluno = a; });
mockPessoaFisicaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns((Guid entityId) =>
{
if (entityId == _pessoaFisicaId)
{
return(Task.FromResult(_pessoaFisica));
}
if (entityId == _responsavelId)
{
return(Task.FromResult(_responsavel));
}
return(Task.FromResult <PessoaFisica>(null));
});
mockEscolaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(_escola));
mockMatriculaService.Setup(x => x.GerarMatriculaAsync())
.Returns(Task.FromResult(_matricula));
_service = new AlunoService(mockAlunoRepository.Object,
mockPessoaFisicaRepository.Object,
mockEscolaRepository.Object,
mockMatriculaService.Object);
CallSync(() => _service.MatricularAsync(_alunoId, _pessoaFisicaId, _responsavelId, _escolaId, _salaId).Wait());
}
public object GetById(int id)
{
try
{
var resultado = new AlunoService().GetById(id);
if (resultado != null)
{
return(Ok(resultado));
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
throw ex;
}
}
public object Update([FromBody] Aluno dados)
{
try
{
var resultado = new AlunoService().Update(dados);
if (resultado != null)
{
return(Ok(resultado));
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
throw ex;
}
}
public object ListPaginada(int pagina, int qtdPagina)
{
try
{
var resultado = new AlunoService().ListPaginada(pagina, qtdPagina);
if (resultado != null)
{
return(Ok(resultado));
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Deveria_Chamar_Servico_de_Persistir_Aluno_Test()
{
//arrange
var aluno = ObjectBuilder.CreateAluno();
aluno.Turma = ObjectBuilder.CreateTurma();
AlunoRepository
.Setup(x => x.Add(It.IsAny <Aluno>()));
UnitOfWork.Setup(x => x.Commit());
//act
AlunoService.Add(new AlunoDTO(aluno));
//assert
AlunoRepository.Verify(x => x.Add(It.IsAny <Aluno>()), Times.Once());
UnitOfWork.Verify(x => x.Commit(), Times.Once());
}
public Matricular_aluno_com_pessoa_fisica_inexistente()
{
_pessoaFisica = PessoaFisicaStub.PessoaMenorDeIdade;
_responsavel = PessoaFisicaStub.PessoaMaiorDeIdade;
_escola = new Escola(_escolaId, _escolaNome);
_escola.AdicionarSala(_salaId, _salaFaseAno, Turno.Matutino);
var mockAlunoRepository = new Mock <IAlunoRepository>();
var mockPessoaFisicaRepository = new Mock <IPessoaFisicaRepository>();
var mockEscolaRepository = new Mock <IEscolaRepository>();
var mockMatriculaService = new Mock <IMatriculaService>();
mockAlunoRepository.Setup(x => x.AddAsync(It.IsAny <Aluno>()))
.Callback((Aluno a) => { _aluno = a; });
mockPessoaFisicaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns((Guid entityId) =>
{
if (entityId == _responsavel.EntityId)
{
return(Task.FromResult(_responsavel));
}
return(Task.FromResult <PessoaFisica>(null));
});
mockEscolaRepository.Setup(x => x.GetByEntityIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(_escola));
mockMatriculaService.Setup(x => x.GerarMatriculaAsync())
.Returns(Task.FromResult(_matricula));
_service = new AlunoService(mockAlunoRepository.Object,
mockPessoaFisicaRepository.Object,
mockEscolaRepository.Object,
mockMatriculaService.Object);
}
public void Deveria_Chamar_Servico_de_Editar_Aluno_Test()
{
//arrange
var aluno = ObjectBuilder.CreateAluno();
aluno.Nome = "Alex Regis";
AlunoRepository
.Setup(x => x.Update(aluno));
AlunoRepository
.Setup(x => x.GetById(It.IsAny <int>()))
.Returns(aluno);
UnitOfWork.Setup(x => x.Commit());
//act
AlunoService.Update(new AlunoDTO(aluno));
//assert
AlunoRepository.Verify(x => x.Update(aluno), Times.Once());
UnitOfWork.Verify(x => x.Commit(), Times.Once());
}
public AlunosController(AlunoService service)
{
_service = service;
}
public AlunoController(AlunoService service)
{
this.service = service;
}
