"""version 1 des Imageservers, wird ersetzt durch version2""" genericServerPath="http://www.mpiwg-berlin.mpg.de/zogilib_images" #can be changed with main config from Ft.Xml.Domlette import NonvalidatingReader from OFS.Folder import Folder from OFS.OrderedFolder import OrderedFolder from OFS.SimpleItem import SimpleItem from Globals import Persistent,package_home from Acquisition import Implicit from Products.PageTemplates.PageTemplateFile import PageTemplateFile from Products.PageTemplates.PageTemplate import PageTemplate from xmlrpclib import ServerProxy import re import os import os.path import urllib import xml.dom.minidom import operator import tempfile import shutil from types import * import time from threading import Thread import Queue import cgi import sys import shutil import logging #ersetzt logging def logger(txt,method,txt2): """logging""" logging.info(txt+ txt2) def logTime(msg=""): """log the time""" logging.info("%s %s"%(msg,time.clock())) from AccessControl import ClassSecurityInfo, getSecurityManager try: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder except: print "ZSQL Extend Folder nicht importiert" print "Metadatendfolder funktioniert nicht!!!" class ZSQLExtendFolder: """leer""" manage_options=() try: from Products.ECHO_content.ECHO_collection import ECHO_basis except: print "ECHO Elements not imported" class ECHO_basis: """leer""" manage_options=() tdir="tmp" #tdir = "/mpiwg/temp/tmp/archivesImageServer/" #tdir="/tmp/archivesImageServer/" imageExtensions=['.jpg','.jpeg','.tif','.tiff','.png','.gif'] def splitPath(str): str2=str.replace("\\","/") return os.path.split(str2)[1] def getText(nodelist): rc = "" for node in nodelist: if node.nodeType == node.TEXT_NODE: rc = rc + node.data return rc def getTextFromNode(nodename): nodelist=nodename.childNodes rc = "" for node in nodelist: if node.nodeType == node.TEXT_NODE: rc = rc + node.data return rc class generateSet: """generateSetThread""" def __init__(self,filenames,filenamesIds,ImageViewerPath,ImageStoragePath,destBasis,ids,url,local=None,version="working"): """init generateSet""" self.filenames=filenames self.filenamesIds=filenamesIds self.ImageViewerPath=ImageViewerPath self.ImageStoragePath=ImageStoragePath self.destBasis=destBasis self.ids=ids self.local=local self.url=url self.version=version self.done=None self.response="" 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="
Get File: %s
\n"%filename)
toggle=False
if self.local:
if self.version=="working":
sourcePath=self.destBasis+"/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
if not os.path.exists(sourcePath):
self.response+=str("
%s doesn't exist I'll try the non scaled image
"%sourcePath) toggle=True if (self.version!="working") or toggle: toggle=False sourcePath=self.ImageStoragePath+"/"+id[0] if not os.path.exists(sourcePath): sourcePath=self.ImageStoragePath+"/"+os.path.splitext(id[0])[0]+".jpg" targetPath=tmpPath+"/"+filename try: shutil.copyfile(sourcePath,targetPath) except: self.response+=(str("Error in File: %s (possible missing)
\n"%sourcePath))
else:
if self.version=="working":
requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
else:
requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
image=urllib.urlopen(path).read()
fh=file(tmpPath+"/"+filename,"w")
fh.write(image)
fh.close()
#folgeseiten
if int(self.filenamesIds[id[0]][1])>1:
#ids=self.show_thumbs()
try:
nr=self.ids.index(id[0])
except:
self.response+=str("
Error in File: %s (possible missing)
\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("
Get File: %s
\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("
Error in File: %s (missing?)
\n"%filename)
else:
requestString=self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
image=urllib.urlopen(path).read()
fh=file(tmpPath+"/"+filename,"w")
fh.write(image)
fh.close()
self.response+="
Create gtar
"
self.response+="
This can take a while....
\n"
fh=os.popen2("gnutar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
self.response+="
"
for c in fh.read():
self.response+=c
if c==")":
self.response+="
\n"
shutil.rmtree(tmpPath)
self.response+="
finished
\n"
len=os.stat(tmpZip)[6]
downloadUrl=self.url+"/downloadSet"
self.response+="""
The file will be stored for a while, you can download it later, the URL is:
%s?fn=%s\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="
" for tag in self.mlist: ret+="%s=%s
"%(tag,getattr(self,tag)) return ret+"" class ImageDigilib(Folder,Persistent,Implicit): """Anzeige object fuer digilib""" meta_type="ImageDigilib" security=ClassSecurityInfo() leiden_meta_fields=['image_id','date','country','place','people','description','photographer'] manage_options = Folder.manage_options+( {'label':'Add Metadata','action':'addMetaObjectForm'}, {'label':'View Info','action':'editImageDigilib'}, ) def editImageDigilib(self): """edit image date""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageDigilib.zpt')).__of__(self) return pt() def getAccessRight(self): """get the accessright, return is string "extern" or "intern" """ return self.getRights(self.filename.split('.')[0]) security.declarePublic('isAccessible') def isAccessible(self): """gives true if obejct is accessible taking the rights of the user into account""" logTime("isaccessible") #TODO: implement rights, currently true if external and false if internal, and true if user has role authenticated username=self.REQUEST['AUTHENTICATED_USER'] #print username #print self.acl_users.getUserNames() user=getSecurityManager().getUser() roles=user.getRoles() if self.getRightsQuery()=="": #query empty then always true return True if 'Authenticated' in roles: return True if self.getAccessRight()=="extern": return True else: return False def addMetaObject(self,id,RESPONSE=None): """Add an MetaObject""" objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType) request=self.REQUEST objectCreate=objectType.createObjectManager(id,request) self._setObject(id,objectCreate) objectCreate.propertysheets.meta.manage_editProperties(request) if RESPONSE is not None: RESPONSE.redirect('manage_main') def addMetaObjectForm(self): """Add Form""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetaObject.zpt')).__of__(self) return pt() def __init__(self,id,filename,meta=None): self.id=id self.title=filename self.filename=filename self.meta=meta def getBasename(self): """returns base filename (sans extension)""" return os.path.splitext(self.filename)[0] def getMeta(self): """ausgabe der metadaten""" 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): """upload an Image from an Requast""" #path_name=self.ImageStoragePath fn = self.filename or splitPath(fileupload.filename) fn = os.path.splitext(fn)[0]+os.path.splitext(fileupload.filename)[1] # Extensions des gespeicherten Files sollte gleich dem hochgeladenen File sein. filename=path_name+"/"+fn filedata=fileupload.read() f=open(filename,"w") f.write(filedata) f.close() self.filename = fn try: os.chmod(filename,0664) except: """hack""" #< thumb self.scaleThumbs() #scale standard self.scaleWorkingVersions() def downloadWorkingVersion(self): """download working version (2000 pixel)""" return self.download(fmt="&dw=2000&dh=2000",suffix=".jpg") def download(self,fmt="&mo=rawfile,hires",suffix=None): """download""" requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename): filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename else: filename=self.filename if suffix: filename=os.path.splitext(filename)[0]+suffix self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename) self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream") #print path imagefh=urllib.urlopen(path,'rb') self.REQUEST.RESPONSE.write(imagefh.read()) self.REQUEST.RESPONSE.close() #return self.REQUEST.RESPONSE.redirect(path) def updateImageForm(self): """form""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self) 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.getImageStoragePath(),oldname) newpath=os.path.join(self.getImageStoragePath(),newname) os.rename(oldpath,newpath) #umbenennen des versionsfolders oldfolder=os.path.join(self.getImageStoragePath(),"."+oldname+".dir") newfolder=os.path.join(self.getImageStoragePath(),"."+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() #self.scaleToJpg() if RESPONSE: RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename) def scaleToJpg(self,RESPONSE=None): """create a jpg""" #create backup of the original file imagePath=os.path.join(self.getImageStoragePath(),self.filename) path=os.path.join(self.getImageStoragePath(),"."+self.getId()+".dir") if not os.path.exists(path): os.mkdir(path,0775) os.chmod(path,0775) newName=os.path.join(path,self.getId()+str(time.time())) if os.path.exists(newName): logger("ImageArchive:scaleToJpg", logging.INFO, "%s already exists"%newName) else: try: os.rename(imagePath,newName) except: logger("ImageArchive:scaleToJpg", logging.ERROR, "%s "%newName) return False ext= os.path.splitext(imagePath)[1].lower() if ext.rstrip()==".jpg": shutil.copy(newName,imagePath) print "copy",imagePath return True dir=self.getId() src=path self.scale(dest=self.getImageStoragePath(),dir=dir,src=path,scaleBy=1,RESPONSE=RESPONSE) return True def updateImage(self,_fileupload,_rename=None,RESPONSE=None): """lade neues Version des Bildes""" #teste ob Dokumenten ordner schon vorhanden #imagePath=os.path.join(self.getImageStoragePath(),self.getId()) logging.error("updateImage:"+self.filename) identifyField="filename" if _fileupload and _fileupload.filename!="": imagePath=os.path.join(self.getImageStoragePath(),self.filename) idWithoutSuffix= os.path.splitext(self.getId())[0] path=os.path.join(self.getImageStoragePath(),"."+self.getId()+".dir") if not os.path.exists(path): os.mkdir(path,0775) os.chmod(path,0775) versionNumber=getattr(self,'versionNumber',0)+1 #teste ob version schon existiert while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.filename))): versionNumber+=1 #kopieren der bestehenden Version in den Versions ordner. imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.filename)) try: #logger("ImageArchive:updateImage", logging.INFO, "rename: %s -> %s"%(imagePath,imageNewPath)) os.rename(imagePath,imageNewPath) except: logger("ImageArchive:updateImage ", logging.ERROR, "rename: %s -> %s didn't work!"%(imagePath,imageNewPath)) #lesen des upload files und schreiben filedata=_fileupload.read() #passe suffix an oldNameBase=os.path.splitext(imagePath)[0] uploadFileExt=os.path.splitext(_fileupload.filename)[1] newImagePath=oldNameBase+uploadFileExt f=open(newImagePath,"w") # if we wanted to have filename=id we should do it here! logging.error("saving:"+newImagePath) f.write(filedata) f.close() try: os.chmod(newImagePath,0664) except: pass #scale thumb self.scaleThumbs() #scale standard self.scaleWorkingVersions() #self.scaleToJpg() if _rename: self.renameImage(_fileupload.filename) else: self.filename=os.path.splitext(self.filename)[0]+uploadFileExt # Aendere zumindest die Extensiion try: #todo: sollte nur aufgerufen werden, wenn eine Datenbank dahinter liegt. args=self.REQUEST.form args['-identify']=identifyField+"="+args['_identifyField'] self.ZSQLChange(args=args) except: pass if RESPONSE: RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename) return "done" security.declarePublic('thumb') def thumb(self,url=None): """show thumb""" thumbname=os.path.splitext(self.filename)[0]+".jpg" requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores" path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString self.REQUEST.SESSION['string']=""% path if url: return ""% path else: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self) return pt() def thumbMD(self,url=None): """show thumb mit Metadaten erwarten image in ImageCollectionMD """ thumbname=os.path.splitext(self.filename)[0]+".jpg" requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores" path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString imageString=""% path self.REQUEST.SESSION['string']=imageString if url: return ""% 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(imageString=imageString) def image(self,dw=None,dh=None): """show image only with scaler""" str=[] if (not dw) and (not dh): str.append("mo=file") if dw: str.append("dw=%s"%dw) if dh: str.append("dw=%s"%dh) str.append("lv=2&fn=%s"%self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]) requestString="&".join(str) self.REQUEST.RESPONSE.redirect(getattr(self,'serverPath',genericServerPath)+"/scaledImage?"+requestString) def index_html(self): """show image with zogilib""" #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=getattr(self,'serverPath',genericServerPath)+"?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0] return self.REQUEST.RESPONSE.redirect(path) def manage_AddImageDigilibForm(self): """Nothing yet""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageDigilibForm.zpt')).__of__(self) return pt() def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None): """Add ImageCollection""" #fileupload=self.REQUEST['fileupload'] #fn=splitPath(fileupload.filename) fn = id # filename is the same as id newObj=ImageDigilib(id,fn,meta) self._setObject(id,newObj) getattr(self,id).uploadImage(fileupload,self.getImageStoragePath()) if RESPONSE is not None: RESPONSE.redirect('manage_main') class ImageCollection(OrderedFolder, Persistent, Implicit,ECHO_basis): """Sammelordner fuer Bilder""" meta_type="ImageCollection" security=ClassSecurityInfo() #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn=" #scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn=" zipThreads={} zipThreads2={} genericMetaDataType="leiden_meta" leiden_meta_fields=['image_id','date','country','place','people','description','photographer'] defaultMetaString="http://fm-web.mpiwg-berlin.mpg.de:8050/FMRes/FMPJS?-db=Wissenschaftlerportraits.fp5&-layID=69&-token=25&-max=1&-format=formvwcss.htm&-mode=browse&images::filename=%s&-find" ## TEST FUER IMAGEDATENBANK WP imgcoll_main = PageTemplateFile('zpt/overview', globals()) imgcoll_mainMD = PageTemplateFile('zpt/overviewMD', globals()) imgcoll_thumb = PageTemplateFile('zpt/thumb', globals()) imgcoll_thumbMD = PageTemplateFile('zpt/thumbMD', globals()) destBasis="/docuserver/scaled/" scaledBasis=destBasis srcBasis="/docuserver/images" scaleomatStr="/docuserver/libs/scaleomat/scaleomat.pl" #dest="/Volumes/paviaExtern/docuserver/images/exhibitionImages/" def configScaleForm(self): """configure the scaler form""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','configScale.zpt')).__of__(self) return pt() def configScale(self,scaleomatStr,RESPONSE=None): """config the scaler""" self.scaleomatStr=scaleomatStr if RESPONSE is not None: RESPONSE.redirect('manage_main') def scale(self,dest=None,dir=None,src=None,scaleTo=None,scaleBy=None,RESPONSE=None): """scaler""" #scaleomatStr="ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl -src=/mpiwg/online/ %s" scaleomatStr=self.scaleomatStr destBasis=self.destBasis srcBasis=self.srcBasis if src: srcStr=" -src=%s"%src else: srcStr=" -src=%s"%srcBasis scaleStr=scaleomatStr+srcStr if dir: dirTmp=dir.replace(srcBasis,'') dirStr=" -dir=%s"%dirTmp scaleStr=scaleStr+dirStr elif filename: fileTmp=filename.replace(srcBasis,'') fileStr=" -dir=%s"%fileTmp scaleStr=scaleStr+fileStr else: logger("ImageCollection:scale",logging.ERROR,"no directory or filename given") return False if dest is not None: destStr=" -dest=%s"%os.path.join(destBasis,dest) scaleStr=scaleStr+destStr else: logger("ImageCollection:scale",logging.ERROR,"no destionation given") return False if scaleTo: scaleToStr=" -scaleto=%s"%scaleTo scaleStr=scaleStr+scaleToStr elif scaleBy: scaleByStr=" -scaleby=%s"%scaleBy scaleStr=scaleStr+scaleByStr else: logger("ImageCollection:scale",logging.ERROR,"no destionation given") return False #ret=scaleStr logger("ImageCollection:scale",logging.INFO,scaleStr) ret=os.popen2(scaleStr,1)[1].read() if RESPONSE: RESPONSE.write(ret) return True def getImageObject(self,name): """gibt objeckt name zurueck""" if hasattr(self,name): return getattr(self,name) name=os.path.splitext(name)[0] for extension in imageExtensions: nameExt=name+extension if hasattr(self,nameExt): return getattr(self,nameExt) nameExt=name+"_"+extension if hasattr(self,nameExt): return getattr(self,nameExt) return getattr(self,"defaultImg") def getServerPath(self): """get Server path""" return getattr(self,'serverPath',genericServerPath) def getScalerPath(self): """get ScalerPath""" path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn=" def getImageViewerPath(self): """get ImageViewerPath""" return self.ImageViewerPath def getImageStoragePath(self): """get ImageStoragePath""" if self.ImageViewerPath[0]=="/": if len(self.ImageViewerPath)>1: iv=self.ImageViewerPath[1:] else: iv="" else: iv=self.ImageViewerPath return os.path.join(self.srcBasis,iv) 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): """download aller gewaehlten files""" threadName=repeat if not threadName or threadName=="": threadStart=generateSet(self.REQUEST.SESSION['filenames'],self.REQUEST.SESSION['filenamesIds'],self.ImageViewerPath,self.ImageStoragePath,self.destBasis,self.show_thumbs(),self.absolute_url(),local=local,version=version) thread=Thread(target=threadStart) thread.start() self.zipThreads[thread.getName()[0:]]=threadStart self.zipThreads2[thread.getName()[0:]]=thread self.REQUEST.SESSION['threadName']=thread.getName()[0:] wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template']) if wait_template: return wait_template[0][1]() pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self) return pt() #xmltrans.run() else: self.REQUEST.SESSION['threadName']=threadName if (self.zipThreads[threadName].getResult()==None): 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) return pt() else: if self.zipThreads[threadName].isDone(): self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult() self.zipThreads2[threadName].join() del(self.zipThreads2[threadName]) del(self.zipThreads[threadName]) pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self) return pt() else: self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult() self.REQUEST.SESSION['threadName']=threadName pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self) return pt() def checkThreads(self): """teste running threads""" ret="""%s --> alive
"%threadName else: ret+="%s --> dead
"%threadName return ret+"" def downloadSet(self,fn): """download prepared set""" filename=os.path.join(tdir,fn) self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.tgz") self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream") len=os.stat(filename)[6] self.REQUEST.RESPONSE.setHeader("Content-Length",len) images=file(filename).read() self.REQUEST.RESPONSE.write(images) self.REQUEST.RESPONSE.close() def scaleToJpgs(self,RESPONSE=None): """scale all tifs to jps""" for x in self._objects: if (not hasattr(getattr(self,x['id']),'scaleToJpg')) or (not getattr(self,x['id']).scaleToJpg()): if RESPONSE: RESPONSE.write('error:%s'%x) def scaleThumbs(self,RESPONSE=None): """scale thumbs""" #scale thumbs dest=os.path.join(self.scaledBasis,'thumb') self.scale(dir=self.getImageStoragePath(),dest=dest,scaleTo=100,RESPONSE=RESPONSE) #ret=os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl -src=/mpiwg/online/ -dir=%s -dest=/mpiwg/temp/online/scaled/thumb -scaleto=100 &"% self.ImageViewerPath) #if RESPONSE: # RESPONSE.write(ret.read()) # RESPONSE.write("\n") return "RESCALING STARTED" def scaleWorkingVersions(self,RESPONSE=None): """scale working versions""" #scale standard dest=os.path.join(self.scaledBasis,'small') self.scale(dir=self.getImageStoragePath(),dest=dest,scaleTo=1000,RESPONSE=RESPONSE) dest=os.path.join(self.scaledBasis,'medium') self.scale(dir=self.getImageStoragePath(),dest=dest,scaleTo=2000,RESPONSE=RESPONSE) #ret=os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl -src=/mpiwg/online/ -dir=%s -dest=/mpiwg/temp/online/scaled/small -scaleto=2000 &"% self.ImageViewerPath) if RESPONSE: RESPONSE.write(ret.read()) RESPONSE.write("\n") return "rescaling started" def __init__(self,id,title,ImageViewerPath,defaultMetaString,destBasis,srcBasis,serverPath=genericServerPath): self.id=id self.title=title self.ImageViewerPath=ImageViewerPath self.defaultMetaString=defaultMetaString self.serverPath=serverPath self.destBasis=destBasis self.srcBasis=srcBasis self.defaultrows = 6 self.defaultcols = 2 optTMP= Folder.manage_options manage_options = optTMP+( {'label':'Main Config','action':'ImageCollection_config'}, {'label':'Config Scaler','action':'configScaleForm'}, {'label':'Import','action':'ImportFiles'}, {'label':'Recalculate MetadataLink','action':'recalculateMetaLink'}, {'label':'Import Metadata File','action':'importMetaFileForm'}, {'label':'Import Metadata','action':'importMetaData'}, {'label':'Rescale thumbs','action':'scaleThumbs'}, {'label':'Rescale working version','action':'scaleWorkingVersions'}, ) 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"]): image[1].manageMetaData(strict) return "ok" def importMetaFileForm(self): """import metadata""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self) return pt() def importMetaFile(self,fileupload,tag): """import""" filedata=fileupload.read() dom=xml.dom.minidom.parseString(filedata) rows=dom.getElementsByTagName(tag) #print "ROWS",rows request=self.REQUEST for row in rows: for a in self.leiden_meta_fields: self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes) image_id=self.REQUEST['image_id'] if (not hasattr(self,image_id)) & (not image_id==""): #print image_id newObj=ImageCollection(str(image_id),image_id,'','','') self._setObject(str(image_id),newObj) id="leiden_meta_data_file" self.REQUEST['id']=id #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType) #objectCreate=objectType.createInObjectManager(id,request) #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/" try: addID=getattr(self,image_id) objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id) #getattr(self,image_id)._setObject(id,objectCreate) obj=getattr(addID,id) obj.propertysheets.meta.manage_editProperties(request) except: """nothing""" return "OK" def nextImage(self,request,selected=None,returnFn=None): """show nextimage""" try: ids=self.show_thumbs() if request.SESSION.has_key("filename"): filename=request.SESSION["filename"] try: nr=ids.index(filename) except: nr=0 else: nr=0 if nr==len(ids)-1: return "" else: if returnFn: return ids[nr+1] if selected: return "next image" else: return "next image" except: return "" def prevImage(self,request,selected=None): """show nextimage""" #return self.getId() try: ids=self.show_thumbs() if request.SESSION.has_key("filename"): filename=request.SESSION["filename"] try: nr=ids.index(filename) except: nr=0 else: nr=0 if nr==0: return "" else: if selected: return "previous image" else: return "previous image" except: return "" def meta_default(self,filename): """url der metadaten""" return self.defaultMetaString % urllib.quote(filename) def getThumbAttribute(self,id,attr): if hasattr(self,id): return getattr(getattr(self,id),attr) else: if attr=='title': return "Missing Image:%s" % id def getThumbFunction(self,id,attr): #return "DUMP" if hasattr(self,id): return getattr(getattr(self,id),attr)() def xmlinput(self,url): """Anzeige von ausgewaehlten thumbs""" #return url url=urllib.unquote(url) xmldoc=urllib.urlopen(url).read() #return xmldoc try: dom=xml.dom.minidom.parseString(xmldoc) except: return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc) images=dom.getElementsByTagName('image') rc=[] fnIds={} for image in images: imagename=image.getElementsByTagName('imagename')[0] idnr=image.getElementsByTagName('idnr')[0] id=getText(idnr.childNodes) try: numberOfPages=image.getElementsByTagName('numberOfPages')[0] except: numberOfPages=None if numberOfPages: nopT=getText(numberOfPages.childNodes) try: nop=int(nopT) except: nop=0 else: nop=0 texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste for text in texts: if not text=="": text=self.getImageByName(text,onlyName="yes") try: rc.append((str(text),id,nop)) fnIds[str(text)]=(id,nop) except: rc.append((repr(text),id,nop)) fnIds[repr(text)]=(id,nop) rc.sort() self.REQUEST.SESSION['filenames']=rc self.REQUEST.SESSION['filenamesIds']=fnIds overview=self.ZopeFind(self,obj_ids=['overview_selected.html']) if overview: return overview[0][1]() else: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self) return pt() pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self) return pt() def recalculateMetaLink(self): """recalculate the metadata""" for entryid in self.__dict__: entry=getattr(self,entryid) if hasattr(entry,'meta_type'): if entry.meta_type=="ImageDigilib": entry.meta=entry.meta_default(entry.getId()) return "OK" def addImage(self): """Add an Image""" pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self) return pt() def addImage2(self,fileupload,fileName=None,meta=None,use_default=None,RESPONSE=None): """Add""" #print "FU",fileupload if use_default: try: meta=self.meta_default(fileupload.filename) except: meta=None else: meta=None fn=fileName or splitPath(fileupload.filename) manage_AddImageDigilib(self,fn,fileupload,meta=meta) if RESPONSE: return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn) #return self.REQUEST['URL1']+'/'+fileupload.filename def ImportFiles2(self,RESPONSE=None): """Import the existing files of a folder""" files=os.listdir(self.getImageStoragePath()) ret="" #print self.__dict__ for file in files: fn=os.path.splitext(file)[0] if not (file[0]=="."): if self.__dict__.has_key(file) or self.__dict__.has_key(fn+'.tif') or self.__dict__.has_key(fn+'.tiff') : ret=ret+"