Exemplo n.º 1
0
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
    ))
Exemplo n.º 2
0
    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)
Exemplo n.º 3
0
    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)
Exemplo n.º 4
0
 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
Exemplo n.º 5
0
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)
Exemplo n.º 6
0
    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)
Exemplo n.º 7
0
 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
Exemplo n.º 8
0
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),
    })
Exemplo n.º 9
0
 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)
Exemplo n.º 10
0
    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
Exemplo n.º 11
0
    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
Exemplo n.º 12
0
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
Exemplo n.º 13
0
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]
Exemplo n.º 14
0
 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)
Exemplo n.º 15
0
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)
Exemplo n.º 17
0
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
Exemplo n.º 18
0
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
Exemplo n.º 19
0
    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)
Exemplo n.º 20
0
 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')
     ]
Exemplo n.º 21
0
    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
Exemplo n.º 22
0
 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
Exemplo n.º 23
0
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
Exemplo n.º 24
0
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')
Exemplo n.º 25
0
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
Exemplo n.º 26
0
    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)
Exemplo n.º 27
0
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 {}
Exemplo n.º 28
0
 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)
Exemplo n.º 29
0
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
Exemplo n.º 30
0
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())
Exemplo n.º 31
0
    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)
Exemplo n.º 32
0
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")
Exemplo n.º 33
0
 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)
Exemplo n.º 34
0
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
Exemplo n.º 35
0
 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)
Exemplo n.º 36
0
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
Exemplo n.º 37
0
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
Exemplo n.º 38
0
 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)
Exemplo n.º 39
0
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
Exemplo n.º 40
0
    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
Exemplo n.º 41
0
    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)
Exemplo n.º 42
0
    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
Exemplo n.º 43
0
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)
Exemplo n.º 44
0
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)
Exemplo n.º 45
0
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
Exemplo n.º 46
0
 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
Exemplo n.º 47
0
	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
Exemplo n.º 48
0
    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
Exemplo n.º 49
0
def to_tree(queryset):
    queryset = queryset.order_by('thread_id', 'lft')
    return [expand_node(n) for n in cache_tree_children(queryset,)]
Exemplo n.º 50
0
 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)})
Exemplo n.º 51
0
 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')]
Exemplo n.º 52
0
    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)
Exemplo n.º 54
0
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)
Exemplo n.º 55
0
def get_tree(nodes, values):
    root_nodes = cache_tree_children(nodes)
    return [recursive_node_to_dict(n, values) for n in root_nodes]
Exemplo n.º 56
0
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