1: """CDLI extensions of the filearchive"""
2: from Products.versionedFile.extVersionedFile 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: import urllib
10: import cgi
11: from OFS.OrderedFolder import OrderedFolder
12: from OFS.SimpleItem import SimpleItem
13: import time
14: from OFS.Folder import manage_addFolder
15: import re
16: from AccessControl import ClassSecurityInfo
17: from Acquisition import Implicit
18: from Globals import Persistent
19: from threading import Thread
20: from ZPublisher.HTTPRequest import HTTPRequest
21: from ZPublisher.HTTPResponse import HTTPResponse
22: from ZPublisher.BaseRequest import RequestContainer
23: import threading
24: from BTrees.OOBTree import OOBTree
25: import logging
26: import transaction
27:
28: def unique(s):
29: """Return a list of the elements in s, but without duplicates.
30:
31: For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
32: unique("abcabc") some permutation of ["a", "b", "c"], and
33: unique(([1, 2], [2, 3], [1, 2])) some permutation of
34: [[2, 3], [1, 2]].
35:
36: For best speed, all sequence elements should be hashable. Then
37: unique() will usually work in linear time.
38:
39: If not possible, the sequence elements should enjoy a total
40: ordering, and if list(s).sort() doesn't raise TypeError it's
41: assumed that they do enjoy a total ordering. Then unique() will
42: usually work in O(N*log2(N)) time.
43:
44: If that's not possible either, the sequence elements must support
45: equality-testing. Then unique() will usually work in quadratic
46: time.
47: (from the python cookbook)
48: """
49:
50: n = len(s)
51: if n == 0:
52: return []
53:
54: # Try using a dict first, as that's the fastest and will usually
55: # work. If it doesn't work, it will usually fail quickly, so it
56: # usually doesn't cost much to *try* it. It requires that all the
57: # sequence elements be hashable, and support equality comparison.
58: u = {}
59: try:
60: for x in s:
61: u[x] = 1
62: except TypeError:
63: del u # move on to the next method
64: else:
65: return u.keys()
66:
67: # We can't hash all the elements. Second fastest is to sort,
68: # which brings the equal elements together; then duplicates are
69: # easy to weed out in a single pass.
70: # NOTE: Python's list.sort() was designed to be efficient in the
71: # presence of many duplicate elements. This isn't true of all
72: # sort functions in all languages or libraries, so this approach
73: # is more effective in Python than it may be elsewhere.
74: try:
75: t = list(s)
76: t.sort()
77: except TypeError:
78: del t # move on to the next method
79: else:
80: assert n > 0
81: last = t[0]
82: lasti = i = 1
83: while i < n:
84: if t[i] != last:
85: t[lasti] = last = t[i]
86: lasti += 1
87: i += 1
88: return t[:lasti]
89:
90: # Brute force is all that's left.
91: u = []
92: for x in s:
93: if x not in u:
94: u.append(x)
95: return u
96:
97:
98: class BasketContent(SimpleItem):
99: """classe fuer den Inhalt eines Baskets"""
100:
101: def __init__(self,content=[]):
102: """content"""
103: self.contentList=content[0:]
104:
105: def getContent(self):
106: """get content"""
107:
108: return self.contentList
109:
110: def setContent(self,content):
111: self.contentList=content[0:]
112:
113: def numberOfItems(self):
114: """number"""
115:
116: return len(self.getContent())
117:
118:
119: class uploadATFfinallyThread(Thread):
120: """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
121:
122: def __init__(self):
123: """init for uploadATFfinallyThread"""
124: self.continueVar=True
125: self.returnValue=None
126: self.end=False
127: Thread.__init__(self)
128:
129: def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
130: """set start values for the thread"""
131: self.procedure=procedure
132: self.comment=comment
133: self.basketname=basketname
134: self.unlock=unlock
135: self.SESSION=SESSION
136: self.username=username
137: self.serverport=serverport
138:
139: def __call__(self):
140: """call of the thread (equals run)"""
141: self.run()
142: return True
143:
144: def getContext(self, app,serverport="8080"):
145: """get the context within the ZODB"""
146:
147: resp = HTTPResponse(stdout=None)
148: env = {
149: 'SERVER_NAME':'localhost',
150: 'SERVER_PORT':serverport,
151: 'REQUEST_METHOD':'GET'
152: }
153: req = HTTPRequest(None, env, resp)
154: return app.__of__(RequestContainer(REQUEST = req))
155:
156:
157: def run(self):
158: """run"""
159:
160: self.result=""
161: #find context within ZODB
162: from Zope import DB
163: conn = DB.open()
164: root = conn.root()
165: app = root['Application']
166: ctx = self.getContext(app,serverport=self.serverport)
167:
168: #add the files
169: self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
170: #commit the transactions
171: transaction.get().commit()
172: conn.close()
173: #set flag for end of this method
174: self.end=True
175: print "ended"
176: return True
177:
178: def __del__(self):
179: """delete"""
180:
181:
182:
183: def getResult(self):
184: """method for accessing result"""
185:
186: return self.result
187:
188: def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
189: """upload the files"""
190: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
191: ctx2=ctx.cdliRoot
192:
193: self.result+="<h2>Start processing</h2>"
194:
195: #shall I only upload the changed files?
196: if procedure=="uploadchanged":
197:
198: uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
199:
200: #or all
201: elif procedure=="uploadAll":
202: uploadFns=[]
203: for x in os.listdir(SESSION['tmpdir']):
204: if not x in SESSION['lockerrors']:
205: uploadFns.append(x)
206:
207: #or maybe nothing
208: elif procedure=="noupload":
209: return True
210: else:
211: uploadFns=[]
212:
213: #do first the changed files
214: for fn in uploadFns:
215: founds=ctx2.CDLICatalog.search({'title':fn})
216: if len(founds)>0:
217: SESSION['author']=str(username)
218: self.result+="<p>Changing : %s"%fn
219: founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
220:
221:
222: #now add the new files
223: newPs=SESSION['newPs']
224: if len(newPs)>0:
225: tmpDir=SESSION['tmpdir']
226: self.result+="<p>Adding files</p>"
227: #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
228:
229: ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
230:
231:
232:
233: #unlock locked files?
234: if unlock:
235: self.result+="<p>Unlock files</p>"
236: unlockFns=[]
237: for x in os.listdir(SESSION['tmpdir']):
238: if not x in SESSION['errors']:
239: unlockFns.append(x)
240:
241: for fn in unlockFns:
242: founds=ctx2.CDLICatalog.search({'title':fn})
243: if len(founds)>0:
244: SESSION['author']=str(username)
245:
246: founds[0].getObject().lockedBy=""
247:
248: #if a basketname is give, add files to the basket
249: if not (basketname ==''):
250: self.result+="<p>Add basket</p>"
251: basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
252:
253: if not basketId: # create new basket
254: ob=ctx2.basketContainer.addBasket(basketname)
255: basketId=ob.getId()
256: basket=getattr(ctx2.basketContainer,str(basketId))
257: ids=os.listdir(SESSION['tmpdir'])
258: basket.addObjects(ids,deleteOld=True,username=str(username))
259:
260: if RESPONSE is not None:
261: RESPONSE.redirect(self.aq_parent.absolute_url())
262:
263:
264:
265: return True
266:
267: class uploadATFThread(Thread):
268: """class for checking the files befor uploading"""
269:
270: def __init__(self):
271: """initialise"""
272:
273: self.continueVar=True
274: self.returnValue=None
275:
276: Thread.__init__(self)
277:
278:
279: def set(self,upload,basketId,username,serverport="8080"):
280: """set start values for the thread"""
281: self.result=""
282: self.upload=upload
283: self.basketId=basketId
284: self.username=username
285: self.serverport=serverport
286:
287: def __call__(self):
288: """call method """
289: self.run()
290: return True
291:
292: def getContext(self, app,serverport="8080"):
293: """get the context within the ZODB"""
294: resp = HTTPResponse(stdout=None)
295: env = {
296: 'SERVER_NAME':'localhost',
297: 'SERVER_PORT':serverport,
298: 'REQUEST_METHOD':'GET'
299: }
300: req = HTTPRequest(None, env, resp)
301: return app.__of__(RequestContainer(REQUEST = req))
302:
303: def run(self):
304:
305: self.result=""
306: #find context within ZODB
307: from Zope import DB
308: conn = DB.open()
309: root = conn.root()
310: app = root['Application']
311: ctx = self.getContext(app,serverport=self.serverport)
312: self.uploadATFThread(ctx,self.upload,self.basketId)
313:
314: #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
315:
316:
317: transaction.get().commit()
318: while self.continueVar:
319: pass
320:
321: conn.close()
322:
323:
324: def getResult(self):
325: """method for accessing result"""
326: return self.result
327:
328: def uploadATFThread(self,ctx,upload,basketId=0):
329: """upload an atf file"""
330: #TODO: add comments
331: #TODO: finish uploadATF
332: self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
333:
334: #make sure that id is a string and not an integer
335: basketId=str(basketId)
336:
337: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
338: ctx2=ctx.cdliRoot
339:
340: #get temporary file for staging the downloaded and splitted files
341: dir=mkdtemp()
342:
343:
344: changed=[] # changed files
345: errors=[] # files with errors
346: lockerrors=[] # files with errors
347:
348: newPs=[] # new p filed
349: psNotInCatalog=[] # files not in the catalog
350:
351: #split the uploadedd atf file
352: basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
353:
354: #find basketId if not set
355:
356: #get active abaket
357: if basketId == '0':
358: basketObj=ctx2.basketContainer.getActiveBasket()
359: if basketObj:
360: basketId=basketObj.getId()
361:
362: #if there is no active basket and no basketid given, id is empty, else get besketname and length
363: if basketId == '0':
364: basketNameFromId=""
365: basketLen=0
366: else:
367: basketNameFromId=getattr(ctx2.basketContainer,basketId).title
368: basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
369:
370:
371: self.result+="""<html><body><h2>I got the files</h2><
372: p>I am computing the differences to the exisiting files</p>"""
373:
374: #start to check the files
375: for fn in os.listdir(dir):
376:
377: self.result+="<p>process:%s</p>"%fn
378:
379: # check if file is in the catalog
380: #TODO: checkCatalog is not implemented yet
381: if ctx2.cdli_main.checkCatalog(fn):
382: psNotInCatalog.append(fn)
383:
384: #check if p-file already at the server
385: founds=ctx2.CDLICatalog.search({'title':fn})
386:
387: #if not than add filename to the list of newfiles
388:
389: data=file(os.path.join(dir,fn)).read()
390: #status,msg=checkFile(fn,data,dir)
391: status=True
392: msg=""
393: if not status: # error
394: errors.append((fn,msg))
395: else:
396: if len(founds)==0:
397: newPs.append(fn)
398:
399: #if p file alread at the server
400: for found in founds:
401: #analyse the differences to the actual file
402: obj=found.getObject()
403:
404: if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
405: lockerrors.append(fn)
406: else:
407:
408: diffs=obj.diff(data)
409: if diffs[0]>0:
410: changed.append((obj,diffs)) #hochladen
411:
412: #ready, set the returnValues
413: self.result+="<h3>Done</h3></body></html>"
414:
415: self.returnValue={}
416: self.returnValue['changed']=changed
417: self.returnValue['errors']=errors
418: self.returnValue['lockerrors']=lockerrors
419: self.returnValue['newPs']=newPs
420: self.returnValue['tmpdir']=dir
421: self.returnValue['basketLen']=basketLen
422: self.returnValue['numberOfFiles']=numberOfFiles
423: self.returnValue['basketNameFromId']=basketNameFromId
424: self.returnValue['basketNameFromFile']=basketNameFromFile
425: self.returnValue['basketId']=basketId
426: self.returnValue['dir']=dir
427:
428: #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
429:
430:
431: class Basket_old(Folder):
432: """shopping basket - alte fassung """
433:
434: meta_type="Basket"
435: _v_stack={}
436:
437: def getObjUrl(self,objId):
438: """getUrl"""
439: founds=self.CDLICatalog.search({'title':objId})
440: if len(founds)>0:
441: return founds[0].getObject().absolute_url()
442:
443: else: #assume version number
444: splitted=objId.split("_")
445: founds=self.CDLICatalog.search({'title':splitted[1]})
446: return founds[0].getObject().absolute_url()+'/'+objId
447:
448: def storeAllLink(self,results):
449: """erzeuge link zum speicher aller results"""
450: nr=self.REQUEST['_ZopeId']
451:
452: if results:
453: self._v_stack[nr]=[x.getObject().getId() for x in results]
454:
455: return self.absolute_url()+"/storeAll?id="+nr
456:
457: def storeAll(self,id):
458: """store all"""
459: try:
460: results=self._v_stack[id]
461: except:
462: #TODO: write expired page
463: return "expired"
464:
465: return self.storeInBasketForm(results)
466:
467: def storeInBasketForm(self,ids):
468: """ store an object form"""
469:
470: if type(ids) is not ListType:
471: ids=[ids]
472: self.REQUEST.SESSION['ids']=ids[0:]
473:
474: self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']
475:
476: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
477: return pt()
478:
479: def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
480: """store it"""
481:
482: if not ids:
483: ids=REQUEST.SESSION['ids']
484:
485: self.REQUEST.SESSION['basketUser']=username
486:
487: baskets=self.ZopeFind(self,obj_ids=[username])
488: if len(baskets)>0:
489: basket=baskets[0][1]
490: else:
491: manage_addBasketObject(self,username)
492: basket=self._getOb(username)
493:
494:
495: basket.addObjects(ids)
496: back=self.REQUEST.SESSION.get('BACKLINK', None)
497:
498: if RESPONSE:
499: RESPONSE.redirect(back)
500:
501:
502:
503: def showBasket(self,user=None,set=None,RESPONSE=None):
504: """show the basket"""
505:
506: if user:
507: self.REQUEST.SESSION['basketUser']=user
508:
509: if not user and not set:
510: user=self.REQUEST.SESSION.get('basketUser',None)
511:
512: if not user:
513: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
514: return pt()
515: else:
516: baskets=self.ZopeFind(self,obj_ids=[user])
517:
518:
519: if len(baskets)>0:
520: RESPONSE.redirect(baskets[0][1].absolute_url())
521: return True
522: else:
523: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
524: return pt()
525:
526:
527: def manage_addBasket_oldForm(self):
528: """add the basket form"""
529: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
530: return pt()
531:
532: def manage_addBasket_old(self,id,title,RESPONSE=None):
533: """add the basket"""
534: ob=Basket()
535:
536: ob.id=str(id)
537: ob.title=title
538: self._setObject(id, ob)
539: ob=self._getOb(id)
540:
541: if RESPONSE is not None:
542: RESPONSE.redirect('manage_main')
543:
544:
545: class BasketObject_old(Folder):
546: """Basket Object - alte fassung"""
547:
548: meta_type="basketObject"
549: def __init__(self):
550: """init basket object"""
551: self.contents=[]
552:
553: def numberOfItems(self):
554: """return anzahl der elemente im basket"""
555: num=len(self.contents)
556:
557: return num
558:
559: def addObjects(self,ids):
560: """addObjects"""
561:
562: for id in ids:
563: founds=self.CDLICatalog.search({'title':id})
564: for found in founds:
565: if found.getObject() not in self.contents:
566: tm=self.contents[0:]
567: tm.append(found.getObject())
568: self.contents=tm[0:]
569:
570: return True
571:
572: def index_html(self):
573: """view the basket"""
574: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
575: return pt()
576:
577: def deleteObjects(self,ids,RESPONSE=None):
578: """delete objects"""
579: list = self.contents[0:]
580: for content in list:
581:
582: if content.getId() in ids:
583: self.contents.remove(content)
584:
585:
586: if RESPONSE:
587: RESPONSE.redirect(self.absolute_url())
588:
589:
590: def unlockTest(self):
591: """unlock all files of the testuser for debuggin"""
592: for object in self.contents:
593:
594: if str(object.lockedBy)=="test":
595: object.lockedBy=""
596:
597: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
598: """download all selected files in one file"""
599:
600: ret=""
601: lockedObjects={}
602:
603: if self.temp_folder.downloadCounter > 10:
604: return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
605:
606:
607: if lock:
608:
609: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
610:
611: return "please login first"
612:
613: #check if a locked object exist in the basket.
614: lockedObjects={}
615: for object in self.contents:
616:
617: if not object.lockedBy=="":
618: lockedObjects[object.title]=repr(object.lockedBy)
619:
620:
621: keys=lockedObjects.keys()
622:
623:
624: if len(keys)>0 and (not procedure):
625: self.REQUEST.SESSION['lockedObjects']=lockedObjects
626: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
627: return pt()
628:
629: elif not procedure: #keine fails gesperrt dann alle donwloaden
630: procedure="downloadAll"
631:
632: self.temp_folder.downloadCounter+=1
633: self._p_changed=1
634:
635: transaction.get().commit()
636:
637: for object in self.contents:
638:
639: if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
640: ret+=object.getLastVersion().getData()
641:
642: if lock and object.lockedBy=='':
643: object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
644:
645:
646: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
647: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
648: length=len(ret)
649: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
650: self.REQUEST.RESPONSE.write(ret)
651: self.temp_folder.downloadCounter-=1
652: self._p_changed=1
653: transaction.get().commit()
654:
655:
656:
657: def manage_addBasket_oldObjectForm(self):
658: """add form"""
659: pass
660:
661: def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
662: """add"""
663:
664: ob=BasketObject()
665:
666: ob.id=str(id)
667: ob.title=title
668: self._setObject(id, ob)
669: ob=self._getOb(id)
670:
671: if RESPONSE is not None:
672: RESPONSE.redirect('manage_main')
673:
674:
675: class CDLIBasketContainer(OrderedFolder):
676: """contains the baskets"""
677:
678:
679: security=ClassSecurityInfo()
680: meta_type="CDLIBasketContainer"
681:
682: def upDateBaskets(self):
683: """update content in to objects"""
684:
685: founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
686:
687: for found in founds:
688: found[1].updateBasket()
689:
690: security.declareProtected('manage','deleteBaskets')
691: def deleteBaskets(self,ids=None):
692: """delete baskets, i.e. move them into trash folder"""
693:
694:
695: found=self.ZopeFind(self,obj_ids=['trash'])
696:
697: if len(found)<1:
698: manage_addFolder(self, 'trash')
699: trash=self._getOb('trash')
700: else:
701: trash=found[0][1]
702:
703: if type(ids) is not ListType:
704: ids=[ids]
705: cut=self.manage_cutObjects(ids)
706: trash.manage_pasteObjects(cut)
707:
708: security.declareProtected('manage','manageBaskets')
709: def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
710: """manage baskets, delete or copy"""
711: if submit=="delete":
712: self.deleteBaskets(ids)
713:
714:
715:
716: if RESPONSE:
717: RESPONSE.redirect(self.absolute_url())
718:
719: security.declareProtected('View','getBasketIdfromName')
720: def getBasketIdfromName(self,basketname):
721: """get id from name"""
722:
723: for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
724: if basket[1].title==basketname:
725: return basket[0]
726: else:
727: None
728:
729: security.declareProtected('manage','uploadBasket_html')
730:
731: def uploadBasket_html(self,basketId='0'):
732: """upload an atf file, html form"""
733:
734:
735: basketId=str(basketId)
736: if not basketId=='0':
737: basketName=getattr(self.basketContainer,basketId).title
738: else:
739: basketName=""
740:
741: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
742: return pt(basketId=basketId,basketName=basketName)
743:
744:
745: security.declareProtected('View','index_html')
746: def index_html(self):
747: """stanadard ansicht"""
748:
749:
750:
751: ext=self.ZopeFind(self,obj_ids=["index.html"])
752: if ext:
753: return ext[0][1]()
754:
755: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
756: return pt()
757:
758: def getStorageFolderRoot(self):
759: """root des storage folders"""
760: return self.cdli_main
761:
762: def __init__(self,id,title):
763: """ init basket container"""
764: self.id=id
765: self.title=title
766:
767:
768: def getBasketsId(self):
769: """get all baskets als klartext"""
770:
771: ret=""
772: baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
773: for basket in baskets:
774: com,user,time,values = basket[1].getContentIds()
775: ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"
776: for x in values:
777: ret+= x[0]+"\t"+x[1]+"\n"
778: return ret
779:
780: def getBaskets(self,sortField='title'):
781: """get all baskets files"""
782:
783: def sortName(x,y):
784: return cmp(x[1].title.lower(),y[1].title.lower())
785:
786: def sortDate(x,y):
787: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
788:
789:
790: def sortComment(x,y):
791:
792:
793:
794: try:
795: xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
796: except:
797: xc='ZZZZZZZZZZZZZ'.lower()
798: try:
799: yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
800: except:
801: yc='ZZZZZZZZZZZZZ'.lower()
802:
803:
804: if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
805:
806: try:
807: xc=x[1].getLastVersion().getComment().lower()
808: except:
809: xc='ZZZZZZZZZZZZZ'.lower()
810:
811: if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
812: try:
813: yc=y[1].getLastVersion().getComment().lower()
814: except:
815: yc='ZZZZZZZZZZZZZ'.lower()
816:
817:
818: return cmp(xc,yc)
819:
820: def sortAuthor(x,y):
821:
822: return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
823:
824: baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
825:
826:
827: if sortField=='title':
828: baskets.sort(sortName)
829: elif sortField=='date':
830: baskets.sort(sortDate)
831: elif sortField=='author':
832: baskets.sort(sortAuthor)
833: elif sortField=='comment':
834: baskets.sort(sortComment)
835:
836: return baskets
837:
838:
839:
840: def getNewId(self):
841: """createIds"""
842: last=getattr(self,'last',0)
843: last +=1
844: while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
845: last+=1
846:
847: self.last=last
848: return last
849:
850: def setActiveBasket(self,basketId,REQUEST=None):
851: """store active basketId in a cookie"""
852: self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
853: try:
854: qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
855: del(qs['basketId'])
856: except:
857: qs={}
858: if REQUEST:
859: REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
860:
861: def getActiveBasket(self):
862: """get active basket from cookie"""
863:
864: id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
865: if id:
866: obj=getattr(self,str(id),None)
867: else:
868: obj=None
869: return obj
870:
871: def getActualUserName(self):
872: """get name of the actualuser"""
873: return str(self.REQUEST['AUTHENTICATED_USER'])
874:
875:
876: def addBasket(self,newBasketName):
877: """add a new basket"""
878:
879: ob=manage_addCDLIBasket(self,newBasketName)
880: return ob
881:
882: def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
883: """store it"""
884: if not ids:
885: ids=self.REQUEST.SESSION['fileIds']
886:
887: if type(ids) is not ListType:
888: ids=[ids]
889:
890: if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
891: basketRet=self.addBasket(newBasketName)
892: self.setActiveBasket(basketRet.getId())
893: basket=getattr(self,basketRet.getId())
894: elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
895: basket=self.getActiveBasket()
896:
897: added=basket.addObjects(ids)
898: back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
899:
900:
901: if fromFileList:
902:
903: return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
904:
905: if RESPONSE:
906:
907: RESPONSE.redirect(back)
908:
909: return True
910:
911: def manage_addCDLIBasketContainerForm(self):
912: """add the CDLIBasketContainer form"""
913: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
914: return pt()
915:
916: def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
917: """add the basket"""
918: ob=CDLIBasketContainer(id,title)
919:
920: self._setObject(id, ob)
921:
922: if RESPONSE is not None:
923: RESPONSE.redirect('manage_main')
924:
925: class CDLIBasket(Folder,CatalogAware):
926: """basket"""
927:
928: meta_type="CDLIBasket"
929: default_catalog="CDLIBasketCatalog"
930:
931:
932: def getFile(self,obj):
933: return obj[1]
934:
935: def getFileLastVersion(self,obj):
936: return obj[0]
937:
938: def getFileNamesInLastVersion(self):
939: """get content of the last version as list"""
940:
941: return [x[1].getId() for x in self.getLastVersion().getContent()]
942:
943:
944: def isActual(self,obj):
945: """teste ob im basket die aktuelle version ist"""
946: actualNo=obj[1].getLastVersion().getVersionNumber()
947: storedNo=obj[0].getVersionNumber()
948:
949: founds=self.CDLICatalog.search({'title':obj[0].getId()})
950: if len(founds)>0:
951: actualNo=founds[0].getObject().getLastVersion().getVersionNumber()
952:
953: if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
954: return False, -1
955:
956: if actualNo==storedNo:
957: return True , 0
958: else:
959: return False, actualNo
960:
961: def history(self):
962: """history"""
963:
964: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
965: if ext:
966: return getattr(self,ext[0][1].getId())()
967:
968: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)
969: return pt()
970:
971: def getStorageFolderRoot(self):
972: """root des storage folders"""
973: return self.aq_parent.cdli_main
974:
975: def __init__(self,id,title,shortDescription="",comment=""):
976: """init a CDLIBasket"""
977:
978: self.id=id
979: self.title=title
980: self.shortDescription=shortDescription
981: self.comment=comment
982:
983:
984:
985: def getLastVersion(self):
986: """hole letzte version"""
987:
988: ids=[]
989: idsTmp= self.objectIds()
990: for x in idsTmp:
991: try:
992: ids.append(int(x))
993: except:
994: pass
995: ids.sort()
996:
997: if len(ids)==0:
998: return None
999: else:
1000: ob=getattr(self,str(ids[-1]))
1001:
1002:
1003: return ob
1004:
1005: def getVersions(self):
1006: """get versions"""
1007: versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
1008: return versions
1009:
1010:
1011: def updateObjects(self,ids,RESPONSE=None,REQUEST=None):
1012: """update ids, ids not in the basket the add"""
1013: if type(ids) is not ListType:
1014: ids=[ids]
1015:
1016: lastVersion=self.getLastVersion()
1017: oldContent=lastVersion.content.getContent()
1018: newContent=[]
1019:
1020: #first copy the old
1021: for obj in oldContent:
1022: if obj[1].getId() not in ids:
1023: newContent.append(obj)
1024: #now add the new
1025:
1026: for id in ids:
1027: founds=self.CDLICatalog.search({'title':id})
1028:
1029: for found in founds:
1030: if found.getObject() not in oldContent:
1031: #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
1032: newContent.append((found.getObject().getLastVersion(),found.getObject()))
1033:
1034:
1035: content=newContent
1036: user=self.getActualUserName()
1037:
1038: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
1039:
1040: obj=self._getOb(ob.getId())
1041: if RESPONSE:
1042:
1043: RESPONSE.redirect(obj.absolute_url())
1044:
1045: return obj
1046:
1047: def addObjects(self,ids,deleteOld=None,username=None):
1048: """generate a new version of the basket with objects added"""
1049:
1050: lastVersion=self.getLastVersion()
1051:
1052: if lastVersion is None:
1053: oldContent=[]
1054: else:
1055: oldContent=lastVersion.content.getContent()
1056:
1057: if deleteOld:
1058: oldContent=[]
1059:
1060: newContent=[]
1061: added=0
1062: for id in ids:
1063: try:
1064: founds=self.CDLICatalog.search({'title':id})
1065: except:
1066: founds=[]
1067: for found in founds:
1068: if found.getObject() not in oldContent:
1069: #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
1070: newContent.append((found.getObject().getLastVersion(),found.getObject()))
1071: added+=1
1072:
1073: content=oldContent+newContent
1074: if not username:
1075: user=self.getActualUserName()
1076: else:
1077: user = username
1078:
1079: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
1080:
1081: return added
1082:
1083:
1084:
1085:
1086: def getContentIds(self):
1087: """print basket content"""
1088: ret=[]
1089: lv=self.getLastVersion()
1090: for obj in lv.content.getContent():
1091: ret.append((obj[0].getId(),obj[1].getId()))
1092:
1093:
1094: return lv.getComment(),lv.getUser(),lv.getTime(),ret
1095:
1096: def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
1097: """change a basket"""
1098: if submit=="update":
1099: return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
1100: elif submit=="delete":
1101: return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
1102:
1103: def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
1104: """delete objects"""
1105:
1106: if type(ids) is not ListType:
1107: ids=[ids]
1108:
1109: lastVersion=self.getLastVersion()
1110: oldContent=lastVersion.content.getContent()
1111: newContent=[]
1112: for obj in oldContent:
1113: if obj[1].getId() not in ids:
1114: newContent.append(obj)
1115:
1116:
1117: user=self.getActualUserName()
1118:
1119: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
1120:
1121: if RESPONSE:
1122: obj=self._getOb(ob.getId())
1123: RESPONSE.redirect(obj.absolute_url())
1124:
1125: def manage_addCDLIBasketForm(self):
1126: """add the CDLIBasketContainer form"""
1127: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
1128: return pt()
1129:
1130: def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
1131: """add the basket"""
1132:
1133: id=str(self.getNewId())
1134:
1135: ob=CDLIBasket(id,title,shortDescription,comment)
1136:
1137: self._setObject(id, ob)
1138:
1139: if RESPONSE is not None:
1140: RESPONSE.redirect('manage_main')
1141: else:
1142: return ob
1143:
1144: class CDLIBasketVersion(Implicit,Persistent,Folder):
1145: """version of a basket"""
1146:
1147: meta_type="CDLIBasketVersion"
1148: security=ClassSecurityInfo()
1149:
1150: def updateBasket(self):
1151: """update"""
1152: try:
1153: self._setObject('content',BasketContent(self.basketContent))
1154: except:
1155: try:
1156: if len(self.basketContent)>0:
1157: self.content.setContent(self.basketContent)
1158: except:
1159: print "error",self.getId(),self.aq_parent.getId()
1160: self.basketContent=[]
1161:
1162:
1163: def containsNonActualFiles(self):
1164: """returns True if basket contains one or more non current files"""
1165:
1166: objs=self.getContent()
1167: for obj in objs:
1168: if not self.isActual(obj)[0]:
1169: return True
1170: return False
1171:
1172: security.declareProtected('View','downloadObjectsAsOneFile')
1173: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
1174: """download all selected files in one file"""
1175:
1176: if self.temp_folder.downloadCounterBaskets > 10000:
1177: return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
1178:
1179:
1180: if (check=="yes") and self.containsNonActualFiles():
1181: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
1182:
1183: return pt(lock=lock)
1184:
1185: else:
1186:
1187: return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
1188:
1189: def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):
1190: """print do the download"""
1191:
1192: ret=""
1193: lockedObjects={}
1194:
1195: self.temp_folder.downloadCounterBaskets+=1
1196: self._p_changed=1
1197: get_transaction().commit()
1198:
1199: if lock:
1200:
1201: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
1202: self.temp_folder.downloadCounterBaskets-=1
1203: self._p_changed=1
1204: transaction.get().commit()
1205: self.temp_folder.downloadCounterBaskets-=1
1206: self._p_changed=1
1207: transaction.get().commit()
1208: return "please login first"
1209:
1210: #check if a locked object exist in the basket.
1211: lockedObjects={}
1212: for object in self.content.getContent():
1213:
1214: if not object[1].lockedBy=="":
1215: lockedObjects[object[1].title]=repr(object[1].lockedBy)
1216:
1217:
1218: keys=lockedObjects.keys()
1219:
1220:
1221: if len(keys)>0 and (not procedure):
1222: self.REQUEST.SESSION['lockedObjects']=lockedObjects
1223: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
1224:
1225: self.temp_folder.downloadCounterBaskets-=1
1226: self._p_changed=1
1227: transaction.get().commit()
1228:
1229: return pt()
1230:
1231: elif not procedure: #keine fails gesperrt dann alle donwloaden
1232: procedure="downloadAll"
1233:
1234:
1235:
1236:
1237: for object in self.content.getContent():
1238:
1239: if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
1240: if current=="no": #version as they are in the basket
1241: ret+=str(object[0].getData())+"\n"
1242: elif current=="yes":
1243: #search current object
1244: founds=self.CDLICatalog.search({'title':object[0].getId()})
1245: if len(founds)>0:
1246: ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
1247:
1248: if lock and object[1].lockedBy=='':
1249: object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
1250: basket_name=self.aq_parent.title+"_V"+self.getId()
1251:
1252: #write basketname to header of atf file
1253: ret="#basket: %s\n"%basket_name+ret
1254:
1255: self.temp_folder.downloadCounterBaskets-=1
1256: self._p_changed=1
1257: transaction.get().commit()
1258:
1259: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
1260: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
1261: length=len(ret)
1262: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
1263: self.REQUEST.RESPONSE.write(ret)
1264: return True
1265:
1266: def numberOfItems(self):
1267: """return anzahl der elemente im basket"""
1268: return self.content.numberOfItems()
1269:
1270: def getTime(self):
1271: """getTime"""
1272: #return self.bobobase_modification_time().ISO()
1273:
1274: if hasattr(self,'time'):
1275: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
1276: elif hasattr(self,'timefixed'):
1277: return self.timefixed
1278: else:
1279: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
1280: return self.bobobase_modification_time().ISO()
1281:
1282: def getContent(self):
1283: """get Basket Content"""
1284: return self.content.getContent()
1285:
1286:
1287: def __init__(self,id,user,comment="",basketContent=[]):
1288: """ init a basket version"""
1289: self.id=id
1290: self.coment=comment
1291: self._setObject('content',BasketContent(basketContent))
1292: #self.basketContent=basketContent[0:]a
1293: self.user=user
1294: self.time=time.localtime()
1295:
1296: def getUser(self):
1297: """get user"""
1298: return self.user
1299:
1300: def getComment(self):
1301: """get Comment"""
1302: return self.comment
1303:
1304: security.declareProtected('View','index_html')
1305: def index_html(self):
1306: """view the basket"""
1307:
1308: if self.REQUEST.get('change',False):
1309: ob=self.aq_parent.updateObjects(self.REQUEST['change'])
1310:
1311: self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
1312:
1313: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
1314: return pt()
1315:
1316: def getObjUrl(self,result):
1317: """getUrl of the version of the object"""
1318: objId=result[1].getTitle()
1319: founds=self.CDLICatalog.search({'title':objId})
1320: if len(founds)>0:
1321: return founds[0].getObject().getLastVersion().absolute_url()
1322:
1323: else: #assume version number
1324: splitted=objId.split("_")
1325: founds=self.CDLICatalog.search({'title':splitted[1]})
1326: return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
1327:
1328: def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
1329: """add a version"""
1330:
1331: #check for already existing versions
1332:
1333: lastVersion=self.getLastVersion()
1334: if lastVersion is None:
1335: newId=str(1)
1336: else:
1337: newId=str(int(lastVersion.getId())+1)
1338:
1339: ob=CDLIBasketVersion(newId,user,comment,basketContent)
1340:
1341: self._setObject(newId, ob)
1342:
1343: if RESPONSE is not None:
1344: RESPONSE.redirect('manage_main')
1345: else:
1346: return ob
1347:
1348: class CDLIFileObject(CatalogAware,extVersionedFileObject):
1349: """CDLI file object"""
1350:
1351: meta_type="CDLI File Object"
1352: default_catalog='CDLIObjectsCatalog'
1353:
1354: security=ClassSecurityInfo()
1355:
1356:
1357: security.declarePublic('makeThisVersionCurrent')
1358:
1359: def PrincipiaSearchSource(self):
1360: """Return cataloguable key for ourselves."""
1361: return str(self)
1362:
1363: def makeThisVersionCurrent_html(self):
1364: """form for making this version current"""
1365:
1366: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
1367: return pt()
1368: def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
1369: """copy this version to current"""
1370: parent=self.aq_parent
1371:
1372:
1373: newversion=parent.manage_addCDLIFileObject('',comment,author)
1374: newversion.data=self.data[0:]
1375:
1376: if RESPONSE is not None:
1377: RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
1378:
1379:
1380: return True
1381:
1382: security.declarePublic('view')
1383:
1384: def getFormattedData(self):
1385: """fromat text"""
1386: data=self.getData()
1387: return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
1388:
1389: def view(self):
1390: """view file"""
1391: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
1392: return pt()
1393:
1394: security.declarePublic('getPNumber')
1395: def getPNumber(self):
1396: """get the pnumber"""
1397: try:
1398: txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
1399: except:
1400: txt=self.getData()[0:]
1401:
1402: return "ERROR"
1403: try:
1404: return "P"+txt.group(1)
1405: except:
1406: return "ERROR"
1407:
1408: security.declarePublic('getDesignation')
1409: def getDesignation(self):
1410: """get the designation out of the file"""
1411: try:
1412: txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
1413: except:
1414: txt=self.getData()[0:]
1415:
1416: return "ERROR"
1417: try:
1418: return txt.group(2)
1419: except:
1420: return "ERROR"
1421:
1422: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
1423:
1424: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
1425: from_tmp=False,REQUEST=None):
1426: """Add a new File object.
1427:
1428: Creates a new File object 'id' with the contents of 'file'"""
1429:
1430: id=str(id)
1431: title=str(title)
1432: content_type=str(content_type)
1433: precondition=str(precondition)
1434:
1435: id, title = cookId(id, title, file)
1436:
1437: self=self.this()
1438:
1439: # First, we create the file without data:
1440: self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
1441: self._getOb(id).versionComment=str(vC)
1442: self._getOb(id).time=time.localtime()
1443:
1444: setattr(self._getOb(id),'author',author)
1445:
1446:
1447: # Now we "upload" the data. By doing this in two steps, we
1448: # can use a database trick to make the upload more efficient.
1449:
1450: if file and not from_tmp:
1451: self._getOb(id).manage_upload(file)
1452: elif file and from_tmp:
1453: self._getOb(id).manage_upload_from_tmp(file)
1454: if content_type:
1455: self._getOb(id).content_type=content_type
1456:
1457: self.reindex_object()
1458: self._getOb(id).reindex_object()
1459:
1460: if REQUEST is not None:
1461: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
1462:
1463: class CDLIFile(extVersionedFile,CatalogAware):
1464: """CDLI file"""
1465:
1466: meta_type="CDLI file"
1467: default_catalog='CDLICatalog'
1468:
1469: #security.declarePublic('history')
1470: def getLastVersionData(self):
1471: """get last version data"""
1472: return self.getLastVersion().getData()
1473:
1474: def getLastVersionFormattedData(self):
1475: """get last version data"""
1476: return self.getLastVersion().getFormattedData()
1477:
1478: #security.declarePublic('history')
1479:
1480:
1481: def history(self):
1482: """history"""
1483:
1484: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
1485: if ext:
1486: return getattr(self,ext[0][1].getId())()
1487:
1488: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
1489: return pt()
1490:
1491:
1492: def getBasketFromId(self,basketid, context=None):
1493: """get basket from id"""
1494:
1495: if not context:
1496: context=self
1497:
1498: for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
1499: if basket[0]==basketid:
1500: return basket[1]
1501: else:
1502: None
1503:
1504:
1505: def isContainedInBaskets(self,context=None):
1506: """check is this file is part of any basket
1507: @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
1508: has to exist.
1509: """
1510:
1511: if not context:
1512: context=self
1513:
1514: ret=[]
1515: for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
1516: #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
1517: try:
1518: ret.append(x.getObject())
1519: except:
1520: pass
1521: return ret
1522: #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
1523:
1524:
1525: def addCDLIFileObjectForm(self):
1526: """add a new version"""
1527:
1528: if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
1529: return "please login first"
1530: if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
1531: out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
1532: return out()
1533: else:
1534: return "Sorry file is locked by somebody else"
1535:
1536: def manage_addCDLIFileObject(self,id,vC,author,
1537: file='',title='',
1538: precondition='',
1539: content_type='',
1540: changeName='no',newName='',
1541: come_from=None,
1542: from_tmp=False,RESPONSE=None):
1543: """add"""
1544:
1545: try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
1546: vC=self.REQUEST['vC']
1547: except:
1548: pass
1549:
1550:
1551: if changeName=="yes":
1552: filename=file.filename
1553: self.title=filename[max(filename.rfind('/'),
1554: filename.rfind('\\'),
1555: filename.rfind(':'),
1556: )+1:]
1557:
1558:
1559: if not newName=='':
1560: self.title=newName[0:]
1561:
1562:
1563:
1564:
1565: positionVersionNum=getattr(self,'positionVersionNum','front')
1566:
1567: if positionVersionNum=='front':
1568: id="V%i"%self.getVersion()+"_"+self.title
1569: else:
1570: tmp=os.path.splitext(self.title)
1571: if len(tmp)>1:
1572: id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]
1573: else:
1574: id=tmp[0]+"_V%i"%self.getVersion()
1575:
1576:
1577: manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type,from_tmp=from_tmp)
1578: #objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
1579: objs=getattr(self,id).setVersionNumber(int(self.getVersion()))
1580: try:
1581: #FIXME: wozu ist das gut?
1582: self.REQUEST.SESSION['objID_parent']=self.getId()
1583: except:
1584: pass
1585:
1586: if RESPONSE:
1587:
1588: obj=self.ZopeFind(self,obj_ids=[id])[0][1]
1589: if obj.getSize()==0:
1590: self.REQUEST.SESSION['objID']=obj.getId()
1591: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
1592: return pt()
1593:
1594: else:
1595: if come_from and (come_from!=""):
1596: RESPONSE.redirect(come_from+"?change="+self.getId())
1597: else:
1598: RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
1599:
1600: else:
1601: return self.ZopeFind(self,obj_ids=[id])[0][1]
1602:
1603:
1604: def manage_addCDLIFileForm(self):
1605: """interface for adding the OSAS_root"""
1606: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
1607: return pt()
1608:
1609: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
1610: """add the OSAS_root"""
1611: newObj=CDLIFile(id,title,lockedBy,author)
1612:
1613: tryToggle=True
1614: tryCount=0
1615:
1616:
1617:
1618: self._setObject(id,newObj)
1619: getattr(self,id).reindex_object()
1620:
1621: if RESPONSE is not None:
1622: RESPONSE.redirect('manage_main')
1623:
1624:
1625:
1626: def checkFile(filename,data,folder):
1627: """check the files"""
1628: # first check the file name
1629: fn=filename.split(".") # no extension
1630:
1631: if not fn[0][0]=="P":
1632: return False,"P missing in the filename"
1633: elif len(fn[0])!=7:
1634: return False,"P number has not the right length 6"
1635: else:
1636: fn=os.path.join(folder,filename)
1637: stin,out=os.popen4("/usr/bin/atfcheck.plx %s"%fn)
1638: value=out.read()
1639: ret= out.close()
1640:
1641: if value:
1642:
1643: return False,"atf checker error: %s"%value
1644: else:
1645: return True,""
1646:
1647: def splitatf(fh,dir=None,ext=None):
1648: """split it"""
1649: ret=None
1650: nf=None
1651: i=0
1652:
1653: for lineTmp in fh.readlines():
1654: for line in lineTmp.split("\r"):
1655: if ext:
1656: i+=1
1657: if (i%100)==0:
1658: ext.result+="."
1659: if i==10000:
1660: i=0
1661: ext.result+="<br>"
1662: #check if basket name is in the first line
1663: if line.find("#atf basket")>=0: #old convention
1664: ret=line.replace('#atf basket ','')
1665: ret=ret.split('_')[0]
1666: elif line.find("#basket:")>=0: #new convention
1667: ret=line.replace('#basket: ','')
1668: ret=ret.split('_')[0]
1669:
1670: else:
1671: if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
1672: if nf:
1673: nf.close() #close last file
1674:
1675:
1676: filename=line[1:].split("=")[0].rstrip()+".atf"
1677: if dir:
1678: filename=os.path.join(dir,filename)
1679: nf=file(filename,"w")
1680: if nf:
1681: nf.write(line.replace("\n","")+"\n")
1682:
1683: nf.close()
1684: fh.close()
1685: return ret,len(os.listdir(dir))
1686:
1687:
1688: class CDLIFileFolder(extVersionedFileFolder):
1689: """CDLI File Folder"""
1690:
1691: security=ClassSecurityInfo()
1692: meta_type="CDLI Folder"
1693: filesMetaType=['CDLI file']
1694: folderMetaType=['CDLI Folder']
1695: default_catalog='CDLICatalog'
1696: defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzufŸgen einer neuen version eines files dieser catalog neuiniziert
1697: #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
1698: tmpStore2={}
1699: def setTemp(self,name,value):
1700: """set tmp"""
1701:
1702: setattr(self,name,value)
1703:
1704:
1705: def delete(self,ids):
1706: """delete this file, i.e. move into a trash folder"""
1707:
1708: found=self.ZopeFind(self,obj_ids=['.trash'])
1709:
1710: if len(found)<1:
1711: manage_addCDLIFileFolder(self, '.trash',title="Trash")
1712: trash=self._getOb('.trash')
1713: else:
1714: trash=found[0][1]
1715:
1716: if type(ids) is not ListType:
1717: ids=[ids]
1718: cut=self.manage_cutObjects(ids)
1719: trash.manage_pasteObjects(cut)
1720:
1721: def getVersionNumbersFromIds(self,ids):
1722: """get the numbers of the current versions of documents described by their ids"""
1723:
1724: ret=[]
1725: searchStr=" OR ".join(ids)
1726:
1727: founds=self.CDLICatalog.search({'title':searchStr})
1728:
1729: for found in founds:
1730: lastVersion=found.getObject().getLastVersion()
1731: ret.append((found.getId,lastVersion))
1732:
1733: return ret
1734:
1735: def checkCatalog(self,fn):
1736: """check if fn is in the catalog"""
1737: #TODO add checkCatalog
1738:
1739:
1740:
1741: def findObjectsFromListWithVersion(self,list,author=None):
1742: """find objects from a list with versions
1743: @param list: list of tuples (cdliFile,version)
1744: """
1745:
1746:
1747:
1748: #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
1749: #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
1750:
1751:
1752: pt=getattr(self,'filelistVersioned.html')
1753:
1754: return pt(search=list,author=author)
1755:
1756:
1757:
1758: def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
1759: """findObjectsFromList (, TAB oder LINE separated)"""
1760:
1761:
1762: if upload: # list from file upload
1763: txt=upload.read()
1764:
1765: if enterList:
1766: txt=enterList
1767:
1768: if upload or enterList:
1769: txt=txt.replace(",","\n")
1770: txt=txt.replace("\t","\n")
1771: txt=txt.replace("\r","\n")
1772: idsTmp=txt.split("\n")
1773: ids=[]
1774: for id in idsTmp: # make sure that no empty lines
1775: idTmp=id.lstrip().rstrip()
1776: if len(idTmp)>0:
1777:
1778: ids.append(idTmp)
1779:
1780: #self.REQUEST.SESSION['ids']=" OR ".join(ids)
1781:
1782: pt=getattr(self,'filelist.html')
1783: self.REQUEST.SESSION['searchList']=ids
1784: return pt(search=ids)
1785:
1786: if basketName:
1787: #TODO: get rid of one of these..
1788:
1789: pt=getattr(self,'filelist.html')
1790: return pt(basketName=basketName,numberOfObjects=numberOfObjects)
1791:
1792: if list is not None: # got already a list
1793: ret=[]
1794: for fileId in list:
1795: if fileId.find("*"): #check for wildcards
1796: fileId=fileId
1797: elif len(fileId.split("."))==1:
1798: fileId=fileId+".atf"
1799:
1800: ret+=self.CDLICatalog({'title':fileId})
1801: #TODO: get rid of one of these..
1802: ids=[x.getObject().getId() for x in ret]
1803: self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
1804: self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
1805:
1806: if display:
1807: pt=getattr(self,'filelist.html')
1808:
1809: return pt(search=ids)
1810: else:
1811: return ret
1812:
1813:
1814:
1815: if start:
1816: RESPONSE.redirect("filelist.html?start:int="+str(start))
1817:
1818:
1819: security.declareProtected('Manage','createAllFilesAsSingleFile')
1820: def createAllFilesAsSingleFile(self,RESPONSE=None):
1821: """download all files"""
1822:
1823: def sortF(x,y):
1824: return cmp(x[0],y[0])
1825:
1826: catalog=getattr(self,self.default_catalog)
1827: #tf,tfilename=mkstemp()
1828: if not hasattr(self.temp_folder,'downloadCounter'):
1829: self.temp_folder.downloadCounter=0
1830:
1831: if getattr(self.temp_folder,'downloadCounter',0) > 5:
1832: return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
1833:
1834: self.temp_folder.downloadCounter+=1
1835: self._p_changed=1
1836: transaction.get().commit()
1837:
1838: list=[(x.getId,x) for x in catalog()]
1839: list.sort(sortF)
1840:
1841:
1842:
1843: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
1844: RESPONSE.setHeader("Content-Type","application/octet-stream")
1845: tmp=""
1846: for l in list:
1847: obj=l[1].getObject()
1848:
1849: if obj.meta_type=="CDLI file":
1850:
1851: #os.write(tf,obj.getLastVersion().data)
1852: if RESPONSE:
1853: RESPONSE.write(obj.getLastVersion().getData()[0:])
1854: self.temp_folder.downloadCounter-=1
1855: self._p_changed=1
1856: transaction.get().commit()
1857: #os.close(tf)
1858: #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
1859: return True
1860:
1861: def downloadFile(self,fn):
1862: """download fn - not used yet"""
1863: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
1864: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
1865: self.REQUEST.RESPONSE.write(file(fn).read())
1866:
1867:
1868:
1869: def hasParent(self):
1870: """returns true falls subfolder"""
1871:
1872: if self.aq_parent.meta_type in self.folderMetaType:
1873: return True
1874: else:
1875: return False
1876:
1877: def getFolders(self):
1878: """get all subfolders"""
1879: ret=[]
1880: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
1881: for folder in folders:
1882: ret.append((folder[1],
1883: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
1884: len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
1885: ))
1886: return ret
1887:
1888:
1889: security.declareProtected('View','index_html')
1890: def index_html(self):
1891: """main"""
1892: ext=self.ZopeFind(self,obj_ids=["index.html"])
1893: if ext:
1894: return ext[0][1]()
1895:
1896: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
1897: return pt()
1898:
1899:
1900: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
1901:
1902:
1903: def manage_addCDLIFileFolder(self, id, title='',
1904: createPublic=0,
1905: createUserF=0,
1906: REQUEST=None):
1907: """Add a new Folder object with id *id*.
1908:
1909: If the 'createPublic' and 'createUserF' parameters are set to any true
1910: value, an 'index_html' and a 'UserFolder' objects are created respectively
1911: in the new folder.
1912: """
1913: ob=CDLIFileFolder()
1914: ob.id=str(id)
1915: ob.title=title
1916: self._setObject(id, ob)
1917: ob=self._getOb(id)
1918:
1919: checkPermission=getSecurityManager().checkPermission
1920:
1921: if createUserF:
1922: if not checkPermission('Add User Folders', ob):
1923: raise Unauthorized, (
1924: 'You are not authorized to add User Folders.'
1925: )
1926: ob.manage_addUserFolder()
1927:
1928:
1929: if REQUEST is not None:
1930: return self.manage_main(self, REQUEST, update_menu=1)
1931:
1932: class CDLIRoot(Folder):
1933: """main folder for cdli"""
1934:
1935: meta_type="CDLIRoot"
1936: downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
1937:
1938: def findWordRegExp(self,searchTerm):
1939: """find all words in index which match regexp in SearchTerm"""
1940: ret=[]
1941: for x in self.lineIndex.iterkeys():
1942: if re.match(searchTerm,x):
1943: ret.append(x)
1944: return ret
1945:
1946: def searchRegExpInLineIndexDocs(self,searchTerm):
1947: """search in inLineIndex with regexp"""
1948: if not searchTerm:
1949: return []
1950: ret=[]
1951: words=self.findWordRegExp(searchTerm) # suche nach allen Treffern
1952: logging.info("wd:%s"%words)
1953: for word in words:
1954: ret+=self.searchInLineIndexDocs(word)
1955:
1956: return unique(ret)
1957:
1958: def showInLineIndex(self):
1959: """get the index for debug purposes"""
1960: print "show"
1961: for x in self.lineIndex.iterkeys():
1962: logging.info("word:%s"%repr(x))
1963: #for y in self.lineIndex[x].iterkeys():
1964: # print "doc",repr(y),repr(self.lineIndex[x][y])
1965:
1966: return self.lineIndex
1967:
1968: def searchInLineIndexDocs(self,word,uniq=True,regExp=False):
1969: """search occurences"""
1970:
1971: if regExp:
1972: return self.searchRegExpInLineIndexDocs(word)
1973:
1974: try:
1975: lst=list(self.lineIndex.get(word).keys())
1976: except:
1977: lst=[]
1978: if uniq:
1979: return unique(lst)
1980: else:
1981: return lst
1982:
1983: def getLinesFromIndex(self,word,doc,regExp=False):
1984: """get lines"""
1985: if not regExp:
1986: return self.lineIndex.get(word)[doc]
1987: else: # wenn regexp, suche welches word
1988: for w in self.findWordRegExp(word):
1989: if self.lineIndex.get(w): # ein word in im dex gefunden
1990: try:
1991: dc=self.lineIndex.get(word)[doc]
1992: return dc # und ein document dann gib es zurueck
1993: except:
1994: pass #andernfalls weiter
1995:
1996: def cleanInLineIndex(self):
1997: """delete InlineIndex"""
1998: for x in list(self.lineIndex.keys()):
1999: del(self.lineIndex[x])
2000: print [x for x in self.lineIndex.keys()]
2001:
2002: return "ok"
2003:
2004: def storeInLineIndex(self,key,value):
2005: """store in index"""
2006:
2007: if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):
2008: self.lineIndex=OOBTree()
2009: li=self.lineIndex
2010:
2011: if li.has_key(key):
2012:
2013: # if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):
2014: if li[key].has_key(value[0]):
2015: tmp=li[key][value[0]]
2016: tmp.append(value[1]) # add it if now in the array
2017: li[key][value[0]]=tmp[0:]
2018: else:
2019: li[key][value[0]]=[value[1]] # new array for lines
2020:
2021: else:
2022:
2023: li[key]=OOBTree()# new btree for lines
2024: li[key][value[0]]=[value[1]]
2025:
2026:
2027: self.lineIndex=li
2028:
2029: transaction.get().commit()
2030:
2031:
2032: def showFile(self,fileId):
2033: """show a file"""
2034: f=self.CDLICatalog({'title':fileId})
2035: if not f:
2036: return ""
2037:
2038: return f[0].getObject().getLastVersionFormattedData()
2039:
2040: def showLineFromFile(self,fileId,lineNum,word):
2041: """get line lineNum fromFileId"""
2042:
2043: file=self.showFile(fileId)
2044: #str="^%s\.[^%s\.]*%s[^\n]*\n"%(lineNum,lineNum,word)
2045: #str="^%s\..*?%s[^\n]*\n"%(lineNum,word)
2046:
2047: #print str
2048: #m=re.search(str,file,flags=re.M|re.DOTALL)
2049: #if m:
2050: # return m.group()
2051: #else:
2052: # return ""
2053: #ret=lineNum+"."
2054: #splitted=file.split(lineNum+".")
2055: #if len(splitted)>1:
2056: #for part in splitted[1:]:
2057: #if part.find(word)>-1:
2058: # for x in part.split("\n"):
2059: #ret+=x
2060: #if x.find(word)>-1:
2061: #break
2062: #break;
2063: #return ret
2064:
2065: def showWordInFile(self,fileId,word,lineList=None):
2066: """get lines with word fromFileId"""
2067:
2068: file=self.showFile(fileId)
2069:
2070: ret=[]
2071: for line in file.split("\n"):
2072: if line.find(word)>-1:
2073: if lineList: #liste of moeglichen Zeilennummern
2074: num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
2075:
2076: if num in lineList:
2077:
2078: ret.append(line)
2079: else: # nimm alles ohne line check
2080: ret.append(line)
2081: return ret
2082:
2083: def tagWordInFile(self,fileId,word,lineList=None):
2084: """get lines with word fromFileId"""
2085:
2086: file=self.showFile(fileId)
2087: tagStr="""<span class="found">%s</span>"""
2088: ret=[]
2089: for line in file.split("\n"):
2090: if line.find(word)>-1:
2091: if lineList: #liste of moeglichen Zeilennummern
2092: num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
2093:
2094: if num in lineList:
2095:
2096: ret.append(line.replace(word,tagStr%word))
2097: else: # nimm alles ohne line check
2098: ret.append(line.replace(word,tagStr%word))
2099: else:
2100: ret.append(line)
2101: return "<br>\n".join(ret)
2102:
2103: def URLquote(self,str):
2104: """quote url"""
2105: return urllib.quote(str)
2106:
2107: def URLunquote(self,str):
2108: """unquote url"""
2109: return urllib.unquote(str)
2110:
2111: def URLquote_plus(self,str):
2112: """quote url"""
2113: return urllib.quote_plus(str)
2114:
2115: def URLunquote_plus(self,str):
2116: """unquote url"""
2117: return urllib.unquote_plus(str)
2118:
2119:
2120: def forceunlock(self):
2121: "break all locks"
2122: ret=[]
2123: for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
2124: un=f[1].forceunlock()
2125:
2126: if un and un !="":
2127: ret.append((f[0],un))
2128:
2129: return ret
2130:
2131: def getChangesByAuthor(self,author,n=100):
2132: """getChangesByAuthor"""
2133: zcat=self.CDLIObjectsCatalog
2134: res=zcat({'lastEditor':author,
2135: 'sort_on':'getTime',
2136: 'sort_order':'descending',
2137: 'sort_limit':n})[:n ]
2138:
2139: return res
2140:
2141: def getChangesByAuthor_html(self,author,n=100):
2142: """html output for changes by author"""
2143: tmp={}
2144: list=[]
2145: for x in self.getChangesByAuthor(author):
2146: nr=x.getObject().getVersionNumber()
2147: id=x.getObject().aq_parent.getId()
2148: #hinzufuegen, wenn Version neuer als die
2149: if tmp.get(id,(0,0))[1] < nr:
2150: tmp[id]=(x.getObject().aq_parent,nr)
2151:
2152:
2153: return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)
2154:
2155: def getLastChanges(self,n=100):
2156: """get the last n changes"""
2157: n=int(n)
2158: zcat=self.CDLICatalog
2159: return zcat({'sort_on':'getLastChangeDate',
2160: 'sort_order':'descending',
2161: 'sort_limit':n})[:n ]
2162:
2163:
2164: def getLastChanges_html(self,n=100):
2165: """get the last n changes"""
2166: list = [x.getId for x in self.getLastChanges(n)]
2167: return self.cdli_main.findObjectsFromList(list=list,display=True)
2168:
2169: def refreshTxt(self,txt="",threadName=None):
2170: """txt fuer refresh"""
2171:
2172: return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
2173:
2174:
2175: def getResult(self,threadName=None):
2176: """result of thread"""
2177: try:
2178: return self._v_uploadATF[threadName].getResult()
2179: except:
2180: return "One moment, please"
2181:
2182:
2183: def checkThreads(self):
2184: """check threads"""
2185: ret="<html><body>"
2186: for thread in threading.enumerate():
2187: ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
2188:
2189: return ret
2190:
2191:
2192:
2193: def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
2194: """standard ausgabe"""
2195: #self._v_uploadATF.returnValue=None
2196:
2197: threadName=repeat
2198: if not threadName or threadName=="":
2199: tmpVar=False
2200:
2201: thread=uploadATFThread()
2202: threadName=thread.getName()[0:]
2203: if (not hasattr(self,'_v_uploadATF')):
2204: self._v_uploadATF={}
2205:
2206: self._v_uploadATF[threadName]=thread
2207: #self._xmltrans.start()
2208: #thread=Thread(target=self._v_uploadATF)
2209:
2210: self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
2211: #thread.start()
2212: self._v_uploadATF[threadName].start()
2213:
2214:
2215: self.threadName=self._v_uploadATF[threadName].getName()[0:]
2216: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2217:
2218: if wait_template:
2219: return wait_template[0][1]()
2220: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
2221: return pt(txt='/uploadATF',threadName=threadName)
2222: #_v_xmltrans.run()
2223:
2224: else:
2225: #recover thread, if lost
2226: if (not hasattr(self,'_v_uploadATF')):
2227: self._v_uploadATF={}
2228: if not self._v_uploadATF.get(threadName,None):
2229: for thread in threading.enumerate():
2230: if threadName == thread.getName():
2231: self._v_uploadATF[threadName]=thread
2232:
2233: if not self._v_uploadATF[threadName].returnValue:
2234:
2235:
2236: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2237: if wait_template:
2238: return wait_template[0][1]()
2239:
2240: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
2241:
2242: return pt(txt='/uploadATF',threadName=threadName)
2243:
2244: else:
2245: # tmp={}
2246: # for key in self._v_uploadATF[threadName].returnValue.keys():
2247: # t=self._v_uploadATF[threadName].returnValue[key]
2248: # if type(t) is ListType:
2249: # tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
2250: # else:
2251: # tmp[key]=self._v_uploadATF[threadName].returnValue[key]
2252: # repr(tmp[key]),repr(key)
2253: #
2254: # #
2255: #tmp=self.cdli_main.tmpStore2[threadName]
2256: tmp=self._v_uploadATF[threadName].returnValue
2257:
2258: self._v_uploadATF[threadName].continueVar=False
2259:
2260: self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
2261: self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]
2262: self.REQUEST.SESSION['errors']=tmp['errors']
2263: self.REQUEST.SESSION['newPs']=tmp['newPs']
2264: self.REQUEST.SESSION['tmpdir']=tmp['dir']
2265: #del(self.cdli_main.tmpStore2[threadName])
2266:
2267:
2268: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
2269:
2270: return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
2271: basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
2272:
2273: def redoUpload(self,threadName):
2274: """redo the upload"""
2275: tmp=self.cdli_main.tmpStore2[threadName]
2276: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
2277: return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
2278: basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
2279:
2280: def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
2281: """nowupload the files"""
2282:
2283:
2284:
2285: threadName=repeat
2286: if not threadName or threadName=="":
2287: thread=uploadATFfinallyThread()
2288: threadName=thread.getName()[0:]
2289:
2290: if (not hasattr(self,'_v_uploadATF')):
2291: self._v_uploadATF={}
2292:
2293:
2294: self._v_uploadATF[threadName]=thread
2295:
2296:
2297: 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'])
2298:
2299: self._v_uploadATF[threadName].start()
2300:
2301:
2302:
2303: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2304:
2305: if wait_template:
2306: return wait_template[0][1]()
2307: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
2308:
2309: return pt(txt='/uploadATFfinally',threadName=threadName)
2310: #_v_xmltrans.run()
2311:
2312: else:
2313: #recover thread, if lost
2314: if not hasattr(self,'_v_uploadATF'):
2315: self._v_uploadATF={}
2316: if not self._v_uploadATF.get(threadName,None):
2317: for thread in threading.enumerate():
2318: if threadName == thread.getName():
2319: self._v_uploadATF[threadName]=thread
2320:
2321: if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
2322:
2323: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2324: if wait_template:
2325: return wait_template[0][1]()
2326:
2327: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
2328: return pt(txt='/uploadATFfinally',threadName=threadName)
2329: else:
2330:
2331: if RESPONSE is not None:
2332: RESPONSE.redirect(self.absolute_url())
2333:
2334: def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
2335: """import files"""
2336: root=self.cdli_main
2337: count=0
2338: if not files:
2339: files=os.listdir(folderName)
2340:
2341: for f in files:
2342: folder=f[0:3]
2343: f2=f[0:5]
2344: obj=self.ZopeFind(root,obj_ids=[folder])
2345: if ext:
2346:
2347: ext.result+="<p>adding: %s </p>"%f
2348: if not obj:
2349: manage_addCDLIFileFolder(root,folder,folder)
2350: fobj=getattr(root,folder)
2351: #transaction.get().commit()
2352: else:
2353: fobj=obj[0][1]
2354:
2355: obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
2356:
2357: if not obj2:
2358: manage_addCDLIFileFolder(fobj,f2,f2)
2359: fobj2=getattr(fobj,f2)
2360:
2361: else:
2362: fobj2=obj2[0][1]
2363:
2364: file2=os.path.join(folderName,f)
2365: id=f
2366: manage_addCDLIFile(fobj2,f,'','')
2367: id=f
2368: ob=fobj2._getOb(f)
2369: ob.title=id
2370:
2371: manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)
2372: self.CDLICatalog.catalog_object(ob)
2373: #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
2374: #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
2375: count+=1
2376:
2377: if count > 1000:
2378: print "committing"
2379: transaction.get().commit()
2380: count=0
2381: transaction.get().commit()
2382: return "ok"
2383:
2384:
2385: manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
2386:
2387:
2388: def manage_addCDLIRoot(self, id, title='',
2389: createPublic=0,
2390: createUserF=0,
2391: REQUEST=None):
2392: """Add a new Folder object with id *id*.
2393:
2394: If the 'createPublic' and 'createUserF' parameters are set to any true
2395: value, an 'index_html' and a 'UserFolder' objects are created respectively
2396: in the new folder.
2397: """
2398: ob=CDLIRoot()
2399: ob.id=str(id)
2400: ob.title=title
2401: self._setObject(id, ob)
2402: ob=self._getOb(id)
2403:
2404: checkPermission=getSecurityManager().checkPermission
2405:
2406: if createUserF:
2407: if not checkPermission('Add User Folders', ob):
2408: raise Unauthorized, (
2409: 'You are not authorized to add User Folders.'
2410: )
2411: ob.manage_addUserFolder()
2412:
2413:
2414: if REQUEST is not None:
2415: return self.manage_main(self, REQUEST, update_menu=1)
2416:
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