1: import string
2: import socket
3: import urllib
4: import xml.dom.minidom
5: from types import *
6: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
7: from Globals import package_home
8: import os.path
9:
10: displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ECHO_externalLink','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement','ImageCollection','versionedFileFolder']
11:
12: def content_html(self,type):
13: """template fuer content"""
14: #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
15: #
16: #if templates:
17: # return templates[0][1]()
18:
19: if hasattr(self,type+"_template"):
20: obj=getattr(self,type+"_template")
21: return obj()
22: else:
23: pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
24: pt.content_type="text/html"
25: return pt()
26:
27:
28:
29: class ECHO_basis:
30: """basis eigenschaften fuer echo objekte"""
31: def showRDF(self):
32: """showrdf"""
33: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
34: ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
35: ret+=self.getRDF(urn="echo:colllectionroot")+"\n"
36:
37: ret+="""</RDF:RDF>"""
38: return ret
39:
40:
41:
42: def createSubElementRDF(self,urn=None):
43: """rdf list"""
44: if not urn:
45: urn=self.absolute_url()
46: ret=""
47:
48: rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
49: flag=0
50:
51: li="""<RDF:li RDF:resource="%s" />\n"""
52: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
53: nurn=self.absolute_url()+'/getFullTextXML'
54: rettemp+=li%nurn
55: flag=1
56: if not ('<error>' in self.getImageView(noredirect='Yes')):
57: nurn=self.absolute_url()+'/getImageView'
58: rettemp+=li%nurn
59: flag=1
60:
61:
62: if not ('<error>' in self.showMetaDataXML()):
63: nurn=self.absolute_url()+'/showMetaDataXML'
64: rettemp+=li%nurn
65: flag=1
66:
67: rettemp+="</RDF:Seq>"
68:
69: if flag==1:
70: ret+=rettemp
71:
72: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
73: nurn=self.absolute_url()+'/getFullTextXML'
74: ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")
75:
76: if not ('<error>' in self.getImageView(noredirect='Yes')):
77: nurn=self.absolute_url()+'/getImageView'
78: ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
79:
80: if not ('<error>' in self.showMetaDataXML()):
81: nurn=self.absolute_url()+'/showMetaDataXML'
82: ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")
83:
84: return ret
85:
86: def content_html(self,type="collection"):
87: """template fuer content bei einbau und ECHO_Umgebung"""
88:
89: return content_html(self,type)
90:
91: def getTitle(self):
92: """title"""
93: try:
94: return self.title.encode('utf-8','ignore')
95: except:
96: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
97: return self.title.encode('utf-8','ignore')
98:
99: def getLabel(self):
100: """title"""
101: try:
102: return self.label.encode('utf-8','ignore')
103: except:
104: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
105: return self.label.encode('utf-8','ignore')
106:
107:
108: def changeECHOEntriesForm(self):
109: """change Entries for the ECHO Navigation environment"""
110: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
111: return pt()
112:
113: def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None):
114: """change Entries for the ECHO Navigation environment
115: @param label: label fuer die Navigation"""
116: self.label=label
117: self.weight=weight
118: self.description=description
119: self.queryString=queryString
120:
121: if RESPONSE:
122: RESPONSE.redirect("manage_main")
123:
124: manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)
125:
126: #ende der echo erweiterungen
127:
128:
129: def toList(field):
130: """Einzelfeld in Liste umwandeln"""
131: if type(field)==StringType:
132: return [field]
133: else:
134: return field
135:
136: def getText(nodelist):
137:
138: rc = ""
139: for node in nodelist:
140: if node.nodeType == node.TEXT_NODE:
141: rc = rc + node.data
142: return rc
143:
144: def getTextFromNode(nodename):
145: nodelist=nodename.childNodes
146: rc = ""
147: for node in nodelist:
148: if node.nodeType == node.TEXT_NODE:
149: rc = rc + node.data
150: return rc
151:
152:
153: def readFieldFromXML(meta_url,parent,field):
154: """lesespezifisches metadatum"""
155:
156: try:
157: dom=xml.dom.minidom.parse(meta_url)
158:
159: except:
160: try:
161: fh=urllib.urlopen(meta_url)
162: dom=xml.dom.minidom.parse(fh)
163: except:
164: return None
165: if not dom: return None
166:
167: parent=dom.getElementsByTagName(parent)
168: if not parent: return None
169:
170: field=parent[0].getElementsByTagName(field)
171:
172: if not field: return None
173:
174: return getText(field[0].childNodes)
175:
176:
177:
178: def urlopen(url):
179: """urlopen mit timeout"""
180: socket.setdefaulttimeout(2)
181: ret=urllib.urlopen(url)
182: socket.setdefaulttimeout(5)
183: return ret
184: # urlopener = urllib.URLopener()
185: #
186: # try:
187: # con = urlopener.open(url)
188: # return con
189: # except timeoutsocket.Timeout:
190: # return None
191:
192:
193:
194:
195:
196: def checkOnlyOneInGroup(object):
197: """check if object is a group and if it containt only one element it return this element"""
198: displayedObjects=object.ZopeFind(object,obj_metatypes=displayTypes)
199: if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object
200:
201: return displayedObjects[0][1]
202: else: return object
203:
204: def getSubCols(self,sortfield="weight",subColTypes= displayTypes,sortFieldMD=None):
205:
206: def sortfnc(sortfield,x,y):
207: xa=x[1].getMDValue(sortfield)
208: ya=y[1].getMDValue(sortfield)
209: print xa,ya
210: return cmp(xa,ya)
211:
212: sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y))
213: ids=[]
214: displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes)
215:
216:
217: for entry in displayedObjects:
218:
219: object=entry[1]
220: ids.append(object)
221:
222: try:
223: sortfield=self.sortfield
224: except:
225: """nothing"""
226:
227: tmplist=[]
228: for x in ids:
229: if hasattr(x,sortfield):
230: try:
231:
232: x=int(x)
233: except:
234: """nothing"""
235: tmp=getattr(x,sortfield)
236: else:
237: tmp=10000000
238: tmplist.append((tmp,x))
239:
240: if not sortFieldMD:
241: tmplist.sort()
242: else:
243: tmplist.sort(sortWithMD(sortFieldMD))
244:
245: return [x for (key,x) in tmplist]
246:
247: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
248: """Rerender all Links"""
249: ret=""
250:
251: if not obj:
252: obj = self
253:
254: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
255:
256: for entry in entries:
257: if entry[1].meta_type == 'ECHO_resource':
258: try:
259: entry[1].ECHO_getResourceMD(template="no")
260: if "title" in types:
261: entry[1].generate_title()
262: if "label" in types:
263: entry[1].generate_label()
264: ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
265: except:
266: ret+="Error:"+entry[0]+"<br>"
267:
268:
269:
270:
271: return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
272:
273: def reloadMetaDataFromStorage(self,RESPONSE=None):
274: """copy metadata from the storage to ECHO"""
275: ret=""
276: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
277:
278: for resource in resources:
279: x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
280: ret+=x
281: #print x
282:
283:
284: if RESPONSE is not None:
285: #RESPONSE.redirect('./manage_main')
286: return "<html><body>"+ret+"</html></body>"
287:
288: return ret
289:
290: def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
291: """rdf"""
292:
293: ret=""
294: about="""<RDF:Description RDF:about="%s">"""
295: name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
296: link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
297: clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
298: #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
299: type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
300: #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""
301: if not urn:
302: #urn="urn:"+re.sub('/',':',self.absolute_url())
303: urn=self.absolute_url()
304: about2=about%urn
305: if not nameDef:
306: if hasattr(self,'label') and not (self.label==""):
307: name2=name%self.label
308: elif not self.title=="":
309: name2=name%self.title
310: else:
311: name2=name%self.getId()
312:
313: name2=re.sub('&','&',name2)
314: else:
315: name2=name%nameDef
316:
317: linkURL=re.sub('http:','',linkURL)
318: linkURL2=re.sub('&','&',linkURL)
319: link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
320: clickable2=clickable%"true"
321:
322: if not typeName:
323: type2=type%self.meta_type
324: else:
325: type2=type%typeName
326:
327: #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
328: ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
329: return ret
330:
331: def getCopyrightsFromForm(self,argv):
332: medias={}
333: partners={}
334: copyrights={}
335:
336: copyrightsFinal=[]
337: for arg in argv.keys():
338:
339: if arg[0:5]=='media':
340: nm=int(arg[5:])
341: medias[nm]=argv[arg]
342: elif arg[0:5]=='partn':
343: nm=int(arg[5:])
344: partners[nm]=argv[arg]
345: elif arg[0:5]=='copyr':
346: nm=int(arg[5:])
347: copyrights[nm]=argv[arg]
348:
349:
350:
351: copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
352: for copyright in copyrightsList:
353:
354: if copyright[2]=='institution0000':
355: copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
356: else:
357: if not copyright[0]=='':
358: copyrightsFinal.append(copyright)
359:
360:
361: return copyrightsFinal
362:
363: #List of different types for the graphical linking viewer
364: viewClassificationListMaster=['view point','area']
365:
366:
367: def checkDiffs(self,metadict):
368: """check differences"""
369:
370:
371:
372:
373: def NoneToEmpty(obj):
374: if obj:
375: return obj
376: else:
377: return ""
378:
379:
380:
381: diffs={}
382:
383: tags=self.findTagsFromMapping(self.contentType)
384: self.referencetypes=tags[2]
385: self.fields=tags[3]
386:
387:
388: for field in tags[1]:
389: try:
390: if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
391: diffs[self.getFieldTag(tags,field)]=1
392: else:
393:
394: diffs[self.getFieldTag(tags,field)]=0
395: except:
396: diffs[self.getFieldTag(tags,field)]=0
397:
398: return diffs
399:
400:
401:
402:
403: def sendFile(self, filename, type):
404: """sends an object or a local file (in the product) as response"""
405: paths = filename.split('/')
406: object = self
407: # look for an object called filename
408: for path in paths:
409: if hasattr(object, path):
410: object = getattr(object, path)
411: else:
412: object = None
413: break
414: if object:
415: # if the object exists then send it
416: return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
417: else:
418: # send a local file with the given content-type
419: fn = os.path.join(package_home(globals()), filename)
420: self.REQUEST.RESPONSE.setHeader("Content-Type", type)
421: self.REQUEST.RESPONSE.write(file(fn).read())
422: return
423:
424: class BrowserCheck:
425: """check the browsers request to find out the browser type"""
426:
427: def __init__(self, zope):
428: """initialisiere"""
429: self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
430: self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)
431: self.isIE = string.find(self.ua, 'MSIE') > -1
432: self.nav = self.ua[string.find(self.ua, '('):]
433: ie = string.split(self.nav, "; ")[1]
434: if string.find(ie, "MSIE") > -1:
435: self.versIE = string.split(ie, " ")[1]
436: self.isMac = string.find(self.ua, 'Macintosh') > -1
437: self.isWin = string.find(self.ua, 'Windows') > -1
438: self.isIEWin = self.isIE and self.isWin
439: self.isIEMac = self.isIE and self.isMac
440:
441:
442:
443: def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
444: """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
445:
446: def updateTextToolNode(tag,value):
447: #print dom,tag,value
448: metanode=dom.getElementsByTagName('texttool')[0]
449: try:
450: nodeOld=metanode.getElementsByTagName(tag)
451: except:
452: nodeOld=None
453:
454: if nodeOld:
455: metanode.removeChild(nodeOld[0]).unlink()
456:
457: node=dom.createElement(tag)
458: nodetext=dom.createTextNode(value)
459: node.appendChild(nodetext)
460: metanode.appendChild(node)
461:
462: if xmlfrag:
463: geturl="""<?xml version="1.0" ?>
464: <resource type="MPIWG">
465: <meta>
466: <bib type="Book">
467: </bib>
468: </meta>
469: </resource>"""
470: dom=xml.dom.minidom.parseString(geturl)
471: else:
472: try:
473: geturl=""
474: for line in ECHO_helpers.urlopen(url).readlines():
475: geturl=geturl+line
476:
477:
478: except:
479: return (None,"Cannot open: "+url)
480:
481: try:
482: dom=xml.dom.minidom.parseString(geturl)
483: except:
484: return (None,"Cannot parse: "+url+"<br>"+geturl)
485:
486:
487:
488: metanodes=dom.getElementsByTagName('bib')
489:
490: if not metanodes:
491: metanodes=dom.getElementsByTagName('archimedes')
492:
493: metanode=metanodes[0]
494:
495: for metaData in metadict.keys():
496:
497: try:
498: nodeOld=metanode.getElementsByTagName(metaData)
499: except:
500: nodeOld=None
501:
502: if nodeOld:
503: metanode.removeChild(nodeOld[0]).unlink()
504: else:
505: # try also old writing rule - instead of _:
506: try:
507: nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
508: except:
509: nodeOld=None
510:
511: if nodeOld:
512: metanode.removeChild(nodeOld[0]).unlink()
513:
514: metanodeneu=dom.createElement(metaData)
515: metanodetext=dom.createTextNode(metadict[metaData])
516: #try:
517: #metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
518: #except:
519: #metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
520: metanodeneu.appendChild(metanodetext)
521: metanode.appendChild(metanodeneu)
522:
523:
524:
525:
526:
527: if project:
528: updateTextToolNode('project',project)
529:
530: if startpage:
531: updateTextToolNode('startpage',startpage)
532:
533: if topbar:
534: updateTextToolNode('toptemplate',topbar)
535:
536: if thumbtemplate:
537: updateTextToolNode('thumbtemplate',thumbtemplate)
538:
539: if xslt:
540: updateTextToolNode('xslt',xslt)
541:
542:
543: if digiliburlprefix:
544: updateTextToolNode('digiliburlprefix',digiliburlprefix)
545:
546: try:
547: return dom.toxml().encode('utf-8')
548: except:
549: return dom.toxml('utf-8')
550:
551:
552:
553: def readMetadata(url):
554: """Methode zum Auslesen der Metadateninformation zu einer Resource
555: Vorerst noch Typ bib"""
556:
557: metadict={}
558: try:
559: geturl=""
560: for line in ECHO_helpers.urlopen(url).readlines():
561: geturl=geturl+line
562:
563:
564: except:
565: return (None,"Cannot open: "+url)
566:
567: try:
568: dom=xml.dom.minidom.parseString(geturl)
569: except:
570: return (None,"Cannot parse: "+url+"<br>"+geturl)
571:
572: metanode=dom.getElementsByTagName('bib')
573: metadict['bib_type']='Book'
574: if len(metanode)==0:
575: metanode=dom.getElementsByTagName('archimedes')
576: metadict['bib_type']='Archimedes'
577:
578:
579: if not len(metanode)==0:
580: metacontent=metanode[0].childNodes
581:
582: try:
583: metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
584: except:
585: """nothing"""
586:
587: for node in metacontent:
588: try:
589: #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
590: metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
591: except:
592: """nothing"""
593:
594:
595: return metadict,""
596:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_helpers.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content