In this article, you will learn how you can create a generic multi-field model custom validation mechanism for your django projects. By default, django provides a way for you to validate your model fields by passing a list of validator functions to the validators argument. What if we have to apply validations to multiple model fields? For example, in an e-commerce application, say we have to ensure that when a user selects a discount of type percentage, then the discount value should be less than or equal to 100. We will in the following sections, with detailed code and explanations, see how we can do this in Django.

Creating the model

Let’s assume we are implementing a Coupon model that keeps track of coupons we offer to customers. Our coupon model looks like this

class Coupon(models.Model):
    class DiscountTypes(models.TextChoices):
        PERCENTAGE_DISCOUNT = "percentage_discount"
        FIXED_CART_DISCOUNT = "fixed_cart_discount"
        FIXED_PRODUCT_DISCOUNT = "fixed_product_discount"
        BOGO = "bogo", _("BOGO (Buy X GET X/Y) Offer")

    class DisplayIn(models.TextChoices):
        MY_ACCOUNT = "my_account"
        CHECKOUT = "checkout"
        CART = "cart"

    code = models.CharField(max_length=20, unique=True, null=True)
    amount = models.FloatField(default=0)
    start_date = models.DateTimeField(auto_now=True)
    expiry_date = models.DateTimeField()
    free_shipping = models.BooleanField(default=False)
    description = models.TextField(max_length=200)
    discount_type = models.CharField(max_length=40, choices=DiscountTypes.choices)
    apply_automatically = models.BooleanField(default=False)
    display_in = MultiSelectField(max_length=20, max_choices=3, choices=DisplayIn.choices, null=True)
    minimum_spend = models.IntegerField(default=0, null=True)
    maximum_spend = models.IntegerField(default=0, null=True)
    individual_use_only = models.BooleanField(default=False)
    exclude_sale_items = models.BooleanField(default=False)
    email_restrictions = models.TextField(help_text=
                                          "Comma separated list of emails to restrict for access to this coupon",
                                          null=True, blank=True)
    def __str__(self):
        return self.code

The coupon has different discount types including:

• Percentage discount
• Fixed cart discount
• fixed product discount
• Bogo discount

Validation

Let’s say we want to ensure that, if an admin creates a percentage discount coupon, the amount field should not be above 100. To make this generic and reusable, let’s create a Validator abstract base class. This is will provide two methods:

register — A class method that will be used to register the fields that we want to validate and the error message that should be shown.

run — An abstract method that will be implemented by child classes to provide the actual validation functionality.

Our Validator abstract base class should look like this:

from abc import ABC, abstractmethod
from django.db import models
import typing as t


class Validator(ABC):
    @classmethod
    def register(cls, fields: t.List[str] = [], message="Model is not valid"):
        cls.fields = fields
        cls.message = message
        return cls()

    @abstractmethod
    def run(self, model: models.Model):
        pass

Now let’s create a mixin called ModelValidationMixin. This will override the clean and the save methods of the django model. It will loop through a validators (a list of Validator implementations) property and check for validation errors. Our ModelValidationMixin should look like this:

class ModelValidationMixin:
    validators: t.List[Validator] = []

    def clean(self):
        for validator in self.validators:
            if not validator.run(self):
                raise ValidationError(validator.message)

    def save(self, *args, **kwargs):
        self.full_clean()
        super(ModelValidationMixin, self).save(*args, **kwargs)

Next, let’s implement a validation class (LessThan100IfPercentageDiscount) which will answer our initial question above — Ensure that if the discount type is percentage_discount, the discount amount inputted should not go above 100.

class LessThan100IfPercentageDiscount(Validator):
    def run(self, model):
        return not (model.discount_type == Coupon.DiscountTypes.PERCENTAGE_DISCOUNT and model.amount > 100.0)

As a bonus let’s also implement another validation class that will ensure that the start_date is never ahead of the expiry_date (LessThanValidator) — Usable for comparing other fields that need a less-than comparism.

class LessThanValidator(Validator):
    def run(self, model: models.Model):
        return getattr(model, self.fields[0]) < getattr(model, self.fields[1])

Let’s wrap it up

To use the above validators, our Coupon model class will then look like:

class Coupon(ModelValidationMixin, models.Model):
    class DiscountTypes(models.TextChoices):
        PERCENTAGE_DISCOUNT = "percentage_discount"
        FIXED_CART_DISCOUNT = "fixed_cart_discount"
        FIXED_PRODUCT_DISCOUNT = "fixed_product_discount"
        BOGO = "bogo", _("BOGO (Buy X GET X/Y) Offer")

    class DisplayIn(models.TextChoices):
        MY_ACCOUNT = "my_account"
        CHECKOUT = "checkout"
        CART = "cart"

    code = models.CharField(max_length=20, unique=True, null=True)
    amount = models.FloatField(default=0)
    start_date = models.DateTimeField(auto_now=True)
    expiry_date = models.DateTimeField()
    free_shipping = models.BooleanField(default=False)
    description = models.TextField(max_length=200)
    discount_type = models.CharField(max_length=40, choices=DiscountTypes.choices)
    apply_automatically = models.BooleanField(default=False)
    display_in = MultiSelectField(max_length=20, max_choices=3, choices=DisplayIn.choices, null=True)
    minimum_spend = models.IntegerField(default=0, null=True)
    maximum_spend = models.IntegerField(default=0, null=True)
    individual_use_only = models.BooleanField(default=False)
    exclude_sale_items = models.BooleanField(default=False)
    email_restrictions = models.TextField(help_text=
                                          "Comma separated list of emails to restrict for access to this coupon",
                                          null=True, blank=True)
    validators = [
        LessThanValidator.register(["start_date", "expiry_date"],
                                   message={"expiry_date": "Should be greater than start date"}),
        LessThan100IfPercentageDiscount.register(message={"amount": "Amount should be less that 100 if coupon type is"
                                                                    "percentage_discount"})
    ]

    def __str__(self):
        return self.code

After running this, in the django admin interface, you’ll notice an error that appears while trying to input a discount amount of 120 while the discount type is percentage_discount

Generic Multi-Field Django Model Custom Validation was originally published in Django Unleashed on Medium, where people are continuing the conversation by highlighting and responding to this story.

Sometime ago, while working on an android project, and I reached a point where I had to detect when my application is idle and perform a certain action. By idle here I mean the user has opened the app but is not interacting with.

What are we going to build?
Let’s assume a bank wanted to give it’s customers the ability to increase their account balances just by clicking a button 😃 (that might never happen, yes I know) and we need to build such an app for them. The user’s balance will reset to 0 if he delays for a period of time without interacting with the app. Simple app right? But remember our goal is to detect when the user has not been interacting with our app for sometime and not to build some fancy application. After this, you will be able to detect idle state of your application. Now enough of the talking. Let’s dive into some concepts and code.

We’ll start by creating a new android project on android studio. Feel free to call it whatever you want. I’ll provide a link to the repo at the end. Next we’ll create an empty activity and call it MainActivity. We’ll then create java class and call it BaseActivity. BaseActivity will be the parent class of all activities. The reason why I did this is because we’ll not want to write code in all our activities where we need to detect idle state of the application.

Let’s add some code to the BaseActivity class.

As you can see I created a method myCustomOnCreate that will be overidden by all child activities inorder to render the layout.

I already created the layout that allows the user add up what he has in account by simply tapping on a button. I have also implemented the java functionality. Remember that’s not purpose of this article so we’ll focus more performing an action when our app is idle. This is a look of our simple app.

We will be using the android Handler class and Runnable interface. Inside the BaseActivity class, let’s create a handler object and pass a runnable object with a timeout to the handlers postDelayed. This will call the run method implementation inside our runnable implementation after timeout has occured. Let’s create a method and call it reactToIdleState. This method will be called inside the run method of the runnable implementation. We will also need to override this method inside all our Activities that extend BaseActivity. That is the method that will be called when the app becomes idle

In the BaseActivity onCreate method, we will initialize our handler and call it’s postDelayed method passing into it the runnable object and the timeout as shown below. This simply means “Call the runnable’s run method after a timeout has reached”.

There are only two ways the user can interact with our app. Either by simple touching the screen or clicking the button to add their balance. So will make our BaseActivity class implement the View.OnClickListener interface and implement it’s onClick method. We will also the override the Activity onTouchEvent. In these two methods we will remove the callback from the handler by calling the removeCallbacks method and passing to it our runnable object, then call the postDelayed method again on the handler object. I have created a method called resetHandler to the job. We will call this method in our onClick and OnTouchEvent methods so every time user touches his screen or clicks the button we re-initialize the post delay.

If you notice, in the onClick method I called a myCustomOnClick method that will be overridden inside all activities that extend BaseActivity and needs to respond to click events. That’s it for the BaseActivity. Now any of our activities can extend our BaseActivity and override the appropriate methods to perform actions on app idleness.

Our MainActivty will do the following

• Declare member variables and initialise them in the myCustomOnCreate method.

• React to the click events by overriding the BaseActivity myCustomOnClick method.

• Override the BaseActivity reactToIdleState method and perform desired action when the app is idle.

That’s it for our app. You can improve on the app functionality. But I would expect you to apply the concept to your own application where you need to know when the user hasn’t been interacting with the app for a while. Any idea about some other approach or questions will be highly welcome in the comment section. I’ll also be pleased if there could be corrections or something to add in the comment section. Here is the link to the complete project https://github.com/sonegillis/idle-state-detect-app. You can clone the project and run on your android device. To know more about Handlers and Runnable you can check out the following links to the google android developer site.
- https://developer.android.com/reference/android/os/Handler
- https://developer.android.com/reference/java/lang/Runnable

So what are servlets and what do they do?

Servlets are a java technology used to handle incoming HTTP requests on a server. When an HTTP request is made to a server from browser for example, this request gets routed to Web Application Container simple called a Web Container. These web containers often contain one or more servlets. So when an http request is routed to a web container it in turn routes it to one of the servlets contained within it. The servlet then processes the HTTP request by looking at the headers and understanding how to interpret the body.

Simply, a servlet is nothing more than a Java object which contains several methods with the key methods being doGet and doPost methods each used for handling HTTP request with the GET and POST request method respectively. A java servlet is an implementation of the HttpServlet interface and implements several request handling methods that correspond to HTTP request methods.

How does the Web Container knows which servlet to route a request to?

Web containers usually use some routing function or simple a router to determine based on the incoming request, which servlet should do the handling. In Java these are configured in a file named web.xml. When a request comes from a client, the web container looks in the the web.xml file to get which servlet to use to handle the incoming request.

Conclusion

Servlets are the basic java objects used in handling incoming http request. Although creating Servlets by implementing the default HttpServlet java interface is the long way to go about building scalable Java web applications, understanding the fundamentals of how they work is very important as it is used by more advanced frameworks like Spring which has become a major tool in building scalable java web applications.

I will be posting some articles in the near future about the Spring framework and how we can use to build cloud services.