Annotation of cdli/cdli_files.py, revision 1.55
1.22 dwinter 1: """CDLI extensions of the filearchive"""
1.47 dwinter 2: from Products.versionedFile.extVersionedFile import *
1.1 dwinter 3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
1.22 dwinter 4: from tempfile import mkstemp,mkdtemp
1.1 dwinter 5: import os.path
6: import os
7: from types import *
1.3 dwinter 8: import urlparse
1.49 dwinter 9: import urllib
10: import cgi
1.4 dwinter 11: from OFS.OrderedFolder import OrderedFolder
12: from OFS.SimpleItem import SimpleItem
13: import time
1.12 dwinter 14: from OFS.Folder import manage_addFolder
15: import re
1.19 dwinter 16: from AccessControl import ClassSecurityInfo
17: from Acquisition import Implicit
1.39 dwinter 18: from Globals import Persistent
1.19 dwinter 19: from threading import Thread
20: from ZPublisher.HTTPRequest import HTTPRequest
21: from ZPublisher.HTTPResponse import HTTPResponse
22: from ZPublisher.BaseRequest import RequestContainer
1.20 dwinter 23: import threading
1.53 dwinter 24: from BTrees.OOBTree import OOBTree
1.22 dwinter 25:
1.55 ! dwinter 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:
1.39 dwinter 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"""
1.19 dwinter 105:
1.39 dwinter 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:
1.19 dwinter 117: class uploadATFfinallyThread(Thread):
1.20 dwinter 118: """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
119:
1.19 dwinter 120: def __init__(self):
1.20 dwinter 121: """init for uploadATFfinallyThread"""
1.19 dwinter 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"):
1.20 dwinter 128: """set start values for the thread"""
1.19 dwinter 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):
1.20 dwinter 138: """call of the thread (equals run)"""
1.19 dwinter 139: self.run()
140: return True
141:
142: def getContext(self, app,serverport="8080"):
1.20 dwinter 143: """get the context within the ZODB"""
144:
1.19 dwinter 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:
1.26 dwinter 154:
1.19 dwinter 155: def run(self):
1.20 dwinter 156: """run"""
157:
1.19 dwinter 158: self.result=""
1.20 dwinter 159: #find context within ZODB
1.19 dwinter 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:
1.20 dwinter 166: #add the files
1.19 dwinter 167: self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
1.20 dwinter 168: #commit the transactions
1.19 dwinter 169: get_transaction().commit()
170: conn.close()
1.20 dwinter 171: #set flag for end of this method
1.19 dwinter 172: self.end=True
1.49 dwinter 173: print "ended"
174: return True
1.19 dwinter 175:
1.22 dwinter 176: def __del__(self):
177: """delete"""
178:
179:
180:
1.19 dwinter 181: def getResult(self):
1.20 dwinter 182: """method for accessing result"""
183:
1.19 dwinter 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"""
1.20 dwinter 188: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
1.19 dwinter 189: ctx2=ctx.cdliRoot
190:
191: self.result+="<h2>Start processing</h2>"
1.20 dwinter 192:
193: #shall I only upload the changed files?
1.19 dwinter 194: if procedure=="uploadchanged":
195:
196: uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])
197:
1.20 dwinter 198: #or all
1.19 dwinter 199: elif procedure=="uploadAll":
200: uploadFns=[]
201: for x in os.listdir(SESSION['tmpdir']):
1.45 dwinter 202: if not x in SESSION['lockerrors']:
1.19 dwinter 203: uploadFns.append(x)
1.20 dwinter 204:
205: #or maybe nothing
1.19 dwinter 206: elif procedure=="noupload":
207: return True
208: else:
209: uploadFns=[]
210:
1.20 dwinter 211: #do first the changed files
1.19 dwinter 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
1.49 dwinter 217: founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
1.19 dwinter 218:
219:
1.20 dwinter 220: #now add the new files
1.19 dwinter 221: newPs=SESSION['newPs']
222: if len(newPs)>0:
223: tmpDir=SESSION['tmpdir']
224: self.result+="<p>Adding files</p>"
1.20 dwinter 225: #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
1.22 dwinter 226:
227: ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
1.19 dwinter 228:
229:
230:
1.20 dwinter 231: #unlock locked files?
1.19 dwinter 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:
1.20 dwinter 246: #if a basketname is give, add files to the basket
1.19 dwinter 247: if not (basketname ==''):
248: self.result+="<p>Add basket</p>"
1.41 dwinter 249: basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
1.19 dwinter 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):
1.20 dwinter 266: """class for checking the files befor uploading"""
1.19 dwinter 267:
268: def __init__(self):
1.20 dwinter 269: """initialise"""
270:
1.19 dwinter 271: self.continueVar=True
272: self.returnValue=None
273:
274: Thread.__init__(self)
275:
276:
277: def set(self,upload,basketId,username,serverport="8080"):
1.20 dwinter 278: """set start values for the thread"""
1.19 dwinter 279: self.result=""
280: self.upload=upload
281: self.basketId=basketId
282: self.username=username
283: self.serverport=serverport
284:
285: def __call__(self):
1.20 dwinter 286: """call method """
1.19 dwinter 287: self.run()
288: return True
289:
290: def getContext(self, app,serverport="8080"):
1.20 dwinter 291: """get the context within the ZODB"""
1.19 dwinter 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=""
1.20 dwinter 304: #find context within ZODB
1.19 dwinter 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)
1.24 dwinter 311:
1.30 dwinter 312: #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
1.24 dwinter 313:
1.22 dwinter 314: get_transaction().commit()
1.49 dwinter 315:
1.19 dwinter 316: while self.continueVar:
317: pass
1.49 dwinter 318:
1.19 dwinter 319: conn.close()
1.22 dwinter 320:
1.19 dwinter 321:
322: def getResult(self):
1.20 dwinter 323: """method for accessing result"""
1.19 dwinter 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
1.25 dwinter 330: self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
331:
1.20 dwinter 332: #make sure that id is a string and not an integer
1.19 dwinter 333: basketId=str(basketId)
334:
1.20 dwinter 335: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
336: ctx2=ctx.cdliRoot
1.19 dwinter 337:
1.20 dwinter 338: #get temporary file for staging the downloaded and splitted files
1.19 dwinter 339: dir=mkdtemp()
1.20 dwinter 340:
341:
342: changed=[] # changed files
343: errors=[] # files with errors
1.45 dwinter 344: lockerrors=[] # files with errors
345:
1.20 dwinter 346: newPs=[] # new p filed
347: psNotInCatalog=[] # files not in the catalog
348:
349: #split the uploadedd atf file
1.25 dwinter 350: basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
1.19 dwinter 351:
1.20 dwinter 352: #find basketId if not set
353:
354: #get active abaket
1.19 dwinter 355: if basketId == '0':
356: basketObj=ctx2.basketContainer.getActiveBasket()
357: if basketObj:
358: basketId=basketObj.getId()
359:
1.45 dwinter 360: #if there is no active basket and no basketid given, id is empty, else get besketname and length
1.19 dwinter 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:
1.25 dwinter 369: self.result+="""<html><body><h2>I got the files</h2><
370: p>I am computing the differences to the exisiting files</p>"""
1.20 dwinter 371:
372: #start to check the files
1.19 dwinter 373: for fn in os.listdir(dir):
374:
1.25 dwinter 375: self.result+="<p>process:%s</p>"%fn
1.19 dwinter 376:
1.20 dwinter 377: # check if file is in the catalog
378: #TODO: checkCatalog is not implemented yet
1.19 dwinter 379: if ctx2.cdli_main.checkCatalog(fn):
380: psNotInCatalog.append(fn)
381:
1.20 dwinter 382: #check if p-file already at the server
1.19 dwinter 383: founds=ctx2.CDLICatalog.search({'title':fn})
384:
1.20 dwinter 385: #if not than add filename to the list of newfiles
1.46 dwinter 386:
387: data=file(os.path.join(dir,fn)).read()
1.47 dwinter 388: #status,msg=checkFile(fn,data,dir)
389: status=True
1.48 dwinter 390: msg=""
1.46 dwinter 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
1.31 dwinter 409:
1.20 dwinter 410: #ready, set the returnValues
1.19 dwinter 411: self.result+="<h3>Done</h3></body></html>"
412:
413: self.returnValue={}
414: self.returnValue['changed']=changed
415: self.returnValue['errors']=errors
1.45 dwinter 416: self.returnValue['lockerrors']=lockerrors
1.19 dwinter 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:
1.4 dwinter 429: class Basket_old(Folder):
430: """shopping basket - alte fassung """
1.1 dwinter 431:
432: meta_type="Basket"
433: _v_stack={}
434:
1.3 dwinter 435: def getObjUrl(self,objId):
436: """getUrl"""
1.9 dwinter 437: founds=self.CDLICatalog.search({'title':objId})
1.3 dwinter 438: if len(founds)>0:
439: return founds[0].getObject().absolute_url()
440:
1.4 dwinter 441: else: #assume version number
1.3 dwinter 442: splitted=objId.split("_")
1.9 dwinter 443: founds=self.CDLICatalog.search({'title':splitted[1]})
1.3 dwinter 444: return founds[0].getObject().absolute_url()+'/'+objId
445:
1.1 dwinter 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:
1.4 dwinter 511: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
1.1 dwinter 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:
1.4 dwinter 525: def manage_addBasket_oldForm(self):
1.1 dwinter 526: """add the basket form"""
527: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
528: return pt()
529:
1.4 dwinter 530: def manage_addBasket_old(self,id,title,RESPONSE=None):
1.1 dwinter 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:
1.4 dwinter 543: class BasketObject_old(Folder):
544: """Basket Object - alte fassung"""
1.1 dwinter 545:
1.2 dwinter 546: meta_type="basketObject"
1.1 dwinter 547: def __init__(self):
1.16 dwinter 548: """init basket object"""
549: self.contents=[]
1.1 dwinter 550:
551: def numberOfItems(self):
552: """return anzahl der elemente im basket"""
1.39 dwinter 553: num=len(self.contents)
554:
555: return num
1.1 dwinter 556:
557: def addObjects(self,ids):
558: """addObjects"""
559:
560: for id in ids:
1.9 dwinter 561: founds=self.CDLICatalog.search({'title':id})
1.1 dwinter 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):
1.16 dwinter 571: """view the basket"""
572: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
573: return pt()
1.1 dwinter 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:
1.16 dwinter 585: RESPONSE.redirect(self.absolute_url())
1.1 dwinter 586:
587:
1.2 dwinter 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):
1.1 dwinter 596: """download all selected files in one file"""
1.2 dwinter 597:
1.1 dwinter 598: ret=""
1.2 dwinter 599: lockedObjects={}
1.48 dwinter 600:
1.46 dwinter 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!"""
1.45 dwinter 603:
1.2 dwinter 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:
1.46 dwinter 630: self.temp_folder.downloadCounter+=1
631: self._p_changed=1
632: get_transaction().commit()
1.16 dwinter 633:
1.46 dwinter 634:
1.1 dwinter 635: for object in self.contents:
1.2 dwinter 636:
637: if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
1.46 dwinter 638: ret+=object.getLastVersion().getData()
1.2 dwinter 639:
640: if lock and object.lockedBy=='':
641: object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
642:
1.1 dwinter 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")
1.2 dwinter 646: length=len(ret)
647: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
1.1 dwinter 648: self.REQUEST.RESPONSE.write(ret)
1.46 dwinter 649: self.temp_folder.downloadCounter-=1
650: self._p_changed=1
651: get_transaction().commit()
1.2 dwinter 652:
653:
1.4 dwinter 654: def manage_addBasket_oldObjectForm(self):
1.1 dwinter 655: """add form"""
656: pass
657:
1.4 dwinter 658: def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
1.1 dwinter 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:
1.4 dwinter 671:
672: class CDLIBasketContainer(OrderedFolder):
673: """contains the baskets"""
674:
675:
1.9 dwinter 676: security=ClassSecurityInfo()
1.4 dwinter 677: meta_type="CDLIBasketContainer"
678:
1.39 dwinter 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:
1.32 dwinter 687: security.declareProtected('manage','deleteBaskets')
1.12 dwinter 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:
1.32 dwinter 705: security.declareProtected('manage','manageBaskets')
1.12 dwinter 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())
1.32 dwinter 715:
1.33 dwinter 716: security.declareProtected('View','getBasketIdfromName')
1.5 dwinter 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
1.9 dwinter 725:
726: security.declareProtected('manage','uploadBasket_html')
727:
1.4 dwinter 728: def uploadBasket_html(self,basketId='0'):
729: """upload an atf file, html form"""
1.9 dwinter 730:
731:
1.4 dwinter 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:
1.32 dwinter 742: security.declareProtected('View','index_html')
1.4 dwinter 743: def index_html(self):
744: """stanadard ansicht"""
1.9 dwinter 745:
746:
747:
1.4 dwinter 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:
1.51 dwinter 764:
1.49 dwinter 765: def getBasketsId(self):
766: """get all baskets als klartext"""
1.51 dwinter 767:
768: ret=""
1.49 dwinter 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"
1.51 dwinter 775: return ret
1.49 dwinter 776:
1.4 dwinter 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)
1.39 dwinter 832:
1.4 dwinter 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:
1.6 dwinter 847: def setActiveBasket(self,basketId,REQUEST=None):
1.4 dwinter 848: """store active basketId in a cookie"""
849: self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
1.49 dwinter 850: try:
851: qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
852: del(qs['basketId'])
853: except:
854: qs={}
1.6 dwinter 855: if REQUEST:
1.49 dwinter 856: REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
1.6 dwinter 857:
1.4 dwinter 858: def getActiveBasket(self):
859: """get active basket from cookie"""
860:
861: id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
1.6 dwinter 862: if id:
863: obj=getattr(self,str(id),None)
864: else:
865: obj=None
1.4 dwinter 866: return obj
1.6 dwinter 867:
1.4 dwinter 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:
1.6 dwinter 879: def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
1.4 dwinter 880: """store it"""
1.6 dwinter 881: if not ids:
882: ids=self.REQUEST.SESSION['fileIds']
883:
1.4 dwinter 884: if type(ids) is not ListType:
885: ids=[ids]
886:
1.6 dwinter 887: if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
1.4 dwinter 888: basketRet=self.addBasket(newBasketName)
889: self.setActiveBasket(basketRet.getId())
890: basket=getattr(self,basketRet.getId())
1.6 dwinter 891: elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
1.4 dwinter 892: basket=self.getActiveBasket()
1.6 dwinter 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:
1.7 dwinter 899:
1.6 dwinter 900: return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
901:
1.4 dwinter 902: if RESPONSE:
1.6 dwinter 903:
1.4 dwinter 904: RESPONSE.redirect(back)
905:
1.6 dwinter 906: return True
907:
1.4 dwinter 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:
1.5 dwinter 922: class CDLIBasket(Folder,CatalogAware):
1.4 dwinter 923: """basket"""
924:
925: meta_type="CDLIBasket"
1.5 dwinter 926: default_catalog="CDLIBasketCatalog"
1.4 dwinter 927:
1.39 dwinter 928:
1.4 dwinter 929: def getFile(self,obj):
930: return obj[1]
931:
932: def getFileLastVersion(self,obj):
933: return obj[0]
934:
1.5 dwinter 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:
1.37 dwinter 940:
1.4 dwinter 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()
1.12 dwinter 945:
946: founds=self.CDLICatalog.search({'title':obj[0].getId()})
1.37 dwinter 947: if len(founds)>0:
948: actualNo=founds[0].getObject().getLastVersion().getVersionNumber()
949:
1.12 dwinter 950: if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
951: return False, -1
952:
1.4 dwinter 953: if actualNo==storedNo:
1.12 dwinter 954: return True , 0
1.4 dwinter 955: else:
1.12 dwinter 956: return False, actualNo
1.4 dwinter 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"""
1.39 dwinter 984:
985: ids=[]
986: idsTmp= self.objectIds()
987: for x in idsTmp:
988: try:
989: ids.append(int(x))
990: except:
991: pass
1.4 dwinter 992: ids.sort()
1.39 dwinter 993:
1.4 dwinter 994: if len(ids)==0:
995: return None
996: else:
997: ob=getattr(self,str(ids[-1]))
1.39 dwinter 998:
999:
1.4 dwinter 1000: return ob
1001:
1002: def getVersions(self):
1003: """get versions"""
1004: versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
1005: return versions
1006:
1007:
1.37 dwinter 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()
1.39 dwinter 1014: oldContent=lastVersion.content.getContent()
1.37 dwinter 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:
1.38 dwinter 1037: obj=self._getOb(ob.getId())
1.37 dwinter 1038: if RESPONSE:
1.38 dwinter 1039:
1.37 dwinter 1040: RESPONSE.redirect(obj.absolute_url())
1.38 dwinter 1041:
1042: return obj
1043:
1.19 dwinter 1044: def addObjects(self,ids,deleteOld=None,username=None):
1.4 dwinter 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:
1.39 dwinter 1052: oldContent=lastVersion.content.getContent()
1.4 dwinter 1053:
1054: if deleteOld:
1055: oldContent=[]
1056:
1057: newContent=[]
1.6 dwinter 1058: added=0
1.4 dwinter 1059: for id in ids:
1.49 dwinter 1060: try:
1061: founds=self.CDLICatalog.search({'title':id})
1062: except:
1063: founds=[]
1.4 dwinter 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()))
1.6 dwinter 1068: added+=1
1.4 dwinter 1069:
1070: content=oldContent+newContent
1.19 dwinter 1071: if not username:
1072: user=self.getActualUserName()
1073: else:
1074: user = username
1075:
1.4 dwinter 1076: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
1077:
1.6 dwinter 1078: return added
1.4 dwinter 1079:
1.51 dwinter 1080:
1081:
1082:
1.49 dwinter 1083: def getContentIds(self):
1084: """print basket content"""
1085: ret=[]
1086: lv=self.getLastVersion()
1.51 dwinter 1087: for obj in lv.content.getContent():
1.49 dwinter 1088: ret.append((obj[0].getId(),obj[1].getId()))
1089:
1090:
1091: return lv.getComment(),lv.getUser(),lv.getTime(),ret
1092:
1.37 dwinter 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:
1.12 dwinter 1100: def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
1.4 dwinter 1101: """delete objects"""
1.12 dwinter 1102:
1103: if type(ids) is not ListType:
1104: ids=[ids]
1105:
1106: lastVersion=self.getLastVersion()
1.39 dwinter 1107: oldContent=lastVersion.content.getContent()
1.12 dwinter 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())
1.4 dwinter 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:
1.39 dwinter 1141: class CDLIBasketVersion(Implicit,Persistent,Folder):
1.4 dwinter 1142: """version of a basket"""
1143:
1144: meta_type="CDLIBasketVersion"
1.32 dwinter 1145: security=ClassSecurityInfo()
1.4 dwinter 1146:
1.39 dwinter 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:
1.37 dwinter 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:
1.32 dwinter 1169: security.declareProtected('View','downloadObjectsAsOneFile')
1.37 dwinter 1170: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
1.4 dwinter 1171: """download all selected files in one file"""
1.46 dwinter 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!"""
1.45 dwinter 1175:
1176:
1.37 dwinter 1177: if (check=="yes") and self.containsNonActualFiles():
1178: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
1.46 dwinter 1179:
1.37 dwinter 1180: return pt(lock=lock)
1181:
1.46 dwinter 1182: else:
1183:
1184: return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
1185:
1.45 dwinter 1186: def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):
1.46 dwinter 1187: """print do the download"""
1.45 dwinter 1188:
1.46 dwinter 1189: ret=""
1.4 dwinter 1190: lockedObjects={}
1191:
1.46 dwinter 1192: self.temp_folder.downloadCounterBaskets+=1
1193: self._p_changed=1
1.45 dwinter 1194: get_transaction().commit()
1195:
1.4 dwinter 1196: if lock:
1197:
1198: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
1.46 dwinter 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()
1.4 dwinter 1205: return "please login first"
1206:
1207: #check if a locked object exist in the basket.
1208: lockedObjects={}
1.39 dwinter 1209: for object in self.content.getContent():
1.4 dwinter 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)
1.45 dwinter 1221:
1.46 dwinter 1222: self.temp_folder.downloadCounterBaskets-=1
1223: self._p_changed=1
1224: get_transaction().commit()
1.45 dwinter 1225:
1.46 dwinter 1226: return pt()
1.4 dwinter 1227:
1228: elif not procedure: #keine fails gesperrt dann alle donwloaden
1229: procedure="downloadAll"
1230:
1.46 dwinter 1231:
1.45 dwinter 1232:
1.4 dwinter 1233:
1.39 dwinter 1234: for object in self.content.getContent():
1.45 dwinter 1235:
1.4 dwinter 1236: if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
1.37 dwinter 1237: if current=="no": #version as they are in the basket
1.49 dwinter 1238: ret+=str(object[0].getData())+"\n"
1.37 dwinter 1239: elif current=="yes":
1240: #search current object
1241: founds=self.CDLICatalog.search({'title':object[0].getId()})
1242: if len(founds)>0:
1.49 dwinter 1243: ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
1.37 dwinter 1244:
1.4 dwinter 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
1.45 dwinter 1250: ret="#basket: %s\n"%basket_name+ret
1251:
1.46 dwinter 1252: self.temp_folder.downloadCounterBaskets-=1
1253: self._p_changed=1
1254: get_transaction().commit()
1.4 dwinter 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)
1.46 dwinter 1261: return True
1.4 dwinter 1262:
1263: def numberOfItems(self):
1264: """return anzahl der elemente im basket"""
1.39 dwinter 1265: return self.content.numberOfItems()
1.4 dwinter 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"""
1.39 dwinter 1281: return self.content.getContent()
1.4 dwinter 1282:
1283:
1284: def __init__(self,id,user,comment="",basketContent=[]):
1285: """ init a basket version"""
1286: self.id=id
1287: self.coment=comment
1.39 dwinter 1288: self._setObject('content',BasketContent(basketContent))
1289: #self.basketContent=basketContent[0:]a
1.4 dwinter 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:
1.32 dwinter 1301: security.declareProtected('View','index_html')
1.4 dwinter 1302: def index_html(self):
1303: """view the basket"""
1.37 dwinter 1304:
1305: if self.REQUEST.get('change',False):
1.38 dwinter 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
1.37 dwinter 1309:
1.4 dwinter 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:
1.12 dwinter 1318: return founds[0].getObject().getLastVersion().absolute_url()
1.4 dwinter 1319:
1320: else: #assume version number
1321: splitted=objId.split("_")
1.9 dwinter 1322: founds=self.CDLICatalog.search({'title':splitted[1]})
1.12 dwinter 1323: return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
1.4 dwinter 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:
1.46 dwinter 1345: class CDLIFileObject(CatalogAware,extVersionedFileObject):
1.1 dwinter 1346: """CDLI file object"""
1347:
1348: meta_type="CDLI File Object"
1.25 dwinter 1349: default_catalog='CDLIObjectsCatalog'
1.1 dwinter 1350:
1.12 dwinter 1351: security=ClassSecurityInfo()
1352:
1.26 dwinter 1353:
1354: security.declarePublic('makeThisVersionCurrent')
1355:
1.28 dwinter 1356: def PrincipiaSearchSource(self):
1357: """Return cataloguable key for ourselves."""
1358: return str(self)
1359:
1.26 dwinter 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()
1.27 dwinter 1365: def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
1.26 dwinter 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:]
1.27 dwinter 1372:
1373: if RESPONSE is not None:
1374: RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
1375:
1376:
1.26 dwinter 1377: return True
1378:
1379: security.declarePublic('view')
1.52 dwinter 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:
1.1 dwinter 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:
1.40 dwinter 1391: security.declarePublic('getPNumber')
1392: def getPNumber(self):
1.46 dwinter 1393: """get the pnumber"""
1394: try:
1.49 dwinter 1395: txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
1.40 dwinter 1396: except:
1.49 dwinter 1397: txt=self.getData()[0:]
1.40 dwinter 1398:
1399: return "ERROR"
1400: try:
1401: return "P"+txt.group(1)
1402: except:
1403: return "ERROR"
1404:
1.12 dwinter 1405: security.declarePublic('getDesignation')
1406: def getDesignation(self):
1407: """get the designation out of the file"""
1.16 dwinter 1408: try:
1.46 dwinter 1409: txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
1.13 dwinter 1410: except:
1.46 dwinter 1411: txt=self.getData()[0:]
1.16 dwinter 1412:
1413: return "ERROR"
1.12 dwinter 1414: try:
1415: return txt.group(2)
1416: except:
1417: return "ERROR"
1418:
1.1 dwinter 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='',
1.48 dwinter 1422: from_tmp=False,REQUEST=None):
1.1 dwinter 1423: """Add a new File object.
1424:
1425: Creates a new File object 'id' with the contents of 'file'"""
1.48 dwinter 1426:
1.1 dwinter 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:
1.45 dwinter 1443:
1.1 dwinter 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.
1.48 dwinter 1446:
1447: if file and not from_tmp:
1.1 dwinter 1448: self._getOb(id).manage_upload(file)
1.48 dwinter 1449: elif file and from_tmp:
1450: self._getOb(id).manage_upload_from_tmp(file)
1.1 dwinter 1451: if content_type:
1452: self._getOb(id).content_type=content_type
1453:
1.45 dwinter 1454: self.reindex_object()
1.49 dwinter 1455: self._getOb(id).reindex_object()
1456:
1.1 dwinter 1457: if REQUEST is not None:
1458: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
1.3 dwinter 1459:
1.46 dwinter 1460: class CDLIFile(extVersionedFile,CatalogAware):
1.3 dwinter 1461: """CDLI file"""
1462:
1463: meta_type="CDLI file"
1464: default_catalog='CDLICatalog'
1.5 dwinter 1465:
1.26 dwinter 1466: #security.declarePublic('history')
1.51 dwinter 1467: def getLastVersionData(self):
1468: """get last version data"""
1469: return self.getLastVersion().getData()
1470:
1.52 dwinter 1471: def getLastVersionFormattedData(self):
1472: """get last version data"""
1473: return self.getLastVersion().getFormattedData()
1474:
1.51 dwinter 1475: #security.declarePublic('history')
1476:
1477:
1.26 dwinter 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:
1.44 dwinter 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:
1.12 dwinter 1501:
1.8 dwinter 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
1.12 dwinter 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()})]
1.5 dwinter 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:
1.37 dwinter 1533: def manage_addCDLIFileObject(self,id,vC,author,
1534: file='',title='',
1535: precondition='',
1536: content_type='',
1537: changeName='no',newName='',
1.48 dwinter 1538: come_from=None,
1539: from_tmp=False,RESPONSE=None):
1.3 dwinter 1540: """add"""
1.48 dwinter 1541:
1.3 dwinter 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:
1.37 dwinter 1561:
1.3 dwinter 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:
1.37 dwinter 1573:
1.48 dwinter 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()))
1.22 dwinter 1577: try:
1578: #FIXME: wozu ist das gut?
1579: self.REQUEST.SESSION['objID_parent']=self.getId()
1580: except:
1581: pass
1.37 dwinter 1582:
1.3 dwinter 1583: if RESPONSE:
1.37 dwinter 1584:
1.3 dwinter 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:
1.37 dwinter 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)
1.3 dwinter 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)
1.22 dwinter 1609:
1610: tryToggle=True
1611: tryCount=0
1612:
1613:
1614:
1615: self._setObject(id,newObj)
1.45 dwinter 1616: getattr(self,id).reindex_object()
1.22 dwinter 1617:
1.3 dwinter 1618: if RESPONSE is not None:
1619: RESPONSE.redirect('manage_main')
1620:
1621:
1.1 dwinter 1622:
1.45 dwinter 1623: def checkFile(filename,data,folder):
1624: """check the files"""
1625: # first check the file name
1626: fn=filename.split(".") # no extension
1.48 dwinter 1627:
1.45 dwinter 1628: if not fn[0][0]=="P":
1.46 dwinter 1629: return False,"P missing in the filename"
1.45 dwinter 1630: elif len(fn[0])!=7:
1.46 dwinter 1631: return False,"P number has not the right length 6"
1.45 dwinter 1632: else:
1.46 dwinter 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:
1.48 dwinter 1639:
1.46 dwinter 1640: return False,"atf checker error: %s"%value
1641: else:
1642: return True,""
1.45 dwinter 1643:
1.25 dwinter 1644: def splitatf(fh,dir=None,ext=None):
1.2 dwinter 1645: """split it"""
1.4 dwinter 1646: ret=None
1.2 dwinter 1647: nf=None
1.25 dwinter 1648: i=0
1.49 dwinter 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:
1.50 dwinter 1678: nf.write(line.replace("\n","")+"\n")
1.49 dwinter 1679:
1.2 dwinter 1680: nf.close()
1681: fh.close()
1.5 dwinter 1682: return ret,len(os.listdir(dir))
1.4 dwinter 1683:
1.19 dwinter 1684:
1.46 dwinter 1685: class CDLIFileFolder(extVersionedFileFolder):
1.4 dwinter 1686: """CDLI File Folder"""
1.1 dwinter 1687:
1.19 dwinter 1688: security=ClassSecurityInfo()
1.1 dwinter 1689: meta_type="CDLI Folder"
1690: filesMetaType=['CDLI file']
1691: folderMetaType=['CDLI Folder']
1692: default_catalog='CDLICatalog'
1.25 dwinter 1693: defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzufŸgen einer neuen version eines files dieser catalog neuiniziert
1.45 dwinter 1694: #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
1.24 dwinter 1695: tmpStore2={}
1.19 dwinter 1696: def setTemp(self,name,value):
1697: """set tmp"""
1698:
1699: setattr(self,name,value)
1700:
1701:
1.12 dwinter 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:
1.4 dwinter 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:
1.9 dwinter 1724: founds=self.CDLICatalog.search({'title':searchStr})
1.4 dwinter 1725:
1726: for found in founds:
1727: lastVersion=found.getObject().getLastVersion()
1728: ret.append((found.getId,lastVersion))
1729:
1730: return ret
1731:
1.14 dwinter 1732: def checkCatalog(self,fn):
1733: """check if fn is in the catalog"""
1.19 dwinter 1734: #TODO add checkCatalog
1.14 dwinter 1735:
1736:
1.19 dwinter 1737:
1.45 dwinter 1738: def findObjectsFromListWithVersion(self,list,author=None):
1.26 dwinter 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:
1.45 dwinter 1751: return pt(search=list,author=author)
1.26 dwinter 1752:
1753:
1754:
1.35 dwinter 1755: def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
1.1 dwinter 1756: """findObjectsFromList (, TAB oder LINE separated)"""
1.15 dwinter 1757:
1758:
1.6 dwinter 1759: if upload: # list from file upload
1760: txt=upload.read()
1.35 dwinter 1761:
1762: if enterList:
1763: txt=enterList
1764:
1765: if upload or enterList:
1.6 dwinter 1766: txt=txt.replace(",","\n")
1767: txt=txt.replace("\t","\n")
1.12 dwinter 1768: txt=txt.replace("\r","\n")
1.6 dwinter 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)
1.12 dwinter 1778:
1.6 dwinter 1779: pt=getattr(self,'filelist.html')
1.7 dwinter 1780: self.REQUEST.SESSION['searchList']=ids
1.6 dwinter 1781: return pt(search=ids)
1.7 dwinter 1782:
1.6 dwinter 1783: if basketName:
1.7 dwinter 1784: #TODO: get rid of one of these..
1785:
1.6 dwinter 1786: pt=getattr(self,'filelist.html')
1.7 dwinter 1787: return pt(basketName=basketName,numberOfObjects=numberOfObjects)
1.6 dwinter 1788:
1.15 dwinter 1789: if list is not None: # got already a list
1.6 dwinter 1790: ret=[]
1791: for fileId in list:
1.35 dwinter 1792: if fileId.find("*"): #check for wildcards
1793: fileId=fileId
1794: elif len(fileId.split("."))==1:
1.6 dwinter 1795: fileId=fileId+".atf"
1.35 dwinter 1796:
1.6 dwinter 1797: ret+=self.CDLICatalog({'title':fileId})
1.7 dwinter 1798: #TODO: get rid of one of these..
1.25 dwinter 1799: ids=[x.getObject().getId() for x in ret]
1800: self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
1.7 dwinter 1801: self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
1.25 dwinter 1802:
1803: if display:
1804: pt=getattr(self,'filelist.html')
1805:
1806: return pt(search=ids)
1807: else:
1808: return ret
1809:
1810:
1.1 dwinter 1811:
1.7 dwinter 1812: if start:
1813: RESPONSE.redirect("filelist.html?start:int="+str(start))
1.15 dwinter 1814:
1.18 dwinter 1815:
1.19 dwinter 1816: security.declareProtected('Manage','createAllFilesAsSingleFile')
1.1 dwinter 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()
1.49 dwinter 1825: if not hasattr(self.temp_folder,'downloadCounter'):
1826: self.temp_folder.downloadCounter=0
1827:
1828: if getattr(self.temp_folder,'downloadCounter',0) > 5:
1.46 dwinter 1829: return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
1.45 dwinter 1830:
1.46 dwinter 1831: self.temp_folder.downloadCounter+=1
1832: self._p_changed=1
1.45 dwinter 1833: get_transaction().commit()
1834:
1.1 dwinter 1835: list=[(x.getId,x) for x in catalog()]
1836: list.sort(sortF)
1.46 dwinter 1837:
1.45 dwinter 1838:
1.1 dwinter 1839:
1840: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
1841: RESPONSE.setHeader("Content-Type","application/octet-stream")
1.46 dwinter 1842: tmp=""
1.1 dwinter 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:
1.49 dwinter 1850: RESPONSE.write(obj.getLastVersion().getData()[0:])
1.46 dwinter 1851: self.temp_folder.downloadCounter-=1
1852: self._p_changed=1
1.45 dwinter 1853: get_transaction().commit()
1.1 dwinter 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:
1.32 dwinter 1886: security.declareProtected('View','index_html')
1.1 dwinter 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:
1.22 dwinter 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"
1.45 dwinter 1933: downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
1.51 dwinter 1934:
1.53 dwinter 1935: def showInLineIndex(self):
1936: """get the index for debug purposes"""
1937: print "show"
1938: for x in self.lineIndex.iterkeys():
1939: print "word:",x
1940: for y in self.lineIndex[x].iterkeys():
1941: print "doc",y,self.lineIndex[x][y]
1942:
1943: return self.lineIndex
1944:
1.55 ! dwinter 1945: def searchInLineIndexDocs(self,word,uniq=True):
1.53 dwinter 1946: """search occurences"""
1.55 ! dwinter 1947:
! 1948:
! 1949: lst=list(self.lineIndex.get(word.upper()).keys())
! 1950: if uniq:
! 1951: return unique(lst)
! 1952: else:
! 1953: return lst
! 1954:
1.53 dwinter 1955: def getLinesFromIndex(self,word,doc):
1956: """get lines"""
1957: return self.lineIndex[word][doc]
1958:
1959: def cleanInLineIndex(self):
1960: """delete InlineIndex"""
1961: for x in list(self.lineIndex.keys()):
1962: del(self.lineIndex[x])
1963: print [x for x in self.lineIndex.keys()]
1964:
1965: return "ok"
1966:
1967: def storeInLineIndex(self,key,value):
1968: """store in index"""
1969:
1970: if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):
1971: self.lineIndex=OOBTree()
1972: li=self.lineIndex
1973:
1974: if li.has_key(key):
1.54 dwinter 1975:
1976: # if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):
1977: if li[key].has_key(value[0]):
1978: tmp=li[key][value[0]]
1979: tmp.append(value[1]) # add it if now in the array
1980: li[key][value[0]]=tmp[0:]
1.53 dwinter 1981: else:
1982: li[key][value[0]]=[value[1]] # new array for lines
1983:
1984: else:
1985:
1986: li[key]=OOBTree()# new btree for lines
1987: li[key][value[0]]=[value[1]]
1988:
1989:
1990: self.lineIndex=li
1991:
1992: get_transaction().commit()
1993:
1.51 dwinter 1994:
1995: def showFile(self,fileId):
1996: """show a file"""
1997: f=self.CDLICatalog({'title':fileId})
1998: if not f:
1999: return ""
2000:
1.52 dwinter 2001: return f[0].getObject().getLastVersionFormattedData()
1.55 ! dwinter 2002:
! 2003: def showLineFromFile(self,fileId,lineNum):
! 2004: """get line lineNum fromFileId"""
! 2005:
! 2006: file=self.showFile(fileId)
! 2007: str="^%s\.(.*)"%lineNum
! 2008:
! 2009: m=re.search(str,file,flags=re.M)
! 2010: if m:
! 2011: return m.group(1)
! 2012: else:
! 2013: return ""
1.51 dwinter 2014:
1.37 dwinter 2015: def URLquote(self,str):
2016: """quote url"""
2017: return urllib.quote(str)
2018:
2019: def URLunquote(self,str):
2020: """unquote url"""
2021: return urllib.unquote(str)
2022:
2023:
1.26 dwinter 2024: def forceunlock(self):
2025: "break all locks"
2026: ret=[]
2027: for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
2028: un=f[1].forceunlock()
1.39 dwinter 2029:
1.26 dwinter 2030: if un and un !="":
2031: ret.append((f[0],un))
1.46 dwinter 2032:
1.26 dwinter 2033: return ret
2034:
2035: def getChangesByAuthor(self,author,n=100):
1.25 dwinter 2036: """getChangesByAuthor"""
1.26 dwinter 2037: zcat=self.CDLIObjectsCatalog
2038: res=zcat({'lastEditor':author,
1.25 dwinter 2039: 'sort_on':'getTime',
2040: 'sort_order':'descending',
2041: 'sort_limit':n})[:n ]
1.26 dwinter 2042:
2043: return res
2044:
2045: def getChangesByAuthor_html(self,author,n=100):
2046: """html output for changes by author"""
2047: tmp={}
2048: list=[]
2049: for x in self.getChangesByAuthor(author):
2050: nr=x.getObject().getVersionNumber()
2051: id=x.getObject().aq_parent.getId()
2052: #hinzufuegen, wenn Version neuer als die
2053: if tmp.get(id,(0,0))[1] < nr:
2054: tmp[id]=(x.getObject().aq_parent,nr)
2055:
2056:
1.45 dwinter 2057: return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)
1.26 dwinter 2058:
1.25 dwinter 2059: def getLastChanges(self,n=100):
2060: """get the last n changes"""
2061: n=int(n)
2062: zcat=self.CDLICatalog
2063: return zcat({'sort_on':'getLastChangeDate',
2064: 'sort_order':'descending',
2065: 'sort_limit':n})[:n ]
2066:
2067:
2068: def getLastChanges_html(self,n=100):
2069: """get the last n changes"""
2070: list = [x.getId for x in self.getLastChanges(n)]
2071: return self.cdli_main.findObjectsFromList(list=list,display=True)
2072:
1.24 dwinter 2073: def refreshTxt(self,txt="",threadName=None):
1.22 dwinter 2074: """txt fuer refresh"""
2075:
1.24 dwinter 2076: return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
1.22 dwinter 2077:
2078:
1.24 dwinter 2079: def getResult(self,threadName=None):
1.22 dwinter 2080: """result of thread"""
2081: try:
1.24 dwinter 2082: return self._v_uploadATF[threadName].getResult()
1.22 dwinter 2083: except:
2084: return "One moment, please"
2085:
1.24 dwinter 2086:
2087: def checkThreads(self):
2088: """check threads"""
1.42 dwinter 2089: ret="<html><body>"
2090: for thread in threading.enumerate():
1.45 dwinter 2091: ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
1.42 dwinter 2092:
2093: return ret
2094:
2095:
1.24 dwinter 2096:
1.22 dwinter 2097: def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
2098: """standard ausgabe"""
2099: #self._v_uploadATF.returnValue=None
2100:
2101: threadName=repeat
2102: if not threadName or threadName=="":
2103: tmpVar=False
1.24 dwinter 2104:
1.22 dwinter 2105: thread=uploadATFThread()
1.24 dwinter 2106: threadName=thread.getName()[0:]
1.36 dwinter 2107: if (not hasattr(self,'_v_uploadATF')):
1.24 dwinter 2108: self._v_uploadATF={}
2109:
2110: self._v_uploadATF[threadName]=thread
1.22 dwinter 2111: #self._xmltrans.start()
2112: #thread=Thread(target=self._v_uploadATF)
2113:
1.24 dwinter 2114: self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
1.22 dwinter 2115: #thread.start()
1.24 dwinter 2116: self._v_uploadATF[threadName].start()
1.22 dwinter 2117:
2118:
1.24 dwinter 2119: self.threadName=self._v_uploadATF[threadName].getName()[0:]
1.22 dwinter 2120: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2121:
2122: if wait_template:
2123: return wait_template[0][1]()
2124: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1.24 dwinter 2125: return pt(txt='/uploadATF',threadName=threadName)
1.22 dwinter 2126: #_v_xmltrans.run()
2127:
2128: else:
2129: #recover thread, if lost
1.36 dwinter 2130: if (not hasattr(self,'_v_uploadATF')):
1.24 dwinter 2131: self._v_uploadATF={}
2132: if not self._v_uploadATF.get(threadName,None):
1.22 dwinter 2133: for thread in threading.enumerate():
2134: if threadName == thread.getName():
1.24 dwinter 2135: self._v_uploadATF[threadName]=thread
2136:
2137: if not self._v_uploadATF[threadName].returnValue:
1.22 dwinter 2138:
2139:
2140: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2141: if wait_template:
2142: return wait_template[0][1]()
2143:
2144: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
2145:
1.24 dwinter 2146: return pt(txt='/uploadATF',threadName=threadName)
1.22 dwinter 2147:
2148: else:
1.30 dwinter 2149: # tmp={}
2150: # for key in self._v_uploadATF[threadName].returnValue.keys():
2151: # t=self._v_uploadATF[threadName].returnValue[key]
2152: # if type(t) is ListType:
2153: # tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
2154: # else:
2155: # tmp[key]=self._v_uploadATF[threadName].returnValue[key]
1.46 dwinter 2156: # repr(tmp[key]),repr(key)
1.30 dwinter 2157: #
2158: # #
1.28 dwinter 2159: #tmp=self.cdli_main.tmpStore2[threadName]
1.30 dwinter 2160: tmp=self._v_uploadATF[threadName].returnValue
1.29 dwinter 2161:
1.49 dwinter 2162: self._v_uploadATF[threadName].continueVar=False
1.29 dwinter 2163:
1.22 dwinter 2164: self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
1.45 dwinter 2165: self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]
2166: self.REQUEST.SESSION['errors']=tmp['errors']
1.22 dwinter 2167: self.REQUEST.SESSION['newPs']=tmp['newPs']
2168: self.REQUEST.SESSION['tmpdir']=tmp['dir']
1.30 dwinter 2169: #del(self.cdli_main.tmpStore2[threadName])
1.39 dwinter 2170:
1.30 dwinter 2171:
1.22 dwinter 2172: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
1.39 dwinter 2173:
1.47 dwinter 2174: return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
1.22 dwinter 2175: basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
1.30 dwinter 2176:
2177: def redoUpload(self,threadName):
2178: """redo the upload"""
2179: tmp=self.cdli_main.tmpStore2[threadName]
2180: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
1.45 dwinter 2181: return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
1.30 dwinter 2182: basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
2183:
1.22 dwinter 2184: def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
2185: """nowupload the files"""
2186:
2187:
2188:
2189: threadName=repeat
2190: if not threadName or threadName=="":
1.24 dwinter 2191: thread=uploadATFfinallyThread()
2192: threadName=thread.getName()[0:]
1.36 dwinter 2193:
1.35 dwinter 2194: if (not hasattr(self,'_v_uploadATF')):
1.46 dwinter 2195: self._v_uploadATF={}
1.36 dwinter 2196:
1.43 dwinter 2197:
1.24 dwinter 2198: self._v_uploadATF[threadName]=thread
1.22 dwinter 2199:
2200:
1.24 dwinter 2201: 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'])
1.22 dwinter 2202:
1.24 dwinter 2203: self._v_uploadATF[threadName].start()
1.22 dwinter 2204:
2205:
1.24 dwinter 2206:
1.22 dwinter 2207: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2208:
2209: if wait_template:
2210: return wait_template[0][1]()
2211: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
2212:
1.24 dwinter 2213: return pt(txt='/uploadATFfinally',threadName=threadName)
1.22 dwinter 2214: #_v_xmltrans.run()
2215:
2216: else:
2217: #recover thread, if lost
2218: if not hasattr(self,'_v_uploadATF'):
1.24 dwinter 2219: self._v_uploadATF={}
2220: if not self._v_uploadATF.get(threadName,None):
1.22 dwinter 2221: for thread in threading.enumerate():
2222: if threadName == thread.getName():
1.24 dwinter 2223: self._v_uploadATF[threadName]=thread
1.22 dwinter 2224:
1.24 dwinter 2225: if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[threadName].end) :
1.22 dwinter 2226:
2227: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
2228: if wait_template:
2229: return wait_template[0][1]()
2230:
2231: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1.24 dwinter 2232: return pt(txt='/uploadATFfinally',threadName=threadName)
1.22 dwinter 2233: else:
2234:
2235: if RESPONSE is not None:
2236: RESPONSE.redirect(self.absolute_url())
2237:
1.49 dwinter 2238: def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
1.1 dwinter 2239: """import files"""
1.22 dwinter 2240: root=self.cdli_main
1.49 dwinter 2241: count=0
1.3 dwinter 2242: if not files:
2243: files=os.listdir(folderName)
2244:
1.1 dwinter 2245: for f in files:
2246: folder=f[0:3]
2247: f2=f[0:5]
1.22 dwinter 2248: obj=self.ZopeFind(root,obj_ids=[folder])
1.19 dwinter 2249: if ext:
2250:
1.43 dwinter 2251: ext.result+="<p>adding: %s </p>"%f
1.1 dwinter 2252: if not obj:
1.22 dwinter 2253: manage_addCDLIFileFolder(root,folder,folder)
2254: fobj=getattr(root,folder)
2255: #get_transaction().commit()
1.1 dwinter 2256: else:
2257: fobj=obj[0][1]
2258:
2259: obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
2260:
2261: if not obj2:
2262: manage_addCDLIFileFolder(fobj,f2,f2)
2263: fobj2=getattr(fobj,f2)
2264:
2265: else:
2266: fobj2=obj2[0][1]
2267:
1.48 dwinter 2268: file2=os.path.join(folderName,f)
1.1 dwinter 2269: id=f
2270: manage_addCDLIFile(fobj2,f,'','')
2271: id=f
2272: ob=fobj2._getOb(f)
2273: ob.title=id
2274:
1.48 dwinter 2275: manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)
1.3 dwinter 2276: self.CDLICatalog.catalog_object(ob)
2277: #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
2278: #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
1.49 dwinter 2279: count+=1
2280:
2281: if count > 1000:
2282: print "committing"
2283: get_transaction().commit()
2284: count=0
2285: get_transaction().commit()
1.3 dwinter 2286: return "ok"
1.22 dwinter 2287:
2288:
2289: manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
1.1 dwinter 2290:
2291:
1.22 dwinter 2292: def manage_addCDLIRoot(self, id, title='',
1.1 dwinter 2293: createPublic=0,
2294: createUserF=0,
2295: REQUEST=None):
2296: """Add a new Folder object with id *id*.
2297:
2298: If the 'createPublic' and 'createUserF' parameters are set to any true
2299: value, an 'index_html' and a 'UserFolder' objects are created respectively
2300: in the new folder.
2301: """
1.22 dwinter 2302: ob=CDLIRoot()
1.1 dwinter 2303: ob.id=str(id)
2304: ob.title=title
2305: self._setObject(id, ob)
2306: ob=self._getOb(id)
2307:
2308: checkPermission=getSecurityManager().checkPermission
2309:
2310: if createUserF:
2311: if not checkPermission('Add User Folders', ob):
2312: raise Unauthorized, (
2313: 'You are not authorized to add User Folders.'
2314: )
2315: ob.manage_addUserFolder()
2316:
2317:
2318: if REQUEST is not None:
1.22 dwinter 2319: return self.manage_main(self, REQUEST, update_menu=1)
2320:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>