Exemple #1
0
def index(request):
    select_detailed_source = SelecrSourceForm()
    source_points = Source.objects.exclude(point=None)
    searchform = SearchForm(request.GET)
    tagcloud = Tag.objects.cloud_for_model(Resource)
    qs = Resource.objects.filter(enabled=True).exclude(status="rejected")
    query = request.GET.get("q", None)
    if query != None:
        if query != "":
            qs = qs.filter(search_query_set(query))
        else:
            blankquery = True
        objects = []
        [objects.append(item) for item in qsfiltered]
        # treat querystring, remove page
        querystring = QueryDict(request.META.get("QUERY_STRING"))
        # handle pagination
        if "page" in request.GET:
            pageid = request.GET.get("page")
            if pageid:
                querystring._mutable = True
                del querystring["page"]
            querystring_nopage = querystring.urlencode()
        else:
            pageid = 1
            querystring_nopage = request.META.get("QUERY_STRING")

        paginator = Paginator(objects, CONTENT_PER_PAGE)

        try:
            page_obj = paginator.page(pageid)
        except TypeError:
            page_obj = paginator.page(1)
        except PageNotAnInteger:
            page_obj = paginator.page(1)
        except EmptyPage:
            page_obj = paginator.page(paginator.num_pages)
        object_list = page_obj.object_list
        return render_to_response("index.html", locals(), context_instance=RequestContext(request))

    else:
        # browse mode
        # featured list
        curricular_grades = CurricularGrade.objects.filter(parent=None)
        featured_list = (
            qs.filter(
                # category__code='video', thumbnails__gt=0
            )
            .order_by("?")
            .all()[0:2]
        )
        if featured_list.count() > 0:
            featured_list = featured_list.all()
        # tags
        tags_to_cloud = Tag.objects.usage_for_queryset(qs, counts=True)  # [0:20]
        calculate_cloud(tags_to_cloud, steps=5, distribution=LOGARITHMIC)
        query = ""
        # latest additions
        latest_additions = Resource.objects.filter(status="installed").order_by("-created")[0:5]
        return render_to_response("index.html", locals(), context_instance=RequestContext(request))
Exemple #2
0
 def get_context_data(self, **kwargs):
     tags = DjangoPerson.skilltags.cloud(steps=5)
     calculate_cloud(tags, 5)
     context = super().get_context_data(**kwargs)
     context.update({
         'tags': tags,
     })
     return context
Exemple #3
0
def annotationview(request, asset_id, annot_id):
    annotation = get_object_or_404(SherdNote,
                                   pk=annot_id, asset=asset_id,
                                   asset__course=request.course)

    user = request.user
    if user.is_staff and request.GET.has_key('as'):
        user = get_object_or_404(User,username=request.GET['as'])

    if request.method in ("DELETE", "POST"):
        if request.method == "DELETE":
            redirect_to = reverse('asset-view', args=[asset_id])
        elif request.method == "POST":
            redirect_to = '.'

        form = request.GET.copy()
        form['next'] = redirect_to
        request.GET = form
        return annotation_dispatcher(request, annot_id)

    readonly = False
    if annotation.author != request.user:
        readonly = True
        
    asset = annotation.asset

    global_annotation = asset.global_annotation(user)

    if global_annotation == annotation:
        return HttpResponseRedirect(
            reverse('asset-view', args=[asset_id]))

    form = AnnotationForm(instance=annotation, prefix="annotation")

    tags = calculate_cloud(
        Tag.objects.usage_for_queryset(
            asset.sherdnote_set.all(), counts=True))
    user_tags = calculate_cloud(
        Tag.objects.usage_for_queryset(
            user.sherdnote_set.filter(
                asset__course=request.course),
            counts=True))

    comments = Comment and Comment.objects.for_model(asset) or None

    return {
        'annotation_form': form,
        'asset': asset,
        'comments': comments,
        'annotation': annotation,
        'global_annotation': global_annotation,
        'global_annotation_form': GlobalAnnotationForm(
            instance=global_annotation, prefix="annotation"),
        'tags': tags,
        'space_viewer':user,
        'user_tags': user_tags,
        'readonly': readonly,
        }
def country_skill_cloud(request, country_code):
    country = get_object_or_404(Country, iso_code = country_code.upper())
    tags = Tag.objects.cloud_for_model(DjangoPerson, steps=5, filters={
        'country': country
    })
    calculate_cloud(tags, 5)
    return render(request, 'skills.html', {
        'tags': tags,
        'country': country
    })
Exemple #5
0
 def test_invalid_distribution(self):
     try:
         calculate_cloud(self.tags, steps=5, distribution='cheese')
     except ValueError as ve:
         self.assertEqual(str(ve), 'Invalid distribution algorithm specified: cheese.')
     except Exception as e:
         raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
             (str(type(e)), str(e)))
     else:
         raise self.failureException('a ValueError exception was supposed to be raised!')
Exemple #6
0
 def get_context_data(self, **kwargs):
     context = super().get_context_data(**kwargs)
     tags = Tag.objects.cloud_for_model(DjangoPerson, steps=5, filters={
         'country': self.object,
     })
     calculate_cloud(tags, 5)
     context.update({
         'tags': tags,
     })
     return context
Exemple #7
0
def document_view(request, document_id):
	if request.user.get_profile().is_lecturer:
		document = get_object_or_404(Document, Q(pk=document_id, is_lecturer_visible=True))
	else:
		document = get_object_or_404(Document, Q(pk=document_id))
	course = get_object_or_404(Course.objects.distinct('pk'), Q(pk=document.course.pk), Q(scopes__users__id=request.user.pk))
	category = Category.objects.get(Q(pk=course.category.pk))

	if document.is_etherpad:
		return HttpResponseRedirect(reverse("etherpad", args=[document.id]))

	comments = DocumentComment.objects.filter(document=document).order_by('pub_date')
	revisions = DocumentRevision.objects.filter(document=document).order_by('-pub_date')[1:]
	tags_raw = Tag.objects.usage_for_model(Document, counts=True)
	cloud_raw = calculate_cloud(tags_raw, steps=2)	
	tags = document.get_tags()
	cloud = [] 
	
	for tag in tags_raw:
		if tag in tags:
			cloud.insert(len(cloud) + 1, tag)

	if 'HTTP_USER_AGENT' in request.META:
		if request.META['HTTP_USER_AGENT'].find('MSIE') > 0:
			internet_explorer_warning = True
	
	return render_to_response("document.html", locals(), context_instance=RequestContext(request))		
Exemple #8
0
def pluginbrowser(request):

    if request.method == 'POST':
        #This form actually should not be submitted via POST. It is done by javascript function with AJAX call.
        #So this block of code will not be executed.
        form = PluginSearchForm(request.POST)
        if form.is_valid():
            return HttpResponseRedirect('/')
    else:
        _dbobjects = get_my_plugins(request.user) | get_shared_plugins(request.user)
        #get newest 10 plugins
        newest_plugin_list = _dbobjects.order_by('-created')[:10]
        #get recently updated 10 plugins
        #updated_plugin_list = _dbobjects.order_by('-lastmodified')[:10]
        updated_plugin_list = _dbobjects.exclude(created__gte=F('lastmodified')).order_by('-lastmodified')[:10]
                                                       #^^^^^when a new plugin is saved, "created" is slightly newer than "lastmodified"
        popular_plugin_list = _dbobjects.filter(popularity__score__isnull=False).order_by('-popularity__score')[:10]
        form = PluginSearchForm()

        plugin_tags = calculate_cloud(Tag.objects.usage_for_queryset(_dbobjects, counts=True, min_count=2))

        d = {'form': form,
             'newest_plist': newest_plugin_list,
             'updated_plist': updated_plugin_list,
             'popular_plist': popular_plugin_list,
             'anonymous_user': request.user.is_anonymous(),
             'plugin_tags': plugin_tags,
            }
        return render_to_response('plugin/pluginlibrary.html', d)
    def cloud_for_model(self, model, steps=4, distribution=LOGARITHMIC,
                        filters=None, min_count=None):
        """
        Obtain a list of tags associated with instances of the given
        Model, giving each tag a ``count`` attribute indicating how
        many times it has been used and a ``font_size`` attribute for
        use in displaying a tag cloud.

        ``steps`` defines the range of font sizes - ``font_size`` will
        be an integer between 1 and ``steps`` (inclusive).

        ``distribution`` defines the type of font size distribution
        algorithm which will be used - logarithmic or linear. It must
        be either ``tagging.utils.LOGARITHMIC`` or
        ``tagging.utils.LINEAR``.

        To limit the tags displayed in the cloud to those associated
        with a subset of the Model's instances, pass a dictionary of
        field lookups to be applied to the given Model as the
        ``filters`` argument.

        To limit the tags displayed in the cloud to those with a
        ``count`` greater than or equal to ``min_count``, pass a value
        for the ``min_count`` argument.
        """
        tags = list(self.usage_for_model(model, counts=True, filters=filters,
                                         min_count=min_count))
        return calculate_cloud(tags, steps, distribution)
Exemple #10
0
def tag_index(request, template_name="tagging_ext/index.html", min_size=0, limit=100):
    query = """
        SELECT tag_item.tag_id as tag_id, COUNT(tag_item.tag_id) as counter 
        FROM tagging_taggeditem as tag_item 
        INNER JOIN tagging_tag as tag ON (tag.id = tag_item.tag_id)
        GROUP BY tag.name,tag_id
        HAVING COUNT(tag.name) > %s
        ORDER BY tag.name
        LIMIT %s
    """

    cursor = connection.cursor()
    cursor.execute(query, [min_size, limit])

    tags = []

    for row in cursor.fetchall():
        try:
            tag = Tag.objects.get(id=row[0])
        except ObjectDoesNotExist:
            continue
            
        if ' ' in tag.name:
            continue
        
        tag.count = row[1]
        tags.append(tag)    

    tags = calculate_cloud(tags, steps=5, distribution=LOGARITHMIC)
        
    return render_to_response(template_name, {'tags': tags},
        context_instance=RequestContext(request))
Exemple #11
0
def get_tagcloud_intersection(agree_issues, disagree_issues):
    try :
        agree_tags = Tag.objects.usage_for_model(Issue, 
            counts=True, filters=dict(id__in=agree_issues))
    except EmptyResultSet:
        agree_tags = []
    try:
        disagree_tags = Tag.objects.usage_for_model(Issue, 
            counts=True, filters=dict(id__in=disagree_issues))
    except EmptyResultSet:
        disagree_tags = [] 

    tags_dagree= dict((tag.name, tag) for tag in disagree_tags)
    all_tags = []
    # loop over al for tags, look if tag also exists in disagree tag
    # if so add a status with 'conflict' to the tag.
    # agree_tags have 'agree' status
    # disagree_tags have no status.
    for a_tag in agree_tags:
        a_tag.status = 'agree'
        if tags_dagree.has_key(a_tag.name):
            d_tag = tags_dagree[a_tag.name]
            d_tag.count = d_tag.count + a_tag.count
            d_tag.status = 'conflict'
            all_tags.append(d_tag)
            tags_dagree.pop(a_tag.name)
        else:
            all_tags.append(a_tag)

    all_tags.extend(tags_dagree.values())
    
    return calculate_cloud(all_tags)
Exemple #12
0
 def render(self, djp, wrapper, prefix,
            for_model = None, steps = 4, min_count = None, **kwargs):
     try:
         formodel = ContentType.objects.get(id = int(for_model)).model_class()
     except:
         return u''
     
     steps     = int(steps)
     if min_count:
         min_count = int(min_count)
     site = get_site(djp.request.path)
     appmodel  = site.for_model(formodel)
     
     tags = self.get_tags(**kwargs)
     if tags:
         query = TaggedItem.objects.get_by_model(formodel,tags)
         query = self.model.objects.usage_for_queryset(query, counts=True)
         tags  = calculate_cloud(query)
     else:
         tags = Tag.objects.cloud_for_model(formodel,
                                            steps = steps,
                                            min_count = min_count)
     request = djp.request
     for tag in tags:
         try:
             tag.url = appmodel.tagurl(request, tag.name)
         except:
             tag.url = None
         if tag.count == 1:
             tag.times = 'time'
         else:
             tag.times = 'times'
     c = {'tags': tags}
     return loader.render_to_string(['bits/tag_cloud.html',
                                     'djpcms/bits/tag_cloud.html'],c)
Exemple #13
0
def tags(request):
    all_tags = {}
    
    # Want 2.7 for the collections.Counter :(
    def update_tags(tag):
        existing = all_tags.get(tag.name, None)
        if existing:
            existing.count += tag.count
        else:
            all_tags[tag.name] = tag
        
    scraper_tags = Tag.objects.usage_for_model(Scraper, counts=True, filters={'privacy_status':'public', 'privacy_status':'visible'})
    view_tags = Tag.objects.usage_for_model(View, counts=True, filters={'privacy_status':'public', 'privacy_status':'visible'})
    for tag in itertools.chain(scraper_tags, view_tags):
        update_tags(tag)
    
    # Use UserCodeRole objects to get code objects that are private but 
    # accessible to this user and then use update_tags to update the 
    # dictionary
    if request.user.is_authenticated():
        privatescraper_ids = [u.code.id for u in UserCodeRole.objects.filter(code__privacy_status='private', user=request.user)]
        qs = Code.objects.filter(pk__in=privatescraper_ids)
        extra_tags = Tag.objects.usage_for_queryset(qs, counts=True)
        for tag in extra_tags:
            update_tags(tag)
        
    tags = calculate_cloud(all_tags.values(), steps=4, distribution=LOGARITHMIC)

    return render_to_response('frontend/tags.html', {'tags':tags}, context_instance=RequestContext(request))
def get_tag_cloud(context, steps=6, template='zinnia/tags/tag_cloud.html'):
    """Return a cloud of published tags"""
    tags = Tag.objects.usage_for_queryset(
        Entry.published.all(), counts=True)
    return {'template': template,
            'tags': calculate_cloud(tags, steps),
            'context_tag': context.get('tag')}
Exemple #15
0
def container_view(request):

    assets = [a for a in Asset.objects.filter(course=request.course).order_by('title')
              if a not in request.course.asset_set.archives()]

    from tagging.models import Tag
    all_tags = Tag.objects.usage_for_queryset(
        SherdNote.objects.filter(
            asset__course=request.course),
        counts=True)
    all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
    all_tags = calculate_cloud(all_tags)

    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [asset for asset in assets
                      if filter_by[fil](asset, filter_value)]

    active_filters = dict((filter, request.GET.get(filter))
                          for filter in filter_by
                          if filter in request.GET)

    return {
        'assets':assets,
        'tags': all_tags,
        'active_filters': active_filters,
        'space_viewer':request.user,
        }
Exemple #16
0
 def tag_cloud(self):
     "Returns instance tags annotated with tag cloud weights"
     # Just using self.tags doesn't aggregate properly (the only
     # matching item is self)
     tags = (Tag.objects
             .filter(pk__in=[t.pk for t in self.tags])
             .annotate(count=Count('items')))
     return calculate_cloud(tags)
Exemple #17
0
def get_tag_cloud(context, steps=6, template='zinnia/tags/tag_cloud.html'):
    """Return a cloud of published tags"""
    tags = Tag.objects.usage_for_queryset(Entry.published.all(), counts=True)
    return {
        'template': template,
        'tags': calculate_cloud(tags, steps),
        'context_tag': context.get('tag')
    }
Exemple #18
0
def container_view(request):
    """for all class assets view at /asset/ 
    OPTIMIZATION:  What we need:
       asset: primary label, thumb.url
              tags {name}
       project: collaboration.get_parent, feedback_discussion
                status (from collaboration)
                attribution
    """
    #extra() is case-insensitive order hack
    #http://scottbarnham.com/blog/2007/11/20/case-insensitive-ordering-with-django-and-postgresql/
    archives = list(request.course.asset_set.archives())
    assets = [
        a for a in Asset.objects.filter(course=request.course).extra(
            select={
                'lower_title': 'lower(assetmgr_asset.title)'
            }).select_related().order_by('lower_title') if a not in archives
    ]

    asset_ids = [a.id for a in assets]
    thumbs = dict([
        (th.asset_id, th.url)
        for th in Source.objects.filter(label='thumb', asset__in=asset_ids)
    ])

    primaries = dict([
        (p.asset_id, p)
        for p in Source.objects.filter(primary=True, asset__in=asset_ids)
    ])
    #import pdb;pdb.set_trace()
    for a in assets:
        a._primary_cache = primaries[a.id]
        a._thumb_url = thumbs.get(a.id, None)

    from tagging.models import Tag
    all_tags = Tag.objects.usage_for_queryset(
        SherdNote.objects.filter(asset__course=request.course), counts=True)
    all_tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
    all_tags = calculate_cloud(all_tags)

    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [
                asset for asset in assets
                if filter_by[fil](asset, filter_value)
            ]

    active_filters = get_active_filters(request)

    return {
        'assets': assets,
        'tags': all_tags,
        'active_filters': active_filters,
        'space_viewer': request.user,
        'space_owner': None,
        'is_faculty': request.course.is_faculty(request.user),
    }
Exemple #19
0
 def cloud_for_queryset(self, queryset, steps=2, distribution=LOGARITHMIC, min_count=None):
     """
     returns the tag cloud for the given queryset
     See: https://code.google.com/p/django-tagging/issues/detail?id=137
     """
     tags = list(
         Tag.objects.usage_for_queryset(queryset, counts=True, min_count=min_count)
     )
     return calculate_cloud(tags, steps, distribution)
Exemple #20
0
def get_tagcloud_issues(issues):
    id_issues = issues.values('id')
    issue_tags = Tag.objects.usage_for_model(Issue,
                                             counts=True,
                                             filters=dict(id__in=id_issues))
    return calculate_cloud(
        issue_tags,
        steps=7,
    )
Exemple #21
0
 def cloud_for_queryset(self,
                        queryset,
                        steps=4,
                        distribution=LOGARITHMIC,
                        min_count=None):
     tags = list(
         self.usage_for_queryset(queryset, counts=True,
                                 min_count=min_count))
     return calculate_cloud(tags, steps, distribution)
Exemple #22
0
def get_user_tag_cloud(user):
    votes = Vote.objects.get_user_votes(user, Model=Issue)
    votes = votes.values_list('object_id') 
    try :
        tags = Tag.objects.usage_for_model(Issue, 
            counts=True, filters=dict(id__in=votes))
    except EmptyResultSet:
        tags = []

    return calculate_cloud(tags)
Exemple #23
0
 def get_member_data(self, member):
     bills_tags = Tag.objects.usage_for_queryset(member.bills.all(),counts=True)
     tag_cloud = map(lambda x: dict(size=x.font_size, count=x.count, name=x.name),
                     calculate_cloud(bills_tags))
     bills  = map(lambda b: dict(title=b.full_title, 
                                 url=b.get_absolute_url(),
                                 stage=b.stage, 
                                 stage_text=b.get_stage_display()), 
                  member.bills.all())
     return DictStruct(id=member.id, tag_cloud=tag_cloud,bills=bills)
Exemple #24
0
def tagged_items(request, slug, tags=None):
    """ View items tagged in project """
    project = get_object_or_404(Project, slug=slug)
    project_type = ContentType.objects.get_for_model(project)

    tag_list = tags.split("+")

    querysets = [
        Task.objects.select_related().filter(project=project),
        Thread.objects.filter(content_type__pk=project_type.pk,
                              object_id=project.id)
    ]
    all_tags = []
    qs_items = []
    for query in querysets:
        qs = TaggedItem.objects.get_intersection_by_model(query, tag_list)
        if qs:
            qs_tags = Tag.objects.usage_for_queryset(qs, counts=True)
            all_tags.extend(qs_tags)
            qs_items.extend(qs)

    # Order items and put in cloud
    all_tags = reduce(lambda l, x: x not in l and l.append(x) or l, all_tags,
                      [])
    tags = calculate_cloud(all_tags, 4, LOGARITHMIC)

    # Tagged items
    tagged_items = []
    for item in qs_items:
        item.type = item._meta.module_name
        if hasattr(item, "created_at"):
            item.sort = item.created_at
        else:
            item.sort = item.latest_message_time
        tagged_items.append(item)
    tagged_items.sort(key=lambda x: x.sort)

    # Complile tags
    selected_tags = []
    tag_url = ''
    for item in tag_list:
        tag_url += item + '+'
        name = Tag.objects.get(name=item)
        tags.remove(name)
        selected_tags.append(name)

    return direct_to_template(request,
                              template='blproject/tagged_item_list.html',
                              extra_context={
                                  'tag_cloud': tags,
                                  'tag_url': tag_url,
                                  'selected_tags': selected_tags,
                                  'tagged_items': tagged_items,
                                  'project': project
                              })
Exemple #25
0
    def get_context_data(self, **kwargs):
        kwargs = super(AlbumTagRessourcesView, self).get_context_data(**kwargs)

        tags_q = Tag.objects.usage_for_queryset(self.get_ressources_queryset(), min_count=1)
        tags_q = calculate_cloud(tags_q, steps=6)

        kwargs.update({
            'tag_object': self.tag_object,
            'ressources_tags': tags_q,
        })
        return kwargs
Exemple #26
0
    def test_linear_distribution(self):
        sizes = {}
        for tag in calculate_cloud(self.tags, steps=5, distribution=LINEAR):
            sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1

        # This isn't a pre-calculated test, just making sure it's consistent
        self.assertEquals(sizes[1], 97)
        self.assertEquals(sizes[2], 12)
        self.assertEquals(sizes[3], 7)
        self.assertEquals(sizes[4], 2)
        self.assertEquals(sizes[5], 4)
Exemple #27
0
 def test_linear_distribution(self):
     sizes = {}
     for tag in calculate_cloud(self.tags, steps=5, distribution=LINEAR):
         sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1
     
     # This isn't a pre-calculated test, just making sure it's consistent
     self.assertEquals(sizes[1], 97)
     self.assertEquals(sizes[2], 12)
     self.assertEquals(sizes[3], 7)
     self.assertEquals(sizes[4], 2)
     self.assertEquals(sizes[5], 4)
Exemple #28
0
 def test_default_distribution(self):
     sizes = {}
     for tag in calculate_cloud(self.tags, steps=5):
         sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1
     
     # This isn't a pre-calculated test, just making sure it's consistent
     self.assertEquals(sizes[1], 48)
     self.assertEquals(sizes[2], 30)
     self.assertEquals(sizes[3], 19)
     self.assertEquals(sizes[4], 15)
     self.assertEquals(sizes[5], 10)
Exemple #29
0
    def test_default_distribution(self):
        sizes = {}
        for tag in calculate_cloud(self.tags, steps=5):
            sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1

        # This isn't a pre-calculated test, just making sure it's consistent
        self.assertEquals(sizes[1], 48)
        self.assertEquals(sizes[2], 30)
        self.assertEquals(sizes[3], 19)
        self.assertEquals(sizes[4], 15)
        self.assertEquals(sizes[5], 10)
Exemple #30
0
def index(request):
    if request.user.is_authenticated():
        #User should have that after authorisation
        #request.user.user_permissions.add('User')
        pass
    #latest_addons = Addon.objects.all().order_by('-pub_date')[:5]
    recomended_addons = Addon.objects.all().order_by('-rating')[:4]
    categories = Category.objects.all()
    tags = Tag.objects.usage_for_model(Addon, counts=True)
    tag_cloud = utils.calculate_cloud(tags, steps=5, distribution=utils.LOGARITHMIC)
    return render_to_response('main/index.html', {'tag_cloud': tag_cloud, 'recomended_addons': recomended_addons, 'categories': categories, 'user': request.user, 'site_name': Site.objects.get_current().name})
Exemple #31
0
def get_user_tag_cloud(user):
    votes = Vote.objects.get_user_votes(user, Model=Issue)
    votes = votes.values_list('object_id')
    try:
        tags = Tag.objects.usage_for_model(Issue,
                                           counts=True,
                                           filters=dict(id__in=votes))
    except EmptyResultSet:
        tags = []

    return calculate_cloud(tags)
Exemple #32
0
    def get_context_data(self, **kwargs):
        kwargs = super(AlbumDetailView, self).get_context_data(**kwargs)

        tags_q = Tag.objects.usage_for_queryset(self.object_list, min_count=1)
        tags_q = calculate_cloud(tags_q, steps=6)

        kwargs.update({
            # Filter ressource tags from the ressource list queryset
            # Behavior to watch, maybe at this step, the queryset has been limited by the paginator
            'ressources_tags': tags_q,
        })
        return kwargs
Exemple #33
0
    def get_context_data(self, **kwargs):
        kwargs = super(AlbumTagRessourcesView, self).get_context_data(**kwargs)

        tags_q = Tag.objects.usage_for_queryset(self.get_ressources_queryset(),
                                                min_count=1)
        tags_q = calculate_cloud(tags_q, steps=6)

        kwargs.update({
            'tag_object': self.tag_object,
            'ressources_tags': tags_q,
        })
        return kwargs
Exemple #34
0
    def get_context_data(self, **kwargs):
        kwargs = super(AlbumDetailView, self).get_context_data(**kwargs)

        tags_q = Tag.objects.usage_for_queryset(self.object_list, min_count=1)
        tags_q = calculate_cloud(tags_q, steps=6)

        kwargs.update({
            # Filter ressource tags from the ressource list queryset
            # Behavior to watch, maybe at this step, the queryset has been limited by the paginator
            'ressources_tags': tags_q,
        })
        return kwargs
Exemple #35
0
 def get_member_data(self, member):
     bills_tags = Tag.objects.usage_for_queryset(member.bills.all(),
                                                 counts=True)
     tag_cloud = map(
         lambda x: dict(size=x.font_size, count=x.count, name=x.name),
         calculate_cloud(bills_tags))
     bills = map(
         lambda b: dict(title=b.full_title,
                        url=b.get_absolute_url(),
                        stage=b.stage,
                        stage_text=b.get_stage_display()),
         member.bills.all())
     return DictStruct(id=member.id, tag_cloud=tag_cloud, bills=bills)
Exemple #36
0
def core_get_tag_cloud(context, steps=6, min_count=None, max_num_tags=2,
                       template='zinnia/tags/tag_cloud.html'):
    """
    Return a cloud of published tags.
    """
    tags = Tag.objects.usage_for_queryset(
        Entry.published.all(), counts=True,
        min_count=min_count)
    tags = sorted(tags, key=lambda t: t.count, reverse=True)
    tags = list(islice(tags, max_num_tags))
    return {'template': template,
            'tags': calculate_cloud(tags, steps),
            'context_tag': context.get('tag')}
Exemple #37
0
def asset_workspace(request, asset_id):
    asset = get_object_or_404(Asset, pk=asset_id,
                              course=request.course)

    user = request.user
    if user.is_staff and request.GET.has_key('as'):
        user = get_object_or_404(User,username=request.GET['as'])

    global_annotation = asset.global_annotation(user)

    tags = calculate_cloud(
        Tag.objects.usage_for_queryset(
            asset.sherdnote_set.all(), counts=True))

    user_tags = calculate_cloud(
        Tag.objects.usage_for_queryset(
            user.sherdnote_set.filter(
                asset__course=request.course
                ), counts=True))

    comments = Comment.objects.for_model(asset)

    discussions = Clumper(DiscussionIndex.with_permission(
            request,
            #order, to be easily groupable by discussion
            DiscussionIndex.objects.filter(asset=asset).order_by('-modified')
            ), group_by='discussion')

    return {
        'asset': asset,
        'comments': comments,
        'global_annotation': global_annotation,
        'tags': tags,
        'space_viewer':user,
        'user_tags': user_tags,
        'annotation_form': AnnotationForm(prefix="annotation"),
        'global_annotation_form': GlobalAnnotationForm(instance=global_annotation, prefix="annotation"),
        'discussions' : discussions
        }
Exemple #38
0
def your_records(request, user_name):

    c = request.course
    in_course_or_404(user_name, c)

    today = datetime.date.today()
    user = get_object_or_404(User, username=user_name)

    editable = (user==request.user)
    assets = annotated_by(Asset.objects.filter(course=c),
                          user,
                          include_archives=c.is_faculty(user)
                          )

    projects = Project.get_user_projects(user, c)
    if not editable:
        projects = projects.filter(submitted=True)
    projects = projects.order_by('-modified')


    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [asset for asset in assets
                      if filter_by[fil](asset, filter_value, user)]

    tags = calculate_cloud(Tag.objects.usage_for_queryset(
            user.sherdnote_set.filter(
                asset__course=c),
            counts=True))
    
    active_filters = dict((filter, request.GET.get(filter))
                          for filter in filter_by
                          if filter in request.GET)
    #bad language, we should change this to user_of_assets or something
    space_viewer = user 
    if request.GET.has_key('as') and request.user.is_staff:
        space_viewer = get_object_or_404(User, username=request.GET['as'])

    return {
        'assets'        : assets,
        'projects'      : projects,
        'tags'          : tags,
        'dates'         : {'today':'today',
                           'yesterday':'yesterday',
                           'lastweek':'within the last week'},
        'space_owner'   : user,
        'space_viewer'  : space_viewer,
        'editable'      : editable,
        'active_filters': active_filters,
        }
Exemple #39
0
def container_view(request):
    """for all class assets view at /asset/ 
    OPTIMIZATION:  What we need:
       asset: primary label, thumb.url
              tags {name}
       project: collaboration.get_parent, feedback_discussion
                status (from collaboration)
                attribution
    """
    #extra() is case-insensitive order hack
    #http://scottbarnham.com/blog/2007/11/20/case-insensitive-ordering-with-django-and-postgresql/
    archives = list(request.course.asset_set.archives())
    assets = [a for a in Asset.objects.filter(course=request.course).extra(
            select={'lower_title': 'lower(assetmgr_asset.title)'}
            ).select_related().order_by('lower_title')
              if a not in archives]

    asset_ids = [a.id for a in assets]
    thumbs = dict([(th.asset_id,th.url) for th in Source.objects.filter(label='thumb', asset__in=asset_ids)])
    
    primaries = dict([(p.asset_id,p) for p in Source.objects.filter(primary=True, asset__in=asset_ids)])
    #import pdb;pdb.set_trace()
    for a in assets:
        a._primary_cache = primaries[a.id]
        a._thumb_url = thumbs.get(a.id,None)


    from tagging.models import Tag
    all_tags = Tag.objects.usage_for_queryset(
        SherdNote.objects.filter(
            asset__course=request.course),
        counts=True)
    all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
    all_tags = calculate_cloud(all_tags)

    for fil in filter_by:
        filter_value = request.GET.get(fil)
        if filter_value:
            assets = [asset for asset in assets
                      if filter_by[fil](asset, filter_value)]

    active_filters = get_active_filters(request)

    return {
        'assets':assets,
        'tags': all_tags,
        'active_filters': active_filters,
        'space_viewer':request.user,
        'space_owner':None,
        'is_faculty':request.course.is_faculty(request.user),
        }
    def testTagClouds(self):
        tags = []
        for line in open(os.path.join(os.path.dirname(__file__), 'tags.txt')).readlines():
            name, count = line.rstrip().split()
            tag = Tag(name=name)
            tag.count = int(count)
            tags.append(tag)

        sizes = {}
        for tag in calculate_cloud(tags, steps=5):
            sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1

        # This isn't a pre-calculated test, just making sure it's consistent
        self.assertEqual({1: 48, 2: 30, 3: 19, 4: 15, 5: 10}, sizes)

        sizes = {}
        for tag in calculate_cloud(tags, steps=5, distribution=LINEAR):
            sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1

        # This isn't a pre-calculated test, just making sure it's consistent
        self.assertEqual({1: 97, 2: 12, 3: 7, 4: 2, 5: 4}, sizes)

        self.assertRaises(ValueError, calculate_cloud, tags, steps=5, distribution='cheese')
Exemple #41
0
def blog_index(request, blog, page=1):
    """
    Blog front page. Displays latest blog posts, excluding future posts.
    Paginated.
    """
    blog_tags = Tag.objects.usage_for_model(Entry, counts=True,
        filters=dict(blog__slug=blog))
    cloud = calculate_cloud(blog_tags)
    blog_obj = get_object_or_404(Blog, slug=blog)
    qs = Entry.objects.published_on_blog(blog).order_by('-pub_date')
    c = {'blog': blog_obj,
        'blog_tags': cloud}
    return object_list(request, queryset=qs, paginate_by=10, allow_empty=False,
        page=page, extra_context=c)
Exemple #42
0
 def cloud_for_queryset(self,
                        queryset,
                        steps=2,
                        distribution=LOGARITHMIC,
                        min_count=None):
     """
     returns the tag cloud for the given queryset
     See: https://code.google.com/p/django-tagging/issues/detail?id=137
     """
     tags = list(
         Tag.objects.usage_for_queryset(queryset,
                                        counts=True,
                                        min_count=min_count))
     return calculate_cloud(tags, steps, distribution)
Exemple #43
0
def asset_accoutrements(request, asset, user, annotation_form):
    global_annotation = asset.global_annotation(user, auto_create=False)
    if global_annotation:
        global_annotation_form = GlobalAnnotationForm(
            instance=global_annotation, prefix="annotation")
    else:
        global_annotation_form = GlobalAnnotationForm(prefix="annotation")

    tags = calculate_cloud(
        Tag.objects.usage_for_queryset(asset.sherdnote_set.all(), counts=True))

    user_tags = calculate_cloud(
        Tag.objects.usage_for_queryset(
            user.sherdnote_set.filter(asset__course=request.course),
            counts=True))

    comments = Comment and Comment.objects.for_model(asset) or None

    discussions = Clumper(
        DiscussionIndex.with_permission(
            request,
            #order, to be easily groupable by discussion
            DiscussionIndex.objects.filter(asset=asset).order_by('-modified')),
        group_by='discussion')

    return {
        'asset': asset,
        'comments': comments,
        'global_annotation': global_annotation,
        'tags': tags,
        'space_viewer': user,
        'user_tags': user_tags,
        'annotation_form': annotation_form,
        'global_annotation_form': global_annotation_form,
        'discussions': discussions
    }
Exemple #44
0
def get_tag_cloud_su_sensitive(context,
                               steps=6,
                               min_count=None,
                               template='zinnia/tags/tag_cloud.html'):
    if context['request'].user.is_superuser:
        queryset = Entry.objects.all()
    else:
        queryset = Entry.published.all()
    tags = Tag.objects.usage_for_queryset(queryset,
                                          counts=True,
                                          min_count=min_count)
    return {
        'template': template,
        'tags': calculate_cloud(tags, steps),
        'context_tag': context.get('tag')
    }
Exemple #45
0
    def get_member_data(self, member):
        bills_tags = Tag.objects.usage_for_queryset(member.bills.all(),
                                                    counts=True)
        # we'll use getattr for font_size, as it might not always be there
        # This prevents the need of using a forked django-tagging, and go
        # upstream
        tag_cloud = [{
            'size': getattr(x, 'font_size', 1),
            'count':x.count,
            'name':x.name} for x in calculate_cloud(bills_tags)]

        bills  = map(lambda b: dict(title=b.full_title,
                                    url=b.get_absolute_url(),
                                    stage=b.stage,
                                    stage_text=b.get_stage_display()),
                     member.bills.all())
        return DictStruct(id=member.id, tag_cloud=tag_cloud,bills=bills)
Exemple #46
0
def tag_index(request, template_name="tagging_ext/index.html", *args, **kw):
    query = """
        SELECT tag.name as name, COUNT(tag_item.tag_id) as counter, tag_item.tag_id as tag_id
        FROM tagging_taggeditem as tag_item
        INNER JOIN tagging_tag as tag ON (tag.id = tag_item.tag_id)
        GROUP BY tag.name, tag_id
        ORDER BY tag.name
    """
    cursor = connection.cursor()
    cursor.execute(query)

    tags = calculate_cloud([TagInTheCloud(*row) for row in cursor],
                           steps=5,
                           distribution=LOGARITHMIC)

    return render_to_response(template_name, {'tags': tags},
                              context_instance=RequestContext(request))
Exemple #47
0
def dashboard(request):
    """
    Brief snippets of all interesting site features
    """
    all_subscriptions = SubscriptionUser.objects.filter(user=request.user)
    subscriptions = all_subscriptions.filter(active=True)
    inactive_subscriptions = all_subscriptions.filter(active=False)

    for subscription in subscriptions:
        subscription.count = max(1, subscription.is_fresh(request.user))
    subscriptions = calculate_cloud(subscriptions)

    return render(
        request, "subscriptions/dashboard.html", {
            "subscriptions": subscriptions,
            "inactive_subscriptions": inactive_subscriptions,
            "feed": get_hits(request.user),
        })
Exemple #48
0
def blog_index(request, blog, page=1):
    """
    Blog front page. Displays latest blog posts, excluding future posts.
    Paginated.
    """
    blog_tags = Tag.objects.usage_for_model(Entry,
                                            counts=True,
                                            filters=dict(blog__slug=blog))
    cloud = calculate_cloud(blog_tags)
    blog_obj = get_object_or_404(Blog, slug=blog)
    qs = Entry.objects.published_on_blog(blog).order_by('-pub_date')
    c = {'blog': blog_obj, 'blog_tags': cloud}
    return object_list(request,
                       queryset=qs,
                       paginate_by=10,
                       allow_empty=False,
                       page=page,
                       extra_context=c)
Exemple #49
0
def annotations_collection_fragment(request,username=None):
    """username is WAY overloaded
     username='******' : just give me the selection menu
     username=None : give me all assets for the class
     username=<username> : all username assets
    """
    rv = {'space_viewer':request.user,
          'space_owner':False, #indicates we want the whole class (None is no one)
          'page_in_edit_mode': request.GET.has_key('edit_mode'),
          }
    if username != 'none':
        if username \
                and (request.user.username != username or request.course.is_true_member(request.user)):
            rv['space_owner'] = in_course_or_404(username, request.course)
            #assets = annotated_by(Asset.objects.filter(course=request.course),
            #                      space_owner)
            note_query = rv['space_owner'].sherdnote_set.filter(asset__course=request.course)
        else:
            #assets = Asset.objects.filter(course=request.course)
            note_query = SherdNote.objects.filter(asset__course=request.course)

        rv['tags'] =  calculate_cloud(Tag.objects.usage_for_queryset(note_query, counts=True))

        #all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
        #all_tags = calculate_cloud(all_tags)
    
        filter_by = ('tag','modified')

        for fil in filter_by:
            filter_value = request.GET.get(fil)
            if filter_value:
                s_filter = getattr(SherdNote.objects,'%s_filter'%fil)
                note_query = s_filter(filter_value,note_query)

        #until asset_table.html can work off the notes objects instead of the assets list
        rv['assets'] = Asset.objects.filter(id__in = note_query.values_list('asset',flat=True))

        rv['active_filters'] = get_active_filters(request)
        rv['dates'] = (('today','today'),
                       ('yesterday','yesterday'),
                       ('lastweek','within the last week'),
                       )
    
    return rv
Exemple #50
0
    def cloud_for_model(
        self,
        model,
        steps=4,
        distribution=LOGARITHMIC,
        filters=None,
        min_count=None,
        limit=None,
    ):
        """
        Obtain a list of tags associated with instances of the given
        Model, giving each tag a ``count`` attribute indicating how
        many times it has been used and a ``font_size`` attribute for
        use in displaying a tag cloud.

        ``steps`` defines the range of font sizes - ``font_size`` will
        be an integer between 1 and ``steps`` (inclusive).

        ``distribution`` defines the type of font size distribution
        algorithm which will be used - logarithmic or linear. It must
        be either ``tagging.utils.LOGARITHMIC`` or
        ``tagging.utils.LINEAR``.

        To limit the tags displayed in the cloud to those associated
        with a subset of the Model's instances, pass a dictionary of
        field lookups to be applied to the given Model as the
        ``filters`` argument.

        To limit the tags displayed in the cloud to those with a
        ``count`` greater than or equal to ``min_count``, pass a value
        for the ``min_count`` argument.

        To limite the amount of tags displayed in the cloud, pass a value for
        the ``limit`` argument.
        """
        tags = list(
            self.usage_for_model(
                model,
                counts=True,
                filters=filters,
                min_count=min_count,
                limit=limit,
            ), )
        return calculate_cloud(tags, steps, distribution)
Exemple #51
0
    def render(self, context):
        object = self.object.resolve(context)
        user = self.user.resolve(context)
        if self.include:
            if not user.is_anonymous():
                ownedwrapper = OwnedWrapper.objects.get_for_object(
                    user, object)
                context[self.var_name] = Tag.objects.get_for_object(
                    ownedwrapper)
        else:
            qs = OwnedWrapper.objects.filter(object_id=object.id,
                                             content_type=OwnedWrapper.t(
                                                 object.__class__))
            if not user.is_anonymous():
                qs = qs.exclude(user=user)

            tags = list(Tag.objects.usage_for_queryset(qs, counts=True))
            context[self.var_name] = calculate_cloud(tags)

        return ''
Exemple #52
0
def website_detail(request, slug):
    w = get_object_or_404(Website, slug=slug)

    if w.tags:
        try:
            related_tags = Tag.objects.related_for_model(w.tags,
                                                         Website,
                                                         counts=True)
            tag_cloud = calculate_cloud(related_tags)
        except:
            tag_cloud = []
    else:
        tag_cloud = []

    return render_to_response(
        'websites/website_detail.html',
        RequestContext(request, {
            'object': w,
            'related_tag_cloud': tag_cloud,
        }))
Exemple #53
0
def index(request):
    if request.user.is_authenticated():
        #User should have that after authorisation
        #request.user.user_permissions.add('User')
        pass
    #latest_addons = Addon.objects.all().order_by('-pub_date')[:5]
    recomended_addons = Addon.objects.all().order_by('-rating')[:4]
    categories = Category.objects.all()
    tags = Tag.objects.usage_for_model(Addon, counts=True)
    tag_cloud = utils.calculate_cloud(tags,
                                      steps=5,
                                      distribution=utils.LOGARITHMIC)
    return render_to_response(
        'main/index.html', {
            'tag_cloud': tag_cloud,
            'recomended_addons': recomended_addons,
            'categories': categories,
            'user': request.user,
            'site_name': Site.objects.get_current().name
        })
Exemple #54
0
    def get_tag_cloud(cls, user):
        """Get current tags available to user.

            @param user: user to get current items for
            @type user: auth.models.user
            @return: current tags available to user
            @rtype: list of tagging.Tag
            """
        # without if-construct sqlite3 barfs on AnonymousUser
        if user.id:
            qs = (Q(user=user) | Q(is_public=True)) & Q(is_current=True)
        else:
            qs = Q(is_public=True) & Q(is_current=True)

        if cls:
            tags = Tag.objects.usage_for_queryset(cls.objects.filter(qs), counts=True)
        else:
            tags = Tag.objects.usage_for_queryset(
                                                  repository.models.Data.objects.filter(qs & Q(is_approved=True)), counts=True)
            tags.extend(Tag.objects.usage_for_queryset(
                        repository.models.Task.objects.filter(qs), counts=True))
            tags.extend(Tag.objects.usage_for_queryset(
                        repository.models.Method.objects.filter(qs), counts=True))

        current = {}
        for t in tags:
            if not t.name in current:
                current[t.name] = t
            else:
                current[t.name].count += t.count

        tags = current.values()
        if tags:
            cloud = calculate_cloud(tags, steps=2)
            random.seed(hash(cls)+len(tags))
            random.shuffle(cloud)
        else:
            cloud = None
        return cloud
Exemple #55
0
def tags(request):
    all_tags = {}

    # Python 2.7 would clean this up by using collections.Counter
    def update_tags(tag):
        existing = all_tags.get(tag.name, None)
        if existing:
            existing.count += tag.count
        else:
            all_tags[tag.name] = tag

    scraper_tags = Tag.objects.usage_for_model(Scraper, counts=True,
      filters={'privacy_status':'public'})
    view_tags = Tag.objects.usage_for_model(View, counts=True,
      filters={'privacy_status':'public'})
    for tag in itertools.chain(scraper_tags, view_tags):
        update_tags(tag)

    tags = calculate_cloud(all_tags.values(),
      steps=4, distribution=LOGARITHMIC)

    return render_to_response('frontend/tags.html', {'tags':tags},
      context_instance=RequestContext(request))
Exemple #56
0
def mock_analysis_space(request):

    user_tags = calculate_cloud(
        Tag.objects.usage_for_queryset(
            request.user.sherdnote_set.filter(asset__course=request.course),
            counts=True))

    sources = sources_from_args(request)

    title = getattr(request, request.method).get('title', '')

    mock_asset = dict(
        title=title,
        source_set={'all': sources.values()},
        html_source={'url': request.GET.get('url', None)},
    )
    return {
        'mock': True,
        'asset': mock_asset,
        'user_tags': user_tags,
        'annotation_form': AnnotationForm(prefix="annotation"),
        'global_annotation_form': GlobalAnnotationForm(prefix="annotation"),
    }
Exemple #57
0
 def render(self, context):
     tags = Tag.objects.annotate(count=Count("items")).exclude(count=0)
     context[self.context_var] = calculate_cloud(tags, **self.kwargs)
     return ''
Exemple #58
0
def blogcloud():
    tags = Tag.objects.usage_for_model(Entry, counts=True)
    tags = tagutils.calculate_cloud(tags)
    return {'tags': tags}
Exemple #59
0
 def test_invalid_distribution(self):
     try:
         calculate_cloud(self.tags, steps=5, distribution='cheese')
     except ValueError, ve:
         self.assertEquals(
             str(ve), 'Invalid distribution algorithm specified: cheese.')
Exemple #60
0
def get_tag_cloud(steps=6, template='objectapp/tags/tag_cloud.html'):
    """Return a cloud of published tags"""
    tags = Tag.objects.usage_for_queryset(Gbobject.published.all(),
                                          counts=True)
    return {'template': template, 'tags': calculate_cloud(tags, steps)}