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