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

Diff for /ImageArchive/ImageArchive.py between versions 1.50 and 1.77

version 1.50, 2005/04/10 13:01:45 version 1.77, 2006/05/15 08:18:02
Line 1 Line 1
   genericServerPath="http://www.mpiwg-berlin.mpg.de/zogilib_images" #can be changed with main config
   
   
   
 from OFS.Folder import Folder  from OFS.Folder import Folder
   from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from Globals import Persistent,package_home  from Globals import Persistent,package_home
 from Acquisition import Implicit  from Acquisition import Implicit
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
   from xmlrpclib import ServerProxy
 import re  import re
 import os  import os
 import os.path  import os.path
Line 14  import tempfile Line 20  import tempfile
 import shutil  import shutil
 from types import *  from types import *
 import time  import time
   from threading import Thread
   import Queue
   import cgi
   import sys
   import zLOG
   
   
   from AccessControl import ClassSecurityInfo, getSecurityManager
   
   try:
       from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   except:
       print "ZSQL Extend Folder nicht importiert"
       print "Metadatendfolder funktioniert nicht!!!"
       class ZSQLExtendFolder:
           """leer"""
           manage_options=()
   
   
   
 try:  try:
     from Products.ECHO_content.ECHO_collection import ECHO_basis      from Products.ECHO_content.ECHO_collection import ECHO_basis
Line 25  except: Line 50  except:
         manage_options=()          manage_options=()
   
   
   tdir = "/mpiwg/temp/tmp/archivesImageServer/"
   #tdir="/tmp/archivesImageServer/"
   
   imageExtensions=['jpg','jpeg','tif','tiff','png']
   
 def splitPath(str):  def splitPath(str):
     str2=str.replace("\\","/")      str2=str.replace("\\","/")
Line 47  def getTextFromNode(nodename): Line 76  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
   class generateSet:
       """generateSetThread"""
   
           
       def __init__(self,filenames,filenamesIds,ImageViewerPath,ids,url,local=None,version="working"):
           """init generateSet"""
           self.filenames=filenames
           self.filenamesIds=filenamesIds
           self.ImageViewerPath=ImageViewerPath
           self.ids=ids
           self.local=local
           self.url=url
           self.version=version
           self.done=None
           
   
       def __call__(self):
           """call generate Set"""
   
           storeTempDir=tempfile.tempdir
           tempfile.tempdir=tdir
   
           tmpPath=tempfile.mktemp()
           tmpZip=tempfile.mktemp()+".gtz"
           tmpFn=os.path.split(tmpZip)[1]
   
           if not os.path.exists(tempfile.tempdir):
               os.mkdir(tempfile.tempdir) 
   
           if not os.path.exists(tmpPath):
                       os.mkdir(tmpPath) 
               
           self.response=""
   
           
           self.response="<h3>1. step: getting the images</h3>"
   
           for id in self.filenames:
   
                       if self.filenamesIds.has_key(id[0]):
                               filename=self.filenamesIds[id[0]][0]+"_"+id[0]
                       else:
                               filename=id[0]
   
                       self.response+=str("<p>Get File: %s<br>\n"%filename)
   
   
                       if self.local:
                               
                               if self.version=="working":
   
                                       sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
                               else:
                                       sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
                               targetPath=tmpPath+"/"+filename
                               try:
                                   shutil.copyfile(sourcePath,targetPath)
                               except:
                                   self.response+=(str("<p>Error in File: %s (possible missing)<br>\n"%filename))
                       else:
                               if self.version=="working":
                                       requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
                                       path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
   
                               else:
                                       requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
                                       path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
                                   
   
                               image=urllib.urlopen(path).read()
                       
                       
                               fh=file(tmpPath+"/"+filename,"w")
   
                       
                               fh.write(image)
                               fh.close()
   
                       #folgeseiten
   
                       if int(self.filenamesIds[id[0]][1])>1: 
                               #ids=self.show_thumbs()
                               
                               try:
                                   nr=self.ids.index(id[0])
                               except:
                                   self.response+=str("<p>Error in File: %s (possible missing)<br>\n"%id[0])
                   
   
                                   nr=0
   
                               numberOfPages=self.filenamesIds[id[0]][1]
                               for k in range(int(numberOfPages)-1):
                                       i=k+1
                                       if self.filenamesIds.has_key(id[0]):
                                               filename=self.filenamesIds[id[0]][0]+"_"+self.ids[nr+i]
                                       else:
                                               filename=id[0]
   
                                       self.response+=str("<p>Get File: %s<br>\n"%filename)
   
                                       if self.local:
                                               sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+self.ids[nr+i]
                                               targetPath=tmpPath+"/"+filename
                                               try:
                                                       shutil.copyfile(sourcePath,targetPath)
                                           
                                               except:
                                                   self.response+=str("<p>Error in File: %s (missing?)<br>\n"%filename)
                                                     
                                       else:
   
                                               requestString=self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
                                               path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
   
                                               image=urllib.urlopen(path).read()
                                       
   
                                               fh=file(tmpPath+"/"+filename,"w")
                                               fh.write(image)
                                               fh.close()
   
           self.response+="<h3>2. step: creating the downloadable file</h3>"
           self.response+="<p>Create gtar<br>"
           self.response+="<p>This can take a while....<br>\n"
   
           fh=os.popen2("gnutar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
           self.response+="<br>"
           for c in fh.read():
               self.response+=c
               if c==")":
                   self.response+="<br>\n"
                       
                               
   
           
           shutil.rmtree(tmpPath)
   
           self.response+="<p>finished<br>\n"
   
           len=os.stat(tmpZip)[6]
           downloadUrl=self.url+"/downloadSet"
           self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
           self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
                       <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
   
           self.done=True
       def getResult(self):
           """get result"""
           return self.response
   
       def isDone(self):
           if self.done:
               return True
           else:
               return False
           
 class metaData(SimpleItem):  class metaData(SimpleItem):
     """Klasse fuer metadaten"""      """Klasse fuer metadaten"""
     meta_type="metaData"      meta_type="metaData"
Line 86  class metaData(SimpleItem): Line 272  class metaData(SimpleItem):
         return ret+"</body></html>"          return ret+"</body></html>"
                                   
                   
   
       
 class ImageDigilib(Folder,Persistent,Implicit):  class ImageDigilib(Folder,Persistent,Implicit):
     """Anzeige object fuer digilib"""      """Anzeige object fuer digilib"""
     meta_type="ImageDigilib"      meta_type="ImageDigilib"
       security=ClassSecurityInfo()
     leiden_meta_fields=['image_id','date','country','place','people','description','photographer']      leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
Line 98  class ImageDigilib(Folder,Persistent,Imp Line 286  class ImageDigilib(Folder,Persistent,Imp
                   
         )          )
   
       def getAccessRight(self):
           """get the accessright, return is string "extern" or "intern" """
           return self.getRights(self.filename.split('.')[0])
            
       security.declarePublic('isAccessible')
       
       def isAccessible(self):
           """gives true if obejct is accessible taking the rights of the user into account"""
           
           #TODO: implement rights, currently  true if external and false if internal, and true if user has role authenticated
       
           username=self.REQUEST['AUTHENTICATED_USER']
           #print username
           #print self.acl_users.getUserNames()
           user=getSecurityManager().getUser()
   
           roles=user.getRoles()
   
           
           if self.getRightsQuery()=="":
               #query empty then always true
           return True
   
   
           if 'Authenticated' in roles:
               return True
           
           if self.getAccessRight()=="extern":
               return True
           else:
               return False
           
     def addMetaObject(self,id,RESPONSE=None):      def addMetaObject(self,id,RESPONSE=None):
         """Add an MetaObject"""          """Add an MetaObject"""
         objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)          objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
Line 127  class ImageDigilib(Folder,Persistent,Imp Line 347  class ImageDigilib(Folder,Persistent,Imp
         self.filename=filename          self.filename=filename
         self.meta=meta          self.meta=meta
   
       def getBasename(self):
           """returns base filename (sans extension)"""
           return os.path.splitext(self.filename)[0]
   
     def getMeta(self):      def getMeta(self):
         """ausgabe der metadaten"""          """ausgabe der metadaten"""
         return self.meta          return self.meta
Line 153  class ImageDigilib(Folder,Persistent,Imp Line 377  class ImageDigilib(Folder,Persistent,Imp
     def uploadImage(self,fileupload,path_name):      def uploadImage(self,fileupload,path_name):
         """upload an Image from an Requast"""          """upload an Image from an Requast"""
         #path_name=self.ImageStoragePath          #path_name=self.ImageStoragePath
         fn=splitPath(fileupload.filename)          fn = self.filename or splitPath(fileupload.filename)
         filename=path_name+"/"+fn          filename=path_name+"/"+fn
         filedata=fileupload.read()          filedata=fileupload.read()
         f=open(filename,"w")          f=open(filename,"w")
         f.write(filedata)          f.write(filedata)
         f.close()          f.close()
           self.filename = fn
         try:          try:
             os.chmod(filename,0664)              os.chmod(filename,0664)
         except:          except:
Line 180  class ImageDigilib(Folder,Persistent,Imp Line 405  class ImageDigilib(Folder,Persistent,Imp
           
     def download(self,fmt="&mo=rawfile,hires",suffix=None):      def download(self,fmt="&mo=rawfile,hires",suffix=None):
         """download"""          """download"""
         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt          
           requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
           path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
           
           
     if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):      if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):
         filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename          filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename
Line 204  class ImageDigilib(Folder,Persistent,Imp Line 432  class ImageDigilib(Folder,Persistent,Imp
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self)
         return pt()                  return pt()        
   
   
       security.declareProtected('View management screens','renameImageForm')
     def renameImageForm(self):      def renameImageForm(self):
         """form"""          """form"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)
         return pt()          return pt()
   
       security.declareProtected('View management screens','renameImage')
     def renameImage(self,newname,RESPONSE=None):      def renameImage(self,newname,RESPONSE=None):
         """umbenennen"""          """umbenennen"""
         #umbennen des files im folder          #umbennen des files im folder
Line 263  class ImageDigilib(Folder,Persistent,Imp Line 494  class ImageDigilib(Folder,Persistent,Imp
     def updateImage(self,file,rename=None,RESPONSE=None):      def updateImage(self,file,rename=None,RESPONSE=None):
         """lade neues Version des Bildes"""          """lade neues Version des Bildes"""
         #teste ob Dokumenten ordner schon vorhanden          #teste ob Dokumenten ordner schon vorhanden
         imagePath=os.path.join(self.ImageStoragePath,self.getId())              #imagePath=os.path.join(self.ImageStoragePath,self.getId())
               imagePath=os.path.join(self.ImageStoragePath,self.filename)
         path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")          path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")
                   
         if not os.path.exists(path):          if not os.path.exists(path):
Line 274  class ImageDigilib(Folder,Persistent,Imp Line 506  class ImageDigilib(Folder,Persistent,Imp
   
         #teste ob version schon existiert          #teste ob version schon existiert
   
         while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))):              while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.filename))):
             versionNumber+=1              versionNumber+=1
   
         #kopieren der bestehenden Version in den Versions ordner.          #kopieren der bestehenden Version in den Versions ordner.
         imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))              imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.filename))
           try:
           #zLOG.LOG("ImageArchive:updateImage", zLOG.INFO, "rename: %s -> %s"%(imagePath,imageNewPath))
         os.rename(imagePath,imageNewPath)          os.rename(imagePath,imageNewPath)
           except:
           zLOG.LOG("ImageArchive:updateImage", zLOG.ERROR, "rename: %s -> %s didn't work!"%(imagePath,imageNewPath))  
   
         #lesen des upload files und schreiben          #lesen des upload files und schreiben
         filedata=file.read()          filedata=file.read()
         f=open(imagePath,"w")              f=open(imagePath,"w") # if we wanted to have filename=id we should do it here!
         f.write(filedata)          f.write(filedata)
         f.close()          f.close()
         try:          try:
Line 308  class ImageDigilib(Folder,Persistent,Imp Line 544  class ImageDigilib(Folder,Persistent,Imp
   
         return "done"          return "done"
                   
       security.declarePublic('thumb')
     def thumb(self,url=None):      def thumb(self,url=None):
         """show thumb"""          """show thumb"""
         thumbname=os.path.splitext(self.filename)[0]+".jpg"          thumbname=os.path.splitext(self.filename)[0]+".jpg"
         ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):          requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
 ##             image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()          path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
 ##             f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")  
 ##             f.write(image)  
 ##             f.close()  
 ##             os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)  
                           
         #DEVEL:take nausikaa for server solution  
                   
         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"  
         #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname  
         self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path          self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
         if url:          if url:
             return "<img border=\"0\" src=\"%s\">"% path              return "<img border=\"0\" src=\"%s\">"% path
Line 329  class ImageDigilib(Folder,Persistent,Imp Line 559  class ImageDigilib(Folder,Persistent,Imp
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
             return pt()              return pt()
           
   
       def thumbMD(self,url=None):
           """show thumb mit Metadaten erwarten image in ImageCollectionMD
           """
           thumbname=os.path.splitext(self.filename)[0]+".jpg"
           
           requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
           path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
           
   
       
           self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
           if url:
               return "<img border=\"0\" src=\"%s\">"% path
           else:
               
               overview=self.ZopeFind(self.aq_parent,obj_ids=['thumb.html'])
               if overview:
                   return getattr(self,overview[0][0])()
               else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbMD.zpt')).__of__(self)
                   return pt()
   
   
       def image(self,dw=None,dh=None):
          """show image only with scaler"""
          str=[]
          if (not dw) and (not dh):
              str.append("mo=file")
          if dw:
              str.append("dw=%s"%dw)
   
          if dh:
              str.append("dw=%s"%dh)
          
          str.append("lv=2&fn=%s"%self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0])
          
          
          requestString="&".join(str)
          
          self.REQUEST.RESPONSE.redirect(getattr(self,'serverPath',genericServerPath)+"/scaledImage?"+requestString)
          
     def index_html(self):      def index_html(self):
         """show image"""          """show image with zogilib"""
         #DEVELOP: take first one for server          #DEVELOP: take first one for server
                   #path="http://127.0.0.1:8080/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
         path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]          path=getattr(self,'serverPath',genericServerPath)+"?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
         return self.REQUEST.RESPONSE.redirect(path)          return self.REQUEST.RESPONSE.redirect(path)
   
           
Line 346  def manage_AddImageDigilib(self,id,fileu Line 618  def manage_AddImageDigilib(self,id,fileu
     """Add ImageCollection"""      """Add ImageCollection"""
           
     #fileupload=self.REQUEST['fileupload']      #fileupload=self.REQUEST['fileupload']
     fn=splitPath(fileupload.filename)      #fn=splitPath(fileupload.filename)
       fn = id # filename is the same as id
     newObj=ImageDigilib(id,fn,meta)      newObj=ImageDigilib(id,fn,meta)
           
     self._setObject(id,newObj)      self._setObject(id,newObj)
Line 357  def manage_AddImageDigilib(self,id,fileu Line 630  def manage_AddImageDigilib(self,id,fileu
   
                                     
   
 class ImageCollection(Folder, Persistent, Implicit,ECHO_basis):  class ImageCollection(OrderedFolder, Persistent, Implicit,ECHO_basis):
       """Sammelordner fuer Bilder"""
     """Sammelordner für Bilder"""  
     meta_type="ImageCollection"      meta_type="ImageCollection"
   
         
       security=ClassSecurityInfo()
       
       #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn="
       #scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="
       
       zipThreads={}
       zipThreads2={}
           
     genericMetaDataType="leiden_meta"      genericMetaDataType="leiden_meta"
   
Line 371  class ImageCollection(Folder, Persistent Line 650  class ImageCollection(Folder, Persistent
           
     defaultMetaString="http://fm-web.mpiwg-berlin.mpg.de:8050/FMRes/FMPJS?-db=Wissenschaftlerportraits.fp5&-layID=69&-token=25&-max=1&-format=formvwcss.htm&-mode=browse&images::filename=%s&-find" ## TEST FUER IMAGEDATENBANK WP      defaultMetaString="http://fm-web.mpiwg-berlin.mpg.de:8050/FMRes/FMPJS?-db=Wissenschaftlerportraits.fp5&-layID=69&-token=25&-max=1&-format=formvwcss.htm&-mode=browse&images::filename=%s&-find" ## TEST FUER IMAGEDATENBANK WP
   
       imgcoll_main = PageTemplateFile('zpt/overview', globals())
       imgcoll_mainMD = PageTemplateFile('zpt/overviewMD', globals())
       imgcoll_thumb = PageTemplateFile('zpt/thumb', globals())
       imgcoll_thumbMD = PageTemplateFile('zpt/thumbMD', globals())    
   
       def getImageObject(self,name):
           """gibt objeckt name zurueck"""
           if hasattr(self,name):
               return getattr(self,name)
           
           name=os.path.splitext(name)[0]
           for extension in imageExtensions:
               nameExt=name+"."+extension
   
               if hasattr(self,nameExt):
                   return getattr(self,nameExt)
               
               nameExt=name+"_."+extension
               if hasattr(self,nameExt):
                   return getattr(self,nameExt)
           
           return getattr(self,"defaultImg")
           
       def getServerPath(self):
           """get Server path"""
           return getattr(self,'serverPath',genericServerPath)
       
       def getScalerPath(self):
           """get ScalerPath"""
           path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="
       
       def getImageViewerPath(self):
           """get ImageViewerPath"""
           return self.ImageViewerPath
   
       def getImageStoragePath(self):
           """get ImageStoragePath"""
           return self.ImageStoragePath
       
       def refreshTxt(self):
           """txt fuer refresh"""
           tn=self.REQUEST.SESSION['threadName']
           return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/createSet",tn)
         
           def createSet(self,RESPONSE=None,local=None,version="working",repeat=None):
     def createSet(self,RESPONSE=None,local=None,version="working"):  
         """download aller gewaehlten files"""          """download aller gewaehlten files"""
             storeTempDir=tempfile.tempdir  
         tempfile.tempdir="/tmp/archivesImageServer"  
           
         tmpPath=tempfile.mktemp()  
           
   
         tmpZip=tempfile.mktemp()+".zip"  
         tmpFn=os.path.split(tmpZip)[1]  
   
               threadName=repeat
   
         if not os.path.exists(tempfile.tempdir):  
             os.mkdir(tempfile.tempdir)   
   
         if not os.path.exists(tmpPath):  
             os.mkdir(tmpPath)   
           
           
         if RESPONSE:  
             RESPONSE.setHeader("Content-Type","text/html")  
             RESPONSE.write("<h1>I am creating  the download archive</h1>")  
             RESPONSE.write("<h3>1. step: getting the images</h3>")  
   
         if not self.REQUEST.SESSION.has_key('filenames'):  
             RESPONSE.write("<h2>ERROR</h2>")  
             RESPONSE.write("<p>I forgot, the selected files. Please reselect.\n")  
             return 0  
                   
         for id in self.REQUEST.SESSION['filenames']:              if not threadName or threadName=="":
                   threadStart=generateSet(self.REQUEST.SESSION['filenames'],self.REQUEST.SESSION['filenamesIds'],self.ImageViewerPath,self.show_thumbs(),self.absolute_url(),local=local,version=version)
                   thread=Thread(target=threadStart)
   
             if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):                  thread.start()
                 filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+id[0]  
             else:  
                 filename=id[0]  
   
             if RESPONSE:  
                 RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))  
   
             if local:                  self.zipThreads[thread.getName()[0:]]=threadStart
                 if version=="working":                  self.zipThreads2[thread.getName()[0:]]=thread
                     sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"                  self.REQUEST.SESSION['threadName']=thread.getName()[0:]
                 else:                  wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
                     sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]                  if wait_template:
                 targetPath=tmpPath+"/"+filename                      return wait_template[0][1]()
                 try:                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
                     shutil.copyfile(sourcePath,targetPath)                  return pt()
                 except:                  #xmltrans.run()
                     if RESPONSE:  
                         RESPONSE.write(str("<p>Error in File: %s (possible missing)<br>\n"%filename))  
                     else:  
                         """nothing"""  
             else:  
                 if version=="working":  
                     path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"  
                 else:                  else:
                     path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"                  self.REQUEST.SESSION['threadName']=threadName
                 image=urllib.urlopen(path).read()  
               
               
                 fh=file(tmpPath+"/"+filename,"w")  
   
                   if (self.zipThreads[threadName].getResult()==None):
                           
                 fh.write(image)                      wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                 fh.close()                      if wait_template:
                           return wait_template[0][1]()
   
             #folgeseiten                      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
             if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:                       return pt()
                 ids=self.show_thumbs()  
                     try:  
                  nr=ids.index(id[0])  
                 except:  
                  if RESPONSE:  
                         RESPONSE.write(str("<p>Error in File: %s (possible missing)<br>\n"%id[0]))  
                  else:  
                         """nothing"""  
   
                      nr=0  
   
                 numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]  
                 for k in range(int(numberOfPages)-1):  
                     i=k+1  
                     if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):  
                         filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+ids[nr+i]  
                     else:                      else:
                         filename=id[0]                      if self.zipThreads[threadName].isDone():
                           self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                     if RESPONSE:                          self.zipThreads2[threadName].join()
                         RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))                          del(self.zipThreads2[threadName])
                           del(self.zipThreads[threadName])
                           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
                           return pt()
   
                     if local:  
                         sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+ids[nr+1]  
                         targetPath=tmpPath+"/"+filename  
                         try:  
                             shutil.copyfile(sourcePath,targetPath)  
                         except:  
                             if RESPONSE:  
                                 RESPONSE.write(str("<p>Error in File: %s (missing?)<br>\n"%filename))  
                             else:                              else:
                                 """nothing"""                          self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                     else:                          self.REQUEST.SESSION['threadName']=threadName
                         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"                          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
                           return pt()
   
                         image=urllib.urlopen(path).read()  
                                           
   
                         fh=file(tmpPath+"/"+filename,"w")  
                         fh.write(image)  
                         fh.close()  
   
         if RESPONSE:  
             RESPONSE.write("<h3>2. step: creating the downloadable file</h3>")  
             RESPONSE.write("<p>Create Zip<br>")  
             RESPONSE.write("<p>This can take a while....<br>\n")  
         if RESPONSE:  
             fh=os.popen2("zip -u %s %s/*"%(tmpZip,tmpPath),1)[1]  
             RESPONSE.write("<br>")  
             for c in fh.read():  
                 RESPONSE.write(c)  
   
                 if c==")":  
                     RESPONSE.write("<br>\n")  
                           
       def checkThreads(self):
           """teste running threads"""
           ret="""<html>
           <head>
           <meta http-equiv="REFRESH" content="5;url=%s/checkThreads"
           <body><h2>Threads of %s</h2>"""%(self.absolute_url(),self.getId())
                                   
           for threadName in self.zipThreads.keys():
               if self.zipThreads2[threadName].isAlive():
                   ret+="<p>%s --> alive</p>"%threadName
         else:          else:
             os.popen("zip -u %s %s/*"%(tmpZip,tmpPath))                  ret+="<p>%s --> dead</p>"%threadName
           return ret+"</body></html>"
           
         shutil.rmtree(tmpPath)  
   
         if RESPONSE:  
             RESPONSE.write("<p>finished<br>\n")  
   
         if RESPONSE:  
             len=os.stat(tmpZip)[6]  
             downloadUrl=self.absolute_url()+"/downloadSet"  
             RESPONSE.write("""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))  
             RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>  
             <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))  
             RESPONSE.close()  
                   
     def downloadSet(self,fn):      def downloadSet(self,fn):
         """download prepared set"""          """download prepared set"""
         filename="/tmp/archivesImageServer/"+fn              filename=os.path.join(tdir,fn)
   
                   
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.zip")              self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.tgz")
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")          self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
         len=os.stat(filename)[6]          len=os.stat(filename)[6]
         self.REQUEST.RESPONSE.setHeader("Content-Length",len)          self.REQUEST.RESPONSE.setHeader("Content-Length",len)
Line 552  class ImageCollection(Folder, Persistent Line 799  class ImageCollection(Folder, Persistent
   
   
           
     def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString):      def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,serverPath=genericServerPath):
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.ImageStoragePath=ImageStoragePath          self.ImageStoragePath=ImageStoragePath
         self.ImageViewerPath=ImageViewerPath          self.ImageViewerPath=ImageViewerPath
         self.defaultMetaString=defaultMetaString          self.defaultMetaString=defaultMetaString
           self.serverPath=serverPath
           self.defaultrows = 6
           self.defaultcols = 2
   
     optTMP= Folder.manage_options      optTMP= Folder.manage_options
   
Line 577  class ImageCollection(Folder, Persistent Line 827  class ImageCollection(Folder, Persistent
         """import metadata, if strict ist not None then only metadata will be rebuild where metadata is empty"""          """import metadata, if strict ist not None then only metadata will be rebuild where metadata is empty"""
                   
         for image in self.ZopeFind(self,obj_metatypes=["ImageDigilib"]):          for image in self.ZopeFind(self,obj_metatypes=["ImageDigilib"]):
             print image[1].getId()             
             image[1].manageMetaData(strict)              image[1].manageMetaData(strict)
         return "ok"          return "ok"
                   
Line 699  class ImageCollection(Folder, Persistent Line 949  class ImageCollection(Folder, Persistent
     try:      try:
         dom=xml.dom.minidom.parseString(xmldoc)          dom=xml.dom.minidom.parseString(xmldoc)
         except:          except:
         return xmldoc                  return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc)
   
     images=dom.getElementsByTagName('image')      images=dom.getElementsByTagName('image')
   
         rc=[]          rc=[]
Line 709  class ImageCollection(Folder, Persistent Line 960  class ImageCollection(Folder, Persistent
                                   
                   
                                   
                   
         idnr=image.getElementsByTagName('idnr')[0]          idnr=image.getElementsByTagName('idnr')[0]
         id=getText(idnr.childNodes)          id=getText(idnr.childNodes)
                   try:
         numberOfPages=image.getElementsByTagName('numberOfPages')[0]          numberOfPages=image.getElementsByTagName('numberOfPages')[0]
                   except:
                       numberOfPages=None
                       
                   if numberOfPages:
         nopT=getText(numberOfPages.childNodes)          nopT=getText(numberOfPages.childNodes)
         try:          try:
             nop=int(nopT)              nop=int(nopT)
         except:          except:
             nop=0              nop=0
                   else:
                       nop=0
                               
                 texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste                  texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
                 for text in texts:                  for text in texts:
                     if not text=="":                      if not text=="":
                           text=self.getImageByName(text,onlyName="yes")
             try:              try:
                 rc.append((str(text),id,nop))                  rc.append((str(text),id,nop))
                 fnIds[str(text)]=(id,nop)                  fnIds[str(text)]=(id,nop)
Line 732  class ImageCollection(Folder, Persistent Line 993  class ImageCollection(Folder, Persistent
         self.REQUEST.SESSION['filenames']=rc          self.REQUEST.SESSION['filenames']=rc
     self.REQUEST.SESSION['filenamesIds']=fnIds      self.REQUEST.SESSION['filenamesIds']=fnIds
           
           overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
               
           if overview:
                   return overview[0][1]()
           else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
                   return pt()        
           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
         return pt()                  return pt()        
   
Line 752  class ImageCollection(Folder, Persistent Line 1021  class ImageCollection(Folder, Persistent
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
         return pt()          return pt()
           
     def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):      def addImage2(self,fileupload,fileName=None,meta=None,use_default=None,RESPONSE=None):
         """Add"""          """Add"""
   
         #print "FU",fileupload          #print "FU",fileupload
Line 764  class ImageCollection(Folder, Persistent Line 1033  class ImageCollection(Folder, Persistent
                 meta=None                  meta=None
         else:          else:
             meta=None              meta=None
         fn=splitPath(fileupload.filename)          
           fn=fileName or splitPath(fileupload.filename)
           
         manage_AddImageDigilib(self,fn,fileupload,meta=meta)          manage_AddImageDigilib(self,fn,fileupload,meta=meta)
           
           if RESPONSE:
         return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)          return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
         #return  self.REQUEST['URL1']+'/'+fileupload.filename          #return  self.REQUEST['URL1']+'/'+fileupload.filename
   
Line 802  class ImageCollection(Folder, Persistent Line 1074  class ImageCollection(Folder, Persistent
   
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
     def importStructure(self,path):      ## def importStructure(self,path):
         """import"""  ##         """import"""
         splitted=os.path.split(path)  ##         splitted=os.path.split(path)
         if os.path.isDir(path):  ##         if os.path.isDir(path) and (len(splitted[1])>0) and (splitted[1][0]=="."):
             manage_AddImageCollection(self,splitted[1],splitted[1],path,self.ImageViewerPath,self.defaultMetaString,RESPONSE=None)  ##             manage_AddImageCollection(self,splitted[1],splitted[1],path,self.ImageViewerPath,self.defaultMetaString,RESPONSE=None)
                           
             obj=getattr(self,splitted[1])  ##             obj=getattr(self,splitted[1])
             obj.ImportFiles()  ##             obj.ImportFiles()
   
     def ImportStructure(self,RESPONSE=None):      def ImportStructure(self,RESPONSE=None):
         """Import the existing files of a folder"""          """Import the existing files of a folder"""
Line 821  class ImageCollection(Folder, Persistent Line 1093  class ImageCollection(Folder, Persistent
         for file in files:          for file in files:
   
             if os.path.isdir(os.path.join(self.ImageStoragePath,file)):              if os.path.isdir(os.path.join(self.ImageStoragePath,file)):
                 manage_AddImageCollection(self,file,file,os.path.join(self.ImageStoragePath,file),self.ImageViewerPath,self.defaultMetaString)                  imageStoragePath=os.path.join(self.ImageStoragePath,file)
                   imageViewerPath=os.path.join(self.ImageViewerPath,file)
                   manage_AddImageCollection(self,file,file,imageStoragePath,imageViewerPath,self.defaultMetaString)
                           
                 obj=getattr(self,file)                  obj=getattr(self,file)
                 obj.ImportStructure()                  obj.ImportStructure()
Line 896  class ImageCollection(Folder, Persistent Line 1170  class ImageCollection(Folder, Persistent
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
         return pt()          return pt()
   
     def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):      def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,serverPath,RESPONSE=None):
         """Change"""          """Change"""
         self.title=title          self.title=title
         self.ImageStoragePath=ImageStoragePath          self.ImageStoragePath=ImageStoragePath
         self.ImageViewerPath=ImageViewerPath          self.ImageViewerPath=ImageViewerPath
         self.defaultMetaString=defaultMetaString          self.defaultMetaString=defaultMetaString
           self.serverPath=serverPath
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
Line 923  class ImageCollection(Folder, Persistent Line 1198  class ImageCollection(Folder, Persistent
         ids.sort()          ids.sort()
         return ids          return ids
   
     def firstSets(self,selected=None):      def firstSets(self,selected=None,text='first set'):
         ids=self.show_thumbs()          ids=self.show_thumbs()
         if ids:          if ids:
             if selected:              if selected:
                 return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"                  return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">"+text+"</a>"
             else:              else:
                 return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"                  return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">"+text+"</a>"
   
     def lastSets(self,selected=None):      def lastSets(self,selected=None,text='last set'):
         ids=self.show_thumbs()          ids=self.show_thumbs()
         if ids:          if ids:
             colRows=self.getColTimesRow()              colRows=self.getColTimesRow()
Line 945  class ImageCollection(Folder, Persistent Line 1220  class ImageCollection(Folder, Persistent
                 nr=0                  nr=0
   
             if selected:              if selected:
                 return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"                  return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
             else:              else:
                 return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"                  return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
   
                   
                                   
     def nextSets(self,selected=None):      def nextSets(self,selected=None,text='next set'):
         """show nextimage"""          """show nextimage"""
         ids=self.show_thumbs()          ids=self.show_thumbs()
         colRows=self.getColTimesRow()          colRows=self.getColTimesRow()
           pagesize = colRows[0] * colRows[1]
         if ids:          if ids:
             if colRows[1]:              if colRows[1]:
   
                 if self.REQUEST.SESSION.has_key("filename"):                  if self.REQUEST.SESSION.has_key("filename"):
                     filename=self.REQUEST.SESSION["filename"]                      filename=self.REQUEST.SESSION["filename"]
                     try:                      try:
                         nr=ids.index(filename)+colRows[0]*colRows[1]                          nr=ids.index(filename)+pagesize
                         if nr>=len(ids):                          if nr>=len(ids):
                             nr=len(ids)-1                              return ""
                     except:                      except:
                         nr=0                          nr=pagesize
                 else:                  else:
                     nr=0                      nr = pagesize
   
                 if nr==len(ids)-1:                  if nr>=len(ids)-1:
                     return ""                      return ""
                 else:                  else:
                     if selected:                      if selected:
                         return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"                          return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
                     else:                      else:
                         return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"                          return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
   
     def prevSets(self,selected=None):      def prevSets(self,selected=None,text='previous sets'):
                   
         """show nextimage"""          """show nextimage"""
         #return self.getId()          #return self.getId()
Line 1004  class ImageCollection(Folder, Persistent Line 1279  class ImageCollection(Folder, Persistent
                     return ""                      return ""
                 else:                  else:
                     if selected:                      if selected:
                         return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"                          return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
                     else:                      else:
                         return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"                          return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
             else:              else:
                 return ""                  return ""
   
   
     def showFolders(self):      def showFolders(self):
         """show subfolders"""          """show subfolders"""
         ret=""          ret=""
Line 1018  class ImageCollection(Folder, Persistent Line 1295  class ImageCollection(Folder, Persistent
             ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")              ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")
             ret+="<br>"              ret+="<br>"
                           
         iCs=self.ZopeFind(self,obj_metatypes="ImageCollection")          iCs=self.ZopeFind(self,obj_metatypes=["ImageCollection"])
         if not iCs:          if not iCs:
             return ret              return ret
         else:          else:
Line 1028  class ImageCollection(Folder, Persistent Line 1305  class ImageCollection(Folder, Persistent
                 ret+=link%(iC[1].absolute_url(),iC[0])                  ret+=link%(iC[1].absolute_url(),iC[0])
             ret+="<br>"              ret+="<br>"
             return ret              return ret
   
   
       def getSetSelector(self, selected=None):
           """returns the HTML select element for the sets"""
           actualNr=0
           ids=self.show_thumbs()
           colRows=self.getColTimesRow()
           pagesize = colRows[0]*colRows[1]
           numpages = int(len(ids)/pagesize)
           if not ((len(ids) % pagesize)==0):
               numpages+=1
       
           ret=""
           if numpages>1:
               if selected:
                   ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
               else:
                   ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
                   
               for i in range(numpages):
                   try:
                     nr=ids.index(self.REQUEST.SESSION['filename'])
                   except:
                     nr=0
                   k=i * pagesize
                   if (k <= nr) and (nr < i*(pagesize+1)):
                      actualNr=i
                      ret+="""<option value="%s" selected>%i</option>"""%(ids[k], i + 1)
                   else:
                      ret+="""<option value="%s">%i</option>"""%(ids[k], i + 1)
                      
               ret+="</select>"
               
           return ret
   
       def isAllSets(self, showall=None):
           """returns if there are any sets"""
           ids=self.show_thumbs()
           colRows=self.getColTimesRow(showall=showall)
           pagesize = colRows[0]*colRows[1]
           return (len(ids) <= pagesize)
           
   
       def allSets(self, texton='show all', textoff='show groups'):
           """returns HTML to toggle 'show all'"""
           if self.isAllSets(showall='No'):
               return ""
           showall=self.REQUEST.SESSION.get('showall','no')
           if showall=='no':
               ret='<a href="'+self.REQUEST['URL1']+'?showall=yes" target="_top">'+texton+'</a>'
           else:
               ret='<a href="'+self.REQUEST['URL1']+'?showall=no" target="_top">'+textoff+'</a>'
           return ret
   
   
     def showRuler(self,selected=None):      def showRuler(self,selected=None):
         """show ruler"""          """show ruler"""
         showall =self.REQUEST.SESSION.get('showall','no')          showall =self.REQUEST.SESSION.get('showall','no')
Line 1110  class ImageCollection(Folder, Persistent Line 1442  class ImageCollection(Folder, Persistent
   
         return ret          return ret
           
       
     def show_thumbs_selected_rows(self,numberOfColumns):      def show_thumbs_selected_rows(self,numberOfColumns):
         """Ausgabe anzahl"""          """Ausgabe anzahl"""
         ids=self.show_selected_thumbs()          ids=self.show_selected_thumbs()
Line 1146  class ImageCollection(Folder, Persistent Line 1479  class ImageCollection(Folder, Persistent
   
         RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")          RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
                   
       def setDefaultColTimesRow(self, cols, rows):
           """sets default columns and rows"""
           self.defaultcols = cols
           self.defaultrows = rows
   
     def getColTimesRow(self,showall='No'):      def getColTimesRow(self,showall='No'):
         """coltimesrow"""          """coltimesrow"""
                   
         REQUEST=self.REQUEST          REQUEST=self.REQUEST
         """matrix"""          """matrix"""
         if REQUEST.cookies.has_key("ImageViewerRows"):          if REQUEST.cookies.has_key("ImageViewerRows"):
               
             try:              try:
                 rows=int(REQUEST.cookies["ImageViewerRows"])                  rows=int(REQUEST.cookies["ImageViewerRows"])
             except:              except:
                 rows=6                  rows=getattr(self,'defaultrows',6)
         else:          else:
             rows=6              rows=getattr(self,'defaultrows',6)
                           
         if REQUEST.cookies.has_key("ImageViewerCols"):          if REQUEST.cookies.has_key("ImageViewerCols"):
             #print "COLS",REQUEST.cookies["ImageViewerCols"]              #print "COLS",REQUEST.cookies["ImageViewerCols"]
             cols=int(REQUEST.cookies["ImageViewerCols"])              cols=int(REQUEST.cookies["ImageViewerCols"])
         else:          else:
             cols=2              cols=getattr(self,'defaultcols',3)
   
   
         idsnumber=len(self.show_thumbs())          idsnumber=len(self.show_thumbs())
         if rows:          if rows:
             if cols*rows >idsnumber:              if cols*rows >idsnumber:
                 rows=int(idsnumber/cols)+1                  rows=int(idsnumber/cols)+1
   
         #print cols,rows          if showall is None:
               showall=self.REQUEST.SESSION.get('showall', 'No')
         if showall=='yes':          if showall=='yes':
             rows=int(idsnumber/cols)+1              rows=int(idsnumber/cols)+1
                           
         return (cols,rows)          return (cols,rows)
                                   
                   
     def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):      def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None,showall="No"):
         """Ausgabe anzahl"""          """Ausgabe anzahl"""
   
         idsAll=self.show_thumbs()          idsAll=self.show_thumbs()
         if len(idsAll)==0: #keine Einträge          if len(idsAll)==0: #keine Eintraege
             return 0              return 0
         if self.REQUEST.SESSION.has_key("filename"):          if self.REQUEST.SESSION.has_key("filename") and not (showall=="yes"):
             filename=self.REQUEST.SESSION["filename"]              filename=self.REQUEST.SESSION["filename"]
             filename=self.getImageByName(filename,onlyName="yes")              filename=self.getImageByName(filename,onlyName="yes")
                                   
Line 1259  class ImageCollection(Folder, Persistent Line 1598  class ImageCollection(Folder, Persistent
         """navigation"""          """navigation"""
         #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']          #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)
         return pt()  
           return pt().data
   
     def navig_html(self):      def navig_html(self):
         """navigation"""          """navigation"""
Line 1281  class ImageCollection(Folder, Persistent Line 1621  class ImageCollection(Folder, Persistent
   
     def getImageByName(self,filename,onlyName=None):      def getImageByName(self,filename,onlyName=None):
         """get filename"""          """get filename"""
                   print repr(filename)
         fn=getattr(self,filename,None)          #FIXME: umlaute in filename
           fn=getattr(self,repr(filename),None)
         if not fn:          if not fn:
             filenameM=filename.split(".")[0]              filenameM=filename.split(".")[0]
             founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])              founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])
Line 1297  class ImageCollection(Folder, Persistent Line 1638  class ImageCollection(Folder, Persistent
             return filename              return filename
         else:          else:
             return fn              return fn
     def index_html(self):          
           
       security.declareProtected('View','index_html')
       def index_html(self,fn=None,generic='No'):
         """main template collection"""          """main template collection"""
   
           if fn:
               ret=[]
   
               if type(fn) is ListType:
                   """experimentell mehr als ein filename"""
                   for filename in fn:
                       if not (filename == ""):
                           ret.append((filename,'',1))
               else:
                   ret.append((fn,'',1))
   
               self.REQUEST.SESSION['filenames']=ret
                   #self.REQUEST.SESSION['filenamesIds']=fnIds
             
               overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
               
   
               if overview and (generic =='No'):
                   return overview[0][1]()
               else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
                   return pt()        
   
         if self.REQUEST.has_key('filename'):          if self.REQUEST.has_key('filename'):
             filen=self.REQUEST['filename']              filen=self.REQUEST['filename']
         else:          else:
Line 1313  class ImageCollection(Folder, Persistent Line 1681  class ImageCollection(Folder, Persistent
             self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')              self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
                           
             
           overview=self.ZopeFind(self,obj_ids=['overview.html'])
           if overview and (generic == 'No'):
               return overview[0][1]()
           elif hasattr(self,'templates'):
               pt=self.templates.imgcoll_main.__of__(self)
               return pt()
           else:
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
         return pt()          return pt()
           
       def navigation(self):
           """generate navigation bar"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_fragment')).__of__(self)
           return pt()    
       
 def manage_AddImageCollectionForm(self):  def manage_AddImageCollectionForm(self):
     """Nothing yet"""      """Nothing yet"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
Line 1330  def manage_AddImageCollection(self,id,ti Line 1711  def manage_AddImageCollection(self,id,ti
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
     
   class ImageCollectionMD(ImageCollection,ZSQLExtendFolder):
       """Imageviewer and Metadata"""
       meta_type="ImageCollection MD"
       #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn="
       scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="
       rightsQueryDefault="SELECT accessibility from vision_main where id_image=(SELECT id from vision_images where filename ~ '%s*' )"
       rightsQueryFieldDefault="accessibility"
       
       manage_options=ImageCollection.manage_options+(
           {'label':'ZSQLExtend','action':'changeZSQLExtendForm'},
           {'label':'Change Rights Query','action':'changeRightsQueryForm'},
          )
   
       try:        
           changeZSQLExtendForm=ZSQLExtendFolder.changeZSQLExtendForm
       except:
           pass
       
     
       def addImage(self):
           """Add an Image"""
                   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImageMD.zpt')).__of__(self)
           return pt()
       
       def addImage2(self,_fileupload,_fileName=None,_meta=None,_use_default=None,RESPONSE=None,**argv):
           """Add"""
   
           filenameKey="filename"
           #print "FU",fileupload
   
           if _use_default:
               try:
                   meta=self.meta_default(_fileupload.filename)
               except:
                   meta=None
           else:
               meta=None
           
           fn=_fileName or splitPath(_fileupload.filename)
           
           manage_AddImageDigilib(self,fn,_fileupload,meta=meta)
           
           args[key]=_filename
           
           self.ZSQLAdd(args=argv)
           
           if RESPONSE:
               return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
           #return  self.REQUEST['URL1']+'/'+fileupload.filename
   
       def navig_html(self):
           """navigation"""
           #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
          
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigationMD.zpt')).__of__(self)
           return pt()
           
       def navig_selected_html(self):
           """navigation"""
           #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selectedMD.zpt')).__of__(self)
   
           return pt()
   
       def decode(self,str):
           """decoder"""
           if not str:
               return ""
           if type(str) is StringType:
               try:            
                   return str.decode('utf-8')
               except:
                   return str.decode('latin-1')
           else:
               
               return str
   
       def standardSearch(self):
           """standard search page"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','standardSearchPage.zpt')).__of__(self)
           return pt()        
           
       def searchResultXML(self):
           """xmlformat"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultXML.zpt')).__of__(self)
           return pt()        
   
       def searchDB(self,REQUEST=None,RESPONSE=None,xml=None):
           """search"""
           #context.ZSQLFind(_table='vision_main')
           urlTmp=REQUEST['URL1']
           
           url=urlTmp+'/searchResultXML?-table=vision_main&'+REQUEST['QUERY_STRING']
           
           if xml is None:
               RESPONSE.redirect('xmlinput?url='+urllib.quote(url))
           else:
               RESPONSE.redirect(url)
               
       def index_html(self,fn=None,selection=None,generic='No',REQUEST=None,RESPONSE=None):
           """main template collection"""
   
           
           mode=self.REQUEST.get('mode','view')
           if fn:
               ret=[]
   
               if type(fn) is ListType:
                   """experimentell mehr als ein filename"""
                   for filename in fn:
                       if not (filename == ""):
                           ret.append((filename,'',1))
               else:
                   ret.append((fn,'',1))
   
               self.REQUEST.SESSION['filenames']=ret
                   #self.REQUEST.SESSION['filenamesIds']=fnIds
             
               overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
               
   
               if overview and (generic =='No'):
                   return overview[0][1]()
               else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                   return pt()        
   
           
           # filename given, then only display this file
           if self.REQUEST.has_key('filename'):
   
               filen=self.REQUEST['filename']
           else:
               filen=""
   
   
           self.REQUEST.SESSION['filename']=filen[0:]
           
           if not self.REQUEST.SESSION['filename']=="":
               url=getattr(self.getImageByName(self.REQUEST.SESSION['filename']),'absolute_url')()
               if mode=="view":
                   self.REQUEST.RESPONSE.redirect(url)
               elif mode=="download":
                   self.REQUEST.RESPONSE.redirect(url+"/download")
                   
           if self.REQUEST.has_key('showall'):
   
               self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
           else:
               self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
               
               
           if selection:
               #selection i.e. selection already stored at self.REQUEST.SESSION['filenames']
               overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
               
   
               if overview and (generic =='No'):#
                   print "selected"
                   print repr(overview[0][1])
                   return overview[0][1]()
               else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                   return pt()   
               
               
           #no filename then show overview
   
           overview=self.ZopeFind(self,obj_ids=['overviewMD.html'])
           if overview and (generic == 'No'):
   
             
               return overview[0][1]()
           elif hasattr(self,'templates'):
             
               pt=self.templates.imgcoll_mainMD.__of__(self)
               return pt()
           else:
             
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overviewMD.zpt')).__of__(self)
               return pt()
           
       def nextImage(self,request,selected=None,returnFn=None):
           """show nextimage"""
       
           if not selected and self.REQUEST.has_key('fn'):
               imagename=self.REQUEST['fn'].split('/')[-1]
               nr=self.getObjectPosition(imagename)
       
               objects=self.objectIds()
               if len(objects)==nr+1:
                   return ""
               else:
                   fn="/".join(self.REQUEST['fn'].split('/')[0:-1])+"/"+objects[nr+1]
                   return "<a href=\""+self.REQUEST['URL0']+"?fn="+fn+"\" target=\"_top\">next image</a>"                
   
       def prevImage(self,request,selected=None,returnFn=None):
           """show nextimage"""
       
           if not selected and self.REQUEST.has_key('fn'):
               imagename=self.REQUEST['fn'].split('/')[-1]
               nr=self.getObjectPosition(imagename)
       
               objects=self.objectIds()
               if nr==0:
                   return ""
               else:
                   fn="/".join(self.REQUEST['fn'].split('/')[0:-1])+"/"+objects[nr-1]
                   return "<a href=\""+self.REQUEST['URL0']+"?fn="+fn+"\" target=\"_top\">prev image</a>"                
       
           
       def changeRightsQueryForm(self):
           """change Rights Query"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeRightsQueryForm.zpt')).__of__(self)
           return pt()
     
       def changeRightsQuery(self,rightsQuery,rightsQueryField,RESPONSE=None):
           """change Rightsquery"""
           
           self.rightsQuery=rightsQuery
           self.rightsQueryField=rightsQueryField
           
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
       
           
       def getRightsQuery(self):
           """get Query"""
           return getattr(self,'rightsQuery',self.rightsQueryDefault)
       
       def getRightsQueryField(self):
           """get Query Fiueld"""
           return getattr(self,'rightsQueryField',self.rightsQueryFieldDefault)
       
       
       
       def setGenericSearchStringForm(self):
           """form setze generischen search string fuer MD"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','setGenericSearchStringForm.zpt')).__of__(self)
           return pt()
   
       def setGenericSearchString(self,searchString):
           """setze generischen search string"""
           self.searchString=searchString
   
       def thumblistMD(self):
           """main template collection"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbListMD.zpt')).__of__(self)
           return pt()
       
       def getRights(self,id):
           """get the rights from a database"""
           #print self.rightsQuery%id
           results=self.ZSQLSimpleSearch(self.getRightsQuery()%id)
           if results:
               result = getattr(results[0],self.getRightsQueryField())
           else:
               result = ''
           return result
        
       def xmlinput(self,url):
           """Anzeige von ausgewaehlten thumbs"""
           #return url
           
           url=urllib.unquote(url)
           xmldoc=urllib.urlopen(url).read()
           #return xmldoc
           try:
                   dom=xml.dom.minidom.parseString(xmldoc)
           except:
                   return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc)
   
           images=dom.getElementsByTagName('image')
   
           rc=[]
           fnIds={}
           for image in images:
                   imagename=image.getElementsByTagName('imagename')[0]
                 
                   
                   
                   
                   idnr=image.getElementsByTagName('idnr')[0]
                   id=getText(idnr.childNodes)
                   try:
                       numberOfPages=image.getElementsByTagName('numberOfPages')[0]
                   except:
                       numberOfPages=None
                       
                   if numberOfPages:
                       nopT=getText(numberOfPages.childNodes)
                       try:
                               nop=int(nopT)
                       except:
                               nop=0
                   else:
                       nop=0
                               
                   texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
                   for text in texts:
                       if not text=="":
                           text=self.getImageByName(text,onlyName="yes")
                           try:
                                   rc.append((str(text),id,nop))
                                   fnIds[str(text)]=(id,nop)
                           except:
                                   rc.append((repr(text),id,nop))
                                   fnIds[repr(text)]=(id,nop)
                   
   
           rc.sort()
           self.REQUEST.SESSION['filenames']=rc
           self.REQUEST.SESSION['filenamesIds']=fnIds
           
           overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
               
           if overview:
                   return overview[0][1]()
           else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                   return pt()        
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
           return pt()        
   
       def selection(self):
           """show only selected"""
           if self.REQUEST.has_key('filename'):
               filen=self.REQUEST['filename']
           else:
               filen=""
           self.REQUEST.SESSION['filename']=filen
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
           return pt()  
           
       def thumblistSelectedMD(self):
           """main template collection"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselectedMD.zpt')).__of__(self)
           return pt()
       
   def manage_AddImageCollectionMDForm(self):
       """Nothing yet"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionFormMD.zpt')).__of__(self)
       return pt()
       
   def manage_AddImageCollectionMD(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
       """Add ImageCollection"""
       newObj=ImageCollectionMD(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
       self._setObject(id,newObj)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
   
           
 class ImageCollectionIFrame(ImageCollection):  class ImageCollectionIFrame(ImageCollection):
     """Class fuer Collection set als IFrame"""      """Class fuer Collection set als IFrame"""
   
Line 1386  def manage_AddImageCollectionIFrame(self Line 2126  def manage_AddImageCollectionIFrame(self
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   class ImageZogiLib(ImageDigilib):
       """Anzeige Object fuer Bilder ausserhalb von collections
       ImageViewerPath und ImageStoragePath und wenn vorhanden Pfad zur Collection
       werden zusaetzlich abgespeichert
       """
       #TODO: scaler path notwendig?
       meta_type="ImageZogiLib"
   
       manage_options=ImageDigilib.manage_options+(
            {'label':'Main Config','action':'changeImageZogiLibForm'},        
           )
   
       def __init__(self,id,fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath=None,REQUEST=None):
           ImageDigilib.__init__(self,id,fn)
           self.ImageViewerPath=ImageViewerPath
           self.ImageStoragePath=ImageStoragePath
           self.ImageCollectionPath=ImageCollectionPath
           self.scalerPath=scalerPath
   
       def changeImageZogiLibForm(self):
           """change zogilib Form"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeImageZogiLib.zpt')).__of__(self)
           return pt()        
   
   
       def changeImageZogilib(fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath,REQUEST=None):
           """Change it"""
           self.ImageViewerPath=ImageViewerPath
           self.ImageStoragePath=ImageStoragePath
           self.ImageCollectionPath=ImageColectionPath
           self.scalerPath=scalerPath
       
   def manage_AddImageZogiLib(self,id=None,ImageViewerPath=None,ImageStoragePath=None,fileUpload=None,ImageCollectionPath=None,scalerPath=None,libPath=None,caption=None,RESPONSE=None):
       """hinzufuegen eineis zogilibImage"""
   
       if libPath:
           splitted=libPath.split("?")
           urlSplit=splitted[0].split("/")
           params=cgi.parse_qs(splitted[1])
           #is LibPath a digilib path?
           if urlSplit[-1]=="Scaler":
               if type(params['fn']) is ListType:
                   fnParam=params['fn'][0]
               else:
                   fnParam=params['fn']
               fileNameSplit=os.path.split(fnParam)
               ImageViewerPath=fileNameSplit[0]
               id=fileNameSplit[1]
               scalerPath=splitted[0]+"?fn="
           else: #assume if not the path is a path to an ImageCollection
               if type(params['filename']) is ListType:
                   id=params['filename'][0]
               else:
                   id=params['filename']
   
               server=ServerProxy(splitted[0])
               ImageCollectionPath=libPath
               ImageViewerPath=server.getImageViewerPath()
               ImageStoragePath=server.getImageStoragePath()
               scalerPath=server.getScalerPath()
           
   
   
       if fileUpload:
           fn=splitPath(fileUpload.filename)
       else:
           fn=id
           
       newObj=ImageZogiLib(id,fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath)
       
       self._setObject(id,newObj)
       getattr(self,id).caption=caption[0:]
       if fileUpload:
           getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
                    
   def manage_AddImageZogiLibForm(self):
       """to be done"""
       
Removed from v.1.50  
changed lines
  Added in v.1.77

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