How to Implement Multiple User Types with Django
Django Framework:
Django is a framework that can make web applications more accessible and faster. Django is an open-source collection of python libraries, and Django can be used for both the front and back end. Django also provides read, delete and update interfaces which can be used during the runtime of the process and these can be used dynamically. Many websites use the Django framework to create their web applications; some of them include:
- Mozilla
- Clubhouse
- Nextdoor
Implementation of Multiple Users using Django
When we consider multiple users, we generally consider multiple users with one user as the regular user and the other user as the admin user. The is_staffis a built-in function available in Django which is used to differentiate the normal user and the admin user. Generally, the is_staff and the is_superuser are the two built-in functions in the Django Admin app. The is_staff built-in function is used to inform whether the user can log in to the Django Admin pages or not.
After the Admin page's login, the user's functions are given by the permissions framework. The is_superuser built-in function is the additional function used to assign all the permissions at once without adding them to the user. Hence, we can say that the user's permissions first is managed by the permission framework and then by the is_superuser built-in function available in Django.
We should never use the built-in user models available in Django directly, but we need to make some changes in the available models in Django; at least we need to improve theAbstractUser model, and we also need to switch the AUTH_USER_MODEL in the user module settings. If we want to customize the user module in the future and if we want to switch the AUTH_USER_MODEL becomes very difficult in the future because, after the creation of the Django user, we need to update all the keys at once, which becomes a very difficult task. This task can be made easier with the help of these simple measures; these measures will add some custom methods in the User model without relying on the OneToOne model.
The users created by the Django framework are case sensitive. If we create a user name as sai and another user name as Sai, these will be different, so while using the user names, we must correctly write the user names as they are case sensitive. Hence we can create multiple users with the Django framework.
The multiple users are created by providing the different usernames for each user we have created, we need to provide the different user names for the created user. Now let us consider an example of the creation of the two users in which, one user is of the manager and the other user is of its employees:
Example:
class User(AbstractUser):
is_manager = models.BooleanField(‘Manager status’, default = False)
is_employees = models.BooleanField(‘Employee status’, default = False)
Example:
class User(AbstarctUser):
Multiple_User = (
(1, ‘Manager’),
(2, ‘Supervisor’),
(3, ‘Employees’),
(4, ‘watchman’),
(5, ‘Customer’),
)
Mul_users =models.PositiveSmallIntegerFeild( Choices = Multiple_User)
This method is used when we need to check which type of the user we have and we can also find the central point in the given data. Generally when a user creates the multiple users we need to check the Authentication and the Authorization processes, these both are very important when we create the user, first we need to look for the permissions are provided by the user or not and we need to check for the login credentials of the user.
Authentication:
This process is used for verifying if the given account details are of the same person with the help of the login credentials which are provided by the user
Authorization:
This process is used for verifying if all the permissions are passed by the user who want to use the particular user credentials. We need to check whether the given user passes through all the permissions and we can login into the particular user.