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