ChatGPT e programação: aumente sua produtividade

Boas-vindas ao curso ChatGPT e programação: aumente sua produtividade! Meu nome é Rodrigo Ferreira, sou uma das pessoas instrutoras da Alura, e serei o instrutor que vai te acompanhar ao longo desse curso.

Rodrigo é um homem branco de cabeço castanho-escuro curto e liso. Ele veste uma camiseta azul e usa um fone de ouvido branco. No ambiente ao fundo, há uma parede branca iluminada em degradê de azul e roxo, com dois quadros de moldura preta à sua direita.

Talvez você já tenha ouvido falar em ChatGPT, uma ferramenta que está bastante popular no momento. Ela nos ajuda com diversas áreas, inclusive no trabalho com programação.

A ideia desse curso é explorar o ChatGPT e aprender a fazer o melhor uso dessa ferramenta incrível para nos auxiliar no dia a dia com programação.

Caso trabalhe com isso, independentemente da tecnologia utilizada ou da sua área, seja front-end, back-end, Java, PHP, Mobile, você pode usar essa ferramenta para aprender coisas novas, automatizar tarefas, e aumentar a produtividade no cotidiano.

Objetivos

Aprenderemos alguns cenários de uso do ChatGPT no dia a dia de uma pessoa que trabalha com programação. Por exemplo: utilizaremos a ferramenta para entender algoritmos.

Imagine que você pegou um código, seja de uma biblioteca, de um framework, ou de outra pessoa que trabalha com você, e não entendeu exatamente o que ele faz. Porém, por algum motivo, não há como perguntar para a pessoa no momento.

Nesse caso, podemos perguntar para o ChatGPT! Ele consegue entender o código e nos explicá-lo detalhadamente passo a passo, independentemente da linguagem ou do tipo de código.

Além disso, usaremos o ChatGPT como ferramenta de aprendizado, para compreender conceitos. Podemos pedir para ele explicar conceitos de programação, de orientação a objetos, de algum padrão de projeto, ou qualquer outro princípio da área. Aprenderemos a fazer isso de maneira assertiva.

Também usaremos a ferramenta para encontrar bugs no código. Eventualmente, podemos ter algum código com erro, e mesmo analisando minuciosamente, não conseguimos identificar o bug. Nesse cenário, basta colar o código e pedir para que o ChatGPT identifique onde está o erro.

O principal uso que faremos da ferramenta é a geração de códigos. Vamos observar diversos cenários em que o ChatGPT pode gerar automaticamente os códigos necessários, e faremos isso com diferentes tipos de código para diferentes situações.

É esse o objetivo do curso: utilizar o ChatGPT para aprender coisas novas e gerar códigos de forma automatizada, ganhando mais agilidade, mais produtividade, e evitando a construção de códigos repetitivos que, geralmente, consideramos chatos, mas que precisam ser feitos nos projetos.

Requisitos

Para fazer esse curso, você precisa conhecer e saber usar o ChatGPT.

Na plataforma da Alura, existem outros cursos que ensinam a usar a ferramenta, então nessa etapa, não aprenderemos do zero o que é o ChatGPT e como criar uma conta. Vamos considerar que você já conhece a ferramenta e tem uma conta criada. Assim, podemos em focar no uso do ChatGPT para nos auxiliar em programação!

Além disso, você precisa saber programação. Como o objetivo desse curso em específico é utilizar a ferramenta como auxílio para programação, é esperado que você já tenha esse tipo de conhecimento em qualquer linguagem (PHP, .NET, Java, Python…).

A linguagem não importa, desde que você conheça alguns pontos principais:

• O que é uma API Rest, projeto que vamos utilizar no curso;
• CRUD (Create, Read, Update, Delete);
• E banco de dados.

Conforme dito anteriormente, o foco do curso não é explicar conceitos técnicos de programação, como o que é uma API Rest, o que é a funcionalidade CRUD, e banco de dados.

Você já precisa conhecer esses conceitos, independentemente da linguagem de tecnologia, porque teremos uma aplicação que usa esses recursos, os quais não serão ensinados no curso.

Nosso objetivo é usar o ChatGPT como ferramenta de apoio à programação.

Ao longo do curso, faremos diversas coisas com base no projeto, usando essa ferramenta fantástica que pode te ajudar muito a ganhar em produtividade e também a aprender coisas novas!

Despertou seu interesse? Então, vamos começar. Te vejo na primeira aula!

Anteriormente, passamos pela atividade de configuração do ambiente e agora temos o projeto importado no IntelliJ. Conforme mencionado, nesse curso, trabalharemos no projeto de uma aplicação em Java, mas independentemente da linguagem de programação utilizada, focaremos no ChatGPT e em como ele pode auxiliar em programação.

Como precisávamos de um projeto, ele foi escrito em Java, mas poderia ser em qualquer outra linguagem, então não precisamos nos preocupar com esse detalhe. Nosso foco é saber como utilizar o ChatGPT para ajudar no dia a dia com programação.

Conhecendo o projeto

Com o projeto aberto no IntelliJ, vamos entendê-lo um pouco melhor antes de começar com o ChatGPT. Primeiramente, vamos executar a aplicação e fazer um teste.

Vimos anteriormente que o projeto se trata de uma API Rest. Para executá-lo, vamos acessar o painel lateral esquerdo da interface e expandir o projeto "vollmed-api". Encontraremos a pasta "src", contendo o diretório "main", que contém o diretório "java", onde está armazenado todo o código-fonte do projeto.

Entre os arquivos, temos a classe ApiApplication.java. Vamos abri-la:

package med.voll.api;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;




@SpringBootApplication
public class ApiApplication {




public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}


}

Na linha de código 7, onde está a classe ApiApplication, há um ícone de play na lateral esquerda. Vamos clicar sobre ele e selecionar a opção "Run 'ApiApplication.main()'".

Então, temos uma classe com o método main() que irá executar a aplicação e carregar toda a infraestrutura da nossa API.

Após executar, será retornado um log na aba "Run", indicando o que está sendo feito. Trata-se do log das bibliotecas e frameworks do mundo Java.

Ao final do log, é importante aparecer a seguinte linha:

Tomcat started on port(s): 8080 (http) with context path ''

Isso indica que o servidor inicializou na porta 8080. Uma vez inicializado o projeto, já podemos disparar requisições para a API usando o endereço "localhost:8080".

As requisições também foram disponibilizadas para fazermos os testes.

Por ser uma API, não temos tela de interface, então testaremos por meio de algum aplicativo de testes de API. Nesse caso, o Postman.

O instrutor já importou as coleções com as requisições. São elas:

• Agenda Consultas
• CRUD Médicos
• CRUD Pacientes
• Relatórios

Estamos trabalhando no projeto de uma clínica médica. Na coleção de CRUD de médicos, temos as requisições referentes às funcionalidades de médicos, que são: "Cadastrar médico", "Listar médicos", "Detalhar médico", "Atualizar médico", e "Excluir médico".

Além disso, temos um CRUD de pacientes, com as mesmas funcionalidades; uma parte de relatórios, que contém somente 1 relatório; e a parte de agendamento de consultas, contendo duas requisições.

Essa é a aplicação e suas funcionalidades!

Identificando bugs

No Postman, conseguimos simular e testar a API.

Vamos começar, por exemplo, com o teste de cadastro de paciente. Para isso, acessamos a coleção "CRUD Pacientes" e abrimos a requisição do tipo POST "Cadastrar paciente".

{
    "nome": "Paciente 1",
    "email": "[email protected]",
    "cpf": "123.123.123-00",
    "telefone": "61999998888",
    "endereco": {
        "logradouro": "Rua",
        "bairro": "Bairro",
        "cep": "12345678",
        "cidade": "Cidade",
        "uf": "UF",
        "numero": "1",
        "complemento": "Complemento"
    }
}

Na seção direita do Postman, são exibidos os detalhes da requisição. Na barra de endereços, temos o "localhost:8080/pacientes", e no corpo da requisição (aba "Body"), temos um JSON representando os dados que serão enviados para a aplicação.

Estamos basicamente cadastrando um novo paciente, então temos campos como nome, email, cpf, telefone, e os dados de endereco.

Vamos clicar no botão azul "Send", à direita da barra de endereço, para disparar a requisição. Feito isso, será aberta uma barra inferior contendo a resposta devolvida pelo servidor, nesse caso, "201 Created".

Será devolvido também o corpo da resposta. No caso, a API devolveu um JSON com os dados do paciente recém-cadastrado:

{
    "id": 1,
    "ativo": true,
    "nome": "Paciente 1",
    "email": "[email protected]",
    "cpf": "123.123.123-00",
    "telefone": "61999998888",
    "endereco": {
        "logradouro": "Rua",
        "bairro": "Bairro",
        "cep": "12345678",
        "numero": "1",
        "complemento": null,
        "cidade": "Cidade",
        "uf": "UF"
    }
}

Nesse momento, já identificamos um problema: observando os dados cadastrados no corpo da requisição, preenchemos todas as informações; porém, no retorno do servidor, o campo complemento do endereço foi devolvido com o valor null.

Então, temos um bug no nosso código. Podemos usar o ChatGPT para identificar onde ele está!

Com a ferramenta aberta no navegador, vamos utilizá-la para resolver o problema. O ideal é fazer uma pergunta bastante objetiva e detalhada para o ChatGPT, para que ele consiga nos auxiliar da melhor maneira possível.

Podemos explicar o contexto e solicitar ajuda da seguinte forma:

Tenho uma aplicação desenvolvida em Java, utilizando o framework Spring Boot, com uma funcionalidade de cadastro de pacientes que está com um bug. Poderia me auxiliar na detecção desse bug?

Geralmente, o ChatGPT é bastante simpático e aberto, então foi obtida a mensagem abaixo:

Claro, ficarei feliz em ajudar você a encontrar o bug em sua aplicação Java com o Spring Boot. Por favor, forneça mais informações sobre o problema em questão. Descreva o comportamento indesejado que está ocorrendo e inclua qualquer mensagem de erro ou trecho de código relevante. Quanto mais detalhes você puder fornecer, melhor será a minha compreensão do problema e mais precisa será minha assistência.

Agora, sim, forneceremos os detalhes. Começamos com o contexto inicial, então nessa segunda etapa já podemos colar o código e pedir para que a ferramenta tente encontrar o erro.

Retornando ao IntelliJ, vamos buscar pelo método de cadastro de paciente. Ele está localizado na linha de código 29 do arquivo PacienteController.java:

@PostMapping
@Transactional
public ResponseEntity<DadosDetalhamentoPaciente> cadastrar(@RequestBody @Valid DadosCadastroPaciente dados, UriComponentsBuilder uriBuilder) {
    var detalhesPaciente = service.cadastrar(dados);
    var uri = uriBuilder.path("/pacientes/{id}").buildAndExpand(detalhesPaciente.id()).toUri();
    return ResponseEntity.created(uri).body(detalhesPaciente);
}

Com o código copiado, vamos retornar ao ChatGPT e colar o trecho no campo de perguntas. Em seguida, vamos pressionar "Shift" e teclar "Enter" para dar um espaço após o código.

Além do método, precisamos levar também o restante das classes do projeto, para que o ChatGPT possa analisar. O método cadastrar() recebe como parâmetro a classe DadosCadastroPaciente. Ela é muito importante, pois o ChatGPT precisará analisá-la para tentar identificar o problema.

Então, vamos copiar todo o código da classe, presente no arquivo DadosCadastroPaciente.java, e colar logo abaixo do método no campo da pergunta.

public record DadosCadastroPaciente(
        @NotBlank
        String nome,

    @NotBlank
    @Email
    String email,

    @NotBlank
    @Pattern(regexp = "^(\\(\\d{2}\\)|\\d{2})\\s?\\d{4,5}-?\\d{4}$")
    String telefone,

    @NotBlank
    @Pattern(regexp = "\\d{3}\\.?\\d{3}\\.?\\d{3}\\-?\\d{2}")
    String cpf,

    @NotNull @Valid 
    DadosEndereco endereco) {


}

A classe DadosCadastroPaciente é composta por outra classe, a DadosEndereco, localizada no arquivo DadosEndereco.java. Também iremos colá-la no ChatGPT.

public record DadosEndereco(
        @NotBlank
        String logradouro,

    @NotBlank
    String bairro,

    @NotBlank
    @Pattern(regexp = "\\d{8}")
    String cep,
    
    @NotBlank
    String cidade,
    
    @NotBlank
    String uf,
    
    String complemento,
    String numero) {


}

Com essas 3 classes, a ferramenta deve conseguir identificar o bug. Caso contrário, ela irá solicitar mais códigos.

A princípio, obtivemos a seguinte resposta:

Obrigado por compartilhar o código. Vou analisar e tentar identificar possíveis problemas ou bugs.

À primeira vista, o código parece estar correto. No entanto, alguns detalhes estão faltando para entender completamente o contexto e a natureza do bug que você está enfrentando.

1. Você poderia fornecer mais informaçõe sobre o comportamento indesejado ou o erro específico que está ocorrendo quando você tenta cadastrar um paciente? Isso ajudará a direcionar minha análise.
2. Além disso, você pode fornecer o código da classe service onde o método cadastrar está implementado? Isso me ajudaria a entender melhor o fluxo de trabalho e verificar se há algum problema nessa parte do código.
3. Certifique-se de que todas as dependências necessárias estão corretamente configuradas no arquivo pom.xml. Se houver algum problema de configuração ou incompatibilidade entre as versões das bibliotecas, isso pode causar erros ou comportamento indesejado.

Por enquanto, com base no código fornecido, não parece haver erros óbvios. O método cadastrar no controlador Spring Boot parece receber dados de cadastro de pacientes, validar as entradas usando as anotações do Bean Validation e, em seguida, chamar o método cadastrar no serviço correspondente. O resultado desse cadastro é retornado como uma resposta HTTP 201 (Created) com o URI do paciente recém-criado.

Por favor, forneça as informações adicionais solicitadas para que eu possa ajudá-lo de maneira mais efetiva a resolver o problema.

Conforme solicitado pelo ChatGPT, vamos informar onde está o bug que buscamos:

O bug está no campo complemento do endereço, que está sendo enviado no JSON, porém está sendo salvo como null.

Com essa informação, a ferramenta encontra o problema:

Obrigado por fornecer mais informações sobre o bug. Com base na sua descrição, o problema parece estar relacionado ao campo "complemento" do objeto DadosEndereco não sendo persistido corretamente. Vamos verificar algumas possíveis causas:

1. Certifique-se de que o campo "complemento" esteja sendo enviado corretamente no JSON da requisição. Verifique se o nome do campo no JSON está correspondendo exatamente ao nome do atributo na classe DadosEndereco.
2. Verifique se o campo "complemento" está configurado corretamente como um parâmetro opcional no construtor do DadosEndereco e se está sendo atribuído corretamente ao atributo correspondente.
3. Verifique se a tabela do banco de dados que armazena os dados dos pacientes possui uma coluna correspondente ao campo "complemento". Se não houver uma coluna para o campo "complemento", pode ser necessário atualizar o esquema do banco de dados para refletir essa alteração.
4. Certifique-se de que o mapeamento do objeto DadosEndereco para a tabela do banco de dados esteja configurado corretamente. Verifique se o mapeamento das colunas está alinhado com os nomes e tipos dos atributos da classe DadosEndereco.

Se nenhuma dessas sugestões resolver o problema, seria útil fornecer o código da classe service onde o método cadastrar está implementado. Isso ajudaria a identificar se há alguma lógica adicional que possa estar causando o comportamento indesejado.

Além disso, verificar os logs e possíveis mensagens de erro relacionados à persistência dos dados também pode ser útil para entender melhor o problema específico que você está enfrentando.

O ChatGPT informa que, com base na informação sobre o bug, foi identificado que o campo complemento está no objeto DadosEndereco, então vamos verificar esse objeto específico no IntelliJ.

No arquivo DadosEndereco.java, temos a classe DadosEndereco, que representa o JSON enviado no Postman. Retornando ao Postman, temos o envio do JSON como requisição, contendo os dados do paciente. Porém, dentro dele há outro objeto que representa os dados do endereço.

// Código suprimido
"endereco": {
"logradouro": "Rua",
"bairro": "Bairro",
"cep": "12345678",
"cidade": "Cidade",
"uf": "UF",
"numero": "1",
"complemento": "Complemento"
}

Esse trecho específico, contendo os dados do endereço, está sendo mapeado para a classe DadosEndereco. Mas em algum lugar desse código está o problema, justamente no caso do complemento. Como enviamos um texto como complemento e o retorno foi nulo, esse campo não foi enviado ou não chegou corretamente.

Analisando esse trecho no código do IntelliJ, o erro está na digitação da String, que deveria ser complemento e está escrita como complemeto. No código Java, o nome do campo está diferente do nome enviado no JSON, porém eles precisam ser iguais.

Com o arquivo DadosEndereco.java aberto, vamos clicar com o botão direito sobre complemeto e ir até "Refactor > Rename…". Será aberta uma janela onde iremos renomear a String como para complemento. Dessa forma, a renomeação irá acontecer também no restante do projeto.

Vamos verificar a aba "Run". Se a configuração estiver correta, ao mexer no código, o projeto será reinicializado.

Para conferir se a configuração está correta, podemos usar o atalho "Ctrl + Alt + S" para abrir a janela "Settings" e acessar "Build, Execution, Deployment > Compiler". A opção "Build project automatically" deve estar ativada.

Finalizada a mudança, vamos retornar o Postman. Agora, precisaremos cadastrar outro paciente, pois há uma regra no projeto que não nos permite cadastrar dois paciente com o mesmo nome, email e CPF. Então, cadastraremos o seguinte:

{
    "nome": "Paciente 2",
    "email": "[email protected]",
    "cpf": "333.333.333-00",
    "telefone": "61999998888",
    "endereco": {
        "logradouro": "Rua",
        "bairro": "Bairro",
        "cep": "12345678",
        "cidade": "Cidade",
        "uf": "UF",
        "numero": "1",
        "complemento": "Complemento"
    }
}

Note que estamos enviando o complemento normalmente, da mesma forma que fizemos antes. Disparada a requisição, teremos o seguinte retorno:

{
    "id": 2,
    "ativo": true,
    "nome": "Paciente 2",
    "email": "[email protected]",
    "cpf": "333.333.333-00",
    "telefone": "61999998888",
    "endereco": {
        "logradouro": "Rua",
        "bairro": "Bairro",
        "cep": "12345678",
        "numero": "1",
        "complemento": "Complemento",
        "cidade": "Cidade",
        "uf": "UF"
    }
}

Agora o complemento foi salvo corretamente!

Perceba que usamos o ChatGPT para nos auxiliar, indicando o problema e enviando o código necessário para identificar o bug.

Eventualmente, a ferramenta passará a perceber que existe algum erro de digitação. Mas nem sempre ela conseguirá detectar logo a princípio. Nesse caso, podemos dar dicas, detalhar melhor, colar novamente apenas trechos específicos do código, entre outras ações.

Fica uma lição importante: o ChatGPT é uma ferramenta que irá nos auxiliar, não nos substituir. Além disso, a ferramenta comete erros.

Nem sempre a resposta será a melhor possível, e nem sempre será retornado um código correto, então cabe a nós avaliarmos a resposta e usar as dicas dadas pela IA, em vez de simplesmente copiar e colar qualquer código trazido como solução.

Conclusão

Esse é um dos usos possíveis do ChatGPT em programação: identificação de bugs. Se você tem um projeto (independentemente da linguagem de programação, das tecnologias e dos frameworks), existe algum bug, e está complicado encontrar a origem apenas analisando o código, ou deseja agilizar esse processo, basta perguntar para o ChatGPT!

Primeiro, tente explicar a tecnologia, a funcionalidade, e o bug. Em seguida, você pode colar o código para que a ferramenta faça sua análise. Talvez seja apontado diretamente o problema, ou talvez sejam dadas dicas, como aconteceu no nosso caso.

Podemos usar o ChatGPT para muitas outras coisas. Veremos na sequência!

No último vídeo, aprendemos a identificar bugs com o auxílio do ChatGPT. Agora daremos continuidade a isso, explorando outras maneiras possíveis de utilizar essa ferramenta para nos ajudar no dia a dia de programação.

Entendendo um código

Vamos retornar ao Postman, onde estamos fazendo os testes da nossa API. Já disparamos algumas requisições para cadastrar médico e cadastrar paciente.

Na funcionalidade de listagem de pacientes (método GET "Listar pacientes"), temos o paciente de id 1 e o de id 2.

Já na funcionalidade de listagem de médicos (método GET "Listar médicos"), temos um médico de id 1, com as informações de nome, email, crm e especialidade.

Listar pacientes:

{
    "content": [
        {
            "id": 1,
            "ativo": true,
            "nome": "Paciente 1",
            "email": "[email protected]",
            "cpf": "123.123.123-00"
        },
        {
            "id": 2
            "ativo": true,
            "nome": "Paciente 2",
            "email": "[email protected]",
            "cpf": "333.333.333-00"
        }
}

Listar médicos:

{
    "content": [
        {
            "id": 1,
            "ativo": true,
            "nome": "Médico 1",
            "email": "[email protected]",
            "crm": "123456",
            "especialidade": "CARDIOLOGIA"
        },
    ]
// Código suprimido

Além dessas funcionalidades, temos outra muito interessante: a de marcação de consulta (método POST "Marcar consulta"). Como ela funciona? Nós disparamos uma requisição levando 3 informações: o ID do paciente (idPaciente), o ID do médico (idMedico), e a data (data), que deve estar no formato "ANO-MÊS-DIATHORA:MINUTO".

{
    "idPaciente": 1,
    "idMedico": 1,
    "data": "2025-10-11T10:00"
}

Vamos disparar a requisição acima. Será devolvido o código 200 OK, indicando que a requisição foi processada, e teremos o seguinte corpo da resposta:

{
    "id": 1,
    "idMedico": 1,
    "idPaciente": 1,
    "data": "2025-10-10T10:00:00"
}

Foi marcada a consulta, cujo id é 1, pois é a primeira consulta do nosso banco de dados.

A princípio, não identificamos nenhum bug. Porém, vamos analisar o código dessa funcionalidade. Como será que ela foi implementada?

Como não estamos falando nem de médico nem de paciente, vamos acessar o arquivo ConsultaController.java, da classe ConsultaController.

Essa é a classe que recebe as requisições da rota "/consultas", e ela contém o método agendar(), notado com @PostMapping, ou seja, com a requisição POST, caímos nesse método específico.

// Código suprimido


@PostMapping
@Transactional
public ResponseEntity<DadosDetalhamentoConsulta> agendar(@RequestBody @Valid DadosAgendamentoConsulta dados) {
var detalhesAgendamento = agendaConsultas.agendar(dados);
return ResponseEntity.ok(detalhesAgendamento);
}


// Código suprimido

Esse é o método chamado quando disparamos a requisição no Postman. Ele recebe como parâmetro um objeto do tipo DadosAgendamentoConsulta. Vamos pressionar a tecla "Ctrl" e clicar sobre ele para abrir essa classe específica no seu respectivo arquivo (DadosAgendamentoConsulta.java).

public record DadosAgendamentoConsulta(
        Long idMedico,

    @NotNull
    Long idPaciente,

    @NotNull
    @Future
    LocalDateTime data,

    Especialidade especialidade) {


}

A classe DadosAgendamentoConsulta representa o JSON enviado na requisição. Então, ela contém basicamente os campos presentes no arquivo JSON do Postman: idMedico, idPaciente, data, e especialidade (opcional).

Retornando ao arquivo ConsultaControloler.java, no mesmo método agendar(), identificamos que o agendamento propriamente dito, isto é, a regra de negócio, o algoritmo, não está contido na classe controller.

Nesse caso, o controller chama o objeto agendaConsultas seguido do método agendar() passando os dados entre parênteses.

É no método agendar() da outra classe agendaConsultas que está o algoritmo. Vamos pressionar "Ctrl" novamente e clicar sobre esse método para acessá-lo na respectiva classe (arquivo AgendaConsultaService.java).

@Service
public class AgendaConsultaService {

@Autowired
private ConsultaRepository consultaRepository;

@Autowired
private MedicoRepository medicoRepository;

@Autowired
private PacienteRepository pacienteRepository;

@Autowired
private List<ValidadorAgendamentoConsulta> validadoresAgendamento;

public DadosDetalhamentoConsulta agendar(DadosAgendamentoConsulta dados) {
    if (!pacienteRepository.existsById(dados.idPaciente())) {
        throw new ValidacaoException("Id do paciente informado não existe!");
    }

    if (dados.idMedico() != null && !medicoRepository.existsById(dados.idMedico())) {
        throw new ValidacaoException("Id do médico informado não existe!");
    }

    validadoresAgendamento.forEach(v -> v.validar(dados));

    var paciente = pacienteRepository.getReferenceById(dados.idPaciente());
    var medico = escolherMedico(dados);
    if (medico == null) {
        throw new ValidacaoException("Não existe médico disponível nessa data!");
    }

    var consulta = new Consulta(medico, paciente, dados.data());
    consultaRepository.save(consulta);

    return new DadosDetalhamentoConsulta(consulta);
}

private Medico escolherMedico(DadosAgendamentoConsulta dados) {
    if (dados.idMedico() != null) {
        return medicoRepository.getReferenceById(dados.idMedico());
    }

    if (dados.especialidade() == null) {
        throw new ValidacaoException("Especialidade é obrigatória quando médico não for escolhido!");
    }

    return medicoRepository.escolherMedicoAleatorioLivreNaData(dados.especialidade(), dados.data());
}


}

Nesse arquivo, temos a classe AgendaConsultaService, que contém o serviço de agendamento de consultas. O método agendar(), por sua vez, tem o algoritmo necessário para fazer o agendamento de consultas. Vamos tentar entender o que faz o código do método?

Primeiro, ele chama o pacienteRepository, quem acessa a tabela no banco de dados de paciente. Depois ele verifica se existe um paciente com o ID enviado, com o método existsById(). Se não for encontrado, é lançada uma ValidacaoException para interromper a requisição.

O mesmo processo é feito para validar o ID do médico (idMedico).

Em seguida, é chamada uma lista de validadores de agendamento, usando o método forEach() junto a validadoresAgendamento. Ele valida o agendamento passando os dados (v -> v.validar(dados)))

Depois é recuperado o paciente do banco de dados e escolhido o medico. Se o médico for nulo (if (medico == null)), será lançado um erro informando que não existe médico disponível na data selecionada.

Caso contrário, será criada a variável consulta, a qual ficará salva no banco de dados (consultaRepository.save(consulta)), e serão devolvidas as informações que serão retornadas como JSON para o Postman ou para quem disparar a requisição.

Vamos imaginar o seguinte cenário: não foi você quem escreveu esse código; foi outra pessoa da sua equipe que desenvolveu e você o abriu para dar manutenção, fazer ajustes. Agora, considere que você não entendeu tão bem o algoritmo.

Essa é uma situação comum quando analisamos códigos de outras pessoas. Nesse caso, podemos usar o ChatGPT para nos explicar! Podemos simplesmente colar o código e pedir para a ferramenta explicar o que o código faz a cada linha. Dessa forma, ela detalha passo a passo.

Essa é outra forma de utilizar o ChatGPT: como uma ferramenta de aprendizado, para entender trechos de códigos de bibliotecas, de frameworks, ou de outras pessoas, seja do seu time ou de outros.

Nesse momento, podemos continuar usando o mesmo chat de antes, pois ele já terá o contexto do projeto, então não precisaremos informar novamente. Basta continuar a conversa!

Vamos fornecer o contexto da próxima pergunta:

Agora outra dúvida. Tenho outra funcionalidade nesse mesmo projeto que faz o agendamento de consultas, mas eu não entendi o código. Posso colar o código e você me explica linha por linha o que ele faz?

Teremos uma resposta como a seguinte:

Claro, vou ajudar você a entender o código da funcionalidade de agendamento de consultas. Por favor, cole o código aqui para que eu possa analisá-lo e explicar linha por linha o que cada parte faz.

Vamos retornar ao arquivo AgendaConsultaService.java no IntelliJ e copiar tanto o método agendar() quanto o método escolherMedico(), método privado que está sendo chamado pelo método de agendamento. Se não levarmos ele para a pergunta, a ferramenta não conseguirá entender o código completamente.

public DadosDetalhamentoConsulta agendar(DadosAgendamentoConsulta dados) {
    if (!pacienteRepository.existsById(dados.idPaciente())) {
        throw new ValidacaoException("Id do paciente informado não existe!");
    }

if (dados.idMedico() != null && !medicoRepository.existsById(dados.idMedico())) {
    throw new ValidacaoException("Id do médico informado não existe!");
}

validadoresAgendamento.forEach(v -> v.validar(dados));

var paciente = pacienteRepository.getReferenceById(dados.idPaciente());
var medico = escolherMedico(dados);
if (medico == null) {
    throw new ValidacaoException("Não existe médico disponível nessa data!");
}

var consulta = new Consulta(medico, paciente, dados.data());
consultaRepository.save(consulta);

return new DadosDetalhamentoConsulta(consulta);




}




private Medico escolherMedico(DadosAgendamentoConsulta dados) {
if (dados.idMedico() != null) {
return medicoRepository.getReferenceById(dados.idMedico());
}



if (dados.especialidade() == null) {
    throw new ValidacaoException("Especialidade é obrigatória quando médico não for escolhido!");
}

return medicoRepository.escolherMedicoAleatorioLivreNaData(dados.especialidade(), dados.data());


}

Enviado esse código como próxima pergunta, teremos como resposta a análise do código, explicando-o linha por linha.

Vou explicar o código linha por linha para ajudar você a entender a funcionalidade de agendamento de consultas. Aqui está a explicação:

Copiar código

public DadosDetalhamentoConsulta agendar(DadosAgendamentoConsulta dados) {
    if (!pacienteRepository.existsById(dados.idPaciente())) {
        throw new ValidacaoException("Id do paciente informado não existe!");
    }

Nessa parte, o método agendar recebe um objeto DadosAgendamentoConsulta como parâmetro. Ele verifica se o ID do paciente fornecido existe no repositório de pacientes. Caso não exista, é lançada uma exceção do tipo ValidacaoException com uma mensagem informando que o ID do paciente não existe.

Inicialmente, a ferramenta explicou o que faz o primeiro trecho de código, correspondente à assinatura do método.

Em seguida, temos o segundo trecho de código e sua respectiva explicação:

Copiar código

if (dados.idMedico() != null && !medicoRepository.existsById(dados.idMedico())) {
    throw new ValidacaoException("Id do médico informado não existe!");
}

Aqui, é verificado se o ID do médico foi fornecido. Se foi fornecido e o ID do médico não existe no repositório de médicos, é lançada uma exceção do tipo ValidacaoException informando que o ID do médico não existe.

Para a linha dos validadores também há uma explicação:

Copiar código

validadoresAgendamento.forEach(v -> v.validar(dados));

Essa linha executa uma sequência de validadores de agendamento, que foram previamente definidos e armazenados na lista validadoresAgendamento. Cada validador é aplicado ao objeto dados passado como parâmetro.

Esse mesmo processo é feito linha a linha até o final do código.

A resposta tem um limite de caracteres, então o texto ficou incompleto. Porém, temos a opção de continuar gerando a resposta (botão "Continue generating"). Ao final, será retornada uma mensagem como a seguinte:

Espero que essa explicação ajude você a entender o código de agendamento de consultas. Se você tiver mais alguma dúvida, fique à vontade para perguntar.

Conforme dito anteriormente, essa é uma situação bastante comum para quem trabalha com programação, independentemente da linguagem, da tecnologia, das bibliotecas e frameworks utilizados. Geralmente, não trabalhamos individualmente em projetos. Eles são complexos, têm várias funcionalidades, e trabalharemos com outras pessoas.

Nesse contexto, é comum precisar observar e fazer manutenções em códigos desenvolvidos por pessoas diferentes do seu time. Pode ser que a pessoa responsável pelo código não esteja disponível para tirar dúvidas no momento, então a ferramenta do ChatGPT pode ser útil!

Caso houver mais dúvidas, ainda podemos complementar a pergunta, indicando algum trecho específico que talvez não tenha sido tão bem-explicado. Também podemos colar outras partes do código, de classes diferentes.

Conclusão

Assim, conhecemos mais uma utilidade super importante do ChatGPT para quem trabalha com programação. Você pode usar essa ferramenta para entender um código, seja do seu projeto ou de alguma biblioteca externa que esteja utilizando e queira entender melhor o que ela faz.

Outra situação semelhante: você está trabalhando em um projeto com determinada tecnologia e precisará migrar para outra, trocar o framework e a linguagem de programação. Nesse caso, você quer entender melhor como determinado trecho de código funciona nessa tecnologia nova. O ChatGPT pode te auxiliar nesse processo! Ele pode até mesmo ajudar na própria migração.

Descobrimos uma nova funcionalidade muito interessante para a ferramenta, que já temos o costume de fazer, porém, usando o Google, o Stack Overflow, o YouTube… Podemos concentrar todos esses estudos e aprendizados de código no ChatGPT.

Na sequência, aprenderemos outras formas de usar essa ferramenta no nosso dia a dia!