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