/// <summary>
        /// Verifica se o ID do médico e da clínica são válidos e se os campos foram preenchidos.
        /// Antes de alterar os dados do atendimento no Database.
        /// </summary>
        /// <param name="id">Usado para buscar um atendimento no Database.</param>
        /// <param name="entity">Objeto com os dados do atendimento.</param>
        /// <returns>Seleciona o atendimento alterado no Databse ou gera uma exceção.</returns>
        public Atendimento Alterar(int id, Atendimento entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se o ID do médico é válido.
            var RepositorioMedico = new MedicoRepositorio();

            if (RepositorioMedico.SelecionarPorId(entity.IdMedico) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhum médico " +
                                                $"com o ID: {entity.IdMedico}");
            }

            //Verifica se o ID da clínica é válido.
            var RepositorioClinica = new ClinicaRepositorio();

            if (RepositorioClinica.SelecionarPorId(entity.IdClinica) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhuma clínica " +
                                                $"com o ID: {entity.IdMedico}");
            }

            entity.Id = id;
            _atendimentoRepositorio.Alterar(entity);

            return(_atendimentoRepositorio.SelecionarPorId(id));
        }
Beispiel #2
0
        /// <summary>
        ///Verifica se nome da especialidade foi preenchido, se ele respeita o limite de caracteres
        /// determinado no Database e se ele já foi cadastrado. Antes de alterar os dados da especialidade.
        /// </summary>
        /// <param name="entity">Objeto com os dados da especialidade.</param>
        /// <param name="id">Usado para buscar a especialidade no Database.</param>
        /// <returns>Seleciona a especialidade alterada no Database ou gera uma exceção.</returns>
        public Especialidade Alterar(int id, Especialidade entity)
        {
            Especialidade obj;

            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("O campo \"Nome\" é obrigatório e deve ser preenchido!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica se a especialidade já não foi cadastrada.
            obj = _especialidadeRepositorio.SelecionarPorNome(entity.Nome);
            if (obj != null && obj.Id != id)
            {
                throw new ConflitoException($"A especialidade: \"{entity.Nome}\", já foi cadastrada!");
            }

            entity.Id = id;
            _especialidadeRepositorio.Alterar(entity);

            return(_especialidadeRepositorio.SelecionarPorId(id));
        }
Beispiel #3
0
        /// <summary>
        /// Verifica se o ID da especialidade, da clínica e do valor da consulta
        /// são válidos e se os campos foram preenchidos.
        /// Antes de inserir os dados do valor da consulta no Database.
        /// </summary>
        /// <param name="entity">Objeto com os dados do valor da consulta.</param>
        /// <returns>ID do valor da consulta inserido no Databse ou gera uma exceção.</returns>
        public int Inserir(ValorConsulta entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se o ID da especialidade é válido.
            var RepositorioEspecialidade = new EspecialidadeRepositorio();

            if (RepositorioEspecialidade.SelecionarPorId(entity.IdEspecialidade) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhuma especialidade " +
                                                $"com o ID: {entity.IdEspecialidade}");
            }

            //Verifica se o ID da clínica é válido.
            var RepositorioClinica = new ClinicaRepositorio();

            if (RepositorioClinica.SelecionarPorId(entity.IdClinica) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhuma clínica " +
                                                $"com o ID: {entity.IdClinica}");
            }

            //Verifica se o valor valor da consulta é válido.
            if (entity.Valor <= 0)
            {
                throw new DadoInvalidoException($"O valor: \"{entity.Valor}\", é inválido!");
            }

            return(_valorConsultaRepositorio.Inserir(entity));
        }
        /// <summary>
        /// Verifica se o ID do TipoExame e da clínica são válidos e se os campos foram preenchidos.
        /// Antes de inserir os dados do valor de exame no Database.
        /// </summary>
        /// <param name="entity">Objeto com os dados do valor de exame.</param>
        /// <returns>ID do valorExame inserido no Databse ou gera uma exceção.</returns>
        public int Inserir(ValorExame entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se o ID do TipoExame é válido.
            var RepositorioTipoExame = new TipoExameRepositorio();

            if (RepositorioTipoExame.SelecionarPorId(entity.IdTipoExame) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhum Tipo de Exame " +
                                                $"com o ID: {entity.IdTipoExame}");
            }

            //Verifica se o ID da Clinica é válido.
            var RepositorioClinica = new ClinicaRepositorio();

            if (RepositorioClinica.SelecionarPorId(entity.IdClinica) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhuma Clinica " +
                                                $"com o ID: {entity.IdClinica}");
            }

            //Verifica se o valor valor do exame é válido.
            if (entity.Valor <= 0)
            {
                throw new DadoInvalidoException($"O valor: \"{entity.Valor}\", é inválido!");
            }

            return(_valorExameRepositorio.Inserir(entity));
        }
Beispiel #5
0
        /// <summary>
        /// Verifica se existem campos obrigatórios não preenchidos, se o ID do atendimento e do paciente
        /// são válidos e se os campos respeitam os limites de caracteres especificados no Database.
        /// Antes de inserir uma clínica.
        /// </summary>
        /// <param name="entity">Objeto com os dados da consulta.</param>
        /// <returns>ID da consulta inserida no Databse ou gera uma exceção.</returns>
        public int Inserir(Consulta entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica se o ID do atendimento é válido.
            var RepositorioMedico = new AtendimentoRepositorio();

            if (RepositorioMedico.SelecionarPorId(entity.IdAtendimento) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhum antendimento " +
                                                $"com o ID: {entity.IdAtendimento}");
            }

            //Verifica se o ID do paciente é válido.
            var RepositorioPaciente = new PacienteRepositorio();

            if (RepositorioPaciente.SelecionarPorId(entity.IdPaciente) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhum paciente " +
                                                $"com o ID: {entity.IdAtendimento}");
            }

            return(_consultaRepositorio.Inserir(entity));
        }
Beispiel #6
0
        /// <summary>
        /// Método Com as válidações necessarias para o nível de Papel.
        /// </summary>
        /// <param name="entity"></param>
        public void Validacoes(NivelPapel entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }
        }
        /// <summary>
        /// Verifica se o horario ja existe um horario cadastrado no mesmo dia e horario, se o Dia e o horario é válido, se existem campos obrigatórios
        /// que não estão preenchidos, se os campos respeitam os limites de caracteres especificados no Database.
        /// </summary>
        /// <param name="entity">Objeto com os dados do médico.</param>
        /// <returns>ID do médico inserido no Database ou gera alguma exceção.</returns>
        public int Inserir(HorariosExame entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }
            List <HorariosExame> obj = _horariosExameRepositorio.SelecionarPorDiaNegocio(entity.DiaHora);

            if (obj.Count != 0)
            {
                List <HorariosExame> Obj = _horariosExameRepositorio.SelecionarPorHoraNegocio(entity.DiaHora);
                if (Obj.Count != 0)
                {
                    throw new ConflitoException("O horario ja foi marcado como Disponivel!");
                }
            }
            return(_horariosExameRepositorio.Inserir(entity));
        }
Beispiel #8
0
        public void Validacoes(Unidade entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica se a unidade já foi cadastrada.
            if (_unidadeRepositorio.SelecionarPorNome(entity.Nome) != null)
            {
                throw new ConflitoException($"A unidade: \"{entity.Nome}\", já foi cadastrada!");
            }
        }
Beispiel #9
0
        public void Validacoes(Papel entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica se o papel já foi cadastrado.
            if (_papelRepositorio.SelecionarPorDescricao(entity.Desc) != null)
            {
                throw new ConflitoException($"O papel: \"{entity.Desc}\", já foi cadastrado!");
            }
        }
        /// <summary>
        /// Verifica se o CNPJ não está cadastrado e se ele é válido, se existem campos obrigatórios
        /// sem serem preenchidos e se o telefone é válido. Antes de alterar uma clínica.
        /// </summary>
        /// <param name="entity">Objeto com os dados da clínica a ser inserida.</param>
        /// <returns>Seleciona a clínica alterada no Database ou gera alguma exceção.</returns>
        public Clinicas Alterar(int id, Clinicas entity)
        {
            Clinicas obj;

            //Verififica se há campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica se o CNPJ é válido e se ele já foi cadastrado
            if (ValidacaoCnpj.Verificar(entity.Cnpj) == false)
            {
                throw new DadoInvalidoException("CNPJ inválido!");
            }
            else
            {
                obj = _clinicaRepositorio.SelecionarPorCnpj(entity.Cnpj);
                if (obj != null && obj.Id != id)
                {
                    throw new ConflitoException("Já existe uma clínica registrada com este CNPJ!");
                }
            }

            //Verifica se o formato e a quantidade de caracteres do telefone são válidos.
            if (TelefoneValido.Verificar(TelefoneValido.LimparFormatacao(entity.TelefoneCom)) == false)
            {
                throw new DadoInvalidoException($"O número de telefone:\"{entity.TelefoneCom}\" é inválido!");
            }

            entity.Id = id;
            _clinicaRepositorio.Alterar(entity);

            return(_clinicaRepositorio.SelecionarPorId(id));
        }
Beispiel #11
0
        /// <summary>
        /// Verifica se os campos obrigátorios foram preenchidos e se o ID do tipo de exame,
        /// do atentidmento e da consulta são válidos. Antes de alterar os dados do exame o Database.
        /// </summary>
        /// <param name="id">Usado prara buscar o exame.</param>
        /// <param name="entity">Objeto com os dados do Exame.</param>
        /// <returns>Seleciona o exame alterado no Database ou gera uma exceção.</returns>
        public Exame Alterar(int id, Exame entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("O campo DataHora é obrigatório e deve ser preenchido!");
            }

            //Verifica se existe o Id do TipoExame é válido.
            var RepositorioTipoExame = new TipoExameRepositorio();

            if (RepositorioTipoExame.SelecionarPorId(entity.IdTipoExame) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhum Tipo de Exame " +
                                                $"com o ID: {entity.IdTipoExame}");
            }

            //Verifica se existe o Id do atendimento é válido.
            var RepositorioAtendimento = new AtendimentoRepositorio();

            if (RepositorioAtendimento.SelecionarPorId(entity.IdAtendimento) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhuma Clínica" +
                                                $" com o ID: {entity.IdTipoExame}");
            }

            //Verifica se existe o Id da consulta é válido.
            var RepositorioConsulta = new ConsultaRepositorio();

            if (RepositorioConsulta.SelecionarPorId(entity.IdConsulta) == null)
            {
                throw new DadoInvalidoException($"Não foi encontrado nenhuma Clínica" +
                                                $" com o ID: {entity.IdConsulta}");
            }

            entity.Id = id;
            _exameRepositorio.Alterar(entity);

            return(_exameRepositorio.SelecionarPorId(id));
        }
Beispiel #12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="entity"></param>
        public void ValidacoesMembroSquad(MembroSquad entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se o Id da Squad é válido.
            if (_squadRepositorio.SelecionarPorId(entity.IdSquad) == null)
            {
                throw new NaoEncontradoException($"Não foi encontrado nenhuma Squad " +
                                                 $"com o ID: {entity.IdSquad}");
            }

            //Verifica se o Id do Usuário é válido.
            if (_userRepositorio.SelecionarPorId(entity.IdSquad) == null)
            {
                throw new NaoEncontradoException($"Não foi encontrado nenhum usuário " +
                                                 $"com o ID: {entity.IdUser}");
            }
        }
Beispiel #13
0
        /// <summary>
        /// Verifica se nome da especialidade foi preenchido, se ele respeita o limite de caracteres
        /// determinado no Database e se ele já foi casatrado. Antes de inserir a especialidade.
        /// </summary>
        /// <param name="entity">Objeto com os dados da especialidade.</param>
        /// <returns>ID da especialidade inserido no Databse ou gera alguma exceção.</returns>
        public int Inserir(Especialidade entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("O campo \"Nome\" é obrigatório e deve ser preenchido!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("O campo \"Nome\" excedeu o limite de caracteres permitidos!");
            }

            //Verifica se a especialidade já não foi cadastrada.
            if (_especialidadeRepositorio.SelecionarPorNome(entity.Nome) != null)
            {
                throw new ConflitoException($"A especialidade: \"{entity.Nome}\", já foi cadastrada!");
            }

            return(_especialidadeRepositorio.Inserir(entity));
        }
        public void Validacoes(User entity)
        {
            var UserExistente  = _userRepositorio.SelecionarPorNome(entity.Nome);
            int UserExistente_ = UserExistente.Count();

            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica se o usuário já foi cadastrado.
            if (UserExistente_ != 0)
            {
                throw new ConflitoException($"O usuário: \"{entity.Nome}\", já foi cadastrado!");
            }
        }
        /// <summary>
        /// Verifica o horario ja existe um horario cadastrado no mesmo dia e horario, se o Dia e o horario é válido, se existem campos obrigatórios
        /// que não estão preenchidos, se os campos respeitam os limites de caracteres especificados no Database.
        /// </summary>
        /// <param name="entity">Objeto com os dados do médico.</param>
        /// <returns>Seleciona um HorarioConsulta do Database ou gera alguma exceção.</returns>
        public HorariosConsulta Alterar(int id, HorariosConsulta entity)
        {
            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            List <HorariosConsulta> obj = _horariosConsultaRepositorio.SelecionarPorDiaNegocio(entity.DiaHora);

            if (obj.Count > 0)
            {
                var Obj = _horariosConsultaRepositorio.SelecionarPorHoraNegocio(entity.DiaHora);
                if (Obj.Count > 0)
                {
                    throw new ConflitoException("O horario ja foi marcado como Disponivel!");
                }
            }

            entity.Id = id;
            _horariosConsultaRepositorio.Alterar(entity);
            return(_horariosConsultaRepositorio.SelecionarPorId(id));
        }
        /// <summary>
        /// Verifica se o CNPJ não está cadastrado e se ele é válido, se existem campos obrigatórios
        /// sem serem preenchidos e se o telefone é válido. Antes de inserir uma clínica.
        /// </summary>
        /// <param name="entity">Objeto com os dados da clínica a ser inserida.</param>
        /// <returns>ID da clínica inserida no Database ou gera alguma exceção.</returns>
        public int Inserir(Clinicas entity)
        {
            //Verififica se há campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Verifica a validação do CNPJ
            if (!ValidacaoCnpj.Verificar(entity.Cnpj))
            {
                throw new DadoInvalidoException("CNPJ inválido!");
            }

            //Verifica se o CNPJ já não está registrado.
            var obj = _clinicaRepositorio.SelecionarPorCnpj(entity.Cnpj);

            if (obj != null)
            {
                throw new ConflitoException("Já existe uma clínica registrada com este CNPJ!");
            }

            //Verifica se o formato e a quantidade de caracteres do telefone são válidos.
            if (TelefoneValido.Verificar(TelefoneValido.LimparFormatacao(entity.TelefoneCom)) == false)
            {
                throw new DadoInvalidoException($"O número de telefone:\"{entity.TelefoneCom}\" é inválido!");
            }

            return(_clinicaRepositorio.Inserir(entity));
        }
Beispiel #17
0
        /// <summary>
        /// Verifica se o CPF, o CRM e o email já não estão cadastrados, se o CPF é válido, se existem campos obrigatórios
        /// que não estão preenchidos, se os campos respeitam os limites de caracteres especificados no Database e se o
        /// médico é maior de idade. Antes de alterar os dados sobre um médico.
        /// </summary>
        /// <param name="id">Usado para buscar o médico no Database.</param>
        /// <param name="entity">Objeto com as informações a serem alteradas.</param>
        /// <returns>Seleciona um médico do Database ou gera alguma exceção.</returns>
        public Medico Alterar(int id, Medico entity)
        {
            Medico obj;

            //Verifica se existem campos vazios.
            if (CamposVazios.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
            }

            //Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
            if (ExcedeLimiteDeCaracteres.Verificar(entity))
            {
                throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
            }

            //Converte o gênero para caixa alta e verifica se o gênero é válido.
            if (GeneroValido.Verificar(GeneroValido.CaixaAlta(entity.Genero)) == false)
            {
                throw new DadoInvalidoException($"O gênero: \"{entity.Genero}\", é inválido!");
            }

            //Verifica se o formato e a quantidade de caracteres do celular são válidos.
            if (TelefoneValido.Verificar(TelefoneValido.LimparFormatacao(entity.Celular)) == false)
            {
                throw new DadoInvalidoException($"O número de celular:\"{entity.Celular}\" é inválido!");
            }

            //Verifica se o CRM já não foi cadastrado.
            obj = _medicoRepositorio.SelecionarPorCrm(entity.Crm);
            if (obj != null && obj.Id != id)
            {
                throw new ConflitoException($"O CRM: \"{entity.Crm}\", já foi cadastrado!");
            }

            //Verifica se o CPF é válido e se ele já foi cadastrado.
            if (ValidacaoCpf.Verificar(entity.Cpf) == false)
            {
                throw new DadoInvalidoException($"O CPF: \"{entity.Cpf}\" é invalido!");
            }
            else
            {
                obj = _medicoRepositorio.SelecionarPorCpf(entity.Cpf);
                if (obj != null && obj.Id != id)
                {
                    throw new ConflitoException($"O CPF: \"{entity.Cpf}\", já foi cadastrado!");
                }
                else if (_pacienteRepositorio.SelecionarPorCpf(entity.Cpf) != null)
                {
                    throw new ConflitoException($"O CPF: \"{entity.Cpf}\", já foi cadastrado!");
                }
            }

            //Verifica se o email já foi casatrado.
            obj = _medicoRepositorio.SelecionarPorEmail(entity.Email);
            if (obj != null && id != obj.Id)
            {
                throw new ConflitoException($"O email: \"{entity.Email}\", já foi cadastrado!");
            }

            //Verifica se o médico é maior de idade.
            if (Maioridade.Verificar(entity.DataNasc) == false)
            {
                throw new DadoInvalidoException("Idade inválida - Apenas maiores de 18 anos podem se cadastrar");
            }

            entity.Id = id;
            _medicoRepositorio.Alterar(entity);

            return(_medicoRepositorio.SelecionarPorId(id));
        }