Annotation of cdli/cdli_files.py, revision 1.18
1.1 dwinter 1: """CDLI extensions of the filearchive"""
2: from Products.versionedFile.versionedFile import *
3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
1.2 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.4 dwinter 9: from OFS.OrderedFolder import OrderedFolder
10: from OFS.SimpleItem import SimpleItem
11: import time
1.12 dwinter 12: from OFS.Folder import manage_addFolder
13: import re
1.4 dwinter 14:
15: class Basket_old(Folder):
16: """shopping basket - alte fassung """
1.1 dwinter 17:
18: meta_type="Basket"
19: _v_stack={}
20:
1.3 dwinter 21: def getObjUrl(self,objId):
22: """getUrl"""
1.9 dwinter 23: founds=self.CDLICatalog.search({'title':objId})
1.3 dwinter 24: if len(founds)>0:
25: return founds[0].getObject().absolute_url()
26:
1.4 dwinter 27: else: #assume version number
1.3 dwinter 28: splitted=objId.split("_")
1.9 dwinter 29: founds=self.CDLICatalog.search({'title':splitted[1]})
1.3 dwinter 30: return founds[0].getObject().absolute_url()+'/'+objId
31:
1.1 dwinter 32: def storeAllLink(self,results):
33: """erzeuge link zum speicher aller results"""
34: nr=self.REQUEST['_ZopeId']
35:
36: if results:
37: self._v_stack[nr]=[x.getObject().getId() for x in results]
38:
39: return self.absolute_url()+"/storeAll?id="+nr
40:
41: def storeAll(self,id):
42: """store all"""
43: try:
44: results=self._v_stack[id]
45: except:
46: #TODO: write expired page
47: return "expired"
48:
49: return self.storeInBasketForm(results)
50:
51: def storeInBasketForm(self,ids):
52: """ store an object form"""
53:
54: if type(ids) is not ListType:
55: ids=[ids]
56: self.REQUEST.SESSION['ids']=ids[0:]
57:
58: self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']
59:
60: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
61: return pt()
62:
63: def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
64: """store it"""
65:
66: if not ids:
67: ids=REQUEST.SESSION['ids']
68:
69: self.REQUEST.SESSION['basketUser']=username
70:
71: baskets=self.ZopeFind(self,obj_ids=[username])
72: if len(baskets)>0:
73: basket=baskets[0][1]
74: else:
75: manage_addBasketObject(self,username)
76: basket=self._getOb(username)
77:
78:
79: basket.addObjects(ids)
80: back=self.REQUEST.SESSION.get('BACKLINK', None)
81:
82: if RESPONSE:
83: RESPONSE.redirect(back)
84:
85:
86:
87: def showBasket(self,user=None,set=None,RESPONSE=None):
88: """show the basket"""
89:
90: if user:
91: self.REQUEST.SESSION['basketUser']=user
92:
93: if not user and not set:
94: user=self.REQUEST.SESSION.get('basketUser',None)
95:
96: if not user:
1.4 dwinter 97: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
1.1 dwinter 98: return pt()
99: else:
100: baskets=self.ZopeFind(self,obj_ids=[user])
101:
102:
103: if len(baskets)>0:
104: RESPONSE.redirect(baskets[0][1].absolute_url())
105: return True
106: else:
107: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
108: return pt()
109:
110:
1.4 dwinter 111: def manage_addBasket_oldForm(self):
1.1 dwinter 112: """add the basket form"""
113: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
114: return pt()
115:
1.4 dwinter 116: def manage_addBasket_old(self,id,title,RESPONSE=None):
1.1 dwinter 117: """add the basket"""
118: ob=Basket()
119:
120: ob.id=str(id)
121: ob.title=title
122: self._setObject(id, ob)
123: ob=self._getOb(id)
124:
125: if RESPONSE is not None:
126: RESPONSE.redirect('manage_main')
127:
128:
1.4 dwinter 129: class BasketObject_old(Folder):
130: """Basket Object - alte fassung"""
1.1 dwinter 131:
1.2 dwinter 132: meta_type="basketObject"
1.1 dwinter 133: def __init__(self):
1.16 dwinter 134: """init basket object"""
135: self.contents=[]
1.1 dwinter 136:
137: def numberOfItems(self):
138: """return anzahl der elemente im basket"""
139: return len(self.contents)
140:
141: def addObjects(self,ids):
142: """addObjects"""
143:
144: for id in ids:
1.9 dwinter 145: founds=self.CDLICatalog.search({'title':id})
1.1 dwinter 146: for found in founds:
147: if found.getObject() not in self.contents:
148: tm=self.contents[0:]
149: tm.append(found.getObject())
150: self.contents=tm[0:]
151:
152: return True
153:
154: def index_html(self):
1.16 dwinter 155: """view the basket"""
156: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
157: return pt()
1.1 dwinter 158:
159: def deleteObjects(self,ids,RESPONSE=None):
160: """delete objects"""
161: list = self.contents[0:]
162: for content in list:
163:
164: if content.getId() in ids:
165: self.contents.remove(content)
166:
167:
168: if RESPONSE:
1.16 dwinter 169: RESPONSE.redirect(self.absolute_url())
1.1 dwinter 170:
171:
1.2 dwinter 172: def unlockTest(self):
173: """unlock all files of the testuser for debuggin"""
174: for object in self.contents:
175:
176: if str(object.lockedBy)=="test":
177: object.lockedBy=""
178:
179: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
1.1 dwinter 180: """download all selected files in one file"""
1.2 dwinter 181:
1.1 dwinter 182: ret=""
1.2 dwinter 183: lockedObjects={}
184:
185:
186: if lock:
187:
188: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
189:
190: return "please login first"
191:
192: #check if a locked object exist in the basket.
193: lockedObjects={}
194: for object in self.contents:
195:
196: if not object.lockedBy=="":
197: lockedObjects[object.title]=repr(object.lockedBy)
198:
199:
200: keys=lockedObjects.keys()
201:
202:
203: if len(keys)>0 and (not procedure):
204: self.REQUEST.SESSION['lockedObjects']=lockedObjects
205: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
206: return pt()
207:
208: elif not procedure: #keine fails gesperrt dann alle donwloaden
209: procedure="downloadAll"
210:
1.16 dwinter 211:
1.1 dwinter 212: for object in self.contents:
1.2 dwinter 213:
214: if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
215: ret+=object.getLastVersion().data
216:
217: if lock and object.lockedBy=='':
218: object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
219:
1.1 dwinter 220:
221: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
222: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
1.2 dwinter 223: length=len(ret)
224: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
1.1 dwinter 225: self.REQUEST.RESPONSE.write(ret)
1.2 dwinter 226:
227:
1.4 dwinter 228: def manage_addBasket_oldObjectForm(self):
1.1 dwinter 229: """add form"""
230: pass
231:
1.4 dwinter 232: def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
1.1 dwinter 233: """add"""
234:
235: ob=BasketObject()
236:
237: ob.id=str(id)
238: ob.title=title
239: self._setObject(id, ob)
240: ob=self._getOb(id)
241:
242: if RESPONSE is not None:
243: RESPONSE.redirect('manage_main')
244:
1.4 dwinter 245:
246: class CDLIBasketContainer(OrderedFolder):
247: """contains the baskets"""
248:
249:
1.9 dwinter 250: security=ClassSecurityInfo()
1.4 dwinter 251: meta_type="CDLIBasketContainer"
252:
1.12 dwinter 253: def deleteBaskets(self,ids=None):
254: """delete baskets, i.e. move them into trash folder"""
255:
256:
257: found=self.ZopeFind(self,obj_ids=['trash'])
258:
259: if len(found)<1:
260: manage_addFolder(self, 'trash')
261: trash=self._getOb('trash')
262: else:
263: trash=found[0][1]
264:
265: if type(ids) is not ListType:
266: ids=[ids]
267: cut=self.manage_cutObjects(ids)
268: trash.manage_pasteObjects(cut)
269:
270: def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
271: """manage baskets, delete or copy"""
272: if submit=="delete":
273: self.deleteBaskets(ids)
274:
275:
276:
277: if RESPONSE:
278: RESPONSE.redirect(self.absolute_url())
1.5 dwinter 279: def getBasketIdfromName(self,basketname):
280: """get id from name"""
281:
282: for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
283: if basket[1].title==basketname:
284: return basket[0]
285: else:
286: None
1.9 dwinter 287:
288: security.declareProtected('manage','uploadBasket_html')
289:
1.4 dwinter 290: def uploadBasket_html(self,basketId='0'):
291: """upload an atf file, html form"""
1.9 dwinter 292:
293:
1.4 dwinter 294: basketId=str(basketId)
295: if not basketId=='0':
296: basketName=getattr(self.basketContainer,basketId).title
297: else:
298: basketName=""
299:
300: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
301: return pt(basketId=basketId,basketName=basketName)
302:
303:
304:
305: def index_html(self):
306: """stanadard ansicht"""
1.9 dwinter 307:
308:
309:
1.4 dwinter 310: ext=self.ZopeFind(self,obj_ids=["index.html"])
311: if ext:
312: return ext[0][1]()
313:
314: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
315: return pt()
316:
317: def getStorageFolderRoot(self):
318: """root des storage folders"""
319: return self.cdli_main
320:
321: def __init__(self,id,title):
322: """ init basket container"""
323: self.id=id
324: self.title=title
325:
326:
327: def getBaskets(self,sortField='title'):
328: """get all baskets files"""
329:
330: def sortName(x,y):
331: return cmp(x[1].title.lower(),y[1].title.lower())
332:
333: def sortDate(x,y):
334: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
335:
336:
337: def sortComment(x,y):
338:
339:
340:
341: try:
342: xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
343: except:
344: xc='ZZZZZZZZZZZZZ'.lower()
345: try:
346: yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
347: except:
348: yc='ZZZZZZZZZZZZZ'.lower()
349:
350:
351: if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
352:
353: try:
354: xc=x[1].getLastVersion().getComment().lower()
355: except:
356: xc='ZZZZZZZZZZZZZ'.lower()
357:
358: if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
359: try:
360: yc=y[1].getLastVersion().getComment().lower()
361: except:
362: yc='ZZZZZZZZZZZZZ'.lower()
363:
364:
365: return cmp(xc,yc)
366:
367: def sortAuthor(x,y):
368:
369: return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
370:
371: baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
372:
373:
374: if sortField=='title':
375: baskets.sort(sortName)
376: elif sortField=='date':
377: baskets.sort(sortDate)
378: elif sortField=='author':
379: baskets.sort(sortAuthor)
380: elif sortField=='comment':
381: baskets.sort(sortComment)
382:
383: return baskets
384:
385:
386:
387: def getNewId(self):
388: """createIds"""
389: last=getattr(self,'last',0)
390: last +=1
391: while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
392: last+=1
393:
394: self.last=last
395: return last
396:
1.6 dwinter 397: def setActiveBasket(self,basketId,REQUEST=None):
1.4 dwinter 398: """store active basketId in a cookie"""
399: self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
1.12 dwinter 400:
1.6 dwinter 401: if REQUEST:
1.12 dwinter 402: REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])
1.6 dwinter 403:
1.4 dwinter 404: def getActiveBasket(self):
405: """get active basket from cookie"""
406:
407: id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
1.6 dwinter 408: if id:
409: obj=getattr(self,str(id),None)
410: else:
411: obj=None
1.4 dwinter 412: return obj
1.6 dwinter 413:
1.4 dwinter 414: def getActualUserName(self):
415: """get name of the actualuser"""
416: return str(self.REQUEST['AUTHENTICATED_USER'])
417:
418:
419: def addBasket(self,newBasketName):
420: """add a new basket"""
421:
422: ob=manage_addCDLIBasket(self,newBasketName)
423: return ob
424:
1.6 dwinter 425: def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
1.4 dwinter 426: """store it"""
1.6 dwinter 427: if not ids:
428: ids=self.REQUEST.SESSION['fileIds']
429:
1.4 dwinter 430: if type(ids) is not ListType:
431: ids=[ids]
432:
1.6 dwinter 433: if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
1.4 dwinter 434: basketRet=self.addBasket(newBasketName)
435: self.setActiveBasket(basketRet.getId())
436: basket=getattr(self,basketRet.getId())
1.6 dwinter 437: elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
1.4 dwinter 438: basket=self.getActiveBasket()
1.6 dwinter 439:
440: added=basket.addObjects(ids)
441: back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
442:
443:
444: if fromFileList:
1.7 dwinter 445:
1.6 dwinter 446: return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
447:
1.4 dwinter 448: if RESPONSE:
1.6 dwinter 449:
1.4 dwinter 450: RESPONSE.redirect(back)
451:
1.6 dwinter 452: return True
453:
1.4 dwinter 454: def manage_addCDLIBasketContainerForm(self):
455: """add the CDLIBasketContainer form"""
456: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
457: return pt()
458:
459: def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
460: """add the basket"""
461: ob=CDLIBasketContainer(id,title)
462:
463: self._setObject(id, ob)
464:
465: if RESPONSE is not None:
466: RESPONSE.redirect('manage_main')
467:
1.5 dwinter 468: class CDLIBasket(Folder,CatalogAware):
1.4 dwinter 469: """basket"""
470:
471: meta_type="CDLIBasket"
1.5 dwinter 472: default_catalog="CDLIBasketCatalog"
1.4 dwinter 473:
474: def getFile(self,obj):
475: return obj[1]
476:
477: def getFileLastVersion(self,obj):
478: return obj[0]
479:
1.5 dwinter 480: def getFileNamesInLastVersion(self):
481: """get content of the last version as list"""
482:
483: return [x[1].getId() for x in self.getLastVersion().getContent()]
484:
1.4 dwinter 485: def isActual(self,obj):
486: """teste ob im basket die aktuelle version ist"""
487: actualNo=obj[1].getLastVersion().getVersionNumber()
488: storedNo=obj[0].getVersionNumber()
1.12 dwinter 489:
490: founds=self.CDLICatalog.search({'title':obj[0].getId()})
491: if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
492: return False, -1
493:
1.4 dwinter 494: if actualNo==storedNo:
1.12 dwinter 495: return True , 0
1.4 dwinter 496: else:
1.12 dwinter 497: return False, actualNo
1.4 dwinter 498:
499: def history(self):
500: """history"""
501:
502: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
503: if ext:
504: return getattr(self,ext[0][1].getId())()
505:
506: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)
507: return pt()
508:
509: def getStorageFolderRoot(self):
510: """root des storage folders"""
511: return self.aq_parent.cdli_main
512:
513: def __init__(self,id,title,shortDescription="",comment=""):
514: """init a CDLIBasket"""
515:
516: self.id=id
517: self.title=title
518: self.shortDescription=shortDescription
519: self.comment=comment
520:
521:
522:
523: def getLastVersion(self):
524: """hole letzte version"""
525: ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]
526: ids.sort()
527: if len(ids)==0:
528: return None
529: else:
530: ob=getattr(self,str(ids[-1]))
531: return ob
532:
533: def getVersions(self):
534: """get versions"""
535: versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
536: return versions
537:
538:
539:
540: def addObjects(self,ids,deleteOld=None):
541: """generate a new version of the basket with objects added"""
542:
543: lastVersion=self.getLastVersion()
544:
545: if lastVersion is None:
546: oldContent=[]
547: else:
548: oldContent=lastVersion.basketContent[0:]
549:
550: if deleteOld:
551: oldContent=[]
552:
553: newContent=[]
1.6 dwinter 554: added=0
1.4 dwinter 555: for id in ids:
556: founds=self.CDLICatalog.search({'title':id})
1.6 dwinter 557:
1.4 dwinter 558: for found in founds:
559: if found.getObject() not in oldContent:
560: #TODO: was passiert wenn, man eine Object dazufgt, das schon da ist aber eine neuere version
561: newContent.append((found.getObject().getLastVersion(),found.getObject()))
1.6 dwinter 562: added+=1
1.4 dwinter 563:
564: content=oldContent+newContent
565:
566: user=self.getActualUserName()
567:
568: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
569:
1.6 dwinter 570: return added
1.4 dwinter 571:
1.12 dwinter 572: def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
1.4 dwinter 573: """delete objects"""
1.12 dwinter 574:
575: if type(ids) is not ListType:
576: ids=[ids]
577:
578: lastVersion=self.getLastVersion()
579: oldContent=lastVersion.basketContent[0:]
580: newContent=[]
581: for obj in oldContent:
582: if obj[1].getId() not in ids:
583: newContent.append(obj)
584:
585:
586: user=self.getActualUserName()
587:
588: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
589:
590: if RESPONSE:
591: obj=self._getOb(ob.getId())
592: RESPONSE.redirect(obj.absolute_url())
1.4 dwinter 593:
594: def manage_addCDLIBasketForm(self):
595: """add the CDLIBasketContainer form"""
596: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
597: return pt()
598:
599: def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
600: """add the basket"""
601:
602: id=str(self.getNewId())
603:
604: ob=CDLIBasket(id,title,shortDescription,comment)
605:
606: self._setObject(id, ob)
607:
608: if RESPONSE is not None:
609: RESPONSE.redirect('manage_main')
610: else:
611: return ob
612:
613: class CDLIBasketVersion(SimpleItem):
614: """version of a basket"""
615:
616: meta_type="CDLIBasketVersion"
617:
618: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
619: """download all selected files in one file"""
620:
621: ret=""
622: lockedObjects={}
623:
624:
625: if lock:
626:
627: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
628:
629: return "please login first"
630:
631: #check if a locked object exist in the basket.
632: lockedObjects={}
633: for object in self.basketContent:
634:
635: if not object[1].lockedBy=="":
636: lockedObjects[object[1].title]=repr(object[1].lockedBy)
637:
638:
639: keys=lockedObjects.keys()
640:
641:
642: if len(keys)>0 and (not procedure):
643: self.REQUEST.SESSION['lockedObjects']=lockedObjects
644: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
645: return pt()
646:
647: elif not procedure: #keine fails gesperrt dann alle donwloaden
648: procedure="downloadAll"
649:
650:
651: for object in self.basketContent:
652:
653: if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
654: ret+=object[0].data
655:
656: if lock and object[1].lockedBy=='':
657: object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
658:
659: basket_name=self.aq_parent.title+"_V"+self.getId()
660:
661: #write basketname to header of atf file
662: ret="#atf basket %s\n"%basket_name+ret
663:
664: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
665: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
666: length=len(ret)
667: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
668: self.REQUEST.RESPONSE.write(ret)
669:
670:
671: def numberOfItems(self):
672: """return anzahl der elemente im basket"""
673: return len(self.basketContent)
674:
675: def getTime(self):
676: """getTime"""
677: #return self.bobobase_modification_time().ISO()
678:
679: if hasattr(self,'time'):
680: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
681: elif hasattr(self,'timefixed'):
682: return self.timefixed
683: else:
684: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
685: return self.bobobase_modification_time().ISO()
686:
687: def getContent(self):
688: """get Basket Content"""
689: return self.basketContent
690:
691:
692: def __init__(self,id,user,comment="",basketContent=[]):
693: """ init a basket version"""
694: self.id=id
695: self.coment=comment
696: self.basketContent=basketContent[0:]
697: self.user=user
698: self.time=time.localtime()
699:
700: def getUser(self):
701: """get user"""
702: return self.user
703:
704: def getComment(self):
705: """get Comment"""
706: return self.comment
707:
708: def index_html(self):
709: """view the basket"""
710: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
711: return pt()
712:
713: def getObjUrl(self,result):
714: """getUrl of the version of the object"""
715: objId=result[1].getTitle()
716: founds=self.CDLICatalog.search({'title':objId})
717: if len(founds)>0:
1.12 dwinter 718: return founds[0].getObject().getLastVersion().absolute_url()
1.4 dwinter 719:
720: else: #assume version number
721: splitted=objId.split("_")
1.9 dwinter 722: founds=self.CDLICatalog.search({'title':splitted[1]})
1.12 dwinter 723: return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId
1.4 dwinter 724:
725: def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
726: """add a version"""
727:
728: #check for already existing versions
729:
730: lastVersion=self.getLastVersion()
731: if lastVersion is None:
732: newId=str(1)
733: else:
734: newId=str(int(lastVersion.getId())+1)
735:
736: ob=CDLIBasketVersion(newId,user,comment,basketContent)
737:
738: self._setObject(newId, ob)
739:
740: if RESPONSE is not None:
741: RESPONSE.redirect('manage_main')
742: else:
743: return ob
744:
1.1 dwinter 745: class CDLIFileObject(versionedFileObject):
746: """CDLI file object"""
747:
748: meta_type="CDLI File Object"
749:
1.12 dwinter 750: security=ClassSecurityInfo()
751:
1.1 dwinter 752: def view(self):
753: """view file"""
754: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
755: return pt()
756:
1.12 dwinter 757: security.declarePublic('getDesignation')
758: def getDesignation(self):
759: """get the designation out of the file"""
1.16 dwinter 760: try:
1.18 ! dwinter 761: txt=re.match("&[Pp](\d*)\s*=([^\r\n]*)",self.data[0:])
1.13 dwinter 762: except:
1.16 dwinter 763: txt=self.data[0:]
764:
765: return "ERROR"
1.12 dwinter 766: try:
767: return txt.group(2)
768: except:
769: return "ERROR"
770:
1.1 dwinter 771: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
772:
773: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
774: REQUEST=None):
775: """Add a new File object.
776:
777: Creates a new File object 'id' with the contents of 'file'"""
778:
779: id=str(id)
780: title=str(title)
781: content_type=str(content_type)
782: precondition=str(precondition)
783:
784: id, title = cookId(id, title, file)
785:
786: self=self.this()
787:
788: # First, we create the file without data:
789: self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
790: self._getOb(id).versionComment=str(vC)
791: self._getOb(id).time=time.localtime()
792:
793: setattr(self._getOb(id),'author',author)
794:
795: # Now we "upload" the data. By doing this in two steps, we
796: # can use a database trick to make the upload more efficient.
797: if file:
798: self._getOb(id).manage_upload(file)
799: if content_type:
800: self._getOb(id).content_type=content_type
801:
802: if REQUEST is not None:
803: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
1.3 dwinter 804:
805: class CDLIFile(versionedFile,CatalogAware):
806: """CDLI file"""
807:
808: meta_type="CDLI file"
809: default_catalog='CDLICatalog'
1.5 dwinter 810:
1.8 dwinter 811:
1.12 dwinter 812:
1.8 dwinter 813: def isContainedInBaskets(self,context=None):
814: """check is this file is part of any basket
815: @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
816: has to exist.
817: """
818:
819: if not context:
820: context=self
1.12 dwinter 821:
822: ret=[]
823: for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()}):
824: #if the basket x is deleted it seemes to be that x is sometimes still in the Catalog, why?
825: try:
826: ret.append(x.getObject())
827: except:
828: pass
829: return ret
830: #return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
1.5 dwinter 831:
832:
833: def addCDLIFileObjectForm(self):
834: """add a new version"""
835:
836: if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
837: return "please login first"
838: if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
839: out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
840: return out()
841: else:
842: return "Sorry file is locked by somebody else"
843:
1.3 dwinter 844: def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
845: """add"""
846: try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
847: vC=self.REQUEST['vC']
848: except:
849: pass
850:
851:
852: if changeName=="yes":
853: filename=file.filename
854: self.title=filename[max(filename.rfind('/'),
855: filename.rfind('\\'),
856: filename.rfind(':'),
857: )+1:]
858:
859:
860: if not newName=='':
861: self.title=newName[0:]
862:
863:
864:
865:
866:
867: positionVersionNum=getattr(self,'positionVersionNum','front')
868:
869: if positionVersionNum=='front':
870: id="V%i"%self.getVersion()+"_"+self.title
871: else:
872: tmp=os.path.splitext(self.title)
873: if len(tmp)>1:
874: id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]
875: else:
876: id=tmp[0]+"_V%i"%self.getVersion()
877:
878:
879: manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
880: objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
881: self.REQUEST.SESSION['objID_parent']=self.getId()
882:
883: if RESPONSE:
884: obj=self.ZopeFind(self,obj_ids=[id])[0][1]
885: if obj.getSize()==0:
886: self.REQUEST.SESSION['objID']=obj.getId()
887: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
888: return pt()
889:
890: else:
1.12 dwinter 891: RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)
1.3 dwinter 892:
893: else:
894: return self.ZopeFind(self,obj_ids=[id])[0][1]
895:
896:
897: def manage_addCDLIFileForm(self):
898: """interface for adding the OSAS_root"""
899: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
900: return pt()
901:
902: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
903: """add the OSAS_root"""
904: newObj=CDLIFile(id,title,lockedBy,author)
905: self._setObject(id,newObj)
906:
907: if RESPONSE is not None:
908: RESPONSE.redirect('manage_main')
909:
910:
1.1 dwinter 911:
912:
1.2 dwinter 913: def splitatf(fh,dir=None):
914: """split it"""
1.4 dwinter 915: ret=None
1.2 dwinter 916: nf=None
917: for line in fh.readlines():
1.4 dwinter 918: #check if basket name is in the first line
919: if line.find("#atf basket")>=0:
920: ret=line.replace('#atf basket ','')
1.5 dwinter 921: ret=ret.split('_')[0]
1.4 dwinter 922: else:
923: if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
924: if nf:
925: nf.close() #close last file
926:
927:
928: filename=line[1:].split("=")[0].rstrip()+".atf"
929: if dir:
930: filename=os.path.join(dir,filename)
931: nf=file(filename,"w")
932: if nf:
933: nf.write(line)
1.2 dwinter 934:
935: nf.close()
936: fh.close()
1.5 dwinter 937: return ret,len(os.listdir(dir))
1.4 dwinter 938:
1.1 dwinter 939: class CDLIFileFolder(versionedFileFolder):
1.4 dwinter 940: """CDLI File Folder"""
1.1 dwinter 941:
942: meta_type="CDLI Folder"
943: filesMetaType=['CDLI file']
944: folderMetaType=['CDLI Folder']
945: default_catalog='CDLICatalog'
946:
1.12 dwinter 947: def delete(self,ids):
948: """delete this file, i.e. move into a trash folder"""
949:
950: found=self.ZopeFind(self,obj_ids=['.trash'])
951:
952: if len(found)<1:
953: manage_addCDLIFileFolder(self, '.trash',title="Trash")
954: trash=self._getOb('.trash')
955: else:
956: trash=found[0][1]
957:
958: if type(ids) is not ListType:
959: ids=[ids]
960: cut=self.manage_cutObjects(ids)
961: trash.manage_pasteObjects(cut)
962:
1.4 dwinter 963: def getVersionNumbersFromIds(self,ids):
964: """get the numbers of the current versions of documents described by their ids"""
965:
966: ret=[]
967: searchStr=" OR ".join(ids)
968:
1.9 dwinter 969: founds=self.CDLICatalog.search({'title':searchStr})
1.4 dwinter 970:
971: for found in founds:
972: lastVersion=found.getObject().getLastVersion()
973: ret.append((found.getId,lastVersion))
974:
975: return ret
976:
1.14 dwinter 977: def checkCatalog(self,fn):
978: """check if fn is in the catalog"""
979:
980:
1.4 dwinter 981: def uploadATF(self,upload,basketId=0,RESPONSE=None):
1.1 dwinter 982: """upload an atf file"""
1.3 dwinter 983: #TODO: add comments
1.2 dwinter 984: #TODO: finish uploadATF
1.4 dwinter 985: basketId=str(basketId)
986:
987:
988:
1.2 dwinter 989: dir=mkdtemp()
990: changed=[]
991: errors=[]
1.3 dwinter 992: newPs=[]
1.14 dwinter 993: psNotInCatalog=[]
1.4 dwinter 994: basketNameFromFile, numberOfFiles=splitatf(upload,dir)
1.9 dwinter 995:
996: if basketId == '0':
997: basketObj=self.basketContainer.getActiveBasket()
998: if basketObj:
999: basketId=basketObj.getId()
1000:
1.4 dwinter 1001: if basketId == '0':
1002: basketNameFromId=""
1003: basketLen=0
1004: else:
1005: basketNameFromId=getattr(self.basketContainer,basketId).title
1006: basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()
1007:
1008:
1.2 dwinter 1009: for fn in os.listdir(dir):
1.14 dwinter 1010:
1011: if self.checkCatalog(fn):
1012: psNotInCatalog.append(fn)
1013:
1014:
1.4 dwinter 1015: founds=self.CDLICatalog.search({'title':fn})
1016:
1.3 dwinter 1017: if len(founds)==0:
1018: newPs.append(fn)
1019:
1.2 dwinter 1020: for found in founds:
1021: obj=found.getObject()
1022:
1023: if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
1024: errors.append(obj)
1025: else:
1026: data=file(os.path.join(dir,fn)).read()
1027: diffs=obj.diff(data)
1028: if diffs[0]>0:
1029: changed.append((obj,diffs))
1030: #hochladen
1031:
1.3 dwinter 1032: self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]
1033: self.REQUEST.SESSION['errors']=[x.getId() for x in errors]
1034: self.REQUEST.SESSION['newPs']=newPs
1035: self.REQUEST.SESSION['tmpdir']=dir
1.4 dwinter 1036:
1.2 dwinter 1037: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
1.4 dwinter 1038: return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,
1039: basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)
1.2 dwinter 1040:
1.5 dwinter 1041: def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):
1.3 dwinter 1042: """upload the files"""
1043:
1044: if procedure=="uploadchanged":
1.16 dwinter 1045:
1046: uploadFns=self.REQUEST.SESSION.get('changed',[])+self.REQUEST.SESSION.get('newPs',[])
1.3 dwinter 1047:
1048: elif procedure=="uploadAll":
1049: uploadFns=[]
1050: for x in os.listdir(self.REQUEST.SESSION['tmpdir']):
1051: if not x in self.REQUEST.SESSION['errors']:
1052: uploadFns.append(x)
1.16 dwinter 1053: elif procedure=="noupload":
1054: if RESPONSE is not None:
1055: RESPONSE.redirect(self.aq_parent.absolute_url())
1056: return ""
1057: else:
1058: return ""
1.3 dwinter 1059: else:
1060: uploadFns=[]
1061:
1062: for fn in uploadFns:
1.9 dwinter 1063: founds=self.CDLICatalog.search({'title':fn})
1.3 dwinter 1064: if len(founds)>0:
1.9 dwinter 1065: self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])
1.16 dwinter 1066:
1.9 dwinter 1067: founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST.SESSION['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))
1.3 dwinter 1068:
1069:
1070:
1071: newPs=self.REQUEST.SESSION['newPs']
1072: if len(newPs)>0:
1073: tmpDir=self.REQUEST.SESSION['tmpdir']
1074:
1075: self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)
1076:
1.1 dwinter 1077:
1078:
1.3 dwinter 1079: #unlock
1080: if unlock:
1081: unlockFns=[]
1082: for x in os.listdir(self.REQUEST.SESSION['tmpdir']):
1083: if not x in self.REQUEST.SESSION['errors']:
1084: unlockFns.append(x)
1085:
1086: for fn in unlockFns:
1.9 dwinter 1087: founds=self.CDLICatalog.search({'title':fn})
1.3 dwinter 1088: if len(founds)>0:
1.9 dwinter 1089: self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])
1.3 dwinter 1090:
1091: founds[0].getObject().lockedBy=""
1092:
1.5 dwinter 1093: if not (basketname ==''):
1.11 dwinter 1094: basketId=self.basketContainer.getBasketIdfromName(basketname)
1.5 dwinter 1095:
1.9 dwinter 1096: if not basketId: # create new basket
1097: ob=self.basketContainer.addBasket(basketname)
1098: basketId=ob.getId()
1.11 dwinter 1099: basket=getattr(self.basketContainer,str(basketId))
1.4 dwinter 1100: ids=os.listdir(self.REQUEST.SESSION['tmpdir'])
1101: basket.addObjects(ids,deleteOld=True)
1102:
1.3 dwinter 1103: if RESPONSE is not None:
1104: RESPONSE.redirect(self.aq_parent.absolute_url())
1105:
1106:
1.7 dwinter 1107: def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
1.1 dwinter 1108: """findObjectsFromList (, TAB oder LINE separated)"""
1.15 dwinter 1109:
1110:
1.6 dwinter 1111: if upload: # list from file upload
1112: txt=upload.read()
1113: txt=txt.replace(",","\n")
1114: txt=txt.replace("\t","\n")
1.12 dwinter 1115: txt=txt.replace("\r","\n")
1.6 dwinter 1116: idsTmp=txt.split("\n")
1117: ids=[]
1118: for id in idsTmp: # make sure that no empty lines
1119: idTmp=id.lstrip().rstrip()
1120: if len(idTmp)>0:
1121:
1122: ids.append(idTmp)
1123:
1124: #self.REQUEST.SESSION['ids']=" OR ".join(ids)
1.12 dwinter 1125:
1.6 dwinter 1126: pt=getattr(self,'filelist.html')
1.7 dwinter 1127: self.REQUEST.SESSION['searchList']=ids
1.6 dwinter 1128: return pt(search=ids)
1.7 dwinter 1129:
1.6 dwinter 1130: if basketName:
1.7 dwinter 1131: #TODO: get rid of one of these..
1132:
1.6 dwinter 1133: pt=getattr(self,'filelist.html')
1.7 dwinter 1134: return pt(basketName=basketName,numberOfObjects=numberOfObjects)
1.6 dwinter 1135:
1.15 dwinter 1136: if list is not None: # got already a list
1.6 dwinter 1137: ret=[]
1138: for fileId in list:
1139: if len(fileId.split("."))==1:
1140: fileId=fileId+".atf"
1.12 dwinter 1141:
1.6 dwinter 1142: ret+=self.CDLICatalog({'title':fileId})
1.7 dwinter 1143: #TODO: get rid of one of these..
1.6 dwinter 1144: self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage
1.7 dwinter 1145: self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
1.6 dwinter 1146: return ret
1.1 dwinter 1147:
1.7 dwinter 1148: if start:
1149: RESPONSE.redirect("filelist.html?start:int="+str(start))
1.15 dwinter 1150:
1151: print "nothing"
1.18 ! dwinter 1152:
! 1153: #security.declareProtected('View','createAllFilesAsSingleFile')
1.1 dwinter 1154: def createAllFilesAsSingleFile(self,RESPONSE=None):
1155: """download all files"""
1156:
1157: def sortF(x,y):
1158: return cmp(x[0],y[0])
1159:
1160: catalog=getattr(self,self.default_catalog)
1161: #tf,tfilename=mkstemp()
1162:
1163:
1164: list=[(x.getId,x) for x in catalog()]
1165: list.sort(sortF)
1166:
1167: RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
1168: RESPONSE.setHeader("Content-Type","application/octet-stream")
1169:
1170: for l in list:
1171: obj=l[1].getObject()
1172:
1173: if obj.meta_type=="CDLI file":
1174:
1175: #os.write(tf,obj.getLastVersion().data)
1176: if RESPONSE:
1.13 dwinter 1177: RESPONSE.write(obj.getLastVersion().data[0:])
1.1 dwinter 1178: #os.close(tf)
1179: #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
1180: return True
1181:
1182: def downloadFile(self,fn):
1183: """download fn - not used yet"""
1184: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
1185: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
1186: self.REQUEST.RESPONSE.write(file(fn).read())
1187:
1188:
1189:
1190: def hasParent(self):
1191: """returns true falls subfolder"""
1192:
1193: if self.aq_parent.meta_type in self.folderMetaType:
1194: return True
1195: else:
1196: return False
1197:
1198: def getFolders(self):
1199: """get all subfolders"""
1200: ret=[]
1201: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
1202: for folder in folders:
1203: ret.append((folder[1],
1204: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
1205: len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
1206: ))
1207: return ret
1208:
1209:
1210: def getFolders_OLD(self):
1211: """get all subfolders"""
1212: ret=[]
1213: folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
1214: for folder in folders:
1215: ret.append((folder[1],
1216: len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
1217: len(getattr(self,self.default_catalog)({'path':folder[0]}))
1218: ))
1219: return ret
1220:
1221: def index_html(self):
1222: """main"""
1223: ext=self.ZopeFind(self,obj_ids=["index.html"])
1224: if ext:
1225: return ext[0][1]()
1226:
1227: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
1228: return pt()
1229:
1.3 dwinter 1230: def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None):
1.1 dwinter 1231: """import files"""
1232:
1.3 dwinter 1233: if not files:
1234: files=os.listdir(folderName)
1235:
1.1 dwinter 1236: for f in files:
1237: folder=f[0:3]
1238: f2=f[0:5]
1239: obj=self.ZopeFind(self,obj_ids=[folder])
1240:
1241: if not obj:
1242: manage_addCDLIFileFolder(self,folder,folder)
1243: fobj=getattr(self,folder)
1244:
1245: else:
1246: fobj=obj[0][1]
1247:
1248: obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
1249:
1250: if not obj2:
1251: manage_addCDLIFileFolder(fobj,f2,f2)
1252: fobj2=getattr(fobj,f2)
1253:
1254: else:
1255: fobj2=obj2[0][1]
1256:
1257: file2=file(os.path.join(folderName,f))
1258: id=f
1259: manage_addCDLIFile(fobj2,f,'','')
1260: id=f
1261: ob=fobj2._getOb(f)
1262: ob.title=id
1263:
1264: manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
1.3 dwinter 1265: self.CDLICatalog.catalog_object(ob)
1266: #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
1267: #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
1268:
1269: return "ok"
1.1 dwinter 1270:
1271: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
1272:
1273:
1274: def manage_addCDLIFileFolder(self, id, title='',
1275: createPublic=0,
1276: createUserF=0,
1277: REQUEST=None):
1278: """Add a new Folder object with id *id*.
1279:
1280: If the 'createPublic' and 'createUserF' parameters are set to any true
1281: value, an 'index_html' and a 'UserFolder' objects are created respectively
1282: in the new folder.
1283: """
1284: ob=CDLIFileFolder()
1285: ob.id=str(id)
1286: ob.title=title
1287: self._setObject(id, ob)
1288: ob=self._getOb(id)
1289:
1290: checkPermission=getSecurityManager().checkPermission
1291:
1292: if createUserF:
1293: if not checkPermission('Add User Folders', ob):
1294: raise Unauthorized, (
1295: 'You are not authorized to add User Folders.'
1296: )
1297: ob.manage_addUserFolder()
1298:
1299:
1300: if REQUEST is not None:
1301: return self.manage_main(self, REQUEST, update_menu=1)
1302:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to cdli_files.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / cdli