[BACK]Return to MPIWGProjects.py CVS log [TXT] [DIR] Up to [Repository] / MPIWGWeb

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.12 and 1.47.2.103

version 1.12, 2004/07/08 07:04:31 version 1.47.2.103, 2008/09/07 17:13:32
Line 1 Line 1
 """This contains the class MPIWG Projects  """This contains the class MPIWG Projects
 for organizing and maintaining the different projectspages  for organizing and maintaining the different project pages
   
   $author dwinter   - last change  26.06.2008
   
 """  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.MPIWGBibliography.BibliographyManager import BibliographyManager
   from OFS.Image import Image
   from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  
 import string  
 import re  import re
   import os 
 from types import *  from types import *
   import logging
 import xmlhelper # Methoden zur Verwaltung der projekt xmls  import xmlhelper # Methoden zur Verwaltung der projekt xml
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from OFS.Folder import Folder  from OFS.Folder import Folder
   from OFS.Image import Image
   from AccessControl import ClassSecurityInfo
 from bibliography import *  from bibliography import *
   import time
   #import xml.dom.minidom
   import sys
   #from Ft.Xml.XPath import Evaluate
   #from Ft.Xml.XPath.Context import Context
   #from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
   #from Ft.Xml import EMPTY_NAMESPACE
   #import copy
   #import updatePersonalWWW
   
 definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']  #import MPIWGStaff
   
 checkFields = ['xdata_01']  from MPIWGHelper import *
   
   import MPIWGRoot
   import MPIWGLink
   import MPIWGTemplate
   
   # die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus Kompatibilitaetsgruenden, bleiben die Klassen hier noch drin.
   # Sonst funktionieren die alten Webseiten nicht mehr.
   
 def sortF(x,y):  class MPIWGRoot(MPIWGRoot.MPIWGRoot):
     try:      """depricated"""
         return cmp(x[1],y[1])  
     except:  
         return 0  
           
 def sortI(x,y):  class MPIWGLink(MPIWGLink.MPIWGLink):
     xsplit=x[1].split(".")      """depricated"""
     ysplit=y[1].split(".")  
     xret=""  
     yret=""  
     try:  
         for i in range(5):  
             try:  
                 yret=yret+"%04i"%int(xsplit[i])  
             except:  
                 yret=yret+"%04i"%0  
   
             try:  class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
                 xret=xret+"%04i"%int(ysplit[i])      """depricated"""
             except:  
                 xret=xret+"%04i"%0  
                                   
   class MPIWGProject_publication(Folder):
       """publications object fuer project"""
                   
         return cmp(int(yret),int(xret))      meta_type="MPIWGProject_publication"
     except:  
         return cmp(x[1],y[1])  
   
       def editPublication(self,text=None,image1=None,image2=None,description=None,RESPONSE=None):
           """edit a publication"""
           
 class MPIWGRoot(ZSQLExtendFolder):          if (not text) and (not description):
     """Stammordner für den Web-Server"""              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
               return pt()
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',  
              'xdata_03':'Historical Persons','xdata_04':'Time period',  
              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',  
              'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',  
              'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',  
              'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',  
              'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}  
           
     folders=['MPIWGProject','Folder']          self.text=text[0:]
     meta_type='MPIWGRoot'          self.description=description
   
     def replaceNotEmpty(self,format,field):          if image1:
         """replace not empty"""              if hasattr(self,'publicationImage1'):
         if field and (not field==''):                  self.publicationImage1.manage_upload(image1)
             return format%field  
         else:          else:
             return ""                  nO = Image('publicationImage1','',image1)
                   self._setObject('publicationImage1',nO)
                   
           if image2:
               if hasattr(self,'publicationImage2'):
                   self.publicationImage2.manage_upload(image2)
               else:
                   nO = Image('publicationImage2','',image2)
                   self._setObject('publicationImage2',nO)
                   
     def formatBibliography(self,here,found):  
         """format"""  
         return formatBibliography(here,found)  
           
     def getValue(self,field):          if RESPONSE:
         """Inhalt des Feldes"""              RESPONSE.redirect("../managePublications")
   
         if type(field)==StringType:  class MPIWGProject_image(Image):
             try:      """Images for Projects"""
                 if field[len(field)-1]==";":  
                     field=field[0:len(text)-1]  
             except:  
                     """nothing"""  
                           
             return field.encode('utf-8')      meta_type="MPIWGProject_image"
                   
         else:      def showImage(self,imageUrl=None):
             return field[0].encode('utf-8')          """show Images at an extra page"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
           return pt()
   
       def editImage(self,file=None,caption=None,RESPONSE=None):
           """edit the Image"""
           if (not file) and (not caption):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
               return pt()
           
     def sortedNames(self,list):          if file and (not file.filename.lstrip().rstrip()==""):
         """sort names"""              self.manage_upload(file)
   
         def sortLastName(x_c,y_c):          if caption:
             x=urllib.unquote(x_c)              self.caption=caption[0:]
             y=urllib.unquote(y_c)  
                           
             try:          if RESPONSE:
                 last_x=x.split()[len(x.split())-1]              RESPONSE.redirect("../manageImages")
                 last_y=y.split()[len(y.split())-1]  
   
             except:  class MPIWGProject(CatalogAware,Folder):
       """Class for Projects"""
   
                 last_x=""  
                 last_y=""  
                           
       security=ClassSecurityInfo()
       meta_type='MPIWGProject'
       default_catalog='ProjectCatalog'
                           
       def decode(self,str):
           """return unicode object"""
           return unicodify(str)
                           
             if last_x<last_y:      def sortedByPlace(self,metatype):
                 return 1          """find metatype and sort by place"""
             elif last_x>last_y:          def sort(x,y):
                 return -1              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
             else:  
                 return 0  
                           
         list.sort(sortLastName)          founds=self.ZopeFind(self,obj_metatypes=[metatype]);
         list.reverse()  
                   
         return list          founds.sort(sort)
           
     def __init__(self, id, title):          return founds
         """init"""  
         self.id=id  
         self.title=title  
   
     def urlQuote(self,str):  
         """quote"""  
         return urllib.quote(str)  
   
     def urlUnQuote(self,str):      def copyPublicationsToList(self,RESPONSE=None):
         """quote"""          """copy publications in to list"""
         return urllib.unquote(str)  
           
     def harvestHistoricalPersons(self):          publicationTxt=self.getContent('WEB_related_pub')
         """erstelle liste aller erwaehnten actors"""  
   
         def normalize(str):          pubSplits=publicationTxt.split("<p>")
             """loesche fuhrendes space"""  
             if (len(str)>1) and (str[0]==" "):  
                 ret=str[1:]  
             else:  
                 ret=str  
             return ret  
                   
         list={}          for pubSplit in pubSplits:
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])              pubSplit=pubSplit.replace("</p>","")
               self.addPublication(pubSplit)
                   
         for project in projects:          if RESPONSE:
             lg=len(project[1].xdata_03[0])-1              RESPONSE.redirect('managePublications')
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):  
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]  
   
       def copyImageToMargin(self,RESPONSE=None):  
           """copy inline images to marginal images"""
                       
             
           #getImages from WEB_project_description
           description=self.getContent('WEB_project_description')
           
           text2=description
           splitted=text2.split("""<p class="picture">""")
           
           imageURLs=[]
           imageCaptions=[]
           for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
                                   
             try:              try:
                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
                     for person in project[1].xdata_03[0].split(";"):                  except:
                         personNormal=normalize(person)  
                         if personNormal in list.keys():  
                             list[urllib.quote(personNormal)][1].append(project[1])  
                         else:  
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])  
                 else: #guess , is sepeator  
                     for person in project[1].xdata_03[0].split(","):  
                         personNormal=normalize(person)  
                         if urllib.quote(personNormal) in list.keys():  
                             list[urllib.quote(personNormal)][1].append(project[1])  
                         else:  
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])  
   
                       try:
                           imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
             except:              except:
                 print "ERROR",project                          imageURLs.append("")
                                   
         return list                  split2="</p>".join(tmp[1:])
   
     def storeHistoricalPersons(self,RESPONSE=None):  
         """store persons"""  
         self.personDict={}  
         personDict=self.harvestHistoricalPersons()  
         for person in personDict.keys():  
             for project in personDict[person][1]:  
                 if person in self.personDict.keys():  
                     self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))  
                 else:  
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])  
   
         if RESPONSE is not None:                  splitted=split2.split("""<p class="picturetitle">""")
             RESPONSE.redirect("showHistoricalPersons")                  if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       imageCaptions.append(tmp[0].encode('utf-8'))
                           
   
     def showHistoricalPersons(self):                  else:
         """show persons"""                      #keine caption
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)  
         return pt()  
   
                       imageCaptions.append("")
                   
     def editHistoricalPersonsForm(self):  
         """edit historical persons for consistency"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)  
         return pt()  
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):          #eintragen:
         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""          for imageURL in imageURLs:
         if type(fieldContentsEntry) is StringType:              filename=imageURL.split("/")[-1]
             fieldContents=[fieldContentsEntry]              #lege neues images object an, mit leerem bild
         else:  
             fieldContents=fieldContentsEntry  
                           
         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})              if self.ZopeFind(self,obj_ids=[filename]):
         #print projects                  #existiert das bild schon, dann neuen filenamen
         return projects                  filename="project_image_"+filename
   
     def changeMPIWGRootForm(self):              self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
         """edit"""              #hole die bilddaten aus der url
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)              url=self.absolute_url()+"/"+imageURL
         return pt()              #url=self.absolute_url()+"/"+filename
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):              try:#relative url
         """change"""                  data=urllib.urlopen(url).read()
         self.title=title              except:
         self.disciplineList=disciplineList                  try:#absolute
         self.themesList=themesList                      data=urllib.urlopen(self.imageURL).read()
                   except:
                       logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
   
         if RESPONSE is not None:              obj=getattr(self,filename)
             RESPONSE.redirect('manage_main')              obj.update_data(data)
   
     def getDisciplineList(self):          if RESPONSE:
         """get disciplines as list"""              RESPONSE.redirect('manageImages')
         return self.disciplineList.split("\n")  
       
     def getThemeList(self):  
         """get themes as list"""  
         return self.themesList.split("\n")  
       
     def test(self):  
         """test"""  
         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url  
   
     def getContexts(self,childs=None,parents=None,depth=None):      def manageImages(self,imageName=None,op=None):
         """childs alle childs, alle parents"""          """managage images"""
         ret=[]  
         if parents:  
             splitted=parents.split(".")          if imageName and op:
             parentId=string.join(splitted[0:len(splitted)-1],".")              if op=='up':
                           images=self.getImages()
             for project in self.getProjectFields('xdata_05',sort='int'):                  for image in images:
                 if project[1]==parentId:                      if image[0]==imageName:
                     ret.append(project)                          nr=images.index(image)
                           if not nr==0:
         if childs:                              images[nr-1][1].place+=1
             for project in self.getProjectFields('xdata_05',sort='int'):                              images[nr][1].place-=1
                 searchStr=childs+"(\..*)"                          pass
                 if re.match(searchStr,project[1]):              elif op=='down':
                                       images=self.getImages()
                     if depth:                  for image in images:
                         print "ho"                      if image[0]==imageName:
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):                          nr=images.index(image)
                           if not (nr==len(images)-1):
                               images[nr+1][1].place-=1
                               images[nr][1].place+=1
                           pass
                                           
                             ret.append(project)  
                     else:  
                         ret.append(project)  
         return ret  
           
     def getProjectFields(self,fieldName,folder=None,sort=None):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
         """getListofFieldNames"""          return pt()
         ret=[]  
         #print "FN",fieldName  
         if not folder:  
             folder=self  
         for object in folder.__dict__:  
   
             obj=getattr(folder,object)      def managePublications(self,pubName=None,op=None):
             if hasattr(obj,'meta_type'):          """managage images"""
                 #print obj.meta_type  
                 if obj.meta_type=='MPIWGProject':  
                     if fieldName=="WEB_title_or_short":  
                         #print "HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"  
                         #print len(obj.getContent('xdata_07'))  
                         if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer  
                             fieldNameTmp="WEB_title"  
                         else:  
                             fieldNameTmp="xdata_07"  
                     else:  
                         fieldNameTmp=fieldName  
                                           
                     ret.append((obj,obj.getContent(fieldNameTmp)))  
   
                 if obj.meta_type in self.folders:          if pubName and op:
               if op=='up':
                   publications=self.getPublications()
                   for publication in publications:
                       if publication[0]==pubName:
                           nr=publications.index(publication)
                           if not nr==0:
                               publications[nr-1][1].place+=1
                               publications[nr][1].place-=1
                           pass
               elif op=='down':
                   publications=self.getPublications()
                   for publication in publications:
                       if publication[0]==pubName:
                           nr=publications.index(publication)
                           if not (nr==len(publications)-1):
                               publications[nr+1][1].place-=1
                               publications[nr][1].place+=1
                           pass
                                           
                     ret += self.getProjectFields(fieldName,obj)  
   
         if sort=="int":          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
             ret.sort(sortI)          return pt()
       def hasExtendedPublicationList(self):
           """test if extended publication list exists"""
           if not hasattr(self,"publicationList"):
               return False
         else:          else:
             ret.sort(sortF)              return True
                   
         return ret      def createExtendedPublicationList(self,RESPONSE=None):
           """erzeuge erweiterte publications liste"""
           pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
           self._setObject("publicationList", pl)
   
     def showNewProjects(self):  
         projects=[]  
         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets  
             if objs[0].xdata_05[0] == "":  
                                   
                 projects.append(objs)          zt=ZopePageTemplate('index.html')
           pl._setObject('index.html',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                                 'zpt/showExtendedProjectBibliography.zpt')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/html')
                                   
         return projects  
           
           if RESPONSE:
               RESPONSE.redirect("managePublications")
                   
     manage_options = Folder.manage_options+(      def getPublications(self):
         {'label':'Import Persons','action':'importNamesForm'},          """get all Publications"""
         {'label':'Main config','action':'changeMPIWGRootForm'},          def sort_images(x,y):
         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},  
         )  
       
     def importNamesForm(self):  
         """Form"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)  
         return pt()  
   
     def importNames(self,fileupload,folderName,RESPONSE=None):          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
         """import komma-sep list email,lastName,firstName"""  
         project=getattr(self,folderName)  
         load=fileupload.read()  
                   
         for line in load.split('\r'):          publications.sort(sort_images)
           return publications
                           
       def addPublication(self,text,RESPONSE=None):
           """add an MPIWG_Publication"""
                           
             splitted=line.split(",")          name="publication_"+str(self.getLastPublicationNumber()+1)
             print splitted  
                   
             if not (splitted[0]==""):          newPublication=MPIWGProject_publication(name)
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])  
                                   
                 try:          self._setObject(name,newPublication)
                     project._setObject(splitted[0],newObj)          obj=getattr(self,name)
                     print "done:",splitted[0]          obj.text=text[0:]
                 except:          obj.enabled=True;
                     print "not done:",splitted[0]          obj.place=self.getLastPublicationNumber()+1
           obj.id=name
                                           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('managePublications')
   
     def getAllMembers(self):  
         """give list of all members"""  
         ret=[]  
   
         #for x in self.members.objectValues('MPIWGStaff'):  
             #print x.title  
         #    ret.append(x.title.decode('utf-8'))  
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):  
                                ret.append(x[1].title.decode('utf-8'))  
               
         #ret.sort()  
         #print ret  
     
         return ret  
   
     def printAllMembers(self):  
         """prin"""  
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
           
       def getLastPublicationNumber(self):
           publications=self.getPublications()
                   
     def makeList(self,entry):          if not publications:
         """makes a list out of one entry or repeat a list"""              return 0
         if type(entry) is StringType:  
             return [entry]  
         else:          else:
             return entry              return getattr(publications[-1][1],'place',0)
   
   
     def getTree(self):  
         """generate Tree from project list"""  
         returnList=[]  
         for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05  
             for idNr in project[1].split(";"): # more than one number  
                 if not idNr=="":  
                     splittedId=idNr.split(".")  
                     depth=len(splittedId)  
                     nr=idNr  
                     title=project[0].WEB_title  
                       
                     returnList.append((depth,nr,title,project[0]))  
                   
         return returnList      def deletePublication(self,id,RESPONSE=None):
               """delete Publication id"""
               self.manage_delObjects([id])
               if RESPONSE:
                   RESPONSE.redirect('managePublications')
   
     def changePosition(self,treeId,select,RESPONSE=None):      def getImages(self):
         """Change Postion Entry"""          """get all Images"""
         numbers=[]  
   
         # Suche hoechste bisherige nummer          def sort_images(x,y):
         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
         #print "pj",projects  
         for project in projects: #suche alle subtrees der treeId  
             #print treeId  
                           
             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])  
             if founds:  
                 #print "x",founds.group(0),len(founds.group(0).split("."))  
                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene  
                     try:  
                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))  
                     except:  
                         numbers.append(int(0))  
   
           if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
         try:          try:
             highest=max(numbers)                  self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
         except:          except:
             highest=0                  pass
         projects=self.showNewProjects()              self.imageURL=''
         for i in self.makeList(select):              self.imagecap=''
             highest+=10  
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)  
   
   
         if RESPONSE is not None:  
             RESPONSE.redirect('showTree')  
           
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
           
         for idNr in form.keys():  
             fields[int(idNr)][3].xdata_05=form[idNr]  
   
           
   
         if RESPONSE is not None:  
             RESPONSE.redirect('showTree')  
   
     def getProjectWithId(self,id):  
         fields=self.getProjectFields('xdata_05')  
         for field in fields:  
             if field[1]==id:  
                 return field[0]  
   
         return None  
               
           
               
           
                   
           images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
                           
     def getUrlFromPerson(self,list):          images.sort(sort_images)
         """get urls to person list"""          return images
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen      def getLastImageNumber(self):
                 splitted=person.split(",")          images=self.getImages()
                 if len(splitted)==1:  
                     splitted=person.split(" ")  
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
                 if splittedNew[0]=='':  
                     del splittedNew[0]  
                 search=string.join(splittedNew,' AND ')  
                                   
                 if not search=='':          if not images:
               return 0
           else:
               return getattr(images[-1][1],'place',0)
   
       def deleteImage(self,id,RESPONSE=None):
           """delete Image id"""
                     try:                      try:
                         proj=self.MembersCatalog({'title':search})                  self.manage_delObjects([id])
                     except:                      except:
                         proj=None                  logging.error("ERROR MPIWG: %s %s"%sys.exc_info()[0:2])
           if RESPONSE:
               RESPONSE.redirect('manageImages')
   
                 if proj:  
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))  
                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))  
                 else:  
                     #ret.append("%s"%person.encode('utf-8'))  
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                                                     
     def getProjectsOfMembers(self):      def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
         """give tuple member /projects"""          """check if project has children"""
         ret=[]          ct=self.getContexts(childs=self.getContent('xdata_05'),
         members=self.getAllMembers()                                   depth=1,date=date,onlyActive=onlyActive)
         #return str(members)  
         for x in members:  
             ret+=self.getProjectsOfMember(name=x)  
   
         return ret          if ct and len(ct)>0:
                return True
           else:
                return False
   
     def getProjectsOfMember(self,name=None,email=None):  
         """get project of a member"""  
         def sortP(x,y):  
             """sort by sorting number"""  
                           
             return cmp(x.xdata_05,y.xdata_05)      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
           """add an MPIWG_Project_image"""
                   
           if not filename:
               filename=fileHd.filename
     
         ret=[]          if not fileHd:
         splitNeu=[]              fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
         if email:  
             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email])  
             name =  members[0][1].title.decode('utf-8')  
   
         y=name  
         splitted=y.split(",")    
         for s in splitted:  
             splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
               
         proj=self.ProjectCatalog({'xdata_01':search})  
         if proj:  
             proj2=[x for x in proj]  
             proj2.sort(sortP)  
             ret.append((y,proj2))  
   
         proj=self.ProjectCatalog({'xdata_08':search})  
         if proj:  
             proj2=[x for x in proj]  
             proj2.sort(sortP)  
             ret.append((y,proj2))  
   
           newImage=MPIWGProject_image(filename,filename,fileHd)
                   
         return ret          self._setObject(filename,newImage)
                obj=getattr(self,filename)
     def givePersonList(self,name):          obj.caption=caption[0:]
         """check if person is in personfolder and return list of person objects"""          obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
                   
         splitted=name.split(",")          if RESPONSE is not None:
         if len(splitted)==1:              RESPONSE.redirect('manageImages')
             splitted=name.split(" ")  
         splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
         if splittedNew[0]=='':  
             del splittedNew[0]  
         search=string.join(splittedNew,' AND ')  
         if not search=='':  
             proj=self.MembersCatalog({'title':search})  
   
         if proj:      def PrincipiaSearchSource(self):
             return [[x.lastName,x.firstName] for x in proj]          """Return cataloguable key for ourselves."""
           return str(self)
   
       def versionHeader(self):
           """version Header, gibt header text entsprechend der aktuellen version aus"""
           
           actualTime=time.localtime()
           retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
           s=self.aq_parent.absolute_url()
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return retTXT%(s,s)
         else:          else:
             return []              return ""
               
 ##         splitted=name.split(",") # version nachname, vorname...  
 ##         if len(splitted)>1:  
 ##             lastName=splitted[0]   
 ##             firstName=splitted[1]  
 ##         else:   
 ##             splitted=name.split(" ") #version vorname irgenwas nachnamae  
           
 ##             lastName=splitted[len(splitted)-1]  
 ##             firstName=string.join(splitted[0:len(splitted)-1])  
   
 ##         objs=[]  
   
         #print  self.members   
       ##   for x in self.members.__dict__:  
 ##             obj=getattr(self.members,x)  
 ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):  
                   
 ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):  
                       
 ##                     objs.append((obj,lastName+", "+firstName))  
   
       def getActualVersion(self,date=None):
           """actuelle version"""
           def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           if not date:
               if self.isActual():
                   return self
               else:
                   return None
                   
         return objs          #suche ob aeltere versionen vorhanden sind
   
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self
               else:
                   return None
   
     def personCheck(self,names):  
         """all persons for list"""  
         #print "names",names  
         splitted=names.split(";")  
         ret={}  
         for name in splitted:  
   
             if not (name==""):          else:
                 try:              finds.sort(sortProjectsByTime)
                     ret[name]=self.givePersonList(name)  
                 except:  
                     """NOTHIHN"""  
         #print "RET",ret  
         return ret  
   
     def giveCheckList(self,person,fieldname):          for find in finds:
         """return checklist"""              #gehe durch die alten Projekte und finde das entprechende
         #print "GCL",fieldname              if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
         if fieldname=='xdata_01':                  return find[1]
             x=self.personCheck(person.getContent(fieldname))  
             #print "GCLBACKX",x  
             return x  
                   
           #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
   
     def isCheckField(self,fieldname):          if int(date)>int(ad):
         """return chechfield"""  
                   
         return (fieldname in checkFields)              return self
           else:
               return None
   
   
       def isActual(self):
           """gibt 1 zurueck wenn aktuell, 0 sonst"""
           actualTime=time.localtime()
           
           
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return 0
           else:
               return 1
                   
 def manage_addMPIWGRootForm(self):      def copyObjectToArchive(self):
     """form for adding the root"""          """kopiere aktuelles objekt ins archiv"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)          cb=self.aq_parent.manage_copyObjects(self.getId())
           self.manage_pasteObjects(cb)
           actualTime=time.localtime()
           
           self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
           obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
           obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
           ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
           obj.manage_delObjects(ids)
           
       def setArchiveTime(self,time):
           """set Archive Time"""
           self.archiveTime=time[0:]
           
       def versionManageForm(self):
           """version Manage form:currently only set to invisible"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGRoot(self,id,title,RESPONSE=None):      def versionManage(self,invisible=None,RESPONSE=None):
     """add a root folder"""          """version Manage form:currently only set to invisible"""
     newObj=MPIWGRoot(id,title)          self.invisible=invisible
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
   
 class MPIWGProject(Folder):  
     """Class for Projects"""  
   
     meta_type='MPIWGProject'  
   
     def crossLinker(self):      def crossLinker(self):
         """experimental crosslinker"""          """experimental crosslinker"""
         splitted=self.WEB_project_description[0].split()          splitted=self.WEB_project_description[0].split()
Line 644  class MPIWGProject(Folder): Line 520  class MPIWGProject(Folder):
                     new.append(split)                      new.append(split)
             except:              except:
                 new.append(split)                  new.append(split)
         return string.join(new)          return " ".join(new)
                           
                           
   
   
     def generateTemplate(self,RESPONSE=None):      def generateTemplate(self,RESPONSE=None):
         """Erzeuge Template für defined fields not_used"""          """Erzeuge Template fuer defined fields not_used"""
   
         id="index_html"          id="index_html"
         title=id          title=id
Line 665  class MPIWGProject(Folder): Line 541  class MPIWGProject(Folder):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def __init__(self, id, argv=None):      def __init__(self, id, argv=None):
         """initieriere classe"""          """initiere classe"""
                   
           self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
         self.id=id          self.id=id
         self.title=id          self.title=id
           self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
           self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
           
         if argv:          if argv:
             for arg in definedFields:              for arg in definedFields:
         try:          try:
Line 685  class MPIWGProject(Folder): Line 565  class MPIWGProject(Folder):
         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},          {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},          {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},          {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
           {'label':'Versionmanager','action':'versionManageForm'},
         )          )
   
   
       def isActiveProject(self):
           """check if the project is still active, default is true, set to false is the project is accomplished"""
           return getattr(self,'isActiveFlag',True)
    
       def isArchivedProject(self):
           """check if the project is archived"""
           
           completed=getattr(self,'completedAt',0)
          
          #completed leer 
           if completed=="" :
               return False;
           if completed == 0:
               return False;
           
           
           return True
           
           
       def setActiveFlag(self,status=True):
           """set the active flag"""
           self.isActiveFlag=status
           
       def setCompletedAt(self,date):
           """set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
           #logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           #logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"completedAt",transformedDate)
               return True;
           else:
               return False;
       
       def setStartedAt(self,date):
           """set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
           #logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           #logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"startedAt",transformedDate)
               return True;
           else:
               return False;
       def getCompletedAt(self):
           """gibt das transformierte Datum zurueck, an dem das Projekt beendet wurde."""
           date=getattr(self,'completedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               # test ob parent abgeschlossen ist
               
               ct=self.getContexts(parents=self.getContent('xdata_05'),depth=1)
               if (len(ct)>0): #is there are parent
                   
                   return ct[0][0].getCompletedAt()
               return '';
           
       def getStartedAt(self):
           """gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
           date=getattr(self,'startedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
           
       def reTransformDate(self,date):
           """transformiert , transformdate zurueck"""
           year=int(date/10000)
           month=int((date-year*10000)/100)
           day=int((date-year*10000-month*100))
           if (day==0) and (month==0):
               return """%s"""%year;
           if day==0 :
               return """%s.%s"""%(month,year);
           
           return """%s.%s.%s"""%(day,month,year);
           
           
       def transformDate(self,date):
           """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach  YYYYMMDD, alle nicht angebebenn Werte
           werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist""" 
      
           if (date==None):
               return None;
           
             
           if (date.lstrip().rstrip()=="" ) :
               return "";
           
           splitted=date.split(".")
           length=len(splitted)
           year=0
           month=0
           day=0
           if length > 3:
               return "";
           if length==3:
               day = int(splitted[0])
           if length>1:
               month=int(splitted[length-2])
           
           if length > 0:
               try:
                   year = int(splitted[length-1])
               except:
                   pass
           
          ## logging.info("month:"+(month))
           if not (0<=month<13):
               return None;
           
           if not(0<=day<32):
               return None;
           
           if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
               year=2000+year;
           return year*10000+month*100+day
           
           
       
       def checkDate(self,date):
           """teste ob zum Zeitpunkt date eine andere version existierte"""
           
   
           def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           #suche ob aeltere versionen vorhanden sind
   
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self.REQUEST['URL1']+"/"+self.getId()
               else:
                   return self.REQUEST['URL1']+"/no_project"
   
   
           else:
               finds.sort(sortProjectsByTime)
   
           for find in finds:
               #gehe durch die alten Projekte und finde das entprechende
               if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                   return self.REQUEST['URL1']+"/"+find[1].getId()
   
           #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
           
           if int(date)>int(ad):
           
               return self.REQUEST['URL1']+"/"+self.getId()
           else:
               return self.REQUEST['URL1']+"/no_project"
           
               
       def no_project(self):
           """warnung: project noch nicht existent"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
           return pt()
       
     
       def harvest_page(self,context=None):
           """seite fuer harvesting fuer die Projektsuche"""
           if not context:
               context=self
               
           if self.isActiveProject() and self.isActual():
                ext=getattr(self,"harvest_main",None)
                if ext:
                    return getattr(self,ext.getId())()
   
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
   
   
                return pt()
            
       def index_html(self,request=True,context=None):
           """show homepage"""
           if not context:
               context=self
           if request:
               if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
                   self.REQUEST.SESSION['MPI_redirected']=1
                   self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
               else:
                   self.REQUEST.SESSION['MPI_redirected']=None
           
           #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
         
           ext=getattr(self,"project_main",None)
           if ext:
               return getattr(self,ext.getId())()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
   
           return pt()
   
       
     def getDataFields(self):      def getDataFields(self):
         """giveListofDatafields"""          """giveListofDatafields"""
         ret=[]          ret=[]
         for x in range(1,14):          for x in range(1,14):
               if not x in [6,10,9]: # not used fields
             ret.append('xdata_%02i'%x)              ret.append('xdata_%02i'%x)
         return ret          return ret
                           
Line 703  class MPIWGProject(Folder): Line 786  class MPIWGProject(Folder):
         """get attrbiute"""          """get attrbiute"""
         return getattr(self,field)          return getattr(self,field)
   
     def getContent(self,field):      def getContent(self,field,filter=None):
         """Inhalt des Feldes"""          """Inhalt des Feldes"""
                   
       if field=="short_title":
           text = self.getContent("xdata_07")
           if text=="":
               text = self.getContent("WEB_title")
           return text
   
         text=u''          text=u''
         #print "FIELD",field  
         for x in getattr(self,field):          for x in getattr(self,field):
             #print "HIHIIII"  
                           
             try:              try:
                 text +=x.encode('utf-8')                  text +=x
             except:              except:
                   text = x
               
           
   
                 try:                  try:
                     text =x.encode('utf-8')              if text[len(text)-1]==";":
                   text=text[0:len(text)-1]
             
                   
                 except:                  except:
                     text="ERROR"              pass
           
           if text=='': ## wozu die folgenden Zeilen??
               text2=text
           else:
               text2=re.sub(r';([^\s])','; \g<1>',text)
          
           if field=="WEB_project_description":##Jedenfalls darf letzteres nicht gemacht werden, falls normaler text
               text2=text
               
           #teste ob ergebnis leer und header dann nehme title
                   
         #delete separator (;) if  is there is one          if (text2=='') and (field=='WEB_project_header'):
               return self.getContent('WEB_title')
   
           if filter:
               splitted=text2.split("""<p class="picture">""")
               if len(splitted)>1:
                   tmp=splitted[1].split("</p>")
                   #return repr(splitted[1])
         try:          try:
             if text[len(text)-1]==";":                          self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                 text=text[0:len(text)-1].encode('utf-8')  
         except:          except:
             """nothing"""                      try:
                           self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                       except:
                           self.imageURL=""
                           
         return text                  split2="</p>".join(tmp[1:])
   
                   text3=splitted[0]+split2
   
                   splitted=text3.split("""<p class="picturetitle">""")
                   if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       self.imagecap=tmp[0].encode('utf-8')
                   
                       split4="".join(tmp[1:])
   
                       text5=splitted[0]+split4
                   else:
                       #keine caption
                       text5=text3
               else:
                   #kein bild
                   text5=text2
           else:
               text5=text2
   
           #teste ob WEB_project_description und keine fuehrenden p tags
           if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
               text5= "<p>"+text5+"</p>"
   
   
           #filter image
           
           text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
           if (text5=="<br>") or (text5=="<br/>"):
               text5=""
   
           #logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
           return unicodify(text5)
           #return utf8ify(text5) # return as utf-8 byte string
   
   
       def showImagesOfPage(self,imageUrl=None):
           """show Images of project"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
           return pt()
   
           
     def show_html(self):      def show_html(self):
         """simple index"""          """simple index"""
         #return "HI"          #return "HI"
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
           return pt()
   
       def saveFromPreview(self):
           """save content aus preview"""
           self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
           self.REQUEST.RESPONSE.redirect("./index.html")
           
       def saveEditedContent(self,kupu=None,preview=None):
           """save Edited content"""
   
           if preview:
               kupu=preview
           #find content of body tags
           start=kupu.find("<body>")
           end=kupu.find("</body>")
           newcontent= kupu[start+6:end]
        
           if preview:
               
               return self.preview(newcontent)
   
           self.copyObjectToArchive()
           self.WEB_project_description=newcontent[0:]
          
           self.REQUEST.RESPONSE.redirect("./index.html")
           
           return True
   
       security.declareProtected('View management screens','edit')
       def edit(self,western=None):
           """Edit pages"""
           if western:
               self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
   
               
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
         return pt()          return pt()
   
       edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
   
       def getPathStyle(self, path, selected, style=""):
           """returns a string with the given style + 'sel' if path == selected."""
   
           if path == selected:
               return style + 'sel'
           else:
               return style    
   
       def getLabel(self):
           """returns label (or title) of this project"""
           l = self.getContent('xdata_07')
           if l:
               return l
           l = self.getContent('WEB_title')
           if l:
               return l
           return self.title
   
       def getBreadcrumbs(self):
           """return list of breadcrumbs from here to the root"""
           crumbs = []
           # skip direct parent Folder /projects/
           parent = self.aq_parent.aq_parent
           # get parents breadcrumbs
           if hasattr(parent, 'getBreadcrumbs'):
               crumbs = parent.getBreadcrumbs()
           
           # try to get acquisition URL from parent
           if hasattr(parent, 'absolute_url'):
               baseUrl = "%s/%s/"%(parent.absolute_url(), 'projects')
           else:
               baseUrl = "/en/research/projects/"
               
           # add in the internal project hierarchy
           ct=self.getContexts(parents=self.getContent('xdata_05'))
           # start with grandparents
           ct.reverse()
           for c in ct:
               label = shortenString(c[0].getLabel(), 13)
               crumbs.append((label, baseUrl+c[0].getId(), c[0]))            
   
           # add this project
           crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
               
           return crumbs
   
       def getRootProject(self):
           """returns the root (=top level) project of the current project"""
           ct=self.getContexts(parents=self.getContent('xdata_05'))
           if len(ct) > 0:
               return ct[-1][0]
           else:
               return self        
   
   
       def preview(self,description):
           """preview"""
           tmpPro=getattr(self,"previewTemplate",None)
           if not tmpPro:
               tmpPro=MPIWGProject("previewTemplate")
               self._setObject("previewTemplate",tmpPro)
           for field in definedFields:
               setattr(tmpPro,field,getattr(self,field))
           tmpPro.WEB_project_description=description[0:]
           tmpPro.invisible=True
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
           return pt()
   
           #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
           
   
       def getWebProject_description(self):
           """get description"""
           debug= self.REQUEST.cookies.get("MP_debug_code",None)
           
           if debug and debug=="western":
               return """
               <html>
               <head>
               <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
               </head>
               <body>%s
               </html></body>
               """%self.WEB_project_description[0]
           
           return """
               <html>
               <head>
               <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
               </head>
               <body>%s
               </html></body>
               """%self.getContent('WEB_project_description')
           
           
           
     def editMPIWGProjectForm(self):      def editMPIWGProjectForm(self):
         """editform"""          """editform"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
         return pt()          return pt()
   
     def editMPIWGProject(self,RESPONSE=None):      def isResponsibleScientist(self,key):
         """edit the project"""          """teste ob eine Person in der Liste der respl. scientists auftaucht"""
           #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
     
           
           keys = [unicodify(x[1]) for x in getattr(self,"responsibleScientistsList",[])]
           #logging.error("RESP. SCIEN:%s"%getattr(self,"responsibleScientistsList",[]))
           #logging.error("RESP. SCIEN:%s"%unicodify(key))
           
           if unicodify(key) in keys:
               return True
           else:
               return False
           
       def getPersonKeyList(self):
           """gibt die key Liste der beteiligten Personen zurŸck (utf8 codiert)"""
           #logging.error("getPersonKeyList:%s"%getattr(self,'responsibleScientistsList',[]))
           try:
               return [utf8ify(x[1]) for x in getattr(self,'responsibleScientistsList',[])]
           except:
               return[]
           
          
       def myCapitalize(self,txt):
           """kapitalisiere auch Namen mit -"""
           splitted=[x.capitalize() for x in txt.split("-")]
           return "-".join(splitted)
       
       def getNamesOrdered(self,list):
           """Sortiert die Liste nach der Reihenfolge in xdata_01"""
           
           nameList=self.getContent('xdata_01')
           if nameList.find(";")>-1: # rate Trenner ist ;
               names=nameList.split(";")  
           else:
               names=nameList.split(",")
               
               self._v_names=[]
               for name in names:
                   self._v_names.append(name.rstrip().lstrip())
               
               
           def sort(x,y):
               try:
                   return cmp(self._v_names.index(x[0]),self._v_names.index(y[0]))
               except:
                   return 0
               
           list.sort(sort)
           
           return list
           
           ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze    
           
           
           
           
       def identifyNames(self,nameList):
           """Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
           und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
           @param nameList
           """
           
           if nameList.find(";")>-1: # rate Trenner ist ;
             names=nameList.split(";")  
             
           else:
               names=nameList.split(",")
               
           ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze    
           returnNamesDict={}
   
          
           for name in names:
               name=name.lstrip().rstrip()
               nameSplitted = name.split(" ")
               if len(nameSplitted)>1:  #vor und nachname angegeben)
                 
                   lastname=nameSplitted[-1]
                   firstname=nameSplitted[0]
               else:
                   firstname =""
                   lastname=nameSplitted[0]
                  
               #finde Mitarbeiter mit den entsprechenden Name
               
               firstname=self.myCapitalize(firstname).encode('utf-8')
               lastname=self.myCapitalize(lastname).encode('utf-8')
               logging.info("Search: %s %s %s"%(name,repr(firstname),repr(lastname)))
               try:
                   cataloggedNames=self.MembersCatalog({'firstName':firstname,'lastName':lastname})
               except:
                   cataloggedNames=[]
                   logging.error("ERROR: identifyNames %s %s"%sys.exc_info()[0:2])
               
               #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
               #if not hasattr(self,'responsibleScientistsList'):
               #     self.responsibleScientistsList={}
               # 
               # if name in self.responsibleScientistsList.values()
               
               if len(cataloggedNames)>0:
                  returnNamesDict[name]=cataloggedNames
               else:
                   returnNamesDict[name]=[]
          
           logging.error("id: %s"%repr(returnNamesDict))
           return returnNamesDict
           
       def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
           """edit the project and archive the old version"""
           
           self.copyObjectToArchive() # archive the object
   
                   
         #return self.REQUEST  
         for x in definedFields:          for x in definedFields:
             if self.REQUEST.has_key(x):              if self.REQUEST.has_key(x):
                                   
                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])                  setattr(self,x,[self.REQUEST[x].decode('utf-8')])
                           
           
          
   
           completedAt = self.REQUEST.get('completedAt')
           if not self.setCompletedAt(completedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
     
           startedAt = self.REQUEST.get('startedAt')
           if not self.setStartedAt(startedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
           
           if self.REQUEST.has_key('historicalNames'):
               self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
           
           if self.REQUEST.has_key('active'):
               self.setActiveFlag(True)
           else:
               self.setActiveFlag(False)
           
           self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
           
           names={}
           keys={}
           tmpList=[]
           for key in self.REQUEST.keys(): #gehe durch das Formular
               splitted=key.split("_")
               if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
                   nr=splitted[2]
                   if splitted[1]=="name":
                       names[nr]=self.REQUEST[key]
                   elif splitted[1]=="key":
                       keys[nr]=self.REQUEST[key]
                   
            
           for nr in names.keys():#schreibe keys und namen in die Liste, stelle ausserdem sicher, dass name unicode
                tmpList.append((unicodify(names[nr]),unicodify(keys.get(nr,""))))
                
           self.responsibleScientistsList=tmpList
           if fromEdit and (RESPONSE is not None):
               #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.decode(self.REQUEST.get('xdata_01',''))))
               
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
   
       security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
       def editMPIWGDisciplinesThemesEditor(self):
           """edit from edit"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
           return pt()
           
       
     def editMPIWGDisciplinesThemesForm(self):      def editMPIWGDisciplinesThemesForm(self):
         """edit the disciplines and themes Form"""          """edit the disciplines and themes Form"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)       
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
         return pt()          return pt()
   
     def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):      def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
         """edit disciplin and form"""          """edit disciplin and form"""
         if disciplines:          if disciplines:
             if type(disciplines) is StringType:              if type(disciplines) is StringType:
                 self.xdata_09=disciplines                  self.xdata_09=disciplines
             else:              else:
                 self.xdata_09=string.join(disciplines,";")                  self.xdata_09=";".join(disciplines)
         else:          else:
                 self.xdata_09=""                  self.xdata_09=""
         if themes:          if themes:
             if type(themes) is StringType:              if type(themes) is StringType:
                 self.xdata_10=themes                  self.xdata_10=themes
             else:              else:
                 self.xdata_10=string.join(themes,";")                  self.xdata_10=";".join(themes)
         else:          else:
             self.xdata_10=""              self.xdata_10=""
                           
           if fromEdit and (RESPONSE is not None):
               RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
   
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def isChecked(self,wert,list):      def isChecked(self,wert,list):
         """check if wert is in ; seperated list"""          """check if wert is in ; seperated list"""
         print "W:",wert  
         print "L:",list,type(list)  
         #felder sind manchmnal als liste mit einem element definiert          #felder sind manchmnal als liste mit einem element definiert
         if type(list) is StringType or UnicodeType:           if type(list) is StringType or UnicodeType: 
             splitted=list.split(";")              splitted=list.split(";")
         else:          else:
             splitted=list[0].split(";")              splitted=list[0].split(";")
   
         print splitted          splitted=[y.rstrip().lstrip() for y in splitted]
           
         for x in splitted:          for x in splitted:
               x=re.sub(r"[^A-z ]","",x)
             if (not x==u'') and x in wert:              if (not x==u'') and x in wert:
                 return 1                  return 1
         return 0          return 0
           
       security.declareProtected('View management screens','editMPIWGBasisEditor')
       def editMPIWGBasisEditor(self, identifiedNames=None):
                               
           """editform"""
           if not identifiedNames:
               identifiedNames=self.identifyNames(self.getContent('xdata_01'))
              # identifiedNames=self.getFullNameEntries()
           
           logging.error("IdentifiedNames: %s"% repr(identifiedNames))
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
           return pt(identifiedNames=identifiedNames)
   
       security.declareProtected('View management screens','editMPIWGBasisForm')
     def editMPIWGBasisForm(self):      def editMPIWGBasisForm(self):
         """editform"""          """editform"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
         return pt()          return pt()
   
       security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
     def editMPIWGRelatedPublicationsForm(self):      def editMPIWGRelatedPublicationsForm(self):
         """Edit related Publications"""          """Edit related Publications"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
         return pt()          return pt()
                   
           
     def loadNewFileForm(self):      def loadNewFileForm(self):
         """Neues XML-File einlesen"""          """Neues XML-File einlesen"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
         return pt()          return pt()
   
     def loadNewFile(self,RESPONSE=None):      def loadNewFile(self,RESPONSE=None):
Line 834  class MPIWGProject(Folder): Line 1307  class MPIWGProject(Folder):
   
 def manage_addMPIWGProjectForm(self):  def manage_addMPIWGProjectForm(self):
     """form for adding the project"""      """form for adding the project"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGProject(self,id,RESPONSE=None):  def manage_addMPIWGProject(self,id,RESPONSE=None):
     """method to add a project"""      """method to add a project"""
     #print argv      #print argv
     if self.REQUEST.has_key('fileupload'):      fileupload=self.REQUEST.get('fileupload',None)
         fileupload=self.REQUEST['fileupload']  
         if fileupload:          if fileupload:
   
             file_name=fileupload.filename              file_name=fileupload.filename
             filedata=fileupload.read()              filedata=fileupload.read()
   
Removed from v.1.12  
changed lines
  Added in v.1.47.2.103

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