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