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

Diff for /ImageArchive/ImageArchive.py between versions 1.42 and 1.63

version 1.42, 2004/12/23 14:08:05 version 1.63, 2005/08/09 16:48:29
Line 4  from Globals import Persistent,package_h Line 4  from Globals import Persistent,package_h
 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 13  import operator Line 14  import operator
 import tempfile  import tempfile
 import shutil  import shutil
 from types import *  from types import *
   import time
   from threading import Thread
   import Queue
   import cgi
   from AccessControl import ClassSecurityInfo
   try:
       from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   except:
       print "ZSQL Extend Folder nicht importiert"
       print "Metadatendfolder funktioniert nicht!!!"
       class ZSQLExtendFolder:
       """leer"""    
 try:  try:
     from Products.ECHO_content.ECHO_collection import ECHO_basis      from Products.ECHO_content.ECHO_collection import ECHO_basis
 except:  except:
     print "ECHO Elements not imported"      print "ECHO Elements not imported"
     class ECHO_basis:      class ECHO_basis:
         """leer"""          """leer"""
   
         manage_options=()          manage_options=()
   
   
   tdir = "/mpiwg/temp/tmp/archivesImageServer/"
   #tdir="/tmp/archivesImageServer/"
   
 def splitPath(str):  def splitPath(str):
     str2=str.replace("\\","/")      str2=str.replace("\\","/")
Line 38  def getText(nodelist): Line 52  def getText(nodelist):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
   def getTextFromNode(nodename):
       nodelist=nodename.childNodes
       rc = ""
       for node in nodelist:
           if node.nodeType == node.TEXT_NODE:
              rc = rc + node.data
       return rc
   
   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":
                       path=self.scalerPath+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
                   else:
                       path=self.scalerPath+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
                   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()
                               nr=self.ids.index(id[0])
                       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:
                           path=self.scalerPath+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
   
                           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):
       """Klasse fuer metadaten"""
       meta_type="metaData"
       
       def __init__(self,xmlurl,container=None):
           """__init__"""
           return self.update(xmlurl,container)
   
   
       def update(self,xmlurl,container=None):
           """update"""
   
           try:
               xmlfh=urllib.urlopen(xmlurl)
               dom=xml.dom.minidom.parse(xmlfh)
           except:
               return None
   
           md=dom.getElementsByTagName(container)
           mlist=[]
           if md:
               for node in md[0].childNodes:
                   if node.nodeType==dom.ELEMENT_NODE:
                       name=node.tagName
                       content=getTextFromNode(node)
                       setattr(self,name,content)
                       mlist.append(name)
               self.mlist=mlist[0:]
           else:
               self.mlist=[]
           
       def index_html(self):
           """index"""
           ret="<html><body>"
           for tag in self.mlist:
               ret+="<p>%s=%s</p>"%(tag,getattr(self,tag))
           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 84  class ImageDigilib(Folder,Persistent,Imp Line 295  class ImageDigilib(Folder,Persistent,Imp
         """ausgabe der metadaten"""          """ausgabe der metadaten"""
         return self.meta          return self.meta
           
       def manageMetaData(self,strict=None):
           """create or updateMetadata"""
           
           md=self.ZopeFind(self,obj_metatypes=["metaData"])
           
           if not md:
               self._setObject("metaData",metaData(self.meta,"ROW"))
   
           else:
               if not strict:
                   md[0][1].update(self.meta,"ROW")
               else:
                   print "strict"
                   if len(md[0][1].mlist)==0:
                       print " +++",self.getId()
                       md[0][1].update(self.meta,"ROW")
                   else:
                       print " ---",self.getId()
                       
     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
Line 114  class ImageDigilib(Folder,Persistent,Imp Line 344  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          path=self.scalerPath+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
           
     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 126  class ImageDigilib(Folder,Persistent,Imp Line 356  class ImageDigilib(Folder,Persistent,Imp
                   
     self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)      self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
     self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")      self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
     image=urllib.urlopen(path).read()          #print path
     self.REQUEST.RESPONSE.write(image)      imagefh=urllib.urlopen(path,'rb')
           
       self.REQUEST.RESPONSE.write(imagefh.read())
     self.REQUEST.RESPONSE.close()      self.REQUEST.RESPONSE.close()
         #return self.REQUEST.RESPONSE.redirect(path)          #return self.REQUEST.RESPONSE.redirect(path)
   
Line 135  class ImageDigilib(Folder,Persistent,Imp Line 367  class ImageDigilib(Folder,Persistent,Imp
         """form"""          """form"""
         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):
           """form"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)
           return pt()
       
       security.declareProtected('View management screens','renameImage')
       def renameImage(self,newname,RESPONSE=None):
           """umbenennen"""
           #umbennen des files im folder
           oldname=self.getId()
           self.aq_parent.manage_renameObjects(ids=[oldname],new_ids=[newname])
           self.title=newname[0:]
               self.filename=newname[0:]   
               #umbennen des files auf dem server
           oldpath=os.path.join(self.ImageStoragePath,oldname)
           newpath=os.path.join(self.ImageStoragePath,newname)
               os.rename(oldpath,newpath)
           
           #umbenennen des versionsfolders
           oldfolder=os.path.join(self.ImageStoragePath,"."+oldname+".dir")
               newfolder=os.path.join(self.ImageStoragePath,"."+newname+".dir")
           if os.path.exists(oldfolder):
                   os.rename(oldfolder,newfolder)
               else:
                   os.mkdir(newfolder)
                   
           #schreibe info uber umbennenung
   
               renameName=os.path.join(newfolder,"renamed")
               if os.path.exists(renameName):
                   fh=file(renameName,'a')
               else:
                   fh=file(renameName,'w')
   
               tm=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
               try:
                   user=self.REQUEST['AUTHENTICATED_USER']
               except:
                   user="unknown"
   
               str="""%s %s %s %s\n"""%(tm,user,oldname,newname)
               fh.write(str)
               fh.close()
               
               #scale thumb
       
           self.scaleThumbs()
           
           #scale standard
   
           self.scaleWorkingVersions()
   
   
     def updateImage(self,file,RESPONSE):              if RESPONSE:
               RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
       
   
       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())
         path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")          path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")
         print "path",path          
         if not os.path.exists(path):          if not os.path.exists(path):
             os.mkdir(path,0775)              os.mkdir(path,0775)
             os.chmod(path,0775)              os.chmod(path,0775)
Line 174  class ImageDigilib(Folder,Persistent,Imp Line 463  class ImageDigilib(Folder,Persistent,Imp
   
         self.scaleWorkingVersions()          self.scaleWorkingVersions()
   
           if rename:
           self.renameImage(file.filename)
       
       
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect(self.absolute_url())              RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
       
           
         return "done"          return "done"
                   
     def thumb(self):      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):  
 ##             image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()  
 ##             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=self.scalerPath+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
                   
         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:
               return "<img border=\"0\" src=\"%s\">"% path
           else:
         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"
       
           path=self.scalerPath+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
       
           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 index_html(self):      def index_html(self):
         """show image"""          """show image"""
         #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="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
         return self.REQUEST.RESPONSE.redirect(path)          return self.REQUEST.RESPONSE.redirect(path)
   
Line 230  class ImageCollection(Folder, Persistent Line 541  class ImageCollection(Folder, Persistent
     """Sammelordner für Bilder"""      """Sammelordner für Bilder"""
     meta_type="ImageCollection"      meta_type="ImageCollection"
   
       #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 239  class ImageCollection(Folder, Persistent Line 554  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
   
       def getScalerPath(self):
           """get ScalerPath"""
           return self.scalerPath
       
       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]  
   
   
         if not os.path.exists(tempfile.tempdir):  
             os.mkdir(tempfile.tempdir)   
   
         if not os.path.exists(tmpPath):  
             os.mkdir(tmpPath)   
                   
               threadName=repeat
                   
         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")  
   
               
                 fh.write(image)  
                 fh.close()  
   
             #folgeseiten                  if (self.zipThreads[threadName].getResult()==None):
             if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:   
                 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                      wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                       if wait_template:
                       return wait_template[0][1]()
   
                 numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]                      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
                 for k in range(int(numberOfPages)-1):                      return pt()
                     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:  
                                 """nothing"""  
                     else:                      else:
                         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"                          self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                           self.REQUEST.SESSION['threadName']=threadName
                         image=urllib.urlopen(path).read()                          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
                           return pt()
                                           
   
                         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 432  class ImageCollection(Folder, Persistent Line 688  class ImageCollection(Folder, Persistent
     manage_options = optTMP+(      manage_options = optTMP+(
         {'label':'Main Config','action':'ImageCollection_config'},          {'label':'Main Config','action':'ImageCollection_config'},
         {'label':'Import','action':'ImportFiles'},          {'label':'Import','action':'ImportFiles'},
         {'label':'Recalculate Metadata','action':'recalculateMeta'},          {'label':'Recalculate MetadataLink','action':'recalculateMetaLink'},
         {'label':'Import Metadata','action':'importMetaForm'},          {'label':'Import Metadata File','action':'importMetaFileForm'},
           {'label':'Import Metadata','action':'importMetaData'},
         {'label':'Rescale thumbs','action':'scaleThumbs'},          {'label':'Rescale thumbs','action':'scaleThumbs'},
     {'label':'Rescale working version','action':'scaleWorkingVersions'},      {'label':'Rescale working version','action':'scaleWorkingVersions'},
         )          )
   
           
                   
     def importMetaForm(self):      def importMetaData(self,strict=None):
           """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"]):
               print image[1].getId()
               image[1].manageMetaData(strict)
           return "ok"
           
   
       def importMetaFileForm(self):
         """import metadata"""          """import metadata"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self)
         return pt()          return pt()
   
     def importMeta(self,fileupload,tag):      def importMetaFile(self,fileupload,tag):
         """import"""          """import"""
         filedata=fileupload.read()          filedata=fileupload.read()
         dom=xml.dom.minidom.parseString(filedata)          dom=xml.dom.minidom.parseString(filedata)
Line 532  class ImageCollection(Folder, Persistent Line 798  class ImageCollection(Folder, Persistent
                   
     def meta_default(self,filename):      def meta_default(self,filename):
         """url der metadaten"""          """url der metadaten"""
         return self.defaultMetaString % filename          return self.defaultMetaString % urllib.quote(filename)
                                             
     def getThumbAttribute(self,id,attr):      def getThumbAttribute(self,id,attr):
         if hasattr(self,id):          if hasattr(self,id):
Line 593  class ImageCollection(Folder, Persistent Line 859  class ImageCollection(Folder, Persistent
         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()        
   
     def recalculateMeta(self):      def recalculateMetaLink(self):
         """recalculate the metadata"""          """recalculate the metadata"""
                   
         for entryid in self.__dict__:          for entryid in self.__dict__:
Line 660  class ImageCollection(Folder, Persistent Line 926  class ImageCollection(Folder, Persistent
   
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
       ## def importStructure(self,path):
   ##         """import"""
   ##         splitted=os.path.split(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)
               
   ##             obj=getattr(self,splitted[1])
   ##             obj.ImportFiles()
   
       def ImportStructure(self,RESPONSE=None):
           """Import the existing files of a folder"""
           files=os.listdir(self.ImageStoragePath)
           ret=""
           #print self.__dict__
   
   
           for file in files:
               
               if os.path.isdir(os.path.join(self.ImageStoragePath,file)):
                   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.ImportStructure()
               else:
                   if not file[0]==".":
                       if self.__dict__.has_key(file):
   
                           ret=ret+"<br>"+file+" already exists!"
                       else:
                           ret=ret+"<br>"+file+" created!"
                           newObj=ImageDigilib(file,file)
                           #print newObj,file
                           #print newObj
                           try:
                               self._setObject(file,newObj)
                           except:
                               """nothing yet"""
           #print ret
           #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
           #print self.ImageStoragePath
   
           #scale thumb
       
           #self.scaleThumbs()
   
       #scale standard
   
       #self.scaleWorkingVersions()
       
       if RESPONSE:
           RESPONSE.redirect('manage_main')
       
     def ImportFiles(self,RESPONSE=None):      def ImportFiles(self,RESPONSE=None):
         """Import the existing files of a folder"""          """Import the existing files of a folder"""
         files=os.listdir(self.ImageStoragePath)          files=os.listdir(self.ImageStoragePath)
Line 714  class ImageCollection(Folder, Persistent Line 1034  class ImageCollection(Folder, Persistent
   
     def show_selected_thumbs(self):      def show_selected_thumbs(self):
         #ids=[]          #ids=[]
                   try:
         return self.REQUEST.SESSION['filenames']          return self.REQUEST.SESSION['filenames']
       except:
        return None
     def show_thumbs(self):      def show_thumbs(self):
         ids=[]          ids=[]
         for entry in self.__dict__:          for entry in self.__dict__:
Line 814  class ImageCollection(Folder, Persistent Line 1135  class ImageCollection(Folder, Persistent
                         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\">previous sets</a>"
             else:              else:
                 return ""                  return ""
       def showFolders(self):
           """show subfolders"""
           ret=""
           link=""" <a target="_top" href="%s">%s</a><br>"""
   
           if self.aq_parent.meta_type=="ImageCollection":
               ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")
               ret+="<br>"
               
           iCs=self.ZopeFind(self,obj_metatypes=["ImageCollection"])
           if not iCs:
               return ret
           else:
   
               link=""" <a target="_top" href="%s">%s</a><br>"""
               for iC in iCs:
                   ret+=link%(iC[1].absolute_url(),iC[0])
               ret+="<br>"
               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 823  class ImageCollection(Folder, Persistent Line 1162  class ImageCollection(Folder, Persistent
             return "<b>No entries</b>"              return "<b>No entries</b>"
                   
         if showall=='no':          if showall=='no':
           actualNr=0
             ids=self.show_thumbs()              ids=self.show_thumbs()
             colRows=self.getColTimesRow()              colRows=self.getColTimesRow()
             num=int(len(ids)/(colRows[0]*colRows[1]))              num=int(len(ids)/(colRows[0]*colRows[1]))
Line 830  class ImageCollection(Folder, Persistent Line 1170  class ImageCollection(Folder, Persistent
                 num+=1                  num+=1
             a=colRows[0]*colRows[1]              a=colRows[0]*colRows[1]
             #print num,num+1              #print num,num+1
           
             if num>1:              if num>1:
   
                 ret="<b>Show thumbnail group no:</b></br>"                  ret=""
                   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(num):                  for i in range(num):
                     if (operator.mod(i,10)==0) and i>0:              try:
                         ret +="<br/>" #alle 10 linebreak einfuegen                nr=ids.index(self.REQUEST.SESSION['filename'])
               except:
                 nr=0
                     k=i*a                      k=i*a
               if (k <= nr) and (nr < i*(a+1)):
                  actualNr=i
                  ret+="""<option value="%s" selected>%i</option>"""%(ids[k],i)
               else:
                      ret+="""<option value="%s">%i</option>"""%(ids[k],i)
           ret+="</select>"    
           anf="<b>Show thumbnail group no:</b></br>"
           
           
           try:
             if selected:                
                           href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr-1)*a]
                     else:
                           href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr-1)*a)]
           
             anf+="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"prev")
           except:
             pass
           ret=anf+ret
           
           try:
             
                     if selected:                                      if selected:                
                         href=self.REQUEST['URL1']+"/selection?filename="+ids[k]                          href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr+1)*a]
                     else:                      else:
                         href=self.REQUEST['URL1']+"?filename="+ids[int(k)]                          href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr+1)*a)]
           
             end="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"next")
           except:
             end=""
           ret=ret+end
   
                     ret+="""<a href="%s" target="_top">%i</a>&nbsp;&nbsp;"""%(href,i)  
                   #for i in range(num):
                   #    
                   #        ret +="<br/>" #alle 10 linebreak einfuegen
                   #    k=i*a
                   #    if selected:                
                   #        href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
                   #    else:
                   #        href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
               #
                   #    ret+="""<a href="%s" target="_top">%i</a>&nbsp;&nbsp;"""%(href,i)
   
             else:              else:
                 ret=""                  ret=""
Line 855  class ImageCollection(Folder, Persistent Line 1239  class ImageCollection(Folder, Persistent
     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()
   
           if not ids:
           return None
         self.REQUEST.SESSION['ids']=ids          self.REQUEST.SESSION['ids']=ids
         number=int(len(ids)/numberOfColumns)+1          number=int(len(ids)/numberOfColumns)+1
         self.REQUEST.SESSION['number']=range(number)          self.REQUEST.SESSION['number']=range(number)
Line 917  class ImageCollection(Folder, Persistent Line 1304  class ImageCollection(Folder, Persistent
         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 Einträge
             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")
                                   
             try:              try:
                 startId=filename                  startId=filename
Line 1018  class ImageCollection(Folder, Persistent Line 1405  class ImageCollection(Folder, Persistent
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
         return pt()            return pt()  
                   
     def index_html(self):      def getImageByName(self,filename,onlyName=None):
           """get filename"""
           
           fn=getattr(self,filename,None)
           if not fn:
               filenameM=filename.split(".")[0]
               founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])
               for found in founds:
                   foundM=found[0].split(".")[0]
                   if filenameM.lower()==foundM.lower():
                       if onlyName:
                           return found[0]
                       else:
                           return found[1]
           if onlyName:
               return filename
           else:
               return fn
       def index_html(self,fn=None):
         """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
   
               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 1034  class ImageCollection(Folder, Persistent Line 1457  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:
               return overview[0][1]()
           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()
           
Line 1051  def manage_AddImageCollection(self,id,ti Line 1478  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="
       manage_options=ImageCollection.manage_options+(
           {'label':'ZSQLExtend','action':'changeZSQLExtendForm'},
          )
   
       try:    
         changeZSQLExtendForm=ZSQLExtendFolder.changeZSQLExtendForm
       except:
         pass
   
       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 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 1107  def manage_AddImageCollectionIFrame(self Line 1580  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
       """
   
       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.42  
changed lines
  Added in v.1.63

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