1: """ Classes for managing metadata"""
2:
3: from OFS.SimpleItem import SimpleItem
4: from Globals import InitializeClass,package_home
5: from OFS.Folder import Folder
6: from AccessControl import ClassSecurityInfo
7: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
8: import os.path
9: import sys
10: import xml.dom.minidom
11: import xml.dom.pulldom
12: import OSAS_helpers
13: import logging
14:
15: #ersetzt logging
16: def logger(txt,method,txt2):
17: """logging"""
18: logging.info(txt+ txt2)
19:
20:
21: import string
22: try:
23: from xml.xpath import Evaluate
24: except:
25: from Ft.Xml.XPath import Evaluate
26: import xmlrpclib
27:
28: from types import *
29:
30: class OSAS_MetadataMapping(SimpleItem):
31: """Einfaches Mapping Object"""
32:
33: meta_type="OSAS_MetadataMapping__neu"
34:
35: def readFieldsFromParent(self):
36: """read all elements from root"""
37:
38: return self.aq_parent.fieldList
39:
40: def __init__(self,id,title,arglist):
41: """init
42: @param id: id
43: @param title: title fuer zope navigation
44: @param arglist: dictionary mit Namen der zugelassenen generische Metadaten als key und Tripel als Werte (human readable, tag version,explanation
45: """
46: self.id=id
47: self.title=title
48: for fieldName in arglist.keys():
49: setattr(self,"md_"+fieldName,arglist[fieldName])
50:
51:
52: manage_options = SimpleItem.manage_options+(
53: {'label':'Main Config','action':'changeMetadataMappingForm'},
54: )
55:
56:
57: def showSetXML(self,RESPONSE=None):
58: """prints out the mapping as XML"""
59: ret="""<set name="%s">"""%self.title
60: for fieldName in self.readFieldsFromParent():
61: entry=getattr(self,"md_"+fieldName)
62: if entry[2]=="": # no explanation of this field
63: ret+="""<entry genericName="%s" tag="%s" label="%s"/>"""%(fieldName,entry[0],entry[1])
64: else:
65: ret+="""<entry genericName="%s" tag="%s" label="%s">%s</entry>"""%(fieldName,entry[0],entry[1],entry[2])
66: ret+="</set>"
67:
68: if not RESPONSE:
69: return ret
70: else:
71: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
72: return ret
73:
74: def getValue(self,fieldName):
75: """get md value
76: @param fieldName: Bezeichnung des gesuchten Metadatums
77: @retunr: Value des Metadatums"""
78:
79: ret= getattr(self,"md_"+fieldName,(None,None,None,None,None))
80: if len(ret)!= 4: # alte MD haben keine info ueber optional/required und listen werte
81: ret=ret+("","")
82: return ret
83:
84:
85: def isEmptyValue(self,fieldName):
86: """teste ob fielname in diesem Metadatenschema definiert ist"""
87: field=getattr(self,"md_"+fieldName,'')
88: if field[1]=='':
89: return 0
90: else:
91: return 1
92:
93: def generateMappingHash(self):
94: """erzeugen des dictionaries: generisches Feld -> Definition in diesem Schema"""
95: hash={}
96: for field in self.fieldList:
97: hash[field]=getattr(self,"md_"+field)
98: return hash
99:
100:
101:
102: def changeMetadataMappingForm(self):
103: """change"""
104: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMetadataMapping.zpt')).__of__(self)
105: return pt()
106:
107: def changeMetadataMapping(self,titleOfObject,RESPONSE=None):
108: """change"""
109:
110: self.title=titleOfObject
111: arglist=self.REQUEST.form
112:
113: for fieldName in self.readFieldsFromParent():
114: setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName],arglist['status_'+fieldName],arglist['values_'+fieldName]))
115:
116:
117: if RESPONSE is not None:
118: RESPONSE.redirect('manage_main')
119:
120: manage_workspace=changeMetadataMappingForm
121:
122: def manage_addMetadataMappingForm(self):
123: """interface for adding the OSAS_root"""
124: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataMappingForm.zpt')).__of__(self)
125:
126: return pt()
127:
128: def manage_addMetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
129: """add the OSAS_root"""
130:
131: argList={}
132: for arg in self.fieldList:
133: if not (arg in ['idOfObject','titleOfObject']):
134: argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg],self.REQUEST.form['status_'+arg],self.REQUEST.form['values_'+arg])
135:
136: newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList)
137: self._setObject(idOfObject,newObj)
138: if RESPONSE is not None:
139: RESPONSE.redirect('manage_main')
140:
141:
142:
143: class OSAS_Metadata(Folder):
144: """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
145: security=ClassSecurityInfo()
146:
147: def __init__(self,id,shortDescription,description,fields):
148: """initialize a new instance"""
149: self.id = id
150: self.shortDescription =shortDescription #label fuer link auf add page
151: self.description=description #description of the method for link page
152: self.fieldList=fields.split(",")[0:]
153:
154: meta_type='OSAS_Metadata__neu'
155:
156: manage_options = Folder.manage_options+(
157: {'label':'Main Config','action':'changeMetadataForm'},
158: {'label':'Import XML Schema','action':'importXMLSchemaForm'},
159: {'label':'Select Fields for Display','action':'indicateDisplayFieldsForm'},
160: )
161:
162: def showGenericXML(self,RESPONSE=None):
163: """show generic fields as XML"""
164: ret="""<set name="%s">"""%"generic"
165: for field in self.fieldList:
166: ret+="""<entry genericName="%s"/>"""%field
167:
168: ret+="</set>"
169:
170: if not RESPONSE:
171: return ret
172: else:
173: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
174: return ret
175:
176: def showOverviewXML(self,RESPONSE):
177: """gives an overview over the Metadata stored in this folder"""
178: ret="""<metadata name="%s">"""%self.getId()
179: ret+=self.showGenericXML()
180: for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping']):
181: ret+=entry[1].showSetXML()
182:
183: ret+="</metadata>"
184:
185: if not RESPONSE:
186: return ret
187: else:
188: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
189: return ret
190:
191: def generateMappingList(self):
192: """Erzeuge Mapping"""
193: mapping={}
194:
195: for dict in self.__dict__:
196: #print dict
197: obj=getattr(self,dict)
198: if hasattr(obj,'meta_type'):
199: if obj.meta_type=="OSAS_MetadataMapping__neu":
200: mapping[obj.getId()]=obj.generateMappingHash()
201:
202: return mapping
203:
204: def generateMappingForType(self,type,clean="yes"):
205: """erzeuge spezifisches Mapping"""
206:
207: hash=self.generateMappingList()
208:
209: for key in hash.keys():
210: if (key.lower() == type.lower()):
211: if clean=="yes":
212: temp={}
213: for x in hash[key].keys():
214: if not hash[key][x]=="":
215: temp[x]=hash[key][x]
216: return temp
217: else:
218:
219: return hash[key]
220:
221: return {}
222:
223: def getFieldList(self):
224: """erzeuge string aus fields"""
225: try:
226: return string.join(self.fieldList,",")
227: except:
228: return ""
229:
230: security.declarePublic('getFields')
231: def getFields(self):
232: """ausgabe der Felder"""
233: return self.fieldList
234:
235: def getTypeTitle(self,id):
236: """Title von ID"""
237: try:
238: obj=getattr(self,id)
239: return obj.title
240: except:
241: return id
242:
243: def getType(self,type):
244: """gib metadataobject type zurueck"""
245:
246: for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping__neu']):
247: if obj[0]==type:
248: return obj
249: return (self.id,self)
250:
251:
252:
253: def getStoredTypes(self):
254: """Gebe gespeicherte typen zurück"""
255:
256: types=[]
257:
258: for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping__neu']):
259: if obj[1].title=="":
260: title=obj[1].id
261: else:
262: title=obj[1].title
263: types.append((obj[1].id, title, obj[1]))
264:
265: return types
266:
267: def indicateDisplayFieldsForm(self):
268: """form zur Makierung der Felder die in der Browserumgebung angezeigt werden"""
269: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','indicateDisplayFieldsForm.zpt')).__of__(self)
270: return pt()
271:
272: def indicateDisplayFields(self,displayFields,RESPONSE=None):
273: """set Displayfields
274: @param displayFields: Liste von Felder die im Browserenvironment angezeigt werden
275: """
276: self.displayFields=OSAS_helpers.toList(displayFields)
277: if RESPONSE is not None:
278: RESPONSE.redirect('manage_main')
279:
280: def getDisplayFieldsAsStr(self,indexMeta):
281: ret=[]
282: try:
283: if indexMeta and not (indexMeta==""):
284: dom=xml.dom.pulldom.parseString(indexMeta)
285:
286: for (event,node) in dom:
287:
288: if event == xml.dom.pulldom.START_ELEMENT and node.tagName=="bib":
289: dom.expandNode(node)
290:
291: try:
292: type=node.getAttribute('type')
293: mapping=getattr(self,type).generateMappingHash()
294: except:
295: type='generic'
296: mapping=getattr(self,type).generateMappingHash()
297:
298: for field in self.displayFields:
299: try:
300: ret.append(OSAS_helpers.getText(node.getElementsByTagName(mapping[field][0])[0].childNodes))
301: except:
302: """nothing"""
303:
304: return "; ".join(ret)
305: else:
306: return ""
307: except:
308: return ""
309: def getDisplayFieldsAsStrOLD(self,indexMeta):
310: """Gebe display fields als string zurück
311: @param path: Pfad zum Object
312: """
313: ret=[]
314: try:
315: dom=xml.dom.minidom.parseString(indexMeta)
316: except:
317: logger("OSAS_metadata (getDisplayFieldsAsStr)",logging.INFO,"Cannot parse: %s"%indexMeta)
318: try:
319: bib = dom.getElementsByTagName("meta")[0].getElementsByTagName("bib")[0]
320: except:
321: return ""
322: try:
323: type=bib.getAttribute('type')
324: mapping=getattr(self,type).generateMappingHash()
325: except:
326: type='generic'
327: mapping=getattr(self,type).generateMappingHash()
328:
329: for field in self.displayFields:
330: try:
331: ret.append(OSAS_helpers.getText(bib.getElementsByTagName(mapping[field][0])[0].childNodes))
332: except:
333: """nothing"""
334:
335: return "; ".join(ret)
336:
337: security.declarePublic('changeMetadataForm')
338: def changeMetadataForm(self):
339: """Main configuration"""
340: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMetadata.zpt')).__of__(self)
341: return pt()
342:
343: security.declarePublic('changeMetadata')
344: def changeMetadata(self,shortDescription,description,fields,RESPONSE=None):
345: """Change Metadata"""
346: self.shortDescription=shortDescription
347: self.description=description
348: self.fieldList=fields.split(",")[0:]
349: if RESPONSE is not None:
350: RESPONSE.redirect('manage_main')
351:
352: security.declarePublic('index_html')
353:
354: def importXMLSchemaForm(self):
355: """form"""
356: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importXMLSchemaForm.zpt')).__of__(self)
357: return pt()
358:
359:
360: def importXMLSchema(self,file,RESPONSE=None):
361: """import xmlschema, Metadatenschema wird eingelesen und entsprechende Metadatenmappings angelegt."""
362:
363: dom=xml.dom.minidom.parse(file)
364: sets=dom.getElementsByTagName('set')
365: #erster schritt: anlegen der fieldlist
366: for set in sets:
367: if set.getAttribute('name')=='generic':
368: list=[]
369: for entry in set.getElementsByTagName('entry'):
370: list.append(entry.getAttribute('genericName'))
371: self.fieldList=list[0:]
372:
373: #zweiter schritt: anlegen der mapping
374: for set in sets:
375: id=set.getAttribute('name').encode('utf-8')
376: list=[]
377: argList={}
378: for entry in set.getElementsByTagName('entry'):
379: genericName=entry.getAttribute('genericName')
380: tag=entry.getAttribute('tag')
381: label=entry.getAttribute('label')
382: description=OSAS_helpers.getText(entry.childNodes)
383: argList[genericName]=(tag,label,description)
384: self._setObject(id,OSAS_MetadataMapping(id,id,argList))
385: if RESPONSE:
386: RESPONSE.write("Wrote: %s"%id)
387:
388:
389: def createMetadataFragment(self,type,path,prefix="",presets={}):
390: """fragment"""
391: self.REQUEST.SESSION['MDF_type']=type
392: self.REQUEST.SESSION['MDF_path']=path
393: self.REQUEST.SESSION['MDF_prefix']=prefix
394: self.REQUEST.SESSION['MDF_presets']=presets
395:
396: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm_fragment.zpt')).__of__(self)
397: return pt()
398:
399: def createMetadataForm(self,type="",path=""):
400: """createMetadataForm"""
401: self.REQUEST.SESSION['MDF_type']=type
402: self.REQUEST.SESSION['MDF_path']=path
403:
404:
405: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm_template.zpt')).__of__(self)
406: return pt()
407:
408: def readMetadata(self,MDF_path,MDF_type,MDF_prefix="",MDF_xpathStart="", MDF_addPath=None,MDF_identifyFields=None,newdoc=None,actualNode=None):
409:
410: if type(MDF_path)==ListType:
411: MDF_path=MDF_path[0]
412:
413: indexFile=os.path.join(MDF_path,'index.meta')
414:
415: server=xmlrpclib.Server(self.serverUrl)
416:
417: documentStr=server.getFile(indexFile)
418:
419: if documentStr:
420: newdoc=xml.dom.minidom.parseString(documentStr)
421: dom=newdoc.documentElement
422: actualNode=dom
423: else:
424: return {}
425:
426: if self.containerTag=="":
427: containerTag="doc"
428: else:
429: containerTag=self.containerTag
430:
431: if MDF_xpathStart=="":
432: dom=newdoc.documentElement
433: actualNode=dom
434: else:
435: #try to find xpath
436: if MDF_identifyFields:
437: query=[]
438: for field in MDF_identifyFields.keys():
439:
440: query.append("""(%s="%s")"""%(field,MDF_identifyFields[field]))
441: querystr=" and ".join(query)
442: xpathStr=MDF_xpathStart+"[%s]"%querystr
443:
444: else:
445: xpathStr=MDF_xpathStart
446:
447:
448: xpathNodes=Evaluate(xpathStr,actualNode)
449:
450:
451: if len(xpathNodes)>0:
452: actualNode=xpathNodes[0]
453: else:
454: return {}
455:
456: ret={}
457: for node in actualNode.childNodes:
458: name=node.tagName
459: text=OSAS_helpers.getText(node.childNodes)
460: ret[name]=text
461:
462: return ret
463:
464: def writeMetadata(self,MDF_path,MDF_type,form,MDF_prefix="",MDF_xpathStart="", MDF_addPath=None,MDF_identifyFields=None,newdoc=None,actualNode=None):
465: """writeMetadata"""
466: #MDF_path="/tmp/index.meta"
467: if type(MDF_path)==ListType:
468: MDF_path=MDF_path[0]
469:
470:
471: indexFile=os.path.join(MDF_path,'index.meta')
472:
473: server=xmlrpclib.Server(self.serverUrl)
474: if newdoc:
475: if not actualNode: actualNode=newdoc
476: dom=newdoc
477: else:
478: documentStr=server.getFile(indexFile)
479:
480: if documentStr:
481:
482: newdoc=xml.dom.minidom.parseString(documentStr)
483: dom=newdoc.documentElement
484: actualNode=dom
485:
486:
487: else:
488:
489: impl=xml.dom.minidom.getDOMImplementation()
490: newdoc=None
491:
492:
493: if self.containerTag=="":
494: containerTag="doc"
495: else:
496: containerTag=self.containerTag
497:
498: create=None
499: if MDF_xpathStart=="":
500: if not newdoc:
501: newdoc=impl.createDocument(None,containerTag,None)
502: dom=newdoc.documentElement
503: actualNode=dom
504: else:
505:
506: #try to find xpath
507: if MDF_identifyFields:
508: query=[]
509: for field in MDF_identifyFields:
510:
511: query.append("""(%s="%s")"""%(field,form[MDF_prefix+"MD_"+field]))
512: querystr=" and ".join(query)
513: xpathStr=MDF_xpathStart+"[%s]"%querystr
514:
515: else:
516: xpathStr=MDF_xpathStart
517:
518:
519: xpathNodes=Evaluate(xpathStr,actualNode)
520:
521:
522:
523:
524: if len(xpathNodes)>0:
525: actualNode=xpathNodes[0]
526:
527: else:
528: #existiert nicht dann neue erzeugen
529:
530: if len(Evaluate(MDF_xpathStart,dom))>0:
531:
532: create=True
533:
534: splitted=MDF_xpathStart.split("/")
535: base=""
536: for element in splitted:
537:
538: if not (element=="") and not (element==containerTag):
539: base="/".join([base,element])
540:
541: if not newdoc:
542: newdoc=impl.createDocument(None,element,None)
543: actualNode=newdoc.documentElement
544: dom=actualNode
545: else:
546: changed=None
547:
548: if not (MDF_addPath==base):
549:
550:
551: for childNode in actualNode.childNodes:
552: if getattr(childNode,'tagName','')==element:
553: actualNode=childNode
554: changed=1
555:
556: if (os.path.normpath("/".join(["",containerTag,base]))==MDF_xpathStart) and create:
557: actualNode=actualNode.parentNode
558: changed=None
559:
560: if not changed:
561: namenode=newdoc.createElement(element)
562:
563: actualNode.appendChild(namenode)
564: actualNode=namenode
565:
566:
567:
568:
569: for name in self.REQUEST.form.keys():
570: length=len(MDF_prefix)
571: if MDF_type and not (MDF_type == ""):
572: actualNode.setAttribute("type",MDF_type)
573: if name[0:3+length]==MDF_prefix+"MD_":
574: tagName=name[3+length:]
575:
576: #CHECK if element exists
577: for childNode in actualNode.childNodes:
578: if getattr(childNode,'tagName','')==tagName:
579: actualNode.removeChild(childNode).unlink()
580:
581: namenode=newdoc.createElement(tagName)
582: namenodetext=newdoc.createTextNode(self.REQUEST.form[name])
583: namenode.appendChild(namenodetext)
584: actualNode.appendChild(namenode)
585:
586: ret=newdoc.toxml(encoding='utf-8')
587: zLOG.LOG("OSAS_metadata (writeMetadata)",zLOG.INFO,"write: %s"%ret)
588:
589:
590: server.writeMetaDataFile(indexFile,ret)
591:
592:
593: return newdoc,actualNode
594:
595: def writeMetadataFile(self,MDF_path,MDF_type,MDF_xpathStart="",newdoc=None,actualNode=None):
596: """writeMetaFile"""
597:
598: return self.writeMetadata(MDF_path,MDF_type,self.REQUEST.form,MDF_xpathStart=MDF_xpathStart,newdoc=newdoc,actualNode=actualNode)
599:
600:
601: def isEmptyValue(self,fieldName):
602: """im generischen fall stets falsch"""
603: return 1
604:
605: def getValue(self,fieldName):
606: """im generischen fall gleich fieldname"""
607: return fieldName,fieldName,"","",""
608:
609: def getList(self,list):
610: """return list"""
611:
612: if list=="":
613: return None
614: listsplit=[i.rstrip() for i in list.split("\n")]
615: return listsplit
616:
617: def showHelp(self,refType,genericTag):
618: """helptext"""
619: for reference in self.ZopeFind(self):
620: if reference[1].title==refType:
621: text=getattr(reference[1],'md_'+genericTag)[2]
622: return text
623: return "NO EXPLANATION"
624:
625: def showHelpTag(self,url,reftype,item):
626: """gen javascript for showhelp"""
627: url2=url+'/showHelp?refType=%s&genericTag=%s'%(reftype,item)
628: ret="""javascript:wd=window.open(\'%s\',\'Help\',\'width=300,height=250\');void(\'\');wd.focus();"""%url2
629: return ret
630:
631:
632: def manage_addMetadataForm(self):
633: """interface for adding the OSAS_add_Metadata"""
634: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm.zpt')).__of__(self)
635: return pt()
636:
637: def manage_addMetadata(self,id,shortDescription,description,fields,RESPONSE=None):
638: """add the OSAS_root"""
639: newObj=OSAS_Metadata(id,shortDescription,description,fields)
640: self.Destination()._setObject(id,newObj)
641: if RESPONSE is not None:
642: RESPONSE.redirect('manage_main')
643:
644:
645: InitializeClass(OSAS_Metadata)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to OSAS_metadata.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / OSA_system2