Mercurial > hg > MetaDataProvider

comparison MetaData.py @ 3:3dadf0d89261

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more renovation
author casties
date Tue, 26 Jul 2011 20:08:11 +0200
parents ac8e119b25ec
children 8291255b1868
comparison
equal deleted inserted replaced
2:ac8e119b25ec 3:3dadf0d89261
33 if node.nodeType == node.TEXT_NODE: 33 if node.nodeType == node.TEXT_NODE:
34 rc = rc + node.data 34 rc = rc + node.data
35 return rc 35 return rc
36 36
37 37
38 def normalizeBibtype(bt): 38 def normalizeBibField(bt, underscore=True):
39 """returns normalised bib type for looking up mappings""" 39 """returns normalised bib type for looking up mappings"""
40 bt = bt.strip().replace(' ', '-').lower() 40 bt = bt.strip().replace(' ', '-').lower()
41 if underscore:
42 bt = bt.replace('_', '-')
43
41 return bt 44 return bt
42 45
43 def getBibdataFromDom(dom): 46 def getBibdataFromDom(dom):
44 """returns dict with all elements from bib-tag""" 47 """returns dict with all elements from bib-tag"""
45 bibinfo = {} 48 bibinfo = {}
46 bib = dom.find(".//meta/bib") 49 bib = dom.find(".//meta/bib")
47 if bib is not None: 50 if bib is not None:
48 # put type in @type 51 # put type in @type
49 type = bib.get('type') 52 type = bib.get('type')
50 bibinfo['@type'] = normalizedBibtype(type) 53 bibinfo['@type'] = normalizeBibField(type)
51 # put all subelements in dict 54 # put all subelements in dict
52 for e in bib: 55 for e in bib:
53 bibinfo[e.tag] = getText(e) 56 bibinfo[normalizeBibField(e.tag)] = getText(e)
54 57
55 return bibinfo 58 return bibinfo
56 59
57 def toString(list): 60 def toString(list):
58 ret=u"" 61 ret=u""
100 meta_type='MetaData' 103 meta_type='MetaData'
101 security=ClassSecurityInfo() 104 security=ClassSecurityInfo()
102 manage_options = Folder.manage_options+( 105 manage_options = Folder.manage_options+(
103 {'label':'Main Config','action':'changeMetadataForm'}, 106 {'label':'Main Config','action':'changeMetadataForm'},
104 {'label':'Import XML Schema','action':'importMetaDataExportXML'}, 107 {'label':'Import XML Schema','action':'importMetaDataExportXML'},
105 {'label':'Select Fields for Display','action':'indicateDisplayFieldsForm'}, 108 #{'label':'Select Fields for Display','action':'indicateDisplayFieldsForm'},
106 ) 109 )
107 110
108 def __init__(self,id,shortDescription='',description='',fields=''): 111 def __init__(self,id,shortDescription='',description='',fields=''):
109 """initialize a new instance""" 112 """initialize a new instance"""
110 self.id = id 113 self.id = id
114 self.metaDataServerUrl="" # muss mit change metadata gesetzt werden 117 self.metaDataServerUrl="" # muss mit change metadata gesetzt werden
115 118
116 119
117 def correctPath(self,path,remove=None,prefix=None,cut=0): 120 def correctPath(self,path,remove=None,prefix=None,cut=0):
118 """convinience method um einen pfad zu veraendern""" 121 """convinience method um einen pfad zu veraendern"""
119
120 if remove is not None: 122 if remove is not None:
121 path=path.replace(remove,'') 123 path=path.replace(remove,'')
122 if prefix is not None: 124 if prefix is not None:
123 path=os.path.join(prefix,path) 125 path=os.path.join(prefix,path)
124 126
129 131
130 def importMetaDataExportXML(self,importFile=None,RESPONSE=None): 132 def importMetaDataExportXML(self,importFile=None,RESPONSE=None):
131 """imports metadata from the metadataexportxml file""" 133 """imports metadata from the metadataexportxml file"""
132 134
133 if importFile is None: 135 if importFile is None:
134 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMetaDataExportXML.zpt')).__of__(self) 136 pt=PageTemplateFile('zpt/importMetaDataExportXML', globals()).__of__(self)
135 return pt() 137 return pt()
136 138
137 dom=xml.dom.minidom.parse(importFile) 139 dom=ET.parse(importFile)
138 self.createMappingFromDom(dom.getElementsByTagName("metadataExport")[0]) 140 node = dom.getroot()
141 if node.tag != 'metadataExport':
142 node = dom.find("metadataExport")
143
144 self.createMappingFromDom(node)
139 145
140 if RESPONSE is not None: 146 if RESPONSE is not None:
141 RESPONSE.redirect('manage_main') 147 RESPONSE.redirect('manage_main')
142 148
143 149
145 """erzeuge ein Mapping aus dem der metadatanode des xmlformats, metadata ist ein metadataobject""" 151 """erzeuge ein Mapping aus dem der metadatanode des xmlformats, metadata ist ein metadataobject"""
146 152
147 if metadata is None: 153 if metadata is None:
148 metadata=self 154 metadata=self
149 155
150 nodes=metadatanode.childNodes 156 nodes=metadatanode
151 157
152 #erster schritt: anlegen der fieldlist
153 for node in nodes: 158 for node in nodes:
154 logging.debug("node: %s"%repr(node)) 159 logging.debug("node: %s"%repr(node))
155 if node.tagName=="set": 160 if node.tag=="set":
156 set=node 161 set=node
157 if set.getAttribute('name')=='generic': 162 id=set.get('name')
158 list=[] 163 list=[]
159 for entry in set.getElementsByTagName('entry'): 164 argList={}
160 list.append(entry.getAttribute('genericName')) 165 for entry in set:
161 metadata.fieldList=list[0:] 166 genericName=entry.get('genericName')
162 167 if set.get('name')=='generic':
163 else: 168 # generic mapping doesn't have labels
164 id=set.getAttribute('name').encode('utf-8') 169 tag = genericName
165 list=[] 170 label = genericName
166 argList={} 171 else:
167 for entry in set.getElementsByTagName('entry'): 172 tag=entry.get('tag')
168 genericName=entry.getAttribute('genericName') 173 label=entry.get('label')
169 tag=entry.getAttribute('tag') 174
170 label=entry.getAttribute('label') 175 if not tag:
171 description=getTextFromNode(entry.childNodes) #TODO: clean 176 # ignore empty tags
172 argList[genericName]=(tag,label,description) 177 continue
173 metadata._setObject(id,MetaDataMapping(id,id,argList)) 178
174 179 description=getText(entry)
175 elif node.tagName=="metadata": 180 argList[tag]={'tag':tag,'label':label,'explanation':description,'status':'optional'}
181
182 logging.debug("createMappingFromDom: new mapping=%s"%repr(argList))
183 metadata._setObject(id,MetaDataMapping(id,id,argList))
184
185 elif node.tag=="metadata":
176 mn=node 186 mn=node
177 name=mn.getAttribute('name').encode('utf-8') 187 name=mn.get('name')
188 logging.debug("createMappingFromDom: new metadata=%s"%repr(name))
178 metadata._setObject(name,MetaData(name,name)) 189 metadata._setObject(name,MetaData(name,name))
179 mdObj=getattr(metadata,name) 190 mdObj=getattr(metadata,name)
180 mdObj.createMappingFromDom(mn) 191 mdObj.createMappingFromDom(mn)
181
182 192
183 def getMDFromPathOrUrl(self,path): 193 def getMDFromPathOrUrl(self,path):
184 parsedurl = urlparse.urlparse(path) 194 parsedurl = urlparse.urlparse(path)
185 if parsedurl[0] != "": 195 if parsedurl[0] != "":
186 # has schema (e.g. http) 196 # has schema (e.g. http)
271 281
272 ret+="""<dc:%s>%s</dc:%s>"""%(md[0],xml.sax.saxutils.escape(md[1]),md[0]) 282 ret+="""<dc:%s>%s</dc:%s>"""%(md[0],xml.sax.saxutils.escape(md[1]),md[0])
273 ret+="</bib>" 283 ret+="</bib>"
274 return ret 284 return ret
275 285
286
287 def getBibMapping(self, bibtype):
288 """returns MetaDataMapping for bibtype"""
289 # try type as id
290 mapping = getattr(self.main.meta.bib, bibtype, None)
291 if mapping is None:
292 # try manually
293 mapFolder = self.main.meta.bib
294 for obj in mapFolder.objectValues():
295 if obj.meta_type == "MetadataMapping":
296 # real type is in title
297 mapType = obj.title
298 if mapType == bibtype:
299 # try type as is
300 return obj
301
302 if normalizeBibField(mapType, underscore=True) == normalizeBibField(bibtype, underscore=True):
303 # try normalized type without underscore
304 return obj
305
306 return mapping
276 307
277 def getBibFields(self, bibdata): 308 def getBibFields(self, bibdata):
278 """returns dict with metadata description for bibdata""" 309 """returns dict with metadata description for bibdata"""
310 bibfields = {}
279 bibtype = bibdata['@type'] 311 bibtype = bibdata['@type']
280 # get mapping from main/meta/bib 312 # get mapping from main/meta/bib
281 try: 313 mapping = self.getBibMapping(bibtype)
282 mapping=getattr(self.main.meta.bib, bibtype.lower()) 314 if mapping is None:
283 except: 315 logging.error("getBibFields: no mapping for type: %s"%bibtype)
284 logging.error("getStdMappedHash: no mapping for type: %s"%bibtype) 316 return bibfields
285 return mdHash 317
286 318 # get field descriptions (copy so we can change it)
287 # get field descriptions 319 bibfields = mapping.getFields().copy()
288 bibFields = mapping.getFields.copy()
289 # add field list 320 # add field list
290 bibFields['@fieldList'] = mapping.getFieldList() 321 bibfields['@fieldList'] = mapping.getFieldList()
291 322
292 return bibFields 323 return bibfields
293 324
294 325 def getBibMappedData(self, bibdata, allFields=False):
295 def getFormatted(self, template, path=None, dom=None, bibdata=None): 326 """returns dict with metadata descriptions and data for bibdata"""
327 bibfields = self.getBibFields(bibdata)
328 mappedData = {}
329 mappedList = []
330 for bk in bibfields.keys():
331 # ignore descriptions without data
332 if not bibdata.get(bk, None):
333 continue
334
335 # field description (copy so we can change it)
336 bf = bibfields[bk].copy()
337 # add value
338 bf['value'] = bibdata[bk]
339 mappedData[bk] = bf
340 mappedList.append(bk)
341
342 if allFields and len(mappedData) < len(bibdata):
343 # add fields that were not in bibfields
344 for bk in bibdata.keys():
345 if bk in mappedData or not bibdata[bk]:
346 continue
347
348 mappedData[bk] = {'tag':bk, 'label':bk, 'value':bibdata[bk]}
349 mappedList.append(bk)
350
351 mappedData['@fieldList'] = mappedList
352 return mappedData
353
354 def getFormatted(self, template, path=None, dom=None, bibdata=None, allFields=False):
296 """returns string with document data formatted according to template. 355 """returns string with document data formatted according to template.
297 gets data from server or dom or pre-parsed bibdata.""" 356 gets data from server or dom or pre-parsed bibdata."""
298 logging.debug("getFormatted(template=%s)"%(template)) 357 logging.debug("getFormatted(template=%s)"%(template))
299 358
300 if dom is None and bibdata is None: 359 if dom is None and bibdata is None:
319 if tp is None: 378 if tp is None:
320 logging.error("getFormatted: no generic template either: %s"%(template)) 379 logging.error("getFormatted: no generic template either: %s"%(template))
321 return "" 380 return ""
322 381
323 # put bib field descriptions in mdHash 382 # put bib field descriptions in mdHash
324 bibFields = self.getBibFields(bibdata) 383 bibfields = self.getBibMappedData(bibdata, allFields=allFields)
325 384
326 return tp(bibFields=bibFields, md=bibdata) 385 return tp(mdmap=bibfields, md=bibdata)
327 386
328 387
329 def getFormattedMetaData(self, path=None, dom=None, bibdata=None): 388 def getFormattedMetaData(self, path=None, dom=None, bibdata=None):
330 """get the metadafrom server""" 389 """get the metadafrom server"""
331 logging.debug("getFormattedMetaData(path=%s)"%path) 390 logging.debug("getFormattedMetaData(path=%s)"%path)
337 return self.getFormatted('metadata_template', path=path, dom=dom, bibdata=bibdata) 396 return self.getFormatted('metadata_template', path=path, dom=dom, bibdata=bibdata)
338 397
339 def getFormattedMetaDataExtended(self,path=None, dom=None, bibdata=None): 398 def getFormattedMetaDataExtended(self,path=None, dom=None, bibdata=None):
340 """get the metadafrom server""" 399 """get the metadafrom server"""
341 logging.debug("getFormattedMetaDataExtended(path=%s)"%path) 400 logging.debug("getFormattedMetaDataExtended(path=%s)"%path)
342 return self.getFormatted('metadata_extended_template', path=path, dom=dom, bibdata=bibdata) 401 return self.getFormatted('metadata_extended_template', path=path, dom=dom, bibdata=bibdata, allFields=True)
343 402
344 def getFormattedLabel(self,path=None, dom=None, bibdata=None): 403 def getFormattedLabel(self,path=None, dom=None, bibdata=None):
345 """get the metadafrom server""" 404 """get the metadafrom server"""
346 logging.debug("getFormattedLabel(%s)"%path) 405 logging.debug("getFormattedLabel(%s)"%path)
347 return self.getFormatted('label_template', path=path, dom=dom, bibdata=bibdata) 406 return self.getFormatted('label_template', path=path, dom=dom, bibdata=bibdata)
352 return self.getFormatted('metadata_template', path) 411 return self.getFormatted('metadata_template', path)
353 412
354 def getFormattedMetaDataExtendedFromServer(self,path): 413 def getFormattedMetaDataExtendedFromServer(self,path):
355 """get the metadafrom server""" 414 """get the metadafrom server"""
356 logging.debug("getFormattedMetaDataExtendedFromServer(path=%s)"%path) 415 logging.debug("getFormattedMetaDataExtendedFromServer(path=%s)"%path)
357 return self.getFormatted('metadata_extended_template', path) 416 return self.getFormatted('metadata_extended_template', path=path, allFields=True)
358 417
359 def getFormattedLabelFromServer(self,path): 418 def getFormattedLabelFromServer(self,path):
360 """get the metadafrom server""" 419 """get the metadafrom server"""
361 logging.debug("getFormattedLabelFromServer(%s)"%path) 420 logging.debug("getFormattedLabelFromServer(%s)"%path)
362 return self.getFormatted('label_template', path) 421 return self.getFormatted('label_template', path)