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