DEV Community: Akolade

Initializing an Array in C#

Akolade — Tue, 14 May 2024 08:04:17 +0000

C# is pretty interesting to write and it is so so fascinating too

There are different ways to initialize an array in C#, stick to the end, I will show you different ways to go about it. The best approach will depend on a lot of factors, most especially preference(in my opinion).

Now let's dive in.....
While there have been latest changes in the last upgrade to C# which is C# 12, I would go all the way back to how it started, well maybe not all the way back. The aim here is to show you all the possible syntaxes to initialize array in C#.

Below is the list of possible array declarations and initializations:

string[] array = new string[2]; 
string[] array = new string[] { "A", "B" };
string[] array = { "A" , "B" }; 
string[] array = new[] { "A", "B" }; 
string[] array = ["A", "B"];

let's explain each of them

string[] array = new string[2];
This syntax creates a new array of strings that has a length of 2. It is like making an box with space for just two words in it, but we haven't put any words in it yet.

string[] array = new string[] { "A", "B" };
This syntax creates a new array of strings with an explicit initialization. The array is already filled with two elements: "A" and "B". It's like making a box and immediately putting the two words inside it.

string[] array = { "A" , "B" };
This is a shorter way of creating a new array of strings, it just only omits new string[].but is does the same as the example above. it is like a quicker route to get to the same destination.

string[] array = new[] { "A", "B" };

This is similar to the second example but it uses the new[] syntax. This syntax allows the compiler to infer the type of the array elements based on the initializer values. Since the initializer values are strings, the array will be of type string[]. This is like telling the computer to figure out what you are putting in the box

string[] array = ["A", "B"];

This is the newest way to initialize an array in C# 12, simple and straightforward. It's also similar to the way arrays are initialized in Python and JavaScript. This makes it easier for developers familiar with those languages to work with arrays in C#.

Starting from C# 3 and above, there is a shorter way to write the first two and fourth declarations. You can write them like this:

var array = new string[2];
var array = new string[] { "A", "B" };
var array = new[] { "A", "B" };

This is possible because the information on the right side of the assignment is enough to infer the proper type of the array. This makes the code simpler and more concise.

To wrap this up, it is worthy to note that there are other ways to declare or initialize an array in C#, but we will stick to this methods. These methods cover the most common and straightforward approaches to working with arrays in C#

Thank you for reading

You can check me on LinkedIN

Expanding My Skill Set: A Journey into NodeJS/ExpressJS

Akolade — Tue, 11 Apr 2023 13:37:00 +0000

In my quest to become a well rounded backend developer, I recently delved into NodeJS\ExpressJs.

Coming from a background of writing Django, I noticed some similarities between the two frameworks, albeit with some notable differences. With ExpressJS for example, you must handle the middlewares and controllers directly. Middleware is the fundamental concept and a core part of the framework's design and sits in the middle of the request/response cycle.

In ExpressJS middleware functions can be used to perform various tasks such as parsing incoming data, authentication, error handling and logging. Middleware is also written as a function that takes three parameters: request, response and next. The Middleware functions can either modify the request and response object or terminate the request/response cycle by sending a response or invoking next to pass control to the next middleware

But in Django, middleware is an optional feature, I mean you don't need to handle it yourself. It provides a way to process requests and responses globally across all views it sits between the web server and the views functions. The Middleware can also be used for authentication, session management, and caching.

Django automatically handles the order in which middleware is applied to the request/response chain based on the order in which they are defined in the MIDDLEWARE setting.

Just know that middleware in Django and ExpressJs serve similar purposes but are handled differently.

After a few weeks of intensively learning NodeJS/ExpressJS, I have come to appreciate the ease and efficiency of Django. Nonetheless, I built a small app using ExpressJS and, although I am not entirely satisfied with the outcome, I am determined to continue honing my skills in this area.

In the meantime, you can explore a microservice I recently designed with Django REST Framework. The microservice boasts of a comprehensive authentication system that includes user registration and verification via OTP, as well as OAuth2 integration for social login. I have also implemented logging and monitoring features to ensure optimal performance.

You can check the code here, although it is not yet hosted due to ongoing documentation efforts. However, feel free to clone the repository and explore its features.

Thank you for reading through. you can follow me on Twitter.

Django MVT: An Introduction to the Model-View-Template Architecture of a Django App

Akolade — Mon, 13 Feb 2023 11:40:41 +0000

MVT/ MTV is an essential concept in Django which is very similar to MVC as used on other frameworks. MVT in Django is a design pattern used to organize components of a Web App.

MVT architecture consists of three components- Model, View, and Template. These components are very important because they work together to handle the Logic, Data and Presentation of our web application.

Now let us break it down and explore each component in detail.

When a User makes a request to fetch a web page, we know that the three most important thing on a web page is the data which is coming from the database, the layout designed with HTML CSS and JS and the Logic.

The User request goes to the web application Django framework then to the URLs the navigation will be sent to the views where the logic is written. Then this view will use the model object and template. the data that needs to be sent will be decided by the view.

It is important to separate these 3 from each other and this practice is known as the Separation of Concerns.

Model: The model is responsible for managing the data and this can be linked with the models in our app. Model is simply a database table that defines a Python class and extends the Django Models class. In short, the model is used to store and retrieve data from the database. You can read my article on models here

View: If a user sends a request, Django will check if there is a view for this request and execute accordingly but if there is no view, no response will be returned.

The view is where we write all the logic for our web app and the view fetches the data stored by the Model and renders a template.

To learn more about views, check my previous article here

Template: Template is simply the frontend component of our Web App. In order to generate HTML dynamically Django uses DTL- Django template language, with DTL we would be able to display data dynamically.

Let's compare MTV to MVC in other languages

Now we know that Django MVT architecture is similar to the Model-View-Controller (MVC) design pattern used in other languages. Well, there are some key differences.

the Controller in MVC acts as the intermediary between the Model and View. The Controller processes user requests, updates the models and selects the right view to render.

But this is way different in Django, the View does similar work with the Controller but it is safe to say that the View is not the Controller because in other languages/frameworks, the controller has to be configured but in Django, this has already been handled.

Conclusion

The Separation of Concerns in Django MVT makes it easier to makes it very easy to maintain and change the look of our web app, the template can be updated without affecting the View or Model.

Django MVT also allows or promotes the DRY(Don't Repeat Yourself) concept.

Note this: Regardless of the differences and similarities between MVT and MVC, they are both effective ways to structure the code and components of a web app.

Whether you are a beginner or a seasoned developer, understanding MVT is essential to building apps in Django.

Thank you for reading through. If you like this article, you can give me a follow on Twitter.

HAPPY CODING....

Pipenv: Why you should use it as a Python Developer

Akolade — Wed, 01 Feb 2023 12:43:29 +0000

Pipenv is a tool that aims to bring the best of all packaging worlds to the Python world. It harnesses Pipfile, pip, and virtualenv into one single command. It automatically creates and manages a virtual environment for your projects, as well as adds/removes packages from your Pipfile as you install/uninstall packages.

Before diving deep, let's look at some of the problems Pipenv tends to solve

Problems Pipenv Solves

Pipenv solves the problems of dependency management in Python projects by providing a unified and automated approach to handling dependencies, creating virtual environments, and resolving dependencies. It eliminates the need for manual dependency pinning by locking the dependencies of a project in a Pipfile.lock, ensuring reproducibility and deterministic builds. Unlike requirements.txt, Pipenv does not rely on manual updates for sub-dependencies, as it automatically resolves dependencies and keeps them up-to-date.

Dependencies and Virtual Environment Management: Pipenv automatically manages the dependencies of your projects, ensuring that the packages your project needs to run are always installed and up-to-date. Pipenv automatically creates a virtual environment for each project, making it easier to isolate projects from one another and manage their dependencies.
Simplifies Package Installation: Another issue that Pipenv addresses are the process of installing packages. With traditional methods, such as using a requirements.txt file, the process of installing packages can be complicated and time-consuming. Pipenv simplifies this process by allowing developers to specify the packages required for a project in a Pipfile, which can then be installed with a single command. Furthermore, Pipenv automatically resolves dependencies, making sure that the correct version of each package is installed.
Reproducibility: Pipenv also ensures reproducibility by locking the dependencies of a project in a Pipfile.lock. This makes it possible to easily reproduce a project on another machine. In contrast, when using a requirements.txt file, the dependencies are not locked and it can be difficult to ensure that the same environment is replicated on different machines.

The use of a requirements.txt file can lead to a number of problems, such as the fact that it does not specify the version of a required package to be used. This can result in the latest version of a package being installed, even if it is not backward compatible with the version used during development, causing the application to break in production. Additionally, even if the version of a package is pinned, it is possible that its sub-dependencies will not be pinned, resulting in the latest version being installed and causing issues.

To address this issue, some developers use the pip freeze command to freeze the exact versions of all packages, including sub-dependencies and include them in a requirements.txt file. However, this method can lead to a new set of problems, as the developer becomes responsible for keeping all packages up-to-date, including sub-dependencies. This can be time-consuming and difficult to manage, especially if a security issue is discovered in a package that requires an immediate update.

Pipenv Installation

To install Pipenv, run the following command in your terminal:

pip install pipenv

Then run this next command

pipenv shell

This command will automatically activate and create a virtual environment.

Then you should see something like this:

Creating a virtualenv for this project...
Pipfile:(the directory of your project)
.....
.....
Successfully created virtual environment!

Now we can install our packages with pipenv, and note that if you need to be precise about the version, you need to mention it. for instance:

pipenv install django==4.1.5

you should also see something like this in your terminal:

Installing django==4.1.5...
Pipfile.lock not found, creating...
Locking [packages] dependencies...
Locking [dev-packages] dependencies...
Updated Pipfile.lock (c5aae75378f71e86f154c89ed111b8e652646df5f3a7e3d9df5fb1b2b1ba2d88)!
Installing dependencies from Pipfile.lock (ba2d88)...

When you check your project directory, you will notice two files already created, a Pipfile and a Pipfile.lock.

Let's install another package before we continue.

Assuming you want to run some tests on your application with pytest but are aware that pytest is not required in production, we can signal that this dependence is exclusively for development by using —dev.


pipenv install pytest --dev

This argument --dev will put the dependency in [dev-packages] a special section in the Pipfile.

We have finally installed all our dependencies and we have built our app. everything is working in development and ready for deployment, right? Before deploying, we must lock our environment to ensure that it remains consistent in production.

pipenv lock
# this command will update the Pipfile.lock. you dont need to manaually edit it since it its not a requirements.txt file.

once Pipfile.lock is set, then run this command:

pipenv install --ignore-pipfile

The command installs the most recent successful environment recorded. It also ignores the Pipfile and installs what is in the Pipfile.lock alone.

If another developer wants to contribute to your code, they just simply need to run this command below.

pipenv install --dev
# it will install all the dependencies needed for development

Following this process will solve the problems we have previously discussed. and this will ensure your dependencies both in development and production environments are the same.

Now Let's Move on...

Pifile and Pipfile.lock

The Pipfile: The Pipfile is a file used by Pipenv to manage dependencies for a Python project. It is similar to a requirements.txt file but with added features and a different format which is more human-readable. The Pipfile is used to specify the packages that are required for a project to run, as well as the versions of those packages.

The Pipfile has several sections:

[source]: This section lists the sources from which packages can be installed. By default, packages are installed from the Python Package Index (PyPI), but additional sources can be added to this section.
[packages]: This section lists all the packages that are required for the project to run, including their versions. The syntax is similar to pip's requirements.txt file, with the package name followed by its version.
[dev-packages]: This section lists the packages that are required for development purposes, such as testing frameworks or linting tools. These packages are not needed to run the project but are necessary for development.
[requires]: for other requirements like the specific Python version.

[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
django = "==4.1.5"

[dev-packages]
pytest = "*"

[requires]
python_version = "3.10"

The Pipfile is an important part of Pipenv, as it allows developers to specify the packages that are required for a project to run. Specifying the versions of the packages helps to ensure that everyone working on the project is using the same dependencies.

The Pipfile makes it easier to share projects and collaborate with others, as it provides a clear list of the dependencies that are required.

The Pipfile.lock: The pipfile.lock is a file generated by Pipenv that is used to ensure that everyone working on a project has the same dependencies and the same versions of those dependencies.

The pipfile.lock file is generated based on the information in the Pipfile and contains a complete and accurate record of the packages and their versions that are required for the project to run.

This information is used by Pipenv to ensure that the correct packages and versions are installed and used when running the project. If a package or its version is changed in the Pipfile, the pipfile.lock file will be updated to reflect those changes.

The pipfile.lock file is also used to secure the project against vulnerable packages. Pipenv checks the packages listed in the pipfile.lock file against a database of known vulnerabilities, and will alert the developer if any vulnerable packages are detected. This helps to ensure that the project is secure and free from known vulnerabilities.

The Pipfile.lock looks like this and it uses JSON as it syntax

{
    "_meta": {
        "hash": {
            "sha256": "0401892dedcc2ab095249867cfacc9804fcb29bf6ecfa3423caa2a51e5599e12"
        },
        "pipfile-spec": 6,
        "requires": {
            "python_version": "3.10"
        },
        "sources": [
            {
                "name": "pypi",
                "url": "https://pypi.org/simple",
                "verify_ssl": true
            }
        ]
    },
        "django": {
            "hashes": [
                "sha256:4b214a05fe4c99476e99e2445c8b978c8369c18d4dea8e22ec412862715ad763",
                "sha256:ff56ebd7ead0fd5dbe06fe157b0024a7aaea2e0593bb3785fb594cf94dad58ef"
            ],
            "index": "pypi",
            "version": "==4.1.5"
        },
        .....
    }
}

To simply uninstall a package, just run:

pipenv uninstall django 
or 
pipenv uninstall --all # wipes all packages

How to Convert requirements.txt to Pipfile: To convert a requirements.txt file to a Pipfile, run the following command in your terminal:

pipenv install -r requirements.txt

Pip and Pipenv - Diffrences

Pip and Pipenv are both package management tools for Python, but they have different purposes.

Pip is a simple package manager that is used to install and manage Python packages. It's a standard tool that has been included with Python since version 2.7.

Pipenv, on the other hand, is a more advanced package management tool that aims to bring the best of both pip and virtualenv into one tool. Pipenv provides a more user-friendly interface for managing packages and dependencies, and it automatically creates and manages virtual environments, making it easier to maintain a clean and organized Python environment.

Pipenv offers a more comprehensive solution for Python package management, but it can be overkill for simple projects, whereas Pip is a more straightforward tool for managing packages.

Why Should I Use Pipenv and is it worth it?

Using Pipenv is worth considering if you want a more organized and efficient way of managing your Python packages and dependencies.

With Pipenv, you can create virtual environments for your projects, ensuring that each project has its own set of packages and dependencies without interfering with other projects. This makes it easier to maintain a clean and organized environment, as well as to manage conflicts between dependencies.

Pipenv provides a user-friendly interface for managing packages and generates a "Pipfile" that serves as a record of all required packages and versions, making it easier to share and reproduce the environment for a project.

These features make Pipenv a good choice for larger, more complex projects that have multiple dependencies, where it can be difficult to manage packages and dependencies manually.

Pipenv is a valuable tool for Python developers who want to streamline their workflow and ensure that their projects are well-organized and reproducible.

Wow you made it here.. I hope you enjoyed the article and that it was informative enough to assist you with your endeavors. Thank you for reading and Happy Coding

You can follow me on Twitter here

Database: Types, Configuration and Migration

Akolade — Thu, 26 Jan 2023 11:28:35 +0000

Django comes with its own default database SQLite, which is a lightweight and simple relational database management system.

While SQLite is a good choice for development and testing, it may not be suitable for production environments due to its limitations such as poor performance, limited concurrency, lack of scalability, limited features, lack of built-in tools for maintenance and lack of built-in security features.

If you're planning to deploy a Django application in production, you should consider using a more robust and scalable database management system like PostgreSQL or MySQL.

How to Select A Database

The decision of whether to use a SQL or NoSQL database with Django depends on the specific requirements of your project.

SQL databases, such as PostgreSQL or MySQL, are well-suited for projects requiring high data integrity and consistency. They provide a structured way of storing and querying data and are well-integrated with Django's ORM (Object-Relational Mapping) system, making it easy to create, query, and modify data using Python classes and objects. SQL databases are also good for projects that have a lot of relationships between data and need to be able to perform complex JOIN operations.

NoSQL databases, such as MongoDB, are well-suited for projects that handle a lot of unstructured data and require horizontal scalability. They don't have the same level of data integrity and consistency as SQL databases, but they can handle a large amount of data and are designed to scale horizontally. NoSQL databases are also a good fit for projects that need to store and retrieve large amounts of unstructured data, like JSON documents.

It's important to note that Django doesn't officially support NoSQL Databases but they can be integrated using a third-party library. Read more here

Let's configure a Database in our Django settings

I will be using Postgres for this. you can as well check out how to configure a database using MySQL

1. Install and configure Postgres.

Download Postgres here for your operating system.

Install it. Then start your Postgres server.

2. Install dependencies or database adapter

In your environment, install psycopg2: pip install psycopg2

we need to now tell Django that we have changed our database.

You know Django comes with a default configuration for the SQLite database, we need to override that configuration

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

For Postgres configuration, the following variables are required.

DB name
DB user
Password of the User
Host and Port
Engine

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'blog',
        'USER': 'postgres',
        'PASSWORD': '123456789',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Note: I won't cover how to create a database schema with Postgres. You can look that up in a video tutorial.

Migration

After installation and configuration, what is next? yes, you got it. we need to make migrations. this is because we now have a fresh and clean database instance.

makemigrations: we need to run this command python manage.py makemigrations . This command is used to create new migrations files based on the changes detected in the models. These migration files can then be used to create or modify the database schema to match the current state of the model.

then we will run the migrate command: python manage.py migrate when you run this command, Django will look at the migration field that was created by the makemigrations command and use them to create and modify the database schema.

Conclusion

Now that we understand how to set up our database, it is also advisable to make more research to get a better view and understanding of databases.

You can follow me on Twitter, I write about Django weekly.. cheers and happy coding

Models in Django

Akolade — Tue, 17 Jan 2023 12:42:52 +0000

One of the key features of Django is it use of models, which are used to represent the data in a Django application. Now before we move, this is a continuation of my Django Basics series, you can read them here

What are Models

Models in Django are defined as Python classes that inherit from the django.db.models.Model class. Each class represents a table in the database, and each attribute of the class represents a column in the table.

did I lose you with that definition? okay, let's make it simpler

Model is a python class that defines the fields and behavior of the data you will be storing. these python classes or models are defined in the models.py file of your app and are used to structure and interact with the database.

Django provides a built-in Object-Relational Mapping (ORM) system, which allows you to interact with the database using Python code instead of writing raw SQL queries. This means that you can create, read, update, and delete database records using Python methods

Creating a Model

It is quite easy to create a model just like defining a class in python, but there is more to it, we also need to define the fields in the model. for example, if you were building a simple blog application, you might have a model for the blog posts, which would look something like this:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=255)
    bio = models.TextField()
    email = models.EmailField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
     def __str__(self):
        return self.name

class Post(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    pub_date = models.DateTimeField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
     def __str__(self):
        return self.title

This model defines two classes: Author and Post which both inherit from models.Model, this tells Django that the classes should be treated as models and that they should be stored in the database.

Author class defines the fields and behavior of the Author data and it has 5 fields:

name: This is a CharField which is used to store character data (i.e. strings) in the database. The max_length parameter specifies the maximum number of characters that can be stored in this field.
bio: This is a TextField which is used to store large amounts of text in the database.
email: This is a EmailField which is used to store email addresses, it will validate the email format.
created_at: This is a DateTimeField which is used to store date and time information, the auto_now_add argument is set to True which means that the field will be set to the current date and time when the model instance is first created.
updated_at: This is a DateTimeField which is used to store date and time information, the auto_now argument is set to True which means that the field will be set to the current date and time every time the model instance is saved.

Post: This class defines the fields and behaviour of the Post data. it has six fields

title: This is a CharField which is used to store a short title for the post.
content: This is a TextField which is used to store the content of the post.
pub_date: This is a DateTimeField which is used to store the publication date and time of the post.
author: This is a ForeignKey which is used to establish a one-to-many relationship between the Post model and the Author model. It means that each post is associated with a single author.
created_at and updated_at: the same meaning as that of Author

Model Method

Both classes define a __str__ method, which returns a string representation of the object, this method is used when the object is displayed in the Django admin interface or when the object is returned by a query.

Django Fields

For better understanding, it is necessary to define what those fields we just use are and also state some examples

Fields are used to define the data that a model should store.

The field class defines the type of data that the field will store, as well as any constraints or validation that should be applied to that data. The data for each field is stored in the corresponding database table, fields are used to define the structure of the table and the type of data that is stored in each column.

Types of Fields

Django provides a variety of built-in field classes for common data types such as text, numbers, dates, and files. Some examples of these field classes are:

CharField: used to store character data, such as a name or a title.
TextField: used to store large amounts of text, such as a blog post or a description.
IntegerField: used to store integers, such as the number of views or likes on a post.
DateField: used to store a date without a time.
DateTimeField: used to store a date and time.
DecimalField: used to store decimal numbers, such as currency values.
FileField: used to store files, such as images or documents.
ImageField: used to store images, this field is a subclass of FileField with some additional validation for image file types.

Each field class has its own set of optional arguments that can be used to customize its behavior. Some of the most common arguments are

max_length: This argument is used to specify the maximum number of characters that can be stored in a field. It is typically used with CharField and TextField fields.
default: This argument is used to specify a default value for the field. This value will be used when creating a new model instance if no value is provided for the field. It can be a value or a callable that returns a value.
null: This argument is used to specify whether or not the field can be empty (NULL) in the database. The default value is False, which means that the field cannot be empty.
blank: This argument is used to specify whether or not the field can be left blank in forms. The default value is False, which means that the field must be filled in when the form is submitted.
choices: This argument is used to specify a list of valid choices for the field. It should be a list of 2-tuples, where the first element is the value to be stored in the database and the second element is the human-readable label.
auto_now: This argument is used to automatically set the field to the current date and time every time the model instance is saved.
auto_now_add: This argument is used to automatically set the field to the current date and time when the model instance is first created.
on_delete : is used to specify what should happen when the referenced object (i.e. the object on the other side of a foreign key or many-to-many relationship) is deleted. It is used in fields such as ForeignKey and OneToOneField and it is a required argument.

You can also use fields to establish relationships between models, for example, you can use a ForeignKey field to establish a one-to-many relationship between two models, or you can use a ManyToManyField to establish a many-to-many relationship.

Since you got to this point, now let's re-create the Post model again and add more structure and fields.

class Post(models.Model):

    options = (
    ('draft', 'Draft'),
    ('published', 'Published'),
    )

    title = models.CharField(max_length=255, unique=True)
    content = models.TextField()
    pub_date = models.DateTimeField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='Posts')
    slug = models.SlugField(max_length=255, unique_for_date='publish')
    status = models.CharField(max_length=16, choices=option, default='draft')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)


    def __str__()
        return self.title

    class Meta:
        ordering = ('-publish',)

Now let me explain:

options : A tuple of tuples that define the valid options for the status field, the first element of each tuple is the stored value in the database and the second is the human-readable label.
title: A CharField that is used to store the title of the article. The max_length argument is set to 255 characters and the unique argument is set to True, this means that the title must be unique among all articles.
slug: A SlugField that is used to store a short, URL-friendly version of the title. The max_length argument is set to 255 characters, and the unique_for_date argument is set to 'publish', this means that the slug must be unique among all articles for a given date.
author: A ForeignKey that is used to establish a relationship between the Post model and the Author model. This field is used to store the Author who created the article, the on_delete argument is set to models.CASCADE, which means that when the user is deleted, all the articles associated to him will be deleted as well.
status: A CharField that is used to store the current status of the article, such as 'draft' or 'published'. The max_length argument is set to 16 characters, the choices argument is set to options, this means that the valid choices are the ones defined in the options tuple and the default argument is set to 'draft', which means that if no status is specified, the default status will be 'draft'.

Wow, you made it here. Thank you.

In the next article, I will write about databases - types, configuration and migration

Till Then ----- Happy Coding

Writing Views in Django

Akolade — Wed, 11 Jan 2023 13:13:33 +0000

In Django, a view is a Python function that takes a web request and returns a web response. The response can be in the form of HTML, JSON, XML, Image or anything at all. Yes anything

Below is a simple view that displays a message to the user

from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello, World!')

The code above is simply returning an HTTP response, but rendering templates is quite similar and easy.

Views are an important part of any Django application because they handle the logic of your application. They are responsible for processing requests, interacting with models to retrieve data, and returning a response to the client.

Don't stress too much about models read my next article, I will write about it

To create a view in Django, you will need to define a function in your app's views.py file and map it to a URL pattern. For example, let's say you want to create a view that displays a list of blog posts. You could define a view like this:

from django.shortcuts import render
from .models import BlogPost

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

This view uses the Django ORM to retrieve all blog posts from the database and passes them to a template to be rendered.

To map this view to a URL, you will need to create a file called urls.py in your app directory and define a URL pattern then import views into the file. For example:

from django.urls import path
from . import views

urlpatterns = [
    path('posts/', views.list_posts, name='list_posts'),
]

This will create a URL pattern that maps the /posts/ URL to the list_posts view.

In addition to simple views like the one shown above, it is important to note that Django also supports class-based views, which are classes that inherit from the View class and implement one or more methods to handle different types of requests. For example, you could create a class-based view for the list_posts view like this:

from django.views.generic import ListView
from .models import BlogPost

class ListPostsView(ListView):
    model = BlogPost
    template_name = 'blog/list_posts.html'
    context_object_name = 'posts'

This view will handle the same functionality as the function-based view, but it is organized as a class with separate methods for handling different types of requests (e.g. get, post, put, etc.).

Simple Definition of Django ORM

Django ORM: Django Object Relational Mapper is like a helper that makes it easy for people (programmers) to talk to a computer program (database) and ask it to remember things like a list, but instead of writing a lot of confusing codes, they use simple words that the helper (ORM) understand and then it translates it to the computer language that it can understand.

Conclusion

There are many more advanced concepts you can explore with Django views, such as decorators, generic views, and view mixins. There is no point jumping into this now, we can always learn along the way.

For broader information about Django views, you can refer to the documentation.

Everything you need to know about Django(Python) as a Beginner.

Akolade — Tue, 03 Jan 2023 13:18:35 +0000

As a newbie, forget all the noise and learn Django for backend web development (well do your research and see what is suitable for you).

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel. In this article, we'll cover everything a beginner needs to know about Django.

What is Django

Django is a powerful, free and open-source Python web framework that simplifies the development of complex, database-driven websites. Some of the notable sites that use Django are Dropbox, Instagram, NASA, Mozilla, and Disqus.

Django follows the “batteries included” philosophy, which means that it comes with a lot of built-in features, such as, an ORM (Object-Relational Mapper), authentication, multiple database support and security which allows a developer to generate a powerful website as quickly as possible

One of the main benefits of using Django is its emphasis on convention over configuration, which means that it has a set of pre-defined conventions for things like project layout and database schema, so you don’t have to spend a lot of time configuring your application. This makes it easy for new developers to get up and running quickly.

Now let's dive in.

Installation and Setup

To start using Django, you need to have Python installed on your system. You can check if you have Python installed by running the following command in your terminal: python --version

If you don't have Python installed, you can download it from the official Python website (https://www.python.org/) and follow the installation instructions.

Once Python is installed, you need to choose a directory for your project: and then open your terminal or Powershell and run the following command.

cd desktop  # or documents or anywhere you want

# you can then create a folder for your project and cd into the folder
mkdir django-project
cd django-project

# open vscode 
code.

Before we install Django we need to install and activate a virtual environment. Think of the virtual environment as a container that helps us isolate our project dependencies.

# install the virtual environment
pip install virtualenv

# create the virtual environment
virtualenv env 

# to activate the virtual environment (on windows) 
env\Scripts\activate

# activating the virtual environment (on macOS) 
source env/bin/activate

Now let's install Django. You can do this by running the following command.

pip install django

Django project structure

Once Django is installed, you can create a new project by running the following command:

django-admin startproject myproject

This will create a new directory called "myproject" with the basic structure of a Django project. A Django project consists of one or more apps, and each app can have multiple models, views, and templates.

Here's a breakdown of the main directories and files in a Django project:

manage.py : A command-line utility that lets you interact with this Django project in various ways.
__init__.py : An empty file that tells Python that this directory should be considered as a Python package.
settings.py : settings for this Django project, such as database configurations, installed apps and middleware.
urls.py : The URL declarations for this Django Project
asgi.py : An entry point for ASGI-compatible web servers to serve your project.
wsgi.py : An entry point for WSGI-compatible web servers to serve your project

Now run your basic server using this command

python manage.py runserver

The output of the command should be visible in your broswer with this link- https://127.0.0.1:8000 like this:

Next, you will need to create a Django "app" within your project. An app is a self-contained unit of code that performs a specific function in your project. You can create an app by running the following command:

python manage.py startapp myapp

This will create a new directory called "myapp" with the basic structure of a Django app. The most important file in this directory is views.py, which contains functions that handle requests and return responses.

Your setup should look like this :

To create a view, you will need to define a function in views.py and map it to a URL pattern. To do this, you will need to create a file called urls.py in your app directory and define a URL pattern. For example:

views.py

from django.shortcuts import render
from django.http import HttpResponse

def index(request):
    return render(request, 'templates/index.html')

urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

This will create a URL pattern that maps the root URL (/) to the index function in views.py.

To display the results of your view in a template, you will need to create a template and render it in your view. Django uses the Django Template Language (DTL) to render templates. You can create a template by creating a templates directory in your app directory and create an index.html file inside it.

<html>
    <body>
        <h1>Hello, Django!</h1>
    </body>
</html>

In your project urls.py file, You also need to include your app's urls

from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('myapp', include("myapp.urls"))
]

Now let's register the app and also define our templates path in settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp', 
]

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Conclusion

Django is a powerful and feature-rich web framework that is well-suited for building a wide range of applications.

If you're just starting out with Django, it's important to take the time to learn the basics and get familiar with the framework before diving into more advanced concepts.

This is just a basic overview of how Django works. There is a lot more to learn, such as working with models, databases, forms, static files, and authentication, but these concepts should give you a good foundation to start building your own Django.

To learn more about Django check this tutorial by Mozilla.

Also check this youtube tutorial: Django with Mosh.

Check out my Twitter page, I write about Python and Django.

My First Project: A personal Ecommerce Website

Akolade — Sun, 13 Nov 2022 12:37:35 +0000

Whoopssss: I built my first project as a developer..

This Project took a little over a month to conceptualize and complete.

The Tech stack used are: Python, Django, Postgres, HTML, CSS, JavaScript, AWS, Heroku.

Now down to the functionalities and features of the website

User Authentication and Authorization: Users can decide to create an account with their google, Facebook, Twitter account(I used Django allauth for this and the third party API’s) or users can just create an account with an email. Once user is logged on, they won’t have access to to login/signup page. Additionally, there is logic that enables Users who choose not to register to still go on with business.

Add to Cart and Checkout: Users, both authenticated and unauthenticated, will be able to add and remove items from their carts before proceeding to checkout. A cookie was used to handle the checkout and cart page for an unauthenticated customer. Even if they leave the page for a while, their cart will still be intact.

Payment Integration: Payments can be made using a debit card or a PayPal account (I initially used paystack which worked perfectly , but I wanted something more universal). I am still looking at how to add more than one payment platform.

Visitors can subscribe to a newsletter by entering their name and email address, and the data is collected in the backend. There is also a functionality that checks if the email has already been used.

The Product Collections page is dynamically rendered, and I plan to add dynamic product details pages for each product later.

Challenges Faced:

The first issue was that after creating a customer / user, the customer was unable to access the collections, checkout, and cart page. I keep getting this error RelatedObjectDoesNotExist. After reading various documentation, research, and thinking, I finally conquered It in 3-4 days, with the solution being as simple as one line of code. I only had to create and assign the user.
Postgres and AWS: It took me three days to finally get this thing. Postgres keeps giving server connection error. AWS free tier charged my card I don’t know why(the small money I was managing)
There are many other challenges but let’s us leave it at this.

Well building this project really taught me what really happen on the backend. I can now say that building a project will really teach you a lot.. enough of blazing through tutorials, start building and make research.

Next Project should either be a portfolio website, CRUD app or Payroll management system(I was formerly an HR so this will be fun).

You can follow me on Twitter

Also check out my github profile: emmakolade

Thank you for reading through.