Django : global search in different model - Post result does not appears

Disclaimer: This answer may not fit in the OP's views or models, but, it will work as-is with the examples.

For the sake of clarity, I am assuming we have two models, Musician and Album which are located in the sample app.

# sample/models.py

from django.db import models


class Musician(models.Model):
    name = models.CharField(max_length=50)

    def __str__(self):
        return f'{self.name}'


class Album(models.Model):
    artist = models.ForeignKey(Musician, on_delete=models.CASCADE)
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return f'{self.name} : {self.artist}'

Then, we have to create a mixin class, for a better OOP experience as well as for the extensibility across multiple views.

#sample/mixins.py

from django.apps import apps
from django.db.models import Q
from functools import reduce
from operator import or_


class SearchMixin:
    search_keyword_arg = 'q'
    search_settings = {}
    lookup_expr = 'icontains'

    def get_search_term(self):
        return self.request.GET.get(self.search_keyword_arg)

    def build_search_query(self, model_ref, term):
        return reduce(or_, [Q(**{f'{field}__{self.lookup_expr}': term}) for field in self.search_settings[model_ref]])

    def get_search_results(self):
        has_search_result = False
        search_term = self.get_search_term()
        if not search_term:
            return {'has_search_result': has_search_result}

        results = {}

        for model_ref, fields in self.search_settings.items():
            app_name, model_str = model_ref.split('.')
            ModelKlass = apps.get_model(app_label=app_name, model_name=model_str)
            qs = ModelKlass.objects.filter(self.build_search_query(model_ref, search_term))
            results[model_ref.replace('.', '_').lower()] = qs
            if has_search_result is False and qs.exists():
                has_search_result = True

        results['has_search_result'] = has_search_result
        return results

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['search_result'] = self.get_search_results()
        return context

This SearchMixin class have the search functionality that we want. We can add this class to any Django view to get the result.

For that, we are inheriting the SearchMixin clas to a ListView as,

# sample/views.py

from django.views.generic import TemplateView
from sample.mixins import SearchMixin


class GlobalSearchView(SearchMixin, TemplateView):
    template_name = 'sample/global_search.html'
    search_settings = {
        'sample.Musician': ['name'],
        'sample.Album': ['name', 'description'],
    }

Notes:

• I have used a TemplateView which is more suitable in this particular case.
• There is a new class attribute named search_settings which is used to determine the search fields.

How the search_settings attribute should be?

• It must be a dict (or dict like object)

• The key of the dict object should be in the app_name.ModelClassName format

• value of the dict must be an iterable of model fields

How does it look like in the template?
The SearchMixin class adding the search results to a context variable named search_result and which has another variable has_search_result (search_result.has_search_result) which can be used to check whether we have got "any match".

Also, each QuerySets are accessible by separate variables. The format of the variable is, app_name<underscore><model_name_in_lower_case>.

For example, for the sample.Musician model, the search results can be obtained (if any) in template as, {{ search_result.sample_musician }}

# sample/templates/sample/global_search.html

{% if search_result.has_search_result %}
    <strong>Musician result</strong><br>
    {% for musician in search_result.sample_musician %}<br>
        {{ musician.name }}
    {% endfor %}
    <br><br>
    <strong>Album result</strong><br>
    {% for album in search_result.sample_album %}
        {{ album.name }} -- {{ album.description }}<br>
    {% endfor %}
{% else %}
    No match
{% endif %}

Now, connect the view in urls.py and search the by using the query parameter as,

/foo-bar/global-search/?q=xx

I think it's better to put everything in get_context_data like that:

 # global search 
class GlobalSearchView(ListView):
    template_name = 'search_global.html'
    count = 0
    countnutri = 0
    
    def get_context_data(self, *args, **kwargs):
        context = super().get_context_data(*args, **kwargs)
        context['count'] = self.count or 0
        context['countnutri'] = self.countnutri or 0
        query = self.request.GET.get('q', None)
        context['query'] = query
        if query:
            nutriscore = Post.objects.filter(
                Q(title__icontains=query) | Q(slug__icontains=query) | Q(typederepas__name__icontains=query) | Q(prixrepas__name__icontains=query) | Q(vitesserepas__name__icontains=query) | Q(force__name__icontains=query) | Q(bienfaitrepas__name__icontains=query)
            ).distinct()
            user = UserProfile.objects.filter(
                Q(pays__icontains=query) | Q(town__icontains=query) | Q(user__username__icontains=query) | Q(mealtrend__name__icontains=query) | Q(pricetrend__name__icontains=query) | Q(speedtrend__name__icontains=query)| Q(strengthtrend__name__icontains=query) | Q(wellnesstrend__name__icontains=query)
            ).distinct()
            context['results'] = chain(nutriscore,user)
        return context

Then you can use results variable in your template

you have 3 return statements, so only the 1st on will be executed:

            return qs  # return user
            return qn  # return nutriscore / NOT EXECUTED
            return results  # return results / NOT EXECUTED

you should keep only return results.

if you really want to return the 3 items, return as a tuple:

            return qa, qn, results