version 1.60, 2007/01/30 00:58:26
|
version 1.65, 2007/02/08 10:46:36
|
Line 24 import threading
|
Line 24 import threading
|
from BTrees.OOBTree import OOBTree |
from BTrees.OOBTree import OOBTree |
import logging |
import logging |
import transaction |
import transaction |
|
import copy |
|
|
def unique(s): |
def unique(s): |
"""Return a list of the elements in s, but without duplicates. |
"""Return a list of the elements in s, but without duplicates. |
Line 173 class uploadATFfinallyThread(Thread):
|
Line 174 class uploadATFfinallyThread(Thread):
|
conn.close() |
conn.close() |
#set flag for end of this method |
#set flag for end of this method |
self.end=True |
self.end=True |
print "ended" |
logging.info("ended") |
return True |
return True |
|
|
def __del__(self): |
def __del__(self): |
Line 195 class uploadATFfinallyThread(Thread):
|
Line 196 class uploadATFfinallyThread(Thread):
|
|
|
#shall I only upload the changed files? |
#shall I only upload the changed files? |
if procedure=="uploadchanged": |
if procedure=="uploadchanged": |
|
changed=[x[0] for x in SESSION.get('changed',[])] |
uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[]) |
uploadFns=changed+SESSION.get('newPs',[]) |
|
|
#or all |
#or all |
elif procedure=="uploadAll": |
elif procedure=="uploadAll": |
Line 212 class uploadATFfinallyThread(Thread):
|
Line 213 class uploadATFfinallyThread(Thread):
|
uploadFns=[] |
uploadFns=[] |
|
|
#do first the changed files |
#do first the changed files |
|
i=0 |
for fn in uploadFns: |
for fn in uploadFns: |
|
i+=1 |
founds=ctx2.CDLICatalog.search({'title':fn}) |
founds=ctx2.CDLICatalog.search({'title':fn}) |
if len(founds)>0: |
if len(founds)>0: |
SESSION['author']=str(username) |
SESSION['author']=str(username) |
self.result+="<p>Changing : %s"%fn |
self.result="<p>Changing : %s"%fn+self.result |
founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True) |
founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True) |
|
if i==200: |
|
i=0 |
|
transaction.get().commit() |
|
logging.info("changing: do commit") |
|
|
|
transaction.get().commit() |
|
logging.info("changing: last commit") |
|
|
#now add the new files |
#now add the new files |
newPs=SESSION['newPs'] |
newPs=SESSION['newPs'] |
if len(newPs)>0: |
if len(newPs)>0: |
tmpDir=SESSION['tmpdir'] |
tmpDir=SESSION['tmpdir'] |
self.result+="<p>Adding files</p>" |
logging.info("adding start") |
|
self.result="<p>Adding files</p>"+self.result |
#TODO: make this configurable, at the moment base folder for the files has to be cdli_main |
#TODO: make this configurable, at the moment base folder for the files has to be cdli_main |
|
|
ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self) |
ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self) |
|
logging.info("adding finished") |
|
|
|
|
#unlock locked files? |
#unlock locked files? |
if unlock: |
if unlock: |
self.result+="<p>Unlock files</p>" |
logging.info("unlocking start") |
|
self.result="<p>Unlock files</p>"+self.result |
unlockFns=[] |
unlockFns=[] |
for x in os.listdir(SESSION['tmpdir']): |
for x in os.listdir(SESSION['tmpdir']): |
if not x in SESSION['errors']: |
if not x in SESSION['errors']: |
unlockFns.append(x) |
unlockFns.append(x) |
|
logging.info("unlocking have now what to unlock") |
|
|
for fn in unlockFns: |
for fn in unlockFns: |
|
#logging.info("will unlock: %s"%fn) |
founds=ctx2.CDLICatalog.search({'title':fn}) |
founds=ctx2.CDLICatalog.search({'title':fn}) |
|
#logging.info("found it: %s"%repr(founds)) |
if len(founds)>0: |
if len(founds)>0: |
|
#logging.info("unlock: %s"%founds[0].getObject().getId()) |
SESSION['author']=str(username) |
SESSION['author']=str(username) |
|
|
founds[0].getObject().lockedBy="" |
founds[0].getObject().lockedBy="" |
|
logging.info("unlocking done") |
|
|
#if a basketname is give, add files to the basket |
#if a basketname is given, add files to the basket |
if not (basketname ==''): |
if not (basketname ==''): |
self.result+="<p>Add basket</p>" |
logging.info("add to basket %s"%basketname) |
|
self.result="<p>Add to basket</p>"+self.result |
basketId=ctx2.basketContainer.getBasketIdfromName(basketname) |
basketId=ctx2.basketContainer.getBasketIdfromName(basketname) |
|
|
if not basketId: # create new basket |
if not basketId: # create new basket |
|
logging.info("create basket %s"%basketname) |
|
self.result="<p>Create a new basket</p>"+self.result |
ob=ctx2.basketContainer.addBasket(basketname) |
ob=ctx2.basketContainer.addBasket(basketname) |
basketId=ob.getId() |
basketId=ob.getId() |
basket=getattr(ctx2.basketContainer,str(basketId)) |
basket=getattr(ctx2.basketContainer,str(basketId)) |
Line 262 class uploadATFfinallyThread(Thread):
|
Line 281 class uploadATFfinallyThread(Thread):
|
RESPONSE.redirect(self.aq_parent.absolute_url()) |
RESPONSE.redirect(self.aq_parent.absolute_url()) |
|
|
|
|
|
logging.info("uploadfinally done") |
return True |
return True |
|
|
class tmpStore(SimpleItem): |
class tmpStore(SimpleItem): |
Line 320 class uploadATFThread(Thread):
|
Line 339 class uploadATFThread(Thread):
|
app = root['Application'] |
app = root['Application'] |
ctx = self.getContext(app,serverport=self.serverport) |
ctx = self.getContext(app,serverport=self.serverport) |
logging.info("run intern") |
logging.info("run intern") |
|
try: |
ctx.temp_folder._setObject(idTmp,tmpStore(idTmp)) |
ctx.temp_folder._setObject(idTmp,tmpStore(idTmp)) |
|
except: |
|
logging.error("thread upload: %s %s"%sys.exc_info()[0:2]) |
|
|
logging.info("call thread intern") |
logging.info("call thread intern") |
self.uploadATFThread(ctx,self.upload,idTmp,self.basketId) |
self.uploadATFThread(ctx,self.upload,idTmp,self.basketId) |
|
|
Line 388 class uploadATFThread(Thread):
|
Line 411 class uploadATFThread(Thread):
|
#start to check the files |
#start to check the files |
for fn in os.listdir(dir): |
for fn in os.listdir(dir): |
|
|
self.result+="<p>process:%s</p>"%fn |
self.result="<p>process:%s</p>"%fn+self.result |
|
|
# check if file is in the catalog |
# check if file is in the catalog |
#TODO: checkCatalog is not implemented yet |
#TODO: checkCatalog is not implemented yet |
Line 416 class uploadATFThread(Thread):
|
Line 439 class uploadATFThread(Thread):
|
obj=found.getObject() |
obj=found.getObject() |
|
|
if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))): |
if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))): |
lockerrors.append(fn) |
lockerrors.append((fn,str(obj.lockedBy))) |
else: |
else: |
|
|
diffs=obj.diff(data) |
diffs=obj.diff(data) |
Line 438 class uploadATFThread(Thread):
|
Line 461 class uploadATFThread(Thread):
|
stObj.returnValue['basketNameFromFile']=basketNameFromFile |
stObj.returnValue['basketNameFromFile']=basketNameFromFile |
stObj.returnValue['basketId']=basketId |
stObj.returnValue['basketId']=basketId |
stObj.returnValue['dir']=dir |
stObj.returnValue['dir']=dir |
|
#stObj.returnValue['changed']=copy.copy(changed) |
stObj.returnValue['changed']=[x[0].getId() for x in changed] |
stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed] |
stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors] |
#stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors] |
|
stObj.returnValue['lockerrors']=[x for x in lockerrors] |
self.returnValue=True |
self.returnValue=True |
#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True) |
#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True) |
|
|
|
|
class Basket_old(Folder): |
|
"""shopping basket - alte fassung """ |
|
|
|
meta_type="Basket" |
|
_v_stack={} |
|
|
|
def getObjUrl(self,objId): |
|
"""getUrl""" |
|
founds=self.CDLICatalog.search({'title':objId}) |
|
if len(founds)>0: |
|
return founds[0].getObject().absolute_url() |
|
|
|
else: #assume version number |
|
splitted=objId.split("_") |
|
founds=self.CDLICatalog.search({'title':splitted[1]}) |
|
return founds[0].getObject().absolute_url()+'/'+objId |
|
|
|
def storeAllLink(self,results): |
|
"""erzeuge link zum speicher aller results""" |
|
nr=self.REQUEST['_ZopeId'] |
|
|
|
if results: |
|
self._v_stack[nr]=[x.getObject().getId() for x in results] |
|
|
|
return self.absolute_url()+"/storeAll?id="+nr |
|
|
|
def storeAll(self,id): |
|
"""store all""" |
|
try: |
|
results=self._v_stack[id] |
|
except: |
|
#TODO: write expired page |
|
return "expired" |
|
|
|
return self.storeInBasketForm(results) |
|
|
|
def storeInBasketForm(self,ids): |
|
""" store an object form""" |
|
|
|
if type(ids) is not ListType: |
|
ids=[ids] |
|
self.REQUEST.SESSION['ids']=ids[0:] |
|
|
|
self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER'] |
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self) |
|
return pt() |
|
|
|
def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None): |
|
"""store it""" |
|
|
|
if not ids: |
|
ids=REQUEST.SESSION['ids'] |
|
|
|
self.REQUEST.SESSION['basketUser']=username |
|
|
|
baskets=self.ZopeFind(self,obj_ids=[username]) |
|
if len(baskets)>0: |
|
basket=baskets[0][1] |
|
else: |
|
manage_addBasketObject(self,username) |
|
basket=self._getOb(username) |
|
|
|
|
|
basket.addObjects(ids) |
|
back=self.REQUEST.SESSION.get('BACKLINK', None) |
|
|
|
if RESPONSE: |
|
RESPONSE.redirect(back) |
|
|
|
|
|
|
|
def showBasket(self,user=None,set=None,RESPONSE=None): |
|
"""show the basket""" |
|
|
|
if user: |
|
self.REQUEST.SESSION['basketUser']=user |
|
|
|
if not user and not set: |
|
user=self.REQUEST.SESSION.get('basketUser',None) |
|
|
|
if not user: |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self) |
|
return pt() |
|
else: |
|
baskets=self.ZopeFind(self,obj_ids=[user]) |
|
|
|
|
|
if len(baskets)>0: |
|
RESPONSE.redirect(baskets[0][1].absolute_url()) |
|
return True |
|
else: |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self) |
|
return pt() |
|
|
|
|
|
def manage_addBasket_oldForm(self): |
|
"""add the basket form""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self) |
|
return pt() |
|
|
|
def manage_addBasket_old(self,id,title,RESPONSE=None): |
|
"""add the basket""" |
|
ob=Basket() |
|
|
|
ob.id=str(id) |
|
ob.title=title |
|
self._setObject(id, ob) |
|
ob=self._getOb(id) |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
|
|
class BasketObject_old(Folder): |
|
"""Basket Object - alte fassung""" |
|
|
|
meta_type="basketObject" |
|
def __init__(self): |
|
"""init basket object""" |
|
self.contents=[] |
|
|
|
def numberOfItems(self): |
|
"""return anzahl der elemente im basket""" |
|
num=len(self.contents) |
|
|
|
return num |
|
|
|
def addObjects(self,ids): |
|
"""addObjects""" |
|
|
|
for id in ids: |
|
founds=self.CDLICatalog.search({'title':id}) |
|
for found in founds: |
|
if found.getObject() not in self.contents: |
|
tm=self.contents[0:] |
|
tm.append(found.getObject()) |
|
self.contents=tm[0:] |
|
|
|
return True |
|
|
|
def index_html(self): |
|
"""view the basket""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self) |
|
return pt() |
|
|
|
def deleteObjects(self,ids,RESPONSE=None): |
|
"""delete objects""" |
|
list = self.contents[0:] |
|
for content in list: |
|
|
|
if content.getId() in ids: |
|
self.contents.remove(content) |
|
|
|
|
|
if RESPONSE: |
|
RESPONSE.redirect(self.absolute_url()) |
|
|
|
|
|
def unlockTest(self): |
|
"""unlock all files of the testuser for debuggin""" |
|
for object in self.contents: |
|
|
|
if str(object.lockedBy)=="test": |
|
object.lockedBy="" |
|
|
|
def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None): |
|
"""download all selected files in one file""" |
|
|
|
ret="" |
|
lockedObjects={} |
|
|
|
if self.temp_folder.downloadCounter > 10: |
|
return """I am sorry, currently the server has to many requests for downloads, please come back later!""" |
|
|
|
|
|
if lock: |
|
|
|
if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User': |
|
|
|
return "please login first" |
|
|
|
#check if a locked object exist in the basket. |
|
lockedObjects={} |
|
for object in self.contents: |
|
|
|
if not object.lockedBy=="": |
|
lockedObjects[object.title]=repr(object.lockedBy) |
|
|
|
|
|
keys=lockedObjects.keys() |
|
|
|
|
|
if len(keys)>0 and (not procedure): |
|
self.REQUEST.SESSION['lockedObjects']=lockedObjects |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self) |
|
return pt() |
|
|
|
elif not procedure: #keine fails gesperrt dann alle donwloaden |
|
procedure="downloadAll" |
|
|
|
self.temp_folder.downloadCounter+=1 |
|
self._p_changed=1 |
|
|
|
transaction.get().commit() |
|
|
|
for object in self.contents: |
|
|
|
if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']): |
|
ret+=object.getLastVersion().getData() |
|
|
|
if lock and object.lockedBy=='': |
|
object.lockedBy=self.REQUEST['AUTHENTICATED_USER'] |
|
|
|
|
|
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId()) |
|
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream") |
|
length=len(ret) |
|
self.REQUEST.RESPONSE.setHeader("Content-Length",length) |
|
self.REQUEST.RESPONSE.write(ret) |
|
self.temp_folder.downloadCounter-=1 |
|
self._p_changed=1 |
|
transaction.get().commit() |
|
|
|
|
|
|
|
def manage_addBasket_oldObjectForm(self): |
|
"""add form""" |
|
pass |
|
|
|
def manage_addBasket_oldObject(self,id,title='',RESPONSE=None): |
|
"""add""" |
|
|
|
ob=BasketObject() |
|
|
|
ob.id=str(id) |
|
ob.title=title |
|
self._setObject(id, ob) |
|
ob=self._getOb(id) |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
|
|
class CDLIBasketContainer(OrderedFolder): |
class CDLIBasketContainer(OrderedFolder): |
"""contains the baskets""" |
"""contains the baskets""" |
|
|
Line 1063 class CDLIBasket(Folder,CatalogAware):
|
Line 843 class CDLIBasket(Folder,CatalogAware):
|
|
|
def addObjects(self,ids,deleteOld=None,username=None): |
def addObjects(self,ids,deleteOld=None,username=None): |
"""generate a new version of the basket with objects added""" |
"""generate a new version of the basket with objects added""" |
|
logging.info("add to basket (%s)"%(self.getId())) |
lastVersion=self.getLastVersion() |
lastVersion=self.getLastVersion() |
|
|
if lastVersion is None: |
if lastVersion is None: |
Line 1081 class CDLIBasket(Folder,CatalogAware):
|
Line 861 class CDLIBasket(Folder,CatalogAware):
|
founds=self.CDLICatalog.search({'title':id}) |
founds=self.CDLICatalog.search({'title':id}) |
except: |
except: |
founds=[] |
founds=[] |
|
|
for found in founds: |
for found in founds: |
if found.getObject() not in oldContent: |
if found.getObject() not in oldContent: |
#TODO: was passiert wenn, man eine Object dazufgt, das schon da ist aber eine neuere version |
#TODO: was passiert wenn, man eine Object dazufgt, das schon da ist aber eine neuere version |
Line 1094 class CDLIBasket(Folder,CatalogAware):
|
Line 875 class CDLIBasket(Folder,CatalogAware):
|
user = username |
user = username |
|
|
ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content) |
ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content) |
|
logging.info("add to basket (%s) done"%(self.getId())) |
return added |
return added |
|
|
|
|
Line 1228 class CDLIBasketVersion(Implicit,Persist
|
Line 1009 class CDLIBasketVersion(Implicit,Persist
|
lockedObjects={} |
lockedObjects={} |
for object in self.content.getContent(): |
for object in self.content.getContent(): |
|
|
if not object[1].lockedBy=="": |
if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))): |
lockedObjects[object[1].title]=repr(object[1].lockedBy) |
lockedObjects[object[1].title]=repr(object[1].lockedBy) |
|
|
|
|
Line 1388 class CDLIFileObject(CatalogAware,extVer
|
Line 1169 class CDLIFileObject(CatalogAware,extVer
|
|
|
|
|
newversion=parent.manage_addCDLIFileObject('',comment,author) |
newversion=parent.manage_addCDLIFileObject('',comment,author) |
newversion.data=self.data[0:] |
newversion.manage_upload(self.getData()) |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect(self.aq_parent.absolute_url()+'/history') |
RESPONSE.redirect(self.aq_parent.absolute_url()+'/history') |
Line 1694 def splitatf(fh,dir=None,ext=None):
|
Line 1475 def splitatf(fh,dir=None,ext=None):
|
if dir: |
if dir: |
filename=os.path.join(dir,filename) |
filename=os.path.join(dir,filename) |
nf=file(filename,"w") |
nf=file(filename,"w") |
|
logging.info("open %s"%filename) |
if nf: |
if nf: |
nf.write(line.replace("\n","")+"\n") |
nf.write(line.replace("\n","")+"\n") |
|
|
|
try: |
nf.close() |
nf.close() |
|
except: |
|
pass |
fh.close() |
fh.close() |
return ret,len(os.listdir(dir)) |
return ret,len(os.listdir(dir)) |
|
|
Line 2145 class CDLIRoot(Folder):
|
Line 1930 class CDLIRoot(Folder):
|
|
|
return ret |
return ret |
|
|
|
def forceDahl(self): |
|
"break all locks" |
|
ret=[] |
|
for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1): |
|
if str(f[1].lockedBy)=="dahl": |
|
un=f[1].forceunlock() |
|
|
|
if un and un !="": |
|
ret.append((f[0],un)) |
|
|
|
return ret |
|
|
def getChangesByAuthor(self,author,n=100): |
def getChangesByAuthor(self,author,n=100): |
"""getChangesByAuthor""" |
"""getChangesByAuthor""" |
zcat=self.CDLIObjectsCatalog |
zcat=self.CDLIObjectsCatalog |
Line 2211 class CDLIRoot(Folder):
|
Line 2008 class CDLIRoot(Folder):
|
"""standard ausgabe""" |
"""standard ausgabe""" |
#self._v_uploadATF.returnValue=None |
#self._v_uploadATF.returnValue=None |
from random import randint |
from random import randint |
if not self.REQUEST.SESSION.get('idTmp',None): |
if (not self.REQUEST.SESSION.get('idTmp',None)): |
|
|
idTmp=str(randint(0,1000000000)) |
idTmp=str(randint(0,1000000000)) |
self.REQUEST.SESSION['idTmp']=idTmp |
self.REQUEST.SESSION['idTmp']=idTmp |
Line 2367 class CDLIRoot(Folder):
|
Line 2164 class CDLIRoot(Folder):
|
obj=self.ZopeFind(root,obj_ids=[folder]) |
obj=self.ZopeFind(root,obj_ids=[folder]) |
if ext: |
if ext: |
|
|
ext.result+="<p>adding: %s </p>"%f |
ext.result="<p>adding: %s </p>"%f+ext.result |
if not obj: |
if not obj: |
manage_addCDLIFileFolder(root,folder,folder) |
manage_addCDLIFileFolder(root,folder,folder) |
fobj=getattr(root,folder) |
fobj=getattr(root,folder) |
Line 2421 def manage_addCDLIRoot(self, id, title='
|
Line 2218 def manage_addCDLIRoot(self, id, title='
|
ob=CDLIRoot() |
ob=CDLIRoot() |
ob.id=str(id) |
ob.id=str(id) |
ob.title=title |
ob.title=title |
|
try: |
self._setObject(id, ob) |
self._setObject(id, ob) |
|
except: |
|
pass |
ob=self._getOb(id) |
ob=self._getOb(id) |
|
|
checkPermission=getSecurityManager().checkPermission |
checkPermission=getSecurityManager().checkPermission |