Implementes an advanced search feature, which allows for individual field terms

apps/dynamic_search/api.py

@@ -9,34 +9,31 @@ from django.db.models import Q
 
 from dynamic_search.conf.settings import LIMIT
 
-search_list = {}
+registered_search_dict = {}
 
 
-def register(model, text, field_list):
-    if model in search_list:
-        search_list[model]['fields'].append(field_list)
-    else:
-        search_list[model] = {'fields': field_list, 'text': text}
+def register(model_name, model, title, fields):
+    registered_search_dict.setdefault(model_name, {'model': model, 'fields': [], 'title': title})
+    registered_search_dict[model_name]['fields'].extend(fields)
 
 
 def normalize_query(query_string,
                     findterms=re.compile(r'"([^"]+)"|(\S+)').findall,
                     normspace=re.compile(r'\s{2,}').sub):
-    """ Splits the query string in invidual keywords, getting rid of unecessary spaces
-        and grouping quoted words together.
-        Example:
-
+    """
+    Splits the query string in invidual keywords, getting rid of unecessary spaces
+    and grouping quoted words together.
+    Example:
         >>> normalize_query('  some random  words "with   quotes  " and   spaces')
         ['some', 'random', 'words', 'with quotes', 'and', 'spaces']
-
     """
     return [normspace(' ', (t[0] or t[1]).strip()) for t in findterms(query_string)]
 
 
 def get_query(terms, search_fields):
     """
-        Returns a query, that is a combination of Q objects. That combination
-        aims to search keywords within a model by testing the given search fields.
+    Returns a query, that is a combination of Q objects. That combination
+    aims to search keywords within a model by testing the given search fields.
     """
     queries = []
     for term in terms:
@@ -58,21 +55,55 @@ def get_query(terms, search_fields):
 
         queries.append(or_query)
     return queries
+    
 
-
-def perform_search(query_string):
+def perform_search(query_string, field_list=None):
     model_list = {}
     flat_list = []
     result_count = 0
     shown_result_count = 0
     elapsed_time = 0
+    start_time = datetime.datetime.now()
+
+    search_dict = {}
 
     if query_string:
-        start_time = datetime.datetime.now()
-        terms = normalize_query(query_string)
+        simple_query_string = query_string.get('q', u'').strip()
+        if simple_query_string:
+            for model, values in registered_search_dict.items():
+                search_dict.setdefault(values['model'], {'query_entries': [], 'title': values['title']})
+                field_names = [field['name'] for field in values['fields']]
+                # One entry, single set of terms for all fields names
+                search_dict[values['model']]['query_entries'].append(
+                    {
+                        'field_name': field_names,
+                        'terms': normalize_query(simple_query_string)
+                    }
+                )
+        else:
+            for key, value in query_string.items():
+                try:
+                    model, field_name = key.split('__', 1)
+                    model_entry = registered_search_dict.get(model, {})
+                    if model_entry:
+                        for model_field in model_entry.get('fields', [{}]):
+                            if model_field.get('name') == field_name:
+                                search_dict.setdefault(model_entry['model'], {'query_entries': [], 'title': model_entry['title']})
+                                search_dict[model_entry['model']]['query_entries'].append(
+                                    {
+                                        'field_name': [field_name],
+                                        'terms': normalize_query(value.strip())
+                                    }
+                                )
+                except ValueError:
+                    pass
 
-        for model, data in search_list.items():
-            queries = get_query(terms, data['fields'])
+        for model, data in search_dict.items():
+            title = data['title']
+            queries = []
+            
+            for query_entry in data['query_entries']:
+                queries.extend(get_query(query_entry['terms'], query_entry['field_name']))
 
             model_result_ids = None
             for query in queries:
@@ -84,14 +115,24 @@ def perform_search(query_string):
                 else:
                     model_result_ids &= single_result_ids
 
+            if model_result_ids == None:
+                model_result_ids = []
+                
             result_count += len(model_result_ids)
             results = model.objects.in_bulk(list(model_result_ids)[: LIMIT]).values()
             shown_result_count += len(results)
             if results:
-                model_list[data['text']] = results
+                model_list[title] = results
                 for result in results:
                     if result not in flat_list:
                         flat_list.append(result)
+                        
         elapsed_time = unicode(datetime.datetime.now() - start_time).split(':')[2]
 
-    return model_list, flat_list, shown_result_count, result_count, elapsed_time
+    return {
+        'model_list': model_list,
+        'flat_list': flat_list,
+        'shown_result_count': shown_result_count,
+        'result_count': result_count,
+        'elapsed_time': elapsed_time
+    }