Schedule & send rent invoices to tenants at regular intervals using Django & AfricasTalking API
Tags: django, python, webdev, programming
Published: 2021-08-01 10:15:13

##THE PROBLEM
If you are a caretaker or a landlord of a rentals property, chances are every end of the month, you draft paper invoices and then walk door to door issuing each tenant with their specific invoice. Not only is this tedious and time consuming but also you risk walking to a tenant's door and finding that they are not in and you have to come again at a later time or the next day(s). 
A hypothetical property, Kwetu Apartments is one such business that has hitherto been doing things this way and they have decided that it is time they embrace technology and become a digital first business by leveraging on automation tools to handle the otherwise daunting manual invoicing method. 
##THE SOLUTION
The owner of Kwetu Apartments approached our team of software developers and after lengthy talks, we decided to develop a portal for them that will:
1.Send text message reminders to tenants with invoice details every 30th of each month.
2.process rent payments using either card or mpesa and then update each tenant's status as either paid or not.
The portal will then send text messages to those who have not paid to remind them to make payments. 
The assumption here is that we have already developed the logic to process tenants payments and now what we have to do is implement the logic to send text reminders every 30th each month. In case you need an article on payment processing then [go through this](https://dev.to/nick_langat/collect-payments-in-your-django-ecommerce-portal-using-flutterwave-part-1-14kp) post I wrote a few days back. 

##PROJECT SETUP
Create a new project and start a new app:
```
django-admin startproject tenants_project .

python manage.py startapp invoices
```
Remember to add `invoices` to the list of installed apps in `tenants_project/settings.py`
Let's quickly create a database class that will house all our tenants and their details:
```python
from django.db import models

# Create your models here.
class Tenant(models.Model):
    name=models.CharField(max_length=250)
    phone=models.CharField(max_length=250)

    def __str__(self):
        return self.name
```
Go ahead and `makemigrations` then `migrate`. Register the model in `admin.py`. Also create a superuser, login to the admin section of the project and add a few tenant instances. After that we can begin sending them invoices messages every month!
##AFRICASTALKING CONFIG
Stop the server but retain the virtual env. Install AfricasTalking helper library by:
```
pip  install africastalking
```
Now log in to [their website](https://account.africastalking.com/). Click on 'Sandbox' and from the resulting dashboard click on 'Settings' then 'API Key'. Click to generate a new key which you will copy and store it safe as we are using it in a bit. 
##SCHEDULER LOGIC 
We then move on to install a package that will help us with task scheduling. While still on terminal do this:
```
pip install apscheduler
```
Create a file within `invoices` called `invoice_update.py` and add the code below to it:
```python
from .models import Tenant
import africastalking

# Initialize SDK
username = "sandbox"    
api_key = "YOUR SANDBOX API KEY" 
africastalking.initialize(username, api_key)

sms = africastalking.SMS

def send_reminders():
    tenants=Tenant.objects.all()
    for tenant in tenants:
        invoice_message=f'Hello, {tenant.name}, your rent payment of shs 10,000 is due on demand. Please plan to pay before 5th.'
        response =sms.send(invoice_message, [str(tenant.phone)]) 
        print(response)
```
Next, create another file within `invoices` called `updater.py` and add the code below to it:
```python
from apscheduler.schedulers.background import BackgroundScheduler
from . import invoice_update

def start():
    scheduler = BackgroundScheduler()
    scheduler.add_job(invoice_update.send_reminders, 'interval', seconds=10)
    scheduler.start()
```
So here we are scheduling a reminder with invoice details for all the tenants in our database. For testing purposes we are running that task every ten seconds but in production we would put a cron job to run every 30th. Save that file then move to `invoices/apps.py` and update it like so:
```python
from django.apps import AppConfig

class InvoicesConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'invoices'

    def ready(self):
        from . import updater
        updater.start()
```
So every time our project boots, our scheduler runs in the background and does its thing. 
Let's take it for a spin and see what's what:
```
python manage.py runserver
```
Head over to your [AT Sandbox](https://simulator.africastalking.com:1517/) and launch it. 
You will see an image like below:
![sandbox home](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sg6a2r01bt0lf4iwg2vw.png)
Click on the SMS card and you will see:
![sms](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vs3n6x8yzgay9w9vh97h.png)
Great, our tenants got the invoice messages as intended by Kwetu Apartments. 
##WRAP UP
In this article we have eliminated the need of Kwetu Apartment caretakers and landlords to draft paper invoices and then walk door to door delivering them to tenants. We developed a solution that is robust and scalable that can server as many users as possibles with minimal human input. 
The code to this project can be found [at my repo](https://github.com/nicksonlangat/kwetu_apartments).

Thanks for reading and coding along. Go ahead and add creativity and share what you will come up with. 
If you have any questions or comment then leave them below or on my [Twitter](https://twitter.com/NicksonLangat20).
Cheers and happy hacking!