Models in Djuix.io

A model is your database blueprint - it defines how your data is structured and stored. It contains the essential fields and behaviors of the data you're storing. Generally, each model maps to a single database table.

Picking from Django Docs concerning model basics:

Each model is a Python class that subclasses django.db.models.Model.
Each attribute of the model represents a database field.
With all of this, Django gives you an automatically-generated database-access API.

Let's face it: if you're new to Django, wrapping your head around model creation can take a while. You need to understand Python classes, inheriting from django.db.models.Model, define fields as class attributes, and that's just the beginning! It's powerful, sure, but it can be overwhelming.

This is where djuix.io swoops in to save the day!

While Django's approach to models is powerful, it can be challenging for beginners. Let's compare the traditional Django approach with Djuix's streamlined method.

Code base Approach

In standard Django, you define models as Python classes:

from django.db import models

class Product(models.Model):
  name = models.CharField(max_length=100)
  price = models.DecimalField(max_digits=10, decimal_places=2)
  description = models.TextField()
  created_at = models.DateTimeField(auto_now_add=True)

This requires understanding of Python class syntax, Django's model API, and various field types.

Djuix's Click Approach

Djuix eliminates the need to write Python code for model creation. Instead, you can use our intuitive GUI:

Click on "Models" in the sidebar or within the app
Click "Create New Model"
Choose from a list of supported fields
Save

Create Model.mov

Note: To see the code structure of the created model click on the more icon and select “View”

Fields

Working with Model Fields in Djuix

Djuix supports native Django fields with an extended field to make creating realtionships intuiative and convinent. Here's a list of supported fields:

CharField IntegerField BooleanField BigIntegerField TextField DateField

ManyToManyField

DateTimeField EmailField FileField ImageField JSONField

OneToOneField

TimeField SlugField DecimalField FloatField PositiveIntegerField

ForeignKeyField

→ All these fields can be vetted with detailed information refer to the here

Relationship Fields

Djuix simplifies the process of creating relationships between models. When you select ForeignKey, OneToOneField, or ManyToManyField, Djuix will automatically provide a list of available models in your project, grouped by app.

Code

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

class Profile(models.Model):
    user = models.OneToOneField(
        User,
        on_delete=models.CASCADE,
        related_name='profile'
    )
    bio = models.TextField()

Djuix Approach:

Select AuthField type
Choose relationship (One-to-One/Many-to-Many/Foreign Key)
Set related name
Done!

Foreign Key.mov

Field Configuration

Common Options

Null/Blank settings
Default values
Help text
Unique constraints
Validation rules

AuthField: A Djuix Innovation

Djuix introduces the AuthField, a custom field type designed to simplify the process of relating models to Django's built-in User model or your custom user model.

In traditional Django, you might write:

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

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(blank=True)

With Djuix, you can achieve the same result by selecting "AuthField" and choosing the relationship type (OneToOne, ForeignKey, or ManyToMany) in the GUI.

AuthField.mov

This approach not only simplifies the code but also automatically handles the import of the correct User model, whether it's the default Django User or a custom user model.