def get(self, request, asset_id):
the_assets = Asset.objects.filter(pk=asset_id, course=request.course)
if the_assets.count() == 0:
return asset_switch_course(request, asset_id)
(assets, notes) = self.visible_assets_and_notes(request, the_assets)
# if asset is not in my collection, it must be in my course
if assets.count() == 0 and the_assets[0].course != request.course:
return HttpResponseForbidden("forbidden")
# only return original author's global annotations
notes = notes.exclude(~Q(author=request.user), range1__isnull=True)
asset = the_assets[0]
if asset.primary.is_image():
notes = notes.order_by('author', 'title')
else:
notes = notes.order_by('author', 'range1', 'title')
notes = notes.prefetch_related(
'termrelationship_set__term__vocabulary',
'projectnote_set__project')
help_setting = UserSetting.get_setting(request.user,
"help_item_detail_view", True)
ctx = AssetResource().render_one_context(request, asset, notes)
ctx['user_settings'] = {'help_item_detail_view': help_setting}
ctx['type'] = 'asset'
ctx.update(self.get_tags_and_terms(request, assets))
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)
def get_context(self, request, assets, notes):
# Allow the logged in user to add assets to his composition
citable = request.GET.get('citable', '') == 'true'
# Include annotation metadata. (makes response much larger)
include_annotations = request.GET.get('annotations', '') == 'true'
# Initialize the context
ures = UserResource()
ctx = {
'space_viewer': ures.render_one(request, self.record_viewer),
'is_faculty': self.is_viewer_faculty
}
if self.record_owner:
ctx['space_owner'] = ures.render_one(request, self.record_owner)
ctx['active_filters'] = {}
for key, val in request.GET.items():
if (key in self.valid_filters or key.startswith('vocabulary-')):
ctx['active_filters'][key] = val
ctx['editable'] = self.viewing_own_records
ctx['citable'] = citable
# render the assets
ares = AssetResource(include_annotations=include_annotations,
extras={'editable': self.viewing_own_records,
'citable': citable})
ctx['assets'] = ares.render_list(request,
self.record_viewer,
assets, notes)
return ctx
def get_context(self, request, assets, notes):
# Allow the logged in user to add assets to his composition
citable = request.GET.get('citable', '') == 'true'
# Include annotation metadata. (makes response much larger)
include_annotations = request.GET.get('annotations', '') == 'true'
# Initialize the context
ures = UserResource()
ctx = {
'space_viewer': ures.render_one(request, self.record_viewer),
'is_faculty': self.is_viewer_faculty
}
if self.record_owner:
ctx['space_owner'] = ures.render_one(request, self.record_owner)
ctx['active_filters'] = {}
for key, val in request.GET.items():
if (key in self.valid_filters or key.startswith('vocabulary-')):
ctx['active_filters'][key] = val
ctx['editable'] = self.viewing_own_records
ctx['citable'] = citable
# render the assets
ares = AssetResource(include_annotations=include_annotations,
extras={
'editable': self.viewing_own_records,
'citable': citable
})
ctx['assets'] = ares.render_list(request, self.record_viewer, assets,
notes)
return ctx
def get(self, request, asset_id):
self.record_owner = request.user
the_assets = Asset.objects.filter(pk=asset_id, course=request.course)
if the_assets.count() == 0:
return asset_switch_course(request, asset_id)
(assets, notes) = self.visible_assets_and_notes(request, the_assets)
# if asset is not in my collection, it must be in my course
if assets.count() == 0 and the_assets[0].course != request.course:
return HttpResponseForbidden("forbidden")
asset = the_assets[0]
help_setting = UserSetting.get_setting(request.user,
"help_item_detail_view", True)
ctx = AssetResource().render_one(request, asset, notes)
ctx = {
'user_settings': {
'help_item_detail_view': help_setting
},
'type': 'asset',
'assets': {
asset.pk: AssetResource().render_one(request, asset, notes)
}
}
return self.render_to_json_response(ctx)
def get(self, request, asset_id=None, annot_id=None):
if asset_id:
try:
asset = Asset.objects.get(pk=asset_id, course=request.course)
asset.primary
except Asset.DoesNotExist:
return asset_switch_course(request, asset_id)
except Source.DoesNotExist:
ctx = RequestContext(request)
return render_to_response('500.html', {}, context_instance=ctx)
data = {'asset_id': asset_id, 'annotation_id': annot_id}
if not request.is_ajax():
return render_to_response('assetmgr/asset_workspace.html',
data,
context_instance=RequestContext(request))
ctx = {'type': 'asset'}
if asset_id:
# @todo - refactor this context out of the mix
# ideally, the client would simply request the json
# the mixin is expecting a queryset, so this becomes awkward here
assets = Asset.objects.filter(pk=asset_id)
(assets, notes) = self.visible_assets_and_notes(request, assets)
# only return original author's global annotations
notes = notes.exclude(~Q(author=request.user), range1__isnull=True)
ares = AssetResource()
ctx.update(ares.render_one_context(request, asset, notes))
help_setting = UserSetting.get_setting(request.user,
"help_item_detail_view",
True)
ctx['user_settings'] = {'help_item_detail_view': help_setting}
vocabulary = VocabularyResource().render_list(
request, Vocabulary.objects.get_for_object(request.course))
user_resource = UserResource()
owners = user_resource.render_list(request, request.course.members)
update_history = True
show_collection = True
template = 'asset_workspace'
data['panels'] = [{
'panel_state': 'open',
'panel_state_label': "Annotate Media",
'context': ctx,
'owners': owners,
'vocabulary': vocabulary,
'template': template,
'current_asset': asset_id,
'current_annotation': annot_id,
'update_history': update_history,
'show_collection': show_collection}]
return self.render_to_json_response(data)
def threaded_comment_json(request, comment):
viewer = request.user
coll = ContentType.objects.get_for_model(Collaboration)
all_comments = ThreadedComment.objects.filter(
content_type=coll,
object_pk=comment.content_object.pk,
site__pk=settings.SITE_ID)
all_comments = fill_tree(all_comments)
all_comments = list(annotate_tree_properties(all_comments))
rand = ''.join([choice(letters) for i in range(5)])
citations = threaded_comment_citations(all_comments, viewer)
asset_resource = AssetResource()
sherd_resource = SherdNoteResource()
return {
'type':
'discussion',
'form':
comments.get_form()(comment.content_object).__unicode__(),
'editing':
True,
'can_edit':
True,
'discussion': {
'id':
comment.id,
'max_length':
COMMENT_MAX_LENGTH,
'thread': [{
'open':
obj.open if hasattr(obj, "open") else None,
'close':
[i for i in obj.close] if hasattr(obj, "close") else None,
'id':
obj.id,
'author':
obj.name,
'author_username':
obj.user.username,
'submit_date':
pretty_date(obj.submit_date),
'title':
obj.title,
'content':
obj.comment,
'can_edit':
True if obj.user == viewer else False
} for obj in all_comments]
},
'assets':
dict([('%s_%s' % (rand, ann.asset.pk),
asset_resource.render_one(request, ann.asset))
for ann in citations if (ann.title != "Annotation Deleted"
and ann.title != 'Asset Deleted')]),
'annotations':
[sherd_resource.render_one(request, ann, rand) for ann in citations],
}
def get_extra_context(self):
parent = self.get_assignment(self.project)
item = parent.assignmentitem_set.first().asset
item_ctx = AssetResource().render_one_context(self.request, item)
return {'item': item, 'item_json': json.dumps(item_ctx)}
def get_context_data(self, **kwargs):
course_id = kwargs.get('course_id')
selection_id = kwargs.get('annot_id', None)
if not self.check_signature(course_id, selection_id):
raise Http404()
selection = get_object_or_404(SherdNote, pk=selection_id)
ctx = AssetResource().render_one_context(self.request, selection.asset,
[selection])
media_type = selection.asset.media_type()
ctx = {
'item': json.dumps(ctx),
'item_id': selection.asset.id,
'selection_id': selection.id,
'presentation': 'medium',
'media_type': media_type,
'title': selection.display_title(),
'thumb_url': selection.asset.thumb_url,
'defaultHeight': EMBED_HEIGHT
}
if media_type == 'video':
ctx['timecode'] = selection.range_as_timecode()
return ctx
def get(self, request, asset_id):
the_assets = Asset.objects.filter(pk=asset_id, course=request.course)
if the_assets.count() == 0:
return asset_switch_course(request, asset_id)
(assets, notes) = self.visible_assets_and_notes(request, the_assets)
# if asset is not in my collection, it must be in my course
if assets.count() == 0 and the_assets[0].course != request.course:
return HttpResponseForbidden("forbidden")
# only return original author's global annotations
notes = notes.exclude(~Q(author=request.user), range1__isnull=True)
asset = the_assets[0]
help_setting = UserSetting.get_setting(request.user,
"help_item_detail_view", True)
ctx = {
'user_settings': {
'help_item_detail_view': help_setting
},
'type': 'asset',
'assets': {
asset.pk: AssetResource().render_one(request, asset, notes)
}
}
return self.render_to_json_response(ctx)
def get(self, request):
self.root = 'http://' + request.get_host()
assets = Asset.objects.filter(course=request.course)
assets, notes = self.visible_assets_and_notes(request, assets)
# @todo - factor out the tastypie interim json step
ar = AssetResource(include_annotations=True)
api_response = ar.render_list(request, None, request.user,
assets, notes)
if len(api_response) == 0:
return HttpResponse("There are no videos in your collection")
for i in range(0, len(api_response)):
self.parse_response(api_response[i])
return HttpResponse(json.dumps(self.export))
def get(self, request):
self.root = 'http://' + request.get_host()
assets = Asset.objects.filter(course=request.course)
assets, notes = self.visible_assets_and_notes(request, assets)
# @todo - factor out the tastypie interim json step
ar = AssetResource(include_annotations=True)
api_response = ar.render_list(request, None, request.user, assets,
notes)
if len(api_response) == 0:
return HttpResponse("There are no videos in your collection")
for i in range(0, len(api_response)):
self.parse_response(api_response[i])
return HttpResponse(json.dumps(self.export))
def related_assets_notes(self, request, project):
asset_resource = AssetResource()
sherd_resource = SherdNoteResource()
rand = ''.join([choice(letters) for i in range(5)])
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)
return assets, notes
def related_assets_notes(self, request, project):
asset_resource = AssetResource()
sherd_resource = SherdNoteResource()
rand = ''.join([choice(ascii_letters) for i in range(5)]) # nosec
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)
return assets, notes
def threaded_comment_json(request, comment):
viewer = request.user
coll = ContentType.objects.get_for_model(Collaboration)
all_comments = ThreadedComment.objects.filter(
content_type=coll, object_pk=comment.content_object.pk,
site__pk=settings.SITE_ID)
all_comments = fill_tree(all_comments)
all_comments = list(annotate_tree_properties(all_comments))
rand = ''.join([choice(letters) for i in range(5)])
citations = threaded_comment_citations(all_comments, viewer)
asset_resource = AssetResource()
sherd_resource = SherdNoteResource()
return {
'type': 'discussion',
'form': django_comments.get_form()(
comment.content_object).__unicode__(),
'editing': True,
'can_edit': True,
'discussion': {
'id': comment.id,
'max_length': COMMENT_MAX_LENGTH,
'thread': [{'open': obj.open if hasattr(obj, "open") else None,
'close': [i for i in obj.close]
if hasattr(obj, "close") else None,
'id': obj.id,
'author': obj.name,
'author_username': obj.user.username,
'submit_date': pretty_date(obj.submit_date),
'title': obj.title,
'content': obj.comment,
'can_edit': True if obj.user == viewer else False}
for obj in all_comments]
},
'assets': dict([('%s_%s' % (rand, ann.asset.pk),
asset_resource.render_one(request, ann.asset))
for ann in citations
if (ann.title != "Annotation Deleted" and
ann.title != 'Asset Deleted')]),
'annotations': [sherd_resource.render_one(request, ann, rand)
for ann in citations],
}
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, asset_id=None, annot_id=None):
if asset_id:
try:
asset = Asset.objects.get(pk=asset_id, course=request.course)
asset.primary
except Asset.DoesNotExist:
return asset_switch_course(request, asset_id)
except Source.DoesNotExist:
ctx = RequestContext(request)
return render_to_response('500.html', {}, context_instance=ctx)
data = {'asset_id': asset_id, 'annotation_id': annot_id}
if not request.is_ajax():
return render_to_response('assetmgr/asset_workspace.html',
data,
context_instance=RequestContext(request))
context = {'type': 'asset'}
if asset_id:
# @todo - refactor this context out of the mix
# ideally, the client would simply request the json
# the mixin is expecting a queryset, so this becomes awkward here
self.record_owner = request.user
assets = Asset.objects.filter(pk=asset_id)
(assets, notes) = self.visible_assets_and_notes(request, assets)
context['assets'] = {
asset.pk: AssetResource().render_one(request, asset, notes)
}
help_setting = UserSetting.get_setting(request.user,
"help_item_detail_view",
True)
context['user_settings'] = {'help_item_detail_view': help_setting}
vocabulary = VocabularyResource().render_list(
request, Vocabulary.objects.get_for_object(request.course))
user_resource = UserResource()
owners = user_resource.render_list(request, request.course.members)
data['panels'] = [{
'panel_state': 'open',
'panel_state_label': "Annotate Media",
'context': context,
'owners': owners,
'vocabulary': vocabulary,
'template': 'asset_workspace',
'current_asset': asset_id,
'current_annotation': annot_id,
'update_history': True,
'show_collection': True
}]
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)
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)
def detail_asset_json(request, asset):
the_json = AssetResource().render_one(request, asset)
the_json['user_analysis'] = asset.user_analysis_count(request.user)
help_setting = \
UserSetting.get_setting(request.user, "help_item_detail_view", True)
return {
'type': 'asset',
'assets': {
asset.pk: the_json
},
'user_settings': {
'help_item_detail_view': help_setting
}
}
def get(self, *args, **kwargs):
item = get_object_or_404(Asset, id=kwargs.get('asset_id', None))
parent = get_object_or_404(Project, id=kwargs.get('project_id', None))
responses = parent.responses(self.request.course, self.request.user)
response_ids = [r.id for r in responses]
# notes related to visible responses are visible
pnotes = ProjectNote.objects.filter(project__id__in=response_ids)
note_ids = pnotes.values_list('annotation__id', flat=True)
notes = SherdNote.objects.filter(id__in=note_ids)
if item.primary.is_image():
notes = notes.order_by('author', 'title')
else:
notes = notes.order_by('author', 'range1', 'title')
notes = notes.prefetch_related('author', 'asset')
ctx = AssetResource().render_one_context(self.request, item, notes)
return self.render_to_json_response(ctx)
from django.conf.urls.defaults import url, patterns, include
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)
def render_assets(request, record_owner, assets):
course = request.course
logged_in_user = request.user
# Is the current user faculty OR staff
is_faculty = cached_course_is_faculty(course, logged_in_user)
# Can the record_owner edit the records
viewing_own_records = (record_owner == logged_in_user)
viewing_faculty_records = record_owner and course.is_faculty(record_owner)
# Allow the logged in user to add assets to his composition
citable = request.GET.get('citable', '') == 'true'
# Does the course allow viewing other user selections?
owner_selections_are_visible = (
course_details.all_selections_are_visible(course) or
viewing_own_records or viewing_faculty_records or is_faculty)
# Spew out json for the assets
if request.GET.get('annotations', '') == 'true':
resource = AssetResource(owner_selections_are_visible,
record_owner,
{'editable': viewing_own_records,
'citable': citable})
else:
resource = AssetSummaryResource({'editable': viewing_own_records,
'citable': citable})
asset_json = resource.render_list(request, assets)
active_filters = {}
for k, val in request.GET.items():
if (k == 'tag' or k == 'modified' or k.startswith('vocabulary-')):
active_filters[k] = val
user_resource = UserResource()
# #todo -- figure out a cleaner way to do this. Ugli-ness
# Collate tag set & vocabulary set for the result set.
# Get all visible notes for the returned asset set
# These notes may include global annotations for all users,
# whereas the rendered set will not
active_asset_ids = [a['id'] for a in asset_json]
active_notes = []
if record_owner:
if owner_selections_are_visible:
active_notes = SherdNote.objects.filter(
asset__course=course, asset__id__in=active_asset_ids,
author__id=record_owner.id)
else:
if all_selections_are_visible(course) or is_faculty:
# Display all tags for the asset set including globals
active_notes = SherdNote.objects.filter(
asset__course=course, asset__id__in=active_asset_ids)
else:
whitelist = [f.id for f in course.faculty]
whitelist.append(request.user.id)
active_notes = SherdNote.objects.filter(
asset__course=course,
asset__id__in=active_asset_ids,
author__id__in=whitelist)
tags = []
if len(active_notes) > 0:
tags = Tag.objects.usage_for_queryset(active_notes)
tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
active_vocabulary = []
note_ids = [n.id for n in active_notes]
content_type = ContentType.objects.get_for_model(SherdNote)
term_resource = TermResource()
for v in Vocabulary.objects.get_for_object(request.course):
vocabulary = {
'id': v.id,
'display_name': v.display_name,
'term_set': []
}
related = TermRelationship.objects.filter(term__vocabulary=v,
content_type=content_type,
object_id__in=note_ids)
terms = []
for r in related:
if r.term.display_name not in terms:
the_term = term_resource.render_one(request, r.term)
vocabulary['term_set'].append(the_term)
terms.append(r.term.display_name)
active_vocabulary.append(vocabulary)
# Assemble the context
data = {'assets': asset_json,
'active_tags': TagResource().render_list(request, tags),
'active_filters': active_filters,
'active_vocabulary': active_vocabulary,
'space_viewer': user_resource.render_one(request, logged_in_user),
'editable': viewing_own_records,
'citable': citable,
'is_faculty': is_faculty}
if record_owner:
data['space_owner'] = user_resource.render_one(request, record_owner)
json_stream = simplejson.dumps(data, indent=2)
return HttpResponse(json_stream, mimetype='application/json')
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 render_assets(request, record_owner, assets):
course = request.course
logged_in_user = request.user
# Is the current user faculty OR staff
is_faculty = cached_course_is_faculty(course, logged_in_user)
# Can the record_owner edit the records
viewing_own_records = (record_owner == logged_in_user)
viewing_faculty_records = record_owner and course.is_faculty(record_owner)
# Allow the logged in user to add assets to his composition
citable = request.GET.get('citable', '') == 'true'
# Does the course allow viewing other user selections?
owner_selections_are_visible = (
course_details.all_selections_are_visible(course)
or viewing_own_records or viewing_faculty_records or is_faculty)
# Spew out json for the assets
if request.GET.get('annotations', '') == 'true':
resource = AssetResource(owner_selections_are_visible, record_owner, {
'editable': viewing_own_records,
'citable': citable
})
else:
resource = AssetSummaryResource({
'editable': viewing_own_records,
'citable': citable
})
asset_json = resource.render_list(request, assets)
active_filters = {}
for key, val in request.GET.items():
if (key == 'tag' or key == 'modified'
or key.startswith('vocabulary-')):
active_filters[key] = val
user_resource = UserResource()
# #todo -- figure out a cleaner way to do this. Ugli-ness
# Collate tag set & vocabulary set for the result set.
# Get all visible notes for the returned asset set
# These notes may include global annotations for all users,
# whereas the rendered set will not
active_asset_ids = [a['id'] for a in asset_json]
active_notes = []
if record_owner:
if owner_selections_are_visible:
active_notes = SherdNote.objects.filter(
asset__course=course,
asset__id__in=active_asset_ids,
author__id=record_owner.id)
else:
if all_selections_are_visible(course) or is_faculty:
# Display all tags for the asset set including globals
active_notes = SherdNote.objects.filter(
asset__course=course, asset__id__in=active_asset_ids)
else:
whitelist = [f.id for f in course.faculty]
whitelist.append(request.user.id)
active_notes = SherdNote.objects.filter(
asset__course=course,
asset__id__in=active_asset_ids,
author__id__in=whitelist)
tags = []
if len(active_notes) > 0:
tags = Tag.objects.usage_for_queryset(active_notes)
tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
active_vocabulary = []
note_ids = [n.id for n in active_notes]
content_type = ContentType.objects.get_for_model(SherdNote)
term_resource = TermResource()
for vocab in Vocabulary.objects.get_for_object(request.course):
vocabulary = {
'id': vocab.id,
'display_name': vocab.display_name,
'term_set': []
}
related = TermRelationship.objects.filter(term__vocabulary=vocab,
content_type=content_type,
object_id__in=note_ids)
terms = []
for rel in related:
if rel.term.display_name not in terms:
the_term = term_resource.render_one(request, rel.term)
vocabulary['term_set'].append(the_term)
terms.append(rel.term.display_name)
active_vocabulary.append(vocabulary)
# Assemble the context
data = {
'assets': asset_json,
'active_tags': TagResource().render_list(request, tags),
'active_filters': active_filters,
'active_vocabulary': active_vocabulary,
'space_viewer': user_resource.render_one(request, logged_in_user),
'editable': viewing_own_records,
'citable': citable,
'is_faculty': is_faculty
}
if record_owner:
data['space_owner'] = user_resource.render_one(request, record_owner)
json_stream = simplejson.dumps(data, indent=2)
return HttpResponse(json_stream, mimetype='application/json')
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
