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 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 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 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 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 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 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_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 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 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 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)
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 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'))
