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))

 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

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 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!')

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
    })

 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)

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,
        }

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))

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))		

    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)

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 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)

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')}

 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)

 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)

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)

 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)

 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)

 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)