def test_publish_options(self):
# faculty
self.request.user = self.instructor_one
frm = ProjectForm(self.request, instance=None, data={})
lst = frm.fields['publish'].choices
self.assertEquals(len(lst), 2)
self.assertEquals(lst[0][0], PUBLISH_DRAFT[0])
self.assertEquals(lst[1][0], PUBLISH_WHOLE_CLASS[0])
# student
self.request.user = self.student_one
frm = ProjectForm(self.request, instance=None, data={})
lst = frm.fields['publish'].choices
self.assertEquals(len(lst), 3)
self.assertEquals(lst[0][0], PUBLISH_DRAFT[0])
self.assertEquals(lst[1][0], 'InstructorShared')
self.assertEquals(lst[2][0], PUBLISH_WHOLE_CLASS[0])
# maybe public option
self.sample_course.add_detail(ALLOW_PUBLIC_COMPOSITIONS_KEY, 1)
frm = ProjectForm(self.request, instance=None, data={})
lst = frm.fields['publish'].choices
self.assertEquals(len(lst), 3)
self.assertEquals(lst[0][0], PUBLISH_DRAFT[0])
self.assertEquals(lst[1][0], 'InstructorShared')
self.assertEquals(lst[2][0], PUBLISH_WHOLE_CLASS[0])
def get(self, *args, **kwargs):
try:
project = Project.objects.get(id=kwargs.get('project_id', None))
if (not project.can_edit(self.request.course, self.request.user)):
return HttpResponseForbidden("forbidden")
form = ProjectForm(self.request, instance=project)
except Project.DoesNotExist:
form = ProjectForm(self.request, instance=None)
return self.render_to_response({'form': form})
def project_save(request, project_id):
project = get_object_or_404(Project, pk=project_id, course=request.course)
if not project.can_edit(request.course, request.user):
return HttpResponseRedirect(project.get_absolute_url())
# verify user is in course
in_course_or_404(project.author.username, request.course)
projectform = ProjectForm(request, instance=project, data=request.POST)
if projectform.is_valid():
# legacy and for optimizing queries
projectform.instance.submitted = \
request.POST.get('publish', None) != 'PrivateEditorsAreOwners'
# this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.participants.add(request.user)
# update the collaboration
policy_name = request.POST.get('publish', 'PrivateEditorsAreOwners')
projectform.instance.create_or_update_collaboration(policy_name)
v_num = projectform.instance.get_latest_version()
is_assignment = projectform.instance.is_assignment(request.course,
request.user)
return HttpResponse(json.dumps({
'status': 'success',
'is_assignment': is_assignment,
'title': projectform.instance.title,
'revision': {
'id': v_num,
'public_url': projectform.instance.public_url(),
'visibility': project.visibility_short(),
'due_date': project.get_due_date()
}
}, indent=2), content_type='application/json')
else:
ctx = {'status': 'error', 'msg': ""}
for key, value in projectform.errors.items():
if key == '__all__':
ctx['msg'] = ctx['msg'] + value[0] + "\n"
else:
ctx['msg'] = \
'%s "%s" is not valid for the %s field.\n %s\n' % \
(ctx['msg'], projectform.data[key],
projectform.fields[key].label,
value[0].lower())
return HttpResponse(json.dumps(ctx, indent=2),
content_type='application/json')
def post(self, request, *args, **kwargs):
frm = ProjectForm(request, instance=self.project, data=request.POST)
if frm.is_valid():
policy = request.POST.get('publish', PUBLISH_DRAFT[0])
if policy == PUBLISH_DRAFT[0]:
frm.instance.date_submitted = None
else:
frm.instance.date_submitted = datetime.now()
frm.instance.author = request.user
project = frm.save()
project.participants.add(request.user)
item_id = request.POST.get('item', None)
project.create_or_update_item(item_id)
# update the collaboration
collaboration = project.create_or_update_collaboration(policy)
DiscussionIndex.update_class_references(project.body, None, None,
collaboration,
project.author)
parent_id = request.POST.get('parent', None)
project.set_parent(parent_id)
ctx = {
'status': 'success',
'is_essay_assignment': project.is_essay_assignment(),
'title': project.title,
'context': {
'project': {
'url': project.get_absolute_url()
}
},
'revision': {
'id': project.latest_version(),
'public_url': project.public_url(),
'visibility': project.visibility_short(),
'due_date': project.get_due_date()
}
}
else:
ctx = {'status': 'error', 'msg': ""}
for key, value in frm.errors.items():
if key == '__all__':
ctx['msg'] = ctx['msg'] + value[0] + "\n"
else:
ctx['msg'] = \
'%s "%s" is not valid for the %s field.\n %s\n' % \
(ctx['msg'], frm.data[key],
frm.fields[key].label,
value[0].lower())
return self.render_to_json_response(ctx)
def post(self, request, *args, **kwargs):
frm = ProjectForm(request, instance=self.project, data=request.POST)
if frm.is_valid():
policy = request.POST.get('publish', PUBLISH_DRAFT[0])
if policy == PUBLISH_DRAFT[0]:
frm.instance.date_submitted = None
else:
frm.instance.date_submitted = datetime.now()
frm.instance.author = request.user
project = frm.save()
project.participants.add(request.user)
item_id = request.POST.get('item', None)
project.create_or_update_item(item_id)
# update the collaboration
collaboration = project.create_or_update_collaboration(policy)
DiscussionIndex.update_class_references(
project.body, None, None, collaboration, project.author)
parent_id = request.POST.get('parent', None)
project.set_parent(parent_id)
ctx = {
'status': 'success',
'is_assignment': project.is_assignment(),
'title': project.title,
'context': {
'project': {
'url': project.get_absolute_url()
}
},
'revision': {
'id': project.latest_version(),
'public_url': project.public_url(),
'visibility': project.visibility_short(),
'due_date': project.get_due_date()
}
}
else:
ctx = {'status': 'error', 'msg': ""}
for key, value in frm.errors.items():
if key == '__all__':
ctx['msg'] = ctx['msg'] + value[0] + "\n"
else:
ctx['msg'] = \
'%s "%s" is not valid for the %s field.\n %s\n' % \
(ctx['msg'], frm.data[key],
frm.fields[key].label,
value[0].lower())
return self.render_to_json_response(ctx)
def project_save(request, project_id):
project = get_object_or_404(Project, pk=project_id, course=request.course)
if not project.can_edit(request):
return HttpResponseRedirect(project.get_absolute_url())
# verify user is in course
in_course_or_404(project.author.username, request.course)
projectform = ProjectForm(request, instance=project, data=request.POST)
if projectform.is_valid():
# legacy and for optimizing queries
projectform.instance.submitted = request.POST.get("publish", None) != "PrivateEditorsAreOwners"
# this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.collaboration(request, sync_group=True)
v_num = projectform.instance.get_latest_version()
return HttpResponse(
simplejson.dumps(
{
"status": "success",
"is_assignment": projectform.instance.is_assignment(request),
"title": projectform.instance.title,
"revision": {
"id": v_num,
"public_url": projectform.instance.public_url(),
"visibility": project.visibility_short(),
"due_date": project.get_due_date(),
},
},
indent=2,
),
mimetype="application/json",
)
else:
ctx = {"status": "error", "msg": ""}
for key, value in projectform.errors.items():
if key == "__all__":
ctx["msg"] = ctx["msg"] + value[0] + "\n"
else:
ctx["msg"] = '%s "%s" is not valid for the %s field.\n %s\n' % (
ctx["msg"],
projectform.data[key],
projectform.fields[key].label,
value[0].lower(),
)
return HttpResponse(simplejson.dumps(ctx, indent=2), mimetype="application/json")
def get_context_data(self, **kwargs):
try:
project = Project.objects.get(id=kwargs.get('project_id', None))
if (not project.can_edit(self.request.course, self.request.user)):
return HttpResponseForbidden("forbidden")
form = ProjectForm(self.request, instance=project)
except Project.DoesNotExist:
form = ProjectForm(self.request, instance=None)
ctx = {'form': form}
ctx.update(self.get_extra_context())
return ctx
def test_response_policy_options(self):
frm = ProjectForm(self.request, instance=None, data={})
lst = frm.fields['response_view_policy'].choices
self.assertEquals(len(lst), 3)
self.assertEquals(lst[0], RESPONSE_VIEW_NEVER)
self.assertEquals(lst[1], RESPONSE_VIEW_SUBMITTED)
self.assertEquals(lst[2], RESPONSE_VIEW_ALWAYS)
self.sample_course.add_detail(SELECTION_VISIBILITY_KEY, 0)
frm = ProjectForm(self.request, instance=None, data={})
lst = frm.fields['response_view_policy'].choices
self.assertEquals(len(lst), 1)
self.assertEquals(lst[0], RESPONSE_VIEW_NEVER)
def project_save(request, project_id):
project = get_object_or_404(Project, pk=project_id, course=request.course)
if not project.can_edit(request):
return HttpResponseRedirect(project.get_absolute_url())
# verify user is in course
in_course_or_404(project.author.username, request.course)
projectform = ProjectForm(request, instance=project, data=request.POST)
if projectform.is_valid():
# legacy and for optimizing queries
projectform.instance.submitted = \
request.POST.get('publish', None) != 'PrivateEditorsAreOwners'
# this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.collaboration(request, sync_group=True)
v_num = projectform.instance.get_latest_version()
return HttpResponse(json.dumps(
{
'status': 'success',
'is_assignment': projectform.instance.is_assignment(request),
'title': projectform.instance.title,
'revision': {
'id': v_num,
'public_url': projectform.instance.public_url(),
'visibility': project.visibility_short(),
'due_date': project.get_due_date()
}
},
indent=2),
mimetype='application/json')
else:
ctx = {'status': 'error', 'msg': ""}
for key, value in projectform.errors.items():
if key == '__all__':
ctx['msg'] = ctx['msg'] + value[0] + "\n"
else:
ctx['msg'] = \
'%s "%s" is not valid for the %s field.\n %s\n' % \
(ctx['msg'], projectform.data[key],
projectform.fields[key].label,
value[0].lower())
return HttpResponse(json.dumps(ctx, indent=2),
mimetype='application/json')
def test_bound_assignment_response_policy_options(self):
self.sample_course.add_detail(SELECTION_VISIBILITY_KEY, 0)
selection_assignment = ProjectFactory.create(
course=self.sample_course,
author=self.student_one,
policy=PUBLISH_WHOLE_CLASS[0],
project_type=PROJECT_TYPE_ASSIGNMENT)
frm = ProjectForm(self.request, instance=selection_assignment, data={})
lst = frm.fields['response_view_policy'].choices
self.assertEquals(len(lst), 1)
self.assertEquals(lst[0], RESPONSE_VIEW_NEVER)
assignment = ProjectFactory.create(
course=self.sample_course,
author=self.instructor_one,
policy=PUBLISH_WHOLE_CLASS[0],
project_type=PROJECT_TYPE_SELECTION_ASSIGNMENT)
frm = ProjectForm(self.request, instance=assignment, data={})
lst = frm.fields['response_view_policy'].choices
self.assertEquals(len(lst), 1)
self.assertEquals(lst[0], RESPONSE_VIEW_NEVER)
def test_project_form(self):
frm = ProjectForm(self.request, instance=None, data={})
lst = frm.fields['participants'].choices
self.assertEquals(lst[0][1], 'Instructor One')
self.assertEquals(lst[1][1], 'Instructor Two')
self.assertEquals(lst[2][1], 'Student One')
self.assertEquals(lst[3][1], 'Student Three')
self.assertEquals(lst[4][1], 'Student Two')
self.assertFalse(frm.fields['participants'].required)
self.assertFalse(frm.fields['body'].required)
self.assertFalse(frm.fields['submit'].required)
self.assertFalse(frm.fields['publish'].required)
self.assertFalse(frm.fields['response_view_policy'].required)
def test_bound_assignment_form(self):
self.sample_course.add_detail(ALLOW_PUBLIC_COMPOSITIONS_KEY, 1)
assignment = ProjectFactory.create(
course=self.sample_course,
author=self.student_one,
policy=PUBLISH_DRAFT[0],
project_type=PROJECT_TYPE_ASSIGNMENT)
data = {}
frm = ProjectForm(self.request, instance=assignment, data=data)
self.assertEquals(frm.initial['publish'], PUBLISH_DRAFT[0])
lst = frm.fields['publish'].choices
self.assertEquals(len(lst), 2)
self.assertEquals(lst[0][0], PUBLISH_DRAFT[0])
self.assertEquals(lst[1][0], PUBLISH_WHOLE_CLASS[0])
def test_bound_composition_form(self):
self.sample_course.add_detail(ALLOW_PUBLIC_COMPOSITIONS_KEY, 1)
project = ProjectFactory.create(course=self.sample_course,
author=self.student_one,
policy=PUBLISH_DRAFT[0],
response_view_policy='always')
data = {}
frm = ProjectForm(self.request, instance=project, data=data)
self.assertEquals(frm.initial['publish'], PUBLISH_DRAFT[0])
lst = frm.fields['publish'].choices
self.assertEquals(len(lst), 3)
self.assertEquals(lst[0][0], PUBLISH_DRAFT[0])
self.assertEquals(lst[1][0], PUBLISH_WHOLE_CLASS[0])
self.assertEquals(lst[2][0], 'PublicEditorsAreOwners')
def render_one(self, request, project, version_number=None):
self.request = request
bundle = self.build_bundle(obj=project, request=request)
dehydrated = self.full_dehydrate(bundle)
project_ctx = self._meta.serializer.to_simple(dehydrated, None)
project_ctx['body'] = project.body
project_ctx['public_url'] = project.public_url()
project_ctx['modified'] = project.modified.strftime(self.date_fmt)
project_ctx['current_version'] = version_number
project_ctx['visibility'] = project.visibility_short()
project_ctx['type'] = project.project_type
assets, notes = self.related_assets_notes(request, project)
data = {
'project': project_ctx,
'type': 'project',
'can_edit': self.editable,
'annotations': notes,
'assets': assets
}
data['responses'] = self.all_responses(request, project)
data['response_count'] = len(data['responses'])
my_responses = self.my_responses(request, project)
if len(my_responses) == 1:
data['my_response'] = my_responses[0]
elif len(my_responses) > 1:
data['my_responses'] = my_responses
data['my_responses_count'] = len(my_responses)
if self.editable:
projectform = ProjectForm(request, instance=project)
data['form'] = {
'participants':
smart_text(projectform['participants']),
'publish':
smart_text(projectform['publish']),
'response_view_policy':
smart_text(projectform['response_view_policy']),
}
return data
def render_one(self, request, project, version_number=None):
bundle = self.build_bundle(obj=project, request=request)
dehydrated = self.full_dehydrate(bundle)
project_ctx = self._meta.serializer.to_simple(dehydrated, None)
project_ctx['body'] = project.body
project_ctx['public_url'] = project.public_url()
project_ctx['current_version'] = version_number
project_ctx['visibility'] = project.visibility_short()
project_ctx['type'] = ('assignment' if project.is_assignment(request)
else 'composition')
rand = ''.join([choice(letters) for i in range(5)])
asset_resource = AssetResource()
sherd_resource = SherdNoteResource()
assets = {}
notes = []
for note in project.citations():
notes.append(sherd_resource.render_one(request, note, rand))
if (note.title not in ["Annotation Deleted", 'Asset Deleted']):
key = '%s_%s' % (rand, note.asset.pk)
if key not in assets.keys():
assets[key] = \
asset_resource.render_one(request, note.asset)
data = {
'project': project_ctx,
'type': 'project',
'can_edit': self.editable,
'annotations': notes,
'assets': assets
}
data['responses'] = []
for response in project.responses(request):
if response.can_read(request):
obj = {
'url': response.get_absolute_url(),
'title': response.title,
'modified': response.modified.strftime(self.date_fmt),
'attribution_list': []
}
last = len(response.attribution_list()) - 1
for idx, author in enumerate(response.attribution_list()):
obj['attribution_list'].append({
'name':
get_public_name(author, request),
'last':
idx == last
})
data['responses'].append(obj)
data['response_count'] = len(data['responses'])
my_responses = []
for response in project.responses_by(request, request.user):
obj = {
'url': response.get_absolute_url(),
'title': response.title,
'modified': response.modified.strftime(self.date_fmt),
'attribution_list': []
}
last = len(response.attribution_list()) - 1
for idx, author in enumerate(response.attribution_list()):
obj['attribution_list'].append({
'name':
get_public_name(author, request),
'last':
idx == last
})
my_responses.append(obj)
if len(my_responses) == 1:
data['my_response'] = my_responses[0]
elif len(my_responses) > 1:
data['my_responses'] = my_responses
data['my_responses_count'] = len(my_responses)
if project.is_participant(request.user):
data['revisions'] = [{
'version_number':
v.version_number,
'versioned_id':
v.versioned_id,
'author':
get_public_name(v.instance().author, request),
'modified':
v.modified.strftime("%m/%d/%y %I:%M %p")
} for v in project.versions.order_by('-change_time')]
if self.editable:
projectform = ProjectForm(request, instance=project)
data['form'] = {
'participants': projectform['participants'].__unicode__(),
'publish': projectform['publish'].__unicode__()
}
return data
def composition_project_json(request, project, can_edit, version_number=None):
'''
JSON representation for a project. Includes:
* basic project information
* assets
* annotations
* responses (if applicable & permissable)
* revisions (if permissable)
* a project participant form (if permissable)
'''
rand = ''.join([choice(letters) for i in range(5)])
participants = project.attribution_list()
is_assignment = project.is_assignment(request)
course = request.course if request.course \
else request.collaboration_context.content_object
asset_resource = AssetSummaryResource()
sherd_resource = SherdNoteResource()
citations = project.citations()
data = {
'project': {
'id':
project.pk,
'title':
project.title,
'url':
project.get_absolute_url(),
'due_date':
project.get_due_date(),
'body':
project.body,
'participants': [{
'name': p.get_full_name(),
'username': p.username,
'public_name': get_public_name(p, request),
'is_viewer': request.user.username == p.username,
'last': idx == (len(participants) - 1)
} for idx, p in enumerate(participants)],
'public_url':
project.public_url(),
'visibility':
project.visibility_short(),
'username':
request.user.username,
'type':
'assignment' if is_assignment else 'composition',
'description':
project.description(),
'current_version':
version_number if version_number else None,
'create_selection':
is_assignment,
'is_assignment':
is_assignment,
'course_title':
course.title
},
'type':
'project',
'can_edit':
can_edit,
'annotations':
[sherd_resource.render_one(request, ann, rand) for ann in citations],
}
assets = {}
for ann in citations:
if ann.title != "Annotation Deleted" and ann.title != 'Asset Deleted':
key = '%s_%s' % (rand, ann.asset.pk)
if key not in assets:
assets[key] = asset_resource.render_one(request, ann.asset)
data['assets'] = assets
data['responses'] = []
for response in project.responses(request):
if response.can_read(request):
obj = {
'url': response.get_absolute_url(),
'title': response.title,
'modified': response.modified.strftime("%m/%d/%y %I:%M %p"),
'attribution_list': []
}
last = len(response.attribution_list()) - 1
for idx, author in enumerate(response.attribution_list()):
obj['attribution_list'].append({
'name':
get_public_name(author, request),
'last':
idx == last
})
data['responses'].append(obj)
data['response_count'] = len(data['responses'])
my_responses = []
for response in project.responses_by(request, request.user):
obj = {
'url': response.get_absolute_url(),
'title': response.title,
'modified': response.modified.strftime("%m/%d/%y %I:%M %p"),
'attribution_list': []
}
last = len(response.attribution_list()) - 1
for idx, author in enumerate(response.attribution_list()):
obj['attribution_list'].append({
'name':
get_public_name(author, request),
'last':
idx == last
})
my_responses.append(obj)
if len(my_responses) == 1:
data['my_response'] = my_responses[0]
elif len(my_responses) > 1:
data['my_responses'] = my_responses
data['my_responses_count'] = len(my_responses)
if project.is_participant(request.user):
data['revisions'] = [{
'version_number':
v.version_number,
'versioned_id':
v.versioned_id,
'author':
get_public_name(v.instance().author, request),
'modified':
v.modified.strftime("%m/%d/%y %I:%M %p")
} for v in project.versions.order_by('-change_time')]
if can_edit:
projectform = ProjectForm(request, instance=project)
data['form'] = {
'participants': projectform['participants'].__unicode__(),
'publish': projectform['publish'].__unicode__()
}
return data
