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