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