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 events_around(request, around_date):
import datetime
import dateutil.parser
around = dateutil.parser.parse(around_date)
a_month = datetime.timedelta(days=31)
a_month_ago = around - a_month
after_one_month = around + a_month
from django.utils import timezone
now = timezone.now()
if (now > around):
events = Event.objects.filter(user=request.user, start__range=(
a_month_ago, around)).order_by('start')
else:
events = Event.objects.filter(user=request.user, start__range=(
around, after_one_month)).order_by('start')
serialized_events = {}
for event in events:
serialized_event = _serialize_event(event)
date = event.start.strftime('%Y-%m-%d')
if date in serialized_events:
serialized_events[date].append(serialized_event)
else:
serialized_events[date] = [serialized_event]
return APIUtilities.success(serialized_events)
def autocomplete_standard(request, query):
standards = Tag.objects.filter(
title__icontains=query, category=TagCategory.objects.get(title='Standards'))
limit = request.GET.get('limit', None)
result_set = []
def append_standard(standard_id, standard_title):
try:
next(
serialized_standard for serialized_standard in result_set if serialized_standard['id'] == standard_id)
except:
result_set.append({
'id': standard.id,
'title': standard.title,
})
if limit:
for standard in standards[:int(limit)]:
append_standard(standard.id, standard.title)
else:
for standard in standards:
append_standard(standard.id, standard.title)
return APIUtilities.success(result_set)
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 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 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 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 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_daily_events(request, date, now):
from django.core.urlresolvers import reverse
import datetime
end = now + datetime.timedelta(days=1)
events = Event.objects.filter(
user=request.user,
start__gte=now,
end__lte=end,
).order_by('start')
serialized_events = []
for event in events:
serialized_event = {
'id': event.id,
'start': event.start.isoformat(),
'end': event.end.isoformat(),
'date': date,
'title': event.title,
'all_day': event.all_day,
'url': reverse(
'planner:event', kwargs={
'event_id': event.id,
}
)
}
serialized_events.append(serialized_event)
return APIUtilities.success(serialized_events)
def reposition_sections(request):
for section_id, section_position in request.POST.items():
section = Section.objects.get(pk=section_id)
section.position = int(section_position)
section.save()
return APIUtilities.success()
def reposition_items(request):
for item_id, item_position in request.POST.items():
item = SectionItem.objects.get(pk=item_id)
item.position = int(item_position)
item.save()
return APIUtilities.success()
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 push_changes(request, curriculum_id):
import datetime
now = datetime.datetime.now().isoformat()
from curriculum.tasks import push_changes as push_changes_task
push_changes_task.delay(now, curriculum_id)
return APIUtilities.success({'lastPushed': now})
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 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 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)
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 event_after(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 Min
closest_future_events = Event.objects.filter(
class_link=event.class_link, start__gt=event.end)
closest_future_event = closest_future_events.get(
start=closest_future_events.aggregate(Min('start'))['start__min'])
return APIUtilities.success(_serialize_event(closest_future_event))
else:
return APIUtilities.success(None)
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_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_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_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 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_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 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 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 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()
