Annotation of cdli/cdli_files.py, revision 1.97

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.83      dwinter    24: from BTrees.OOBTree import OOBTree, OOTreeSet
1.57      dwinter    25: import logging
1.58      dwinter    26: import transaction
1.61      dwinter    27: import copy
1.66      dwinter    28: import codecs
1.76      dwinter    29: import sys
1.83      dwinter    30: from BTrees.IOBTree import IOBTree 
1.81      casties    31: import cdliSplitter
1.83      dwinter    32: from sets import Set
                     33: import md5
1.87      dwinter    34: from DownloadBasket import DownloadBasketFinallyThread
1.85      dwinter    35:                                        
                     36: def makelist(mySet):
                     37:         x = list(mySet)
                     38:         x.sort()
                     39:         return x
                     40:     
1.79      casties    41: def unicodify(s):
                     42:     """decode str (utf-8 or latin-1 representation) into unicode object"""
                     43:     if not s:
                     44:         return u""
                     45:     if isinstance(s, str):
                     46:         try:
                     47:             return s.decode('utf-8')
                     48:         except:
                     49:             return s.decode('latin-1')
                     50:     else:
                     51:         return s
                     52: 
                     53: def utf8ify(s):
                     54:     """encode unicode object or string into byte string in utf-8 representation.
                     55:        assumes string objects to be utf-8"""
                     56:     if not s:
                     57:         return ""
                     58:     if isinstance(s, str):
                     59:         return s
                     60:     else:
                     61:         return s.encode('utf-8')
                     62: 
1.81      casties    63: def formatAtfHtml(l):
                     64:     """escape special ATF characters for HTML"""
                     65:     if not l:
                     66:         return ""
                     67: 
                     68:     # replace &
                     69:     l = l.replace('&','&')
                     70:     # replace angular brackets
                     71:     l = l.replace('<','&lt;')
                     72:     l = l.replace('>','&gt;')
                     73:     return l
                     74: 
                     75: def formatAtfLineHtml(l, nolemma=True):
                     76:     """format ATF line for HTML"""
                     77:     if not l:
                     78:         return ""
                     79: 
                     80:     if nolemma:
                     81:         # ignore lemma lines
                     82:         if l.lstrip().startswith('#lem:'):
                     83:             return ""
                     84:     
                     85:     return formatAtfHtml(l)
                     86: 
1.79      casties    87: 
1.81      casties    88: 
                     89: def formatAtfFullLineNum(txt, nolemma=True):
                     90:     """format full line numbers in ATF text"""
                     91:     # surface codes
                     92:     surfaces = {'@obverse':'obv',
                     93:                 '@reverse':'rev',
                     94:                 '@surface':'surface',
                     95:                 '@edge':'edge',
                     96:                 '@left':'left',
                     97:                 '@right':'right',
                     98:                 '@top':'top',
                     99:                 '@bottom':'bottom',
                    100:                 '@face':'face',
                    101:                 '@seal':'seal'}
                    102: 
                    103:     if not txt:
                    104:         return ""
                    105:     
                    106:     ret = []
                    107:     surf = ""
                    108:     col = ""
                    109:     for line in txt.splitlines():
                    110:         line = unicodify(line)
                    111:         if line and line[0] == '@':
                    112:             # surface or column
                    113:             words = line.split(' ')
                    114:             if words[0] in surfaces:
                    115:                 surf = line.replace(words[0],surfaces[words[0]]).strip()
                    116:             
                    117:             elif words[0] == '@column':
                    118:                 col = ' '.join(words[1:])
                    119:             
                    120:         elif line and line[0] in '123456789':
                    121:             # ordinary line -> add line number
                    122:             line = "%s:%s:%s"%(surf,col,line)
                    123:             
                    124:         ret.append(line)
                    125:     
                    126:     return '\n'.join(ret)
                    127:             
                    128:             
1.73      dwinter   129: def generateXMLReturn(hash):
                    130:     """erzeugt das xml file als returnwert fuer uploadATFRPC"""
                    131: 
                    132:     ret="<return>"
                    133:     
                    134:     ret+="<errors>"
                    135:     for error in hash['errors']:
                    136:         ret+="""<error atf="%s">%s</error>"""%error
                    137:     
                    138:     ret+="</errors>"
                    139:     
                    140:     ret+="<changes>"
                    141:     for changed in hash['changed']:
                    142:         ret+="""<change atf="%s">%s</change>"""%changed
                    143:     ret+="</changes>"
                    144:     
                    145:     ret+="<newPs>"
                    146:     for new in hash['newPs']:
                    147:         ret+="""<new atf="%s"/>"""%new
                    148:     ret+="</newPs>"
                    149:     
                    150:     ret+="</return>"
                    151:     return ret
                    152:     
                    153:     
1.55      dwinter   154: def unique(s):
                    155:     """Return a list of the elements in s, but without duplicates.
                    156: 
                    157:     For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
                    158:     unique("abcabc") some permutation of ["a", "b", "c"], and
                    159:     unique(([1, 2], [2, 3], [1, 2])) some permutation of
                    160:     [[2, 3], [1, 2]].
                    161: 
                    162:     For best speed, all sequence elements should be hashable.  Then
                    163:     unique() will usually work in linear time.
                    164: 
                    165:     If not possible, the sequence elements should enjoy a total
                    166:     ordering, and if list(s).sort() doesn't raise TypeError it's
                    167:     assumed that they do enjoy a total ordering.  Then unique() will
                    168:     usually work in O(N*log2(N)) time.
                    169: 
                    170:     If that's not possible either, the sequence elements must support
                    171:     equality-testing.  Then unique() will usually work in quadratic
                    172:     time.
                    173:     (from the python cookbook)
                    174:     """
                    175: 
                    176:     n = len(s)
                    177:     if n == 0:
                    178:         return []
                    179: 
                    180:     # Try using a dict first, as that's the fastest and will usually
                    181:     # work.  If it doesn't work, it will usually fail quickly, so it
                    182:     # usually doesn't cost much to *try* it.  It requires that all the
                    183:     # sequence elements be hashable, and support equality comparison.
                    184:     u = {}
                    185:     try:
                    186:         for x in s:
                    187:             u[x] = 1
                    188:     except TypeError:
                    189:         del u  # move on to the next method
                    190:     else:
                    191:         return u.keys()
                    192: 
                    193:     # We can't hash all the elements.  Second fastest is to sort,
                    194:     # which brings the equal elements together; then duplicates are
                    195:     # easy to weed out in a single pass.
                    196:     # NOTE:  Python's list.sort() was designed to be efficient in the
                    197:     # presence of many duplicate elements.  This isn't true of all
                    198:     # sort functions in all languages or libraries, so this approach
                    199:     # is more effective in Python than it may be elsewhere.
                    200:     try:
                    201:         t = list(s)
                    202:         t.sort()
                    203:     except TypeError:
                    204:         del t  # move on to the next method
                    205:     else:
                    206:         assert n > 0
                    207:         last = t[0]
                    208:         lasti = i = 1
                    209:         while i < n:
                    210:             if t[i] != last:
                    211:                 t[lasti] = last = t[i]
                    212:                 lasti += 1
                    213:             i += 1
                    214:         return t[:lasti]
                    215: 
                    216:     # Brute force is all that's left.
                    217:     u = []
                    218:     for x in s:
                    219:         if x not in u:
                    220:             u.append(x)
                    221:     return u
                    222: 
                    223: 
1.39      dwinter   224: class BasketContent(SimpleItem):
                    225:     """classe fuer den Inhalt eines Baskets"""
1.77      dwinter   226:    
1.39      dwinter   227:     def __init__(self,content=[]):
                    228:         """content"""
                    229:         self.contentList=content[0:]
                    230:     
                    231:     def getContent(self):
                    232:         """get content"""
1.87      dwinter   233:         
1.39      dwinter   234:         return self.contentList
                    235:     
                    236:     def setContent(self,content):
                    237:         self.contentList=content[0:]
                    238:     
                    239:     def numberOfItems(self):
                    240:         """number"""
                    241:         
                    242:         return len(self.getContent())
                    243:         
                    244:     
1.19      dwinter   245: class uploadATFfinallyThread(Thread):
1.20      dwinter   246:     """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
                    247:     
1.19      dwinter   248:     def __init__(self):
1.20      dwinter   249:         """init for uploadATFfinallyThread"""
1.19      dwinter   250:         self.continueVar=True
                    251:         self.returnValue=None
                    252:         self.end=False
                    253:         Thread.__init__(self)
                    254:            
                    255:     def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
1.20      dwinter   256:         """set start values for the thread"""
1.19      dwinter   257:         self.procedure=procedure
                    258:         self.comment=comment
                    259:         self.basketname=basketname
                    260:         self.unlock=unlock
                    261:         self.SESSION=SESSION
                    262:         self.username=username
                    263:         self.serverport=serverport
1.60      dwinter   264:        
1.19      dwinter   265:         
                    266:     def __call__(self):
1.20      dwinter   267:         """call of the thread (equals run)"""
1.19      dwinter   268:         self.run()
                    269:         return True
                    270:     
                    271:     def getContext(self, app,serverport="8080"):
1.20      dwinter   272:         """get the context within the ZODB"""
                    273:         
1.19      dwinter   274:         resp = HTTPResponse(stdout=None)
                    275:         env = {
                    276:             'SERVER_NAME':'localhost',
                    277:             'SERVER_PORT':serverport,
                    278:             'REQUEST_METHOD':'GET'
                    279:             }
                    280:         req = HTTPRequest(None, env, resp)
                    281:         return app.__of__(RequestContainer(REQUEST = req))
                    282:           
1.26      dwinter   283:         
1.19      dwinter   284:     def run(self):
1.20      dwinter   285:         """run"""
                    286:         
1.19      dwinter   287:         self.result=""
1.20      dwinter   288:         #find context within ZODB
1.19      dwinter   289:         from Zope import DB
                    290:         conn = DB.open()
                    291:         root = conn.root()
                    292:         app  = root['Application']
                    293:         ctx = self.getContext(app,serverport=self.serverport)
                    294: 
1.20      dwinter   295:         #add the files
1.19      dwinter   296:         self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
1.20      dwinter   297:         #commit the transactions
1.58      dwinter   298:         transaction.get().commit()
1.19      dwinter   299:         conn.close()
1.20      dwinter   300:         #set flag for end of this method
1.19      dwinter   301:         self.end=True
1.66      dwinter   302:         logging.info("ended")
                    303:         return True
1.19      dwinter   304:     
1.22      dwinter   305:     def __del__(self):
                    306:         """delete"""
                    307:         
                    308:         
                    309:     
1.19      dwinter   310:     def getResult(self):
1.20      dwinter   311:         """method for accessing result"""
                    312:         
1.19      dwinter   313:         return self.result
                    314:      
                    315:     def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
                    316:         """upload the files"""
1.20      dwinter   317:         #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
1.19      dwinter   318:         ctx2=ctx.cdliRoot
                    319:    
                    320:         self.result+="<h2>Start processing</h2>"
1.20      dwinter   321:         
                    322:         #shall I only upload the changed files?
1.81      casties   323:         logging.debug("uploadATFfinally procedure: %s"%procedure)
1.19      dwinter   324:         if procedure=="uploadchanged":
1.66      dwinter   325:             changed=[x[0] for x in SESSION.get('changed',[])]
1.61      dwinter   326:             uploadFns=changed+SESSION.get('newPs',[])
1.19      dwinter   327:         
1.20      dwinter   328:         #or all
1.19      dwinter   329:         elif procedure=="uploadAll":
                    330:             uploadFns=[]
                    331:             for x in os.listdir(SESSION['tmpdir']):
1.45      dwinter   332:                 if not x in SESSION['lockerrors']:
1.19      dwinter   333:                     uploadFns.append(x)
1.20      dwinter   334:                     
                    335:         #or maybe nothing
1.19      dwinter   336:         elif procedure=="noupload":
1.81      casties   337:             return True
1.19      dwinter   338:         else:
                    339:             uploadFns=[]
                    340:             
1.20      dwinter   341:         #do first the changed files    
1.65      dwinter   342:         i=0
1.19      dwinter   343:         for fn in uploadFns:
1.81      casties   344:             logging.debug("uploadATFfinally uploadFn=%s"%fn)
1.66      dwinter   345:             i+=1
1.19      dwinter   346:             founds=ctx2.CDLICatalog.search({'title':fn})
                    347:             if len(founds)>0:
                    348:                 SESSION['author']=str(username)
1.63      dwinter   349:                 self.result="<p>Changing : %s"%fn+self.result
1.81      casties   350:                 logging.debug("uploadatffinallythread changing:%s"%fn+self.result)
1.49      dwinter   351:                 founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
1.81      casties   352:             if i%200==0:
                    353:                 transaction.get().commit()
                    354:                 logging.debug("uploadatffinallythread changing: do commit")
1.65      dwinter   355:         
                    356:         transaction.get().commit()
1.81      casties   357:         logging.debug("uploadatffinallythread changing: last commit")
1.62      dwinter   358: 
1.20      dwinter   359:         #now add the new files        
1.19      dwinter   360:         newPs=SESSION['newPs']
                    361:         if len(newPs)>0:
                    362:             tmpDir=SESSION['tmpdir']
1.81      casties   363:             logging.debug("uploadatffinallythread adding start")
1.63      dwinter   364:             self.result="<p>Adding files</p>"+self.result
1.20      dwinter   365:             #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
1.22      dwinter   366:             ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
1.81      casties   367:             logging.debug("uploadatffinallythread adding finished")
1.19      dwinter   368:         
1.20      dwinter   369:         #unlock locked files?
1.19      dwinter   370:         if unlock:
1.81      casties   371:             logging.debug("uploadatffinallythread unlocking start")
1.63      dwinter   372:             self.result="<p>Unlock files</p>"+self.result
1.19      dwinter   373:             unlockFns=[]
                    374:             for x in os.listdir(SESSION['tmpdir']):
                    375:                     if not x in SESSION['errors']:
                    376:                         unlockFns.append(x)
1.81      casties   377:                         
                    378:             logging.debug("unlocking have now what to unlock")
1.65      dwinter   379:                         
1.19      dwinter   380:             for fn in unlockFns:
1.65      dwinter   381:                 #logging.info("will unlock: %s"%fn)
1.19      dwinter   382:                 founds=ctx2.CDLICatalog.search({'title':fn})
1.65      dwinter   383:                 #logging.info("found it: %s"%repr(founds))
1.19      dwinter   384:                 if len(founds)>0:
1.65      dwinter   385:                     #logging.info("unlock: %s"%founds[0].getObject().getId())
1.19      dwinter   386:                     SESSION['author']=str(username)
                    387:                     founds[0].getObject().lockedBy=""
1.81      casties   388: 
                    389:             logging.debug("uploadatffinallythread unlocking done")
1.19      dwinter   390:                     
1.65      dwinter   391:         #if a basketname is given, add files to the basket
1.19      dwinter   392:         if not (basketname ==''):
1.81      casties   393:             logging.debug("uploadatffinallythread add to basket %s"%basketname)
1.65      dwinter   394:             self.result="<p>Add to basket</p>"+self.result
1.41      dwinter   395:             basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
1.19      dwinter   396:             
                    397:             if not basketId: # create new basket
1.81      casties   398:                 logging.debug("uploadatffinallythread create basket %s"%basketname)
1.65      dwinter   399:                 self.result="<p>Create a new basket</p>"+self.result
1.19      dwinter   400:                 ob=ctx2.basketContainer.addBasket(basketname)
                    401:                 basketId=ob.getId()
                    402:             basket=getattr(ctx2.basketContainer,str(basketId))
                    403:             ids=os.listdir(SESSION['tmpdir'])
1.93      dwinter   404:             #logging.debug("should add:"+repr(ids))
1.19      dwinter   405:             basket.addObjects(ids,deleteOld=True,username=str(username))    
                    406:                
1.81      casties   407:         logging.debug("uploadatffinallythread uploadfinally done")
                    408: 
1.19      dwinter   409:         if RESPONSE is not None:
                    410:             RESPONSE.redirect(self.aq_parent.absolute_url())
                    411:         
                    412:         return True
1.60      dwinter   413: 
                    414: class tmpStore(SimpleItem):
                    415:     """simple item"""
                    416:     meta_type="cdli_upload"
1.19      dwinter   417:     
1.60      dwinter   418:     def __init__(self,id):
                    419:         """init tmp"""
                    420:         self.id=id
                    421:         
1.19      dwinter   422: class uploadATFThread(Thread):
1.20      dwinter   423:     """class for checking the files befor uploading"""
1.19      dwinter   424:     
                    425:     def __init__(self):
1.20      dwinter   426:         """initialise"""
                    427:         
1.19      dwinter   428:         self.continueVar=True
                    429:         self.returnValue=None
                    430:         
                    431:         Thread.__init__(self)
                    432:         
                    433:         
1.60      dwinter   434:     def set(self,upload,basketId,username,idTmp,serverport="8080"):
1.20      dwinter   435:         """set start values for the thread"""
1.19      dwinter   436:         self.result=""
                    437:         self.upload=upload
                    438:         self.basketId=basketId
                    439:         self.username=username
                    440:         self.serverport=serverport
1.60      dwinter   441:         self.idTmp=idTmp
1.19      dwinter   442:         
                    443:     def __call__(self):
1.20      dwinter   444:         """call method """
1.19      dwinter   445:         self.run()
                    446:         return True
                    447:     
                    448:     def getContext(self, app,serverport="8080"):
1.20      dwinter   449:         """get the context within the ZODB"""
1.19      dwinter   450:         resp = HTTPResponse(stdout=None)
                    451:         env = {
                    452:             'SERVER_NAME':'localhost',
                    453:             'SERVER_PORT':serverport,
                    454:             'REQUEST_METHOD':'GET'
                    455:             }
                    456:         req = HTTPRequest(None, env, resp)
                    457:         return app.__of__(RequestContainer(REQUEST = req))
                    458:         
                    459:     def run(self):
1.60      dwinter   460:         idTmp=self.idTmp
1.19      dwinter   461:         self.result=""
1.20      dwinter   462:         #find context within ZODB
1.19      dwinter   463:         from Zope import DB
                    464:         conn = DB.open()
                    465:         root = conn.root()
                    466:         app  = root['Application']
                    467:         ctx = self.getContext(app,serverport=self.serverport)
1.60      dwinter   468:         logging.info("run intern")
1.63      dwinter   469:         try:
1.73      dwinter   470:             logging.info("created: %s"%idTmp)
1.63      dwinter   471:             ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
                    472:         except:
                    473:             logging.error("thread upload: %s %s"%sys.exc_info()[0:2])
                    474:             
1.60      dwinter   475:         logging.info("call thread intern")
                    476:         self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)
1.24      dwinter   477:      
1.30      dwinter   478:         #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
1.58      dwinter   479:         
1.66      dwinter   480:         
1.58      dwinter   481:         transaction.get().commit()
1.49      dwinter   482:        
1.19      dwinter   483:         conn.close()
1.22      dwinter   484:         
1.73      dwinter   485:         return getattr(ctx.temp_folder,idTmp)
1.19      dwinter   486:         
                    487:     def getResult(self):
1.20      dwinter   488:         """method for accessing result"""
1.19      dwinter   489:         return self.result
                    490:     
1.60      dwinter   491:     def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
1.19      dwinter   492:         """upload an atf file"""
                    493:         #TODO: add comments
                    494:         #TODO: finish uploadATF
1.60      dwinter   495:         
                    496:         stObj=getattr(ctx.temp_folder,idTmp)
                    497:         logging.info("start, upload thread")
1.25      dwinter   498:         self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
                    499:     
1.20      dwinter   500:         #make sure that id is a string and not an integer
1.19      dwinter   501:         basketId=str(basketId)
                    502:         
1.20      dwinter   503:         #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
                    504:         ctx2=ctx.cdliRoot
1.19      dwinter   505:         
1.20      dwinter   506:         #get temporary file for staging the downloaded and splitted files
1.19      dwinter   507:         dir=mkdtemp()
1.20      dwinter   508:         
                    509:         
                    510:         changed=[] # changed files
                    511:         errors=[]  # files with errors
1.45      dwinter   512:         lockerrors=[]  # files with errors
                    513: 
1.20      dwinter   514:         newPs=[]   # new p filed
                    515:         psNotInCatalog=[] # files not in the catalog
                    516:         
                    517:         #split the uploadedd atf file
1.25      dwinter   518:         basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
1.19      dwinter   519:         
1.20      dwinter   520:         #find basketId if not set
                    521:         
                    522:         #get active abaket
1.19      dwinter   523:         if basketId == '0':
                    524:             basketObj=ctx2.basketContainer.getActiveBasket()
                    525:             if basketObj:
                    526:                 basketId=basketObj.getId()
                    527:                 
1.45      dwinter   528:         #if there is no active basket and no basketid given, id is empty, else get besketname and length
1.19      dwinter   529:         if basketId == '0':
                    530:             basketNameFromId=""
                    531:             basketLen=0
                    532:         else:
                    533:             basketNameFromId=getattr(ctx2.basketContainer,basketId).title
                    534:             basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
                    535:             
1.60      dwinter   536:         logging.info("got the file, upload thread")
1.25      dwinter   537:         self.result+="""<html><body><h2>I got the files</h2><
                    538:                         p>I am computing the differences to the exisiting files</p>"""
1.20      dwinter   539:                                    
                    540:         #start to check the files
1.19      dwinter   541:         for fn in os.listdir(dir):
                    542:             
1.63      dwinter   543:             self.result="<p>process:%s</p>"%fn+self.result
1.19      dwinter   544:             
1.20      dwinter   545:             # check if file is in the catalog
                    546:             #TODO: checkCatalog is not implemented yet
1.19      dwinter   547:             if ctx2.cdli_main.checkCatalog(fn):
                    548:                 psNotInCatalog.append(fn)
                    549:                 
1.20      dwinter   550:             #check if p-file already at the server  
1.19      dwinter   551:             founds=ctx2.CDLICatalog.search({'title':fn})    
                    552:       
1.20      dwinter   553:             #if not than add filename to the list of newfiles
1.46      dwinter   554:             
                    555:             data=file(os.path.join(dir,fn)).read()
1.69      dwinter   556:             status,msg=checkFile(fn,data,dir)
                    557:             #status=True
                    558:             
                    559:             
1.46      dwinter   560:             if not status: # error
                    561:                 errors.append((fn,msg))
1.69      dwinter   562:             
1.46      dwinter   563:             else:
                    564:                 if len(founds)==0:
                    565:                     newPs.append(fn)
                    566: 
                    567:                 #if p file alread at the server    
                    568:                 for found in founds:
                    569:                     #analyse the differences to the actual file
                    570:                     obj=found.getObject()
                    571: 
                    572:                     if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
1.63      dwinter   573:                                 lockerrors.append((fn,str(obj.lockedBy)))
1.46      dwinter   574:                     else:
                    575:                 
                    576:                         diffs=obj.diff(data)
                    577:                         if diffs[0]>0:
                    578:                             changed.append((obj,diffs)) #hochladen
1.31      dwinter   579: 
1.20      dwinter   580:         #ready, set the returnValues
1.19      dwinter   581:         self.result+="<h3>Done</h3></body></html>"
                    582:         
1.60      dwinter   583:         stObj.returnValue={}
1.19      dwinter   584:         
1.60      dwinter   585:         stObj.returnValue['errors']=errors
1.69      dwinter   586:         
1.60      dwinter   587:         stObj.returnValue['newPs']=newPs
                    588:         stObj.returnValue['tmpdir']=dir
                    589:         stObj.returnValue['basketLen']=basketLen
                    590:         stObj.returnValue['numberOfFiles']=numberOfFiles
                    591:         stObj.returnValue['basketNameFromId']=basketNameFromId
                    592:         stObj.returnValue['basketNameFromFile']=basketNameFromFile
                    593:         stObj.returnValue['basketId']=basketId
                    594:         stObj.returnValue['dir']=dir
1.61      dwinter   595:         #stObj.returnValue['changed']=copy.copy(changed)
                    596:         stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
                    597:         #stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
1.63      dwinter   598:         stObj.returnValue['lockerrors']=[x for x in lockerrors]
1.60      dwinter   599:         self.returnValue=True
1.19      dwinter   600:         #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
                    601:     
1.63      dwinter   602:  
1.4       dwinter   603: class CDLIBasketContainer(OrderedFolder):
                    604:     """contains the baskets"""
                    605:     
                    606: 
1.9       dwinter   607:     security=ClassSecurityInfo()
1.4       dwinter   608:     meta_type="CDLIBasketContainer"
                    609:     
1.73      dwinter   610:     def getPNumbersOfBasket(self,basketName):
                    611:         """get all pnumbers of a basket as a list, returns an empty list if basket not found
                    612:         @param basketName: name of the basket
                    613:         """
                    614:         ret=[]
                    615:         basketId=self.getBasketIdfromName(basketName)
                    616:         if not basketId:
                    617:             return []
                    618:         
                    619:         ob=getattr(self,basketId).getContent()
                    620:         
                    621:         ret=[x[0].split(".")[0] for x in ob]
                    622:         
                    623:         return ret
                    624:     
1.77      dwinter   625:     security.declareProtected('manage','getBasketAsOneFile')       
1.73      dwinter   626:     def getBasketAsOneFile(self,basketName,current="no"):
                    627:         """returns all files of the basket combined in one file
                    628:         @param basketName: Name of the basket
                    629:         @param current: (optional) if current is set to "yes" then the most current version of 
                    630:                         all files are downloaded and not the versions of the files as stored in the basket
                    631:         """
                    632:         ret=""
                    633:         basketId=self.getBasketIdfromName(basketName)
                    634:         if not basketId:
                    635:             return ""
                    636:         
                    637:         ob=getattr(self,basketId).getLastVersion()
                    638:         for object in ob.getContent():
                    639:             if current=="no": #version as they are in the basket
                    640:                             ret+=str(object[0].getData())+"\n"
                    641:             elif current=="yes":
                    642:                             #search current object
1.93      dwinter   643:                             #logging.debug("current: %s"%object[1].getId().split(".")[0])
1.73      dwinter   644:                             founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
                    645:                             if len(founds)>0:      
                    646:                                 ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
                    647:         return ret
                    648:     
1.77      dwinter   649:     security.declareProtected('manage','upDateBaskets') 
1.39      dwinter   650:     def upDateBaskets(self):
                    651:         """update content in to objects"""
                    652:         
                    653:         founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
                    654: 
                    655:         for found in founds:
                    656:             found[1].updateBasket()
                    657:         
1.32      dwinter   658:     security.declareProtected('manage','deleteBaskets')        
1.12      dwinter   659:     def deleteBaskets(self,ids=None):
                    660:         """delete baskets, i.e. move them into trash folder"""
                    661:         
                    662:         
                    663:         found=self.ZopeFind(self,obj_ids=['trash'])
                    664:         
                    665:         if len(found)<1:
                    666:             manage_addFolder(self, 'trash')
                    667:             trash=self._getOb('trash')
                    668:         else:
                    669:             trash=found[0][1]
                    670:         
                    671:         if type(ids) is not ListType:
                    672:             ids=[ids]
                    673:         cut=self.manage_cutObjects(ids)
                    674:         trash.manage_pasteObjects(cut)
                    675:         
1.32      dwinter   676:     security.declareProtected('manage','manageBaskets')       
1.73      dwinter   677:     def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
1.12      dwinter   678:         """manage baskets, delete or copy"""
                    679:         if submit=="delete":
                    680:             self.deleteBaskets(ids)
                    681:         
1.72      dwinter   682:         elif submit=="join":
1.73      dwinter   683:             flag,msg=self.joinBasket(joinBasket, ids)
1.72      dwinter   684:             logging.info("joining %s %s"%(flag,msg))
                    685:             
                    686:         elif submit=="subtract":
                    687:             logging.info("BBBb %s %s"%(basket1,basket2))
1.73      dwinter   688:             flag,msg=self.subtractBasket(subtractBasket, basket1,basket2)
1.72      dwinter   689:             logging.info("subtract %s %s"%(flag,msg))
1.12      dwinter   690:             
                    691:         if RESPONSE:
                    692:             RESPONSE.redirect(self.absolute_url())
1.32      dwinter   693:     
1.33      dwinter   694:     security.declareProtected('View','getBasketIdfromName')       
1.5       dwinter   695:     def getBasketIdfromName(self,basketname):
                    696:         """get id from name"""
                    697: 
                    698:         for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
                    699:             if basket[1].title==basketname:
                    700:                 return basket[0]
                    701:         else:
                    702:             None
1.9       dwinter   703:     
                    704:     security.declareProtected('manage','uploadBasket_html')        
                    705:             
1.4       dwinter   706:     def uploadBasket_html(self,basketId='0'):
                    707:         """upload an atf file, html form"""
1.9       dwinter   708:         
                    709: 
1.4       dwinter   710:         basketId=str(basketId)
                    711:         if not basketId=='0':
                    712:             basketName=getattr(self.basketContainer,basketId).title
                    713:         else:
                    714:             basketName=""
                    715:             
                    716:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
                    717:         return pt(basketId=basketId,basketName=basketName)
                    718:    
                    719: 
1.77      dwinter   720:     security.declareProtected('manage','index_html')    
1.4       dwinter   721:     def index_html(self):
                    722:         """stanadard ansicht"""
1.9       dwinter   723:         
                    724: 
                    725: 
1.4       dwinter   726:         ext=self.ZopeFind(self,obj_ids=["index.html"])
                    727:         if ext:
                    728:             return ext[0][1]()
                    729:         
                    730:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
                    731:         return pt()
                    732:     
                    733:     def getStorageFolderRoot(self):
                    734:         """root des storage folders"""
                    735:         return self.cdli_main
                    736:     
                    737:     def __init__(self,id,title):
                    738:         """ init basket container"""
                    739:         self.id=id
                    740:         self.title=title
                    741:      
1.51      dwinter   742:  
1.49      dwinter   743:     def getBasketsId(self):
                    744:         """get all baskets als klartext"""
1.51      dwinter   745:         
                    746:         ret=""
1.49      dwinter   747:         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
                    748:         for basket in baskets:
                    749:             com,user,time,values = basket[1].getContentIds()
                    750:             ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"
                    751:             for x in values:
                    752:                 ret+= x[0]+"\t"+x[1]+"\n"
1.66      dwinter   753:                 return ret
1.49      dwinter   754: 
1.4       dwinter   755:     def getBaskets(self,sortField='title'):
                    756:         """get all baskets files"""
                    757: 
                    758:         def sortName(x,y):
                    759:             return cmp(x[1].title.lower(),y[1].title.lower())
                    760: 
                    761:         def sortDate(x,y):
                    762:             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
                    763: 
                    764:         
                    765:         def sortComment(x,y):
                    766: 
                    767:         
                    768:             
                    769:              try:
                    770:                 xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
                    771:              except:
                    772:                 xc='ZZZZZZZZZZZZZ'.lower()
                    773:              try:
                    774:                 yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
                    775:              except:
                    776:                 yc='ZZZZZZZZZZZZZ'.lower()
                    777:     
                    778:     
                    779:              if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
                    780:                  
                    781:                  try:
                    782:                      xc=x[1].getLastVersion().getComment().lower()
                    783:                  except:
                    784:                      xc='ZZZZZZZZZZZZZ'.lower()
                    785:                      
                    786:              if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
                    787:                  try:
                    788:                      yc=y[1].getLastVersion().getComment().lower()
                    789:                  except:
                    790:                      yc='ZZZZZZZZZZZZZ'.lower()
                    791:     
                    792:              
                    793:                  return cmp(xc,yc)
                    794:         
                    795:         def sortAuthor(x,y):
                    796:             
                    797:             return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
                    798:         
                    799:         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
                    800:         
                    801:         
                    802:         if sortField=='title':
                    803:             baskets.sort(sortName)
                    804:         elif sortField=='date':
                    805:             baskets.sort(sortDate)
                    806:         elif sortField=='author':
                    807:             baskets.sort(sortAuthor)
                    808:         elif sortField=='comment':
                    809:             baskets.sort(sortComment)
1.39      dwinter   810: 
1.4       dwinter   811:         return baskets
1.72      dwinter   812:     
                    813:         
                    814:     def subtractBasket(self,newBasket,basket1,basket2):
                    815:         """subtract basket2 from basket1 
                    816:         (i.e. newbasket will contain alle elements of basket1 which are not in basket2), 
                    817:         if basket2 contains files which are not in basket1, then theses files fill be ignored
                    818:                
                    819:         @param newbasket: name of the new basket
                    820:         @param basket1: basket where basket2 will be subtracted from
                    821:         @param basket2: see above
                    822:       
                    823:         """
                    824:         logging.info("CCCCC %s %s"%(basket1,basket2))
                    825:    
                    826:         try:
                    827:             newB=self.addBasket(newBasket)
                    828:         except:
                    829:             return False, "cannot create the new basket"
                    830:         
                    831:         
1.4       dwinter   832: 
1.72      dwinter   833:        
                    834:      
                    835:         bas2= getattr(self,basket2)            
                    836:         bas2content=bas2.getContent()
                    837:         bas2ids=[x[0] for x in bas2content]
                    838:         
                    839:        
                    840:             
                    841:         bas1= getattr(self,basket1)   
                    842:         bas1content=bas1.getContent()
                    843:         
                    844:         
                    845:         newBasketContent={}
                    846:         
                    847:         for id,version in bas1content:
                    848:             if not (id in bas2ids):
                    849:                 newBasketContent[id]=version
                    850:         
                    851:         username=self.getActualUserName()
                    852:         
                    853:         logging.info("sbc %s"%newBasketContent)
                    854:         newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
                    855:         
                    856:         return True, ""
                    857:     
                    858:             
                    859:     def joinBasket(self,newBasket,oldBaskets):
1.71      dwinter   860:         """join two baskets
                    861:         @param newbasket: name of the new basket
                    862:         @param oldbaskets: list of baskets to be joined
                    863:         """
1.72      dwinter   864:         try:
                    865:             newB=self.addBasket(newBasket)
                    866:         except:
                    867:             return False, "cannot create the new basket"
                    868:         
                    869:         newBasketContent={}
                    870:         for ob in oldBaskets:
                    871:             x= getattr(self,ob,None)
                    872:             if x is None:
                    873:                 return False, "cannot find basket: %s"%ob
                    874:             
                    875:             ids=x.getContent() # hole den Inhalt
                    876:             
                    877:             for id,version in ids:
                    878:                 if newBasketContent.has_key(id): # p number gibt's schon
                    879:                     newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
                    880:                 else:
                    881:                     newBasketContent[id]=version
                    882:         username=self.getActualUserName()
                    883:         
                    884:         logging.info("nbc %s"%newBasketContent)
                    885:         newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
                    886:         
                    887:         return True, ""
                    888:     
1.4       dwinter   889:     def getNewId(self):
                    890:         """createIds"""
                    891:         last=getattr(self,'last',0)
                    892:         last +=1
                    893:         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
                    894:             last+=1
                    895:     
                    896:         self.last=last
                    897:         return last
                    898:     
1.6       dwinter   899:     def setActiveBasket(self,basketId,REQUEST=None):
1.4       dwinter   900:         """store active basketId in a cookie"""
                    901:         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
1.66      dwinter   902:         try:
                    903:             qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
                    904:             del(qs['basketId'])
                    905:         except:
                    906:             qs={}
1.6       dwinter   907:         if REQUEST:
1.49      dwinter   908:             REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
1.6       dwinter   909:             
1.4       dwinter   910:     def getActiveBasket(self):
                    911:         """get active basket from cookie"""
                    912:         
                    913:         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
1.6       dwinter   914:         if id:
                    915:             obj=getattr(self,str(id),None)
                    916:         else:
                    917:             obj=None
1.4       dwinter   918:         return obj
1.6       dwinter   919:     
1.4       dwinter   920:     def getActualUserName(self):
                    921:         """get name of the actualuser"""
                    922:         return str(self.REQUEST['AUTHENTICATED_USER'])
                    923:     
1.77      dwinter   924:     security.declareProtected('manage','addBasket') 
1.4       dwinter   925:     def addBasket(self,newBasketName):
                    926:         """add a new basket"""
                    927:         
                    928:         ob=manage_addCDLIBasket(self,newBasketName)
                    929:         return ob
1.72      dwinter   930: 
1.6       dwinter   931:     def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
1.4       dwinter   932:         """store it"""
1.6       dwinter   933:         if not ids:
                    934:             ids=self.REQUEST.SESSION['fileIds']
1.83      dwinter   935:            
                    936:         if (type(ids) is not ListType) and (not isinstance(ids,Set)):
1.4       dwinter   937:             ids=[ids]
                    938:         
1.83      dwinter   939:         if isinstance(ids,Set):
                    940:             ids=list(ids)
                    941:             
1.6       dwinter   942:         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
1.4       dwinter   943:             basketRet=self.addBasket(newBasketName)
                    944:             self.setActiveBasket(basketRet.getId())
                    945:             basket=getattr(self,basketRet.getId())
1.6       dwinter   946:         elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
1.4       dwinter   947:             basket=self.getActiveBasket()
1.6       dwinter   948:         
                    949:         added=basket.addObjects(ids)
                    950:         back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
                    951:         
                    952:         
                    953:         if fromFileList:
1.7       dwinter   954: 
1.83      dwinter   955:             return self.cdli_main.findObjectsFromList(list=ids,basketName=basket.title,numberOfObjects=added)
1.6       dwinter   956:        
1.4       dwinter   957:         if RESPONSE:
1.6       dwinter   958:             
1.4       dwinter   959:             RESPONSE.redirect(back)
                    960:             
1.6       dwinter   961:         return True
                    962:     
1.4       dwinter   963: def manage_addCDLIBasketContainerForm(self):
                    964:     """add the CDLIBasketContainer form"""
                    965:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
                    966:     return pt()
                    967: 
                    968: def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
                    969:     """add the basket"""
                    970:     ob=CDLIBasketContainer(id,title)
                    971:     
                    972:     self._setObject(id, ob)
                    973:     
                    974:     if RESPONSE is not None:
                    975:         RESPONSE.redirect('manage_main')
                    976: 
1.5       dwinter   977: class CDLIBasket(Folder,CatalogAware):
1.4       dwinter   978:     """basket"""
                    979:     
                    980:     meta_type="CDLIBasket"
1.5       dwinter   981:     default_catalog="CDLIBasketCatalog"
1.4       dwinter   982:     
1.75      dwinter   983:     def searchInBasket(self,indexName,searchStr,regExp=False):
                    984:         """searchInBasket"""
                    985: 
1.81      casties   986:         lst=self.searchInLineIndexDocs(indexName,searchStr,uniq=True,regExp=regExp) #TODO: fix this
1.75      dwinter   987:         ret={}
                    988:         
                    989:         lv=self.getLastVersion()
1.76      dwinter   990: 
                    991: 
1.75      dwinter   992:         for obj in lv.content.getContent():
                    993:             id=obj[1].getId().split(".")[0]
                    994:             if id in lst:
                    995:         
                    996:                 ret[id]=self.showWordInFile(id,searchStr,lineList=self.getLinesFromIndex(indexName,searchStr,id,regExp=regExp),regExp=regExp,indexName=indexName)
                    997:         
                    998:         
                    999:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultsInBasket')).__of__(self)
                   1000:         return pt(result=ret,indexName=indexName,regExp=regExp,word=searchStr)
                   1001:         
                   1002:          
                   1003:  
                   1004:         
                   1005:     def searchInBasket_v1(self,searchStr):
1.74      dwinter  1006:         """search occurences of searchStr in files im basket"""
                   1007:         ret=[]
                   1008:         lv=self.getLastVersion()
                   1009:         logging.info("searching")
                   1010:         for obj in lv.content.getContent():
                   1011:             txt=obj[0].getData()
                   1012:             for x in txt.split("\n"):
                   1013:                 logging.info("search %s"%x)
                   1014:                 if re.match(searchStr,x):
                   1015:                     ret.append(x)
                   1016:         
                   1017:         return "\n".join(ret)
                   1018:                 
                   1019:             
1.4       dwinter  1020:     def getFile(self,obj):
                   1021:         return obj[1]
                   1022:     
                   1023:     def getFileLastVersion(self,obj):
                   1024:         return obj[0]
                   1025:     
1.5       dwinter  1026:     def getFileNamesInLastVersion(self):
                   1027:         """get content of the last version as list"""
                   1028:         
                   1029:         return [x[1].getId() for x in self.getLastVersion().getContent()]
                   1030:     
1.37      dwinter  1031: 
1.4       dwinter  1032:     def isActual(self,obj):
                   1033:         """teste ob im basket die aktuelle version ist"""
1.85      dwinter  1034:         try:
1.93      dwinter  1035:             #logging.debug("isActual:"+repr(obj))
1.85      dwinter  1036:             actualNo=obj[1].getLastVersion().getVersionNumber()
                   1037:             storedNo=obj[0].getVersionNumber()
                   1038:             
1.87      dwinter  1039:            
1.93      dwinter  1040:             #actualNo=self.getFileObjectLastVersion(obj.getId()).getVersionNumber()
1.85      dwinter  1041:                 
1.87      dwinter  1042:             #if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
                   1043:             #    return False, -1
1.37      dwinter  1044:             
1.85      dwinter  1045:             if actualNo==storedNo:
                   1046:                 return True , 0
                   1047:             else:
                   1048:                 return False, actualNo
                   1049:         except:
1.93      dwinter  1050:             logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
                   1051:     
1.12      dwinter  1052:             return False, -1
1.85      dwinter  1053:             
1.4       dwinter  1054:     def history(self):
                   1055:         """history"""  
                   1056: 
                   1057:         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
                   1058:         if ext:
                   1059:             return getattr(self,ext[0][1].getId())()
                   1060:         
                   1061:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)
                   1062:         return pt()
                   1063:     
                   1064:     def getStorageFolderRoot(self):
                   1065:         """root des storage folders"""
                   1066:         return self.aq_parent.cdli_main
                   1067:     
                   1068:     def __init__(self,id,title,shortDescription="",comment=""):
                   1069:         """init a CDLIBasket"""
                   1070:         
                   1071:         self.id=id
                   1072:         self.title=title
                   1073:         self.shortDescription=shortDescription
                   1074:         self.comment=comment
                   1075:  
1.72      dwinter  1076:     def getActualUserName(self):
                   1077:         """get name of the actualuser"""
                   1078:        
                   1079:         return str(self.REQUEST['AUTHENTICATED_USER'])
                   1080:   
1.4       dwinter  1081:            
                   1082:     def getLastVersion(self):
                   1083:         """hole letzte version"""
1.39      dwinter  1084: 
                   1085:         ids=[]
                   1086:         idsTmp= self.objectIds()
                   1087:         for x in idsTmp:
                   1088:             try:
                   1089:                 ids.append(int(x))
                   1090:             except:
                   1091:                 pass
1.4       dwinter  1092:         ids.sort()
1.39      dwinter  1093:       
1.4       dwinter  1094:         if len(ids)==0:
                   1095:             return None
                   1096:         else:    
                   1097:             ob=getattr(self,str(ids[-1]))
1.39      dwinter  1098: 
                   1099:             
1.4       dwinter  1100:             return ob
                   1101:    
                   1102:     def getVersions(self):
                   1103:         """get versions"""
                   1104:         versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
                   1105:         return versions
                   1106: 
                   1107:    
1.37      dwinter  1108:     def updateObjects(self,ids,RESPONSE=None,REQUEST=None):
                   1109:         """update ids, ids not in the basket the add"""
                   1110:         if type(ids) is not ListType:
                   1111:             ids=[ids]
                   1112:        
                   1113:         lastVersion=self.getLastVersion() 
1.39      dwinter  1114:         oldContent=lastVersion.content.getContent()
1.37      dwinter  1115:         newContent=[]
                   1116:         
                   1117:         #first copy the old
                   1118:         for obj in oldContent:
                   1119:             if obj[1].getId() not in ids:
                   1120:                 newContent.append(obj)
                   1121:         #now add the new
                   1122:                
                   1123:         for id in ids:
                   1124:             founds=self.CDLICatalog.search({'title':id})
                   1125: 
                   1126:             for found in founds:
                   1127:                 if found.getObject() not in oldContent:
                   1128:                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                   1129:                     newContent.append((found.getObject().getLastVersion(),found.getObject()))
                   1130:         
                   1131: 
                   1132:         content=newContent 
                   1133:         user=self.getActualUserName()
                   1134:         
                   1135:         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
                   1136:         
1.38      dwinter  1137:         obj=self._getOb(ob.getId())
1.37      dwinter  1138:         if RESPONSE:
1.38      dwinter  1139:            
1.37      dwinter  1140:             RESPONSE.redirect(obj.absolute_url())
1.38      dwinter  1141:         
                   1142:         return obj
                   1143:     
1.72      dwinter  1144:     def addObjectsWithVersion(self,ids,deleteOld=None,username=None,catalog=None):
                   1145:         """generate a new version of the basket with objects added, 
                   1146:         hier wird jedoch nicht die letzte Version jedes Files hinzugefuegt, s
                   1147:         ondern ids is ein Tupel mit der Id (d.h. der p-number) und der Versionsnummer.
                   1148:         """
                   1149:         logging.info("add to basket (%s)"%(self.getId()))
                   1150:         lastVersion=self.getLastVersion()
                   1151:         
                   1152:         if not catalog:
                   1153:             catalog=self.CDLICatalog
                   1154:             
                   1155:         if lastVersion is None:
                   1156:             oldContent=[]
                   1157:         else:
                   1158:             oldContent=lastVersion.content.getContent()
                   1159: 
                   1160:         if deleteOld:
                   1161:             oldContent=[]
                   1162: 
                   1163:         newContent=[]
                   1164:         added=0
                   1165:        
                   1166:         for id,version in ids.iteritems():
                   1167:             logging.info("adding %s %s"%(id,version))
                   1168:             id=id.split(".")[0] # title nur die pnumber ohne atf
                   1169:            
                   1170:             try:
                   1171:                 founds=catalog.search({'title':id})
                   1172:             except:
                   1173:                 founds=[]
                   1174:             logging.info(" found %s "%(founds))
                   1175:             for found in founds:
                   1176:                 if found.getObject() not in oldContent:
                   1177:                  
                   1178:                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                   1179:                     newContent.append((found.getObject().getVersions()[version-1][1],found.getObject()))
                   1180:                     added+=1
                   1181: 
                   1182:         content=oldContent+newContent
                   1183:         if not username:
                   1184:             logging.error("XXXXXXXXXXX %s"%repr(self))
                   1185:             user=self.getActualUserName()
                   1186:         else:
                   1187:             user = username
                   1188:             
                   1189:         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
                   1190:         logging.info("add to basket (%s) done"%(self.getId()))
                   1191:         return added
                   1192:     
                   1193:     
1.19      dwinter  1194:     def addObjects(self,ids,deleteOld=None,username=None):
1.4       dwinter  1195:         """generate a new version of the basket with objects added"""
1.83      dwinter  1196:         
                   1197:         def swap(x):
                   1198:             return (x[1],x[0])
                   1199:             
1.65      dwinter  1200:         logging.info("add to basket (%s)"%(self.getId()))
1.4       dwinter  1201:         lastVersion=self.getLastVersion()
                   1202:         
                   1203:         if lastVersion is None:
                   1204:             oldContent=[]
                   1205:         else:
1.39      dwinter  1206:             oldContent=lastVersion.content.getContent()
1.4       dwinter  1207: 
                   1208:         if deleteOld:
                   1209:             oldContent=[]
                   1210: 
1.6       dwinter  1211:         added=0
1.83      dwinter  1212: #        for id in ids:
                   1213: #            logging.debug("adding:"+id)
                   1214: #            try:
                   1215: #                founds=self.CDLICatalog.search({'title':id})
                   1216: #            except:
                   1217: #                founds=[]
                   1218: #           
                   1219: #            for found in founds:
                   1220: #                if found.getObject() not in oldContent:
                   1221: #                    #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
                   1222: #                    newContent.append((found.getObject().getLastVersion(),found.getObject()))
                   1223: #                    added+=1
                   1224: 
1.85      dwinter  1225:         hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
1.83      dwinter  1226:         #logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))
1.93      dwinter  1227:        
1.83      dwinter  1228:                       
1.94      dwinter  1229:         if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key("hash"):  #TODO: muss eigentlich  self.cdliRoot.v_tmpStore.has_key(hash): heissen (ohne "), erstmal so gesetzt damit der hash hier nie benutzt wird
1.83      dwinter  1230:             logging.debug("from store!")
1.85      dwinter  1231:             newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))
1.83      dwinter  1232:          
                   1233:         else:
                   1234:             logging.debug("not from store!")
                   1235:             newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])
                   1236:         
                   1237:         
                   1238:         content=Set(oldContent).union(newContent)
                   1239:         added = len(content)-len(oldContent)
1.19      dwinter  1240:         if not username:
                   1241:             user=self.getActualUserName()
                   1242:         else:
                   1243:             user = username
1.83      dwinter  1244:         
                   1245:         #logging.debug("content:"+repr(list(content)))
                   1246:         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=list(content))
1.65      dwinter  1247:         logging.info("add to basket (%s) done"%(self.getId()))
1.6       dwinter  1248:         return added
1.4       dwinter  1249:     
1.51      dwinter  1250:     
                   1251:                 
1.72      dwinter  1252:     def getContent(self):
                   1253:         """print content"""
                   1254:         ret=[]
                   1255:         
                   1256:         lv=self.getLastVersion()
                   1257:         for obj in lv.content.getContent():
1.93      dwinter  1258:             #logging.info("XXXXXXXXXX %s"%repr(obj))
1.72      dwinter  1259:             ret.append((obj[1].getId(),obj[0].versionNumber))
                   1260:             
                   1261:         return ret
                   1262:         
1.49      dwinter  1263:     def getContentIds(self):
                   1264:         """print basket content"""
                   1265:         ret=[]
                   1266:         lv=self.getLastVersion()
1.51      dwinter  1267:         for obj in lv.content.getContent():
1.49      dwinter  1268:             ret.append((obj[0].getId(),obj[1].getId()))
                   1269:         
                   1270:         
                   1271:         return lv.getComment(),lv.getUser(),lv.getTime(),ret
                   1272: 
1.37      dwinter  1273:     def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
                   1274:         """change a basket"""
                   1275:         if submit=="update":
                   1276:             return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
                   1277:         elif submit=="delete":
                   1278:             return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
                   1279:             
1.12      dwinter  1280:     def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
1.4       dwinter  1281:         """delete objects"""
1.12      dwinter  1282:         
                   1283:         if type(ids) is not ListType:
                   1284:             ids=[ids]
                   1285:        
                   1286:         lastVersion=self.getLastVersion() 
1.39      dwinter  1287:         oldContent=lastVersion.content.getContent()
1.12      dwinter  1288:         newContent=[]
                   1289:         for obj in oldContent:
                   1290:             if obj[1].getId() not in ids:
                   1291:                 newContent.append(obj)
                   1292:         
                   1293:                 
                   1294:         user=self.getActualUserName()
                   1295:         
                   1296:         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
                   1297:         
                   1298:         if RESPONSE:
                   1299:             obj=self._getOb(ob.getId())
                   1300:             RESPONSE.redirect(obj.absolute_url())
1.4       dwinter  1301:         
                   1302: def manage_addCDLIBasketForm(self):
                   1303:     """add the CDLIBasketContainer form"""
                   1304:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
                   1305:     return pt()
                   1306: 
                   1307: def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
                   1308:     """add the basket"""
                   1309:     
                   1310:     id=str(self.getNewId())
                   1311:     
                   1312:     ob=CDLIBasket(id,title,shortDescription,comment)
                   1313:     
                   1314:     self._setObject(id, ob)
                   1315:     
                   1316:     if RESPONSE is not None:
                   1317:         RESPONSE.redirect('manage_main')
                   1318:     else:
                   1319:         return ob
                   1320: 
1.39      dwinter  1321: class CDLIBasketVersion(Implicit,Persistent,Folder):
1.4       dwinter  1322:     """version of a basket"""
                   1323:     
                   1324:     meta_type="CDLIBasketVersion"
1.32      dwinter  1325:     security=ClassSecurityInfo()
1.4       dwinter  1326:     
1.39      dwinter  1327:     def updateBasket(self):
                   1328:         """update"""
                   1329:         try:
                   1330:             self._setObject('content',BasketContent(self.basketContent))
                   1331:         except:
                   1332:             try:
                   1333:                 if len(self.basketContent)>0:
                   1334:                     self.content.setContent(self.basketContent)
                   1335:             except:
                   1336:                 print "error",self.getId(),self.aq_parent.getId()
                   1337:         self.basketContent=[]
                   1338: 
                   1339:         
1.37      dwinter  1340:     def containsNonActualFiles(self):
                   1341:         """returns True if basket contains one or more non current files"""
                   1342:         
                   1343:         objs=self.getContent()
                   1344:         for obj in objs:
                   1345:             if not self.isActual(obj)[0]:
                   1346:                 return True
                   1347:         return False
                   1348:     
1.72      dwinter  1349:     def downloadListOfPnumbers(self):
                   1350:         """download pnumbers of the basket as list"""
                   1351:         
                   1352:         basket_name=self.aq_parent.title
                   1353:         
                   1354:         ids=self.getContent() # get the list of objects
                   1355:         logging.error(ids)
                   1356:         ret="\n".join([x[1].getId().split(".")[0] for x in ids])
                   1357:         
                   1358:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.txt" """%basket_name)
                   1359:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
                   1360:         length=len(ret)
                   1361:         self.REQUEST.RESPONSE.setHeader("Content-Length",length)
                   1362:         self.REQUEST.RESPONSE.write(ret)    
                   1363:         
1.77      dwinter  1364:     security.declareProtected('manage','downloadObjectsAsOneFile')
1.37      dwinter  1365:     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
1.4       dwinter  1366:         """download all selected files in one file"""
1.93      dwinter  1367:         
1.46      dwinter  1368:         if self.temp_folder.downloadCounterBaskets > 10000:
                   1369:             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
1.45      dwinter  1370: 
                   1371: 
1.37      dwinter  1372:         if (check=="yes") and self.containsNonActualFiles():
                   1373:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
1.46      dwinter  1374:             
1.37      dwinter  1375:             return pt(lock=lock)
                   1376:             
1.46      dwinter  1377:         else:
                   1378:             
                   1379:             return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
                   1380:         
1.87      dwinter  1381:     def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no",repeat=None):
1.46      dwinter  1382:         """print do the download"""
1.87      dwinter  1383:  
1.93      dwinter  1384:         
1.46      dwinter  1385:         ret=""
1.4       dwinter  1386:         lockedObjects={}
                   1387: 
1.87      dwinter  1388:            
1.93      dwinter  1389:     
1.4       dwinter  1390:         if lock:
1.87      dwinter  1391:             logging.debug("------lock:"+repr(lock))
1.4       dwinter  1392:             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
1.87      dwinter  1393:                 
1.4       dwinter  1394:                 return "please login first"
                   1395: 
                   1396:             #check if a locked object exist in the basket.
                   1397:             lockedObjects={}
1.39      dwinter  1398:             for object in self.content.getContent():
1.4       dwinter  1399: 
1.63      dwinter  1400:                 if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
1.4       dwinter  1401:                     lockedObjects[object[1].title]=repr(object[1].lockedBy)
                   1402:                    
                   1403:                     
                   1404:             keys=lockedObjects.keys()
                   1405:             
                   1406:             
                   1407:             if len(keys)>0 and (not procedure):
                   1408:                 self.REQUEST.SESSION['lockedObjects']=lockedObjects
                   1409:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
1.45      dwinter  1410:                 
1.87      dwinter  1411:                
1.46      dwinter  1412:                 return pt()
1.4       dwinter  1413:          
                   1414:             elif not procedure: #keine fails gesperrt dann alle donwloaden
                   1415:                 procedure="downloadAll" 
                   1416:         
1.46      dwinter  1417:         
1.87      dwinter  1418:        
                   1419:        
                   1420:         threadName=repeat
                   1421:         if not threadName or threadName=="":
                   1422:             thread=DownloadBasketFinallyThread()
                   1423:             threadName=thread.getName()[0:]
                   1424: 
                   1425:             if (not hasattr(self,'_v_downloadBasket')):
                   1426:                                 self._v_downloadBasket={}
                   1427: 
                   1428: 
                   1429:             self._v_downloadBasket[threadName]=thread
                   1430:             logging.debug("dwonloadfinally:"+repr(self))
1.97    ! dwinter  1431: 
1.96      dwinter  1432:             if isinstance(self,CDLIBasketVersion):
                   1433:                 obj=self
                   1434:             else:
                   1435:                 obj=self.aq_parent
1.95      dwinter  1436:             logging.debug("dwonloadfinally2:"+repr(obj))
                   1437:             logging.debug("dwonloadfinally2:"+repr(obj.aq_parent))
                   1438: 
1.96      dwinter  1439:             obj2=obj.aq_parent
                   1440:             if not isinstance(obj2,CDLIBasket):
1.95      dwinter  1441:                 obj2=obj2.aq_parent
                   1442: 
                   1443:             basketID=obj2.getId()
                   1444:             versionNumber=obj.getId()
                   1445:             logging.debug("dwonloadfinally2:"+repr(basketID))
                   1446:             logging.debug("dwonloadfinally2:"+repr(versionNumber))
                   1447: 
1.97    ! dwinter  1448: 
1.88      dwinter  1449:             if lock:
                   1450:                 logging.debug("-----start locking")
                   1451:                 for object in self.content.getContent():
                   1452:                          if object[1].lockedBy =='':
                   1453:                              object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
                   1454:                 logging.debug("-----finished locking")
                   1455:                 
                   1456:                     #obj.lockedBy=user
                   1457:             self._v_downloadBasket[threadName].set(lock,procedure,self.REQUEST['AUTHENTICATED_USER'],current,basketID,versionNumber)
1.45      dwinter  1458: 
1.87      dwinter  1459:             self._v_downloadBasket[threadName].start()
1.4       dwinter  1460: 
1.87      dwinter  1461:             
                   1462:             
                   1463:             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   1464: 
                   1465:             if wait_template:
                   1466:                 return wait_template[0][1]()
                   1467:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadBasketWait.zpt')).__of__(self)
                   1468: 
1.88      dwinter  1469:             return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
                   1470:                                 counter=self._v_downloadBasket[threadName].getCounter(),
                   1471:                                 number=self._v_downloadBasket[threadName].getNumberOfFiles())
1.87      dwinter  1472:             #_v_xmltrans.run()
                   1473:         
                   1474:         else:
                   1475:             #recover thread, if lost
                   1476:             if not hasattr(self,'_v_downloadBasket'):
                   1477:                self._v_downloadBasket={}
                   1478:             if not self._v_downloadBasket.get(threadName,None):
                   1479:                  for thread in threading.enumerate():
                   1480:                          if threadName == thread.getName():
                   1481:                                        self._v_downloadBasket[threadName]=thread
                   1482:                                        
                   1483:             if self._v_downloadBasket.get(threadName,None) and (self._v_downloadBasket[threadName] is not None) and (not self._v_downloadBasket[threadName].end) :
                   1484: 
                   1485:                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   1486:                 if wait_template:
                   1487:                         return wait_template[0][1]()
1.83      dwinter  1488:                 
1.87      dwinter  1489:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadBasketWait.zpt')).__of__(self)
1.88      dwinter  1490:                 return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
                   1491:                           counter=self._v_downloadBasket[threadName].getCounter(),
                   1492:                           number=self._v_downloadBasket[threadName].getNumberOfFiles())
1.87      dwinter  1493:             else:
                   1494:               
                   1495:              
                   1496:               logging.debug("FINISHED")
                   1497:               if not self._v_downloadBasket.get(threadName,None):
                   1498:                  for thread in threading.enumerate():
                   1499:                          if threadName == thread.getName():
                   1500:                                        self._v_downloadBasket[threadName]=thread
                   1501:                                        
                   1502:               #files = self._v_downloadBasket[threadName].result
                   1503:               files=self.basketContainer.resultHash[threadName]
1.90      dwinter  1504:               lockedFiles=self.basketContainer.resultLockedHash[threadName]
1.92      dwinter  1505:      
1.87      dwinter  1506:              # fh=file("/var/tmp/test")
                   1507:               #ret =fh.read()
                   1508:          
                   1509:               if (not isinstance(self.aq_parent,CDLIBasket)):
                   1510:                   basket_name=self.aq_parent.aq_parent.title+"_V"+self.getId()
                   1511:               else:
                   1512:                   basket_name=self.aq_parent.title+"_V"+self.getId()
1.86      dwinter  1513:         
                   1514:         
                   1515:     
1.87      dwinter  1516:                   #write basketname to header of atf file
                   1517:               
1.45      dwinter  1518: 
1.87      dwinter  1519:               self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
                   1520:               self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
                   1521:               #length=len(ret)
                   1522:               #self.REQUEST.RESPONSE.setHeader("Content-Length",length)
1.90      dwinter  1523:         
1.87      dwinter  1524:               ret="#basket: %s\n"%basket_name
1.90      dwinter  1525:               self.REQUEST.RESPONSE.write(ret) 
                   1526:                  
1.87      dwinter  1527:               for fileName in files:
1.91      dwinter  1528:                 try:
1.87      dwinter  1529:                   self.REQUEST.RESPONSE.write(file(fileName).read())
1.91      dwinter  1530:                 except:
                   1531:                   logging.error("downloadasonefile: cannot read %s"%fileName)
1.90      dwinter  1532:                   
                   1533:             
                   1534:               self.REQUEST.RESPONSE.write("\n# locked files\n")
                   1535:               for fileName in lockedFiles:
1.92      dwinter  1536:                   self.REQUEST.RESPONSE.write("#  %s by %s\n"%fileName)
1.90      dwinter  1537:               
                   1538:               self.REQUEST.RESPONSE.write("# locked files end\n")
                   1539:               
1.87      dwinter  1540:               del self.basketContainer.resultHash[threadName]
1.90      dwinter  1541:               del self.basketContainer.resultLockedHash[threadName]
1.87      dwinter  1542:              
1.4       dwinter  1543:     def numberOfItems(self):
                   1544:         """return anzahl der elemente im basket"""
1.39      dwinter  1545:         return self.content.numberOfItems()
1.4       dwinter  1546:     
                   1547:     def getTime(self):
                   1548:         """getTime"""
                   1549:         #return self.bobobase_modification_time().ISO()
                   1550:       
                   1551:         if hasattr(self,'time'):
                   1552:             return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
                   1553:         elif hasattr(self,'timefixed'):
                   1554:             return self.timefixed
                   1555:         else:
                   1556:             setattr(self,'timefixed',self.bobobase_modification_time().ISO())
                   1557:             return self.bobobase_modification_time().ISO()
                   1558:     
                   1559:     def getContent(self):
                   1560:         """get Basket Content"""
1.39      dwinter  1561:         return self.content.getContent()
1.4       dwinter  1562: 
                   1563:     
                   1564:     def __init__(self,id,user,comment="",basketContent=[]):
                   1565:         """ init a basket version"""
                   1566:         self.id=id
1.74      dwinter  1567:         self.comment=comment
1.39      dwinter  1568:         self._setObject('content',BasketContent(basketContent))
                   1569:         #self.basketContent=basketContent[0:]a
1.4       dwinter  1570:         self.user=user
                   1571:         self.time=time.localtime()
                   1572:         
                   1573:     def getUser(self):
                   1574:         """get user"""
                   1575:         return self.user
                   1576:     
                   1577:     def getComment(self):
                   1578:         """get Comment"""
                   1579:         return self.comment
                   1580:  
1.77      dwinter  1581:     security.declareProtected('manage','index_html')
1.4       dwinter  1582:     def index_html(self):
                   1583:             """view the basket"""
1.37      dwinter  1584: 
                   1585:             if self.REQUEST.get('change',False):
1.38      dwinter  1586:                     ob=self.aq_parent.updateObjects(self.REQUEST['change'])
                   1587:                    
                   1588:                     self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
1.37      dwinter  1589:                                         
1.4       dwinter  1590:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
                   1591:             return pt()
                   1592:      
                   1593:     def getObjUrl(self,result):
                   1594:         """getUrl of the version of the object"""
                   1595:         objId=result[1].getTitle()
                   1596:         founds=self.CDLICatalog.search({'title':objId})
                   1597:         if len(founds)>0:
1.12      dwinter  1598:              return founds[0].getObject().getLastVersion().absolute_url()
1.4       dwinter  1599:          
                   1600:         else: #assume version number
                   1601:             splitted=objId.split("_")
1.9       dwinter  1602:             founds=self.CDLICatalog.search({'title':splitted[1]})        
1.12      dwinter  1603:             return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
1.4       dwinter  1604:    
                   1605: def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
                   1606:     """add a version"""
                   1607:     
                   1608:     #check for already existing versions
                   1609:  
                   1610:     lastVersion=self.getLastVersion()
                   1611:     if lastVersion is None:
                   1612:         newId=str(1)
                   1613:     else:
                   1614:         newId=str(int(lastVersion.getId())+1)
                   1615:     
                   1616:     ob=CDLIBasketVersion(newId,user,comment,basketContent)
                   1617:     
                   1618:     self._setObject(newId, ob)
                   1619:     
                   1620:     if RESPONSE is not None:
                   1621:         RESPONSE.redirect('manage_main')
                   1622:     else:
                   1623:         return ob
                   1624:     
1.46      dwinter  1625: class CDLIFileObject(CatalogAware,extVersionedFileObject):
1.1       dwinter  1626:     """CDLI file object"""
                   1627:     
                   1628:     meta_type="CDLI File Object"
1.25      dwinter  1629:     default_catalog='CDLIObjectsCatalog'
1.1       dwinter  1630:     
1.12      dwinter  1631:     security=ClassSecurityInfo()
                   1632:     
1.78      dwinter  1633:     security.declareProtected('manage','index_html')
1.81      casties  1634: 
                   1635:     security.declarePublic('view')
                   1636:     view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())
                   1637: 
                   1638:     security.declarePublic('editATF')
                   1639:     editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())
                   1640: 
1.28      dwinter  1641:     def PrincipiaSearchSource(self):
                   1642:            """Return cataloguable key for ourselves."""
                   1643:            return str(self)
                   1644:        
1.89      dwinter  1645:     def setAuthor(self, author):
                   1646:         """change the author"""
                   1647:         self.author = author
                   1648:        
1.26      dwinter  1649:     def makeThisVersionCurrent_html(self):
1.85      dwinter  1650:         """form for mthis version current"""
1.26      dwinter  1651:         
                   1652:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
                   1653:         return pt()                 
1.81      casties  1654: 
                   1655:     security.declarePublic('makeThisVersionCurrent')
1.27      dwinter  1656:     def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
1.26      dwinter  1657:         """copy this version to current"""
                   1658:         parent=self.aq_parent
1.81      casties  1659:         parent.manage_addVersionedFileObject(id=None,vC=comment,author=author,file=self.getData(),RESPONSE=RESPONSE)
                   1660:         #newversion=parent.manage_addCDLIFileObject('',comment,author)
                   1661:         #newversion.manage_upload(self.getData())
1.27      dwinter  1662:                                         
1.81      casties  1663:         #if RESPONSE is not None:
                   1664:         #    RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
1.27      dwinter  1665: 
1.26      dwinter  1666:         return True
                   1667:     
1.52      dwinter  1668:     def getFormattedData(self):
                   1669:         """fromat text"""
                   1670:         data=self.getData()
1.70      dwinter  1671: #        return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
                   1672:         return re.sub("#lem","       #lem",data) #remove return vor #lem
1.52      dwinter  1673:         
1.1       dwinter  1674:     
1.40      dwinter  1675:     security.declarePublic('getPNumber')
                   1676:     def getPNumber(self):
1.46      dwinter  1677:         """get the pnumber"""
                   1678:         try:
1.49      dwinter  1679:                 txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
1.40      dwinter  1680:         except:
1.49      dwinter  1681:                 txt=self.getData()[0:]
1.40      dwinter  1682:                 
                   1683:                 return "ERROR"
                   1684:         try:
                   1685:             return "P"+txt.group(1)
                   1686:         except:
                   1687:             return "ERROR"
                   1688: 
1.12      dwinter  1689:     security.declarePublic('getDesignation')
                   1690:     def getDesignation(self):
                   1691:         """get the designation out of the file"""
1.16      dwinter  1692:         try:
1.46      dwinter  1693:                 txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.getData()[0:])
1.13      dwinter  1694:         except:
1.46      dwinter  1695:                 txt=self.getData()[0:]
1.16      dwinter  1696:                 
                   1697:                 return "ERROR"
1.12      dwinter  1698:         try:
                   1699:             return txt.group(2)
                   1700:         except:
                   1701:             return "ERROR"
1.81      casties  1702: 
1.12      dwinter  1703:         
1.1       dwinter  1704: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
                   1705: 
1.81      casties  1706: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
                   1707:                              precondition='', content_type='',
1.48      dwinter  1708:                              from_tmp=False,REQUEST=None):
1.1       dwinter  1709:     """Add a new File object.
                   1710:     Creates a new File object 'id' with the contents of 'file'"""
1.48      dwinter  1711:  
1.1       dwinter  1712:     id=str(id)
                   1713:     title=str(title)
                   1714:     content_type=str(content_type)
                   1715:     precondition=str(precondition)
                   1716:     
                   1717:     id, title = cookId(id, title, file)
                   1718: 
                   1719:     self=self.this()
                   1720: 
                   1721:     # First, we create the file without data:
1.81      casties  1722:     self._setObject(id, CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=vC,time=time.localtime(),author=author))
1.80      casties  1723:     fob = self._getOb(id)
1.45      dwinter  1724:     
1.1       dwinter  1725:     # Now we "upload" the data.  By doing this in two steps, we
                   1726:     # can use a database trick to make the upload more efficient.
1.48      dwinter  1727: 
                   1728:     if file and not from_tmp:
1.80      casties  1729:         fob.manage_upload(file)
1.48      dwinter  1730:     elif file and from_tmp:
1.81      casties  1731:         fob.manage_file_upload(file) # manage_upload_from_tmp doesn't exist in ExtFile2
                   1732:     #    fob.manage_upload_from_tmp(file) # manage_upload_from_tmp doesn't exist in ExtFile2
1.1       dwinter  1733:     if content_type:
1.80      casties  1734:         fob.content_type=content_type
1.1       dwinter  1735: 
1.81      casties  1736:     #logging.debug("manage_add: lastversion=%s"%self.getData())
                   1737:     logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))
1.45      dwinter  1738:     self.reindex_object()
1.81      casties  1739:     #logging.debug("manage_add: fob_data=%s"%fob.getData())
1.80      casties  1740:     logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
1.81      casties  1741:     fob.index_object()
1.49      dwinter  1742: 
1.85      dwinter  1743:     self.CDLIRoot.updateOrAddToFileBTree(ob)
1.1       dwinter  1744:     if REQUEST is not None:
                   1745:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
1.3       dwinter  1746:     
1.80      casties  1747: 
1.46      dwinter  1748: class CDLIFile(extVersionedFile,CatalogAware):
1.3       dwinter  1749:     """CDLI file"""
                   1750:     
1.77      dwinter  1751:     security=ClassSecurityInfo()
1.3       dwinter  1752:     meta_type="CDLI file"
1.81      casties  1753:     content_meta_type = ["CDLI File Object"]
                   1754:     
1.3       dwinter  1755:     default_catalog='CDLICatalog'
1.81      casties  1756:     
1.78      dwinter  1757:     security.declareProtected('manage','index_html')
1.81      casties  1758:     
1.51      dwinter  1759:     def getLastVersionData(self):
                   1760:         """get last version data"""
1.81      casties  1761:         return self.getData()
1.51      dwinter  1762: 
1.52      dwinter  1763:     def getLastVersionFormattedData(self):
                   1764:         """get last version data"""
1.81      casties  1765:         return self.getContentObject().getFormattedData()
                   1766: 
                   1767:     def getTextId(self):
                   1768:         """returns P-number of text"""
                   1769:         # assuming that its the beginning of the title
                   1770:         return self.title[:7]
1.52      dwinter  1771: 
1.51      dwinter  1772:     #security.declarePublic('history')
1.26      dwinter  1773:     def history(self):
                   1774:         """history"""  
                   1775: 
                   1776:         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
                   1777:         if ext:
                   1778:             return getattr(self,ext[0][1].getId())()
                   1779:         
                   1780:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
                   1781:         return pt()
                   1782: 
                   1783: 
1.44      dwinter  1784:     def getBasketFromId(self,basketid, context=None):
                   1785:         """get basket from id"""
                   1786: 
                   1787:         if not context:
                   1788:             context=self
                   1789:             
                   1790:         for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
                   1791:             if basket[0]==basketid:
                   1792:                 return basket[1]
                   1793:         else:
                   1794:             None
                   1795: 
1.12      dwinter  1796:  
1.8       dwinter  1797:     def isContainedInBaskets(self,context=None):
                   1798:         """check is this file is part of any basket
                   1799:         @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
                   1800:                         has to exist.
                   1801:         """
                   1802: 
                   1803:         if not context:
                   1804:             context=self
1.12      dwinter  1805:         
                   1806:         ret=[]
                   1807:         for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
                   1808:             #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
                   1809:             try:
                   1810:                 ret.append(x.getObject())
                   1811:             except:
                   1812:                 pass
                   1813:         return ret
                   1814:         #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
1.5       dwinter  1815:         
                   1816:         
1.81      casties  1817:     def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
                   1818:         """factory for content objects. to be overridden in derived classes."""
                   1819:         logging.debug("_newContentObject(CDLI)")
                   1820:         return CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=versionComment,time=time,author=author)
                   1821: 
                   1822: 
1.5       dwinter  1823:     def addCDLIFileObjectForm(self):
                   1824:         """add a new version"""
                   1825:         
                   1826:         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
                   1827:             return "please login first"
                   1828:         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
                   1829:             out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
                   1830:             return out()
                   1831:         else:
                   1832:             return "Sorry file is locked by somebody else"
                   1833:         
1.37      dwinter  1834:     def manage_addCDLIFileObject(self,id,vC,author,
                   1835:                                  file='',title='',
                   1836:                                  precondition='', 
                   1837:                                  content_type='',
                   1838:                                  changeName='no',newName='', 
1.48      dwinter  1839:                                  come_from=None,
                   1840:                                  from_tmp=False,RESPONSE=None):
1.3       dwinter  1841:         """add"""
1.48      dwinter  1842:       
1.3       dwinter  1843:         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
                   1844:             vC=self.REQUEST['vC']
                   1845:         except:
                   1846:             pass
                   1847:         
1.81      casties  1848:         ob = self.addContentObject(id, vC, author, file, title, changeName=changeName, newName=newName, from_tmp=from_tmp,
                   1849:                                    precondition=precondition, content_type=content_type)
1.3       dwinter  1850: 
1.22      dwinter  1851:         try:
1.81      casties  1852:             #FIXME: wozu ist das gut?
                   1853:             self.REQUEST.SESSION['objID_parent']=self.getId()
1.22      dwinter  1854:         except:
1.81      casties  1855:             pass
1.37      dwinter  1856:   
1.85      dwinter  1857:         #self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache
                   1858:       
                   1859:         
1.3       dwinter  1860:         if RESPONSE:
1.81      casties  1861:             if ob.getSize()==0:
                   1862:                 self.REQUEST.SESSION['objID']=ob.getId()
1.3       dwinter  1863:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
                   1864:                 return pt()
                   1865:             else:
1.37      dwinter  1866:                 if come_from and (come_from!=""):
1.81      casties  1867:                     RESPONSE.redirect(come_from+"?change="+self.getId())
1.37      dwinter  1868:                 else:
                   1869:                     RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
1.3       dwinter  1870:         else:
1.81      casties  1871:             return ob
1.3       dwinter  1872:         
                   1873:         
                   1874: def manage_addCDLIFileForm(self):
                   1875:     """interface for adding the OSAS_root"""
                   1876:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
                   1877:     return pt()
                   1878: 
                   1879: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
                   1880:     """add the OSAS_root"""
                   1881:     newObj=CDLIFile(id,title,lockedBy,author)
1.22      dwinter  1882:                                         
                   1883:     tryToggle=True
                   1884:     tryCount=0
                   1885: 
                   1886:     self._setObject(id,newObj)                  
1.45      dwinter  1887:     getattr(self,id).reindex_object()
1.22      dwinter  1888:         
1.3       dwinter  1889:     if RESPONSE is not None:
                   1890:         RESPONSE.redirect('manage_main')
                   1891: 
1.81      casties  1892: 
1.69      dwinter  1893: def checkUTF8(data):
                   1894:     """check utf 8"""
                   1895:     try:
                   1896:         data.encode('utf-8')
                   1897:         return True
                   1898:     except:
                   1899:         return False
                   1900:     
1.1       dwinter  1901: 
1.45      dwinter  1902: def checkFile(filename,data,folder):
                   1903:     """check the files"""
                   1904:     # first check the file name
                   1905:     fn=filename.split(".") # no extension
1.48      dwinter  1906: 
1.45      dwinter  1907:     if not fn[0][0]=="P":
1.46      dwinter  1908:         return False,"P missing in the filename"
1.45      dwinter  1909:     elif len(fn[0])!=7:
1.46      dwinter  1910:         return False,"P number has not the right length 6"
1.69      dwinter  1911:     elif not checkUTF8(data):
                   1912:         return False,"not utf-8"
1.45      dwinter  1913:     else:
1.69      dwinter  1914:         return True,""
                   1915:     
1.45      dwinter  1916:     
1.25      dwinter  1917: def splitatf(fh,dir=None,ext=None):
1.2       dwinter  1918:     """split it"""
1.4       dwinter  1919:     ret=None
1.2       dwinter  1920:     nf=None
1.25      dwinter  1921:     i=0
1.49      dwinter  1922: 
1.81      casties  1923:     #ROC: why split \n first and then \r???
1.73      dwinter  1924:     if (type(fh) is StringType) or (type(fh) is UnicodeType):
                   1925:         iter=fh.split("\n")
                   1926:     else:
                   1927:         iter=fh.readlines()
                   1928:         
                   1929:     for lineTmp in iter:
1.66      dwinter  1930:         lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
                   1931:         for line in lineTmp.split("\r"):
                   1932:             #logging.log("Deal with: %s"%line)
                   1933:             if ext:
                   1934:                 i+=1
                   1935:                 if (i%100)==0:
                   1936:                     ext.result+="."
                   1937:                 if i==10000:
                   1938:                     i=0
                   1939:                     ext.result+="<br>"
                   1940:             #check if basket name is in the first line
                   1941:             if line.find("#atf basket")>=0: #old convention
                   1942:                 ret=line.replace('#atf basket ','')
                   1943:                 ret=ret.split('_')[0]
                   1944:             elif line.find("#basket:")>=0: #new convention
                   1945:                 ret=line.replace('#basket: ','')
                   1946:                 ret=ret.split('_')[0]
                   1947: 
                   1948:             else:
                   1949:                 if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
                   1950:                     if nf:
                   1951:                         nf.close() #close last file
                   1952: 
1.49      dwinter  1953: 
1.66      dwinter  1954:                     filename=line[1:].split("=")[0].rstrip()+".atf"
                   1955:                     if dir:
                   1956:                         filename=os.path.join(dir,filename)
                   1957:                     nf=file(filename,"w")
                   1958:                     logging.info("open %s"%filename)
                   1959:                 if nf:    
                   1960:                     nf.write(line.replace("\n","")+"\n")
                   1961: 
                   1962:     try:        
                   1963:         nf.close()
1.61      dwinter  1964:     except:
1.66      dwinter  1965:         pass
1.73      dwinter  1966:     
                   1967:     if not((type(fh) is StringType) or (type(fh) is UnicodeType)):
                   1968:         fh.close()
1.5       dwinter  1969:     return ret,len(os.listdir(dir))
1.4       dwinter  1970: 
1.19      dwinter  1971: 
1.46      dwinter  1972: class CDLIFileFolder(extVersionedFileFolder):
1.4       dwinter  1973:     """CDLI File Folder"""
1.1       dwinter  1974:     
1.19      dwinter  1975:     security=ClassSecurityInfo()
1.1       dwinter  1976:     meta_type="CDLI Folder"
1.81      casties  1977:     file_meta_type=['CDLI file']
                   1978:     folder_meta_type=['CDLI Folder']
                   1979: 
                   1980:     file_catalog='CDLICatalog'
                   1981: 
1.45      dwinter  1982:     #downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
1.24      dwinter  1983:     tmpStore2={}
1.81      casties  1984: 
                   1985:     def _newVersionedFile(self, id, title='', lockedBy=None, author=None):
                   1986:         """factory for versioned files. to be overridden in derived classes."""
                   1987:         logging.debug("_newVersionedFile(CDLI)")
                   1988:         return CDLIFile(id, title, lockedBy=lockedBy, author=author)
                   1989: 
1.19      dwinter  1990:     def setTemp(self,name,value):
                   1991:         """set tmp"""
                   1992: 
                   1993:         setattr(self,name,value)
                   1994:                                         
1.81      casties  1995:     deleteFileForm = PageTemplateFile("zpt/doDeleteFile", globals())
1.19      dwinter  1996:                                        
1.81      casties  1997:     def delete(self,ids,REQUEST=None):
                   1998:         """delete these files"""
1.12      dwinter  1999:         if type(ids) is not ListType:
                   2000:             ids=[ids]
1.81      casties  2001: 
                   2002:         self.manage_delObjects(ids)
1.12      dwinter  2003:         
1.81      casties  2004:         if REQUEST is not None:
                   2005:             return self.index_html()
                   2006: 
                   2007: 
1.4       dwinter  2008:     def getVersionNumbersFromIds(self,ids):
                   2009:         """get the numbers of the current versions of documents described by their ids"""
                   2010:         
                   2011:         ret=[]
                   2012:         searchStr=" OR ".join(ids)
                   2013:         
1.9       dwinter  2014:         founds=self.CDLICatalog.search({'title':searchStr})
1.4       dwinter  2015:         
                   2016:         for found in founds:
1.81      casties  2017:             lastVersion=found.getObject().getContentObject()
1.4       dwinter  2018:             ret.append((found.getId,lastVersion))
                   2019:         
                   2020:         return ret
                   2021:     
1.67      dwinter  2022:     def getFile(self,fn):
                   2023:         """get the content of the file fn"""
1.81      casties  2024:         logging.debug("getFile: %s"%repr(fn))
                   2025:         if not self.hasObject(fn):
                   2026:             # search deeper
                   2027:             founds=getattr(self, self.file_catalog).search({'textid':fn})
                   2028:             if founds:
                   2029:                 obj=founds[0].getObject().getContentObject()
                   2030:             else:
                   2031:                 return "" 
1.67      dwinter  2032:         else:
1.81      casties  2033:             obj = self[fn].getContentObject()
1.68      dwinter  2034: 
1.81      casties  2035:         return obj.getData()[0:] 
                   2036:  
1.67      dwinter  2037:     
1.14      dwinter  2038:     def checkCatalog(self,fn):
                   2039:         """check if fn is in the catalog"""
1.19      dwinter  2040:         #TODO add checkCatalog
1.14      dwinter  2041:         
1.19      dwinter  2042:                                    
1.45      dwinter  2043:     def findObjectsFromListWithVersion(self,list,author=None):
1.26      dwinter  2044:         """find objects from a list with versions
                   2045:         @param list: list of tuples  (cdliFile,version)
                   2046:         """
                   2047:         #self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
                   2048:         #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
                   2049:         
                   2050:         pt=getattr(self,'filelistVersioned.html')
                   2051:             
1.45      dwinter  2052:         return pt(search=list,author=author)
1.26      dwinter  2053:     
                   2054:     
1.67      dwinter  2055:     def getAllPNumbers(self):
                   2056:         """get a list of all files (resp their p-numbers) stored"""
                   2057:         
                   2058:         ret=[x.getId for x in  self.CDLICatalog()]
                   2059:      
                   2060:         return ret
                   2061:     
1.83      dwinter  2062:     def expandFile(self,fileId,fileTree):
                   2063:         """wildcard in fileID suche alle Treffer"""
                   2064:         founds=self.CDLICatalog({'title':fileId})
                   2065:         for found in founds:
                   2066:             fileTree.add(found.getId)
                   2067:             logging.debug("ADDD:"+found.getId)
                   2068:          
1.85      dwinter  2069:     def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None,REQUEST=None,returnHash=False,hash=None):
1.1       dwinter  2070:         """findObjectsFromList (, TAB oder LINE separated)"""
1.15      dwinter  2071:                                        
1.83      dwinter  2072:         logging.debug("start: findObjectsFromList")
1.85      dwinter  2073:         #logging.debug("start: findObjectsFromList"+repr(list))
                   2074:         
                   2075:             
1.6       dwinter  2076:         if upload: # list from file upload
                   2077:             txt=upload.read()
1.35      dwinter  2078:                                        
                   2079:         if enterList:
                   2080:             txt=enterList
                   2081:             
                   2082:         if upload or enterList:
1.6       dwinter  2083:             txt=txt.replace(",","\n")
                   2084:             txt=txt.replace("\t","\n")
1.12      dwinter  2085:             txt=txt.replace("\r","\n")
1.6       dwinter  2086:             idsTmp=txt.split("\n")
                   2087:             ids=[]
                   2088:             for id in idsTmp: # make sure that no empty lines
                   2089:                 idTmp=id.lstrip().rstrip()
                   2090:                 if len(idTmp)>0:
                   2091:                     
                   2092:                     ids.append(idTmp)
                   2093:                     
                   2094:             #self.REQUEST.SESSION['ids']=" OR ".join(ids)
1.12      dwinter  2095: 
1.6       dwinter  2096:             pt=getattr(self,'filelist.html')
1.7       dwinter  2097:             self.REQUEST.SESSION['searchList']=ids
1.6       dwinter  2098:             return pt(search=ids)
1.7       dwinter  2099:         
1.6       dwinter  2100:         if basketName:
1.7       dwinter  2101:             #TODO: get rid of one of these..
                   2102:             
1.6       dwinter  2103:             pt=getattr(self,'filelist.html')
1.7       dwinter  2104:             return pt(basketName=basketName,numberOfObjects=numberOfObjects)
1.6       dwinter  2105:         
1.85      dwinter  2106:         if hash is not None and hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
                   2107:                
                   2108:                logging.debug("asking for storage2")
                   2109:                result =self.cdliRoot.v_tmpStore[hash]
                   2110:                if result:
                   2111:                    logging.debug("give result from storage2")
                   2112:                    return hash,self.cdliRoot.v_tmpStore[hash]
                   2113:           
1.15      dwinter  2114:         if list is not None: # got already a list
1.83      dwinter  2115:             
                   2116:             logging.debug(" ----List version")
1.6       dwinter  2117:             ret=[]
1.83      dwinter  2118:             fileTree=Set()
                   2119:             
1.6       dwinter  2120:             for fileId in list:
1.83      dwinter  2121:                
                   2122:                 if fileId.find("*")>-1: #check for wildcards
                   2123:                         self.expandFile(fileId,fileTree)
                   2124:                         
1.35      dwinter  2125:                 elif len(fileId.split("."))==1:
1.6       dwinter  2126:                         fileId=fileId+".atf"
1.83      dwinter  2127:                         fileTree.add(fileId)
                   2128:                 #logging.debug("   -----:"+fileId)
                   2129:                 #ret+=self.CDLICatalog({'title':fileId})
                   2130:                 #x =self.getFileObject(fileId)
                   2131:                 #if x is not None:
                   2132:                 #    ret.append(x)
1.35      dwinter  2133:                 
1.83      dwinter  2134:             
                   2135:             
                   2136:             ids = fileTree & self.v_file_ids
1.85      dwinter  2137:             #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
                   2138:             l=makelist(fileTree)[0:]
1.93      dwinter  2139:             #logging.debug("l-list:"+repr(l))
1.85      dwinter  2140:             self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
                   2141:             self.REQUEST.SESSION['searchList']=l
                   2142:             #self.REQUEST.SESSION['searchList']=['P000001.atf']
                   2143:           
1.83      dwinter  2144:             
1.85      dwinter  2145:             hash = md5.new(repr(makelist(fileTree))).hexdigest() # erzeuge hash als identification
                   2146:             self.REQUEST.SESSION['hash']=hash
                   2147:             #TODO: do I need garbage collection for v_tmpStore ?
1.83      dwinter  2148:             
1.84      dwinter  2149:             #logging.debug("Hash:"+repr(hash))
1.85      dwinter  2150: #        
                   2151: #            if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash): 
                   2152: #               logging.debug("asking for storage")
                   2153: #               res=self.cdliRoot.v_tmpStore[hash]
                   2154: #               if res:
                   2155: #                   if returnHash == True:
                   2156: #                       return hash,res
                   2157: #                   return res
1.83      dwinter  2158:           
1.7       dwinter  2159:             #TODO: get rid of one of these..
1.83      dwinter  2160:             #ids=[x.getObject().getId() for x in ret]
                   2161:             ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
1.84      dwinter  2162:             
                   2163:             #self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
                   2164:             #self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
1.85      dwinter  2165:            
1.25      dwinter  2166:             if display:
                   2167:                 pt=getattr(self,'filelist.html')
                   2168:                 
                   2169:                 return pt(search=ids)
1.83      dwinter  2170:             else:     
                   2171:                 #self.REQUEST.SESSION['hash'] = ret # store in session 
1.85      dwinter  2172:                 if not hasattr(self,'v_tmpStore'):
                   2173:                     self.cdliRoot.v_tmpStore={}
1.83      dwinter  2174:                 #logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
1.84      dwinter  2175:                 #logging.debug("HHHHHHNEU:"+repr(hash))
1.85      dwinter  2176:                 self.cdliRoot.v_tmpStore[hash] = ret # store in session 
                   2177:                 if returnHash == True:
                   2178:                     return hash,ret
1.25      dwinter  2179:                 return ret
                   2180:         
                   2181:         
1.1       dwinter  2182:         
1.7       dwinter  2183:         if start:
                   2184:             RESPONSE.redirect("filelist.html?start:int="+str(start))
1.85      dwinter  2185: 
1.19      dwinter  2186:     security.declareProtected('Manage','createAllFilesAsSingleFile')
1.1       dwinter  2187:     def createAllFilesAsSingleFile(self,RESPONSE=None):
                   2188:         """download all files"""
                   2189:         
                   2190:         def sortF(x,y):
                   2191:             return cmp(x[0],y[0])
                   2192:         
1.81      casties  2193:         catalog=getattr(self,self.file_catalog)
1.1       dwinter  2194:         #tf,tfilename=mkstemp()
1.66      dwinter  2195:         if not hasattr(self.temp_folder,'downloadCounter'):
                   2196:             self.temp_folder.downloadCounter=0
1.49      dwinter  2197: 
                   2198:         if getattr(self.temp_folder,'downloadCounter',0) > 5:
1.46      dwinter  2199:             return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
1.45      dwinter  2200: 
1.46      dwinter  2201:         self.temp_folder.downloadCounter+=1
                   2202:         self._p_changed=1
1.58      dwinter  2203:         transaction.get().commit()
1.45      dwinter  2204:        
1.1       dwinter  2205:         list=[(x.getId,x) for x in catalog()]
                   2206:         list.sort(sortF)
1.46      dwinter  2207:         
1.45      dwinter  2208: 
1.1       dwinter  2209:         
                   2210:         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
                   2211:         RESPONSE.setHeader("Content-Type","application/octet-stream")
1.46      dwinter  2212:         tmp=""
1.1       dwinter  2213:         for l in list:
                   2214:             obj=l[1].getObject()
                   2215:             
                   2216:             if obj.meta_type=="CDLI file":
                   2217:                 
                   2218:                 #os.write(tf,obj.getLastVersion().data)
                   2219:                 if RESPONSE:
1.81      casties  2220:                     RESPONSE.write(obj.getData()[0:])
1.71      dwinter  2221:                     RESPONSE.write("\n")
1.46      dwinter  2222:                 self.temp_folder.downloadCounter-=1 
                   2223:                 self._p_changed=1
1.58      dwinter  2224:         transaction.get().commit()
1.1       dwinter  2225:         #os.close(tf)
                   2226:         #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
                   2227:         return True
                   2228:     
                   2229:     def downloadFile(self,fn):
                   2230:         """download fn - not used yet"""
                   2231:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
                   2232:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
                   2233:         self.REQUEST.RESPONSE.write(file(fn).read())
                   2234:         
                   2235:       
                   2236:                 
                   2237:     def hasParent(self):
                   2238:         """returns true falls subfolder"""
                   2239:       
1.81      casties  2240:         if self.aq_parent.meta_type in self.folder_meta_type:
1.1       dwinter  2241:             return True
                   2242:         else:
                   2243:             return False
                   2244:         
                   2245:     def getFolders(self):
                   2246:         """get all subfolders"""
                   2247:         ret=[]
1.81      casties  2248:         folders=self.ZopeFind(self,obj_metatypes=self.folder_meta_type)
1.1       dwinter  2249:         for folder in folders:
                   2250:             ret.append((folder[1],
1.81      casties  2251:                         len(self.ZopeFind(folder[1],obj_metatypes=self.folder_meta_type)),
                   2252:                         len(self.ZopeFind(folder[1],obj_metatypes=self.file_meta_type))
1.1       dwinter  2253:                         ))
                   2254:         return ret
                   2255:     
                   2256:             
1.77      dwinter  2257:     security.declareProtected('manage','index_html')
1.1       dwinter  2258:     def index_html(self):
                   2259:         """main"""
                   2260:         ext=self.ZopeFind(self,obj_ids=["index.html"])
                   2261:         if ext:
                   2262:             return ext[0][1]()
                   2263:         
                   2264:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
                   2265:         return pt()
                   2266:     
1.22      dwinter  2267:     
                   2268: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
                   2269: 
                   2270:     
                   2271: def manage_addCDLIFileFolder(self, id, title='',
                   2272:                      createPublic=0,
                   2273:                      createUserF=0,
                   2274:                      REQUEST=None):
                   2275:     """Add a new Folder object with id *id*.
                   2276: 
                   2277:     If the 'createPublic' and 'createUserF' parameters are set to any true
                   2278:     value, an 'index_html' and a 'UserFolder' objects are created respectively
                   2279:     in the new folder.
                   2280:     """
                   2281:     ob=CDLIFileFolder()
                   2282:     ob.id=str(id)
                   2283:     ob.title=title
                   2284:     self._setObject(id, ob)
                   2285:     ob=self._getOb(id)
                   2286: 
                   2287:     checkPermission=getSecurityManager().checkPermission
                   2288: 
                   2289:     if createUserF:
                   2290:         if not checkPermission('Add User Folders', ob):
                   2291:             raise Unauthorized, (
                   2292:                   'You are not authorized to add User Folders.'
                   2293:                   )
                   2294:         ob.manage_addUserFolder()
                   2295: 
                   2296:   
                   2297:     if REQUEST is not None:
                   2298:         return self.manage_main(self, REQUEST, update_menu=1)
                   2299:     
                   2300: class CDLIRoot(Folder):
                   2301:     """main folder for cdli"""
                   2302:     
                   2303:     meta_type="CDLIRoot"
1.81      casties  2304:     downloadCounterBaskets=0 # counts the current basket downloads if counter > 10 no downloads are possible
                   2305:     
                   2306:     file_catalog = 'CDLICatalog'
                   2307:     
                   2308:     # word splitter for search
                   2309:     splitter = {'words':cdliSplitter.wordSplitter(),
                   2310:                 'graphemes':cdliSplitter.graphemeSplitter()}
                   2311:     
1.51      dwinter  2312:     
1.86      dwinter  2313:     def viewATF(self,id,RESPONSE):
                   2314:         """view an Object"""
                   2315:         ob = self.CDLICatalog({'title':id})
                   2316:         logging.debug(ob[0].getObject().getLastVersion().absolute_url()+"/view")
                   2317:         if len(ob)>0:
                   2318:             RESPONSE.redirect(ob[0].getObject().getLastVersion().absolute_url()+"/view")
                   2319:         return "not found"
                   2320:     
                   2321:     def history(self,id,RESPONSE):
                   2322:         """view an Object"""
                   2323:         ob = self.CDLICatalog({'title':id})
                   2324:         if len(ob)>0:
                   2325:             RESPONSE.redirect(ob[0].absolute_url+"/history")
                   2326:         return "not found"
                   2327:     
                   2328: 
                   2329:     def downloadLocked(self,id,RESPONSE):
                   2330:         """view an Object"""
                   2331:         ob = self.CDLICatalog({'title':id})
                   2332:         if len(ob)>0:
                   2333:             RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
                   2334:         return "not found"
                   2335:     
                   2336:     def download(self,id,RESPONSE):
                   2337:         """view an Object"""
                   2338:         ob = self.CDLICatalog({'title':id})
                   2339:         if len(ob)>0:
                   2340:             RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
                   2341:         return "not found"
                   2342:     def addCDLIFileObjectForm(self,id,RESPONSE):
                   2343:         """view an Object"""
                   2344:         ob = self.CDLICatalog({'title':id})
                   2345:         if len(ob)>0:
                   2346:             RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
                   2347:         return "not found"
                   2348:     
                   2349:     def addVersionedFileObjectForm(self,id,RESPONSE):
                   2350:         """view an Object"""
                   2351:         ob = self.CDLICatalog({'title':id})
                   2352:         if len(ob)>0:
                   2353:             RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
                   2354:         return "not found"
                   2355:     
                   2356:     def unlock(self,id,RESPONSE):
                   2357:         """view an Object"""
                   2358:         ob = self.CDLICatalog({'title':id})
                   2359:         if len(ob)>0:
                   2360:             RESPONSE.redirect(ob[0].absolute_url+"/unlock")
                   2361:         return "not found"
                   2362:     
1.83      dwinter  2363:     def getFileObject(self,fileId):
1.85      dwinter  2364:         """get an object"""
1.83      dwinter  2365:         x=self.v_files.get(fileId)
                   2366:         #logging.debug(x)
                   2367:         return x
                   2368:     
                   2369:     def getFileObjectLastVersion(self,fileId):
1.85      dwinter  2370:         """get an object"""
1.83      dwinter  2371:         x=self.v_files_lastVersion.get(fileId)
1.95      dwinter  2372:         #logging.debug("lastVersion: "+repr(x))
1.83      dwinter  2373:         return x
                   2374:     
1.85      dwinter  2375:     def showFileIds(self):
                   2376:         """showIds"""
                   2377:         return self.v_file_ids
                   2378:     
1.83      dwinter  2379:     def generateFileBTree(self):
                   2380:         """erzeuge einen Btree aus allen Files"""
                   2381:         self.v_files = OOBTree()
                   2382:         self.v_files_lastVersion = OOBTree()
                   2383:         self.v_file_ids = Set()
                   2384:         
                   2385:         for x in self.CDLICatalog.searchResults():
                   2386:             
                   2387:             self.v_files.update({x.getId:x.getObject()})
                   2388:             self.v_files_lastVersion.update({x.getId:x.getObject().getLastVersion()})
                   2389:             self.v_file_ids.add(x.getId)
                   2390:             logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))
                   2391:         
1.85      dwinter  2392:         return True
                   2393:     
                   2394:     
                   2395:     def updateOrAddToFileBTree(self,obj):
                   2396:         """update a BTree"""
                   2397:         self.v_files.update({obj.getId():obj})
                   2398:         self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})
                   2399:         
                   2400:         self.v_file_ids.add(obj.getId())
                   2401:         logging.debug("update:"+obj.getId()+"XXX"+repr(obj))
                   2402:         
                   2403:     def deleteFromBTree(self,objId):
                   2404:         """delete an obj"""
                   2405:         self.v_files.pop(objId)
                   2406:         self.v_files_lastVersion.pop(objId)
                   2407:         self.v_file_ids.remove(objId)
                   2408:         
                   2409: 
                   2410:  
1.73      dwinter  2411:     def deleteFiles(self,ids):
1.81      casties  2412:         """delete files"""
1.73      dwinter  2413:         for id in ids:
                   2414:             founds=self.CDLICatalog.search({'title':id.split(".")[0]})
                   2415:             if founds:
1.81      casties  2416:                 logging.debug("deleting %s"%founds)
1.73      dwinter  2417:                 folder=founds[0].getObject().aq_parent #get the parent folder of the object
1.81      casties  2418:                 logging.debug("deleting from %s"%folder)
                   2419:                 cut=folder.delete([founds[0].getId]) #cut it out
                   2420: 
1.73      dwinter  2421: 
                   2422: 
1.81      casties  2423:     def searchText(self, query, index='graphemes'):
                   2424:         """searches query in the fulltext index and returns a list of file ids/P-numbers"""
                   2425:         # see also: http://www.plope.com/Books/2_7Edition/SearchingZCatalog.stx#2-13
                   2426:         logging.debug("searchtext for '%s' in index %s"%(query,index))
                   2427:         #import Products.ZCTextIndex.QueryParser
                   2428:         #qp = QueryParser.QueryParser()
                   2429:         #logging.debug()
                   2430:         idxQuery = {index:{'query':query}}
                   2431:         idx = getattr(self, self.file_catalog)
                   2432:         # do search
                   2433:         resultset = idx.search(query_request=idxQuery,sort_index='textid')
                   2434:         # put only the P-Number in the result 
                   2435:         results = [res.getId[:7] for res in resultset]
                   2436:         logging.debug("searchtext: found %d texts"%len(results))
                   2437:         return results
                   2438: 
                   2439: 
                   2440:     def getFile(self, pnum):
                   2441:         """get the translit file with the given pnum"""
                   2442:         f = getattr(self, self.file_catalog).search({'textid':pnum})
                   2443:         if not f:
                   2444:             return ""
1.71      dwinter  2445:         
1.81      casties  2446:         return f[0].getObject().getData()
                   2447:          
1.57      dwinter  2448: 
1.74      dwinter  2449:     def showFile(self,fileId,wholePage=False):
1.71      dwinter  2450:         """show a file
                   2451:         @param fileId: P-Number of the document to be displayed
                   2452:         """
1.81      casties  2453:         f=getattr(self, self.file_catalog).search({'textid':fileId})
1.51      dwinter  2454:         if not f:
                   2455:             return ""
                   2456:         
1.74      dwinter  2457:         if wholePage:
1.81      casties  2458:             logging.debug("show whole page")
                   2459:             return f[0].getObject().getContentObject().view()
1.74      dwinter  2460:         else:
                   2461:             return f[0].getObject().getLastVersionFormattedData()
1.55      dwinter  2462:     
1.56      dwinter  2463: 
1.81      casties  2464:     def showWordInFile(self,fileId,word,indexName='graphemes',regExp=False,):
                   2465:         """get lines with word from FileId"""
                   2466:         logging.debug("showwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
1.56      dwinter  2467:         
1.81      casties  2468:         file = formatAtfFullLineNum(self.getFile(fileId))
1.66      dwinter  2469:         ret=[]
1.71      dwinter  2470:         
1.81      casties  2471:         # add whitespace before and whitespace and line-end to splitter bounds expressions
                   2472:         bounds = self.splitter[indexName].bounds
                   2473:         splitexp = "(%s|\s)(%%s)(%s|\s|\Z)"%(bounds,bounds)
                   2474:         # clean word expression 
                   2475:         # TODO: this should use QueryParser itself
                   2476:         # take out double quotes
                   2477:         word = word.replace('"','')
                   2478:         # take out ignorable signs
                   2479:         ignorable = self.splitter[indexName].ignorex
                   2480:         word = ignorable.sub('', word)
                   2481:         # compile into regexp objects and escape parens
                   2482:         wordlist = [re.compile(splitexp%re.escape(w)) for w in word.split(' ')]
                   2483:             
                   2484:         for line in file.splitlines():
1.71      dwinter  2485:             for word in wordlist:
1.81      casties  2486:                 #logging.debug("showwordinfile: searching for %s in %s"%(word.pattern,ignoreable.sub('',line)))
                   2487:                 if word.search(ignorable.sub('',line)):
                   2488:                     line = formatAtfLineHtml(line)
                   2489:                     ret.append(line)
                   2490:                     break
                   2491:                     
1.66      dwinter  2492:         return ret
1.56      dwinter  2493: 
1.81      casties  2494:     
                   2495:     def showWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
                   2496:         """
                   2497:         get lines with word from all ids in list FileIds.
                   2498:         returns dict with id:lines pairs.
                   2499:         """
                   2500:         logging.debug("showwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))
1.51      dwinter  2501:         
1.81      casties  2502:         return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])
                   2503:     
                   2504: 
                   2505:     def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):
                   2506:         """get text with word highlighted from FileId"""
                   2507:         logging.debug("tagwordinfile word='%s' index=%s file=%s"%(word,indexName,fileId)) 
                   2508:         
                   2509:         file=self.getFile(fileId)
                   2510:         tagStart=u'<span class="found">'
                   2511:         tagEnd=u'</span>'
                   2512:         tagStr=tagStart + u'%%s' + tagEnd
1.66      dwinter  2513:         ret=[]
1.71      dwinter  2514:         
1.81      casties  2515:         # add whitespace to splitter bounds expressions and compile into regexp object
                   2516:         bounds = self.splitter[indexName].bounds
                   2517:         wordsplit = re.compile("(%s|\s)"%bounds)
                   2518:         # clean word expression 
                   2519:         # TODO: this should use QueryParser itself
                   2520:         word = word.replace('"','') # take out double quotes
                   2521:         # take out ignoreable signs
                   2522:         ignorable = self.splitter[indexName].ignorex
                   2523:         word = ignorable.sub('', word)
                   2524:         # split search terms by blanks
                   2525:         words = word.split(' ')
                   2526:         # split search terms again (for grapheme search with words)
                   2527:         splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))
1.71      dwinter  2528:             
1.81      casties  2529:         for line in file.splitlines():
1.79      casties  2530:             line = unicodify(line)
1.81      casties  2531:             # ignore lemma and other lines
                   2532:             if line.lstrip().startswith('#lem:'):
                   2533:                 continue
                   2534:             # ignore p-num line
                   2535:             if line.startswith('&P'):
                   2536:                 continue
                   2537:             # ignore version lines
                   2538:             if line.startswith('#version'):
                   2539:                 continue
                   2540:             # ignore atf type lines
                   2541:             if line.startswith('#atf:'):
                   2542:                 continue
                   2543: 
                   2544:             # first scan
                   2545:             hitwords = []
                   2546:             for w in words:
                   2547:                 if ignorable.sub('',line).find(w) > -1:
                   2548:                     # word is in line
                   2549:                     # append split word for grapheme search with words
                   2550:                     hitwords.extend(splitwords[w])
                   2551:                     #hitwords.extend(wordsplit.split(w))
                   2552:                    
                   2553:             # examine hits closer
                   2554:             if hitwords:
                   2555:                 # split line into words
                   2556:                 parts = wordsplit.split(line)
                   2557:                 line = ""
                   2558:                 for p in parts:
                   2559:                     #logging.debug("tagwordinfile: searching for %s in %s"%(p,hitwords))
                   2560:                     # reassemble line
                   2561:                     if ignorable.sub('', p) in hitwords:
                   2562:                         #logging.debug("tagwordinfile: found %s in %s"%(p,hitwords))
                   2563:                         # this part was found
                   2564:                         line += tagStart + formatAtfHtml(p) + tagEnd
                   2565:                     else:
                   2566:                         line += formatAtfHtml(p)
                   2567:                 
                   2568:             else:
                   2569:                 # no hits
                   2570:                 line = formatAtfHtml(line)
                   2571:             
                   2572:             ret.append(line)
                   2573:                         
                   2574:         return u'<br>\n'.join(ret)
                   2575: 
1.66      dwinter  2576: 
                   2577: 
1.81      casties  2578:     def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
                   2579:         """
                   2580:         get texts with highlighted word from all ids in list FileIds.
                   2581:         returns dict with id:text pairs.
                   2582:         """
                   2583:         logging.debug("tagwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds)) 
                   2584:         return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])
                   2585:     
1.56      dwinter  2586: 
1.82      casties  2587:     def getFileVersionList(self, pnum):
                   2588:         """get the version history as a list for the translit file with the given pnum"""
                   2589:         f = getattr(self, self.file_catalog).search({'textid':pnum})
                   2590:         if not f:
                   2591:             return []
                   2592:         
                   2593:         return f[0].getObject().getVersionList()
                   2594:          
                   2595: 
1.37      dwinter  2596:     def URLquote(self,str):
                   2597:         """quote url"""
                   2598:         return urllib.quote(str)
                   2599:     
                   2600:     def URLunquote(self,str):
                   2601:         """unquote url"""
                   2602:         return urllib.unquote(str)
                   2603:     
1.58      dwinter  2604:     def URLquote_plus(self,str):
                   2605:         """quote url"""
                   2606:         return urllib.quote_plus(str)
                   2607:     
                   2608:     def URLunquote_plus(self,str):
                   2609:         """unquote url"""
                   2610:         return urllib.unquote_plus(str)
                   2611:     
1.37      dwinter  2612:     
1.26      dwinter  2613:     def forceunlock(self):
                   2614:         "break all locks"
                   2615:         ret=[]
                   2616:         for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
                   2617:            un=f[1].forceunlock()
1.39      dwinter  2618: 
1.26      dwinter  2619:            if un and un !="":
                   2620:                ret.append((f[0],un))
1.46      dwinter  2621: 
1.61      dwinter  2622:         return ret
1.71      dwinter  2623:                                         
1.61      dwinter  2624: 
1.26      dwinter  2625:     def getChangesByAuthor(self,author,n=100):
1.25      dwinter  2626:         """getChangesByAuthor"""
1.26      dwinter  2627:         zcat=self.CDLIObjectsCatalog
                   2628:         res=zcat({'lastEditor':author,
1.25      dwinter  2629:                      'sort_on':'getTime',
                   2630:                      'sort_order':'descending',
                   2631:                      'sort_limit':n})[:n ]
1.26      dwinter  2632:                        
                   2633:         return res
                   2634:     
                   2635:     def getChangesByAuthor_html(self,author,n=100):
                   2636:         """html output for changes by author"""
                   2637:         tmp={}
                   2638:         list=[]                         
                   2639:         for x in self.getChangesByAuthor(author):
                   2640:            nr=x.getObject().getVersionNumber()
                   2641:            id=x.getObject().aq_parent.getId()
                   2642:            #hinzufuegen, wenn Version neuer als die 
                   2643:            if tmp.get(id,(0,0))[1] < nr:
                   2644:                 tmp[id]=(x.getObject().aq_parent,nr)
                   2645: 
                   2646:      
1.45      dwinter  2647:         return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values(),author=author)           
1.26      dwinter  2648:         
1.25      dwinter  2649:     def getLastChanges(self,n=100):
                   2650:         """get the last n changes""" 
                   2651:         n=int(n)                   
                   2652:         zcat=self.CDLICatalog
                   2653:         return zcat({'sort_on':'getLastChangeDate',
                   2654:                      'sort_order':'descending',
                   2655:                      'sort_limit':n})[:n ]
                   2656:      
                   2657:     
                   2658:     def getLastChanges_html(self,n=100):
                   2659:         """get the last n changes"""
                   2660:         list = [x.getId for x in self.getLastChanges(n)]
                   2661:         return self.cdli_main.findObjectsFromList(list=list,display=True)
                   2662:                                        
1.24      dwinter  2663:     def refreshTxt(self,txt="",threadName=None):
1.22      dwinter  2664:         """txt fuer refresh"""
                   2665:   
1.24      dwinter  2666:         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)
1.22      dwinter  2667: 
1.87      dwinter  2668:     def refreshTxtBasket(self,txt="",threadName=None):
                   2669:         """txt fuer refresh"""
                   2670:   
                   2671:         return """ 2;url=%s?repeat=%s """%(txt,threadName)
                   2672: 
1.22      dwinter  2673:     
1.24      dwinter  2674:     def getResult(self,threadName=None):
1.22      dwinter  2675:        """result of thread"""
                   2676:        try:
1.24      dwinter  2677:         return self._v_uploadATF[threadName].getResult()
1.22      dwinter  2678:        except:
                   2679:         return "One moment, please"
                   2680:     
1.24      dwinter  2681:         
                   2682:     def checkThreads(self):
                   2683:         """check threads"""
1.42      dwinter  2684:         ret="<html><body>"
                   2685:         for thread in threading.enumerate():
1.45      dwinter  2686:            ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())
1.42      dwinter  2687:        
                   2688:         return ret
                   2689:                                        
                   2690:                                            
1.73      dwinter  2691:     def uploadATFRPC(self,data,username):
                   2692:         """upload an atffile via xml-rpc"""
                   2693:         uploader=uploadATFThread()
                   2694:         
                   2695:         #generate an random id for the upload object
                   2696:         from random import randint
                   2697:         if (not self.REQUEST.SESSION.get('idTmp',None)):
                   2698: 
                   2699:             idTmp=str(randint(0,1000000000))
                   2700:             self.REQUEST.SESSION['idTmp']=idTmp
                   2701:         else:
                   2702:             idTmp=self.REQUEST.SESSION.get('idTmp',None)
                   2703:             
                   2704:         
                   2705:         uploader.set(data,0,username,idTmp)
                   2706:         
                   2707:         stObj=uploader.run()
                   2708:         
                   2709:         processor=uploadATFfinallyThread()
                   2710:         
                   2711:         basketname=stObj.returnValue['basketNameFromFile']
                   2712:         
                   2713:         processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])
                   2714:         
                   2715:         processor.run()
                   2716:         
                   2717:         
                   2718:         return generateXMLReturn(stObj.returnValue)
                   2719:         
1.22      dwinter  2720:     def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
1.69      dwinter  2721:         """upload an atf file / basket file"""
1.22      dwinter  2722:         #self._v_uploadATF.returnValue=None
1.71      dwinter  2723:         
                   2724:         #generate an random id for the upload thread
1.60      dwinter  2725:         from random import randint
1.61      dwinter  2726:         if (not self.REQUEST.SESSION.get('idTmp',None)):
1.22      dwinter  2727: 
1.60      dwinter  2728:             idTmp=str(randint(0,1000000000))
                   2729:             self.REQUEST.SESSION['idTmp']=idTmp
                   2730:         else:
                   2731:             idTmp=self.REQUEST.SESSION.get('idTmp',None)
                   2732:             
1.71      dwinter  2733:     
1.22      dwinter  2734:         threadName=repeat
                   2735:         if not threadName or threadName=="":
1.71      dwinter  2736:             #new thread not called from the waiting page
1.22      dwinter  2737:             tmpVar=False
1.24      dwinter  2738:        
1.22      dwinter  2739:             thread=uploadATFThread()
1.24      dwinter  2740:             threadName=thread.getName()[0:]                                
1.36      dwinter  2741:             if (not hasattr(self,'_v_uploadATF')):
1.24      dwinter  2742:                    self._v_uploadATF={}
                   2743:                                        
                   2744:             self._v_uploadATF[threadName]=thread
1.22      dwinter  2745:             #self._xmltrans.start()
                   2746:             #thread=Thread(target=self._v_uploadATF)
1.60      dwinter  2747:             logging.info("set thread. extern")
                   2748:             self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
1.22      dwinter  2749:             #thread.start()
1.60      dwinter  2750:             logging.info("start thread. extern")
1.24      dwinter  2751:             self._v_uploadATF[threadName].start()
1.22      dwinter  2752: 
                   2753:             
1.24      dwinter  2754:             self.threadName=self._v_uploadATF[threadName].getName()[0:]
1.22      dwinter  2755:             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   2756: 
                   2757:             if wait_template:
                   2758:                 return wait_template[0][1]()
                   2759:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1.24      dwinter  2760:             return pt(txt='/uploadATF',threadName=threadName)
1.22      dwinter  2761:             #_v_xmltrans.run()
                   2762:             
                   2763:         else:
                   2764:             #recover thread, if lost
1.36      dwinter  2765:             if (not hasattr(self,'_v_uploadATF')):
1.24      dwinter  2766:                self._v_uploadATF={}
                   2767:             if not self._v_uploadATF.get(threadName,None):
1.22      dwinter  2768:                  for thread in threading.enumerate():
                   2769:                          if threadName == thread.getName():
1.24      dwinter  2770:                                        self._v_uploadATF[threadName]=thread
                   2771:                                        
1.60      dwinter  2772:             if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):
1.22      dwinter  2773:         
                   2774: 
                   2775:                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   2776:                 if wait_template:
                   2777:                         return wait_template[0][1]()
                   2778:                 
                   2779:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                   2780: 
1.24      dwinter  2781:                 return pt(txt='/uploadATF',threadName=threadName)
1.22      dwinter  2782:                 
                   2783:             else:
1.60      dwinter  2784:                 tmp=getattr(self.temp_folder,idTmp).returnValue
1.71      dwinter  2785:  
1.22      dwinter  2786:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
1.39      dwinter  2787: 
1.47      dwinter  2788:                 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  2789:                   basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
1.30      dwinter  2790:                      
                   2791:     def redoUpload(self,threadName):
                   2792:        """redo the upload"""
                   2793:        tmp=self.cdli_main.tmpStore2[threadName]
                   2794:        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
1.45      dwinter  2795:        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  2796:                   basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])
                   2797:                  
1.22      dwinter  2798:     def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
                   2799:         """nowupload the files"""
                   2800:        
                   2801:        
                   2802:        
                   2803:         threadName=repeat
                   2804:         if not threadName or threadName=="":
1.24      dwinter  2805:             thread=uploadATFfinallyThread()
                   2806:             threadName=thread.getName()[0:]
1.36      dwinter  2807: 
1.35      dwinter  2808:             if (not hasattr(self,'_v_uploadATF')):
1.46      dwinter  2809:                                 self._v_uploadATF={}
1.36      dwinter  2810: 
1.43      dwinter  2811: 
1.24      dwinter  2812:             self._v_uploadATF[threadName]=thread
1.22      dwinter  2813: 
1.60      dwinter  2814:             idTmp=self.REQUEST.SESSION['idTmp']
                   2815:             stObj=getattr(self.temp_folder,idTmp)
                   2816:             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  2817: 
1.24      dwinter  2818:             self._v_uploadATF[threadName].start()
1.22      dwinter  2819: 
                   2820:             
1.24      dwinter  2821:             
1.22      dwinter  2822:             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   2823: 
                   2824:             if wait_template:
                   2825:                 return wait_template[0][1]()
                   2826:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
                   2827: 
1.24      dwinter  2828:             return pt(txt='/uploadATFfinally',threadName=threadName)
1.22      dwinter  2829:             #_v_xmltrans.run()
                   2830:         
                   2831:         else:
                   2832:             #recover thread, if lost
                   2833:             if not hasattr(self,'_v_uploadATF'):
1.24      dwinter  2834:                self._v_uploadATF={}
                   2835:             if not self._v_uploadATF.get(threadName,None):
1.22      dwinter  2836:                  for thread in threading.enumerate():
                   2837:                          if threadName == thread.getName():
1.24      dwinter  2838:                                        self._v_uploadATF[threadName]=thread
1.22      dwinter  2839:                                        
1.24      dwinter  2840:             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  2841: 
                   2842:                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   2843:                 if wait_template:
                   2844:                         return wait_template[0][1]()
                   2845:                 
                   2846:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
1.24      dwinter  2847:                 return pt(txt='/uploadATFfinally',threadName=threadName)
1.22      dwinter  2848:             else:
1.85      dwinter  2849:               
                   2850:              
                   2851:               idTmp=self.REQUEST.SESSION['idTmp']
                   2852:               stObj=getattr(self.temp_folder,idTmp) 
1.60      dwinter  2853:               self.REQUEST.SESSION['idTmp']=None
1.85      dwinter  2854:              
                   2855:               #update changed
                   2856:               logging.debug("dir:"+repr(stObj.returnValue['changed']))
                   2857:               for x in stObj.returnValue['changed']:
                   2858:                     ob=self.CDLICatalog.search({'title':x[0]})
                   2859:                    
                   2860:                     self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
1.22      dwinter  2861:               if RESPONSE is not None:
                   2862:                   RESPONSE.redirect(self.absolute_url())
                   2863: 
1.49      dwinter  2864:     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
1.1       dwinter  2865:         """import files"""
1.81      casties  2866:         logging.debug("importFiles folderName=%s files=%s ext=%s"%(folderName,files,ext))
1.22      dwinter  2867:         root=self.cdli_main
1.49      dwinter  2868:         count=0
1.3       dwinter  2869:         if not files:
                   2870:             files=os.listdir(folderName)
                   2871:             
1.1       dwinter  2872:         for f in files:
                   2873:             folder=f[0:3]
                   2874:             f2=f[0:5]
1.85      dwinter  2875:             
                   2876:             #check if main folder PXX already exists
1.22      dwinter  2877:             obj=self.ZopeFind(root,obj_ids=[folder])
1.81      casties  2878:             logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj)) 
1.19      dwinter  2879:             if ext:
1.65      dwinter  2880:                 ext.result="<p>adding: %s </p>"%f+ext.result
1.81      casties  2881: 
1.85      dwinter  2882:             
                   2883:             if not obj: # if not create it
1.22      dwinter  2884:                 manage_addCDLIFileFolder(root,folder,folder)
                   2885:                 fobj=getattr(root,folder)
1.58      dwinter  2886:                 #transaction.get().commit()                           
1.81      casties  2887: 
1.1       dwinter  2888:             else:
                   2889:                 fobj=obj[0][1]
                   2890:             
1.85      dwinter  2891:             #check IF PYYYYY already exist
1.1       dwinter  2892:             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
1.81      casties  2893:             logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2)) 
1.1       dwinter  2894:         
1.85      dwinter  2895:             if not obj2:# if not create it
1.1       dwinter  2896:                 manage_addCDLIFileFolder(fobj,f2,f2)
                   2897:                 fobj2=getattr(fobj,f2)
                   2898:         
                   2899:             else:
                   2900:                 fobj2=obj2[0][1]
                   2901:               
1.85      dwinter  2902:             # not add the file
1.48      dwinter  2903:             file2=os.path.join(folderName,f)  
1.1       dwinter  2904:             id=f
1.81      casties  2905:             logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
                   2906:             fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
1.66      dwinter  2907:             count+=1
1.85      dwinter  2908:             
                   2909:             #now add the file to the storage
                   2910:             ob = getattr(fobj2,f)
                   2911:             self.cdliRoot.updateOrAddToFileBTree(ob)
                   2912:             
1.81      casties  2913:             if count%100==0:
                   2914:                 logging.debug("importfiles: committing")
1.66      dwinter  2915:                 transaction.get().commit()
1.81      casties  2916: 
                   2917:         transaction.get().commit()
1.3       dwinter  2918:         return "ok"
1.22      dwinter  2919:          
                   2920: 
                   2921: manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())
1.1       dwinter  2922: 
                   2923:     
1.22      dwinter  2924: def manage_addCDLIRoot(self, id, title='',
1.1       dwinter  2925:                      createPublic=0,
                   2926:                      createUserF=0,
                   2927:                      REQUEST=None):
                   2928:     """Add a new Folder object with id *id*.
                   2929: 
                   2930:     If the 'createPublic' and 'createUserF' parameters are set to any true
                   2931:     value, an 'index_html' and a 'UserFolder' objects are created respectively
                   2932:     in the new folder.
                   2933:     """
1.22      dwinter  2934:     ob=CDLIRoot()
1.1       dwinter  2935:     ob.id=str(id)
                   2936:     ob.title=title
1.61      dwinter  2937:     try:
1.66      dwinter  2938:         self._setObject(id, ob)
1.61      dwinter  2939:     except:
1.66      dwinter  2940:         pass
1.1       dwinter  2941:     ob=self._getOb(id)
                   2942: 
                   2943:     checkPermission=getSecurityManager().checkPermission
                   2944: 
                   2945:     if createUserF:
                   2946:         if not checkPermission('Add User Folders', ob):
                   2947:             raise Unauthorized, (
                   2948:                   'You are not authorized to add User Folders.'
                   2949:                   )
                   2950:         ob.manage_addUserFolder()
                   2951: 
                   2952:   
                   2953:     if REQUEST is not None:
1.22      dwinter  2954:         return self.manage_main(self, REQUEST, update_menu=1)    
                   2955:  

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