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

Diff for /ImageArchive/ImageArchive.py between versions 1.38 and 1.53

version 1.38, 2004/11/18 16:34:36 version 1.53, 2005/04/28 22:03:44
Line 12  import xml.dom.minidom Line 12  import xml.dom.minidom
 import operator  import operator
 import tempfile  import tempfile
 import shutil  import shutil
   from types import *
   import time
   from threading import Thread
   import Queue
   
 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"
     ECHO_basis=None      class ECHO_basis:
           """leer"""
   
           manage_options=()
   
   
           
 def splitPath(str):  def splitPath(str):
     str2=str.replace("\\","/")      str2=str.replace("\\","/")
Line 33  def getText(nodelist): Line 41  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="full"):
           """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="/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) 
           
       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="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:
                       path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+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()
                               
                       try:
                                   nr=self.ids.index(id[0])
                   except:
                                   self.reponse+=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+1]
                           targetPath=tmpPath+"/"+filename
                           try:
                               shutil.copyfile(sourcePath,targetPath)
                           except:
                                                   self.response+=str("<p>Error in File: %s (missing?)<br>\n"%filename)
                             
                       else:
                           path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+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 Zip<br>"
           self.response+="<p>This can take a while....<br>\n"
   
           fh=os.popen2("zip -u %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"""
Line 79  class ImageDigilib(Folder,Persistent,Imp Line 275  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 89  class ImageDigilib(Folder,Persistent,Imp Line 304  class ImageDigilib(Folder,Persistent,Imp
         f.write(filedata)          f.write(filedata)
         f.close()          f.close()
         try:          try:
             os.chmod(filename,0644)              os.chmod(filename,0664)
         except:          except:
             """hack"""              """hack"""
     #scale thumb      #scale thumb
Line 121  class ImageDigilib(Folder,Persistent,Imp Line 336  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 131  class ImageDigilib(Folder,Persistent,Imp Line 348  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()        
   
     def updateImage(self,file,RESPONSE):      def renameImageForm(self):
           """form"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)
           return pt()
   
       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()
   
   
               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 169  class ImageDigilib(Folder,Persistent,Imp Line 442  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):          ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
Line 189  class ImageDigilib(Folder,Persistent,Imp Line 467  class ImageDigilib(Folder,Persistent,Imp
         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="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          #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()
           
Line 207  def manage_AddImageDigilibForm(self): Line 488  def manage_AddImageDigilibForm(self):
           
 def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):  def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
     """Add ImageCollection"""      """Add ImageCollection"""
       
     #fileupload=self.REQUEST['fileupload']      #fileupload=self.REQUEST['fileupload']
     fn=splitPath(fileupload.filename)      fn=splitPath(fileupload.filename)
     newObj=ImageDigilib(id,fn,meta)      newObj=ImageDigilib(id,fn,meta)
Line 218  def manage_AddImageDigilib(self,id,fileu Line 500  def manage_AddImageDigilib(self,id,fileu
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
                                     
   
 class ImageCollection(Folder, Persistent, Implicit, ECHO_basis):  class ImageCollection(Folder, Persistent, Implicit, ECHO_basis):
   
     """Sammelordner für Bilder"""      """Sammelordner für Bilder"""
     meta_type="ImageCollection"      meta_type="ImageCollection"
   
      
       zipThreads={}
     genericMetaDataType="leiden_meta"      genericMetaDataType="leiden_meta"
   
     leiden_meta_fields=['image_id','date','country','place','people','description','photographer']      leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
Line 230  class ImageCollection(Folder, Persistent Line 516  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 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"):      def createSet(self,RESPONSE=None,local=None,version="working",repeat=None):
         """download aller gewaehlten files"""          """download aller gewaehlten files"""
         tempfile.tempdir="/tmp/archivesImageServer"  
                   
         tmpPath=tempfile.mktemp()              threadName=repeat
                   
   
         tmpZip=tempfile.mktemp()+".zip"              if not threadName or threadName=="":
         tmpFn=os.path.split(tmpZip)[1]                  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)
   
                   thread.start()
   
         if not os.path.exists(tempfile.tempdir):  
             os.mkdir(tempfile.tempdir)   
   
         if not os.path.exists(tmpPath):                  self.zipThreads[thread.getName()[0:]]=threadStart
             os.mkdir(tmpPath)                   self.REQUEST.SESSION['threadName']=thread.getName()[0:]
                           wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
                           if wait_template:
         if RESPONSE:                      return wait_template[0][1]()
             RESPONSE.setHeader("Content-Type","text/html")                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_Wait.zpt')).__of__(self)
             RESPONSE.write("<h1>I am creating  the download archive</h1>")                  return pt()
             RESPONSE.write("<h3>1. step: getting the images</h3>")                  #xmltrans.run()
   
         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 self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):  
                 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:  
                 if 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:  
                     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()  
                           
                   if (self.zipThreads[threadName].getResult()==None):
                           
                 fh=file(tmpPath+"/"+filename,"w")                      wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                       if wait_template:
                       return wait_template[0][1]()
   
                                   pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_Wait.zpt')).__of__(self)
                 fh.write(image)                      return pt()
                 fh.close()  
   
             #folgeseiten  
             if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:   
                 ids=self.show_thumbs()  
                 nr=ids.index(id[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:                          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
                         RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))                          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")  
                           
                                   
         else:  
             os.popen("zip -u %s %s/*"%(tmpZip,tmpPath))  
   
                   
         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"""
Line 408  class ImageCollection(Folder, Persistent Line 615  class ImageCollection(Folder, Persistent
         self.ImageViewerPath=ImageViewerPath          self.ImageViewerPath=ImageViewerPath
         self.defaultMetaString=defaultMetaString          self.defaultMetaString=defaultMetaString
   
     if ECHO_basis:  
         optTMP= Folder.manage_options+ECHO_basis.manage_options  
     else:  
         optTMP= Folder.manage_options          optTMP= Folder.manage_options
   
     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 516  class ImageCollection(Folder, Persistent Line 730  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 537  class ImageCollection(Folder, Persistent Line 751  class ImageCollection(Folder, Persistent
                   
         url=urllib.unquote(url)          url=urllib.unquote(url)
         xmldoc=urllib.urlopen(url).read()          xmldoc=urllib.urlopen(url).read()
         #print url          #return xmldoc
     try:      try:
         dom=xml.dom.minidom.parseString(xmldoc)          dom=xml.dom.minidom.parseString(xmldoc)
         except:          except:
Line 548  class ImageCollection(Folder, Persistent Line 762  class ImageCollection(Folder, Persistent
     fnIds={}      fnIds={}
         for image in images:          for image in images:
         imagename=image.getElementsByTagName('imagename')[0]          imagename=image.getElementsByTagName('imagename')[0]
         text=getText(imagename.childNodes)                  
           
                   
         idnr=image.getElementsByTagName('idnr')[0]          idnr=image.getElementsByTagName('idnr')[0]
         id=getText(idnr.childNodes)          id=getText(idnr.childNodes)
         numberOfPages=image.getElementsByTagName('numberOfPages')[0]          numberOfPages=image.getElementsByTagName('numberOfPages')[0]
Line 557  class ImageCollection(Folder, Persistent Line 773  class ImageCollection(Folder, Persistent
             nop=int(nopT)              nop=int(nopT)
         except:          except:
             nop=0              nop=0
                   texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
                   for text in texts:
         if not text=="":          if not text=="":
             try:              try:
                 rc.append((str(text),id,nop))                  rc.append((str(text),id,nop))
Line 565  class ImageCollection(Folder, Persistent Line 783  class ImageCollection(Folder, Persistent
                 rc.append((repr(text),id,nop))                  rc.append((repr(text),id,nop))
                 fnIds[repr(text)]=(id,nop)                  fnIds[repr(text)]=(id,nop)
   
   
         rc.sort()          rc.sort()
         self.REQUEST.SESSION['filenames']=rc          self.REQUEST.SESSION['filenames']=rc
     self.REQUEST.SESSION['filenamesIds']=fnIds      self.REQUEST.SESSION['filenamesIds']=fnIds
Line 572  class ImageCollection(Folder, Persistent Line 791  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 585  class ImageCollection(Folder, Persistent Line 804  class ImageCollection(Folder, Persistent
           
     def addImage(self):      def addImage(self):
         """Add an Image"""          """Add an Image"""
           
         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,meta,use_default=None,RESPONSE=None):
         """Add"""          """Add"""
   
         #print "FU",fileupload          #print "FU",fileupload
   
         if use_default:          if use_default:
Line 637  class ImageCollection(Folder, Persistent Line 858  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 691  class ImageCollection(Folder, Persistent Line 966  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 791  class ImageCollection(Folder, Persistent Line 1067  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 800  class ImageCollection(Folder, Persistent Line 1094  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 807  class ImageCollection(Folder, Persistent Line 1102  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:                                      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)]
   
                     ret+="""<a href="%s" target="_top">%i</a>&nbsp;&nbsp;"""%(href,i)            anf+="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"prev")
           except:
             pass
           ret=anf+ret
           
           try:
             
             if selected:                
                           href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr+1)*a]
                     else:
                           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
   
   
                   #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 832  class ImageCollection(Folder, Persistent Line 1171  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 902  class ImageCollection(Folder, Persistent Line 1244  class ImageCollection(Folder, Persistent
             return 0              return 0
         if self.REQUEST.SESSION.has_key("filename"):          if self.REQUEST.SESSION.has_key("filename"):
             filename=self.REQUEST.SESSION["filename"]              filename=self.REQUEST.SESSION["filename"]
                           filename=self.getImageByName(filename,onlyName="yes")
                                   
             try:              try:
                 startId=filename                  startId=filename
Line 995  class ImageCollection(Folder, Persistent Line 1337  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 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):      def index_html(self):
         """main template collection"""          """main template collection"""
         if self.REQUEST.has_key('filename'):          if self.REQUEST.has_key('filename'):
Removed from v.1.38  
changed lines
  Added in v.1.53

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