def create(self, request, key):
prev_text = get_text_by_keys_or_404(key)
prev_text_version = prev_text.last_text_version
prev_comments = prev_text_version.get_comments()
prev_scope_removed = [c for c in prev_comments if c.is_scope_removed()]
res = text_edit(request, key=key)
text = get_text_by_keys_or_404(key)
text_version = text.last_text_version
comments = text_version.get_comments()
scope_removed = [c for c in comments if c.is_scope_removed()]
return {'version_key' : text_version.key , 'created': text_version.created, 'nb_deleted' : len(prev_comments) - len(comments), 'nb_scope_removed' : len(scope_removed) - len(prev_scope_removed)}
def text_history_compare(request, key, v1_version_key, v2_version_key, mode=''):
text = get_text_by_keys_or_404(key)
v1 = get_textversion_by_keys_or_404(v1_version_key, key=key)
v2 = get_textversion_by_keys_or_404(v2_version_key, key=key)
content = get_uniffied_inner_diff_table(v1.title,
v2.title,
_("by %(author)s") %{'author' : v1.get_name()},
_("by %(author)s") %{'author' : v2.get_name()},
v1.content,
v2.content)
if mode=='1':
# alternate diff
#from cm.utils.diff import text_diff
from cm.utils.diff import diff_match_patch2
dif = diff_match_patch2()
content = dif.diff_prettyHtml_one_way(dif.diff_main(v1.get_content(), v2.get_content()), mode='ins_del')
text_versions = text.get_versions()
first_version = text_versions[len(text_versions) - 1]
template_dict = {
'text' : text,
'v1': v1,
'v2': v2,
'content' : content.strip(),
'empty' : '<table class="diff"><tbody></tbody></table>'==content,
'first_version':first_version,
}
return render_to_response('site/text_history_compare.html',
template_dict,
context_instance=RequestContext(request))
def text_history(request, key):
text = get_text_by_keys_or_404(key)
if request.method == 'POST':
v1_key = request.POST.get('newkey', None)
v2_key = request.POST.get('oldkey', None)
if v1_key and v2_key:
return redirect(request,
'text-history-compare',
args=[text.key, v2_key, v1_key])
text_versions = text.get_versions()
paginate_by = get_int(request.GET, 'paginate', TEXT_PAGINATION)
last_last_version = text_versions[1] if len(text_versions) > 1 else None
first_version = text_versions[len(text_versions) - 1]
context = {
'text': text,
'last_version': text.last_text_version,
'last_last_version': last_last_version,
'first_version': first_version
}
return object_list(
request,
text_versions,
template_name='site/text_history.html',
paginate_by=paginate_by,
extra_context=context,
)
def text_followup(request, key):
text = get_text_by_keys_or_404(key)
user = request.user if request.user.is_authenticated() else None
from cm.security import user_has_perm # import here!
anonymous_can_view_text = user_has_perm(None, 'can_view_text', text=text)
text_notify_check = Notification.objects.filter(text=text,type='text',user=user, active=True).count()
workspace_notify_check = Notification.objects.filter(text=None,type='workspace',user=user, active=True).count()
if request.method == 'POST':
if 'activate' in request.POST:
text.private_feed_key = generate_key()
text.save()
display_message(request, _(u"Private feed activated."))
if 'reset' in request.POST:
text.private_feed_key = generate_key()
text.save()
display_message(request, _(u"Private notifications feed reseted."))
if request.POST.get('notif_id',None):
notif_id = request.POST.get('notif_id')
notif_val = request.POST.get(notif_id,None)
if notif_val != None :
Notification.objects.set_notification(text=text, type='text', active=(notif_val == 'true'), email_or_user=request.user)
template_dict = {
'text' : text,
'workspace_notify_check' : workspace_notify_check,
'text_notify_check' : text_notify_check,
'anonymous_can_view_text' : anonymous_can_view_text,
}
return render_to_response('site/text_followup.html', template_dict , context_instance=RequestContext(request))
def text_view(request, key, adminkey=None):
text = get_text_by_keys_or_404(key)
register_activity(request, "text_view", text=text)
text_version = text.get_latest_version()
embed_code = embed_html(key, 'id="text_view_frame" name="text_view_frame" onload="if (window.iframe_onload) iframe_onload();"', None, request.META.get('QUERY_STRING'))
template_dict = { 'embed_code':embed_code, 'text' : text, 'text_version' : text_version, 'title' : text_version.title}
return render_to_response('site/text_view.html', template_dict, context_instance=RequestContext(request))
def read(self, request, key):
text = get_text_by_keys_or_404(key)
setattr(text,'nb_comments',len(get_viewable_comments(request, text.last_text_version.comment_set.all(), text)))
setattr(text,'nb_versions',text.get_versions_number())
setattr(text,'embed_html',embed_html(text.key))
return text
def text_feed(request, key):
from cm.views import get_text_by_keys_or_404
text = get_text_by_keys_or_404(key)
feed_title = _(u"Text %(text_title)s's public feed" % {'text_title' : text.title})
feed_description = _(u"Public activity feed for text %(text_title)s") % {'text_title' : text.title}
request.user = AnonymousUser()
activitites = get_viewable_activities(request, {'view_comments' : 1, 'view_texts' : 1}, text=text)
return _feed(request, activitites, feed_title, feed_description)
def text_feed_private(request, key, private_feed_key):
from cm.views import get_text_by_keys_or_404
text = get_text_by_keys_or_404(key)
if text.private_feed_key != private_feed_key:
raise Http404
feed_title = _(u"Text %(text_title)s's private feed" % {'text_title' : text.title})
feed_description = _(u"Private activity feed for text %(text_title)s") % {'text_title' : text.title}
activities = Activity.objects.filter(type__in=Activity.ACTIVITIES_TYPES, text=text).order_by('-created')
return _feed(request, activities, feed_title, feed_description)
def text_revert(request, key, text_version_key):
if request.method != 'POST':
raise UnauthorizedException('Unauthorized')
text = get_text_by_keys_or_404(key)
text_version = text.revert_to_version(text_version_key)
display_message(request, _(u'A new version (copied from version %(version_title)s) has been created') % {'version_title':text_version.title})
return HttpResponse('') # no redirect because this is called by js
def text_embed(request, key):
text = get_text_by_keys_or_404(key)
embed_code = embed_html(text.key) ;
template_dict = {
'text' : text,
'embed_code': embed_code
}
return render_to_response('site/text_embed.html', template_dict , context_instance=RequestContext(request))
def text_view_comments(request, key, version_key=None, adminkey=None):
text = get_text_by_keys_or_404(key)
read_only = False
if version_key :
text_version = get_textversion_by_keys_or_404(version_key, adminkey, key)
if settings.ALLOW_CLIENT_MODIF_ON_LAST_VERSION_ONLY :
read_only = (text.last_text_version_id != text_version.id)
else :
text_version = text.get_latest_version()
comments = get_viewable_comments(request, text_version.comment_set.filter(reply_to__isnull=True),text)
filter_datas = get_filter_datas(request, text_version, text)
get_params = simplejson.dumps(request.GET)
wrapped_text_version, _ , _ = spannify(text_version.get_content())
from cm.models import ApplicationConfiguration
categories = {}
for i in range(1, 6):
if text_version.__dict__['category_' + str(i)] == None or text_version.__dict__['category_' + str(i)].lower() != 'none':
if text_version.__dict__['category_' + str(i)] != None and text_version.__dict__['category_' + str(i)] != '':
categories[i] = text_version.__dict__['category_' + str(i)]
else:
if ApplicationConfiguration.get_key('workspace_category_' + str(i)) != None and ApplicationConfiguration.get_key('workspace_category_' + str(i)) != '':
categories[i] = ApplicationConfiguration.get_key('workspace_category_' + str(i))
template_dict = {
'text' : text,
'text_version' : text_version,
'title' : text_version.title, # TODO use it ...
'get_params' : get_params,
'content' : wrapped_text_version,
'client_date_fmt' : settings.CLIENT_DATE_FMT,
'read_only' : read_only,
}
template_dict['json_comments'] = jsonize(comments, request)
template_dict['json_filter_datas'] = jsonize(filter_datas, request)
if categories:
categories[0] = 'none'
template_dict['categories'] = jsonize(categories, request)
custom_css_str = ApplicationConfiguration.get_key('custom_css')
if custom_css_str:
custom_css = cssutils.parseString(custom_css_str)
for css_rule in custom_css:
if css_rule.type == css_rule.STYLE_RULE and css_rule.wellformed:
css_rule.selectorText = "#textcontainer %s" %css_rule.selectorText
template_dict['custom_css'] = custom_css.cssText
template_dict['custom_font'] = ApplicationConfiguration.get_key('custom_font')
template_dict['custom_titles_font'] = ApplicationConfiguration.get_key('custom_titles_font')
return render_to_response('site/text_view_comments.html',
template_dict,
context_instance=RequestContext(request))
def text_view_frame(request, key, version_key=None, adminkey=None):
text = get_text_by_keys_or_404(key)
if version_key :
text_version = get_textversion_by_keys_or_404(version_key, adminkey, key)
else :
text_version = text.get_latest_version()
template_dict = {'text' : text, 'text_version' : text_version}
return render_to_response('site/text_view_frame.html',
template_dict,
context_instance=RequestContext(request))
def text_pre_edit(request, key, adminkey=None):
text = get_text_by_keys_or_404(key)
text_version = text.get_latest_version()
comments = text_version.get_comments()
new_format = request.POST['new_format']
new_content = on_content_receive(request.POST['new_content'], new_format)
# TODO: RBE : si commentaire mal forme : (position non existante : boom par key error)
_tomodify_comments, toremove_comments = compute_new_comment_positions(text_version.content, text_version.format, new_content, new_format, comments)
return HttpResponse(simplejson.dumps({'nb_removed' : len(toremove_comments) }))
def text_history_version(request, key, version_key):
text = get_text_by_keys_or_404(key)
text_version = get_textversion_by_keys_or_404(version_key, key=key)
text_versions = text.get_versions()
first_version = text_versions[len(text_versions) - 1]
template_dict = {'text' : text,
'text_version' : text_version,
'embed_code' : embed_html(key, 'id="text_view_frame" name="text_view_frame"', version_key),
'first_version':first_version,
}
return render_to_response('site/text_history_version.html',
template_dict,
context_instance=RequestContext(request))
def text_feed_private(request, key, private_feed_key):
from cm.views import get_text_by_keys_or_404
text = get_text_by_keys_or_404(key)
if text.private_feed_key != private_feed_key:
raise Http404
feed_title = _(u"Text %(text_title)s's private feed" %
{'text_title': text.title})
feed_description = _(u"Private activity feed for text %(text_title)s") % {
'text_title': text.title
}
activities = Activity.objects.filter(type__in=Activity.ACTIVITIES_TYPES,
text=text).order_by('-created')
return _feed(request, activities, feed_title, feed_description)
def text_feed(request, key):
from cm.views import get_text_by_keys_or_404
text = get_text_by_keys_or_404(key)
feed_title = _(u"Text %(text_title)s's public feed" %
{'text_title': text.title})
feed_description = _(u"Public activity feed for text %(text_title)s") % {
'text_title': text.title
}
request.user = AnonymousUser()
activitites = get_viewable_activities(request, {
'view_comments': 1,
'view_texts': 1
},
text=text)
return _feed(request, activitites, feed_title, feed_description)
def text_settings(request, key):
text = get_text_by_keys_or_404(key)
text_version = text.get_latest_version()
if request.method == 'POST':
form = SettingsTextForm(request.POST, instance = text_version)
if form.is_valid():
form.save()
display_message(request, _(u'Text settings updated'))
return redirect(request, 'text-view', args=[text.key])
else:
form = SettingsTextForm(instance = text_version)
template_dict = {'text' : text, 'form' : form}
return render_to_response('site/text_settings.html', template_dict , context_instance=RequestContext(request))
def user_add(request, key=None, mass=False):
text = get_text_by_keys_or_404(key) if key else None
if request.method == 'POST':
userform = UserForm(request.POST) if not mass else MassUserForm(request.POST)
userroleform = UserRoleForm(request.POST) if not(key) else None
noteform = UserAddForm(request.POST)
userprofileform = UserProfileAddForm(request.POST)
localroleform = UserRoleTextForm(request.POST, prefix="local") if key else None
if userform.is_valid() and (not userroleform or userroleform.is_valid()) and noteform.is_valid() and userprofileform.is_valid() and (not localroleform or localroleform.is_valid()):
data = userform.cleaned_data
data.update(userprofileform.cleaned_data)
data.update(noteform.cleaned_data)
emails = data['email']
del data['email']
email_created = set()
for email in [s.strip() for s in SEPARATORS_RE.split(emails)]:
if email and not User.objects.filter(email__iexact=email) and email not in email_created:
user = UserProfile.objects.create_inactive_user(email, True, **data)
if key:
localuserrole = UserRole.objects.create(user=user, role=localroleform.cleaned_data['role'], text=text)
else:
userrole = UserRole.objects.create(user=user, role=userroleform.cleaned_data['role'], text=None)
email_created.add(email)
register_activity(request, "user_created", user=user)
display_message(request, ungettext(u'%(nb_users)d user added', u'%(nb_users)d users added', len(email_created)) % {'nb_users': len(email_created)})
if key:
return HttpResponseRedirect(reverse('text-share', args=[text.key]))
else:
return HttpResponseRedirect(reverse('user'))
else:
userform = UserForm() if not mass else MassUserForm()
userroleform = UserRoleForm() if not(key) else None
userprofileform = UserProfileAddForm()
noteform = UserAddForm()
localroleform = UserRoleTextForm(prefix="local") if key else None
if key:
template = 'site/user_mass_add_text.html' if mass else 'site/user_add_text.html'
else:
template = 'site/user_mass_add.html' if mass else 'site/user_add.html'
return render_to_response(template, {'forms' : [userform, userprofileform , userroleform, noteform, localroleform],
'save_name' : ungettext(u'Add user', u'Add users', 2 if mass else 1),
'mass' : mass,
'text' : text,
}, context_instance=RequestContext(request))
def text_history(request, key):
text = get_text_by_keys_or_404(key)
if request.method == 'POST':
v1_key = request.POST.get('newkey',None)
v2_key = request.POST.get('oldkey',None)
if v1_key and v2_key:
return redirect(request, 'text-history-compare', args=[text.key, v2_key, v1_key ])
text_versions = text.get_versions()
paginate_by = get_int(request.GET,'paginate',TEXT_PAGINATION)
last_last_version = text_versions[1] if len(text_versions)>1 else None
first_version = text_versions[len(text_versions) - 1]
context = {'text':text, 'last_version':text.last_text_version, 'last_last_version':last_last_version, 'first_version':first_version}
return object_list(request, text_versions,
template_name = 'site/text_history.html',
paginate_by = paginate_by,
extra_context=context,
)
def text_edit(request, key, adminkey=None):
text = get_text_by_keys_or_404(key)
text_version = text.get_latest_version()
if request.method == 'POST':
if request.user.is_authenticated():
form = EditTextForm(request.POST)
else:
form = EditTextFormAnon(request.POST)
if form.is_valid():
if request.POST.get('new_version'):
new_version = form.save_new_version(text, request)
register_activity(request,
"text_edited_new_version",
text=text,
text_version=new_version)
else:
form.save_into_text(text, request)
register_activity(request, "text_edited", text=text)
return redirect(request, 'text-view', args=[text.key])
else:
default_data = {
'content': text_version.content,
'title': text_version.title,
'format': text_version.format,
'tags': text_version.tags,
'new_version': NEW_TEXT_VERSION_ON_EDIT,
'note': '',
'keep_comments': True,
'cancel_modified_scopes': True,
}
if request.user.is_authenticated():
form = EditTextForm(default_data)
else:
form = EditTextFormAnon(default_data)
template_dict = {'text': text, 'form': form}
return render_to_response('site/text_edit.html',
template_dict,
context_instance=RequestContext(request))
def text_edit(request, key, adminkey=None):
text = get_text_by_keys_or_404(key)
text_version = text.get_latest_version()
if request.method == 'POST':
if request.user.is_authenticated():
form = EditTextForm(request.POST)
else:
form = EditTextFormAnon(request.POST)
if form.is_valid():
if request.POST.get('new_version'):
new_version = form.save_new_version(text, request)
register_activity(request, "text_edited_new_version", text=text, text_version=new_version)
else:
form.save_into_text(text, request)
register_activity(request, "text_edited", text=text)
return redirect(request, 'text-view', args=[text.key])
else:
default_data = {
'content': text_version.content,
'title': text_version.title,
'format': text_version.format,
'tags': text_version.tags,
'new_version': NEW_TEXT_VERSION_ON_EDIT,
'note' : '',
'keep_comments' : True,
'cancel_modified_scopes' : True,
}
if request.user.is_authenticated():
form = EditTextForm(default_data)
else:
form = EditTextFormAnon(default_data)
template_dict = {'text' : text, 'form' : form}
return render_to_response('site/text_edit.html', template_dict , context_instance=RequestContext(request))
def user_add(request, key=None, mass=False):
text = get_text_by_keys_or_404(key) if key else None
if request.method == 'POST':
userform = UserForm(request.POST) if not mass else MassUserForm(
request.POST)
userroleform = UserRoleForm(request.POST)
noteform = UserAddForm(request.POST)
userprofileform = UserProfileAddForm(request.POST)
localroleform = UserRoleTextForm(request.POST,
prefix="local") if key else None
if userform.is_valid() and userroleform.is_valid(
) and noteform.is_valid() and userprofileform.is_valid() and (
not localroleform or localroleform.is_valid()):
data = userform.cleaned_data
data.update(userprofileform.cleaned_data)
data.update(noteform.cleaned_data)
emails = data['email']
del data['email']
email_created = set()
for email in [s.strip() for s in SEPARATORS_RE.split(emails)]:
if email and not User.objects.filter(
email__iexact=email) and email not in email_created:
user = UserProfile.objects.create_inactive_user(
email, True, **data)
userrole = UserRole.objects.create(
user=user,
role=userroleform.cleaned_data['role'],
text=None)
if key:
localuserrole = UserRole.objects.create(
user=user,
role=localroleform.cleaned_data['role'],
text=text)
email_created.add(email)
register_activity(request, "user_created", user=user)
display_message(
request,
ungettext(u'%(nb_users)d user added',
u'%(nb_users)d users added', len(email_created)) %
{'nb_users': len(email_created)})
if key:
return HttpResponseRedirect(
reverse('text-share', args=[text.key]))
else:
return HttpResponseRedirect(reverse('user'))
else:
userform = UserForm() if not mass else MassUserForm()
userroleform = UserRoleForm()
userprofileform = UserProfileAddForm(
{'preferred_language': request.LANGUAGE_CODE})
noteform = UserAddForm()
localroleform = UserRoleTextForm(prefix="local") if key else None
if key:
template = 'site/user_mass_add_text.html' if mass else 'site/user_add_text.html'
else:
template = 'site/user_mass_add.html' if mass else 'site/user_add.html'
return render_to_response(template, {
'forms':
[userform, userprofileform, userroleform, noteform, localroleform],
'save_name':
ungettext(u'Add user', u'Add users', 2 if mass else 1),
'mass':
mass,
'text':
text,
},
context_instance=RequestContext(request))
def text_share(request, key):
display_suspended_users = get_int(request.GET, 'display', 0)
tag_selected = request.GET.get('tag_selected', 0)
paginate_by = get_int(request.GET, 'paginate', USER_PAGINATION)
text = get_text_by_keys_or_404(key)
order_by = get_among(request.GET,'order',('user__username',
'user__email',
'-user__username',
'-user__email',
'role__name',
'-role__name',
),
'user__username')
UserRole.objects.create_userroles_text(text)
if request.method == 'POST':
if 'save' in request.POST:
user_profile_keys_roles = get_keys_from_dict(request.POST, 'user-role-')
count = 0
for user_profile_key in user_profile_keys_roles:
role_id = user_profile_keys_roles[user_profile_key]
if not user_profile_key:
user_role = UserRole.objects.get(user = None, text = text)
else:
user_role = UserRole.objects.get(user__userprofile__key = user_profile_key, text = text)
if (role_id != u'' or user_role.role_id!=None) and role_id!=unicode(user_role.role_id):
if role_id:
user_role.role_id = int(role_id)
else:
user_role.role_id = None
user_role.save()
count += 1
display_message(request, _(u'%(count)i user(s) role modified') %{'count':count})
return HttpResponseRedirect(reverse('text-share', args=[text.key]))
anon_role = UserRole.objects.get(user = None, text = text).role
global_anon_role = UserRole.objects.get(user = None, text = None).role
context = {
'anon_role' : anon_role,
'global_anon_role' : global_anon_role,
'all_roles' : Role.objects.all(),
'anon_roles' : Role.objects.filter(anon = True),
'text' : text,
'display_suspended_users' : display_suspended_users,
'tag_list' : Tag.objects.usage_for_model(UserProfile),
'tag_selected': tag_selected,
}
query = UserRole.objects.filter(text=text).filter(~Q(user=None)).order_by(order_by)
if not display_suspended_users:
query = query.exclude(Q(user__userprofile__is_suspended=True) & Q(user__is_active=True))
else:
# trick to include userprofile table anyway (to filter by tags)
query = query.filter(Q(user__userprofile__is_suspended=True) | Q(user__userprofile__is_suspended=False))
if tag_selected:
tag_ids = Tag.objects.filter(name=tag_selected)
if tag_ids:
content_type_id = ContentType.objects.get_for_model(UserProfile).pk
query = query.extra(where=['tagging_taggeditem.object_id = cm_userprofile.id',
'tagging_taggeditem.content_type_id = %i' %content_type_id,
'tagging_taggeditem.tag_id = %i' %tag_ids[0].id],
tables=['tagging_taggeditem'],
)
return object_list(request, query,
template_name = 'site/text_share.html',
paginate_by = paginate_by,
extra_context = context,
)
