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