def entry_tags(self):
"""Returns a :class:`QuerySet` of :class:`.Tag`\ s that are used on any entries in this blog."""
entry_pks = list(self.entries.values_list('pk', flat=True))
kwargs = {
'%s__object_id__in' % TaggedItem.tag_relname(): entry_pks
}
return TaggedItem.tags_for(BlogEntry).filter(**kwargs)
def get_tag_cloud(model, queryset, tags_filter=None):
if tags_filter is None:
tags_filter = set()
for item in queryset.all():
tags_filter.update(item.tags.all())
tags_filter = set([tag.id for tag in tags_filter])
tags = set(TaggedItem.objects.filter(
content_type__model=model.__name__.lower()
).values_list('tag_id', flat=True))
if tags_filter is not None:
tags = tags.intersection(tags_filter)
tag_ids = list(tags)
kwargs = TaggedItem.bulk_lookup_kwargs(queryset)
kwargs['tag_id__in'] = tag_ids
counted_tags = dict(TaggedItem.objects
.filter(**kwargs)
.values('tag')
.annotate(count=models.Count('tag'))
.values_list('tag', 'count'))
tags = TaggedItem.tag_model().objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def get_tag_cloud(model, queryset, tags_filter=None):
if tags_filter is None:
tags_filter = set()
for item in queryset.all():
tags_filter.update(item.tags.all())
tags_filter = set([tag.id for tag in tags_filter])
tags = set(
TaggedItem.objects.filter(
content_type__model=model.__name__.lower()).values_list('tag_id',
flat=True))
if tags_filter is not None:
tags = tags.intersection(tags_filter)
tag_ids = list(tags)
kwargs = TaggedItem.bulk_lookup_kwargs(queryset)
kwargs['tag_id__in'] = tag_ids
counted_tags = dict(
TaggedItem.objects.filter(**kwargs).values('tag').annotate(
count=models.Count('tag')).values_list('tag', 'count'))
tags = TaggedItem.tag_model().objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def _delete_and_recreate_tags(slug):
source_demo = Submission.objects.using("default").get(slug=slug)
destination_demo = Submission.objects.using("new").get(slug=slug)
source_type, destination_type = _get_demo_content_types()
source_tags = source_demo.taggit_tags.all()
source_tags_names = [tag.name for tag in source_tags]
destination_tags = destination_demo.taggit_tags.using("new").all()
destination_tags_names = [tag.name for tag in destination_tags]
if source_tags_names == destination_tags_names:
logger.info(
"%s: Found %s matching tag(s): %s" % (source_demo.slug, len(destination_tags), destination_tags_names)
)
return destination_tags
else:
dest_demo_tagged_items = TaggedItem.objects.using("new").filter(
tag__in=[tag for tag in destination_tags], object_id=destination_demo.id, content_type=destination_type
)
dest_demo_tagged_items.using("new").delete()
logger.info("%s: Migrating %s tag(s): %s" % (source_demo.slug, len(source_tags), source_tags_names))
for source_tag in source_tags:
try:
destination_tag = Tag.objects.using("new").get(name=source_tag.name)
except Tag.DoesNotExist:
destination_tag = Tag(name=source_tag.name)
destination_tag.save(using="new")
destination_demo_tag = TaggedItem(
content_type=destination_type, object_id=destination_demo.id, tag=destination_tag
)
destination_demo_tag.save(using="new")
return destination_tags
def _delete_and_recreate_tags(slug):
source_demo = Submission.objects.using('default').get(slug=slug)
destination_demo = Submission.objects.using('new').get(slug=slug)
source_type, destination_type = _get_demo_content_types()
source_tags = source_demo.taggit_tags.all()
source_tags_names = [tag.name for tag in source_tags]
destination_tags = destination_demo.taggit_tags.using('new').all()
destination_tags_names = [tag.name for tag in destination_tags]
if source_tags_names == destination_tags_names:
logger.info(
"%s: Found %s matching tag(s): %s" %
(source_demo.slug, len(destination_tags), destination_tags_names))
return destination_tags
else:
dest_demo_tagged_items = TaggedItem.objects.using('new').filter(
tag__in=[tag for tag in destination_tags],
object_id=destination_demo.id,
content_type=destination_type)
dest_demo_tagged_items.using('new').delete()
logger.info("%s: Migrating %s tag(s): %s" %
(source_demo.slug, len(source_tags), source_tags_names))
for source_tag in source_tags:
try:
destination_tag = (Tag.objects.using('new').get(
name=source_tag.name))
except Tag.DoesNotExist:
destination_tag = Tag(name=source_tag.name)
destination_tag.save(using='new')
destination_demo_tag = TaggedItem(content_type=destination_type,
object_id=destination_demo.id,
tag=destination_tag)
destination_demo_tag.save(using='new')
return destination_tags
def get_context_data(self, **kwargs):
context = super(BlogBaseView, self).get_context_data(**kwargs)
context['blog_tags'] = TaggedItem.tags_for(Blog).order_by('name')
context['recent_blog_list'] = Blog.objects.recent_posts()
# context['blog_list'] = Blog.objects.all()
return context
def set_taggeditems(self):
objects = OldTaggedItem.objects.all()
print objects.count()
for old_tagitem in objects:
old_id = old_tagitem.tag_id
new_id = self.dupemap.get(old_id, old_id)
new_tags = NewTag.objects.filter(id=new_id)
if new_tags:
new_tag = new_tags[0]
new_tagitem = NewTaggedItem(
id=old_tagitem.id,
tag=new_tag,
content_type=old_tagitem.content_type,
object_id=old_tagitem.object_id)
new_tagitem.save()
print NewTaggedItem.objects.count()
def handle(self, *arg, **kwargs):
print '##########################################################'
print '### This file is generated by ./manage.py dump_topics. ###'
print '##########################################################'
print 'from django.utils.translation import pgettext\n'
for tag in TaggedItem.tags_for(Document):
print 'pgettext("KB Topic", """{tag}""")'.format(tag=tag.name)
def handle(self, *arg, **kwargs):
print '##########################################################'
print '### This file is generated by ./manage.py dump_topics. ###'
print '##########################################################'
print 'from tower import ugettext as _\n'
for tag in TaggedItem.tags_for(Document):
print '_("""{tag}""", "KB Topic")'.format(tag=tag.name)
def done(self, form_list, form_dict, **kw):
"""Overriden to do a job"""
options = self.get_options()
data = {}
for f in form_list:
data.update(f.cleaned_data)
data.update(self.request.session[options['session_prefix']])
content_type = ContentType.objects.get_by_natural_key(data['app_label'], data['model'])
ids = data['ids']
model = content_type.model_class()
objs = model.objects.filter(pk__in=ids)
ids = list(objs.values_list('pk', flat=True))
cnt = len(ids)
tags = [Tag.objects.get_or_create(name=t)[0] for t in data['tags']]
existent = TaggedItem.objects.filter(tag__in=tags, content_type=content_type, object_id__in=ids)
if data['clear']:
existent.delete()
messages.add_message(self.request, messages.INFO, _("Untagged %(number)s %(model_name)s") % {
"number": cnt,
"model_name": model_ngettext(model._meta, cnt)
})
else:
existent_tags = set([(e.tag_id, e.object_id) for e in existent])
tagged_items = [
TaggedItem(tag=tag, content_type=content_type, object_id=o.id)
for o in objs for tag in tags if not (tag.id, o.id) in existent_tags
]
TaggedItem.objects.bulk_create(tagged_items)
messages.add_message(self.request, messages.INFO, _("Tagged %(number)s %(model_name)s") % {
"number": cnt,
"model_name": model_ngettext(model._meta, cnt)
})
return HttpResponseRedirect(data['referer'])
def tag_cloud(self, other_model=None, queryset=None, published=True):
from taggit.models import TaggedItem
tag_ids = self._taglist(other_model, queryset)
kwargs = {}
if published:
kwargs = TaggedItem.bulk_lookup_kwargs(self.model.objects.published())
kwargs['tag_id__in'] = tag_ids
counted_tags = dict(TaggedItem.objects
.filter(**kwargs)
.values('tag')
.annotate(count=models.Count('tag'))
.values_list('tag', 'count'))
tags = TaggedItem.tag_model().objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def get_tags(self, request, namespace):
"""
Get tags with articles count for given namespace string.
Return list of Tag objects ordered by custom 'num_articles' attribute.
"""
if (request and hasattr(request, 'toolbar') and
request.toolbar and request.toolbar.edit_mode):
articles = self.namespace(namespace)
else:
articles = self.published().namespace(namespace)
if not articles:
# return empty iterable early not to perform useless requests
return []
kwargs = TaggedItem.bulk_lookup_kwargs(articles)
# aggregate and sort
counted_tags = dict(TaggedItem.objects
.filter(**kwargs)
.values('tag')
.annotate(tag_count=models.Count('tag'))
.values_list('tag', 'tag_count'))
# and finally get the results
tags = Tag.objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.num_articles = counted_tags[tag.pk]
return sorted(tags, key=attrgetter('num_articles'), reverse=True)
def tag_cloud(self,
other_model=None,
queryset=None,
published=True,
on_site=False):
from taggit.models import TaggedItem
if on_site:
queryset = queryset.on_site()
tag_ids = self._taglist(other_model, queryset)
kwargs = {}
if published:
kwargs = {
"object_id__in": self.model.objects.published(),
"content_type": ContentType.objects.get_for_model(self.model),
}
kwargs["tag_id__in"] = tag_ids
counted_tags = dict(
TaggedItem.objects.filter(**kwargs).values("tag").annotate(
count=models.Count("tag")).values_list("tag", "count"))
tags = TaggedItem.tag_model().objects.filter(
pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def get_tags(self, entries=None, language=None):
"""Returns tags used to tag post and its count. Results are ordered by count."""
if not entries:
entries = self
if language:
entries = entries.filter_by_language(language)
entries = entries.distinct()
if not entries:
return []
kwargs = TaggedItem.bulk_lookup_kwargs(entries)
# aggregate and sort
counted_tags = dict(TaggedItem.objects
.filter(**kwargs)
.values('tag')
.annotate(count=models.Count('tag'))
.values_list('tag', 'count'))
# and finally get the results
tags = Tag.objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def tag_cloud(self, other_model=None, queryset=None, published=True):
from taggit.models import TaggedItem
tag_ids = self._taglist(other_model, queryset)
kwargs = {}
if published:
kwargs = TaggedItem.bulk_lookup_kwargs(self.model.objects.published())
kwargs['tag_id__in'] = tag_ids
counted_tags = dict(TaggedItem.objects
.filter(**kwargs)
.values('tag')
.annotate(count=models.Count('tag'))
.values_list('tag', 'count'))
tags = TaggedItem.tag_model().objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def get_tags(self, request, namespace):
"""
Get tags with articles count for given namespace string.
Return list of Tag objects ordered by custom 'num_articles' attribute.
"""
if (request and hasattr(request, 'toolbar') and request.toolbar
and request.toolbar.edit_mode):
articles = self.namespace(namespace)
else:
articles = self.published().namespace(namespace)
if not articles:
# return empty iterable early not to perform useless requests
return []
kwargs = TaggedItem.bulk_lookup_kwargs(articles)
# aggregate and sort
counted_tags = dict(
TaggedItem.objects.filter(**kwargs).values('tag').annotate(
tag_count=models.Count('tag')).values_list('tag', 'tag_count'))
# and finally get the results
tags = Tag.objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.num_articles = counted_tags[tag.pk]
return sorted(tags, key=attrgetter('num_articles'), reverse=True)
def extract_document(cls, obj_id):
"""Extracts indexable attributes from a Question and its answers."""
# Note: Need to keep this in sync with
# tasks.update_question_vote_chunk.
obj = cls.uncached.values(
'id', 'title', 'content', 'num_answers', 'solution_id',
'is_locked', 'created', 'updated', 'num_votes_past_week',
'creator__username').get(pk=obj_id)
d = {}
d['id'] = obj['id']
d['model'] = cls.get_model_name()
d['title'] = obj['title']
d['question_content'] = obj['content']
d['num_answers'] = obj['num_answers']
d['is_solved'] = bool(obj['solution_id'])
d['is_locked'] = obj['is_locked']
d['has_answers'] = bool(obj['num_answers'])
# We do this because get_absolute_url is an instance method
# and we don't want to create an instance because it's a DB
# hit and expensive. So we do it by hand. get_absolute_url
# doesn't change much, so this is probably ok.
d['url'] = reverse('questions.answers',
kwargs={'question_id': obj['id']})
# TODO: Sphinx stores created and updated as seconds since the
# epoch, so we convert them to that format here so that the
# search view works correctly. When we ditch Sphinx, we should
# see if it's faster to filter on ints or whether we should
# switch them to dates.
d['created'] = int(time.mktime(obj['created'].timetuple()))
d['updated'] = int(time.mktime(obj['updated'].timetuple()))
d['question_creator'] = obj['creator__username']
d['num_votes'] = (QuestionVote.objects
.filter(question=obj['id'])
.count())
d['num_votes_past_week'] = obj['num_votes_past_week']
d['tag'] = list(TaggedItem.tags_for(
Question, Question(pk=obj_id)).values_list('name', flat=True))
answer_values = list(Answer.objects
.filter(question=obj_id)
.values_list('content',
'creator__username'))
d['answer_content'] = [a[0] for a in answer_values]
d['answer_creator'] = list(set([a[1] for a in answer_values]))
if not answer_values:
d['has_helpful'] = False
else:
d['has_helpful'] = Answer.objects.filter(
question=obj_id).filter(votes__helpful=True).exists()
d['indexed_on'] = int(time.time())
return d
def userfeed_tags(user):
'''Return all the UserFeed tags for a user.'''
#ct = ContentType.objects.get_for_model(UserFeed)
kwargs = {
"userfeed__in": UserFeed.objects.filter(user=user)
}
tags = TaggedItem.tag_model().objects.filter(**kwargs).distinct()
return tags
def view_questions(request, questions_template):
questions_count = Question.objects.count()
#FIXME/TODO:This has to be cached at all costs
all_tags = TaggedItem.tags_for(Question)
return response(request, questions_template, {
'questions_count': questions_count,
'all_tags': all_tags
})
def set_taggeditems(self):
objects = OldTaggedItem.objects.all()
print objects.count()
for old_tagitem in objects:
old_id = old_tagitem.tag_id
new_id = self.dupemap.get(old_id, old_id)
new_tags = NewTag.objects.filter(id=new_id)
if new_tags:
new_tag = new_tags[0]
new_tagitem = NewTaggedItem(
id=old_tagitem.id,
tag=new_tag,
content_type=old_tagitem.content_type,
object_id=old_tagitem.object_id,
)
new_tagitem.save()
print NewTaggedItem.objects.count()
def read(cls, req, slug=None, model=None):
if model:
models = [System, Module, Interface, ArchitecturalPattern]
lookup = dict(zip(map(lambda model: model._meta.object_name.lower(), models), models))
return TaggedItem.tags_for(lookup[model])
if slug:
return map(lambda i: i.content_object, TaggedItem.objects.select_related().filter(tag=Tag.objects.get(slug=slug)))
else:
return map(lambda i: dict(name=i['name'], count=i['count'], resource_uri=reverse('api_tag', args=[i['slug']])), Tag.objects.values('name', 'slug').annotate(count=Count('taggit_taggeditem_items')).order_by('-count'))
def clean(self):
data = self.cleaned_data
if data['auto']:
tags = set(data['tags'])
tags.update([
tag
for tag in TaggedItem.tags_for(models.Post)
if re.search(r'\b%s\b' % tag.name, data['content'], re.I|re.M)
])
data['tags'] = list(tags)
return data
def lookups(self, request, model_admin):
"""
Returns a list of tuples. The first element in each tuple is the coded value
for the option that will appear in the URL query. The second element is the
human-readable name for the option that will appear in the right sidebar.
"""
list = []
tags = TaggedItem.tags_for(model_admin.model)
for tag in tags:
list.append( (tag.name, _(tag.name)) )
return list
def lookups(self, request, model_admin):
"""
Returns a list of tuples. The first element in each tuple is the coded value
for the option that will appear in the URL query. The second element is the
human-readable name for the option that will appear in the right sidebar.
"""
list = []
tags = TaggedItem.tags_for(model_admin.model)
for tag in tags:
list.append( (tag.name, (tag.name)) )
return list
def lookups(self, request, model_admin):
"""
Returns tuple of tuples (key, value) for available Tag choices.
:param request: the Request instance.
:param model_admin: the ModelAdmin instance.
:rtype: tuple.
"""
return (
(tag.id, tag.name)
for tag in TaggedItem.tags_for(Ticket)
)
def get_context_data(self, **kwargs):
query = self.request.GET.get('query', None)
if query is None:
return {'tags': []}
filter = {}
if len(query) > 3:
filter['name__icontains'] = query
else:
filter['name__istartswith'] = query
tags = TaggedItem.tags_for(Icon).filter(**filter).order_by('name')
return {
'tags': [t.name for t in tags]
}
def forwards(self, orm):
for entry in orm['checklists.Entry'].objects.all():
tags = TaggedItem.tags_for(orm['checklists.Entry'], entry)
for label in [unicode(tag) for tag in tags]:
names = {}
# Add localized fields for the SpeciesGroup table
for language_code, language_name in settings.LANGUAGES:
if settings.LANGUAGE_CODE == language_code:
names['name_%s' % language_code] = label.capitalize()
else:
names['name_%s' % language_code] = ''
tag, created = orm['checklists.EntryTag'].objects.get_or_create(
slug=label.lower(),
**names
)
entry.tags.add(tag)
def extract_document(cls, obj_id):
"""Extracts indexable attributes from a Question and its answers."""
obj = cls.uncached.values(
"id",
"title",
"content",
"num_answers",
"solution_id",
"is_locked",
"created",
"updated",
"num_votes_past_week",
"creator__username",
).get(pk=obj_id)
d = {}
d["id"] = obj["id"]
d["title"] = obj["title"]
d["question_content"] = obj["content"]
d["replies"] = obj["num_answers"]
d["is_solved"] = bool(obj["solution_id"])
d["is_locked"] = obj["is_locked"]
d["has_answers"] = bool(obj["num_answers"])
# TODO: Sphinx stores created and updated as seconds since the
# epoch, so we convert them to that format here so that the
# search view works correctly. When we ditch Sphinx, we should
# see if it's faster to filter on ints or whether we should
# switch them to dates.
d["created"] = int(time.mktime(obj["created"].timetuple()))
d["updated"] = int(time.mktime(obj["updated"].timetuple()))
d["question_creator"] = obj["creator__username"]
d["question_votes"] = obj["num_votes_past_week"]
d["tag"] = list(TaggedItem.tags_for(Question, Question(pk=obj_id)).values_list("name", flat=True))
answer_values = list(Answer.objects.filter(question=obj_id).values_list("content", "creator__username"))
d["answer_content"] = [a[0] for a in answer_values]
d["answer_creator"] = list(set([a[1] for a in answer_values]))
if not answer_values:
d["has_helpful"] = False
else:
d["has_helpful"] = Answer.objects.filter(question=obj_id).filter(votes__helpful=True).exists()
return d
def view_tagged_questions(request, tag_name, tagged_questions_template):
tag = get_object_or_404(Tag, name=tag_name)
questions = Question.objects.filter(tags__name__in=[tag_name]).values('id', 'slug', 'title')
paginator = Paginator(questions, settings.DEFAULT_PAGINATION_COUNT)
try:
page = int(request.GET.get('page', 1))
except ValueError:
page = 1
try:
questions = paginator.page(page)
except (EmptyPage, InvalidPage):
questions = paginator.page(paginator.num_pages)
#FIXME/TODO:This has to be cached at all costs
all_tags = TaggedItem.tags_for(Question)
return response(request, tagged_questions_template, {'questions': questions.object_list,
'tag': tag,
'all_tags':all_tags})
def _add_tags(obj, tags_str, creator, content_type_name):
for tag_name in tags_str.split(','):
tag_name = tag_name.strip()
# don't recreate the tag if it already exists
try:
t = Tag.objects.get(slug=slugify(tag_name))
except ObjectDoesNotExist as dne:
t = Tag()
t.name = tag_name[:99]
t.slug = slugify(tag_name)
t.save()
ti = TaggedItem()
ti.tag = t
ti.object_id = obj.id
ti.tag_creator = creator
ti.content_type = ContentType.objects.filter(name=content_type_name)[0]
ti.save()
def get_tags(self, language):
"""Returns tags used to tag post and its count. Results are ordered by count."""
# get tagged post
entries = self.filter_by_language(language).distinct()
if not entries:
return []
kwargs = TaggedItem.bulk_lookup_kwargs(entries)
# aggregate and sort
counted_tags = dict(
TaggedItem.objects.filter(**kwargs).values('tag').annotate(
count=models.Count('tag')).values_list('tag', 'count'))
# and finally get the results
tags = Tag.objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.count = counted_tags[tag.pk]
return sorted(tags, key=lambda x: -x.count)
def view_tagged_questions(request, tag_name, tagged_questions_template):
tag = get_object_or_404(Tag, name=tag_name)
questions = Question.objects.filter(tags__name__in=[tag_name]).values(
'id', 'slug', 'title')
paginator = Paginator(questions, settings.DEFAULT_PAGINATION_COUNT)
try:
page = int(request.GET.get('page', 1))
except ValueError:
page = 1
try:
questions = paginator.page(page)
except (EmptyPage, InvalidPage):
questions = paginator.page(paginator.num_pages)
#FIXME/TODO:This has to be cached at all costs
all_tags = TaggedItem.tags_for(Question)
return response(request, tagged_questions_template, {
'questions': questions.object_list,
'tag': tag,
'all_tags': all_tags
})
def get_tags(self, namespace):
"""
Get tags with articles count for given namespace string.
Returns list of Tag objects with ordered by custom 'num_entries' attribute.
"""
entries = self.filter(app_config__namespace=namespace)
if not entries:
return []
kwargs = TaggedItem.bulk_lookup_kwargs(entries)
# aggregate and sort
counted_tags = dict(
TaggedItem.objects.filter(**kwargs).values('tag').annotate(
tag_count=models.Count('tag')).values_list('tag', 'tag_count'))
# and finally get the results
tags = Tag.objects.filter(pk__in=counted_tags.keys())
for tag in tags:
tag.num_entries = counted_tags[tag.pk]
return sorted(tags, key=attrgetter('num_entries'), reverse=True)
def lookups(self, request, model_admin):
t = list()
for i in TaggedItem.tags_for(model_admin.model):
t.append((i.slug, i.name))
return t
def extract_document(cls, obj_id, obj=None):
"""Extracts indexable attributes from a Question and its answers."""
fields = ['id', 'title', 'content', 'num_answers', 'solution_id',
'is_locked', 'is_archived', 'created', 'updated',
'num_votes_past_week', 'locale', 'product_id', 'topic_id',
'is_spam']
composed_fields = ['creator__username']
all_fields = fields + composed_fields
if obj is None:
# Note: Need to keep this in sync with
# tasks.update_question_vote_chunk.
model = cls.get_model()
obj = model.objects.values(*all_fields).get(pk=obj_id)
else:
fixed_obj = dict([(field, getattr(obj, field))
for field in fields])
fixed_obj['creator__username'] = obj.creator.username
obj = fixed_obj
if obj['is_spam']:
raise UnindexMeBro()
d = {}
d['id'] = obj['id']
d['model'] = cls.get_mapping_type_name()
# We do this because get_absolute_url is an instance method
# and we don't want to create an instance because it's a DB
# hit and expensive. So we do it by hand. get_absolute_url
# doesn't change much, so this is probably ok.
d['url'] = reverse('questions.details',
kwargs={'question_id': obj['id']})
d['indexed_on'] = int(time.time())
d['created'] = int(time.mktime(obj['created'].timetuple()))
d['updated'] = int(time.mktime(obj['updated'].timetuple()))
topics = Topic.objects.filter(id=obj['topic_id'])
products = Product.objects.filter(id=obj['product_id'])
d['topic'] = [t.slug for t in topics]
d['product'] = [p.slug for p in products]
d['question_title'] = obj['title']
d['question_content'] = obj['content']
d['question_num_answers'] = obj['num_answers']
d['question_is_solved'] = bool(obj['solution_id'])
d['question_is_locked'] = obj['is_locked']
d['question_is_archived'] = obj['is_archived']
d['question_has_answers'] = bool(obj['num_answers'])
d['question_creator'] = obj['creator__username']
d['question_num_votes'] = (QuestionVote.objects
.filter(question=obj['id'])
.count())
d['question_num_votes_past_week'] = obj['num_votes_past_week']
d['question_tag'] = list(TaggedItem.tags_for(
Question, Question(pk=obj_id)).values_list('name', flat=True))
d['question_locale'] = obj['locale']
answer_values = list(Answer.objects
.filter(question=obj_id, is_spam=False)
.values_list('content',
'creator__username'))
d['question_answer_content'] = [a[0] for a in answer_values]
d['question_answer_creator'] = list(set(a[1] for a in answer_values))
if not answer_values:
d['question_has_helpful'] = False
else:
d['question_has_helpful'] = Answer.objects.filter(
question=obj_id).filter(votes__helpful=True).exists()
return d
def get_queryset(self):
return TaggedItem.tags_for(Post)
def tags_used_for_submissions():
return TaggedItem.tags_for(Submission)
def extract_document(cls, obj_id, obj=None):
"""Extracts indexable attributes from a Question and its answers."""
fields = ['id', 'title', 'content', 'num_answers', 'solution_id',
'is_locked', 'is_archived', 'created', 'updated',
'num_votes_past_week', 'locale', 'product_id', 'topic_id',
'is_spam']
composed_fields = ['creator__username']
all_fields = fields + composed_fields
if obj is None:
# Note: Need to keep this in sync with
# tasks.update_question_vote_chunk.
model = cls.get_model()
obj = model.objects.values(*all_fields).get(pk=obj_id)
else:
fixed_obj = dict([(field, getattr(obj, field))
for field in fields])
fixed_obj['creator__username'] = obj.creator.username
obj = fixed_obj
if obj['is_spam']:
raise UnindexMeBro()
d = {}
d['id'] = obj['id']
d['model'] = cls.get_mapping_type_name()
# We do this because get_absolute_url is an instance method
# and we don't want to create an instance because it's a DB
# hit and expensive. So we do it by hand. get_absolute_url
# doesn't change much, so this is probably ok.
d['url'] = reverse('questions.details',
kwargs={'question_id': obj['id']})
d['indexed_on'] = int(time.time())
d['created'] = int(time.mktime(obj['created'].timetuple()))
d['updated'] = int(time.mktime(obj['updated'].timetuple()))
topics = Topic.objects.filter(id=obj['topic_id'])
products = Product.objects.filter(id=obj['product_id'])
d['topic'] = [t.slug for t in topics]
d['product'] = [p.slug for p in products]
d['question_title'] = obj['title']
d['question_content'] = obj['content']
d['question_num_answers'] = obj['num_answers']
d['question_is_solved'] = bool(obj['solution_id'])
d['question_is_locked'] = obj['is_locked']
d['question_is_archived'] = obj['is_archived']
d['question_has_answers'] = bool(obj['num_answers'])
d['question_creator'] = obj['creator__username']
d['question_num_votes'] = (QuestionVote.objects
.filter(question=obj['id'])
.count())
d['question_num_votes_past_week'] = obj['num_votes_past_week']
d['question_tag'] = list(TaggedItem.tags_for(
Question, Question(pk=obj_id)).values_list('name', flat=True))
d['question_locale'] = obj['locale']
answer_values = list(Answer.objects
.filter(question=obj_id, is_spam=False)
.values_list('content',
'creator__username'))
d['question_answer_content'] = [a[0] for a in answer_values]
d['question_answer_creator'] = list(set(a[1] for a in answer_values))
if not answer_values:
d['question_has_helpful'] = False
else:
d['question_has_helpful'] = Answer.objects.filter(
question=obj_id).filter(votes__helpful=True).exists()
return d
def message_log(req, context={}, template="messagelog/index.html"):
messages = Message.objects.all()
if 'messages_qs' in context:
messages = context['messages_qs']
contact = None
search = None
show_advanced_filter = None # "Y" to show the advanced filter, "N" to hide it
all_tags = [] # A distinct list of all tags pertaining to any Messages in the Message Log
selected_tags = None # The tags selected by the user by which to filter the Messages
tag_filter_flag = None # "Y" if the user chose to do tag filtering, "N" otherwise
tag_filter_style = None # Tag filtering style: "any" to show Messages which match any of the selected_tags,
# "all" to show Messages which match all of the selected tags
if 'contact' in req.GET:
if req.GET['contact'] == '':
contact=None
else:
contact = Contact.objects.get(pk=req.GET['contact'])
messages = messages.filter(contact=contact)
if 'search' in req.GET and req.GET['search'] != '':
search = req.GET['search']
safe_search = re.escape(search.strip("'\""))
messages = messages.filter(Q(text__iregex=safe_search) |\
Q(connection__identity__iregex=safe_search))
# Extract and sort all tag names
for tag in TaggedItem.tags_for(Message):
all_tags.append(tag.name)
all_tags.sort()
# Retrieve list of selected tags (default to empty list)
if "selected_tags" in req.GET:
selected_tags = req.GET.getlist("selected_tags")
else:
selected_tags = []
# Retrieve tag filter flag (default to "N")
if "tag_filter_flag" in req.GET and req.GET["tag_filter_flag"] == "Y":
tag_filter_flag = req.GET["tag_filter_flag"]
else:
tag_filter_flag = "N"
# Retrieve advanced filter flag
if ("show_advanced_filter" in req.GET and req.GET["show_advanced_filter"] == "Y") or (tag_filter_flag == "Y"):
show_advanced_filter = "Y"
else:
show_advanced_filter = "N"
# Retrieve tag filter style (default to "any")
if "tag_filter_style" in req.GET and req.GET["tag_filter_style"] == "all":
tag_filter_style = req.GET["tag_filter_style"]
else:
tag_filter_style = "any"
# If no tags were selected, automatically disable tag filtering
if len(selected_tags) == 0:
tag_filter_flag = "N"
# If the user chose to do tag filtering, perform the filter now
if tag_filter_flag == "Y":
if tag_filter_style == "all":
for tag_name in selected_tags:
messages = messages.filter(tags__name__in=[tag_name])
else:
messages = messages.filter(tags__name__in=selected_tags).distinct()
context.update({
"messages_table": MessageTable(messages, request=req),
"search": search,
"contact": contact,
"contacts": Contact.objects.all().order_by("name"),
"show_advanced_filter": show_advanced_filter,
"all_tags": all_tags,
"selected_tags": selected_tags,
"tag_filter_flag": tag_filter_flag,
"tag_filter_style": tag_filter_style
})
return render_to_response(
template, context, context_instance=RequestContext(req)
)
def lookups(self, request, model_admin):
model_tags = [tag.name for tag in
TaggedItem.tags_for(model_admin.model)]
model_tags.sort()
return tuple([(tag, tag) for tag in model_tags])
def lookups(self, request, model_admin):
model_tags = [
tag.name for tag in TaggedItem.tags_for(model_admin.model)
]
model_tags.sort()
return tuple([(tag, tag) for tag in model_tags])
def categories(self):
return TaggedItem.tags_for(Post)
def extract_document(cls, obj_id, obj=None):
"""Extracts indexable attributes from a Question and its answers."""
fields = ['id', 'title', 'content', 'num_answers', 'solution_id',
'is_locked', 'created', 'updated', 'num_votes_past_week',
'locale']
composed_fields = ['creator__username']
all_fields = fields + composed_fields
if obj is None:
# Note: Need to keep this in sync with
# tasks.update_question_vote_chunk.
obj = cls.uncached.values(*all_fields).get(pk=obj_id)
else:
fixed_obj = dict([(field, getattr(obj, field))
for field in fields])
fixed_obj['creator__username'] = obj.creator.username
obj = fixed_obj
d = {}
d['id'] = obj['id']
d['document_id'] = cls.get_document_id(obj['id'])
d['model'] = cls.get_model_name()
# We do this because get_absolute_url is an instance method
# and we don't want to create an instance because it's a DB
# hit and expensive. So we do it by hand. get_absolute_url
# doesn't change much, so this is probably ok.
d['url'] = reverse('questions.answers',
kwargs={'question_id': obj['id']})
d['indexed_on'] = int(time.time())
# TODO: Sphinx stores created and updated as seconds since the
# epoch, so we convert them to that format here so that the
# search view works correctly. When we ditch Sphinx, we should
# see if it's faster to filter on ints or whether we should
# switch them to dates.
d['created'] = int(time.mktime(obj['created'].timetuple()))
d['updated'] = int(time.mktime(obj['updated'].timetuple()))
topics = Topic.uncached.filter(question__id=obj['id'])
products = Product.uncached.filter(question__id=obj['id'])
d['topic'] = [t.slug for t in topics]
d['product'] = [p.slug for p in products]
d['question_title'] = obj['title']
d['question_content'] = obj['content']
d['question_num_answers'] = obj['num_answers']
d['question_is_solved'] = bool(obj['solution_id'])
d['question_is_locked'] = obj['is_locked']
d['question_has_answers'] = bool(obj['num_answers'])
d['question_creator'] = obj['creator__username']
d['question_num_votes'] = (QuestionVote.objects
.filter(question=obj['id'])
.count())
d['question_num_votes_past_week'] = obj['num_votes_past_week']
d['question_tag'] = list(TaggedItem.tags_for(
Question, Question(pk=obj_id)).values_list('name', flat=True))
d['question_locale'] = obj['locale']
answer_values = list(Answer.objects
.filter(question=obj_id)
.values_list('content',
'creator__username'))
d['question_answer_content'] = [a[0] for a in answer_values]
d['question_answer_creator'] = list(set(a[1] for a in answer_values))
if not answer_values:
d['question_has_helpful'] = False
else:
d['question_has_helpful'] = Answer.objects.filter(
question=obj_id).filter(votes__helpful=True).exists()
return d
def tags_used_for_submissions():
return TaggedItem.tags_for(Submission)
def message_log(req, context={}, template="messagelog/index.html"):
messages = Message.objects.all()
if 'messages_qs' in context:
messages = context['messages_qs']
contact = None
search = None
show_advanced_filter = None # "Y" to show the advanced filter, "N" to hide it
all_tags = [
] # A distinct list of all tags pertaining to any Messages in the Message Log
selected_tags = None # The tags selected by the user by which to filter the Messages
tag_filter_flag = None # "Y" if the user chose to do tag filtering, "N" otherwise
tag_filter_style = None # Tag filtering style: "any" to show Messages which match any of the selected_tags,
# "all" to show Messages which match all of the selected tags
if 'contact' in req.GET:
if req.GET['contact'] == '':
contact = None
else:
contact = Contact.objects.get(pk=req.GET['contact'])
messages = messages.filter(contact=contact)
if 'search' in req.GET and req.GET['search'] != '':
search = req.GET['search']
safe_search = re.escape(search.strip("'\""))
messages = messages.filter(Q(text__iregex=safe_search) |\
Q(connection__identity__iregex=safe_search))
# Extract and sort all tag names
for tag in TaggedItem.tags_for(Message):
all_tags.append(tag.name)
all_tags.sort()
# Retrieve list of selected tags (default to empty list)
if "selected_tags" in req.GET:
selected_tags = req.GET.getlist("selected_tags")
else:
selected_tags = []
# Retrieve tag filter flag (default to "N")
if "tag_filter_flag" in req.GET and req.GET["tag_filter_flag"] == "Y":
tag_filter_flag = req.GET["tag_filter_flag"]
else:
tag_filter_flag = "N"
# Retrieve advanced filter flag
if ("show_advanced_filter" in req.GET
and req.GET["show_advanced_filter"] == "Y") or (tag_filter_flag
== "Y"):
show_advanced_filter = "Y"
else:
show_advanced_filter = "N"
# Retrieve tag filter style (default to "any")
if "tag_filter_style" in req.GET and req.GET["tag_filter_style"] == "all":
tag_filter_style = req.GET["tag_filter_style"]
else:
tag_filter_style = "any"
# If no tags were selected, automatically disable tag filtering
if len(selected_tags) == 0:
tag_filter_flag = "N"
# If the user chose to do tag filtering, perform the filter now
if tag_filter_flag == "Y":
if tag_filter_style == "all":
for tag_name in selected_tags:
messages = messages.filter(tags__name__in=[tag_name])
else:
messages = messages.filter(tags__name__in=selected_tags).distinct()
context.update({
"messages_table": MessageTable(messages, request=req),
"search": search,
"contact": contact,
"contacts": Contact.objects.all().order_by("name"),
"show_advanced_filter": show_advanced_filter,
"all_tags": all_tags,
"selected_tags": selected_tags,
"tag_filter_flag": tag_filter_flag,
"tag_filter_style": tag_filter_style
})
return render_to_response(template,
context,
context_instance=RequestContext(req))
def view_questions(request, questions_template):
questions_count = Question.objects.count()
#FIXME/TODO:This has to be cached at all costs
all_tags = TaggedItem.tags_for(Question)
return response(request, questions_template, {'questions_count':questions_count,
'all_tags':all_tags})
def focus(request, field, value, template_name="tasks/focus.html"):
group, bridge = group_and_bridge(request)
if group:
is_member = group.request.user_is_member()
else:
is_member = True
group_by = request.GET.get("group_by")
filter_only = request.GET.get("filter_only", False)
tags_list = []
expanded_tags_list = []
if group:
tasks = group.content_objects(Task)
else:
tasks = Task.objects.filter(object_id=None)
# default filtering
state_keys = dict(workflow.STATE_CHOICES).keys()
default_states = set(state_keys).difference(
# don't show these states
set(["2", "3"])
)
# have to store for each prefix because initial data isn't support on the
# FilterSet
filter_data = {
"state": list(default_states),
}
filter_data.update(request.GET)
task_filter = TaskFilter(filter_data, queryset=tasks)
if field == "modified":
try:
# @@@ this seems hackish and brittle but I couldn't work out another way
year, month, day = value.split("-")
# have to int month and day in case zero-padded
tasks = tasks.filter(modified__year=int(year), modified__month=int(month), modified__day=int(day))
except:
tasks = Task.objects.none() # @@@ or throw 404?
elif field == "state":
task_filter = None # prevent task filtering
try:
state = workflow.REVERSE_STATE_CHOICES[value]
except KeyError:
raise Http404
tasks = tasks.filter(state=state)
elif field == "assignee":
if value == "unassigned": # @@@ this means can"t have a username "unassigned":
tasks = tasks.filter(assignee__isnull=True)
else:
try:
assignee = User.objects.get(username=value)
tasks = tasks.filter(assignee=assignee)
except User.DoesNotExist:
tasks = Task.objects.none() # @@@ or throw 404?
elif field == "tag":
tags_list = urllib.unquote_plus(value).split()
task_tags = TaggedItem.tags_for(Task)
for tag in tags_list:
if tag.endswith(":*"):
expanded_tags_list.extend(t.name for t in task_tags.filter(name__startswith=tag[:-1]))
else:
expanded_tags_list.append(tag)
tasks = tasks.filter(tags__name__in=expanded_tags_list)
if task_filter is not None:
# Django will not merge queries that are both not distinct or distinct
tasks = tasks.distinct() & task_filter.qs
group_by_querydict = request.GET.copy()
group_by_querydict.pop("group_by", None)
group_by_querystring = group_by_querydict.urlencode()
ctx = group_context(group, bridge)
ctx.update({
"task_filter": task_filter,
"tasks": tasks,
"field": field,
"value": value,
"group_by": group_by,
"gbqs": group_by_querystring,
"is_member": is_member,
"task_tags": Task.tags.all(),
"filter_only": filter_only,
"tags_list": expanded_tags_list,
})
return render_to_response(template_name, RequestContext(request, ctx))
def get_context_data(self, **kwargs):
context = super(BlogBaseView, self).get_context_data(**kwargs)
context['blog_tags'] = TaggedItem.tags_for(Blog).order_by('name')
context['recent_blog_list'] = Blog.objects.recent_posts()
return context
def extract_document(cls, obj_id, obj=None):
"""Extracts indexable attributes from a Question and its answers."""
fields = ['id', 'title', 'content', 'num_answers', 'solution_id',
'is_locked', 'created', 'updated', 'num_votes_past_week',
'locale']
composed_fields = ['creator__username']
all_fields = fields + composed_fields
if obj is None:
# Note: Need to keep this in sync with
# tasks.update_question_vote_chunk.
obj = cls.uncached.values(*all_fields).get(pk=obj_id)
else:
fixed_obj = dict([(field, getattr(obj, field))
for field in fields])
fixed_obj['creator__username'] = obj.creator.username
obj = fixed_obj
d = {}
d['id'] = obj['id']
d['document_id'] = cls.get_document_id(obj['id'])
d['model'] = cls.get_model_name()
# We do this because get_absolute_url is an instance method
# and we don't want to create an instance because it's a DB
# hit and expensive. So we do it by hand. get_absolute_url
# doesn't change much, so this is probably ok.
d['url'] = reverse('questions.answers',
kwargs={'question_id': obj['id']})
d['indexed_on'] = int(time.time())
# TODO: Sphinx stores created and updated as seconds since the
# epoch, so we convert them to that format here so that the
# search view works correctly. When we ditch Sphinx, we should
# see if it's faster to filter on ints or whether we should
# switch them to dates.
d['created'] = int(time.mktime(obj['created'].timetuple()))
d['updated'] = int(time.mktime(obj['updated'].timetuple()))
topics = Topic.uncached.filter(question__id=obj['id'])
products = Product.uncached.filter(question__id=obj['id'])
d['topic'] = [t.slug for t in topics]
d['product'] = [p.slug for p in products]
d['question_title'] = obj['title']
d['question_content'] = obj['content']
d['question_num_answers'] = obj['num_answers']
d['question_is_solved'] = bool(obj['solution_id'])
d['question_is_locked'] = obj['is_locked']
d['question_has_answers'] = bool(obj['num_answers'])
d['question_creator'] = obj['creator__username']
d['question_num_votes'] = (QuestionVote.objects
.filter(question=obj['id'])
.count())
d['question_num_votes_past_week'] = obj['num_votes_past_week']
d['question_tag'] = list(TaggedItem.tags_for(
Question, Question(pk=obj_id)).values_list('name', flat=True))
d['question_locale'] = obj['locale']
answer_values = list(Answer.objects
.filter(question=obj_id)
.values_list('content',
'creator__username'))
d['question_answer_content'] = [a[0] for a in answer_values]
d['question_answer_creator'] = list(set(a[1] for a in answer_values))
if not answer_values:
d['question_has_helpful'] = False
else:
d['question_has_helpful'] = Answer.objects.filter(
question=obj_id).filter(votes__helpful=True).exists()
return d
def entry_tags(self):
"""Returns a :class:`QuerySet` of :class:`.Tag`\ s that are used on any entries in this blog."""
entry_pks = list(self.entries.values_list('pk', flat=True))
kwargs = {'%s__object_id__in' % TaggedItem.tag_relname(): entry_pks}
return TaggedItem.tags_for(BlogEntry).filter(**kwargs)
def extract_document(cls, obj_id, obj=None):
"""Extracts indexable attributes from a Question and its answers."""
fields = [
"id",
"title",
"content",
"num_answers",
"solution_id",
"is_locked",
"created",
"updated",
"num_votes_past_week",
"locale",
]
composed_fields = ["creator__username"]
all_fields = fields + composed_fields
if obj is None:
# Note: Need to keep this in sync with
# tasks.update_question_vote_chunk.
model = cls.get_model()
obj = model.uncached.values(*all_fields).get(pk=obj_id)
else:
fixed_obj = dict([(field, getattr(obj, field)) for field in fields])
fixed_obj["creator__username"] = obj.creator.username
obj = fixed_obj
d = {}
d["id"] = obj["id"]
d["model"] = cls.get_mapping_type_name()
# We do this because get_absolute_url is an instance method
# and we don't want to create an instance because it's a DB
# hit and expensive. So we do it by hand. get_absolute_url
# doesn't change much, so this is probably ok.
d["url"] = reverse("questions.answers", kwargs={"question_id": obj["id"]})
d["indexed_on"] = int(time.time())
d["created"] = int(time.mktime(obj["created"].timetuple()))
d["updated"] = int(time.mktime(obj["updated"].timetuple()))
topics = Topic.uncached.filter(question__id=obj["id"])
products = Product.uncached.filter(question__id=obj["id"])
d["topic"] = [t.slug for t in topics]
d["product"] = [p.slug for p in products]
d["question_title"] = obj["title"]
d["question_content"] = obj["content"]
d["question_num_answers"] = obj["num_answers"]
d["question_is_solved"] = bool(obj["solution_id"])
d["question_is_locked"] = obj["is_locked"]
d["question_has_answers"] = bool(obj["num_answers"])
d["question_creator"] = obj["creator__username"]
d["question_num_votes"] = QuestionVote.objects.filter(question=obj["id"]).count()
d["question_num_votes_past_week"] = obj["num_votes_past_week"]
d["question_tag"] = list(TaggedItem.tags_for(Question, Question(pk=obj_id)).values_list("name", flat=True))
d["question_locale"] = obj["locale"]
answer_values = list(Answer.objects.filter(question=obj_id).values_list("content", "creator__username"))
d["question_answer_content"] = [a[0] for a in answer_values]
d["question_answer_creator"] = list(set(a[1] for a in answer_values))
if not answer_values:
d["question_has_helpful"] = False
else:
d["question_has_helpful"] = Answer.objects.filter(question=obj_id).filter(votes__helpful=True).exists()
return d
