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+"/"+id[0]
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: rc.append((str(text),id,nop))
566: fnIds[str(text)]=(id,nop)
567: rc.sort()
568: self.REQUEST.SESSION['filenames']=rc
569: self.REQUEST.SESSION['filenamesIds']=fnIds
570:
571: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
572: return pt()
573:
574: def recalculateMeta(self):
575: """recalculate the metadata"""
576:
577: for entryid in self.__dict__:
578: entry=getattr(self,entryid)
579: if hasattr(entry,'meta_type'):
580:
581: if entry.meta_type=="ImageDigilib":
582: entry.meta=entry.meta_default(entry.getId())
583: return "OK"
584:
585: def addImage(self):
586: """Add an Image"""
587: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
588: return pt()
589:
590: def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
591: """Add"""
592: #print "FU",fileupload
593:
594: if use_default:
595: try:
596: meta=self.meta_default(fileupload.filename)
597: except:
598: meta=None
599: else:
600: meta=None
601: fn=splitPath(fileupload.filename)
602:
603: manage_AddImageDigilib(self,fn,fileupload,meta=meta)
604: return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
605: #return self.REQUEST['URL1']+'/'+fileupload.filename
606:
607: def ImportFiles2(self,RESPONSE=None):
608: """Import the existing files of a folder"""
609: files=os.listdir(self.ImageStoragePath)
610: ret=""
611: #print self.__dict__
612: for file in files:
613: if not file[0]==".":
614: if self.__dict__.has_key(file):
615:
616: ret=ret+"<br>"+file+" already exists!"
617: else:
618: ret=ret+"<br>"+file+" created!"
619: meta=self.meta_default(file)
620: newObj=ImageDigilib(file,file,meta)
621: #print newObj,file
622: #print newObj
623: self._setObject(file,newObj)
624: #print ret
625: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
626: #print self.ImageStoragePath
627:
628: #scale thumb
629:
630: self.scaleThumbs()
631:
632: #scale standard
633:
634: self.scaleWorkingVersions()
635:
636:
637: RESPONSE.redirect('manage_main')
638:
639: def ImportFiles(self,RESPONSE=None):
640: """Import the existing files of a folder"""
641: files=os.listdir(self.ImageStoragePath)
642: ret=""
643: #print self.__dict__
644: for file in files:
645: if not file[0]==".":
646: if self.__dict__.has_key(file):
647:
648: ret=ret+"<br>"+file+" already exists!"
649: else:
650: ret=ret+"<br>"+file+" created!"
651: newObj=ImageDigilib(file,file)
652: #print newObj,file
653: #print newObj
654: try:
655: self._setObject(file,newObj)
656: except:
657: """nothing yet"""
658: #print ret
659: #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
660: #print self.ImageStoragePath
661:
662: #scale thumb
663:
664: self.scaleThumbs()
665:
666: #scale standard
667:
668: self.scaleWorkingVersions()
669:
670: if RESPONSE:
671: RESPONSE.redirect('manage_main')
672:
673: def ImageCollection_config(self):
674: """Nothing yet"""
675: if not hasattr(self,'defaultMetaString'):
676: self.defaultMetaString=""
677:
678: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
679: return pt()
680:
681: def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
682: """Change"""
683: self.title=title
684: self.ImageStoragePath=ImageStoragePath
685: self.ImageViewerPath=ImageViewerPath
686: self.defaultMetaString=defaultMetaString
687:
688: if RESPONSE is not None:
689: RESPONSE.redirect('manage_main')
690:
691: def show_selected_thumbs(self):
692: #ids=[]
693:
694: return self.REQUEST.SESSION['filenames']
695:
696: def show_thumbs(self):
697: ids=[]
698: for entry in self.__dict__:
699: #print entry
700: if hasattr(getattr(self,entry),'thumb'):
701: ids.append(entry)
702:
703: #print ids
704: ids.sort()
705: return ids
706:
707: def firstSets(self,selected=None):
708: ids=self.show_thumbs()
709: if ids:
710: if selected:
711: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
712: else:
713: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
714:
715: def lastSets(self,selected=None):
716: ids=self.show_thumbs()
717: if ids:
718: colRows=self.getColTimesRow()
719:
720: if colRows[1]:
721: nr=len(ids)-colRows[0]*colRows[1]
722: else:
723: nr=0
724:
725: if nr<0:
726: nr=0
727:
728: if selected:
729: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"
730: else:
731: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"
732:
733:
734:
735: def nextSets(self,selected=None):
736: """show nextimage"""
737: ids=self.show_thumbs()
738: colRows=self.getColTimesRow()
739: if ids:
740: if colRows[1]:
741:
742: if self.REQUEST.SESSION.has_key("filename"):
743: filename=self.REQUEST.SESSION["filename"]
744: try:
745: nr=ids.index(filename)+colRows[0]*colRows[1]
746: if nr>=len(ids):
747: nr=len(ids)-1
748: except:
749: nr=0
750: else:
751: nr=0
752:
753: if nr==len(ids)-1:
754: return ""
755: else:
756: if selected:
757: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
758: else:
759: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
760:
761: def prevSets(self,selected=None):
762:
763: """show nextimage"""
764: #return self.getId()
765: ids=self.show_thumbs()
766: colRows=self.getColTimesRow()
767: if ids:
768: if colRows[1]:
769: if self.REQUEST.SESSION.has_key("filename"):
770: filename=self.REQUEST.SESSION["filename"]
771: try:
772: nr=ids.index(filename)-colRows[0]*colRows[1]
773: if nr<0:
774: nr=0
775: except:
776: nr=0
777: else:
778: nr=0
779: try:
780: num=ids.index(filename)
781: except:
782: num=0
783:
784: if num==0:
785: return ""
786: else:
787: if selected:
788: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
789: else:
790: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
791: else:
792: return ""
793:
794: def showRuler(self,selected=None):
795: """show ruler"""
796: showall =self.REQUEST.SESSION.get('showall','no')
797: ids=self.show_thumbs()
798: if len(ids)==0:
799: return "<b>No entries</b>"
800:
801: if showall=='no':
802: ids=self.show_thumbs()
803: colRows=self.getColTimesRow()
804: num=int(len(ids)/(colRows[0]*colRows[1]))
805: if not (operator.mod(len(ids),colRows[0]*colRows[1])==0):
806: num+=1
807: a=colRows[0]*colRows[1]
808: #print num,num+1
809: if num>1:
810:
811: ret="<b>Show thumbnail group no:</b></br>"
812: for i in range(num):
813: if (operator.mod(i,10)==0) and i>0:
814: ret +="<br/>" #alle 10 linebreak einfuegen
815: k=i*a
816: if selected:
817: href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
818: else:
819: href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
820:
821: ret+="""<a href="%s" target="_top">%i</a> """%(href,i)
822:
823: else:
824: ret=""
825: ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
826: else:
827: ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']
828:
829: return ret
830:
831: def show_thumbs_selected_rows(self,numberOfColumns):
832: """Ausgabe anzahl"""
833: ids=self.show_selected_thumbs()
834: self.REQUEST.SESSION['ids']=ids
835: number=int(len(ids)/numberOfColumns)+1
836: self.REQUEST.SESSION['number']=range(number)
837: return range(number+1)
838:
839: def setColTimesRowForm(self):
840: """form for matrix setting"""
841: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','selectColTimesRow.zpt')).__of__(self)
842: return pt()
843:
844: def setDone(self):
845: """done"""
846:
847: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changedColTimesRow.zpt')).__of__(self)
848: return pt()
849:
850: def setColTimesRow(self,cols,rows):
851: """set coltimes row"""
852: RESPONSE=self.REQUEST.RESPONSE
853: if not rows:
854: rows=None
855: if rows=="":
856: rows=None
857:
858: if rows:
859: RESPONSE.setCookie("ImageViewerRows",rows)
860: RESPONSE.setCookie("ImageViewerCols",cols)
861:
862: RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
863:
864: def getColTimesRow(self,showall='No'):
865: """coltimesrow"""
866:
867: REQUEST=self.REQUEST
868: """matrix"""
869: if REQUEST.cookies.has_key("ImageViewerRows"):
870:
871: try:
872: rows=int(REQUEST.cookies["ImageViewerRows"])
873: except:
874: rows=6
875: else:
876: rows=6
877:
878: if REQUEST.cookies.has_key("ImageViewerCols"):
879: #print "COLS",REQUEST.cookies["ImageViewerCols"]
880: cols=int(REQUEST.cookies["ImageViewerCols"])
881: else:
882: cols=2
883:
884: idsnumber=len(self.show_thumbs())
885: if rows:
886: if cols*rows >idsnumber:
887: rows=int(idsnumber/cols)+1
888:
889: #print cols,rows
890: if showall=='yes':
891: rows=int(idsnumber/cols)+1
892:
893: return (cols,rows)
894:
895:
896: def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
897: """Ausgabe anzahl"""
898:
899: idsAll=self.show_thumbs()
900: if len(idsAll)==0: #keine Einträge
901: return 0
902: if self.REQUEST.SESSION.has_key("filename"):
903: filename=self.REQUEST.SESSION["filename"]
904:
905:
906: try:
907: startId=filename
908: if startId=="":
909: startId=idsAll[0][0:]
910: except:
911: startId=idsAll[0][0:]
912: else:
913: startId=idsAll[0][0:]
914:
915:
916:
917:
918: if numberOfRows:
919:
920: startPic=idsAll.index(startId)
921: try:
922:
923: startPic=idsAll.index(startId)
924: endPic=startPic+numberOfColumns*numberOfRows
925: ids=idsAll[startPic:endPic]
926: except:
927: ids=idsAll
928: else:
929:
930: ids=idsAll
931:
932:
933: self.REQUEST.SESSION['ids']=ids
934: number=int(len(ids)/numberOfColumns)+1
935:
936: return range(number+1)
937:
938: def show_thumbs_columns(self,row,numberOfColumns):
939: """Ausgabe einer Liste der Reihe"""
940: ids=self.REQUEST.SESSION['ids']
941: max=len(ids)
942: if (row*numberOfColumns)<max:
943: return ids[(row-1)*numberOfColumns:row*numberOfColumns]
944: else:
945: return ids[(row-1)*numberOfColumns:]
946:
947: def thumblistSelected_old(self):
948: """main template collection"""
949: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected.zpt')).__of__(self)
950: return pt()
951:
952: def thumblistSelected(self):
953: """main template collection"""
954: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected2.zpt')).__of__(self)
955: return pt()
956:
957: def thumblist_old(self):
958: """main template collection"""
959: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
960: return pt()
961:
962: def thumblist(self):
963: """main template collection"""
964: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb2.zpt')).__of__(self)
965: return pt()
966:
967: def thumblistNewWindow(self):
968: """Thumbs mit clik neues Fenster oeffnen"""
969: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbNewWindow.zpt')).__of__(self)
970: return pt()
971:
972:
973: def navig_selected_html(self):
974: """navigation"""
975: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
976: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)
977: return pt()
978:
979: def navig_html(self):
980: """navigation"""
981: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
982: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation.zpt')).__of__(self)
983: return pt()
984:
985:
986: def selection(self):
987: """show only selected"""
988: if self.REQUEST.has_key('filename'):
989: filen=self.REQUEST['filename']
990: else:
991: filen=""
992: self.REQUEST.SESSION['filename']=filen
993: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
994: return pt()
995:
996: def index_html(self):
997: """main template collection"""
998: if self.REQUEST.has_key('filename'):
999: filen=self.REQUEST['filename']
1000: else:
1001: filen=""
1002:
1003: self.REQUEST.SESSION['filename']=filen
1004:
1005: if self.REQUEST.has_key('showall'):
1006:
1007: self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
1008: else:
1009: self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
1010:
1011:
1012: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
1013: return pt()
1014:
1015: def manage_AddImageCollectionForm(self):
1016: """Nothing yet"""
1017: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
1018: return pt()
1019:
1020: def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
1021: """Add ImageCollection"""
1022: newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
1023: self._setObject(id,newObj)
1024:
1025: if RESPONSE is not None:
1026: RESPONSE.redirect('manage_main')
1027:
1028:
1029: class ImageCollectionIFrame(ImageCollection):
1030: """Class fuer Collection set als IFrame"""
1031:
1032: meta_type="ImageCollectionIFrame"
1033: label=ImageCollection.title
1034:
1035: def getImageTag(self):
1036: """ hack : method needed by echo_content"""
1037: return ""
1038:
1039: def rotate(self,angle,url,RESPONSE):
1040: """rotate"""
1041:
1042: RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
1043: RESPONSE.redirect(url)
1044: def request(self):
1045: """request"""
1046: return self.REQUEST
1047:
1048: def index_html(self):
1049: """index"""
1050: if self.REQUEST.has_key('filename'):
1051: filen=self.REQUEST['filename']
1052: else:
1053: filen=""
1054: self.REQUEST.SESSION['filename']=filen
1055:
1056:
1057: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameMain.zpt')).__of__(self)
1058: return pt()
1059:
1060: def iframe_html(self):
1061: """iframe"""
1062: if self.REQUEST.has_key('filename'):
1063: filen=self.REQUEST['filename']
1064: else:
1065: filen=""
1066: self.REQUEST.response.setCookie('filename',filen)
1067: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameOverview.zpt')).__of__(self)
1068: return pt()
1069:
1070:
1071: def manage_AddImageCollectionIFrameForm(self):
1072: """Nothing yet"""
1073: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionIFrameForm.zpt')).__of__(self)
1074: return pt()
1075:
1076: def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
1077: """Add ImageCollection"""
1078: newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
1079: self._setObject(id,newObj)
1080:
1081: if RESPONSE is not None:
1082: RESPONSE.redirect('manage_main')
1083:
1084:
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