Mercurial > hg > MetaDataProvider
comparison MetaDataFolder.py @ 4:8291255b1868
adding new base level class MetaDataFolder.
author | casties |
---|---|
date | Wed, 27 Jul 2011 14:13:45 +0200 |
parents | |
children | c1dbf78cc036 |
comparison
equal
deleted
inserted
replaced
3:3dadf0d89261 | 4:8291255b1868 |
---|---|
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 |