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 Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
10: from OFS.SimpleItem import SimpleItem
11: from Globals import package_home
12: import Globals
13: from AccessControl import ClassSecurityInfo
14: import os.path
15: from OFS.Folder import Folder
16: import ECHO_collection
17: import base64
18: import bz2
19: import xmlrpclib
20: import zLOG
21:
22: 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']
23:
24:
25: #decode and compress for xmlrpc communication with OSAS_server
26:
27: def encodeRPC(string):
28: return base64.encodestring(bz2.compress(string))
29: def decodeRPC(string):
30: return bz2.decompress(base64.decodestring(string))
31:
32: def content_html(self,type):
33: """template fuer content"""
34: #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
35: #
36: #if templates:
37: # return templates[0][1]()
38:
39: if hasattr(self,type+"_template"):
40: obj=getattr(self,type+"_template")
41: return obj()
42: else:
43: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%type)).__of__(self)
44: pt.content_type="text/html"
45: return pt()
46:
47:
48:
49: class ECHO_basis:
50: """basis eigenschaften fuer echo objekte"""
51: security=ClassSecurityInfo()
52: security.declarePublic('getImageTag')
53:
54: management_page_charset="utf-8"
55: isVisible = True
56:
57: def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
58: return ECHO_collection.manage_addECHO_locale(self,lang,title,label)
59:
60: def getImageTag(self):
61: """sollte uerberschrieben werden, falls von der Klasse eine imagetag zurueckkommt"""
62:
63: return ""
64:
65: def showRDF(self):
66: """showrdf"""
67: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
68: 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"""
69:
70: ret+=self.getRDF(urn="echo:collectionroot")+"\n"
71:
72:
73: ret+="""</RDF:RDF>"""
74: return ret
75:
76:
77: def RDF(self):
78: """showrdf"""
79: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
80: 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"""
81:
82: ret+=self.getRDF(urn=self.absolute_url())+"\n"
83:
84:
85: ret+="""</RDF:RDF>"""
86: return ret
87:
88:
89: def createSubElementRDF(self,urn=None):
90: """rdf list"""
91: if not urn:
92: urn=self.absolute_url()
93: ret=""
94:
95: rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
96: flag=0
97:
98: li="""<RDF:li RDF:resource="%s" />\n"""
99: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
100: nurn=self.absolute_url()+'/getFullTextXML'
101: rettemp+=li%nurn
102: flag=1
103: if not ('<error>' in self.getImageView(noredirect='Yes')):
104: nurn=self.absolute_url()+'/getImageView'
105: rettemp+=li%nurn
106: flag=1
107:
108:
109: if not ('<error>' in self.showMetaDataXML()):
110: nurn=self.absolute_url()+'/showMetaDataXML'
111: rettemp+=li%nurn
112: flag=1
113:
114: rettemp+="</RDF:Seq>"
115:
116: if flag==1:
117: ret+=rettemp
118:
119: if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
120: nurn=self.absolute_url()+'/getFullTextXML'
121: ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")
122:
123: if not ('<error>' in self.getImageView(noredirect='Yes')):
124: nurn=self.absolute_url()+'/getImageView'
125: ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
126:
127: if not ('<error>' in self.showMetaDataXML()):
128: nurn=self.absolute_url()+'/showMetaDataXML'
129: ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")
130:
131: return ret
132:
133: def content_html_XMLRpc(self):
134: """xml_rpc_version"""
135: return encodeRPC(self.content_html())
136:
137: def content_html(self,type="collection"):
138: """template fuer content bei einbau und ECHO_Umgebung"""
139:
140: return content_html(self,type)
141:
142: def getIsVisible(self):
143: """return if object and all parents are visible"""
144:
145: # if object is not visible return False
146: if hasattr(self,'isVisible'):
147: if not self.isVisible : return False
148:
149: # else if parent of object is not ECHO_root, ECHO_basis or None
150: if not self.aq_parent.meta_type in ['ECHO_root','ECHO_basis',None] :
151: return self.aq_parent.getIsVisible()
152:
153: # else return True
154: return True
155:
156: def setIsVisible(self, isVisible):
157: """ set object attribute isVisible"""
158: self.isVisible = isVisible
159:
160: def getAttributeIsVisible(self):
161: """ return object attribute isVisible"""
162: if hasattr(self,'isVisible'):
163: return self.isVisible
164: return True
165:
166: def getTitle(self):
167: """title"""
168: if hasattr(self,'getLanguage'):
169: lang=self.getLanguage()
170: else:
171: lang=None
172:
173: locale=None
174: if lang and not (lang =="de"):
175: locale=self.ZopeFind(self,obj_ids=["locale_"+lang])
176:
177: if locale:
178: return self.decode(locale[0][1].title)
179: else:
180: try:
181: return self.decode(self.title)
182: except:
183: return self.title
184:
185: def getLabel(self):
186: """title"""
187: if hasattr(self,'getLanguage'):
188: lang=self.getLanguage()
189: else:
190: lang=None
191:
192: locale=None
193:
194: if lang and not (lang=="de"):
195: locale=self.ZopeFind(self,obj_ids=["locale_"+lang])
196:
197: if locale:
198: return self.decode(locale[0][1].label)
199:
200:
201: if not hasattr(self,'label'):
202: self.label=""
203:
204: if self.label=="":
205: ret=self.getTitle()
206: if ret=="":
207: ret=self.getId()
208: return ret
209:
210: return self.decode(self.label)
211:
212: def changeECHOEntriesForm(self):
213: """change Entries for the ECHO Navigation environment"""
214: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
215: return pt()
216:
217: def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None):
218: """change Entries for the ECHO Navigation environment
219: @param label: label fuer die Navigation"""
220: self.label=label
221: self.weight=weight
222: self.description=description
223: self.queryString=queryString
224:
225: if RESPONSE:
226: RESPONSE.redirect("manage_main")
227:
228: manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)
229:
230:
231: def hasOverview(self):
232: """returns if there is an overview graphics"""
233: return hasattr(self, 'overview')
234:
235: def hasParentOverview(self):
236: """returns if the parent has an overview graphics"""
237: return hasattr(self.aq_parent, 'overview')
238:
239: def getOverview(self):
240: """map overview graphics"""
241: #return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
242: if self.hasOverview():
243: return getattr(self, 'overview')
244: return None
245:
246: def getMapAreas(self):
247: """returns the list of MapAreas"""
248: forcetypes = self.REQUEST.get('map_force_types', None)
249: if forcetypes:
250: typelist = forcetypes.split(',')
251: else:
252: typelist = None
253: areas = []
254: # get all contained MapAreas
255: for res in self.ZopeFind(self, obj_metatypes=('MapArea')):
256: area = res[1]
257: # check the allowed types
258: if typelist is not None and area.getType() not in typelist:
259: continue
260: areas.append(area)
261: return areas
262:
263: def addMapArea(self, newarea):
264: """add a map area to this object"""
265: if (newarea.id is None):
266: # create new id
267: ids = [a.id for a in self.getMapAreas()]
268: i = len(ids)
269: while ("a%02d"%i in ids):
270: # if it exists, try the next one
271: i += 1
272: newarea.id = "a%02d"%i
273: self._setObject(newarea.id, newarea)
274:
275: def getMapText(self):
276: """returns the MapText"""
277: # get (the first) contained MapText
278: #lang="en"
279: lang=self.getLanguage()
280: res=None
281: if lang and not (lang=="de"):
282: resTmp = self.ZopeFind(self, obj_metatypes=('ECHO_mapText'))
283: res = self.ZopeFind(resTmp[0][1])
284:
285: if not res:
286: res = self.ZopeFind(self, obj_metatypes=('ECHO_mapText'))
287: if len(res) > 0:
288: text = res[0][1]
289: return text
290: return None
291:
292: def ECHO_graphicEntry(self):
293: """change map coordinates"""
294: if self.hasParentOverview():
295: pt=zptFile(self, 'zpt/ECHO_draw.zpt')
296: return pt()
297: else:
298: return "NO OVERVIEW GRAPHICS"
299:
300: def ECHO_addCoords(self,RESPONSE=None):
301: """change or add MapArea"""
302: #return self.REQUEST
303: # change existing areas
304: for area in self.getMapAreas():
305: id = area.getId()
306: if self.REQUEST.has_key('del.'+id):
307: # delete this area
308: self._delObject(id)
309: # return to same menu
310: if RESPONSE is not None:
311: RESPONSE.redirect('ECHO_graphicEntry')
312: return
313: # modify this area
314: coordstring = self.REQUEST.get('coords.'+id, '')
315: coords = string.split(coordstring, ',')
316: angle = self.REQUEST.get('angle.'+id, '0')
317: type = self.REQUEST.get('type.'+id, 'area')
318: permanent = self.REQUEST.get('permanent.'+id, '')
319: if len(coords) == 4:
320: area.setCoordString(coordstring)
321: area.setAngle(angle)
322: area.setType(type)
323: area.setPermanent(permanent)
324: # add the "new" area
325: if self.REQUEST.has_key('add'):
326: coordstring = self.REQUEST.get('coords.new', '')
327: coords = string.split(coordstring, ',')
328: angle = self.REQUEST.get('angle.new', '0')
329: type = self.REQUEST.get('type.new', 'area')
330: permanent = self.REQUEST.get('permanent.new', '')
331: if len(coords) == 4:
332: coords.append(angle)
333: area = MapArea(None, coords, type=type, permanent=permanent)
334: self.addMapArea(area)
335: # return to edit area menu
336: if RESPONSE is not None:
337: RESPONSE.redirect('ECHO_graphicEntry')
338:
339: def createJSAreas(self, areas):
340: """create area calls for JavaScript"""
341: forceperm = self.REQUEST.get('map_force_permanent', None)
342: js="\n"
343: for ob in areas:
344: # check for force-permanent
345: if forceperm is not None:
346: perm = forceperm
347: else:
348: perm = ob.isPermanent()
349: js+="""addArea('%s', 'overview', %s, '%s', '%s');\n"""%(ob.getFullId(),ob.getCoordString(),ob.getType(),perm)
350: return js
351:
352: def createMapHead(self):
353: """create javascript include and script tags for head"""
354: pt=zptFile(self, 'zpt/ECHO_content_map_frag_js')
355: return pt()
356:
357: def createMapImg(self):
358: """generate img-tag for map"""
359: bt = BrowserCheck(self)
360: tag = ""
361: src = self.getOverview().absolute_url()
362: if bt.isN4:
363: # N4 needs ilayer to create an id
364: tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
365: else:
366: # img with id
367: tag += '<img id="overview" src="%s" />'%src
368: return tag
369:
370: def createParentMapImg(self):
371: """generate img-tag for map of parent"""
372: return self.aq_parent.createMapImg()
373:
374: def createMapLink(self, ob, text=None, target="_blank"):
375: """generate map link"""
376: bt = BrowserCheck(self)
377: id = ob.getFullId()
378: link = ob.getLinkId()
379: if text is None:
380: text = ob.getLabel()
381: if text is None:
382: text = "link"
383: tiptext = ob.getTip()
384: tag = ""
385: if bt.isN4:
386: # N4 needs layer for highlighting
387: tag += '<ilayer id="a.%s"><a class="maplink" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
388: tag += ">" + text + "</a></ilayer>"
389: else:
390: # a-element
391: tag = '<a id="a.%s" class="maplink" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
392: if tiptext:
393: tag += ' title="%s"'%tiptext
394: tag += ">" + text + "</a>"
395: return tag
396:
397: def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil", circlesrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/kreis", target="_blank",backLink=None,alternativArrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil_blau"):
398: """generate map link image, text and other stuff"""
399: bt = BrowserCheck(self)
400: id = ob.getFullId()
401: link = ob.getLinkId()
402: tiptext = ob.getTip()
403: tag = ""
404:
405: if bt.isN4:
406: #
407: # N4 needs layer and img elements
408: #
409: tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
410: if ob.isTypeArrow():
411: # N4 - Arrow
412: rot = ob.angle
413:
414: if hasattr(getattr(self,link),'link'):
415: cLink=getattr(self,link).link
416: # if existing delete virtuell path
417: cLink=cLink.replace('/'.join(self.REQUEST['VirtualRootPhysicalPath']),'')
418:
419: if backLink and hasattr(getattr(self,link),'link') and backLink==self.REQUEST['SERVER_URL']+cLink.lstrip():
420: marksrc=alternativArrowsrc
421: else:
422: marksrc = arrowsrc
423:
424:
425: if float(rot) < 0:
426: marksrc = circlesrc
427: tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,marksrc,rot)
428: elif ob.isTypeText():
429: # N4 - Text
430: tag += '<div id="t.%s" class="maptext"'%(id)
431: tag += 'style="visibility:hidden">'
432: tag += ob.getText()
433: tag += '</div>'
434: else:
435: # N4 - Area
436: tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
437: if tiptext:
438: tag += ' alt="%s"'%tiptext
439: tag += ' /></a>'
440: tag += '</layer>'
441: else:
442: #
443: # (more or less) DOM capable browser
444: #
445: tag = '<a id="b.%s" class="mapmarklink" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s">'%(id,id,id,link,target)
446: if ob.isTypeArrow():
447: # DOM - Arrow
448: rot = ob.angle
449:
450: if hasattr(getattr(self,link),'link'):
451: cLink=getattr(self,link).link
452: # if existing delete virtuell path
453: if hasattr(self.REQUEST,'VirtualRootPhysicalPath'):
454: cLink=cLink.replace('/'.join(self.REQUEST['VirtualRootPhysicalPath']),'')
455:
456: if backLink and hasattr(getattr(self,link),'link') and backLink==self.REQUEST['SERVER_URL']+cLink.lstrip():
457: marksrc=alternativArrowsrc
458: else:
459: marksrc = arrowsrc
460:
461: try:
462: rot=float(rot)
463: except:
464: rot=0
465:
466: if float(rot) < 0:
467: marksrc = circlesrc
468: if bt.isIEWin and bt.versIE > 5:
469: # IE/Win 5.5 has "feature" for PNG transparency
470: 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,marksrc,rot,marksrc,rot)
471: else:
472: # arrow image
473: tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,marksrc,rot)
474: elif ob.isTypeText():
475: # DOM - Text
476: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
477: tag += '><div id="t.%s" class="maptext"'%(id)
478: tag += 'style="visibility:hidden">'
479: tag += ob.getText()
480: tag += '</div></div>'
481: else:
482: # DOM - Area
483: if bt.isIE:
484: # IE needs transparent img for area
485: tag += '<img id="i.%s" border="0" style="position:absolute; top:-100px; left:-100px;" src="trans_img"'%(id)
486: if tiptext:
487: tag += ' title="%s"'%tiptext
488: tag += " />"
489: else:
490: # empty div for area
491: tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
492: if tiptext:
493: tag += ' title="%s"'%tiptext
494: tag += '> </div>'
495: tag += '</a>'
496: return tag
497:
498:
499: #ende der echo erweiterungen
500:
501:
502: def toList(field):
503: """Einzelfeld in Liste umwandeln"""
504: if type(field)==types.StringType:
505: return [field]
506: else:
507: return field
508:
509: def getText(nodelist):
510: rc = ""
511: for node in nodelist:
512: if node.nodeType == node.TEXT_NODE:
513: rc = rc + node.data
514: return rc
515:
516: def getTextFromNode(nodename):
517: nodelist=nodename.childNodes
518: rc = ""
519: for node in nodelist:
520: if node.nodeType == node.TEXT_NODE:
521: rc = rc + node.data
522: return rc
523:
524:
525: def readFieldFromXML(meta_url,parent,field):
526: """lesespezifisches metadatum"""
527:
528: try:
529: dom=xml.dom.minidom.parse(meta_url)
530:
531: except:
532: try:
533: fh=urllib.urlopen(meta_url)
534: dom=xml.dom.minidom.parse(fh)
535: except:
536: return None
537: if not dom: return None
538:
539: parent=dom.getElementsByTagName(parent)
540: if not parent: return None
541:
542: field=parent[0].getElementsByTagName(field)
543:
544: if not field: return None
545:
546: return getText(field[0].childNodes)
547:
548:
549:
550: def urlopen(url):
551: """urlopen mit timeout"""
552: socket.setdefaulttimeout(10)
553: ret=urllib.urlopen(url)
554: socket.setdefaulttimeout(5)
555: return ret
556: # urlopener = urllib.URLopener()
557: #
558: # try:
559: # con = urlopener.open(url)
560: # return con
561: # except timeoutsocket.Timeout:
562: # return None
563:
564:
565:
566:
567:
568: def checkOnlyOneInGroup(object):
569: """check if object is a group and if it containt only one element it return this element"""
570: displayedObjects=object.ZopeFind(object,obj_metatypes=displayTypes)
571: if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object
572:
573: return displayedObjects[0][1]
574: else: return object
575:
576:
577: def getSubCols(self, sortfield=None, subColTypes=displayTypes, sortFieldMD=None,searchMD=None,searchMD_modus='search',searchSimple=None,generic="yes",search_sub=0):
578:
579: def sort(x,y):
580: return cmp(x[0],y[0])
581:
582: def sortfnc(sortfield,x,y):
583: try:
584: xa=x[1].getMDValue(sortfield,generic=generic)
585: except:
586: xa=""
587: try:
588: ya=y[1].getMDValue(sortfield,generic=generic)
589: except:
590: ya=""
591: return cmp(xa,ya)
592:
593: sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y))
594: ids=[]
595: displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes,search_sub=search_sub)
596:
597: if searchSimple and (not (searchSimple==""))and hasattr(self,'resourceCatalog'):
598: searchString=" AND ".join(searchSimple.split())
599: ids=[x.getObject() for x in self.resourceCatalog({'getMDValueSimpleSearchField':searchString})]
600: else:
601: for entry in displayedObjects:
602: object=entry[1]
603: if searchMD:
604: if hasattr(object,'getMDValue'):
605: flag=0
606: for field in searchMD.keys():
607: #if object.getMDValue(field,generic=generic)==searchMD[field]:
608: #if re.match(searchMD[field],object.getMDValue(field,generic=generic)):
609: if searchMD_modus=='match':
610: searchResult=re.match(searchMD[field],object.getMDValue(field,generic=generic))
611: else:
612: searchResult=re.search(searchMD[field],object.getMDValue(field,generic=generic))
613: if searchResult:
614: flag=1
615: else:
616: flag=0
617: break
618: if flag==1:
619: ids.append(object)
620: else:
621: ids.append(object)
622: if not sortfield:
623: sortfield=getattr(self,'sortfield','weight')
624: tmplist=[]
625: for x in ids:
626: if hasattr(x,sortfield):
627: try:
628: tmp=int(getattr(x,sortfield))
629: except:
630: tmp=getattr(x,sortfield)
631:
632: else:
633: tmp=10000000
634:
635: tmplist.append((tmp,x))
636:
637: if not sortFieldMD:
638: tmplist.sort(sort)
639: else:
640: tmplist.sort(sortWithMD(sortFieldMD))
641:
642: ret=[x for (key,x) in tmplist]
643:
644: return ret
645:
646: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
647: """Rerender all Links"""
648: ret=""
649:
650: if not obj:
651: obj = self
652:
653: entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
654:
655: for entry in entries:
656: if entry[1].meta_type == 'ECHO_resource':
657: try:
658: entry[1].ECHO_getResourceMD(template="no",overwrite="yes")
659: if "title" in types:
660: entry[1].generate_title()
661: if "label" in types:
662: entry[1].generate_label()
663: ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
664: except:
665: ret+="Error:"+entry[0]+"<br>"
666:
667:
668:
669:
670: return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
671:
672: def reloadMetaDataFromStorage(self,RESPONSE=None):
673: """copy metadata from the storage to ECHO"""
674: ret=""
675: resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
676: if RESPONSE is not None:
677: RESPONSE.setHeader("Content-Type", type)
678: RESPONSE.write("<html><body>\n")
679:
680: for resource in resources:
681: x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
682: if RESPONSE is not None:
683: RESPONSE.write(x+"\n")
684:
685: ret+=x
686:
687: if RESPONSE is not None:
688: #RESPONSE.redirect('./manage_main')
689: RESPONSE.write( "</html></body>")
690:
691: return ret
692:
693: def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
694: """rdf"""
695:
696: ret=""
697: about="""<RDF:Description RDF:about="%s">"""
698: name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
699: link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
700: clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
701: #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
702: type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
703: #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""
704: if not urn:
705: #urn="urn:"+re.sub('/',':',self.absolute_url())
706: urn=self.absolute_url()
707: about2=about%urn
708: if not nameDef:
709: if hasattr(self,'label') and not (self.label==""):
710: name2=name%self.label
711: elif not self.title=="":
712: name2=name%self.title
713: else:
714: name2=name%self.getId()
715:
716: name2=re.sub('&','&',name2)
717: else:
718: name2=name%nameDef
719:
720: linkURL=re.sub('http:','',linkURL)
721: linkURL2=re.sub('&','&',linkURL)
722: link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
723: clickable2=clickable%"true"
724:
725: if not typeName:
726: type2=type%self.meta_type
727: else:
728: type2=type%typeName
729:
730: #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
731: ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
732: return ret
733:
734: def getCopyrightsFromForm(self,argv):
735: medias={}
736: partners={}
737: copyrights={}
738:
739: copyrightsFinal=[]
740: for arg in argv.keys():
741:
742: if arg[0:5]=='media':
743: nm=int(arg[5:])
744: medias[nm]=argv[arg]
745: elif arg[0:5]=='partn':
746: nm=int(arg[5:])
747: partners[nm]=argv[arg]
748: elif arg[0:5]=='copyr':
749: nm=int(arg[5:])
750: copyrights[nm]=argv[arg]
751:
752:
753:
754: copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
755: for copyright in copyrightsList:
756:
757: if copyright[2]=='institution0000':
758: copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
759: else:
760: if not copyright[0]=='':
761: copyrightsFinal.append(copyright)
762:
763:
764: return copyrightsFinal
765:
766: #List of different types for the graphical linking viewer
767: viewClassificationListMaster=['view point','area']
768:
769:
770: def checkDiffs(self,metadict):
771: """check differences"""
772:
773:
774:
775:
776: def NoneToEmpty(obj):
777: if obj:
778: return obj
779: else:
780: return ""
781:
782:
783:
784: diffs={}
785:
786: tags=self.findTagsFromMapping(self.contentType)
787: self.referencetypes=tags[2]
788: self.fields=tags[3]
789:
790:
791: for field in tags[1]:
792: try:
793: if (NoneToEmpty(self.getMDValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
794: diffs[self.getFieldTag(tags,field)]=1
795: else:
796:
797: diffs[self.getFieldTag(tags,field)]=0
798: except:
799: diffs[self.getFieldTag(tags,field)]=0
800:
801: return diffs
802:
803:
804: def zptFile(self, path, orphaned=False):
805: """returns a page template file from the product"""
806: if orphaned:
807: # unusual case
808: pt=PageTemplateFile(os.path.join(package_home(globals()), path))
809: else:
810:
811: pt=PageTemplateFile(os.path.join(package_home(globals()), path)).__of__(self)
812: return pt
813:
814:
815: def findObjectPath(startobject, filename):
816: """returns the object with the name filename starting at startobject"""
817: if startobject is None:
818: return None
819: paths = filename.split('/')
820: object = startobject
821: for path in paths:
822:
823: if hasattr(object, path):
824: object = getattr(object, path)
825: else:
826: object = None
827: break
828: return object
829:
830:
831: def zptObjectOrFile(self, filename, localdir='zpt', orphaned=False):
832: """returns a page template instance or a file from the product"""
833: # look for an object called path
834: pt = findObjectPath(self, filename)
835: # the object should also not be a python function
836: if (pt is None) or isinstance(pt, types.FunctionType):
837: # get a ZPT file
838: pt = zptFile(self, localdir+'/'+filename, orphaned=orphaned)
839: return pt
840:
841:
842: def sendFile(self, filename, type):
843: """sends an object or a local file (in the product) as response"""
844: # look for an object called filename
845: object = findObjectPath(self, filename)
846: if object:
847: # if the object exists then send it
848: return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
849: else:
850: # send a local file with the given content-type
851: fn = os.path.join(package_home(globals()), filename)
852: self.REQUEST.RESPONSE.setHeader("Content-Type", type)
853: self.REQUEST.RESPONSE.write(file(fn).read())
854: return
855:
856:
857: class BrowserCheck:
858: """check the browsers request to find out the browser type"""
859:
860: def __init__(self, zope):
861: """initialisiere"""
862: self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
863: self.isN4 = False
864: self.isIE = False
865: if string.find(self.ua, 'MSIE') > -1:
866: self.isIE = True
867: else:
868: self.isN4 = string.find(self.ua, 'Mozilla/4.') > -1
869: try:
870: self.nav = self.ua[string.find(self.ua, '('):]
871: ie = string.split(self.nav, "; ")[1]
872: if string.find(ie, "MSIE") > -1:
873: self.versIE = string.split(ie, " ")[1]
874: except: pass
875: self.isMac = string.find(self.ua, 'Macintosh') > -1
876: self.isWin = string.find(self.ua, 'Windows') > -1
877: self.isIEWin = self.isIE and self.isWin
878: self.isIEMac = self.isIE and self.isMac
879:
880:
881: def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
882: """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
883:
884: def updateTextToolNode(tag,value):
885:
886: metanode=dom.getElementsByTagName('texttool')[0]
887: try:
888: nodeOld=metanode.getElementsByTagName(tag)
889: except:
890: nodeOld=None
891:
892: if nodeOld:
893: metanode.removeChild(nodeOld[0]).unlink()
894:
895: node=dom.createElement(tag)
896: nodetext=dom.createTextNode(value)
897: node.appendChild(nodetext)
898: metanode.appendChild(node)
899:
900:
901: if xmlfrag:
902: geturl="""<?xml version="1.0" encoding="UTF-8" ?>
903: <resource type="MPIWG">
904: <meta>
905: <bib type="Book">
906: </bib>
907: </meta>
908: </resource>"""
909: dom=xml.dom.minidom.parseString(geturl)
910: else:
911: try:
912: geturl=""
913: for line in urlopen(url).readlines():
914: geturl=geturl+line
915:
916:
917: except:
918: zLOG.LOG("ECHO writeMetadata",zLOG.ERROR,"XCannot open: "+url)
919: return (None,"XCannot open: "+url)
920:
921: try:
922: dom=xml.dom.minidom.parseString(geturl)
923: except:
924: zLOG.LOG("ECHO writeMetadata",zLOG.ERROR,"Cannot parse: "+url+"<br>"+geturl)
925: return (None,"Cannot parse: "+url+"<br>"+geturl)
926:
927:
928:
929: metanodes=dom.getElementsByTagName('bib')
930:
931: if not metanodes:
932: metanodes=dom.getElementsByTagName('archimedes')
933:
934: metanode=metanodes[0]
935:
936: for metaData in metadict.keys():
937: if metaData:
938: try:
939: nodeOld=metanode.getElementsByTagName(metaData)
940: except:
941: nodeOld=None
942:
943: if nodeOld:
944: metanode.removeChild(nodeOld[0]).unlink()
945: else:
946: # try also old writing rule - instead of _:
947: try:
948: nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
949: except:
950: nodeOld=None
951:
952: if nodeOld:
953: metanode.removeChild(nodeOld[0]).unlink()
954:
955:
956: metanodeneu=dom.createElement(metaData)
957: try:
958: metanodetext=dom.createTextNode(metadict[metaData].decode('utf-8'))
959: except:
960: metanodetext=dom.createTextNode(metadict[metaData])
961: #try:
962:
963: #metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
964: #except:
965: #metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
966: metanodeneu.appendChild(metanodetext)
967: metanode.appendChild(metanodeneu)
968:
969:
970:
971:
972:
973: if project:
974: updateTextToolNode('project',project)
975:
976: if startpage:
977: updateTextToolNode('startpage',startpage)
978:
979: if topbar:
980: updateTextToolNode('toptemplate',topbar)
981:
982: if thumbtemplate:
983: updateTextToolNode('thumbtemplate',thumbtemplate)
984:
985: if xslt:
986: updateTextToolNode('xslt',xslt)
987:
988:
989: if digiliburlprefix:
990: updateTextToolNode('digiliburlprefix',digiliburlprefix)
991:
992: try:
993:
994: return dom.toxml(encoding='utf-8').encode('utf-8')
995: except:
996:
997:
998: return dom.toxml(encoding='utf-8')
999:
1000: def readMetadata(url):
1001: """Methode zum Auslesen der Metadateninformation zu einer Resource
1002: Vorerst noch Typ bib"""
1003:
1004: metadict={}
1005:
1006: try:
1007: geturl=""
1008: for line in urlopen(url).readlines():
1009: geturl=geturl+line
1010:
1011:
1012: except:
1013: return (None,"Cannot open: "+url)
1014:
1015: try:
1016: dom=xml.dom.minidom.parseString(geturl)
1017: except:
1018: return (None,"Cannot parse: "+url+"<br>"+geturl)
1019:
1020: metanode=dom.getElementsByTagName('bib')
1021: metadict['bib_type']='Book'
1022: if len(metanode)==0:
1023: metanode=dom.getElementsByTagName('archimedes')
1024: metadict['bib_type']='Archimedes'
1025:
1026:
1027: if not len(metanode)==0:
1028: metacontent=metanode[0].childNodes
1029:
1030: try:
1031: metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
1032: except:
1033: """nothing"""
1034:
1035: for node in metacontent:
1036: try:
1037: #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
1038: #metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
1039: metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
1040:
1041: except:
1042: """nothing"""
1043:
1044: return (metadict,"")
1045:
1046:
1047: class MapArea(SimpleItem):
1048: """simple class to hold coordinates"""
1049:
1050: meta_type = 'MapArea'
1051: # Create a SecurityInfo for this class.
1052: security = ClassSecurityInfo()
1053: security.setDefaultAccess("allow")
1054: # type constants
1055: TYPE_AREA = 'area'
1056: TYPE_ARROW = 'arrow'
1057: TYPE_TEXT = 'text'
1058:
1059: def __init__(self, id, coords, label=None, type=None, tip=None, permanent=False):
1060: """init"""
1061: self.coords = coords[0:4]
1062: if len(coords) > 4:
1063: self.angle = coords[4]
1064: else:
1065: self.angle = 0
1066: self.id = id
1067: self.label = label
1068: self.setType(type)
1069: self.tip = tip
1070: self.permanent = permanent
1071:
1072: def setCoords(self, coords):
1073: """sets the coords"""
1074: self.coords = coords
1075:
1076: def getCoordString(self):
1077: """returns coordinates as a string"""
1078: return string.join(self.coords, ',')
1079:
1080: def setCoordString(self, coordstring):
1081: """sets coordinates from a string"""
1082: coords = string.split(coordstring, ',')
1083: self.coords = [c.strip() for c in coords]
1084:
1085: def getFullId(self, prefix=None):
1086: """returns the id with prefixed parent id"""
1087: if prefix is None:
1088: if hasattr(self, 'aq_parent'):
1089: prefix = self.aq_parent.id
1090: else:
1091: prefix = "id"
1092: fid = prefix + "." + self.id
1093: return fid
1094:
1095: def getType(self):
1096: """returns the type"""
1097: return self.type
1098:
1099: def setType(self, type):
1100: """sets the type"""
1101: if type == MapArea.TYPE_ARROW:
1102: self.type = MapArea.TYPE_ARROW
1103: elif type == MapArea.TYPE_AREA:
1104: self.type = MapArea.TYPE_AREA
1105: elif type == MapArea.TYPE_TEXT:
1106: self.type = MapArea.TYPE_TEXT
1107: else:
1108: self.type = MapArea.TYPE_AREA
1109:
1110: def isTypeArea(self):
1111: """returns if the type is area"""
1112: return self.type == MapArea.TYPE_AREA
1113:
1114: def isTypeArrow(self):
1115: """returns if the type is arrow"""
1116: return self.type == MapArea.TYPE_ARROW
1117:
1118: def isTypeText(self):
1119: """returns if the type is text"""
1120: return self.type == MapArea.TYPE_TEXT
1121:
1122: def getAngle(self):
1123: """returns the angle"""
1124: return self.angle
1125:
1126: def setAngle(self, angle):
1127: """sets the angle"""
1128: self.angle = angle
1129:
1130: def getTip(self):
1131: """returns the popup text"""
1132: # patch old version
1133: if not hasattr(self, 'tip'):
1134: self.tip = self.text
1135:
1136: if self.tip is None:
1137: if hasattr(self, 'aq_parent'):
1138: parent = self.aq_parent
1139: if parent.contentType == 'text-popup':
1140: return parent.description
1141: return self.tip
1142:
1143: def setTip(self, text):
1144: """sets the text"""
1145: self.tiptext = text
1146:
1147: def getText(self):
1148: """returns the text fpr the area"""
1149: if hasattr(self, 'aq_parent'):
1150: parent = self.aq_parent
1151: text = parent.getMapText()
1152: if text is not None:
1153: return text.document_src()
1154: return ""
1155:
1156: def getLabel(self):
1157: """returns the link label"""
1158: if self.label is None:
1159: if hasattr(self, 'aq_parent'):
1160: return self.aq_parent.label or self.aq_parent.id
1161: return self.label
1162:
1163: def setLabel(self, label):
1164: """sets the label"""
1165: self.label = label
1166:
1167: def isPermanent(self):
1168: """returns the permanent state"""
1169: # patch old objects
1170: if not hasattr(self, 'permanent'):
1171: self.permanent = False
1172: return self.permanent
1173:
1174: def setPermanent(self, state):
1175: """sets the permanent state"""
1176: if state:
1177: self.permanent = True
1178: else:
1179: self.permanent = False
1180:
1181: def getLinkId(self):
1182: if hasattr(self, 'aq_parent'):
1183: return self.aq_parent.id
1184: return self.id
1185:
1186: # call this to initialize framework classes, which
1187: # does the right thing with the security assertions.
1188: Globals.InitializeClass(MapArea)
1189:
1190:
1191: class MapText(Folder,ZopePageTemplate):
1192: """class to hold text for map areas"""
1193:
1194: meta_type = 'ECHO_mapText'
1195: # Create a SecurityInfo for this class.
1196: security = ClassSecurityInfo()
1197: security.setDefaultAccess("allow")
1198:
1199:
1200: _default_content_fn = os.path.join(package_home(globals()),
1201: 'html', 'ECHO_mapText_default.html')
1202:
1203: def __init__(self, id, text=None, content_type=None):
1204: self.id = str(id)
1205: self.ZBindings_edit(self._default_bindings)
1206: if text is None:
1207: text = open(self._default_content_fn).read()
1208: self.pt_edit(text, content_type)
1209:
1210: def createLocale(self):
1211: """create locale"""
1212: return ECHO_collection.manage_addECHO_localeForm(self)
1213:
1214: manage_main=ZopePageTemplate.pt_editForm
1215:
1216: def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
1217: """manage add echo locale in map"""
1218: ECHO_collection.manage_addECHO_locale(self,lang,title,label,text,content_type)
1219: if RESPONSE is not None:
1220: RESPONSE.redirect('manage_main')
1221:
1222:
1223: def changeLocale(self):
1224: """change locale"""
1225: return self.locale_en.change_ECHO_localeForm()
1226:
1227: def change_ECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
1228: """change echo locale"""
1229:
1230: obj= self.locale_en.change_ECHO_locale(lang,title,label,text,content_type,RESPONSE)
1231:
1232:
1233:
1234: if RESPONSE is not None:
1235: RESPONSE.redirect('manage_main')
1236:
1237:
1238: # Product registration and Add support
1239: manage_addMapTextForm = PageTemplateFile(
1240: 'zpt/AddECHO_mapText', globals(), __name__='manage_addMapTextForm')
1241:
1242: def manage_addMapText(self, id, title=None, text=None,
1243: REQUEST=None, submit=None):
1244: "Add a Map Text with optional file content."
1245:
1246: id = str(id)
1247: if REQUEST is None:
1248: self._setObject(id, MapText(id, text))
1249: ob = getattr(self, id)
1250: if title:
1251: ob.pt_setTitle(title)
1252: return ob
1253: else:
1254: file = REQUEST.form.get('file')
1255: headers = getattr(file, 'headers', None)
1256: if headers is None or not file.filename:
1257: zpt = MapText(id, text)
1258: else:
1259: zpt = MapText(id, file, headers.get('content_type'))
1260:
1261: self._setObject(id, zpt)
1262: if title:
1263: ob = getattr(self, id)
1264: ob.pt_setTitle(title)
1265:
1266: try:
1267: u = self.DestinationURL()
1268: except AttributeError:
1269: u = REQUEST['URL1']
1270:
1271: if submit == " Add and Edit ":
1272: u = "%s/%s" % (u, urllib.quote(id))
1273: REQUEST.RESPONSE.redirect(u+'/manage_main')
1274: return ''
1275:
1276: # call this to initialize framework classes, which
1277: # does the right thing with the security assertions.
1278: Globals.InitializeClass(MapText)
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