api.py file

gistfile1.py

from django.contrib.auth.models import User
from django.shortcuts import render_to_response
from django.utils.encoding import force_unicode
from tastypie.resources import ModelResource,ALL
from tastypie import fields
from tastypie.serializers import Serializer
import pickle
#we deal with stuff related with content
from masomo.models import Content,Subject,Topic,Chapter,Page
#we now deal with stuff related with setup and devices
from masomo.models import Device,School
from lxml.etree import parse as parse_xml
from lxml.etree import Element, tostring

from tastypie.bundle import Bundle


def get_type_string(data):
    """
    Translates a Python data type into a string format.
    """
    data_type = type(data)

    if data_type in (int, long):
        return 'integer'
    elif data_type == float:
        return 'float'
    elif data_type == bool:
        return 'boolean'
    elif data_type in (list, tuple):
        return 'list'
    elif data_type == dict:
        return 'hash'
    elif data is None:
        return 'null'
    elif isinstance(data, basestring):
        return 'string'

class UserResource(ModelResource):
    class Meta:
        queryset = User.objects.all()
        resource_name = 'user'
        excludes = ['email', 'password', 'is_active', 'is_staff', 'is_superuser']
        filtering = {
            #'username': ALL,
        }

class SchoolResource(ModelResource):
    #entry = fields.ToOneField(EntryResource, 'subject')
    user = fields.ForeignKey(UserResource,'user',full=True)
    class Meta:
        queryset = School.objects.all()
        excludes = ['id']
        include_resource_uri = False
        resource_name = 'school'


class DeviceResource(ModelResource):
    school = fields.ToOneField(SchoolResource,'school',full=True)
    class Meta:
        queryset = Device.objects.all()
        excludes = ['id']
        include_resource_uri = False
        resource_name = 'device'
        filtering = {
        'apikey' : ['exact'],
         }

    def alter_list_data_to_serialize(self, request, data_dict):
        if isinstance(data_dict, dict):
            if 'meta' in data_dict:
                # Get rid of the "meta".
                del(data_dict['meta'])
                # Rename the objects.
                data_dict['devices'] = data_dict['objects']
                del(data_dict['objects'])
        #return data_dict
        return render_to_response('device_list.html', {'data_dict': data_dict}, content_type="application/xhtml+xml")

class CustomSerializer(Serializer):
    def to_etree(self, data, options=None, name=None, depth=0):
        """
        Given some data, converts that data to an ``etree.Element`` suitable
        for use in the XML output.
        """
        if isinstance(data, (list, tuple)):
            element = Element('subjects')
            for item in data:
                element.append(self.to_etree(item, options, depth=depth+1))
        elif isinstance(data, dict):
            if depth == 0:
                element = Element(name or 'content')
                #if these guys insist on elimu content i know where to add it but kazi ni mob
                #element2 = Element('elimu')
                #element.append(element2)
                
            else:
                element = Element(name or 'subject')
                element.set('type', 'hash')
            for (key, value) in data.iteritems():
                element.append(self.to_etree(value, options, name=key, depth=depth+1))
        elif isinstance(data, Bundle):
            element = Element(name or 'subject')
            for field_name, field_object in data.data.items():
                element.append(self.to_etree(field_object, options, name=field_name, depth=depth+1))
        elif hasattr(data, 'dehydrated_type'):
            if getattr(data, 'dehydrated_type', None) == 'related' and data.is_m2m == False:
                if data.full:
                    return self.to_etree(data.fk_resource, options, name, depth+1)
                else:
                    return self.to_etree(data.value, options, name, depth+1)
            elif getattr(data, 'dehydrated_type', None) == 'related' and data.is_m2m == True:
                if data.full:
                    #will break many to many fiels should i ever incluce them
                    element = Element(name or 'subjects')
                    for bundle in data.m2m_bundles:
                        element.append(self.to_etree(bundle, options, bundle.resource_name, depth+1))
                else:
                    element = Element(name or 'subjects')
                    for value in data.value:
                        element.append(self.to_etree(value, options, name, depth=depth+1))
            else:
                #will break any m2m fiels should i ever include them
                return self.to_etree(data.value, options, name)
        else:
            element = Element(name or 'value')
            simple_data = self.to_simple(data, options)
            data_type = get_type_string(simple_data)
            if data_type != 'string':
                element.set('type', get_type_string(simple_data))
            if data_type != 'null':
                element.text = force_unicode(simple_data)
        return element

    def from_etree(self, data):
        """
        Not the smartest deserializer on the planet. At the request level,
        it first tries to output the deserialized subelement called "object"
        or "objects" and falls back to deserializing based on hinted types in
        the XML element attribute "type".
        """
        if data.tag == 'request':
            # if "object" or "objects" exists, return deserialized forms.
            elements = data.getchildren()
            for element in elements:
                if element.tag in ('subject', 'subjects'):
                    return self.from_etree(element)
            return dict((element.tag, self.from_etree(element)) for element in elements)
        elif data.tag == 'subject' or data.get('type') == 'hash':
            return dict((element.tag, self.from_etree(element)) for element in data.getchildren())
        elif data.tag == 'subjects' or data.get('type') == 'list':
            return [self.from_etree(element) for element in data.getchildren()]
        else:
            type_string = data.get('type')
            if type_string in ('string', None):
                return data.text
            elif type_string == 'integer':
                return int(data.text)
            elif type_string == 'float':
                return float(data.text)
            elif type_string == 'boolean':
                if data.text == 'True':
                    return True
                else:
                    return False
            else:
                return None



class SubjectResource(ModelResource):
    class Meta:
        queryset = Subject.objects.all()
        excludes = ['id']
        include_resource_uri = False
        resource_name = 'subject'
        #serializer = CustomSerializer()
    #def alter_list_data_to_serialize(self, request, data_dict):
     #  if isinstance(data_dict, dict):
      #      if 'meta' in data_dict:
      #          # Get rid of the "meta".
       #         del(data_dict['meta'])
                # Rename the objects.
        #        data_dict['subjects'] = data_dict['objects']
         #       del(data_dict['objects'])
        #return data_dict

class ChapterResource(ModelResource):
    subject = fields.ToOneField('masomo.api.SubjectResource', 'subject', full=True)
    class Meta:
        queryset = Chapter.objects.all()
        resource_name = 'chapter'


class TopicResource(ModelResource):
    chapter = fields.ForeignKey(ChapterResource,'chapter',full=True)
    class Meta:
        queryset = Topic.objects.all()
        resource_name = 'topic'

class PageResource(ModelResource):
    topic = fields.ToOneField(TopicResource,'topic',full=True)
    class Meta:
        queryset = Page.objects.all()
        resource_name = 'page'
        #serializer = CustomSerializer()

class EntryResource(ModelResource):
    #subject = fields.ToManyField('masomo.api.SubjectResource', 'subject', full=True)
    #chapter = fields.ForeignKey(ChapterResource,'chapter',full=True)
    #topic = fields.ToOneField(TopicResource,'topic',full=True)
    page = fields.ToOneField(PageResource,'page',full=True)
    class Meta:
        queryset = Content.objects.all()
        excludes = ['id']
        include_resource_uri = False
        resource_name = 'content'
        serializer= CustomSerializer();