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 xml.dom.minidom
10: import OSAS_helpers
11: import logging
12:
13: #ersetzt logging
14: def logger(txt,method,txt2):
15: """logging"""
16: logging.info(txt+ txt2)
17:
18:
19:
20: class OSAS_MetadataMapping(SimpleItem):
21: """Einfaches Mapping Object"""
22:
23: meta_type="OSAS_MetadataMapping__neu"
24:
25: def readFieldsFromParent(self):
26: """read all elements from root"""
27:
28: return self.aq_parent.fieldList
29:
30: def __init__(self,id,title,arglist):
31: """init
32: @param id: id
33: @param title: title fuer zope navigation
34: @param arglist: dictionary mit Namen der zugelassenen generische Metadaten als key und Tripel als Werte (human readable, tag version,explanation
35: """
36: self.id=id
37: self.title=title
38: for fieldName in arglist.keys():
39: setattr(self,"md_"+fieldName,arglist[fieldName])
40:
41:
42: manage_options = SimpleItem.manage_options+(
43: {'label':'Main Config','action':'changeMetadataMappingForm'},
44: )
45:
46:
47: def showSetXML(self,RESPONSE=None):
48: """prints out the mapping as XML"""
49: ret="""<set name="%s">"""%self.title
50: for fieldName in self.readFieldsFromParent():
51: entry=getattr(self,"md_"+fieldName)
52: if entry[2]=="": # no explanation of this field
53: ret+="""<entry genericName="%s" tag="%s" label="%s"/>"""%(fieldName,entry[0],entry[1])
54: else:
55: ret+="""<entry genericName="%s" tag="%s" label="%s">%s</entry>"""%(fieldName,entry[0],entry[1],entry[2])
56: ret+="</set>"
57:
58: if not RESPONSE:
59: return ret
60: else:
61: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
62: return ret
63:
64: def getValue(self,fieldName):
65: """get md value
66: @param fieldName: Bezeichnung des gesuchten Metadatums
67: @retunr: Value des Metadatums"""
68:
69: return getattr(self,"md_"+fieldName,(None,None,None))
70:
71:
72: def isEmptyValue(self,fieldName):
73: """teste ob fielname in diesem Metadatenschema definiert ist"""
74: field=getattr(self,"md_"+fieldName,'')
75: if field[1]=='':
76: return 0
77: else:
78: return 1
79:
80: def generateMappingHash(self):
81: """erzeugen des dictionaries: generisches Feld -> Definition in diesem Schema"""
82: hash={}
83: for field in self.fieldList:
84: hash[field]=getattr(self,"md_"+field)
85: return hash
86:
87:
88:
89: def changeMetadataMappingForm(self):
90: """change"""
91: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMetadataMapping.zpt')).__of__(self)
92: return pt()
93:
94: def changeMetadataMapping(self,titleOfObject,RESPONSE=None):
95: """change"""
96:
97: self.title=titleOfObject
98: arglist=self.REQUEST.form
99:
100: for fieldName in self.readFieldsFromParent():
101: setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName]))
102:
103:
104: if RESPONSE is not None:
105: RESPONSE.redirect('manage_main')
106:
107:
108:
109: def manage_addMetadataMappingForm(self):
110: """interface for adding the OSAS_root"""
111: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataMappingForm.zpt')).__of__(self)
112:
113: return pt()
114:
115: def manage_addMetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
116: """add the OSAS_root"""
117:
118: argList={}
119: for arg in self.fieldList:
120: if not (arg in ['idOfObject','titleOfObject']):
121: argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg])
122:
123: newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList)
124: self._setObject(idOfObject,newObj)
125: if RESPONSE is not None:
126: RESPONSE.redirect('manage_main')
127:
128:
129:
130: class OSAS_Metadata(Folder):
131: """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
132: security=ClassSecurityInfo()
133:
134: def __init__(self,id,linklabel,description,fields):
135: """initialize a new instance"""
136: self.id = id
137: self.linklabel =linklabel #label fuer link auf add page
138: self.description=description #description of the method for link page
139: self.fieldList=fields.split(",")[0:]
140:
141: meta_type='OSAS_Metadata__neu'
142:
143: manage_options = Folder.manage_options+(
144: {'label':'Main Config','action':'changeMetadataForm'},
145: {'label':'Import XML Schema','action':'importXMLSchemaForm'},
146: {'label':'Select Fields for Display','action':'indicateDisplayFieldsForm'},
147: )
148:
149: def showGenericXML(self,RESPONSE=None):
150: """show generic fields as XML"""
151: ret="""<set name="%s">"""%"generic"
152: for field in self.fieldList:
153: ret+="""<entry genericName="%s"/>"""%field
154:
155: ret+="</set>"
156:
157: if not RESPONSE:
158: return ret
159: else:
160: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
161: return ret
162:
163: def showOverviewXML(self,RESPONSE):
164: """gives an overview over the Metadata stored in this folder"""
165: ret="""<metadata name="%s">"""%self.getId()
166: ret+=self.showGenericXML()
167: for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping']):
168: ret+=entry[1].showSetXML()
169:
170: ret+="</metadata>"
171:
172: if not RESPONSE:
173: return ret
174: else:
175: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
176: return ret
177:
178: def generateMappingList(self):
179: """Erzeuge Mapping"""
180: mapping={}
181: for dict in self.__dict__:
182: #print dict
183: obj=getattr(self,dict)
184: if hasattr(obj,'meta_type'):
185: if obj.meta_type=="OSAS_MetadataMapping":
186: mapping[obj.getId()]=obj.generateMappingHash()
187: return mapping
188:
189: def generateMappingForType(self,type,clean="yes"):
190: """erzeuge spezifisches Mapping"""
191: hash=self.generateMappingList()
192: if hash.has_key(type):
193: if clean=="yes":
194: temp={}
195: for x in hash[type].keys():
196: if not hash[type][x]=="":
197: temp[x]=hash[type][x]
198: return temp
199: else:
200: return hash[type]
201:
202: else:
203: return {}
204:
205: def getFieldList(self):
206: """erzeuge string aus fields"""
207: try:
208: return string.join(self.fieldList,",")
209: except:
210: return ""
211:
212: def getFields(self):
213: """ausgabe der Felder"""
214: return self.fieldList
215:
216: def getTypeTitle(self,id):
217: """Title von ID"""
218: try:
219: obj=getattr(self,id)
220: return obj.title
221: except:
222: return id
223:
224: def getStoredTypes(self):
225: """Gebe gespeicherte typen zurück"""
226:
227: types=[]
228:
229: for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping_neu']):
230: if obj.title=="":
231: title=obj.id
232: else:
233: title=obj.title
234: types.append((obj.id,title))
235:
236: return types
237:
238: def indicateDisplayFieldsForm(self):
239: """form zur Makierung der Felder die in der Browserumgebung angezeigt werden"""
240: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','indicateDisplayFieldsForm.zpt')).__of__(self)
241: return pt()
242:
243: def indicateDisplayFields(self,displayFields,RESPONSE=None):
244: """set Displayfields
245: @param displayFields: Liste von Felder die im Browserenvironment angezeigt werden
246: """
247: self.displayFields=OSAS_helpers.toList(displayFields)
248: if RESPONSE is not None:
249: RESPONSE.redirect('manage_main')
250:
251: def getDisplayFieldsAsStr(self,indexMeta):
252: """Gebe display fields als string zurück
253: @param path: Pfad zum Object
254: """
255: ret=[]
256: try:
257: dom=xml.dom.minidom.parseString(indexMeta)
258: except:
259: logger("OSAS_metadata (getDisplayFieldsAsStr)",logging.INFO,"Cannot parse: %s"%indexMeta)
260: try:
261: bib = dom.getElementsByTagName("meta")[0].getElementsByTagName("bib")[0]
262: except:
263: return ""
264: try:
265: type=bib.getAttribute('type')
266: mapping=getattr(self,type).generateMappingHash()
267: except:
268: type='generic'
269: mapping=getattr(self,type).generateMappingHash()
270:
271: for field in self.displayFields:
272: try:
273: ret.append(OSAS_helpers.getText(bib.getElementsByTagName(mapping[field][0])[0].childNodes))
274: except:
275: """nothing"""
276:
277: return "; ".join(ret)
278:
279: security.declarePublic('changeMetadataForm')
280: def changeMetadataForm(self):
281: """Main configuration"""
282: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMetadata.zpt')).__of__(self)
283: return pt()
284:
285: security.declarePublic('changeMetadata')
286: def changeMetadata(self,linklabel,description,fields,RESPONSE=None):
287: """Change Metadata"""
288: self.linklabel=linklabel
289: self.description=description
290: self.fieldList=fields.split(",")[0:]
291: if RESPONSE is not None:
292: RESPONSE.redirect('manage_main')
293:
294: security.declarePublic('index_html')
295:
296: def importXMLSchemaForm(self):
297: """form"""
298: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importXMLSchemaForm.zpt')).__of__(self)
299: return pt()
300:
301: def importXMLSchema(self,file,RESPONSE=None):
302: """import xmlschema, Metadatenschema wird eingelesen und entsprechende Metadatenmappings angelegt."""
303:
304: dom=xml.dom.minidom.parse(file)
305: sets=dom.getElementsByTagName('set')
306: #erster schritt: anlegen der fieldlist
307: for set in sets:
308: if set.getAttribute('name')=='generic':
309: list=[]
310: for entry in set.getElementsByTagName('entry'):
311: list.append(entry.getAttribute('genericName'))
312: self.fieldList=list[0:]
313:
314: #zweiter schritt: anlegen der mapping
315: for set in sets:
316: id=set.getAttribute('name').encode('utf-8')
317: list=[]
318: argList={}
319: for entry in set.getElementsByTagName('entry'):
320: genericName=entry.getAttribute('genericName')
321: tag=entry.getAttribute('tag')
322: label=entry.getAttribute('label')
323: description=OSAS_helpers.getText(entry.childNodes)
324: argList[genericName]=(tag,label,description)
325: self._setObject(id,OSAS_MetadataMapping(id,id,argList))
326: if RESPONSE:
327: RESPONSE.write("Wrote: %s"%id)
328:
329:
330: def manage_addMetadataForm(self):
331: """interface for adding the OSAS_add_Metadata"""
332: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm.zpt')).__of__(self)
333: return pt()
334:
335: def manage_addMetadata(self,id,linklabel,description,fields,RESPONSE=None):
336: """add the OSAS_root"""
337: newObj=OSAS_Metadata(id,linklabel,description,fields)
338: self.Destination()._setObject(id,newObj)
339: if RESPONSE is not None:
340: RESPONSE.redirect('manage_main')
341:
342:
343: InitializeClass(OSAS_Metadata)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to OSAS_metadata_old.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / OSA_system2