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