1: genericServerPath="http://www.mpiwg-berlin.mpg.de/zogilib_images" #can be changed with main config
2:
3:
4:
5: from OFS.Folder import Folder
6: from OFS.OrderedFolder import OrderedFolder
7: from OFS.SimpleItem import SimpleItem
8: from Globals import Persistent,package_home
9: from Acquisition import Implicit
10: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
11: from Products.PageTemplates.PageTemplate import PageTemplate
12: from xmlrpclib import ServerProxy
13: import re
14: import os
15: import os.path
16: import urllib
17: import xml.dom.minidom
18: import operator
19: import tempfile
20: import shutil
21: from types import *
22: import time
23: from threading import Thread
24: import Queue
25: import cgi
26: import sys
27: import zLOG
28:
29:
30: from AccessControl import ClassSecurityInfo, getSecurityManager
31:
32: try:
33: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
34: except:
35: print "ZSQL Extend Folder nicht importiert"
36: print "Metadatendfolder funktioniert nicht!!!"
37: class ZSQLExtendFolder:
38: """leer"""
39: manage_options=()
40:
41:
42:
43: try:
44: from Products.ECHO_content.ECHO_collection import ECHO_basis
45: except:
46: print "ECHO Elements not imported"
47: class ECHO_basis:
48: """leer"""
49:
50: manage_options=()
51:
52:
53: tdir = "/mpiwg/temp/tmp/archivesImageServer/"
54: #tdir="/tmp/archivesImageServer/"
55:
56: imageExtensions=['jpg','jpeg','tif','tiff','png']
57:
58: def splitPath(str):
59: str2=str.replace("\\","/")
60: return os.path.split(str2)[1]
61:
62: def getText(nodelist):
63:
64: rc = ""
65: for node in nodelist:
66:
67: if node.nodeType == node.TEXT_NODE:
68: rc = rc + node.data
69: return rc
70:
71: def getTextFromNode(nodename):
72: nodelist=nodename.childNodes
73: rc = ""
74: for node in nodelist:
75: if node.nodeType == node.TEXT_NODE:
76: rc = rc + node.data
77: return rc
78:
79: class generateSet:
80: """generateSetThread"""
81:
82:
83: def __init__(self,filenames,filenamesIds,ImageViewerPath,ids,url,local=None,version="working"):
84: """init generateSet"""
85: self.filenames=filenames
86: self.filenamesIds=filenamesIds
87: self.ImageViewerPath=ImageViewerPath
88: self.ids=ids
89: self.local=local
90: self.url=url
91: self.version=version
92: self.done=None
93:
94:
95: def __call__(self):
96: """call generate Set"""
97:
98: storeTempDir=tempfile.tempdir
99: tempfile.tempdir=tdir
100:
101: tmpPath=tempfile.mktemp()
102: tmpZip=tempfile.mktemp()+".gtz"
103: tmpFn=os.path.split(tmpZip)[1]
104:
105: if not os.path.exists(tempfile.tempdir):
106: os.mkdir(tempfile.tempdir)
107:
108: if not os.path.exists(tmpPath):
109: os.mkdir(tmpPath)
110:
111: self.response=""
112:
113:
114: self.response="<h3>1. step: getting the images</h3>"
115:
116: for id in self.filenames:
117:
118: if self.filenamesIds.has_key(id[0]):
119: filename=self.filenamesIds[id[0]][0]+"_"+id[0]
120: else:
121: filename=id[0]
122:
123: self.response+=str("<p>Get File: %s<br>\n"%filename)
124:
125:
126: if self.local:
127:
128: if self.version=="working":
129:
130: sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
131: else:
132: sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
133: targetPath=tmpPath+"/"+filename
134: try:
135: shutil.copyfile(sourcePath,targetPath)
136: except:
137: self.response+=(str("<p>Error in File: %s (possible missing)<br>\n"%filename))
138: else:
139: if self.version=="working":
140: requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
141: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
142:
143: else:
144: requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
145: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
146:
147:
148: image=urllib.urlopen(path).read()
149:
150:
151: fh=file(tmpPath+"/"+filename,"w")
152:
153:
154: fh.write(image)
155: fh.close()
156:
157: #folgeseiten
158:
159: if int(self.filenamesIds[id[0]][1])>1:
160: #ids=self.show_thumbs()
161:
162: try:
163: nr=self.ids.index(id[0])
164: except:
165: self.response+=str("<p>Error in File: %s (possible missing)<br>\n"%id[0])
166:
167:
168: nr=0
169:
170: numberOfPages=self.filenamesIds[id[0]][1]
171: for k in range(int(numberOfPages)-1):
172: i=k+1
173: if self.filenamesIds.has_key(id[0]):
174: filename=self.filenamesIds[id[0]][0]+"_"+self.ids[nr+i]
175: else:
176: filename=id[0]
177:
178: self.response+=str("<p>Get File: %s<br>\n"%filename)
179:
180: if self.local:
181: sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+self.ids[nr+i]
182: targetPath=tmpPath+"/"+filename
183: try:
184: shutil.copyfile(sourcePath,targetPath)
185:
186: except:
187: self.response+=str("<p>Error in File: %s (missing?)<br>\n"%filename)
188:
189: else:
190:
191: requestString=self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
192: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
193:
194: image=urllib.urlopen(path).read()
195:
196:
197: fh=file(tmpPath+"/"+filename,"w")
198: fh.write(image)
199: fh.close()
200:
201: self.response+="<h3>2. step: creating the downloadable file</h3>"
202: self.response+="<p>Create gtar<br>"
203: self.response+="<p>This can take a while....<br>\n"
204:
205: fh=os.popen2("gnutar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
206: self.response+="<br>"
207: for c in fh.read():
208: self.response+=c
209: if c==")":
210: self.response+="<br>\n"
211:
212:
213:
214:
215: shutil.rmtree(tmpPath)
216:
217: self.response+="<p>finished<br>\n"
218:
219: len=os.stat(tmpZip)[6]
220: downloadUrl=self.url+"/downloadSet"
221: self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
222: self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
223: <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
224:
225: self.done=True
226: def getResult(self):
227: """get result"""
228: return self.response
229:
230: def isDone(self):
231: if self.done:
232: return True
233: else:
234: return False
235:
236: class metaData(SimpleItem):
237: """Klasse fuer metadaten"""
238: meta_type="metaData"
239:
240: def __init__(self,xmlurl,container=None):
241: """__init__"""
242: return self.update(xmlurl,container)
243:
244:
245: def update(self,xmlurl,container=None):
246: """update"""
247:
248: try:
249: xmlfh=urllib.urlopen(xmlurl)
250: dom=xml.dom.minidom.parse(xmlfh)
251: except:
252: return None
253:
254: md=dom.getElementsByTagName(container)
255: mlist=[]
256: if md:
257: for node in md[0].childNodes:
258: if node.nodeType==dom.ELEMENT_NODE:
259: name=node.tagName
260: content=getTextFromNode(node)
261: setattr(self,name,content)
262: mlist.append(name)
263: self.mlist=mlist[0:]
264: else:
265: self.mlist=[]
266:
267: def index_html(self):
268: """index"""
269: ret="<html><body>"
270: for tag in self.mlist:
271: ret+="<p>%s=%s</p>"%(tag,getattr(self,tag))
272: return ret+"</body></html>"
273:
274:
275:
276:
277: class ImageDigilib(Folder,Persistent,Implicit):
278: """Anzeige object fuer digilib"""
279: meta_type="ImageDigilib"
280: security=ClassSecurityInfo()
281: leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
282:
283: manage_options = Folder.manage_options+(
284:
285: {'label':'Add Metadata','action':'addMetaObjectForm'},
286:
287: )
288:
289: def getAccessRight(self):
290: """get the accessright, return is string "extern" or "intern" """
291: return self.getRights(self.filename.split('.')[0])
292:
293: security.declarePublic('isAccessible')
294:
295: def isAccessible(self):
296: """gives true if obejct is accessible taking the rights of the user into account"""
297:
298: #TODO: implement rights, currently true if external and false if internal, and true if user has role authenticated
299:
300: username=self.REQUEST['AUTHENTICATED_USER']
301: #print username
302: #print self.acl_users.getUserNames()
303: user=getSecurityManager().getUser()
304:
305: roles=user.getRoles()
306:
307:
308: if self.getRightsQuery()=="":
309: #query empty then always true
310: return True
311:
312:
313: if 'Authenticated' in roles:
314: return True
315:
316: if self.getAccessRight()=="extern":
317: return True
318: else:
319: return False
320:
321: def addMetaObject(self,id,RESPONSE=None):
322: """Add an MetaObject"""
323: objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
324:
325: request=self.REQUEST
326: objectCreate=objectType.createObjectManager(id,request)
327:
328: self._setObject(id,objectCreate)
329:
330: objectCreate.propertysheets.meta.manage_editProperties(request)
331:
332: if RESPONSE is not None:
333: RESPONSE.redirect('manage_main')
334:
335:
336:
337:
338: def addMetaObjectForm(self):
339: """Add Form"""
340: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetaObject.zpt')).__of__(self)
341: return pt()
342:
343:
344: def __init__(self,id,filename,meta=None):
345: self.id=id
346: self.title=filename
347: self.filename=filename
348: self.meta=meta
349:
350: def getBasename(self):
351: """returns base filename (sans extension)"""
352: return os.path.splitext(self.filename)[0]
353:
354: def getMeta(self):
355: """ausgabe der metadaten"""
356: return self.meta
357:
358: def manageMetaData(self,strict=None):
359: """create or updateMetadata"""
360:
361: md=self.ZopeFind(self,obj_metatypes=["metaData"])
362:
363: if not md:
364: self._setObject("metaData",metaData(self.meta,"ROW"))
365:
366: else:
367: if not strict:
368: md[0][1].update(self.meta,"ROW")
369: else:
370: print "strict"
371: if len(md[0][1].mlist)==0:
372: print " +++",self.getId()
373: md[0][1].update(self.meta,"ROW")
374: else:
375: print " ---",self.getId()
376:
377: def uploadImage(self,fileupload,path_name):
378: """upload an Image from an Requast"""
379: #path_name=self.ImageStoragePath
380: fn = self.filename or splitPath(fileupload.filename)
381: filename=path_name+"/"+fn
382: filedata=fileupload.read()
383: f=open(filename,"w")
384: f.write(filedata)
385: f.close()
386: self.filename = fn
387: try:
388: os.chmod(filename,0664)
389: except:
390: """hack"""
391: #scale thumb
392:
393: self.scaleThumbs()
394:
395: #scale standard
396:
397: self.scaleWorkingVersions()
398:
399:
400:
401: def downloadWorkingVersion(self):
402: """download working version (2000 pixel)"""
403:
404: return self.download(fmt="&dw=2000&dh=2000",suffix=".jpg")
405:
406: def download(self,fmt="&mo=rawfile,hires",suffix=None):
407: """download"""
408:
409: requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
410: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
411:
412:
413: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):
414: filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename
415: else:
416: filename=self.filename
417:
418: if suffix:
419: filename=os.path.splitext(filename)[0]+suffix
420:
421: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
422: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
423: #print path
424: imagefh=urllib.urlopen(path,'rb')
425:
426: self.REQUEST.RESPONSE.write(imagefh.read())
427: self.REQUEST.RESPONSE.close()
428: #return self.REQUEST.RESPONSE.redirect(path)
429:
430: def updateImageForm(self):
431: """form"""
432: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self)
433: return pt()
434:
435:
436: security.declareProtected('View management screens','renameImageForm')
437: def renameImageForm(self):
438: """form"""
439: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)
440: return pt()
441:
442: security.declareProtected('View management screens','renameImage')
443: def renameImage(self,newname,RESPONSE=None):
444: """umbenennen"""
445: #umbennen des files im folder
446: oldname=self.getId()
447: self.aq_parent.manage_renameObjects(ids=[oldname],new_ids=[newname])
448: self.title=newname[0:]
449: self.filename=newname[0:]
450: #umbennen des files auf dem server
451: oldpath=os.path.join(self.ImageStoragePath,oldname)
452: newpath=os.path.join(self.ImageStoragePath,newname)
453: os.rename(oldpath,newpath)
454:
455: #umbenennen des versionsfolders
456: oldfolder=os.path.join(self.ImageStoragePath,"."+oldname+".dir")
457: newfolder=os.path.join(self.ImageStoragePath,"."+newname+".dir")
458: if os.path.exists(oldfolder):
459: os.rename(oldfolder,newfolder)
460: else:
461: os.mkdir(newfolder)
462:
463: #schreibe info uber umbennenung
464:
465: renameName=os.path.join(newfolder,"renamed")
466: if os.path.exists(renameName):
467: fh=file(renameName,'a')
468: else:
469: fh=file(renameName,'w')
470:
471: tm=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
472: try:
473: user=self.REQUEST['AUTHENTICATED_USER']
474: except:
475: user="unknown"
476:
477: str="""%s %s %s %s\n"""%(tm,user,oldname,newname)
478: fh.write(str)
479: fh.close()
480:
481: #scale thumb
482:
483: self.scaleThumbs()
484:
485: #scale standard
486:
487: self.scaleWorkingVersions()
488:
489:
490: if RESPONSE:
491: RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
492:
493:
494: def updateImage(self,file,rename=None,RESPONSE=None):
495: """lade neues Version des Bildes"""
496: #teste ob Dokumenten ordner schon vorhanden
497: #imagePath=os.path.join(self.ImageStoragePath,self.getId())
498: imagePath=os.path.join(self.ImageStoragePath,self.filename)
499: path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")
500:
501: if not os.path.exists(path):
502: os.mkdir(path,0775)
503: os.chmod(path,0775)
504:
505: versionNumber=getattr(self,'versionNumber',0)+1
506:
507: #teste ob version schon existiert
508:
509: while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.filename))):
510: versionNumber+=1
511:
512: #kopieren der bestehenden Version in den Versions ordner.
513: imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.filename))
514: try:
515: #zLOG.LOG("ImageArchive:updateImage", zLOG.INFO, "rename: %s -> %s"%(imagePath,imageNewPath))
516: os.rename(imagePath,imageNewPath)
517: except:
518: zLOG.LOG("ImageArchive:updateImage", zLOG.ERROR, "rename: %s -> %s didn't work!"%(imagePath,imageNewPath))
519:
520: #lesen des upload files und schreiben
521: filedata=file.read()
522: f=open(imagePath,"w") # if we wanted to have filename=id we should do it here!
523: f.write(filedata)
524: f.close()
525: try:
526: os.chmod(imagePath,0664)
527: except:
528: """hack"""
529: #scale thumb
530:
531: self.scaleThumbs()
532:
533: #scale standard
534:
535: self.scaleWorkingVersions()
536:
537: if rename:
538: self.renameImage(file.filename)
539:
540:
541: if RESPONSE:
542: RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
543:
544:
545: return "done"
546:
547: security.declarePublic('thumb')
548: def thumb(self,url=None):
549: """show thumb"""
550: thumbname=os.path.splitext(self.filename)[0]+".jpg"
551: requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
552: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
553:
554:
555: self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
556: if url:
557: return "<img border=\"0\" src=\"%s\">"% path
558: else:
559: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
560: return pt()
561:
562:
563: def thumbMD(self,url=None):
564: """show thumb mit Metadaten erwarten image in ImageCollectionMD
565: """
566: thumbname=os.path.splitext(self.filename)[0]+".jpg"
567:
568: requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
569: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
570:
571:
572:
573: self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
574: if url:
575: return "<img border=\"0\" src=\"%s\">"% path
576: else:
577:
578: overview=self.ZopeFind(self.aq_parent,obj_ids=['thumb.html'])
579: if overview:
580: return getattr(self,overview[0][0])()
581: else:
582: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbMD.zpt')).__of__(self)
583: return pt()
584:
585:
586: def image(self,dw=None,dh=None):
587: """show image only with scaler"""
588: str=[]
589: if (not dw) and (not dh):
590: str.append("mo=file")
591: if dw:
592: str.append("dw=%s"%dw)
593:
594: if dh:
595: str.append("dw=%s"%dh)
596:
597: str.append("lv=2&fn=%s"%self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0])
598:
599:
600: requestString="&".join(str)
601:
602: self.REQUEST.RESPONSE.redirect(getattr(self,'serverPath',genericServerPath)+"/scaledImage?"+requestString)
603:
604: def index_html(self):
605: """show image with zogilib"""
606: #DEVELOP: take first one for server
607: #path="http://127.0.0.1:8080/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
608: path=getattr(self,'serverPath',genericServerPath)+"?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
609: return self.REQUEST.RESPONSE.redirect(path)
610:
611:
612: def manage_AddImageDigilibForm(self):
613: """Nothing yet"""
614: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageDigilibForm.zpt')).__of__(self)
615: return pt()
616:
617: def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
618: """Add ImageCollection"""
619:
620: #fileupload=self.REQUEST['fileupload']
621: #fn=splitPath(fileupload.filename)
622: fn = id # filename is the same as id
623: newObj=ImageDigilib(id,fn,meta)
624:
625: self._setObject(id,newObj)
626: getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
627:
628: if RESPONSE is not None:
629: RESPONSE.redirect('manage_main')
630:
631:
632:
633: class ImageCollection(OrderedFolder, Persistent, Implicit,ECHO_basis):
634: """Sammelordner fuer Bilder"""
635: meta_type="ImageCollection"
636:
637:
638: security=ClassSecurityInfo()
639:
640: #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn="
641: #scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="
642:
643: zipThreads={}
644: zipThreads2={}
645:
646: genericMetaDataType="leiden_meta"
647:
648: leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
649:
650:
651: 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
652:
653: imgcoll_main = PageTemplateFile('zpt/overview', globals())
654: imgcoll_mainMD = PageTemplateFile('zpt/overviewMD', globals())
655: imgcoll_thumb = PageTemplateFile('zpt/thumb', globals())
656: imgcoll_thumbMD = PageTemplateFile('zpt/thumbMD', globals())
657:
658: def getImageObject(self,name):
659: """gibt objeckt name zurueck"""
660: if hasattr(self,name):
661: return getattr(self,name)
662:
663: name=os.path.splitext(name)[0]
664: for extension in imageExtensions:
665: nameExt=name+"."+extension
666:
667: if hasattr(self,nameExt):
668: return getattr(self,nameExt)
669:
670: nameExt=name+"_."+extension
671: if hasattr(self,nameExt):
672: return getattr(self,nameExt)
673:
674: return getattr(self,"defaultImg")
675:
676: def getServerPath(self):
677: """get Server path"""
678: return getattr(self,'serverPath',genericServerPath)
679:
680: def getScalerPath(self):
681: """get ScalerPath"""
682: path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="
683:
684: def getImageViewerPath(self):
685: """get ImageViewerPath"""
686: return self.ImageViewerPath
687:
688: def getImageStoragePath(self):
689: """get ImageStoragePath"""
690: return self.ImageStoragePath
691:
692: def refreshTxt(self):
693: """txt fuer refresh"""
694: tn=self.REQUEST.SESSION['threadName']
695: return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/createSet",tn)
696:
697: def createSet(self,RESPONSE=None,local=None,version="working",repeat=None):
698: """download aller gewaehlten files"""
699:
700: threadName=repeat
701:
702:
703: if not threadName or threadName=="":
704: threadStart=generateSet(self.REQUEST.SESSION['filenames'],self.REQUEST.SESSION['filenamesIds'],self.ImageViewerPath,self.show_thumbs(),self.absolute_url(),local=local,version=version)
705: thread=Thread(target=threadStart)
706:
707: thread.start()
708:
709:
710: self.zipThreads[thread.getName()[0:]]=threadStart
711: self.zipThreads2[thread.getName()[0:]]=thread
712: self.REQUEST.SESSION['threadName']=thread.getName()[0:]
713: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
714: if wait_template:
715: return wait_template[0][1]()
716: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
717: return pt()
718: #xmltrans.run()
719: else:
720: self.REQUEST.SESSION['threadName']=threadName
721:
722: if (self.zipThreads[threadName].getResult()==None):
723:
724: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
725: if wait_template:
726: return wait_template[0][1]()
727:
728: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
729: return pt()
730: else:
731: if self.zipThreads[threadName].isDone():
732: self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
733: self.zipThreads2[threadName].join()
734: del(self.zipThreads2[threadName])
735: del(self.zipThreads[threadName])
736: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
737: return pt()
738:
739: else:
740: self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
741: self.REQUEST.SESSION['threadName']=threadName
742: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
743: return pt()
744:
745:
746:
747:
748:
749: def checkThreads(self):
750: """teste running threads"""
751: ret="""<html>
752: <head>
753: <meta http-equiv="REFRESH" content="5;url=%s/checkThreads"
754: <body><h2>Threads of %s</h2>"""%(self.absolute_url(),self.getId())
755:
756: for threadName in self.zipThreads.keys():
757: if self.zipThreads2[threadName].isAlive():
758: ret+="<p>%s --> alive</p>"%threadName
759: else:
760: ret+="<p>%s --> dead</p>"%threadName
761: return ret+"</body></html>"
762:
763: def downloadSet(self,fn):
764: """download prepared set"""
765: filename=os.path.join(tdir,fn)
766:
767:
768: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.tgz")
769: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
770: len=os.stat(filename)[6]
771: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
772: images=file(filename).read()
773: self.REQUEST.RESPONSE.write(images)
774: self.REQUEST.RESPONSE.close()
775:
776:
777:
778: def scaleThumbs(self,RESPONSE=None):
779: """scale thumbs"""
780:
781: #scale thumbs
782: 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)
783: if RESPONSE:
784: RESPONSE.write(ret.read())
785: RESPONSE.write("\n")
786:
787: return "RESCALING STARTED"
788:
789: def scaleWorkingVersions(self,RESPONSE=None):
790: """scale working versions"""
791:
792: #scale standard
793:
794: 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)
795: if RESPONSE:
796: RESPONSE.write(ret.read())
797: RESPONSE.write("\n")
798: return "rescaling started"
799:
800:
801:
802: def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,serverPath=genericServerPath):
803: self.id=id
804: self.title=title
805: self.ImageStoragePath=ImageStoragePath
806: self.ImageViewerPath=ImageViewerPath
807: self.defaultMetaString=defaultMetaString
808: self.serverPath=serverPath
809: self.defaultrows = 6
810: self.defaultcols = 2
811:
812: optTMP= Folder.manage_options
813:
814: manage_options = optTMP+(
815: {'label':'Main Config','action':'ImageCollection_config'},
816: {'label':'Import','action':'ImportFiles'},
817: {'label':'Recalculate MetadataLink','action':'recalculateMetaLink'},
818: {'label':'Import Metadata File','action':'importMetaFileForm'},
819: {'label':'Import Metadata','action':'importMetaData'},
820: {'label':'Rescale thumbs','action':'scaleThumbs'},
821: {'label':'Rescale working version','action':'scaleWorkingVersions'},
822: )
823:
824:
825:
826: def importMetaData(self,strict=None):
827: """import metadata, if strict ist not None then only metadata will be rebuild where metadata is empty"""
828:
829: for image in self.ZopeFind(self,obj_metatypes=["ImageDigilib"]):
830:
831: image[1].manageMetaData(strict)
832: return "ok"
833:
834:
835: def importMetaFileForm(self):
836: """import metadata"""
837: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self)
838: return pt()
839:
840: def importMetaFile(self,fileupload,tag):
841: """import"""
842: filedata=fileupload.read()
843: dom=xml.dom.minidom.parseString(filedata)
844: rows=dom.getElementsByTagName(tag)
845: #print "ROWS",rows
846: request=self.REQUEST
847: for row in rows:
848:
849: for a in self.leiden_meta_fields:
850: self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)
851:
852: image_id=self.REQUEST['image_id']
853: if (not hasattr(self,image_id)) & (not image_id==""):
854: #print image_id
855: newObj=ImageCollection(str(image_id),image_id,'','','')
856: self._setObject(str(image_id),newObj)
857:
858: id="leiden_meta_data_file"
859: self.REQUEST['id']=id
860: #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
861: #objectCreate=objectType.createInObjectManager(id,request)
862: #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
863: try:
864: addID=getattr(self,image_id)
865: objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
866: #getattr(self,image_id)._setObject(id,objectCreate)
867: obj=getattr(addID,id)
868: obj.propertysheets.meta.manage_editProperties(request)
869: except:
870: """nothing"""
871: return "OK"
872:
873:
874: def nextImage(self,request,selected=None,returnFn=None):
875: """show nextimage"""
876: try:
877: ids=self.show_thumbs()
878: if request.SESSION.has_key("filename"):
879: filename=request.SESSION["filename"]
880: try:
881: nr=ids.index(filename)
882:
883: except:
884: nr=0
885: else:
886: nr=0
887:
888: if nr==len(ids)-1:
889: return ""
890: else:
891: if returnFn:
892: return ids[nr+1]
893:
894: if selected:
895: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
896: else:
897: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
898: except:
899: return ""
900:
901: def prevImage(self,request,selected=None):
902: """show nextimage"""
903: #return self.getId()
904: try:
905: ids=self.show_thumbs()
906: if request.SESSION.has_key("filename"):
907: filename=request.SESSION["filename"]
908: try:
909: nr=ids.index(filename)
910: except:
911: nr=0
912: else:
913: nr=0
914:
915: if nr==0:
916: return ""
917: else:
918: if selected:
919: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
920: else:
921: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
922: except:
923: return ""
924:
925: def meta_default(self,filename):
926: """url der metadaten"""
927: return self.defaultMetaString % urllib.quote(filename)
928:
929: def getThumbAttribute(self,id,attr):
930: if hasattr(self,id):
931: return getattr(getattr(self,id),attr)
932: else:
933: if attr=='title':
934: return "<b>Missing Image:%s</b>" % id
935:
936: def getThumbFunction(self,id,attr):
937: #return "DUMP"
938: if hasattr(self,id):
939: return getattr(getattr(self,id),attr)()
940:
941:
942: def xmlinput(self,url):
943: """Anzeige von ausgewaehlten thumbs"""
944: #return url
945:
946: url=urllib.unquote(url)
947: xmldoc=urllib.urlopen(url).read()
948: #return xmldoc
949: try:
950: dom=xml.dom.minidom.parseString(xmldoc)
951: except:
952: return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc)
953:
954: images=dom.getElementsByTagName('image')
955:
956: rc=[]
957: fnIds={}
958: for image in images:
959: imagename=image.getElementsByTagName('imagename')[0]
960:
961:
962:
963:
964: idnr=image.getElementsByTagName('idnr')[0]
965: id=getText(idnr.childNodes)
966: try:
967: numberOfPages=image.getElementsByTagName('numberOfPages')[0]
968: except:
969: numberOfPages=None
970:
971: if numberOfPages:
972: nopT=getText(numberOfPages.childNodes)
973: try:
974: nop=int(nopT)
975: except:
976: nop=0
977: else:
978: nop=0
979:
980: texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
981: for text in texts:
982: if not text=="":
983: text=self.getImageByName(text,onlyName="yes")
984: try:
985: rc.append((str(text),id,nop))
986: fnIds[str(text)]=(id,nop)
987: except:
988: rc.append((repr(text),id,nop))
989: fnIds[repr(text)]=(id,nop)
990:
991:
992: rc.sort()
993: self.REQUEST.SESSION['filenames']=rc
994: self.REQUEST.SESSION['filenamesIds']=fnIds
995:
996: overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
997:
998: if overview:
999: return overview[0][1]()
1000: else:
1001: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
1002: return pt()
1003:
1004: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
1005: return pt()
1006:
1007: def recalculateMetaLink(self):
1008: """recalculate the metadata"""
1009:
1010: for entryid in self.__dict__:
1011: entry=getattr(self,entryid)
1012: if hasattr(entry,'meta_type'):
1013:
1014: if entry.meta_type=="ImageDigilib":
1015: entry.meta=entry.meta_default(entry.getId())
1016: return "OK"
1017:
1018: def addImage(self):
1019: """Add an Image"""
1020:
1021: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
1022: return pt()
1023:
1024: def addImage2(self,fileupload,fileName=None,meta=None,use_default=None,RESPONSE=None):
1025: """Add"""
1026:
1027: #print "FU",fileupload
1028:
1029: if use_default:
1030: try:
1031: meta=self.meta_default(fileupload.filename)
1032: except:
1033: meta=None
1034: else:
1035: meta=None
1036:
1037: fn=fileName or splitPath(fileupload.filename)
1038:
1039: manage_AddImageDigilib(self,fn,fileupload,meta=meta)
1040:
1041: if RESPONSE:
1042: return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
1043: #return self.REQUEST['URL1']+'/'+fileupload.filename
1044:
1045: def ImportFiles2(self,RESPONSE=None):
1046: """Import the existing files of a folder"""
1047: files=os.listdir(self.ImageStoragePath)
1048: ret=""
1049: #print self.__dict__
1050: for file in files:
1051: if not file[0]==".":
1052: if self.__dict__.has_key(file):
1053:
1054: ret=ret+"<br>"+file+" already exists!"
1055: else:
1056: ret=ret+"<br>"+file+" created!"
1057: meta=self.meta_default(file)
1058: newObj=ImageDigilib(file,file,meta)
1059: #print newObj,file
1060: #print newObj
1061: self._setObject(file,newObj)
1062: #print ret
1063: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
1064: #print self.ImageStoragePath
1065:
1066: #scale thumb
1067:
1068: self.scaleThumbs()
1069:
1070: #scale standard
1071:
1072: self.scaleWorkingVersions()
1073:
1074:
1075: RESPONSE.redirect('manage_main')
1076:
1077: ## def importStructure(self,path):
1078: ## """import"""
1079: ## splitted=os.path.split(path)
1080: ## if os.path.isDir(path) and (len(splitted[1])>0) and (splitted[1][0]=="."):
1081: ## manage_AddImageCollection(self,splitted[1],splitted[1],path,self.ImageViewerPath,self.defaultMetaString,RESPONSE=None)
1082:
1083: ## obj=getattr(self,splitted[1])
1084: ## obj.ImportFiles()
1085:
1086: def ImportStructure(self,RESPONSE=None):
1087: """Import the existing files of a folder"""
1088: files=os.listdir(self.ImageStoragePath)
1089: ret=""
1090: #print self.__dict__
1091:
1092:
1093: for file in files:
1094:
1095: if os.path.isdir(os.path.join(self.ImageStoragePath,file)):
1096: imageStoragePath=os.path.join(self.ImageStoragePath,file)
1097: imageViewerPath=os.path.join(self.ImageViewerPath,file)
1098: manage_AddImageCollection(self,file,file,imageStoragePath,imageViewerPath,self.defaultMetaString)
1099:
1100: obj=getattr(self,file)
1101: obj.ImportStructure()
1102: else:
1103: if not file[0]==".":
1104: if self.__dict__.has_key(file):
1105:
1106: ret=ret+"<br>"+file+" already exists!"
1107: else:
1108: ret=ret+"<br>"+file+" created!"
1109: newObj=ImageDigilib(file,file)
1110: #print newObj,file
1111: #print newObj
1112: try:
1113: self._setObject(file,newObj)
1114: except:
1115: """nothing yet"""
1116: #print ret
1117: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
1118: #print self.ImageStoragePath
1119:
1120: #scale thumb
1121:
1122: #self.scaleThumbs()
1123:
1124: #scale standard
1125:
1126: #self.scaleWorkingVersions()
1127:
1128: if RESPONSE:
1129: RESPONSE.redirect('manage_main')
1130:
1131: def ImportFiles(self,RESPONSE=None):
1132: """Import the existing files of a folder"""
1133: files=os.listdir(self.ImageStoragePath)
1134: ret=""
1135: #print self.__dict__
1136: for file in files:
1137: if not file[0]==".":
1138: if self.__dict__.has_key(file):
1139:
1140: ret=ret+"<br>"+file+" already exists!"
1141: else:
1142: ret=ret+"<br>"+file+" created!"
1143: newObj=ImageDigilib(file,file)
1144: #print newObj,file
1145: #print newObj
1146: try:
1147: self._setObject(file,newObj)
1148: except:
1149: """nothing yet"""
1150: #print ret
1151: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
1152: #print self.ImageStoragePath
1153:
1154: #scale thumb
1155:
1156: self.scaleThumbs()
1157:
1158: #scale standard
1159:
1160: self.scaleWorkingVersions()
1161:
1162: if RESPONSE:
1163: RESPONSE.redirect('manage_main')
1164:
1165: def ImageCollection_config(self):
1166: """Nothing yet"""
1167: if not hasattr(self,'defaultMetaString'):
1168: self.defaultMetaString=""
1169:
1170: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
1171: return pt()
1172:
1173: def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,serverPath,RESPONSE=None):
1174: """Change"""
1175: self.title=title
1176: self.ImageStoragePath=ImageStoragePath
1177: self.ImageViewerPath=ImageViewerPath
1178: self.defaultMetaString=defaultMetaString
1179: self.serverPath=serverPath
1180:
1181: if RESPONSE is not None:
1182: RESPONSE.redirect('manage_main')
1183:
1184: def show_selected_thumbs(self):
1185: #ids=[]
1186: try:
1187: return self.REQUEST.SESSION['filenames']
1188: except:
1189: return None
1190: def show_thumbs(self):
1191: ids=[]
1192: for entry in self.__dict__:
1193: #print entry
1194: if hasattr(getattr(self,entry),'thumb'):
1195: ids.append(entry)
1196:
1197: #print ids
1198: ids.sort()
1199: return ids
1200:
1201: def firstSets(self,selected=None,text='first set'):
1202: ids=self.show_thumbs()
1203: if ids:
1204: if selected:
1205: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">"+text+"</a>"
1206: else:
1207: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">"+text+"</a>"
1208:
1209: def lastSets(self,selected=None,text='last set'):
1210: ids=self.show_thumbs()
1211: if ids:
1212: colRows=self.getColTimesRow()
1213:
1214: if colRows[1]:
1215: nr=len(ids)-colRows[0]*colRows[1]
1216: else:
1217: nr=0
1218:
1219: if nr<0:
1220: nr=0
1221:
1222: if selected:
1223: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
1224: else:
1225: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
1226:
1227:
1228:
1229: def nextSets(self,selected=None,text='next set'):
1230: """show nextimage"""
1231: ids=self.show_thumbs()
1232: colRows=self.getColTimesRow()
1233: pagesize = colRows[0] * colRows[1]
1234: if ids:
1235: if colRows[1]:
1236: if self.REQUEST.SESSION.has_key("filename"):
1237: filename=self.REQUEST.SESSION["filename"]
1238: try:
1239: nr=ids.index(filename)+pagesize
1240: if nr>=len(ids):
1241: return ""
1242: except:
1243: nr=pagesize
1244: else:
1245: nr = pagesize
1246:
1247: if nr>=len(ids)-1:
1248: return ""
1249: else:
1250: if selected:
1251: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
1252: else:
1253: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
1254:
1255: def prevSets(self,selected=None,text='previous sets'):
1256:
1257: """show nextimage"""
1258: #return self.getId()
1259: ids=self.show_thumbs()
1260: colRows=self.getColTimesRow()
1261: if ids:
1262: if colRows[1]:
1263: if self.REQUEST.SESSION.has_key("filename"):
1264: filename=self.REQUEST.SESSION["filename"]
1265: try:
1266: nr=ids.index(filename)-colRows[0]*colRows[1]
1267: if nr<0:
1268: nr=0
1269: except:
1270: nr=0
1271: else:
1272: nr=0
1273: try:
1274: num=ids.index(filename)
1275: except:
1276: num=0
1277:
1278: if num==0:
1279: return ""
1280: else:
1281: if selected:
1282: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
1283: else:
1284: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
1285: else:
1286: return ""
1287:
1288:
1289: def showFolders(self):
1290: """show subfolders"""
1291: ret=""
1292: link=""" <a target="_top" href="%s">%s</a><br>"""
1293:
1294: if self.aq_parent.meta_type=="ImageCollection":
1295: ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")
1296: ret+="<br>"
1297:
1298: iCs=self.ZopeFind(self,obj_metatypes=["ImageCollection"])
1299: if not iCs:
1300: return ret
1301: else:
1302:
1303: link=""" <a target="_top" href="%s">%s</a><br>"""
1304: for iC in iCs:
1305: ret+=link%(iC[1].absolute_url(),iC[0])
1306: ret+="<br>"
1307: return ret
1308:
1309:
1310: def getSetSelector(self, selected=None):
1311: """returns the HTML select element for the sets"""
1312: actualNr=0
1313: ids=self.show_thumbs()
1314: colRows=self.getColTimesRow()
1315: pagesize = colRows[0]*colRows[1]
1316: numpages = int(len(ids)/pagesize)
1317: if not ((len(ids) % pagesize)==0):
1318: numpages+=1
1319:
1320: ret=""
1321: if numpages>1:
1322: if selected:
1323: ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
1324: else:
1325: ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
1326:
1327: for i in range(numpages):
1328: try:
1329: nr=ids.index(self.REQUEST.SESSION['filename'])
1330: except:
1331: nr=0
1332: k=i * pagesize
1333: if (k <= nr) and (nr < i*(pagesize+1)):
1334: actualNr=i
1335: ret+="""<option value="%s" selected>%i</option>"""%(ids[k], i + 1)
1336: else:
1337: ret+="""<option value="%s">%i</option>"""%(ids[k], i + 1)
1338:
1339: ret+="</select>"
1340:
1341: return ret
1342:
1343: def isAllSets(self, showall=None):
1344: """returns if there are any sets"""
1345: ids=self.show_thumbs()
1346: colRows=self.getColTimesRow(showall=showall)
1347: pagesize = colRows[0]*colRows[1]
1348: return (len(ids) <= pagesize)
1349:
1350:
1351: def allSets(self, texton='show all', textoff='show groups'):
1352: """returns HTML to toggle 'show all'"""
1353: if self.isAllSets(showall='No'):
1354: return ""
1355: showall=self.REQUEST.SESSION.get('showall','no')
1356: if showall=='no':
1357: ret='<a href="'+self.REQUEST['URL1']+'?showall=yes" target="_top">'+texton+'</a>'
1358: else:
1359: ret='<a href="'+self.REQUEST['URL1']+'?showall=no" target="_top">'+textoff+'</a>'
1360: return ret
1361:
1362:
1363: def showRuler(self,selected=None):
1364: """show ruler"""
1365: showall=self.REQUEST.SESSION.get('showall','no')
1366: ids=self.show_thumbs()
1367: if len(ids)==0:
1368: return "<b>No entries</b>"
1369:
1370: if showall=='no':
1371: actualNr=0
1372: ids=self.show_thumbs()
1373: colRows=self.getColTimesRow()
1374: num=int(len(ids)/(colRows[0]*colRows[1]))
1375: if not (operator.mod(len(ids),colRows[0]*colRows[1])==0):
1376: num+=1
1377: a=colRows[0]*colRows[1]
1378: #print num,num+1
1379:
1380: if num>1:
1381:
1382: ret=""
1383: if selected:
1384: ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
1385: else:
1386: ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
1387: for i in range(num):
1388: try:
1389: nr=ids.index(self.REQUEST.SESSION['filename'])
1390: except:
1391: nr=0
1392: k=i*a
1393: if (k <= nr) and (nr < i*(a+1)):
1394: actualNr=i
1395: ret+="""<option value="%s" selected>%i</option>"""%(ids[k],i)
1396: else:
1397: ret+="""<option value="%s">%i</option>"""%(ids[k],i)
1398: ret+="</select>"
1399: anf="<b>Show thumbnail group no: </b></br>"
1400:
1401:
1402: try:
1403: if selected:
1404: href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr-1)*a]
1405: else:
1406: href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr-1)*a)]
1407:
1408: anf+="""<a href="%s" target="_top">%s</a> """%(href,"prev")
1409: except:
1410: pass
1411: ret=anf+ret
1412:
1413: try:
1414:
1415: if selected:
1416: href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr+1)*a]
1417: else:
1418: href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr+1)*a)]
1419:
1420: end="""<a href="%s" target="_top">%s</a> """%(href,"next")
1421: except:
1422: end=""
1423: ret=ret+end
1424:
1425:
1426: #for i in range(num):
1427: #
1428: # ret +="<br/>" #alle 10 linebreak einfuegen
1429: # k=i*a
1430: # if selected:
1431: # href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
1432: # else:
1433: # href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
1434: #
1435: # ret+="""<a href="%s" target="_top">%i</a> """%(href,i)
1436:
1437: else:
1438: ret=""
1439: ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
1440: else:
1441: ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']
1442:
1443: return ret
1444:
1445:
1446: def show_thumbs_selected_rows(self,numberOfColumns):
1447: """Ausgabe anzahl"""
1448: ids=self.show_selected_thumbs()
1449:
1450: if not ids:
1451: return None
1452: self.REQUEST.SESSION['ids']=ids
1453: number=int(len(ids)/numberOfColumns)+1
1454: self.REQUEST.SESSION['number']=range(number)
1455: return range(number+1)
1456:
1457: def setColTimesRowForm(self):
1458: """form for matrix setting"""
1459: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','selectColTimesRow.zpt')).__of__(self)
1460: return pt()
1461:
1462: def setDone(self):
1463: """done"""
1464:
1465: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changedColTimesRow.zpt')).__of__(self)
1466: return pt()
1467:
1468: def setColTimesRow(self,cols,rows):
1469: """set coltimes row"""
1470: RESPONSE=self.REQUEST.RESPONSE
1471: if not rows:
1472: rows=None
1473: if rows=="":
1474: rows=None
1475:
1476: if rows:
1477: RESPONSE.setCookie("ImageViewerRows",rows)
1478: RESPONSE.setCookie("ImageViewerCols",cols)
1479:
1480: RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
1481:
1482: def setDefaultColTimesRow(self, cols, rows):
1483: """sets default columns and rows"""
1484: self.defaultcols = cols
1485: self.defaultrows = rows
1486:
1487: def getColTimesRow(self,showall='No'):
1488: """coltimesrow"""
1489:
1490: REQUEST=self.REQUEST
1491: """matrix"""
1492: if REQUEST.cookies.has_key("ImageViewerRows"):
1493: try:
1494: rows=int(REQUEST.cookies["ImageViewerRows"])
1495: except:
1496: rows=getattr(self,'defaultrows',6)
1497: else:
1498: rows=getattr(self,'defaultrows',6)
1499:
1500: if REQUEST.cookies.has_key("ImageViewerCols"):
1501: #print "COLS",REQUEST.cookies["ImageViewerCols"]
1502: cols=int(REQUEST.cookies["ImageViewerCols"])
1503: else:
1504: cols=getattr(self,'defaultcols',3)
1505:
1506:
1507: idsnumber=len(self.show_thumbs())
1508: if rows:
1509: if cols*rows >idsnumber:
1510: rows=int(idsnumber/cols)+1
1511:
1512: if showall is None:
1513: showall=self.REQUEST.SESSION.get('showall', 'No')
1514: if showall=='yes':
1515: rows=int(idsnumber/cols)+1
1516:
1517: return (cols,rows)
1518:
1519:
1520: def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None,showall="No"):
1521: """Ausgabe anzahl"""
1522:
1523: idsAll=self.show_thumbs()
1524: if len(idsAll)==0: #keine Eintraege
1525: return 0
1526: if self.REQUEST.SESSION.has_key("filename") and not (showall=="yes"):
1527: filename=self.REQUEST.SESSION["filename"]
1528: filename=self.getImageByName(filename,onlyName="yes")
1529:
1530: try:
1531: startId=filename
1532: if startId=="":
1533: startId=idsAll[0][0:]
1534: except:
1535: startId=idsAll[0][0:]
1536: else:
1537: startId=idsAll[0][0:]
1538:
1539:
1540:
1541:
1542: if numberOfRows:
1543:
1544: startPic=idsAll.index(startId)
1545: try:
1546:
1547: startPic=idsAll.index(startId)
1548: endPic=startPic+numberOfColumns*numberOfRows
1549: ids=idsAll[startPic:endPic]
1550: except:
1551: ids=idsAll
1552: else:
1553:
1554: ids=idsAll
1555:
1556:
1557: self.REQUEST.SESSION['ids']=ids
1558: number=int(len(ids)/numberOfColumns)+1
1559:
1560: return range(number+1)
1561:
1562: def show_thumbs_columns(self,row,numberOfColumns):
1563: """Ausgabe einer Liste der Reihe"""
1564: ids=self.REQUEST.SESSION['ids']
1565: max=len(ids)
1566: if (row*numberOfColumns)<max:
1567: return ids[(row-1)*numberOfColumns:row*numberOfColumns]
1568: else:
1569: return ids[(row-1)*numberOfColumns:]
1570:
1571: def thumblistSelected_old(self):
1572: """main template collection"""
1573: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected.zpt')).__of__(self)
1574: return pt()
1575:
1576: def thumblistSelected(self):
1577: """main template collection"""
1578: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected2.zpt')).__of__(self)
1579: return pt()
1580:
1581: def thumblist_old(self):
1582: """main template collection"""
1583: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
1584: return pt()
1585:
1586: def thumblist(self):
1587: """main template collection"""
1588: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb2.zpt')).__of__(self)
1589: return pt()
1590:
1591: def thumblistNewWindow(self):
1592: """Thumbs mit clik neues Fenster oeffnen"""
1593: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbNewWindow.zpt')).__of__(self)
1594: return pt()
1595:
1596:
1597: def navig_selected_html(self):
1598: """navigation"""
1599: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
1600: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)
1601:
1602: return pt().data
1603:
1604: def navig_html(self):
1605: """navigation"""
1606: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
1607:
1608: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation.zpt')).__of__(self)
1609: return pt()
1610:
1611:
1612: def selection(self):
1613: """show only selected"""
1614: if self.REQUEST.has_key('filename'):
1615: filen=self.REQUEST['filename']
1616: else:
1617: filen=""
1618: self.REQUEST.SESSION['filename']=filen
1619: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
1620: return pt()
1621:
1622: def getImageByName(self,filename,onlyName=None):
1623: """get filename"""
1624: print repr(filename)
1625: #FIXME: umlaute in filename
1626: fn=getattr(self,repr(filename),None)
1627: if not fn:
1628: filenameM=filename.split(".")[0]
1629: founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])
1630: for found in founds:
1631: foundM=found[0].split(".")[0]
1632: if filenameM.lower()==foundM.lower():
1633: if onlyName:
1634: return found[0]
1635: else:
1636: return found[1]
1637: if onlyName:
1638: return filename
1639: else:
1640: return fn
1641:
1642:
1643: security.declareProtected('View','index_html')
1644: def index_html(self,fn=None,generic='No'):
1645: """main template collection"""
1646:
1647: if fn:
1648: ret=[]
1649:
1650: if type(fn) is ListType:
1651: """experimentell mehr als ein filename"""
1652: for filename in fn:
1653: if not (filename == ""):
1654: ret.append((filename,'',1))
1655: else:
1656: ret.append((fn,'',1))
1657:
1658: self.REQUEST.SESSION['filenames']=ret
1659: #self.REQUEST.SESSION['filenamesIds']=fnIds
1660:
1661: overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
1662:
1663:
1664: if overview and (generic =='No'):
1665: return overview[0][1]()
1666: else:
1667: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
1668: return pt()
1669:
1670: if self.REQUEST.has_key('filename'):
1671: filen=self.REQUEST['filename']
1672: else:
1673: filen=""
1674:
1675: self.REQUEST.SESSION['filename']=filen[0:]
1676:
1677: if self.REQUEST.has_key('showall'):
1678:
1679: self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
1680: else:
1681: self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
1682:
1683:
1684: overview=self.ZopeFind(self,obj_ids=['overview.html'])
1685: if overview and (generic == 'No'):
1686: return overview[0][1]()
1687: elif hasattr(self,'templates'):
1688: pt=self.templates.imgcoll_main.__of__(self)
1689: return pt()
1690: else:
1691: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
1692: return pt()
1693:
1694: def navigation(self):
1695: """generate navigation bar"""
1696:
1697: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_fragment')).__of__(self)
1698: return pt()
1699:
1700: def manage_AddImageCollectionForm(self):
1701: """Nothing yet"""
1702: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
1703: return pt()
1704:
1705: def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
1706: """Add ImageCollection"""
1707: newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
1708: self._setObject(id,newObj)
1709:
1710: if RESPONSE is not None:
1711: RESPONSE.redirect('manage_main')
1712:
1713:
1714:
1715: class ImageCollectionMD(ImageCollection,ZSQLExtendFolder):
1716: """Imageviewer and Metadata"""
1717: meta_type="ImageCollection MD"
1718: #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn="
1719: scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="
1720: rightsQueryDefault="SELECT accessibility from vision_main where id_image=(SELECT id from vision_images where filename ~ '%s*' )"
1721: rightsQueryFieldDefault="accessibility"
1722:
1723: manage_options=ImageCollection.manage_options+(
1724: {'label':'ZSQLExtend','action':'changeZSQLExtendForm'},
1725: {'label':'Change Rights Query','action':'changeRightsQueryForm'},
1726: )
1727:
1728: try:
1729: changeZSQLExtendForm=ZSQLExtendFolder.changeZSQLExtendForm
1730: except:
1731: pass
1732:
1733:
1734: def addImage(self):
1735: """Add an Image"""
1736:
1737: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImageMD.zpt')).__of__(self)
1738: return pt()
1739:
1740: def addImage2(self,_fileupload,_fileName=None,_meta=None,_use_default=None,RESPONSE=None,**argv):
1741: """Add"""
1742:
1743: filenameKey="filename"
1744: #print "FU",fileupload
1745:
1746: if _use_default:
1747: try:
1748: meta=self.meta_default(_fileupload.filename)
1749: except:
1750: meta=None
1751: else:
1752: meta=None
1753:
1754: fn=_fileName or splitPath(_fileupload.filename)
1755:
1756: manage_AddImageDigilib(self,fn,_fileupload,meta=meta)
1757:
1758: args[key]=_filename
1759:
1760: self.ZSQLAdd(args=argv)
1761:
1762: if RESPONSE:
1763: return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
1764: #return self.REQUEST['URL1']+'/'+fileupload.filename
1765:
1766: def navig_html(self):
1767: """navigation"""
1768: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
1769:
1770: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigationMD.zpt')).__of__(self)
1771: return pt()
1772:
1773: def navig_selected_html(self):
1774: """navigation"""
1775: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
1776: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selectedMD.zpt')).__of__(self)
1777:
1778: return pt()
1779:
1780: def decode(self,str):
1781: """decoder"""
1782: if not str:
1783: return ""
1784: if type(str) is StringType:
1785: try:
1786: return str.decode('utf-8')
1787: except:
1788: return str.decode('latin-1')
1789: else:
1790:
1791: return str
1792:
1793: def standardSearch(self):
1794: """standard search page"""
1795: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','standardSearchPage.zpt')).__of__(self)
1796: return pt()
1797:
1798: def searchResultXML(self):
1799: """xmlformat"""
1800: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultXML.zpt')).__of__(self)
1801: return pt()
1802:
1803: def searchDB(self,REQUEST=None,RESPONSE=None,xml=None):
1804: """search"""
1805: #context.ZSQLFind(_table='vision_main')
1806: urlTmp=REQUEST['URL1']
1807:
1808: url=urlTmp+'/searchResultXML?-table=vision_main&'+REQUEST['QUERY_STRING']
1809:
1810: if xml is None:
1811: RESPONSE.redirect('xmlinput?url='+urllib.quote(url))
1812: else:
1813: RESPONSE.redirect(url)
1814:
1815: def index_html(self,fn=None,selection=None,generic='No',REQUEST=None,RESPONSE=None):
1816: """main template collection"""
1817:
1818:
1819: mode=self.REQUEST.get('mode','view')
1820: if fn:
1821: ret=[]
1822:
1823: if type(fn) is ListType:
1824: """experimentell mehr als ein filename"""
1825: for filename in fn:
1826: if not (filename == ""):
1827: ret.append((filename,'',1))
1828: else:
1829: ret.append((fn,'',1))
1830:
1831: self.REQUEST.SESSION['filenames']=ret
1832: #self.REQUEST.SESSION['filenamesIds']=fnIds
1833:
1834: overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
1835:
1836:
1837: if overview and (generic =='No'):
1838: return overview[0][1]()
1839: else:
1840: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
1841: return pt()
1842:
1843:
1844: # filename given, then only display this file
1845: if self.REQUEST.has_key('filename'):
1846:
1847: filen=self.REQUEST['filename']
1848: else:
1849: filen=""
1850:
1851:
1852: self.REQUEST.SESSION['filename']=filen[0:]
1853:
1854: if not self.REQUEST.SESSION['filename']=="":
1855: url=getattr(self.getImageByName(self.REQUEST.SESSION['filename']),'absolute_url')()
1856: if mode=="view":
1857: self.REQUEST.RESPONSE.redirect(url)
1858: elif mode=="download":
1859: self.REQUEST.RESPONSE.redirect(url+"/download")
1860:
1861: if self.REQUEST.has_key('showall'):
1862:
1863: self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
1864: else:
1865: self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
1866:
1867:
1868: if selection:
1869: #selection i.e. selection already stored at self.REQUEST.SESSION['filenames']
1870: overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
1871:
1872:
1873: if overview and (generic =='No'):#
1874: print "selected"
1875: print repr(overview[0][1])
1876: return overview[0][1]()
1877: else:
1878: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
1879: return pt()
1880:
1881:
1882: #no filename then show overview
1883:
1884: overview=self.ZopeFind(self,obj_ids=['overviewMD.html'])
1885: if overview and (generic == 'No'):
1886:
1887:
1888: return overview[0][1]()
1889: elif hasattr(self,'templates'):
1890:
1891: pt=self.templates.imgcoll_mainMD.__of__(self)
1892: return pt()
1893: else:
1894:
1895: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overviewMD.zpt')).__of__(self)
1896: return pt()
1897:
1898: def nextImage(self,request,selected=None,returnFn=None):
1899: """show nextimage"""
1900:
1901: if not selected and self.REQUEST.has_key('fn'):
1902: imagename=self.REQUEST['fn'].split('/')[-1]
1903: nr=self.getObjectPosition(imagename)
1904:
1905: objects=self.objectIds()
1906: if len(objects)==nr+1:
1907: return ""
1908: else:
1909: fn="/".join(self.REQUEST['fn'].split('/')[0:-1])+"/"+objects[nr+1]
1910: return "<a href=\""+self.REQUEST['URL0']+"?fn="+fn+"\" target=\"_top\">next image</a>"
1911:
1912: def prevImage(self,request,selected=None,returnFn=None):
1913: """show nextimage"""
1914:
1915: if not selected and self.REQUEST.has_key('fn'):
1916: imagename=self.REQUEST['fn'].split('/')[-1]
1917: nr=self.getObjectPosition(imagename)
1918:
1919: objects=self.objectIds()
1920: if nr==0:
1921: return ""
1922: else:
1923: fn="/".join(self.REQUEST['fn'].split('/')[0:-1])+"/"+objects[nr-1]
1924: return "<a href=\""+self.REQUEST['URL0']+"?fn="+fn+"\" target=\"_top\">prev image</a>"
1925:
1926:
1927: def changeRightsQueryForm(self):
1928: """change Rights Query"""
1929: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeRightsQueryForm.zpt')).__of__(self)
1930: return pt()
1931:
1932: def changeRightsQuery(self,rightsQuery,rightsQueryField,RESPONSE=None):
1933: """change Rightsquery"""
1934:
1935: self.rightsQuery=rightsQuery
1936: self.rightsQueryField=rightsQueryField
1937:
1938: if RESPONSE is not None:
1939: RESPONSE.redirect('manage_main')
1940:
1941:
1942:
1943: def getRightsQuery(self):
1944: """get Query"""
1945: return getattr(self,'rightsQuery',self.rightsQueryDefault)
1946:
1947: def getRightsQueryField(self):
1948: """get Query Fiueld"""
1949: return getattr(self,'rightsQueryField',self.rightsQueryFieldDefault)
1950:
1951:
1952:
1953: def setGenericSearchStringForm(self):
1954: """form setze generischen search string fuer MD"""
1955: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','setGenericSearchStringForm.zpt')).__of__(self)
1956: return pt()
1957:
1958: def setGenericSearchString(self,searchString):
1959: """setze generischen search string"""
1960: self.searchString=searchString
1961:
1962: def thumblistMD(self):
1963: """main template collection"""
1964: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbListMD.zpt')).__of__(self)
1965: return pt()
1966:
1967: def getRights(self,id):
1968: """get the rights from a database"""
1969: #print self.rightsQuery%id
1970: results=self.ZSQLSimpleSearch(self.getRightsQuery()%id)
1971: if results:
1972: result = getattr(results[0],self.getRightsQueryField())
1973: else:
1974: result = ''
1975: return result
1976:
1977: def xmlinput(self,url):
1978: """Anzeige von ausgewaehlten thumbs"""
1979: #return url
1980:
1981: url=urllib.unquote(url)
1982: xmldoc=urllib.urlopen(url).read()
1983: #return xmldoc
1984: try:
1985: dom=xml.dom.minidom.parseString(xmldoc)
1986: except:
1987: return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc)
1988:
1989: images=dom.getElementsByTagName('image')
1990:
1991: rc=[]
1992: fnIds={}
1993: for image in images:
1994: imagename=image.getElementsByTagName('imagename')[0]
1995:
1996:
1997:
1998:
1999: idnr=image.getElementsByTagName('idnr')[0]
2000: id=getText(idnr.childNodes)
2001: try:
2002: numberOfPages=image.getElementsByTagName('numberOfPages')[0]
2003: except:
2004: numberOfPages=None
2005:
2006: if numberOfPages:
2007: nopT=getText(numberOfPages.childNodes)
2008: try:
2009: nop=int(nopT)
2010: except:
2011: nop=0
2012: else:
2013: nop=0
2014:
2015: texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
2016: for text in texts:
2017: if not text=="":
2018: text=self.getImageByName(text,onlyName="yes")
2019: try:
2020: rc.append((str(text),id,nop))
2021: fnIds[str(text)]=(id,nop)
2022: except:
2023: rc.append((repr(text),id,nop))
2024: fnIds[repr(text)]=(id,nop)
2025:
2026:
2027: rc.sort()
2028: self.REQUEST.SESSION['filenames']=rc
2029: self.REQUEST.SESSION['filenamesIds']=fnIds
2030:
2031: overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
2032:
2033: if overview:
2034: return overview[0][1]()
2035: else:
2036: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
2037: return pt()
2038:
2039: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
2040: return pt()
2041:
2042: def selection(self):
2043: """show only selected"""
2044: if self.REQUEST.has_key('filename'):
2045: filen=self.REQUEST['filename']
2046: else:
2047: filen=""
2048: self.REQUEST.SESSION['filename']=filen
2049: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
2050: return pt()
2051:
2052: def thumblistSelectedMD(self):
2053: """main template collection"""
2054: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselectedMD.zpt')).__of__(self)
2055: return pt()
2056:
2057: def manage_AddImageCollectionMDForm(self):
2058: """Nothing yet"""
2059: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionFormMD.zpt')).__of__(self)
2060: return pt()
2061:
2062: def manage_AddImageCollectionMD(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
2063: """Add ImageCollection"""
2064: newObj=ImageCollectionMD(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
2065: self._setObject(id,newObj)
2066:
2067: if RESPONSE is not None:
2068: RESPONSE.redirect('manage_main')
2069:
2070:
2071:
2072:
2073: class ImageCollectionIFrame(ImageCollection):
2074: """Class fuer Collection set als IFrame"""
2075:
2076: meta_type="ImageCollectionIFrame"
2077: label=ImageCollection.title
2078:
2079: def getImageTag(self):
2080: """ hack : method needed by echo_content"""
2081: return ""
2082:
2083: def rotate(self,angle,url,RESPONSE):
2084: """rotate"""
2085:
2086: RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
2087: RESPONSE.redirect(url)
2088: def request(self):
2089: """request"""
2090: return self.REQUEST
2091:
2092: def index_html(self):
2093: """index"""
2094: if self.REQUEST.has_key('filename'):
2095: filen=self.REQUEST['filename']
2096: else:
2097: filen=""
2098: self.REQUEST.SESSION['filename']=filen
2099:
2100:
2101: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameMain.zpt')).__of__(self)
2102: return pt()
2103:
2104: def iframe_html(self):
2105: """iframe"""
2106: if self.REQUEST.has_key('filename'):
2107: filen=self.REQUEST['filename']
2108: else:
2109: filen=""
2110: self.REQUEST.response.setCookie('filename',filen)
2111: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameOverview.zpt')).__of__(self)
2112: return pt()
2113:
2114:
2115: def manage_AddImageCollectionIFrameForm(self):
2116: """Nothing yet"""
2117: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionIFrameForm.zpt')).__of__(self)
2118: return pt()
2119:
2120: def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
2121: """Add ImageCollection"""
2122: newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
2123: self._setObject(id,newObj)
2124:
2125: if RESPONSE is not None:
2126: RESPONSE.redirect('manage_main')
2127:
2128:
2129: class ImageZogiLib(ImageDigilib):
2130: """Anzeige Object fuer Bilder ausserhalb von collections
2131: ImageViewerPath und ImageStoragePath und wenn vorhanden Pfad zur Collection
2132: werden zusaetzlich abgespeichert
2133: """
2134: #TODO: scaler path notwendig?
2135: meta_type="ImageZogiLib"
2136:
2137: manage_options=ImageDigilib.manage_options+(
2138: {'label':'Main Config','action':'changeImageZogiLibForm'},
2139: )
2140:
2141: def __init__(self,id,fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath=None,REQUEST=None):
2142: ImageDigilib.__init__(self,id,fn)
2143: self.ImageViewerPath=ImageViewerPath
2144: self.ImageStoragePath=ImageStoragePath
2145: self.ImageCollectionPath=ImageCollectionPath
2146: self.scalerPath=scalerPath
2147:
2148: def changeImageZogiLibForm(self):
2149: """change zogilib Form"""
2150: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeImageZogiLib.zpt')).__of__(self)
2151: return pt()
2152:
2153:
2154: def changeImageZogilib(fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath,REQUEST=None):
2155: """Change it"""
2156: self.ImageViewerPath=ImageViewerPath
2157: self.ImageStoragePath=ImageStoragePath
2158: self.ImageCollectionPath=ImageColectionPath
2159: self.scalerPath=scalerPath
2160:
2161: def manage_AddImageZogiLib(self,id=None,ImageViewerPath=None,ImageStoragePath=None,fileUpload=None,ImageCollectionPath=None,scalerPath=None,libPath=None,caption=None,RESPONSE=None):
2162: """hinzufuegen eineis zogilibImage"""
2163:
2164: if libPath:
2165: splitted=libPath.split("?")
2166: urlSplit=splitted[0].split("/")
2167: params=cgi.parse_qs(splitted[1])
2168: #is LibPath a digilib path?
2169: if urlSplit[-1]=="Scaler":
2170: if type(params['fn']) is ListType:
2171: fnParam=params['fn'][0]
2172: else:
2173: fnParam=params['fn']
2174: fileNameSplit=os.path.split(fnParam)
2175: ImageViewerPath=fileNameSplit[0]
2176: id=fileNameSplit[1]
2177: scalerPath=splitted[0]+"?fn="
2178: else: #assume if not the path is a path to an ImageCollection
2179: if type(params['filename']) is ListType:
2180: id=params['filename'][0]
2181: else:
2182: id=params['filename']
2183:
2184: server=ServerProxy(splitted[0])
2185: ImageCollectionPath=libPath
2186: ImageViewerPath=server.getImageViewerPath()
2187: ImageStoragePath=server.getImageStoragePath()
2188: scalerPath=server.getScalerPath()
2189:
2190:
2191:
2192: if fileUpload:
2193: fn=splitPath(fileUpload.filename)
2194: else:
2195: fn=id
2196:
2197: newObj=ImageZogiLib(id,fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath)
2198:
2199: self._setObject(id,newObj)
2200: getattr(self,id).caption=caption[0:]
2201: if fileUpload:
2202: getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
2203:
2204: if RESPONSE is not None:
2205: RESPONSE.redirect('manage_main')
2206:
2207:
2208: def manage_AddImageZogiLibForm(self):
2209: """to be done"""
2210:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ImageArchive.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ImageArchive