1: import re
2: import string
3: import socket
4: import urllib
5: import string
6: import xml.dom.minidom
7: import types
8: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
9: from OFS.SimpleItem import SimpleItem
10: from Globals import package_home
11: import Globals
12: from AccessControl import ClassSecurityInfo
13: import os.path
14:
15: 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','ECHO_movie']
16:
17: def content_html(self,type):
18: """template fuer content"""
19: #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
20: #
21: #if templates:
22: # return templates[0][1]()
23:
24: if hasattr(self,type+"_template"):
25: obj=getattr(self,type+"_template")
26: return obj()
27: else:
28: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%type)).__of__(self)
29: pt.content_type="text/html"
30: return pt()
31:
32:
33:
34: class ECHO_basis:
35: """basis eigenschaften fuer echo objekte"""
36: security=ClassSecurityInfo()
37: security.declarePublic('getImageTag')
38: def getImageTag(self):
39: """sollte uerberschrieben werden, falls von der Klasse eine imagetag zurueckkommt"""
40:
41: return ""
42:
43: def showRDF(self):
44: """showrdf"""
45: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
46: 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"""
47:
48: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
49:
50:
51: ret+="""</RDF:RDF>"""
52: return ret
53:
54:
55: def RDF(self):
56: """showrdf"""
57: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
58: 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"""
59:
60: ret+=self.getRDF(urn=self.absolute_url())+"\n"
61:
62:
63: ret+="""</RDF:RDF>"""
64: return ret
65:
66:
67: def createSubElementRDF(self,urn=None):
68: """rdf list"""
69: if not urn:
70: urn=self.absolute_url()
71: ret=""
72:
73: rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
74: flag=0
75:
76: li="""<RDF:li RDF:resource="%s" />\n"""
77: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
78: nurn=self.absolute_url()+'/getFullTextXML'
79: rettemp+=li%nurn
80: flag=1
81: if not ('<error>' in self.getImageView(noredirect='Yes')):
82: nurn=self.absolute_url()+'/getImageView'
83: rettemp+=li%nurn
84: flag=1
85:
86:
87: if not ('<error>' in self.showMetaDataXML()):
88: nurn=self.absolute_url()+'/showMetaDataXML'
89: rettemp+=li%nurn
90: flag=1
91:
92: rettemp+="</RDF:Seq>"
93:
94: if flag==1:
95: ret+=rettemp
96:
97: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
98: nurn=self.absolute_url()+'/getFullTextXML'
99: ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")
100:
101: if not ('<error>' in self.getImageView(noredirect='Yes')):
102: nurn=self.absolute_url()+'/getImageView'
103: ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
104:
105: if not ('<error>' in self.showMetaDataXML()):
106: nurn=self.absolute_url()+'/showMetaDataXML'
107: ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")
108:
109: return ret
110:
111: def content_html(self,type="collection"):
112: """template fuer content bei einbau und ECHO_Umgebung"""
113:
114: return content_html(self,type)
115:
116: def getTitle(self):
117: """title"""
118: return self.decode(self.title)
119: try:
120: return self.title.encode('utf-8','ignore')
121: except:
122: self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
123: return self.title.encode('utf-8','ignore')
124:
125: def getLabel(self):
126: """title"""
127: if self.label=="":
128: ret=self.getTitle
129: if ret=="":
130: ret=self.getId()
131: return ret
132:
133: return self.decode(self.label)
134: try:
135: return self.label.encode('utf-8','ignore')
136: except:
137: self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
138: return self.label.encode('utf-8','ignore')
139:
140:
141: def changeECHOEntriesForm(self):
142: """change Entries for the ECHO Navigation environment"""
143: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
144: return pt()
145:
146: def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None):
147: """change Entries for the ECHO Navigation environment
148: @param label: label fuer die Navigation"""
149: self.label=label
150: self.weight=weight
151: self.description=description
152: self.queryString=queryString
153:
154: if RESPONSE:
155: RESPONSE.redirect("manage_main")
156:
157: manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)
158:
159:
160: def hasOverview(self):
161: """returns if there is an overview graphics"""
162: return hasattr(self, 'overview')
163:
164: def hasParentOverview(self):
165: """returns if the parent has an overview graphics"""
166: return hasattr(self.aq_parent, 'overview')
167:
168: def getOverview(self):
169: """map overview graphics"""
170: #return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
171: if self.hasOverview():
172: return getattr(self, 'overview')
173: return None
174:
175: def getMapAreas(self):
176: """returns the list of MapAreas"""
177: # get all contained MapAreas
178: areas = [res[1] for res in self.ZopeFind(self, obj_metatypes=('MapArea'))]
179: return areas
180:
181: def addMapArea(self, newarea):
182: """add a map area to this object"""
183: if (newarea.id is None):
184: # create new id
185: areas = self.getMapAreas()
186: newarea.id = "a%02d"%len(areas)
187: self._setObject(newarea.id, newarea)
188:
189: def ECHO_graphicEntry(self):
190: """change map coordinates"""
191: if self.hasParentOverview():
192: pt=zptFile(self, 'zpt/ECHO_draw.zpt')
193: return pt()
194: else:
195: return "NO OVERVIEW GRAPHICS"
196:
197: def ECHO_addCoords(self,RESPONSE=None):
198: """change or add MapArea"""
199: #return self.REQUEST
200: # change existing areas
201: for area in self.getMapAreas():
202: id = area.getId()
203: if self.REQUEST.has_key('del.'+id):
204: # delete this area
205: self._delObject(id)
206: # return to same menu
207: if RESPONSE is not None:
208: RESPONSE.redirect('ECHO_graphicEntry')
209: return
210: # modify this area
211: coordstring = self.REQUEST.get('coords.'+id, '')
212: coords = string.split(coordstring, ',')
213: angle = self.REQUEST.get('angle.'+id, '0')
214: type = self.REQUEST.get('type.'+id, 'area')
215: if len(coords) == 4:
216: area.setCoordString(coordstring)
217: area.setAngle(angle)
218: area.setType(type)
219: # add new area
220: if self.REQUEST.has_key('add'):
221: coordstring = self.REQUEST.get('coords.new', '')
222: coords = string.split(coordstring, ',')
223: angle = self.REQUEST.get('angle.new', '0')
224: type = self.REQUEST.get('type.new', 'area')
225: if len(coords) == 4:
226: coords.append(angle)
227: area = MapArea(None, coords, type=type)
228: self.addMapArea(area)
229: # return to edit area menu
230: if RESPONSE is not None:
231: RESPONSE.redirect('ECHO_graphicEntry')
232:
233: def createJSAreas(self, areas):
234: """create area calls for JavaScript"""
235: dynamical="\n"
236: for ob in areas:
237: if ob.isTypeArrow():
238: dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob.getFullId(),ob.getCoordString())
239: else:
240: dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob.getFullId(),ob.getCoordString())
241: return dynamical
242:
243: def createMapHead(self):
244: """create javascript include and script tags for head"""
245: pt=zptFile(self, 'zpt/ECHO_content_map_frag_js')
246: return pt()
247:
248: def createMapImg(self):
249: """generate img-tag for map"""
250: bt = BrowserCheck(self)
251: tag = ""
252: src = self.getOverview().absolute_url()
253: if bt.isN4:
254: # N4 needs ilayer to create an id
255: tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
256: else:
257: # img with id
258: tag += '<img id="overview" src="%s" />'%src
259: return tag
260:
261: def createParentMapImg(self):
262: """generate img-tag for map of parent"""
263: return self.aq_parent.createMapImg()
264:
265: def createMapLink(self, ob, text=None):
266: """generate map link"""
267: bt = BrowserCheck(self)
268: id = ob.getFullId()
269: link = ob.getLinkId()
270: if text is None:
271: text = ob.getLabel()
272: if text is None:
273: text = "link"
274: tiptext = ob.getText()
275: tag = ""
276: if bt.isN4:
277: # N4 needs layer for highlighting
278: tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
279: tag += ">" + text + "</a></ilayer>"
280: else:
281: # a-element
282: tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
283: if tiptext:
284: tag += ' title="%s"'%tiptext
285: tag += ">" + text + "</a>"
286: return tag
287:
288: def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
289: """generate map link image, text and other stuff"""
290: bt = BrowserCheck(self)
291: id = ob.getFullId()
292: link = ob.getLinkId()
293: tiptext = ob.getText()
294: tag = ""
295:
296: if bt.isN4:
297: # N4 needs layer and img elements
298: tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
299: if ob.isTypeArrow():
300: rot = ob.angle
301: tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
302: else:
303: tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
304: if tiptext:
305: tag += ' alt="%s"'%tiptext
306: tag += ' /></a>'
307: tag += '</layer>'
308: else:
309: # create a-element
310: tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
311: if ob.isTypeArrow():
312: rot = ob.angle
313: if bt.isIEWin and bt.versIE > 5:
314: # IE/Win 5.5 has "feature" for PNG transparency
315: tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,arrowsrc,rot,arrowsrc,rot)
316: else:
317: # arrow image
318: tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
319: else:
320: if bt.isIE:
321: # IE needs transparent img for area
322: tag += '<img id="i.%s" border="0" style="position:absolute; top:-100px; left:-100px;" src="trans_img"'%(id)
323: if tiptext:
324: tag += ' title="%s"'%tiptext
325: tag += " />"
326: else:
327: # div for area
328: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
329: if tiptext:
330: tag += ' title="%s"'%tiptext
331: tag += '> </div>'
332: tag += '</a>'
333: return tag
334:
335:
336: #ende der echo erweiterungen
337:
338:
339: def toList(field):
340: """Einzelfeld in Liste umwandeln"""
341: if type(field)==types.StringType:
342: return [field]
343: else:
344: return field
345:
346: def getText(nodelist):
347:
348: rc = ""
349: for node in nodelist:
350: if node.nodeType == node.TEXT_NODE:
351: rc = rc + node.data
352: return rc
353:
354: def getTextFromNode(nodename):
355: nodelist=nodename.childNodes
356: rc = ""
357: for node in nodelist:
358: if node.nodeType == node.TEXT_NODE:
359: rc = rc + node.data
360: return rc
361:
362:
363: def readFieldFromXML(meta_url,parent,field):
364: """lesespezifisches metadatum"""
365:
366: try:
367: dom=xml.dom.minidom.parse(meta_url)
368:
369: except:
370: try:
371: fh=urllib.urlopen(meta_url)
372: dom=xml.dom.minidom.parse(fh)
373: except:
374: return None
375: if not dom: return None
376:
377: parent=dom.getElementsByTagName(parent)
378: if not parent: return None
379:
380: field=parent[0].getElementsByTagName(field)
381:
382: if not field: return None
383:
384: return getText(field[0].childNodes)
385:
386:
387:
388: def urlopen(url):
389: """urlopen mit timeout"""
390: socket.setdefaulttimeout(2)
391: ret=urllib.urlopen(url)
392: socket.setdefaulttimeout(5)
393: return ret
394: # urlopener = urllib.URLopener()
395: #
396: # try:
397: # con = urlopener.open(url)
398: # return con
399: # except timeoutsocket.Timeout:
400: # return None
401:
402:
403:
404:
405:
406: def checkOnlyOneInGroup(object):
407: """check if object is a group and if it containt only one element it return this element"""
408: displayedObjects=object.ZopeFind(object,obj_metatypes=displayTypes)
409: if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object
410:
411: return displayedObjects[0][1]
412: else: return object
413:
414: def getSubCols(self, sortfield=None, subColTypes=displayTypes, sortFieldMD=None,searchMD=None):
415:
416:
417: def sort(x,y):
418: return cmp(x[0],y[0])
419:
420: def sortfnc(sortfield,x,y):
421: try:
422: xa=x[1].getMDValue(sortfield)
423: except:
424: xa=""
425: try:
426: ya=y[1].getMDValue(sortfield)
427: except:
428: ya=""
429: return cmp(xa,ya)
430:
431: sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y))
432: ids=[]
433: displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes)
434:
435:
436: for entry in displayedObjects:
437:
438:
439: object=entry[1]
440: if searchMD and hasattr(object,'getMDValue'):
441: flag=0
442: for field in searchMD.keys():
443: if object.getMDValue(field)==searchMD[field]:
444: flag=1
445: else:
446: flag=0
447: break
448: if flag==1:
449: ids.append(object)
450: else:
451: ids.append(object)
452:
453: if not sortfield:
454: sortfield=getattr(self,'sortfield','weight')
455:
456:
457: tmplist=[]
458:
459: for x in ids:
460:
461: if hasattr(x,sortfield):
462: try:
463: tmp=int(getattr(x,sortfield))
464: except:
465: tmp=getattr(x,sortfield)
466:
467: else:
468: tmp=10000000
469:
470: tmplist.append((tmp,x))
471:
472: if not sortFieldMD:
473: tmplist.sort(sort)
474: else:
475: tmplist.sort(sortWithMD(sortFieldMD))
476:
477: return [x for (key,x) in tmplist]
478:
479: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
480: """Rerender all Links"""
481: ret=""
482:
483: if not obj:
484: obj = self
485:
486: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
487:
488: for entry in entries:
489: if entry[1].meta_type == 'ECHO_resource':
490: try:
491: entry[1].ECHO_getResourceMD(template="no")
492: if "title" in types:
493: entry[1].generate_title()
494: if "label" in types:
495: entry[1].generate_label()
496: ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
497: except:
498: ret+="Error:"+entry[0]+"<br>"
499:
500:
501:
502:
503: return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
504:
505: def reloadMetaDataFromStorage(self,RESPONSE=None):
506: """copy metadata from the storage to ECHO"""
507: ret=""
508: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
509:
510: for resource in resources:
511: x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
512: ret+=x
513:
514: if RESPONSE is not None:
515: #RESPONSE.redirect('./manage_main')
516: return "<html><body>"+ret+"</html></body>"
517:
518: return ret
519:
520: def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
521: """rdf"""
522:
523: ret=""
524: about="""<RDF:Description RDF:about="%s">"""
525: name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
526: link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
527: clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
528: #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
529: type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
530: #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""
531: if not urn:
532: #urn="urn:"+re.sub('/',':',self.absolute_url())
533: urn=self.absolute_url()
534: about2=about%urn
535: if not nameDef:
536: if hasattr(self,'label') and not (self.label==""):
537: name2=name%self.label
538: elif not self.title=="":
539: name2=name%self.title
540: else:
541: name2=name%self.getId()
542:
543: name2=re.sub('&','&',name2)
544: else:
545: name2=name%nameDef
546:
547: linkURL=re.sub('http:','',linkURL)
548: linkURL2=re.sub('&','&',linkURL)
549: link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
550: clickable2=clickable%"true"
551:
552: if not typeName:
553: type2=type%self.meta_type
554: else:
555: type2=type%typeName
556:
557: #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
558: ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
559: return ret
560:
561: def getCopyrightsFromForm(self,argv):
562: medias={}
563: partners={}
564: copyrights={}
565:
566: copyrightsFinal=[]
567: for arg in argv.keys():
568:
569: if arg[0:5]=='media':
570: nm=int(arg[5:])
571: medias[nm]=argv[arg]
572: elif arg[0:5]=='partn':
573: nm=int(arg[5:])
574: partners[nm]=argv[arg]
575: elif arg[0:5]=='copyr':
576: nm=int(arg[5:])
577: copyrights[nm]=argv[arg]
578:
579:
580:
581: copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
582: for copyright in copyrightsList:
583:
584: if copyright[2]=='institution0000':
585: copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
586: else:
587: if not copyright[0]=='':
588: copyrightsFinal.append(copyright)
589:
590:
591: return copyrightsFinal
592:
593: #List of different types for the graphical linking viewer
594: viewClassificationListMaster=['view point','area']
595:
596:
597: def checkDiffs(self,metadict):
598: """check differences"""
599:
600:
601:
602:
603: def NoneToEmpty(obj):
604: if obj:
605: return obj
606: else:
607: return ""
608:
609:
610:
611: diffs={}
612:
613: tags=self.findTagsFromMapping(self.contentType)
614: self.referencetypes=tags[2]
615: self.fields=tags[3]
616:
617:
618: for field in tags[1]:
619: try:
620: if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
621: diffs[self.getFieldTag(tags,field)]=1
622: else:
623:
624: diffs[self.getFieldTag(tags,field)]=0
625: except:
626: diffs[self.getFieldTag(tags,field)]=0
627:
628: return diffs
629:
630:
631: def zptFile(self, path, orphaned=False):
632: """returns a page template file from the product"""
633: if orphaned:
634: # unusual case
635: pt=PageTemplateFile(os.path.join(package_home(globals()), path))
636: else:
637: pt=PageTemplateFile(os.path.join(package_home(globals()), path)).__of__(self)
638: return pt
639:
640:
641: def findObjectPath(startobject, filename):
642: """returns the object with the name filename starting at startobject"""
643: if startobject is None:
644: return None
645: paths = filename.split('/')
646: object = startobject
647: for path in paths:
648: if hasattr(object, path):
649: object = getattr(object, path)
650: else:
651: object = None
652: break
653: return object
654:
655:
656: def zptObjectOrFile(self, filename, localdir='zpt', orphaned=False):
657: """returns a page template instance or a file from the product"""
658: # look for an object called path
659: pt = findObjectPath(self, filename)
660: # the object should also not be a python function
661: if (pt is None) or isinstance(pt, types.FunctionType):
662: # get a ZPT file
663: pt = zptFile(self, localdir+'/'+filename, orphaned=orphaned)
664: return pt
665:
666:
667: def sendFile(self, filename, type):
668: """sends an object or a local file (in the product) as response"""
669: # look for an object called filename
670: object = findObjectPath(self, filename)
671: if object:
672: # if the object exists then send it
673: return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
674: else:
675: # send a local file with the given content-type
676: fn = os.path.join(package_home(globals()), filename)
677: self.REQUEST.RESPONSE.setHeader("Content-Type", type)
678: self.REQUEST.RESPONSE.write(file(fn).read())
679: return
680:
681:
682: class BrowserCheck:
683: """check the browsers request to find out the browser type"""
684:
685: def __init__(self, zope):
686: """initialisiere"""
687: self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
688: self.isN4 = False
689: self.isIE = False
690: if string.find(self.ua, 'MSIE') > -1:
691: self.isIE = True
692: else:
693: self.isN4 = string.find(self.ua, 'Mozilla/4.') > -1
694: try:
695: self.nav = self.ua[string.find(self.ua, '('):]
696: ie = string.split(self.nav, "; ")[1]
697: if string.find(ie, "MSIE") > -1:
698: self.versIE = string.split(ie, " ")[1]
699: except: pass
700: self.isMac = string.find(self.ua, 'Macintosh') > -1
701: self.isWin = string.find(self.ua, 'Windows') > -1
702: self.isIEWin = self.isIE and self.isWin
703: self.isIEMac = self.isIE and self.isMac
704:
705:
706: def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
707: """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
708:
709: def updateTextToolNode(tag,value):
710:
711: metanode=dom.getElementsByTagName('texttool')[0]
712: try:
713: nodeOld=metanode.getElementsByTagName(tag)
714: except:
715: nodeOld=None
716:
717: if nodeOld:
718: metanode.removeChild(nodeOld[0]).unlink()
719:
720: node=dom.createElement(tag)
721: nodetext=dom.createTextNode(value)
722: node.appendChild(nodetext)
723: metanode.appendChild(node)
724:
725: if xmlfrag:
726: geturl="""<?xml version="1.0" ?>
727: <resource type="MPIWG">
728: <meta>
729: <bib type="Book">
730: </bib>
731: </meta>
732: </resource>"""
733: dom=xml.dom.minidom.parseString(geturl)
734: else:
735: try:
736: geturl=""
737: for line in urlopen(url).readlines():
738: geturl=geturl+line
739:
740:
741: except:
742: return (None,"XCannot open: "+url)
743:
744: try:
745: dom=xml.dom.minidom.parseString(geturl)
746: except:
747: return (None,"Cannot parse: "+url+"<br>"+geturl)
748:
749:
750:
751: metanodes=dom.getElementsByTagName('bib')
752:
753: if not metanodes:
754: metanodes=dom.getElementsByTagName('archimedes')
755:
756: metanode=metanodes[0]
757:
758: for metaData in metadict.keys():
759:
760: try:
761: nodeOld=metanode.getElementsByTagName(metaData)
762: except:
763: nodeOld=None
764:
765: if nodeOld:
766: metanode.removeChild(nodeOld[0]).unlink()
767: else:
768: # try also old writing rule - instead of _:
769: try:
770: nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
771: except:
772: nodeOld=None
773:
774: if nodeOld:
775: metanode.removeChild(nodeOld[0]).unlink()
776:
777: metanodeneu=dom.createElement(metaData)
778: metanodetext=dom.createTextNode(metadict[metaData])
779: #try:
780: #metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
781: #except:
782: #metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
783: metanodeneu.appendChild(metanodetext)
784: metanode.appendChild(metanodeneu)
785:
786:
787:
788:
789:
790: if project:
791: updateTextToolNode('project',project)
792:
793: if startpage:
794: updateTextToolNode('startpage',startpage)
795:
796: if topbar:
797: updateTextToolNode('toptemplate',topbar)
798:
799: if thumbtemplate:
800: updateTextToolNode('thumbtemplate',thumbtemplate)
801:
802: if xslt:
803: updateTextToolNode('xslt',xslt)
804:
805:
806: if digiliburlprefix:
807: updateTextToolNode('digiliburlprefix',digiliburlprefix)
808:
809: try:
810: return dom.toxml().encode('utf-8')
811: except:
812: return dom.toxml('utf-8')
813:
814:
815:
816: def readMetadata(url):
817: """Methode zum Auslesen der Metadateninformation zu einer Resource
818: Vorerst noch Typ bib"""
819:
820: metadict={}
821:
822: try:
823: geturl=""
824: for line in urlopen(url).readlines():
825: geturl=geturl+line
826:
827:
828: except:
829: return (None,"Cannot open: "+url)
830:
831: try:
832: dom=xml.dom.minidom.parseString(geturl)
833: except:
834: return (None,"Cannot parse: "+url+"<br>"+geturl)
835:
836: metanode=dom.getElementsByTagName('bib')
837: metadict['bib_type']='Book'
838: if len(metanode)==0:
839: metanode=dom.getElementsByTagName('archimedes')
840: metadict['bib_type']='Archimedes'
841:
842:
843: if not len(metanode)==0:
844: metacontent=metanode[0].childNodes
845:
846: try:
847: metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
848: except:
849: """nothing"""
850:
851: for node in metacontent:
852: try:
853: #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
854: #metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
855: metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
856:
857: except:
858: """nothing"""
859:
860:
861: return metadict,""
862:
863:
864: class MapArea(SimpleItem):
865: """simple class to hold coordinates"""
866:
867: meta_type = 'MapArea'
868: # Create a SecurityInfo for this class.
869: security = ClassSecurityInfo()
870: security.setDefaultAccess("allow")
871: # type constants
872: TYPE_AREA = 'area'
873: TYPE_ARROW = 'arrow'
874:
875: def __init__(self, id, coords, label=None, type=None, text=None):
876: """init"""
877: self.coords = coords[0:4]
878: if len(coords) > 4:
879: self.angle = coords[4]
880: else:
881: self.angle = 0
882: self.id = id
883: self.label = label
884: self.setType(type)
885: self.text = text
886:
887: def setCoords(self, coords):
888: """sets the coords"""
889: self.coords = coords
890:
891: def getCoordString(self):
892: """returns coordinates as a string"""
893: return string.join(self.coords, ',')
894:
895: def setCoordString(self, coordstring):
896: """sets coordinates from a string"""
897: coords = string.split(coordstring, ',')
898: self.coords = [c.strip() for c in coords]
899:
900: def getFullId(self, prefix=None):
901: """returns the id with prefixed parent id"""
902: if prefix is None:
903: if hasattr(self, 'aq_parent'):
904: prefix = self.aq_parent.id
905: else:
906: prefix = "id"
907: fid = prefix + "." + self.id
908: return fid
909:
910: def getType(self):
911: """returns the type"""
912: return self.type
913:
914: def setType(self, type):
915: """sets the type"""
916: if type == MapArea.TYPE_ARROW:
917: self.type = MapArea.TYPE_ARROW
918: elif type == MapArea.TYPE_AREA:
919: self.type = MapArea.TYPE_AREA
920: else:
921: self.type = MapArea.TYPE_AREA
922:
923: def isTypeArea(self):
924: """returns if the type is area"""
925: return self.type == MapArea.TYPE_AREA
926:
927: def isTypeArrow(self):
928: """returns if the type is arrow"""
929: return self.type == MapArea.TYPE_ARROW
930:
931: def getAngle(self):
932: """returns the angle"""
933: return self.angle
934:
935: def setAngle(self, angle):
936: """sets the angle"""
937: self.angle = angle
938:
939: def getText(self):
940: """returns the popup text"""
941: if self.text is None:
942: if hasattr(self, 'aq_parent'):
943: parent = self.aq_parent
944: if parent.contentType == 'text-popup':
945: return parent.description
946: return self.text
947:
948: def setText(self, text):
949: """sets the text"""
950: self.text = text
951:
952: def getLabel(self):
953: """returns the link label"""
954: if self.label is None:
955: if hasattr(self, 'aq_parent'):
956: return self.aq_parent.label or self.aq_parent.id
957: return self.label
958:
959: def setLabel(self, label):
960: """sets the label"""
961: self.label = label
962:
963: def getLinkId(self):
964: if hasattr(self, 'aq_parent'):
965: return self.aq_parent.id
966: return self.id
967:
968:
969: # call this to initialize framework classes, which
970: # does the right thing with the security assertions.
971: Globals.InitializeClass(MapArea)
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