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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.16 and 1.47.2.90

version 1.16, 2004/07/29 08:18:10 version 1.47.2.90, 2008/08/26 15:01:41
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 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 KompatibilitŠtsgrŸnden, 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(SimpleItem):
       """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,RESPONSE=None):
           """edit a publication"""
           
 class MPIWGRoot(ZSQLExtendFolder):          if (not text):
     """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'  
   
     def replaceNotEmpty(self,format,field):          if RESPONSE:
         """replace not empty"""              RESPONSE.redirect("../managePublications")
         if field and (not field==''):  
             return format%field  
         else:  
             return ""  
                   
   class MPIWGProject_image(Image):
       """Images for Projects"""
                   
     def formatBibliography(self,here,found):      meta_type="MPIWGProject_image"
         """format"""  
         return formatBibliography(here,found)  
           
     def getValue(self,field):      def showImage(self,imageUrl=None):
         """Inhalt des Feldes"""          """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()
   
         if type(field)==StringType:      def editImage(self,file=None,caption=None,RESPONSE=None):
             try:          """edit the Image"""
                 if field[len(field)-1]==";":          if (not file) and (not caption):
                     field=field[0:len(text)-1]              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
             except:              return pt()
                     """nothing"""  
                           
             return field.encode('utf-8')          if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
                   
         else:          if caption:
             return field[0].encode('utf-8')              self.caption=caption[0:]
   
           if RESPONSE:
               RESPONSE.redirect("../manageImages")
           
     def sortedNames(self,list):  class MPIWGProject(CatalogAware,Folder):
         """sort names"""      """Class for Projects"""
   
         def sortLastName(x_c,y_c):  
             try:  
                 x=urllib.unquote(x_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(x_c)  
   
             try:      security=ClassSecurityInfo()
                 y=urllib.unquote(y_c).encode('utf-8','ignore')      meta_type='MPIWGProject'
             except:      default_catalog='ProjectCatalog'
                 x=urllib.unquote(y_c)  
                                   
       def decode(self,str):
           """return unicode object"""
           return unicodify(str)
   
       def sortedByPlace(self,metatype):
           """find metatype and sort by place"""
           def sort(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                           
             try:          founds=self.ZopeFind(self,obj_metatypes=[metatype]);
                 last_x=x.split()[len(x.split())-1]  
                 last_y=y.split()[len(y.split())-1]  
   
             except:          founds.sort(sort)
   
                 last_x=""          return founds
                 last_y=""  
                           
                           
       def copyPublicationsToList(self,RESPONSE=None):
           """copy publications in to list"""
                           
             if last_x<last_y:          publicationTxt=self.getContent('WEB_related_pub')
                 return 1  
             elif last_x>last_y:  
                 return -1  
             else:  
                 return 0  
                           
         list.sort(sortLastName)          pubSplits=publicationTxt.split("<p>")
         list.reverse()  
                   
         return list          for pubSplit in pubSplits:
               pubSplit=pubSplit.replace("</p>","")
               self.addPublication(pubSplit)
           
     def __init__(self, id, title):          if RESPONSE:
         """init"""              RESPONSE.redirect('managePublications')
         self.id=id  
         self.title=title  
   
     def urlQuote(self,str):  
         """quote"""  
         return urllib.quote(str)  
   
     def urlUnQuote(self,str):      def copyImageToMargin(self,RESPONSE=None):  
         """quote"""          """copy inline images to marginal images"""
         return urllib.unquote(str)  
           
     def harvestHistoricalPersons(self):  
         """erstelle liste aller erwaehnten actors"""  
   
         def normalize(str):          #getImages from WEB_project_description
             """loesche fuhrendes space"""          description=self.getContent('WEB_project_description')
             if (len(str)>1) and (str[0]==" "):  
                 ret=str[1:]  
             else:  
                 ret=str  
             return ret  
                   
         list={}          text2=description
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])          splitted=text2.split("""<p class="picture">""")
                   
         for project in projects:          imageURLs=[]
             lg=len(project[1].xdata_03[0])-1          imageCaptions=[]
           for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):                  try:
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
                   except:
   
                       try:
                           imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
                       except:
                           imageURLs.append("")
                       
                   split2="</p>".join(tmp[1:])
             
                                   
             try:                  splitted=split2.split("""<p class="picturetitle">""")
                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;                  if len(splitted)>1:
                     for person in project[1].xdata_03[0].split(";"):                      tmp=splitted[1].split("</p>")
                         personNormal=normalize(person)                      imageCaptions.append(tmp[0].encode('utf-8'))
                         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]])  
   
             except:  
                 print "ERROR",project  
                                   
         return list  
   
     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:                  else:
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])                      #keine caption
   
         if RESPONSE is not None:                      imageCaptions.append("")
             RESPONSE.redirect("showHistoricalPersons")  
                           
   
     def getPersonDict(self,name):          #eintragen:
         """name von dict"""          for imageURL in imageURLs:
               filename=imageURL.split("/")[-1]
               #lege neues images object an, mit leerem bild
   
         try:              if self.ZopeFind(self,obj_ids=[filename]):
             return self.personDict[name][0].encode('utf-8')                  #existiert das bild schon, dann neuen filenamen
                   filename="project_image_"+filename
               
               self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
               #hole die bilddaten aus der url
               url=self.absolute_url()+"/"+imageURL
               #url=self.absolute_url()+"/"+filename
           
               try:#relative url
                   data=urllib.urlopen(url).read()
               except:
                   try:#absolute
                       data=urllib.urlopen(self.imageURL).read()
         except:          except:
             return self.personDict[name][0]                      logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
             return self.personDict[name][0].decode('latin-1').encode('utf-8')  
                   
               obj=getattr(self,filename)
               obj.update_data(data)
   
     def showHistoricalPersons(self):          if RESPONSE:
         """show persons"""              RESPONSE.redirect('manageImages')
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)  
         return pt()  
   
       def manageImages(self,imageName=None,op=None):
           """managage images"""
                   
     def editHistoricalPersonsForm(self):  
         """edit historical persons for consistency"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)  
         return pt()  
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):          if imageName and op:
         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""              if op=='up':
         if type(fieldContentsEntry) is StringType:                  images=self.getImages()
             fieldContents=[fieldContentsEntry]                  for image in images:
         else:                      if image[0]==imageName:
             fieldContents=fieldContentsEntry                          nr=images.index(image)
                           if not nr==0:
                               images[nr-1][1].place+=1
                               images[nr][1].place-=1
                           pass
               elif op=='down':
                   images=self.getImages()
                   for image in images:
                       if image[0]==imageName:
                           nr=images.index(image)
                           if not (nr==len(images)-1):
                               images[nr+1][1].place-=1
                               images[nr][1].place+=1
                           pass
                           
         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})  
         #print projects  
         return projects  
   
     def changeMPIWGRootForm(self):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
         """edit"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)  
         return pt()          return pt()
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):      def managePublications(self,pubName=None,op=None):
         """change"""          """managage images"""
         self.title=title  
         self.disciplineList=disciplineList  
         self.themesList=themesList  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def getDisciplineList(self):          if pubName and op:
         """get disciplines as list"""              if op=='up':
         return self.disciplineList.split("\n")                  publications=self.getPublications()
                       for publication in publications:
     def getThemeList(self):                      if publication[0]==pubName:
         """get themes as list"""                          nr=publications.index(publication)
         return self.themesList.split("\n")                          if not nr==0:
                                   publications[nr-1][1].place+=1
     def test(self):                              publications[nr][1].place-=1
         """test"""                          pass
         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url              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
   
     def getContexts(self,childs=None,parents=None,depth=None):  
         """childs alle childs, alle parents"""  
         ret=[]  
         if parents:  
             splitted=parents.split(".")  
             parentId=string.join(splitted[0:len(splitted)-1],".")  
                   
             for project in self.getProjectFields('xdata_05',sort='int'):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
                 if project[1]==parentId:          return pt()
                     ret.append(project)      def hasExtendedPublicationList(self):
           """test if extended publication list exists"""
           if not hasattr(self,"publicationList"):
               return False
           else:
               return True
   
         if childs:      def createExtendedPublicationList(self,RESPONSE=None):
             for project in self.getProjectFields('xdata_05',sort='int'):          """erzeuge erweiterte publications liste"""
                 searchStr=childs+"(\..*)"          pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
                 if re.match(searchStr,project[1]):          self._setObject("publicationList", pl)
                                           
                     if depth:  
   
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):          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')
                                           
                             ret.append(project)  
                     else:  
                         ret.append(project)  
         return ret  
           
     def getProjectFields(self,fieldName,folder=None,sort=None):          if RESPONSE:
         """getListofFieldNames"""              RESPONSE.redirect("managePublications")
         ret=[]  
         #print "FN",fieldName  
         if not folder:  
             folder=self  
         for object in folder.__dict__:  
   
             obj=getattr(folder,object)      def getPublications(self):
             if hasattr(obj,'meta_type'):          """get all Publications"""
                 #print obj.meta_type          def sort_images(x,y):
                 if obj.meta_type=='MPIWGProject':              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                     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:          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
                                           
                     ret += self.getProjectFields(fieldName,obj)          publications.sort(sort_images)
           return publications
   
         if sort=="int":      def addPublication(self,text,RESPONSE=None):
             ret.sort(sortI)          """add an MPIWG_Publication"""
         else:  
             ret.sort(sortF)  
           
         return ret  
   
     def showNewProjects(self):          name="publication_"+str(self.getLastPublicationNumber()+1)
         projects=[]  
         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets  
             if objs[0].xdata_05[0] == "":  
                                   
                 projects.append(objs)          newPublication=MPIWGProject_publication(name)
                                   
         return projects          self._setObject(name,newPublication)
           obj=getattr(self,name)
           obj.text=text[0:]
           obj.enabled=True;
           obj.place=self.getLastPublicationNumber()+1
           obj.id=name
           
           if RESPONSE is not None:
               RESPONSE.redirect('managePublications')
                   
     manage_options = Folder.manage_options+(  
         {'label':'Import Persons','action':'importNamesForm'},  
         {'label':'Main config','action':'changeMPIWGRootForm'},  
         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},  
         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},  
         )  
           
     def importNamesForm(self):      def getLastPublicationNumber(self):
         """Form"""          publications=self.getPublications()
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)  
         return pt()  
   
     def importNames(self,fileupload,folderName,RESPONSE=None):          if not publications:
         """import komma-sep list email,lastName,firstName"""              return 0
         project=getattr(self,folderName)          else:
         load=fileupload.read()              return getattr(publications[-1][1],'place',0)
                   
         for line in load.split('\r'):      def deletePublication(self,id,RESPONSE=None):
               """delete Publication id"""
               self.manage_delObjects([id])
               if RESPONSE:
                   RESPONSE.redirect('managePublications')
                           
       def getImages(self):
           """get all Images"""
                           
             splitted=line.split(",")          def sort_images(x,y):
             print splitted              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                   
             if not (splitted[0]==""):  
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])  
                                   
           if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
                 try:                  try:
                     project._setObject(splitted[0],newObj)                  self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
                     print "done:",splitted[0]  
                 except:                  except:
                     print "not done:",splitted[0]                  pass
               self.imageURL=''
               self.imagecap=''
                                           
         if RESPONSE is not None:          images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
             RESPONSE.redirect('manage_main')  
   
     def getAllMembers(self):  
         """give list of all members"""  
         ret=[]  
   
         #for x in self.members.objectValues('MPIWGStaff'):          images.sort(sort_images)
             #print x.title          return images
         #    ret.append(x.title.decode('utf-8'))  
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):      def getLastImageNumber(self):
                                ret.append(x[1].title.decode('utf-8'))          images=self.getImages()
                           
         #ret.sort()          if not images:
         #print ret              return 0
           else:
               return getattr(images[-1][1],'place',0)
       
         return ret      def deleteImage(self,id,RESPONSE=None):
           """delete Image id"""
           self.manage_delObjects([id])
           if RESPONSE:
               RESPONSE.redirect('manageImages')
   
     def printAllMembers(self):  
         """prin"""  
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
           
       def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
           """check if project has children"""
           ct=self.getContexts(childs=self.getContent('xdata_05'),
                                    depth=1,date=date,onlyActive=onlyActive)
                   
     def makeList(self,entry):          if ct and len(ct)>0:
         """makes a list out of one entry or repeat a list"""               return True
         if type(entry) is StringType:  
             return [entry]  
         else:          else:
             return entry               return False
   
   
     def getTree(self):      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
         """generate Tree from project list"""          """add an MPIWG_Project_image"""
         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  
                     title=[project[0].getContent('WEB_title')]  
                     #print title  
                                           
                     returnList.append((depth,nr,title,project[0]))          if not filename:
               filename=fileHd.filename
                   
         return returnList          if not fileHd:
               fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
   
     def formatElementForOverview(self,element):          newImage=MPIWGProject_image(filename,filename,fileHd)
         """format the element for output in overview"""  
         if element[0]==1: #department  
             return "<h2>Department %s: %s</h2>"%(element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))  
   
         elif element[0]==2: #mainprojects          self._setObject(filename,newImage)
             return "<h3>%s</h3><p>"%(element[3].getContent('WEB_title'))          obj=getattr(self,filename)
           obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
   
         elif element[0]==3:          if RESPONSE is not None:
             return "<br>%s"%(element[3].getContent('WEB_title'))              RESPONSE.redirect('manageImages')
                   
     def changePosition(self,treeId,select,RESPONSE=None):      def PrincipiaSearchSource(self):
         """Change Postion Entry"""          """Return cataloguable key for ourselves."""
         numbers=[]          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:
               return ""
   
         # Suche hoechste bisherige nummer      def getActualVersion(self,date=None):
         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05          """actuelle version"""
         #print "pj",projects          def sortProjectsByTime(x,y):
         for project in projects: #suche alle subtrees der treeId              return cmp(x[1].archiveTime,y[1].archiveTime)
             #print treeId  
           if not date:
               if self.isActual():
                   return self
               else:
                   return None
                           
             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])          #suche ob aeltere versionen vorhanden sind
             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))  
   
         try:          finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
             highest=max(numbers)          if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
         except:              ad=getattr(self,'creationTime','20050101000000')
             highest=0              if int(date)>int(ad):
         projects=self.showNewProjects()                  return self
         for i in self.makeList(select):              else:
             highest+=10                  return None
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)  
   
   
         if RESPONSE is not None:          else:
             RESPONSE.redirect('showTree')              finds.sort(sortProjectsByTime)
                   
     def changeTree(self,RESPONSE=None):          for find in finds:
         """change the complete tree"""              #gehe durch die alten Projekte und finde das entprechende
         form=self.REQUEST.form              if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
         hashList={}                  return find[1]
         fields=self.getTree()  
   
           #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
                   
         for idNr in form.keys():          if int(date)>int(ad):
             fields[int(idNr)][3].xdata_05=form[idNr]  
   
               return self
           else:
               return None
                   
   
         if RESPONSE is not None:      def isActual(self):
             RESPONSE.redirect('showTree')          """gibt 1 zurueck wenn aktuell, 0 sonst"""
           actualTime=time.localtime()
   
     def getProjectWithId(self,id):  
         fields=self.getProjectFields('xdata_05')  
         for field in fields:  
             if field[1]==id:  
                 return field[0]  
   
         return None          #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return 0
           else:
               return 1
                           
       def copyObjectToArchive(self):
           """kopiere aktuelles objekt ins archiv"""
           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()
                   
       def versionManage(self,invisible=None,RESPONSE=None):
           """version Manage form:currently only set to invisible"""
           self.invisible=invisible
                           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                   
     def getRelativeUrlFromPerson(self,list):  
         """get urls to person list"""  
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen      def crossLinker(self):
                 splitted=person.split(",")          """experimental crosslinker"""
                 if len(splitted)==1:          splitted=self.WEB_project_description[0].split()
                     splitted=person.split(" ")          new=[]
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]          for split in splitted:
                 if splittedNew[0]=='':              try:
                     del splittedNew[0]                  found=self.DescriptionCatalog({'fulltext':split})
                 search=string.join(splittedNew,' AND ')  
                                   
                 if not search=='':                  if len(found)>1:
   
                     try:                      new.append("<a href=%s>%s</a>"%(split,split))
                         proj=self.MembersCatalog({'title':search})                  else:
                       new.append(split)
                     except:                      except:
                         proj=None                  new.append(split)
           return " ".join(new)
   
                 if proj:  
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))  
                     ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id,person))  
                 else:  
                     #ret.append("%s"%person.encode('utf-8'))  
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                   
                           
     def getUrlFromPerson(self,list):  
         """get urls to person list"""  
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen      def generateTemplate(self,RESPONSE=None):
                 splitted=person.split(",")          """Erzeuge Template fuer defined fields not_used"""
                 if len(splitted)==1:  
                     splitted=person.split(" ")          id="index_html"
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]          title=id
                 if splittedNew[0]=='':          if self._getOb('index_html'):
                     del splittedNew[0]              self._delObject('index_html')
                 search=string.join(splittedNew,' AND ')  
                                   
                 if not search=='':          newObj=ZopePageTemplate(id,'TEXT')
           self._setObject(id,newObj)
           #self.manage_addPageTemplate(id,title)
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
               
       def __init__(self, id, argv=None):
           """initiere classe"""
   
           self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
           self.id=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:
               for arg in definedFields:
                     try:                      try:
                         proj=self.MembersCatalog({'title':search})                          setattr(self,arg,argv[arg])
                     except:                      except:
                         proj=None                          setattr(self,arg,"")
   
                 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:                  else:
                     #ret.append("%s"%person.encode('utf-8'))              for arg in definedFields:
                     ret.append("%s"%person)                  setattr(self,arg,'')
         return string.join(ret,";")  
                                                     
     def getProjectsOfMembers(self):      manage_options = Folder.manage_options+(
         """give tuple member /projects"""          {'label':'Load New File','action':'loadNewFileForm'},
         ret=[]          {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
         members=self.getAllMembers()          {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
         #return str(members)          {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
         for x in members:          {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
             ret+=self.getProjectsOfMember(name=x)          {'label':'Versionmanager','action':'versionManageForm'},
           )
   
         return ret  
   
     def getProjectsOfMember(self,name=None,email=None):      def isActiveProject(self):
         """get project of a member"""          """check if the project is still active, default is true, set to false is the project is accomplished"""
         def sortP(x,y):          return getattr(self,'isActiveFlag',True)
             """sort by sorting number"""  
                           
             return cmp(x.xdata_05,y.xdata_05)      def isArchivedProject(self):
           """check if the project is archived"""
                   
           completed=getattr(self,'completedAt',0)
     
         ret=[]         #completed leer 
         splitNeu=[]          if completed=="" :
         if email:              return False;
             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email])          if completed == 0:
             name =  members[0][1].title.decode('utf-8')              return False;
   
         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))  
   
                   
         return ret          return True
             
     def givePersonList(self,name):  
         """check if person is in personfolder and return list of person objects"""  
                   
         splitted=name.split(",")      def setActiveFlag(self,status=True):
         if len(splitted)==1:          """set the active flag"""
             splitted=name.split(" ")          self.isActiveFlag=status
         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 setCompletedAt(self,date):
             return [[x.lastName,x.firstName] for x in proj]          """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:          else:
             return []              return False;
                           
 ##         splitted=name.split(",") # version nachname, vorname...      def setStartedAt(self,date):
 ##         if len(splitted)>1:          """set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
 ##             lastName=splitted[0]           logging.info("DATE:"+repr(date))
 ##             firstName=splitted[1]          transformedDate=self.transformDate(date);
 ##         else:           logging.info("transformed"+repr(transformedDate))
 ##             splitted=name.split(" ") #version vorname irgenwas nachnamae          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:
               return '';
                   
 ##             lastName=splitted[len(splitted)-1]      def getStartedAt(self):
 ##             firstName=string.join(splitted[0:len(splitted)-1])          """gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
           date=getattr(self,'startedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
   
 ##         objs=[]      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);
   
         #print  self.members           return """%s.%s.%s"""%(day,month,year);
       ##   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 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;
                   
         return objs  
   
           if (date.lstrip().rstrip()=="" ) :
               return "";
   
     def personCheck(self,names):          splitted=date.split(".")
         """all persons for list"""          length=len(splitted)
         #print "names",names          year=0
         splitted=names.split(";")          month=0
         ret={}          day=0
         for name in splitted:          if length > 3:
               return "";
           if length==3:
               day = int(splitted[0])
           if length>1:
               month=int(splitted[length-2])
   
             if not (name==""):          if length > 0:
                 try:                  try:
                     ret[name]=self.givePersonList(name)                  year = int(splitted[length-1])
                 except:                  except:
                     """NOTHIHN"""                  pass
         #print "RET",ret  
         return ret  
   
     def giveCheckList(self,person,fieldname):         ## logging.info("month:"+(month))
         """return checklist"""          if not (0<=month<13):
         #print "GCL",fieldname              return None;
         if fieldname=='xdata_01':  
             x=self.personCheck(person.getContent(fieldname))  
             #print "GCLBACKX",x  
             return x  
                   
           if not(0<=day<32):
               return None;
   
     def isCheckField(self,fieldname):          if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
         """return chechfield"""              year=2000+year;
           return year*10000+month*100+day
                   
         return (fieldname in checkFields)  
   
   
       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)
                   
 def manage_addMPIWGRootForm(self):          #suche ob aeltere versionen vorhanden sind
     """form for adding the root"""  
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)          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()      return pt()
   
 def manage_addMPIWGRoot(self,id,title,RESPONSE=None):      def getGetNeighbourhood(self,wordStr, length=100,tagging=True):
     """add a root folder"""          """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
     newObj=MPIWGRoot(id,title)          alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden 
     self._setObject(id,newObj)          case insensitive gesucht
           @param wordStr: string mit Worten getrennt durch Leerzeichen, Phrasen sind mit " gekennzeichnet
                           "eine phrase", "*"  bezeichnet wildcards und wird ignoriert"
           @param length: optional, default wert 100, 2*length ist die groesse der Umgebung
           @param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false
           """
   
     if RESPONSE is not None:          ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird
         RESPONSE.redirect('manage_main')          ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt
                   
           def isInRanges(nr,length):
               """test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck, 
               -1, wenn kein Treffer
   
 class MPIWGProject(Folder):              @param nr: Position die geprueft werden soll
     """Class for Projects"""              @param length: Laenge des Wortes das geprueft werden soll
               """
               for x in ranges:
                   if (x[0]<=nr) and (nr < (x[1]-length)):
                       return ranges.index(x)
               return -1
   
     meta_type='MPIWGProject'          # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
           def rep_empty(str):
               x= re.sub(" ","_",str.group(0))
               return re.sub("\"","",x)
               
           wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "
           
           #deal with wildcards, for our purposes it is enough to delete the wildcard 
           wordStr=wordStr.replace("*","")
           
           words=wordStr.split(" ")
           #if not words is ListType:
           #   words=[words]
   
     def crossLinker(self):          txt=self.harvest_page()
         """experimental crosslinker"""          if not txt:
         splitted=self.WEB_project_description[0].split()              return ret
         new=[]          txt=re.sub("<.*?>", "", txt) # loesche alle Tags
         for split in splitted:          for word in words:
             try:              word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
                 found=self.DescriptionCatalog({'fulltext':split})              pos=0
                       
                 if len(found)>1:              n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf
                             
                     new.append("<a href=%s>%s</a>"%(split,split))              for i in range(n):
                   pos=txt.lower().find(word.lower(),pos)
   
                   if pos > 0:
                       x=max(0,pos-length)
                       y=min(len(txt),pos+length)
                     
                       
                       #is word already in one of the results
                       nr=isInRanges(pos,len(word))
                       if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese
                           x=min(ranges[nr][0],x)
                           y=max(ranges[nr][1],y)
                 
                       str=txt[x:y]
                   
                       if nr >=0: # word ist in einer schon gefunden Umgebung
                           ranges[nr]=(x,y) # neue Position der Umgebung
   
                           ret[nr]=str # neue Umgebung
                       else: # andernfalls neue Umgebung hinzufuegen
                           ranges.append((x,y))
   
                           ret.append(str)
                       
                       pos=pos+len(word)
                 else:                  else:
                     new.append(split)                      break;
             except:  
                 new.append(split)  
         return string.join(new)  
                           
           # now highlight everything        
           if tagging:
               for x in range(len(ret)):
                   for word in words:
                       repl=re.compile(word,re.IGNORECASE)
                       ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])
                           
           return ret
   
       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())()
   
     def generateTemplate(self,RESPONSE=None):               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
         """Erzeuge Template für defined fields not_used"""  
   
         id="index_html"  
         title=id  
         if self._getOb('index_html'):  
             self._delObject('index_html')  
   
                return pt()
                   
         newObj=ZopePageTemplate(id,'TEXT')      def index_html(self,request=True,context=None):
         self._setObject(id,newObj)          """show homepage"""
         #self.manage_addPageTemplate(id,title)          if not context:
         if RESPONSE is not None:              context=self
             RESPONSE.redirect('manage_main')          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())()
                           
     def __init__(self, id, argv=None):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
         """initieriere classe"""  
                   
         self.id=id          return pt()
         self.title=id  
         if argv:  
             for arg in definedFields:  
         try:  
                     setattr(self,arg,argv[arg])  
         except:  
             setattr(self,arg,"")  
         else:  
             for arg in definedFields:  
                 setattr(self,arg,'')  
                           
     manage_options = Folder.manage_options+(  
         {'label':'Load New File','action':'loadNewFileForm'},  
         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},  
         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},  
         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},  
         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},  
         )  
   
     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 764  class MPIWGProject(Folder): Line 846  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"""
                   
         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=x.decode('latin-1').encode('utf-8')              pass
           
           if text=='':
               text2=text
           else:
               text2=re.sub(r';([^\s])','; \g<1>',text)
                   
         #delete separator (;) if  is there is one          #teste ob ergebnis leer und header dann nehme title
           
           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=""
   
                   split2="</p>".join(tmp[1:])
   
                   text3=splitted[0]+split2
   
         if (type(text)==StringType) or (type(text)==UnicodeType):                  splitted=text3.split("""<p class="picturetitle">""")
             return text                  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:          else:
             return text[0]                  #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()          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()
       
       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 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 = [x[1] for x in getattr(self,"responsibleScientistsList",[])]
               
           if key in keys:
               return True
           else:
               return False
           
       def getPersonKeyList(self):
           """gibt die key Lister der beteiligten Personen zurŸck"""
           return [x[1] for x in getattr(self,'responsibleScientistsList',[])]
          
           
          
               
       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
           """
           nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
           names=nameList.split(",")
           
           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
               logging.info("Search: %s %s %s"%(name,firstname,lastname))
               firstname=firstname.capitalize()
               lastname=lastname.capitalize()
               cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
               
               #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]=[]
          
           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():
                tmpList.append((names[nr],keys.get(nr,"")))
                
           self.responsibleScientistsList=tmpList
           if fromEdit and (RESPONSE is not None):
               #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(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()
               
           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 898  class MPIWGProject(Folder): Line 1261  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.16  
changed lines
  Added in v.1.47.2.90

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