Ejemplo n.º 1
0
        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);
            }
        }
Ejemplo n.º 2
0
        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);
            }
        }
Ejemplo n.º 3
0
        public void Store(CourseDto courseDto)
        {
            var savedCourse = _courseRepository.GetByName(courseDto.Name);

            BaseValidator.New()
            .When(savedCourse != null && savedCourse.Id != courseDto.Id, Resource.CourseAlreadyExists)
            .TriggersIfExceptionExists();

            var publicoAlvo = _targetAudienceConverter.Converter(courseDto.TargetAudience);

            var course =
                new Course(courseDto.Name, courseDto.Description, courseDto.Hours, publicoAlvo, courseDto.Amount);

            if (courseDto.Id > 0)
            {
                course = _courseRepository.GetById(courseDto.Id);
                course.ChangeName(courseDto.Name);
                course.ChangeAmount(courseDto.Amount);
                course.ChangeHours(courseDto.Hours);
            }

            if (courseDto.Id == 0)
            {
                _courseRepository.Add(course);
            }
        }
Ejemplo n.º 4
0
        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);
            }
        }
Ejemplo n.º 5
0
        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);
            }
        }
Ejemplo n.º 6
0
        public void Store(StudentDto studentDto)
        {
            var studentWithSameNif = _studentRepository.GetByNif(studentDto.Nif);

            BaseValidator.New()
            .When(studentWithSameNif != null && studentWithSameNif.Id != studentDto.Id, Resource.AlreadyRegisteredNif)
            .TriggersIfExceptionExists();

            if (studentDto.Id == 0)
            {
                var convertedTargetAudience = _targetAudienceConverter.Converter(studentDto.TargetAudience);
                var student = new Student(studentDto.Name, studentDto.Email, studentDto.Nif, convertedTargetAudience);
                _studentRepository.Add(student);
            }
            else
            {
                var student = _studentRepository.GetById(studentDto.Id);
                student.ChangeName(studentDto.Nif);
            }
        }
Ejemplo n.º 7
0
        public void Armazenar(AlunoDto alunoDto)
        {
            var alunoComMesmoCpf = _alunoRepositorio.ObterPeloCpf(alunoDto.Cpf);

            ValidadorDeRegra.Novo()
            .Quando(alunoComMesmoCpf != null && alunoComMesmoCpf.Id == alunoDto.Id, Resource.CpfExistente)
            .DispararExcessaoSeExistir();

            if (alunoDto.Id == 0)
            {
                var publicoAlvoConvertido = _conversorDePublicoAlvo.Converter(alunoDto.PublicoAlvo);
                var aluno = new Aluno(alunoDto.Nome, alunoDto.Email, alunoDto.Cpf, publicoAlvoConvertido);
                _alunoRepositorio.Adicionar(aluno);
            }
            else
            {
                var aluno = _alunoRepositorio.ObterPorId(alunoDto.Id);
                aluno.AlterarNome(alunoDto.Nome);
            }
        }
Ejemplo n.º 8
0
        public void Armazenar(AlunoDto alunoDto)
        {
            var alunoComMesmoCpf = _alunoRepositorio.ObterPeloCpf(alunoDto.Cpf);

            ValidadorDeRegra.Novo()
            .Quando(alunoComMesmoCpf != null && alunoComMesmoCpf.Id != alunoDto.Id, Resource.CPF_EXISTENTE)
            //.Quando(!Enum.TryParse<EPublicoAlvo>(alunoDto.PublicoAlvo, out var publicoAlvoConvertido), Resource.PUBLICO_ALVO_INVALIDO)
            .DispararExcecaoSeExistir();

            if (alunoDto.Id == 0)
            {
                var publicoAlvoConvertido = _conversorDePublicoAlvo.Converter(alunoDto.PublicoAlvo);
                var aluno = new Aluno(alunoDto.Nome, alunoDto.Email, alunoDto.Cpf, publicoAlvoConvertido);
                _alunoRepositorio.Adicionar(aluno);
            }
            else
            {
                var aluno = _alunoRepositorio.ObterPorId(alunoDto.Id);
                aluno.AlterarNome(alunoDto.Nome);
            }
        }