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