.NET Core: um curso orientado para o mercado de trabalho.

Aprenda a instalar o Visual Studio e conheça as diferenças entre VS Code e JetBrains Rider. Saiba qual escolher para desenvolver aplicações modernas em C# e .NET.

Aprenda a instalar o Docker Desktop e entenda o básico sobre containers e Docker para preparar o ambiente local do curso.

Aprenda a subir e acessar um banco de dados usando Docker. Veja como containers facilitam a configuração do ambiente local para desenvolvimento com APIs em .NET.

Entenda o que são Docker Volumes e como funcionam na persistência de dados. Conceitos fundamentais para trabalhar com containers e banco de dados no ambiente local.

Entenda o que é uma API, como funciona a comunicação entre sistemas e por que APIs são essenciais no desenvolvimento de aplicações web.

Crie um projeto de API em .NET e configure o Swagger para documentação e testes dos endpoints. Base essencial para iniciar o desenvolvimento de APIs modernas em C#.

Conheça o papel de cada pasta e arquivo em um projeto de API .NET. Entenda Program, configurações, dependências e a organização base do projeto.

Nesta aula, mergulharemos no conceito de Domain-Driven Design (DDD). Exploraremos como o DDD oferece uma abordagem estratégica para o desenvolvimento de software, focando na modelagem complexa de domínios de negócio e na criação de soluções software que refletem essas complexidades. Discutiremos os principais pilares do DDD, incluindo a importância da linguagem ubíqua, melhorando a comunicação entre equipes técnicas e stakeholders e desenvolvendo software mais alinhado às necessidades do negócio.

Nesta aula, exploraremos a aplicação do Domain-Driven Design (DDD) de forma conceitual. Sem entrar em detalhes práticos, vamos discutir como o DDD orienta a estruturação de modelos de domínio e a importância de alinhar o software à complexidade dos negócios. Abordaremos como entidades, objetos de valor e agregados capturam conceitos do domínio, e a relevância de separar a lógica do domínio da infraestrutura. Ao analisar projetos exemplo, destacaremos a implementação de padrões como repositórios e serviços de domínio, além da arquitetura em camadas.

Nesta aula, vamos identificar os desafios comuns enfrentados ao aplicar o Domain-Driven Design (DDD) em projetos .NET e propor soluções baseadas nesta mesma abordagem. Apresentarei estratégias para superar esses desafios que facilitam a aderência ao DDD.

Nesta aula eu crio junto com você no Visual Studio os projetos que compõem uma arquitetura DDD em .NET. Organize Domain, Application, Infrastructure e API seguindo boas práticas profissionais.

Entenda por que o projeto cross-cutting não é necessário em DDD no .NET. Veja como manter uma arquitetura .NET mais simples e organizada.

Aprenda a criar sua conta no Azure DevOps e preparar o ambiente para controle de código, gestão de tarefas, repositórios Git e pipelines no desenvolvimento .NET.

Configure o Azure DevOps com a estrutura inicial para gerenciar código e desenvolvimento.

Crie um projeto no Azure DevOps, conecte seu repositório Git e faça o primeiro commit do projeto .NET, iniciando o versionamento do código.

Aprenda como realizar uma Sprint Planning no Azure DevOps, criando tarefas, User Stories e planejando a primeira sprint do projeto seguindo práticas de Scrum.

Aprenda a gerenciar tarefas dentro da Sprint no Azure DevOps e adicionar estimativas de esforço. Veja como organizar o trabalho do time e acompanhar o progresso das atividades no projeto.

Implemente o endpoint POST para registrar novos usuários na API .NET. Veja como receber os dados da requisição e iniciar a lógica de criação de conta.

Aprenda como funcionam propriedades com get e set em C# e veja dicas úteis no Visual Studio para escrever código mais rápido e produtivo no desenvolvimento .NET.

Entenda o que são Pull Requests e como eles ajudam na revisão de código, colaboração entre desenvolvedores e controle de mudanças no código.

Aprenda a configurar políticas de proteção de branch no Azure DevOps para garantir revisões de código, qualidade nas entregas e mais segurança no fluxo de desenvolvimento.

Comece a implementar a regra de negócio para cadastro de pessoas e entenda o Princípio da Responsabilidade Única (Single Responsibility Principle — SRP) do SOLID.

Aprenda a usar FluentValidation para validar dados na aplicação .NET. Implemente regras de validação claras e organizadas para garantir consistência nas requisições da API.

Aprenda o que são Resource Files no .NET e como usá-los para centralizar mensagens e textos da aplicação, facilitando manutenção e suporte a múltiplos idiomas.

Aprenda a aplicar localização na API .NET usando a cultura enviada na request, permitindo retornar mensagens e textos no idioma correto para cada usuário.

Aprenda a criar exceptions customizadas na API .NET e entenda por que essa abordagem pode melhorar a organização dos erros, mesmo com algumas desvantagens.

Aprenda a criar e usar um Exception Filter na API .NET para centralizar o tratamento de erros e padronizar as respostas retornadas pelos endpoints.

Entenda o que é uma entidade no DDD e crie a entidade User no domínio. Além disso vamos aprender sobre as propriedades que representam o usuário na aplicação .NET.

Entenda o uso de IDs na API e as diferenças entre GUID v4 e v7. Veja quando usar cada um e boas práticas para geração e performance no .NET.

Entenda as diferenças, vantagens e desvantagens entre domínio anêmico e domínio rico no DDD.

Aprenda a mapear a request para a entidade User e compare AutoMapper vs Mapster. Veja diferenças, vantagens e como aplicar mapeamento no .NET.

Entenda os conceitos essenciais de segurança, incluindo criptografia, hash, proteção de dados e boas práticas para aplicações .NET e APIs modernas.

Implemente o hash com Argon2id e entenda parâmetros como memória, iterações e paralelismo. Veja como ajustar segurança e performance no .NET.

Aprenda como validar senhas usando Argon2id no .NET. Compare hashes com segurança e entenda o processo de verificação de credenciais na autenticação de usuários.

Aprenda a configurar injeção de dependência no .NET, registrando serviços para organizar melhor o código da API.

Aprenda o que são métodos de extensão em C# e como usá-los para deixar o código .NET mais limpo, organizado e reutilizável em diferentes partes da aplicação.

Aprenda a configurar URLs em minúsculas e tratar strings da request, removendo espaços em branco extras para padronizar e melhorar os dados recebidos pela API.

Entenda o Entity Framework Core, crie o DbContext e veja diferenças para o Dapper. Uma introdução prática sobre acesso a dados em aplicações .NET.

Crie o repositório de usuários e entenda o princípio Interface Segregation do SOLID, aplicando boas práticas para manter o código desacoplado e organizado no .NET.

Configure o Entity Framework e os repositórios na injeção de dependência, organizando o acesso a dados da aplicação .NET com mais desacoplamento e manutenção.

Aprenda a recuperar a connection string do appsettings e testar o fluxo de cadastro de usuários, validando a integração da API .NET com o banco de dados.

Entenda o padrão Unit of Work e aprenda como implementar no .NET para controlar transações e garantir consistência nas operações com banco de dados.

Retorne os dados do usuário registrado e melhore a documentação com Swagger. Deixe sua API .NET mais clara, testável e profissional para quem consome os endpoints.

Implemente a validação de e-mail duplicado no cadastro de usuários, garantindo unicidade e evitando registros duplicados na API .NET.

Entenda o que são migrations e como usá-las no Entity Framework Core para versionar o banco de dados e evoluir a estrutura da aplicação .NET.

Aprenda a criar as migrations com FluentMigrator no .NET, versionando o banco de dados e controlando mudanças de forma organizada e segura.

Aprenda a executar migrations automaticamente ao iniciar a API .NET, garantindo que o banco de dados esteja sempre atualizado com a estrutura da aplicação.

Entenda testes de unidade no .NET, seus benefícios e quais tipos de testes serão aplicados no projeto para garantir qualidade e confiabilidade do código.

Crie seu primeiro teste de unidade no .NET e entenda o padrão AAA (Arrange, Act, Assert) para estruturar testes claros, organizados e fáceis de manter.

Aprenda a gerar dados fake com Bogus para testes em .NET, criando objetos mais realistas e facilitando a escrita de testes automatizados.

Aprenda a melhorar seus asserts com Shouldly e conheça o FluentAssertions para escrever testes mais claros, expressivos e fáceis de manter no .NET.

Aprenda a testar os cenários de erro do validator de cadastro de usuário, garantindo que as validações bloqueiem dados inválidos no registro da conta.

Inicie os testes do use case de registro de usuário, validando fluxo, dependências e regras de negócio na aplicação .NET com testes de unidade.

Aprenda a usar Moq no .NET para criar mocks e simular dependências, facilitando a escrita de testes de unidade isolados e confiáveis.

Finalizando o teste de sucesso do use case de registro de usuário, validando o fluxo completo e garantindo que a criação da conta funciona corretamente.

Crie testes de unidade para cenários onde o use case lança exceções, validando erros e garantindo comportamento correto no registro de usuário na API.

Entenda o que são testes de integração no .NET e como validar o funcionamento conjunto da API, banco de dados e dependências externas.

Entenda o WebApplicationFactory e como os testes são executados de forma paralela e sequencial no .NET.

Aprenda como fazer assertions em testes de integração no .NET, validando status code, corpo da resposta e comportamento esperado da API.

Aprenda como executar testes de integração no .NET, analisando resultados e garantindo que a API funcione corretamente em cenários reais.

Aprenda a verificar se a mensagem retornada pela API está no idioma solicitado na request, validando a cultura e o conteúdo nos testes de integração.

Aprenda o conceito de Theory no xUnit e como criar testes parametrizados no .NET para cobrir múltiplos cenários com menos código e mais organização.

Aprenda o que é Testcontainers e como configurar no .NET para subir containers em testes de integração, garantindo ambientes isolados e consistentes.

Aprenda a obter a connection string do Testcontainers e configurar no IConfiguration, permitindo que a API use o banco do container nos testes de integração.

Execute testes de integração usando Testcontainers no .NET, validando a API com banco em container e garantindo um ambiente isolado e confiável.

Melhore os asserts dos testes de integração e use InternalsVisibleTo para acessar membros internos, aumentando a cobertura e qualidade dos testes no .NET.

Entenda o que são pipelines e CI/CD, e como automatizar build, testes e deploy no Azure DevOps para projetos .NET.

Aprenda a criar um pipeline de CI no Azure DevOps para build e testes automatizados, garantindo qualidade e integração contínua em projetos .NET.

Aprenda a organizar pipelines no Azure DevOps, estruturando builds, testes e etapas para manter o fluxo CI/CD mais limpo, escalável e fácil de manter no .NET.

Aprenda a publicar a cobertura de testes no pipeline do Azure DevOps, analisando métricas e garantindo qualidade no código da aplicação .NET.

Entenda como funciona a métrica de code coverage e aprenda a excluir arquivos que não devem entrar na cobertura para gerar indicadores mais relevantes.

Aprenda como conduzir uma retrospectiva usando Azure DevOps, analisando resultados da sprint e identificando melhorias no processo de desenvolvimento.

Continuação do fluxo do usuário no projeto usando Azure DevOps e práticas de Scrum.

Implemente a função de login no repositório e entenda AsNoTracking e Single vs First no EF Core, escolhendo a melhor abordagem para consultas e performance.

Implemente a regra de negócio de login e crie o endpoint na API .NET, estruturando o fluxo de autenticação do usuário.

Entenda os princípios Open/Closed e Liskov Substitution do SOLID aplicados ao Exception Filter, melhorando extensibilidade e consistência no tratamento de erros.

Crie testes de unidade para o use case de login, validando credenciais, regras de negócio e cenários de sucesso e erro na aplicação.

Implemente testes de integração para os cenários de erro do login, validando respostas da API e tratamento de credenciais inválidas no .NET.

Crie o teste de integração do login com sucesso, iniciando o banco com um usuário seed e validando o fluxo real de autenticação na API .NET.

Refatore os testes de integração no .NET, removendo código duplicado e criando uma estrutura mais limpa, reutilizável e fácil de manter.

Entenda o que é um Access Token, como ele funciona na autenticação de APIs e seu papel na identificação e autorização de usuários em aplicações modernas.

Aprenda o que é JWT, como funciona sua estrutura e como ele é utilizado para transportar informações de forma segura na autenticação de APIs .NET.

Aprenda a gerar JWT na API .NET, configurando claims, chave de assinatura e informações necessárias para autenticação e autorização de usuários.

Implemente o retorno do Access Token nos fluxos de cadastro e login, concluindo a autenticação do usuário na API .NET.

Corrija os testes impactados pela implementação do Access Token e melhore a organização da injeção de dependência seguindo boas práticas no .NET.

Comece a implementar a validação do Access Token nas requisições da API .NET, entendendo como verificar autenticidade e proteger endpoints.

Aprenda a validar se o usuário associado ao Access Token existe e está ativo na base de dados, aumentando a segurança das requisições autenticadas.

Aprenda a personalizar as respostas retornadas durante a validação do Access Token, fornecendo mensagens mais claras para tokens inválidos, expirados ou ausentes.

Aprenda a configurar o Swagger para enviar o Access Token nas requisições, facilitando os testes de endpoints protegidos por autenticação JWT.

Na aula sobre a criação de User Stories e tarefas no Azure DevOps, utilizando a metodologia Scrum, você aprenderá a elaborar histórias de usuário eficazes, priorizar tarefas e acompanhar o progresso do projeto. Vamos explorar as práticas ágeis para garantir um planejamento eficiente e uma execução bem-sucedida do seu projeto de desenvolvimento.

Na aula de estimativa de tarefas usando pontos de Fibonacci no Azure DevOps, você aprenderá a atribuir valores a cada tarefa de forma ágil e precisa. Isso permite uma melhor compreensão do esforço envolvido e uma gestão mais eficiente do projeto. Vamos explorar como aplicar essa técnica para melhorar a estimativa e o planejamento das tarefas em seu projeto.

Na aula de criação de projetos no Visual Studio com base no Domain-Driven Design (DDD), você aprenderá como estruturar seus projetos de forma eficaz para refletir os conceitos do DDD. Abordaremos a criação de camadas, como a de aplicação, domínio e infraestrutura, e a organização das entidades, repositórios e serviços de domínio. Isso garantirá que seu projeto esteja alinhado com as melhores práticas do DDD, resultando em um código limpo e altamente coeso.

Nesta aula você aprenderá a dar os primeiros passos cruciais para versionar seu projeto .NET usando o Git. Vamos juntos criar um arquivo .gitignore personalizado para o ambiente .NET, garantindo um controle de versão eficiente e sem complicações. Em seguida, vamos realizar o primeiro commit, marcando o início do seu percurso no controle de versão.

Nesta aula prática e hands-on, vamos explorar o processo de criação manual de um schema ou database em dois dos bancos de dados mais populares: MySQL e SQL Server.

Nesta aula prática, você será guiado passo a passo na criação manual da tabela de usuário em dois bancos de dados essenciais: MySQL e SQL Server. Exploraremos a sintaxe SQL necessária para definir campos como nome, e-mail, senha e outras informações relevantes. Ao final da aula, você terá a habilidade de criar tabelas de usuário personalizadas em ambos os bancos de dados, proporcionando uma base sólida para o desenvolvimento de sistemas de autenticação e gerenciamento de usuários.

Na aula sobre a criação do endpoint de registro de usuário, você aprenderá a implementar esse recurso essencial no seu projeto .NET. Exploraremos a criação de APIs RESTful, a definição de rotas e controladores (controllers).

Nesta aula, você aprenderá a configurar e implementar o GitFlow, um modelo de fluxo de trabalho eficaz para colaboração em projetos Git. Passo a passo, vamos explorar a configuração inicial do GitFlow. Em seguida, realizaremos o primeiro commit seguindo as práticas do GitFlow, marcando o início de um controle de versão estruturado e colaborativo. Prepare-se para elevar suas habilidades de controle de versão para o próximo nível nesta jornada prática com o GitFlow!

Nesta aula focada em prática, iremos detalhar a criação da regra de negócio para o cadastro de usuários através da nossa API. Abordaremos conceitos essenciais, como validação de dados, geração de senhas seguras e verificação de informações.

Nesta aula prática, vamos explorar como elevar a qualidade das validações de dados em suas requisições utilizando a biblioteca FluentValidation. Passo a passo, você aprenderá a criar validações concisas e expressivas para garantir a integridade dos dados enviados à sua aplicação.

Na aula sobre a criação de mensagens de exceção em arquivos de recursos, você aprenderá a tirar proveito dos recursos de localização para tornar seu aplicativo mais flexível e acessível em diversos idiomas. Vamos explorar como definir e organizar mensagens de exceção em arquivos de recursos, permitindo a adaptação dinâmica do idioma com base nas preferências do usuário. Isso resultará em uma experiência mais amigável e personalizada para os usuários, independentemente de sua língua ou localização.

Na aula de criação de middleware para alterar a cultura da API e fornecer mensagens traduzidas aos usuários, você aprenderá como criar um componente intermediário para detectar e ajustar a cultura com base nas preferências do usuário. Exploraremos como integrar a tradução de mensagens e como personalizar a resposta da API para fornecer informações no idioma apropriado. Isso resultará em uma experiência mais amigável para os usuários, independentemente do idioma que escolham.

Nesta aula prática, vamos explorar como garantir o suporte adequado para culturas (cultures) enviadas nas requisições à sua API. Aprenderemos a validar e processar culturas de maneira eficiente, considerando suporte linguístico e regional. Abordaremos técnicas para identificar e lidar com culturas suportadas, proporcionando uma experiência mais personalizada para os usuários. Ao final da aula, você terá as habilidades necessárias para implementar uma verificação robusta de suporte de culturas em sua API. Vamos aprimorar a internacionalização e a adaptabilidade em seu projeto!

Nesta aula exploraremos a importância e o processo de criação de exceções personalizadas em suas aplicações. Discutiremos os motivos para personalizar exceções, como comunicar erros de maneira eficaz e agregar informações específicas para facilitar a depuração. Passo a passo, você aprenderá a criar suas próprias exceções, definindo mensagens claras e adicionando detalhes relevantes. Ao final da aula, você terá uma compreensão sólida de por que e como incorporar exceções personalizadas, melhorando a manutenção e a robustez de seus projetos. Vamos capacitar suas aplicações a comunicarem problemas de forma mais inteligente!

Abordaremos a importância e o processo de criação de filtros de exceções em suas aplicações. Exploraremos por que os filtros de exceções são essenciais para melhorar a manipulação de erros e como podem aprimorar a experiência do usuário. Demonstraremos passo a passo como criar filtros que capturam e tratam exceções de forma personalizada, proporcionando respostas mais amigáveis e informativas. Ao final da aula, você estará capacitado para implementar filtros de exceções eficazes, fortalecendo a robustez e a usabilidade de seus aplicativos.

Nesta aula prática, vamos mergulhar na criação da entidade de usuário em seu domínio. Explicaremos a importância de uma sólida modelagem de domínio, discutindo como a entidade de usuário se encaixa no contexto de suas aplicações. Passo a passo, você aprenderá a implementar a entidade, abordando atributos essenciais como nome, e-mail, senha, e qualquer outro dado relevante. Durante o processo, destacaremos práticas recomendadas de design e modelagem de entidades.

Nesta aula prática e informativa, vamos explorar como configurar o AutoMapper para facilitar o mapeamento de objetos em suas aplicações .NET. Passo a passo, você aprenderá a instalar e configurar o AutoMapper, criando perfis de mapeamento que automatizam a correspondência entre tipos diferentes. Abordaremos estratégias de mapeamento personalizado, resolução de conflitos e otimizações para melhorar a eficiência. Ao final da aula, você terá as habilidades necessárias para implementar o AutoMapper em seus projetos, simplificando e tornando mais eficiente o processo de mapeamento entre objetos. Vamos simplificar suas operações de mapeamento!

Nesta aula crucial, abordaremos a implementação de técnicas de criptografia para garantir a segurança das senhas em suas aplicações. Passo a passo, você aprenderá a utilizar algoritmos seguros e as melhores práticas para armazenar senhas de maneira protegida. Exploraremos conceitos como hash e te ensino uma tecnica extra para aumentar a resistência contra ataques.

Nesta aula vamos explorar o conceito fundamental do DbContext no Entity Framework. Passo a passo, você aprenderá o papel central do DbContext na interação entre sua aplicação e o banco de dados. Discutiremos como configurar o DbContext, definir conjuntos de entidades, e realizar operações CRUD no banco de dados usando o Entity Framework. Durante a aula, destacaremos práticas recomendadas e casos de uso comuns. Ao final, você terá uma compreensão sólida de como aproveitar ao máximo o DbContext para criar aplicações eficientes e orientadas a dados. Vamos aprofundar seus conhecimentos no Entity Framework!

Nesta aula prática, vamos desenvolver um repositório dedicado à entidade de usuário usando o Entity Framework. Passo a passo, você aprenderá a implementar operações básicas de acesso a dados, como adicionar, buscar, atualizar e excluir usuários no banco de dados. Discutiremos boas práticas ao projetar um repositório, garantindo eficiência e manutenibilidade.

Nesta aula vamos abordar a configuração da injeção de dependência para fortalecer a modularidade e a escalabilidade do seu projeto de infraestrutura. Passo a passo, você aprenderá a utilizar os recursos de injeção de dependência oferecidos pelo .NET Core para conectar e gerenciar as dependências do seu projeto. Discutiremos como configurar serviços, registrar implementações específicas e como essa prática contribui para a manutenção do código.

Nesta aula prática e orientada, vamos explorar a configuração da injeção de dependência para otimizar o projeto de application. Passo a passo, você aprenderá a utilizar os recursos de injeção de dependência oferecidos pelo .NET Core para conectar e gerenciar as dependências do seu projeto de application. Discutiremos como registrar serviços, injetar dependências em classes e interfaces, e como essa prática promove a modularidade e testabilidade do código.

Nesta aula prática, vamos focar em garantir que o processo de registro de usuários esteja operando corretamente nos bancos de dados MySQL e SQL Server por meio da API. Destacaremos a importância da função SaveChanges no DbContext e como ela impacta a efetivação das operações no banco de dados. Ao final da aula, você terá a habilidade de garantir que a funcionalidade de registro está totalmente operacional e integrada nos ambientes MySQL e SQL Server.

Nesta aula prática e informativa, vamos explorar como recuperar a connection string de maneira eficaz do arquivo appsettings.json em suas aplicações .NET. Passo a passo, você aprenderá a utilizar as configurações do .NET para acessar e extrair a connection string do arquivo de configuração.

Nesta aula vamos explorar como recuperar diversos valores e tipos do arquivo appsettings.json em suas aplicações .NET. De forma prática, você aprenderá a utilizar as configurações do .NET para extrair informações além das connection strings, como valores booleanos, números inteiros, etc. Ao final da aula, você estará equipado com as habilidades necessárias para acessar e utilizar diversas configurações de forma flexível e segura em suas aplicações. Vamos aprofundar seu entendimento sobre a gestão de configurações!

Nesta aula prática e crucial, vamos explorar a implementação da verificação de e-mail para garantir que não ocorram registros duplicados em sua aplicação. Passo a passo, você aprenderá a verificar se um e-mail já está registrado no banco de dados durante o processo de registro de usuários. Utilizando o Entity Framework.

Nesta aula prática, vamos abordar o processo de criação de um Pull Request no Azure DevOps, uma prática crucial para colaboração eficaz em projetos. Passo a passo, você aprenderá a criar uma branch, realizar alterações significativas, e propor essas mudanças através de um Pull Request no ambiente do Azure DevOps. Discutiremos boas práticas, como associar work items, adicionar descrições detalhadas e conduzir revisões de código eficientes.

Nesta aula avançada, vamos mergulhar profundamente no conceito de Pull Request no Azure DevOps, proporcionando uma compreensão detalhada e abrangente.

Nesta aula breve, vamos aprender como fortalecer o controle sobre a branch develop no Azure DevOps. Primeiramente, exploraremos como bloquear commits diretos, promovendo boas práticas de branching. Em seguida, veremos como criar políticas específicas para a develop, assegurando revisões de código, testes bem-sucedidos e conformidade com padrões de codificação. Ao final, você terá as habilidades necessárias para estabelecer uma governança robusta em sua branch de desenvolvimento.

Nesta aula você aprenderá a configurar sua API para criar dinamicamente o schema ou database.

Nesta aula exploraremos o conceito fundamental de migrations, destacando sua importância na gestão controlada do esquema do banco de dados ao longo do tempo. Além disso, discutiremos por que optaremos pelo FluentMigrator, uma ferramenta que oferece simplicidade e flexibilidade através de uma abordagem Fluent Interface na definição e aplicação de migrations. Ao compreender esses conceitos, você estará preparado para evoluir seu banco de dados de maneira eficiente e organizada.

Nesta aula, vamos focar na implementação prática da função Up utilizando o FluentMigrator para criar a tabela Usuario. Após configurar o ambiente e criar a migration, você aprenderá a detalhar as especificações da tabela na função Up, utilizando a Fluent API do FluentMigrator para definir colunas, tipos de dados e quaisquer restrições necessárias. Ao final, você estará apto a executar a migration, consolidando uma compreensão valiosa sobre como iniciar eficientemente o uso de migrations em seus projetos.

Nesta aula vamos focar na configuração rápida da sua API para reconhecer diferentes versões. Em seguida, testaremos a execução de migrações, garantindo a consistência em ambientes MySQL e SQL Server. Ao compreender esses passos essenciais, você estará pronto para evoluir e testar seu banco de dados de maneira eficiente em ambientes diversos.

Nesta aula vamos começar a implementar testes de unidade para o seu validator. Abordaremos a configuração do ambiente de testes, escolha da estrutura de testes mais adequada, e escreveremos testes para o validator, cobrindo diversos cenários e validando o comportamento esperado. Finalizaremos com a execução e avaliação dos resultados, proporcionando uma base sólida para testes de unidade em seu projeto. Vamos dar os primeiros passos na garantia da qualidade do seu código!

Nesta aula introdutória, começaremos a jornada de implementação de testes, focando na arquitetura fundamental de funções de teste. Exploraremos os conceitos essenciais, como a estrutura Arrange-Act-Assert (AAA), onde a fase de preparação (Arrange) configura o cenário, a fase de execução (Act) realiza a operação a ser testada, e a fase de verificação (Assert) valida os resultados.

Nesta aula, vou guiar você na utilização eficaz da biblioteca Bogus para gerar dados falsos em testes de unidade. O Bogus simplifica a criação de dados fictícios realistas, permitindo a rápida geração de objetos para cenários de teste. Abordaremos como configurar e personalizar as instâncias do Bogus para atender às suas necessidades específicas, proporcionando uma maneira eficiente e flexível de criar dados de teste consistentes e diversificados. Ao final da aula, você estará apto a integrar o Bogus em seus testes de unidade, aprimorando a qualidade e a abrangência dos seus testes.

Nesta aula, aprenderemos a testar com sucesso utilizando a poderosa biblioteca Fluent Assertions. Vou guiá-lo na implementação de verificações claras e expressivas utilizando Fluent Assertions, proporcionando uma leitura mais intuitiva dos testes. Exploraremos como utilizar a sintaxe encadeada para criar afirmações que refletem de forma precisa o comportamento esperado do código. Ao aplicar Fluent Assertions, você garantirá que seus testes não apenas validem o sucesso, mas também comuniquem claramente a intenção por trás de cada verificação. Ao final desta aula, você estará preparado para elevar a qualidade e a legibilidade dos seus testes de unidade.

Nesta aula, vou explicar por que deixaremos de usar o Fluent Assertions devido à mudança em sua licença, que agora torna a biblioteca paga em determinados contextos. Discutiremos os impactos dessa alteração, especialmente para projetos comerciais, e as implicações legais e financeiras de continuar utilizando a biblioteca.

Em seguida, apresentarei alternativas gratuitas e open source para substituí-la em nossos projetos.

Nesta aula prática, abordaremos a criação de testes de unidade específicos para casos de erro no validator. Demonstrarei como estruturar testes que avaliam o comportamento do validator diante de entradas inválidas, garantindo que o código reaja adequadamente a situações de erro.

Nesta aula, exploraremos como empregar a funcionalidade Theory em testes de unidade. O Theory, uma característica presente no xUnit, permite a criação de testes parametrizados, onde múltiplos conjuntos de dados são fornecidos para uma mesma lógica de teste. Vou demonstrar como utilizar essa abordagem para testar diferentes cenários e comportamentos da sua aplicação de forma eficiente. Com o Theory, você ganhará flexibilidade e poderá garantir que sua lógica de validação seja testada em diversas situações, contribuindo para a robustez do código. Ao final desta aula, você estará capacitado para aplicar o Theory em seus testes de unidade, melhorando a abrangência e eficácia dos seus casos de teste. Vamos simplificar a criação de testes parametrizados!

Nesta aula prática, daremos os primeiros passos na implementação de testes de unidade para o seu Use Case. Exploraremos como estruturar e organizar testes específicos para garantir que o Use Case atenda aos requisitos funcionais.

Nesta breve aula prática, concentraremos nossos esforços na criação de builders para configurações do AutoMapper e em uma classe específica para criptografia de senhas, destinados a otimizar os testes de Use Case. Esses builders proporcionarão uma maneira eficiente de criar objetos mapeados, enquanto a classe de criptografia garantirá uma abordagem padronizada para cenários de autenticação nos testes. Ao integrar essas ferramentas nos seus testes de Use Case, você estará fortalecendo a consistência e a qualidade dos seus testes de unidade.

Nesta aula introdutória, vamos explorar o conceito de mocks e como aplicá-los de maneira eficaz nos seus testes de unidade. Um mock simula o comportamento de objetos ou componentes reais, permitindo isolar a lógica de teste e garantir um ambiente controlado para verificações específicas. Demonstrarei como criar e utilizar mocks em situações práticas, abordando o cenário de substituir dependências externas por mocks para focar na unidade de código sendo testada. Compreendendo o poder dos mocks, você estará mais preparado para criar testes de unidade robustos e independentes.

Nesta última etapa do teste de Use Case, focaremos na conclusão do cenário de sucesso. Ao aplicar assertivas e verificações específicas, garantiremos que o Use Case opera conforme o esperado quando os dados de entrada estão corretos. Com a estruturação cuidadosa do teste, você terá não apenas validado o sucesso do Use Case, mas também criado uma base sólida para testes futuros.

Nesta aula, abordaremos a criação de mocks para funções que retornam valores, uma prática fundamental em testes de unidade. Exploraremos como utilizar bibliotecas de mocks, como o Moq, para simular o comportamento de funções específicas e controlar os resultados que essas funções devem retornar durante os testes. Ao compreender a criação de mocks para funções com retorno de valores, você terá uma ferramenta poderosa para isolar componentes, garantindo que seus testes se concentrem na lógica específica sendo avaliada.

Nesta aula prática, vou orientar você na criação de testes de Use Case que esperam exceções, um cenário crucial para garantir que seu código lide adequadamente com situações inesperadas. Utilizando técnicas de asserts específicos para exceções, abordaremos como configurar o ambiente de teste para forçar o lançamento de exceções controladas e como verificar se o Use Case trata essas exceções conforme o esperado. Ao compreender como criar testes de Use Case que esperam exceções, você estará preparado para garantir a robustez do seu código mesmo diante de condições adversas.

Nesta aula, vamos explorar o conceito de testes de integração e como implementá-los de maneira eficaz em seu projeto. Os testes de integração visam validar a interação entre diferentes componentes ou módulos do sistema, garantindo a correta colaboração entre eles. Explicarei como configurar cenários de teste que envolvem a integração real de partes distintas da aplicação, destacando a importância de testar o comportamento conjunto do sistema. Ao final, você terá uma visão clara de como os testes de integração complementam os testes de unidade, promovendo uma cobertura mais abrangente e confiável do seu código.

Nesta aula prática, mergulharemos na execução de um teste de integração completo para um caso de sucesso. Vamos integrar diversos componentes da aplicação, simulando um cenário real e verificando se a colaboração entre esses elementos ocorre conforme esperado. Desde a preparação do ambiente até a execução de asserts específicos para a integração, abordaremos cada passo crucial para garantir que todas as partes do sistema estejam funcionando harmoniosamente em um caso de uso completo. Ao final da aula, você terá experiência prática na implementação de testes de integração, fortalecendo a confiabilidade e a coesão do seu código.

Nesta aula, vamos explorar a importância de utilizar um banco de dados in-memory para testes de integração e como configurá-lo de maneira eficaz. Um banco de dados in-memory oferece a vantagem de ser leve e eficiente, proporcionando uma solução rápida e isolada para os testes, sem afetar o estado do banco de dados real. Vou orientar você na configuração desse ambiente de teste, abrangendo desde a escolha da biblioteca apropriada até a criação de cenários que garantam a integridade e a consistência dos dados durante os testes de integração.

Nesta aula prática, daremos continuidade ao teste de integração, agora incorporando a utilização de um banco de dados in-memory. Demonstrarei como configurar o ambiente de teste para simular um banco de dados real de forma rápida e eficiente, proporcionando um cenário controlado para o caso de sucesso.

Nesta aula, vamos explorar a criação de testes de integração específicos para cenários que esperam erros, assegurando que sua aplicação lida de forma adequada com situações inesperadas. Utilizando um ambiente de banco de dados in-memory, demonstrarei como configurar testes que forcem a ocorrência de erros controlados, permitindo verificar se o sistema responde corretamente a essas exceções. Desde a preparação do cenário até a validação do comportamento esperado, você ganhará expertise na criação de testes de integração que abordam e validam o tratamento de erros.

Nesta aula, abordaremos a importância de verificar se a API retorna mensagens de erro no idioma correto, uma consideração crucial para a experiência do usuário. Demonstrarei como criar testes de integração que validam se as mensagens de erro estão adequadas ao idioma definido.

Nesta aula, conduzirei você por um guia passo a passo para integrar seu projeto no Azure DevOps com o SonarCloud, uma combinação fundamental para garantir a qualidade contínua do código. Desde a configuração inicial do projeto no SonarCloud até a incorporação das análises no seu pipeline no Azure DevOps, cada passo será explicado de forma clara.

Nesta aula, você será guiado na criação de um pipeline no Azure DevOps, integrando-o de maneira direta e eficaz ao SonarCloud. Abordaremos desde a configuração inicial do pipeline até a inclusão das análises do SonarCloud, assegurando uma integração contínua que avalia a qualidade do código automaticamente. Ao final, você terá um pipeline configurado para incorporar análises do SonarCloud em seu fluxo de desenvolvimento, fortalecendo a garantia de qualidade em seu projeto.

Nesta aula, vamos abordar a correção de security hotspots, áreas destacadas pelo SonarCloud como potenciais vulnerabilidades de segurança no código. Explorarei passo a passo como identificar e corrigir esses hotspots, adotando boas práticas de segurança para fortalecer seu código. Ao explicar os conceitos por trás de cada correção, você ganhará uma compreensão aprofundada de como mitigar riscos de segurança em seu projeto.

Nesta aula, abordaremos o processo detalhado de correção de code smells, identificados pelo SonarCloud como áreas do código que podem ser otimizadas para melhor legibilidade e manutenibilidade. Passo a passo, vou guiá-lo na identificação desses code smells e na aplicação de correções práticas, utilizando técnicas que não apenas eliminam os problemas, mas também promovem um código mais claro e eficiente. Ao final desta aula, você não apenas terá corrigido os code smells no seu projeto, mas também desenvolvido um entendimento aprofundado sobre como manter um código limpo e resiliente ao longo do tempo.

Nesta aula, vamos mergulhar no atributo NotNullWhen do C#, uma ferramenta poderosa para o controle de fluxo de código baseado em análise de nulidade. Vou explicar como o NotNullWhen é utilizado para informar ao compilador as expectativas sobre a nulidade de parâmetros e retornos de métodos sob certas condições, melhorando a segurança do tipo e reduzindo a possibilidade de erros de NullReferenceException. Através de exemplos práticos, demonstraremos como aplicar o NotNullWhen em cenários comuns, como em métodos de validação ou funções que retornam um valor booleano indicando o sucesso da operação e, simultaneamente, um resultado por referência.

Nesta aula, concentraremos nossos esforços na correção da cobertura de testes, conforme apontada pelo SonarCloud. Vou guiá-lo através do processo de identificação das áreas com cobertura insuficiente e, em seguida, demonstrar estratégias práticas para melhorar essa cobertura.

Nesta aula, abordaremos o processo de reavaliação das métricas no SonarCloud após a correção de todos os números identificados. Passo a passo, vou guiá-lo na revisão das métricas-chave, destacando como as correções implementadas impactaram positivamente a qualidade do código. Analisaremos indicadores como maintainability, reliability, security, e coverage, fornecendo insights valiosos sobre o progresso alcançado. Essa reavaliação não apenas valida as melhorias realizadas, mas também oferece uma visão clara do impacto das ações corretivas na qualidade geral do projeto.

Realizaremos uma análise abrangente do progresso alcançado e identificaremos oportunidades de melhoria. Vou guiar você na avaliação dos objetivos definidos para a Sprint, revisando entregas, marcos e a eficácia do time. Discutiremos conquistas notáveis, desafios enfrentados e lições aprendidas durante a Sprint.

Vou guiá-lo através do processo de conduzir uma retrospectiva eficiente no Azure DevOps. Desde a configuração do ambiente até a análise dos resultados da Sprint, enfocaremos a identificação de oportunidades de melhoria e ações específicas para impulsionar o progresso contínuo do projeto. Aprenderemos a facilitar a colaboração da equipe e promover um ambiente propício ao feedback construtivo.

Na segunda sessão de Sprint Planning, nosso principal objetivo será direcionar nosso foco para o fluxo do usuário. Vamos dedicar tempo para mapear e priorizar as histórias de usuário de maneira a refletir as jornadas e experiências que nossos usuários vivenciam. Durante esta sessão, discutiremos as funcionalidades que impactam diretamente a usabilidade e satisfação do usuário, buscando alinhar nossas metas de desenvolvimento com as expectativas do cliente.

Nesta aula rápida, você aprenderá a configurar seu projeto para adotar URLs em minúsculas por padrão. Ao seguir estas instruções simples, você promoverá uma uniformidade elegante nas URLs do seu aplicativo, contribuindo para uma experiência de usuário mais consistente e uma estrutura de aplicativo mais organizada.

Nesta rápida aula, você aprenderá a criar um converter personalizado para lidar com espaços em branco nas propriedades do corpo das requisições. Abordaremos a configuração desse converter, incluindo a implementação de lógica para eliminar espaços indesejados nas propriedades dos objetos recebidos. Com essa solução, você garantirá a consistência e a integridade dos dados, evitando problemas relacionados a espaços em branco durante o processamento das requisições. Ao final da aula, você estará apto a integrar essa abordagem customizada em seu projeto, aprimorando a robustez na manipulação de dados nas requisições HTTP.

Nesta aula, vamos explorar em detalhes a função no repositório dedicada à operação de login, fazendo uso da opção AsNoTracking. Abordarei como essa função específica é projetada para otimizar consultas, sem rastrear entidades no contexto do Entity Framework durante operações de login. Explicarei as razões para a escolha do AsNoTracking, destacando benefícios como a redução do consumo de recursos e melhor desempenho ao lidar com consultas que não exigem o rastreamento de alterações.

Nesta aula, vamos elaborar a regra de negócio para as operações de login, enfatizando a validação de credenciais. Além disso, abordarei a importância da implementação de uma Custom Exception específica para casos de falha no login. Exploraremos como criar e utilizar essa exceção personalizada para capturar situações de autenticação inválida, proporcionando uma gestão mais eficiente de erros e possibilitando uma resposta personalizada ao usuário.

Nesta aula, concentraremos nossos esforços na organização e no reaproveitamento eficiente de código, priorizando a estrutura e clareza do endpoint de login e controllers. Abordarei técnicas para modularizar e reutilizar partes do código, promovendo uma base sólida para futuras extensões e manutenções. Vamos explorar maneiras de estruturar os controllers de forma coesa, melhorando a legibilidade e facilitando a manutenção.

Nesta aula, abordaremos a implementação de testes de unidade focados na cobertura da lógica da regra de negócio para operações de login. Explorarei a criação de casos de teste que avaliam diferentes cenários, desde autenticações bem-sucedidas até situações de falha, garantindo uma abrangência completa da funcionalidade.

Nesta aula, nos concentraremos na criação de testes de integração destinados a validar de forma abrangente o processo de login em sua aplicação. Explorarei a configuração de cenários de teste que simulam interações reais com os diversos componentes envolvidos, desde a camada de controle até a persistência de dados. Utilizaremos ferramentas e frameworks de teste de integração para garantir a coesão e funcionalidade correta do fluxo de login.

Nesta aula, abordaremos uma refatoração essencial para eliminar redundâncias nos seus testes de integração. Vou demonstrar uma técnica eficaz para identificar e consolidar padrões de código duplicados, simplificando a manutenção e promovendo uma abordagem mais eficiente nos seus testes. Ao aprender essa técnica de refatoração, você estará capacitado a otimizar seus testes de integração, melhorando a clareza e a consistência do código, ao mesmo tempo em que mantém a confiabilidade nos resultados dos testes.

Nesta aula, você aprenderá passo a passo como gerar um Access Token utilizando JSON Web Tokens (JWT) para autenticação em sua aplicação. Abordarei a criação e configuração do token, incluindo informações como payload e cabeçalho, e explicarei como a assinatura garante a integridade dos dados. Vamos explorar a utilização de bibliotecas ou frameworks específicos para a geração do JWT, proporcionando uma implementação segura e eficiente.

Nesta aula, abordaremos a realização de testes práticos para validar a geração correta do Access Token por meio de chamadas à API. Exploraremos a configuração de cenários de teste realistas que simulam solicitações autênticas, verificando a resposta e a estrutura do token gerado.

Nesta aula, concentraremos esforços na refatoração dos testes de unidade para assegurar uma cobertura completa e precisa da geração do Access Token. Abordarei estratégias para ajustar e melhorar os casos de teste existentes, incorporando cenários específicos que validam a correta criação e estruturação do token. Vamos explorar técnicas de refatoração que garantam a manutenibilidade dos testes, possibilitando a fácil incorporação de futuras alterações na lógica de geração do Access Token.

Nesta aula, vou guiar você através do processo de configuração do Swagger para incluir tokens nas requisições, proporcionando uma experiência mais completa e autenticada durante o teste de sua API. Exploraremos passo a passo como integrar a autenticação via token no Swagger, permitindo que você teste endpoints protegidos diretamente na interface do Swagger.

Nesta aula, você aprenderá a realizar a validação eficaz de tokens JWT recebidos durante o processo de autenticação. Abordarei os passos necessários para verificar a autenticidade, integridade e validade temporal do token, garantindo uma camada robusta de segurança.

Nesta aula, vamos explorar a criação de um atributo personalizado para autorização, proporcionando uma abordagem flexível e adaptável para controlar o acesso aos seus endpoints. Vou demonstrar passo a passo como desenvolver e integrar esse atributo customizado em sua aplicação, permitindo que você defina políticas específicas de autorização de maneira modular. Ao final da aula, você estará apto a aplicar esse atributo de forma estratégica, proporcionando uma camada adicional de controle e segurança na autenticação dos usuários em seus endpoints.

Nesta aula, vamos explorar a implementação de uma classe dedicada a recuperar a entidade de usuário a partir do token de autenticação em sua aplicação. Abordarei a lógica por trás dessa classe, destacando a importância da segurança na manipulação de tokens e a necessidade de obter informações relevantes do usuário de forma eficiente.

Abordarei como extrair e utilizar as informações de perfil do token de autenticação, proporcionando uma maneira eficiente de personalizar a experiência do usuário com base em seus dados específicos. Com instruções claras, você será capaz de implementar essa funcionalidade em sua aplicação, garantindo uma abordagem personalizada e adaptada às necessidades individuais de cada usuário.

Nesta aula abrangente, exploraremos a criação de testes de unidade e integração específicos para a funcionalidade de recuperar o perfil do usuário em sua aplicação. Irei demonstrar como estruturar casos de teste que abranjam diferentes cenários, desde situações ideais até possíveis falhas. Com foco na qualidade e confiabilidade, você aprenderá a implementar testes robustos que garantem a precisão e a consistência na recuperação de perfis.

Nesta aula, vou guiar você através do processo prático de atualização do perfil do usuário em sua aplicação. Abordarei estratégias eficientes para realizar modificações no perfil, considerando boas práticas de segurança e desempenho. Com exemplos claros e passo a passo, você aprenderá a implementar operações de atualização de perfil, permitindo que seus usuários mantenham suas informações sempre atualizadas.

Nesta aula, exploraremos a criação de testes de unidade específicos para a operação de atualização de usuário em sua aplicação. Abordarei estratégias para criar casos de teste que cubram diferentes cenários, desde atualizações bem-sucedidas até situações de erro. Com enfoque na qualidade e confiabilidade, você aprenderá a implementar testes robustos que validam a precisão e a consistência da lógica de atualização de perfil.

Nesta aula, apresentarei uma refatoração concisa e valiosa no encriptador de senhas de sua aplicação. Exploraremos estratégias para otimizar e aprimorar o código, mantendo a segurança essencial na manipulação de senhas. Com exemplos práticos, você aprenderá a implementar essa pequena, porém significativa, refatoração, proporcionando uma gestão mais eficiente e segura das senhas em sua aplicação.

Nesta aula abrangente, guiarei você através do fluxo completo de alteração de senha do usuário em sua aplicação. Desde a solicitação inicial até a validação e aplicação segura da nova senha, abordaremos cada etapa com detalhes práticos. Vou destacar as melhores práticas para garantir a segurança durante o processo e técnicas adequadas de validação.

Nesta aula abrangente, vamos explorar a criação de testes de unidade e integração específicos para a funcionalidade de alteração de senha do usuário em sua aplicação. Irei demonstrar como estruturar casos de teste que abranjam diferentes cenários, desde solicitações bem-sucedidas até situações de erro. Com enfoque na qualidade e confiabilidade, você aprenderá a implementar testes robustos que garantem a precisão e segurança na alteração de senhas.

Nesta aula, abordaremos a resolução de erros relacionados a "Shallow Clone" identificados pelo SonarCloud em seu projeto. Vou fornecer uma explicação detalhada sobre o que significa esse termo e como a prática de shallow clone pode afetar negativamente a análise de código. Com exemplos práticos, mostrarei como ajustar as configurações de clone para evitar esse problema específico, garantindo uma integração suave e precisa com o SonarCloud.

Nesta aula de aprimoramento contínuo, vamos analisar de perto as métricas fornecidas pelo SonarCloud e realizar correções nos pontos apontados. Exploraremos estratégias eficazes para abordar e melhorar as métricas de qualidade de código, desde a resolução de code smells até a otimização da cobertura de testes. Com orientações práticas, você aprenderá a interpretar as métricas do SonarCloud e aplicar ajustes no código para garantir uma base sólida e confiável.

Nesta aula, conduziremos a Sprint Planning focada na conclusão do fluxo de receitas em nosso projeto. Vamos priorizar tarefas como o cadastro, atualização, filtragem e exclusão de receitas, garantindo uma experiência robusta e completa para os usuários. Discutiremos os requisitos específicos, estabeleceremos metas claras e definiremos as histórias de usuário que comporão esta sprint. Ao final desta aula, teremos um plano sólido para a sprint, com objetivos claros e um caminho definido para alcançar a conclusão bem-sucedida do fluxo de receitas em nosso projeto.

Nesta aula, daremos os primeiros passos na migração da tabela de receitas em nosso projeto e exploraremos o conceito de chaves estrangeiras. Vou explicar como as chaves estrangeiras são usadas para estabelecer relacionamentos entre tabelas em um banco de dados, garantindo integridade referencial e consistência dos dados. Abordaremos a criação de uma nova migração para adicionar uma chave estrangeira à tabela de receitas, estabelecendo um relacionamento com a tabela de usuários.

Nesta aula, vamos estender a migração da tabela de receitas para incluir relacionamentos com as tabelas de ingredientes, instruções e tipos de prato. Além disso, exploraremos o conceito de exclusão em cascata e como implementá-lo com o Fluent Migrator. Vou demonstrar como adicionar chaves estrangeiras para estabelecer os relacionamentos entre as tabelas, garantindo integridade referencial e consistência dos dados. Em seguida, explicarei como configurar a exclusão em cascata, para que a remoção de uma receita também remova automaticamente seus ingredientes e instruções associados. Abordaremos a sintaxe específica do Fluent Migrator para definir essas regras de exclusão em cascata, garantindo que o banco de dados mantenha sua integridade mesmo durante operações de exclusão.

Nesta aula, vamos testar a nova migration criada e eu apresentarei as entidades necessárias para a receita em nosso projeto. Vou demonstrar como executar os testes da migration para garantir que o banco de dados seja atualizado corretamente. Em seguida, apresentarei as entidades, como Receita, Ingrediente, Instrução e Tipo de Prato, explicando suas propriedades e relacionamentos.

Nesta aula, daremos os primeiros passos na criação de um validador para requests de receitas em nosso projeto. Vamos focar na validação das propriedades mais simples da receita, como nome, tempo de preparo e nível de dificuldade. Vou mostrar como usar o FluentValidation para definir regras de validação para cada propriedade, garantindo que os dados enviados através da API estejam corretos e consistentes.

Nesta aula, iniciaremos os testes de unidade para o validador de receitas em nosso projeto. Vou mostrar como configurar e escrever testes para garantir que as regras de validação definidas no validador estejam funcionando corretamente. Vamos utilizar uma abordagem baseada em testes unitários, onde cada regra de validação será testada individualmente, verificando se os cenários de sucesso e de falha são tratados adequadamente.

Nesta aula, vamos abordar a validação das listas de informações da receita, como ingredientes e instruções, utilizando o FluentValidation. Exploraremos como definir regras de validação para essas listas, garantindo que estejam corretas e consistentes. Demonstrarei como criar validadores específicos para cada tipo de lista, verificando a presença, o formato e outros critérios de validação.

Nesta aula, vamos aprofundar nossos testes de unidade para o validador de receitas, considerando agora as listas de ingredientes e instruções. Vou demonstrar como escrever testes que verificam se as regras de validação para essas listas estão sendo aplicadas corretamente.

Nesta aula, abordaremos a regra de negócio para criar receitas em nosso sistema. Vou explicar os requisitos e as validações necessárias para garantir que uma receita seja criada de forma correta e consistente. Discutiremos as etapas envolvidas, como a verificação da existência de ingredientes e a validação das quantidades, a garantia de que as instruções sejam claras e coerentes, e a associação adequada com o tipo de prato.

Nesta aula, vamos explorar os tipos de IDs mais comuns no mercado, analisando seus prós e contras, e discutir a abordagem que vamos utilizar em nosso projeto. Vou explicar as diferenças entre IDs inteiros, GUIDs e UUIDs, destacando suas características, como unicidade, performance, segurança e facilidade de uso. Discutiremos as vantagens e desvantagens de cada tipo em diferentes cenários de aplicação. Em seguida, apresentarei nossa abordagem para a modelagem de dados em nosso projeto, explicando por que escolhemos um determinado tipo de ID e como isso se alinha com nossos requisitos e objetivos.

Nesta aula, vamos aprender a usar o pacote NuGet chamado Sqids para criptografar IDs antes de retorná-los ao front-end. Vamos instalar o pacote Sqids e integrar sua funcionalidade em nosso projeto .NET. Demonstrarei como configurar e utilizar o Sqids para converter IDs numéricos em strings criptografadas de forma segura. Em seguida, vamos implementar essa criptografia nos endpoints relevantes da nossa API, garantindo que os IDs expostos ao front-end estejam protegidos.

Nesta aula, vou guiá-lo através dos passos necessários para criar testes de unidade abrangentes para o processo de registro de receitas. Vou explicar a importância de testar cada parte do fluxo de criação de receitas, garantindo que todas as validações e regras de negócio sejam verificadas.

Nesta aula, vou mostrar como criar o endpoint para filtrar receitas e explicar as regras de negócio associadas, além de justificar a escolha do método POST para receber os filtros no corpo da requisição. Criaremos um modelo de filtro que incluirá propriedades como nome da receita, tipo de prato, tempo de preparo e ingredientes. A escolha do método POST se deve à complexidade dos filtros, que são mais facilmente enviados no corpo da requisição, evitando limitações de tamanho de URL e melhorando a segurança e flexibilidade.

Nesta aula, vou mostrar como implementar e explicar o repositório para filtrar receitas em nosso projeto. Implementaremos nossa função utilizando LINQ para construir consultas dinâmicas que aplicam filtros como nome da receita, tipo de prato, tempo de preparo e ingredientes. Explicarei a importância de abstrair a lógica de acesso a dados no repositório para promover um design mais modular e testável.

Nesta aula, vamos explorar o conceito de Data Transfer Objects (DTOs) e records no C#, explicando como e por que usá-los em nosso projeto. Discutiremos como os DTOs ajudam a transferir dados entre camadas da aplicação. Em seguida, vamos entender os records, uma funcionalidade do C# que facilita a criação de objetos imutáveis com uma sintaxe simplificada.

Nesta aula, vou mostrar e explicar todos os testes de unidade necessários para garantir que o filtro de receitas funcione corretamente.

Nesta aula, vamos implementar a regra de negócio e o repositório necessários para recuperar uma receita específica pelo seu ID. Vou mostrar como criar um método no repositório que busca a receita no banco de dados utilizando o ID fornecido. Em seguida, explicarei a regra de negócio para validar a existência da receita e como retornar os dados adequados ou uma mensagem de erro caso a receita não seja encontrada.

Nesta aula, vamos explorar o conceito de ModelBinder e aprender como criar um ModelBinder personalizado. ModelBinders são responsáveis por mapear dados de solicitações HTTP para parâmetros nos controllers. Criaremos um ModelBinder personalizado para demonstrar como ele pode ser usado para transformar dados complexos antes que eles cheguem aos métodos de ação.

Nesta aula, vamos aprender a adicionar um filtro no Swagger para que ele aceite IDs como strings nas suas APIs documentadas. Vou mostrar como configurar o Swagger para interpretar corretamente os parâmetros de ID como strings, em vez de números.

Nesta aula, você aprenderá a criar testes de unidade para o método de recuperação de receitas por ID, utilizando frameworks como xUnit e Moq. Vamos configurar o ambiente de teste, escrever testes para cenários de sucesso e falha, e usar mocks para simular o comportamento do repositório.

Nesta aula, vou explicar o fluxo completo para deletar uma receita, desde a definição do endpoint DELETE na API até a lógica de verificação e exclusão no serviço. Abordaremos a verificação da existência da receita, o tratamento de dependências relacionadas e a exclusão em cascata, garantindo a integridade dos dados. Por fim, discutiremos como retornar respostas apropriadas, como códigos de status HTTP 204 para sucesso ou 404 para receita não encontrada.

Nesta aula, vamos criar testes de unidade para o fluxo de deletar uma receita. Utilizando frameworks como xUnit e Moq, configuraremos o ambiente de teste e escreveremos testes para verificar se a lógica de exclusão de receitas funciona corretamente. Testaremos cenários de sucesso, onde a receita é deletada com sucesso, e cenários de falha, como quando a receita não é encontrada.

Nesta aula, vou mostrar como implementar a função para atualizar dados de uma receita utilizando o Entity Framework. Também explicarei como é possível ter funções de mesmo nome e mesmos parâmetros em interfaces diferentes, explorando o conceito de implementação explícita de interface.

Nesta aula, vou demonstrar que a funcionalidade de atualização de receitas está funcionando corretamente e que as alterações feitas em uma receita são aplicadas corretamente no banco de dados. Utilizando o endpoint da API, faremos atualizações em diferentes campos de uma receita, como nome, ingredientes e instruções. Em seguida, verificaremos as mudanças persistidas no banco de dados para assegurar que a operação de atualização foi bem-sucedida.

Nesta aula, vou mostrar como criar e executar testes de unidade e integração para a funcionalidade de atualização de receitas. Utilizaremos xUnit e Moq para validar a lógica de atualização de forma isolada e, em seguida, realizaremos testes de integração para verificar a interação entre os componentes do sistema e a persistência dos dados no banco de dados In-Memory. Isso garantirá que a atualização de receitas funcione corretamente em todos os níveis.

Nesta aula, vou mostrar como implementar o fluxo de recuperação de receitas para o dashboard utilizando o método Take para limitar o número de resultados. Explicarei como configurar o endpoint na API para retornar uma lista de receitas que será exibida no dashboard. Vamos utilizar o Entity Framework para consultar o banco de dados e aplicar o método Take para pegar uma quantidade específica de receitas. Demonstrando como isso pode melhorar a performance e a experiência do usuário ao carregar apenas os dados necessários.

Nesta aula, vou demonstrar como criar e executar testes de unidade e integração para a funcionalidade de recuperação de receitas no dashboard. Primeiro, configuraremos testes de unidade utilizando xUnit e Moq para validar a lógica de recuperação de receitas. Em seguida, implementaremos testes de integração para verificar a interação entre a API, o repositório e o banco de dados, assegurando que o fluxo completo de recuperação de receitas para o dashboard funcione corretamente.

Nesta aula, vou mostrar como analisar as métricas de qualidade de código fornecidas pelo SonarCloud e corrigir os problemas apontados. Revisaremos o relatório gerado, destacando as principais áreas de melhoria e vou demonstrar como corrigir os problemas identificados.

Nesta aula de Sprint Planning 4, vamos definir o fluxo de trabalho para a integração do nosso sistema com várias ferramentas externas. Focaremos em integrar o ChatGPT para gerar receitas, implementar funcionalidades de upload de imagens, configurar serviços de mensageria para comunicação eficiente e conectar com as APIs do Google para ampliar as capacidades do nosso projeto.

Nesta aula, vou explicar o fluxo inicial para implementar a geração de receitas utilizando o ChatGPT. Começaremos definindo o endpoint na API que receberá a solicitação de geração de receita, seguido pela validação dos dados recebidos e o UseCase.

Nesta aula, vou te guiar através do processo de criação de uma conta na plataforma da OpenAI e explicar os preços associados ao uso do ChatGPT. Primeiramente, acessaremos o site da OpenAI, onde mostrarei como realizar o cadastro, preencher as informações necessárias e configurar a conta. Em seguida, exploraremos a seção de preços da OpenAI e como é calculado o uso do ChatGPT. Ao final desta aula, você estará preparado para configurar sua conta na OpenAI e entender os custos envolvidos no uso do ChatGPT.

Nesta aula, vou mostrar como integrar o ChatGPT em uma aplicação .NET. Começaremos obtendo a chave de API da OpenAI e configurando as dependências no projeto .NET. Em seguida, criaremos uma classe de serviço para realizar chamadas utilizando o Nuget da OpenAI e processando respostas. Ao final, você terá uma aplicação .NET capaz de interagir com o ChatGPT, permitindo a geração de respostas automatizadas.

Nesta aula, vou mostrar como integrar o ChatGPT em sua aplicação .NET e converter as respostas em texto para instâncias de classes. Primeiramente, configuraremos o serviço para fazer chamadas à API do ChatGPT e obter a resposta em texto. Em seguida, demonstrarei como analisar o texto retornado e mapeá-lo para uma classe específica, utilizando técnicas de parsing e manipulação de strings.

Nesta aula, vou mostrar como criar testes de unidade e integração para a funcionalidade de geração de receitas com ChatGPT em nossa API. Utilizaremos frameworks como xUnit e Moq para validar a lógica de geração de receitas de forma isolada e simularemos respostas da API do ChatGPT. Em seguida, discutiremos os testes de integração para validar o fluxo completo, incluindo a comunicação com o ChatGPT.

Nesta aula, vou explicar o fluxo inicial para implementar a funcionalidade de upload de imagens em nossa aplicação.

Nesta aula, vou explicar a importância de validar arquivos recebidos para garantir que sejam realmente imagens e mostrar como realizar essa validação. Validar arquivos é crucial para a segurança e integridade do sistema, prevenindo a injeção de arquivos maliciosos. Demonstrararei como usar bibliotecas para inspecionar o conteúdo do arquivo, confirmando que ele é uma imagem válida.

Nesta aula, vou mostrar como criar uma conta no portal do Azure. Primeiro, acessaremos o site oficial do Azure e clicaremos na opção para iniciar o processo de criação de conta e preencheremos as informações necessárias. Vou te guiar por cada etapa, explicando as opções disponíveis para escolher o que melhor se adapta às suas necessidades.

Nesta aula, farei uma visão geral do portal do Azure, explicando os conceitos de Subscription e Resource Group. Primeiro, acessaremos o portal do Azure e exploraremos o layout e as principais funcionalidades. Explicarei o que é uma Subscription, que representa um acordo com a Microsoft para usar os serviços do Azure, incluindo o controle de custos, faturamento e acesso aos serviços. Em seguida, abordaremos o conceito de Resource Group, que é um contêiner lógico que agrupa recursos relacionados para facilitar a gestão e organização. Discutiremos como criar e gerenciar Resource Groups, além de entender suas melhores práticas para manter a infraestrutura organizada e eficiente.

Nesta aula, vamos criar uma Storage Account no Azure e configurar nosso projeto para utilizá-la. Primeiro, acessaremos o portal do Azure e criaremos uma nova Storage Account, preenchendo os detalhes necessários, como nome e localização. Em seguida, obteremos a Connection String para conectar nosso projeto à Storage Account. Configuraremos o projeto .NET usando a biblioteca Azure.Storage.Blobs para permitir o upload e a gestão de arquivos, ajustando as configurações no appsettings.json e implementando o código necessário.

Nesta aula, vamos implementar a funcionalidade de upload de imagem para a Azure Storage Account usando o pacote NuGet Azure.Storage.Blobs.

Nesta aula, vamos explorar diferentes formas de recuperar e retornar imagens associadas a receitas na nossa API, discutindo as vantagens de cada abordagem. Primeiro, explicaremos como retornar a URL pública da imagem armazenada na Azure Storage Account, permitindo que o cliente acesse a imagem diretamente. Em seguida, abordaremos a técnica de retornar a imagem como um fluxo de bytes (stream), embutindo a imagem na resposta da API para maior controle sobre o acesso e a segurança. Também discutiremos a opção de usar URLs assinadas (SAS tokens) para fornecer acesso temporário e seguro às imagens armazenadas.

Nesta aula, vou mostrar como deletar uma imagem associada a uma receita. Implementaremos a lógica no controlador para identificar a imagem associada à receita e utilizar a biblioteca Azure.Storage.Blobs para remover a imagem da Azure Storage Account.

Nesta aula, vou ensinar como criar uma receita com uma imagem associada, utilizando o FormData para enviar os dados através da API. Configuraremos o endpoint HTTP POST na API para receber a solicitação de criação de receita e imagem. No frontend, usaremos o FormData para construir a requisição, permitindo o envio conjunto dos dados da receita e da imagem. No controlador, extrairemos e validaremos os dados, fazendo o upload da imagem para a Azure Storage Account com Azure.Storage.Blobs e salvando a receita no banco de dados.

Nesta aula, vamos realizar uma pequena refatoração para evitar duplicação de código nas validações de arquivos de imagem em nossa API. Primeiro, identificaremos os trechos de código repetidos relacionados à validação de imagens.

Nesta aula, vamos aprender como recuperar uma lista de receitas juntamente com suas imagens associadas. Vamos implementar a lógica para buscar as receitas no banco de dados e incluir as URLs das imagens armazenadas na Azure Storage Account. Utilizaremos a biblioteca Azure.Storage.Blobs para gerar as URLs de acesso às imagens de cada receita. Finalmente, retornaremos a lista de receitas com suas respectivas URLs de imagens no response da API.

Nesta aula, vamos criar testes de unidade e integração para o fluxo de upload de imagem em nossa aplicação. Primeiro, configuraremos testes de unidade utilizando frameworks como xUnit e Moq para validar a lógica de upload de imagem de forma isolada.

Nesta aula, vamos criar testes de integração para o fluxo de registro de receita utilizando Form-Data. Vamos configurar o ambiente de testes para suportar requisições multipart/form-data, que permitem o envio conjunto de dados da receita e a imagem associada usando o HttpClient.

Nesta aula, vamos configurar o fluxo inicial para deletar contas de usuários em nossa aplicação. Configuraremos o endpoint HTTP DELETE na API para receber a solicitação de deleção, implementaremos a lógica no UseCase para identificar o usuário autenticado e colocar na fila de mensagens uma nova mensagem para ser processada e discutiremos como realizar a exclusão segura de todos os dados associados ao usuário.

Nesta aula, vou ensinar como configurar um Azure Service Bus para o envio de mensagens. Primeiro, criaremos um namespace e uma fila no portal do Azure. Em seguida, instalaremos o pacote NuGet Azure.Messaging.ServiceBus no projeto .NET e implementaremos a lógica para conectar ao Service Bus usando a Connection String.

Nesta aula, vou ensinar como configurar um Background Service em uma aplicação .NET. Primeiro, criaremos uma nova classe que herda de BackgroundService e implementaremos o método ExecuteAsync, onde definiremos a lógica que será executada em segundo plano. Em seguida, registraremos o serviço no contêiner de dependências da aplicação utilizando o método AddHostedService no Startup.cs. Vou demonstrar como configurar intervalos de execução e como lidar com o ciclo de vida do serviço para garantir que ele funcione corretamente e de maneira eficiente.

Nesta aula, vamos implementar a lógica para deletar a conta de um usuário registrado em nosso projeto. Implementaremos um UseCase e uma função no repositório para remover o usuário do banco de dados, assegurando que todos os dados associados sejam excluídos de forma segura.

Nesta aula, vamos iniciar a configuração do portal do Google e integrar nossos serviços com uma aplicação .NET. Primeiro, acessaremos o Google Cloud Console e criaremos um novo projeto. Em seguida, vamos criar um ID de cliente OAuth 2.0. Depois de configurar o Google Cloud, voltaremos ao projeto .NET e instalaremos os pacotes NuGet necessários. Demonstrararei como configurar a autenticação no projeto .NET utilizando as credenciais obtidas.

Nesta aula, vou explicar o fluxo completo de login com Google em uma aplicação .NET. Primeiro, discutiremos a configuração do Google Cloud Console, onde criaremos um projeto e configuraremos as credenciais OAuth 2.0 necessárias para a autenticação. Em seguida, no lado do cliente, implementaremos o botão de login com Google, que redirecionará o usuário para a página de autorização do Google. Depois que o usuário conceder permissão, o Google redirecionará de volta à nossa aplicação com as informações do usuário(a).

Nesta aula, vamos criar um endpoint HTTP GET na nossa API para realizar o login com Google, especificamente para ser utilizado por um front-end.

Nesta aula, vamos finalizar a implementação do fluxo de login com Google em nossa aplicação. Após termos criado o endpoint HTTP GET, vamos integrar a lógica de verificação de usuário no banco de dados. Se o usuário não existir, criaremos um novo registro com as informações obtidas do Google. Em seguida, geraremos um token de autenticação JWT para o usuário, permitindo o acesso seguro aos recursos protegidos da aplicação. Finalmente, retornaremos esse token para o app, completando o fluxo de login.

Nesta aula, vamos abordar como criar testes de unidade e integração para o fluxo de login com Google em nossa aplicação.

Nesta aula, vamos discutir sobre o fluxo de "Esquecer Senha" em nossa aplicação, incluindo o envio de email para recuperação de senha.

Nesta aula de sprint planning, vamos aprender como fazer o deploy da API em produção no Azure. Discutiremos os preparativos necessários, incluindo a configuração do Azure App Service, a criação de pipelines de CI/CD no Azure DevOps e a definição das variáveis de ambiente para a produção.

Nesta aula, vamos explorar a importância da criptografia de senhas e implementar a troca para bcrypt em nossa aplicação. Discutiremos por que a criptografia é crucial para a segurança dos usuários e como bcrypt, uma biblioteca de hashing robusta, melhora essa segurança aplicando salting e hashing. Implementaremos bcrypt para hashear senhas no momento do registro e validá-las durante o login.

Nesta aula, vamos implementar o uso de refresh tokens em nossa aplicação para melhorar a segurança e a experiência do usuário no processo de autenticação. Discutiremos o conceito de refresh tokens e como eles funcionam para manter a sessão do usuário ativa sem exigir login frequente. Implementaremos endpoints na API para emitir refresh tokens durante o login inicial e validar e emitir novos tokens de acesso quando os tokens atuais expirarem.

Nesta aula, vamos explorar o que é Docker e por que ele se tornou uma ferramenta essencial no desenvolvimento moderno de software. Docker é uma plataforma de virtualização que permite criar, implantar e gerenciar aplicações em contêineres, que são unidades leves e portáteis de software que incluem tudo o que a aplicação precisa para rodar, como código, runtime, bibliotecas e dependências. Discutiremos os benefícios do uso de Docker, incluindo a consistência entre os ambientes de desenvolvimento e produção, a escalabilidade e a eficiência no uso de recursos.

Nesta aula, vamos aprender como criar um arquivo Dockerfile para nossa API, permitindo que ela seja empacotada em um contêiner Docker. Primeiro, discutiremos a importância do Dockerfile e os principais comandos utilizados para definir a imagem do contêiner. Em seguida, criaremos um Dockerfile no diretório raiz do projeto, especificando a imagem base, copiando os arquivos necessários e definindo o ponto de entrada da aplicação. Vamos configurar cada etapa do Dockerfile para garantir que a aplicação seja construída e executada corretamente dentro do contêiner.

Nesta aula, vamos explorar o conceito de Container Registry e aprender a criar um no portal do Azure. Um Container Registry é um serviço que permite armazenar e gerenciar imagens de contêineres de forma segura e centralizada. Discutiremos os benefícios de utilizar um Container Registry, como facilitar o desenvolvimento, a implantação e a escalabilidade das aplicações em contêineres. Em seguida, acessaremos o portal do Azure, criaremos um Azure Container Registry (ACR) e configuraremos suas propriedades básicas.

Nesta aula, vou mostrar como criar um banco de dados MySQL no portal do Azure para o ambiente de produção. Primeiro, acessaremos o portal do Azure e navegaremos até a seção de bancos de dados. Em seguida, escolheremos a opção de criar um novo banco de dados MySQL, configurando os detalhes necessários como o nome do servidor, a versão do MySQL, a localização e as credenciais de administrador.

Nesta aula, vamos aprender como criar um arquivo appsettings.Production.json e armazená-lo de forma segura no portal do Azure DevOps. Primeiro, criaremos o arquivo appsettings.Production.json para o nosso projeto, onde definiremos todas as configurações específicas do ambiente de produção, como strings de conexão, APIs e outras configurações críticas. Em seguida, discutiremos a importância de proteger informações sensíveis e como evitar a exposição de dados confidenciais. Vamos utilizar o Azure DevOps para armazenar de forma segura essas configurações.

Nesta aula, vamos criar um pipeline de Continuous Delivery (CD) que integra nossa aplicação com o Azure Container Registry (ACR). Primeiro, configuraremos o pipeline no Azure DevOps, definindo as etapas necessárias para construir e empacotar a aplicação em uma imagem de contêiner. Em seguida, configuraremos a integração com o ACR, garantindo que a imagem seja automaticamente enviada para o registro após a construção. Vamos configurar gatilhos para automatizar o processo de deploy, garantindo que novas versões da aplicação sejam implantadas de forma contínua e eficiente.

Nesta aula, vamos adicionar tasks no pipeline do Azure DevOps para fazer o download do arquivo appsettings.Production.json armazenado em Secure Files. Primeiro, acessaremos a configuração do pipeline no Azure DevOps e editaremos o arquivo YAML. Adicionaremos uma task para baixar o arquivo appsettings.production.json de Secure Files e colocá-lo no diretório correto do projeto durante o processo de build.

Nesta aula, vamos criar um App Service no Azure para hospedar e executar nossa API utilizando uma imagem Docker do Azure Container Registry. Primeiro, acessaremos o portal do Azure e navegaremos até a seção de App Services. Em seguida, criaremos um novo App Service, configurando os detalhes necessários, como nome, sistema operacional e região. Na configuração do App Service, escolheremos a opção de utilizar uma imagem Docker e conectaremos ao Azure Container Registry para selecionar a imagem da nossa API. Configuraremos as variáveis de ambiente necessárias e vamos testar nossa API no ambiente de Produção.

Nesta aula, vamos aprender a criar um endpoint de HealthCheck para monitorar a saúde da sua API. Primeiro, discutiremos a importância dos health checks para garantir que sua aplicação esteja funcionando corretamente. Em seguida, adicionaremos a biblioteca AspNetCore.HealthChecks ao projeto .NET e configuraremos o middleware de health check no Startup.cs. Finalmente, criaremos um endpoint dedicado que verifica o status dos componentes essenciais da aplicação, como a conexão com o banco de dados e a disponibilidade de serviços externos.

Nesta aula, vamos aprender a configurar o Continuous Deploy (CD) para automatizar a implantação da sua aplicação no Azure App Service. Primeiro, discutiremos os benefícios do CD, como entregas mais rápidas e a redução de erros manuais. Em seguida, configuraremos gatilhos para que cada nova alteração no código desencadeie automaticamente o processo de deploy para o App Service. Ao final desta aula, você terá um pipeline de Continuous Deploy configurado, garantindo que sua aplicação seja implantada de forma contínua e eficiente no Azure App Service sempre que houver uma nova atualização.