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 = 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 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)
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 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 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 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, *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 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, *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 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)
