def test_invalid_values(self): """ If dictsortreversed is passed something other than a list of dictionaries, fail silently. """ self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '') self.assertEqual(dictsortreversed('Hello!', 'age'), '') self.assertEqual(dictsortreversed({'a': 1}, 'age'), '') self.assertEqual(dictsortreversed(1, 'age'), '')
def test_invalid_values(self): """ If dictsortreversed is passed something other than a list of dictionaries, fail silently. """ self.assertEqual(dictsortreversed([1, 2, 3], "age"), "") self.assertEqual(dictsortreversed("Hello!", "age"), "") self.assertEqual(dictsortreversed({"a": 1}, "age"), "") self.assertEqual(dictsortreversed(1, "age"), "")
def test_invalid_args(self): """Fail silently if invalid lookups are passed.""" self.assertEqual(dictsortreversed([{}], "._private"), "") self.assertEqual(dictsortreversed([{ "_private": "test" }], "_private"), "") self.assertEqual( dictsortreversed([{ "nested": { "_private": "test" } }], "nested._private"), "")
def sort_items_by_date(object_list, date_fields="date_published, timestamp, pub_date, date_submitted, date_created", recent_first=False): """ Given a list of heterogeneous items (instances from several different models) and a list of possible date field names, sort the items by date. Any items in the list without a date field attribute will be left out of the results. Defaults to most recent items last, but accepts a recent_first argument to reverse the chronology. """ date_field_list = date_fields.split(",") object_dict_list = [] for object in object_list: if object: object_date_field = None for field in date_field_list: for f in object._meta.fields: if f.name == field: object_date_field = f.name break if object_date_field: object_dict = { 'date': getattr(object, object_date_field), 'object': object } object_dict_list.append(object_dict) if recent_first: sorted_item_dicts = dictsortreversed(object_dict_list, 'date') else: sorted_item_dicts = dictsort(object_dict_list, 'date') sorted_items = [] for item in sorted_item_dicts: if item['object'] not in sorted_items: sorted_items.append(item['object']) return sorted_items
def tag_list(request): from django.views.generic.list_detail import object_list from django.template.defaultfilters import dictsortreversed tags = Tag.objects.all() tags_by_popularity = [] content_types = ContentType.objects.all() item_count = 0 for content_type in content_types: model = content_type.model_class() if hasattr(model, 'tags'): item_count = item_count + model.objects.all().count() ct_tags = Tag.objects.usage_for_model(model, counts=True) for tag in ct_tags: tags_by_popularity.append(tag) tags_by_popularity = dictsortreversed(tags_by_popularity, 'count') extra_context = { 'tagged_item_count': item_count, 'tags_by_popularity': tags_by_popularity, 'most_popular_tag': tags_by_popularity[0], } return object_list( request, queryset=tags, template_object_name='tag', template_name='sections/tag_list.html', extra_context=extra_context, )
def test_sort_list_of_tuple_like_dicts(self): data = [ { '0': 'a', '1': '42' }, { '0': 'c', '1': 'string' }, { '0': 'b', '1': 'foo' }, ] expected = [ { '0': 'c', '1': 'string' }, { '0': 'b', '1': 'foo' }, { '0': 'a', '1': '42' }, ] self.assertEqual(dictsortreversed(data, '0'), expected)
def test_sort(self): sorted_dicts = dictsortreversed( [ { "age": 23, "name": "Barbara-Ann" }, { "age": 63, "name": "Ra Ra Rasputin" }, { "name": "Jonny B Goode", "age": 18 }, ], "age", ) self.assertEqual( [sorted(dict.items()) for dict in sorted_dicts], [ [("age", 63), ("name", "Ra Ra Rasputin")], [("age", 23), ("name", "Barbara-Ann")], [("age", 18), ("name", "Jonny B Goode")], ], )
def test_sort_list_of_tuple_like_dicts(self): data = [ { "0": "a", "1": "42" }, { "0": "c", "1": "string" }, { "0": "b", "1": "foo" }, ] expected = [ { "0": "c", "1": "string" }, { "0": "b", "1": "foo" }, { "0": "a", "1": "42" }, ] self.assertEqual(dictsortreversed(data, "0"), expected)
def render(self, context): from django.template.defaultfilters import dictsortreversed try: tags = [] if self.model: app_label, model_name = self.model.split('.') content_types = [ContentType.objects.get(app_label=app_label, model=model_name)] else: content_types = ContentType.objects.all() item_count = 0 for content_type in content_types: model = content_type.model_class() if hasattr(model, 'tags'): item_count = item_count + model.objects.all().count() ct_tags = Tag.objects.usage_for_model(model, counts=True) for tag in ct_tags: tags.append(tag) context[self.varname] = dictsortreversed(tags, 'count')[:self.num] context['tagged_item_count'] = item_count except: pass return ''
def place_detail(request, country, city, place_slug, state=None, allow_empty=True): from django.views.generic.list_detail import object_detail if state: slug = slugify(city + " " + state + " " + country) else: slug = slugify(city + " " + country) try: city = City.objects.get(slug=slug) except: raise Http404 try: place = Place.objects.get(city=city, slug=place_slug) except: raise Http404 if "savoy.contrib.aggregator" in settings.INSTALLED_APPS: object_list = dictsortreversed(place.aggregator_items(), 'timestamp') else: object_list = sort_items_by_date(place.items(), recent_first=True) extra_context = { 'object_list' : object_list, } return object_detail( request, queryset = Place.objects.filter(city=city), template_name = 'geo/place_detail.html', template_object_name='place', slug_field = 'slug', slug = place_slug, extra_context = extra_context, )
def render(self, context): from string import punctuation from django.template.defaultfilters import dictsortreversed try: removelist = ["a", "an", "as", "at", "but", "by", "for", "from", "is", "in", "into", "of", "off", "on", "onto", "per", "since", "than", "the", "this", "that", "to", "up", "via", "with", "and", "it", "be", "was", "i","you","me","my","is","so", "some","it's","its","are","if","some","there", "what","just", ""] cat_statuses = "" for status in Status.objects.all(): cat_statuses += status.body + " " wordlist = cat_statuses.split() punctuation = punctuation.replace('@', '') wordlist = [word.strip(punctuation).lower() for word in wordlist] wordfreq = [wordlist.count(p) for p in wordlist] dictionary = dict(zip(wordlist,wordfreq)) word_dict_list = [] for key in dictionary: if key not in removelist and not key.startswith('@'): word_dict_list.append({ 'name': key, 'count': dictionary[key] }) context[self.varname] = dictsortreversed(word_dict_list, 'count')[:int(self.num)] except: pass return ''
def by_release_and_component_total(self, release, component): """ Return a list of the total translation by languages for a release and component """ from django.db import connection cursor = connection.cursor() cursor.execute("SELECT sum(t.trans), sum(t.fuzzy), "\ "sum(t.untrans), sum(t.total), t.language_id "\ "FROM pofile as t "\ "WHERE t.release_id=%s AND "\ "t.component_id=%s AND "\ "language_id is NOT NULL "\ "GROUP by language_id", [release.id, component.id]) postats = [] for row in cursor.fetchall(): l = Language.objects.get(id=row[4]) po = self.model(trans=row[0], fuzzy=row[1], untrans=row[2], total=row[3], filename=l.code, # Not used but needed language=l) po.calculate_perc() postats.append(po) return dictsortreversed(postats,'trans_perc')
def project_usage(request, project_id): project = get_object_or_404(Project, pid=project_id) if (not project.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) result = gen_cache_for_project(request, start, end, project) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) usage_list = [] total, total_jobs = 0, 0 # Custom SQL as need to get users that were removed from project too query = CPUJob.objects.filter(project=project, date__range=(start, end)) query = query.values('account').annotate().order_by('account') for row in query: u = Account.objects.get(id=row['account']).person time, jobs = usage.get_person_usage(u, project, start, end) if time: total += time total_jobs += jobs if jobs > 0: usage_list.append({'person': u, 'usage': time, 'jobs': jobs}) for u in usage_list: if total == 0: u['percent'] = 0 else: u['percent'] = (u['usage'] / total) * 100 usage_list = dictsortreversed(usage_list, 'usage') count = 0 for i in usage_list: i['colour'] = graphs.get_colour(count) count += 1 graph = graphs.get_project_trend_graph_url(project, start, end) return render(template_name='kgusage/project_usage.html', context=locals(), request=request)
def test_dictsortreversed(self): sorted_dicts = dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'}, {'age': 63, 'name': 'Ra Ra Rasputin'}, {'name': 'Jonny B Goode', 'age': 18}], 'age') self.assertEqual([sorted(dict.items()) for dict in sorted_dicts], [[('age', 63), ('name', 'Ra Ra Rasputin')], [('age', 23), ('name', 'Barbara-Ann')], [('age', 18), ('name', 'Jonny B Goode')]]) # If it gets passed a list of something else different from # dictionaries it should fail silently self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '') self.assertEqual(dictsortreversed('Hello!', 'age'), '') self.assertEqual(dictsortreversed({'a': 1}, 'age'), '') self.assertEqual(dictsortreversed(1, 'age'), '')
def project_usage(request, project_id, machine_category_id): machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) project = get_object_or_404(Project, pid=project_id) if not project.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return result result = gen_cache_for_project(request, start, end, project, machine_category) if result is not None: return result usage_list = [] total, total_jobs = 0, 0 # Custom SQL as need to get users that were removed from project too rows = CPUJob.objects.filter( project=project, machine__category=machine_category, date__range=(start, end) ).values('account').annotate().order_by('account') for row in rows: u = Account.objects.get(id=row['account']).person time, jobs = usage.get_person_usage(u, project, start, end, machine_category) if time: total += time total_jobs += jobs if jobs > 0: usage_list.append({'person': u, 'usage': time, 'jobs': jobs}) for u in usage_list: if total == 0: u['percent'] = 0 else: u['percent'] = (u['usage'] / total) * 100 usage_list = dictsortreversed(usage_list, 'usage') count = 0 for i in usage_list: i['colour'] = graphs.get_colour(count) count += 1 graph = graphs.get_project_trend_graph_url(project, start, end, machine_category) return render_to_response('usage/project_usage.html', locals(), context_instance=RequestContext(request))
def project_usage(request, project_id, machine_category_id=settings.DEFAULT_MC): machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) project = get_object_or_404(Project, pk=project_id) if not project.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') if project.machine_categories.count() == 1: machine_category = project.machine_categories.all()[0] usage_list = [] total, total_jobs = 0, 0 querystring = request.META.get('QUERY_STRING', '') start, end = get_date_range(request) start_str = start.strftime('%Y-%m-%d') end_str = end.strftime('%Y-%m-%d') mc_ids = tuple([(int(m.id)) for m in machine_category.machine_set.all()]) if len(mc_ids) == 1: mc_ids = "(%i)" % mc_ids[0] # Custom SQL as need to get users that were removed from project too cursor = connection.cursor() sql = "SELECT user_id from cpu_job where project_id = '%s' and `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' GROUP BY user_id" % (str(project.pid), mc_ids, start_str, end_str) cursor.execute(sql) rows = list(cursor.fetchall()) cursor.close() for uid in rows: u = UserAccount.objects.get(id=uid[0]).user time, jobs = u.get_usage(project, start, end) if time: total += time total_jobs += jobs if jobs > 0: usage_list.append({'user': u, 'usage': time, 'jobs': jobs}) for u in usage_list: if total == 0: u['percent'] = 0 else: u['percent'] = (u['usage'] / total) * 100 usage_list = dictsortreversed(usage_list, 'usage') count = 0 for i in usage_list: i['colour'] = get_colour(count) count += 1 graph = get_project_trend_graph_url(project, start, end, machine_category) return render_to_response('usage/project_usage.html', locals(), context_instance=RequestContext(request))
def test_sort_list_of_tuple_like_dicts(self): data = [ {'0': 'a', '1': '42'}, {'0': 'c', '1': 'string'}, {'0': 'b', '1': 'foo'}, ] expected = [ {'0': 'c', '1': 'string'}, {'0': 'b', '1': 'foo'}, {'0': 'a', '1': '42'}, ] self.assertEqual(dictsortreversed(data, '0'), expected)
def spot_list(request, queryset=Spot.objects.all(), template="spots/spot_list.html", relevant_to_spot=None, extra_context={}): """ Renders a list of spots. Defaults to all spots, but takes an optional QuerySet argument. If a Spot is passed to the "relevant_to_spot" argument, the output will include details as to the distance and direction of each spot from the relevant_to_spot. """ spots = queryset query = dict(request.REQUEST.items()) order_by = query.pop('order_by', '-date_created') # If a Django QS filter was submited with the request, apply it. if len(query): spots = spots.filter(**format_qs(query)) # If order_by was specified, apply it (unless it's distance -- we'll handle that later). if order_by: if not order_by == "-distance" and not order_by == "distance": spots = spots.order_by(*order_by.split(',')) # Create the spot dicts for rendering in templates. If relevant_to_spot was speficied, # include the distance and direction from that spot. if relevant_to_spot: spots = [ {'spot': spot, 'distance': relevant_to_spot._get_distance_to_spot(spot), 'direction': relevant_to_spot._get_compass_direction_to_spot(spot) } for spot in spots ] if order_by == '-distance': spots = dictsort(spots, 'distance') if order_by == 'distance': spots = dictsortreversed(spots, 'distance') else: spots = [ {'spot': spot, 'distance': None, 'direction': None } for spot in spots ] # Create a list of countries that have spots, for rendering in the templates. cities_with_spots = City.objects.filter(spots__isnull=False).distinct() countries = [] for city in cities_with_spots: for country in COUNTRY_CHOICES: if country[0] == city.country: country_dict = { 'code': city.country, 'name': country[1], 'url': reverse('spot_list_for_country', args=[city.country])} if country_dict not in countries: countries.append(country_dict) break # Build the breadcrumbs for this list. breadcrumbs, view_name = build_breadcrumbs() # Create the context and render the template. context = { 'spots': spots, 'order_by': order_by, 'view_name': view_name, 'countries': countries, } context.update(extra_context) return render_to_response(template, context, context_instance=RequestContext(request))
def update_characteristics(self, instance, **kwargs): """ When a Review item is saved, update the Beer's characteristics with the new data. """ from django.template.defaultfilters import dictsortreversed from ninetyseven.apps.reviews.models import Review from tagging.models import Tag beer = instance.beer reviews = Review.objects.filter(beer=beer) tags = Tag.objects.usage_for_queryset(reviews, counts=True) top_tags = dictsortreversed(tags, 'count')[:5] beer.characteristics = " ".join(tag.name for tag in top_tags) beer.save()
def popular_tags(request): poptags = Tag.objects.usage_for_model(Entry, counts=True, filters={'status': Entry.STATUS_OPEN}) poptags = dictsortreversed(poptags, 'count') if len(poptags) < 1: poptags_max = 0 else: poptags_max = poptags[0].count return { 'popular_tags': poptags, 'popular_tags_max': poptags_max, }
def test_sort(self): sorted_dicts = dictsortreversed( [{'age': 23, 'name': 'Barbara-Ann'}, {'age': 63, 'name': 'Ra Ra Rasputin'}, {'name': 'Jonny B Goode', 'age': 18}], 'age', ) self.assertEqual( [sorted(dict.items()) for dict in sorted_dicts], [[('age', 63), ('name', 'Ra Ra Rasputin')], [('age', 23), ('name', 'Barbara-Ann')], [('age', 18), ('name', 'Jonny B Goode')]], )
def mergetweets(posts, tweetsfeed, ptentries): elist = [] for p in posts: elist.append(p) for p in ptentries: elist.append(p) for t in tweetsfeed: elist.append({ 'date_published': t.date_published, 'byline': '', 'text': t.title[t.title.find(': ')+2:], 'twit': t.title[:t.title.find(': ')] }) elist = dictsortreversed(elist, 'date_published') return elist
def city_detail(request, country, city, state=None, allow_empty=True): from django.views.generic.list_detail import object_detail # Find the city we're dealing with based on its slug. if state: slug = slugify(city + " " + state + " " + country) else: slug = slugify(city + " " + country) try: city = City.objects.get(slug=slug) except: raise Http404 # Get the city and state name and code for inclusion in our template context. country_name = city.get_country_display() country_code = city.country if country == "us": state_name = city.get_state_display() state_code = city.state else: state_name = city.province state_code = slugify(city.province) if "savoy.contrib.aggregator" in settings.INSTALLED_APPS: object_list = dictsortreversed(city.aggregator_items(), 'timestamp') else: object_list = sort_items_by_date(city.items(), recent_first=True) extra_context = { 'country': country_name, 'country_code': country_code, 'state': state_name, 'state_code': state_code, 'object_list': object_list, } # Render a generic detail view. return object_detail( request, queryset = City.objects.all(), template_name = 'geo/city_detail.html', template_object_name='city', slug_field = 'slug', slug = slug, extra_context = extra_context, )
def render(self, context): from string import punctuation from django.template.defaultfilters import dictsortreversed try: cat_statuses = "" for status in Status.objects.all(): cat_statuses += status.body + " " wordlist = cat_statuses.split() punctuation = punctuation.replace('@', '') wordlist = [word.strip(punctuation).lower().replace("'s", '') for word in wordlist] wordfreq = [wordlist.count(p) for p in wordlist] dictionary = dict(zip(wordlist,wordfreq)) word_dict_list = [] for key in dictionary: if key.startswith('@'): word_dict_list.append({ 'name': key[1:], 'count': dictionary[key] }) context[self.varname] = dictsortreversed(word_dict_list, 'count')[:int(self.num)] except: pass return ''
def gen_project_graph(self, project, start, end, machine_category): """Generates a bar graph for a project Keyword arguments: project -- Project start -- start date end -- end date machine_category -- MachineCategory object """ today = datetime.date.today() start_str = start.strftime('%Y-%m-%d') end_str = end.strftime('%Y-%m-%d') start_t = start.strftime('%d/%m/%y') end_t = end.strftime('%d/%m/%y') fig = Figure(figsize=(6,3)) ax = fig.add_axes([0.2, 0.2, 0.7, 0.7]) period = (end-start).days ax.set_xlim(0,period+1) if period < 10: step = 1 elif period < 100: step = 20 else: step = 50 ax.set_xticks(arange(period+1, step=step)) #print drange(start, end, datetime.timedelta(days=2)) ax.set_title('%s %s - %s' % (project.pid, start_t, end_t)) ax.set_ylabel("CPU Time (hours)") ax.set_xlabel("Days") mc_ids = tuple([(int(m.id)) for m in machine_category.machine_set.all()]) if len(mc_ids) == 1: mc_ids = "(%i)" % mc_ids[0] t_start = start t_end = end b_total = 0 user_data = [] cursor = connection.cursor() SQL = "SELECT user_id from cpu_job where project_id = '%s' and `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' GROUP BY user_id" % (str(project.pid), mc_ids, start_str, end_str) cursor.execute(SQL) rows = list(cursor.fetchall()) cursor.close() for uid in rows: try: ua = UserAccount.objects.get(id=uid[0]) except UserAccount.DoesNotExist: # Usage is from an unknown user. continue u = ua.user cursor = connection.cursor() SQL = "SELECT date, SUM( cpu_usage ) FROM `cpu_job` WHERE `project_id` LIKE '%s' AND `user_id` = %s AND `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' Group By date" % (str(project.pid), str(ua.id), mc_ids, start_str, end_str) cursor.execute(SQL) rows = dict(cursor.fetchall()) if rows: data, dates_y, labels = [], [], [] start = t_start end = t_end while start <= end: if start != today: try: total = float(rows[start]) except: total = 0 data.append(total / 3600.00) labels.append(str(start)) b_total += total start = start + datetime.timedelta(days=1) user_data.append({'user': u, 'data': data, 'total': sum(data)}) #print ua.user #print data #print '-----' #print 'prev: %s ' % prev_data #ax.bar(dates, data, color=colours[count], edgecolor=colours[count]) #prev_data = data #print b_total/ 3600 count = 0 prev_data = None # majloc = dates.AutoDateLocator() # majfmt = dates.AutoDateFormatter(majloc) # ax.xaxis.set_major_locator(majloc) # ax.xaxis.set_major_formatter(majfmt) user_data = dictsortreversed(user_data, 'total') user_data = [d['data'] for d in user_data] for data in user_data: x_data = range(1, len(data) + 1) if prev_data: ax.bar(x_data, data, color=get_colour(count), edgecolor=get_colour(count), bottom=prev_data, align='center') p = 0 while p < len(prev_data): prev_data[p] += data[p] p += 1 else: ax.bar(x_data, data, color=get_colour(count), edgecolor=get_colour(count), align='center') prev_data = data count += 1 canvas = FigureCanvasAgg(fig) canvas.print_figure("%s/projects/%s_%s-%s_%i.png" % (str(settings.GRAPH_ROOT), str(project.pid), str(start_str), str(end_str), machine_category.id))
def test_sort_list_of_tuples(self): data = [("a", "42"), ("c", "string"), ("b", "foo")] expected = [("c", "string"), ("b", "foo"), ("a", "42")] self.assertEqual(dictsortreversed(data, 0), expected)
def search( request, template_name="aggregator/search.html", template_loader=loader, extra_context=None, context_processors=None, mimetype=None, ): """ ContentItem search. Works a bit like a generic view in that you can pass a bunch of optional keyword arguments which work just like they do in generic views. Those arguments are: ``template_name``, ``template_loader``, ``extra_context``, ``context_processors``, and ``mimetype``. Templates: ``aggregator/search.html`` (default) Context: ``search_string`` The search string, as the user entered it ``search_terms`` A list of all terms searched ``items`` Search results, ordered by most recent first ``hits`` An integer representing the number of search results ``all_content_types`` List of all ContentTypes objects available to the aggregator ``content_types`` List of ContentTypes objects used to render this page ``model_string`` String representation of models appearing on this page (useful as a cache key argument) """ # Create search terms list. if request.GET.__contains__("search"): search_string = request.GET["search"] # First, split on double-quotes to extract any multi-word terms search_terms = search_string.split('"') cleaned_search_terms = [] # Then, remove any unnecessary whitespace at the beginings or ends of the terms for item in search_terms: if not item.startswith(" ") and not item.endswith(" ") and not item == "": cleaned_search_terms.append(item) if item.startswith(" "): cleaned_search_terms.append(item[1:]) if item.endswith(" "): cleaned_search_terms.append(item[:-1]) # Filtering by model model_query = request.GET.get("models", "default") model_query_list = request.GET.getlist("models") if model_query == "default": content_types = get_aggregator_content_types(type_set="default") model_list = [ct.app_label + "." + ct.model for ct in content_types] model_string = "default" elif model_query == "all": model_string = "all" content_types = get_aggregator_content_types(type_set="all") else: model_string = ",".join(model_query_list) model_list = model_query_list content_types = [] for item in model_list: for model in settings.AGGREGATOR_MODELS: if item == model["model"]: app_label = item.split(".")[0] model = item.split(".")[1] content_type = ContentType.objects.get(app_label=app_label, model=model) content_types.append(content_type) # Set up a list to put results into search_results = [] # Search each model for the search terms for content_type in content_types: content_type_string = content_type.app_label + "." + content_type.model model = content_type.model_class() manager = model._default_manager opts = model._meta query = Q() queries = [] for model in settings.AGGREGATOR_MODELS: if content_type_string == model["model"]: search_fields = model["search_fields"] for term in cleaned_search_terms: for field in search_fields: lookup = field + "__icontains" kwargs = {lookup: term} q = Q(**kwargs) queries.append(q) for q in queries: query = query | q results = manager.filter(query) # Create a list of primary keys for each item in the results, then use that list to get a # QuerySet of associated ContentItem objects. Append the results of that QuerySet to the # search_results list. result_pks = [i["pk"] for i in results.values("pk")] result_content_items = ContentItem.objects.filter(content_type=content_type, object_id__in=result_pks) search_results.extend(result_content_items) items = dictsortreversed(search_results, "timestamp") else: cleaned_search_terms = [] search_string = "" items = [] content_types = [] model_string = "" hits = 0 # Build the context context = RequestContext( request, { "search_terms": cleaned_search_terms, "search_string": search_string, "items": items, "all_content_types": get_aggregator_content_types(type_set="all"), "content_types": content_types, "model_string": model_string, "hits": len(items), }, context_processors, ) if extra_context: for key, value in extra_context.items(): if callable(value): context[key] = value() else: context[key] = value # Load, render, and return t = template_loader.get_template(template_name) return HttpResponse(t.render(context), mimetype=mimetype)
def test_sort_list_of_tuples(self): data = [('a', '42'), ('c', 'string'), ('b', 'foo')] expected = [('c', 'string'), ('b', 'foo'), ('a', '42')] self.assertEqual(dictsortreversed(data, 0), expected)
def test_invalid_args(self): """Fail silently if invalid lookups are passed.""" self.assertEqual(dictsortreversed([{}], '._private'), '') self.assertEqual(dictsortreversed([{'_private': 'test'}], '_private'), '') self.assertEqual(dictsortreversed([{'nested': {'_private': 'test'}}], 'nested._private'), '')