def create_unit(request):
title = request.POST.get('title', None)
textbook_id = request.POST.get('textbook_id', None)
curriculum_id = request.POST.get('curriculum_id', None)
# Period properties.
period_type = request.POST.get('type', None)
unit = request.POST.get('unit', None)
begin = request.POST.get('begin', None)
end = request.POST.get('end', None)
period_from = request.POST.get('from', None)
period_to = request.POST.get('to', None)
position = request.POST.get('position', None)
parent = request.POST.get('parent', None)
if begin:
period = {
'type': period_type,
'unit': unit,
'begin': int(begin),
'end': int(end),
'from': period_from,
'to': period_to
}
else:
period = {
'type': period_type,
'unit': unit,
'position': int(position),
'parent': int(parent)
}
try:
curriculum = Curriculum.objects.get(pk=curriculum_id)
except:
return APIUtilities._api_not_found()
if textbook_id:
try:
textbook = Textbook.objects.get(pk=textbook_id)
except:
return APIUtilities._api_not_found()
else:
textbook = None
new_unit = Unit(title=title, period=period)
new_unit.save()
if textbook:
textbook.units.add(new_unit)
curriculum.units.add(new_unit)
context = {
'id': new_unit.id
}
return APIUtilities.success(context)
def add_url_to_section_item_resources(request):
section_item_resources_id = request.POST.get('section_item_resources_id', None)
try:
section_item_resources = SectionItemResources.objects.get(pk=section_item_resources_id)
except:
section_item_resources = create_resource_set(request, section_item_resources)
if not section_item_resources:
return APIUtilities._api_not_found()
from oer.views import new_url_from_form
new_resource = new_url_from_form(
request.user, request.POST.get('title', None),
request.POST.get('url', None))
new_objective_resource = Resource(resource=new_resource)
new_objective_resource.save()
section_item_resources.resources.add(new_objective_resource)
context = {
'resource': {
'id': new_objective_resource.id,
'url': new_resource.revision.content.url,
'title': new_resource.title,
'thumbnail': settings.MEDIA_URL + new_resource.image.name if new_resource.image else '',
}
}
return APIUtilities.success(context)
def asynchronous_view(request, resource_id):
from oer.views import render_resource
try:
resource = Resource.objects.get(pk=resource_id)
except:
return APIUtilities._api_not_found()
(resource, resource_type, revision) = render_resource(resource.resource.id)
from django.template import Template, Context
template = Template(open(
settings.TEMPLATE_DIR + '/templates/partials/resource-body.html', 'r').read())
context = Context({
'MEDIA_URL': settings.MEDIA_URL,
'STATIC_URL': settings.STATIC_URL,
'debug': settings.DEBUG,
'resource': resource
})
template_html = template.render(context)
from django.http import HttpResponse
return HttpResponse(
template_html, 200,
content_type="text/html"
)
def get_standard(request, standard_id):
try:
standard = StandardCategory.objects.get(pk=standard_id)
except:
return APIUtilities._api_not_found()
return APIUtilities.success(get_serialized_sections(standard))
def get_sections(request, unit_id):
try:
unit = Unit.objects.get(pk=unit_id)
except:
return APIUtilities._api_not_found()
return APIUtilities.success(get_serialized_sections(unit))
def create_section(request):
parent_id = request.POST.get('parent_id', None)
is_unit = request.POST.get('is_unit', None)
title = request.POST.get('title', None)
section_type = request.POST.get('section_type', None)
position = request.POST.get('position', None)
settings = {
'type': section_type
}
try:
if is_unit:
parent = Unit.objects.get(pk=parent_id)
else:
parent = StandardCategory.objects.get(pk=parent_id)
except:
return APIUtilities._api_not_found()
new_section = Section(position=position, title=title, settings=settings)
new_section.save()
parent.sections.add(new_section)
context = {
'id': new_section.id
}
return APIUtilities.success(context)
def delete_comment(request, comment_id):
try:
comment = Comment.objects.get(pk=comment_id)
# TODO(Varun): Same logic as duplicated from template generation to show
# delete button
from interactions.CommentUtilities import CommentUtilities
(host_type, host, root) = CommentUtilities.get_comment_root(comment)
if host_type.name == 'project':
if request.user == comment.user or request.user in host.admins.all():
# Delete all descendant elements of this comment.
delete_comment_tree(comment)
return APIUtilities._api_success()
else:
return APIUtilities._api_unauthorized_failure()
elif host_type.name == 'resource':
if request.user == comment.user or (
request.user in host.collaborators.all() or
request.user == host.creator):
delete_comment_tree(comment)
return APIUtilities._api_success()
return APIUtilities._api_failure()
except Comment.DoesNotExist:
return APIUtilities._api_not_found()
def link_objective_to_standard(request):
objective_id = request.POST.get('objective_id', None)
standard_id = request.POST.get('standard_id', None)
remove_objective_id = request.POST.get('remove_objective_id', None)
standards_categories = TagCategory.objects.filter(title__in=['Standards', 'Objectives'])
try:
from curriculum.models import Objective
objective = Objective.objects.get(pk=objective_id)
previous_objective = Objective.objects.get(pk=remove_objective_id)
standard = Tag.objects.get(pk=standard_id, category__in=standards_categories)
except:
return APIUtilities._api_not_found()
if objective.parent:
return APIUtilities.failure({
'standard_id': objective.parent.id,
'standard_title': objective.parent.title
})
else:
previous_objective.parent = None
previous_objective.save()
objective.parent = standard
objective.save()
objective.parent = standard
objective.save()
return APIUtilities.success()
def get_resource_vote_count(request, resource_id):
try:
from oer.models import Resource
resource = Resource.objects.get(pk=resource_id)
except:
return APIUtilities._api_not_found()
try:
from django.contrib.contenttypes.models import ContentType
resource_ct = ContentType.objects.get_for_model(Resource)
upvotes = Vote.objects.filter(
parent_id=resource.id, parent_type=resource_ct, positive=1)
downvotes = Vote.objects.filter(
parent_id=resource.id, parent_type=resource_ct, positive=0)
user_upvoted = False
user_downvoted = False
if (request.user.is_authenticated()):
if upvotes.filter(user=request.user).count() > 0:
user_upvoted = True
if downvotes.filter(user=request.user).count() > 0:
user_downvoted = True
context = {
'upvote_count': upvotes.count(),
'downvote_count': downvotes.count(),
'user_upvoted': 'true' if user_upvoted else 'false',
'user_downvoted': 'true' if user_downvoted else 'false'
}
return APIUtilities._api_success(context)
except:
return APIUtilities._api_failure()
def create_mapping(request):
from_id = request.POST.get('from', None)
to_id = request.POST.get('to', None)
standards_category = TagCategory.objects.get(title='Standards')
try:
from_node = Tag.objects.get(pk=from_id, category=standards_category)
to_node = Tag.objects.get(pk=to_id, category=standards_category)
except:
return APIUtilities._api_not_found()
from meta.models import TagMapping
mapping = TagMapping(from_node=from_node, to_node=to_node)
mapping.save()
serialize_mapping = {
'id': mapping.id,
'from_id': from_node.id,
'from_title': from_node.title,
'to_id': to_node.id,
'to_title': to_node.title,
}
return APIUtilities.success(serialize_mapping)
def get_mappings(request, standard_id):
from meta.models import TagMapping
standards_category = TagCategory.objects.get(title='Standards')
try:
standard = Tag.objects.get(pk=standard_id, category=standards_category)
except:
return APIUtilities._api_not_found()
tag_mappings = TagMapping.objects.filter(from_node=standard)
serialized_tag_mappings = []
for tag_mapping in tag_mappings:
serialized_tag_mappings.append({
'id': tag_mapping.id,
'standard': tag_mapping.to_node.id,
'standardTitle': tag_mapping.to_node.title,
'notes': tag_mapping.deviation,
})
context = {
'mappings': serialized_tag_mappings
}
return APIUtilities.success(context)
def favorite(request, resource_id):
try:
resource = Resource.objects.get(pk=resource_id)
except:
return APIUtilities._api_not_found()
from interactions.views import favorite_resource
return favorite_resource(request, 'resource', resource.resource.id)
def update_item(request):
item_id = request.POST.get('id', None)
description = request.POST.get('description', None)
try:
item = SectionItem.objects.get(pk=item_id)
except:
return APIUtilities._api_not_found()
try:
if description:
item.description = description
item.save()
context = { 'item': {
'id': item.id,
'description': item.description
}}
else:
new_metas = []
import re
for post_key, post_value in request.POST.items():
if 'meta' in post_key:
# Loop through the json objects.
match = re.match('meta\[(?P<num>\d+)\]\[(?P<key>.+)\]', post_key)
try:
new_metas[int(match.group('num'))][match.group('key')] = post_value
except:
new_metas.append({match.group('key'): post_value})
for new_meta in new_metas:
# If the meta object exists, update it.
try:
next(meta_item for meta_item in item.meta if meta_item['slug'] == new_meta['slug'])['body'] = new_meta['body']
except:
# If not, create it.
if not item.meta:
item.meta = []
item.meta.append({
'slug': new_meta['slug'],
'body': new_meta['body'],
'title': new_meta['title'],
'position': new_meta['position']
})
item.save()
context = {
'id': item.id,
'meta': item.meta
}
return APIUtilities.success(context)
except:
return APIUtilities._api_failure()
def get_curriculum(request, curriculum_id):
try:
curriculum = Curriculum.objects.get(pk=curriculum_id)
except:
return APIUtilities._api_not_found()
def get_serialized_standard_children(standard):
sub_standards = []
for sub_standard in standard.standard_categories.all():
sub_standards.append(
get_serialized_standard_children(sub_standard))
return {
'id': standard.id,
'title': standard.title,
'standards': sub_standards
}
serialized_textbooks = []
serialized_units = []
serialized_standards = []
for textbook in curriculum.textbooks.all():
serialized_textbook_units = []
for unit in curriculum.units.all():
if unit in textbook.units.all():
serialized_textbook_units.append({
'id': unit.id,
'textbook_id': textbook.id
})
serialized_textbooks.append({
'id': textbook.id,
'title': textbook.title,
'description': textbook.description,
'thumbnail': settings.MEDIA_URL + textbook.thumbnail.name,
'units': serialized_textbook_units
})
for unit in curriculum.units.all():
serialized_units.append({
'id': unit.id,
'title': unit.title,
'period': unit.period
})
for standard_category in curriculum.standard_categories.all():
serialized_standards.append(
get_serialized_standard_children(standard_category))
return APIUtilities.success({
'textbooks': serialized_textbooks,
'units': serialized_units,
'standards': serialized_standards
})
def delete_event(request, event_id):
try:
event = Event.objects.get(pk=event_id)
except:
return APIUtilities._api_not_found()
if request.user != event.user:
return APIUtilities._api_unauthorized_failure()
event.delete()
return APIUtilities.success()
def delete_curriculum(request, curriculum_id):
try:
curriculum = Curriculum.objects.get(pk=curriculum_id)
except:
return APIUtilities._api_not_found()
if request.user != curriculum.user:
return APIUtilities._api_unauthorized_failure()
delete_individual_curriculum(curriculum)
return APIUtilities.success()
def delete_item(request, section_item_id):
try:
item = SectionItem.objects.get(pk=section_item_id)
except:
return APIUtilities._api_not_found()
if not request.user:
return APIUtilities._api_unauthorized_failure()
delete_individual_item(item)
return APIUtilities.success()
def suggest_resources(request, section_item_id):
try:
section_item = SectionItem.objects.get(pk=section_item_id)
except:
return APIUtilities._api_not_found()
if section_item.content:
if not section_item.content.parent:
context = {
'message': 'To suggest resources, the objective needs to be linked ' +
'a standard.'
}
return APIUtilities._api_failure(context)
else:
context = {
'message': 'To suggest resources, this item needs to be an objective.'
}
return APIUtilities._api_failure(context)
from meta.models import TagMapping
mappings = TagMapping.objects.filter(from_node=section_item.content.parent)
from oer.models import Resource as OEResource
#resources = OEResource.objects.none()
tags = []
for mapping in mappings:
tags.append(mapping.to_node)
resources = OEResource.objects.filter(tags__in=tags)
serialized_resources = {}
for resource in resources:
serialized_resources[resource.id] = {
'id': resource.id,
'url': reverse(
'read', kwargs={
'resource_id': resource.id,
'resource_slug': resource.slug
}
),
'title': resource.title,
'user': resource.user.get_full_name(),
'user_url': reverse('user:user_profile', kwargs={
'username': resource.user.username }),
'description': resource.description,
'thumbnail': settings.MEDIA_URL + resource.image.name,
}
context = {
'resources': serialized_resources
}
return APIUtilities.success(context)
def delete_mapping(request):
mapping_id = request.POST.get('id', None)
try:
from meta.models import TagMapping
mapping = TagMapping.objects.get(pk=mapping_id)
except:
return APIUtilities._api_not_found()
mapping.delete()
return APIUtilities.success()
def get_reference(request, resource_id):
try:
resource = Resource.objects.get(pk=resource_id)
except:
return APIUtilities._api_not_found()
reference = resource.resource.revision.content
context = dict({
'textbook_title': reference.textbook.title,
'thumbnail': settings.MEDIA_URL + reference.textbook.thumbnail.name,
}.items() + reference.scope.items())
return APIUtilities.success(context)
def delete_item_meta(request, section_item_id, position):
try:
item = SectionItem.objects.get(pk=section_item_id)
except:
return APIUtilities._api_not_found()
meta = item.meta
del meta[int(position)]
item.meta = meta
item.save()
return APIUtilities.success()
def remove_item_from_event(request):
section_item_id = request.POST.get('item_id')
event_id = request.POST.get('event_id')
try:
from curriculum.models import SectionItem
section_item = SectionItem.objects.get(pk=section_item_id)
event = Event.objects.get(pk=event_id)
except:
return APIUtilities._api_not_found()
event.items.remove(section_item)
return APIUtilities.success()
def delete_section(request, section_id):
try:
section = Section.objects.get(pk=section_id)
except:
return APIUtilities._api_not_found()
if not request.user:
return APIUtilities._api_unauthorized_failure()
for item in section.items.all():
delete_individual_item(item)
section.delete()
return APIUtilities.success()
def delete_section_item_resources(request, section_item_resources_id):
try:
section_item_resources = SectionItemResources.objects.get(pk=section_item_resources_id)
except:
return APIUtilities._api_not_found()
for resource in section_item_resources.resources.all():
resource.delete()
sections_with_resources = SectionItem.objects.get(resource_sets=section_item_resources)
sections_with_resources.resource_sets.remove(section_item_resources)
section_item_resources.delete()
return APIUtilities.success()
def delete_class(request, class_id):
try:
class_to_delete = Class.objects.get(pk=class_id)
except:
return APIUtilities._api_not_found()
if request.user != class_to_delete.user:
return APIUtilities._api_unauthorized_failure()
# Deep delete all events with this class link.
events = Event.objects.filter(class_link=class_to_delete)
for event in events:
event.delete()
class_to_delete.delete()
return APIUtilities.success()
def add_item_to_section(request):
section_id = request.POST.get('id', None)
item_id = request.POST.get('item_id', None)
try:
section = Section.objects.get(pk=section_id)
item = SectionItem.objects.get(pk=item_id)
except:
return APIUtilities._api_not_found()
try:
section.items.add(item)
return APIUtilities.success()
except:
return APIUtilities._api_failure()
def list_user_favorites(request):
try:
from django.contrib.auth.models import User
user = User.objects.get(username=request.user.username)
except:
return APIUtilities._api_not_found()
# Get user favorites.
user_favorites = Favorite.objects.filter(user=user)
from django.core.urlresolvers import reverse
serialized_favorites = list()
for favorite in user_favorites:
if favorite.parent_type.name == 'resource':
url = reverse(
'read', kwargs={
'resource_id': favorite.parent.id,
'resource_slug': favorite.parent.slug
})
thumbnail = 'http://' + request.get_host(
) + settings.MEDIA_URL + favorite.parent.image.name
else:
url = reverse(
'user:user_folder', kwargs={
'username': favorite.parent.creator.username,
'collection_slug': favorite.parent.slug
})
thumbnail = 'http://' + request.get_host(
) + settings.STATIC_URL + 'images/folder-icon.png'
serialized_favorites.append({
'id': favorite.parent.id,
'user_url': reverse('user:user_profile', kwargs={
'username': favorite.user.username }),
'url': url,
'title': favorite.parent.title,
'user': favorite.user.get_full_name(),
'username': favorite.user.username,
'views': favorite.parent.views,
'thumbnail': thumbnail
})
context = {
'favorites': serialized_favorites
}
return APIUtilities._api_success(context)
def update_settings(request):
curriculum_id = request.POST.get('curriculum_id', None)
title = request.POST.get('title', None)
grade = request.POST.get('grade', None)
subject = request.POST.get('subject', None)
session = request.POST.get('session', None)
from_datetime = request.POST.get('from', None)
to_datetime = request.POST.get('to', None)
"""duration_relevance = request.POST.get('duration_relevance', None)
standards = request.POST.get('standards', None)"""
sync = request.POST.get('sync', None)
try:
curriculum = Curriculum.objects.get(pk=curriculum_id)
except:
return APIUtilities._api_not_found()
if title:
curriculum.title = title
if subject:
curriculum.subject = subject
if grade:
curriculum.grade = grade
if session or from_datetime or to_datetime or sync:
current_settings = curriculum.settings
if session:
current_settings['periods']['session'] = session
if from_datetime:
current_settings['periods']['start'] = from_datetime
if to_datetime:
current_settings['periods']['end'] = to_datetime
if sync:
current_settings['sync']['on'] = True if sync == 'true' else False
curriculum.settings = current_settings
curriculum.save()
return APIUtilities.success()
def create_item_resources(request):
section_item_id = request.POST.get('id', None)
title = request.POST.get('title', None)
position = request.POST.get('position', None)
try:
section_item = SectionItem.objects.get(pk=section_item_id)
except:
return APIUtilities._api_not_found()
new_section_item_resources = SectionItemResources(
title=title, position=int(position))
new_section_item_resources.save()
section_item.resource_sets.add(new_section_item_resources)
return APIUtilities.success({'id': new_section_item_resources.id})
def event_before(request, event_id):
try:
event = Event.objects.get(pk=event_id)
except:
return APIUtilities._api_not_found()
if event.class_link:
from django.db.models import Max
closest_previous_events = Event.objects.filter(
class_link=event.class_link, end__lt=event.start)
closest_previous_event = closest_previous_events.get(
end=closest_previous_events.aggregate(Max('end'))['end__max'])
return APIUtilities.success(_serialize_event(closest_previous_event))
else:
return APIUtilities.success(None)
