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