def test_with_simple_space_delimited_tags(self):
""" Test with simple space-delimited tags. """
self.assertEquals(parse_tag_input('one'), [u'one'])
self.assertEquals(parse_tag_input('one two'), [u'one', u'two'])
self.assertEquals(parse_tag_input('one two three'), [u'one', u'three', u'two'])
self.assertEquals(parse_tag_input('one one two two'), [u'one', u'two'])
def add_search_results(self, request, queryset, search_results):
for item in queryset:
meta_content = parse_tag_input(item.tags)
meta_content += parse_tag_input(item.alias)
meta_content += [item.term, item.short_definition]
meta_content = " ".join(meta_content)
#print "meta: %r" % meta_content
search_results.add(
model_instance=item,
# displayed short_definition of the result hit
headline="%s: %s" % (item.term, item.short_definition),
# displayed in the result list
language=item.language,
# Link to the hit
url=item.get_absolute_url(),
# the main content -> result lines would be cut out from hits in this content
content=item.get_search_content(request),
# hits in meta content has a higher score, but the content would not displayed
meta_content=meta_content,
)
def testDoubleQuotedMultipleWords(self):
"""A completed quote will trigger this. Unclosed quotes are ignored."""
self.assertEqual([u'one'], parse_tag_input('"one'))
self.assertEqual([u'one', u'two'], parse_tag_input('"one two'))
self.assertEqual([u'one', u'three', u'two'], parse_tag_input('"one two three'))
self.assertEqual([u'one two'], parse_tag_input('"one two"'))
self.assertEqual([u'a-one', u'a-two and a-three'], parse_tag_input('a-one "a-two and a-three"'))
def test_with_simple_space_delimited_tags(self):
""" Test with simple space-delimited tags. """
self.assertEquals(parse_tag_input("one"), [u"one"])
self.assertEquals(parse_tag_input("one two"), [u"one", u"two"])
self.assertEquals(parse_tag_input("one two three"), [u"one", u"three", u"two"])
self.assertEquals(parse_tag_input("one one two two"), [u"one", u"two"])
def test_with_comma_delimited_multiple_words(self):
""" Test with comma-delimited multiple words.
An unquoted comma in the input will trigger this. """
self.assertEquals(parse_tag_input(",one"), [u"one"])
self.assertEquals(parse_tag_input(",one two"), [u"one two"])
self.assertEquals(parse_tag_input(",one two three"), [u"one two three"])
self.assertEquals(parse_tag_input("a-one, a-two and a-three"), [u"a-one", u"a-two and a-three"])
def test_with_double_quoted_multiple_words(self):
""" Test with double-quoted multiple words.
A completed quote will trigger this. Unclosed quotes are ignored. """
self.assertEquals(parse_tag_input('"one'), [u"one"])
self.assertEquals(parse_tag_input('"one two'), [u"one", u"two"])
self.assertEquals(parse_tag_input('"one two three'), [u"one", u"three", u"two"])
self.assertEquals(parse_tag_input('"one two"'), [u"one two"])
self.assertEquals(parse_tag_input('a-one "a-two and a-three"'), [u"a-one", u"a-two and a-three"])
def test_with_comma_delimited_multiple_words(self):
""" Test with comma-delimited multiple words.
An unquoted comma in the input will trigger this. """
self.assertEquals(parse_tag_input(',one'), [u'one'])
self.assertEquals(parse_tag_input(',one two'), [u'one two'])
self.assertEquals(parse_tag_input(',one two three'), [u'one two three'])
self.assertEquals(parse_tag_input('a-one, a-two and a-three'),
[u'a-one', u'a-two and a-three'])
def test_with_comma_delimited_multiple_words(self):
""" Test with comma-delimited multiple words.
An unquoted comma in the input will trigger this. """
self.assertEquals(parse_tag_input(',one'), [u'one'])
self.assertEquals(parse_tag_input(',one two'), [u'one two'])
self.assertEquals(parse_tag_input(',one two three'),
[u'one two three'])
self.assertEquals(parse_tag_input('a-one, a-two and a-three'),
[u'a-one', u'a-two and a-three'])
def test_with_double_quoted_multiple_words(self):
""" Test with double-quoted multiple words.
A completed quote will trigger this. Unclosed quotes are ignored. """
self.assertEquals(parse_tag_input('"one'), [u'one'])
self.assertEquals(parse_tag_input('"one two'), [u'one', u'two'])
self.assertEquals(parse_tag_input('"one two three'),
[u'one', u'three', u'two'])
self.assertEquals(parse_tag_input('"one two"'), [u'one two'])
self.assertEquals(parse_tag_input('a-one "a-two and a-three"'),
[u'a-one', u'a-two and a-three'])
def test_with_comma_delimited_multiple_words(self):
""" Test with comma-delimited multiple words.
An unquoted comma in the input will trigger this. """
self.assertEquals(parse_tag_input(",one"), [u"one"])
self.assertEquals(parse_tag_input(",one two"), [u"one two"])
self.assertEquals(parse_tag_input(",one two three"), [u"one two three"])
self.assertEquals(
parse_tag_input("a-one, a-two and a-three"),
[u"a-one", u"a-two and a-three"],
)
def update_tags(self, obj, tag_names):
"""
Update tags associated with an object.
"""
ctypes = ctypes_leading_to(obj)
current_tags = list(self.filter(items__content_type__pk__in=[ctype.pk for ctype in ctypes],
items__object_id=obj.pk))
updated_tag_names = parse_tag_input(tag_names)
if settings.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if tag.name not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(content_type__pk__in=[ctype.pk for ctype in ctypes],
object_id=obj.pk,
tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
for robj in get_all_parents_until_registered(obj):
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(name=tag_name)
TaggedItem._default_manager.create(tag=tag, object=robj)
def clean(self, value):
value = super(TagField, self).clean(value)
if value == u'':
return value
for tag_name in parse_tag_input(
value, default_namespace=self.default_namespace):
try:
check_tag_length(get_tag_parts(tag_name))
except (ValueError, e):
if len(e.args) < 3:
raise
part, max_len = e.args[1:3]
if part == 'tag':
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
max_len)
elif part == 'namespace':
raise forms.ValidationError(
_('Each tag\'s namespace may be no more than %s characters long.'
) % max_len)
elif part == 'name':
raise forms.ValidationError(
_('Each tag\'s name may be no more than %s characters long.'
) % max_len)
elif part == 'value':
raise forms.ValidationError(
_('Each tag\'s value may be no more than %s characters long.'
) % max_len)
else:
raise
return value
def pre_save_handler(sender, instance, **kwargs):
"""
Intercept attempts to save and sort the tag field alphabetically, so
we won't have different permutations in the filter list.
"""
taglist = parse_tag_input(instance.tags)
instance.tags = taglist_to_string(taglist)
def update_tags(self, obj, tag_names):
"""
Update tags associated with an object.
"""
ctype = ContentType.objects.get_for_model(obj)
current_tags = list(self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk))
updated_tag_names = parse_tag_input(tag_names)
if settings.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if tag.name not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
object_id=obj.pk,
tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(name=tag_name)
try:
TaggedItem._default_manager.create(tag=tag, object=obj)
except IntegrityError:
# there is a race condition between querying for current_tags above
# and calling create() here. another process / transaction
# may have already created this tag. This scenario usually occurs
# with two concurrent calls to a django model's save() method
# if the model has a TagField that is being changed. should be
# harmless to pass here since the TaggedItem already exists
pass
def update_tags(self, obj, tag_names, default_namespace=None, q=None):
"""
Update tags associated with an object.
Accepts a ``default_namespace`` parameter that is assigned to tags
with no namespace specified.
"""
ctype = ContentType.objects.get_for_model(obj)
current_tags = self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk)
if q is not None:
current_tags = current_tags.filter(q)
current_tags = list(current_tags)
updated_tag_names = parse_tag_input(
tag_names, default_namespace=default_namespace)
if conf.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if str(tag) not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(
content_type__pk=ctype.pk,
object_id=obj.pk,
tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [str(tag) for tag in current_tags]
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(**get_tag_parts(tag_name))
TaggedItem._default_manager.create(tag=tag, object=obj)
def update_tags(self, obj, tag_names, default_namespace=None, q=None):
"""
Update tags associated with an object.
Accepts a ``default_namespace`` parameter that is assigned to tags
with no namespace specified.
"""
ctype = ContentType.objects.get_for_model(obj)
current_tags = self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk)
if q is not None:
current_tags = current_tags.filter(q)
current_tags = list(current_tags)
updated_tag_names = parse_tag_input(tag_names,
default_namespace=default_namespace)
if conf.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if unicode(tag) not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
object_id=obj.pk, tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [unicode(tag) for tag in current_tags]
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(**get_tag_parts(tag_name))
TaggedItem._default_manager.create(tag=tag, object=obj)
def update_tags(self, obj, tag_names):
"""
Update tags associated with an object.
"""
ctype = ContentType.objects.get_for_model(obj)
current_tags = list(self.filter(items__content_type__pk=ctype.pk, items__object_id=obj.pk))
updated_tag_names = parse_tag_input(tag_names)
if settings.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags if tag.name not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(
content_type__pk=ctype.pk, object_id=obj.pk, tag__in=tags_for_removal
).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(name=tag_name)
try:
TaggedItem._default_manager.create(tag=tag, object=obj)
except:
pass
def add_tag(self, obj, tag_name):
"""
Associates the given object with a tag.
"""
tag_names = parse_tag_input(tag_name)
if not len(tag_names):
raise AttributeError(_('No tags were given: "%s".') % tag_name)
if len(tag_names) > 1:
raise AttributeError(_('Multiple tags were given: "%s".') % tag_name)
tag_name = tag_names[0]
if settings.FORCE_LOWERCASE_TAGS:
tag_name = tag_name.lower()
ctype = ContentType.objects.get_for_model(obj)
###ADDED BY RHIZOME TO DISTINGUISH TYPE
post_content_type, artwork_content_type, member_exhibition_content_type = get_content_types()
if ctype == post_content_type:
tag, created = self.get_or_create(slug=tag_name, type="editorial")
if ctype == artwork_content_type:
tag, created = self.get_or_create(slug=tag_name, type="artbase")
if ctype == member_exhibition_content_type:
tag, created = self.get_or_create(slug=tag_name, type="member_exhibition")
TaggedItem._default_manager.get_or_create(
tag=tag, content_type=ctype, object_id=obj.pk)
def update_tags(self, obj, tag_names, user=None):
"""
Update tags associated with an object.
user - the user adding the new tags
"""
ctype = ContentType.objects.get_for_model(obj)
current_tags = list(self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk))
updated_tag_names = parse_tag_input(tag_names)
if settings.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
updated_tag_name_slugs = [slugify(t) for t in updated_tag_names]
update_tag_name_dict = dict(zip(updated_tag_name_slugs, updated_tag_names))
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if tag.slug not in updated_tag_name_slugs]
if len(tags_for_removal):
TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
object_id=obj.pk,
tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
current_tag_name_slugs = [tag.slug for tag in current_tags]
for tag_slug in updated_tag_name_slugs:
if tag_slug not in current_tag_name_slugs:
tag_name = update_tag_name_dict[tag_slug]
tag, created = self.get_or_create(slug=tag_slug, defaults=dict(name=tag_name))
TaggedItem._default_manager.create(tag=tag, object=obj, user=user)
def pre_save_handler(sender, instance, **kwargs):
"""
Intercept attempts to save and sort the tag field alphabetically, so
we won't have different permutations in the filter list.
"""
taglist = parse_tag_input(instance.tags)
instance.tags = taglist_to_string(taglist)
def update_tags(self, obj, tag_names, labels=None):
"""
Update tags associated with an object.
"""
ctype = ContentType.objects.get_for_model(obj)
##TODO: This fails silently in non-rel when it should not
#current_tags = list(self.filter(items__content_type__pk=ctype.pk,
# items__object_id=obj.pk))
##This works, divided into two queries
items = TaggedItem.objects.filter(content_type__pk=ctype.pk, object_id=obj.pk)
current_tags = self.filter(pk__in=[item.tag_id for item in items])
updated_tag_names = parse_tag_input(tag_names)
if settings.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if tag.name not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
object_id=obj.pk,
tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(name=tag_name)
TaggedItem._default_manager.create(tag=tag, object=obj)
def add_tag(self, obj, tag_name):
"""
Associates the given object with a tag.
"""
tag_names = parse_tag_input(tag_name)
if not len(tag_names):
raise AttributeError(_('No tags were given: "%s".') % tag_name)
if len(tag_names) > 1:
raise AttributeError(_('Multiple tags were given: "%s".') % tag_name)
tag_name = tag_names[0]
if settings.FORCE_LOWERCASE_TAGS:
tag_name = tag_name.lower()
tag, created = self.get_or_create(slug=slugify(tag_name),
defaults={'name': tag_name})
if not created:
# check if there is a preferred synonym for this tag
try:
related_tag = RelatedTag.objects.get(tag=tag, relation_type='=>')
except RelatedTag.DoesNotExist:
pass
else:
# there is a preferred synonym; use it instead of the original
tag = related_tag.related_tag
ctype = ContentType.objects.get_for_model(obj)
TaggedItem._default_manager.get_or_create(
tag=tag, content_type=ctype, object_id=obj.pk)
def save(self):
self.rendered = markdown(self.description,
['video', 'codehilite', 'urlize'])
self.tags = ','.join([slugify(x) for x in parse_tag_input(self.tags)])
self.slug = '%s-%s' % (slugify(self.title[:30])
or 'sin-titulo', self.pk)
super(Leak, self).save()
def update_tags(self, obj, tag_names):
"""
Update tags associated with an object.
"""
ctype = ContentType.objects.get_for_model(obj)
current_tags = list(
self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk))
updated_tag_names = parse_tag_input(tag_names)
if settings.FORCE_LOWERCASE_TAGS:
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
tags_for_removal = [tag for tag in current_tags \
if tag.name not in updated_tag_names]
if len(tags_for_removal):
TaggedItem._default_manager.filter(
content_type__pk=ctype.pk,
object_id=obj.pk,
tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
for tag_name in updated_tag_names:
if tag_name not in current_tag_names:
tag, created = self.get_or_create(name=tag_name)
TaggedItem._default_manager.create(tag=tag, object=obj)
def testBadUsersNaughtyUsers(self):
self.assertEqual([], parse_tag_input(None))
self.assertEqual([], parse_tag_input(''))
self.assertEqual([], parse_tag_input('"'))
self.assertEqual([], parse_tag_input('""'))
self.assertEqual([], parse_tag_input('"' * 7))
self.assertEqual([], parse_tag_input(',,,,,,'))
self.assertEqual([u','], parse_tag_input('",",",",",",","'))
self.assertEqual([u'a-one', u'a-three', u'a-two', u'and'], parse_tag_input('a-one "a-two" and "a-three'))
def is_tag_list(value):
"""
Validates that ``value`` is a valid list of tags.
"""
for tag_name in parse_tag_input(value):
if len(tag_name) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(_("Each tag may be no more than %s characters long.") % settings.MAX_TAG_LENGTH)
return value
def render(self, name, value, attrs=None):
output = ['<div class="tagbox" id="id_%s">' % (name)]
if value:
tags = parse_tag_input(value)
for tag in tags:
output.append(tag + ",")
output.append("</div>")
return mark_safe(u"\n".join(output))
def isTagList(field_data, all_data):
"""
Validates that ``field_data`` is a valid list of tags.
"""
for tag_name in parse_tag_input(field_data):
if len(tag_name) > settings.MAX_TAG_LENGTH:
raise ValidationError(
_('Each tag may be no more than %s characters long.') % settings.MAX_TAG_LENGTH)
def parse_tag_input_local(input, max_count = 5):
"""
Given a list of comma separated tags, return the parsed tags as a list. Maximum
max_count tags returned.
"""
words = parse_tag_input(input)
words = [word.replace(' ', '-') for word in words][0:max_count]
return words
def append_user_tags(self, tags):
user_tags = parse_tag_input(self.user.tags)
print(user_tags)
print(tags)
merged = list(set(tags + user_tags))
print(merged)
self.user.tags = ','.join(merged)
self.user.save()
def clean(self, value):
value = super(TagField, self).clean(value)
for tag_name in parse_tag_input(value):
if len(tag_name) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
settings.MAX_TAG_LENGTH)
return value
def clean_name(self):
value = self.cleaned_data["name"]
tag_names = parse_tag_input(value)
if len(tag_names) > 1:
raise forms.ValidationError(_("Multiple tags were given."))
elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(_("A tag may be no more than %s characters long.") % settings.MAX_TAG_LENGTH)
return value
def save(self, *args, **kwargs):
self.rendered = markdown(
self.description,
['ltmo.mdx_urlize', 'ltmo.mdx_video', 'codehilite']
)
self.tags = ','.join([slugify(x) for x in parse_tag_input(self.tags)])
self.slug = '%s-%s' %(slugify(self.title[:30]) or 'sin-titulo', self.pk)
super(Leak, self).save(*args, **kwargs)
def clean(self, value):
value = super(TagField, self).clean(value)
for tag_name in parse_tag_input(value):
if len(tag_name) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
settings.MAX_TAG_LENGTH)
return value
def testBadUsersNaughtyUsers(self):
self.assertEqual([], parse_tag_input(None))
self.assertEqual([], parse_tag_input(''))
self.assertEqual([], parse_tag_input('"'))
self.assertEqual([], parse_tag_input('""'))
self.assertEqual([], parse_tag_input('"' * 7))
self.assertEqual([], parse_tag_input(',,,,,,'))
self.assertEqual([u','], parse_tag_input('",",",",",",","'))
self.assertEqual([u'a-one', u'a-three', u'a-two', u'and'],
parse_tag_input('a-one "a-two" and "a-three'))
def render(self, context):
tags = parse_tag_input(self.tags_string.resolve(context))
tags = ['<a href="%s" rel="tag">%s</a>' % (url_reverse(self.urlname, kwargs={'tag':t}), t) for t in tags]
if len(tags) > 2:
first_part = self.junctor.join(tags[:-1])
return first_part + self.last_junctor + tags[-1]
if len(tags) == 2:
return self.last_junctor.join(tags)
return self.junctor.join(tags)
def clean_tags(self):
tag_list = parse_tag_input(self.cleaned_data['tags'])
tags = ''
for tag in tag_list:
tag = tag.replace(' ', '-')
if tag not in tags:
tags += tag + ","
return tags
def test_with_naughty_input(self):
""" Test with naughty input. """
# Bad users! Naughty users!
self.assertEqual(parse_tag_input(None), [])
self.assertEqual(parse_tag_input(""), [])
self.assertEqual(parse_tag_input('"'), [])
self.assertEqual(parse_tag_input('""'), [])
self.assertEqual(parse_tag_input('"' * 7), [])
self.assertEqual(parse_tag_input(",,,,,,"), [])
self.assertEqual(parse_tag_input('",",",",",",","'), [","])
self.assertEqual(parse_tag_input('a-one "a-two" and "a-three'), ["a-one", "a-three", "a-two", "and"])
def __init__(self, *args, **kwargs):
super(UserAddForm, self).__init__(*args, **kwargs)
tag_string = self.instance.profile.tag_list
self.initial['tag_list'] = parse_tag_input(tag_string)
self.fields['tag_list'].choices = Tag.objects.all().values_list('name', 'name')
self.fields['organisation'].initial = self.instance.profile.organisation
self.fields['trust_level'].initial = self.instance.profile.trust_level
self.fields['trust_level'].label = 'Trusted user'
def isTag(field_data, all_data):
"""
Validates that ``field_data`` is a valid tag.
"""
tag_names = parse_tag_input(field_data)
if len(tag_names) > 1:
raise ValidationError(_('Multiple tags were given.'))
elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:
raise ValidationError(
_('A tag may be no more than %s characters long.') % settings.MAX_TAG_LENGTH)
def clean_name(self):
value = self.cleaned_data['name']
tag_names = parse_tag_input(value)
if len(tag_names) > 1:
raise forms.ValidationError(_('Multiple tags were given.'))
elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(
_('A tag may be no more than %s characters long.') %
settings.MAX_TAG_LENGTH)
return value
def clean_name(self):
value = self.cleaned_data['name']
tag_names = parse_tag_input(value)
if len(tag_names) > 1:
raise forms.ValidationError(_('Multiple tags were given.'))
elif len(tag_names[0]) > getattr(settings, 'MAX_TAG_LENGTH', MAX_TAG_LENGTH):
raise forms.ValidationError(
_('A tag may be no more than %s characters long.') %
getattr(settings, 'MAX_TAG_LENGTH', MAX_TAG_LENGTH))
return value
def is_tag_list(value):
"""
Validates that ``value`` is a valid list of tags.
"""
for tag_name in parse_tag_input(value):
if len(tag_name) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
settings.MAX_TAG_LENGTH)
return value
def _pre_save(self, **kwargs): #signal, sender, instance):
"""
Save tags back to the database
"""
tags = self._get_instance_tag_cache(kwargs['instance'])
tags = parse_tag_input(tags)
#print 'Tags before: %s' % tags
instance = kwargs['instance']
self._set_instance_tag_cache(instance, edit_string_for_tags(tags))
def clean(self, value):
value = super(TagField, self).clean(value)
if value == u'':
return value
for tag_name in parse_tag_input(value):
if len(tag_name) > getattr(settings, 'MAX_TAG_LENGTH', MAX_TAG_LENGTH):
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
getattr(settings, 'MAX_TAG_LENGTH', MAX_TAG_LENGTH))
return value
def update_actionbar_tags(request, *objects):
# split tags on commas unless there is a quote in the input
nt = request.POST.get('new_tags')
if '"' in nt:
new_tags = parse_tag_input(nt)
else:
new_tags = filter(None, map(lambda s: s.strip(), nt.split(',')))
all_tags = parse_tag_input(request.POST.get('all_tags'))
try:
update_tags = dict(
(base64.b32decode(k[11:].replace('_', '=')), v)
for k, v in request.POST.iteritems()
if k.startswith('update_tag_')
)
except TypeError:
# Could not decode base32 encoded tag names
update_tags = ()
remove_tags = [
tag_name
for tag_name in all_tags
if tag_name not in update_tags.keys() and tag_name not in new_tags
]
for obj in objects:
wrapper = OwnedWrapper.objects.get_for_object(
user=request.user, object=obj)
for tag_name, action in update_tags.iteritems():
if action == 'mixed':
# Don't need to change anything
continue
elif action == 'true':
# Add tag to all selected presentations
Tag.objects.add_tag(wrapper, '"%s"' % tag_name)
for tag_name in new_tags:
Tag.objects.add_tag(wrapper, '"%s"' % tag_name)
for tag_name in remove_tags:
keep_tags = Tag.objects.get_for_object(
wrapper).exclude(name=tag_name).values_list('name')
Tag.objects.update_tags(
wrapper, ' '.join(map(lambda s: '"%s"' % s, keep_tags)))
def test_with_naughty_input(self):
""" Test with naughty input. """
# Bad users! Naughty users!
self.assertEquals(parse_tag_input(None), [])
self.assertEquals(parse_tag_input(''), [])
self.assertEquals(parse_tag_input('"'), [])
self.assertEquals(parse_tag_input('""'), [])
self.assertEquals(parse_tag_input('"' * 7), [])
self.assertEquals(parse_tag_input(',,,,,,'), [])
self.assertEquals(parse_tag_input('",",",",",",","'), [u','])
self.assertEquals(parse_tag_input('a-one "a-two" and "a-three'),
[u'a-one', u'a-three', u'a-two', u'and'])
def clean(self, value):
value = super(TagField, self).clean(value)
if value == u'':
return value
for tag_name in parse_tag_input(value):
if len(tag_name) > getattr(settings, 'MAX_TAG_LENGTH',
MAX_TAG_LENGTH):
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
getattr(settings, 'MAX_TAG_LENGTH', MAX_TAG_LENGTH))
return value
def get_skip_tags(self):
global SKIP_TAGS_CACHE
if SKIP_TAGS_CACHE is None:
# print "*** Fill skip tags cache"
self.get_preferences()
skip_tag_string = self.data.get("skip_tags", DEFAULT_SKIP_TAGS)
SKIP_TAGS_CACHE = parse_tag_input(skip_tag_string)
# print "*** skip tags: %r" % SKIP_TAGS_CACHE
return SKIP_TAGS_CACHE
def is_tag(value):
"""
Validates that ``value`` is a valid tag.
"""
tag_names = parse_tag_input(value)
if len(tag_names) > 1:
raise ValidationError(_('Multiple tags were given.'))
elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(
_('A tag may be no more than %s characters long.') %
settings.MAX_TAG_LENGTH)
return value
def test_with_naughty_input(self):
""" Test with naughty input. """
# Bad users! Naughty users!
self.assertEquals(parse_tag_input(None), [])
self.assertEquals(parse_tag_input(""), [])
self.assertEquals(parse_tag_input('"'), [])
self.assertEquals(parse_tag_input('""'), [])
self.assertEquals(parse_tag_input('"' * 7), [])
self.assertEquals(parse_tag_input(",,,,,,"), [])
self.assertEquals(parse_tag_input('",",",",",",","'), [u","])
def add_tags(request, type, id):
if request.method != 'POST':
return HttpResponseNotAllowed(['POST'])
tags = request.POST.get('tags')
if '"' in tags:
new_tags = parse_tag_input(tags)
else:
new_tags = filter(None, map(lambda s: s.strip(), tags.split(',')))
ownedwrapper = OwnedWrapper.objects.get_for_object(
user=request.user, type=type, object_id=id)
for tag in new_tags:
Tag.objects.add_tag(ownedwrapper, '"%s"' % tag)
return HttpResponseRedirect(request.GET.get('next') or '/')
def default(self, obj):
if isinstance(obj, Comment) :
comment = obj
#replies = list(comment.comment_set.order_by('created'))
text=comment.text_version.text
replies = get_viewable_comments(self.request, comment.comment_set.all(), text)
# can_view == true because of get_viewable_comments filter
can_moderate = has_perm(self.request, 'can_edit_comment', text)
can_edit = has_perm(self.request, 'can_edit_comment', text) or has_own_perm(self.request, 'can_edit_comment_own', text, comment)
can_delete = has_perm(self.request, 'can_delete_comment', text) or has_own_perm(self.request, 'can_delete_comment_own', text, comment)
return {'id' : comment.id,
'key' : comment.key,
'id_key' : comment.id_key,
'created_user_str' : datetime_to_user_str(request_tz_convert(comment.created, self.request)),
'modified_user_str' : datetime_to_user_str(request_tz_convert(comment.modified, self.request)),
# 'created_str' : datetime_to_str(comment.created), # TODO change to a simple number as modified if possible
'created' : datetime_to_epoch(comment.created), # TODO change to a simple number as modified if possible
'modified' : datetime_to_epoch(comment.modified),
# 'modified' : time.mktime(comment.modified.timetuple()),
# 'created' : datetime_to_js_date_str(comment.created),
'reply_to_id' : comment.reply_to_id,
'replies' : replies,
'name' : comment.get_name(),
'email' : comment.get_email(),
'logged_author' : (comment.user != None),
'title':comment.title,
'content':comment.content,
'content_html':comment.content_html,
'tags': ', '.join(parse_tag_input(comment.tags)),
'category': comment.category,
'format': comment.format,
'start_wrapper' : comment.start_wrapper,
'end_wrapper' : comment.end_wrapper,
'start_offset' : comment.start_offset,
'end_offset' : comment.end_offset,
'state' : comment.state,
'permalink' : reverse('text-view-show-comment', args=[text.key, comment.id_key]),
# permission
'can_edit' : can_edit,
'can_delete' : can_delete,
'can_moderate' : can_moderate,
}
if isinstance(obj, Tag) :
tag = obj
# RBE each time issuing a db request to find comments related to this tag !!! TODO
return { 'ids' : [t.id for t in tag.items.all()], 'name' : tag.name, 'font_size' : tag.font_size}
return simplejson.JSONEncoder.default(self, obj)
def get_context_data(self, **kwargs):
context = super(SubmitVideoView, self).get_context_data(**kwargs)
# Provided for backwards-compatibility.
context['data'] = {
'link': self.object.website_url,
'publish_date': self.object.when_published,
'tags': parse_tag_input(context['form'].initial.get('tags', '')),
'title': self.object.name,
'description': self.object.description,
'thumbnail_url': self.object.thumbnail_url,
'user': self.object.video_service_user,
'user_url': self.object.video_service_url,
}
return context
def clean_tags(self):
tag_list = parse_tag_input(self.cleaned_data['tags'])
tags = ''
for tag in tag_list:
tag = tag.lower().replace(' ', '-')
if tag not in tags:
tags += tag + ","
# Project name must always be a tag
group_tag = slugify(self.cleaned_data['name'])
if group_tag not in tag_list:
tags = group_tag + ',' + tags
return tags
def add_tags(request, type, id):
if request.method != 'POST':
return HttpResponseNotAllowed(['POST'])
tags = request.POST.get('tags')
if '"' in tags:
new_tags = parse_tag_input(tags)
else:
new_tags = [_f for _f in [s.strip() for s in tags.split(',')] if _f]
ownedwrapper = OwnedWrapper.objects.get_for_object(user=request.user,
type=type,
object_id=id)
for tag in new_tags:
Tag.objects.add_tag(ownedwrapper, '"%s"' % tag)
return HttpResponseRedirect(
validate_next_link(request.GET.get('next'), '/'))
