def container_view(request):
"""for all class assets view at /asset/
OPTIMIZATION: What we need:
asset: primary label, thumb.url
tags {name}
project: collaboration.get_parent, feedback_discussion
status (from collaboration)
attribution
"""
#extra() is case-insensitive order hack
#http://scottbarnham.com/blog/2007/11/20/case-insensitive-ordering-with-django-and-postgresql/
archives = list(request.course.asset_set.archives())
assets = [
a for a in Asset.objects.filter(course=request.course).extra(
select={
'lower_title': 'lower(assetmgr_asset.title)'
}).select_related().order_by('lower_title') if a not in archives
]
asset_ids = [a.id for a in assets]
thumbs = dict([
(th.asset_id, th.url)
for th in Source.objects.filter(label='thumb', asset__in=asset_ids)
])
primaries = dict([
(p.asset_id, p)
for p in Source.objects.filter(primary=True, asset__in=asset_ids)
])
#import pdb;pdb.set_trace()
for a in assets:
a._primary_cache = primaries[a.id]
a._thumb_url = thumbs.get(a.id, None)
from tagging.models import Tag
all_tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(asset__course=request.course), counts=True)
all_tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
all_tags = calculate_cloud(all_tags)
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [
asset for asset in assets
if filter_by[fil](asset, filter_value)
]
active_filters = get_active_filters(request)
return {
'assets': assets,
'tags': all_tags,
'active_filters': active_filters,
'space_viewer': request.user,
'space_owner': None,
'is_faculty': request.course.is_faculty(request.user),
}
def container_view(request):
"""for all class assets view at /asset/
OPTIMIZATION: What we need:
asset: primary label, thumb.url
tags {name}
project: collaboration.get_parent, feedback_discussion
status (from collaboration)
attribution
"""
#extra() is case-insensitive order hack
#http://scottbarnham.com/blog/2007/11/20/case-insensitive-ordering-with-django-and-postgresql/
archives = list(request.course.asset_set.archives())
assets = [a for a in Asset.objects.filter(course=request.course).extra(
select={'lower_title': 'lower(assetmgr_asset.title)'}
).select_related().order_by('lower_title')
if a not in archives]
asset_ids = [a.id for a in assets]
thumbs = dict([(th.asset_id,th.url) for th in Source.objects.filter(label='thumb', asset__in=asset_ids)])
primaries = dict([(p.asset_id,p) for p in Source.objects.filter(primary=True, asset__in=asset_ids)])
#import pdb;pdb.set_trace()
for a in assets:
a._primary_cache = primaries[a.id]
a._thumb_url = thumbs.get(a.id,None)
from tagging.models import Tag
all_tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(
asset__course=request.course),
counts=True)
all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
all_tags = calculate_cloud(all_tags)
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [asset for asset in assets
if filter_by[fil](asset, filter_value)]
active_filters = get_active_filters(request)
return {
'assets':assets,
'tags': all_tags,
'active_filters': active_filters,
'space_viewer':request.user,
'space_owner':None,
'is_faculty':request.course.is_faculty(request.user),
}
def annotations_collection_fragment(request,username=None):
"""username is WAY overloaded
username='******' : just give me the selection menu
username=None : give me all assets for the class
username=<username> : all username assets
"""
rv = {'space_viewer':request.user,
'space_owner':False, #indicates we want the whole class (None is no one)
'page_in_edit_mode': request.GET.has_key('edit_mode'),
}
if username != 'none':
if username \
and (request.user.username != username or request.course.is_true_member(request.user)):
rv['space_owner'] = in_course_or_404(username, request.course)
#assets = annotated_by(Asset.objects.filter(course=request.course),
# space_owner)
note_query = rv['space_owner'].sherdnote_set.filter(asset__course=request.course)
else:
#assets = Asset.objects.filter(course=request.course)
note_query = SherdNote.objects.filter(asset__course=request.course)
rv['tags'] = calculate_cloud(Tag.objects.usage_for_queryset(note_query, counts=True))
#all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
#all_tags = calculate_cloud(all_tags)
filter_by = ('tag','modified')
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
s_filter = getattr(SherdNote.objects,'%s_filter'%fil)
note_query = s_filter(filter_value,note_query)
#until asset_table.html can work off the notes objects instead of the assets list
rv['assets'] = Asset.objects.filter(id__in = note_query.values_list('asset',flat=True))
rv['active_filters'] = get_active_filters(request)
rv['dates'] = (('today','today'),
('yesterday','yesterday'),
('lastweek','within the last week'),
)
return rv
def get_records(user, course, request):
c = course
today = datetime.date.today()
editable = (user==request.user)
#bad language, we should change this to user_of_assets or something
space_viewer = request.user
if request.GET.has_key('as') and request.user.is_staff:
space_viewer = get_object_or_404(User, username=request.GET['as'])
assignments = []
responder = None
if user == 'all':
archives = list(course.asset_set.archives())
assets = [a for a in Asset.objects.filter(course=c).extra(
select={'lower_title': 'lower(assetmgr_asset.title)'}
).select_related().order_by('lower_title')
if a not in archives]
user = None
all_tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(
asset__course=course),
counts=True)
all_tags.sort(lambda a,b:cmp(a.name.lower(),b.name.lower()))
tags = calculate_cloud(all_tags)
projects = [p for p in Project.objects.filter(course=c,
submitted=True).order_by('title')
if p.visible(request)]
else:
assets = annotated_by(Asset.objects.filter(course=c),
user,
include_archives=c.is_faculty(user)
)
tags = calculate_cloud(Tag.objects.usage_for_queryset(
user.sherdnote_set.filter(
asset__course=c),
counts=True))
projects = Project.get_user_projects(user, c).order_by('-modified')
if not editable:
projects = [p for p in projects if p.visible(request)]
project_type = ContentType.objects.get_for_model(Project)
assignments = []
maybe_assignments = Project.objects.filter(
c.faculty_filter)
for assignment in maybe_assignments:
if not assignment.visible(request):
continue
if assignment in projects:
continue
if is_unanswered_assignment(assignment, user, request, project_type):
assignments.append(assignment)
if user.id == space_viewer.id:
responder = space_viewer.username
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [asset for asset in assets
if filter_by[fil](asset, filter_value, user)]
active_filters = get_active_filters(request, filter_by)
if request.is_ajax():
asset_json = []
for asset in assets:
the_json = asset.sherd_json(request)
gannotation, created = SherdNote.objects.global_annotation(asset, user or space_viewer, auto_create=False)
if gannotation:
the_json['global_annotation'] = gannotation.sherd_json(request, 'x', ('tags','body') )
the_json['editable'] = editable
annotations = []
if request.GET.has_key('annotations'):
# @todo: refactor this serialization into a common place.
def author_name(request, annotation, key):
if not annotation.author_id:
return None
return 'author_name',get_public_name(annotation.author, request)
for ann in asset.sherdnote_set.filter(range1__isnull=False,author=user):
annotations.append( ann.sherd_json(request, 'x', ('title','author','tags',author_name,'body','modified', 'timecode') ) )
the_json['annotations'] = annotations
asset_json.append(the_json)
project_json = []
for p in projects:
the_json = {}
the_json['id'] = p.id
the_json['title'] = p.title
the_json['url'] = p.get_absolute_url()
participants = p.attribution_list()
the_json['authors'] = [ {'name': get_public_name(u, request) } for u in participants]
the_json['modified'] = p.modified.strftime("%m/%d/%y %I:%M %p")
the_json['status'] = p.status()
the_json['editable'] = editable
feedback = p.feedback_discussion()
if feedback:
the_json['feedback'] = feedback.id
collaboration = p.collaboration()
if collaboration:
collaboration_parent = collaboration.get_parent()
if collaboration_parent:
the_json['collaboration'] = {}
the_json['collaboration']['title'] = collaboration_parent.title
if collaboration_parent.content_object:
the_json['collaboration']['url'] = collaboration_parent.content_object.get_absolute_url()
project_json.append(the_json)
data = {'assets': asset_json,
'assignments' : [ {'id': a.id, 'responder': responder, 'url': a.get_absolute_url(), 'title': a.title, 'modified': a.modified.strftime("%m/%d/%y %I:%M %p")} for a in assignments],
'projects' : project_json,
'tags': [ { 'name': tag.name } for tag in tags ],
'active_filters': active_filters,
'space_viewer' : { 'username': space_viewer.username, 'public_name': get_public_name(space_viewer, request), 'can_manage': (space_viewer.is_staff and not user) },
'editable' : editable,
'owners' : [{ 'username': m.username, 'public_name': get_public_name(m, request) } for m in request.course.members],
'compositions' : len(projects) > 0 or len(assignments) > 0,
'is_faculty': c.is_faculty(space_viewer),
}
if user:
data['space_owner'] = { 'username': user.username, 'public_name': get_public_name(user, request) }
json_stream = simplejson.dumps(data, indent=2)
return HttpResponse(json_stream, mimetype='application/json')
else:
dates = (('today','today'),
('yesterday','yesterday'),
('lastweek','within the last week'),)
return {
'assets' : assets,
'assignments' : assignments,
'projects' : projects,
'tags' : tags,
'dates' : dates,
'space_owner' : user,
'space_viewer' : space_viewer,
'editable' : editable,
'active_filters': active_filters,
}
def get_records(request, record_owner, projects, assignments, assets):
course = request.course
logged_in_user = request.user
# Can the record_owner edit the records
viewing_my_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.has_key('citable') and request.GET.get('citable') == 'true'
# Is the current user faculty OR staff
is_faculty = course.is_faculty(logged_in_user)
# Does the course allow viewing other user selections?
owner_selections_are_visible = course_details.all_selections_are_visible(course) or \
viewing_my_records or viewing_faculty_records or is_faculty
# Filter the assets
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [asset for asset in assets
if filter_by[fil](asset, filter_value, record_owner)]
active_filters = get_active_filters(request, filter_by)
# Spew out json for the assets
asset_json = []
options = {
'owner_selections_are_visible': request.GET.has_key('annotations') and owner_selections_are_visible,
'all_selections_are_visible': course_details.all_selections_are_visible(course) or is_faculty,
'can_edit': viewing_my_records,
'citable': citable
}
for asset in assets:
asset_json.append(homepage_asset_json(request, asset, logged_in_user, record_owner, options))
# Spew out json for the projects
project_json = []
for p in projects:
project_json.append(homepage_project_json(request, p, viewing_my_records))
# Tags
tags = []
if record_owner:
if owner_selections_are_visible:
# Tags for selected user
tags = Tag.objects.usage_for_queryset(
record_owner.sherdnote_set.filter(asset__course=course),
counts=True)
else:
if owner_selections_are_visible:
# Tags for the whole class
tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(asset__course=course),
counts=True)
else:
# Tags for myself and faculty members
tags = Tag.objects.usage_for_queryset(
logged_in_user.sherdnote_set.filter(asset__course=course),
counts=True)
for f in course.faculty:
tags.extend(Tag.objects.usage_for_queryset(
f.sherdnote_set.filter(asset__course=course),
counts=True))
tags.sort(lambda a, b:cmp(a.name.lower(), b.name.lower()))
# Assemble the context
data = { 'assets': asset_json,
'assignments' : [ {'id': a.id, 'url': a.get_absolute_url(), 'title': a.title, 'modified': a.modified.strftime("%m/%d/%y %I:%M %p")} for a in assignments],
'projects' : project_json,
'tags': [ { 'name': tag.name } for tag in tags ],
'active_filters': active_filters,
'space_viewer' : { 'username': logged_in_user.username, 'public_name': get_public_name(logged_in_user, request), 'can_manage': (logged_in_user.is_staff and not record_owner) },
'editable' : viewing_my_records,
'citable' : citable,
'owners' : [{ 'username': m.username, 'public_name': get_public_name(m, request) } for m in request.course.members],
'compositions' : len(projects) > 0 or len(assignments) > 0,
'is_faculty': is_faculty,
}
if record_owner:
data['space_owner'] = { 'username': record_owner.username, 'public_name': get_public_name(record_owner, request) }
json_stream = simplejson.dumps(data, indent=2)
return HttpResponse(json_stream, mimetype='application/json')
def get_records(request, record_owner, projects, assignments, assets):
course = request.course
logged_in_user = request.user
# Can the record_owner edit the records
viewing_my_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.has_key('citable') and request.GET.get(
'citable') == 'true'
# Is the current user faculty OR staff
is_faculty = course.is_faculty(logged_in_user)
# Does the course allow viewing other user selections?
owner_selections_are_visible = course_details.all_selections_are_visible(course) or \
viewing_my_records or viewing_faculty_records or is_faculty
# Filter the assets
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [
asset for asset in assets
if filter_by[fil](asset, filter_value, record_owner)
]
active_filters = get_active_filters(request, filter_by)
# Spew out json for the assets
asset_json = []
options = {
'owner_selections_are_visible':
request.GET.has_key('annotations') and owner_selections_are_visible,
'all_selections_are_visible':
course_details.all_selections_are_visible(course) or is_faculty,
'can_edit':
viewing_my_records,
'citable':
citable
}
for asset in assets:
asset_json.append(
homepage_asset_json(request, asset, logged_in_user, record_owner,
options))
# Spew out json for the projects
project_json = []
for p in projects:
project_json.append(
homepage_project_json(request, p, viewing_my_records))
# Tags
tags = []
if record_owner:
if owner_selections_are_visible:
# Tags for selected user
tags = Tag.objects.usage_for_queryset(
record_owner.sherdnote_set.filter(asset__course=course),
counts=True)
else:
if owner_selections_are_visible:
# Tags for the whole class
tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(asset__course=course), counts=True)
else:
# Tags for myself and faculty members
tags = Tag.objects.usage_for_queryset(
logged_in_user.sherdnote_set.filter(asset__course=course),
counts=True)
for f in course.faculty:
tags.extend(
Tag.objects.usage_for_queryset(
f.sherdnote_set.filter(asset__course=course),
counts=True))
tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
# Assemble the context
data = {
'assets':
asset_json,
'assignments': [{
'id': a.id,
'url': a.get_absolute_url(),
'title': a.title,
'modified': a.modified.strftime("%m/%d/%y %I:%M %p")
} for a in assignments],
'projects':
project_json,
'tags': [{
'name': tag.name
} for tag in tags],
'active_filters':
active_filters,
'space_viewer': {
'username': logged_in_user.username,
'public_name': get_public_name(logged_in_user, request),
'can_manage': (logged_in_user.is_staff and not record_owner)
},
'editable':
viewing_my_records,
'citable':
citable,
'owners': [{
'username': m.username,
'public_name': get_public_name(m, request)
} for m in request.course.members],
'compositions':
len(projects) > 0 or len(assignments) > 0,
'is_faculty':
is_faculty,
}
if record_owner:
data['space_owner'] = {
'username': record_owner.username,
'public_name': get_public_name(record_owner, request)
}
json_stream = simplejson.dumps(data, indent=2)
return HttpResponse(json_stream, mimetype='application/json')
def get_records(request, record_owner, assets):
course = request.course
logged_in_user = request.user
# Can the record_owner edit the records
viewing_own_work = (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 = ('citable' in request.GET and
request.GET.get('citable') == 'true')
# Is the current user faculty OR staff
is_faculty = course.is_faculty(logged_in_user)
# Does the course allow viewing other user selections?
owner_selections_are_visible = (
course_details.all_selections_are_visible(course) or
viewing_own_work or viewing_faculty_records or is_faculty)
# Filter the assets
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [asset for asset in assets
if filter_by[fil](asset, filter_value, record_owner)]
active_filters = get_active_filters(request, filter_by)
# Spew out json for the assets
asset_json = []
options = {
'owner_selections_are_visible': ('annotations' in request.GET and
owner_selections_are_visible),
'all_selections_are_visible':
course_details.all_selections_are_visible(course) or is_faculty,
'can_edit': viewing_own_work,
'citable': citable
}
for asset in assets:
asset_json.append(gallery_asset_json(request, asset, logged_in_user,
record_owner, options))
# Tags
tags = []
if record_owner:
if owner_selections_are_visible:
# Tags for selected user
tags = Tag.objects.usage_for_queryset(
record_owner.sherdnote_set.filter(asset__course=course),
counts=True)
else:
if owner_selections_are_visible:
# Tags for the whole class
tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(asset__course=course),
counts=True)
else:
# Tags for myself and faculty members
tags = Tag.objects.usage_for_queryset(
logged_in_user.sherdnote_set.filter(asset__course=course),
counts=True)
for f in course.faculty:
tags.extend(Tag.objects.usage_for_queryset(
f.sherdnote_set.filter(asset__course=course),
counts=True))
tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
user_resource = UserResource()
owners = user_resource.render_list(request, request.course.members)
# Assemble the context
data = {'assets': asset_json,
'tags': [{'name': tag.name} for tag in tags],
'active_filters': active_filters,
'space_viewer': user_resource.render_one(request, logged_in_user),
'editable': viewing_own_work,
'citable': citable,
'owners': owners,
'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 get_records(user, course, request):
c = course
today = datetime.date.today()
editable = (user == request.user)
#bad language, we should change this to user_of_assets or something
space_viewer = request.user
if request.GET.has_key('as') and request.user.is_staff:
space_viewer = get_object_or_404(User, username=request.GET['as'])
assignments = []
responder = None
if user == 'all':
archives = list(course.asset_set.archives())
assets = [
a for a in Asset.objects.filter(course=c).extra(
select={
'lower_title': 'lower(assetmgr_asset.title)'
}).select_related().order_by('lower_title')
if a not in archives
]
user = None
all_tags = Tag.objects.usage_for_queryset(
SherdNote.objects.filter(asset__course=course), counts=True)
all_tags.sort(lambda a, b: cmp(a.name.lower(), b.name.lower()))
tags = calculate_cloud(all_tags)
projects = [
p for p in Project.objects.filter(course=c,
submitted=True).order_by('title')
if p.visible(request)
]
else:
assets = annotated_by(Asset.objects.filter(course=c),
user,
include_archives=c.is_faculty(user))
tags = calculate_cloud(
Tag.objects.usage_for_queryset(
user.sherdnote_set.filter(asset__course=c), counts=True))
projects = Project.get_user_projects(user, c).order_by('-modified')
if not editable:
projects = [p for p in projects if p.visible(request)]
project_type = ContentType.objects.get_for_model(Project)
assignments = []
maybe_assignments = Project.objects.filter(c.faculty_filter)
for assignment in maybe_assignments:
if not assignment.visible(request):
continue
if assignment in projects:
continue
if is_unanswered_assignment(assignment, user, request,
project_type):
assignments.append(assignment)
if user.id == space_viewer.id:
responder = space_viewer.username
for fil in filter_by:
filter_value = request.GET.get(fil)
if filter_value:
assets = [
asset for asset in assets
if filter_by[fil](asset, filter_value, user)
]
active_filters = get_active_filters(request, filter_by)
if request.is_ajax():
asset_json = []
for asset in assets:
the_json = asset.sherd_json(request)
gannotation, created = SherdNote.objects.global_annotation(
asset, user or space_viewer, auto_create=False)
if gannotation:
the_json['global_annotation'] = gannotation.sherd_json(
request, 'x', ('tags', 'body'))
the_json['editable'] = editable
annotations = []
if request.GET.has_key('annotations'):
# @todo: refactor this serialization into a common place.
def author_name(request, annotation, key):
if not annotation.author_id:
return None
return 'author_name', get_public_name(
annotation.author, request)
for ann in asset.sherdnote_set.filter(range1__isnull=False,
author=user):
annotations.append(
ann.sherd_json(request, 'x',
('title', 'author', 'tags', author_name,
'body', 'modified', 'timecode')))
the_json['annotations'] = annotations
asset_json.append(the_json)
project_json = []
for p in projects:
the_json = {}
the_json['id'] = p.id
the_json['title'] = p.title
the_json['url'] = p.get_absolute_url()
participants = p.attribution_list()
the_json['authors'] = [{
'name': get_public_name(u, request)
} for u in participants]
the_json['modified'] = p.modified.strftime("%m/%d/%y %I:%M %p")
the_json['status'] = p.status()
the_json['editable'] = editable
feedback = p.feedback_discussion()
if feedback:
the_json['feedback'] = feedback.id
collaboration = p.collaboration()
if collaboration:
collaboration_parent = collaboration.get_parent()
if collaboration_parent:
the_json['collaboration'] = {}
the_json['collaboration'][
'title'] = collaboration_parent.title
if collaboration_parent.content_object:
the_json['collaboration'][
'url'] = collaboration_parent.content_object.get_absolute_url(
)
project_json.append(the_json)
data = {
'assets':
asset_json,
'assignments': [{
'id':
a.id,
'responder':
responder,
'url':
a.get_absolute_url(),
'title':
a.title,
'modified':
a.modified.strftime("%m/%d/%y %I:%M %p")
} for a in assignments],
'projects':
project_json,
'tags': [{
'name': tag.name
} for tag in tags],
'active_filters':
active_filters,
'space_viewer': {
'username': space_viewer.username,
'public_name': get_public_name(space_viewer, request),
'can_manage': (space_viewer.is_staff and not user)
},
'editable':
editable,
'owners': [{
'username': m.username,
'public_name': get_public_name(m, request)
} for m in request.course.members],
'compositions':
len(projects) > 0 or len(assignments) > 0,
'is_faculty':
c.is_faculty(space_viewer),
}
if user:
data['space_owner'] = {
'username': user.username,
'public_name': get_public_name(user, request)
}
json_stream = simplejson.dumps(data, indent=2)
return HttpResponse(json_stream, mimetype='application/json')
else:
dates = (
('today', 'today'),
('yesterday', 'yesterday'),
('lastweek', 'within the last week'),
)
return {
'assets': assets,
'assignments': assignments,
'projects': projects,
'tags': tags,
'dates': dates,
'space_owner': user,
'space_viewer': space_viewer,
'editable': editable,
'active_filters': active_filters,
}
