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