Changeset 202


Ignore:
Timestamp:
05/15/09 18:14:40 (6 years ago)
Author:
brent
Message:

Refactored CC writer.

Location:
collective.imstransport/trunk/collective/imstransport
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • collective.imstransport/trunk/collective/imstransport/utilities/imscc/ccwriter.py

    r188 r202  
    88LOM_version = 'LOMv1.0' 
    99LOM_namespace = 'http://ltsc.ieee.org/xsd/LOM' 
     10LOM_IMSCC_namespace = 'http://ltsc.ieee.org/xsd/imscc/LOM' 
     11WL_namespace = 'http://www.imsglobalorg/xsd/imswl_v1p0' 
     12WL_scheminst = 'http://www.w3.org/2001/XMLSchema-instance' 
     13 
     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 
    1024 
    1125class CCWriter(object): 
    1226 
    13     def __init__(self, context): 
    14         self.context = context 
     27    def __init__(self): 
    1528        self.document = minidom.Document() 
    1629        self.destination = None 
     
    2033        self.itemDict = {} 
    2134 
    22     def setExtensionNamespaces(self, extension_ns): 
    23         """ Set any extension namespaces """ 
    24         self.namespaces += extension_ns 
    25  
    26     def setDestination(self, destination): 
    27         """ Set the output object for the writer. """ 
    28         self.destination = destination 
    29  
    30     def setExtensionMetadataMethod(self, extensionMetadata): 
    31         """ Set the extension metadata method """     
    32         self.extensionMetadata = extensionMetadata 
    33  
    34      
    35     def writeManifestNode(self, manifestId, manifestVer, namespaces, schema_locations): 
    36         """ Write the manifest node. """ 
    37         self.manifest_node = self._createNode(self.document, 
    38                                               '', 
    39                                               'manifest',  
    40                                               attrs=[('identifier', manifestId), 
    41                                                      ('xmlns:version', manifestVer),]) 
     35    def createManifest(self, id, ver): 
     36        """ Create a new empty manifest. """ 
     37        doc = minidom.Document() 
     38        self._createNode(doc, '', 'manifest',  
     39                         attrs=[('identifier', id), 
     40                                ('xmlns:version', ver),]) 
    4241        self.addNamespaces(namespaces) 
    4342        self.addSchemaLocations(schema_locations) 
    44  
    45  
    46     def writeLOMCCMetadata(self, id, title, urlbase, imsschema, imsversion, lang=None, description=None, keywords=None): 
    47         """ Write the lom imscc metadata node for the top level object """ 
    48  
    49         # Create the top level Metadata node 
    50         self.metadata_node = self._createNode(self.manifest_node, '', 'metadata') 
    51  
    52  
    53         self.schema_node = self._createNode(self.metadata_node, 
    54                                             '', 
    55                                             'schema',  
    56                                             imsschema) 
    57  
    58         self.schema_node = self._createNode(self.metadata_node, 
    59                                             '', 
    60                                             'schemaversion',  
    61                                             imsversion) 
    62  
    63         # LOM Node 
    64         lomimscc_node = self._createNode(self.metadata_node, 
    65                                       '', 
    66                                       'lomimscc:lom',) 
    67  
    68         # General Node 
    69         general_node = self._createNode(lomimscc_node, '', 'lomimscc:general') 
    70         identifier_node = self._createNode(general_node, '', 'lomimscc:identifier') 
    71         self._createNode(identifier_node, 
    72                            '', 
    73                            'lomimscc:catalog', 
    74                            urlbase) 
    75         self._createNode(identifier_node, '', 'lomimscc:entry', id) 
    76         title_node = self._createNode(general_node, '', 'lomimscc:title') 
    77         self._createNode(title_node, 
    78                            '', 
    79                            'lomimscc:string', 
    80                            title, 
    81                            [('xml:lang', lang)]) 
    82         if lang: 
    83             self._createNode(general_node, '', 'lomimscc:language', lang) 
    84         if description: 
    85             desc_node = self._createNode(general_node, '', 'lomimscc:description') 
    86             self._createNode(desc_node, 
    87                                '', 
    88                                'lomimscc:string', 
    89                                description, 
    90                                [('xml:lang', lang)]) 
    91         if keywords: 
    92             keyword_node = self._createNode(general_node, '', 'lomimscc:keyword') 
    93             for kw in keywords: 
    94                 self._createNode(keyword_node, 
    95                                    '', 
    96                                    'lomimscc:string', 
    97                                    kw, 
    98                                    [('xml:lang', lang)]) 
    99  
    100  
    101     def writeManifest(): 
    102  
    103         # Create the Organizations node 
    104         defaultId = self._createPathId(self.context.virtual_url_path(), 'ORG') 
    105         organizations_node = self._createNode(self.manifest_node, 
    106                                               '', 
    107                                               'organizations',) 
    108  
    109  
    110         # Write out organizations information. 
    111         self.writeOrganizations(self.context, organizations_node, self) 
    112  
    113         resources_node = self._createNode(self.manifest_node, '', 'resources') 
    114  
    115         allObjects = self._getAllObjects() 
     43        return doc 
     44 
     45    def writeTopLevelMetadata(self, doc, id, title, urlbase, lang, desc=None, keywords=None): 
     46        """ Write top level metadata into the manifest. """ 
     47        manifest = getElementByTagName('manifest') 
     48        if manifest: 
     49            md = self._createNode(manifest[0], '', 'metadata') 
     50            self._createNode(md, '', 'schema', IMS_schema) 
     51            self._createNode(md, '', 'version', IMS_version) 
     52            lom = self._createNode(md, LOM_IMSCC_namespace, 'lom') 
     53            gen = self._createNode(lom, '', 'general') 
     54            ident = self._createNode(gen, '', 'identifier') 
     55            self._createNode(ident, '', 'catalog', urlbase) 
     56            self._createNode(ident, '', 'entry', id) 
     57            tn = self._createNode(gen, '', 'title') 
     58            self._createNode(tn, '', 'string', title, [('xml:lang', lang)]) 
     59            self._createNode(gen, '', 'language', lang) 
     60            if desc: 
     61                dn = self._createNode(gen, '', 'description') 
     62                self._createNode(dn, '', 'string', desc, [('xml:lang', lang)]) 
     63            if keywords: 
     64                kn = self._createNode(gen, '', 'keyword') 
     65                for kw in keywords: 
     66                    self._createNode(kn, '', 'string', kw, [('xml:lang', lang)]) 
    11667         
    117         for obj in allObjects: 
    118             # Handle the case where an object might be folderish, but 
    119             # also has a text attribute. 
    120             if not obj.isPrincipiaFolderish or hasattr(obj.aq_explicit,'getText'): 
    121                 path = self._getObjectPath(obj) 
    122                 self._writeResource(obj, resources_node, path, extensionMetadata=self.extensionMetadata) 
    123                 self._writeObjectData(obj, path) 
    124  
    125         self._writeObjectData(self.getManifest(), 'imsmanifest.xml') 
    126  
    127         if self.destination: 
    128             return self.destination.getOutput() 
     68    def createOrganizations(self, doc, orgId, itemId): 
     69        """ Create an organizations section in the manifest """ 
     70        manifest = doc.getElementsByTagName('manifest') 
     71        if manifest: 
     72            orgs = self._createNode(manifest, '', 'organizations') 
     73            org = self._createNode(orgs, '', 'organization', attrs=[('identifier', orgId), 
     74                                                                    ('structure', 'rooted-hierarchy')]) 
     75            item = self._createNode(org, '', 'item', attrs=[('identifier', itemId)]) 
     76            return item 
     77        return None 
     78 
     79    def createResources(self, doc): 
     80        manifest = doc.getElementsByTagName('manifest') 
     81        if manifest: 
     82            return self._createNode(manifest, '', 'resources') 
     83        return None 
     84                          
     85    def writeItem(self, orgs, itemId, refId, title): 
     86        """ Write an item in the organizations section """ 
     87        itn = self._createNode(orgs, '', 'item', attrs=[('identifier', itemId), 
     88                                                        ('identifierref', refId)]) 
     89        self._createNode(itn, '', 'title', title) 
     90 
     91 
     92    def writeResource(self, res, refid, type, path): 
     93        """ Write a resource object in the resources section """ 
     94        attrs = [('identifier', refId)] 
     95        if type == 'Link': 
     96            attrs.append(('type', 'imswl_xmlv1p0')) 
    12997        else: 
    130             return None, None 
    131  
    132     def writeOrganizations(self): 
    133         """ Write the organizations section. """ 
    134         self.organizations_node = self._createNode(self.manifest_node, 
    135                                                    '', 
    136                                                    'organizations',) 
    137  
    138     def writeOrganizationNode(self, id): 
    139         """ Common Cartridge requires organization to specify rooted-hierarchy as structure """ 
    140         self.organization_node = self._createNode(self.organizations_node, 
    141                                                   '', 
    142                                                   'organization', 
    143                                                   attrs=[('identifier',id),('structure','rooted-hierarchy')]) 
     98            attrs.append(('type', 'webcontent')) 
     99            attrs.append(('href', path)) 
     100        rn = self._createNode(res, '', 'resource', attrs=attrs) 
     101        return rn 
     102 
     103    def createResourceMetadata(self, res): 
     104        """ Create a resource metadat node """ 
     105        md = self._createNode(res, '', 'metadata') 
     106        return self._createNode(md, LOM_namespace, 'lom') 
     107     
     108    def writeGeneralNode(self, lom, id, title, urlbase, lang, desc=None, kw=None): 
     109        """ Write the general Node """ 
     110        gen = self._createNode(lom, '', 'general') 
     111        idn = self._createNode(gen, '', 'identifier') 
     112        self._createNode(idn, '', 'catalog', urlbase) 
     113        self._createNode(idn, '', 'entry', id) 
     114        tn = self._createNode(gen, '', 'title') 
     115        self._createNode(tn, '', 'string', title, [('xml:lang', lang)]) 
     116        self._createNode(gen, '', 'language', lang) 
     117        if desc: 
     118            dn = self._createNode(gen, '', 'description') 
     119            self._createNode(dn, '', 'string', desc, [('xml:lang', lang)]) 
     120        if kw: 
     121            kn = self._createNode(gen, '', 'keyword') 
     122            for k in kw: 
     123                self._createNode(kn, '', 'string', k, [('xml:lang', lang)]) 
     124 
     125    def writeLifeCycleNode(self, lom, creators, contrib, mod, lang): 
     126        """ Write the lifecycle Node """ 
     127        ln = self._createNode(lom, '', 'lifeCycle') 
     128        if creators: 
     129            self._createContributeElement(ln, '', LOM_version, 'author', creators, mod) 
     130        if contrib: 
     131            self._creaetContributeElement(ln, '', LOM_version, 'unknown', contrib, mod) 
     132 
     133    def writeMetaMetadata(self, lom, id, urlbase, email, modtime, lang, contrib): 
     134        """ write the metaMetadata Node """ 
     135        mmd = self._createNode(lom, '', 'metaMetadata') 
     136        cat = self._createNode(mmd, '', 'identifier') 
     137        self._createNode(cat, '', 'catalog', '%s,%s' %(urlbase, email)) 
     138        entry = self._createNode(cat, '', 'entry', id) 
     139        if contrib: 
     140            self.createContributeElement(mmd, '', LOM_version, 'creator', contrib, mod)         
     141            self._createNode(mmd, '', 'metadataSchema', LOM_version) 
     142        self._createNode(mmd, '', 'language', lang) 
     143 
     144    def writeTechnical(self, lom, format, size, location): 
     145        """ Write the Technical Node """ 
     146        tech = self._createNode(lom, '', 'technical') 
     147        self._createNode(tech, '', 'format', format) 
     148        self._createNode(tech, '', 'size', size) 
     149        self._createNode(tech, '', 'location', location) 
     150 
     151    def writeRights(self, value, copyright, lang):  
     152        """ Write the Rights Node """ 
     153        rights = self._createNode(lom, '', 'rights') 
     154        cwn = self._createNode(rights, '', 'copyrightAndOtherRestrictions') 
     155        self._createNode(cwn, '', 'source', LOM_version)            
     156        self._createNode(cwn, '', 'value', value) 
     157        desc = self._createNode(rights, '', 'description') 
     158        self._createNode(desc, '', 'string', copyright, [('xml:lang', lang)]) 
     159 
     160 
     161    def _createContributeElement(self, node,  ns, source, value, entities=[], date=None, email=None): 
     162        """ writes out a Contribute Element """ 
     163        cn = self._createNode(node, ns, 'contribute') 
     164        role = self._createNode(cn, ns, 'role') 
     165        self._createNode(role, ns, 'source', source) 
     166        self._createNode(role, ns, 'value', value) 
     167        if entities: 
     168            if type(entities) not in [type([]), type(())]: 
     169                entities = [entities] 
     170            for e in entities: 
     171                centity_node = self._createNode(cn, ns, 'entity',self.createVCard(e,email)) 
     172        if date: 
     173            dn = self._createNode(cn, ns, 'date') 
     174            self._createNode(dn, ns, 'dateTime', date) 
     175 
     176    def _createVCard(self, name, email=None): 
     177        """ 
     178        Writes out a VCard entry for a contribute element 
    144179         
    145     def writeShellItem(self, id): 
    146         """ Common Cartridge requires a top level item node """ 
    147         self.top_item_node = self._createNode(self.organization_node, 
    148                                               '', 
    149                                               'item', 
    150                                               attrs=[('identifier',id)]) 
    151  
    152     def writeItem(self, itemId, title, refId=None): 
    153         """ Write out a single item and its title. Folder nodes include containing objects """ 
    154  
    155         attrs = [('identifier', itemId),] 
    156         if refId: 
    157             attrs.append(('identifierref', refId)) 
    158  
    159         item_node = self._createNode(self.top_item_node, 
    160                                        '', 
    161                                        'item', 
    162                                        attrs=attrs) 
    163  
    164         self._createNode(item_node, '', 'title', title) 
    165  
    166  
    167     def writeResources(self): 
    168         """ Resources node """ 
    169         self.resources_node = self._createNode(self.manifest_node, '', 'resources') 
    170  
    171  
    172     def getResourceMetadataWriter(self, writer): 
    173         """ ResourceMetadataWriter objects create the resource node along with all metadata therein """ 
    174         return ResourceMetadataWriter(writer)                   
    175  
    176  
    177     def getManifest(self): 
     180        Note: Should replace this with the python vcard library. 
     181         
     182        """ 
     183        vCard = 'BEGIN:VCARD\n' 
     184        vCard += 'FN:'+name+'\n' 
     185        if email: 
     186            vCard += 'EMAIL;INTERNET:'+email+'\n' 
     187        vCard += 'END:VCARD' 
     188        return vCard 
     189 
     190 
     191    def writeResourceFiles(self, res, path): 
     192        """ Write a file node """ 
     193        self._createNode(res, '', 'file', attrs=[('href', path)]) 
     194 
     195 
     196    def getManifest(self, manifest): 
    178197        """ Get the manifest expressed in XML. """ 
    179         return self.document.toxml(encoding='utf-8') 
     198        return manifest.toxml(encoding='utf-8') 
    180199 
    181200 
     
    209228                return x.nodeValue.strip() 
    210229        return None         
     230 
     231    def getLinkXml(self, title, link): 
     232        """ Return text for a file that stores the link in an xml file """ 
     233        doc = minidom.Document() 
     234        wlnode = self._createNode(doc, WL_namespace, 'webLink', 
     235                                  attrs=[('xmlns:xsi', WL_schemainst),('xmlns',WL_namespace)]) 
     236        self._createNode(wlnode, '', 'title', value=title) 
     237        self._createNode(wlnode, '', 'url', attrs=[('href',link),('target','_blank')]) 
     238        return wlnode.toxml('utf-8') 
  • collective.imstransport/trunk/collective/imstransport/utilities/imscc/imsccreader.py

    r199 r202  
    1313    """ Create objects from IMS manifest. """ 
    1414 
    15     name = _(u'IMS Content Package') 
     15    name = _(u'IMS Common Cartridge') 
    1616 
    1717    XML = 'http://www.w3.org/XML/1998/namespace' 
  • collective.imstransport/trunk/collective/imstransport/utilities/imscc/imsccwriter.py

    r197 r202  
    44from collective.imstransport.utilities.imscc.ccwriter import CCWriter 
    55from collective.imstransport.utilities.imscc.ccresourcewriter import CCResourceWriter 
    6 from collective.imstransport.utilities.imsinterchange import IMSInterchangeWriter 
     6from collective.imstransport.utilities.imsinterchange import IMSWriter 
    77from collective.imstransport import IMSTransportMessageFactory as _ 
    88 
     
    2323 
    2424 
    25 class IMSCCWriter(IMSInterchangeWriter): 
     25class IMSCCWriter(IMSWriter): 
    2626    """ Write an IMS content package manifest file. """ 
    2727 
    28     name = _(u'IMS Content Package') 
     28    name = _(u'IMS Common Cartridge') 
    2929 
    3030    def createPackage(self, file, context): 
    3131        """ Creates an IMS Package """ 
    3232 
    33         self.context = context 
     33        destination = ZipfileWriter(context, file) 
    3434 
    35         self.destination = ZipfileWriter(context, file) 
    36         ccwriter = CCWriter(context) 
    37         ccwriter.writeManifestNode(self._createPathId(context.virtual_url_path(), 'MAN'), 
    38                                    context.ModificationDate(), 
    39                                    namespaces, 
    40                                    schema_locations) 
     35        ccw = CCWriter() 
    4136 
     37        # Create the Manifest 
     38        manId = self._createPathId(context.virtual_url_path(), 'MAN') 
     39        manVer = context.ModificationDate() 
     40        manifest = ccw.createManifest(manId, manVer) 
     41 
     42        # Add top level metadata 
    4243        lang = context.Language() 
    4344        if not lang: 
    4445            lang = context.portal_properties.site_properties.getProperty('default_language') 
    45         ccwriter.writeLOMCCMetadata(context.getId(), context.Title(), context.portal_url(), IMS_schema, IMS_version, lang, context.Description(), context.Subject()) 
     46        ccw.writeTopLevelMetadata(manifest, 
     47                                  context.getId(), 
     48                                  context.Title(), 
     49                                  context.portal_url(), 
     50                                  lang, 
     51                                  context.Description(), 
     52                                  context.Subject()) 
    4653 
    47         ccwriter.writeOrganizations() 
    48         ccwriter.writeOrganizationNode(self._createPathId(context.virtual_url_path(), 'ORG')) 
    49         ccwriter.writeShellItem(self._createPathId(context.virtual_url_path(), 'SHL')) 
     54        # Write Organizations and Resources 
    5055 
    51         ccwriter.writeResources() 
     56        orgs = ccw.createOrganizations(doc) 
     57        res = ccw.createResources(doc) 
    5258 
     59        if orgs and res: 
     60            objs = self._getAllObjects(context) 
     61            for obj in objs: 
     62                # Need to consider excluding folders 
     63                # Get resource info 
     64                path = self._getObjectPath(obj, context) 
     65                vpath = obj.virtual_url_path() 
     66                refid = self._createPathId(vpath, 'RES') 
     67                # Check if we need to add to the organizations section 
     68                if not obj.getExcludeFromNav(): 
     69                    itemId = self._createPathId(vpath, 'ITM') 
     70                    ccw.writeItem(orgs, itemId, refid, obj.title) 
     71                res = ccw.writeResource(res, refid, obj.Type(), path) 
    5372 
    54         objects = self._getAllObjects(context) 
     73                id = obj.getId() 
     74                title = obj.Title() 
     75                urlbase = obj.portal_url() 
     76                lang = obj.Language() 
     77                if not lang: 
     78                    lang = obj.portal_properties.site_properties.getProperty('default_language') 
     79                desc = obj.Description() 
     80                kw = obj.Subject() 
     81                creators = obj.Creators()  
     82                contrib = obj.Contributors() 
     83                mod = object.ModificationDate().replace(' ','T') 
     84                email = obj.portal_url.getPortalObject().getProperty('email_from_address') 
     85                format = obj.Format() 
     86                size = self.getObjSize(obj) 
     87                location = obj.renderBase() 
     88                value = 'yes' 
     89                rights_hoder =object.portal_properties.site_properties.getProperty('rights_holder') 
     90                rights_holder_email = object.portal_properties.site_properties.getProperty('rights_holder_email') 
     91                copyright = self._getCopyrightString(obj.Rights(), rights_holder, rights_holder_email) 
     92                 
     93                md = ccw.createResourceMetadata(res) 
     94                ccw.writeGeneralNode(md, id, title, urlbase, lang, desc, kw) 
     95                ccw,writeLifeCycleNode(md, creators, contrib, mod, lang) 
     96                ccw.writeMetaMetadataNode(md, id, urlbase, email, mod, lang, contrib) 
     97                ccw.writeTechnicalNode(md, format, size, location) 
     98                ccw.writeRightsNode(md, value, copyright, lang) 
    5599 
    56         for object in objects: 
    57             path = self._getObjectPath(object, context) 
    58             itemId = self._createPathId(object.virtual_url_path(), 'ITM') 
    59             refId = self._createPathId(object.virtual_url_path(), 'RES') 
    60  
    61             if not object.isPrincipiaFolderish or getattr(object, 'getText', None): 
    62                 if not object.getExcludeFromNav(): 
    63                     ccwriter.writeItem(itemId, object.title, refId) 
    64  
    65                 path = self._getObjectPath(object, context) 
    66                 rlomwriter = CCResourceWriter(ccwriter) 
    67100                if object.Type() == 'Link': 
    68                     rlomwriter.writeResource(refId, 'imswl_xmlv1p0', '') 
    69                 else: 
    70                     rlomwriter.writeResource(refId, 'webcontent', path)                     
    71                 rlomwriter.writeLOMMetadata() 
    72                 rlomwriter.writeLOMNode(LOM_namespace) 
    73  
    74                 lang = object.Language() 
    75                 if not lang: 
    76                     lang = context.portal_properties.site_properties.getProperty('default_language') 
    77                 rlomwriter.writeGeneralNode(object.getId(), object.Title(), object.portal_url(), lang, object.Description(), object.Subject()) 
    78  
    79                 rlomwriter.writeLifeCycleNode() 
    80  
    81                 email = object.portal_url.getPortalObject().getProperty('email_from_address') 
    82                 date = object.ModificationDate().replace(' ','T') 
    83                 contributors = object.Contributors() 
    84  
    85                 rlomwriter.writeMetaMetadata(object.id, object.portal_url(), email, date, LOM_version, lang, contributors) 
    86                 rlomwriter.writeTechnical(object.Format(), self.getObjSize(object), object.renderBase()) 
    87                 rights_holder = object.portal_properties.site_properties.getProperty('rights_holder') 
    88                 rights_holder_email = object.portal_properties.site_properties.getProperty('rights_holder_email') 
    89                 rlomwriter.writeRights(LOM_version, 'yes', self._getCopyrightString(object.Rights(), rights_holder, rights_holder_email)) 
    90                 rlomwriter.writeCustomMetadata(object) 
    91  
    92                  
    93                 if object.Type() == 'Link': 
    94                     self._writeObjectData(rlomwriter.getLinkXml('http://www.imsglobal.org/xsd/imswl_v1p0', 'xsi:http://www.w3.org/2001/XMLSchema-instance', object.title, object.getRemoteUrl()), '%s%s' %(path,'.xml')) 
    95                     rlomwriter.writeFileNode('%s%s' %(path,'.xml')) 
     101                    link = ccw.getLinkXml(title, object.getRemoteUrl()) 
     102                    rpath = '%s%s' %(path,'.xml') 
     103                    self._writeObjectData(link, rpath) 
     104                    ccw.writeResourceFiles(res, rpath) 
    96105                else: 
    97106                    self._writeObjectData(object, path) 
    98                     rlomwriter.writeFileNode(path) 
     107                    ccw.writeResourceFiles(res, path) 
    99108 
    100                      
    101         self._writeObjectData(ccwriter.getManifest(), 'imsmanifest.xml') 
     109        self._writeObjectData(ccw.getManifest(manifest), 'imsmanifest.xml') 
    102110 
    103         if self.destination: 
    104             return self.destination.getOutput() 
     111        if destination: 
     112            return destination.getOutput() 
    105113        else: 
    106114            return None, None 
  • collective.imstransport/trunk/collective/imstransport/utilities/imsinterchange.py

    r199 r202  
    5151        return result                     
    5252 
    53 class IMSInterchangeReader(object): 
    54  
    55     implements(IIMSManifestReader) 
    56     name = _(u'IMS Interchange Reader') 
    57  
    58     def determineType(self, context, hashref, objDict, filename): 
    59         """ Determine the type of the incoming object """ 
    60  
    61         if objDict[hashref].has_key('type') and objDict[hashref]['type']: 
    62             return objDict[hashref]['type'] 
    63         elif objDict[hashref].has_key('Format') and objDict[hashref]['Format'] in ['text/html', 'text/htm' 'text/plain' 'text/x-rst', 'text/structured']: 
    64             return 'Document' 
    65         elif objDict[hashref].has_key('Format') and re.match('^image', objDict[hashref]['Format']): 
    66             return 'Image' 
    67         else: 
    68             return self.determineFileMimetype(filename, context) 
    69              
    70     def createIdFromFile(self, file): 
    71         """ Get Id from file path """ 
    72         return file.split('/')[-1] 
    73  
    74     def createPathFromFile(self, file): 
    75         """ Get folder path from file path """ 
    76         return '/'.join(file.split('/')[:-1]) 
    77  
    78  
    79     def determineFileMimetype(self, name, context): 
    80         """ Determine the file mimetype """ 
    81         portal = context.portal_url.getPortalObject() 
    82         registry = portal.mimetypes_registry 
    83         mimetype = registry.lookupExtension(name) 
    84  
    85         if mimetype and mimetype.major() == 'text' and mimetype.minor() == 'html': 
    86             return 'Document' 
    87         elif mimetype and mimetype.major() == 'image': 
    88             return 'Image' 
    89         else: 
    90             return 'File' 
    91  
    92     def parseFile(self, context, file, objDict, hashref, id, path): 
    93         """ parse a file object and add data to it """ 
    94         objDict[hashref]['file'] = file 
    95         objDict[hashref]['id'] = id 
    96         objDict[hashref]['path'] = path 
    97         objDict[hashref]['type'] = self.determineType(context, hashref, objDict, file) 
    98  
    99  
    100     def parseResourceMetadata(self, resourcereader, resourceid, context): 
    101         """ Read the resource metadata """ 
    102  
    103         resourcereader.readGeneral() 
    104         resourcereader.readLifecycle() 
    105         resourcereader.readMetaMetadata() 
    106         resourcereader.readTechnical() 
    107         resourcereader.readRights() 
    108         customnode = resourcereader.getCustomData('', '') 
    109         if customnode: 
    110             metadict = resourcereader.readCustomMetadata(customnode) 
    111             resourcereader.appendCustomData(metadict) 
    112         return resourcereader.processResourceMetadata() 
    113          
    114     def readCustomData(self, context, prefix, ns, location): 
    115         """  
    116         Hook for reading custom metadata for additional metadata requirements.  
    117         Should return a dictionary of values representing attribute name and value. 
    118         """ 
    119  
    120         return {} 
    121  
    122     def getObjectDictionary(self): 
    123         """ Return the object dictionary """ 
    124         return self.objdict 
    125  
    126  
    127     def getPackageName(self): 
    128  
    129         return self.name 
    130  
    131  
    132 class IMSInterchangeWriter(object): 
     53 
     54class IMSWriter(object): 
     55    """ Base class for IMS writer objects. """ 
    13356 
    13457    implements(IIMSManifestWriter) 
    135     name = _(u'IMS Interchange Writer')   
    136  
    13758 
    13859    def _writeObjectData(self, obj, path): 
     
    223144        return 
    224145     
     146 
     147     
     148 
     149 
     150class IMSInterchangeReader(object): 
     151 
     152    implements(IIMSManifestReader) 
     153    name = _(u'IMS Interchange Reader') 
     154 
     155    def determineType(self, context, hashref, objDict, filename): 
     156        """ Determine the type of the incoming object """ 
     157 
     158        if objDict[hashref].has_key('type') and objDict[hashref]['type']: 
     159            return objDict[hashref]['type'] 
     160        elif objDict[hashref].has_key('Format') and objDict[hashref]['Format'] in ['text/html', 'text/htm' 'text/plain' 'text/x-rst', 'text/structured']: 
     161            return 'Document' 
     162        elif objDict[hashref].has_key('Format') and re.match('^image', objDict[hashref]['Format']): 
     163            return 'Image' 
     164        else: 
     165            return self.determineFileMimetype(filename, context) 
     166             
     167    def createIdFromFile(self, file): 
     168        """ Get Id from file path """ 
     169        return file.split('/')[-1] 
     170 
     171    def createPathFromFile(self, file): 
     172        """ Get folder path from file path """ 
     173        return '/'.join(file.split('/')[:-1]) 
     174 
     175 
     176    def determineFileMimetype(self, name, context): 
     177        """ Determine the file mimetype """ 
     178        portal = context.portal_url.getPortalObject() 
     179        registry = portal.mimetypes_registry 
     180        mimetype = registry.lookupExtension(name) 
     181 
     182        if mimetype and mimetype.major() == 'text' and mimetype.minor() == 'html': 
     183            return 'Document' 
     184        elif mimetype and mimetype.major() == 'image': 
     185            return 'Image' 
     186        else: 
     187            return 'File' 
     188 
     189    def parseFile(self, context, file, objDict, hashref, id, path): 
     190        """ parse a file object and add data to it """ 
     191        objDict[hashref]['file'] = file 
     192        objDict[hashref]['id'] = id 
     193        objDict[hashref]['path'] = path 
     194        objDict[hashref]['type'] = self.determineType(context, hashref, objDict, file) 
     195 
     196 
     197    def parseResourceMetadata(self, resourcereader, resourceid, context): 
     198        """ Read the resource metadata """ 
     199 
     200        resourcereader.readGeneral() 
     201        resourcereader.readLifecycle() 
     202        resourcereader.readMetaMetadata() 
     203        resourcereader.readTechnical() 
     204        resourcereader.readRights() 
     205        customnode = resourcereader.getCustomData('', '') 
     206        if customnode: 
     207            metadict = resourcereader.readCustomMetadata(customnode) 
     208            resourcereader.appendCustomData(metadict) 
     209        return resourcereader.processResourceMetadata() 
     210         
     211    def readCustomData(self, context, prefix, ns, location): 
     212        """  
     213        Hook for reading custom metadata for additional metadata requirements.  
     214        Should return a dictionary of values representing attribute name and value. 
     215        """ 
     216 
     217        return {} 
     218 
     219    def getObjectDictionary(self): 
     220        """ Return the object dictionary """ 
     221        return self.objdict 
     222 
     223 
     224    def getPackageName(self): 
     225 
     226        return self.name 
     227 
     228 
     229class IMSInterchangeWriter(object): 
     230 
     231    implements(IIMSManifestWriter) 
     232    name = _(u'IMS Interchange Writer')   
     233 
     234 
     235    def _writeObjectData(self, obj, path): 
     236        """ Write file data to the destination object. """ 
     237        if type(obj) == type(''): 
     238            data = obj         
     239        else: 
     240            format = '' 
     241            if hasattr(obj.aq_explicit, 'Format'): 
     242                format = obj.Format() 
     243            if obj.Type() in ['File', 'Image'] and hasattr(obj.aq_explicit, 'data'): 
     244                    data = obj.data 
     245            elif 'text/html' == format and hasattr(obj.aq_explicit, 'getText'): 
     246                    data = obj.getText() 
     247            elif format in ['text/plain', 'text/x-rst', 'text/structured'] and hasattr(obj.aq_explicit, 'getRawText'): 
     248                    data = obj.getRawText() 
     249            else: 
     250                data = '' 
     251 
     252        if self.destination: 
     253            self.destination.writeFile(path, data) 
     254 
     255    def _getAllObjects(self, context): 
     256        """ Get all sub objects. """ 
     257        objects = [obj.getObject() for obj in context.portal_catalog.searchResults(path={'query':('/'.join(context.getPhysicalPath())+'/'),'depth':-1})] 
     258        return [object for object in objects if not object.isPrincipiaFolderish or getattr(object.aq_explicit, 'getText', None)] 
     259 
     260    def _getChildrenObjects(self, parent, objects): 
     261        """ Get objects in current folder """ 
     262        parentpath = '/'.join(parent.getPhysicalPath()) 
     263        children = [] 
     264        for object in objects: 
     265            rpath = '/'.join(object.getPhysicalPath()).replace(parentpath, '') 
     266 
     267            if len(rpath.split('/')) == 1: 
     268                children.append(object) 
     269                        
     270        return children 
     271 
     272    def _getObjectPath(self, obj, context): 
     273        """ Get the path of an object. """ 
     274 
     275        root_path = context.aq_explicit.virtual_url_path() 
     276        obj_path = obj.aq_explicit.virtual_url_path() 
     277 
     278        if obj_path.find(root_path) != 0: 
     279            return '' 
     280 
     281        # Remove the path of the folder object 
     282        path = obj_path.replace(root_path, '') 
     283        if path and path[0] == '/': 
     284            path = path[1:] 
     285 
     286        if not path: 
     287            return '' 
     288 
     289        if hasattr(obj.aq_explicit, 'Format'): 
     290            if 'text/html' == obj.Format() and obj.isPrincipiaFolderish: 
     291                path += '.html' 
     292 
     293        return path 
     294 
     295    def _createPathId(self, path, pre='RES'): 
     296        """ Create a unique id given a path """ 
     297        return pre + str(md5.md5(path).hexdigest()) 
     298 
     299    def _getCopyrightString(self, copyright, rights_holder, rights_holder_email): 
     300        cp = '' 
     301        if copyright: 
     302            cp += copyright 
     303        if rights_holder: 
     304            if cp: 
     305                cp += ', ' 
     306            cp += rights_holder 
     307        if rights_holder_email: 
     308            if cp: 
     309                cp += ', ' 
     310            cp += rights_holder_email 
     311        return cp 
     312  
     313    def getObjSize(self, object): 
     314        """ Retrieves the correct size of the object""" 
     315        return '%d' %object.get_size() 
     316 
     317    def writeCustomMetadata(self, object): 
     318        """ Write the custom metdata for the package. Overridden at lower levels. """ 
     319 
     320        return 
     321     
Note: See TracChangeset for help on using the changeset viewer.