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