Changeset 172


Ignore:
Timestamp:
05/11/09 15:37:59 (4 years ago)
Author:
jon
Message:

Adding base test files

Location:
collective.imstransport/trunk/collective/imstransport
Files:
3 added
5 edited

Legend:

Unmodified
Added
Removed

  • collective.imstransport/trunk/collective/imstransport/browser/exportform.py

    r163 r172  
    9292        filename = self.context.REQUEST['form.filename'] 
    9393 
    94         content, fn = self.ims_util.exportPackage(self.context, filename, packagetype='Common Cartridge')         
    95  
     94        content, fn = self.ims_util.exportPackage(self.context, filename, packagetype='IMS Content Package')         
     95          
    9696        if content: 
    9797            container.REQUEST.RESPONSE.setHeader('content-type', 'application/zip') 

  • collective.imstransport/trunk/collective/imstransport/utilities/configure.zcml

    r160 r172  
    2121  <utility 
    2222     provides=".interfaces.IIMSManifestReader" 
    23      factory=".bboard.IMSBBoardReader" 
    24      name="IMS Blackboard" 
     23     factory=".imscp.imscpreader.IMSCPReader" 
     24     name="IMS Content Package" 
    2525     /> 
    2626 
    … …  
    2929     factory=".imscc.imsccwriter.IMSCCWriter" 
    3030     name="Common Cartridge" 
     31     />   
     32 
     33  <utility 
     34     provides=".interfaces.IIMSManifestReader" 
     35     factory=".bb.imsbbreader.IMSBBReader" 
     36     name="Blackboard" 
     37     />   
     38 
     39  <utility 
     40     provides=".interfaces.IIMSManifestReader" 
     41     factory=".mit.imsmitreader.IMSMITReader" 
     42     name="MIT Content Package" 
     43     />   
     44 
     45  <utility 
     46     provides=".interfaces.IIMSManifestWriter" 
     47     factory=".imscp.imscpwriter.IMSCPWriter" 
     48     name="IMS Content Package" 
    3149     /> 
    3250 

  • collective.imstransport/trunk/collective/imstransport/utilities/imscc/ccwriter.py

    r160 r172  
    1 from zope.interface import implements 
    2 from collective.imstransport.utilities.interfaces import IIMSManifestWriter 
    31from xml.dom import minidom 
    42from string import join 
    … …  
    108LOM_version = 'LOMv1.0' 
    119LOM_namespace = 'http://ltsc.ieee.org/xsd/LOM' 
    12  
    13 class IMSCCWriter: 
    14     """ Write an IMS content package manifest file. """ 
    15  
    16     implements(IIMSManifestWriter) 
    17  
    18  
    19     def createPackage(self, context, filename): 
    20         """ Creates an IMS Package """ 
    21  
    22         self.context = context 
    23  
    24         namespaces = [('xmlns', 'http://www.imsglobal.org/xsd/imscc/imscp_v1p1'), 
    25                       ('xmlns:lomimscc','http://ltsc.ieee.org/xsd/imscc/LOM'), 
    26                       ('xmlns:lom','http://ltsc.ieee.org/xsd/LOM'), 
    27                       ('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance'),] 
    28  
    29         schema_locations = [ 
    30             'http://www.imsglobal.org/xsd/imscc/imscp_v1p1 http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/imscp_v1p2_localised.xsd', 
    31             'http://ltsc.ieee.org/xsd/LOM http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/domainProfile_2/lomLoose_localised.xsd', 
    32             'http://ltsc.ieee.org/xsd/imscc/LOM http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/domainProfile_1/lomLoose_localised.xsd',] 
    33          
    34         self.destination = ZipfileWriter(context,filename) 
    35         ccwriter = CCWriter(context) 
    36         ccwriter.writeManifestNode(self._createPathId(context.virtual_url_path(), 'MAN'), 
    37                                    context.ModificationDate(), 
    38                                    namespaces, 
    39                                    schema_locations) 
    40         lang = context.Language() 
    41         if not lang: 
    42             lang = context.portal_properties.site_properties.getProperty('default_language') 
    43         ccwriter.writeLOMCCMetadata(context.getId(), context.Title(), context.portal_url(), IMS_schema, IMS_version, lang, context.Description(), context.Subject()) 
    44  
    45         ccwriter.writeOrganizations() 
    46         ccwriter.writeOrganizationNode(self._createPathId(context.virtual_url_path(), 'ORG')) 
    47         ccwriter.writeShellItem(self._createPathId(context.virtual_url_path(), 'SHL')) 
    48  
    49         ccwriter.writeResources() 
    50  
    51  
    52         objects = self._getAllObjects(context) 
    53  
    54         for object in objects: 
    55             path = self._getObjectPath(object) 
    56             itemId = self._createPathId(object.virtual_url_path(), 'ITM') 
    57             refId = self._createPathId(object.virtual_url_path(), 'RES') 
    58  
    59             if not object.isPrincipiaFolderish or getattr(object, 'getText', None): 
    60                 if not object.getExcludeFromNav(): 
    61                     ccwriter.writeItem(itemId, object.title, refId) 
    62  
    63                 path = self._getObjectPath(object) 
    64                 rlomwriter = ResourceMetadataWriter(ccwriter) 
    65                 rlomwriter.writeResource(refId, 'webcontent', path) 
    66                 rlomwriter.writeLOMMetadata() 
    67                 rlomwriter.writeLOMNode(LOM_namespace) 
    68  
    69                 lang = object.Language() 
    70                 if not lang: 
    71                     lang = context.portal_properties.site_properties.getProperty('default_language') 
    72                 rlomwriter.writeGeneralNode(object.getId(), object.Title(), object.portal_url(), lang, object.Description(), object.Subject()) 
    73  
    74                 rlomwriter.writeLifeCycleNode() 
    75  
    76                 email = object.portal_url.getPortalObject().getProperty('email_from_address') 
    77                 date = object.ModificationDate().replace(' ','T') 
    78                 contributors = object.Contributors() 
    79  
    80                 rlomwriter.writeMetaMetadata(object.id, object.portal_url(), email, date, LOM_version, lang, contributors) 
    81                 rlomwriter.writeTechnical(object.Format(), self.getObjSize(object), object.renderBase()) 
    82                 rights_holder = object.portal_properties.site_properties.getProperty('rights_holder') 
    83                 rights_holder_email = object.portal_properties.site_properties.getProperty('rights_holder_email') 
    84                 rlomwriter.writeRights(LOM_version, 'yes', self._getCopyrightString(object.Rights(), rights_holder, rights_holder_email)) 
    85                 customMetadataString = self.writeCustomMetadata(object, '', '', '') 
    86                 if customMetadataString: 
    87                     rlomwriter.addCustomMetadata(customMetadataString); 
    88  
    89                 rlomwriter.writeFileNode(path) 
    90                  
    91                 self._writeObjectData(object, path) 
    92  
    93         self._writeObjectData(ccwriter.getManifest(), 'imsmanifest.xml') 
    94  
    95         if self.destination: 
    96             return self.destination.getOutput() 
    97         else: 
    98             return None, None 
    99  
    100  
    101     def writeCustomMetadata(self, object, prefix, ns, location): 
    102         """  
    103         Hook for writing custom metadata for additional metatdata requirements.  
    104         Should return standards compliant xml that relates to object passed in. 
    105         """ 
    106  
    107         return '' 
    108   
    109     def _writeObjectData(self, obj, path): 
    110         """ Write file data to the destination object. """ 
    111         if type(obj) == type(''): 
    112             data = obj         
    113         else: 
    114             format = '' 
    115             if hasattr(obj.aq_explicit, 'Format'): 
    116                 format = obj.Format() 
    117             if 'Link' == obj.Type(): 
    118                 doc = minidom.Document() 
    119                 anchor_node = self._createNode(doc, '', 'a', obj.Title()) 
    120                 anchor_node.setAttribute('href', obj.getRemoteUrl()) 
    121                 data = doc.toxml(encoding='utf-8') 
    122             elif obj.Type() in ['File', 'Image']: 
    123                 if hasattr(obj.aq_explicit, 'data'): 
    124                     data = obj.data 
    125             elif 'text/html' == format: 
    126                 if hasattr(obj.aq_explicit, 'getText'): 
    127                     data = obj.getText() 
    128             elif format in ['text/plain', 'text/x-rst', 'text/structured']: 
    129                 if hasattr(obj.aq_explicit, 'getRawText'): 
    130                     data = obj.getRawText() 
    131             else: 
    132                 data = '' 
    133  
    134         if self.destination: 
    135             self.destination.writeFile(path, data) 
    136  
    137     def _getAllObjects(self, context): 
    138         """ Get all sub objects. """ 
    139         return [obj.getObject() for obj in context.portal_catalog.searchResults(path={'query':('/'.join(context.getPhysicalPath())+'/'),'depth':-1})] 
    140  
    141     def _getChildrenObjects(self, parent, objects): 
    142         """ Get objects in current folder """ 
    143         parentpath = '/'.join(parent.getPhysicalPath()) 
    144         children = [] 
    145         for object in objects: 
    146             rpath = '/'.join(object.getPhysicalPath()).replace(parentpath, '') 
    147  
    148             if len(rpath.split('/')) == 1: 
    149                 children.append(object) 
    150                         
    151         return children 
    152  
    153      
    154     def _getObjectPath(self, obj): 
    155         """ Get the path of an object. """ 
    156  
    157         path = obj.virtual_url_path().replace(self.context.aq_inner.aq_parent.virtual_url_path(), '')[1:] 
    158  
    159         if path[-1] == '/': 
    160             path = path[:-1] 
    161  
    162         path_parts = path.split('/') 
    163         if len(path_parts) == 1: 
    164             return '' 
    165         else: 
    166             path = '/'.join(path_parts[1:]) 
    167  
    168         if hasattr(obj.aq_explicit, 'Format'): 
    169             if 'text/html' == obj.Format() and obj.isPrincipiaFolderish: 
    170                 path += '.html' 
    171  
    172         return path 
    173  
    174     def _createPathId(self, path, pre='RES'): 
    175         """ Create a unique id given a path """ 
    176         return pre + str(md5.md5(path).hexdigest()) 
    177  
    178     def _getCopyrightString(self, copyright, rights_holder, rights_holder_email): 
    179         cp = '' 
    180         if copyright: 
    181             cp += copyright 
    182         if rights_holder: 
    183             if cp: 
    184                 cp += ', ' 
    185             cp += rights_holder 
    186         if rights_holder_email: 
    187             if cp: 
    188                 cp += ', ' 
    189             cp += rights_holder_email 
    190         return cp 
    191   
    192     def getObjSize(self, object): 
    193         """ Retrieves the correct size of the object""" 
    194         return '%d' %object.get_size() 
    195  
    19610 
    19711class CCWriter(object): 
    … …  
    20519        self.extensionMetadata = None 
    20620        self.itemDict = {} 
    207  
    208         for path in os.environ['PYTHONPATH'].split(':'): 
    209             if 'collective.imstransport' in path: 
    210                 self.ims_path = path 
    211                 break 
    212         else: 
    213             self.ims_path = '' 
    21421 
    21522    def setExtensionNamespaces(self, extension_ns): 
    … …  
    408215            if x.nodeType == x.TEXT_NODE: 
    409216                return x.nodeValue.strip() 
    410         return None 
    411  
    412  
    413 class ResourceMetadataWriter: 
    414     """ Writes resource and LOM metadata for the resource. """ 
    415  
    416     def __init__(self, writer): 
    417         self.writer = writer 
    418         self.resources_node = writer.resources_node 
    419  
    420     def writeResource(self, resourceId, resource_type, path=None): 
    421         """ Writes a resource object and adds LOM metadata """ 
    422         self.resource_node = self.writer._createNode(self.writer.resources_node, 
    423                                          '', 
    424                                          'resource', 
    425                                          attrs=[('type', resource_type), 
    426                                                 ('identifier', resourceId), 
    427                                                 ('href',path)]) 
    428  
    429     def writeLOMMetadata(self): 
    430         """ Write out the metadata. """ 
    431         self.lommetadata_node = self.writer._createNode(self.resource_node, '', 'metadata') 
    432  
    433     def writeLOMNode(self, lom_namespace): 
    434         """ Write the lom node """    
    435         self.lom_node = self.writer._createNode(self.lommetadata_node, 
    436                                       lom_namespace, 
    437                                       'lom', 
    438                                       attrs=[('xmlns', lom_namespace)]) 
    439          
    440     def writeGeneralNode(self, id, title, urlbase, lang=None, description=None, keywords=[]): 
    441  
    442         # General Node 
    443         general_node = self.writer._createNode(self.lom_node, '', 'general') 
    444         identifier_node = self.writer._createNode(general_node, '', 'identifier') 
    445         self.writer._createNode(identifier_node, 
    446                            '', 
    447                            'catalog', 
    448                            urlbase) 
    449         self.writer._createNode(identifier_node, '', 'entry', id) 
    450         title_node = self.writer._createNode(general_node, '', 'title') 
    451         self.writer._createNode(title_node, 
    452                            '', 
    453                            'string', 
    454                            title, 
    455                            [('xml:lang', lang)]) 
    456         if lang: 
    457             self.writer._createNode(general_node, '', 'language', lang) 
    458         if description: 
    459             desc_node = self.writer._createNode(general_node, '', 'description') 
    460             self.writer._createNode(desc_node, 
    461                                '', 
    462                                'string', 
    463                                description, 
    464                                [('xml:lang', lang)]) 
    465         if keywords: 
    466             keyword_node = self. writer._createNode(general_node, '', 'keyword') 
    467             for kw in keywords: 
    468                 self.writer._createNode(keyword_node, 
    469                                    '', 
    470                                    'string', 
    471                                    kw, 
    472                                    [('xml:lang', lang)]) 
    473  
    474     def writeLifeCycleNode(self): 
    475         # lifeCycle Node 
    476         self.lifecycle_node = self.writer._createNode(self.lom_node, '', 'lifeCycle') 
    477  
    478  
    479     def writeMetaMetadata(self, id, urlbase, email, modtime, lomversion, lang=None, contributors=[]): 
    480         # MetaMetadata Node 
    481         metametadata_node = self.writer._createNode(self.lom_node, '', 'metaMetadata') 
    482         catalog_node = self.writer._createNode(metametadata_node, '', 'identifier') 
    483         self.writer._createNode(catalog_node, 
    484                            '', 
    485                            'catalog', 
    486                            '%s,%s' %(urlbase, email)) 
    487         entry_node = self.writer._createNode(catalog_node, '', 'entry', id) 
    488         if contributors: 
    489             self.createContributeElement(self.writer, 
    490                                          '', 
    491                                          metametadata_node, 
    492                                          '', 
    493                                          'creator', 
    494                                          contributors, 
    495                                          modtime)         
    496             self.writer._createNode(metametadata_node, '', 'metadataSchema', lomversion) 
    497  
    498         if lang: 
    499             self.writer._createNode(metametadata_node, '', 'language', lang) 
    500  
    501     def writeTechnical(self, format, size, location): 
    502         # Technical Node 
    503         technical_node = self.writer._createNode(self.lom_node, '', 'technical') 
    504         self.writer._createNode(technical_node, '', 'format', format) 
    505         self.writer._createNode(technical_node, '', 'size', size) 
    506         self.writer._createNode(technical_node, '', 'location', location) 
    507  
    508     def writeRights(self, lomversion, value, copyright):  
    509         # Rights Node 
    510         rights_node = self.writer._createNode(self.lom_node, '', 'rights') 
    511         copyright_other_node = self.writer._createNode(rights_node, 
    512                                                   '', 
    513                                                   'copyrightAndOtherRestrictions') 
    514         source_node = self.writer._createNode(copyright_other_node, '', 'source', lomversion)            
    515         value_node = self.writer._createNode(copyright_other_node, '', 'value', value) 
    516         description_node = self.writer._createNode(rights_node, '', 'description') 
    517         self.writer._createNode(description_node, 
    518                            '', 
    519                            'string', 
    520                            copyright, 
    521                            [('xml:lang', 'x-none')]) 
    522  
    523     def writeFileNode(self, path): 
    524         # File Node 
    525         self.writer._createNode(self.resource_node, '', 'file', attrs=[('href',path)]) 
    526  
    527     def createContributeElement(self, writer, nspace, lc_node, source, value, entities=[], date=None, email=None): 
    528         """ writes out a Contribute Element """ 
    529         contribute_node = writer._createNode(lc_node, nspace, 'contribute') 
    530         role_node = writer._createNode(contribute_node, nspace, 'role') 
    531         source_node = writer._createNode(role_node, nspace, 'source', source) 
    532         value_node = writer._createNode(role_node, nspace, 'value', value) 
    533         if entities: 
    534             if type(entities) not in [type([]), type(())]: 
    535                 entities = [entities] 
    536             for e in entities: 
    537                 centity_node = writer._createNode(contribute_node, nspace, 'entity',self.createVCard(e,email)) 
    538         if date: 
    539             date_node = writer._createNode(contribute_node, nspace, 'date') 
    540             writer._createNode(date_node, nspace, 'dateTime', date) 
    541  
    542     def createVCard(self, name, email=None): 
    543          """ 
    544          Writes out a VCard entry for a contribute element 
    545  
    546          Note: Should replace this with the python vcard library. 
    547  
    548          """ 
    549          vCard = 'BEGIN:VCARD\n' 
    550          vCard += 'FN:'+name+'\n' 
    551          if email: 
    552              vCard += 'EMAIL;INTERNET:'+email+'\n' 
    553          vCard += 'END:VCARD' 
    554          return vCard 
    555  
    556     def addCustomMetadata(self, customxml): 
    557         """ Adds valid xml string to the resource node of each resource """ 
    558         newdata = minidom.parseString(customxml) 
    559         self.lom_node.appendChild(newdata.firstChild) 
    560  
    561 class ZipfileWriter: 
    562     """ Write a zip file which contains all the IMS Content packaging stuff. """ 
    563  
    564     def __init__(self, archive_name, package_name): 
    565         self.fullpath = '' 
    566         self.archive_name = archive_name 
    567         self.package_name = package_name 
    568         self.archive = StringIO() 
    569         self.zipfile = ZipFile(self.archive, 'w', ZIP_DEFLATED) 
    570  
    571  
    572     def writeFile(self, path, data): 
    573         """ Write a file to the zip archive. """ 
    574         fpath = '%s%s' %(self.fullpath, path) 
    575         self.zipfile.writestr(fpath.encode('utf-8'), data) 
    576  
    577     def getOutput(self): 
    578         """ Close the zip file and get the binary archive. """ 
    579         self.zipfile.close() 
    580         self.archive.seek(0) 
    581         return self.archive.read(), self.archive_name 
    582          
     217        return None         

  • collective.imstransport/trunk/collective/imstransport/utilities/imscc/imsccreader.py

    r160 r172  
    11from zope.interface import implements 
    2 from collective.imstransport.utilities.interfaces import IIMSObjectCreator, IIMSManifestReader 
     2from collective.imstransport.utilities.interfaces import IIMSObjectCreator 
    33from zope.component import getUtility 
    4 from ccreader import CCReader 
    5 from ccresourcereader import CCResourceReader 
     4from collective.imstransport.utilities.imsinterchange import IMSInterchangeReader 
    65from collective.imstransport.utilities.packagingio import ZipfileReader 
     6from collective.imstransport.utilities.imscc.ccreader import CCReader 
     7from collective.imstransport.utilities.imscc.ccresourcereader import CCResourceReader 
    78import re 
    89from collective.imstransport import IMSTransportMessageFactory as _ 
    … …  
    1112LOM_namespace = 'http://ltsc.ieee.org/xsd/LOM' 
    1213 
    13 class IMSCCReader(object): 
     14class IMSCCReader(IMSInterchangeReader): 
    1415    """ Create objects from IMS manifest. """ 
    1516 
    16     implements(IIMSManifestReader) 
    17  
    18     name = _(u'IMS Common Cartridge') 
     17    name = _(u'IMS Content Package') 
    1918 
    2019    XML = 'http://www.w3.org/XML/1998/namespace' 
    2120    IMSCP = 'http://www.imsglobal.org/xsd/imscc/imscp_v1p1' 
    2221    LOM = 'http://ltsc.ieee.org/xsd/LOM' 
    23  
    24     def getPackageName(self): 
    25  
    26         return self.name 
    2722 
    2823    def readPackage(self, context, input): 
    … …  
    7671 
    7772 
    78     def parseFile(self, context, file, objDict, hashref, id, path): 
    79         """ parse a file object and add data to it """ 
    80         objDict[hashref]['file'] = file 
    81         objDict[hashref]['id'] = id 
    82         objDict[hashref]['path'] = path 
    83         objDict[hashref]['type'] = self.determineType(context, hashref, objDict, file) 
    8473 
    8574 
    86     def determineType(self, context, hashref, objDict, filename): 
    87         """ Determine the type of the incoming object """ 
    8875 
    89         if objDict[hashref].has_key('type') and objDict[hashref]['type']: 
    90             return objDict[hashref]['type'] 
    91         elif objDict[hashref].has_key('Format') and objDict[hashref]['Format'] in ['text/html', 'text/htm' 'text/plain' 'text/x-rst', 'text/structured']: 
    92             return 'Document' 
    93         elif objDict[hashref].has_key('Format') and re.match('^image', objDict[hashref]['Format']): 
    94             return 'Image' 
    95         else: 
    96             return self.determineFileMimetype(filename, context) 
    97              
    98     def createIdFromFile(self, file): 
    99         """ Get Id from file path """ 
    100         return file.split('/')[-1] 
    101  
    102     def createPathFromFile(self, file): 
    103         """ Get folder path from file path """ 
    104         return '/'.join(file.split('/')[:-1]) 
    105  
    106     def parseResourceMetadata(self, resourcereader, resourceid, context): 
    107         """ Read the resource metadata """ 
    108  
    109         resourcereader.readGeneral() 
    110         resourcereader.readLifecycle() 
    111         resourcereader.readMetaMetadata() 
    112         resourcereader.readTechnical() 
    113         resourcereader.readRights() 
    114         customnode = resourcereader.getCustomData('', '') 
    115         if customnode: 
    116             metadict = resourcereader.readCustomMetadata(customnode) 
    117             resourcereader.appendCustomData(metadict) 
    118         return resourcereader.processResourceMetadata() 
    119          
    120     def readCustomData(self, context, prefix, ns, location): 
    121         """  
    122         Hook for reading custom metadata for additional metadata requirements.  
    123         Should return a dictionary of values representing attribute name and value. 
    124         """ 
    125  
    126         return {} 
    127  
    128     def getObjectDictionary(self): 
    129         """ Return the object dictionary """ 
    130         return self.objdict 
    131  
    132     def determineFileMimetype(self, name, context): 
    133         """ Determine the file mimetype """ 
    134         portal = context.portal_url.getPortalObject() 
    135         registry = portal.mimetypes_registry 
    136         mimetype = registry.lookupExtension(name) 
    137  
    138         if mimetype and mimetype.major() == 'text' and mimetype.minor() == 'html': 
    139             return 'Document' 
    140         elif mimetype and mimetype.major() == 'image': 
    141             return 'Image' 
    142         else: 
    143             return 'File' 
    144  
    145  

  • collective.imstransport/trunk/collective/imstransport/utilities/imscc/imsccwriter.py

    r167 r172  
    11from zope.interface import implements 
    22from collective.imstransport.utilities.interfaces import IIMSManifestWriter 
    3 import md5 
    43from collective.imstransport.utilities.packagingio import ZipfileWriter 
    54from collective.imstransport.utilities.imscc.ccwriter import CCWriter 
    65from collective.imstransport.utilities.imscc.ccresourcewriter import CCResourceWriter 
     6from collective.imstransport.utilities.imsinterchange import IMSInterchangeWriter 
     7from collective.imstransport import IMSTransportMessageFactory as _ 
    78 
    8 IMS_schema = 'IMS Common Cartridge' 
     9IMS_schema = 'IMS Content Package' 
    910IMS_version = '1.0.0' 
    1011LOM_version = 'LOMv1.0' 
    1112LOM_namespace = 'http://ltsc.ieee.org/xsd/LOM' 
    1213 
    13 class IMSCCWriter: 
     14namespaces = [('xmlns', 'http://www.imsglobal.org/xsd/imscc/imscp_v1p1'), 
     15              ('xmlns:lomimscc','http://ltsc.ieee.org/xsd/imscc/LOM'), 
     16              ('xmlns:lom','http://ltsc.ieee.org/xsd/LOM'), 
     17              ('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance'),] 
     18 
     19schema_locations = [ 
     20    'http://www.imsglobal.org/xsd/imscc/imscp_v1p1 http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/imscp_v1p2_localised.xsd', 
     21    'http://ltsc.ieee.org/xsd/LOM http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/domainProfile_2/lomLoose_localised.xsd', 
     22    'http://ltsc.ieee.org/xsd/imscc/LOM http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/domainProfile_1/lomLoose_localised.xsd',] 
     23 
     24 
     25class IMSCCWriter(IMSInterchangeWriter): 
    1426    """ Write an IMS content package manifest file. """ 
    1527 
    16     implements(IIMSManifestWriter) 
     28    name = _(u'IMS Content Package') 
    1729 
    1830    def createPackage(self, context, filename): 
    … …  
    2133        self.context = context 
    2234 
    23         namespaces = [('xmlns', 'http://www.imsglobal.org/xsd/imscc/imscp_v1p1'), 
    24                       ('xmlns:lomimscc','http://ltsc.ieee.org/xsd/imscc/LOM'), 
    25                       ('xmlns:lom','http://ltsc.ieee.org/xsd/LOM'), 
    26                       ('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance'),] 
    27  
    28         schema_locations = [ 
    29             'http://www.imsglobal.org/xsd/imscc/imscp_v1p1 http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/imscp_v1p2_localised.xsd', 
    30             'http://ltsc.ieee.org/xsd/LOM http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/domainProfile_2/lomLoose_localised.xsd', 
    31             'http://ltsc.ieee.org/xsd/imscc/LOM http://www.imsglobal.org/profile/cc/ccv1p0/derived_schema/domainProfile_1/lomLoose_localised.xsd',] 
    3235         
    3336        self.destination = ZipfileWriter(context,filename) 
    34         ccwriter = CCWriter(context) 
     37        ccwriter = CWriter(context) 
    3538        ccwriter.writeManifestNode(self._createPathId(context.virtual_url_path(), 'MAN'), 
    3639                                   context.ModificationDate(), 
    … …  
    6164 
    6265                path = self._getObjectPath(object, context) 
    63                 rlomwriter = CCResourceWriter(ccwriter) 
     66                rlomwriter = CResourceWriter(ccwriter) 
    6467                rlomwriter.writeResource(refId, 'webcontent', path) 
    6568                rlomwriter.writeLOMMetadata() 
    … …  
    98101 
    99102 
    100     def writeCustomMetadata(self, object, prefix, ns, location): 
    101         """  
    102         Hook for writing custom metadata for additional metatdata requirements.  
    103         Should return standards compliant xml that relates to object passed in. 
    104         """ 
    105  
    106         return '' 
    107   
    108     def _writeObjectData(self, obj, path): 
    109         """ Write file data to the destination object. """ 
    110         if type(obj) == type(''): 
    111             data = obj         
    112         else: 
    113             format = '' 
    114             if hasattr(obj.aq_explicit, 'Format'): 
    115                 format = obj.Format() 
    116             if 'Link' == obj.Type(): 
    117                 doc = minidom.Document() 
    118                 anchor_node = self._createNode(doc, '', 'a', obj.Title()) 
    119                 anchor_node.setAttribute('href', obj.getRemoteUrl()) 
    120                 data = doc.toxml(encoding='utf-8') 
    121             elif obj.Type() in ['File', 'Image'] and hasattr(obj.aq_explicit, 'data'): 
    122                     data = obj.data 
    123             elif 'text/html' == format and hasattr(obj.aq_explicit, 'getText'): 
    124                     data = obj.getText() 
    125             elif format in ['text/plain', 'text/x-rst', 'text/structured'] and hasattr(obj.aq_explicit, 'getRawText'): 
    126                     data = obj.getRawText() 
    127             else: 
    128                 data = '' 
    129  
    130         if self.destination: 
    131             self.destination.writeFile(path, data) 
    132  
    133     def _getAllObjects(self, context): 
    134         """ Get all sub objects. """ 
    135         objects = [obj.getObject() for obj in context.portal_catalog.searchResults(path={'query':('/'.join(context.getPhysicalPath())+'/'),'depth':-1})] 
    136         return [object for object in objects if not object.isPrincipiaFolderish or getattr(object.aq_explicit, 'getText', None)] 
    137  
    138     def _getChildrenObjects(self, parent, objects): 
    139         """ Get objects in current folder """ 
    140         parentpath = '/'.join(parent.getPhysicalPath()) 
    141         children = [] 
    142         for object in objects: 
    143             rpath = '/'.join(object.getPhysicalPath()).replace(parentpath, '') 
    144  
    145             if len(rpath.split('/')) == 1: 
    146                 children.append(object) 
    147                         
    148         return children 
    149  
    150      
    151     def _getObjectPath(self, obj, context): 
    152         """ Get the path of an object. """ 
    153  
    154         root_path = context.aq_explicit.virtual_url_path() 
    155         obj_path = obj.aq_explicit.virtual_url_path() 
    156  
    157         if obj_path.find(root_path) != 0: 
    158             return '' 
    159  
    160         # Remove the path of the folder object 
    161         path = obj_path.replace(root_path, '') 
    162         if path and path[0] == '/': 
    163             path = path[1:] 
    164  
    165         if not path: 
    166             return '' 
    167  
    168         if hasattr(obj.aq_explicit, 'Format'): 
    169             if 'text/html' == obj.Format() and obj.isPrincipiaFolderish: 
    170                 path += '.html' 
    171  
    172         return path 
    173  
    174     def _createPathId(self, path, pre='RES'): 
    175         """ Create a unique id given a path """ 
    176         return pre + str(md5.md5(path).hexdigest()) 
    177  
    178     def _getCopyrightString(self, copyright, rights_holder, rights_holder_email): 
    179         cp = '' 
    180         if copyright: 
    181             cp += copyright 
    182         if rights_holder: 
    183             if cp: 
    184                 cp += ', ' 
    185             cp += rights_holder 
    186         if rights_holder_email: 
    187             if cp: 
    188                 cp += ', ' 
    189             cp += rights_holder_email 
    190         return cp 
    191   
    192     def getObjSize(self, object): 
    193         """ Retrieves the correct size of the object""" 
    194         return '%d' %object.get_size() 
Note: See TracChangeset for help on using the changeset viewer.