def edit_bulk_tag_subscription(request, pk):
if not askbot_settings.SUBSCRIBED_TAG_SELECTOR_ENABLED:
raise Http404
bulk_subscription = get_object_or_404(models.BulkTagSubscription,
pk=pk)
data = {'action': _('Edit')}
if request.method == "POST":
form = forms.BulkTagSubscriptionForm(request.POST)
if form.is_valid():
bulk_subscription.tags.clear()
bulk_subscription.users.clear()
bulk_subscription.groups.clear()
if 'groups' in form.cleaned_data:
group_ids = [user.id for user in form.cleaned_data['groups']]
bulk_subscription.groups.add(*group_ids)
lang = translation.get_language()
tags, new_tag_names = get_tags_by_names(
form.cleaned_data['tags'].split(' '),
language_code=lang
)
tag_id_list = [tag.id for tag in tags]
for new_tag_name in new_tag_names:
new_tag = models.Tag.objects.create(
name=new_tag_name,
created_by=request.user,
language_code=lang
)
tag_id_list.append(new_tag.id)
bulk_subscription.tags.add(*tag_id_list)
user_ids = []
for user in form.cleaned_data['users']:
user_ids.append(user)
user.mark_tags(bulk_subscription.tag_list(),
reason='subscribed', action='add')
bulk_subscription.users.add(*user_ids)
return redirect('list_bulk_tag_subscription')
else:
form_initial = {
'users': bulk_subscription.users.all(),
'groups': bulk_subscription.groups.all(),
'tags': ' '.join([tag.name for tag in bulk_subscription.tags.all()]),
}
data.update({
'bulk_subscription': bulk_subscription,
'form': forms.BulkTagSubscriptionForm(initial=form_initial),
})
return render(request, 'tags/form_bulk_tag_subscription.jinja', data)
def create(
self,
tag_names=None,
user_list=None,
group_list=None,
tag_author=None,
language_code=None,
**kwargs
):
tag_names = tag_names or []
user_list = user_list or []
group_list = group_list or []
new_object = super(BulkTagSubscriptionManager, self).create(**kwargs)
tag_name_list = []
if tag_names:
from askbot.models.tag import get_tags_by_names
tags, new_tag_names = get_tags_by_names(tag_names, language_code)
if new_tag_names:
assert(tag_author)
tags_id_list= [tag.id for tag in tags]
tag_name_list = [tag.name for tag in tags]
from askbot.models.tag import Tag
new_tags = Tag.objects.create_in_bulk(
tag_names=new_tag_names,
user=tag_author,
language_code=translation.get_language()
)
tags_id_list.extend([tag.id for tag in new_tags])
tag_name_list.extend([tag.name for tag in new_tags])
new_object.tags.add(*tags_id_list)
if user_list:
user_ids = []
for user in user_list:
user_ids.append(user.id)
user.mark_tags(tagnames=tag_name_list,
reason='subscribed',
action='add')
new_object.users.add(*user_ids)
if group_list:
group_ids = []
for group in group_list:
#TODO: do the group marked tag thing here
group_ids.append(group.id)
new_object.groups.add(*group_ids)
return new_object
def create(
self,
tag_names=None,
user_list=None,
group_list=None,
tag_author=None,
language_code=None,
**kwargs
):
tag_names = tag_names or []
user_list = user_list or []
group_list = group_list or []
new_object = super(BulkTagSubscriptionManager, self).create(**kwargs)
tag_name_list = []
if tag_names:
from askbot.models.tag import get_tags_by_names
tags, new_tag_names = get_tags_by_names(tag_names, language_code)
if new_tag_names:
assert(tag_author)
tags_id_list= [tag.id for tag in tags]
tag_name_list = [tag.name for tag in tags]
from askbot.models.tag import Tag
new_tags = Tag.objects.create_in_bulk(
tag_names=new_tag_names,
user=tag_author,
language_code=translation.get_language()
)
tags_id_list.extend([tag.id for tag in new_tags])
tag_name_list.extend([tag.name for tag in new_tags])
new_object.tags.add(*tags_id_list)
if user_list:
user_ids = []
for user in user_list:
user_ids.append(user.id)
user.mark_tags(tagnames=tag_name_list,
reason='subscribed',
action='add')
new_object.users.add(*user_ids)
if group_list:
group_ids = []
for group in group_list:
# TODO: do the group marked tag thing here
group_ids.append(group.id)
new_object.groups.add(*group_ids)
return new_object
def edit_bulk_tag_subscription(request, pk):
if not askbot_settings.SUBSCRIBED_TAG_SELECTOR_ENABLED:
raise Http404
bulk_subscription = get_object_or_404(models.BulkTagSubscription, pk=pk)
data = {'action': _('Edit')}
if request.method == "POST":
form = forms.BulkTagSubscriptionForm(request.POST)
if form.is_valid():
bulk_subscription.tags.clear()
bulk_subscription.users.clear()
bulk_subscription.groups.clear()
if 'groups' in form.cleaned_data:
group_ids = [user.id for user in form.cleaned_data['groups']]
bulk_subscription.groups.add(*group_ids)
lang = translation.get_language()
tags, new_tag_names = get_tags_by_names(
form.cleaned_data['tags'].split(' '), language_code=lang)
tag_id_list = [tag.id for tag in tags]
for new_tag_name in new_tag_names:
new_tag = models.Tag.objects.create(name=new_tag_name,
created_by=request.user,
language_code=lang)
tag_id_list.append(new_tag.id)
bulk_subscription.tags.add(*tag_id_list)
user_ids = []
for user in form.cleaned_data['users']:
user_ids.append(user)
user.mark_tags(bulk_subscription.tag_list(),
reason='subscribed',
action='add')
bulk_subscription.users.add(*user_ids)
return redirect('list_bulk_tag_subscription')
else:
form_initial = {
'users': bulk_subscription.users.all(),
'groups': bulk_subscription.groups.all(),
'tags':
' '.join([tag.name for tag in bulk_subscription.tags.all()]),
}
data.update({
'bulk_subscription':
bulk_subscription,
'form':
forms.BulkTagSubscriptionForm(initial=form_initial),
})
return render(request, 'tags/form_bulk_tag_subscription.jinja', data)
def edit_bulk_tag_subscription(request, pk):
if askbot_settings.SUBSCRIBED_TAG_SELECTOR_ENABLED is False:
raise Http404
bulk_subscription = get_object_or_404(models.BulkTagSubscription, pk=pk)
data = {"action": _("Edit")}
if request.method == "POST":
form = forms.BulkTagSubscriptionForm(request.POST)
if form.is_valid():
bulk_subscription.tags.clear()
bulk_subscription.users.clear()
bulk_subscription.groups.clear()
if "groups" in form.cleaned_data:
group_ids = [user.id for user in form.cleaned_data["groups"]]
bulk_subscription.groups.add(*group_ids)
lang = translation.get_language()
tags, new_tag_names = get_tags_by_names(form.cleaned_data["tags"].split(" "), language_code=lang)
tag_id_list = [tag.id for tag in tags]
for new_tag_name in new_tag_names:
new_tag = models.Tag.objects.create(name=new_tag_name, created_by=request.user, language_code=lang)
tag_id_list.append(new_tag.id)
bulk_subscription.tags.add(*tag_id_list)
user_ids = []
for user in form.cleaned_data["users"]:
user_ids.append(user)
user.mark_tags(bulk_subscription.tag_list(), reason="subscribed", action="add")
bulk_subscription.users.add(*user_ids)
return HttpResponseRedirect(reverse("list_bulk_tag_subscription"))
else:
form_initial = {
"users": bulk_subscription.users.all(),
"groups": bulk_subscription.groups.all(),
"tags": " ".join([tag.name for tag in bulk_subscription.tags.all()]),
}
data.update(
{"bulk_subscription": bulk_subscription, "form": forms.BulkTagSubscriptionForm(initial=form_initial)}
)
return render(request, "tags/form_bulk_tag_subscription.html", data)
def create(self, tag_names=None, user_list=None, group_list=None, tag_author=None, **kwargs):
tag_names = tag_names or []
user_list = user_list or []
group_list = group_list or []
new_object = super(BulkTagSubscriptionManager, self).create(**kwargs)
tag_name_list = []
if tag_names:
tags, new_tag_names = get_tags_by_names(tag_names)
if new_tag_names:
assert tag_author
tags_id_list = [tag.id for tag in tags]
tag_name_list = [tag.name for tag in tags]
new_tags = Tag.objects.create_in_bulk(tag_names=new_tag_names, user=tag_author)
tags_id_list.extend([tag.id for tag in new_tags])
tag_name_list.extend([tag.name for tag in new_tags])
new_object.tags.add(*tags_id_list)
if user_list:
user_ids = []
for user in user_list:
user_ids.append(user.id)
user.mark_tags(tagnames=tag_name_list, reason="subscribed", action="add")
new_object.users.add(*user_ids)
if group_list:
group_ids = []
for group in group_list:
# TODO: do the group marked tag thing here
group_ids.append(group.id)
new_object.groups.add(*group_ids)
return new_object
def update_tags(
self, tagnames = None, user = None, timestamp = None
):
"""
Updates Tag associations for a thread to match the given
tagname string.
When tags are removed and their use count hits 0 - the tag is
automatically deleted.
When an added tag does not exist - it is created
If tag moderation is on - new tags are placed on the queue
Tag use counts are recalculated
A signal tags updated is sent
*IMPORTANT*: self._question_post() has to
exist when update_tags() is called!
"""
previous_tags = list(self.tags.filter(status = Tag.STATUS_ACCEPTED))
ordered_updated_tagnames = [t for t in tagnames.strip().split(' ')]
previous_tagnames = set([tag.name for tag in previous_tags])
updated_tagnames = set(ordered_updated_tagnames)
removed_tagnames = previous_tagnames - updated_tagnames
#remove tags from the question's tags many2many relation
#used_count values are decremented on all tags
removed_tags = self.remove_tags_by_names(removed_tagnames)
#modified tags go on to recounting their use
#todo - this can actually be done asynchronously - not so important
modified_tags, unused_tags = separate_unused_tags(removed_tags)
delete_tags(unused_tags)#tags with used_count == 0 are deleted
modified_tags = removed_tags
#add new tags to the relation
added_tagnames = updated_tagnames - previous_tagnames
if added_tagnames:
#find reused tags
reused_tags, new_tagnames = get_tags_by_names(added_tagnames)
reused_tags.mark_undeleted()
added_tags = list(reused_tags)
#tag moderation is in the call below
created_tags = Tag.objects.create_in_bulk(
tag_names = new_tagnames, user = user
)
added_tags.extend(created_tags)
#todo: not nice that assignment of added_tags is way above
self.tags.add(*added_tags)
modified_tags.extend(added_tags)
else:
added_tags = Tag.objects.none()
#Save denormalized tag names on thread. Preserve order from user input.
accepted_added_tags = filter_accepted_tags(added_tags)
added_tagnames = set([tag.name for tag in accepted_added_tags])
final_tagnames = (previous_tagnames - removed_tagnames) | added_tagnames
ordered_final_tagnames = list()
for tagname in ordered_updated_tagnames:
if tagname in final_tagnames:
ordered_final_tagnames.append(tagname)
self.tagnames = ' '.join(ordered_final_tagnames)
self.save()#need to save here?
#todo: factor out - tell author about suggested tags
suggested_tags = filter_suggested_tags(added_tags)
if len(suggested_tags) > 0:
if len(suggested_tags) == 1:
msg = _(
'Tag %s is new and will be submitted for the '
'moderators approval'
) % suggested_tags[0].name
else:
msg = _(
'Tags %s are new and will be submitted for the '
'moderators approval'
) % ', '.join([tag.name for tag in suggested_tags])
user.message_set.create(message = msg)
####################################################################
self.update_summary_html() # regenerate question/thread summary html
####################################################################
#if there are any modified tags, update their use counts
if modified_tags:
Tag.objects.update_use_counts(modified_tags)
signals.tags_updated.send(None,
thread = self,
tags = modified_tags,
user = user,
timestamp = timestamp
)
return True
return False
