1: """CDLI extensions of the filearchive"""
2: from Products.versionedFile.versionedFile import *
3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
4: from tempfile import mkstemp,mkdtemp
5: import os.path
6: import os
7: from types import *
8: import urlparse
9: from OFS.OrderedFolder import OrderedFolder
10: from OFS.SimpleItem import SimpleItem
11: import time
12: from OFS.Folder import manage_addFolder
13: import re
14: from AccessControl import ClassSecurityInfo
15: from Acquisition import Implicit
16: from threading import Thread
17: from ZPublisher.HTTPRequest import HTTPRequest
18: from ZPublisher.HTTPResponse import HTTPResponse
19: from ZPublisher.BaseRequest import RequestContainer
20: import threading
21: global tmpVar
22:
23: class uploadATFfinallyThread(Thread):
24: """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
25:
26: def __init__(self):
27: """init for uploadATFfinallyThread"""
28: self.continueVar=True
29: self.returnValue=None
30: self.end=False
31: Thread.__init__(self)
32:
33: def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
34: """set start values for the thread"""
35: self.procedure=procedure
36: self.comment=comment
37: self.basketname=basketname
38: self.unlock=unlock
39: self.SESSION=SESSION
40: self.username=username
41: self.serverport=serverport
42:
43: def __call__(self):
44: """call of the thread (equals run)"""
45: self.run()
46: return True
47:
48: def getContext(self, app,serverport="8080"):
49: """get the context within the ZODB"""
50:
51: resp = HTTPResponse(stdout=None)
52: env = {
53: 'SERVER_NAME':'localhost',
54: 'SERVER_PORT':serverport,
55: 'REQUEST_METHOD':'GET'
56: }
57: req = HTTPRequest(None, env, resp)
58: return app.__of__(RequestContainer(REQUEST = req))
59:
60:
61: def run(self):
62: """run"""
63:
64: self.result=""
65: #find context within ZODB
66: from Zope import DB
67: conn = DB.open()
68: root = conn.root()
69: app = root['Application']
70: ctx = self.getContext(app,serverport=self.serverport)
71:
72: #add the files
73: self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
74: #commit the transactions
75: get_transaction().commit()
76: conn.close()
77: #set flag for end of this method
78: self.end=True
79: return True
80:
81: def getResult(self):
82: """method for accessing result"""
83:
84: return self.result
85:
86: def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
87: """upload the files"""
88: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
89: ctx2=ctx.cdliRoot
90:
91: self.result+="<h2>Start processing</h2>"
92:
93: #shall I only upload the changed files?
94: if procedure=="uploadchanged":
95:
96: uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
97:
98: #or all
99: elif procedure=="uploadAll":
100: uploadFns=[]
101: for x in os.listdir(SESSION['tmpdir']):
102: if not x in SESSION['errors']:
103: uploadFns.append(x)
104:
105: #or maybe nothing
106: elif procedure=="noupload":
107: return True
108: else:
109: uploadFns=[]
110:
111: #do first the changed files
112: for fn in uploadFns:
113: founds=ctx2.CDLICatalog.search({'title':fn})
114: if len(founds)>0:
115: SESSION['author']=str(username)
116: self.result+="<p>Changing : %s"%fn
117: founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))
118:
119:
120: #now add the new files
121: newPs=SESSION['newPs']
122: if len(newPs)>0:
123: tmpDir=SESSION['tmpdir']
124: self.result+="<p>Adding files</p>"
125: #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
126: ctx2.cdli_main.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
127:
128:
129:
130: #unlock locked files?
131: if unlock:
132: self.result+="<p>Unlock files</p>"
133: unlockFns=[]
134: for x in os.listdir(SESSION['tmpdir']):
135: if not x in SESSION['errors']:
136: unlockFns.append(x)
137:
138: for fn in unlockFns:
139: founds=ctx2.CDLICatalog.search({'title':fn})
140: if len(founds)>0:
141: SESSION['author']=str(username)
142:
143: founds[0].getObject().lockedBy=""
144:
145: #if a basketname is give, add files to the basket
146: if not (basketname ==''):
147: self.result+="<p>Add basket</p>"
148: basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
149:
150: if not basketId: # create new basket
151: ob=ctx2.basketContainer.addBasket(basketname)
152: basketId=ob.getId()
153: basket=getattr(ctx2.basketContainer,str(basketId))
154: ids=os.listdir(SESSION['tmpdir'])
155: basket.addObjects(ids,deleteOld=True,username=str(username))
156:
157: if RESPONSE is not None:
158: RESPONSE.redirect(self.aq_parent.absolute_url())
159:
160:
161:
162: return True
163:
164: class uploadATFThread(Thread):
165: """class for checking the files befor uploading"""
166:
167: def __init__(self):
168: """initialise"""
169:
170: self.continueVar=True
171: self.returnValue=None
172:
173: Thread.__init__(self)
174:
175:
176: def set(self,upload,basketId,username,serverport="8080"):
177: """set start values for the thread"""
178: self.result=""
179: self.upload=upload
180: self.basketId=basketId
181: self.username=username
182: self.serverport=serverport
183:
184: def __call__(self):
185: """call method """
186: self.run()
187: return True
188:
189: def getContext(self, app,serverport="8080"):
190: """get the context within the ZODB"""
191: resp = HTTPResponse(stdout=None)
192: env = {
193: 'SERVER_NAME':'localhost',
194: 'SERVER_PORT':serverport,
195: 'REQUEST_METHOD':'GET'
196: }
197: req = HTTPRequest(None, env, resp)
198: return app.__of__(RequestContainer(REQUEST = req))
199:
200: def run(self):
201:
202: self.result=""
203: #find context within ZODB
204: from Zope import DB
205: conn = DB.open()
206: root = conn.root()
207: app = root['Application']
208: ctx = self.getContext(app,serverport=self.serverport)
209: self.uploadATFThread(ctx,self.upload,self.basketId)
210:
211: while self.continueVar:
212: pass
213: get_transaction().abort()
214: conn.close()
215: print "done"
216:
217: def getResult(self):
218: """method for accessing result"""
219: return self.result
220:
221: def uploadATFThread(self,ctx,upload,basketId=0):
222: """upload an atf file"""
223: #TODO: add comments
224: #TODO: finish uploadATF
225: self.result="<html><body><h2>I am loading your file...</h2>"
226: #make sure that id is a string and not an integer
227: basketId=str(basketId)
228:
229: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
230: ctx2=ctx.cdliRoot
231:
232: #get temporary file for staging the downloaded and splitted files
233: dir=mkdtemp()
234:
235:
236: changed=[] # changed files
237: errors=[] # files with errors
238: newPs=[] # new p filed
239: psNotInCatalog=[] # files not in the catalog
240:
241: #split the uploadedd atf file
242: basketNameFromFile, numberOfFiles=splitatf(upload,dir)
243:
244: #find basketId if not set
245:
246: #get active abaket
247: if basketId == '0':
248: basketObj=ctx2.basketContainer.getActiveBasket()
249: if basketObj:
250: basketId=basketObj.getId()
251:
252: #if there is no active baske and no basketid given, id is empty, else get besketname and length
253: if basketId == '0':
254: basketNameFromId=""
255: basketLen=0
256: else:
257: basketNameFromId=getattr(ctx2.basketContainer,basketId).title
258: basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
259:
260:
261: self.result+="<html><body><h2>I got the files</h2><p>I am checking now the files</p>"
262:
263: #start to check the files
264: for fn in os.listdir(dir):
265:
266: self.result+="<p>check:%s</p>"%fn
267:
268: # check if file is in the catalog
269: #TODO: checkCatalog is not implemented yet
270: if ctx2.cdli_main.checkCatalog(fn):
271: psNotInCatalog.append(fn)
272:
273: #check if p-file already at the server
274: founds=ctx2.CDLICatalog.search({'title':fn})
275:
276: #if not than add filename to the list of newfiles
277: if len(founds)==0:
278: newPs.append(fn)
279:
280: #if p file alread at the server
281: for found in founds:
282: #analyse the differences to the actual file
283: obj=found.getObject()
284:
285: if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):
286: errors.append(obj)
287: else:
288: data=file(os.path.join(dir,fn)).read()
289: diffs=obj.diff(data)
290: if diffs[0]>0:
291: changed.append((obj,diffs))
292: #hochladen
293:
294: #ready, set the returnValues
295: self.result+="<h3>Done</h3></body></html>"
296:
297: self.returnValue={}
298: self.returnValue['changed']=changed
299: self.returnValue['errors']=errors
300: self.returnValue['newPs']=newPs
301: self.returnValue['tmpdir']=dir
302: self.returnValue['basketLen']=basketLen
303: self.returnValue['numberOfFiles']=numberOfFiles
304: self.returnValue['basketNameFromId']=basketNameFromId
305: self.returnValue['basketNameFromFile']=basketNameFromFile
306: self.returnValue['basketId']=basketId
307: self.returnValue['dir']=dir
308:
309: #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
310:
311:
312: class Basket_old(Folder):
313: """shopping basket - alte fassung """
314:
315: meta_type="Basket"
316: _v_stack={}
317:
318: def getObjUrl(self,objId):
319: """getUrl"""
320: founds=self.CDLICatalog.search({'title':objId})
321: if len(founds)>0:
322: return founds[0].getObject().absolute_url()
323:
324: else: #assume version number
325: splitted=objId.split("_")
326: founds=self.CDLICatalog.search({'title':splitted[1]})
327: return founds[0].getObject().absolute_url()+'/'+objId
328:
329: def storeAllLink(self,results):
330: """erzeuge link zum speicher aller results"""
331: nr=self.REQUEST['_ZopeId']
332:
333: if results:
334: self._v_stack[nr]=[x.getObject().getId() for x in results]
335:
336: return self.absolute_url()+"/storeAll?id="+nr
337:
338: def storeAll(self,id):
339: """store all"""
340: try:
341: results=self._v_stack[id]
342: except:
343: #TODO: write expired page
344: return "expired"
345:
346: return self.storeInBasketForm(results)
347:
348: def storeInBasketForm(self,ids):
349: """ store an object form"""
350:
351: if type(ids) is not ListType:
352: ids=[ids]
353: self.REQUEST.SESSION['ids']=ids[0:]
354:
355: self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']
356:
357: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
358: return pt()
359:
360: def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
361: """store it"""
362:
363: if not ids:
364: ids=REQUEST.SESSION['ids']
365:
366: self.REQUEST.SESSION['basketUser']=username
367:
368: baskets=self.ZopeFind(self,obj_ids=[username])
369: if len(baskets)>0:
370: basket=baskets[0][1]
371: else:
372: manage_addBasketObject(self,username)
373: basket=self._getOb(username)
374:
375:
376: basket.addObjects(ids)
377: back=self.REQUEST.SESSION.get('BACKLINK', None)
378:
379: if RESPONSE:
380: RESPONSE.redirect(back)
381:
382:
383:
384: def showBasket(self,user=None,set=None,RESPONSE=None):
385: """show the basket"""
386:
387: if user:
388: self.REQUEST.SESSION['basketUser']=user
389:
390: if not user and not set:
391: user=self.REQUEST.SESSION.get('basketUser',None)
392:
393: if not user:
394: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
395: return pt()
396: else:
397: baskets=self.ZopeFind(self,obj_ids=[user])
398:
399:
400: if len(baskets)>0:
401: RESPONSE.redirect(baskets[0][1].absolute_url())
402: return True
403: else:
404: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
405: return pt()
406:
407:
408: def manage_addBasket_oldForm(self):
409: """add the basket form"""
410: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
411: return pt()
412:
413: def manage_addBasket_old(self,id,title,RESPONSE=None):
414: """add the basket"""
415: ob=Basket()
416:
417: ob.id=str(id)
418: ob.title=title
419: self._setObject(id, ob)
420: ob=self._getOb(id)
421:
422: if RESPONSE is not None:
423: RESPONSE.redirect('manage_main')
424:
425:
426: class BasketObject_old(Folder):
427: """Basket Object - alte fassung"""
428:
429: meta_type="basketObject"
430: def __init__(self):
431: """init basket object"""
432: self.contents=[]
433:
434: def numberOfItems(self):
435: """return anzahl der elemente im basket"""
436: return len(self.contents)
437:
438: def addObjects(self,ids):
439: """addObjects"""
440:
441: for id in ids:
442: founds=self.CDLICatalog.search({'title':id})
443: for found in founds:
444: if found.getObject() not in self.contents:
445: tm=self.contents[0:]
446: tm.append(found.getObject())
447: self.contents=tm[0:]
448:
449: return True
450:
451: def index_html(self):
452: """view the basket"""
453: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
454: return pt()
455:
456: def deleteObjects(self,ids,RESPONSE=None):
457: """delete objects"""
458: list = self.contents[0:]
459: for content in list:
460:
461: if content.getId() in ids:
462: self.contents.remove(content)
463:
464:
465: if RESPONSE:
466: RESPONSE.redirect(self.absolute_url())
467:
468:
469: def unlockTest(self):
470: """unlock all files of the testuser for debuggin"""
471: for object in self.contents:
472:
473: if str(object.lockedBy)=="test":
474: object.lockedBy=""
475:
476: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
477: """download all selected files in one file"""
478:
479: ret=""
480: lockedObjects={}
481:
482:
483: if lock:
484:
485: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
486:
487: return "please login first"
488:
489: #check if a locked object exist in the basket.
490: lockedObjects={}
491: for object in self.contents:
492:
493: if not object.lockedBy=="":
494: lockedObjects[object.title]=repr(object.lockedBy)
495:
496:
497: keys=lockedObjects.keys()
498:
499:
500: if len(keys)>0 and (not procedure):
501: self.REQUEST.SESSION['lockedObjects']=lockedObjects
502: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
503: return pt()
504:
505: elif not procedure: #keine fails gesperrt dann alle donwloaden
506: procedure="downloadAll"
507:
508:
509: for object in self.contents:
510:
511: if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
512: ret+=object.getLastVersion().data
513:
514: if lock and object.lockedBy=='':
515: object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
516:
517:
518: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
519: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
520: length=len(ret)
521: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
522: self.REQUEST.RESPONSE.write(ret)
523:
524:
525: def manage_addBasket_oldObjectForm(self):
526: """add form"""
527: pass
528:
529: def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
530: """add"""
531:
532: ob=BasketObject()
533:
534: ob.id=str(id)
535: ob.title=title
536: self._setObject(id, ob)
537: ob=self._getOb(id)
538:
539: if RESPONSE is not None:
540: RESPONSE.redirect('manage_main')
541:
542:
543: class CDLIBasketContainer(OrderedFolder):
544: """contains the baskets"""
545:
546:
547: security=ClassSecurityInfo()
548: meta_type="CDLIBasketContainer"
549:
550: def deleteBaskets(self,ids=None):
551: """delete baskets, i.e. move them into trash folder"""
552:
553:
554: found=self.ZopeFind(self,obj_ids=['trash'])
555:
556: if len(found)<1:
557: manage_addFolder(self, 'trash')
558: trash=self._getOb('trash')
559: else:
560: trash=found[0][1]
561:
562: if type(ids) is not ListType:
563: ids=[ids]
564: cut=self.manage_cutObjects(ids)
565: trash.manage_pasteObjects(cut)
566:
567: def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
568: """manage baskets, delete or copy"""
569: if submit=="delete":
570: self.deleteBaskets(ids)
571:
572:
573:
574: if RESPONSE:
575: RESPONSE.redirect(self.absolute_url())
576: def getBasketIdfromName(self,basketname):
577: """get id from name"""
578:
579: for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
580: if basket[1].title==basketname:
581: return basket[0]
582: else:
583: None
584:
585: security.declareProtected('manage','uploadBasket_html')
586:
587: def uploadBasket_html(self,basketId='0'):
588: """upload an atf file, html form"""
589:
590:
591: basketId=str(basketId)
592: if not basketId=='0':
593: basketName=getattr(self.basketContainer,basketId).title
594: else:
595: basketName=""
596:
597: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
598: return pt(basketId=basketId,basketName=basketName)
599:
600:
601:
602: def index_html(self):
603: """stanadard ansicht"""
604:
605:
606:
607: ext=self.ZopeFind(self,obj_ids=["index.html"])
608: if ext:
609: return ext[0][1]()
610:
611: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
612: return pt()
613:
614: def getStorageFolderRoot(self):
615: """root des storage folders"""
616: return self.cdli_main
617:
618: def __init__(self,id,title):
619: """ init basket container"""
620: self.id=id
621: self.title=title
622:
623:
624: def getBaskets(self,sortField='title'):
625: """get all baskets files"""
626:
627: def sortName(x,y):
628: return cmp(x[1].title.lower(),y[1].title.lower())
629:
630: def sortDate(x,y):
631: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
632:
633:
634: def sortComment(x,y):
635:
636:
637:
638: try:
639: xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
640: except:
641: xc='ZZZZZZZZZZZZZ'.lower()
642: try:
643: yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
644: except:
645: yc='ZZZZZZZZZZZZZ'.lower()
646:
647:
648: if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
649:
650: try:
651: xc=x[1].getLastVersion().getComment().lower()
652: except:
653: xc='ZZZZZZZZZZZZZ'.lower()
654:
655: if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
656: try:
657: yc=y[1].getLastVersion().getComment().lower()
658: except:
659: yc='ZZZZZZZZZZZZZ'.lower()
660:
661:
662: return cmp(xc,yc)
663:
664: def sortAuthor(x,y):
665:
666: return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
667:
668: baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
669:
670:
671: if sortField=='title':
672: baskets.sort(sortName)
673: elif sortField=='date':
674: baskets.sort(sortDate)
675: elif sortField=='author':
676: baskets.sort(sortAuthor)
677: elif sortField=='comment':
678: baskets.sort(sortComment)
679:
680: return baskets
681:
682:
683:
684: def getNewId(self):
685: """createIds"""
686: last=getattr(self,'last',0)
687: last +=1
688: while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
689: last+=1
690:
691: self.last=last
692: return last
693:
694: def setActiveBasket(self,basketId,REQUEST=None):
695: """store active basketId in a cookie"""
696: self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
697:
698: if REQUEST:
699: REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])
700:
701: def getActiveBasket(self):
702: """get active basket from cookie"""
703:
704: id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
705: if id:
706: obj=getattr(self,str(id),None)
707: else:
708: obj=None
709: return obj
710:
711: def getActualUserName(self):
712: """get name of the actualuser"""
713: return str(self.REQUEST['AUTHENTICATED_USER'])
714:
715:
716: def addBasket(self,newBasketName):
717: """add a new basket"""
718:
719: ob=manage_addCDLIBasket(self,newBasketName)
720: return ob
721:
722: def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
723: """store it"""
724: if not ids:
725: ids=self.REQUEST.SESSION['fileIds']
726:
727: if type(ids) is not ListType:
728: ids=[ids]
729:
730: if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
731: basketRet=self.addBasket(newBasketName)
732: self.setActiveBasket(basketRet.getId())
733: basket=getattr(self,basketRet.getId())
734: elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
735: basket=self.getActiveBasket()
736:
737: added=basket.addObjects(ids)
738: back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
739:
740:
741: if fromFileList:
742:
743: return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
744:
745: if RESPONSE:
746:
747: RESPONSE.redirect(back)
748:
749: return True
750:
751: def manage_addCDLIBasketContainerForm(self):
752: """add the CDLIBasketContainer form"""
753: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
754: return pt()
755:
756: def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
757: """add the basket"""
758: ob=CDLIBasketContainer(id,title)
759:
760: self._setObject(id, ob)
761:
762: if RESPONSE is not None:
763: RESPONSE.redirect('manage_main')
764:
765: class CDLIBasket(Folder,CatalogAware):
766: """basket"""
767:
768: meta_type="CDLIBasket"
769: default_catalog="CDLIBasketCatalog"
770:
771: def getFile(self,obj):
772: return obj[1]
773:
774: def getFileLastVersion(self,obj):
775: return obj[0]
776:
777: def getFileNamesInLastVersion(self):
778: """get content of the last version as list"""
779:
780: return [x[1].getId() for x in self.getLastVersion().getContent()]
781:
782: def isActual(self,obj):
783: """teste ob im basket die aktuelle version ist"""
784: actualNo=obj[1].getLastVersion().getVersionNumber()
785: storedNo=obj[0].getVersionNumber()
786:
787: founds=self.CDLICatalog.search({'title':obj[0].getId()})
788: if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
789: return False, -1
790:
791: if actualNo==storedNo:
792: return True , 0
793: else:
794: return False, actualNo
795:
796: def history(self):
797: """history"""
798:
799: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
800: if ext:
801: return getattr(self,ext[0][1].getId())()
802:
803: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)
804: return pt()
805:
806: def getStorageFolderRoot(self):
807: """root des storage folders"""
808: return self.aq_parent.cdli_main
809:
810: def __init__(self,id,title,shortDescription="",comment=""):
811: """init a CDLIBasket"""
812:
813: self.id=id
814: self.title=title
815: self.shortDescription=shortDescription
816: self.comment=comment
817:
818:
819:
820: def getLastVersion(self):
821: """hole letzte version"""
822: ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]
823: ids.sort()
824: if len(ids)==0:
825: return None
826: else:
827: ob=getattr(self,str(ids[-1]))
828: return ob
829:
830: def getVersions(self):
831: """get versions"""
832: versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
833: return versions
834:
835:
836:
837: def addObjects(self,ids,deleteOld=None,username=None):
838: """generate a new version of the basket with objects added"""
839:
840: lastVersion=self.getLastVersion()
841:
842: if lastVersion is None:
843: oldContent=[]
844: else:
845: oldContent=lastVersion.basketContent[0:]
846:
847: if deleteOld:
848: oldContent=[]
849:
850: newContent=[]
851: added=0
852: for id in ids:
853: founds=self.CDLICatalog.search({'title':id})
854:
855: for found in founds:
856: if found.getObject() not in oldContent:
857: #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
858: newContent.append((found.getObject().getLastVersion(),found.getObject()))
859: added+=1
860:
861: content=oldContent+newContent
862: if not username:
863: user=self.getActualUserName()
864: else:
865: user = username
866:
867: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
868:
869: return added
870:
871: def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
872: """delete objects"""
873:
874: if type(ids) is not ListType:
875: ids=[ids]
876:
877: lastVersion=self.getLastVersion()
878: oldContent=lastVersion.basketContent[0:]
879: newContent=[]
880: for obj in oldContent:
881: if obj[1].getId() not in ids:
882: newContent.append(obj)
883:
884:
885: user=self.getActualUserName()
886:
887: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
888:
889: if RESPONSE:
890: obj=self._getOb(ob.getId())
891: RESPONSE.redirect(obj.absolute_url())
892:
893: def manage_addCDLIBasketForm(self):
894: """add the CDLIBasketContainer form"""
895: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
896: return pt()
897:
898: def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
899: """add the basket"""
900:
901: id=str(self.getNewId())
902:
903: ob=CDLIBasket(id,title,shortDescription,comment)
904:
905: self._setObject(id, ob)
906:
907: if RESPONSE is not None:
908: RESPONSE.redirect('manage_main')
909: else:
910: return ob
911:
912: class CDLIBasketVersion(SimpleItem):
913: """version of a basket"""
914:
915: meta_type="CDLIBasketVersion"
916:
917: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
918: """download all selected files in one file"""
919:
920: ret=""
921: lockedObjects={}
922:
923:
924: if lock:
925:
926: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
927:
928: return "please login first"
929:
930: #check if a locked object exist in the basket.
931: lockedObjects={}
932: for object in self.basketContent:
933:
934: if not object[1].lockedBy=="":
935: lockedObjects[object[1].title]=repr(object[1].lockedBy)
936:
937:
938: keys=lockedObjects.keys()
939:
940:
941: if len(keys)>0 and (not procedure):
942: self.REQUEST.SESSION['lockedObjects']=lockedObjects
943: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
944: return pt()
945:
946: elif not procedure: #keine fails gesperrt dann alle donwloaden
947: procedure="downloadAll"
948:
949:
950: for object in self.basketContent:
951:
952: if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
953: ret+=object[0].data
954:
955: if lock and object[1].lockedBy=='':
956: object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
957:
958: basket_name=self.aq_parent.title+"_V"+self.getId()
959:
960: #write basketname to header of atf file
961: ret="#atf basket %s\n"%basket_name+ret
962:
963: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
964: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
965: length=len(ret)
966: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
967: self.REQUEST.RESPONSE.write(ret)
968:
969:
970: def numberOfItems(self):
971: """return anzahl der elemente im basket"""
972: return len(self.basketContent)
973:
974: def getTime(self):
975: """getTime"""
976: #return self.bobobase_modification_time().ISO()
977:
978: if hasattr(self,'time'):
979: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
980: elif hasattr(self,'timefixed'):
981: return self.timefixed
982: else:
983: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
984: return self.bobobase_modification_time().ISO()
985:
986: def getContent(self):
987: """get Basket Content"""
988: return self.basketContent
989:
990:
991: def __init__(self,id,user,comment="",basketContent=[]):
992: """ init a basket version"""
993: self.id=id
994: self.coment=comment
995: self.basketContent=basketContent[0:]
996: self.user=user
997: self.time=time.localtime()
998:
999: def getUser(self):
1000: """get user"""
1001: return self.user
1002:
1003: def getComment(self):
1004: """get Comment"""
1005: return self.comment
1006:
1007: def index_html(self):
1008: """view the basket"""
1009: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
1010: return pt()
1011:
1012: def getObjUrl(self,result):
1013: """getUrl of the version of the object"""
1014: objId=result[1].getTitle()
1015: founds=self.CDLICatalog.search({'title':objId})
1016: if len(founds)>0:
1017: return founds[0].getObject().getLastVersion().absolute_url()
1018:
1019: else: #assume version number
1020: splitted=objId.split("_")
1021: founds=self.CDLICatalog.search({'title':splitted[1]})
1022: return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
1023:
1024: def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
1025: """add a version"""
1026:
1027: #check for already existing versions
1028:
1029: lastVersion=self.getLastVersion()
1030: if lastVersion is None:
1031: newId=str(1)
1032: else:
1033: newId=str(int(lastVersion.getId())+1)
1034:
1035: ob=CDLIBasketVersion(newId,user,comment,basketContent)
1036:
1037: self._setObject(newId, ob)
1038:
1039: if RESPONSE is not None:
1040: RESPONSE.redirect('manage_main')
1041: else:
1042: return ob
1043:
1044: class CDLIFileObject(versionedFileObject):
1045: """CDLI file object"""
1046:
1047: meta_type="CDLI File Object"
1048:
1049: security=ClassSecurityInfo()
1050:
1051: def view(self):
1052: """view file"""
1053: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
1054: return pt()
1055:
1056: security.declarePublic('getDesignation')
1057: def getDesignation(self):
1058: """get the designation out of the file"""
1059: try:
1060: txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
1061: except:
1062: txt=self.data[0:]
1063:
1064: return "ERROR"
1065: try:
1066: return txt.group(2)
1067: except:
1068: return "ERROR"
1069:
1070: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
1071:
1072: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
1073: REQUEST=None):
1074: """Add a new File object.
1075:
1076: Creates a new File object 'id' with the contents of 'file'"""
1077:
1078: id=str(id)
1079: title=str(title)
1080: content_type=str(content_type)
1081: precondition=str(precondition)
1082:
1083: id, title = cookId(id, title, file)
1084:
1085: self=self.this()
1086:
1087: # First, we create the file without data:
1088: self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
1089: self._getOb(id).versionComment=str(vC)
1090: self._getOb(id).time=time.localtime()
1091:
1092: setattr(self._getOb(id),'author',author)
1093:
1094: # Now we "upload" the data. By doing this in two steps, we
1095: # can use a database trick to make the upload more efficient.
1096: if file:
1097: self._getOb(id).manage_upload(file)
1098: if content_type:
1099: self._getOb(id).content_type=content_type
1100:
1101: if REQUEST is not None:
1102: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
1103:
1104: class CDLIFile(versionedFile,CatalogAware):
1105: """CDLI file"""
1106:
1107: meta_type="CDLI file"
1108: default_catalog='CDLICatalog'
1109:
1110:
1111:
1112: def isContainedInBaskets(self,context=None):
1113: """check is this file is part of any basket
1114: @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
1115: has to exist.
1116: """
1117:
1118: if not context:
1119: context=self
1120:
1121: ret=[]
1122: for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
1123: #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
1124: try:
1125: ret.append(x.getObject())
1126: except:
1127: pass
1128: return ret
1129: #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
1130:
1131:
1132: def addCDLIFileObjectForm(self):
1133: """add a new version"""
1134:
1135: if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
1136: return "please login first"
1137: if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
1138: out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
1139: return out()
1140: else:
1141: return "Sorry file is locked by somebody else"
1142:
1143: def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
1144: """add"""
1145: try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
1146: vC=self.REQUEST['vC']
1147: except:
1148: pass
1149:
1150:
1151: if changeName=="yes":
1152: filename=file.filename
1153: self.title=filename[max(filename.rfind('/'),
1154: filename.rfind('\\'),
1155: filename.rfind(':'),
1156: )+1:]
1157:
1158:
1159: if not newName=='':
1160: self.title=newName[0:]
1161:
1162:
1163:
1164:
1165:
1166: positionVersionNum=getattr(self,'positionVersionNum','front')
1167:
1168: if positionVersionNum=='front':
1169: id="V%i"%self.getVersion()+"_"+self.title
1170: else:
1171: tmp=os.path.splitext(self.title)
1172: if len(tmp)>1:
1173: id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]
1174: else:
1175: id=tmp[0]+"_V%i"%self.getVersion()
1176:
1177:
1178: manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
1179: objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
1180: self.REQUEST.SESSION['objID_parent']=self.getId()
1181:
1182: if RESPONSE:
1183: obj=self.ZopeFind(self,obj_ids=[id])[0][1]
1184: if obj.getSize()==0:
1185: self.REQUEST.SESSION['objID']=obj.getId()
1186: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
1187: return pt()
1188:
1189: else:
1190: RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
1191:
1192: else:
1193: return self.ZopeFind(self,obj_ids=[id])[0][1]
1194:
1195:
1196: def manage_addCDLIFileForm(self):
1197: """interface for adding the OSAS_root"""
1198: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
1199: return pt()
1200:
1201: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
1202: """add the OSAS_root"""
1203: newObj=CDLIFile(id,title,lockedBy,author)
1204: self._setObject(id,newObj)
1205:
1206: if RESPONSE is not None:
1207: RESPONSE.redirect('manage_main')
1208:
1209:
1210:
1211:
1212: def splitatf(fh,dir=None):
1213: """split it"""
1214: ret=None
1215: nf=None
1216: for line in fh.readlines():
1217: #check if basket name is in the first line
1218: if line.find("#atf basket")>=0:
1219: ret=line.replace('#atf basket ','')
1220: ret=ret.split('_')[0]
1221: else:
1222: if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
1223: if nf:
1224: nf.close() #close last file
1225:
1226:
1227: filename=line[1:].split("=")[0].rstrip()+".atf"
1228: if dir:
1229: filename=os.path.join(dir,filename)
1230: nf=file(filename,"w")
1231: if nf:
1232: nf.write(line)
1233:
1234: nf.close()
1235: fh.close()
1236: return ret,len(os.listdir(dir))
1237:
1238:
1239: class CDLIFileFolder(versionedFileFolder):
1240: """CDLI File Folder"""
1241:
1242: security=ClassSecurityInfo()
1243: meta_type="CDLI Folder"
1244: filesMetaType=['CDLI file']
1245: folderMetaType=['CDLI Folder']
1246: default_catalog='CDLICatalog'
1247:
1248: def setTemp(self,name,value):
1249: """set tmp"""
1250:
1251: setattr(self,name,value)
1252:
1253:
1254: def delete(self,ids):
1255: """delete this file, i.e. move into a trash folder"""
1256:
1257: found=self.ZopeFind(self,obj_ids=['.trash'])
1258:
1259: if len(found)<1:
1260: manage_addCDLIFileFolder(self, '.trash',title="Trash")
1261: trash=self._getOb('.trash')
1262: else:
1263: trash=found[0][1]
1264:
1265: if type(ids) is not ListType:
1266: ids=[ids]
1267: cut=self.manage_cutObjects(ids)
1268: trash.manage_pasteObjects(cut)
1269:
1270: def getVersionNumbersFromIds(self,ids):
1271: """get the numbers of the current versions of documents described by their ids"""
1272:
1273: ret=[]
1274: searchStr=" OR ".join(ids)
1275:
1276: founds=self.CDLICatalog.search({'title':searchStr})
1277:
1278: for found in founds:
1279: lastVersion=found.getObject().getLastVersion()
1280: ret.append((found.getId,lastVersion))
1281:
1282: return ret
1283:
1284: def checkCatalog(self,fn):
1285: """check if fn is in the catalog"""
1286: #TODO add checkCatalog
1287:
1288: def refreshTxt(self,txt=""):
1289: """txt fuer refresh"""
1290:
1291: return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,self.threadName)
1292:
1293:
1294: def getResult(self):
1295: """result of thread"""
1296: try:
1297: return self._v_uploadATF.getResult()
1298: except:
1299: return "One moment, please"
1300:
1301: def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
1302: """standard ausgabe"""
1303: #self._v_uploadATF.returnValue=None
1304:
1305: threadName=repeat
1306: if not threadName or threadName=="":
1307: tmpVar=False
1308: thread=uploadATFThread()
1309: self._v_uploadATF=thread
1310: #self._xmltrans.start()
1311: #thread=Thread(target=self._v_uploadATF)
1312:
1313: self._v_uploadATF.set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
1314: #thread.start()
1315: self._v_uploadATF.start()
1316:
1317:
1318: self.threadName=self._v_uploadATF.getName()[0:]
1319: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
1320:
1321: if wait_template:
1322: return wait_template[0][1]()
1323: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1324: return pt(txt='/uploadATF')
1325: #_v_xmltrans.run()
1326:
1327: else:
1328: if not hasattr(self,'_v_uploadATF'):
1329: for thread in threading.enumerate():
1330: if threadName == thread.getName():
1331: self._v_uploadATF=thread
1332:
1333: if not self._v_uploadATF.returnValue:
1334:
1335:
1336: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
1337: if wait_template:
1338: return wait_template[0][1]()
1339:
1340: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1341:
1342: return pt(txt='/uploadATF')
1343:
1344: else:
1345:
1346: tmp=self._v_uploadATF.returnValue
1347: self._v_uploadATF.continueVar=False
1348:
1349: self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
1350: self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]
1351: self.REQUEST.SESSION['newPs']=tmp['newPs']
1352: self.REQUEST.SESSION['tmpdir']=tmp['dir']
1353:
1354: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
1355: return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
1356: basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
1357:
1358: def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
1359: """nowupload the files"""
1360:
1361:
1362:
1363: threadName=repeat
1364: if not threadName or threadName=="":
1365:
1366:
1367: self._v_uploadATF=uploadATFfinallyThread()
1368:
1369:
1370: self._v_uploadATF.set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
1371:
1372: self._v_uploadATF.start()
1373:
1374:
1375: self.threadName=self._v_uploadATF.getName()[0:]
1376: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
1377:
1378: if wait_template:
1379: return wait_template[0][1]()
1380: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1381:
1382: return pt(txt='/uploadATFfinally')
1383: #_v_xmltrans.run()
1384:
1385: else:
1386:
1387: if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :
1388:
1389: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
1390: if wait_template:
1391: return wait_template[0][1]()
1392:
1393: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1394: return pt(txt='/uploadATFfinally')
1395: else:
1396:
1397: if RESPONSE is not None:
1398: RESPONSE.redirect(self.aq_parent.absolute_url())
1399:
1400:
1401:
1402:
1403: def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
1404: """findObjectsFromList (, TAB oder LINE separated)"""
1405:
1406:
1407: if upload: # list from file upload
1408: txt=upload.read()
1409: txt=txt.replace(",","\n")
1410: txt=txt.replace("\t","\n")
1411: txt=txt.replace("\r","\n")
1412: idsTmp=txt.split("\n")
1413: ids=[]
1414: for id in idsTmp: # make sure that no empty lines
1415: idTmp=id.lstrip().rstrip()
1416: if len(idTmp)>0:
1417:
1418: ids.append(idTmp)
1419:
1420: #self.REQUEST.SESSION['ids']=" OR ".join(ids)
1421:
1422: pt=getattr(self,'filelist.html')
1423: self.REQUEST.SESSION['searchList']=ids
1424: return pt(search=ids)
1425:
1426: if basketName:
1427: #TODO: get rid of one of these..
1428:
1429: pt=getattr(self,'filelist.html')
1430: return pt(basketName=basketName,numberOfObjects=numberOfObjects)
1431:
1432: if list is not None: # got already a list
1433: ret=[]
1434: for fileId in list:
1435: if len(fileId.split("."))==1:
1436: fileId=fileId+".atf"
1437:
1438: ret+=self.CDLICatalog({'title':fileId})
1439: #TODO: get rid of one of these..
1440: self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage
1441: self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
1442: return ret
1443:
1444: if start:
1445: RESPONSE.redirect("filelist.html?start:int="+str(start))
1446:
1447:
1448:
1449: security.declareProtected('Manage','createAllFilesAsSingleFile')
1450: def createAllFilesAsSingleFile(self,RESPONSE=None):
1451: """download all files"""
1452:
1453: def sortF(x,y):
1454: return cmp(x[0],y[0])
1455:
1456: catalog=getattr(self,self.default_catalog)
1457: #tf,tfilename=mkstemp()
1458:
1459:
1460: list=[(x.getId,x) for x in catalog()]
1461: list.sort(sortF)
1462:
1463: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
1464: RESPONSE.setHeader("Content-Type","application/octet-stream")
1465:
1466: for l in list:
1467: obj=l[1].getObject()
1468:
1469: if obj.meta_type=="CDLI file":
1470:
1471: #os.write(tf,obj.getLastVersion().data)
1472: if RESPONSE:
1473: RESPONSE.write(obj.getLastVersion().data[0:])
1474: #os.close(tf)
1475: #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
1476: return True
1477:
1478: def downloadFile(self,fn):
1479: """download fn - not used yet"""
1480: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
1481: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
1482: self.REQUEST.RESPONSE.write(file(fn).read())
1483:
1484:
1485:
1486: def hasParent(self):
1487: """returns true falls subfolder"""
1488:
1489: if self.aq_parent.meta_type in self.folderMetaType:
1490: return True
1491: else:
1492: return False
1493:
1494: def getFolders(self):
1495: """get all subfolders"""
1496: ret=[]
1497: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
1498: for folder in folders:
1499: ret.append((folder[1],
1500: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
1501: len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
1502: ))
1503: return ret
1504:
1505:
1506: def getFolders_OLD(self):
1507: """get all subfolders"""
1508: ret=[]
1509: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
1510: for folder in folders:
1511: ret.append((folder[1],
1512: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
1513: len(getattr(self,self.default_catalog)({'path':folder[0]}))
1514: ))
1515: return ret
1516:
1517: def index_html(self):
1518: """main"""
1519: ext=self.ZopeFind(self,obj_ids=["index.html"])
1520: if ext:
1521: return ext[0][1]()
1522:
1523: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
1524: return pt()
1525:
1526: def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
1527: """import files"""
1528:
1529: if not files:
1530: files=os.listdir(folderName)
1531:
1532: for f in files:
1533: folder=f[0:3]
1534: f2=f[0:5]
1535: obj=self.ZopeFind(self,obj_ids=[folder])
1536: if ext:
1537:
1538: ext.result+="<p>Adding: %s </p>"%f
1539: if not obj:
1540: manage_addCDLIFileFolder(self,folder,folder)
1541: fobj=getattr(self,folder)
1542:
1543: else:
1544: fobj=obj[0][1]
1545:
1546: obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
1547:
1548: if not obj2:
1549: manage_addCDLIFileFolder(fobj,f2,f2)
1550: fobj2=getattr(fobj,f2)
1551:
1552: else:
1553: fobj2=obj2[0][1]
1554:
1555: file2=file(os.path.join(folderName,f))
1556: id=f
1557: manage_addCDLIFile(fobj2,f,'','')
1558: id=f
1559: ob=fobj2._getOb(f)
1560: ob.title=id
1561:
1562: manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
1563: self.CDLICatalog.catalog_object(ob)
1564: #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
1565: #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
1566:
1567: return "ok"
1568:
1569: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
1570:
1571:
1572: def manage_addCDLIFileFolder(self, id, title='',
1573: createPublic=0,
1574: createUserF=0,
1575: REQUEST=None):
1576: """Add a new Folder object with id *id*.
1577:
1578: If the 'createPublic' and 'createUserF' parameters are set to any true
1579: value, an 'index_html' and a 'UserFolder' objects are created respectively
1580: in the new folder.
1581: """
1582: ob=CDLIFileFolder()
1583: ob.id=str(id)
1584: ob.title=title
1585: self._setObject(id, ob)
1586: ob=self._getOb(id)
1587:
1588: checkPermission=getSecurityManager().checkPermission
1589:
1590: if createUserF:
1591: if not checkPermission('Add User Folders', ob):
1592: raise Unauthorized, (
1593: 'You are not authorized to add User Folders.'
1594: )
1595: ob.manage_addUserFolder()
1596:
1597:
1598: if REQUEST is not None:
1599: return self.manage_main(self, REQUEST, update_menu=1)
1600:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to cdli_files.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / cdli