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

Diff for /ECHO_content/ECHO_collection.py between versions 1.184 and 1.189

version 1.184, 2004/10/27 15:58:15 version 1.189, 2004/11/24 15:17:04
Line 29  from Products.PageTemplates.PageTemplate Line 29  from Products.PageTemplates.PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
 from ECHO_helpers import displayTypes, getText,readFieldFromXML  
 import urllib  import urllib
 import smtplib  import smtplib
 import time  import time
Line 55  import urllib Line 55  import urllib
 import xml.dom.minidom  import xml.dom.minidom
 from ECHO_graphicalOverview import javaHandler,javaScriptMain  from ECHO_graphicalOverview import javaHandler,javaScriptMain
 import ECHO_helpers  import ECHO_helpers
   from ECHO_helpers import *
 def donatus(txt2):  from ECHO_language import *
     import xmlrpclib  
   
     server = xmlrpclib.ServerProxy("http://archimedes.fas.harvard.edu/cgi-bin/donatus-rpc")  
   
     txt=txt2.encode('utf-8')  
     bin=xmlrpclib.Binary(txt)  
   
       
   
     ret=server.donatus.analyze(bin)  
   
                   
     return ret['morphData'].data  
   
   
 def donatusVariant2Lemma(morphData):  
     """creates hash variant -> morphdata"""  
     ret={}  
     dom=xml.dom.minidom.parseString(morphData)  
     lemmas=dom.getElementsByTagName('lemma')  
     for lemma in lemmas:  
         variants=lemma.getElementsByTagName('variant')  
         for variant in variants:  
             atr=variant.getAttribute('form')  
             if ret.has_key(atr):  
                 ret[atr].append=lemma.getAttribute('form')  
             else:  
                 ret[atr]=[lemma.getAttribute('form')]  
   
     return ret  
   
 #regexp for extracting elements from xml  #regexp for extracting elements from xml
 patternTXT=r"<\s*txt.*?>(.*?)</txt>"  patternTXT=r"<\s*txt.*?>(.*?)</txt>"
 regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)  regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)
Line 95  patternPage=r"<\s*page.*?>(.*?)</page>" Line 66  patternPage=r"<\s*page.*?>(.*?)</page>"
 regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)  regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)
   
                   
 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  
             #print 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 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('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)  
             pt.content_type="text/html"  
             return pt()  
       
 def toList(field):  
     """Einzelfeld in Liste umwandeln"""  
     if type(field)==StringType:  
         return [field]  
     else:  
         return field  
       
   
   
 def getTextFromNode(nodename):  
     nodelist=nodename.childNodes  
     rc = ""  
     for node in nodelist:  
         if node.nodeType == node.TEXT_NODE:  
            rc = rc + node.data  
     return rc  
   
 def sendFile(self, filename, type):  
     """sends an object or a local file (in the product) as response"""  
     paths = filename.split('/')  
     object = self  
     # look for an object called filename  
     for path in paths:  
         if hasattr(object, path):  
         object = getattr(object, path)  
     else:  
         object = None  
         break  
     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):  
     self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")  
     self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)  
     self.isIE = string.find(self.ua, 'MSIE') > -1  
     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]  
     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):  
         #print dom,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 ECHO_helpers.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)  
   
       
   
     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 ECHO_helpers.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))  
             except:  
                 """nothing"""  
   
   
     return metadict,""  
       
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
   
Line 506  def setECHO_collectionInformation(self,t Line 98  def setECHO_collectionInformation(self,t
   
         self.coords=coords[0:]          self.coords=coords[0:]
                           
 class ECHO_copyright(Folder):  class ECHO_copyright(Folder,ECHO_basis):
     """Copyright informationen"""      """Copyright informationen"""
     meta_type="ECHO_copyright"      meta_type="ECHO_copyright"
           
Line 562  def manage_addECHO_copyright(self, id,ti Line 154  def manage_addECHO_copyright(self, id,ti
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
 class ECHO_layoutTemplate(ZopePageTemplate):  class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
     """Create a layout Template for different purposes"""      """Create a layout Template for different purposes"""
   
     meta_type="ECHO_layoutTemplate"      meta_type="ECHO_layoutTemplate"
Line 630  def manage_addECHO_layoutTemplate(self, Line 222  def manage_addECHO_layoutTemplate(self,
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_fullText(ZopePageTemplate):  class ECHO_fullText(ZopePageTemplate,ECHO_basis):
     """echo fulltext in xml"""      """echo fulltext in xml"""
   
     meta_type="ECHO_fullText"      meta_type="ECHO_fullText"
Line 796  def manage_addECHO_fullText(self, id, ti Line 388  def manage_addECHO_fullText(self, id, ti
         REQUEST.RESPONSE.redirect(u+'/manage_main')          REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_resource(Folder,Persistent):  class ECHO_resource(Folder,Persistent,ECHO_basis):
     """ECHO Ressource"""      """ECHO Ressource"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_resource'      meta_type='ECHO_resource'
Line 1012  class ECHO_resource(Folder,Persistent): Line 604  class ECHO_resource(Folder,Persistent):
         """create ImageUrl"""          """create ImageUrl"""
   
                   
         resourcepath=readFieldFromXML(self.metalink,'resource','archive-path').replace('/mpiwg/online','')          resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')
                   
         digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')          digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
         images=readFieldFromXML(self.metalink,'texttool','image')          images=readFieldFromXML(self.metalink,'texttool','image')
Line 1021  class ECHO_resource(Folder,Persistent): Line 613  class ECHO_resource(Folder,Persistent):
         if (not resourcepath) or (not digiliburlprefix) or (not images):          if (not resourcepath) or (not digiliburlprefix) or (not images):
             zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())              zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
             return None              return None
                   resourcepath=resourcepath.replace('/mpiwg/online','')
         if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"          if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
   
         if (not images) or (not resourcepath): return None          if (not images) or (not resourcepath): return None
Line 1165  class ECHO_resource(Folder,Persistent): Line 757  class ECHO_resource(Folder,Persistent):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
           
     def getTitle(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"""  
     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 content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'resource')          return ECHO_basis.content_html(self,'resource')
           
     def getViewClassification(self):      def getViewClassification(self):
         if hasattr(self,'viewClassification'):          if hasattr(self,'viewClassification'):
Line 1848  def manage_addECHO_resource(self,id,titl Line 1426  def manage_addECHO_resource(self,id,titl
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
     
   
 class ECHO_externalLink(Folder):  class ECHO_externalLink(Folder,ECHO_basis):
     """Link zu einer externen Ressource"""      """Link zu einer externen Ressource"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_externalLink'      meta_type='ECHO_externalLink'
   
     def getTitle(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"""  
     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 content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'externalLink')          return ECHO_basis.content_html(self,'externalLink')
           
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
   
Line 1955  class ECHO_link(ECHO_externalLink): Line 1518  class ECHO_link(ECHO_externalLink):
     def content_html(self):      def content_html(self):
         """template fuer link"""          """template fuer link"""
         if hasattr(self,"link_template"):          if hasattr(self,"link_template"):
             return content_html(self,'link')              return ECHO_basis.content_html(self,'link')
         else:          else:
             return content_html(self,'collection')              return ECHO_basis.content_html(self,'collection')
           
 def manage_addECHO_linkForm(self):  def manage_addECHO_linkForm(self):
         """Form for external Links"""          """Form for external Links"""
Line 1976  def manage_addECHO_link(self,id,title,la Line 1539  def manage_addECHO_link(self,id,title,la
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit, Cacheable):  class ECHO_collection(Folder, Persistent, Implicit, Cacheable,ECHO_basis):
     """ECHO Collection"""      """ECHO Collection"""
   
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
Line 2310  class ECHO_collection(Folder, Persistent Line 1873  class ECHO_collection(Folder, Persistent
         else:          else:
             return ""              return ""
   
     def getTitle(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"""  
     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 createRessourcesFromXMLForm(self):      def createRessourcesFromXMLForm(self):
         """form"""          """form"""
Line 2720  class ECHO_collection(Folder, Persistent Line 2268  class ECHO_collection(Folder, Persistent
     self.ZCacheable_set(ret)      self.ZCacheable_set(ret)
         return ret          return ret
   
     def content_html(self):      def content_html(self,**argv):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'collection')      #print "NN",argv
           return ECHO_basis.content_html(self,'collection')
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 2918  class ECHO_group(ECHO_collection): Line 2467  class ECHO_group(ECHO_collection):
   
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'group')          return ECHO_basis.content_html(self,'group')
           
   
   
Line 3109  class ECHO_root(Folder,Persistent,Implic Line 2658  class ECHO_root(Folder,Persistent,Implic
     #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"      #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
     ###END CDLI add      ###END CDLI add
   
   
       def checkResource(self,id):
           """checks if a resource is in the tree, gives back none or list of resources"""
           if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
                   return self._v_checkResource[id]
   
           else:
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
   
               if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
               if resources:
                   self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
               else:
                   self._v_checkResource[id]=None
               
               return self._v_checkResource[id]
           
     def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):      def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
         """sendform"""          """sendform"""
         toaddrs=["dwinter@mpiwg-berlin.mpg.de"]          toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
Line 3607  class ECHO_root(Folder,Persistent,Implic Line 3173  class ECHO_root(Folder,Persistent,Implic
                           
                 if self.checkRef(ref):                  if self.checkRef(ref):
             if pn:              if pn:
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)                  link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&p="+pn)
             else:              else:
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)                  link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref)
   
   
             newxml=dom.toxml('utf-8')              newxml=dom.toxml('utf-8')
Line 3692  class ECHO_root(Folder,Persistent,Implic Line 3258  class ECHO_root(Folder,Persistent,Implic
                   
     def getPartners(self):      def getPartners(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
                           if hasattr(self,'partners'):            
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]          return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
         else:
           return []
       
     def getInstitutions(self):      def getInstitutions(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
Line 3888  def manage_addECHO_rootForm(self): Line 3455  def manage_addECHO_rootForm(self):
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)          pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
         return pt()          return pt()
   
 class ECHO_copyrightType(Folder):  class ECHO_copyrightType(Folder,ECHO_basis):
     """copyright typ"""      """copyright typ"""
   
     meta_type="ECHO_copyrightType"      meta_type="ECHO_copyrightType"
Line 3937  def manage_addECHO_copyrightType(self,id Line 3504  def manage_addECHO_copyrightType(self,id
     
   
     
 class ECHO_partner(Image,Persistent):  class ECHO_partner(Image,Persistent,ECHO_basis):
     """ECHO Partner"""      """ECHO Partner"""
   
     meta_type="ECHO_partner"      meta_type="ECHO_partner"
Line 4021  def manage_addECHO_partner(self, id, url Line 3588  def manage_addECHO_partner(self, id, url
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)          REQUEST.RESPONSE.redirect('%s/manage_main' % url)
     return id      return id
   
 class ECHO_linkList(ZopePageTemplate):  class ECHO_linkList(ZopePageTemplate,ECHO_basis):
     """LinkList Objekt"""      """LinkList Objekt"""
     meta_type="ECHO_linkList"      meta_type="ECHO_linkList"
   
Line 4033  class ECHO_linkList(ZopePageTemplate): Line 3600  class ECHO_linkList(ZopePageTemplate):
   
     def content_html(self):      def content_html(self):
     """content_html"""      """content_html"""
     return content_html(self,'pageTemplate')      return ECHO_basis.content_html(self,'pageTemplate')
   
     def changeECHO_linkListWeightForm(self):      def changeECHO_linkListWeightForm(self):
         """change"""          """change"""
Line 4117  def manage_addECHO_linkList(self, id, la Line 3684  def manage_addECHO_linkList(self, id, la
     return ''      return ''
           
   
 class ECHO_support(Folder):  class ECHO_support(Folder,ECHO_basis):
     """gefšrdert durch"""      """gefoerdert durch"""
     meta_type="ECHO_support"      meta_type="ECHO_support"
           
           
Line 4171  def manage_addECHO_support(self, id,inst Line 3738  def manage_addECHO_support(self, id,inst
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
   
 class ECHO_institution(Image,Persistent):  class ECHO_institution(Image,Persistent,ECHO_basis):
     """ECHO Institution"""      """ECHO Institution"""
   
     meta_type="ECHO_institution"      meta_type="ECHO_institution"
Line 4250  def manage_addECHO_institution(self, id, Line 3817  def manage_addECHO_institution(self, id,
         except: url=REQUEST['URL1']          except: url=REQUEST['URL1']
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)          REQUEST.RESPONSE.redirect('%s/manage_main' % url)
     return id      return id
   
Removed from v.1.184  
changed lines
  Added in v.1.189

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