File:  [Repository] / MPIWGWeb / MPIWGProjects.py
Revision 1.47.2.108: download - view: text, annotated - select for diffs - revision graph
Thu Oct 23 10:02:09 2008 UTC (15 years, 7 months ago) by dwinter
Branches: r2
completed at changed

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>