[Solved]-Display objects from different models at the same page according to their published date

The following should do want you need. But to improve performance you can create an extra type field in each of your models so the annotation can be avoided.

Your view will look something like:

from django.db.models import CharField

def home(request):
    # annotate a type for each model to be used in the template
    tenders = Tender.object.all().annotate(type=Value('tender', CharField()))
    jobs = Job.object.all().annotate(type=Value('job', CharField()))
    news = News.object.all().annotate(type=Value('news', CharField()))

    all_items = list(tenders) + list(jobs) + list(news)

    # all items sorted by publication date. Most recent first
    all_items_feed = sorted(all_items, key=lambda obj: obj.pubdat)

    return render(request, 'home.html', {'all_items_feed': all_items_feed})

In your template, items come in the order they were sorted (by recency), and you can apply the appropriate html and styling for each item by distinguishing with the item type:

# home.html
{% for item in all_items_feed %}
    {% if item.type == 'tender' %}
    {% comment "html block for tender items" %}{% endcomment %}

    {% elif item.type == 'news' %}
    {% comment "html block for news items" %}{% endcomment %}

    {% else %}
    {% comment "html block for job items" %}{% endcomment %}

    {% endif %}
{% endfor %}

You may avoid the annotation altogether by using the __class__ attribute of the model objects to distinguish and put them in the appropriate html block.

For a Tender object, item.__class__ will be app_name.models.Tender where app_name is the name of the Django application containing the model.

So without using annotations in your home view, your template will look:

{% for item in all_items_feed %}
    {% if item.__class__ == 'app_name.models.Tender' %}

    {% elif item.__class__ == 'app_name.models.News' %}
     ...
    {% endif %}
{% endfor %}

With this, you save extra overhead on the annotations or having to modify your models.

A straight forward way is to use chain in combination with sorted:

View

# your_app/views.py
from django.shortcuts import render
from itertools import chain
from models import Tender, Job, News

def feed(request):

    object_list = sorted(chain(
        Tender.objects.all(),
        Job.objects.all(),
        News.objects.all()
    ), key=lambda obj: obj.pubdat)

    return render(request, 'feed.html', {'feed': object_list})

Please note – the querysets mentioned above using .all() should be understood as placeholder. As with a lot of entries this could be a performance issue. The example code would evaluate the querysets first and then sort them. Up to some hundreds of records it likely will not have a (measurable) impact on performance – but in a situation with millions/billions of entries it is worth looking at.

To take a slice before sorting use something like:

Tender.objects.all()[:20]

or use a custom Manager for your models to off-load the logic.

class JobManager(models.Manager):
    def featured(self):
        return self.get_query_set().filter(featured=True)

Then you can use something like:

Job.objects.featured()

Template

If you need additional logic depending the object class, create a simple template tag:

#templatetags/ctype_tags.py
from django import template
register = template.Library()

@register.filter
def ctype(value):
    return value.__class__.__name__.lower()

and

#templates/feed.html
{% load ctype_tags %}

<div>
    {% for item in feed reversed %}
    <p>{{ item|ctype }} - {{ item.title }} - {{ item.pubdat }}</p>
    {% endfor %}
</div>

Bonus – combine objects with different field names

Sometimes it can be required to create these kind of feeds with existing/3rd party models. In that case you don’t have the same fieldname for all models to sort by.

DATE_FIELD_MAPPING = {
    Tender: 'pubdat',
    Job: 'publish_date',
    News: 'created',
}

def date_key_mapping(obj):
    return getattr(obj, DATE_FIELD_MAPPING[type(obj)])


def feed(request):
    object_list = sorted(chain(
        Tender.objects.all(),
        Job.objects.all(),
        News.objects.all()
    ), key=date_key_mapping)

Do I make a separate model e.g. class Post and then use signal to
create a new post whenever a new object is created from Tender, or
Job, or News? I really hope there is a better way to achieve this. Or
do I use multi-table inheritance?

I don’t want to show each of the model objects separately at the same
page. But like feeds of facebook or any other social media.

I personally don’t see anything wrong using another model, IMHO its even preferable to use another model, specially when there is an app for that.

Why? Because I would never want to rewrite code for something which can be achieved by extending my current code. You are over-engineering this problem, and if not now, you are gonna suffer later.

An alternative solution would be to use Django haystack:

• http://haystacksearch.org/
• http://django-haystack.readthedocs.io/en/v2.4.1/

It allows you to search through unrelated models. It’s more work than the other solutions but it’s efficient (1 fast query) and you’ll be able to easily filter your listing too.

In your case, you will want to define pubdate in all the search indexes.

I cannot test it right now, but you should create a model like:

class Post(models.Model):

    pubdat = models.DateTimeField(default=timezone.now)
    tender = models.ForeignKey('Tender')
    job = models.ForeignKey('Job')
    news = models.ForeignKey('News')

Then, each time a new model is created, you create a Post as well and relate it to the Tender/Job/News. You should relate each post to only one of the three models.

Create a serializer for Post with indented serializers for Tender, Job and News.

Sorry for the short answer. If you think it can work for your problem, i’ll write more later.