Annotation of cdli/cdli_files.py, revision 1.65

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>