1: """This contains the class MPIWG Projects
2: for organizing and maintaining the different project pages
3:
4: $author dwinter - last change 26.06.2008
5:
6: """
7: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
8: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
9: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
10: from Products.MPIWGBibliography.BibliographyManager import BibliographyManager
11: from OFS.Image import Image
12: from Globals import package_home
13: import urllib
14: import re
15: import os
16: import email
17: from types import *
18: import logging
19: import xmlhelper # Methoden zur Verwaltung der projekt xml
20: from OFS.SimpleItem import SimpleItem
21: from OFS.Folder import Folder
22: from OFS.Image import Image
23: from AccessControl import ClassSecurityInfo
24: from AccessControl import getSecurityManager
25: from bibliography import *
26: import time
27: from OFS.Cache import Cacheable
28: #import xml.dom.minidom
29: import sys
30: #from Ft.Xml.XPath import Evaluate
31: #from Ft.Xml.XPath.Context import Context
32: #from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
33: #from Ft.Xml import EMPTY_NAMESPACE
34: #import copy
35: #import updatePersonalWWW
36:
37: #import MPIWGStaff
38:
39: from MPIWGHelper import *
40:
41: import MPIWGRoot
42: import MPIWGLink
43: import MPIWGTemplate
44:
45: # die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus Kompatibilitaetsgruenden, bleiben die Klassen hier noch drin.
46: # Sonst funktionieren die alten Webseiten nicht mehr.
47:
48: class MPIWGRoot(MPIWGRoot.MPIWGRoot):
49: """depricated"""
50:
51: class MPIWGLink(MPIWGLink.MPIWGLink):
52: """depricated"""
53:
54: class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
55: """depricated"""
56:
57: class MPIWGProject_publication(Folder):
58: """publications object fuer project"""
59:
60: meta_type="MPIWGProject_publication"
61: def redirect(self,RESPONSE,url):
62: """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
63:
64: timeStamp=time.time()
65:
66: if url.find("?")>-1: #giebt es schon parameter
67: addStr="&time=%s"
68: else:
69: addStr="?time=%s"
70:
71: RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
72: logging.debug(email.Utils.formatdate()+' GMT')
73: RESPONSE.redirect(url+addStr%timeStamp)
74:
75: def editPublication(self,text=None,image1=None,image2=None,description=None,RESPONSE=None):
76: """edit a publication"""
77:
78: if (not text) and (not description):
79: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
80: return pt()
81:
82:
83: self.text=text[0:]
84: self.description=description
85:
86: if image1:
87: if hasattr(self,'publicationImage1'):
88: self.publicationImage1.manage_upload(image1)
89: else:
90: nO = Image('publicationImage1','',image1)
91: self._setObject('publicationImage1',nO)
92:
93: if image2:
94: if hasattr(self,'publicationImage2'):
95: self.publicationImage2.manage_upload(image2)
96: else:
97: nO = Image('publicationImage2','',image2)
98: self._setObject('publicationImage2',nO)
99:
100:
101: if RESPONSE:
102: self.redirect(RESPONSE,"../managePublications")
103:
104: class MPIWGProject_image(Image):
105: """Images for Projects"""
106:
107: meta_type="MPIWGProject_image"
108:
109: def showImage(self,imageUrl=None):
110: """show Images at an extra page"""
111: self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
112: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
113: return pt()
114:
115: def editImage(self,file=None,caption=None,RESPONSE=None):
116: """edit the Image"""
117: if (not file) and (not caption):
118: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
119: return pt()
120:
121: if file and (not file.filename.lstrip().rstrip()==""):
122: self.manage_upload(file)
123:
124: if caption:
125: self.caption=caption[0:]
126:
127: if RESPONSE:
128:
129: self.redirect(RESPONSE,"../manageImages")
130:
131: class MPIWGProject(CatalogAware,Folder,Cacheable):
132: """Class for Projects"""
133:
134:
135: security=ClassSecurityInfo()
136: meta_type='MPIWGProject'
137: default_catalog='ProjectCatalog'
138: def redirect(self,RESPONSE,url):
139: """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
140:
141: timeStamp=time.time()
142:
143: if url.find("?")>-1: #giebt es schon parameter
144: addStr="&time=%s"
145: else:
146: addStr="?time=%s"
147:
148: RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
149: logging.debug(email.Utils.formatdate()+' GMT')
150: RESPONSE.redirect(url+addStr%timeStamp)
151:
152: def decode(self,str):
153: """return unicode object"""
154: return unicodify(str)
155:
156: def sortedByPlace(self,metatype):
157: """find metatype and sort by place"""
158: def sort(x,y):
159: return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
160:
161: founds=self.ZopeFind(self,obj_metatypes=[metatype]);
162:
163: founds.sort(sort)
164:
165: return founds
166:
167:
168: def copyPublicationsToList(self,RESPONSE=None):
169: """copy publications in to list"""
170:
171: publicationTxt=self.getContent('WEB_related_pub')
172:
173: pubSplits=publicationTxt.split("<p>")
174:
175: for pubSplit in pubSplits:
176: pubSplit=pubSplit.replace("</p>","")
177: self.addPublication(pubSplit)
178:
179: if RESPONSE:
180:
181: self.redirect(RESPONSE,'managePublications')
182:
183:
184: def copyImageToMargin(self,RESPONSE=None):
185: """copy inline images to marginal images"""
186:
187:
188: #getImages from WEB_project_description
189: description=self.getContent('WEB_project_description')
190:
191: text2=description
192: splitted=text2.split("""<p class="picture">""")
193:
194: imageURLs=[]
195: imageCaptions=[]
196: for split in splitted[1:]:
197: tmp=split.split("</p>")
198: #return repr(splitted[1])
199:
200: try:
201: imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
202: except:
203:
204: try:
205: imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
206: except:
207: imageURLs.append("")
208:
209: split2="</p>".join(tmp[1:])
210:
211:
212: splitted=split2.split("""<p class="picturetitle">""")
213: if len(splitted)>1:
214: tmp=splitted[1].split("</p>")
215: imageCaptions.append(tmp[0].encode('utf-8'))
216:
217:
218: else:
219: #keine caption
220:
221: imageCaptions.append("")
222:
223:
224: #eintragen:
225: for imageURL in imageURLs:
226: filename=imageURL.split("/")[-1]
227: #lege neues images object an, mit leerem bild
228:
229: if self.ZopeFind(self,obj_ids=[filename]):
230: #existiert das bild schon, dann neuen filenamen
231: filename="project_image_"+filename
232:
233: self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
234: #hole die bilddaten aus der url
235: url=self.absolute_url()+"/"+imageURL
236: #url=self.absolute_url()+"/"+filename
237:
238: try:#relative url
239: data=urllib.urlopen(url).read()
240: except:
241: try:#absolute
242: data=urllib.urlopen(self.imageURL).read()
243: except:
244: logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
245:
246: obj=getattr(self,filename)
247: obj.update_data(data)
248:
249: if RESPONSE:
250:
251: self.redirect(RESPONSE,'manageImages')
252:
253: def manageImages(self,imageName=None,op=None):
254: """managage images"""
255:
256:
257: if imageName and op:
258: if op=='up':
259: images=self.getImages()
260: for image in images:
261: if image[0]==imageName:
262: nr=images.index(image)
263: if not nr==0:
264: images[nr-1][1].place+=1
265: images[nr][1].place-=1
266: pass
267: elif op=='down':
268: images=self.getImages()
269: for image in images:
270: if image[0]==imageName:
271: nr=images.index(image)
272: if not (nr==len(images)-1):
273: images[nr+1][1].place-=1
274: images[nr][1].place+=1
275: pass
276:
277:
278: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
279: return pt()
280:
281: def managePublications(self,pubName=None,op=None):
282: """managage images"""
283:
284:
285: if pubName and op:
286: if op=='up':
287: publications=self.getPublications()
288: for publication in publications:
289: if publication[0]==pubName:
290: nr=publications.index(publication)
291: if not nr==0:
292: publications[nr-1][1].place+=1
293: publications[nr][1].place-=1
294: pass
295: elif op=='down':
296: publications=self.getPublications()
297: for publication in publications:
298: if publication[0]==pubName:
299: nr=publications.index(publication)
300: if not (nr==len(publications)-1):
301: publications[nr+1][1].place-=1
302: publications[nr][1].place+=1
303: pass
304:
305:
306: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
307: return pt()
308: def hasExtendedPublicationList(self):
309: """test if extended publication list exists"""
310: if not hasattr(self,"publicationList"):
311: return False
312: else:
313: return True
314:
315: def createExtendedPublicationList(self,RESPONSE=None):
316: """erzeuge erweiterte publications liste"""
317: pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
318: self._setObject("publicationList", pl)
319:
320:
321: zt=ZopePageTemplate('index.html')
322: pl._setObject('index.html',zt)
323: default_content_fn = os.path.join(package_home(globals()),
324: 'zpt/showExtendedProjectBibliography.zpt')
325: text = open(default_content_fn).read()
326: zt.pt_edit(text, 'text/html')
327:
328:
329: if RESPONSE:
330: self.redirect(RESPONSE,"managePublications")
331:
332:
333: def getPublications(self):
334: """get all Publications"""
335: def sort_images(x,y):
336: return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
337:
338: publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
339:
340: publications.sort(sort_images)
341: return publications
342:
343: def addPublication(self,text,RESPONSE=None):
344: """add an MPIWG_Publication"""
345:
346: name="publication_"+str(self.getLastPublicationNumber()+1)
347:
348: newPublication=MPIWGProject_publication(name)
349:
350: self._setObject(name,newPublication)
351: obj=getattr(self,name)
352: obj.text=text[0:]
353: obj.enabled=True;
354: obj.place=self.getLastPublicationNumber()+1
355: obj.id=name
356:
357: if RESPONSE is not None:
358:
359: self.redirect(RESPONSE,'managePublications')
360:
361:
362: def getLastPublicationNumber(self):
363: publications=self.getPublications()
364:
365: if not publications:
366: return 0
367: else:
368: return getattr(publications[-1][1],'place',0)
369:
370: def deletePublication(self,id,RESPONSE=None):
371: """delete Publication id"""
372: self.manage_delObjects([id])
373: if RESPONSE:
374:
375: self.redirect(RESPONSE,'managePublications')
376:
377: def getImages(self):
378: """get all Images"""
379:
380: def sort_images(x,y):
381: return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
382:
383:
384: if (getattr(self,'imageURL','')!='') or (getattr(self,'imagecap','')!='') :
385: try:
386: self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
387: except:
388: pass
389: self.imageURL=''
390: self.imagecap=''
391:
392: images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
393:
394: images.sort(sort_images)
395: return images
396:
397: def getLastImageNumber(self):
398: images=self.getImages()
399:
400: if not images:
401: return 0
402: else:
403: return getattr(images[-1][1],'place',0)
404:
405: def deleteImage(self,id,RESPONSE=None):
406: """delete Image id"""
407: try:
408: self.manage_delObjects([id])
409: except:
410: logging.error("ERROR MPIWG: %s %s"%sys.exc_info()[0:2])
411: if RESPONSE:
412: self.redirect(RESPONSE,'manageImages')
413:
414:
415:
416: def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
417: """check if project has children"""
418:
419: ct=self.getContexts(childs=self.getContent('xdata_05'),
420: depth=1,date=date,onlyActive=onlyActive)
421:
422: if ct and len(ct)>0:
423: return True
424: else:
425: return False
426:
427:
428: def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
429: """add an MPIWG_Project_image"""
430:
431: if not filename:
432: filename=fileHd.filename
433:
434: if not fileHd:
435: fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
436:
437: newImage=MPIWGProject_image(filename,filename,fileHd)
438:
439: self._setObject(filename,newImage)
440: obj=getattr(self,filename)
441: obj.caption=caption[0:]
442: obj.enabled=True;
443: obj.place=self.getLastImageNumber()+1
444: obj.id=filename
445:
446: if RESPONSE is not None:
447:
448: self.redirect(RESPONSE,'manageImages')
449:
450: def PrincipiaSearchSource(self):
451: """Return cataloguable key for ourselves."""
452: return str(self)
453:
454: def versionHeader(self):
455: """version Header, gibt header text entsprechend der aktuellen version aus"""
456:
457: actualTime=time.localtime()
458: retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
459: s=self.aq_parent.absolute_url()
460: #print getattr(self,'archiveTime',actualTime)
461: if getattr(self,'archiveTime',actualTime)< actualTime:
462: return retTXT%(s,s)
463: else:
464: return ""
465:
466: def getActualVersion(self,date=None):
467: """actuelle version"""
468: def sortProjectsByTime(x,y):
469: return cmp(x[1].archiveTime,y[1].archiveTime)
470:
471: if not date:
472: if self.isActual():
473: return self
474: else:
475: return None
476:
477: #suche ob aeltere versionen vorhanden sind
478:
479: finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
480: if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
481: ad=getattr(self,'creationTime','20050101000000')
482: if int(date)>int(ad):
483: return self
484: else:
485: return None
486:
487:
488: else:
489: finds.sort(sortProjectsByTime)
490:
491: for find in finds:
492: #gehe durch die alten Projekte und finde das entprechende
493: if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
494: return find[1]
495:
496: #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
497: ad=getattr(self,'creationTime','20050101000000')
498:
499: if int(date)>int(ad):
500:
501: return self
502: else:
503: return None
504:
505:
506: def isActual(self):
507: """gibt 1 zurueck wenn aktuell, 0 sonst"""
508: actualTime=time.localtime()
509:
510:
511: #print getattr(self,'archiveTime',actualTime)
512: if getattr(self,'archiveTime',actualTime)< actualTime:
513: return 0
514: else:
515: return 1
516:
517: def copyObjectToArchive(self):
518: """kopiere aktuelles objekt ins archiv"""
519: cb=self.aq_parent.manage_copyObjects(self.getId())
520: self.manage_pasteObjects(cb)
521: actualTime=time.localtime()
522:
523: self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
524: obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
525: obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
526: ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
527: obj.manage_delObjects(ids)
528:
529: def setArchiveTime(self,time):
530: """set Archive Time"""
531: self.archiveTime=time[0:]
532:
533: def delArchiveTime(self):
534: """delete archive time"""
535: del self.archiveTime
536:
537: def versionManageForm(self):
538: """version Manage form:currently only set to invisible"""
539: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
540: return pt()
541:
542: def versionManage(self,invisible=None,RESPONSE=None):
543: """version Manage form:currently only set to invisible"""
544: self.invisible=invisible
545:
546: if RESPONSE is not None:
547:
548: self.redirect(RESPONSE,'manage_main')
549:
550:
551: def crossLinker(self):
552: """experimental crosslinker"""
553: splitted=self.WEB_project_description[0].split()
554: new=[]
555: for split in splitted:
556: try:
557: found=self.DescriptionCatalog({'fulltext':split})
558:
559: if len(found)>1:
560:
561: new.append("<a href=%s>%s</a>"%(split,split))
562: else:
563: new.append(split)
564: except:
565: new.append(split)
566: return " ".join(new)
567:
568:
569:
570:
571: def generateTemplate(self,RESPONSE=None):
572: """Erzeuge Template fuer defined fields not_used"""
573:
574: id="index_html"
575: title=id
576: if self._getOb('index_html'):
577: self._delObject('index_html')
578:
579:
580: newObj=ZopePageTemplate(id,'TEXT')
581: self._setObject(id,newObj)
582: #self.manage_addPageTemplate(id,title)
583: if RESPONSE is not None:
584: self.redirect(RESPONSE,'manage_main')
585:
586: def __init__(self, id, argv=None):
587: """initiere classe"""
588:
589: self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
590: self.id=id
591: self.title=id
592: self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
593: self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
594:
595: if argv:
596: for arg in definedFields:
597: try:
598: setattr(self,arg,argv[arg])
599: except:
600: setattr(self,arg,"")
601: else:
602: for arg in definedFields:
603: setattr(self,arg,'')
604:
605: manage_options = Folder.manage_options+(
606: {'label':'Load New File','action':'loadNewFileForm'},
607: {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
608: {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
609: {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
610: {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
611: {'label':'Versionmanager','action':'versionManageForm'},
612: )
613:
614:
615: def isActiveProject(self):
616: """check if the project is still active, default is true, set to false is the project is accomplished"""
617: return getattr(self,'isActiveFlag',True)
618:
619: def isArchivedProject(self):
620: """check if the project is archived"""
621:
622: completed=self.getCompletedAt()
623:
624: #completed leer
625: if completed=="" :
626: return False;
627: if completed == 0:
628: return False;
629:
630:
631: return True
632:
633:
634: def setActiveFlag(self,status=True):
635: """set the active flag"""
636: self.isActiveFlag=status
637:
638: def setCompletedAt(self,date):
639: """set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
640: #logging.info("DATE:"+repr(date))
641: transformedDate=self.transformDate(date);
642: #logging.info("transformed"+repr(transformedDate))
643: if transformedDate is not None:
644: setattr(self,"completedAt",transformedDate)
645: return True;
646: else:
647: return False;
648:
649: def setStartedAt(self,date):
650: """set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
651: #logging.info("DATE:"+repr(date))
652: transformedDate=self.transformDate(date);
653: #logging.info("transformed"+repr(transformedDate))
654: if transformedDate is not None:
655: setattr(self,"startedAt",transformedDate)
656: return True;
657: else:
658: return False;
659:
660: def getCompletedAt(self):
661: """gibt das transformierte Datum zurueck, an dem das Projekt beendet wurde."""
662: date=getattr(self,'completedAt','')
663:
664: if date:
665: return self.reTransformDate(date);
666: else:
667: return ""
668: # test ob parent abgeschlossen ist
669: try: #TODO: ersetzte try except durch vernuenftige abfrage
670: ct=self.getContexts(parents=self.getContent('xdata_05'),depth=1)
671: if (len(ct)>0): #is there are parent
672: return ct[0][0].getCompletedAt()
673: return '';
674: except:
675: return '';
676:
677: def getStartedAt(self):
678: """gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
679: date=getattr(self,'startedAt','')
680: if date:
681: return self.reTransformDate(date);
682: else:
683: return '';
684:
685: def reTransformDate(self,date):
686: """transformiert , transformdate zurueck"""
687: year=int(date/10000)
688: month=int((date-year*10000)/100)
689: day=int((date-year*10000-month*100))
690: if (day==0) and (month==0):
691: return """%s"""%year;
692: if day==0 :
693: return """%s.%s"""%(month,year);
694:
695: return """%s.%s.%s"""%(day,month,year);
696:
697:
698: def transformDate(self,date):
699: """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach YYYYMMDD, alle nicht angebebenn Werte
700: werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist"""
701:
702: if (date==None):
703: return None;
704:
705:
706: if (date.lstrip().rstrip()=="" ) :
707: return "";
708:
709: splitted=date.split(".")
710: length=len(splitted)
711: year=0
712: month=0
713: day=0
714: if length > 3:
715: return "";
716: if length==3:
717: day = int(splitted[0])
718: if length>1:
719: month=int(splitted[length-2])
720:
721: if length > 0:
722: try:
723: year = int(splitted[length-1])
724: except:
725: pass
726:
727: ## logging.info("month:"+(month))
728: if not (0<=month<13):
729: return None;
730:
731: if not(0<=day<32):
732: return None;
733:
734: if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
735: year=2000+year;
736: return year*10000+month*100+day
737:
738:
739:
740: def checkDate(self,date):
741: """teste ob zum Zeitpunkt date eine andere version existierte"""
742:
743:
744: def sortProjectsByTime(x,y):
745: return cmp(x[1].archiveTime,y[1].archiveTime)
746:
747: #suche ob aeltere versionen vorhanden sind
748:
749: finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
750: if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
751: ad=getattr(self,'creationTime','20050101000000')
752: if int(date)>int(ad):
753: return self.REQUEST['URL1']+"/"+self.getId()
754: else:
755: return self.REQUEST['URL1']+"/no_project"
756:
757:
758: else:
759: finds.sort(sortProjectsByTime)
760:
761: for find in finds:
762: #gehe durch die alten Projekte und finde das entprechende
763: if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
764: return self.REQUEST['URL1']+"/"+find[1].getId()
765:
766: #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
767: ad=getattr(self,'creationTime','20050101000000')
768:
769: if int(date)>int(ad):
770:
771: return self.REQUEST['URL1']+"/"+self.getId()
772: else:
773: return self.REQUEST['URL1']+"/no_project"
774:
775:
776: def no_project(self):
777: """warnung: project noch nicht existent"""
778: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
779: return pt()
780:
781:
782: def harvest_page(self,context=None):
783: """seite fuer harvesting fuer die Projektsuche"""
784: if not context:
785: context=self
786:
787: if self.isActiveProject() and self.isActual():
788: ext=getattr(self,"harvest_main",None)
789: if ext:
790: return getattr(self,ext.getId())()
791:
792: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)
793:
794:
795: return pt()
796:
797: def index_html(self,request=True,context=None):
798: """show homepage"""
799:
800: bound_names={}
801:
802: if not context:
803: context=self
804: if request:
805: if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
806: self.REQUEST.SESSION['MPI_redirected']=1
807: self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
808: else:
809: self.REQUEST.SESSION['MPI_redirected']=None
810:
811: #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
812:
813:
814: request2=getattr(self,'REQUEST',None)
815:
816: if request2 is not None:
817: response = request2.response
818: if not response.headers.has_key('content-type'):
819: response.setHeader('content-type', 'text/html')
820:
821: security = getSecurityManager()
822: bound_names['user'] = security.getUser()
823:
824:
825: # Retrieve the value from the cache.
826: keyset = None
827: if self.ZCacheable_isCachingEnabled():
828:
829: # Prepare a cache key.
830: keyset = {'here': self, 'params':request2['QUERY_STRING']}
831:
832: result = self.ZCacheable_get(keywords=keyset)
833:
834: if result is not None:
835: # Got a cached value.
836: return result
837:
838: pt = getTemplate(self, "project_main")
839: # Execute the template in a new security context.
840: security.addContext(self)
841:
842: try:
843: result = pt.pt_render(extra_context=bound_names)
844: if keyset is not None:
845: # Store the result in the cache.
846: self.ZCacheable_set(result, keywords=keyset)
847:
848: return result
849: finally:
850: security.removeContext(self)
851:
852:
853:
854: def index_html_old(self,request=True,context=None):
855: """show homepage"""
856: if not context:
857: context=self
858: if request:
859: if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
860: self.REQUEST.SESSION['MPI_redirected']=1
861: self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
862: else:
863: self.REQUEST.SESSION['MPI_redirected']=None
864:
865: #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
866:
867: ext=getattr(self,"project_main",None)
868: if ext:
869: return getattr(self,ext.getId())()
870:
871: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)
872:
873: return pt()
874:
875:
876: def getDataFields(self):
877: """giveListofDatafields"""
878: ret=[]
879: for x in range(1,14):
880: if not x in [6,10,9]: # not used fields
881: ret.append('xdata_%02i'%x)
882: return ret
883:
884: def getDefinedFields(self):
885: """show all defined fields"""
886:
887: return definedFields
888:
889: def getAttribute(self,field):
890: """get attrbiute"""
891: return getattr(self,field)
892:
893: def getContent(self,field,filter=None):
894: """Inhalt des Feldes"""
895:
896: if field=="short_title":
897: text = self.getContent("xdata_07")
898: if text=="":
899: text = self.getContent("WEB_title")
900: return text
901:
902: text=u''
903:
904: for x in getattr(self,field):
905:
906: try:
907: text +=x
908: except:
909: text = x
910:
911:
912:
913: try:
914: if text[len(text)-1]==";":
915: text=text[0:len(text)-1]
916:
917:
918: except:
919: pass
920:
921: if text=='': ## wozu die folgenden Zeilen??
922: text2=text
923: else:
924: text2=re.sub(r';([^\s])','; \g<1>',text)
925:
926: if field=="WEB_project_description":##Jedenfalls darf letzteres nicht gemacht werden, falls normaler text
927: text2=text
928:
929: #teste ob ergebnis leer und header dann nehme title
930:
931: if (text2=='') and (field=='WEB_project_header'):
932: return self.getContent('WEB_title')
933:
934: if filter:
935: splitted=text2.split("""<p class="picture">""")
936: if len(splitted)>1:
937: tmp=splitted[1].split("</p>")
938: #return repr(splitted[1])
939: try:
940: self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
941: except:
942: try:
943: self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
944: except:
945: self.imageURL=""
946:
947: split2="</p>".join(tmp[1:])
948:
949: text3=splitted[0]+split2
950:
951: splitted=text3.split("""<p class="picturetitle">""")
952: if len(splitted)>1:
953: tmp=splitted[1].split("</p>")
954: self.imagecap=tmp[0].encode('utf-8')
955:
956: split4="".join(tmp[1:])
957:
958: text5=splitted[0]+split4
959: else:
960: #keine caption
961: text5=text3
962: else:
963: #kein bild
964: text5=text2
965: else:
966: text5=text2
967:
968: #teste ob WEB_project_description und keine fuehrenden p tags
969: if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
970: text5= "<p>"+text5+"</p>"
971:
972:
973: #filter image
974:
975: text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
976: if (text5=="<br>") or (text5=="<br/>"):
977: text5=""
978:
979: #logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
980: return unicodify(text5)
981: #return utf8ify(text5) # return as utf-8 byte string
982:
983:
984: def showImagesOfPage(self,imageUrl=None):
985: """show Images of project"""
986: self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
987: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
988: return pt()
989:
990:
991: def show_html(self):
992: """simple index"""
993: #return "HI"
994: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
995: return pt()
996:
997: def saveFromPreview(self):
998: """save content aus preview"""
999: self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
1000: self.REQUEST.RESPONSE.redirect("./index.html")
1001:
1002: def saveEditedContent(self,kupu=None,preview=None):
1003: """save Edited content"""
1004:
1005: if preview:
1006: kupu=preview
1007: #find content of body tags
1008: start=kupu.find("<body>")
1009: end=kupu.find("</body>")
1010: newcontent= kupu[start+6:end]
1011:
1012: if preview:
1013:
1014: return self.preview(newcontent)
1015:
1016: self.copyObjectToArchive()
1017: self.ZCacheable_invalidate()
1018: self.WEB_project_description=newcontent[0:]
1019:
1020: self.REQUEST.RESPONSE.redirect("./index.html")
1021:
1022: return True
1023:
1024: security.declareProtected('View management screens','edit')
1025: def edit(self,western=None):
1026: """Edit pages"""
1027: if western:
1028: self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
1029:
1030:
1031: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
1032: return pt()
1033:
1034: edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
1035:
1036: def getPathStyle(self, path, selected, style=""):
1037: """returns a string with the given style + 'sel' if path == selected."""
1038:
1039: if path == selected:
1040: return style + 'sel'
1041: else:
1042: return style
1043:
1044: def getLabel(self):
1045: """returns label (or title) of this project"""
1046: l = self.getContent('xdata_07')
1047: if l:
1048: return l
1049: l = self.getContent('WEB_title')
1050: if l:
1051: return l
1052: return self.title
1053:
1054: def getBreadcrumbs(self):
1055: """return list of breadcrumbs from here to the root"""
1056: crumbs = []
1057: # skip direct parent Folder /projects/
1058: parent = self.aq_parent.aq_parent
1059: # get parents breadcrumbs
1060: if hasattr(parent, 'getBreadcrumbs'):
1061: crumbs = parent.getBreadcrumbs()
1062:
1063: # try to get acquisition URL from parent
1064: if hasattr(parent, 'absolute_url'):
1065: baseUrl = "%s/%s/"%(parent.absolute_url(), 'projects')
1066: else:
1067: baseUrl = "/en/research/projects/"
1068:
1069: # add in the internal project hierarchy
1070:
1071: ct=self.getContexts(parents=self.getContent('xdata_05'))
1072: # start with grandparents
1073: ct.reverse()
1074: for c in ct:
1075: label = shortenString(c[0].getLabel(), 13)
1076: crumbs.append((label, baseUrl+c[0].getId(), c[0]))
1077:
1078: # add this project
1079: crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
1080:
1081: return crumbs
1082:
1083: def getRootProject(self):
1084: """returns the root (=top level) project of the current project"""
1085:
1086: ct=self.getContexts(parents=self.getContent('xdata_05'))
1087: if len(ct) > 0:
1088: return ct[-1][0]
1089: else:
1090: return self
1091:
1092:
1093: def preview(self,description):
1094: """preview"""
1095: tmpPro=getattr(self,"previewTemplate",None)
1096: if not tmpPro:
1097: tmpPro=MPIWGProject("previewTemplate")
1098: self._setObject("previewTemplate",tmpPro)
1099: for field in definedFields:
1100: setattr(tmpPro,field,getattr(self,field))
1101: tmpPro.WEB_project_description=description[0:]
1102: tmpPro.invisible=True
1103: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
1104: return pt()
1105:
1106: #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
1107:
1108:
1109: def getWebProject_description(self):
1110: """get description"""
1111: debug= self.REQUEST.cookies.get("MP_debug_code",None)
1112:
1113: if debug and debug=="western":
1114: return """
1115: <html>
1116: <head>
1117: <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
1118: </head>
1119: <body>%s
1120: </html></body>
1121: """%self.WEB_project_description[0]
1122:
1123: return """
1124: <html>
1125: <head>
1126: <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
1127: </head>
1128: <body>%s
1129: </html></body>
1130: """%self.getContent('WEB_project_description')
1131:
1132:
1133:
1134: def editMPIWGProjectForm(self):
1135: """editform"""
1136: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
1137: return pt()
1138:
1139: def isResponsibleScientist(self,key):
1140: """teste ob eine Person in der Liste der respl. scientists auftaucht"""
1141: #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
1142:
1143:
1144: keys = [unicodify(x[1]) for x in getattr(self,"responsibleScientistsList",[])]
1145: #logging.error("RESP. SCIEN:%s"%getattr(self,"responsibleScientistsList",[]))
1146: #logging.error("RESP. SCIEN:%s"%unicodify(key))
1147:
1148: if unicodify(key) in keys:
1149: return True
1150: else:
1151: return False
1152:
1153: def getPersonKeyList(self):
1154: """gibt die key Liste der beteiligten Personen zurŸck (utf8 codiert)"""
1155: #logging.error("getPersonKeyList:%s"%getattr(self,'responsibleScientistsList',[]))
1156: try:
1157: return [utf8ify(x[1]) for x in getattr(self,'responsibleScientistsList',[])]
1158: except:
1159: return[]
1160:
1161:
1162: def myCapitalize(self,txt):
1163: """kapitalisiere auch Namen mit -"""
1164: splitted=[x.capitalize() for x in txt.split("-")]
1165: return "-".join(splitted)
1166:
1167: def getNamesOrdered(self,list):
1168: """Sortiert die Liste nach der Reihenfolge in xdata_01"""
1169:
1170: nameList=self.getContent('xdata_01')
1171: if nameList.find(";")>-1: # rate Trenner ist ;
1172: names=nameList.split(";")
1173: else:
1174: names=nameList.split(",")
1175:
1176: self._v_names=[]
1177: for name in names:
1178: self._v_names.append(name.rstrip().lstrip())
1179:
1180:
1181: def sort(x,y):
1182: try:
1183: return cmp(self._v_names.index(x[0]),self._v_names.index(y[0]))
1184: except:
1185: return 0
1186:
1187: list.sort(sort)
1188:
1189: return list
1190:
1191: ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
1192:
1193:
1194:
1195:
1196: def identifyNames(self,nameList):
1197: """Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
1198: und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
1199: @param nameList
1200: """
1201:
1202: if nameList.find(";")>-1: # rate Trenner ist ;
1203: names=nameList.split(";")
1204:
1205: else:
1206: names=nameList.split(",")
1207:
1208: ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
1209: returnNamesDict={}
1210:
1211:
1212: for name in names:
1213: name=name.lstrip().rstrip()
1214: nameSplitted = name.split(" ")
1215: if len(nameSplitted)>1: #vor und nachname angegeben)
1216:
1217: lastname=nameSplitted[-1]
1218: firstname=nameSplitted[0]
1219: else:
1220: firstname =""
1221: lastname=nameSplitted[0]
1222:
1223: #finde Mitarbeiter mit den entsprechenden Name
1224:
1225: firstname=self.myCapitalize(firstname).encode('utf-8')
1226: lastname=self.myCapitalize(lastname).encode('utf-8')
1227: logging.info("Search: %s %s %s"%(name,repr(firstname),repr(lastname)))
1228: try:
1229: cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
1230: except:
1231: cataloggedNames=[]
1232: logging.error("ERROR: identifyNames %s %s"%sys.exc_info()[0:2])
1233:
1234: #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
1235: #if not hasattr(self,'responsibleScientistsList'):
1236: # self.responsibleScientistsList={}
1237: #
1238: # if name in self.responsibleScientistsList.values()
1239:
1240: if len(cataloggedNames)>0:
1241: returnNamesDict[name]=cataloggedNames
1242: else:
1243: returnNamesDict[name]=[]
1244:
1245: logging.error("id: %s"%repr(returnNamesDict))
1246: return returnNamesDict
1247:
1248: def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
1249: """edit the project and archive the old version"""
1250:
1251: self.copyObjectToArchive() # archive the object
1252: self.ZCacheable_invalidate()
1253:
1254: for x in definedFields:
1255: if self.REQUEST.has_key(x):
1256:
1257: setattr(self,x,[self.REQUEST[x].decode('utf-8')])
1258:
1259:
1260:
1261:
1262: completedAt = self.REQUEST.get('completedAt')
1263: if not self.setCompletedAt(completedAt):
1264: RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
1265:
1266: startedAt = self.REQUEST.get('startedAt')
1267: if not self.setStartedAt(startedAt):
1268: RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
1269:
1270: if self.REQUEST.has_key('historicalNames'):
1271: self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
1272:
1273: if self.REQUEST.has_key('active'):
1274: self.setActiveFlag(True)
1275: else:
1276: self.setActiveFlag(False)
1277:
1278: self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
1279:
1280: names={}
1281: keys={}
1282: tmpList=[]
1283: for key in self.REQUEST.keys(): #gehe durch das Formular
1284: splitted=key.split("_")
1285: if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
1286: nr=splitted[2]
1287: if splitted[1]=="name":
1288: names[nr]=self.REQUEST[key]
1289: elif splitted[1]=="key":
1290: keys[nr]=self.REQUEST[key]
1291:
1292:
1293: for nr in names.keys():#schreibe keys und namen in die Liste, stelle ausserdem sicher, dass name unicode
1294: tmpList.append((unicodify(names[nr]),unicodify(keys.get(nr,""))))
1295:
1296: self.responsibleScientistsList=tmpList
1297: if fromEdit and (RESPONSE is not None):
1298: #RESPONSE.redirect('./editMPIWGBasisEditor')
1299: return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.decode(self.REQUEST.get('xdata_01',''))))
1300:
1301: else:
1302: if RESPONSE is not None:
1303: RESPONSE.redirect('manage_main')
1304:
1305:
1306:
1307: security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
1308: def editMPIWGDisciplinesThemesEditor(self):
1309: """edit from edit"""
1310: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
1311: return pt()
1312:
1313:
1314: def editMPIWGDisciplinesThemesForm(self):
1315: """edit the disciplines and themes Form"""
1316:
1317: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
1318: return pt()
1319:
1320: def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
1321: """edit disciplin and form"""
1322: if disciplines:
1323: if type(disciplines) is StringType:
1324: self.xdata_09=disciplines
1325: else:
1326: self.xdata_09=";".join(disciplines)
1327: else:
1328: self.xdata_09=""
1329: if themes:
1330: if type(themes) is StringType:
1331: self.xdata_10=themes
1332: else:
1333: self.xdata_10=";".join(themes)
1334: else:
1335: self.xdata_10=""
1336:
1337: if fromEdit and (RESPONSE is not None):
1338: self.redirect(RESPONSE,'./editMPIWGDisciplinesThemesEditor')
1339:
1340: else:
1341: if RESPONSE is not None:
1342: RESPONSE.redirect('manage_main')
1343:
1344:
1345: def isChecked(self,wert,list):
1346: """check if wert is in ; seperated list"""
1347:
1348: #felder sind manchmnal als liste mit einem element definiert
1349: if type(list) is StringType or UnicodeType:
1350: splitted=list.split(";")
1351: else:
1352: splitted=list[0].split(";")
1353:
1354: splitted=[y.rstrip().lstrip() for y in splitted]
1355:
1356: for x in splitted:
1357: x=re.sub(r"[^A-z ]","",x)
1358: if (not x==u'') and x in wert:
1359: return 1
1360: return 0
1361:
1362: security.declareProtected('View management screens','editMPIWGBasisEditor')
1363: def editMPIWGBasisEditor(self, identifiedNames=None):
1364:
1365: """editform"""
1366: if not identifiedNames:
1367: identifiedNames=self.identifyNames(self.getContent('xdata_01'))
1368: # identifiedNames=self.getFullNameEntries()
1369:
1370: logging.error("IdentifiedNames: %s"% repr(identifiedNames))
1371: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
1372: return pt(identifiedNames=identifiedNames)
1373:
1374: security.declareProtected('View management screens','editMPIWGBasisForm')
1375: def editMPIWGBasisForm(self):
1376: """editform"""
1377: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
1378: return pt()
1379:
1380: security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
1381: def editMPIWGRelatedPublicationsForm(self):
1382: """Edit related Publications"""
1383: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
1384: return pt()
1385:
1386:
1387: def loadNewFileForm(self):
1388: """Neues XML-File einlesen"""
1389: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
1390: return pt()
1391:
1392: def loadNewFile(self,RESPONSE=None):
1393: """einlesen des neuen files"""
1394: fileupload=self.REQUEST['fileupload']
1395: if fileupload:
1396: file_name=fileupload.filename
1397: filedata=fileupload.read()
1398:
1399: argv=xmlhelper.proj2hash(filedata)
1400: #print argv.keys()
1401: for arg in definedFields:
1402:
1403: #print arg,argv[arg],getattr(self,arg)
1404: try:
1405: temp=argv[arg][0:]
1406: #old=getattr(self,arg)
1407: setattr(self,arg,temp)
1408: #print old,getattr(self,arg)
1409: except:
1410: """nothing"""
1411:
1412: if RESPONSE is not None:
1413: RESPONSE.redirect('manage_main')
1414:
1415: def manage_addMPIWGProjectForm(self):
1416: """form for adding the project"""
1417: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
1418: return pt()
1419:
1420: def manage_addMPIWGProject(self,id,RESPONSE=None):
1421: """method to add a project"""
1422: #print argv
1423: fileupload=self.REQUEST.get('fileupload',None)
1424: if fileupload:
1425:
1426: file_name=fileupload.filename
1427: filedata=fileupload.read()
1428:
1429: argv=xmlhelper.proj2hash(filedata)
1430:
1431: #print argv
1432: newObj=MPIWGProject(id,argv)
1433: else:
1434: newObj=MPIWGProject(id)
1435:
1436: self._setObject(id,newObj)
1437:
1438:
1439: if RESPONSE is not None:
1440: RESPONSE.redirect('manage_main')
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to MPIWGProjects.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / MPIWGWeb