DEV Community: Heinek Halwin

Creating Transferrable Knowledge

Heinek Halwin — Sat, 03 Jun 2023 10:53:30 +0000

Hi everyone !
I am a Full stack developer usually working with python django or javascript frameworks such as react or next. And recently I had to work with Kotlin Android to create a project for my university.

Usually, the way I work with a new project is, I put my hours in, I learn the programming language, go through the best practices, watch tutorials, read posts here on DEV ;) and so on. But in this project, I had to dive right in because of time constraints and I imagined I might bump into problems or that it would be a disaster. But instead it went pretty well and I realised I had transferrable knowledge.

What i mean by transferrable knowledge is the ability to identify and use programming concepts across all languages and frameworks. Because underneath all the bells and whistles of each language, they all follow mostly the same programming paradigms and concepts.

Which brings me to next point, how to create transferrable knowledge.

*Firstly and lastly, Learn programming concepts. *

Yes, learn programming concepts! From concepts small as datatypes, data structures, conditional statements, looping statements to concepts vital such as exception handling etc. Also for bonus points, you can learn about Functional programming concepts such as currying, pure functions etc. Same goes for object oriented programming concepts.

Now that you have learned the concepts. You can choose a language to work on your side hustle. Here, you can break down the logic in terms of the concepts you have learned, then you can refer the documentation or tutorials for the syntax to code through the logic of your application and in a few hours, you would be working through the syntax as if it were second nature.

Congrats ! You have now started with creating your transferrable knowledge.

Have you experienced and used this in your career ? Let me know in the comments if you have.

Django and Ajax

Heinek Halwin — Sun, 15 Mar 2020 17:29:30 +0000

Hi guys !

So, its been a while since i wrote an article. Well, before i start one, amidst all the chaos in the real world, i hope everyone is doing fine and is staying indoors. Stay safe guys !

Let's get started then.

What is Ajax ?

Well, ajax is an asynchronous web technique to send and receive data. So, what is the big deal ? Why is it important ? Well, you could send some data, process it, then receive the processed data and perform some action based on it. And, all this could happen without a page reload. You would only need to reload the parts of the webpage that needs to be changed.

Django and Ajax

So, now that you know the benefits of using django and ajax. Where all could you apply it ? I've seen it being applied in forms and on button clicks mostly. But theoretically, you could apply it anywhere, you could trigger a javascript event.

So, you could combine it with a django web template and get some dynamic feedback. Like, clicking a like button and the color changes from grey to blue, or, checking if the username you are typing is already been taken, etc.

Creating a password strength checker

Now, lets use ajax to check the strength of the password that a user is typing. Disclaimer: This is not the actual way to check the strength of a password, but for this article, i'm simply going to check the length of the password.

So, in your django template file.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>  <!-- Add Jquery for AJAX to work -->
    <title>Document</title>
  </head>
  <body>
    <input id="pwd_text" type="password" />
    <p id="ajax_response"></p>
  </body>
</html>

<script>
  $(document).ready(function() {
    $("#pwd_text").change(function() {
      var pwd_value = this.value;
      $.ajax({
        type: "POST",
        url: "{% url 'check-pwd' %}",
        data: { csrfmiddlewaretoken: "{{ csrf_token }}", pwd: pwd_value },
        dataType: "json",
        success: function(data) {
          if (data.status === "weak") {
            $("#ajax_response").text("Weak");
          } else if (data.status === "medium") {
            $("#ajax_response").text("Medium");
          } else {
            $("#ajax_response").text("Strong");
          }
        }
      });
    });
  });
</script>

Your urls.py file

urlpatterns = [
    url(r'^check/pwd$', check_pwd, name="check-pwd"),
]

Your views.py file.

from django.http import JsonResponse


def check_pwd(request):
    pwd = request.POST.get('pwd')
    if len(pwd) < 6:
        data = {
            'status': 'weak'
        }
    elif len(pwd) > 6 and len(pwd) < 10:
        data = {
            'status': 'medium'
        }
    else:
        data = {
            'status': 'strong'
        }
    return JsonResponse(data)

Now, to explain what is happening here, i'm using the event 'change' to monitor the password input field. The value from the field is captured and send to the url link with namespace 'check-pwd'. That link is tied to a python function which will process the password and evaluate whether it is weak, medium or strong based on the length. It will inturn return a status field with the corresponding values. Those values are checked in the success function and the value is then send to the paragraph element 'ajax_response'. Now, you could see the visual reponse to your typing.

So, thats one of the ways you could use ajax in a django project. Hope you guys learned something new and apply this to your own projects.

Thanks and have a great day !

Building your own template tags in django

Heinek Halwin — Sun, 01 Mar 2020 15:36:08 +0000

Hey Guys !

Well, in a previous blog i wrote about creating your own context variable. To take that a step further, why don't we create our own template tags. So, what is a template tag ? It is a built-in django function that returns an output.

Now, you might have some doubts as to why you would need a template tag instead of a context variable, since, they're both functions and they both return a value. Right? Well, if that thought didn't come to mind, the reason for creating your own template tag is that, you can actually pass a value to the function upon which you could do your processing, while you could not with the context variable.

Why and Where do you need your own template tags

Before we go and create our own template tags, first, you need to look in the django official documentation, there's a high probability that the template tag that you're looking for might be in there.

In this blog, i will consider my project to be an online shopping app and my models will include the products on sale and the corresponding reviews on those products. So, my models.py file will look like this.

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

class Product(models.Model):
    name = models.CharField(max_length=50)
    description = models.CharField(max_length=200)
    sold_by = models.ForeignKey(User)
    price = models.IntegerField()

    def __str__(self):
        return self.name


class Review(models.Model):
    content = models.CharField(max_length=100)
    reviewed_on = models.ForeignKey(Product)
    reviewed_by = models.ForeignKey(User)

    def __str__(self):
        return self.content

So, in my product listing page, i want to be able to view the products and the review count for each product there. You could write a ORM query for it in your views.py file but what if you need the same count in each of the dedicated product pages, you would have to repeat that code. Unless, you had a function which accepts the product id and returns the count of reviews of that specific product. You could use that function anywhere. This function is our template tags and we will be using it to solve this problem.

Creating your own template tags using the simple_tag

First, you need to create a folder inside your app called templatetags and create a file named _init_.py . This will initiliase our templatetags folder as a python package, basically, django will consider it as part of its own project folder architecture.

Secondly, lets create a python file with any name, for this blog, i'll name it product_tags.py. Now, we are going to be creating our own template tags using the simple_tag.

from django import template
from your_app.models import Product, Review

register = template.Library()

@register.simple_tag
def calc_review_count(product_id):
    product = Product.objects.get(id=product_id)
    reviews = Review.objects.filter(reviewed_on=product)
    return reviews.count()

Using our custom template tags in our templates

Now, your template tags is ready to be used in your html files. So lets create a ListView pretty quickly in my views.py file.

from django.views.generic import ListView
from .models import Product


class ProductListing(ListView):
    template_name = 'product_list.html'
    model = Product
    context_object_name = 'products'

Finally, lets go ahead and create our html file that i named product_list.html.

{% load product_tags %}  <!-- Loading the file we defined our template tags in -->

<div>
    <table>
        <thead>
             <tr>
                  <th>Name</th>
                  <th>Price</th>
                  <th>Sold By</th>
                  <th>Reviews</th>
             </tr>
        </thead>
        <tbody>
            {% for pdt in products %}
             <tr>
                  <td>pdt.name</td>
                  <td>pdt.price</td>
                  <td>pdt.sold_by</td>
                  <td>{% calc_review_count pdt.id %}</td> <!-- our template tag -->
             </tr>
             {% endfor %}
        </tbody>
    </table>
</div>

Now, in a url that you configured, our template will show us the product listing and the review count for each of those products. Do note that we do not need closing template tags for template tags created using the simple_tag.

So what did you think about creating your own template tags ? Where do you think, you can use this ? Let me know.

Thanks and Have a Great Day !

Customising the Admin Page in Django

Heinek Halwin — Sat, 22 Feb 2020 15:10:47 +0000

Hi all,

Is it customising or customizing ?? Well, thats not the point here. Have you ever wondered why your models in django admin page has only one column while the default user model has more than one ? Well, fear not. In this blog, i will show you how to customise your admin page to show more than one column.

Well, firstly you need to create to model to register in your django admin page. Go over to your models.py file in your app and create your model.

from django.db import models


class Student(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()
    nationality = models.CharField(max_length=30)

    def __str__(self):
        return self.name

Now, i acknowledge that the database is awful and its only for the sake of this blog. Now, we can go ahead and register this model in our admin.py file, so that we can view this in our admin page.

from django.contrib import admin
from .models import Student


admin.site.register(Student)

Now,if you looked in your admin page, your model would still be in a single column displaying only the names of the students.

Customising the admin page

Listing more values

For customising the admin page, all you need to do is modify the admin.py file.

For adding more columns and viewing the other values in the student model, all you need to do is.

from django.contrib import admin
from .models import Student


class StudentAdmin(admin.ModelAdmin):        
    list_display = ('id','name','age','nationality') #for displaying more values as columns

admin.site.register(Student, StudentAdmin)

Filtering from database values

Suppose, you have a lot of values and you want to filter the values based on some attribute from your model, you can do that too. In my case, i want to filter my values based on the age and nationality.

from django.contrib import admin
from .models import Student


class StudentAdmin(admin.ModelAdmin):        
    list_display = ('id','name','age','nationality') #for displaying more values as columns
    list_filter = ('age','nationality') #for filtering

admin.site.register(Student, StudentAdmin)

Now, you can filter your values. What if you wanted a customer filter, you can simply create your own filter as a function and add it to your list_filter tuple.

Performing custom action

One last customisation is the ability to perform a certain action from the dropdown in your admin page. All you need to do is write a function, which you can add to your ModelAdmin class.

from django.contrib import admin
from .models import Student


def student_function():
    do_something


class StudentAdmin(admin.ModelAdmin):        
    list_display = ('id','name','age','nationality') #for displaying more values as columns
    list_filter = ('age','nationality') #for filtering
    actions = [student_function] #custom actions

admin.site.register(Student, StudentAdmin)

Thats all ! Now, you have a custom action, column-wise view of your database values, filtering your database in your admin page.

Have a great day !

Using Context processor in Django to create dynamic footer

Heinek Halwin — Fri, 21 Feb 2020 15:39:45 +0000

Intro to Context Processor

Hi all,

We can all agree that we have come across request.user in a django project. Have you ever wondered what it was ? Well, its an inbuilt context processor.

A context processor is a function that accepts an argument and returns a dictionary as its output. In our case, the returning dictionary is added as the context and the biggest advantage is that, it can be accessed globally i.e, across all templates. While this might seem too complex or hard to achieve, its actually not the case and it is very simple to implement.

So, today we will look into building a dynamic footer using the context processor - a footer which can render the year dynamically, pretty convenient, when you dont have to change your source code every year. I'm assuming you have a django project and an app already built.

Building a dynamic footer using context processor

First, you need to create a file named context_processors.py. Here we will add the following code.

import datetime

def get_current_year_to_context(request):
    current_datetime = datetime.datetime.now()
    return {
        'current_year': current_datetime.year
    }

Second, you need to specify your context processor in your settings file.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                'myapp.context_processors.get_current_year_to_context', # <-- Add your context processor
            ],
        },
    },
]

Thats it. Your context processor is now ready to be used in your templates and it can be accessed using the key that we specified 'current_year'. So, to create a dynamic footer section, all i need to do is.

    Copyright {{ current_year }} - Heinek Halwin

Run your project and you can see that the year is now visible as the current year. Have fun using this in your projects.

Have a great day !