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