def create_thread(request, thread_data):
"""
Create a thread.
Arguments:
request: The django request object used for build_absolute_uri and
determining the requesting user.
thread_data: The data for the created thread.
Returns:
The created thread; see discussion_api.views.ThreadViewSet for more
detail.
"""
course_id = thread_data.get("course_id")
user = request.user
if not course_id:
raise ValidationError({"course_id": ["This field is required."]})
try:
course_key = CourseKey.from_string(course_id)
course = _get_course_or_404(course_key, user)
except (Http404, InvalidKeyError):
raise ValidationError({"course_id": ["Invalid value."]})
context = get_context(course, request)
_check_initializable_thread_fields(thread_data, context)
if (
"group_id" not in thread_data and
is_commentable_cohorted(course_key, thread_data.get("topic_id"))
):
thread_data = thread_data.copy()
thread_data["group_id"] = get_cohort_id(user, course_key)
serializer = ThreadSerializer(data=thread_data, context=context)
actions_form = ThreadActionsForm(thread_data)
if not (serializer.is_valid() and actions_form.is_valid()):
raise ValidationError(dict(serializer.errors.items() + actions_form.errors.items()))
serializer.save()
cc_thread = serializer.object
thread_created.send(sender=None, user=user, post=cc_thread)
api_thread = serializer.data
_do_extra_actions(api_thread, cc_thread, thread_data.keys(), actions_form, context)
track_forum_event(
request,
THREAD_CREATED_EVENT_NAME,
course,
cc_thread,
get_thread_created_event_data(cc_thread, followed=actions_form.cleaned_data["following"])
)
return api_thread
def create_thread(request, course_id, commentable_id):
"""
Given a course and commentable ID, create the thread
"""
log.debug("Creating new thread in %r, id %r", course_id, commentable_id)
course_key = CourseKey.from_string(course_id)
course = get_course_with_access(request.user, 'load', course_key)
post = request.POST
user = request.user
if course.allow_anonymous:
anonymous = post.get('anonymous', 'false').lower() == 'true'
else:
anonymous = False
if course.allow_anonymous_to_peers:
anonymous_to_peers = post.get('anonymous_to_peers', 'false').lower() == 'true'
else:
anonymous_to_peers = False
if 'title' not in post or not post['title'].strip():
return JsonError(_("Title can't be empty"))
if 'body' not in post or not post['body'].strip():
return JsonError(_("Body can't be empty"))
params = {
'anonymous': anonymous,
'anonymous_to_peers': anonymous_to_peers,
'commentable_id': commentable_id,
'course_id': text_type(course_key),
'user_id': user.id,
'thread_type': post["thread_type"],
'body': post["body"],
'title': post["title"],
}
# Check for whether this commentable belongs to a team, and add the right context
if get_team(commentable_id) is not None:
params['context'] = ThreadContext.STANDALONE
else:
params['context'] = ThreadContext.COURSE
thread = cc.Thread(**params)
# Divide the thread if required
try:
group_id = get_group_id_for_comments_service(request, course_key, commentable_id)
except ValueError:
return HttpResponseServerError("Invalid group id for commentable")
if group_id is not None:
thread.group_id = group_id
thread.save()
thread_created.send(sender=None, user=user, post=thread)
# patch for backward compatibility to comments service
if 'pinned' not in thread.attributes:
thread['pinned'] = False
follow = post.get('auto_subscribe', 'false').lower() == 'true'
if follow:
cc_user = cc.User.from_django_user(user)
cc_user.follow(thread)
thread_followed.send(sender=None, user=user, post=thread)
data = thread.to_dict()
add_courseware_context([data], course, user)
track_thread_created_event(request, course, thread, follow)
if request.is_ajax():
return ajax_content_response(request, course_key, data)
else:
return JsonResponse(prepare_content(data, course_key))
def create_thread(request, course_id, commentable_id):
"""
Given a course and commentble ID, create the thread
"""
log.debug("Creating new thread in %r, id %r", course_id, commentable_id)
course_key = SlashSeparatedCourseKey.from_deprecated_string(course_id)
course = get_course_with_access(request.user, 'load', course_key)
post = request.POST
user = request.user
if course.allow_anonymous:
anonymous = post.get('anonymous', 'false').lower() == 'true'
else:
anonymous = False
if course.allow_anonymous_to_peers:
anonymous_to_peers = post.get('anonymous_to_peers',
'false').lower() == 'true'
else:
anonymous_to_peers = False
if 'title' not in post or not post['title'].strip():
return JsonError(_("Title can't be empty"))
if 'body' not in post or not post['body'].strip():
return JsonError(_("Body can't be empty"))
params = {
'anonymous': anonymous,
'anonymous_to_peers': anonymous_to_peers,
'commentable_id': commentable_id,
'course_id': course_key.to_deprecated_string(),
'user_id': user.id,
'thread_type': post["thread_type"],
'body': post["body"],
'title': post["title"],
}
# Check for whether this commentable belongs to a team, and add the right context
if get_team(commentable_id) is not None:
params['context'] = ThreadContext.STANDALONE
else:
params['context'] = ThreadContext.COURSE
thread = cc.Thread(**params)
# Cohort the thread if required
try:
group_id = get_group_id_for_comments_service(request, course_key,
commentable_id)
except ValueError:
return HttpResponseBadRequest("Invalid cohort id")
if group_id is not None:
thread.group_id = group_id
thread.save()
thread_created.send(sender=None, user=user, post=thread)
# patch for backward compatibility to comments service
if 'pinned' not in thread.attributes:
thread['pinned'] = False
follow = post.get('auto_subscribe', 'false').lower() == 'true'
if follow:
cc_user = cc.User.from_django_user(user)
cc_user.follow(thread)
event_data = get_thread_created_event_data(thread, follow)
data = thread.to_dict()
add_courseware_context([data], course, user)
track_forum_event(request, THREAD_CREATED_EVENT_NAME, course, thread,
event_data)
if request.is_ajax():
return ajax_content_response(request, course_key, data)
else:
return JsonResponse(prepare_content(data, course_key))
def create_thread(request, course_id, commentable_id):
"""
Given a course and commentble ID, create the thread
"""
log.debug("Creating new thread in %r, id %r", course_id, commentable_id)
course_key = CourseKey.from_string(course_id)
course = get_course_with_access(request.user, 'load', course_key)
post = request.POST
user = request.user
if course.allow_anonymous:
anonymous = post.get('anonymous', 'false').lower() == 'true'
else:
anonymous = False
if course.allow_anonymous_to_peers:
anonymous_to_peers = post.get('anonymous_to_peers',
'false').lower() == 'true'
else:
anonymous_to_peers = False
if 'title' not in post or not post['title'].strip():
return JsonError(_("Title can't be empty"))
if 'body' not in post or not post['body'].strip():
return JsonError(_("Body can't be empty"))
params = {
'anonymous': anonymous,
'anonymous_to_peers': anonymous_to_peers,
'commentable_id': commentable_id,
'course_id': course_key.to_deprecated_string(),
'user_id': user.id,
'thread_type': post["thread_type"],
'body': post["body"],
'title': post["title"],
}
# Check for whether this commentable belongs to a team, and add the right context
if get_team(commentable_id) is not None:
params['context'] = ThreadContext.STANDALONE
else:
params['context'] = ThreadContext.COURSE
thread = cc.Thread(**params)
# Divide the thread if required
try:
group_id = get_group_id_for_comments_service(request, course_key,
commentable_id)
except ValueError:
return HttpResponseServerError("Invalid group id for commentable")
if group_id is not None:
thread.group_id = group_id
thread.save()
thread_created.send(sender=None, user=user, post=thread)
# patch for backward compatibility to comments service
if 'pinned' not in thread.attributes:
thread['pinned'] = False
follow = post.get('auto_subscribe', 'false').lower() == 'true'
if follow:
cc_user = cc.User.from_django_user(user)
cc_user.follow(thread)
thread_followed.send(sender=None, user=user, post=thread)
data = thread.to_dict()
add_courseware_context([data], course, user)
track_thread_created_event(request, course, thread, follow)
if thread.get('group_id'):
# Send a notification message, if enabled, when anyone posts a new thread on
# a cohorted/private discussion, except the poster him/herself
_send_discussion_notification(
'open-edx.lms.discussions.cohorted-thread-added',
unicode(course_key),
thread,
request.user,
excerpt=_get_excerpt(thread.body),
recipient_group_id=thread.get('group_id'),
recipient_exclude_user_ids=[request.user.id],
is_anonymous_user=anonymous or anonymous_to_peers)
add_thread_group_name(data, course_key)
if thread.get('group_id') and not thread.get('group_name'):
thread['group_name'] = get_cohort_by_id(course_key,
thread.get('group_id')).name
data = thread.to_dict()
if request.is_ajax():
return ajax_content_response(request, course_key, data)
else:
return JsonResponse(prepare_content(data, course_key))
def create_thread(request, course_id, commentable_id):
"""
Given a course and commentble ID, create the thread
"""
log.debug("Creating new thread in %r, id %r", course_id, commentable_id)
course_key = CourseKey.from_string(course_id)
course = get_course_with_access(request.user, 'load', course_key)
post = request.POST
user = request.user
if course.allow_anonymous:
anonymous = post.get('anonymous', 'false').lower() == 'true'
else:
anonymous = False
if course.allow_anonymous_to_peers:
anonymous_to_peers = post.get('anonymous_to_peers', 'false').lower() == 'true'
else:
anonymous_to_peers = False
if 'title' not in post or not post['title'].strip():
return JsonError(_("Title can't be empty"))
if 'body' not in post or not post['body'].strip():
return JsonError(_("Body can't be empty"))
params = {
'anonymous': anonymous,
'anonymous_to_peers': anonymous_to_peers,
'commentable_id': commentable_id,
'course_id': course_key.to_deprecated_string(),
'user_id': user.id,
'thread_type': post["thread_type"],
'body': post["body"],
'title': post["title"],
}
# Check for whether this commentable belongs to a team, and add the right context
if get_team(commentable_id) is not None:
params['context'] = ThreadContext.STANDALONE
else:
params['context'] = ThreadContext.COURSE
thread = cc.Thread(**params)
# Divide the thread if required
try:
group_id = get_group_id_for_comments_service(request, course_key, commentable_id)
except ValueError:
return HttpResponseServerError("Invalid group id for commentable")
if group_id is not None:
thread.group_id = group_id
thread.save()
thread_created.send(sender=None, user=user, post=thread)
# patch for backward compatibility to comments service
if 'pinned' not in thread.attributes:
thread['pinned'] = False
follow = post.get('auto_subscribe', 'false').lower() == 'true'
if follow:
cc_user = cc.User.from_django_user(user)
cc_user.follow(thread)
thread_followed.send(sender=None, user=user, post=thread)
data = thread.to_dict()
add_courseware_context([data], course, user)
track_thread_created_event(request, course, thread, follow)
if thread.get('group_id'):
# Send a notification message, if enabled, when anyone posts a new thread on
# a cohorted/private discussion, except the poster him/herself
_send_discussion_notification(
'open-edx.lms.discussions.cohorted-thread-added',
unicode(course_key),
thread,
request.user,
excerpt=_get_excerpt(thread.body),
recipient_group_id=thread.get('group_id'),
recipient_exclude_user_ids=[request.user.id],
is_anonymous_user=anonymous or anonymous_to_peers
)
add_thread_group_name(data, course_key)
if thread.get('group_id') and not thread.get('group_name'):
thread['group_name'] = get_cohort_by_id(course_key, thread.get('group_id')).name
data = thread.to_dict()
if request.is_ajax():
return ajax_content_response(request, course_key, data)
else:
return JsonResponse(prepare_content(data, course_key))
def create_thread(request, course_id, commentable_id):
"""
Given a course and commentble ID, create the thread
"""
log.debug("Creating new thread in %r, id %r", course_id, commentable_id)
course_key = SlashSeparatedCourseKey.from_deprecated_string(course_id)
course = get_course_with_access(request.user, "load", course_key)
post = request.POST
user = request.user
if course.allow_anonymous:
anonymous = post.get("anonymous", "false").lower() == "true"
else:
anonymous = False
if course.allow_anonymous_to_peers:
anonymous_to_peers = post.get("anonymous_to_peers", "false").lower() == "true"
else:
anonymous_to_peers = False
if "title" not in post or not post["title"].strip():
return JsonError(_("Title can't be empty"))
if "body" not in post or not post["body"].strip():
return JsonError(_("Body can't be empty"))
params = {
"anonymous": anonymous,
"anonymous_to_peers": anonymous_to_peers,
"commentable_id": commentable_id,
"course_id": course_key.to_deprecated_string(),
"user_id": user.id,
"thread_type": post["thread_type"],
"body": post["body"],
"title": post["title"],
}
# Check for whether this commentable belongs to a team, and add the right context
if get_team(commentable_id) is not None:
params["context"] = ThreadContext.STANDALONE
else:
params["context"] = ThreadContext.COURSE
thread = cc.Thread(**params)
# Cohort the thread if required
try:
group_id = get_group_id_for_comments_service(request, course_key, commentable_id)
except ValueError:
return HttpResponseBadRequest("Invalid cohort id")
if group_id is not None:
thread.group_id = group_id
thread.save()
thread_created.send(sender=None, user=user, post=thread)
# patch for backward compatibility to comments service
if "pinned" not in thread.attributes:
thread["pinned"] = False
follow = post.get("auto_subscribe", "false").lower() == "true"
if follow:
cc_user = cc.User.from_django_user(user)
cc_user.follow(thread)
data = thread.to_dict()
add_courseware_context([data], course, user)
track_thread_created_event(request, course, thread, follow)
if request.is_ajax():
return ajax_content_response(request, course_key, data)
else:
return JsonResponse(prepare_content(data, course_key))
