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