DEV Community: Rohit Lakhotia

EP 1: What is an API?

Rohit Lakhotia — Sat, 02 Mar 2024 10:09:24 +0000

What’s an API?

In simple terms, API is just an output to an input that you gave to someone. They’re like the ordering system for your software. You give them instructions (inputs), and they reliably provide you with what you asked for (predictable outputs).

Let’s consider the most widely used Google Maps, when we give the address as an input, it gives you back that address’s latitude/longitude coordinates as an output.

Let’s understand APIs better with a real-life analogy.

Analogy: The Remote Control

Think of an API as a remote control for your home entertainment system. When you want to change the channel on your TV, increase the volume, or play a DVD, you don’t need to understand the complex electronics inside your devices. You simply press buttons on the remote control, and your commands are executed.

In this analogy:

The remote control serves as a client, providing a user-friendly interface.
The various entertainment devices (TV, sound system, DVD player), this is where the logic is i.e. server.
Your commands (changing channels, adjusting volume) represent API requests.

Just as the remote control abstracts the technical complexities of your entertainment system, APIs abstract the inner workings of software systems, allowing them to communicate and perform tasks with ease.

The Power of APIs

APIs are the backbone of modern software development. They allow developers to leverage existing services and functionalities, saving time and resources. From the data you receive from a weather app to the seamless integration of social media platforms, APIs are everywhere to enhance our daily digital experiences.

In brief:

APIs make cross-platform development a breeze.
APIs are like standardized contracts for communication.
APIs facilitate communication between services.
APIs also play a crucial role in security.

Payment Gateway APIs: When you make an online purchase, the payment process is often facilitated by payment gateway APIs like PayPal, Stripe, or Square. They handle secure transactions, sparing developers from implementing complex payment systems.

Social Media Sharing APIs: Social media platforms offer APIs that allow users to share content from other apps directly to their social feeds. For instance, the “Share on Facebook” option in various apps is made possible through Facebook’s API.

How does an API Work?

APIs function through a request and response process, sharing data among applications, systems, and devices. When a user interacts with an application, they initiate a request for data, which is sent to the API. The API retrieves the data and returns it to the user, completing the cycle.

To illustrate this process, let’s liken APIs to the workings of a restaurant. In this analogy, the user plays the role of a customer placing an order. The API functions as the restaurant’s order-taking service, receiving the order details, specifying the desired items, and arranging the preparation process. The kitchen staff, akin to an API server, ensures that the order is accurately prepared and ready for delivery. Any additional requests, such as specifying cooking preferences or adding extra toppings, are handled seamlessly. This comparison serves to simplify the concept of APIs by drawing parallels with a familiar scenario — the ordering process in a restaurant.

For example, imagine a user interacting with a restaurant API to place an order for a pizza. The user specifies the type of pizza, size, toppings, and any special instructions through the API (Input). The API, acting as the order handler, communicates this information to the restaurant’s system (Server). The Chef then prepares the pizza according to the specifications. Once ready, the pizza is delivered to the user’s location (Response), ensuring a smooth and efficient process facilitated by the restaurant API.

Take a closer look, the API client assembles requests based on user actions and sends them to the relevant API endpoint. These endpoints are like URLs, providing access to specific resources in a database.

For instance, if a user wants to view products in an e-commerce store, the API client sends a GET request to the /products endpoint. This way, APIs enable efficient data exchange in the digital world.

How API works between client and server

Imagine a client-server architecture where the client, representing the user, makes requests through a middleman — the API — and receives responses from the server in the backend. Here’s how it works:

Your client kicks things off by initiating the API requests via the URI (**Uniform Resource Identifier**)
The API request is sent to the server, relaying your intentions.
The server processes your request, gathers the necessary information, and sends back a response.
The API, acting as the go-between or the communication channel, hands you the response containing the data you need.

APIs are designed to be secure, using authorization credentials and an API gateway to control access and keep things safe. For extra layers of security, various techniques like HTTP headers, query string parameters, and cookies are employed.

Types of APIs

APIs are categorized into many different types based on the use case. In practical experience, I’ve come across people using the term “API” in three different contexts. These are:

Based on Accessibility:

Private APIs: These are also known as internal APIs. When companies create their applications, they build them using a set of interacting APIs. They’re used within an organization to connect various software components. Private APIs are not available for third-party use.

For example, an e-commerce platform might have numerous private APIs for order processing, product catalog, recommendation, payment processing, etc. working altogether coordinating with each other.

💭 Even database calls are API calls under the hood. The queries that we do are sent to the database through an API call. The database then proceeds to run that query and return the data as a response.

Public APIs: Public APIs provide access to an organization’s data or services for third-party developers. These APIs can be freely available or offered as paid products. Sometimes, companies make some of their APIs available to the public and provide instructions on how to use them.

A good example is the YouTube Data API, YouTube provides a public API that allows developers to access and interact with YouTube’s vast video content, including searching for videos, retrieving video details, uploading videos, and managing user playlists.

Developers can use this API to create applications that integrate YouTube video features, such as video search, recommendations, and video uploading, into their own platforms. This public API has enabled the development of various third-party YouTube applications and services.

Code Interfaces: Now, the first two types of APIs are quite practical, but developers also use the term “API” for lower-level stuff in code, like functions.

A code interface API, or simply a code API, refers to a set of functions, methods, or procedures that a programming language or library provides for developers to interact with and use in their code.

A classic example is the Math.random() function in JavaScript. It's an API that generates random numbers. There are other mathematical operations like Math.power() (power), Math.round() (round), and Math.sqrt() (Square root).

💡 There might be different types of API, but one thing is in common, they give an output based on an input. They might be named Public, Private, or Code Interfaces but still use API as a single term to describe them.

Based on Architectural Style:

Some of the most used types of APIs are:

REST: Representational State Transfer (REST) is the most common architectural style for Internet data transfer. It uses standard HTTP methods like GET, POST, PUT, and DELETE to interact with resources through endpoints.
SOAP: Simple Object Access Protocol (SOAP) uses XML to exchange structured messages between a client and server. It’s often used in enterprise environments and offers advanced security features but can be slower than other architectures.

How developer talks about APIs

“I’ve developed an API that allows you to discover the top 10 trending videos on YouTube tailored to your preferences, delivering personalized content effortlessly.”

Less manual work and faster access to the desired search result.

“I keep encountering this authentication issue with the API; it’s like trying to enter a password that I can’t quite get right.”

The API is throwing this puzzling auth error at me, like a locked door that requires the right key. I’m struggling to get through with the correct credentials.

“You can use the Facebook API to get that data into your app”

Connect your app with the Facebook API, and you can pull in data seamlessly. It’s like having a magic portal to grab the information you need for your application.

“I crafted an API that acts like a personal shopper, finding you the best book recommendations based on your preferences. It’s your literary guide in the vast bookstore of information.”

The future is here! Getting things done within moments in a few touches.

By now, you must have had a clear idea of APIs, from its working to testing you know all of it now. However, understanding APIs on a theoretical level is just the first step. To know the practical aspects of working with APIs, you can try working on them by implementing some of the concepts in projects.

The post was originally published at What is an API? which is a part of my newsletter called Hello, World! where we help developers learn a new software engineering concept every Monday. Read what engineers from Google, Microsoft, and Amazon are reading for free.

Configuring Ghost SSL with multiple domains

Rohit Lakhotia — Sat, 17 Jul 2021 14:12:26 +0000

This post was originally published at rohitlakhotia.com

This tutorial assumes that you have a self-hosted ghost installation up and running.

Ghost only server content on one domain at a time, so in order to serve content from other domains you need to redirect (301 vs 302) that domain to the domain where the ghost CMS is hosted on.

You may wish to have multiple domains that redirect to your site, e.g. to have an extra TLD or to support www domains. This is intentional for SEO purposes, however, you can always redirect extra domains to your Ghost install using Nginx.

If you want to redirect an HTTPS domain, you must have a certificate for it.

Basic Setup

What we will try to achieve here is to have www.rohitlakhotia.com point to the root domain rohitlakhotia.com with an SSL certificate so the browser doesn't show warnings while visiting any of the above.

This would also include the HTTP version to redirect to the HTTPS version so the search engine doesn't consider them duplicate pages.

Configure your secondary domain

We would need to configure the domain DNS records in order to let the browser know where to go while requests are being made.

Configure your domains with proper records

If you look closely the www version and the @ (root) version both point to the same IP (server).

Basically, every request that points to those two versions would be handled by the server at that IP address. Which is exactly what we want. So we can handle them appropriately.

Now we would need to SSH into the server to install the certificate and properly redirect the domain.

After you have access to the server, go to the directory where you have installed ghost. Mostly it would be

/var/www/<your ghost installation>

So cd into the directory and then

 ghost config url https://www.rohitlakhotia.com

In place of www.rohitlakhotia.com, add your domain (secondary domain) that you want to redirect to the root domain.

Before proceeding with the next command just make sure that the A records are successfully updated, else the SSL certificate won't be installed.

ghost setup nginx ssl

This will generate SSL certificates for your domain (which for me is www.rohitlakhotia.com) that you just added and also the Nginx configuration file for the HTTP and HTTPS version. (Easy!)

Now we will again change the ghost installation URL back to the old one which for me is https://rohitlakhotia.com

ghost config url https://rohitlakhotia.com

Now we would need to update the newly created Nginx configuration file so that we can redirect the user to the root domain.

The Nginx configuration files are mostly located at /etc/nginx/sites-available

cd /etc/nginx/sites-available

Here you will find all the Nginx configuration files. There should be a minimum of 4 files. Every domain has files with -ssl.conf (For HTTPS) and .conf (For HTTP).

So we would have 4 files:

rohitlakhotia.com-ssl.conf
rohitlakhotia.com.conf
www.rohitlakhotia.com-ssl.conf
www.rohitlakhotia.com.conf

Now we need to edit the files for the secondary domain.

So the files that I need to edit would be www.rohitlakhotia.com-ssl.conf and www.rohitlakhotia.com.conf

We need to add this line of code inside the location block but at the end.

return 301 https://rohitlakhotia.com$request_uri;

You can change the 301 to 302 depending on your use case (301 vs 302). You will replace rohitlakhotia.com with your primary domain.

What this line would do is whenever a request is made to the secondary domain then it would redirect (301/302) it to the specific URL.

So both the files should look like this

Now check if the configuration files are valid by

sudo nginx -t

If it's successful then reload the Nginx server

sudo nginx -s reload

And that's it.

You just pointed your secondary domain to your primary domain in ghost.

For more content you can checkout my blog

How to Create/Extend Django Custom User Model

Rohit Lakhotia — Sun, 31 May 2020 10:03:37 +0000

Originally Published at My personal website as a blog post Django Custom User Model

If you are looking to find CMS, I have made a curated list of CMS tools that you can filter and find the one that you are looking for. Do check it out: Content Toolkit

The Django build-in User model out of the box is solid. But it sometimes might not suit your need since it has some predefined field and you might want to add some more field to it like Date of Birth or maybe making email-only authentication since Django has username-password authentication out of the box. That’s when Django’s custom user model comes handy.

Django uses Python language. If you want to learn Python go to Learn Python from the Best Free Python Courses and Tutorials.

Do I need a Custom User Model?

Most of the time you don’t. Django’s built-in User models provide more than enough features to serve you out of the box. But if you want the user to authenticate with an email address instead of username then the custom model could be the right choice.

But that being said Django Official documentation suggests you have a custom model even if you don’t want too so in future if you want to add more information about the user you can do so which is more likely if your app grows.

Application-specific data

The User model is meant to show information related to your user’s authentication or authentication point of view. You might even be tempted to store other application-specific information related to the user.

Since most users will have a profile picture, bio. Data like this could be stored in another model which is referenced with an OneToOneField with the User Model.

Storing application data on the User model

There are some advantages and disadvantages to storing application data in the user model.

For smaller applications, it will be simpler. There won’t be many things to look for. Everything in one place. But if the application grows the same model can become clutter in no time.
Since everything will be in one place there won’t be a need for advanced database queries. But that would also make your table in the database bloated.

Storing application data in a profile model

The alternative way to store your user application data is to have another model Profile which is referenced with OneToOneField to the User Model.

Since the application data is kept on another model the User model is only used for authentication purposes and the Profile model is used for user’s application data. Keeping it clutter-free.
But since the application data is different from authentication data than to get the user application data we need to load another object from the database in order to retrieve the data. Depending on your application it could be worth the effort.
The decoupling of application data with authentication data makes it easier to make changes in the future.

Default Fields of User Model

The User Model Django provides out of the box has some fields in general:

username: The username that the user will use to authenticate. This will be unique in the table.
email: The email that the user can choose to share. But out-of-the-box it is not unique.
password1: The password user chooses to authenticate. It is not a plain password. It will be hashed for security reasons.
password2: This is used for confirm password. At the Admin side, only one field named password is seen.
first_name: First name of the person.
last_name: Last name of the person.
last_login: The last Date and Time the user logged in.
date_joined: The Date and Time the user joined/authenticated with your website.
groups: The groups the user is in.
user_permissions: Admin permissions if any.
is_staff: Designates whether the user can log into the admin site.
is_active: Designates whether this user should be treated as active. Unselect this instead of deleting accounts.
is_superuser: Designates that this user has all permissions without explicitly assigning them.

Ways to Extend the `User` model

There are 4 ways to extend an existing User model in Django. Check them below and choose the one that fits your needs.

Proxy Model
Profile Model with OneToOneField with User Model
AbstractBaseUser to Create a Custom User Model
AbstractUser to Create a Custom User Model

1. Proxy Model

Proxy models are a feature that developers might come across and move along without giving much importance. They can come in handy in many situations.

A proxy model is just another class that provides a different interface for the same underlying database model.

A proxy model is actually a subclass of a database-table defining model. Typically creating a subclass of a model results in a new database table with a reference back to the original model’s table ie. multi-table inheritance.

A proxy model doesn’t get its own database table. Instead, it operates on the original table.

It is used to change the behavior of an existing model (e.g. order, new methods, etc.) without changing the existing database schema.

When to use Proxy Model?

When you don’t need to add extra data about but just want extra methods or change the model’s query Manager.

It is a less intuitive way to extend the existing User model and is limited in many ways. You won’t have any drawbacks with this strategy.

models.py

from django.contrib.auth.models import User
from .managers import PersonManager

class Person(User):
    objects = PersonManager()

    class Meta:
        proxy = True
        ordering = ('email', )

    def do_something(self):
        ...

Let see what we did here.

First, we defined a Proxy Model named Person. To tell Django that it is a proxy model we make proxy = True in class Meta.
We assign a custom Manager named PersonManager to the Proxy model by objects = PersonManager( ).
Change the default ordering to email.
Defined a function do_something.

Also now User.objects.all( ) and Person.objects.all( ) will be using the same database table to query. The only difference has been the behavior of the Proxy Model.

2. Profile Model with OneToOne link with User Model

The idea behind this is to create another table in the database and point the User model to that table in the database with OneToOneField.

What is OneToOne Link?

It’s the Foreign Key relation but with unique=True. So every row in a table would have only one relating row in another table and vice versa.

But, when should I use this?

You should do this when you want to store profile related information like a profile picture, bio, etc. Basically everything related to the user that is not authentication specific.

Most of the time this is what you want.

Since we will be creating another model that stores user’s profile data that will be related to the User model. This will need an additional query or join to access the related data. To access the related data Django needs to fire additional queries.

So let’s see what to do here,

models.py

from django.db import models
from django.contrib.auth.models import User

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.CharField(null=True, max_length=200)
        birth_date = models.DateField(null=True, blank=True)    
        profile_pic = models.ImageField(default='default.jpg', upload_to='profiles_pics')
        hobby = models.CharField(null=True, max_length=200)

Now since the models are created, but they need to be created whenever a user is created. We need to use signals to do the same.

models.py

from django.db import models
from django.contrib.auth.models import User
from django.db.models.signals import post_save
from django.dispatch import receiver

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.CharField(null=True, max_length=200)
        birth_date = models.DateField(null=True, blank=True)    
        profile_pic = models.ImageField(default='default.jpg', upload_to='profiles_pics')
        hobby = models.CharField(null=True, max_length=200)

@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)

@receiver(post_save, sender=User)
def save_profile(sender, instance, **kwargs):
    instance.profile.save()

Here, we are telling Django that whenever a save event occurs (signal called post_save) create or save the profile depending on the situation.

So, here whenever an entry/row of a user is created in the table, a new entry/row is also created in the profile table in the database.

But that’s all fine, how do I access this profile data?

You can access this data in Django Templates like:

template.html

<h2>{{ user.username }}</h2>
<p>{{ user.email }}</p>
<p>{{ user.profile.bio }}</p>
<p>{{ user.profile.birth_date }}</p>

For using it in views:

views.py

def update_profile(request, user_id):
    user = User.objects.get(pk=user_id)
    user.profile.hobby = 'Coding, Chess, Guitar'
    user.save()

Since we have signals setup we don’t have to save the Profile models. If we save the User model the Profile models will also be saved.

In Django, we can have multiple forms in the same templates at once. So, if we want to have a profile page where users email, username and other profile data like bio, etc is shown and can be updated by the user.

First, we will create the forms: form.py

forms.py

from django import forms
from django.contrib.auth.models import User
from .models import Profile

class UserUpdateForm(forms.ModelForm):
    email = forms.EmailField()

    class Meta:
        model = User
        fields = ['username', 'email']

class ProfileUpdateForm(forms.ModelForm):
    class Meta:
        model = Profile
        fields = ['profile_pic', 'bio']

To access the forms in views.py

@login_required
def profile(request):
    if request.method == 'POST':
        u_form = UserUpdateForm(request.POST, instance=request.user)
        p_form = ProfileUpdateForm(request.POST, request.FILES, instance=request.user.profile)

        if u_form.is_valid() and p_form.is_valid():
            u_form.save()
            p_form.save()
            messages.success(request, f'Your Profile has been Updated Successfully')
            return redirect('profile')
    else:   
        u_form = UserUpdateForm(instance=request.user)
        p_form = ProfileUpdateForm(instance=request.user.profile)
    context = {
        'u_form': u_form,
        'p_form': p_form
    }
    return render(request, 'users/profile.html', context)

The template: profile.html

<form method="POST" enctype="multipart/form-data">
    {% csrf_token %}
    <fieldset class="form-group">
        <legend class="border-bottom mb-4">Profile Info</legend>
        {{ u_form.as_p }}
        {{ p_form.as_p }}
    </fieldset>
    <button type="submit">Update</button>
</form>

3. `AbstractBaseUser` to Create a Custom User Model

This method is like starting from a clean slate. Use this method if you want to start from scratch.

This method will have no predefined field, it only contains the authentication functionality, but no actual fields. You have to supply them when you subclass.

It can be helpful in many cases like when you want to use email for authentication instead of username. But there are better ways to do the same by using AbstractUser instead of AbstractBaseUser .

You this at your own will. JK. You will be fine.

To demonstrate this we will be using the same example as in the documentation.

Here is an example of an admin-compliant custom user app. This user model uses an email address as the username, and has a required date of birth; it provides no permission checking beyond an admin flag on the user account.

This model would be compatible with all the built-in auth forms and views, except for the user creation forms. This example illustrates how most of the components work together, but is not intended to be copied directly into projects for production use.

This code would all live in a models.py file for a custom authentication app:

models.py

from django.db import models
from django.contrib.auth.models import (
    BaseUserManager, AbstractBaseUser
)

class MyUserManager(BaseUserManager):
    def create_user(self, email, date_of_birth, password=None):
        """
        Creates and saves a User with the given email, date of
        birth and password.
        """
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            email=self.normalize_email(email),
            date_of_birth=date_of_birth,
        )

        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, date_of_birth, password=None):
        """
        Creates and saves a superuser with the given email, date of
        birth and password.
        """
        user = self.create_user(
            email,
            password=password,
            date_of_birth=date_of_birth,
        )
        user.is_admin = True
        user.save(using=self._db)
        return user

class MyUser(AbstractBaseUser):
    email = models.EmailField(
        verbose_name='email address',
        max_length=255,
        unique=True,
    )
    date_of_birth = models.DateField()
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)

    objects = MyUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['date_of_birth']

    def __str__(self):
        return self.email

    def has_perm(self, perm, obj=None):
        "Does the user have a specific permission?"
        # Simplest possible answer: Yes, always
        return True

    def has_module_perms(self, app_label):
        "Does the user have permissions to view the app `app_label`?"
        # Simplest possible answer: Yes, always
        return True

    @property
    def is_staff(self):
        "Is the user a member of staff?"
        # Simplest possible answer: All admins are staff
        return self.is_admin

Then, to register this custom user model with Django’s admin, the following code would be required in the app’s admin.py file:

admin.py

from django import forms
from django.contrib import admin
from django.contrib.auth.models import Group
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.forms import ReadOnlyPasswordHashField

from users.models import MyUser

class UserCreationForm(forms.ModelForm):
    """A form for creating new users. Includes all the required
    fields, plus a repeated password."""
    password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
    password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)

    class Meta:
        model = MyUser
        fields = ('email', 'date_of_birth')

    def clean_password2(self):
        # Check that the two password entries match
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError("Passwords don't match")
        return password2

    def save(self, commit=True):
        # Save the provided password in hashed format
        user = super().save(commit=False)
        user.set_password(self.cleaned_data["password1"])
        if commit:
            user.save()
        return user

class UserChangeForm(forms.ModelForm):
    """A form for updating users. Includes all the fields on
    the user, but replaces the password field with admin's
    password hash display field.
    """
    password = ReadOnlyPasswordHashField()

    class Meta:
        model = MyUser
        fields = ('email', 'password', 'date_of_birth', 'is_active', 'is_admin')

    def clean_password(self):
        # Regardless of what the user provides, return the initial value.
        # This is done here, rather than on the field, because the
        # field does not have access to the initial value
        return self.initial["password"]

class UserAdmin(BaseUserAdmin):
    # The forms to add and change user instances
    form = UserChangeForm
    add_form = UserCreationForm

    # The fields to be used in displaying the User model.
    # These override the definitions on the base UserAdmin
    # that reference specific fields on auth.User.
    list_display = ('email', 'date_of_birth', 'is_admin')
    list_filter = ('is_admin',)
    fieldsets = (
        (None, {'fields': ('email', 'password')}),
        ('Personal info', {'fields': ('date_of_birth',)}),
        ('Permissions', {'fields': ('is_admin',)}),
    )
    # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin
    # overrides get_fieldsets to use this attribute when creating a user.
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'date_of_birth', 'password1', 'password2'),
        }),
    )
    search_fields = ('email',)
    ordering = ('email',)
    filter_horizontal = ()

# Now register the new UserAdmin...
admin.site.register(MyUser, UserAdmin)
# ... and, since we're not using Django's built-in permissions,
# unregister the Group model from admin.
admin.site.unregister(Group)

Finally, specify the custom model as the default user model for your project using the AUTH_USER_MODEL setting in your settings.py:

settings.py

AUTH_USER_MODEL = 'users.MyUser'

4. `AbstractUser` to Create a Custom User Model

This is pretty simple to start with and is flexible too. AbstractUser is your User Model the Django framework provides out of the box. Since you will be subclassing it. So now you can change stuff inside the class like using email field instead of username field for authentications.

AbstractUser is a full User model, complete with fields, like an abstract class, so that you can inherit from it and add your own profile fields and methods.

models.py

from django.db import models
from django.contrib.auth.models import AbstractUser

class MyUser(AbstractUser):
    bio = models.TextField(max_length=500, blank=True)
    hobby = models.CharField(max_length=200, blank=True)

Update your setting.py to use the new User Model

settings.py

AUTH_USER_MODEL = 'users.MyUser'

Where users is the app’s name

Django recommends having your own custom model even if you happy with the out of the box User model.

What to do if I just need the default User Model and don’t want to add any other fields?

Do it like this:

models.py

from django.contrib.auth.models import AbstractUser

class MyUser(AbstractUser):
    pass

    def __str__(self):
        return self.username

And obviously, tell Django to use your Custom User Model in settings.py

settings.py

AUTH_USER_MODEL = 'users.MyUser'

Referencing the `User` model

Now since you have changed your default User Model. You might need to change the way you access it.

Now in Option 2 where we used OneToOneField in Profile Model to relate to User model like this:

models.py

from django.db import models
from django.contrib.auth.models import User

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
        # Other Fields

After using our Custom Model, the right/better way is to use get_user_model( ), like this:

models.py

from django.db import models
from django.contrib.auth import get_user_model

class Profile(models.Model):
    user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE)
        # Other Fields

model.py

from django.db import models
from django.conf import settings

class Profile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
        # Other Fields

Up to you what you choose. Both will work fine.

Reusable apps and `AUTH_USER_MODEL`

Reusable apps shouldn’t implement a custom user model. A project may use many apps, and two reusable apps that implemented a custom user model couldn’t be used together. If you need to store per user information in your app, use a ForeignKey or OneToOneField to settings.AUTH_USER_MODEL as described above.

Right Choice?

It all ends up on you, your needs.

A project I am working now needed Email Authentication instead of the username-password authentication that Django provides out of the box and we wanted the username field to be removed from my User Model. So we used AbstractUser to subclass my Custom User Model.

To store more information about Users like the profile picture, bio, and other user-related information we created another Model called Profile and we used OneToOneField to relate it to Custom User Model.

Conclusion

It’s always a good idea to use a custom user model if you are still happy with the one provided by Django out of the box.

That’s all for Custom User Model in Django.

Let me know if this post helps you in any way in the comment section below.

What is Programming?

Rohit Lakhotia — Fri, 15 May 2020 07:52:05 +0000

Creating products from scratch feels good or in some sense make us feel very proud and confident of ourselves. Which is very important for self-improvement. But how do you create them? What are the things involved? Let's see what is programming?

What is Programming?

There are many definitions to this but what I prefer is:

Programming is a way to instruct/tell a computer to perform a specific task/solve a problem.

There are 3 key phrases to look out for:

You: Computer will do what you (Programmer) told it to do.
Instruct: Instruction is given to the computer in a language that it can understand. We will discuss that below.
Problem: At the end of the day computers are tools (Complex). They are there to make out life simpler.

There is a saying

If you told a computer to fall off a cliff, It definitely would!

That is so true! They will do what they are programmed to do.

What is Programming used for?

Programming is used in many scenarios. It can be making games, software that solves a particular task, apps that run on your phone, predicting trends or future.

It plays a very important role in the software development process.

What is Computer Programming?

Computer programming is programming that helps to solve a particular technical task/problem.

Computer programming helps in developing programming languages that are used for solving technical problems.

So, How is Computer programming done?

We know that computer programming is giving instruction to the computer to solve tasks/problems.

But

How to convey instruction?

The answer is Programming Languages

Just like us, they have their own language (Machine Language) to convey information. Therefore, computers don't understand languages like English, Spanish, etc.

What are Programming Languages?

According to Wikipedia, A programming language is a formal language, which comprises a set of instructions that produce various kinds of output. Programming languages are used in computer programming to implement algorithms.

Types of Programming Languages:

Programming Language can be categorized into 2 types of language:

High-Level Language
Low-Level Language

High-Level Language:

High-Level Languages are programming languages like Java, Python, C, C++, etc which helps programmer to write programs which is independent with the type of computer.

The computer with the help of the compiler compiles the High-Level Language into Low-Level Language which the computer can read and run to get the desired output.

High-Level Language is divided into 3 parts:

Procedural-Oriented language (3GL)
Problem-Oriented language (4GL)
Natural language (5GL)

Low-Level Language:

Low-level languages are languages that the computer can understand and process without the need of a compiler.

Low-Level Languages are divided into 2 parts:

Machine language (1GL)
Assembly language (2GL)

Difference between Coding and Programming?

Coding VS Programming

Definition:

Coding is the translation of Natural Language into Machine commands through an intermediary coding language.

Programming is the process of development of a fully functional software solution.

Involves:

Coding involves writing many lines of code in order to create a software program.

Programming involves not only coding but also other tasks, such as analyzing and implementing algorithms, understanding data structures, solving problems, and more.

Approach:

In Coding, no previous preparation is needed. Trial-and-error. Whereas in Programming, methodical approach, attention to detail.

Experience:

In Coding, basic knowledge of a programming language, it's syntax and keywords are needed.

In Programming, experience in creating algorithms, modeling a problem, data processing, project management is needed.

Outcome:

In Coding, a simple solution or a small part of a project is the output. Whereas in Programming, full ready-to-use application is ready.

Difficulty:

Easier to be a Coder. Difficult to be a Programmer. Needs years of Experience.

When I first started coding my first instinct was to learn Web Development since I wanted to make a website of my own where I would upload cool stuff that people could share and have fun with.

So, I started learning HTML and CSS. BTW if you want to learn HTML5 you can check the Free Courses and Tutorial on HTML5.

But wait.

Is HTML even a Programming Language?

Now that's a matter of debate. Since HTML stands for HyperText Markup Language. It can be classified as Language?

Well, some say it is a programming language some say its just a language.

According to Brian D Foy,

"No, HTML is not a programming language. The "M" stands for "Markup". Generally, a programming language allows you to describe some sort of process of doing something, whereas HTML is a way of adding context and structure to text."

According to Chris Pietschmann,

"YES, a declarative programming language."

Well, What do you think, Is HTML a Programming Language?

Where to go next?

So you started to gather interest in programming? Want to learn to Code? Can't find resources? Then you can check out Free Courses and Tutorial from all over the Web.

DEV Community: Rohit Lakhotia

EP 1: What is an API?

What’s an API?

The Power of APIs

How does an API Work?

How API works between client and server

Types of APIs

How developer talks about APIs

Configuring Ghost SSL with multiple domains

Basic Setup

Configure your secondary domain

Configure your domains with proper records

How to Create/Extend Django Custom User Model

Do I need a Custom User Model?

Application-specific data

Storing application data on the User model

Storing application data in a profile model

Default Fields of User Model

Ways to Extend the User model

1. Proxy Model

2. Profile Model with OneToOne link with User Model

3. AbstractBaseUser to Create a Custom User Model

4. AbstractUser to Create a Custom User Model

Referencing the User model

Reusable apps and AUTH_USER_MODEL

Right Choice?

Conclusion

What is Programming?

What is Programming?

What is Programming used for?

What is Computer Programming?

So, How is Computer programming done?

What are Programming Languages?

Types of Programming Languages:

High-Level Language:

High-Level Language is divided into 3 parts:

Low-Level Language:

Low-Level Languages are divided into 2 parts:

Difference between Coding and Programming?

Is HTML even a Programming Language?

Where to go next?

Ways to Extend the `User` model

3. `AbstractBaseUser` to Create a Custom User Model

4. `AbstractUser` to Create a Custom User Model

Referencing the `User` model

Reusable apps and `AUTH_USER_MODEL`