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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.35 and 1.47.2.85

version 1.35, 2004/10/11 14:49:46 version 1.47.2.85, 2008/06/25 06:41:25
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
   s
 """  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  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.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from OFS.Image import Image
 from Globals import package_home  from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  import MPIWGStaff
Line 13  import string Line 15  import string
 import re  import re
 import os  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 Products.ZSQLMethods.SQL import SQLConnectionIDs
   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
   import MPIWGStaff
   
 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']  from MPIWGHelper import *
   
 checkFields = ['xdata_01']  import MPIWGRoot
   import MPIWGLink
   import MPIWGTemplate
   
   class MPIWGRoot(MPIWGRoot.MPIWGRoot):
       """depricated"""
   
   class MPIWGLink(MPIWGLink.MPIWGLink):
       """depricated"""
   
 def sortF(x,y):  class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
     try:      """depricated"""
         return cmp(x[1],y[1])  
     except:  
         try:  
             return cmp(str(x[1]),str(y[1]))  
         except:             
             print "error",x[1],y[1]  
             return 0   
           
 def sortI(x,y):  class MPIWGProject_publication(SimpleItem):
     xsplit=x[1].split(".")      """publications object fuer project"""
     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:      meta_type="MPIWGProject_publication"
                 xret=xret+"%04i"%int(ysplit[i])  
             except:  
                 xret=xret+"%04i"%0  
                                   
       def editPublication(self,text=None,RESPONSE=None):
           """edit a publication"""
                   
         return cmp(int(yret),int(xret))          if (not text):
     except:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
         return cmp(x[1],y[1])              return pt()
   
           
 class MPIWGRoot(ZSQLExtendFolder):          self.text=text[0:]
     """Stammordner für den Web-Server"""  
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',          if RESPONSE:
              'xdata_03':'Historical Persons','xdata_04':'Time period',              RESPONSE.redirect("../managePublications")
              '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']  class MPIWGProject_image(Image):
     meta_type='MPIWGRoot'      """Images for Projects"""
   
     def upDateSQL(self,fileName):      meta_type="MPIWGProject_image"
         """updates SQL databases using fm.jar"""  
         fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')  
         xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)  
   
         os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()      def showImage(self,imageUrl=None):
         return 1          """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 patchProjects(self,RESPONSE):      def editImage(self,file=None,caption=None,RESPONSE=None):
         """patch"""          """edit the Image"""
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])          if (not file) and (not caption):
         for project in projects:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
         tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]              return pt()
                 setattr(project[1],'WEB_project_description',[tmp[0:]])  
                 RESPONSE.write("<p>%s</p>\n"%project[0])  
               
     def replaceNotEmpty(self,format,field):  
         """replace not empty"""  
         if field and (not field==''):  
             return format%field  
         else:  
             return ""  
                   
           if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
   
     def redirectIndex_html(self,request):          if caption:
         #return request['URL1']+'/index_html'              self.caption=caption[0:]
                   
         return urllib.urlopen(request['URL1']+'/index_html').read()          if RESPONSE:
               RESPONSE.redirect("../manageImages")
   
   class MPIWGProject(CatalogAware,Folder):
       """Class for Projects"""
           
     def formatBibliography(self,here,found):  
         """format"""  
         return formatBibliography(here,found)  
           
     def getValue(self,fieldStr):      security=ClassSecurityInfo()
         """Inhalt des Feldes"""      meta_type='MPIWGProject'
       default_catalog='ProjectCatalog'
                   
         if type(fieldStr)==StringType:      def decode(self,str):
             field=fieldStr          """return unicode object"""
         else:          return unicodify(str)
             field=fieldStr[0]  
         try:  
             if field[len(field)-1]==";":  
                 field=field[0:len(field)-1]  
         except:  
   
             """nothing"""      def sortedByPlace(self,metatype):
         field=re.sub(r';([^\s])','; \g<1>',field)          """find metatype and sort by place"""
         return field.encode('utf-8')          def sort(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
           founds=self.ZopeFind(self,obj_metatypes=[metatype]);
   
           founds.sort(sort)
           
     def sortedNames(self,list):          return founds
         """sort names"""  
   
         def sortLastName(x_c,y_c):  
             try:  
                 x=urllib.unquote(x_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(x_c)  
   
             try:      def copyPublicationsToList(self,RESPONSE=None):
                 y=urllib.unquote(y_c).encode('utf-8','ignore')          """copy publications in to list"""
             except:  
                 x=urllib.unquote(y_c)  
                                   
           publicationTxt=self.getContent('WEB_related_pub')
   
           pubSplits=publicationTxt.split("<p>")
                           
             try:          for pubSplit in pubSplits:
                 last_x=x.split()[len(x.split())-1]              pubSplit=pubSplit.replace("</p>","")
                 last_y=y.split()[len(y.split())-1]              self.addPublication(pubSplit)
   
             except:          if RESPONSE:
               RESPONSE.redirect('managePublications')
   
                 last_x=""  
                 last_y=""  
                           
       def copyImageToMargin(self,RESPONSE=None):  
           """copy inline images to marginal images"""
                           
                           
             if last_x<last_y:          #getImages from WEB_project_description
                 return 1          description=self.getContent('WEB_project_description')
             elif last_x>last_y:  
                 return -1  
             else:  
                 return 0  
                           
         list.sort(sortLastName)          text2=description
         list.reverse()          splitted=text2.split("""<p class="picture">""")
                   
         return list          imageURLs=[]
           imageCaptions=[]
           for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
           
     def __init__(self, id, title):                  try:
         """init"""                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
         self.id=id                  except:
         self.title=title  
   
     def urlQuote(self,str):                      try:
         """quote"""                          imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
         return urllib.quote(str)                      except:
                           imageURLs.append("")
   
     def urlUnQuote(self,str):                  split2="</p>".join(tmp[1:])
         """quote"""  
         return urllib.unquote(str)  
           
     def harvestHistoricalPersons(self):  
         """erstelle liste aller erwaehnten actors"""  
   
         def normalize(str):                  splitted=split2.split("""<p class="picturetitle">""")
             """loesche fuhrendes space"""                  if len(splitted)>1:
             if (len(str)>1) and (str[0]==" "):                      tmp=splitted[1].split("</p>")
                 ret=str[1:]                      imageCaptions.append(tmp[0].encode('utf-8'))
             else:  
                 ret=str  
             return ret  
                   
         list={}  
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])  
                   
         for project in projects:                  else:
             lg=len(project[1].xdata_03[0])-1                      #keine caption
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):                      imageCaptions.append("")
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]  
   
                       
           #eintragen:
           for imageURL in imageURLs:
               filename=imageURL.split("/")[-1]
               #lege neues images object an, mit leerem bild
             
               if self.ZopeFind(self,obj_ids=[filename]):
                   #existiert das bild schon, dann neuen filenamen
                   filename="project_image_"+filename
                                   
             try:              self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;              #hole die bilddaten aus der url
                     for person in project[1].xdata_03[0].split(";"):              url=self.absolute_url()+"/"+imageURL
                         personNormal=normalize(person)              #url=self.absolute_url()+"/"+filename
                         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:#relative url
                   data=urllib.urlopen(url).read()
               except:
                   try:#absolute
                       data=urllib.urlopen(self.imageURL).read()
             except:              except:
                 print "ERROR",project                      logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
                                   
         return list              obj=getattr(self,filename)
               obj.update_data(data)
   
     def storeHistoricalPersons(self,RESPONSE=None):          if RESPONSE:
         """store persons"""              RESPONSE.redirect('manageImages')
         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:      def manageImages(self,imageName=None,op=None):
             RESPONSE.redirect("showHistoricalPersons")          """managage images"""
                           
   
     def getPersonDict(self,name):          if imageName and op:
         """name von dict"""              if op=='up':
                   images=self.getImages()
         try:                  for image in images:
             return self.personDict[name][0].encode('utf-8')                      if image[0]==imageName:
         except:                          nr=images.index(image)
             return self.personDict[name][0]                          if not nr==0:
             return self.personDict[name][0].decode('latin-1').encode('utf-8')                              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
                   
   
     def showHistoricalPersons(self):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
         """show persons"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)  
         return pt()          return pt()
   
       def managePublications(self,pubName=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 pubName 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:                  publications=self.getPublications()
             fieldContents=[fieldContentsEntry]                  for publication in publications:
         else:                      if publication[0]==pubName:
             fieldContents=fieldContentsEntry                          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
                           
         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_managePublicationsForm.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 getPublications(self):
         """change"""          """get all Publications"""
         self.title=title          def sort_images(x,y):
         self.disciplineList=disciplineList              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
         self.themesList=themesList  
   
         if RESPONSE is not None:          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
             RESPONSE.redirect('manage_main')  
   
     def getDisciplineList(self):          publications.sort(sort_images)
         """get disciplines as list"""          return publications
         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 addPublication(self,text,RESPONSE=None):
         """childs alle childs, alle parents"""          """add an MPIWG_Publication"""
         ret=[]  
         if parents:  
             splitted=parents.split(".")  
             parentId=string.join(splitted[0:len(splitted)-1],".")  
                   
             for project in self.getProjectFields('xdata_05',sort='int'):          name="publication_"+str(self.getLastPublicationNumber()+1)
                 if project[1]==parentId:  
                     ret.append(project)  
   
         if childs:          newPublication=MPIWGProject_publication(name)
             for project in self.getProjectFields('xdata_05',sort='int'):  
                 searchStr=childs+"(\..*)"  
                 if re.match(searchStr,project[1]):  
                                           
                     if depth:          self._setObject(name,newPublication)
           obj=getattr(self,name)
           obj.text=text[0:]
           obj.enabled=True;
           obj.place=self.getLastPublicationNumber()+1
           obj.id=name
   
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):          if RESPONSE is not None:
               RESPONSE.redirect('managePublications')
                                           
                             ret.append(project)  
                     else:  
                         ret.append(project)  
         return ret  
           
     def getProjectFields(self,fieldName,folder=None,sort=None):      def getLastPublicationNumber(self):
         """getListofFieldNames"""          publications=self.getPublications()
         ret=[]  
         #print "FN",fieldName  
         if not folder:  
             folder=self  
         for object in folder.__dict__:  
   
             obj=getattr(folder,object)          if not publications:
             if hasattr(obj,'meta_type'):              return 0
                 #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:                      else:
                         fieldNameTmp=fieldName              return getattr(publications[-1][1],'place',0)
                       
                     ret.append((obj,obj.getContent(fieldNameTmp)))  
   
                 if obj.meta_type in self.folders:  
                                           
                     ret += self.getProjectFields(fieldName,obj)      def deletePublication(self,id,RESPONSE=None):
               """delete Publication id"""
               self.manage_delObjects([id])
               if RESPONSE:
                   RESPONSE.redirect('managePublications')
   
         if sort=="int":      def getImages(self):
             ret.sort(sortI)          """get all Images"""
         else:  
             ret.sort(sortF)  
                   
         return ret          def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
     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)          if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
               try:
                   self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
               except:
                   pass
               self.imageURL=''
               self.imagecap=''
                                   
         return projects          images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
           
           images.sort(sort_images)
           return images
                   
     manage_options = Folder.manage_options+(      def getLastImageNumber(self):
         {'label':'Import Persons','action':'importNamesForm'},          images=self.getImages()
         {'label':'Main config','action':'changeMPIWGRootForm'},  
         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},  
         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},  
         )  
           
     def importNamesForm(self):          if not images:
         """Form"""              return 0
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)          else:
         return pt()              return getattr(images[-1][1],'place',0)
   
     def importNames(self,fileupload,folderName,RESPONSE=None):      def deleteImage(self,id,RESPONSE=None):
         """import komma-sep list email,lastName,firstName"""          """delete Image id"""
         project=getattr(self,folderName)          self.manage_delObjects([id])
         load=fileupload.read()          if RESPONSE:
               RESPONSE.redirect('manageImages')
                   
         for line in load.split('\r'):  
                           
       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)
                           
             splitted=line.split(",")          if ct and len(ct)>0:
            # print splitted               return True
           else:
                return False
                   
             if not (splitted[0]==""):  
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])  
                                   
                 try:      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
                     project._setObject(splitted[0],newObj)          """add an MPIWG_Project_image"""
                     #print "done:",splitted[0]  
                 except:  
                     print "not done:",splitted[0]  
                                           
         if RESPONSE is not None:          if not filename:
             RESPONSE.redirect('manage_main')              filename=fileHd.filename
   
     def getAllMembers(self):          if not fileHd:
         """give list of all members"""              fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
         ret=[]  
   
         #for x in self.members.objectValues('MPIWGStaff'):          newImage=MPIWGProject_image(filename,filename,fileHd)
             #print x.title  
         #    ret.append(x.title.decode('utf-8'))  
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):          self._setObject(filename,newImage)
                                ret.append(x[1].title.decode('utf-8'))          obj=getattr(self,filename)
           obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
                           
         ret.sort()          if RESPONSE is not None:
         #print ret              RESPONSE.redirect('manageImages')
     
         return ret  
   
     def printAllMembers(self):  
         """prin"""  
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
           
       def PrincipiaSearchSource(self):
           """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:
               return ""
                   
     def makeList(self,entry):      def getActualVersion(self,date=None):
         """makes a list out of one entry or repeat a list"""          """actuelle version"""
         if type(entry) is StringType:          def sortProjectsByTime(x,y):
             return [entry]              return cmp(x[1].archiveTime,y[1].archiveTime)
   
           if not date:
               if self.isActual():
                   return self
         else:          else:
             return entry                  return None
   
           #suche ob aeltere versionen vorhanden sind
   
     def getTree(self):          finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
         """generate Tree from project list"""          if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
         returnList=[]              ad=getattr(self,'creationTime','20050101000000')
         for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05              if int(date)>int(ad):
             for idNr in project[1].split(";"): # more than one number                  return self
                 if not idNr=="":              else:
                     splittedId=idNr.split(".")                  return None
                     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]))  
                   
         return returnList  
   
           else:
               finds.sort(sortProjectsByTime)
   
     def formatElementForOverview(self,element):          for find in finds:
         """format the element for output in overview"""              #gehe durch die alten Projekte und finde das entprechende
         if element[0]==1: #department              if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
             #print element[3].getContent('xdata_05')                  return find[1]
             if element[3].getContent('xdata_05') == "4":  
                 return """<h2 class="hier"><a href="%s">Ind. Research Group I: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
             if element[3].getContent('xdata_05') == "5":  
                 return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
                           
             return """<h2 class="hier"><a href="%s">Department %s: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))          #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
   
         elif element[0]==2: #mainprojects          if int(date)>int(ad):
             return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
   
         elif element[0]==3:              return self
             return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))          else:
               return None
   
                   
     def changePosition(self,treeId,select,RESPONSE=None):      def isActual(self):
         """Change Postion Entry"""          """gibt 1 zurueck wenn aktuell, 0 sonst"""
         numbers=[]          actualTime=time.localtime()
   
         # Suche hoechste bisherige nummer  
         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05  
         #print "pj",projects  
         for project in projects: #suche alle subtrees der treeId  
             #print treeId  
                           
             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])          #print getattr(self,'archiveTime',actualTime)
             if founds:          if getattr(self,'archiveTime',actualTime)< actualTime:
                 #print "x",founds.group(0),len(founds.group(0).split("."))              return 0
                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene          else:
                     try:              return 1
                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))  
                     except:  
                         numbers.append(int(0))  
   
         try:      def copyObjectToArchive(self):
             highest=max(numbers)          """kopiere aktuelles objekt ins archiv"""
         except:          cb=self.aq_parent.manage_copyObjects(self.getId())
             highest=0          self.manage_pasteObjects(cb)
         projects=self.showNewProjects()          actualTime=time.localtime()
         for i in self.makeList(select):          
             highest+=10          self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)          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:          if RESPONSE is not None:
             RESPONSE.redirect('showTree')              RESPONSE.redirect('manage_main')
           
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
                   
         for idNr in form.keys():      def crossLinker(self):
             fields[int(idNr)][3].xdata_05=form[idNr]          """experimental crosslinker"""
           splitted=self.WEB_project_description[0].split()
           new=[]
           for split in splitted:
               try:
                   found=self.DescriptionCatalog({'fulltext':split})
   
                   if len(found)>1:
                   
                       new.append("<a href=%s>%s</a>"%(split,split))
                   else:
                       new.append(split)
               except:
                   new.append(split)
           return string.join(new)
   
         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  
                           
       def generateTemplate(self,RESPONSE=None):
           """Erzeuge Template fuer defined fields not_used"""
                   
           id="index_html"
           title=id
           if self._getOb('index_html'):
               self._delObject('index_html')
                           
                   
     def getRelativeUrlFromPerson(self,list):          newObj=ZopePageTemplate(id,'TEXT')
         """get urls to person list"""          self._setObject(id,newObj)
         ret=[]          #self.manage_addPageTemplate(id,title)
         persons=list.split(";")          if RESPONSE is not None:
         for person in persons:              RESPONSE.redirect('manage_main')
                           
             if len(person)>1: #nicht nur Trennzeichen      def __init__(self, id, argv=None):
                 splitted=person.split(",")          """initiere classe"""
                 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=='':          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>"%('members/'+proj[0].id+'/index.html',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 getUrlFromPerson(self,list):  
         """get urls to person list"""  
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
               
             if len(person)>1: #nicht nur Trennzeichen  
                 splitted=person.split(",")  
                 if len(splitted)==1:  
                     splitted=person.lstrip().rstrip().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=='':  
   
                     try:  
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 if proj:      manage_options = Folder.manage_options+(
             if person =="Otto Sibum" : person="H. Otto Sibum"          {'label':'Load New File','action':'loadNewFileForm'},
             if person =="Norton Wise" : person="M. Norton Wise"          {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))          {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))          {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
                 else:          {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
                     #ret.append("%s"%person.encode('utf-8'))          {'label':'Versionmanager','action':'versionManageForm'},
                     ret.append("%s"%person)          )
         return string.join(ret,";")  
                                                     
     def getProjectsOfMembers(self):  
         """give tuple member /projects"""  
         ret=[]  
         members=self.getAllMembers()  
         #return str(members)  
         for x in members:  
             ret+=self.getProjectsOfMember(name=x)  
                           
         return ret      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 getProjectsOfMember(self,name=None,email=None):      def isArchivedProject(self):
         """get project of a member"""          """check if the project is archived"""
         def sortP(x,y):  
             """sort by sorting number"""  
             #print x.xdata_05,y.xdata_05  
             return cmp(x.WEB_title,y.WEB_title)  
                   
           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(",")  
         #XXXX  
         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]  
                   
         #for s in splitted:          return True
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
                   
         proj=self.ProjectCatalog({'xdata_01':search})  
   
         if proj:      def setActiveFlag(self,status=True):
             proj2=[]          """set the active flag"""
             for x in proj:          self.isActiveFlag=status
                             
                 if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):      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;
                                                 
                        #print repr(splitted[1]),repr(splitted[0]),repr(x.WEB_title)      def getCompletedAt(self):
                        proj2.append(x)          """gibt das transformierte Datum zurŸck"""
         #    proj2.sort(sortP)          date=getattr(self,'completedAt','')
         #    ret.append((y,proj2))          if date:
               return self.reTransformDate(date);
         else:          else:
             proj2=[]              return '';
                           
         proj=self.ProjectCatalog({'xdata_08':search})      def reTransformDate(self,date):
         if proj:          """transformiert , transformdate zurueck"""
             names=[x.WEB_title for x in proj]          year=int(date/10000)
             for x in proj:          month=int((date-year*10000)/100)
                 if not x.WEB_title in names:          day=int((date-year*10000-month*100))
                     proj2.append(x)          return """%s.%s.%s"""%(day,month,year);
   
   
         proj2.sort(sortP)      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 len(proj2)>0:          if (date=="" ) :
             ret.append((y,proj2))              return "";
   
         return ret          if (date==None):
               return None;
             
     def givePersonList(self,name):          splitted=date.split(".")
         """check if person is in personfolder and return list of person objects"""          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])
                   
         splitted=name.split(",")          if length > 0:
         if len(splitted)==1:              try:
             splitted=name.lstrip().rstrip().split(" ")                  year = int(splitted[length-1])
         splittedNew=[split.lstrip() for split in splitted]              except:
                   pass
                   
         if splittedNew[0]=='':         ## logging.info("month:"+(month))
             del splittedNew[0]          if not (0<=month<13):
         search=string.join(splittedNew,' AND ')              return None;
         if not search=='':  
             proj=self.MembersCatalog({'title':search})  
   
         if proj:          if not(0<=day<32):
             return [[x.lastName,x.firstName] for x in proj]              return None;
         else:  
             return []  
                           
 ##         splitted=name.split(",") # version nachname, vorname...          if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
 ##         if len(splitted)>1:              year=2000+year;
 ##             lastName=splitted[0]           return year*10000+month*100+day
 ##             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       def checkDate(self,date):
       ##   for x in self.members.__dict__:          """teste ob zum Zeitpunkt date eine andere version existierte"""
 ##             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 sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           #suche ob aeltere versionen vorhanden sind
                   
         return objs          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"
   
   
     def personCheck(self,names):          else:
         """all persons for list"""              finds.sort(sortProjectsByTime)
         #print "names",names  
         splitted=names.split(";")  
         ret={}  
         for name in splitted:  
   
             if not (name==""):          for find in finds:
                 try:              #gehe durch die alten Projekte und finde das entprechende
                     ret[name]=self.givePersonList(name)              if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                 except:                  return self.REQUEST['URL1']+"/"+find[1].getId()
                     """NOTHIHN"""  
         #print "RET",ret  
         return ret  
   
     def giveCheckList(self,person,fieldname):          #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
         """return checklist"""          ad=getattr(self,'creationTime','20050101000000')
         #print "GCL",fieldname  
         if fieldname=='xdata_01':  
             x=self.personCheck(person.getContent(fieldname))  
             #print "GCLBACKX",x  
             return x  
                   
           if int(date)>int(ad):
   
     def isCheckField(self,fieldname):              return self.REQUEST['URL1']+"/"+self.getId()
         """return chechfield"""          else:
               return self.REQUEST['URL1']+"/no_project"
                   
         return (fieldname in checkFields)  
   
       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 getGetNeighbourhood(self,wordStr, length=100,tagging=True):
           """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
           alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden 
           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
           """
           
           ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird
           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
                   
 def manage_addMPIWGRootForm(self):              @param nr: Position die geprueft werden soll
     """form for adding the root"""              @param length: Laenge des Wortes das geprueft werden soll
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)              """
     return pt()              for x in ranges:
                   if (x[0]<=nr) and (nr < (x[1]-length)):
                       return ranges.index(x)
               return -1
   
 def manage_addMPIWGRoot(self,id,title,RESPONSE=None):          # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
     """add a root folder"""          def rep_empty(str):
     newObj=MPIWGRoot(id,title)              x= re.sub(" ","_",str.group(0))
     self._setObject(id,newObj)              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]
   
     if RESPONSE is not None:          txt=self.harvest_page()
         RESPONSE.redirect('manage_main')          if not txt:
               return ret
           txt=re.sub("<.*?>", "", txt) # loesche alle Tags
           for word in words:
               word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
               pos=0
                   
               n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf
   
 class MPIWGProject(Folder):              for i in range(n):
     """Class for Projects"""                  pos=txt.lower().find(word.lower(),pos)
   
     meta_type='MPIWGProject'                  if pos > 0:
                       x=max(0,pos-length)
                       y=min(len(txt),pos+length)
   
     def crossLinker(self):  
         """experimental crosslinker"""  
         splitted=self.WEB_project_description[0].split()  
         new=[]  
         for split in splitted:  
             try:  
                 found=self.DescriptionCatalog({'fulltext':split})  
                       
                 if len(found)>1:                      #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)
                             
                     new.append("<a href=%s>%s</a>"%(split,split))                      str=txt[x:y]
                 else:  
                     new.append(split)  
             except:  
                 new.append(split)  
         return string.join(new)  
                           
                       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)
   
     def generateTemplate(self,RESPONSE=None):                      pos=pos+len(word)
         """Erzeuge Template für defined fields not_used"""                  else:
                       break;
   
         id="index_html"          # now highlight everything        
         title=id          if tagging:
         if self._getOb('index_html'):              for x in range(len(ret)):
             self._delObject('index_html')                  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
                   
         newObj=ZopePageTemplate(id,'TEXT')      def harvest_page(self,context=None):
         self._setObject(id,newObj)          """seite fuer harvesting fuer die Projektsuche"""
         #self.manage_addPageTemplate(id,title)          if not context:
         if RESPONSE is not None:              context=self
             RESPONSE.redirect('manage_main')  
                           
     def __init__(self, id, argv=None):          if self.isActiveProject() and self.isActual():
         """initieriere classe"""               ext=getattr(self,"harvest_main",None)
                if ext:
                    return getattr(self,ext.getId())()
                   
         self.id=id               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
         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'},  
         )  
   
                return pt()
   
     def index_html(self):      def index_html(self,request=True,context=None):
         """show homepage"""          """show homepage"""
     ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])          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:          if ext:
             return getattr(self,ext[0][1].getId())()              return getattr(self,ext.getId())()
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
   
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/project_main').__of__(self)  
         return pt()          return pt()
   
       
     def getDataFields(self):      def getDataFields(self):
         """giveListofDatafields"""          """giveListofDatafields"""
         ret=[]          ret=[]
Line 833  class MPIWGProject(Folder): Line 796  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:  
                 try:  
                     text =x.encode('utf-8')  
                 except:                  except:
                     text=x.decode('latin-1').encode('utf-8')                  text = x
               
           
                   
         #delete separator (;) if  is there is one  
         ## try:  
 ##             print text, text[len(text)-1]  
 ##         except:  
 ##             print "error:",text  
         try:          try:
             if text[len(text)-1]==";":              if text[len(text)-1]==";":
                 text=text[0:len(text)-1]                  text=text[0:len(text)-1]
                       
                                   
         except:          except:
             """nothing"""              pass
   
           if text=='':
               text2=text
           else:
         text2=re.sub(r';([^\s])','; \g<1>',text)          text2=re.sub(r';([^\s])','; \g<1>',text)
   
         #teste ob ergebnis leer und header dann nehme title          #teste ob ergebnis leer und header dann nehme title
                   
         if (text2=='') and (field=='WEB_project_header'):          if (text2=='') and (field=='WEB_project_header'):
             return self.getContent('WEB_title')              return self.getContent('WEB_title')
   
         #teste ob WEB_project_description und keine führenden p tags          if filter:
         if (len(text2)>4) and (not text2[0:3]=='<p>') and (field=='WEB_project_description'):              splitted=text2.split("""<p class="picture">""")
             return "<p>"+text2+"</p>"              if len(splitted)>1:
         #if text2=="Otto Sibum":                  tmp=splitted[1].split("</p>")
         #text2="H. Otto Sibum"                  #return repr(splitted[1])
         return text2                  try:
                           self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                   except:
                       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
   
                   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()          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))
               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')
           
           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:
Line 920  class MPIWGProject(Folder): Line 1126  class MPIWGProject(Folder):
         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 980  class MPIWGProject(Folder): Line 1205  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):
Line 988  def manage_addMPIWGProject(self,id,RESPO Line 1213  def manage_addMPIWGProject(self,id,RESPO
     #print argv      #print argv
     fileupload=self.REQUEST.get('fileupload',None)      fileupload=self.REQUEST.get('fileupload',None)
     if fileupload:      if fileupload:
         print fileupload  
         file_name=fileupload.filename          file_name=fileupload.filename
         filedata=fileupload.read()          filedata=fileupload.read()
                   
Removed from v.1.35  
changed lines
  Added in v.1.47.2.85

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