DEV Community: Silas Ochieng

Day 4 :Building Models and Templates for Inventory and Orders Apps in My Django Store Manager

Silas Ochieng — Thu, 03 Jul 2025 15:00:09 +0000

Hey Dev Community! 👋

Today, I made significant progress on my Django project — store_manager. Specifically, I focused on building and refining models and templates for two core applications: the Inventory App and the Orders App. Here's a breakdown of what I did, how I approached it, and a few snippets to give you a feel of the project.

Project Structure Overview

My store_manager project includes two main apps:

inventory: Manages products, categories, and stock.
orders: Handles customer orders and order items.

And then at the templates i have this structure
I created simple yet clean templates to list, create, and manage products and orders.as shown below in this structure

Models creation

Building Inventory Models for My Django Store Manager App

In this, I’ll walk you through the models I built for the inventory app in my Django project store_manager. These models handle suppliers, categories, products, stock movements, and inventory alerts — all built with scalability and real-world functionality in mind.

Supplier Model

Handles details about suppliers providing the products.

class Supplier(models.Model):
    name = models.CharField(max_length=100, unique=True)
    contact_person = models.CharField(max_length=100)
    email = models.EmailField()
    phone = models.CharField(max_length=20)
    address = models.TextField()
    website = models.URLField(blank=True)
    notes = models.TextField(blank=True)
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

Category Model

Supports nested categories and slugs for SEO-friendly URLs.

class Category(models.Model):
    name = models.CharField(max_length=50, unique=True)
    slug = models.SlugField(unique=True)
    description = models.TextField(blank=True)
    parent = models.ForeignKey('self', on_delete=models.SET_NULL, null=True, blank=True, related_name='children')
    image = models.ImageField(upload_to='category_images/', null=True, blank=True)
    is_active = models.BooleanField(default=True)

Product Model

Central model for inventory tracking

class Product(models.Model):
    name = models.CharField(max_length=100)
    slug = models.SlugField(unique=True)
    description = models.TextField(blank=True)
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True, related_name='products')
    supplier = models.ForeignKey(Supplier, on_delete=models.SET_NULL, null=True, related_name='products')
    unit_price = models.DecimalField(max_digits=10, decimal_places=2)
    cost_price = models.DecimalField(max_digits=10, decimal_places=2)
    quantity = models.PositiveIntegerField(default=0)
    reorder_level = models.PositiveIntegerField(default=5)
    sku = models.CharField(max_length=50, unique=True)
    barcode = models.CharField(max_length=50, blank=True)
    is_active = models.BooleanField(default=True)

Product image models

class ProductImage(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE, related_name='images')
    image = models.ImageField(upload_to='product_images/')
    is_default = models.BooleanField(default=False)

StockMovement Model

Logs every product movement: sales, purchases, losses, and more.

class StockMovement(models.Model):
    MOVEMENT_TYPES = [
        ('purchase', 'Purchase'),
        ('sale', 'Sale'),
        ('return', 'Return'),
        ('adjustment', 'Adjustment'),
        ('transfer', 'Transfer'),
        ('loss', 'Loss'),
    ]
    product = models.ForeignKey(Product, on_delete=models.CASCADE, related_name='movements')
    movement_type = models.CharField(max_length=20, choices=MOVEMENT_TYPES)
    quantity = models.IntegerField()
    before_quantity = models.IntegerField(editable=False)
    after_quantity = models.IntegerField(editable=False)

Conclusion

This post covered the core models that power the Inventory side of my Django store_manager app — from suppliers and categories to products, stock movement, and inventory alerts. These models lay the foundation for tracking product availability, managing suppliers, and triggering automated alerts in real-time.

👉 In the next article, I’ll walk you through the Orders app models, where we’ll explore how orders are placed, managed, and linked to inventory changes. Stay tuned and feel free to drop any questions or suggestions in the comments!

django #python #backend #webdev

Day2: Setting Up and Testing My Django Inventory App

Silas Ochieng — Tue, 01 Jul 2025 17:25:51 +0000

Today was a productive day on my Django project — I successfully set up the inventory app, added models, and ran initial tests to confirm everything works as expected. Here’s a quick rundown of what I did, lessons learned, and what’s next.

Project Overview

I'm currently building a store management system using Django. One of the core components is the Inventory app, responsible for managing products, stock levels, categories, and suppliers.

What I Did Today

Set Up the Inventory App
I created the app with:

python manage.py startapp inventory

Then I added 'inventory' to INSTALLED_APPS in settings.py.

Defined the Models
I built out the initial models for:

Product
Category
Supplier
Stock

class Product(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    quantity = models.PositiveIntegerField()
    supplier = models.ForeignKey(Supplier, on_delete=models.SET_NULL, null=True)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    created_at = models.DateTimeField(auto_now_add=True)

Made and Applied Migrations

python manage.py makemigrations
python manage.py migrate

The database schema was generated and applied without issues.

Tested the Models via the Admin Interface

I registered the models in admin.py, created some test data via the Django admin, and confirmed that:

Products are linked correctly to their categories and suppliers.

Data is saved and retrieved as expected.

admin.site.register(Product)
admin.site.register(Category)
admin.site.register(Supplier)

What I Learned

How to structure interrelated models with ForeignKey and on_delete.
The importance of meaningful model field names and types.
Django admin is a powerful way to quickly test your models without writing views or templates yet.
What’s Next
Set up views and templates to list and manage products from the frontend.
Add CRUD functionality for inventory items.
Implement stock notifications for low inventory levels.

Final Thoughts
Setting up your models is foundational to any Django project. Today reminded me that once you get this right, everything else becomes easier — from views to APIs. I'm excited to keep building on this and share more as I go.

If you're working on something similar, I’d love to connect and hear what challenges or tips you’ve picked up!

👋 Let's Connect
Follow me here on https://dev.to/silasochieng— more dev logs coming soon!

Day 1 of 20 Days of Django: Let’s Build a Store Manager App!

Silas Ochieng — Mon, 30 Jun 2025 14:32:02 +0000

👋 Welcome Back!
Let’s get started with building a Django project that manages products and customer orders.

We’ll start by creating a Django project called store_manager, then add two apps — one for managing inventory and another for handling orders.

Step 1: Create Your Project Folder and Environment

To get started, I used Visual Studio Code as my IDE and followed these steps to structure my Django project cleanly with two separate apps: inventory and orders.

You can create your project folder using either the terminal or the VS Code file explorer.

While at the terminal run and it will take you to the folder

or use the file explorer if you prefer and click on a open folder and right-click in the explorer sidebar and select "New Folder".

Name the folder store_manager.

Open that folder in VS Code
Once inside your project folder, open the terminal in VS Code by going to Terminal → New Terminal.

Step 2: Set up a virtual environment

run the following in your project root directory in the terminal

python -m venv venv

Step 3: Activate the virtual environment

while at windows powershell use
../venv/Scripts/Activate`

Step 4: Install Django

Now install Django in your virtual environment:

pip install django

Step 5:Create the Django Project and Apps after successful installation of django in the virtual enviroment

We now initialize our Django project and create two apps inside it:

Create the Django project

django-admin startproject store_manager

Create two apps: inventory and orders

python manage.py startapp inventory python manage.py startapp orders

Now our folder structure looks like this

Register the two apps in settings

Open
store_manager/settings.py
and add both apps to the INSTALLED_APPS list:

Step 6 Set Up Templates for Each App

Inside each app, I created its own templates folder:
For the inventory app:
mkdir -p inventory/templates/inventory
For the orders app:
mkdir -p orders/templates/orders

Step 7 Create App URL Configurations

Each app gets its own urls.py file.
inventory/urls.py orders/urls.py

Step 8 Link App URLs in the Main Project

That is at
store_manager/urls.py:

Add static files in each app directory

Do so for orders app too
Then add media files upload to the project root directory

Step 9 Add basic views in inventory and orders app

inventory view.py

orders view.py

Step 10 Run Migrations and Start Server

Still at the terminals run the following to test

python manage.py migrate python manage.py runserver
Just to conclude my django setup for the store_manager app ran successfully.

Conclusion

This is just but the beginning of my 20days of django keep tune by diving with me into day two of my journey at
https://dev.to/silasochieng and follow in my github account at https://github.com/Silas-ochieng

Git & GitHub Collaboration

Silas Ochieng — Fri, 27 Jun 2025 10:29:59 +0000

Hey there, fellow devs! 👨‍💻👩‍💻

Wondering how to get started with Git and GitHub? I’ve got you covered! If you're new to software development, you might have heard about Git and GitHub but aren't quite sure what they are or how to use them. This guide will explain these tools in simple terms and show you how to set them up, especially using Visual Studio Code (VS Code).

What Are Git & GitHub?

Git
Git is a version control system. Think of it like a time machine for your code. It tracks changes you make to your files, allowing you to go back to previous versions if something goes wrong. This is incredibly useful when multiple people are working on the same project, as it helps prevent conflicts and keeps everyone’s work organized.
GitHub
GitHub is a website that hosts Git repositories. It’s like a social network for developers, where you can store your code, collaborate with others, and share your projects. GitHub provides tools for code review, issue tracking, and project management, making it easier for teams to work together.

Setting Up Git and GitHub

Step 1:

Install Git

Download Git: Go to the https://git-scm.com/ and download the installer for your operating system.
Install Git: Run the installer and follow the prompts. You can usually keep the default options.
Step 2:

Create a GitHub Account

Go to https://github.com/ and sign up for a free account.
Follow the instructions to set up your profile.
Step 3:

Configure Git

After installing Git, you need to set up your identity. This is important for tracking who made what changes.

Open Git Bash (or Command Prompt).

Run the following commands, replacing the placeholders with your information:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
To check your configuration, type:

git config --list

Basic git commands

Start tracking a project

git init

Clone a repository

git clone https://github.com/username/repo.git

Stage changes

git add .

Commit changes

git commit -m "Descriptive commit message"

Check repo status

git status

View commit history

git log

Push to GitHub

git push origin main

Using Git with Visual Studio Code

Step 1:

Install VS Code

Download VS Code from the https://code.visualstudio.com/.
Install it by following the setup instructions.

Step 2:

Open Your Project in VS Code

Launch VS Code.
Open the folder containing your project by selecting File > Open Folder.
Step 3:

Initialize Git in Your Project

Open the integrated terminal in VS Code by pressing Ctrl + ` .

Initialize Git by running:

git init
This command creates a new Git repository in your project folder.

Step 4:

Making Changes and Tracking Them

Add Files: Create or edit files in your project.

Stage Changes: To prepare your changes for committing, use:

git add .
Commit Changes: Save your changes with a message describing what you did:
git commit -m "Your descriptive message"
Step 5:

Pushing Changes to GitHub

Create a New Repository on GitHub: Go to GitHub and click on the "+" icon in the top right corner. Select "New repository" and follow the prompts.

Link Your Local Repository to GitHub: In the VS Code terminal, run:

git remote add origin https://github.com/your-username/your-repo.git
Push Your Changes: To upload your local changes to GitHub, run:

git push -u origin main
Collaborating with Others
Forking a Repository
If you want to contribute to someone else's project:

Go to the original repository on GitHub.
Click the "Fork" button to create a copy in your account.
Clone your forked repository using:

git clone https://github.com/your-username/forked-repo.git

Creating a Pull Request After making changes in your fork, push them to GitHub. Go to the original repository and click "Pull Requests." Click "New Pull Request" and follow the instructions to submit your changes.

Handling Merge Conflicts

Sometimes, if two people edit the same part of a file, Git will have trouble merging. If this happens:

Open the conflicted file in VS Code. Look for lines marked with <<<<<<<, =======, and >>>>>>>. Decide which changes to keep. Save the file, stage it, and commit the resolved changes.

Conclusion

Understanding Git and GitHub is essential for modern software development. By following this guide, you can set up your environment and start collaborating effectively. Remember, practice is key, so don’t hesitate to experiment and explore these tools further!

If you have any questions or need help, feel free to reach out! Happy coding!