source: enpraxis.educommons/branches/educommons-imsintegration/enpraxis/educommons/utilities/eduimsccreader.py @ 171

from zope.interface import implements
from collective.imstransport.utilities.interfaces import IIMSManifestReader
from zope.component import getUtility
from collective.imstransport.utilities.interfaces import IIMSObjectCreator
from collective.imstransport.utilities.imscc.imsccreader import IMSCCReader
from collective.imstransport.utilities.imscc.ccresourcereader import CCResourceReader
from collective.imstransport.utilities.imscc.ccreader import CCReader
from collective.imstransport.utilities.packagingio import ZipfileReader
import re


class eduCCResourceReader(CCResourceReader):
    """ Customize read custom data method in ResourceReader object """

    def readCustomMetadata(self, node):
        """ Read custom metadata """
        
        ec_namespace = 'http://cosl.usu.edu/xsd/eduCommonsv1.2'
        metadata = {}
        reader = self.reader

        objectType_nodes = node.getElementsByTagNameNS(ec_namespace,'objectType')
        if objectType_nodes:
            ot = reader.getTextValue(objectType_nodes[0])
            if ot:
                if ot not in ['Course', 'FSSFile', 'Document', 'File', 'Image', 'Link']:
                    raise ManifestError, '"%s" is not a recognized object type.' %ot
                metadata['type'] = '%s' %ot

        copyright_nodes = node.getElementsByTagNameNS(ec_namespace, 'copyright')
        if copyright_nodes:
            cn = reader.getTextValue(copyright_nodes[0])
            if cn:
                metadata['rights'] = cn

        license_nodes = node.getElementsByTagNameNS(ec_namespace, 'license')
        if license_nodes:
            license_node = license_nodes[0]
            license = [str(license_node.getAttribute('category'))]
            licenseName_nodes = license_node.getElementsByTagNameNS(ec_namespace, 'licenseName')
            if licenseName_nodes:
                license.append(str(reader.getTextValue(licenseName_nodes[0])))
            else:
                license.append('None')
            licenseUrl_nodes = license_node.getElementsByTagNameNS(ec_namespace, 'licenseUrl')
            if licenseUrl_nodes:
                license.append(str(reader.getTextValue(licenseUrl_nodes[0])))
            else:
                license.append('None')
            licenseIconUrl_nodes = license_node.getElementsByTagNameNS(ec_namespace, 'licenseIconUrl')
            if licenseIconUrl_nodes:
                license.append(str(reader.getTextValue(licenseIconUrl_nodes[0])))
            else:
                license.append('None')
            metadata['license'] = license

        clearedCopyright_nodes = node.getElementsByTagNameNS(ec_namespace, 'clearedCopyright')
        if clearedCopyright_nodes:
            cc = reader.getTextValue(clearedCopyright_nodes[0])
            if 'true' == cc:
                metadata['clearedCopyright'] = True
            else:
                metadata['clearedCopyright'] = False

        accessibility_nodes = node.getElementsByTagNameNS(ec_namespace, 'accessible')
        if accessibility_nodes:
            access = reader.getTextValue(accessibility_nodes[0])
            if 'true' == access:
                metadata['accessible'] = True
            else:
                metadata['accessible'] = False

        courseId_nodes = node.getElementsByTagNameNS(ec_namespace, 'courseId')
        if courseId_nodes:
            cin = reader.getTextValue(courseId_nodes[0])
            if cin:
                metadata['courseId'] = cin
                
        term_nodes = node.getElementsByTagNameNS(ec_namespace, 'term')
        if term_nodes:
            tm = reader.getTextValue(term_nodes[0])
            if tm:
                metadata['term'] = tm
                
        displayInsEmail_nodes = node.getElementsByTagNameNS(ec_namespace, 'displayInstEmail')
        if displayInsEmail_nodes:
            die = reader.getTextValue(displayInsEmail_nodes[0])
            if 'true' == die:
                metadata['displayInstEmail'] = True
            else:
                metadata['displayInstEmail'] = False

        instrIsPrincipal_nodes = node.getElementsByTagNameNS(ec_namespace, 'instructorAsCreator')
        if instrIsPrincipal_nodes:
            iis = reader.getTextValue(instrIsPrincipal_nodes[0])
            if 'true' == iis:
                metadata['instructorAsCreator'] = True
            else:
                metadata['instructorAsCreator'] = False

        excludeFromNav_nodes = node.getElementsByTagNameNS(ec_namespace,'excludeFromNav')
        if excludeFromNav_nodes:
            efn = reader.getTextValue(excludeFromNav_nodes[0])
            if 'true' == efn:
                metadata['excludeFromNav'] = True
            else:
                metadata['excludeFromNav'] = False
        
        homePagePath_nodes = node.getElementsByTagNameNS(ec_namespace,'homePagePath')
        if homePagePath_nodes:
            metadata['homePagePath'] = reader.getTextValue(homePagePath_nodes[0])

        return metadata


class eduIMSCCReader(IMSCCReader):
    """ Create objects from IMS manifest. """
    implements(IIMSManifestReader)

    def readPackage(self, context, input):
        """ Read the manifest """

        source = ZipfileReader(input)
        objDict = {}

        if not source:
             return False, 'Internal error. No source object specified'

        ccreader = CCReader(context, source)
             
        manifest = source.readManifest()
        if not manifest:
            return False, \
                   'Manifest', \
                   'Could not locate manifest file "imsmanifest.xml" in the zip archive.'

        ccreader.parseManifest(manifest)
        orgdata = ccreader.readOrganizations()
        resourceids = ccreader.readResources()

        for resourceid in resourceids:
            ccresourcereader = eduCCResourceReader(ccreader, resourceid, {})            
            resdata = self.parseResourceMetadata(ccresourcereader, resourceid, context)
            reshref = ccresourcereader.getHref()
            files = ccresourcereader.readFiles()

            hashref = ''
            if files:
                for file in files:
                    hashref = '%s%s' %(resourceid, file)
                    id = self.createIdFromFile(file)
                    path = self.createPathFromFile(file)

                    if reshref == file or len(files) == 1:
                        hashref = resourceid
                        objDict[hashref] = resdata
                        
                        if hashref in [org for org in orgdata if org]:
                            objDict[hashref]['excludeFromNav'] = False

                    self.parseFile(context, file, objDict, hashref, id, path)

        objcreator = getUtility(IIMSObjectCreator)
        objcreator.createObjects(objDict, context, source)
        return


    def parseResourceMetadata(self, resourcereader, resourceid, context):
        """ Read the resource metadata """
            
        resourcereader.readGeneral()
        resourcereader.readLifecycle()
        resourcereader.readMetaMetadata()
        resourcereader.readTechnical()
        resourcereader.readRights()
        customnode = resourcereader.getCustomData('eduCommons', 'http://cosl.usu.edu/xsd/eduCommonsv1.2')
        if customnode:
            metadict = resourcereader.readCustomMetadata(customnode)
            resourcereader.appendCustomData(metadict)
        return resourcereader.processResourceMetadata()