Forem: Lisa Mosweta

django event management

Lisa Mosweta — Fri, 18 Jul 2025 06:51:37 +0000

Day 5: Understanding MVC as I continue my dive into Django

Lisa Mosweta — Tue, 01 Jul 2025 16:17:21 +0000

So like this is all I learnt today about MVC

MVC stands for:

Model – Handles data and business logic.
View – Displays data to the user.
Controller – Accepts user input and processes it.

Hence, each has it’s own responsibility in keeping our code clean and organized.

Django's Twist:

From what I’ve learned Django uses the MTV architecture, which maps like this:

Django MTV Traditional MVC Purpose
Model Model Handles the data, database, and business logic
Template View Displays the data to the user (HTML, CSS)
View Controller Handles the logic and connects everything

Yup, Django’s “View” is actually the Controller in the traditional sense, and the “Template” is the actual View.
Crazy I know.

This matters cause…

Understanding this mapping clears up confusion when navigating Django projects. To ease more understanding, this is what each component looks like in action:

Model (models.py): Defines your database structure.
View (views.py): Contains the logic to fetch data and choose what template to render.
Template (.html files): Renders the UI using context passed from the view.

Building a Basic Django App Example
Here’s a quick overview of how these parts fit together in a blog app:

models.py

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()

views.py

def post_list(request):
    posts = Post.objects.all()
    return render(request, 'blog/post_list.html', {'posts': posts})

<!-- post_list.html -->
  <h2>{{ post.title }}</h2>
  <p>{{ post.content }}</p>

My last take on MVC is that…

While Django uses different naming conventions, it follows the same principles of MVC.

Anyways, I’m Learning to embrace the MTV structure since it is key to mastering Django and building clean and efficient apps.

Alright that’s it for today, peace

Day 4: First Django Project

Lisa Mosweta — Mon, 30 Jun 2025 17:26:22 +0000

Today has been crazyyyy anyways I created a Django project with two applications each having their own templates and all.
What I was to do:

Use Django’s project and app architecture
Link two apps: trousers and tops
Display templates for each app with an awesome look cause you know ;)

Step 1: Setting Up the Virtual Environment

Installed virtualenv (if not already installed):

sudo apt install python3-venv

Created a virtual environment inside the project folder:

python3 -m venv venv

This created a venv/ folder containing an isolated Python environment with its own pip, python, and site-packages.

Activated the virtual environment:

source venv/bin/activate

Your terminal prompt changes to indicate the virtual environment is active (e.g., (venv)). To deactivate, run:

deactivate

Installed Django inside the virtual environment:

python -m pip install django

Step 2: Starting the Django Project

Created a new Django project named boutique:

django-admin startproject boutique
cd boutique

The folder structure now looks like this:

boutique/
    manage.py
    boutique/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

Step 3: Creating Django Apps

Created two apps named trousers and tops:

python manage.py startapp trousers
python manage.py startapp tops

Step 4: Creating Models That Interact

In trousers/models.py, defined a Trouser model:

from django.db import models

class Trouser(models.Model):
name = models.CharField(max_length=100)
brand = models.CharField(max_length=100)

def __str__(self):
    return f"{self.name} by {self.brand}"

In tops/models.py, imported Trouser and defined a Top model that links to Trouser via a foreign key (for example, if a top is styled to match a trouser):

from django.db import models
from trousers.models import Trouser

class Top(models.Model):
name = models.CharField(max_length=100)
color = models.CharField(max_length=50)
matching_trouser = models.ForeignKey(Trouser, on_delete=models.CASCADE)

def __str__(self):
    return f"{self.name} in {self.color}"

Ran migrations to apply these changes:

python manage.py makemigrations
python manage.py migrate

[Step 5](url): Creating Simple Views

In trousers/views.py, created a view to list all trousers:

from django.shortcuts import render
from .models import Trouser

def trouser_list(request):
trousers = Trouser.objects.all()
return render(request, 'trousers/trousers.html', {'trousers': trousers})

In tops/views.py, created a view to list all tops:

from django.shortcuts import render
from .models import Top

def top_list(request):
tops = Top.objects.all()
return render(request, 'tops/tops.html', {'tops': tops})

Step 6: Linking Templates with Style

Each app has its own templates directory (trousers/templates/trousers/ and tops/templates/tops/).

Used Bootstrap and a light CSS gradient background to make the pages look clean and polished.

Example: trousers/templates/trousers/trousers.html

👖 Trousers Collection

    <li>{{ trouser.name }} by {{ trouser.brand }}</li>

</ul>
<a href="/tops/">View Tops</a>

Example: tops/templates/tops/tops.html

👚 Tops Collection

</ul>
<a href="/trousers/">View Trousers</a>

Step 7: Setting Up URLs to Connect Everything

Created a urls.py in each app folder.

trousers/urls.py:

from django.urls import path
from .views import trouser_list

urlpatterns = [
path('', trouser_list, name='trouser-list'),
]
tops/urls.py:

from django.urls import path
from .views import top_list

urlpatterns = [
path('', top_list, name='top-list'),
]
Included these app URLs in the main project’s boutique/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
path('admin/', admin.site.urls),
path('trousers/', include('trousers.urls')),
path('tops/', include('tops.urls')),
]
Now you can visit:

/trousers/ to see the list of trousers

/tops/ to view the tops and their matching trousers

It’s only the beginning, breath

What I have grasped from learning about git

Lisa Mosweta — Thu, 26 Jun 2025 11:39:37 +0000

INTRODUCTION
I have learnt a lot of stuff but to be specific I will just narrow most of the information down.

Forking
So this is the creating of a personal copy of someone else’s repository on GitHub.It is usually useful when you want to contribute to a project without affecting the original repo.

Collaboration
It allows multiple contributors with different roles.
Collaborators can also clone, commit and push each other's code.

Pull Requests
This is a way to propose changes from one repo to another and it is often from a fork to the original repo.
Team members can also changes before merging.

Merge Conflicts
This occurs when changes in two branches conflict and Git can’t merge them automatically.

Code Review
Helps improve code quality, catch bugs, and ensure consistent coding standards.

** GitHub Issues**
Used to track bugs, feature requests, tasks, or enhancements.

Git Commands
There are multiple git commands such as:
git init: Initialize a new Git repo.
git pull: Get latest changes from remote.
git push: Send your changes to the remote repo.
just to name a few.

Pushing Changes to GitHub
After making and committing changes locally and that you are connected to the branch:
You are supposed to use git push origin to send changes to GitHub.
It Ensures that your local work is saved in the remote repository.

Yeah, that is what I have learnt for today.

How I set up the tools I needed for my journey in Python/ django

Lisa Mosweta — Tue, 24 Jun 2025 21:24:35 +0000

Introduction
Hey so these past few days I’ve been taking the initiative to set up some software tools needed for my journey in python/django.
Here’s a breakdown of how I got everything working, from Git to Python, VS code and Docker too.

Git
First thing I did was make sure Git was installed and properly configured.
Did this by getting the link to the git website and downloading it.
I also configured my user details:
git config --global user.name "lisamswt"
git config --global user.email "lisanyamache05@gmail.com"

Python
It is Python 3.13 to be exact.
I Downloaded it from python.org
Where I clicked on Windows installer before adding python to path and clicking install.

VSCode (my text editor)
It had been the easiest to download.
Plus it has a lot of extensions hence easy to customise.
I downloaded it from: https://code.visualstudio.com/

Docker
I Installed Docker Desktop for windows on:
https://www.docker.com/products/docker-desktop

Conclusion
Now I can gain and apply the skills I’ll learn and create great projects with them.