1: from OFS.Folder import Folder
2: from OFS.SimpleItem import SimpleItem
3: from Globals import Persistent,package_home
4: from Acquisition import Implicit
5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
6: from Products.PageTemplates.PageTemplate import PageTemplate
7: import re
8: import os
9: import os.path
10: import urllib
11: import xml.dom.minidom
12: import operator
13: import tempfile
14: import shutil
15:
16: def splitPath(str):
17: str2=str.replace("\\","/")
18: return os.path.split(str2)[1]
19:
20: def getText(nodelist):
21:
22: rc = ""
23: for node in nodelist:
24:
25: if node.nodeType == node.TEXT_NODE:
26: rc = rc + node.data
27: return rc
28:
29:
30: class ImageDigilib(Folder,Persistent,Implicit):
31: """Anzeige object fuer digilib"""
32: meta_type="ImageDigilib"
33:
34: leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
35:
36: manage_options = Folder.manage_options+(
37:
38: {'label':'Add Metadata','action':'addMetaObjectForm'},
39:
40: )
41:
42: def addMetaObject(self,id,RESPONSE=None):
43: """Add an MetaObject"""
44: objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
45:
46: request=self.REQUEST
47: objectCreate=objectType.createObjectManager(id,request)
48:
49: self._setObject(id,objectCreate)
50:
51: objectCreate.propertysheets.meta.manage_editProperties(request)
52:
53: if RESPONSE is not None:
54: RESPONSE.redirect('manage_main')
55:
56:
57:
58:
59: def addMetaObjectForm(self):
60: """Add Form"""
61: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetaObject.zpt')).__of__(self)
62: return pt()
63:
64:
65: def __init__(self,id,filename,meta=None):
66: self.id=id
67: self.title=filename
68: self.filename=filename
69: self.meta=meta
70:
71: def getMeta(self):
72: """ausgabe der metadaten"""
73: return self.meta
74:
75: def uploadImage(self,fileupload,path_name):
76: """upload an Image from an Requast"""
77: #path_name=self.ImageStoragePath
78: fn=splitPath(fileupload.filename)
79: filename=path_name+"/"+fn
80: filedata=fileupload.read()
81: f=open(filename,"w")
82: f.write(filedata)
83: f.close()
84: try:
85: os.chmod(filename,0644)
86: except:
87: """hack"""
88: #scale thumb
89:
90: self.scaleThumbs()
91:
92: #scale standard
93:
94: self.scaleWorkingVersions()
95:
96:
97:
98: def downloadWorkingVersion(self):
99: """download working version (2000 pixel)"""
100:
101: return self.download(fmt="&dw=2000&dh=2000",suffix=".jpg")
102:
103: def download(self,fmt="&mo=rawfile,hires",suffix=None):
104: """download"""
105: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
106:
107: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):
108: filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename
109: else:
110: filename=self.filename
111:
112: if suffix:
113: filename=os.path.splitext(filename)[0]+suffix
114:
115: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
116: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
117: image=urllib.urlopen(path).read()
118: self.REQUEST.RESPONSE.write(image)
119: self.REQUEST.RESPONSE.close()
120: #return self.REQUEST.RESPONSE.redirect(path)
121:
122: def updateImageForm(self):
123: """form"""
124: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self)
125: return pt()
126:
127: def updateImage(self,file,RESPONSE):
128: """lade neues Version des Bildes"""
129: #teste ob Dokumenten ordner schon vorhanden
130: imagePath=os.path.join(self.ImageStoragePath,self.getId())
131: path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")
132: print "path",path
133: if not os.path.exists(path):
134: os.mkdir(path,0775)
135: os.chmod(path,0775)
136:
137: versionNumber=getattr(self,'versionNumber',0)+1
138:
139: #teste ob version schon existiert
140:
141: while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))):
142: versionNumber+=1
143:
144: #kopieren der bestehenden Version in den Versions ordner.
145: imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))
146: os.rename(imagePath,imageNewPath)
147:
148: #lesen des upload files und schreiben
149: filedata=file.read()
150: f=open(imagePath,"w")
151: f.write(filedata)
152: f.close()
153: try:
154: os.chmod(imagePath,0664)
155: except:
156: """hack"""
157: #scale thumb
158:
159: self.scaleThumbs()
160:
161: #scale standard
162:
163: self.scaleWorkingVersions()
164:
165: if RESPONSE:
166: RESPONSE.redirect(self.absolute_url())
167:
168: return "done"
169:
170: def thumb(self):
171: """show thumb"""
172: thumbname=os.path.splitext(self.filename)[0]+".jpg"
173: ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
174: ## image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()
175: ## f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")
176: ## f.write(image)
177: ## f.close()
178: ## os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)
179:
180: #DEVEL:take nausikaa for server solution
181:
182: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
183: #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
184: self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
185: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
186: return pt()
187:
188: def index_html(self):
189: """show image"""
190: #DEVELOP: take first one for server
191:
192: path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
193:
194: #path="http://localhost:8080/mpiwg/online/"+self.ImageViewerPath+"/"+self.filename
195: #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
196: #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt')).__of__(self)
197: return self.REQUEST.RESPONSE.redirect(path)
198:
199:
200: def manage_AddImageDigilibForm(self):
201: """Nothing yet"""
202: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageDigilibForm.zpt')).__of__(self)
203: return pt()
204:
205: def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
206: """Add ImageCollection"""
207: #fileupload=self.REQUEST['fileupload']
208: fn=splitPath(fileupload.filename)
209: newObj=ImageDigilib(id,fn,meta)
210:
211: self._setObject(id,newObj)
212: getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
213:
214: if RESPONSE is not None:
215: RESPONSE.redirect('manage_main')
216:
217:
218: class ImageCollection(Folder, Persistent, Implicit):
219: """Sammelordner für Bilder"""
220: meta_type="ImageCollection"
221:
222: genericMetaDataType="leiden_meta"
223:
224: leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
225:
226:
227: 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
228:
229:
230:
231: def createSet(self,RESPONSE=None,local=None,version="working"):
232: """download aller gewaehlten files"""
233: tempfile.tempdir="/tmp/archivesImageServer"
234:
235: tmpPath=tempfile.mktemp()
236:
237:
238: tmpZip=tempfile.mktemp()+".zip"
239: tmpFn=os.path.split(tmpZip)[1]
240:
241:
242: if not os.path.exists(tempfile.tempdir):
243: os.mkdir(tempfile.tempdir)
244:
245: if not os.path.exists(tmpPath):
246: os.mkdir(tmpPath)
247:
248:
249: if RESPONSE:
250: RESPONSE.setHeader("Content-Type","text/html")
251: RESPONSE.write("<h1>I am creating the download archive</h1>")
252: RESPONSE.write("<h3>1. step: getting the images</h3>")
253:
254: if not self.REQUEST.SESSION.has_key('filenames'):
255: RESPONSE.write("<h2>ERROR</h2>")
256: RESPONSE.write("<p>I forgot, the selected files. Please reselect.\n")
257: return 0
258:
259: for id in self.REQUEST.SESSION['filenames']:
260:
261: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):
262: filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+id[0]
263: else:
264: filename=id[0]
265:
266: if RESPONSE:
267: RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))
268:
269: if local:
270: if version=="working":
271: sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
272: else:
273: sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
274: targetPath=tmpPath+"/"+filename
275: try:
276: shutil.copyfile(sourcePath,targetPath)
277: except:
278: if RESPONSE:
279: RESPONSE.write(str("<p>Error in File: %s (possible missing)<br>\n"%filename))
280: else:
281: """nothing"""
282: else:
283: if version=="working":
284: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
285: else:
286: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
287: image=urllib.urlopen(path).read()
288:
289:
290: fh=file(tmpPath+"/"+filename,"w")
291:
292:
293: fh.write(image)
294: fh.close()
295:
296: #folgeseiten
297: if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:
298: ids=self.show_thumbs()
299: nr=ids.index(id[0])
300:
301: numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]
302: for k in range(int(numberOfPages)-1):
303: i=k+1
304: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):
305: filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+ids[nr+i]
306: else:
307: filename=id[0]
308:
309: if RESPONSE:
310: RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))
311:
312: if local:
313: sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+ids[nr+1]
314: targetPath=tmpPath+"/"+filename
315: try:
316: shutil.copyfile(sourcePath,targetPath)
317: except:
318: if RESPONSE:
319: RESPONSE.write(str("<p>Error in File: %s (missing?)<br>\n"%filename))
320: else:
321: """nothing"""
322: else:
323: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
324:
325: image=urllib.urlopen(path).read()
326:
327:
328: fh=file(tmpPath+"/"+filename,"w")
329: fh.write(image)
330: fh.close()
331:
332: if RESPONSE:
333: RESPONSE.write("<h3>2. step: creating the downloadable file</h3>")
334: RESPONSE.write("<p>Create Zip<br>")
335: RESPONSE.write("<p>This can take a while....<br>\n")
336: if RESPONSE:
337: fh=os.popen2("zip -u %s %s/*"%(tmpZip,tmpPath),1)[1]
338: RESPONSE.write("<br>")
339: for c in fh.read():
340: RESPONSE.write(c)
341:
342: if c==")":
343: RESPONSE.write("<br>\n")
344:
345:
346: else:
347: os.popen("zip -u %s %s/*"%(tmpZip,tmpPath))
348:
349:
350: shutil.rmtree(tmpPath)
351:
352: if RESPONSE:
353: RESPONSE.write("<p>finished<br>\n")
354:
355: if RESPONSE:
356: len=os.stat(tmpZip)[6]
357: downloadUrl=self.absolute_url()+"/downloadSet"
358: RESPONSE.write("""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
359: RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
360: <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
361: RESPONSE.close()
362:
363: def downloadSet(self,fn):
364: """download prepared set"""
365: filename="/tmp/archivesImageServer/"+fn
366:
367: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.zip")
368: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
369: len=os.stat(filename)[6]
370: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
371: images=file(filename).read()
372: self.REQUEST.RESPONSE.write(images)
373: self.REQUEST.RESPONSE.close()
374:
375:
376:
377: def scaleThumbs(self,RESPONSE=None):
378: """scale thumbs"""
379:
380: #scale thumbs
381: 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)
382: if RESPONSE:
383: RESPONSE.write(ret.read())
384: RESPONSE.write("\n")
385:
386: return "RESCALING STARTED"
387:
388: def scaleWorkingVersions(self,RESPONSE=None):
389: """scale working versions"""
390:
391: #scale standard
392:
393: 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)
394: if RESPONSE:
395: RESPONSE.write(ret.read())
396: RESPONSE.write("\n")
397: return "rescaling started"
398:
399:
400:
401: def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString):
402: self.id=id
403: self.title=title
404: self.ImageStoragePath=ImageStoragePath
405: self.ImageViewerPath=ImageViewerPath
406: self.defaultMetaString=defaultMetaString
407:
408: manage_options = Folder.manage_options+(
409: {'label':'Main Config','action':'ImageCollection_config'},
410: {'label':'Import','action':'ImportFiles'},
411: {'label':'Recalculate Metadata','action':'recalculateMeta'},
412: {'label':'Import Metadata','action':'importMetaForm'},
413: {'label':'Rescale thumbs','action':'scaleThumbs'},
414: {'label':'Rescale working version','action':'scaleWorkingVersions'},
415: {'label':'Weight (ECHO)','action':'weightForm'},
416: )
417:
418: def weightForm(self):
419: """Weight"""
420: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeWeight.zpt')).__of__(self)
421: return pt()
422:
423: def changeWeight(self,weight,RESPONSE=None):
424: """Change weight"""
425: self.weight=weight
426:
427: if RESPONSE is not None:
428: RESPONSE.redirect('manage_main')
429:
430:
431: def importMetaForm(self):
432: """import metadata"""
433: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self)
434: return pt()
435:
436: def importMeta(self,fileupload,tag):
437: """import"""
438: filedata=fileupload.read()
439: dom=xml.dom.minidom.parseString(filedata)
440: rows=dom.getElementsByTagName(tag)
441: #print "ROWS",rows
442: request=self.REQUEST
443: for row in rows:
444:
445: for a in self.leiden_meta_fields:
446: self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)
447:
448: image_id=self.REQUEST['image_id']
449: if (not hasattr(self,image_id)) & (not image_id==""):
450: #print image_id
451: newObj=ImageCollection(str(image_id),image_id,'','','')
452: self._setObject(str(image_id),newObj)
453:
454: id="leiden_meta_data_file"
455: self.REQUEST['id']=id
456: #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
457: #objectCreate=objectType.createInObjectManager(id,request)
458: #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
459: try:
460: addID=getattr(self,image_id)
461: objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
462: #getattr(self,image_id)._setObject(id,objectCreate)
463: obj=getattr(addID,id)
464: obj.propertysheets.meta.manage_editProperties(request)
465: except:
466: """nothing"""
467: return "OK"
468:
469:
470: def nextImage(self,request,selected=None,returnFn=None):
471: """show nextimage"""
472: try:
473: ids=self.show_thumbs()
474: if request.SESSION.has_key("filename"):
475: filename=request.SESSION["filename"]
476: try:
477: nr=ids.index(filename)
478:
479: except:
480: nr=0
481: else:
482: nr=0
483:
484: if nr==len(ids)-1:
485: return ""
486: else:
487: if returnFn:
488: return ids[nr+1]
489:
490: if selected:
491: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
492: else:
493: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
494: except:
495: return ""
496:
497: def prevImage(self,request,selected=None):
498: """show nextimage"""
499: #return self.getId()
500: try:
501: ids=self.show_thumbs()
502: if request.SESSION.has_key("filename"):
503: filename=request.SESSION["filename"]
504: try:
505: nr=ids.index(filename)
506: except:
507: nr=0
508: else:
509: nr=0
510:
511: if nr==0:
512: return ""
513: else:
514: if selected:
515: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
516: else:
517: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
518: except:
519: return ""
520:
521: def meta_default(self,filename):
522: """url der metadaten"""
523: return self.defaultMetaString % filename
524:
525: def getThumbAttribute(self,id,attr):
526: if hasattr(self,id):
527: return getattr(getattr(self,id),attr)
528: else:
529: if attr=='title':
530: return "<b>Missing Image:%s</b>" % id
531:
532: def getThumbFunction(self,id,attr):
533: #return "DUMP"
534: if hasattr(self,id):
535: return getattr(getattr(self,id),attr)()
536:
537:
538: def xmlinput(self,url):
539: """Anzeige von ausgewaehlten thumbs"""
540: #return url
541:
542: url=urllib.unquote(url)
543: xmldoc=urllib.urlopen(url).read()
544: #print url
545: try:
546: dom=xml.dom.minidom.parseString(xmldoc)
547: except:
548: return xmldoc
549: images=dom.getElementsByTagName('image')
550:
551: rc=[]
552: fnIds={}
553: for image in images:
554: imagename=image.getElementsByTagName('imagename')[0]
555: text=getText(imagename.childNodes)
556: idnr=image.getElementsByTagName('idnr')[0]
557: id=getText(idnr.childNodes)
558: numberOfPages=image.getElementsByTagName('numberOfPages')[0]
559: nopT=getText(numberOfPages.childNodes)
560: try:
561: nop=int(nopT)
562: except:
563: nop=0
564: if not text=="":
565: try:
566: rc.append((str(text),id,nop))
567: fnIds[str(text)]=(id,nop)
568: except:
569: rc.append((repr(text),id,nop))
570: fnIds[repr(text)]=(id,nop)
571:
572: rc.sort()
573: self.REQUEST.SESSION['filenames']=rc
574: self.REQUEST.SESSION['filenamesIds']=fnIds
575:
576: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
577: return pt()
578:
579: def recalculateMeta(self):
580: """recalculate the metadata"""
581:
582: for entryid in self.__dict__:
583: entry=getattr(self,entryid)
584: if hasattr(entry,'meta_type'):
585:
586: if entry.meta_type=="ImageDigilib":
587: entry.meta=entry.meta_default(entry.getId())
588: return "OK"
589:
590: def addImage(self):
591: """Add an Image"""
592: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
593: return pt()
594:
595: def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
596: """Add"""
597: #print "FU",fileupload
598:
599: if use_default:
600: try:
601: meta=self.meta_default(fileupload.filename)
602: except:
603: meta=None
604: else:
605: meta=None
606: fn=splitPath(fileupload.filename)
607:
608: manage_AddImageDigilib(self,fn,fileupload,meta=meta)
609: return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
610: #return self.REQUEST['URL1']+'/'+fileupload.filename
611:
612: def ImportFiles2(self,RESPONSE=None):
613: """Import the existing files of a folder"""
614: files=os.listdir(self.ImageStoragePath)
615: ret=""
616: #print self.__dict__
617: for file in files:
618: if not file[0]==".":
619: if self.__dict__.has_key(file):
620:
621: ret=ret+"<br>"+file+" already exists!"
622: else:
623: ret=ret+"<br>"+file+" created!"
624: meta=self.meta_default(file)
625: newObj=ImageDigilib(file,file,meta)
626: #print newObj,file
627: #print newObj
628: self._setObject(file,newObj)
629: #print ret
630: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
631: #print self.ImageStoragePath
632:
633: #scale thumb
634:
635: self.scaleThumbs()
636:
637: #scale standard
638:
639: self.scaleWorkingVersions()
640:
641:
642: RESPONSE.redirect('manage_main')
643:
644: def ImportFiles(self,RESPONSE=None):
645: """Import the existing files of a folder"""
646: files=os.listdir(self.ImageStoragePath)
647: ret=""
648: #print self.__dict__
649: for file in files:
650: if not file[0]==".":
651: if self.__dict__.has_key(file):
652:
653: ret=ret+"<br>"+file+" already exists!"
654: else:
655: ret=ret+"<br>"+file+" created!"
656: newObj=ImageDigilib(file,file)
657: #print newObj,file
658: #print newObj
659: try:
660: self._setObject(file,newObj)
661: except:
662: """nothing yet"""
663: #print ret
664: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
665: #print self.ImageStoragePath
666:
667: #scale thumb
668:
669: self.scaleThumbs()
670:
671: #scale standard
672:
673: self.scaleWorkingVersions()
674:
675: if RESPONSE:
676: RESPONSE.redirect('manage_main')
677:
678: def ImageCollection_config(self):
679: """Nothing yet"""
680: if not hasattr(self,'defaultMetaString'):
681: self.defaultMetaString=""
682:
683: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
684: return pt()
685:
686: def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
687: """Change"""
688: self.title=title
689: self.ImageStoragePath=ImageStoragePath
690: self.ImageViewerPath=ImageViewerPath
691: self.defaultMetaString=defaultMetaString
692:
693: if RESPONSE is not None:
694: RESPONSE.redirect('manage_main')
695:
696: def show_selected_thumbs(self):
697: #ids=[]
698:
699: return self.REQUEST.SESSION['filenames']
700:
701: def show_thumbs(self):
702: ids=[]
703: for entry in self.__dict__:
704: #print entry
705: if hasattr(getattr(self,entry),'thumb'):
706: ids.append(entry)
707:
708: #print ids
709: ids.sort()
710: return ids
711:
712: def firstSets(self,selected=None):
713: ids=self.show_thumbs()
714: if ids:
715: if selected:
716: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
717: else:
718: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
719:
720: def lastSets(self,selected=None):
721: ids=self.show_thumbs()
722: if ids:
723: colRows=self.getColTimesRow()
724:
725: if colRows[1]:
726: nr=len(ids)-colRows[0]*colRows[1]
727: else:
728: nr=0
729:
730: if nr<0:
731: nr=0
732:
733: if selected:
734: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"
735: else:
736: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"
737:
738:
739:
740: def nextSets(self,selected=None):
741: """show nextimage"""
742: ids=self.show_thumbs()
743: colRows=self.getColTimesRow()
744: if ids:
745: if colRows[1]:
746:
747: if self.REQUEST.SESSION.has_key("filename"):
748: filename=self.REQUEST.SESSION["filename"]
749: try:
750: nr=ids.index(filename)+colRows[0]*colRows[1]
751: if nr>=len(ids):
752: nr=len(ids)-1
753: except:
754: nr=0
755: else:
756: nr=0
757:
758: if nr==len(ids)-1:
759: return ""
760: else:
761: if selected:
762: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
763: else:
764: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
765:
766: def prevSets(self,selected=None):
767:
768: """show nextimage"""
769: #return self.getId()
770: ids=self.show_thumbs()
771: colRows=self.getColTimesRow()
772: if ids:
773: if colRows[1]:
774: if self.REQUEST.SESSION.has_key("filename"):
775: filename=self.REQUEST.SESSION["filename"]
776: try:
777: nr=ids.index(filename)-colRows[0]*colRows[1]
778: if nr<0:
779: nr=0
780: except:
781: nr=0
782: else:
783: nr=0
784: try:
785: num=ids.index(filename)
786: except:
787: num=0
788:
789: if num==0:
790: return ""
791: else:
792: if selected:
793: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
794: else:
795: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
796: else:
797: return ""
798:
799: def showRuler(self,selected=None):
800: """show ruler"""
801: showall =self.REQUEST.SESSION.get('showall','no')
802: ids=self.show_thumbs()
803: if len(ids)==0:
804: return "<b>No entries</b>"
805:
806: if showall=='no':
807: ids=self.show_thumbs()
808: colRows=self.getColTimesRow()
809: num=int(len(ids)/(colRows[0]*colRows[1]))
810: if not (operator.mod(len(ids),colRows[0]*colRows[1])==0):
811: num+=1
812: a=colRows[0]*colRows[1]
813: #print num,num+1
814: if num>1:
815:
816: ret="<b>Show thumbnail group no:</b></br>"
817: for i in range(num):
818: if (operator.mod(i,10)==0) and i>0:
819: ret +="<br/>" #alle 10 linebreak einfuegen
820: k=i*a
821: if selected:
822: href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
823: else:
824: href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
825:
826: ret+="""<a href="%s" target="_top">%i</a> """%(href,i)
827:
828: else:
829: ret=""
830: ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
831: else:
832: ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']
833:
834: return ret
835:
836: def show_thumbs_selected_rows(self,numberOfColumns):
837: """Ausgabe anzahl"""
838: ids=self.show_selected_thumbs()
839: self.REQUEST.SESSION['ids']=ids
840: number=int(len(ids)/numberOfColumns)+1
841: self.REQUEST.SESSION['number']=range(number)
842: return range(number+1)
843:
844: def setColTimesRowForm(self):
845: """form for matrix setting"""
846: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','selectColTimesRow.zpt')).__of__(self)
847: return pt()
848:
849: def setDone(self):
850: """done"""
851:
852: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changedColTimesRow.zpt')).__of__(self)
853: return pt()
854:
855: def setColTimesRow(self,cols,rows):
856: """set coltimes row"""
857: RESPONSE=self.REQUEST.RESPONSE
858: if not rows:
859: rows=None
860: if rows=="":
861: rows=None
862:
863: if rows:
864: RESPONSE.setCookie("ImageViewerRows",rows)
865: RESPONSE.setCookie("ImageViewerCols",cols)
866:
867: RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
868:
869: def getColTimesRow(self,showall='No'):
870: """coltimesrow"""
871:
872: REQUEST=self.REQUEST
873: """matrix"""
874: if REQUEST.cookies.has_key("ImageViewerRows"):
875:
876: try:
877: rows=int(REQUEST.cookies["ImageViewerRows"])
878: except:
879: rows=6
880: else:
881: rows=6
882:
883: if REQUEST.cookies.has_key("ImageViewerCols"):
884: #print "COLS",REQUEST.cookies["ImageViewerCols"]
885: cols=int(REQUEST.cookies["ImageViewerCols"])
886: else:
887: cols=2
888:
889: idsnumber=len(self.show_thumbs())
890: if rows:
891: if cols*rows >idsnumber:
892: rows=int(idsnumber/cols)+1
893:
894: #print cols,rows
895: if showall=='yes':
896: rows=int(idsnumber/cols)+1
897:
898: return (cols,rows)
899:
900:
901: def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
902: """Ausgabe anzahl"""
903:
904: idsAll=self.show_thumbs()
905: if len(idsAll)==0: #keine Einträge
906: return 0
907: if self.REQUEST.SESSION.has_key("filename"):
908: filename=self.REQUEST.SESSION["filename"]
909:
910:
911: try:
912: startId=filename
913: if startId=="":
914: startId=idsAll[0][0:]
915: except:
916: startId=idsAll[0][0:]
917: else:
918: startId=idsAll[0][0:]
919:
920:
921:
922:
923: if numberOfRows:
924:
925: startPic=idsAll.index(startId)
926: try:
927:
928: startPic=idsAll.index(startId)
929: endPic=startPic+numberOfColumns*numberOfRows
930: ids=idsAll[startPic:endPic]
931: except:
932: ids=idsAll
933: else:
934:
935: ids=idsAll
936:
937:
938: self.REQUEST.SESSION['ids']=ids
939: number=int(len(ids)/numberOfColumns)+1
940:
941: return range(number+1)
942:
943: def show_thumbs_columns(self,row,numberOfColumns):
944: """Ausgabe einer Liste der Reihe"""
945: ids=self.REQUEST.SESSION['ids']
946: max=len(ids)
947: if (row*numberOfColumns)<max:
948: return ids[(row-1)*numberOfColumns:row*numberOfColumns]
949: else:
950: return ids[(row-1)*numberOfColumns:]
951:
952: def thumblistSelected_old(self):
953: """main template collection"""
954: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected.zpt')).__of__(self)
955: return pt()
956:
957: def thumblistSelected(self):
958: """main template collection"""
959: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected2.zpt')).__of__(self)
960: return pt()
961:
962: def thumblist_old(self):
963: """main template collection"""
964: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
965: return pt()
966:
967: def thumblist(self):
968: """main template collection"""
969: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb2.zpt')).__of__(self)
970: return pt()
971:
972: def thumblistNewWindow(self):
973: """Thumbs mit clik neues Fenster oeffnen"""
974: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbNewWindow.zpt')).__of__(self)
975: return pt()
976:
977:
978: def navig_selected_html(self):
979: """navigation"""
980: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
981: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)
982: return pt()
983:
984: def navig_html(self):
985: """navigation"""
986: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
987: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation.zpt')).__of__(self)
988: return pt()
989:
990:
991: def selection(self):
992: """show only selected"""
993: if self.REQUEST.has_key('filename'):
994: filen=self.REQUEST['filename']
995: else:
996: filen=""
997: self.REQUEST.SESSION['filename']=filen
998: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
999: return pt()
1000:
1001: def index_html(self):
1002: """main template collection"""
1003: if self.REQUEST.has_key('filename'):
1004: filen=self.REQUEST['filename']
1005: else:
1006: filen=""
1007:
1008: self.REQUEST.SESSION['filename']=filen
1009:
1010: if self.REQUEST.has_key('showall'):
1011:
1012: self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
1013: else:
1014: self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
1015:
1016:
1017: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
1018: return pt()
1019:
1020: def manage_AddImageCollectionForm(self):
1021: """Nothing yet"""
1022: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
1023: return pt()
1024:
1025: def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
1026: """Add ImageCollection"""
1027: newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
1028: self._setObject(id,newObj)
1029:
1030: if RESPONSE is not None:
1031: RESPONSE.redirect('manage_main')
1032:
1033:
1034: class ImageCollectionIFrame(ImageCollection):
1035: """Class fuer Collection set als IFrame"""
1036:
1037: meta_type="ImageCollectionIFrame"
1038: label=ImageCollection.title
1039:
1040: def getImageTag(self):
1041: """ hack : method needed by echo_content"""
1042: return ""
1043:
1044: def rotate(self,angle,url,RESPONSE):
1045: """rotate"""
1046:
1047: RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
1048: RESPONSE.redirect(url)
1049: def request(self):
1050: """request"""
1051: return self.REQUEST
1052:
1053: def index_html(self):
1054: """index"""
1055: if self.REQUEST.has_key('filename'):
1056: filen=self.REQUEST['filename']
1057: else:
1058: filen=""
1059: self.REQUEST.SESSION['filename']=filen
1060:
1061:
1062: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameMain.zpt')).__of__(self)
1063: return pt()
1064:
1065: def iframe_html(self):
1066: """iframe"""
1067: if self.REQUEST.has_key('filename'):
1068: filen=self.REQUEST['filename']
1069: else:
1070: filen=""
1071: self.REQUEST.response.setCookie('filename',filen)
1072: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameOverview.zpt')).__of__(self)
1073: return pt()
1074:
1075:
1076: def manage_AddImageCollectionIFrameForm(self):
1077: """Nothing yet"""
1078: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionIFrameForm.zpt')).__of__(self)
1079: return pt()
1080:
1081: def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
1082: """Add ImageCollection"""
1083: newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
1084: self._setObject(id,newObj)
1085:
1086: if RESPONSE is not None:
1087: RESPONSE.redirect('manage_main')
1088:
1089:
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