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