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