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