[BACK]Return to ECHO_helpers.py CVS log [TXT] [DIR] Up to [Repository] / ECHO_content

Diff for /ECHO_content/ECHO_helpers.py between versions 1.19 and 1.52

version 1.19, 2004/09/09 16:56:37 version 1.52, 2005/06/09 15:08:01
Line 1 Line 1
   import re
   import string
 import socket  import socket
 import urllib  import urllib
   import string
   import xml.dom.minidom
   import types
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from OFS.SimpleItem import SimpleItem
   from Globals import package_home
   import Globals
   from AccessControl import ClassSecurityInfo
   import os.path
   
   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']
   
   def content_html(self,type):
           """template fuer content"""
           #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
           #
           #if templates:
           #    return templates[0][1]()
   
           if hasattr(self,type+"_template"):
               obj=getattr(self,type+"_template")
               return obj()
           else:
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%type)).__of__(self)
               pt.content_type="text/html"
               return pt()
       
       
   
   class ECHO_basis:
       """basis eigenschaften fuer echo objekte"""
       security=ClassSecurityInfo()
       security.declarePublic('getImageTag')
       def getImageTag(self):
           """sollte uerberschrieben werden, falls von der Klasse eine imagetag zurueckkommt"""
           
           return ""
       
       def showRDF(self):
           """showrdf"""
               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
           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"""
   
           ret+=self.getRDF(urn="echo:collectionroot")+"\n"
   
   
           ret+="""</RDF:RDF>"""
               return ret 
   
     
       def RDF(self):
           """showrdf"""
               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
           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"""
   
           ret+=self.getRDF(urn=self.absolute_url())+"\n"
   
   
           ret+="""</RDF:RDF>"""
               return ret 
   
     
       def createSubElementRDF(self,urn=None):
           """rdf list"""
           if not urn:
               urn=self.absolute_url()
           ret=""
   
           rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
           flag=0
           
           li="""<RDF:li RDF:resource="%s" />\n"""
           if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
               nurn=self.absolute_url()+'/getFullTextXML'
               rettemp+=li%nurn
               flag=1
           if not ('<error>' in self.getImageView(noredirect='Yes')):
               nurn=self.absolute_url()+'/getImageView'
               rettemp+=li%nurn
               flag=1
   
   
           if not ('<error>' in self.showMetaDataXML()):
               nurn=self.absolute_url()+'/showMetaDataXML'
               rettemp+=li%nurn
               flag=1
               
           rettemp+="</RDF:Seq>"
   
           if flag==1:
               ret+=rettemp
               
           if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
                       nurn=self.absolute_url()+'/getFullTextXML'  
               ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")
   
           if not ('<error>' in self.getImageView(noredirect='Yes')):
                       nurn=self.absolute_url()+'/getImageView'
               ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
               
           if not ('<error>' in self.showMetaDataXML()):
                       nurn=self.absolute_url()+'/showMetaDataXML'
               ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")
   
           return ret
           
       def content_html(self,type="collection"):
           """template fuer content bei einbau und ECHO_Umgebung"""
           
           return content_html(self,type)
           
       def getTitle(self):
       """title"""
       return self.decode(self.title)
       try:
           return self.title.encode('utf-8','ignore') 
       except:
           self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
           return self.title.encode('utf-8','ignore') 
       
       def getLabel(self):
       """title"""
       if not hasattr(self,'label'):
           self.label=""
           
       if self.label=="":
           ret=self.getTitle()
           if ret=="":
               ret=self.getId()
           return ret
       
       return self.decode(self.label)
       try:
           return self.label.encode('utf-8','ignore') 
       except:
           self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
           return self.label.encode('utf-8','ignore') 
       
       
       def changeECHOEntriesForm(self):
           """change Entries for the ECHO Navigation environment"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
           return pt()
       
       def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None):
           """change Entries for the ECHO Navigation environment
           @param label: label fuer die Navigation"""
           self.label=label
           self.weight=weight
           self.description=description
       self.queryString=queryString
           
           if RESPONSE:
               RESPONSE.redirect("manage_main")
   
       manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)
   
   
       def hasOverview(self):
           """returns if there is an overview graphics"""
       return hasattr(self, 'overview')
   
       def hasParentOverview(self):
           """returns if the parent has an overview graphics"""
       return hasattr(self.aq_parent, 'overview')
   
       def getOverview(self):
           """map overview graphics"""
           #return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
       if self.hasOverview():
           return getattr(self, 'overview')
       return None
   
       def getMapAreas(self):
           """returns the list of MapAreas"""
       # get all contained MapAreas
           areas = [res[1] for res in self.ZopeFind(self, obj_metatypes=('MapArea'))]
       return areas
   
       def addMapArea(self, newarea):
       """add a map area to this object"""
       if (newarea.id is None):
           # create new id
           ids = [a.id for a in self.getMapAreas()]
           i = len(ids)
           while ("a%02d"%i in ids):
           # if it exists, try the next one
           i += 1
           newarea.id = "a%02d"%i
       self._setObject(newarea.id, newarea)
   
       def getMapText(self):
           """returns the MapText"""
       # get (the first) contained MapText
           res = self.ZopeFind(self, obj_metatypes=('ECHO_mapText'))
       if len(res) > 0:
           text = res[0][1]
           return text
       return None
   
       def ECHO_graphicEntry(self):
           """change map coordinates"""
           if self.hasParentOverview():
               pt=zptFile(self, 'zpt/ECHO_draw.zpt')
               return pt()
           else:
               return "NO OVERVIEW GRAPHICS"
   
       def ECHO_addCoords(self,RESPONSE=None):
           """change or add MapArea"""
       #return self.REQUEST
       # change existing areas
       for area in self.getMapAreas():
           id = area.getId()
           if self.REQUEST.has_key('del.'+id):
           # delete this area
           self._delObject(id)
           # return to same menu
           if RESPONSE is not None:
               RESPONSE.redirect('ECHO_graphicEntry')
           return
           # modify this area
           coordstring = self.REQUEST.get('coords.'+id, '')
           coords = string.split(coordstring, ',')
           angle = self.REQUEST.get('angle.'+id, '0')
           type = self.REQUEST.get('type.'+id, 'area')
           if len(coords) == 4:
           area.setCoordString(coordstring)
           area.setAngle(angle)
           area.setType(type)
       # add new area
       if self.REQUEST.has_key('add'):
           coordstring = self.REQUEST.get('coords.new', '')
           coords = string.split(coordstring, ',')
           angle = self.REQUEST.get('angle.new', '0')
           type = self.REQUEST.get('type.new', 'area')
           if len(coords) == 4:
           coords.append(angle)
           area = MapArea(None, coords, type=type)
           self.addMapArea(area)
       # return to edit area menu
       if RESPONSE is not None:
           RESPONSE.redirect('ECHO_graphicEntry')
   
       def createJSAreas(self, areas):
           """create area calls for JavaScript"""
           dynamical="\n"
           for ob in areas:
           dynamical+="""addArea('%s', 'overview', %s, '%s');\n"""%(ob.getFullId(),ob.getCoordString(),ob.getType())
           return dynamical
   
       def createMapHead(self):
           """create javascript include and script tags for head"""
           pt=zptFile(self, 'zpt/ECHO_content_map_frag_js')
           return pt()
   
       def createMapImg(self):
       """generate img-tag for map"""
       bt = BrowserCheck(self)
       tag = ""
       src = self.getOverview().absolute_url()
       if bt.isN4:
           # N4 needs ilayer to create an id
           tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
       else:
           # img with id
           tag += '<img id="overview" src="%s" />'%src
       return tag
           
       def createParentMapImg(self):
       """generate img-tag for map of parent"""
       return self.aq_parent.createMapImg()
   
       def createMapLink(self, ob, text=None, target="_blank"):
       """generate map link"""
       bt = BrowserCheck(self)
       id = ob.getFullId()
       link = ob.getLinkId()
       if text is None:
           text = ob.getLabel()
       if text is None:
           text = "link"
       tiptext = ob.getTip()
       tag = ""
       if bt.isN4:
           # N4 needs layer for highlighting
           tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
           tag += ">" + text + "</a></ilayer>"
       else:
           # a-element
           tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
           if tiptext:
           tag += ' title="%s"'%tiptext
           tag += ">" + text + "</a>"
       return tag
   
       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"):
       """generate map link image, text and other stuff"""
       bt = BrowserCheck(self)
       id = ob.getFullId()
       link = ob.getLinkId()
       tiptext = ob.getTip()
       tag = ""
   
       if bt.isN4:
           #
           # N4 needs layer and img elements
           #
           tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
           if ob.isTypeArrow():
           # N4 - Arrow
               rot = ob.angle
           marksrc = arrowsrc
           if rot < 0:
               marksrc = circlesrc
           tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,marksrc,rot)
           else:
           # N4 - Area
           tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
           if tiptext:
               tag += ' alt="%s"'%tiptext
           tag += ' /></a>'
           tag += '</layer>'
       else:
           #
           # (more or less) DOM capable browser
           #
           tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s">'%(id,id,id,link,target)
           if ob.isTypeArrow():
           # DOM - Arrow
           rot = ob.angle
           marksrc = arrowsrc
           if float(rot) < 0:
               marksrc = circlesrc
           print "ROT: ", rot, " mark: ", marksrc
           if bt.isIEWin and bt.versIE > 5:
               # IE/Win 5.5 has "feature" for PNG transparency
               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)
           else:
               # arrow image
               tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,marksrc,rot)
           elif ob.isTypeText():
           # DOM - Text
           tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
           if tiptext:
               tag += ' title="%s"'%tiptext
           tag += '><div id="t.%s" class="maptext" style="visibility:hidden">'%(id)
           tag += ob.getText()
           tag += '</div></div>'
           else:
           # DOM - Area
           if bt.isIE:
               # IE needs transparent img for area
               tag += '<img id="i.%s" border="0" style="position:absolute; top:-100px; left:-100px;" src="trans_img"'%(id)
               if tiptext:
               tag += ' title="%s"'%tiptext
               tag += " />"
           else:
               # empty div for area
               tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
               if tiptext:
               tag += ' title="%s"'%tiptext
               tag += '> </div>'
           tag += '</a>'
       return tag
   
   
       #ende der echo erweiterungen
   
   
   def toList(field):
       """Einzelfeld in Liste umwandeln"""
       if type(field)==types.StringType:
           return [field]
       else:
           return field
   
   def getText(nodelist):
       rc = ""
       for node in nodelist:
           if node.nodeType == node.TEXT_NODE:
              rc = rc + node.data
       return rc
   
   def getTextFromNode(nodename):
       nodelist=nodename.childNodes
       rc = ""
       for node in nodelist:
           if node.nodeType == node.TEXT_NODE:
              rc = rc + node.data
       return rc
   
   
   def readFieldFromXML(meta_url,parent,field):
       """lesespezifisches metadatum"""
       
       try:
           dom=xml.dom.minidom.parse(meta_url)
   
       except:
           try:
               fh=urllib.urlopen(meta_url)
               dom=xml.dom.minidom.parse(fh)
               except:
               return None
       if not dom: return None
   
       parent=dom.getElementsByTagName(parent)
       if not parent: return None
   
       field=parent[0].getElementsByTagName(field)
   
       if not field: return None
   
       return getText(field[0].childNodes)
       
       
           
 def urlopen(url):  def urlopen(url):
     """urlopen mit timeout"""      """urlopen mit timeout"""
       socket.setdefaulttimeout(2)
       ret=urllib.urlopen(url)
     socket.setdefaulttimeout(5)      socket.setdefaulttimeout(5)
     return urllib.urlopen(url)      return ret
 #   urlopener = urllib.URLopener()  #   urlopener = urllib.URLopener()
 #  #
 #   try:          #   try:        
Line 14  def urlopen(url): Line 436  def urlopen(url):
 #       return None  #       return None
   
   
 displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement']  
   
   
 def checkOnlyOneInGroup(object):   def checkOnlyOneInGroup(object): 
Line 23  def checkOnlyOneInGroup(object): Line 445  def checkOnlyOneInGroup(object):
     if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object      if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object
   
         return displayedObjects[0][1]          return displayedObjects[0][1]
     else:      else:       return object
         return object  
   
 def getSubCols(self,sortfield="weight",subColTypes= displayTypes):  def getSubCols(self, sortfield=None, subColTypes=displayTypes, sortFieldMD=None,searchMD=None):
   
                   
       def sort(x,y):
           return cmp(x[0],y[0])
       
       def sortfnc(sortfield,x,y):
           try:
               xa=x[1].getMDValue(sortfield)
           except:
               xa=""
           try:
               ya=y[1].getMDValue(sortfield)
           except:
               ya=""
           return cmp(xa,ya)
       
       sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y))
         ids=[]          ids=[]
     displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes)      displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes)
           
           
     for entry in displayedObjects:      for entry in displayedObjects:
   
               
             object=entry[1]              object=entry[1]
             try:          if searchMD and hasattr(object,'getMDValue'):
                 if object.meta_type in subColTypes:              flag=0
               for field in searchMD.keys():
                   if object.getMDValue(field)==searchMD[field]:
                       flag=1
                   else:
                       flag=0
                       break
               if flag==1:
                   ids.append(object)
           else:
             ids.append(object)              ids.append(object)
                                           
             except:      if not sortfield:
                 """nothing"""              sortfield=getattr(self,'sortfield','weight')
         try:  
             sortfield=self.sortfield  
         except:  
             """nothing"""  
                           
         tmplist=[]          tmplist=[]
   
         for x in ids:          for x in ids:
           
             if hasattr(x,sortfield):              if hasattr(x,sortfield):
                 try:                  try:
                   tmp=int(getattr(x,sortfield))
                     x=int(x)  
                 except:                  except:
                     """nothing"""  
                 tmp=getattr(x,sortfield)                  tmp=getattr(x,sortfield)
                   
             else:              else:
                 tmp=10000000                  tmp=10000000
               
             tmplist.append((tmp,x))              tmplist.append((tmp,x))
         tmplist.sort()  
       if not sortFieldMD:
           tmplist.sort(sort)
       else:
           tmplist.sort(sortWithMD(sortFieldMD))
       
         return [x for (key,x) in tmplist]          return [x for (key,x) in tmplist]
   
   def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
           """Rerender all Links"""
       ret=""
       
           if not obj:
               obj = self
               
           entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
   
           for entry in entries:
           if entry[1].meta_type == 'ECHO_resource':
               try:
                   entry[1].ECHO_getResourceMD(template="no")
                                   if "title" in types:
                                       entry[1].generate_title()
                                   if "label" in types:
                                       entry[1].generate_label()
                   ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
               except:
                   ret+="Error:"+entry[0]+"<br>"
   
           
                   
                   
           return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
   
   def reloadMetaDataFromStorage(self,RESPONSE=None):
           """copy metadata from the storage to ECHO"""
           ret=""
           resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
           for resource in resources:
               x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
               ret+=x
   
           if RESPONSE is not None:
               #RESPONSE.redirect('./manage_main')
               return "<html><body>"+ret+"</html></body>"
   
           return ret
       
   def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
           """rdf"""
           
           ret=""
           about="""<RDF:Description RDF:about="%s">"""
           name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
           link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
           clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
           #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
           type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
               #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""    
           if not urn:
               #urn="urn:"+re.sub('/',':',self.absolute_url())
               urn=self.absolute_url()
           about2=about%urn
           if not nameDef:
               if hasattr(self,'label') and not (self.label==""):
                   name2=name%self.label
               elif not self.title=="":
                   name2=name%self.title
               else:
                   name2=name%self.getId()
   
               name2=re.sub('&','&amp;',name2)
           else:
               name2=name%nameDef
   
           linkURL=re.sub('http:','',linkURL)
           linkURL2=re.sub('&','&amp;',linkURL)
           link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
           clickable2=clickable%"true"
   
           if not typeName:
               type2=type%self.meta_type
           else:
               type2=type%typeName
           
           #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
           ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
           return ret
       
   def getCopyrightsFromForm(self,argv): 
       medias={}
       partners={}
       copyrights={}
       
       copyrightsFinal=[]
       for arg in argv.keys():
           
           if arg[0:5]=='media':
               nm=int(arg[5:])
               medias[nm]=argv[arg]
           elif arg[0:5]=='partn':
               nm=int(arg[5:])
               partners[nm]=argv[arg]
           elif arg[0:5]=='copyr':
               nm=int(arg[5:])
               copyrights[nm]=argv[arg]
   
   
   
       copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
       for copyright in copyrightsList:
           
           if copyright[2]=='institution0000':
               copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
           else:
               if not copyright[0]=='':
                   copyrightsFinal.append(copyright)
           
               
       return copyrightsFinal
   
   #List of different types for the graphical linking viewer
   viewClassificationListMaster=['view point','area']
   
   
   def checkDiffs(self,metadict):
           """check differences"""
   
           
   
       
           def NoneToEmpty(obj):
               if obj:
                   return obj
               else:
                   return ""
   
           
           
           diffs={}
           
           tags=self.findTagsFromMapping(self.contentType)
           self.referencetypes=tags[2]
           self.fields=tags[3]
           
       
           for field in tags[1]:
               try:
                   if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
                       diffs[self.getFieldTag(tags,field)]=1
                   else:
                       
                       diffs[self.getFieldTag(tags,field)]=0
               except:
                   diffs[self.getFieldTag(tags,field)]=0
                   
           return diffs
       
   
   def zptFile(self, path, orphaned=False):
       """returns a page template file from the product"""
       if orphaned:
       # unusual case
       pt=PageTemplateFile(os.path.join(package_home(globals()), path))
       else:
       pt=PageTemplateFile(os.path.join(package_home(globals()), path)).__of__(self)
       return pt
   
   
   def findObjectPath(startobject, filename):
       """returns the object with the name filename starting at startobject"""
       if startobject is None:
       return None
       paths = filename.split('/')
       object = startobject
       for path in paths:
           
           if hasattr(object, path):
           object = getattr(object, path)
       else:
           object = None
           break
       return object
   
   
   def zptObjectOrFile(self, filename, localdir='zpt', orphaned=False):
       """returns a page template instance or a file from the product"""
       # look for an object called path
       pt = findObjectPath(self, filename)
       # the object should also not be a python function
       if (pt is None) or isinstance(pt, types.FunctionType):
       # get a ZPT file
       pt = zptFile(self, localdir+'/'+filename, orphaned=orphaned)
       return pt
   
   
   def sendFile(self, filename, type):
       """sends an object or a local file (in the product) as response"""
       # look for an object called filename
       object = findObjectPath(self, filename)
       if object:
       # if the object exists then send it
       return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
       else:
       # send a local file with the given content-type
       fn = os.path.join(package_home(globals()), filename)
       self.REQUEST.RESPONSE.setHeader("Content-Type", type)
       self.REQUEST.RESPONSE.write(file(fn).read())
       return
   
   
   class BrowserCheck:
       """check the browsers request to find out the browser type"""
       
       def __init__(self, zope):
           """initialisiere"""
       self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
       self.isN4 = False
       self.isIE = False
       if string.find(self.ua, 'MSIE') > -1:
           self.isIE = True
       else:
           self.isN4 = string.find(self.ua, 'Mozilla/4.') > -1
       try:
           self.nav = self.ua[string.find(self.ua, '('):]
           ie = string.split(self.nav, "; ")[1]
           if string.find(ie, "MSIE") > -1:
           self.versIE = string.split(ie, " ")[1]
       except: pass
       self.isMac = string.find(self.ua, 'Macintosh') > -1
       self.isWin = string.find(self.ua, 'Windows') > -1
       self.isIEWin = self.isIE and self.isWin
       self.isIEMac = self.isIE and self.isMac
   
           
   def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
       """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
   
       def updateTextToolNode(tag,value):
   
           metanode=dom.getElementsByTagName('texttool')[0]
           try:
               nodeOld=metanode.getElementsByTagName(tag)
           except:
               nodeOld=None
               
           if nodeOld:
               metanode.removeChild(nodeOld[0]).unlink()
   
           node=dom.createElement(tag)
           nodetext=dom.createTextNode(value)
           node.appendChild(nodetext)
           metanode.appendChild(node)
   
       if xmlfrag:
           geturl="""<?xml version="1.0" ?>
                              <resource type="MPIWG">
                  <meta>
                   <bib type="Book">
                           </bib>
                   </meta>
                   </resource>"""
           dom=xml.dom.minidom.parseString(geturl)
       else:
           try:
               geturl=""
               for line in urlopen(url).readlines():
                   geturl=geturl+line
   
   
           except:
               return (None,"XCannot open: "+url)
   
           try:
               dom=xml.dom.minidom.parseString(geturl)
           except:
               return (None,"Cannot parse: "+url+"<br>"+geturl)
   
       
   
       metanodes=dom.getElementsByTagName('bib')
   
       if not metanodes:
           metanodes=dom.getElementsByTagName('archimedes')
   
       metanode=metanodes[0]
   
       for metaData in metadict.keys():
           
           try:
               nodeOld=metanode.getElementsByTagName(metaData)
           except:
               nodeOld=None
               
           if nodeOld:
               metanode.removeChild(nodeOld[0]).unlink()
           else:
               # try also old writing rule - instead of _:
               try:
                   nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
               except:
                   nodeOld=None
                   
               if nodeOld:
                   metanode.removeChild(nodeOld[0]).unlink()
   
           metanodeneu=dom.createElement(metaData)
                   metanodetext=dom.createTextNode(metadict[metaData])
           #try:
               #metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
           #except:
               #metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
           metanodeneu.appendChild(metanodetext)
           metanode.appendChild(metanodeneu)
   
   
       
       
       
       if project:
           updateTextToolNode('project',project)
   
       if startpage:
           updateTextToolNode('startpage',startpage)
   
       if topbar:
           updateTextToolNode('toptemplate',topbar)
   
       if thumbtemplate:
           updateTextToolNode('thumbtemplate',thumbtemplate)
   
       if xslt:
           updateTextToolNode('xslt',xslt)
   
       
       if digiliburlprefix:
           updateTextToolNode('digiliburlprefix',digiliburlprefix)
       
           try:    
        return dom.toxml().encode('utf-8')
       except:
        return dom.toxml('utf-8')
   
       
       
   def readMetadata(url):
       """Methode zum Auslesen der Metadateninformation zu einer Resource
       Vorerst noch Typ bib"""
       
       metadict={}
       
       try:
           geturl=""
           for line in urlopen(url).readlines():
               geturl=geturl+line
           
           
       except:
           return (None,"Cannot open: "+url)
   
       try:
           dom=xml.dom.minidom.parseString(geturl)
       except:
           return (None,"Cannot parse: "+url+"<br>"+geturl)
   
       metanode=dom.getElementsByTagName('bib')
       metadict['bib_type']='Book'
       if len(metanode)==0:
           metanode=dom.getElementsByTagName('archimedes')
           metadict['bib_type']='Archimedes'
           
           
       if not len(metanode)==0:    
           metacontent=metanode[0].childNodes
       
           try:
               metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
           except:
               """nothing"""
           
           for node in metacontent:
           try:
               #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
               #metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
               metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
           
           except:
               """nothing"""
   
   
       return metadict,""
       
   
   class MapArea(SimpleItem):
       """simple class to hold coordinates"""
   
       meta_type = 'MapArea'
       # Create a SecurityInfo for this class.
       security = ClassSecurityInfo()
       security.setDefaultAccess("allow")
       # type constants
       TYPE_AREA = 'area'
       TYPE_ARROW = 'arrow'
       TYPE_TEXT = 'text'
       
       def __init__(self, id, coords, label=None, type=None, tip=None, volatile=True):
       """init"""
       self.coords = coords[0:4]
       if len(coords) > 4:
           self.angle = coords[4]
       else:
           self.angle = 0
       self.id = id
       self.label = label
       self.setType(type)
       self.tip = tip
       self.volatile = volatile
   
       def setCoords(self, coords):
       """sets the coords"""
       self.coords = coords
   
       def getCoordString(self):
       """returns coordinates as a string"""
       return string.join(self.coords, ',')
   
       def setCoordString(self, coordstring):
       """sets coordinates from a string"""
       coords = string.split(coordstring, ',')
       self.coords = [c.strip() for c in coords]
   
       def getFullId(self, prefix=None):
       """returns the id with prefixed parent id"""
       if prefix is None:
           if hasattr(self, 'aq_parent'):
           prefix = self.aq_parent.id
           else:
           prefix = "id"
       fid = prefix + "." + self.id
       return fid
   
       def getType(self):
       """returns the type"""
       return self.type
   
       def setType(self, type):
       """sets the type"""
       if type == MapArea.TYPE_ARROW:
           self.type = MapArea.TYPE_ARROW
       elif type == MapArea.TYPE_AREA:
           self.type = MapArea.TYPE_AREA
       elif type == MapArea.TYPE_TEXT:
           self.type = MapArea.TYPE_TEXT
       else:
           self.type = MapArea.TYPE_AREA
           
       def isTypeArea(self):
       """returns if the type is area"""
       return self.type == MapArea.TYPE_AREA
   
       def isTypeArrow(self):
       """returns if the type is arrow"""
       return self.type == MapArea.TYPE_ARROW
   
       def isTypeText(self):
       """returns if the type is text"""
       return self.type == MapArea.TYPE_TEXT
   
       def getAngle(self):
       """returns the angle"""
       return self.angle
   
       def setAngle(self, angle):
       """sets the angle"""
       self.angle = angle
   
       def getTip(self):
       """returns the popup text"""
       # patch old version
       if not hasattr(self, 'tip'):
           self.tip = self.text
   
       if self.tip is None:
           if hasattr(self, 'aq_parent'):
           parent = self.aq_parent
           if parent.contentType == 'text-popup':
               return parent.description
       return self.tip
   
       def setTip(self, text):
       """sets the text"""
       self.tiptext = text
   
       def getText(self):
       """returns the text fpr the area"""
       if hasattr(self, 'aq_parent'):
           parent = self.aq_parent
           text = parent.getMapText()
           if text is not None:
           return text.document_src()
       return ""
   
       def getLabel(self):
       """returns the link label"""
       if self.label is None:
           if hasattr(self, 'aq_parent'):
           return self.aq_parent.label or self.aq_parent.id
       return self.label
   
       def setLabel(self, label):
       """sets the label"""
       self.label = label
   
       def getLinkId(self):
       if hasattr(self, 'aq_parent'):
           return self.aq_parent.id
       return self.id
   
   # call this to initialize framework classes, which
   # does the right thing with the security assertions.
   Globals.InitializeClass(MapArea)
   
   
   class MapText(ZopePageTemplate):
       """class to hold text for map areas"""
   
       meta_type = 'ECHO_mapText'
       # Create a SecurityInfo for this class.
       security = ClassSecurityInfo()
       security.setDefaultAccess("allow")
       
       _default_content_fn = os.path.join(package_home(globals()),
                                          'html', 'ECHO_mapText_default.html')
   
       def __init__(self, id, text=None, content_type=None):
           self.id = str(id)
           self.ZBindings_edit(self._default_bindings)
           if text is None:
               text = open(self._default_content_fn).read()
           self.pt_edit(text, content_type)
   
   # Product registration and Add support
   manage_addMapTextForm = PageTemplateFile(
       'zpt/AddECHO_mapText', globals(), __name__='manage_addMapTextForm')
   
   def manage_addMapText(self, id, title=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Map Text with optional file content."
   
       id = str(id)
       if REQUEST is None:
           self._setObject(id, MapText(id, text))
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None)
           if headers is None or not file.filename:
               zpt = MapText(id, text)
           else:
               zpt = MapText(id, file, headers.get('content_type'))
   
           self._setObject(id, zpt)
           if title:
               ob = getattr(self, id)
               ob.pt_setTitle(title)
   
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
   # call this to initialize framework classes, which
   # does the right thing with the security assertions.
   Globals.InitializeClass(MapText)
Removed from v.1.19  
changed lines
  Added in v.1.52

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>