DEV Community: SalimFlowStack

Creating things that really matter

SalimFlowStack — Mon, 10 Mar 2025 16:47:16 +0000

Whether in entrepreneurship or development, if what you're doing doesn't speak to you, it's going to feel that way.

The cleanest code in the world is of no interest if the project behind it doesn't animate you. The same goes for a company: if you start it just to “be an entrepreneur” and not because you really want to build something that motivates you, you're likely to get bored very quickly.

What makes the difference is the alignment between what you create and what drives you.

If you're working on a project that makes sense to you, you're going to want to push it further, to perfect it. You're going to find solutions to problems instead of just executing tasks.

In short, whether you're a dev or an entrepreneur, ask yourself a real question: does what I'm building really speak to me?

If not, find a project that matters to you. That's where energy and real value are created. 🚀

How to Actually Start (and Finish) Development Projects Without Losing Your Mind 😅

SalimFlowStack — Tue, 18 Feb 2025 12:49:19 +0000

We’ve all been there – super pumped about starting a new project, sketching out some cool ideas, and then… poof… months go by, and the project is still in your “to-do” list. You’ve got a million tabs open with resources, and yet, somehow, that shiny new project remains unfinished. 🐢

Don’t worry, you’re not alone! But guess what? It doesn’t have to be this way. I’m here to share how to finally kick off that project, stay on track, and (dare I say it) actually finish it. Let's dive in!

1. Find Ideas That Don’t Suck (aka, Solve Real Problems) 🤔

Before you start coding, let’s talk about your project idea. Don’t just make something because you can – make something because it solves a problem. 📱🚑

For a project to be successful, it needs to address a pain point or a need. Think of it like this: You want people to say, “Wow, I need this in my life!” instead of “Oh, that’s nice… but does it actually do anything?” 😅

So, ask yourself:

What frustrates you daily?
What do you keep forgetting to do?
What do your friends/family/coworkers complain about all the time?

If you can find a problem that needs solving, you’re halfway there!

2. Break Down the Project Into Bite-Sized Chunks (Don’t Overwhelm Yourself) 🍕

Rome wasn’t built in a day, and neither will your amazing app. Don’t try to do everything at once. Divide your project into manageable tasks.

You’ve got to pace yourself. Maybe today, you’ll just set up the project’s folder structure. Tomorrow, you can tackle the login page. Little by little, you’ll build momentum.

Remember, every time you check off a task, it’s like a mini victory! 🎉 (And if you’re like me, you’ll give yourself a high-five every time you finish something. It’s totally normal, I promise. ✋)

3. Stay Committed: How Not to Quit Halfway (Or Get Distracted by Cats 🐱)

We all know how easy it is to get distracted, whether it’s scrolling through Twitter or watching a YouTube video about “5 Habits of Successful Coders” (spoiler: it’s just code). 😜

Here’s the trick: Set deadlines and stick to them. Even if it’s a personal project, you need some form of accountability. I recommend setting small, achievable goals, so you don’t feel overwhelmed.

Pro tip: Share your progress with others! Tweet about it, write about it on Dev.to, or tell your friends. You’ll be surprised at how motivating it can be to know that people are watching. (And don’t worry – they won’t judge your first version. We all start somewhere. 🚀)

4. Test, Iterate, and Don’t Be Afraid to Break Things (But Maybe Backup First) 🔧

No one gets everything right the first time (except maybe unicorns 🦄). You’ll make mistakes. You’ll encounter bugs. You’ll want to pull your hair out. But guess what? That’s part of the fun!

Testing, iterating, and improving your code is where the magic happens. So, when things break (and trust me, they will), treat it like an opportunity to learn and grow. 🧠

And hey, remember to back up your project regularly. Losing your code due to a failed hard drive is the stuff of nightmares. 😱 (Trust me, I’ve been there.)

5. Celebrate Your Success (No Matter How Small) 🎉

Once you’ve finally finished your project, take a moment to celebrate! 🥳 Whether it’s a simple "Yay, I did it!" or a full-on dance party (you do you), be proud of what you accomplished.

And remember, finishing one project is just the beginning. You’ll learn so much, and those lessons will help you with future projects. Plus, now you’ve got one more thing to add to your portfolio. 💼

In conclusion, starting and finishing development projects is all about finding an idea that solves a problem, breaking it down into manageable pieces, staying committed, and learning from your mistakes. Don’t forget to celebrate the small victories along the way! 🎉

So, what are you waiting for? Go ahead, pick a project, and make some code magic happen! 🚀

How AI Tools Like ChatGPT and Copilot Affected My Focus and Coding Skills 🤖💻

SalimFlowStack — Wed, 20 Nov 2024 08:27:38 +0000

As a developer, I've always been passionate about improving my coding skills, reading code, and diving deeper into problem-solving. However, in recent weeks, I've been experiencing something unexpected: I feel like my coding abilities and focus have significantly declined. The cause? The very tools that were supposed to make my life easier – AI-driven assistants like ChatGPT and GitHub Copilot. 😅

The Impact of AI Tools on My Coding Skills ⚡

When I first started using tools like ChatGPT and Copilot, they were a great boost to my productivity. They helped me write code faster, debug issues. At first, everything seemed perfect – a dream come true for a developer who wanted to focus on building rather than writing boilerplate code. 😍

But over time, I began noticing a subtle shift. I was no longer reading code the way I used to. Instead of spending time figuring out solutions, I was relying too heavily on AI to provide them for me. My code comprehension took a hit because I wasn’t engaging with the problems as deeply. It felt like I was outsourcing my cognitive processes to the AI, leading to a reduction in critical thinking and problem-solving abilities. 🤯

Moreover, my focus was deteriorating. With the constant access to quick code suggestions and instant answers, I found it harder to concentrate on tasks for longer periods. My attention span started shrinking, and I couldn’t sit down for long enough to fully immerse myself in challenging problems. I was coding like a robot… but without the efficiency. 🤖🚶‍♂️

Taking Action: Why I Decided to Cut AI Tools ⛔

After a few weeks of feeling stuck in this cycle, I realized I needed to take a step back. I needed to reawaken my ability to focus and engage deeply with code again. So, I decided to remove AI tools like ChatGPT and Copilot from my workflow for a while. It wasn’t an easy decision – these tools were convenient, after all – but I knew I needed to regain my ability to focus and code without distractions. 📴

This decision has been a wake-up call for me, reminding me of the importance of practice, focus, and actively engaging with code. It's easy to let technology take over, but we must ensure it serves us and not the other way around. 🧠💪

Exercises to Improve Focus and Code Comprehension 🔍

If you’re feeling like I did and want to regain your focus and coding skills, here are some exercises that can help:

1. Set Timed Focus Sessions ⏱️

Use the Pomodoro Technique or any time management method to create uninterrupted focus sessions. Work in 25- to 50-minute blocks and dedicate each session to reading and understanding code or solving coding problems. (Bonus: It’s like coding sprints with a timer. No AI interruptions allowed!) 🏃‍♂️💨

2. Solve Problems Without AI Assistance 🚫🤖

Try solving problems on coding platforms (e.g., LeetCode, HackerRank, Codewars) without looking up solutions or using AI tools. It forces you to think critically and find your own way, helping you rebuild problem-solving skills. Remember, Google isn’t your AI best friend here! 😜

3. Read and Refactor Code 🧐🔧

Pick a piece of code (either your own or someone else’s) and spend time understanding it. Try refactoring it to improve readability, efficiency, or performance. This exercise helps improve your code comprehension and writing skills. (Hint: You might end up making your code more elegant than a Shakespearean sonnet.) 🎭✨

4. Write Code from Scratch ✍️

Instead of relying on code generators or snippets, try building projects from scratch. Write everything yourself, even the parts that seem tedious. This process enhances your understanding of how things work under the hood. (And hey, every developer loves the feeling of creating something completely their own, right?) 🚀

5. Limit Multitasking 🚫🔄

Focus on one task at a time. Turn off notifications, and avoid jumping between tasks or switching between multiple tabs. If you’re reading an article, reading code, or debugging, give it your full attention. (Trust me, your brain will thank you!) 🧠💥

6. Engage in Code Review Sessions 📋👀

Take part in code reviews where you review others’ code and explain your reasoning. This will push you to critically analyze code and will improve your understanding and decision-making process. (Also, you might feel like a superhero when your code suggestions actually make a difference! 🦸‍♂️)

Conclusion: Finding a Balance ⚖️

AI tools like ChatGPT and Copilot are undoubtedly powerful, but it’s essential to find a balance. We should use these tools to augment our skills, not replace them entirely. By focusing on the exercises mentioned above, we can regain our ability to concentrate, think critically, and continuously improve as developers. It’s all about using technology in a way that enhances our own abilities rather than diminishing them.

If you’ve been feeling the same way or have similar experiences, I’d love to hear how you’ve managed to overcome it. Let’s continue to learn and grow together – and remember, AI is here to help, not to do all the work for us! 😄🤖

Let’s code like it’s 1999 again! (Just kidding, no one misses dial-up internet. But you get the point.) 🌐

Project Journey #2: 🛠️ Coding, Failing, and Learning with AI Law Shield ⚖️

SalimFlowStack — Sun, 17 Nov 2024 21:16:44 +0000

Welcome back to my AI journey, where I stumbled, learned, and maybe cried a little! 😂

1. Diving into the Code: The Good, The Bad, and The Ugly

This time, I got my hands dirty by coding the first version of my AI model. Spoiler alert: I achieved an accuracy of just 0.18945%! 🎯 (Ouch! I guess even my toaster could do better 🤖🍞).

Let's dive into the code and see what went wrong.


# Initializing BERT for sequence classification
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=5)

What’s happening here?
I'm using BERT, the superstar transformer model, to classify the danger level of legal contracts on a scale of 1 to 5. 📄

def preprocess_data(dataframe, tokenizer):
    texts = dataframe['texte'].tolist()
    labels = [label - 1 for label in dataframe['niveau_de_danger'].tolist()]
    encoded_data = tokenizer(texts, padding=True, truncation=True, return_tensors='pt')
    return encoded_data, labels

Why preprocess data?
I’ve tokenized the contract texts for BERT to digest (like breaking down a complex contract into easier-to-understand clauses). 🍽️

2. Training My Model: And… It Crashed and Burned 💥


def train_model(model, train_loader, num_epochs=5):
    device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
    model.to(device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

    for epoch in range(num_epochs):
        model.train()
        for batch in train_loader:
            optimizer.zero_grad()
            input_ids, attention_mask, labels = [b.to(device) for b in batch]
            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
            accuracy = (outputs.logits.argmax(dim=-1) == labels).float().mean()
            loss = outputs.loss
            loss.backward()
            optimizer.step()
        print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {loss.item()}')
    print(f'Final Loss: {loss:.4f}, Accuracy: {accuracy:.4f}')

This function trains BERT to classify contracts, but let’s just say it didn’t pass the bar exam 😬. The low accuracy told me that my model was basically guessing randomly.

3. Evaluating the Model: Reality Check 🧑‍⚖️


def evaluate_model(model, test_loader):
    model.eval()
    predictions = []
    true_labels = []
    with torch.no_grad():
        for batch in test_loader:
            input_ids, attention_mask, labels = [b.to(device) for b in batch]
            outputs = model(input_ids, attention_mask=attention_mask)
            _, predicted = torch.max(outputs.logits, dim=-1)
            predictions.extend(predicted.cpu().tolist())
            true_labels.extend(labels.cpu().tolist())
    return classification_report(true_labels, predictions)

After running this, I got a brutal classification report that screamed, "You need more data, buddy!" 📉

4. The Root Cause: My Dataset Needs a Lawyer-Grade Makeover 📊

After some reflection, I realized the real issue was my dataset. It’s like trying to learn law from a pamphlet instead of an encyclopedia. 📚

I need to get my hands on a large, reliable, and indexed dataset that can better train the model. If anyone knows where to find high-quality legal datasets, I’m all ears! 👂

5. Annotating Contracts (A Work in Progress) ✍️


def annotate_contract(model, tokenizer, contract_text):
    inputs = tokenizer(contract_text, padding=True, truncation=True, return_tensors='pt')
    with torch.no_grad():
        outputs = model(**inputs)
        _, predicted = torch.max(outputs.logits, dim=-1)
    danger_level = predicted.item() + 1
    problematic_sections = analyze_problematic_sections(contract_text, danger_level)

    return {
        'danger_level': danger_level,
        'problematic_sections': problematic_sections
    }

This function is supposed to analyze the legal contract and predict the danger level, but as you might guess, it’s not ready to replace your lawyer just yet. 🧐

Next Steps: A Better Dataset and Model Tuning 📈

I’m planning to go on a treasure hunt for a better dataset. Once I have more data, I’ll revisit model training, tweak hyperparameters, and hopefully get a model that can actually understand legal jargon! ⚖️

Until next time, may your accuracy be ever in your favor! 🚀

0x2e73

🚀 Project Journey #1: Picking the Tech Stack & Diving into AI 🤖

SalimFlowStack — Thu, 14 Nov 2024 08:28:05 +0000

Hey everyone! 👋

Today marks the beginning of my journey to build an AI-powered app that can analyze contracts and help users understand how risky they might be. 🌐⚖️

I’m a 4th-year apprentice developer, so my main goal with this project is to learn by doing (and hopefully not break too many things in the process 😅). So, let's jump into what I've been up to today!

🛠️ Choosing the Tech Stack

After a lot of research (and a few cups of coffee ☕), I’ve finally decided on the tech stack I’ll be using for this project:

Backend:

Python (with Flask 🚀) for the API
- Why Flask? It's lightweight, super easy to get started with, and perfect for building quick APIs to serve our AI models. Today, I learned how to set up a basic Flask API endpoint, and honestly... it was way easier than I expected!

💡 Frontend:

Next.js (React framework) for the UI 🌐
- Next.js will allow us to build a fast and SEO-friendly frontend. It's got server-side rendering, which means faster load times and better performance. 📈

AI Model:

Python (again, because who doesn’t love Python, right? 🐍)
- The AI will be using NLP (Natural Language Processing) models. Specifically, I’m looking into using BERT or GPT-like models from the HuggingFace library. These models are like super-smart language nerds that can understand and analyze human text. 🤓

🚀 Understanding Transformers and NLP Models 🤖

🔍 What Are Transformers? 🤖

Transformers are a type of deep learning model that revolutionized the field of NLP. They were introduced in a landmark paper called "Attention is All You Need" by Vaswani et al. in 2017. Unlike older models like RNNs (Recurrent Neural Networks) or LSTMs (Long Short-Term Memory networks), transformers are highly efficient at processing long sequences of text in parallel, which makes them both faster and more accurate.

🧠 Key Concept: Attention Mechanism

The secret sauce behind transformers is the attention mechanism. Attention allows the model to focus on the most relevant parts of the input text, regardless of its position in the sequence. Think of it like reading a contract — instead of reading every single word, your brain automatically zooms in on the important parts, like "hidden fees" or "data sharing." 🕵️‍♂️

Here's how it works in simple terms:

Understanding Context: Attention helps the model understand the relationship between different words in a sentence, even if they're far apart.
- Example: In the sentence, "The cat, which was very hungry, finally ate the food," the model knows that "ate" is related to "cat" even though there are many words in between.
Calculating Attention Scores: The model assigns an attention score to each word in the sequence. Higher scores mean more relevance to the task at hand.
- If you're analyzing a contract for risky clauses, the model might give high scores to words like "penalty," "termination," or "data sharing."

🧮 A Quick Peek at the Math

Each word in the input is transformed into a vector (a list of numbers) using something called word embeddings. The model then uses three vectors for each word:

Query (Q): What word are we focusing on?
Key (K): How important is this word to other words?
Value (V): The actual meaning of the word.

These vectors are used to calculate the attention scores, which determine how much focus should be given to each word in the sentence.

The formula looks like this:

Where:

( QK^T ) is the dot product of the query and key vectors.
( d_k ) is the dimension of the key vector (used to scale the values).
Softmax is a function that converts scores into probabilities.

📚 How NLP Models Like BERT and GPT Use Transformers

Transformers are the backbone of popular NLP models like BERT (Bidirectional Encoder Representations from Transformers) and GPT (Generative Pre-trained Transformer). Here's a breakdown of each:

🔎 BERT (Bidirectional Encoder Representations from Transformers)

Purpose: BERT is great for understanding the context of words in both directions (left-to-right and right-to-left). This makes it perfect for tasks like text classification, question answering, and contract analysis.
Architecture: BERT is made up of encoders only, which means it's focused on understanding the input text deeply.
Training: It’s pre-trained on a huge amount of text data with two tasks:
1. Masked Language Modeling: Predicting missing words in a sentence.
  - Example: "The [MASK] is in the garden" → "The cat is in the garden."
2. Next Sentence Prediction: Determining if one sentence logically follows another.
  - Example: "He opened the door." → "He walked into the room." (Yes) vs. "She went to the store." (No)

✍️ GPT (Generative Pre-trained Transformer)

Purpose: GPT is designed for generating text. It's excellent for tasks like text completion, content creation, and even conversational AI.
Architecture: GPT uses decoders only, which means it's focused on generating new text based on given input.
Training: GPT is trained on a vast dataset to predict the next word in a sentence.
- Example: "Once upon a time..." → "Once upon a time, there was a brave knight."

Key Difference:

BERT is bidirectional (understands the full context).
GPT is unidirectional (predicts the next word based on past context).

🛠️ How to Build Your AI for Contract Analysis

1. Data Preparation

Collect and clean a dataset of contracts.
Label the contracts with different levels of danger (like your CSV dataset).

2. Model Selection

For contract analysis, BERT or a fine-tuned version like RoBERTa could be a good fit because it’s great at understanding context.
Use Hugging Face Transformers library to access these models.

3. Training the Model

   from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
   from datasets import load_dataset

   # Load dataset
   dataset = load_dataset('csv', data_files='contracts.csv')

   # Tokenize data
   tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
   def tokenize_function(example):
       return tokenizer(example['text'], truncation=True)
   tokenized_datasets = dataset.map(tokenize_function, batched=True)

   # Load pre-trained BERT model
   model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=5)

   # Set up training arguments
   training_args = TrainingArguments(
       output_dir='./results',
       evaluation_strategy='epoch',
       learning_rate=2e-5,
       per_device_train_batch_size=16,
       num_train_epochs=3
   )

   # Train model
   trainer = Trainer(
       model=model,
       args=training_args,
       train_dataset=tokenized_datasets['train'],
       eval_dataset=tokenized_datasets['test']
   )
   trainer.train()

Dont worry, the real code will be better xD

Thank you for reading this article, dont hesitate to give me some advice, and to like this post if you liked it !

0x2e73

🌟 Starting My AI Journey with AI Law Shield 🚀🛡️

SalimFlowStack — Wed, 13 Nov 2024 13:37:16 +0000

Hey developer community! 👋

Today, I'm super excited to share the beginning of a new project that I'm diving into — AI Law Shield! 🎉 This is my first big adventure into the world of Artificial Intelligence, and I have to admit... I'm both thrilled and a little terrified! 😅

🚀 What's AI Law Shield?

We've all been there, right? Scrolling through pages and pages of contracts, privacy policies, and terms of service just to hit "Accept" without really reading anything? 🙈 Well, AI Law Shield is here to save the day! 💪

The goal of this project is to build an AI-powered tool that can:

Analyze contracts and legal documents in seconds 🕵️‍♂️
Detect any sneaky clauses that might put you at risk ⚠️
Give you a clear danger rating from 1 (you're safe! 🟢) to 5 (ABORT MISSION! 🚨)
Provide detailed annotations so you know exactly what to watch out for 📌

🎯 Why This Project?

I've been an apprentice application developer for the past 4 years 💻, building various projects and honing my coding skills. But despite my experience, I've never really gotten my hands dirty with AI 🤖. So, I thought... why not take on a new challenge and build something practical that could help a lot of people? 🌍 This project will push me out of my comfort zone and into the exciting world of AI, and I'm inviting you all to join me on this learning journey! 🚀

📚 What to Expect?

Over the coming weeks, I'll be documenting every step of this project here on Dev.to. I'll share everything I learn, from creating datasets 📊 to training the model 🤖, and even making it available as a browser extension 🌐!

Here's what you can expect:

📂 Setting up the project & creating datasets
🧠 Training my first AI model (wish me luck! 🤞)
🖥️ Building a user-friendly interface
🌐 Developing a browser extension for real-time contract analysis
💻 Open-sourcing the whole project on GitHub

🌐 Open Source

Yes, you heard that right! This project is open source 👐, so if you're interested in AI, privacy, or just want to see how a fellow developer tackles a new challenge, you can check out the GitHub repo here. Contributions, feedback, and advice are all welcome!

🚀 Let's Do This!

I'm super excited (and slightly terrified) to get started on this journey, and I can't wait to share my progress with you all. If you're interested in learning about AI, or if you just want to watch me stumble through it, stay tuned! 😄

Feel free to leave a comment, ask questions, or just say hi! And if you want to follow along, don't forget to hit that "Follow" button! 🚀

Thanks for reading, and let's make AI Law Shield a reality! 💡

💬 "A wise man once said, 'Always read the fine print'... or just let AI Law Shield do it for you!" 😂

See you in the next post! 👋

0x2e73

Creating a RESTful API with .NET and Clean Architecture: A Complete Guide 🚀

SalimFlowStack — Tue, 12 Nov 2024 14:36:27 +0000

Hey there! 👋 Are you tired of messy code shit architectures? Well, let’s fix that! In this post, we’ll walk through creating a RESTful API using Clean Architecture with .NET 8. By the end, you’ll have a modular, scalable, and super clean API, which means less stress for you and more time to enjoy your coffee ☕. Let’s dive in!

Wtf is clean architecture ?

You might be wondering, "Why should I bother with Clean Architecture? Isn’t my code already fine?" 🤔 Well, no, your code is bad, but its not important, mine is not better. Clean Architecture helps separate concerns into distinct layers, making your code more maintainable, testable, and future-proof. Plus, it gives you that “I’ve got everything under control” feeling. 😉

Clean Architecture is like a neat apartment: when it’s organized, you can find anything easily. When it’s messy? You end up searching for your keys for 20 minutes (we've all been there 🙈).

The Layers of Clean Architecture

Here’s a quick rundown of the layers in Clean Architecture:

Core: Where the magic happens – your entities and interfaces.
Application: This layer handles business logic (services, use cases), talking to Core through interfaces.
Infrastructure: The concrete stuff – think databases, third-party APIs, and services.
WebApi: The shiny API layer that interacts with the outside world (a.k.a. your clients).

Steps to Create the API 🚧

lets code !

Creating the Project

First, let’s start by setting up the foundation (i.e. the cool house we’re building 🏠). Open up a terminal and create the projects:

dotnet new sln -n MyCleanApi
dotnet new classlib -n MyCleanApi.Core
dotnet new classlib -n MyCleanApi.Application
dotnet new classlib -n MyCleanApi.Infrastructure
dotnet new webapi -n MyCleanApi.WebApi
dotnet sln MyCleanApi.sln add MyCleanApi.Core/MyCleanApi.Core.csproj
dotnet sln MyCleanApi.sln add MyCleanApi.Application/MyCleanApi.Application.csproj
dotnet sln MyCleanApi.sln add MyCleanApi.Infrastructure/MyCleanApi.Infrastructure.csproj
dotnet sln MyCleanApi.sln add MyCleanApi.WebApi/MyCleanApi.WebApi.csproj

This will create four projects:

Core: The brains 💡 of your app (entities and interfaces).
Application: Where the business logic happens (the magic ✨).
Infrastructure: The hands-on stuff (database, external APIs).
WebApi: The gateway to your API (like the doorman at a fancy restaurant 🏙️).

Define the Entities (Core) 🏢

In Core, define a simple Product entity (because who doesn’t love products, right? 😄).

namespace MyCleanApi.Core.Entities
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
}

Define Repository Interfaces (Core) 📚

In Core, define the repository interface to manage your Products. This will act like the API to interact with your data.

namespace MyCleanApi.Core.Interfaces
{
    public interface IProductRepository
    {
        Task<IEnumerable<Product>> GetAllAsync();
        Task<Product> GetByIdAsync(int id);
        Task AddAsync(Product product);
        Task UpdateAsync(Product product);
        Task DeleteAsync(int id);
    }
}

Create the Services (Application) 💼

In Application, create the service that will handle your business logic. This is the brains behind the operation. No stress, it’s like a superhero team!

namespace MyCleanApi.Application.Services
{
    public class ProductService
    {
        private readonly IProductRepository _productRepository;

        public ProductService(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        public async Task<IEnumerable<Product>> GetAllProductsAsync()
        {
            return await _productRepository.GetAllAsync();
        }

        public async Task<Product> GetProductByIdAsync(int id)
        {
            return await _productRepository.GetByIdAsync(id);
        }

        public async Task AddProductAsync(Product product)
        {
            await _productRepository.AddAsync(product);
        }

        public async Task UpdateProductAsync(Product product)
        {
            await _productRepository.UpdateAsync(product);
        }

        public async Task DeleteProductAsync(int id)
        {
            await _productRepository.DeleteAsync(id);
        }
    }
}

Implement the Repository (Infrastructure) 🔧

In Infrastructure, implement the repository using Entity Framework (because EF is like the trusty sidekick of your app 🦸‍♂️).

namespace MyCleanApi.Infrastructure.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly AppDbContext _context;

        public ProductRepository(AppDbContext context)
        {
            _context = context;
        }

        public async Task<IEnumerable<Product>> GetAllAsync()
        {
            return await _context.Products.ToListAsync();
        }

        public async Task<Product> GetByIdAsync(int id)
        {
            return await _context.Products.FindAsync(id);
        }

        public async Task AddAsync(Product product)
        {
            await _context.Products.AddAsync(product);
            await _context.SaveChangesAsync();
        }

        public async Task UpdateAsync(Product product)
        {
            _context.Products.Update(product);
            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(int id)
        {
            var product = await _context.Products.FindAsync(id);
            if (product != null)
            {
                _context.Products.Remove(product);
                await _context.SaveChangesAsync();
            }
        }
    }
}

Set Up the Database Context (Infrastructure) 🏗️

Now, let’s make sure the database can handle the Products we’re going to throw at it (it’s tough, don’t worry 😆).

namespace MyCleanApi.Infrastructure
{
    public class AppDbContext : DbContext
    {
        public DbSet<Product> Products { get; set; }

        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
    }
}

Set Up Dependency Injection (WebApi) 🤖

In WebApi, we need to configure dependency injection so everything talks to each other (because even APIs need friends 🫶).

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddScoped<ProductService>();

Create the API Endpoints (WebApi) 📡

Now, let’s expose the API! This is where you handle HTTP requests. We’ll set up the basic CRUD operations for Product.

namespace MyCleanApi.WebApi.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductController : ControllerBase
    {
        private readonly ProductService _productService;

        public ProductController(ProductService productService)
        {
            _productService = productService;
        }

        [HttpGet]
        public async Task<IActionResult> GetAll()
        {
            var products = await _productService.GetAllProductsAsync();
            return Ok(products);
        }

        [HttpGet("{id}")]
        public async Task<IActionResult> GetById(int id)
        {
            var product = await _productService.GetProductByIdAsync(id);
            if (product == null) return NotFound();
            return Ok(product);
        }

        [HttpPost]
        public async Task<IActionResult> Create([FromBody] Product product)
        {
            await _productService.AddProductAsync(product);
            return CreatedAtAction(nameof(GetById), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> Update(int id, [FromBody] Product product)
        {
            product.Id = id;
            await _productService.UpdateProductAsync(product);
            return NoContent();
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id)
        {
            await _productService.DeleteProductAsync(id);
            return NoContent();
        }
    }
}

Testing and Running the API 🎯

Don’t forget to test everything! You can use Postman or any HTTP client to test your API. And remember: always check your database (it’s like checking if your fridge is full before cooking 😅).

Conclusion 🎉

Boom! You’ve now built a RESTful API with .NET and Clean Architecture. Your code is organized, scalable, and ready for future upgrades (like adding a robot army… just kidding… or not 🤖).

Let me know how it goes, or if you have any questions. Happy coding, and may your API requests always return 200 OK! 💻✨