def article(request, category=None, article=None): category = get_object_or_404(Category, slug=category) article = get_object_or_404(Article, slug=article, category=category) if article.status != Article.STATUS.live \ and not request.user.has_perm('suave_press.view_article'): raise Http404 posts = article.posts.all() cache_tree_children(posts) return render(request, 'suave_press/article.html', dict( category=category, article=article, posts=posts ))
def get_list(self, request, **kwargs): base_bundle = self.build_bundle(request=request) objects = self.obj_get_list(bundle=base_bundle, **self.remove_api_resource_names(kwargs)) sorted_objects = self.apply_sorting(objects, options=request.GET) paginator = self._meta.paginator_class( request.GET, sorted_objects, resource_uri=self.get_resource_uri(), limit=self._meta.limit, max_limit=self._meta.max_limit, collection_name=self._meta.collection_name ) to_be_serialized = paginator.page() from mptt.templatetags.mptt_tags import cache_tree_children objects = cache_tree_children(objects) bundles = [] for obj in objects: data = self.get_child_data(obj) bundle = self.build_bundle(data=data, obj=obj, request=request) bundles.append(self.full_dehydrate(bundle)) to_be_serialized[self._meta.collection_name] = bundles to_be_serialized = self.alter_list_data_to_serialize(request, to_be_serialized) return self.create_response(request, to_be_serialized)
def tree(self, request, pk=None): obj = self.get_object() qs = StructureUnit.objects.filter(structure=obj).select_related( 'type__structure_type', ).prefetch_related( 'identifiers', 'notes', 'structure__tagstructure_set', 'structure_unit_relations_a', ).annotate( tag_leaf_node=~Exists( TagVersion.objects.filter( tag__structures__structure=OuterRef('structure'), tag__structures__structure_unit=OuterRef('pk'), ).for_user(request.user), ) ) root_nodes = cache_tree_children(qs) dicts = [] context = self.get_serializer_context() for n in root_nodes: dicts.append(mptt_to_dict(n, StructureUnitSerializer, context=context)) return Response(dicts)
def tree(self): _categories = self.categories.all() dict_child = cache_tree_children(_categories) tree = [] for child in dict_child: tree.append(Category.recursive_categories(child)) return tree
def poi_json_tree(request, format=None): def recursive_node_to_dict(node): result = collections.OrderedDict() result['id'] = node.pk result['name'] = node.cat_name_en result['name_en'] = node.cat_name_en result['name_de'] = node.cat_name_de result['icon'] = node.icon result['selectedIcon'] = node.icon_css_name + "_active" if node.pk in (1,2,3,4,5): result['selectable'] = False # result['state'] = {"checked": False, "disabled": True, "expanded": False, "selected": False} children = [recursive_node_to_dict(c) for c in node.get_children()] if children: result['children'] = children return result root_nodes = cache_tree_children(PoiCategory.objects.filter(enabled=True)) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return Response(dicts)
def get_list(self, request, **kwargs): base_bundle = self.build_bundle(request=request) objects = self.obj_get_list(bundle=base_bundle, **self.remove_api_resource_names(kwargs)) sorted_objects = self.apply_sorting(objects, options=request.GET) paginator = self._meta.paginator_class( request.GET, sorted_objects, resource_uri=self.get_resource_uri(), limit=self._meta.limit, max_limit=self._meta.max_limit, collection_name=self._meta.collection_name ) to_be_serialized = paginator.page() from mptt.templatetags.mptt_tags import cache_tree_children objects = cache_tree_children(objects) bundles = [] for obj in objects: data = self.get_child_data(obj) bundle = self.build_bundle(data=data, obj=obj, request=request) bundles.append(self.full_dehydrate(bundle)) to_be_serialized[self._meta.collection_name] = bundles to_be_serialized = self.alter_list_data_to_serialize(request, to_be_serialized) return self.create_response(request, to_be_serialized)
def filter_queryset(self, request, queryset, view): queryset = service.Service.objects.get_queryset_descendants( queryset, include_self=True).prefetch_related('labels') queryset = service.Service.objects.get_queryset_ancestors( queryset, include_self=True).prefetch_related('labels') queryset = cache_tree_children(queryset) return queryset
def translations(request, class_number): def shown_children(frameset): if frameset.removed: pass else: yield frameset # it it doesn't work anymore, replace with frameset.children.all() for child_frameset in frameset._cached_children: yield from shown_children(child_frameset) all_members, dicovalence_translations, other_translations = [], set(), set() active_class = LevinClass.objects.prefetch_related( 'verbnetclass_set', 'verbnetclass_set__verbnetframeset_set', 'verbnetclass_set__verbnetframeset_set__verbnetmember_set').get(number=class_number) for vn_class in active_class.verbnetclass_set.all(): # it it doesn't work anymore, replace with vn_class.verbnetframeset_set.get(parent=None) root_frameset = cache_tree_children(vn_class.verbnetframeset_set.all())[0] for frameset in shown_children(root_frameset): all_members.extend([m.lemma for m in frameset.verbnetmember_set.all()]) for m in all_members: for t in verb_dict.get(m, []): if t in dicovalence_verbs: dicovalence_translations.add(t) else: other_translations.add(t) return render(request, 'translations.html', { 'active_class': active_class, 'dicovalence_translations': sorted(dicovalence_translations, key=locale.strxfrm), 'other_translations': sorted(other_translations, key=locale.strxfrm), })
def render(self, context): queryset = self.queryset_var.resolve(context) roots = cache_tree_children(queryset) bits = [] for index, node in enumerate(roots): bits.append(self._render_node(context, node, len(roots), roots.index(node))) return ''.join(bits)
def render_tag(self, context, nested, kwargs, pre_node, node, post_node): current = None categories = None if 'current' in kwargs: current = kwargs.pop('current') cache_key = False output = None if template_cache is not None and template_cache.supports_tags(): cache_key = make_template_fragment_key( 'categories', [ nested, current, str(pre_node + node + post_node) ] ) output = template_cache.get(cache_key) if output is None: # Query categories if nested: categories = Category.objects.all() else: categories = Category.objects.root_nodes().flat_ordered() if nested: categories = cache_tree_children(categories) output = self._render_categories( context, nested, categories, current, pre_node, node, post_node ) if cache_key: template_cache.set(cache_key, output, tags=['categories']) return output
def get_json(self): root_nodes = cache_tree_children(self.get_family()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return dicts
def get_root_categories(context): request = context["request"] language = get_language() roots = cache_tree_children( Category.objects.all_visible( customer=request.customer, shop=request.shop, language=language)) return roots
def make_tree_by_root_nodes(root_nodes, fields=None): """ root_nodes: pодительские элементы fields: поля для сериализации """ nodes = cache_tree_children(root_nodes) return [_node_to_dict(n, fields=fields) for n in nodes]
def render(self, context): bits = [] add_nav = context.get('additional_navigation') if add_nav: bits += [self._render_node(context, node) for node in add_nav] roots = cache_tree_children(self.queryset) bits += [self._render_mptt_node(context, node) for node in roots] return ''.join(bits)
def get_jsontree(request): root_nodes = cache_tree_children(YewuTreeMptt.objects.all()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) jsonTree = demjson.encode(dicts) return JsonResponse({"msg":"success", "code": 0, "data": jsonTree})
def render(self, context): cl = self.cl_var.resolve(context) assert isinstance( cl, ChangeList ), "cl variable should be an admin ChangeList" # Also assists PyCharm roots = cache_tree_children(cl.result_list) bits = [self._render_node(context, cl, node) for node in roots] return ''.join(bits)
def get_categories(): root = Category.objects._mptt_filter(level=0) root_nodes = cache_tree_children(root.get_descendants()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) jsonTree = json.dumps(dicts, indent=4) return jsonTree
def get_root_categories(context): request = context["request"] language = get_language() roots = cache_tree_children( Category.objects.all_visible( customer=request.customer, shop=request.shop, language=language)) cache_translations_for_tree(roots, languages=[language]) return roots
def list(self, request, *args, **kwargs): qs = self.filter_queryset(self.get_queryset()) root_nodes = cache_tree_children(qs) dicts = [] for n in root_nodes: dicts.append(mptt_to_dict(n, LocationSerializer)) return Response(dicts)
def data_org_structure(self): # Return the current org structure, excluding inactive OrgUnits. return [ recursive_node_to_dict( cache_tree_children( dept.get_descendants_active(include_self=True))[0]) for dept in OrgUnit.objects.filter(unit_type=0, active=True).order_by('name') ]
def get_tree(self, obj): nodes = mptt_tags.cache_tree_children( obj.root_node.get_descendants(include_self=True)) result = [] for node in nodes: result.append(self.recursive_node_to_dict(node)) return result
def categories_tree(self): from channels.serializers import SimpleChannelCategorySerializer queryset = cache_tree_children(self.categories.all()) categories = [] for category in queryset: categories.append( recursive_mptt_to_dict(category, SimpleChannelCategorySerializer)) return categories
def get_tree_json(m, search=None): queryset = m.objects.all() if search: queryset = queryset.filter(name__contains=search) root_nodes = cache_tree_children(queryset) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return dicts
def noteMenu(request, project_id): project = Project.objects.get(id=project_id) root_nodes = cache_tree_children(Note.objects.filter(project=project)) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return HttpResponse(json.dumps(dicts, indent=4), content_type='application/json')
def get_tree(node_model_instances, values, containermode): # get all the mptt data and cache it in root_nodes root_nodes = cache_tree_children(node_model_instances) dicts = [] # Iterate over all nodes and for n in root_nodes: dicts.append(recursive_node_to_dict(n, values, containermode)) return dicts
def tree(self, request, pk=None): obj = self.get_object() qs = StructureUnit.objects.filter(structure=obj) root_nodes = cache_tree_children(qs) dicts = [] for n in root_nodes: dicts.append(mptt_to_dict(n, StructureUnitSerializer)) return Response(dicts)
def generate_tree(): """ Traverses a node tree and builds a structure easily serializable as JSON. """ roots = cache_tree_children(Category.tree.all()) if roots: # Assume we have one tree for now, this could change if we decide # against storing the root node in the DB return _recurse_tree(roots[0]) return {}
def get_list(self, request, **kwargs): base_bundle = self.build_bundle(request=request) objects = self.obj_get_list(bundle=base_bundle, **self.remove_api_resource_names(kwargs)) objects = cache_tree_children(objects) bundles = [] for obj in objects: data = self.get_child_data(obj) bundle = self.build_bundle(data=data, obj=obj, request=request) bundles.append(self.full_dehydrate(bundle)) return self.create_response(request, bundles)
def get_page_json_tree(queryset=None): """ :param queryset: :return: """ root_nodes = cache_tree_children(queryset) nodes = [] for n in root_nodes: nodes.append(recursive_node_to_dict(n)) return nodes
def yewutree2(request): root_nodes = cache_tree_children(YewuTree.objects.all()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) jsonTree = json.dumps(dicts, indent=6) yewu = YewuTree.objects.all() return render(request, 'cmdb/yewutree/yewu_base.html', locals())
def get(self, request, *args, **kwargs): # We can't force queryset evaluation here else it will mess the tree # resolution from mptt page_list = models.Page.objects.filter(visible=True) context = {"page_list": page_list, "json_tree": []} # Fill the JSON tree if there is at least one entry if page_list.count() > 0: context["json_tree"] = json.dumps(self.get_recursed_tree(cache_tree_children(page_list))) return self.render_to_response(context)
def tree_json(request): """Json view for the tree page.""" import json from mptt.templatetags.mptt_tags import cache_tree_children root_nodes = cache_tree_children(Comic.objects.filter(active=True)) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) root = { 'name': 'corpsey', 'children': dicts, } return HttpResponse(json.dumps(root, indent=4), mimetype="application/json")
def test_cache_tree_children_caches_parents(self): """ Ensures that each node's parent is cached by ``cache_tree_children``. """ # Ensure only 1 query is used during this test with self.assertNumQueries(1): roots = cache_tree_children(Category.objects.all()) games = roots[0] wii = games.get_children()[0] wii_games = wii.get_children()[0] # Ensure that ``wii`` is cached as ``parent`` on ``wii_games``, and # likewise for ``games`` being ``parent`` on the attached ``wii`` self.assertEqual(wii, wii_games.parent) self.assertEqual(games, wii_games.parent.parent)
def initLayersTree(request): try: root_node = Folder.objects.get(created_by=request.user, category='layers') nodes = root_node.get_descendants(include_self=True) node_tree = cache_tree_children(nodes) for n in node_tree: data = (folderTree_to_json(n)) tree = json.dumps(data, indent=4) return HttpResponse(tree, content_type="application/json") except BaseException, e: raise e
def test_cache_tree_children_caches_parents(self): """ Ensures that each node's parent is cached by ``cache_tree_children``. """ # Ensure only 1 query is used during this test with self.assertNumQueries(1): roots = cache_tree_children(Category.objects.all()) games = roots[0] wii = games.get_children()[0] wii_games = wii.get_children()[0] # Ensure that ``wii`` is cached as ``parent`` on ``wii_games``, and # likewise for ``games`` being ``parent`` on the attached ``wii`` self.assertEqual(wii, wii_games.parent) self.assertEqual(games, wii_games.parent.parent)
def maps_selectLayersTree(request, folder_id): try: layerMapOptions_ids = LayerMapOptions.objects.filter(basqui_map__id = folder_id).values_list('layer__pk', flat=True) root_node = Folder.objects.get(created_by=request.user, category='layers') nodes = root_node.get_descendants(include_self=True) node_tree = cache_tree_children(nodes) for n in node_tree: data = (selectLayersTree_to_json(n, layerMapOptions_ids)) tree = json.dumps(data, indent=4) return HttpResponse(tree, content_type="application/json") except BaseException, e: raise e
def initLayersTree(request): try: root_node = Folder.objects.get(created_by=request.user, category="layers") nodes = root_node.get_descendants(include_self=True) node_tree = cache_tree_children(nodes) for n in node_tree: data = folderTree_to_json(n) tree = json.dumps(data, indent=4) return HttpResponse(tree, content_type="application/json") except BaseException, e: raise e
def get(self, request, *args, **kwargs): # We can't force queryset evaluation here else it will mess the tree # resolution from mptt page_list = Page.objects.all() context = { 'page_list': page_list, 'json_tree': [], } # Fill the JSON tree if there is at least one entry if page_list.count()>0: context['json_tree'] = json.dumps(self.get_recursed_tree( cache_tree_children(page_list) )) return self.render_to_response(context)
def maps_selectLayersTree(request, folder_id): try: layerMapOptions_ids = LayerMapOptions.objects.filter(basqui_map__id=folder_id).values_list( "layer__pk", flat=True ) root_node = Folder.objects.get(created_by=request.user, category="layers") nodes = root_node.get_descendants(include_self=True) node_tree = cache_tree_children(nodes) for n in node_tree: data = selectLayersTree_to_json(n, layerMapOptions_ids) tree = json.dumps(data, indent=4) return HttpResponse(tree, content_type="application/json") except BaseException, e: raise e
def render_tag(self, context, nested, kwargs, expire_time, pre_node, node, post_node): placement = 'default' if 'placement' in kwargs: placement = kwargs.pop('placement') namespace = None if 'namespace' in kwargs: namespace = kwargs.pop('namespace') current = None if 'current' in kwargs: current = kwargs.pop('current') else: try: current = resolve(context['request'].path) except Http404: current = False cache_key = False output = None if not django_settings.DEBUG and expire_time is not False: cache_key = make_template_fragment_key('navigation', [nested, placement, namespace, current, str(pre_node + node + post_node)]) output = cache.get(cache_key) if not output: items = NavigationItem.objects.filter(placement=placement) if nested: items = cache_tree_children(items) else: items = items.in_parent(None).flat_ordered() output = self._render_navigation(context, items, current, namespace, pre_node, node, post_node) if cache_key: if expire_time is not None: expire_time = int(expire_time) # Make sure we don't expire any longer than the navigation_cache_keys entry if not settings.MAX_EXPIRE_TIME is None: if expire_time is None or expire_time > MAX_EXPIRE_TIME: raise Exception("Expire time may not exceed {0}".format(MAX_EXPIRE_TIME)) cache.set(cache_key, output, expire_time) cache_keys = cache.get('navigation_cache_keys', []) if cache_key not in cache_keys: cache_keys.append(cache_key) cache.set('navigation_cache_keys', cache_keys, MAX_EXPIRE_TIME) return output
def get_list(self, request, **kwargs): base_bundle = self.build_bundle(request=request) objects = self.obj_get_list(bundle=base_bundle, **kwargs) sorted_objects = self.apply_sorting(objects, options=request.GET) to_be_serialized = {} from mptt.templatetags.mptt_tags import cache_tree_children objects = cache_tree_children(objects) bundles = [] for obj in objects: data = self.get_child_data(obj) bundle = self.build_bundle(data=data, obj=obj, request=request) bundles.append(self.full_dehydrate(bundle)) to_be_serialized[self._meta.collection_name] = bundles to_be_serialized = self.alter_list_data_to_serialize( request, to_be_serialized) return self.create_response(request, to_be_serialized)
def render_tag(self, context, nested, kwargs, expire_time, pre_node, node, post_node): current = None categories = None if 'current' in kwargs: current = kwargs.pop('current') cache_key = False output = None if not settings.DEBUG and expire_time is not False: cache_key = make_template_fragment_key( 'categories', [nested, current, str(pre_node + node + post_node)]) output = cache.get(cache_key) if not output: # Query categories categories = modules.category.list(nested=nested, **kwargs) if nested: categories = cache_tree_children(categories) output = self._render_categories( context, nested, categories, current, pre_node, node, post_node) if cache_key: if expire_time is not None: expire_time = int(expire_time) # Make sure we don't expire any longer than the # categories_cache_keys entry if not max_expire_time is None: if (expire_time is None or expire_time > max_expire_time): raise Exception( "Expire time may not exceed {0}" .format(max_expire_time)) cache.set(cache_key, output, expire_time) cache_keys = cache.get('categories_cache_keys', []) if cache_key not in cache_keys: cache_keys.append(cache_key) cache.set( 'categories_cache_keys', cache_keys, max_expire_time) return output
def poi_category_json(request, campus_id): def recursive_node_to_dict(node): result = collections.OrderedDict() result['id'] = node.pk result['name'] = node.cat_name result['icon'] = node.icon_css_name children = [recursive_node_to_dict(c) for c in node.get_children()] if children: result['children'] = children return result root_nodes = cache_tree_children(PoiCategory.objects.all()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return Response(dicts)
def poi_root_nodes(request, format=None): def recursive_node_to_dict(node): result = collections.OrderedDict() result['id'] = node.pk result['name'] = _(node.cat_name) result['icon'] = node.icon_css_name children = [recursive_node_to_dict(c) for c in node.get_children()] if children: result['nodes'] = children return result root_nodes = cache_tree_children(PoiCategory.objects.filter(enabled=True).filter(parent__isnull=True)) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return Response(dicts)
def get_all_json_struct(): def recursive_node_to_dict(node): result = { 'id': node.pk, 'text': node.name, 'type': node.type, } children = [recursive_node_to_dict(c) for c in node.get_children()] if children: result['children'] = children return result root_nodes = cache_tree_children(Structure.objects.all()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) return dicts
def get_context_data(self, **kwargs): context = super(CommentsJsonView, self).get_context_data(**kwargs) story = context.get('story', None) polls = context.get('polls', None) total_votes = context.get('total_votes', None) root_comments = cache_tree_children(context.get('nodes', None)) context = self.clean_context(context) if story: context['story'] = { 'id': story.id, 'title': story.title, 'selfpost': story.selfpost, 'poll': story.poll, 'score': story.score, 'username': story.username, 'time': format(story.time, 'r'), 'time_unix': format(story.time, 'U'), 'comments': story.comments, 'cache': format(story.cache, 'r'), 'cache_unix': format(story.cache, 'U') } if story.selfpost: context['story']['selfpost_text'] = story.selfpost_text else: context['story']['url'] = story.url context['story']['domain'] = domain(story.url) if polls: context['polls'] = [] for poll in polls: context['polls'].append({ 'name': poll.name, 'votes': poll.score, 'percentage': poll_percentage(poll.score, total_votes, 2) }) context['comments'] = [] for root_comment in root_comments: context['comments'].append( self.recursive_node_to_dict(root_comment, bool(story))) return context
def get_context_data(self, **kwargs): context = super(CommentsJsonView, self).get_context_data(**kwargs) story = context.get('story', None) polls = context.get('polls', None) total_votes = context.get('total_votes', None) root_comments = cache_tree_children(context.get('nodes', None)) context = self.clean_context(context) if story: context['story'] = { 'id': story.id, 'title': story.title, 'selfpost': story.selfpost, 'poll': story.poll, 'score': story.score, 'username': story.username, 'time': format(story.time, 'r'), 'time_unix': format(story.time, 'U'), 'comments': story.comments, 'cache': format(story.cache, 'r'), 'cache_unix': format(story.cache, 'U') } if story.selfpost: context['story']['selfpost_text'] = story.selfpost_text else: context['story']['url'] = story.url context['story']['domain'] = domain(story.url) if polls: context['polls'] = [] for poll in polls: context['polls'].append({ 'name': poll.name, 'votes': poll.score, 'percentage': poll_percentage(poll.score, total_votes, 2) }) context['comments'] = [] for root_comment in root_comments: context['comments'].append(self.recursive_node_to_dict(root_comment, bool(story))) return context
def _get_tree_structure_json(self, outer, inner): ''' Trivial iteration per row query is going to slow down the database. To avoid this, we should cache the children on each node so that those queries can be done all at once. django-mptt has a cache_tree_children() function we can do this with. ''' # Get all system folders root_nodes = cache_tree_children(StateFolder.objects.all()) tree_structure = [] for root_node in root_nodes: if root_node.name == outer: tree_structure.append(self._recursive_node_to_dict(root_node)) if root_node.name == inner: break return tree_structure
def to_tree(queryset): queryset = queryset.order_by('thread_id', 'lft') return [expand_node(n) for n in cache_tree_children(queryset,)]
def handle_get_folders(self, data): root_folders = cache_tree_children(Folder.objects.all()) return JsonResponse({"rootFolder": _filer_folder_to_json_dict(None, root_folders)})
def data_org_structure(self): return [recursive_node_to_dict(cache_tree_children(dept.get_descendants_active(include_self=True))[0]) for dept in OrgUnit.objects.filter(unit_type=0).order_by('name')]
def set_items(self, request): site = self._current_site # Get all the pages, ordered by tree ID (it's convenient to build the # tree using a stack now) pages = self.get_query_set(request).drafts().order_by('tree_id', 'lft').select_related() # Get lists of page IDs for which the current user has # "permission to..." on the current site. perm_edit_ids = Page.permissions.get_change_id_list(request.user, site) perm_publish_ids = Page.permissions.get_publish_id_list(request.user, site) perm_advanced_settings_ids = Page.permissions.get_advanced_settings_id_list(request.user, site) perm_change_list_ids = Page.permissions.get_change_id_list(request.user, site) if perm_edit_ids and perm_edit_ids != Page.permissions.GRANT_ALL: pages = pages.filter(pk__in=perm_edit_ids) #pages = pages.filter(pk__in=perm_change_list_ids) if settings.CMS_MODERATOR: # get all ids of public instances, so we can cache them # TODO: add some filtering here, so the set is the same like page set... published_public_page_id_set = Page.objects.public().filter(published=True).values_list('id', flat=True) # get all moderations for current user and all pages pages_moderator_set = PageModerator.objects \ .filter(user=request.user, page__site=self._current_site) \ .values_list('page', 'moderate_page', 'moderate_children', 'moderate_descendants') # put page / moderations into singe dictionary, where key is page.id # and value is sum of moderations, so if he can moderate page and descendants # value will be MASK_PAGE + MASK_DESCENDANTS page_moderator = map(lambda item: (item[0], item[1] * MASK_PAGE + item[2] * MASK_CHILDREN + item[3] * MASK_DESCENDANTS), pages_moderator_set) page_moderator = dict(page_moderator) # page moderator states pm_qs = PageModeratorState.objects.filter(page__site=self._current_site) pm_qs.query.group_by = ['page_id'] pagemoderator_states_id_set = pm_qs.values_list('page', flat=True) ids = [] root_pages = [] pages = list(pages) all_pages = pages[:] # That is, basically, a copy. try: home_pk = Page.objects.drafts().get_home(self.current_site()).pk except NoHomeFound: home_pk = 0 # Make the pages a tree (using MPTT awesomeness). # This is normally a tag filter, but it's really nice in our case too: # It caches children for every page in the list we pass it, so no # further queries are needed. mptt_tags.cache_tree_children(pages) for page in pages: children = page.get_children() # note: We are using change_list permission here, because we must # display also pages which user must not edit, but he haves a # permission for adding a child under this page. Otherwise he would # not be able to add anything under page which he can't change. if not page.parent_id or (perm_change_list_ids != Page.permissions.GRANT_ALL and not int(page.parent_id) in perm_change_list_ids): page.root_node = True else: page.root_node = False ids.append(page.pk) if settings.CMS_PERMISSION: # caching the permissions page.permission_edit_cache = perm_edit_ids == Page.permissions.GRANT_ALL or page.pk in perm_edit_ids page.permission_publish_cache = perm_publish_ids == Page.permissions.GRANT_ALL or page.pk in perm_publish_ids page.permission_advanced_settings_cache = perm_advanced_settings_ids == Page.permissions.GRANT_ALL or page.pk in perm_advanced_settings_ids page.permission_user_cache = request.user if settings.CMS_MODERATOR: # set public instance existence state page.public_published_cache = page.publisher_public_id in published_public_page_id_set # moderation for current user moderation_value = 0 try: moderation_value = page_moderator[page.pk] except: pass page._moderation_value_cahce = moderation_value page._moderation_value_cache_for_user_id = request.user.pk #moderation states page._has_moderator_state_chache = page.pk in pagemoderator_states_id_set if page.root_node or self.is_filtered(): page.last = True if len(children): # TODO: WTF!?! # The last one is not the last... wait, what? children[-1].last = False page.menu_level = 0 root_pages.append(page) if page.parent_id: page.get_cached_ancestors(ascending=True) else: page.ancestors_ascending = [] page.home_pk_cache = home_pk # childrens is the reverse accessor for the parent foreign key. # We want to set it so the JSTree can display it nicely in admin. # "childrens" is the fully cached version of children. page.childrens = children # TODO: OPTIMIZE!! titles = Title.objects.filter(page__in=ids) for page in all_pages:# add the title and slugs and some meta data page.title_cache = {} page.all_languages = [] for title in titles: if title.page_id == page.pk: page.title_cache[title.language] = title if not title.language in page.all_languages: page.all_languages.append(title.language) page.all_languages.sort() self.root_pages = root_pages
def render(self, context): cl = self.cl_var.resolve(context) assert isinstance(cl, ChangeList), "cl variable should be an admin ChangeList" # Also assists PyCharm roots = cache_tree_children(cl.result_list) bits = [self._render_node(context, cl, node) for node in roots] return ''.join(bits)
import json from mptt.templatetags.mptt_tags import cache_tree_children def recursive_node_to_dict(node): result = { 'id': node.pk, 'name': node.title, } children = [recursive_node_to_dict(c) for c in node.get_children()] if children: result['children'] = children return result root_nodes = cache_tree_children(Node.objects.all()) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n)) print json.dumps(dicts, indent=4)
def get_tree(nodes, values): root_nodes = cache_tree_children(nodes) return [recursive_node_to_dict(n, values) for n in root_nodes]
def get_tree(nodes, values): root_nodes = cache_tree_children(nodes) dicts = [] for n in root_nodes: dicts.append(recursive_node_to_dict(n, values)) return dicts