![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to archive.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / lise|
Return to archive.py CVS log | Up to [Repository] / lise |
1.1 wischi 1: """ TO DO generell falls noch ein File, das nicht index.meta -> archivierung ausgeben """
2: from types import *
3: import urllib
4: import os
5: import sys
6: import re
7: from AccessControl import ClassSecurityInfo
8: from AccessControl.Role import RoleManager
9: from Acquisition import Implicit
10: from Globals import Persistent
11: from time import strptime
12: from time import strftime
13: import time
14: import os.path
15: import dircache
16: import xml.dom.minidom
17: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
18: from Products.PageTemplates.PageTemplate import PageTemplate
19: import tempfile
20: tempfile.tempdir="/var/tmp/archiver"
21:
22: exclusion=[".HSResource","lost+found","Network Trash Folder","TheFindByContentFolder","TheVolumeSettingsFolder"]
23: class fsentry(Implicit, Persistent, RoleManager):
24: """File entry class"""
25: path = ""
26: user = ""
27: month = ""
28: date =""
29: time = ""
30:
31: security=ClassSecurityInfo()
32: def __init__(self,extpath):
33: """initialize class"""
34: extpath=os.path.abspath(re.search(r"(.*)\n",extpath).group(1))
35: self.all=extpath
36: self.path=extpath
37: self.user=""
38: self.mtime=os.path.getmtime(extpath)
39:
40:
41: security.declarePublic('getPath')
42: def getPath(self):
43: """Ausgabe von path"""
44: return self.path
45:
46: security.declarePublic('getUser')
47: def getUser(self):
48: """Ausgabe von user"""
49: return self.user
50:
51: security.declarePublic('getDate')
52: def getDate(self):
53: """Ausgabe von Date"""
54: return strftime("%Y%m%d%H%M",time.gmtime(self.mtime))
55:
56: security.declarePublic('getDate')
57: def getID(self):
58: """Ausgabe einer eindeutigen Sortierbaren ID"""
59: return self.getDate()+self.getPath()
60:
61: security.declarePublic('getTime')
62: def getTime(self):
63: """Ausgabe von path"""
64: return self.time
65: security.declarePublic('getAll')
66: def getAll(self):
67: """Ausgabe von path"""
68: return self.all
69:
70: class filesystem(Implicit, Persistent, RoleManager):
71: """store filesystem"""
72: node={}
73: hasindex={}
74: security=ClassSecurityInfo()
75:
76: def getfs(self,start):
77: """load filessystem"""
78: f = os.popen("find "+ start+" -name '*' ","r")
79: lines = f.readlines()
80:
81: return lines
82:
83: def loadfs(self,start):
84: """analyse filesystem"""
85: for line in self.getfs(start):
86:
87: g=re.search(r"(.*/)(.*)\n",line)
88: if not g==None:
89: path=g.group(1)
90: file=g.group(2)
91: if self.node.has_key(path):
92: elements=self.node[path]
93: elements.append(file)
94: self.node[path]=elements
95: else:
96: self.node[path]=[file]
97: if (file=="index.meta") | (file=="meta"):
98: self.hasindex[path]="1"
99:
100: def __init__(self,start,reload=0):
101: if reload==1:
102: self.node={}
103: self.hasindex={}
104: self.loadfs(start)
105:
106:
107: security.declarePublic('getNode')
108: def getNode(self):
109: return self.node
110:
111: security.declarePublic('getKeys')
112: def getKeys(self):
113: return self.node.keys()
114:
115: security.declarePublic('clearnode')
116: def clearnode(self):
117: self.node={}
118: return 0
119:
120: security.declarePublic('hasIndex')
121: def hasIndex(self,path):
122:
123: return self.hasindex.has_key(path)
124:
125:
126: def onlyIndex_old(self):
127: """return only files with archive material"""
128: j={}
129: for k in self.node:
130: if self.hasindex.has_key(k):
131: if len(self.node[k])>1:
132: if (len(self.node[k])==2) & ('meta' not in self.node[k]):
133: j[k]=self.node[k]
134: elif (len(self.node[k])==2) & ('meta' in self.node[k]):
135: """ nothing """
136: else:
137: j[k]=self.node[k]
138: return j
139:
140: def archive_the_path(self,path):
141: """parse indexmeta and return digilib path"""
142: try:
143: #f = os.popen("cat "+path+"/index.meta","r")
144: f =file(path+"/index.meta","r")
145:
146: lines = f.read()
147:
148: try:
149: dom = xml.dom.minidom.parseString(lines)
150: if getText(dom.getElementsByTagName("content-type")[0].childNodes)=="folder":
151: """folder nicht archivieren"""
152: return 0
153: else:
154: archive_storage_date=getText(dom.getElementsByTagName("archive-storage-date")[0].childNodes)
155:
156: if archive_storage_date=="":
157:
158: """leer also archivieren"""
159: return 1
160: else:
161: """nicht archivieren"""
162: return 0
163: except:
164: """kein tag also archivieren"""
165: return 1
166: except:
167: """kein index.meta also nicht archivieren"""
168: return 0
169:
170: security.declarePublic('onlyIndex')
171: def onlyIndex(self):
172: """return only files with archive material (archive-storage-date not set)"""
173: j={}
174:
175: for k in self.node:
176: if self.archive_the_path(k):
177: j[k]=self.node[k]
178: return j
179: security.declarePublic('getImageDirs')
180: def getImageDirs(self,dom,path):
181: dirs=dom.getElementsByTagName("dir")
182: dirback=[]
183: for dir in dirs:
184: temp=getText(dir.getElementsByTagName("name")[0].childNodes)
185: temp2=re.search(r"(.*)/mpiwg/online/(.*)",path+"/"+temp)
186: if not temp2==None:
187: try:
188: dirback.append(temp2.group(2))
189: except:
190: """nothing"""
191: else:
192: dirback.append(temp)
193: return dirback
194:
195:
196:
197:
198: security.declarePublic('digilib')
199: def digilib(self, path):
200: """check if folder is a container for digilib files"""
201: if self.hasindex.has_key(path+"/"):
202: return(self.parseIndexMeta(path))
203: else:
204: return "NO"
205:
206:
207:
208:
209: security.declarePublic('isdigilib')
210: def isdigilib(self, path):
211: """return number of possible image directories usefull for digilib"""
212: if self.hasindex.has_key(path+"/"):
213: return(len(self.parseIndexMeta(path)))
214: else:
215: return 0
216:
217: security.declarePublic('parseIndexMeta')
218: def parseIndexMeta(self,k):
219: """parse indexmeta and return digilib path"""
220: f = os.popen("cat "+k+"/index.meta","r")
221: lines = f.read()
222:
223: try:
224: dom = xml.dom.minidom.parseString(lines)
225: content_type=getText(dom.getElementsByTagName("content-type")[0].childNodes)
226: if (content_type=="scanned-document") or (content_type=="scanned document"):
227: dirs=self.getImageDirs(dom,k)
228:
229: return dirs
230: except:
231: return []
232:
233:
234: class filesystem2(Implicit, Persistent, RoleManager):
235: """store filesystem"""
236: node={}
237: hasindex={}
238: security=ClassSecurityInfo()
239:
240: def getfs(self,start):
241: """load filessystem"""
242: f = os.popen("find "+ start+" -name '*' ","r")
243: lines = f.readlines()
244:
245: return lines
246:
247: def loadfs(self,start):
248: """analyse filesystem"""
249: for line in self.getfs(start):
250:
251: g=re.search(r"(.*/)(.*)\n",line)
252: if not g==None:
253: try:
254: path=g.group(1)
255: file=g.group(2)
256: except:
257: """nothing"""
258: if self.node.has_key(path):
259: elements=self.node[path]
260: elements.append(file)
261: self.node[path]=elements
262: else:
263: self.node[path]=[file]
264: if (file=="index.meta") | (file=="meta"):
265: self.hasindex[path]="1"
266:
267: def __init__(self,start,reload=0):
268: """nothing"""
269:
270: security.declarePublic('getImageDirs')
271: def getImageDirs(self,dom,path):
272: dirs=dom.getElementsByTagName("dir")
273: dirback=[]
274: for dir in dirs:
275: temp=getText(dir.getElementsByTagName("name")[0].childNodes)
276: temp2=re.search(r"(.*)/mpiwg/online/(.*)",path+"/"+temp)
277: if not temp2==None:
278: try:
279: dirback.append(temp2.group(2))
280: except:
281: """nothing"""
282: else:
283: dirback.append(temp)
284: return dirback
285:
286:
287: security.declarePublic('digilib')
288: def digilib(self, path):
289: """check if folder is a container for digilib files"""
290: if os.path.exists(path+"/index.meta"):
291: return(self.parseIndexMeta(path))
292: else:
293: return "NO"
294:
295: security.declarePublic('isdigilib')
296: def isdigilib(self, path):
297: if os.path.exists(path+"/index.meta"):
298: return(len(self.parseIndexMeta(path)))
299: else:
300: return 0
301: security.declarePublic('parseIndexMeta')
302: def parseIndexMeta(self,k):
303: """parse indexmeta and return digilib path"""
304: f = os.popen("cat "+k+"/index.meta","r")
305: lines = f.read()
306:
307: try:
308: dom = xml.dom.minidom.parseString(lines)
309: content_type=getText(dom.getElementsByTagName("content-type")[0].childNodes)
310: if content_type=="scanned-document":
311: dirs=self.getImageDirs(dom,k)
312:
313: return dirs
314: except:
315: return []
316:
317:
318: class browse(Implicit, Persistent, RoleManager):
319:
320: security=ClassSecurityInfo()
321: tree={}
322: toggledict={}
323:
324: def filterExcluded(self,dir):
325: ret=[]
326: for item in dir:
327: if not item in exclusion:
328: ret.append(item)
329: return ret
330:
331: def __init__(self,startpath):
332: self.tree={}
333: self.tree[startpath]=self.filterExcluded(dircache.listdir(startpath))
334:
335: security.declarePublic('getTree')
336: def getTree(self,path):
337: if self.tree.has_key(path):
338: return self.tree[path]
339: else:
340: self.tree[path]=self.filterExcluded(dircache.listdir(path))
341: return self.tree[path]
342:
343: security.declarePublic('isDirectory')
344: def isDirectory(self,path,file):
345: return os.path.isdir(os.path.abspath(path+"/"+file))
346:
347: security.declarePublic('toggle')
348: def toggle(self,tmppath,file):
349: path=tmppath+"/"+file
350:
351: if self.toggledict.has_key(path):
352: if self.toggledict[path]==0:
353: self.toggledict[path]=1
354:
355: else:
356: self.toggledict[path]=0
357:
358: else:
359: self.toggledict[path]=4
360:
361:
362: security.declarePublic('isToggle')
363: def isToggle(self,tmppath,file):
364: path=tmppath+"/"+file
365:
366: if self.toggledict.has_key(path):
367:
368: return self.toggledict[path]
369: else:
370:
371: return 0
372:
373:
374: def getfs(start):
375: """return filesystem"""
376: f = os.popen("find "+ start+" -name '*'","r")
377: lines = f.readlines()
378: return lines
379:
380: def showall(start):
381: lines = getfs(start)
382: for line in lines:
383: print line
384: return 0
385:
386: def entries(start):
387: """retrun list of entries of a filesystem"""
388: i=0
389: fs=[]
390: lines=getfs(start)
391: for line in lines:
392: try:
393: if os.path.exists(os.path.abspath(re.search(r"(.*)\n",line).group(1))):
394: fs.append(fsentry(line))
395: i=i+1
396: except:
397: """nothing"""
398: return fs
399:
400: def getfilesystem(start,reload=0):
401: """load filesystem"""
402:
403: k=filesystem(start,1)
404: return k
405:
406: def getfilesystem2(start,reload=0):
407: """load filesystem"""
408:
409: k=filesystem2(start,1)
410: return k
411:
412: def tree(start):
413: """get the filetree"""
414: k=browse(start)
415: return k
416:
417: def sort_by_date(fs):
418: """sorts lists of fileentries"""
419: ls=[]
420: dict={}
421: for k in fs:
422: ls.append(k.getID())
423: dict[k.getID()]=k
424: ls.sort()
425: ls.reverse()
426: ret=[]
427: for j in ls:
428: ret.append(dict[j])
429: return ret
430:
431: def path_to_link(path):
432: """generates navigation bar for showfiles"""
433: string=""
434:
435: tmppath=os.path.dirname(path)
436: i=0
437: pathes=[[path, os.path.basename(path)]]
438:
439: while not (len(tmppath)==1):
440:
441: i=i+1
442: if i>20: break
443:
444: pathes.append([tmppath, os.path.basename(tmppath)])
445: tmppath=os.path.dirname(tmppath)
446:
447: while i>=0:
448: string=string+"<a href=showfiles?path="+pathes[i][0]+">"+pathes[i][1]+"</a>/"
449:
450: i=i-1
451: return string
452:
453: def path_to_link_view(path):
454: """generates navigation bar for viewfiles"""
455: string=""
456:
457: tmppath=os.path.dirname(path)
458: i=0
459: pathes=[[path, os.path.basename(path)]]
460:
461: while not (len(tmppath)==1):
462:
463: i=i+1
464: if i>20: break
465:
466: pathes.append([tmppath, os.path.basename(tmppath)])
467: tmppath=os.path.dirname(tmppath)
468:
469: while i>=0:
470: string=string+"<a href=viewfiles?path="+pathes[i][0]+">"+pathes[i][1]+"</a>/"
471:
472: i=i-1
473: return string
474:
475: def path_to_link_store(path):
476: """generates navigation bar for viewfiles"""
477: string=""
478:
479: tmppath=os.path.dirname(path)
480: i=0
481: pathes=[[path, os.path.basename(path)]]
482:
483: while not (len(tmppath)==1):
484:
485: i=i+1
486: if i>20: break
487:
488: pathes.append([tmppath, os.path.basename(tmppath)])
489: tmppath=os.path.dirname(tmppath)
490:
491: while i>=0:
492: string=string+"<a href=storefiles?path="+pathes[i][0]+">"+pathes[i][1]+"</a>/"
493:
494: i=i-1
495: return string
496:
497:
498: class Error(Implicit, Persistent, RoleManager):
499:
500: error=[]
501: security=ClassSecurityInfo()
502: def __init__(self,initerror):
503: self.error=initerror[0:]
504:
505: security.declarePublic('getError')
506: def getError(self):
507: return self.error
508:
509: class metacheck(Implicit, Persistent, RoleManager):
510: lines=[]
511: security=ClassSecurityInfo()
512: def parsearchive(self,str):
513: """parse for error"""
514: retstr=''
515:
516: if not len(str)==0:
517: for line in str:
518: retstr=retstr+line+"<br>"
519: check=re.search(r"(.*):(.*)",line)
520: if check.group(1)=='ABORT':
521: error="error"
522: elif check.group(1)=='DONE':
523: error="ok"
524: else:
525: error="running"
526:
527: return [retstr,error]
528: else:
529: return ['','running']
530: def __init__(self,path):
531: """archive the documents in path"""
532: self.lines=[]
533:
534: if type(path)==StringType:
535: f = os.popen("/usr/local/mpiwg/archive/metacheck "+path,"r")
536: self.lines.append(Error([path,self.parsearchive(f.readlines())]))
537: else:
538: for singlepath in path:
539: f = os.popen("/usr/local/mpiwg/archive/metacheck "+singlepath,"r")
540: self.lines.append(Error([singlepath,self.parsearchive(f.readlines())]))
541: security.declarePublic('messages')
542:
543: def messages(self):
544: return self.lines
545:
546:
547:
548:
549: class archive(Implicit, Persistent, RoleManager):
550: lines=[]
551: security=ClassSecurityInfo()
552: def parsearchive(self,str):
553: """parse for error"""
554: retstr=''
555:
556: if not len(str)==0:
557: for line in str:
558: retstr=retstr+line+"<br>"
559: check=re.search(r"(.*):(.*)",line)
560: if check.group(1)=='ABORT':
561: error="error"
562: elif check.group(1)=='DONE':
563: error="ok"
564: else:
565: error="running"
566:
567: return [retstr,error]
568: else:
569: return ['','running']
570:
571: def __init__(self,path,session):
572: """archive the documents in path"""
573: self.lines=[]
574: self.filenames={}
575: session['archiver']=self
576:
577:
578: if type(path)==StringType:
579: self.filenames[path]=tempfile.mktemp()
580: f = os.popen("/usr/local/mpiwg/archive/archiver "+path+" > "+self.filenames[path]+" &","r")
581: else:
582: for singlepath in path:
583: self.filenames[singlepath]=tempfile.mktemp()
584: f = os.popen("/usr/local/mpiwg/archive/archiver "+singlepath+" > "+self.filenames[singlepath]+" &","r")
585:
586: security.declarePublic('messages')
587: def messages(self):
588: self.lines=[]
589: for path in self.filenames.keys():
590:
591: self.lines.append(Error([path,self.parsearchive(open(self.filenames[path],"r").readlines())]))
592: return self.lines
593:
594:
595: def evalext(str):
596: return eval(str)
597:
598: def storeerror(ret,path,context,i):
599: session=context.REQUEST.SESSION
600: session['error%i'%i]=ret
601: session['path%i'%i]=path
602:
603: return 'error?number=%i'%i
604:
605: def geterror(str,context):
606: session=context.REQUEST.SESSION
607: return session[str]
608:
609: def readfile(path):
610:
611: ret=""
612: f=open(path,'r')
613: for g in f.readlines():
614: ret=ret+g
615: return ret
616:
617: def writefile(self,path,txt,REQUEST):
618: f=open(path,'w')
619: f.write(txt)
620: f.close()
621: rval=self.aq_acquire('archive2')
622: return rval()
623:
624:
625: def metachecker(self,path):
626: """check the metadata the documents in path"""
627: self.REQUEST.SESSION['path']=self.REQUEST['path']
628: return metacheck(path)
629:
630: def archiver(self,path):
631: """archive the documents in path"""
632: tmp=archive(path,self.REQUEST.SESSION)
633: return self.REQUEST.RESPONSE.redirect('archive4')
634:
635: def getText(nodelist):
636:
637: rc = ""
638: for node in nodelist:
639: if node.nodeType == node.TEXT_NODE:
640: rc = rc + node.data
641: return rc
642:
643: def getBib(nodelist):
644: rc= "<table border='0'>"
645: print "HI"
646: for node in nodelist:
647:
648: if node.nodeType == node.ELEMENT_NODE:
649: """nothing"""
650: rc = rc+"<tr><td valign='right'>"+str(node.nodeName)+":</td><td> "+getText(node.childNodes)+"</td></tr>"
651: #print rc
652: return rc+"</table>"
653:
654: def getMetafile(path):
655: """get index.meta"""
656: html=[]
657: if not os.path.exists(path+"/index.meta"):
658:
659: return "NO_METADATA"
660: else:
661: f = os.popen("cat "+path+"/index.meta","r")
662: lines = f.read()
663: dom = xml.dom.minidom.parseString(lines)
664: name=getText(dom.getElementsByTagName("name")[0].childNodes)
665: creator=getText(dom.getElementsByTagName("creator")[0].childNodes)
666: creation_date=getText(dom.getElementsByTagName("archive-creation-date")[0].childNodes)
667: description=getText(dom.getElementsByTagName("description")[0].childNodes)
668: try:
669: type=getText(dom.getElementsByTagName("content-type")[0].childNodes)
670: except:
671: type=""
672: if type=="scanned document":
673: html="<h3>Document: "+name+"</h3>"
674: elif type=="folder":
675: html="<h3>Folder: "+name+"</h3>"
676: else:
677: html="<h3>Document: "+name+"</h3>"
678:
679: html=html+"<p><i>created by: "+creator+" at: "+creation_date+"</i></p>"
680: html=html+"<h4>Description</h4><p>"+description+"</p>"
681: try:
682: bib = dom.getElementsByTagName("meta")[0].getElementsByTagName("bib")[0]
683: if bib.attributes.has_key('type'):
684: html=html+"<h4>Info ("+bib.attributes['type'].value+")</h4>"
685: else:
686: html=html+"<h4>Info</h4>"
687: html=html+getBib(bib.childNodes)
688: print html
689: except:
690: """none"""
691:
692: # html=html.encode('utf-8','replace')+getBib(bib.childNodes).encode('utf-8','replace')
693:
694: return html
695:
696: def hasMetafile(path):
697: """get index.meta"""
698: return os.path.exists(path+"/index.meta")
699: #return path
700:
701: def isdigilib2(path):
702: """check if folder is candidate for digilib without metadata"""
703: try:
704: dir=os.listdir(path)
705:
706: imagesuffixes=['.gif','.jpg','.jpeg','.png','.tiff','.tif','.JPG','.TIFF','.TIF']
707: ret=""
708: for a in dir:
709:
710: suffix=os.path.splitext(a)
711:
712: if suffix[1] in imagesuffixes:
713: return 1
714:
715: try:
716: dom=xml.dom.minidom.parse(os.path.split(path)[0]+"/index.meta")
717: for node in dom.getElementsByTagName("dir"):
718:
719: if getText(node.getElementsByTagName("content-type")[0].childNodes)=="images":
720:
721: if getText(node.getElementsByTagName("name")[0].childNodes)==os.path.split(path)[1]:
722: return 1
723: return 0
724: except:
725:
726: return 0
727:
728:
729:
730:
731:
732: except:
733: return 0
734:
735: def isFullText(path,folder_name):
736: """check if foldername in path is full text"""
737: try:
738: dom=xml.dom.minidom.parse(path+"/index.meta")
739: for node in dom.getElementsByTagName("dir"):
740:
741: if getText(node.getElementsByTagName("content-type")[0].childNodes)=="fulltext":
742:
743: if getText(node.getElementsByTagName("name")[0].childNodes)==folder_name:
744: return 1
745: return 0
746: except:
747:
748: return 0
749:
750:
751: def isPresentation(path,folder_name):
752: """check if foldername in path is full text"""
753: try:
754: dom=xml.dom.minidom.parse(path+"/index.meta")
755: #print dom.toxml()
756: for dirnode in dom.getElementsByTagName("dir"):
757: try:
758:
759: if getText(dirnode.getElementsByTagName('content-type')[0].childNodes)=='presentation':
760: if getText(dirnode.getElementsByTagName("name")[0].childNodes)==folder_name:
761: return 1
762: except:
763: """nothing"""
764: return 0
765: except:
766:
767: return 0
768:
769:
770:
771:
772:
773: def changeName(path):
774: try:
775: temp2=re.search(r"(.*)/mpiwg/online/(.*)",path)
776: if temp2==None:
777: return "digifiles/"+re.search(r"(.*)/mpiwg/production/docuserver/(.*)",path).group(2)
778: else:
779: return temp2.group(2)
780: except: # hack - im archivbereich keine online darstellung gibt jetzt ein no zurück.
781: return "NO"
782:
783:
784: def test(self):
785: self.i=1
786: #newtemplate=PageTemplateFile('/usr/local/mpiwg/Zope/Extensions/test').__of__(self)
787: self.manage_addProduct['OFSP'].manage_addDTMLMethod('neu','neu')
788: self.getattr('neu').manage_edit('HELLO','neu')
789: return "ok"
790:
791:
792: class ls(Implicit, Persistent, RoleManager):
793: """File entry class"""
794: path = ""
795: user = ""
796: month = ""
797: date =""
798: time = ""
799:
800: security=ClassSecurityInfo()
801:
802: def __init__(self,start):
803: self.outfile=tempfile.mktemp()
804: start['outfile']=self
805: os.popen("ls -R / >"+self.outfile+" &","r")
806:
807:
808: security.declarePublic('read')
809: def read(self):
810: return self.f.read()
811: security.declarePublic('retself')
812: def retself(self):
813: return self
814: security.declarePublic('all')
815: def all(self):
816: ret=""
817: for g in self.f:
818: ret=ret+g
819: return ret
820:
821: security.declarePublic('printOutfile')
822: def printOutfile(self):
823: while not os.path.exists(self.outfile):
824: """nothing"""
825: return open(self.outfile).readlines()
826:
827: class overview(Implicit,Persistent, RoleManager):
828: dir=[]
829: resources={}
830: security=ClassSecurityInfo()
831:
832: def __init__(self,path):
833: dir=os.listdir(path)
834:
835: for file in dir:
836: self.resources[self.getResource(path,file)]=path+"/"+file
837:
838:
839: def getResource(self,path,filename):
840: f=file(path+"/"+filename,'r')
841:
842: for line in f.readlines():
843:
844: if line[0:4]=="INFO":
845: if line[6:14]=="resource":
846: return line
847: return "error"
848:
849: def parsearchive(self,str):
850: """parse for error"""
851: retstr=''
852:
853: if not len(str)==0:
854: for line in str:
855: retstr=retstr+line+"<br>"
856: check=re.search(r"(.*):(.*)",line)
857: if check.group(1)=='ABORT':
858: error="error"
859: elif check.group(1)=='DONE':
860: error="ok"
861: else:
862: error="running"
863:
864: return [retstr,error]
865: else:
866: return ['','running']
867:
868: security.declarePublic('messages')
869: def messages(self):
870: self.lines=[]
871: for name in self.resources.keys():
872: path=self.resources[name]
873:
874: self.lines.append(Error([name,self.parsearchive(open(path,"r").readlines())]))
875: return self.lines
876:
877: security.declarePublic('printResource')
878: def printResource(self):
879: return self.resources
880:
881: def getoverview(path):
882:
883: return overview(path)
884:
885:
886: def ls_test(self):
887: tmp=ls(self.REQUEST.SESSION)
888: return self.REQUEST.RESPONSE.redirect('next')
889:
890: def storeFile(self,something):
891: self.REQUEST.SESSION['something']=something
892: return 1
893:
894: def getFile(self):
895: return self.REQUEST.SESSION['something']
896:
897: def isFolder(self,path):
898: """returns TRUE, wenn path ein Folder ist in den weitere Objekte Folder oder Dokumente gelegt werden dürfen"""
899: return not isScannedDocument(self,path) # vorläufig sind alle Documente die keine scanned documente sind folder.
900:
901: def isScannedDocument(self,path):
902: """returns TRUE, wenn path der Stammordner eines gescannten Documents ist"""
903: try:
904: f = file(path+"/index.meta","r")
905: lines = f.read()
906:
907: try:
908: dom = xml.dom.minidom.parseString(lines)
909: content_type=getText(dom.getElementsByTagName("content-type")[0].childNodes)
910: if (content_type=="scanned-document") or (content_type=="scanned document"):
911: return 1
912: else:
913: return 0
914: except:
915: return 0
916: except:
917: return 0
918:
919: from time import localtime,strftime
920:
921: def date(self):
922: return strftime("%d.%m.%Y",localtime())
923:
924:
925:
926: def EditIndex(self,path):
927: try:
928: dom=xml.dom.minidom.parse(path+"/index.meta")
929: indexmeta=dom.toxml()
930: except:
931: indexmeta=""
932: self.REQUEST.SESSION['indexmeta']=indexmeta
933: self.REQUEST.SESSION['path']=path
934: newtemplate=PageTemplateFile('/usr/local/mpiwg/Zope/Extensions/editindex').__of__(self)
935: return newtemplate()
936:
937: def EditIndex2(self):
938: if not self.REQUEST.has_key('fileupload'):
939: #newtext=urllib.unquote(self.REQUEST['indexmeta'])
940: newtext=self.REQUEST['indexmeta']
941: print newtext
942: else:
943: self.file_name=self.REQUEST['fileupload'].filename
944: #newtext=self.REQUEST.form['fileupload'].read()
945: # HACK DW
946: newtext=self.REQUEST['indexmeta']
947:
948: indexmeta=file(self.REQUEST.SESSION['path']+"/index.meta","w")
949: indexmeta.writelines(newtext)
950: return self.REQUEST.response.redirect("storage/storefiles?path="+self.REQUEST.SESSION['path'])