def user_followed_questions(request, user, context): if not request.user.has_user_perm('can_see_followed_threads', user): return render_forbidden(request) user.user_followed_threads.values_list('thread', flat=True) questions = models.Post.objects.filter( post_type='question', thread__in=user.user_followed_threads.values_list('thread', flat=True) # followed_threads ).select_related( 'thread', 'thread__last_activity_by' ).order_by( '-points', '-thread__last_activity_at' )[:const.USER_VIEW_DATA_SIZE] context.update({ 'active_tab': 'users', 'page_class': 'user-profile-page', 'tab_description': _('users followed questions'), 'page_title': _('profile - followed questions'), 'questions': questions, 'view_user': user }) return render_into_skin('user_profile/user_followed_questions.html', context, request)
def node_detail(request, node_id, node_slug): """ node detail """ node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect(node.get_absolute_url()) if not request.user.has_openode_perm('node_read', node): if request.user.has_openode_perm('node_show', node): return node_ask_to_join(request, node_id, node_slug) else: return render_forbidden(request) available_modules = [m[0] for m in node.get_modules()] default_module = node.default_module if default_module in available_modules: return HttpResponseRedirect( reverse('node_module', kwargs={ 'node_id': node.pk, 'node_slug': node.slug, 'module': default_module })) else: # fallback to annotation return HttpResponseRedirect( reverse('node_module', kwargs={ 'node_id': node.pk, 'node_slug': node.slug, 'module': const.NODE_MODULE_ANNOTATION }))
def question_flow_new(request, profile_owner, context): if not request.user.has_perm('can_solve_question_flow', None): return render_forbidden(request) if request.method == "POST": # raw_node = request.GET.get(node) # if raw_node and str(raw_node).isdigit(): question_pk = request.POST.get("question") if question_pk and question_pk.isdigit(): question = get_object_or_404(Thread, pk=int(question_pk)) form = QuestionFlowNodeResponsibleUsersForm(request.POST, question=question) if form.is_valid(): question.question_flow_interviewee_user = form.cleaned_data[form.get_responsible_users_field_name()] question.question_flow_responsible_user = request.user question.question_flow_state = const.QUESTION_FLOW_STATE_SUBMITTED question.save() return HttpResponseRedirect(request.path) context.update({ 'view_user': request.user, "get_qf_form": lambda question: QuestionFlowNodeResponsibleUsersForm(question=question), "page_title": _("question flow new"), }) return render_into_skin('user_profile/question_flow_new.html', context, request)
def category_add(request, node_id, node_slug): """ add ThreadCategory recently used only for structuring Document Threads, so is called Directory """ node = get_object_or_404(Node, pk=node_id) if not request.user.has_openode_perm("document_directory_create", node): return render_forbidden(request) if request.method == "POST": form = AddThreadCategoryForm(request.POST, node=node) if form.is_valid(): thread_category = form.save() request.user.log(thread_category, const.LOG_ACTION_ADD_THREAD_CATEGORY) return HttpResponseRedirect( reverse("node_module", args=[node.pk, node.slug, "library"])) else: form = AddThreadCategoryForm(node=node, initial={"node": node}) to_tmpl = { "node": node, "form": form, "directory": None, } return render_into_skin('node/document/edit_directory.html', to_tmpl, request)
def category_edit(request, node_id, node_slug, category_id): """ edit ThreadCategory recently used only for structuring Document Threads, so is called Directory """ node = get_object_or_404(Node, pk=node_id) try: category = node.thread_categories.get(pk=category_id) except ObjectDoesNotExist: raise Http404 if not category.has_update_perm(request.user): return render_forbidden(request) if request.method == "POST": form = EditThreadCategoryForm(request.POST, instance=category) if form.is_valid(): form.save() request.user.log(category, const.LOG_ACTION_THREAD_CATEGORY_EDIT) return HttpResponseRedirect(reverse("node_module", args=[node.pk, node.slug, "library"])) else: form = EditThreadCategoryForm(instance=category) to_tmpl = { "node": node, "form": form, "directory": category, } return render_into_skin('node/document/edit_directory.html', to_tmpl, request)
def category_edit(request, node_id, node_slug, category_id): """ edit ThreadCategory recently used only for structuring Document Threads, so is called Directory """ node = get_object_or_404(Node, pk=node_id) try: category = node.thread_categories.get(pk=category_id) except ObjectDoesNotExist: raise Http404 if not category.has_update_perm(request.user): return render_forbidden(request) if request.method == "POST": form = EditThreadCategoryForm(request.POST, instance=category) if form.is_valid(): form.save() request.user.log(category, const.LOG_ACTION_THREAD_CATEGORY_EDIT) return HttpResponseRedirect( reverse("node_module", args=[node.pk, node.slug, "library"])) else: form = EditThreadCategoryForm(instance=category) to_tmpl = { "node": node, "form": form, "directory": category, } return render_into_skin('node/document/edit_directory.html', to_tmpl, request)
def category_add(request, node_id, node_slug): """ add ThreadCategory recently used only for structuring Document Threads, so is called Directory """ node = get_object_or_404(Node, pk=node_id) if not request.user.has_openode_perm("document_directory_create", node): return render_forbidden(request) if request.method == "POST": form = AddThreadCategoryForm(request.POST, node=node) if form.is_valid(): thread_category = form.save() request.user.log(thread_category, const.LOG_ACTION_ADD_THREAD_CATEGORY) return HttpResponseRedirect(reverse("node_module", args=[node.pk, node.slug, "library"])) else: form = AddThreadCategoryForm(node=node, initial={"node": node}) to_tmpl = { "node": node, "form": form, "directory": None, } return render_into_skin('node/document/edit_directory.html', to_tmpl, request)
def node_annotation_edit(request, node_id, node_slug): """ Node Annotation Edit """ node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect( reverse('node_annotation_edit', kwargs={ 'node_id': node_id, 'node_slug': node.slug })) if not request.user.has_openode_perm('node_edit_annotation', node): return render_forbidden(request) text = getattr(node.description, "text", u"") data = {"text": text} if text else None if request.method == "POST": data = MergeDict(request.POST, data) form = NodeAnnotationEditForm(data=data, node=node) if form.is_valid(): text = form.cleaned_data["text"] # edit if node.description: node.description.apply_edit(edited_by=request.user, text=text) # create new one else: post = Post.objects.create_new( thread=None, author=request.user, added_at=datetime.now(), text=text, post_type="node_description", ) post.save() node.description = post node.save() request.user.message_set.create( message=_('Node annotation has been succesfully saved.')) return HttpResponseRedirect( reverse('node_annotation_edit', args=[node.pk, node.slug])) else: form = NodeAnnotationEditForm(data=data, node=node) template_data = { 'node': node, 'form': form, 'page_class': 'node-edit', } return render_into_skin('node/annotation/edit.html', template_data, request)
def user_logs(request, user, context): if request.user != user and not request.user.has_perm('openode.view_other_user_log'): return render_forbidden(request) data = { 'logs': user.logs.all().order_by('-action_time')[:50] } context.update(data) return render_into_skin('user_profile/user_logs.html', context, request)
def node_settings(request, node_id, node_slug): """ Node Settings """ node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect( reverse('node_settings', kwargs={ 'node_id': node_id, 'node_slug': node.slug })) if not (request.user.is_admin('openode.change_node') or request.user.has_openode_perm('node_settings', node)): return render_forbidden(request) NodeUserInlineFormSet = inlineformset_factory(Node, NodeUser, form=NodeUserForm, extra=1) node_users = NodeUser.objects.filter(node=node).order_by( 'role', 'user__last_name', 'user__first_name') if request.method == "POST": form = NodeSettingsForm(instance=node, data=request.POST) formset = NodeUserInlineFormSet(request.POST, instance=node, queryset=node_users) form_is_valid = form.is_valid() formset_is_valid = formset.is_valid() if form_is_valid and formset_is_valid: form.save(user=request.user) formset.save() request.user.message_set.create( message=_('Node settings has been succesfully saved.')) return HttpResponseRedirect( reverse('node_settings', args=[node.pk, node.slug])) else: form = NodeSettingsForm(instance=node) formset = NodeUserInlineFormSet(instance=node, queryset=node_users) user_emails_by_role = SortedDict() for node_user in node_users: user_emails_by_role.setdefault(node_user.get_role_display(), []).append(node_user.user.email) template_data = { 'node': node, 'form': form, 'formset': formset, 'user_emails_by_role': user_emails_by_role, 'page_class': 'node-edit', } return render_into_skin('node/edit_settings.html', template_data, request)
def question_flow_to_publish(request, profile_owner, context): if not request.user.has_perm('can_solve_question_flow', None): return render_forbidden(request) context.update({ 'view_user': request.user, "page_title": _("question flow new"), }) return render_into_skin('user_profile/question_flow_to_check.html', context, request)
def node_annotation_edit(request, node_id, node_slug): """ Node Annotation Edit """ node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect(reverse('node_annotation_edit', kwargs={ 'node_id': node_id, 'node_slug': node.slug })) if not request.user.has_openode_perm('node_edit_annotation', node): return render_forbidden(request) text = getattr(node.description, "text", u"") data = {"text": text} if text else None if request.method == "POST": data = MergeDict(request.POST, data) form = NodeAnnotationEditForm(data=data, node=node) if form.is_valid(): text = form.cleaned_data["text"] # edit if node.description: node.description.apply_edit( edited_by=request.user, text=text ) # create new one else: post = Post.objects.create_new( thread=None, author=request.user, added_at=datetime.now(), text=text, post_type="node_description", ) post.save() node.description = post node.save() request.user.message_set.create(message=_('Node annotation has been succesfully saved.')) return HttpResponseRedirect(reverse('node_annotation_edit', args=[node.pk, node.slug])) else: form = NodeAnnotationEditForm(data=data, node=node) template_data = { 'node': node, 'form': form, 'page_class': 'node-edit', } return render_into_skin('node/annotation/edit.html', template_data, request)
def thread(request, node_id, node_slug, module, thread_id, thread_slug): # TODO: refactor - long subroutine. display question body, answers and comments """view that displays body of the question and all answers to it """ node = get_object_or_404(Node, pk=node_id) thread = get_object_or_404(Thread, pk=thread_id, node=node) # raise not found if module is disabled if not getattr( node, "module_%s" % const.NODE_MODULE_BY_THREAD_TYPE[thread.thread_type], False): raise Http404 if not request.user.has_openode_perm('%s_read' % thread.thread_type, thread): return render_forbidden(request) if module not in const.THREAD_TYPE_BY_NODE_MODULE or const.THREAD_TYPE_BY_NODE_MODULE[ module] != thread.thread_type: raise Http404() if module == const.NODE_MODULE_LIBRARY: return document_detail_view(request, node, thread) if node.slug != node_slug or thread.slug != thread_slug: return HttpResponseRedirect( reverse('thread', kwargs={ 'node_id': node_id, 'node_slug': node.slug, 'module': module, 'thread_id': thread_id, 'thread_slug': thread.slug })) # process url parameters # todo: fix inheritance of sort method from questions # before = datetime.datetime.now() default_sort_method = request.session.get('questions_sort_method', thread.get_default_sort_method()) form = ShowQuestionForm(request.GET, default_sort_method) form.full_clean() # always valid show_answer = form.cleaned_data['show_answer'] show_comment = form.cleaned_data['show_comment'] show_page = form.cleaned_data['show_page'] answer_sort_method = form.cleaned_data['answer_sort_method'] main_post = thread._main_post() try: main_post.assert_is_visible_to(request.user) except openode_exceptions.QuestionHidden, error: request.user.message_set.create(message=unicode(error)) return HttpResponseRedirect(reverse('index'))
def edit_answer(request, id): # TODO rename answer to post answer = get_object_or_404(models.Post, id=id) if not answer.has_edit_perm(request.user): return render_forbidden(request) revision = answer.get_latest_revision() try: request.user.assert_can_edit_answer(answer) if request.method == "POST": if request.POST['select_revision'] == 'true': # user has changed revistion number revision_form = forms.RevisionForm(answer, revision, request.POST) if revision_form.is_valid(): # Replace with those from the selected revision rev = revision_form.cleaned_data['revision'] revision = answer.revisions.get(revision=rev) form = forms.EditAnswerForm(answer, revision) else: form = forms.EditAnswerForm(answer, revision, request.POST) else: form = forms.EditAnswerForm(answer, revision, request.POST) revision_form = forms.RevisionForm(answer, revision) if form.is_valid(): if form.has_changed(): user = request.user user.edit_answer( answer=answer, body_text=form.cleaned_data['text'], revision_comment=form.cleaned_data['summary'], ) return HttpResponseRedirect(answer.get_absolute_url()) else: revision_form = forms.RevisionForm(answer, revision) form = forms.EditAnswerForm(answer, revision) data = { 'page_class': 'edit-answer-page', 'active_tab': 'questions', 'answer': answer, 'revision': revision, 'revision_form': revision_form, 'form': form, } return render_into_skin('node/%s/edit_post.html' % answer.thread.thread_type, data, request) except exceptions.PermissionDenied, e: request.user.message_set.create(message=unicode(e)) return HttpResponseRedirect(answer.get_absolute_url())
def category_reorg(request, node_id, node_slug): node = get_object_or_404(Node, pk=node_id) if not request.user.has_openode_perm("document_directory_create", node): return render_forbidden(request) to_tmpl = { "categories": node.thread_categories.filter(level=0), "node": node } return render_into_skin('node/document/reorg_directory.html', to_tmpl, request)
def node_module(request, node_id, node_slug, module, **kwargs): """ node detail modulu thread_type -> setup Thread.thread_type or summary """ # bypass for forum module if module == const.NODE_MODULE_FORUM: return node_module_forum(request, node_id, node_slug, module, **kwargs) node = get_object_or_404(Node, pk=node_id) if module in node.get_modules() and module not in [m[0] for m in node.get_modules()]: raise Http404() if node.slug != node_slug: return HttpResponseRedirect(reverse('node_module', kwargs={'node_id': node.pk, 'node_slug': node.slug, 'module': module})) if not request.user.has_openode_perm('node_read', node): if node.visibility == const.NODE_VISIBILITY_SEMIPRIVATE: return node_ask_to_join(request, node.pk, node.slug) return render_forbidden(request) if request.method != 'GET': return HttpResponseNotAllowed(['GET']) if module in const.THREAD_TYPE_BY_NODE_MODULE: return node_module_thread(request, node, module, **kwargs) template_file = NODE_MODULE_TEMPLATE_FILE[module] template_data = { 'node': node, 'module': module } if module == const.NODE_MODULE_ANNOTATION: try: page_no = int(request.GET.get("page", 1)) except ValueError: page_no = 1 end = LIVE_PER_PAGE * page_no start = end - LIVE_PER_PAGE template_data.update({ "live_threads": get_live_data(request.user, start, end, node), "page": page_no, "check_perm": check_perm }) return render_into_skin(template_file, template_data, request)
def user_followed_nodes(request, user, context): if not request.user.has_user_perm('can_see_followed_nodes', user): return render_forbidden(request) followed_nodes = user.user_followed_nodes.all() data = { 'active_tab': 'users', 'page_class': 'user-profile-page', 'tab_description': _('users followed nodes'), 'page_title': _('profile - followed nodes'), 'followed_nodes': followed_nodes, 'view_user': user } context.update(data) return render_into_skin('user_profile/user_followed_nodes.html', context, request)
def user_managed_nodes(request, user, context): if not request.user.has_user_perm('can_see_followed_nodes', user): return render_forbidden(request) managed_nodes = user.nodes.filter(node_users__role=const.NODE_USER_ROLE_MANAGER) data = { 'active_tab': 'users', 'page_class': 'user-profile-page', 'tab_description': _('users managed nodes'), 'page_title': _('profile - managed nodes'), 'managed_nodes': managed_nodes, } context.update(data) return render_into_skin('user_profile/user_managed_nodes.html', context, request)
def discussion_answer(request, pk): try: post = Post.objects.get(pk=pk) thread = post.thread node = thread.node except ObjectDoesNotExist: raise Http404 if not request.user.has_openode_perm('discussion_read', node): return render_forbidden(request) to_tmpl = { "answer": post, "posts_per_pages": {} } return render_into_skin('node/discussion/discussion_answer.html', to_tmpl, request)
def thread(request, node_id, node_slug, module, thread_id, thread_slug): # refactor - long subroutine. display question body, answers and comments """view that displays body of the question and all answers to it """ node = get_object_or_404(Node, pk=node_id) thread = get_object_or_404(Thread, pk=thread_id, node=node) # raise not found if module is disabled if not getattr(node, "module_%s" % const.NODE_MODULE_BY_THREAD_TYPE[thread.thread_type], False): raise Http404 if not request.user.has_openode_perm('%s_read' % thread.thread_type, thread): return render_forbidden(request) if module not in const.THREAD_TYPE_BY_NODE_MODULE or const.THREAD_TYPE_BY_NODE_MODULE[module] != thread.thread_type: raise Http404() if module == const.NODE_MODULE_LIBRARY: return document_detail_view(request, node, thread) if node.slug != node_slug or thread.slug != thread_slug: return HttpResponseRedirect(reverse('thread', kwargs={ 'node_id': node_id, 'node_slug': node.slug, 'module': module, 'thread_id': thread_id, 'thread_slug': thread.slug })) #process url parameters #todo: fix inheritance of sort method from questions #before = datetime.datetime.now() default_sort_method = request.session.get('questions_sort_method', thread.get_default_sort_method()) form = ShowQuestionForm(request.GET, default_sort_method) form.full_clean() # always valid show_answer = form.cleaned_data['show_answer'] show_comment = form.cleaned_data['show_comment'] show_page = form.cleaned_data['show_page'] answer_sort_method = form.cleaned_data['answer_sort_method'] main_post = thread._main_post() try: main_post.assert_is_visible_to(request.user) except openode_exceptions.QuestionHidden, error: request.user.message_set.create(message=unicode(error)) return HttpResponseRedirect(reverse('index'))
def node_settings(request, node_id, node_slug): """ Node Settings """ node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect(reverse('node_settings', kwargs={ 'node_id': node_id, 'node_slug': node.slug })) if not (request.user.is_admin('openode.change_node') or request.user.has_openode_perm('node_settings', node)): return render_forbidden(request) NodeUserInlineFormSet = inlineformset_factory(Node, NodeUser, form=NodeUserForm, extra=1) node_users = NodeUser.objects.filter(node=node).order_by('role', 'user__last_name', 'user__first_name') if request.method == "POST": form = NodeSettingsForm(instance=node, data=request.POST) formset = NodeUserInlineFormSet(request.POST, instance=node, queryset=node_users) form_is_valid = form.is_valid() formset_is_valid = formset.is_valid() if form_is_valid and formset_is_valid: form.save(user=request.user) formset.save() request.user.message_set.create(message=_('Node settings has been succesfully saved.')) return HttpResponseRedirect(reverse('node_settings', args=[node.pk, node.slug])) else: form = NodeSettingsForm(instance=node) formset = NodeUserInlineFormSet(instance=node, queryset=node_users) user_emails_by_role = SortedDict() for node_user in node_users: user_emails_by_role.setdefault(node_user.get_role_display(), []).append(node_user.user.email) template_data = { 'node': node, 'form': form, 'formset': formset, 'user_emails_by_role': user_emails_by_role, 'page_class': 'node-edit', } return render_into_skin('node/edit_settings.html', template_data, request)
def category_delete(request, node_id, node_slug, category_id): # TODO: check perm node = get_object_or_404(Node, pk=node_id) try: category = node.thread_categories.get(pk=category_id) except ObjectDoesNotExist: raise Http404 else: if not category.has_delete_perm(request.user): return render_forbidden(request) category.delete() return HttpResponseRedirect( reverse("node_module", args=[node.pk, node.slug, const.NODE_MODULE_LIBRARY]) )
def category_delete(request, node_id, node_slug, category_id): # TODO: check perm node = get_object_or_404(Node, pk=node_id) try: category = node.thread_categories.get(pk=category_id) except ObjectDoesNotExist: raise Http404 else: if not category.has_delete_perm(request.user): return render_forbidden(request) category.delete() return HttpResponseRedirect( reverse("node_module", args=[node.pk, node.slug, const.NODE_MODULE_LIBRARY]))
def node_perexes_edit(request, node_id, node_slug): node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect( reverse('node_perexes_edit', kwargs={ 'node_id': node_id, 'node_slug': node.slug })) if not (request.user.is_admin('openode.change_node') or request.user.has_openode_perm('node_settings', node)): return render_forbidden(request) fields = ( "perex_node_important", "perex_node", ) for module_name, xx, xxx in node.get_modules(): fields += ("perex_%s" % module_name, "perex_%s_important" % module_name) Form = modelform_factory(Node, form=PerexesEditForm, fields=fields) if request.method == "POST": form = Form(request.POST, instance=node) if form.is_valid(): form.save() request.user.message_set.create( message=_('Node perexes has been succesfully saved.')) else: form = Form(instance=node) to_tmpl = { "form": form, "node": node, "modules": [m[0] for m in node.get_modules()] } return render_into_skin("node/edit_perexes.html", to_tmpl, request)
def node_perexes_edit(request, node_id, node_slug): node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect(reverse('node_perexes_edit', kwargs={ 'node_id': node_id, 'node_slug': node.slug })) if not (request.user.is_admin('openode.change_node') or request.user.has_openode_perm('node_settings', node)): return render_forbidden(request) fields = ( "perex_node_important", "perex_node", ) for module_name, xx, xxx in node.get_modules(): fields += ( "perex_%s" % module_name, "perex_%s_important" % module_name ) Form = modelform_factory(Node, form=PerexesEditForm, fields=fields) if request.method == "POST": form = Form(request.POST, instance=node) if form.is_valid(): form.save() request.user.message_set.create(message=_('Node perexes has been succesfully saved.')) else: form = Form(instance=node) to_tmpl = { "form": form, "node": node, "modules": [m[0] for m in node.get_modules()] } return render_into_skin("node/edit_perexes.html", to_tmpl, request)
def node_detail(request, node_id, node_slug): """ node detail """ node = get_object_or_404(Node, pk=node_id) if node.slug != node_slug: return HttpResponseRedirect(node.get_absolute_url()) if not request.user.has_openode_perm('node_read', node): if request.user.has_openode_perm('node_show', node): return node_ask_to_join(request, node_id, node_slug) else: return render_forbidden(request) available_modules = [m[0] for m in node.get_modules()] default_module = node.default_module if default_module in available_modules: return HttpResponseRedirect(reverse('node_module', kwargs={'node_id': node.pk, 'node_slug': node.slug, 'module': default_module})) else: # fallback to annotation return HttpResponseRedirect(reverse('node_module', kwargs={'node_id': node.pk, 'node_slug': node.slug, 'module': const.NODE_MODULE_ANNOTATION}))
#maybe load draft if request.user.is_authenticated(): #todo: refactor into methor on thread drafts = models.DraftAnswer.objects.filter( author=request.user, thread=thread ) if drafts.count() > 0: initial['text'] = drafts[0].text #answer form if request.method == "POST": if not thread.has_response_perm(request.user): return render_forbidden(request) answer_form = AnswerForm(request.POST, node=node) if answer_form.is_valid(): text = answer_form.cleaned_data['text'] update_time = datetime.datetime.now() if request.user.is_authenticated(): drafts = models.DraftAnswer.objects.filter( author=request.user, thread=thread ) drafts.delete() try: follow = answer_form.cleaned_data['email_notify']
def edit_thread(request, id): """edit question view """ thread = get_object_or_404(models.Thread, id=id) main_post = thread._main_post() revision = main_post.get_latest_revision() revision_form = None if not thread.has_edit_perm(request.user): return render_forbidden(request) is_document = bool(thread.thread_type == const.THREAD_TYPE_DOCUMENT) is_document_form = bool("file_data" in (request.FILES.keys() + request.POST.keys())) data = { "is_document": is_document, } try: ############################### # DOCUMENT FILE EDIT ############################### if is_document: if (request.method == "POST") and is_document_form: document_form = DocumentFileForm(request.POST, request.FILES) if document_form.is_valid(): if document_form.cleaned_data["remove"]: document = thread.get_document(with_deleted=True) doc_pk = int(document.pk) document.delete() request.user.log( document, const.LOG_ACTION_DELETE_DOCUMENT, object_force_pk=doc_pk ) request.user.message_set.create(message=_('Document has been deleted.')) del document else: document_revision = create_document_revision( thread, document_form.cleaned_data, request ) request.user.log(document_revision.document, const.LOG_ACTION_UPDATE_DOCUMENT) request.user.message_set.create(message=_('Document has been successfully saved.')) return HttpResponseRedirect(thread.get_absolute_url()) else: document_form = DocumentFileForm() data.update({ "document_form": document_form, "document": thread.get_document(), }) ############################### # EDIT THREAD ############################### request.user.assert_can_edit_thread(thread) if request.method == 'POST' and (is_document_form is False): if request.POST['select_revision'] == 'true': #revert-type edit - user selected previous revision revision_form = forms.RevisionForm( main_post, revision, request.POST ) if revision_form.is_valid(): # Replace with those from the selected revision rev_id = revision_form.cleaned_data['revision'] revision = main_post.revisions.get(revision=rev_id) form = forms.EditQuestionForm( main_post=main_post, user=request.user, revision=revision, node=thread.node, text_required=not is_document ) else: form = forms.EditQuestionForm( request.POST, main_post=main_post, user=request.user, revision=revision, node=thread.node, text_required=not is_document ) else: # new content edit # Always check modifications against the latest revision form = forms.EditQuestionForm( request.POST, main_post=main_post, revision=revision, user=request.user, node=thread.node, text_required=not is_document ) revision_form = forms.RevisionForm(main_post, revision) if form.is_valid(): if form.has_changed(): _data = { "thread": thread, "title": form.cleaned_data['title'], "body_text": form.cleaned_data['text'], "revision_comment": form.cleaned_data['summary'], } # if request.user.has_perm('openode.change_tag'): if thread.can_retag(request.user): _data.update({ "tags": form.cleaned_data['tags'] }) request.user.edit_thread(**_data) del _data category = form.cleaned_data["category"] allow_external_access = form.cleaned_data["allow_external_access"] do_save = False if is_document and (thread.category != category): thread.category = category do_save = True request.user.log(thread, const.LOG_ACTION_DOCUMENT_MOVE) if is_document and (thread.external_access != allow_external_access): thread.external_access = allow_external_access do_save = True if do_save: thread.save() if thread.thread_type == const.THREAD_TYPE_QUESTION: request.user.log(thread, const.LOG_ACTION_UPDATE_QUESTION) request.user.message_set.create(message=_('Question has been successfully saved.')) if thread.thread_type == const.THREAD_TYPE_DISCUSSION: request.user.log(thread, const.LOG_ACTION_UPDATE_DISCUSSION) request.user.message_set.create(message=_('Discussion has been successfully saved.')) if thread.thread_type == const.THREAD_TYPE_DOCUMENT: request.user.log(thread, const.LOG_ACTION_UPDATE_DOCUMENT) request.user.message_set.create(message=_('Document has been successfully saved.')) return HttpResponseRedirect(thread.get_absolute_url()) else: revision_form = forms.RevisionForm(main_post, revision) form = forms.EditQuestionForm( main_post=main_post, revision=revision, user=request.user, initial={}, node=thread.node, text_required=not is_document ) data.update({ 'page_class': 'edit-question-page', 'active_tab': 'questions', 'main_post': main_post, 'revision': revision, 'revision_form': revision_form, 'form': form, 'thread_type': thread.thread_type, 'tag_names': thread.get_tag_names(), }) data.update(context.get_for_tag_editor()) return render_into_skin('node/%s/edit.html' % thread.thread_type, data, request) except exceptions.PermissionDenied, e: request.user.message_set.create(message=unicode(e)) return HttpResponseRedirect(thread.get_absolute_url())
def organization_detail(request, organization_id, organization_slug): if not request.user.is_authenticated(): return render_forbidden(request) user_acceptance_level = 'closed' user_membership_level = 'none' try: organization = models.Organization.objects.get(id=organization_id) user_acceptance_level = organization.get_openness_level_for_user( request.user ) except models.Organization.DoesNotExist: raise Http404 ################################################################ # upload organization logo logo_form = OrganizationLogoForm(instance=organization) if request.method == "POST": logo_form = OrganizationLogoForm(request.POST, request.FILES, instance=organization) if logo_form.is_valid(): logo_form.save() return HttpResponseRedirect(request.path) ################################################################ if organization_slug == slugify(organization.title): users = models.User.objects.exclude(status='b') #filter users by full organization memberships #todo: refactor as Organization.get_full_members() full_level = models.OrganizationMembership.FULL memberships = models.OrganizationMembership.objects.filter( organization=organization, level=full_level ) user_ids = memberships.values_list('user__id', flat=True) users = users.filter(id__in=user_ids) if request.user.is_authenticated(): membership = request.user.get_organization_membership(organization) if membership: user_membership_level = membership.get_level_display() else: organization_page_url = reverse( 'organization_detail', kwargs={ 'organization_id': organization.id, 'organization_slug': slugify(organization.title) } ) return HttpResponseRedirect(organization_page_url) sortby = request.GET.get('sort', 'last_name') try: page = int(request.GET.get('page', '1')) except ValueError: page = 1 search_query = request.REQUEST.get('query', "") if search_query == "": if sortby == "newest": order_by_parameter = ('-date_joined',) elif sortby == "last": order_by_parameter = ('date_joined',) elif sortby == "user": order_by_parameter = ('last_name', 'first_name') else: # default order_by_parameter = ('last_name', 'first_name') objects_list = Paginator( users.order_by(*order_by_parameter), const.USERS_PAGE_SIZE ) base_url = request.path + '?sort=%s&' % sortby else: sortby = "last_name" matching_users = models.get_users_by_text_query(search_query, users) objects_list = Paginator( matching_users.order_by(*('last_name', 'first_name')), const.USERS_PAGE_SIZE ) base_url = request.path + '?name=%s&sort=%s&' % (search_query, sortby) try: users_page = objects_list.page(page) except (EmptyPage, InvalidPage): users_page = objects_list.page(objects_list.num_pages) paginator_data = { 'is_paginated': bool(objects_list.count > const.USERS_PAGE_SIZE), 'pages': objects_list.num_pages, 'page': page, 'has_previous': users_page.has_previous(), 'has_next': users_page.has_next(), 'previous': users_page.previous_page_number(), 'next': users_page.next_page_number(), 'base_url': base_url } paginator_context = functions.setup_paginator(paginator_data) #todo: cleanup this branched code after organizations are migrated to auth_organization user_organizations = get_organizations().all() if len(user_organizations) <= 1: user_organizations = None organization_openness_choices = models.Organization().get_openness_choices() data = { 'active_tab': 'users', 'page_class': 'users-page', 'users': users_page, 'organization': organization, 'search_query': search_query, 'tab_id': sortby, 'paginator_context': paginator_context, 'user_acceptance_level': user_acceptance_level, 'user_membership_level': user_membership_level, 'user_organizations': user_organizations, 'organization_openness_choices': organization_openness_choices, "logo_form": logo_form, } return render_into_skin('organization_detail.html', data, request)
initial = {'email_notify': thread.is_subscribed_by(request.user)} # maybe load draft if request.user.is_authenticated(): # todo: refactor into methor on thread drafts = models.DraftAnswer.objects.filter(author=request.user, thread=thread) if drafts.count() > 0: initial['text'] = drafts[0].text # answer form if request.method == "POST": if not thread.has_response_perm(request.user): return render_forbidden(request) answer_form = AnswerForm(request.POST, node=node) if answer_form.is_valid(): text = answer_form.cleaned_data['text'] update_time = datetime.datetime.now() if request.user.is_authenticated(): drafts = models.DraftAnswer.objects.filter(author=request.user, thread=thread) drafts.delete() try: follow = answer_form.cleaned_data['email_notify'] user = request.user
def show_users(request): """Users view, including listing of users by organization""" if not request.user.is_authenticated(): return render_forbidden(request) users = models.User.objects.filter(is_active=True, is_hidden=False).exclude(status='b') organization = None logo_form = None sortby = request.GET.get('sort', 'last_name') try: page = int(request.GET.get('page', '1')) except ValueError: page = 1 search_query = request.REQUEST.get('query', "") if search_query == "": if sortby == "newest": order_by_parameter = ('-date_joined',) elif sortby == "last": order_by_parameter = ('date_joined',) elif sortby == "last_name": order_by_parameter = ('last_name', 'first_name') else: # default order_by_parameter = ('last_name', 'first_name') objects_list = Paginator( users.order_by(*order_by_parameter), const.USERS_PAGE_SIZE ) base_url = request.path + '?sort=%s&' % sortby else: sortby = "last_name" matching_users = models.get_users_by_text_query(search_query, users) objects_list = Paginator( matching_users.order_by(*('last_name', 'first_name')), const.USERS_PAGE_SIZE ) base_url = request.path + '?name=%s&sort=%s&' % (search_query, sortby) try: users_page = objects_list.page(page) except (EmptyPage, InvalidPage): users_page = objects_list.page(objects_list.num_pages) paginator_data = { 'is_paginated': bool(objects_list.count > const.USERS_PAGE_SIZE), 'pages': objects_list.num_pages, 'page': page, 'has_previous': users_page.has_previous(), 'has_next': users_page.has_next(), 'previous': users_page.previous_page_number(), 'next': users_page.next_page_number(), 'base_url': base_url } paginator_context = functions.setup_paginator(paginator_data) data = { 'active_tab': 'users', 'page_class': 'users-page', 'users': users_page, 'organization': organization, 'search_query': search_query, 'tab_id': sortby, 'paginator_context': paginator_context, "logo_form": logo_form, } return render_into_skin('user_list.html', data, request)
def thread_add(request, node_id, node_slug, module): # view used to add a new thread """a view to ask a new question gives space for q title, body, tags user can start posting a question anonymously but then must login/register in order for the question go be shown """ node = get_object_or_404(Node, pk=node_id) if not request.user.has_openode_perm('node_%s_create' % module, node): return render_forbidden(request) if node.slug != node_slug: return HttpResponsePermanentRedirect(reverse('thread_add', kwargs={'node_id': node.pk, 'node_slug': node.slug, 'module': module})) if module not in const.THREAD_TYPE_BY_NODE_MODULE: raise Http404() thread_type = const.THREAD_TYPE_BY_NODE_MODULE[module] if module == "library": return add_document_view(request, node, thread_type) ThreadAddForm = forms.thread_add_form_factory(thread_type) form = ThreadAddForm(request.REQUEST, user=request.user, node=node) if request.method == 'POST': if form.is_valid(): timestamp = datetime.datetime.now() title = form.cleaned_data['title'] if request.user.has_perm('openode.change_tag'): tagnames = form.cleaned_data['tags'] text = form.cleaned_data['text'] if request.user.is_authenticated(): drafts = models.DraftQuestion.objects.filter( author=request.user ) drafts.delete() user = request.user try: kw = dict( title=title, body_text=text, timestamp=timestamp, node=node, thread_type=thread_type ) if request.user.has_perm('openode.change_tag'): kw.update({"tags": tagnames}) post = user.post_thread(**kw) # user must follow self created question if post.is_question(): user.toggle_followed_thread(post.thread) if thread_type == const.THREAD_TYPE_QUESTION: request.user.message_set.create(message=_('Question has been successfully saved and added to your followed items.')) if thread_type == const.THREAD_TYPE_DISCUSSION: request.user.message_set.create(message=_('Discussion has been successfully added.')) return HttpResponseRedirect(post.get_absolute_url()) except exceptions.PermissionDenied, e: request.user.message_set.create(message=unicode(e)) return HttpResponseRedirect(reverse('index'))