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