|
4
|
1 from OFS.Folder import Folder
|
|
|
2 from Products.PageTemplates.PageTemplateFile import PageTemplateFile
|
|
|
3 from Globals import package_home
|
|
|
4 from AccessControl import ClassSecurityInfo
|
|
|
5 import os.path
|
|
|
6 import logging
|
|
|
7
|
|
|
8 from MetaDataMapping import MetaDataMapping
|
|
|
9 from MetaData import MetaData
|
|
|
10
|
|
|
11 def normalizeBibField(bt, underscore=True):
|
|
|
12 """returns normalised bib type for looking up mappings"""
|
|
|
13 bt = bt.strip().replace(' ', '-').lower()
|
|
|
14 if underscore:
|
|
|
15 bt = bt.replace('_', '-')
|
|
|
16
|
|
|
17 return bt
|
|
|
18
|
|
|
19 def getBibdataFromDom(dom):
|
|
|
20 """returns dict with all elements from bib-tag"""
|
|
|
21 bibinfo = {}
|
|
|
22 bib = dom.find(".//meta/bib")
|
|
|
23 if bib is not None:
|
|
|
24 # put type in @type
|
|
|
25 type = bib.get('type')
|
|
|
26 bibinfo['@type'] = normalizeBibField(type)
|
|
|
27 # put all subelements in dict
|
|
|
28 for e in bib:
|
|
|
29 bibinfo[normalizeBibField(e.tag)] = getText(e)
|
|
|
30
|
|
|
31 return bibinfo
|
|
|
32
|
|
|
33 class MetaDataFolder(Folder):
|
|
|
34 """provides methods for managing complete metadata structures"""
|
|
|
35 meta_type='MetaDataFolder'
|
|
|
36 security=ClassSecurityInfo()
|
|
|
37 manage_options = Folder.manage_options+(
|
|
|
38 {'label':'Main Config','action':'changeMetadataFolderForm'},
|
|
|
39 {'label':'Import XML Schema','action':'importMetaDataExportXML'},
|
|
|
40 #{'label':'Select Fields for Display','action':'indicateDisplayFieldsForm'},
|
|
|
41 )
|
|
|
42
|
|
|
43 def __init__(self,id,title=''):
|
|
|
44 """initialize a new instance"""
|
|
|
45 self.id = id
|
|
|
46 self.title = title
|
|
|
47 self.metaDataServerUrl="" # muss mit change metadata gesetzt werden
|
|
|
48
|
|
|
49
|
|
|
50 def getMDFromPathOrUrl(self,path):
|
|
|
51 parsedurl = urlparse.urlparse(path)
|
|
|
52 if parsedurl[0] != "":
|
|
|
53 # has schema (e.g. http)
|
|
|
54 url=path
|
|
|
55 else:
|
|
|
56 # path only
|
|
|
57 if path.endswith("index.meta"):
|
|
|
58 url =self.metaDataServerUrl%path
|
|
|
59 else:
|
|
|
60 url=os.path.join(self.metaDataServerUrl%path,'index.meta')
|
|
|
61
|
|
|
62 #logging.debug("get Metadata: %s"%url)
|
|
|
63 md = getHttpData(url)
|
|
|
64 return md
|
|
|
65
|
|
|
66 def getBibMapping(self, bibtype):
|
|
|
67 """returns MetaDataMapping for bibtype"""
|
|
|
68 # try type as id
|
|
|
69 mapping = getattr(self.main.meta.bib, bibtype, None)
|
|
|
70 if mapping is None:
|
|
|
71 # try manually
|
|
|
72 mapFolder = self.main.meta.bib
|
|
|
73 for obj in mapFolder.objectValues():
|
|
|
74 if obj.meta_type == "MetadataMapping":
|
|
|
75 # real type is in title
|
|
|
76 mapType = obj.title
|
|
|
77 if mapType == bibtype:
|
|
|
78 # try type as is
|
|
|
79 return obj
|
|
|
80
|
|
|
81 if normalizeBibField(mapType, underscore=True) == normalizeBibField(bibtype, underscore=True):
|
|
|
82 # try normalized type without underscore
|
|
|
83 return obj
|
|
|
84
|
|
|
85 return mapping
|
|
|
86
|
|
|
87 def getBibFields(self, bibdata):
|
|
|
88 """returns dict with metadata description for bibdata"""
|
|
|
89 bibfields = {}
|
|
|
90 bibtype = bibdata['@type']
|
|
|
91 # get mapping from main/meta/bib
|
|
|
92 mapping = self.getBibMapping(bibtype)
|
|
|
93 if mapping is None:
|
|
|
94 logging.error("getBibFields: no mapping for type: %s"%bibtype)
|
|
|
95 return bibfields
|
|
|
96
|
|
|
97 # get field descriptions (copy so we can change it)
|
|
|
98 bibfields = mapping.getFields().copy()
|
|
|
99 # add field list
|
|
|
100 bibfields['@fieldList'] = mapping.getFieldList()
|
|
|
101
|
|
|
102 return bibfields
|
|
|
103
|
|
|
104 def getBibMappedData(self, bibdata, allFields=False):
|
|
|
105 """returns dict with metadata descriptions and data for bibdata"""
|
|
|
106 bibfields = self.getBibFields(bibdata)
|
|
|
107 mappedData = {}
|
|
|
108 mappedList = []
|
|
|
109 for bk in bibfields.keys():
|
|
|
110 # ignore descriptions without data
|
|
|
111 if not bibdata.get(bk, None):
|
|
|
112 continue
|
|
|
113
|
|
|
114 # field description (copy so we can change it)
|
|
|
115 bf = bibfields[bk].copy()
|
|
|
116 # add value
|
|
|
117 bf['value'] = bibdata[bk]
|
|
|
118 mappedData[bk] = bf
|
|
|
119 mappedList.append(bk)
|
|
|
120
|
|
|
121 if allFields and len(mappedData) < len(bibdata):
|
|
|
122 # add fields that were not in bibfields
|
|
|
123 for bk in bibdata.keys():
|
|
|
124 if bk in mappedData or not bibdata[bk]:
|
|
|
125 continue
|
|
|
126
|
|
|
127 mappedData[bk] = {'tag':bk, 'label':bk, 'value':bibdata[bk]}
|
|
|
128 mappedList.append(bk)
|
|
|
129
|
|
|
130 mappedData['@fieldList'] = mappedList
|
|
|
131 return mappedData
|
|
|
132
|
|
|
133 def getFormatted(self, template, path=None, dom=None, bibdata=None, allFields=False):
|
|
|
134 """returns string with document data formatted according to template.
|
|
|
135 gets data from server or dom or pre-parsed bibdata."""
|
|
|
136 logging.debug("getFormatted(template=%s)"%(template))
|
|
|
137
|
|
|
138 if dom is None and bibdata is None:
|
|
|
139 # get from server
|
|
|
140 md = self.getMDFromPathOrUrl(path.replace("/mpiwg/online",""))
|
|
|
141 #logging.debug("md:"+md)
|
|
|
142 #dom = amara.parse(md)
|
|
|
143 dom = ET.fromstring(md)
|
|
|
144
|
|
|
145 # get contents of bib tag
|
|
|
146 if bibdata is None:
|
|
|
147 bibdata = getBibdataFromDom(dom)
|
|
|
148
|
|
|
149 bibtype = bibdata['@type']
|
|
|
150
|
|
|
151 # get template
|
|
|
152 tp=getattr(self,"%s_%s"%(template, bibtype.lower()), None)
|
|
|
153 if tp is None:
|
|
|
154 logging.warning("getFormatted: no template for: %s_%s"%(template, bibtype))
|
|
|
155 # try generic
|
|
|
156 tp=getattr(self,"%s_generic"%(template), None)
|
|
|
157 if tp is None:
|
|
|
158 logging.error("getFormatted: no generic template either: %s"%(template))
|
|
|
159 return ""
|
|
|
160
|
|
|
161 # put bib field descriptions in mdHash
|
|
|
162 bibfields = self.getBibMappedData(bibdata, allFields=allFields)
|
|
|
163
|
|
|
164 return tp(mdmap=bibfields, md=bibdata)
|
|
|
165
|
|
|
166
|
|
|
167 def getFormattedMetaData(self, path=None, dom=None, bibdata=None):
|
|
|
168 """get the metadafrom server"""
|
|
|
169 logging.debug("getFormattedMetaData(path=%s)"%path)
|
|
|
170 return self.getFormatted('metadata_template', path=path, dom=dom, bibdata=bibdata)
|
|
|
171
|
|
|
172 def getFormattedMetaDataShort(self, path=None, dom=None, bibdata=None):
|
|
|
173 """get the metadafrom server"""
|
|
|
174 logging.debug("getFormattedMetaDataShort(path=%s)"%path)
|
|
|
175 return self.getFormatted('metadata_template', path=path, dom=dom, bibdata=bibdata)
|
|
|
176
|
|
|
177 def getFormattedMetaDataExtended(self,path=None, dom=None, bibdata=None):
|
|
|
178 """get the metadafrom server"""
|
|
|
179 logging.debug("getFormattedMetaDataExtended(path=%s)"%path)
|
|
|
180 return self.getFormatted('metadata_extended_template', path=path, dom=dom, bibdata=bibdata, allFields=True)
|
|
|
181
|
|
|
182 def getFormattedLabel(self,path=None, dom=None, bibdata=None):
|
|
|
183 """get the metadafrom server"""
|
|
|
184 logging.debug("getFormattedLabel(%s)"%path)
|
|
|
185 return self.getFormatted('label_template', path=path, dom=dom, bibdata=bibdata)
|
|
|
186
|
|
|
187 def getFormattedMetaDataShortFromServer(self,path):
|
|
|
188 """get the metadafrom server"""
|
|
|
189 logging.debug("getFormattedMetaDataShortFromServer(path=%s)"%path)
|
|
|
190 return self.getFormatted('metadata_template', path)
|
|
|
191
|
|
|
192 def getFormattedMetaDataExtendedFromServer(self,path):
|
|
|
193 """get the metadafrom server"""
|
|
|
194 logging.debug("getFormattedMetaDataExtendedFromServer(path=%s)"%path)
|
|
|
195 return self.getFormatted('metadata_extended_template', path=path, allFields=True)
|
|
|
196
|
|
|
197 def getFormattedLabelFromServer(self,path):
|
|
|
198 """get the metadafrom server"""
|
|
|
199 logging.debug("getFormattedLabelFromServer(%s)"%path)
|
|
|
200 return self.getFormatted('label_template', path)
|
|
|
201
|
|
|
202
|
|
|
203 changeMetaDataFolderForm = PageTemplateFile('zpt/changeMetaDataFolder',globals())
|
|
|
204
|
|
|
205 security.declarePublic('changeMetaDataFolder')
|
|
|
206 def changeMetaDataFolder(self,title,metaDataServerUrl,RESPONSE=None):
|
|
|
207 """Change MetaDataFolder"""
|
|
|
208 self.title = title
|
|
|
209 self.metaDataServerUrl=metaDataServerUrl
|
|
|
210 if RESPONSE is not None:
|
|
|
211 RESPONSE.redirect('manage_main')
|
|
|
212
|
|
|
213
|
|
|
214 manage_addMetaDataFolderForm = PageTemplateFile('zpt/addMetaDataFolderForm',globals())
|
|
|
215
|
|
|
216 def manage_addMetaDataFolder(self,id,title,RESPONSE=None):
|
|
|
217 """a MetaDataFolder objekt"""
|
|
|
218 newObj=MetaDataFolder(id,title)
|
|
|
219 self.Destination()._setObject(id,newObj)
|
|
|
220 if RESPONSE is not None:
|
|
|
221 RESPONSE.redirect('manage_main')
|
|
|
222 |
