public void Armazenar(AlunoDTO alunoDTO)
{
var alunoJaSalvo = _alunoRepositorio.ObterPorCpf(alunoDTO.Cpf);
ValidadorDeRegra.Novo()
.Quando(alunoJaSalvo != null && alunoJaSalvo.Id != alunoDTO.Id, Resource.CpfAlunoJaExiste)
.DispararExcecaoSeExistir();
var publicoAlvo = _conversorDePublicoAlvo.Converter(alunoDTO.PublicoAlvo);
var aluno = new Aluno(alunoDTO.Nome,
alunoDTO.Cpf,
alunoDTO.Email,
publicoAlvo);
if (alunoDTO.Id > 0)
{
aluno = _alunoRepositorio.ObterPorId(alunoDTO.Id);
aluno.AlterarNome(alunoDTO.Nome);
}
else
{
_alunoRepositorio.Adicionar(aluno);
}
}
public void AlterarEmail(string email)
{
ValidadorDeRegra.Novo()
.Quando(!ValidadorEmail.IsEmail(email), Resource.EmailInvalido)
.DispararExcecaoSeExistir();
Email = email;
}
public void InformarNota(double notaEsperada)
{
ValidadorDeRegra.Novo()
.Quando(notaEsperada < 0 || notaEsperada > 10, Resource.NotadoAlunoEhInvalida).DispararExcecaoSeExistir();
NotaDoAluno = notaEsperada;
CursoConcluido = true;
}
public void Armazenar(CursoDto cursoDto)
{
var cursoJaSalvo = _cursoRepositorio.ObterPeloNome(cursoDto.Nome);
ValidadorDeRegra.Novo()
.Quando(cursoJaSalvo != null && cursoJaSalvo.Id != cursoDto.Id, Resource.NomeCursoJaExiste)
.DispararExcecaoSeExistir();
var publicoAlvo = _conversorDePublicoAlvo.Converter(cursoDto.PublicoAlvo);
var curso = new Curso(cursoDto.Nome, cursoDto.Descricao, cursoDto.CargaHoraria, publicoAlvo, cursoDto.Valor);
if (cursoDto.Id > 0)
{
curso = _cursoRepositorio.ObterPorId(cursoDto.Id);
curso.AlterarNome(cursoDto.Nome);
curso.AlterarValor(cursoDto.Valor);
curso.AlterarCargaHoraria(cursoDto.CargaHoraria);
}
if (cursoDto.Id == 0)
{
_cursoRepositorio.Adicionar(curso);
}
}
public void AlterarNome(string nome)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), Resource.NomeInvalido)
.DispararExcecaoSeExistir();
Nome = nome;
}
public void Armazenar(CursoDto cursoDto)
{
var cursoJaSalvo = _cursoRepositorio.ObterPeloNome(cursoDto.Nome);
ValidadorDeRegra.Novo()
.Quando(cursoJaSalvo != null && cursoJaSalvo.Id != cursoDto.Id, Resource.NOME_CURSO_EXISTENTE)
//.Quando(!Enum.TryParse<EPublicoAlvo>(cursoDto.PublicoAlvo, out var publicoAlvo), Resource.PUBLICO_ALVO_INVALIDO)
.DispararExcecaoSeExistir();
var publicoAlvo = _conversorDePublicoAlvo.Converter(cursoDto.PublicoAlvo);
var curso = new Curso(cursoDto.Nome, cursoDto.Descricao, cursoDto.CargaHoraria,
(EPublicoAlvo)publicoAlvo, cursoDto.Valor);
if (cursoDto.Id > 0)
{
curso = _cursoRepositorio.ObterPorId(cursoDto.Id);
curso.AlterarNome(cursoDto.Nome);
curso.AlterarValor(cursoDto.Valor);
curso.AlterarCargaHoraria(cursoDto.CargaHoraria);
}
if (cursoDto.Id == 0)
{
_cursoRepositorio.Adicionar(curso);
}
}
public void Cadastrar(AlunoDto alunoDto)
{
var comCpfJaCadastrado = _alunoRepositorio.ObterPeloCpf(alunoDto.Cpf);
ValidadorDeRegra.Novo()
.Quando(comCpfJaCadastrado != null && comCpfJaCadastrado.Id != alunoDto.Id, Resource.CpfJaCadastrado)
.DispararExcecaoSeExistir();
if (alunoDto.Id == 0)
{
var publicoAlvoConvertido = _conversorDePublicoAlvo.Converter(alunoDto.PublicoAlvo);
Aluno aluno = new Aluno(
alunoDto.Nome,
alunoDto.Cpf,
alunoDto.Email,
publicoAlvoConvertido
);
_alunoRepositorio.Adicionar(aluno);
}
else if (alunoDto.Id > 0)
{
var aluno = _alunoRepositorio.ObterPorId(alunoDto.Id);
aluno.AlterarNome(alunoDto.Nome);
}
}
public void Armazenar(CursoDto cursoDto)
{
var cursoJaSalvo = _cursoRepositorio.ObterPeloNome(cursoDto.Nome);
ValidadorDeRegra.Novo()
.Quando(!Enum.TryParse(cursoDto.PublicoAlvo, out PublicoAlvo publicoAlvo), Resource.PublicoAlvoInvalido)
.Quando(cursoJaSalvo != null && cursoJaSalvo.Id != cursoDto.Id, Resource.CursoJaCadastrado)
.DispararExcecaoSeExistir();
var curso = new Curso(cursoDto.Nome, cursoDto.Descricao, cursoDto.CargaHoraria, publicoAlvo, cursoDto.Valor);
if (cursoDto.Id > 0)
{
curso = _cursoRepositorio.ObterPeloId(cursoDto.Id);
curso.AlterarNome(cursoDto.Nome);
curso.AlterarDescricao(cursoDto.Descricao);
curso.AlterarValor(cursoDto.Valor);
curso.AlterarCargaHoraria(cursoDto.CargaHoraria);
_cursoRepositorio.Atualizar(curso);
}
else
{
_cursoRepositorio.Adicionar(curso);
}
}
public void AlterarCargaHoraria(double cargaHoraria)
{
ValidadorDeRegra.Novo()
.Quando(cargaHoraria < 1, Resource.CargaHorariaInvalida)
.DispararExcecaoSeExistir();
CargaHoraria = cargaHoraria;
}
public void AlterarValor(double valor)
{
ValidadorDeRegra.Novo()
.Quando(valor < 1, Resource.VALOR_INVALIDO)
.DispararExcecaoSeExistir();
this.Valor = valor;
}
public void AlterarCargaHoraria(double cargaHoraria)
{
ValidadorDeRegra.Novo()
.Quando(cargaHoraria < 1, Resource.CARGA_HORARIA_INVALIDA)
.DispararExcecaoSeExistir();
this.CargaHoraria = cargaHoraria;
}
public void Cancelar()
{
ValidadorDeRegra.Novo()
.Quando(MatriculaConcluida, Resource.MatriculaConcluida)
.DispararExcecaoSeExistir();
Cancelada = true;
}
public void AlterarValor(double valor)
{
ValidadorDeRegra.Novo()
.Quando(valor < 1, Resource.ValorInvalido)
.DispararExcecaoSeExistir();
Valor = valor;
}
public PublicoAlvo Converter(string publicoAlvo)
{
ValidadorDeRegra.Novo()
.Quando(!Enum.TryParse <PublicoAlvo>(publicoAlvo, out var publicoAlvoConvertido), Resource.PublicoAlvoInvalido)
.DispararExcecaoSeExistir();
return(publicoAlvoConvertido);
}
public void AlterarValor(decimal valorCurso)
{
ValidadorDeRegra.Novo()
.Quando(valorCurso < 1, Resource.ValorCursoInvalido)
.DispararExcecaoSeExistir();
Valor = valorCurso;
}
public EPublicoAlvo Converter(string publicoAlvo)
{
ValidadorDeRegra.Novo()
.Quando(!Enum.TryParse <EPublicoAlvo>(publicoAlvo, out var publicoAlvoConvertido), Resource.PUBLICO_ALVO_INVALIDO)
.DispararExcecaoSeExistir();
return(publicoAlvoConvertido);
}
public void AlteraDataNasc(string newData)
{
ValidadorDeRegra.Novo()
.Quando(this.ValidarData(newData), Resource.DataInvalida)
.DispararExcecaoSeExistir();
DataNasc = newData;
}
public void Concluir(int matriculaId, double notaDoAluno)
{
var matricula = _matriculaRepositorio.ObterPorId(matriculaId);
ValidadorDeRegra.Novo()
.Quando((matricula == null), Resource.MatriculaNaoEncontrada)
.DispararExcecaoSeExistir();
matricula.InformarNota(notaDoAluno);
}
public void InformarNota(double notaDoAluno)
{
ValidadorDeRegra.Novo()
.Quando((notaDoAluno < 0 || notaDoAluno > 10), Resource.NotaDoAlunoInvalida)
.Quando((Cancelada), Resource.MatriculaCancelada)
.DispararExcecaoSeExistir();
NotaDoAluno = notaDoAluno;
CursoConcluido = true;
}
public void Cancelar(int matriculaId)
{
var matricula = _matriculaRepositorio.ObterPorId(matriculaId);
ValidadorDeRegra.Novo()
.Quando((matricula == null), Resource.MatriculaNaoEncontrada)
.DispararExcecaoSeExistir();
matricula.Cancelar();
}
public void InformarNota(double nota)
{
ValidadorDeRegra.Novo()
.Quando(nota < 0 || nota > 10, Resource.NotaInvalida)
.Quando(Cancelada, Resource.MatriculaCancelada)
.DispararExcecaoSeExistir();
NotaDoAluno = nota;
MatriculaConcluida = true;
}
public Produto(string nome, string codigo, int valor, int quantidade)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), Resource.NomeProdutoInvalido)
.Quando(string.IsNullOrEmpty(codigo), Resource.CodigoProdutoInvalido)
.DispararExcecaoSeExistir();
Nome = nome;
Codigo = codigo;
Valor = valor;
Quantidade = quantidade;
}
public Aluno(string nome, string email, string cpf, PublicoAlvo publicoAlvo)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), Resource.NomeInvalido)
.Quando(!ValidadorCpf.IsCpf(cpf), Resource.CpfInvalido)
.Quando(string.IsNullOrEmpty(cpf), Resource.CpfInvalido)
.Quando(!ValidadorEmail.IsEmail(email), Resource.EmailInvalido)
.DispararExcecaoSeExistir();
Nome = nome;
Email = email;
Cpf = cpf;
PublicoAlvo = publicoAlvo;
}
public void Armazenar(CursoDto cursoDto)
{
var cursoJaSalvo = _cursoRepositorio.ObterPeloNome(cursoDto.Nome);
ValidadorDeRegra.Novo()
.Quando(cursoJaSalvo != null, "Nome do curso já consta no banco de dados")
.Quando(!Enum.TryParse <PublicoAlvo>(cursoDto.PublicoAlvo, out var publicoAlvo), "Publico Alvo Inválido")
.DispararExcecaoSeExistir();
var curso = new Curso(cursoDto.Nome, cursoDto.Descricao, cursoDto.CargaHoraria, (PublicoAlvo)publicoAlvo, cursoDto.Valor);
_cursoRepositorio.Adicionar(curso);
}
public Aluno(string nome, string email, string cpf, EPublicoAlvo publicoAlvo)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), Resource.NOME_INVALIDO)
.Quando(string.IsNullOrEmpty(email) || !_emailRegex.Match(email).Success, Resource.EMAIL_INVALIDO)
.Quando(string.IsNullOrEmpty(cpf) || !_cpfRegex.Match(cpf).Success, Resource.CPF_INVALIDO)
.DispararExcecaoSeExistir();
Nome = nome;
Cpf = cpf;
Email = email;
PublicoAlvo = publicoAlvo;
}
public Curso(string nome, string descricao, double cargaHoraria, EPublicoAlvo publicoAlvo, double valor)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), Resource.NOME_INVALIDO)
.Quando(cargaHoraria < 1, Resource.CARGA_HORARIA_INVALIDA)
.Quando(valor < 1, Resource.VALOR_INVALIDO)
.DispararExcecaoSeExistir();
this.Nome = nome;
this.Descricao = descricao;
this.CargaHoraria = cargaHoraria;
this.PublicoAlvo = publicoAlvo;
this.Valor = valor;
}
public void Criar(MatriculaDto matriculaDto)
{
var curso = _cursoRepositorio.ObterPorId(matriculaDto.CursoId);
var aluno = _alunoRepositorio.ObterPorId(matriculaDto.AlunoId);
ValidadorDeRegra.Novo()
.Quando(curso == null, Resource.CursoNaoEncontrado)
.Quando(aluno == null, Resource.AlunoNaoEncontrado)
.DispararExcecaoSeExistir();
var matricula = new Matricula(aluno, curso, matriculaDto.ValorPago);
_matriculaRepositorio.Adicionar(matricula);
}
public Curso(string nome, string descricao, double cargaHoraria, EPublicoAlvo publicoAlvo, double valor)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), Resource.NomeInvalido)
.Quando(cargaHoraria < 1, Resource.CargaHorariaInvalida)
.Quando(valor < 1, Resource.ValorInvalido)
.DispararExcecaoSeExistir();
Nome = nome;
Descricao = descricao;
CargaHoraria = cargaHoraria;
PublicoAlvo = publicoAlvo;
Valor = valor;
}
public Matricula(Aluno aluno, Curso curso, double valorPago)
{
ValidadorDeRegra.Novo()
.Quando(aluno == null, Resource.AlunoInvalido)
.Quando(curso == null, Resource.CursoInvalido)
.Quando(valorPago < 1, Resource.ValorPagoInvalido)
.Quando(curso != null && valorPago > curso.Valor, Resource.ValorPagoMaiorQueValorDoCurso)
.Quando((aluno != null && curso != null) && (aluno.PublicoAlvo != curso.PublicoAlvo), Resource.PublicosAlvoDiferente)
.DispararExcecaoSeExistir();
Aluno = aluno;
Curso = curso;
ValorPago = valorPago;
TemDesconto = valorPago < curso.Valor;
}
public Curso(string nome, string descricao, decimal cargaHoraria, PublicoAlvo publicoAlvo, decimal valor)
{
ValidadorDeRegra.Novo()
.Quando(string.IsNullOrEmpty(nome), "Nome inválido")
.Quando(cargaHoraria < 1, "Carga horária menor que 1")
.Quando(valor < 1, "Valor menor que 1")
.DispararExcecaoSeExistir();
this.Nome = nome;
this.CargaHoraria = cargaHoraria;
this.PublicoAlvo = publicoAlvo;
this.Valor = valor;
this.Descricao = descricao;
}
