def post(self, request):
project = Project.objects.create(author=request.user,
course=request.course,
title="Untitled")
project.collaboration(request, sync_group=True)
parent = request.POST.get("parent")
if parent is not None:
try:
parent = Project.objects.get(pk=parent)
parent_collab = parent.collaboration(request)
if parent_collab.permission_to("add_child", request):
parent_collab.append_child(project)
except Project.DoesNotExist:
parent = None
# @todo -- an error has occurred
if not request.is_ajax():
return HttpResponseRedirect(project.get_absolute_url())
else:
is_faculty = request.course.is_faculty(request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=project.can_edit(request))
project_context = resource.render_one(request, project)
project_context['editing'] = True
data = {'panel_state': 'open',
'template': 'project',
'context': project_context}
return self.render_to_json_response(data)
def get(self, *args, **kwargs):
"""
A single panel read-only view of the specified project/version combo.
No assignment, response or feedback access/links.
Regular access conventions apply. For example, if the project is
"private" an HTTPResponseForbidden will be returned.
Used for reviewing old project versions and public project access.
Keyword arguments:
project_id -- the model id
version_number -- a specific project version or
None for the current version
"""
attach_course_to_request(self.request, **kwargs)
data = {'space_owner': self.request.user.username}
version_number = self.kwargs.get('version_number', None)
if not self.request.is_ajax():
if version_number:
# versioned view
ctx = {
'course_pk': self.project.course.pk,
'project_id': self.project.id,
'version_number': version_number
}
project_url = reverse('project-view-readonly', kwargs=ctx)
else:
project_url = self.project.public_url()
data['project'] = self.project
data['version'] = version_number
data['public_url'] = project_url
data['readonly'] = True
return self.render_to_response(data)
# ajax view
resource = ProjectResource(record_viewer=self.request.user,
is_viewer_faculty=False,
editable=False)
if version_number:
version = get_object_or_404(Version,
object_id=str(self.project.id),
revision_id=version_number)
project_context = resource.render_one(
self.request, version._object_version.object, version_number)
else:
project_context = resource.render_one(self.request, self.project)
data['panels'] = [{
'context': project_context,
'template': 'project_readonly'
}]
return self.render_to_json_response(data)
def post(self, request):
project_type = request.POST.get('project_type', 'composition')
body = request.POST.get('body', '')
response_policy = request.POST.get('response_view_policy', 'always')
due_date = self.format_date(self.request.POST.get('due_date', None))
instructions1 = self.request.POST.get('custom_instructions_1', None)
instructions2 = self.request.POST.get('custom_instructions_2', None)
summary = self.request.POST.get('summary', None)
project = Project.objects.create(author=request.user,
course=request.course,
title=self.get_title(),
project_type=project_type,
response_view_policy=response_policy,
body=body,
due_date=due_date,
custom_instructions_1=instructions1,
custom_instructions_2=instructions2,
summary=summary)
project.participants.add(request.user)
item_id = request.POST.get('item', None)
project.create_or_update_item(item_id)
policy = request.POST.get('publish', PUBLISH_DRAFT[0])
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)
if project_type == PROJECT_TYPE_SEQUENCE_ASSIGNMENT:
messages.add_message(request, messages.SUCCESS,
self.get_confirmation_message(policy))
if not request.is_ajax():
return HttpResponseRedirect(project.get_absolute_url())
else:
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request.course, request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
project_context['editing'] = True
data = {
'panel_state': 'open',
'template': 'project',
'context': project_context
}
return self.render_to_json_response(data)
def get(self, request, project_id):
project = get_object_or_404(Project, id=project_id)
can_edit = project.can_edit(request.course, request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=self.is_viewer_faculty,
editable=can_edit)
context = resource.render_one(request, project)
return self.render_to_json_response(context)
def get(self, request, project_id):
project = get_object_or_404(Project, id=project_id)
if not project.visible(request):
return HttpResponseForbidden("forbidden")
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=self.is_viewer_faculty,
editable=project.can_edit(request))
context = resource.render_one(request, project)
return self.render_to_json_response(context)
def get(self, request, project_id):
project = get_object_or_404(Project, id=project_id)
if not project.visible(request):
return HttpResponseForbidden("forbidden")
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=self.is_viewer_faculty,
editable=project.can_edit(request))
context = resource.render_one(request, project)
return self.render_to_json_response(context)
def get(self, request, project_id):
project = get_object_or_404(Project, id=project_id)
can_edit = project.can_edit(request.course, request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=self.is_viewer_faculty,
editable=can_edit)
context = resource.render_one(request, project)
return self.render_to_json_response(context)
def post(self, request):
project_type = request.POST.get('project_type', 'composition')
body = request.POST.get('body', '')
response_policy = request.POST.get('response_view_policy', 'always')
due_date = self.format_date(self.request.POST.get('due_date', None))
instructions1 = self.request.POST.get('custom_instructions_1', None)
instructions2 = self.request.POST.get('custom_instructions_2', None)
summary = self.request.POST.get('summary', None)
project = Project.objects.create(
author=request.user, course=request.course, title=self.get_title(),
project_type=project_type, response_view_policy=response_policy,
body=body, due_date=due_date, custom_instructions_1=instructions1,
custom_instructions_2=instructions2, summary=summary)
project.participants.add(request.user)
item_id = request.POST.get('item', None)
project.create_or_update_item(item_id)
policy = request.POST.get('publish', PUBLISH_DRAFT[0])
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)
if project_type == PROJECT_TYPE_SEQUENCE_ASSIGNMENT:
messages.add_message(request, messages.SUCCESS,
self.get_confirmation_message(policy))
if not request.is_ajax():
return HttpResponseRedirect(project.get_absolute_url())
else:
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request.course, request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
project_context['editing'] = True
data = {'panel_state': 'open',
'template': 'project',
'context': project_context}
return self.render_to_json_response(data)
def get(self, request):
ures = UserResource()
course_rez = CourseResource()
pres = ProjectResource(editable=self.viewing_own_records,
record_viewer=self.record_viewer,
is_viewer_faculty=self.is_viewer_faculty)
assignments = []
ctx = {
'space_viewer': ures.render_one(request, self.record_viewer),
'editable': self.viewing_own_records,
'course': course_rez.render_one(request, request.course),
'is_faculty': self.is_viewer_faculty
}
if (self.record_owner):
in_course_or_404(self.record_owner.username, request.course)
projects = Project.objects.visible_by_course_and_user(
request, request.course, self.record_owner)
# Show unresponded assignments if viewing self & self is a student
if not self.is_viewer_faculty and self.viewing_own_records:
assignments = Project.objects.unresponded_assignments(
request, self.record_viewer)
ctx['space_owner'] = ures.render_one(request, self.record_owner)
ctx['assignments'] = pres.render_assignments(request, assignments)
else:
projects = Project.objects.visible_by_course(request,
request.course)
#offset = int(request.GET.get("offset", 0))
#limit = int(request.GET.get("limit", 20))
ctx['projects'] = pres.render_projects(request, projects)
ctx['compositions'] = len(projects) > 0 or len(assignments) > 0
return self.render_to_json_response(ctx)
def get(self, request):
ures = UserResource()
course_rez = CourseResource()
pres = ProjectResource(editable=self.viewing_own_records,
record_viewer=self.record_viewer,
is_viewer_faculty=self.is_viewer_faculty)
assignments = []
ctx = {
'space_viewer': ures.render_one(request, self.record_viewer),
'editable': self.viewing_own_records,
'course': course_rez.render_one(request, request.course),
'is_faculty': self.is_viewer_faculty
}
if (self.record_owner):
in_course_or_404(self.record_owner.username, request.course)
projects = Project.objects.visible_by_course_and_user(
request, request.course, self.record_owner,
self.viewing_faculty_records)
# Show unresponded assignments if viewing self & self is a student
if not self.is_viewer_faculty and self.viewing_own_records:
assignments = Project.objects.unresponded_assignments(
request, self.record_viewer)
ctx['space_owner'] = ures.render_one(request, self.record_owner)
ctx['assignments'] = pres.render_assignments(request, assignments)
else:
projects = Project.objects.visible_by_course(
request, request.course)
ctx['projects'] = pres.render_projects(request, projects)
ctx['compositions'] = len(projects) > 0 or len(assignments) > 0
return self.render_to_json_response(ctx)
def post(self, request):
project = Project.objects.create(author=request.user,
course=request.course,
title="Untitled")
project.participants.add(request.user)
policy_name = request.POST.get('publish', 'PrivateEditorsAreOwners')
project.create_or_update_collaboration(policy_name)
parent = request.POST.get("parent", None)
if parent is not None:
parent = get_object_or_404(Project, pk=parent)
collab = parent.get_collaboration()
if collab.permission_to("add_child", request.course,
request.user):
collab.append_child(project)
if not request.is_ajax():
return HttpResponseRedirect(project.get_absolute_url())
else:
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request.course, request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
project_context['editing'] = True
data = {'panel_state': 'open',
'template': 'project',
'context': project_context}
return self.render_to_json_response(data)
def post(self, request):
project = Project.objects.create(author=request.user,
course=request.course,
title="Untitled")
project.collaboration(request, sync_group=True)
parent = request.POST.get("parent")
if parent is not None:
try:
parent = Project.objects.get(pk=parent)
parent_collab = parent.collaboration(request)
if parent_collab.permission_to("add_child", request):
parent_collab.append_child(project)
except Project.DoesNotExist:
parent = None
# @todo -- an error has occurred
if not request.is_ajax():
return HttpResponseRedirect(project.get_absolute_url())
else:
is_faculty = request.course.is_faculty(request.user)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=project.can_edit(request))
project_context = resource.render_one(request, project)
project_context['editing'] = True
data = {
'panel_state': 'open',
'template': 'project',
'context': project_context
}
return self.render_to_json_response(data)
def get(self, request, *args, **kwargs):
course = get_object_or_404(Course, id=kwargs.pop('course_id', None))
faculty = [user.id for user in course.faculty.all()]
faculty_ctx = UserResource().render_list(request, course.faculty.all())
# filter assets & notes by the faculty set
assets = Asset.objects.by_course(course)
if settings.SURELINK_URL:
assets = assets.exclude(
source__url__startswith=settings.SURELINK_URL)
assets = assets.filter(sherdnote_set__author__id__in=faculty).exclude(
source__label='flv_pseudo')
notes = SherdNote.objects.get_related_notes(
assets, None, faculty, True).exclude_primary_types(['flv_pseudo'])
ares = AssetResource(include_annotations=False)
asset_ctx = ares.render_list(request, None, None, assets, notes)
projects = Project.objects.by_course_and_users(course, faculty)
# filter private projects
if projects.count() > 0:
collabs = Collaboration.objects.get_for_object_list(projects)
collabs = collabs.exclude(
policy_record__policy_name='PrivateEditorsAreOwners')
ids = collabs.values_list('object_pk', flat=True)
projects = projects.filter(id__in=ids)
info_ctx = CourseInfoResource().render_one(request, course)
ctx = {
'course': {
'id': course.id,
'title': course.title,
'faculty': faculty_ctx,
'info': info_ctx
},
'assets': asset_ctx,
'projects': ProjectResource().render_list(request, projects)
}
return self.render_to_json_response(ctx)
def get(self, request):
ures = UserResource()
course_res = CourseResource()
pres = ProjectResource(editable=self.viewing_own_records,
record_viewer=self.record_viewer,
is_viewer_faculty=self.is_viewer_faculty)
assignments = []
ctx = {
'space_viewer': ures.render_one(request, self.record_viewer),
'editable': self.viewing_own_records,
'course': course_res.render_one(request, request.course),
'is_faculty': self.is_viewer_faculty,
'is_superuser': request.user.is_superuser,
}
if self.record_owner:
ctx['space_owner'] = ures.render_one(request, self.record_owner)
if not request.course.is_true_member(self.record_owner):
return self.render_to_json_response(ctx)
projects = Project.objects.visible_by_course_and_user(
request.course, request.user, self.record_owner,
self.viewing_faculty_records)
# Show unresponded assignments if viewing self & self is a student
if not self.is_viewer_faculty and self.viewing_own_records:
assignments = list(
Project.objects.unresponded_assignments(
request.course, request.user))
else:
projects = Project.objects.visible_by_course(
request.course, request.user)
# update counts and paginate
ctx['compositions'] = len(projects) > 0 or len(assignments) > 0
ctx.update(self.paginate(pres, assignments, projects))
return self.render_to_json_response(ctx)
def get(self, request, *args, **kwargs):
course = get_object_or_404(Course, id=kwargs.pop('course_id', None))
faculty = [user.id for user in course.faculty.all()]
faculty_ctx = UserResource().render_list(request, course.faculty.all())
# filter assets & notes by the faculty set
assets = Asset.objects.by_course(course)
assets = assets.filter(sherdnote_set__author__id__in=faculty)
notes = SherdNote.objects.get_related_notes(assets, None, faculty)
ares = AssetResource(include_annotations=False)
asset_ctx = ares.render_list(request, None, assets, notes)
projects = Project.objects.by_course_and_users(course, faculty)
# filter private projects
collabs = Collaboration.objects.get_for_object_list(projects)
collabs = collabs.exclude(
_policy__policy_name='PrivateEditorsAreOwners')
ids = [int(c.object_pk) for c in collabs]
projects = projects.filter(id__in=ids)
info_ctx = CourseInfoResource().render_one(request, course)
ctx = {
'course': {
'id': course.id,
'title': course.title,
'faculty': faculty_ctx,
'info': info_ctx
},
'assets': asset_ctx,
'projects': ProjectResource().render_list(request, projects)
}
return self.render_to_json_response(ctx)
from django.contrib import admin
from django.contrib.auth.decorators import login_required
from django.views.generic.simple import direct_to_template
from djangosherd.api import SherdNoteResource
from mediathread.api import TagResource
from mediathread.assetmgr.api import AssetResource
from mediathread.main.api import CourseResource, CourseSummaryResource
from mediathread.projects.api import ProjectResource
from mediathread.taxonomy.api import TermResource, VocabularyResource
from tastypie.api import Api
import os.path
v1_api = Api(api_name='v1')
v1_api.register(SherdNoteResource())
v1_api.register(AssetResource())
v1_api.register(ProjectResource())
v1_api.register(CourseResource())
v1_api.register(CourseSummaryResource())
v1_api.register(TermResource())
v1_api.register(VocabularyResource())
v1_api.register(TagResource())
admin.autodiscover()
site_media_root = os.path.join(os.path.dirname(__file__), "../media")
bookmarklet_root = os.path.join(os.path.dirname(__file__), "../media/",
"bookmarklets")
redirect_after_logout = getattr(settings, 'LOGOUT_REDIRECT_URL', None)
auth_urls = (r'^accounts/', include('django.contrib.auth.urls'))
def get(self, request, *args, **kwargs):
project = get_object_or_404(Project, pk=kwargs.get('project_id', None))
assignment = project.assignment()
if not assignment or not assignment.is_essay_assignment():
return HttpResponseForbidden('')
panels = []
lst = Vocabulary.objects.filter(course=request.course)
lst = lst.prefetch_related('term_set')
vocabulary = VocabularyResource().render_list(request, lst)
owners = UserResource().render_list(request, request.course.members)
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request.course, request.user)
feedback_discussion = project.feedback_discussion() \
if is_faculty or can_edit else None
parent = project.assignment()
# Requested project, can be either an assignment or composition
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
# only editing if it's new
project_context['editing'] = \
True if can_edit and len(project.body) < 1 else False
project_context['create_instructor_feedback'] = \
is_faculty and parent and not feedback_discussion
project_revisions_url = reverse('project-revisions',
args=[request.course.pk, project.id])
panel = {
'is_faculty':
is_faculty,
'show_feedback':
feedback_discussion is not None,
'create_feedback_url':
reverse('discussion-create', args=[request.course.pk]),
'project_revisions_url':
project_revisions_url,
'context':
project_context,
'template':
'project_response',
'owners':
owners,
'vocabulary':
vocabulary
}
panels.append(panel)
# If feedback exists for the requested project
if feedback_discussion:
# 3rd pane is the instructor feedback, if it exists
panel = {
'template': 'project_feedback',
'owners': owners,
'vocabulary': vocabulary,
'context': threaded_comment_json(request, feedback_discussion)
}
panels.append(panel)
# Create a place for asset editing
panel = {
'template': 'asset_quick_edit',
'update_history': False,
'owners': owners,
'vocabulary': vocabulary,
'context': {
'type': 'asset'
}
}
panels.append(panel)
data = {'space_owner': request.user.username, 'panels': panels}
return self.render_to_json_response(data)
def get(self, request, *args, **kwargs):
project = get_object_or_404(Project, pk=kwargs.get('project_id', None))
data = {'space_owner': request.user.username}
if not request.is_ajax():
self.template_name = 'projects/composition.html'
data['project'] = project
return self.render_to_response(data)
else:
panels = []
lst = Vocabulary.objects.filter(course=request.course)
lst = lst.prefetch_related('term_set')
vocabulary = VocabularyResource().render_list(request, lst)
owners = UserResource().render_list(request,
request.course.members)
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request.course, request.user)
# Requested project, can be either an assignment or composition
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
# only editing if it's new
project_context['editing'] = \
True if can_edit and len(project.body) < 1 else False
project_context['create_instructor_feedback'] = False
project_revisions_url = reverse(
'project-revisions', args=[request.course.pk, project.id])
panel = {
'is_faculty': is_faculty,
'context': project_context,
'template': 'project',
'owners': owners,
'project_revisions_url': project_revisions_url,
'vocabulary': vocabulary
}
panels.append(panel)
data['panels'] = panels
# Create a place for asset editing
panel = {
'template': 'asset_quick_edit',
'update_history': False,
'owners': owners,
'vocabulary': vocabulary,
'context': {
'type': 'asset'
}
}
panels.append(panel)
return self.render_to_json_response(data)
def project_workspace(request, project_id, feedback=None):
"""
A multi-panel editable view for the specified project
Legacy note: Ideally, this function would be named project_view but
StructuredCollaboration requires the view name
to be <class>-view to do a reverse lookup
Panel 1: Parent Assignment (if applicable)
Panel 2: Project
Panel 3: Instructor Feedback (if applicable & exists)
Keyword arguments:
project_id -- the model id
"""
project = get_object_or_404(Project, pk=project_id)
if not project.can_read(request):
return HttpResponseForbidden("forbidden")
show_feedback = feedback == "feedback"
data = {
'space_owner': request.user.username,
'show_feedback': show_feedback
}
if not request.is_ajax():
data['project'] = project
return render_to_response('projects/project.html',
data,
context_instance=RequestContext(request))
else:
panels = []
vocabulary = VocabularyResource().render_list(
request, Vocabulary.objects.get_for_object(request.course))
owners = UserResource().render_list(request, request.course.members)
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request)
feedback_discussion = project.feedback_discussion() \
if is_faculty or can_edit else None
# Project Parent (assignment) if exists
parent_assignment = project.assignment()
if parent_assignment:
resource = ProjectResource(
record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=parent_assignment.can_edit(request))
assignment_ctx = resource.render_one(request, parent_assignment)
panel = {
'is_faculty':
is_faculty,
'panel_state':
"open" if (project.title == "Untitled"
and len(project.body) == 0) else "closed",
'subpanel_state':
'closed',
'context':
assignment_ctx,
'owners':
owners,
'vocabulary':
vocabulary,
'template':
'project'
}
panels.append(panel)
# Requested project, can be either an assignment or composition
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
# only editing if it's new
project_context['editing'] = \
True if can_edit and len(project.body) < 1 else False
project_context['create_instructor_feedback'] = \
is_faculty and parent_assignment and not feedback_discussion
panel = {
'is_faculty': is_faculty,
'panel_state': 'closed' if show_feedback else 'open',
'context': project_context,
'template': 'project',
'owners': owners,
'vocabulary': vocabulary
}
panels.append(panel)
# Project Response -- if the requested project is an assignment
# This is primarily a student view. The student's response should
# pop up automatically when the parent assignment is viewed.
if project.is_assignment(request):
responses = project.responses_by(request, request.user)
if len(responses) > 0:
response = responses[0]
response_can_edit = response.can_edit(request)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=response_can_edit)
response_context = resource.render_one(request, response)
panel = {
'is_faculty': is_faculty,
'panel_state': 'closed',
'context': response_context,
'template': 'project',
'owners': owners,
'vocabulary': vocabulary
}
panels.append(panel)
if not feedback_discussion and response_can_edit:
feedback_discussion = response.feedback_discussion()
data['panels'] = panels
# If feedback exists for the requested project
if feedback_discussion:
# 3rd pane is the instructor feedback, if it exists
panel = {
'panel_state': 'open' if show_feedback else 'closed',
'panel_state_label': "Instructor Feedback",
'template': 'discussion',
'owners': owners,
'vocabulary': vocabulary,
'context': threaded_comment_json(request, feedback_discussion)
}
panels.append(panel)
# Create a place for asset editing
panel = {
'panel_state': 'closed',
'panel_state_label': "Item Details",
'template': 'asset_quick_edit',
'update_history': False,
'owners': owners,
'vocabulary': vocabulary,
'context': {
'type': 'asset'
}
}
panels.append(panel)
return HttpResponse(json.dumps(data, indent=2),
mimetype='application/json')
def project_view_readonly(request, project_id, version_number=None):
"""
A single panel read-only view of the specified project/version combination.
No assignment, response or feedback access/links.
Regular access conventions apply. For example, if the project is "private"
an HTTPResponseForbidden will be returned.
Used for reviewing old project versions and public project access.
Keyword arguments:
project_id -- the model id
version_number -- a specific project version or
None for the current version
"""
project = get_object_or_404(Project, pk=project_id)
if not project.can_read(request):
return HttpResponseForbidden("forbidden")
data = {'space_owner': request.user.username}
course = request.course
if not course:
# public view
course = request.collaboration_context.content_object
public_url = project.public_url()
else:
# versioned view
public_url = reverse('project-view-readonly',
kwargs={
'project_id': project.id,
'version_number': version_number
})
if not request.is_ajax():
data['project'] = project
data['version'] = version_number
data['public_url'] = public_url
return render_to_response('projects/project.html',
data,
context_instance=RequestContext(request))
else:
ProjectVersion = get_model('projects', 'projectversion')
if version_number:
version = get_object_or_404(ProjectVersion,
versioned_id=project_id,
version_number=version_number)
project = version.instance()
panels = []
# Requested project, either assignment or composition
request.public = True
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=False,
editable=False)
project_context = resource.render_one(request, project, version_number)
panel = {
'panel_state': 'open',
'panel_state_label': "Version View",
'context': project_context,
'template': 'project'
}
panels.append(panel)
data['panels'] = panels
return HttpResponse(json.dumps(data, indent=2),
mimetype='application/json')
def project_workspace(request, project_id, feedback=None):
"""
A multi-panel editable view for the specified project
Legacy note: Ideally, this function would be named project_view but
StructuredCollaboration requires the view name
to be <class>-view to do a reverse lookup
Panel 1: Parent Assignment (if applicable)
Panel 2: Project
Panel 3: Instructor Feedback (if applicable & exists)
Keyword arguments:
project_id -- the model id
"""
project = get_object_or_404(Project, pk=project_id)
if not project.can_read(request):
return HttpResponseForbidden("forbidden")
show_feedback = feedback == "feedback"
data = {'space_owner': request.user.username,
'show_feedback': show_feedback}
if not request.is_ajax():
data['project'] = project
return render_to_response('projects/project.html',
data,
context_instance=RequestContext(request))
else:
panels = []
vocabulary = VocabularyResource().render_list(
request, Vocabulary.objects.get_for_object(request.course))
owners = UserResource().render_list(request, request.course.members)
is_faculty = request.course.is_faculty(request.user)
can_edit = project.can_edit(request)
feedback_discussion = project.feedback_discussion() \
if is_faculty or can_edit else None
# Project Parent (assignment) if exists
parent_assignment = project.assignment()
if parent_assignment:
resource = ProjectResource(
record_viewer=request.user, is_viewer_faculty=is_faculty,
editable=parent_assignment.can_edit(request))
assignment_ctx = resource.render_one(request, parent_assignment)
panel = {'is_faculty': is_faculty,
'panel_state': "open" if (project.title == "Untitled" and
len(project.body) == 0)
else "closed",
'subpanel_state': 'closed',
'context': assignment_ctx,
'owners': owners,
'vocabulary': vocabulary,
'template': 'project'}
panels.append(panel)
# Requested project, can be either an assignment or composition
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=can_edit)
project_context = resource.render_one(request, project)
# only editing if it's new
project_context['editing'] = \
True if can_edit and len(project.body) < 1 else False
project_context['create_instructor_feedback'] = \
is_faculty and parent_assignment and not feedback_discussion
panel = {'is_faculty': is_faculty,
'panel_state': 'closed' if show_feedback else 'open',
'context': project_context,
'template': 'project',
'owners': owners,
'vocabulary': vocabulary}
panels.append(panel)
# Project Response -- if the requested project is an assignment
# This is primarily a student view. The student's response should
# pop up automatically when the parent assignment is viewed.
if project.is_assignment(request):
responses = project.responses_by(request, request.user)
if len(responses) > 0:
response = responses[0]
response_can_edit = response.can_edit(request)
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=is_faculty,
editable=response_can_edit)
response_context = resource.render_one(request, response)
panel = {'is_faculty': is_faculty,
'panel_state': 'closed',
'context': response_context,
'template': 'project',
'owners': owners,
'vocabulary': vocabulary}
panels.append(panel)
if not feedback_discussion and response_can_edit:
feedback_discussion = response.feedback_discussion()
data['panels'] = panels
# If feedback exists for the requested project
if feedback_discussion:
# 3rd pane is the instructor feedback, if it exists
panel = {'panel_state': 'open' if show_feedback else 'closed',
'panel_state_label': "Instructor Feedback",
'template': 'discussion',
'owners': owners,
'vocabulary': vocabulary,
'context': threaded_comment_json(request,
feedback_discussion)}
panels.append(panel)
# Create a place for asset editing
panel = {'panel_state': 'closed',
'panel_state_label': "Item Details",
'template': 'asset_quick_edit',
'update_history': False,
'owners': owners,
'vocabulary': vocabulary,
'context': {'type': 'asset'}}
panels.append(panel)
return HttpResponse(json.dumps(data, indent=2),
mimetype='application/json')
def project_view_readonly(request, project_id, version_number=None):
"""
A single panel read-only view of the specified project/version combination.
No assignment, response or feedback access/links.
Regular access conventions apply. For example, if the project is "private"
an HTTPResponseForbidden will be returned.
Used for reviewing old project versions and public project access.
Keyword arguments:
project_id -- the model id
version_number -- a specific project version or
None for the current version
"""
project = get_object_or_404(Project, pk=project_id)
if not project.can_read(request):
return HttpResponseForbidden("forbidden")
data = {'space_owner': request.user.username}
course = request.course
if not course:
# public view
course = request.collaboration_context.content_object
public_url = project.public_url()
else:
# versioned view
public_url = reverse('project-view-readonly',
kwargs={'project_id': project.id,
'version_number': version_number})
if not request.is_ajax():
data['project'] = project
data['version'] = version_number
data['public_url'] = public_url
return render_to_response('projects/project.html',
data,
context_instance=RequestContext(request))
else:
ProjectVersion = get_model('projects', 'projectversion')
if version_number:
version = get_object_or_404(ProjectVersion,
versioned_id=project_id,
version_number=version_number)
project = version.instance()
panels = []
# Requested project, either assignment or composition
request.public = True
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=False,
editable=False)
project_context = resource.render_one(request, project, version_number)
panel = {'panel_state': 'open',
'panel_state_label': "Version View",
'context': project_context,
'template': 'project'}
panels.append(panel)
data['panels'] = panels
return HttpResponse(json.dumps(data, indent=2),
mimetype='application/json')
def get(self, request, project_id, version_number=None):
"""
A single panel read-only view of the specified project/version combo.
No assignment, response or feedback access/links.
Regular access conventions apply. For example, if the project is
"private" an HTTPResponseForbidden will be returned.
Used for reviewing old project versions and public project access.
Keyword arguments:
project_id -- the model id
version_number -- a specific project version or
None for the current version
"""
project = get_object_or_404(Project, pk=project_id)
data = {'space_owner': request.user.username}
if not request.is_ajax():
course = request.course
if not course:
public_url = project.public_url()
else:
# versioned view
public_url = reverse('project-view-readonly',
kwargs={'project_id': project.id,
'version_number': version_number})
data['project'] = project
data['version'] = version_number
data['public_url'] = public_url
return self.render_to_response(data)
else:
if version_number:
version = get_object_or_404(Version,
object_id=str(project.id),
revision_id=version_number)
project = version._object_version.object
panels = []
is_faculty = (self.request.course and
self.request.course.is_faculty(request.user))
# Requested project, either assignment or composition
request.public = True
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=False,
editable=False)
project_context = resource.render_one(request, project,
version_number)
panel = {'panel_state': 'open',
'panel_state_label': "Version View",
'context': project_context,
'is_faculty': is_faculty,
'template': 'project'}
panels.append(panel)
data['panels'] = panels
return self.render_to_json_response(data)
def get(self, request, project_id, version_number=None):
"""
A single panel read-only view of the specified project/version combo.
No assignment, response or feedback access/links.
Regular access conventions apply. For example, if the project is
"private" an HTTPResponseForbidden will be returned.
Used for reviewing old project versions and public project access.
Keyword arguments:
project_id -- the model id
version_number -- a specific project version or
None for the current version
"""
project = get_object_or_404(Project, pk=project_id)
data = {'space_owner': request.user.username}
if not request.is_ajax():
course = request.course
if not course:
public_url = project.public_url()
else:
# versioned view
public_url = reverse('project-view-readonly',
kwargs={'project_id': project.id,
'version_number': version_number})
data['project'] = project
data['version'] = version_number
data['public_url'] = public_url
return self.render_to_response(data)
else:
if version_number:
version = get_object_or_404(Version,
object_id=str(project.id),
revision_id=version_number)
project = version.object_version.object
panels = []
is_faculty = (self.request.course and
self.request.course.is_faculty(request.user))
# Requested project, either assignment or composition
request.public = True
resource = ProjectResource(record_viewer=request.user,
is_viewer_faculty=False,
editable=False)
project_context = resource.render_one(request, project,
version_number)
panel = {'panel_state': 'open',
'panel_state_label': "Version View",
'context': project_context,
'is_faculty': is_faculty,
'template': 'project'}
panels.append(panel)
data['panels'] = panels
return self.render_to_json_response(data)
