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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.47.2.12 and 1.47.2.84

version 1.47.2.12, 2005/06/08 20:13:17 version 1.47.2.84, 2008/06/24 11:16:26
Line 7  from Products.PageTemplates.PageTemplate Line 7  from Products.PageTemplates.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 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 14  import string Line 15  import string
 import re  import re
 import os  import os
 from types import *  from types import *
 import zLOG  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 Products.ZSQLMethods.SQL import SQLConnectionIDs
   from AccessControl import ClassSecurityInfo
 from bibliography import *  from bibliography import *
 import time  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"""
   
 def sortF(x,y):  class MPIWGLink(MPIWGLink.MPIWGLink):
     try:      """depricated"""
         return cmp(x[1],y[1])  
     except:  
         try:  
             return cmp(str(x[1]),str(y[1]))  
         except:             
                           
             return 0   class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
       """depricated"""
           
 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])  
   
 class MPIWGTemplate(ZopePageTemplate):  
     """Create a layout Template for different purposes"""  
   
     meta_type="MPIWGTemplate"  
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Change Weight','action':'changeWeightForm'},  
         )  
   
     def changeWeightForm(self):  
         """change weight form"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGTemplateChangeWeight.zpt')).__of__(self)  
         return pt()          return pt()
   
     def changeWeight(self,weight,RESPONSE=None):  
         """change weight"""  
         self.weight=weight  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage')  
   
                   
     def __init__(self, id, text=None, content_type=None,MPIWGType=None):          self.text=text[0:]
         self.id = str(id)  
   
           if RESPONSE:
               RESPONSE.redirect("../managePublications")
   
   class MPIWGProject_image(Image):
       """Images for Projects"""
   
         self.ZBindings_edit(self._default_bindings)      meta_type="MPIWGProject_image"
         if text is None:  
             self._default_content_fn = os.path.join(package_home(globals()),  
                                                'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)  
             text = open(self._default_content_fn).read()  
         self.pt_edit(text, content_type)  
   
           def showImage(self,imageUrl=None):
         """change form"""          """show Images at an extra page"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
     def isActive(self):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
         """teste ob ausgewaehlt"""  
         if self.absolute_url()==self.REQUEST['URL']:  
             return "aktiv"  
         else:  
             return ""  
       
 def manage_addMPIWGTemplateForm(self):  
     """Form for adding"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)  
     return pt()      return pt()
   
 from urllib import quote      def editImage(self,file=None,caption=None,RESPONSE=None):
           """edit the Image"""
           if (not file) and (not caption):
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
     "Add a Page Template with optional file content."              return pt()
     if type(MPIWGType)==StringType:  
         MPIWGTypes=[MPIWGType]  
     else:  
         MPIWGTypes=MPIWGType  
           
     for singleType in MPIWGTypes:  
   
   
         if REQUEST is None:  
             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))  
             ob = getattr(self, id)  
               
             if title:  
                 ob.pt_setTitle(title)  
             return ob  
         else:  
             file = REQUEST.form.get('file')  
             headers = getattr(file, 'headers', None)  
             if headers is None or not file.filename:  
                 zpt = MPIWGTemplate(id,MPIWGType=singleType)  
             else:  
                 zpt = MPIWGTemplate(id, file, headers.get('content_type'))  
   
             self._setObject(id, zpt)  
             ob = getattr(self, id)  
             if title:  
                 ob.pt_setTitle(title)  
   
             try:  
                 u = self.DestinationURL()  
             except AttributeError:  
                 u = REQUEST['URL1']  
   
     ob = getattr(self, id)  
     ob.weight=weight  
       
     REQUEST.RESPONSE.redirect(u+'/manage_main')  
     return ''  
   
       
 class MPIWGRoot(ZSQLExtendFolder):  
     """Stammordner für den Web-Server"""  
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',          if file and (not file.filename.lstrip().rstrip()==""):
              'xdata_03':'Historical Persons','xdata_04':'Time period',              self.manage_upload(file)
              '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','ECHO_Navigation']          if caption:
     meta_type='MPIWGRoot'              self.caption=caption[0:]
   
     def getKategory(self,url):          if RESPONSE:
     """kategorie"""              RESPONSE.redirect("../manageImages")
     splitted=url.split("/")  
     return splitted[4]  
   
     def generateUrlProject(self,url,project=None):  class MPIWGProject(CatalogAware,Folder):
         """erzeuge aus absoluter url, relative des Projektes"""      """Class for Projects"""
   
         splitted=url.split("/")  
         length=len(splitted)  
         short=splitted[length-2:length]  
     if project:  
             base=self.REQUEST['URL3']+"/"+"/".join(short)  
     else:  
         base=self.REQUEST['URL1']+"/"+"/".join(short)  
         return base  
       
     def isNewCapital(self,text=None,reset=None):  
         if reset:  
             self.REQUEST['capital']="A"  
             return True  
         else:  
             if len(text)>0 and not (text[0]==self.REQUEST['capital']):  
                 self.REQUEST['capital']=text[0]  
                 return True  
             else:  
                 return False  
                   
     def subNav(self,id):      security=ClassSecurityInfo()
         """return subnav elemente"""      meta_type='MPIWGProject'
         def sortWeight(x,y):      default_catalog='ProjectCatalog'
             x1=int(getattr(x[1],'weight','0'))  
             y1=int(getattr(y[1],'weight','0'))  
             return cmp(x1,y1)  
         if hasattr(self,id):  
             subs=self.ZopeFind(getattr(self,id),obj_metatypes=['MPIWGTemplate'])  
             subret=[]  
             for x in subs:  
                 if not(x[1].title==""):  
                     subret.append(x)  
             subret.sort(sortWeight)  
             return subret  
         else:  
             return None  
     def isActive(self,name):  
         """teste ob subnavigation aktiv"""  
         for part in self.REQUEST['URL'].split("/"):  
             if part==name:  
                 return True  
         return False  
                   
       def decode(self,str):
           """return unicode object"""
           return unicodify(str)
                   
     def upDateSQL(self,fileName):      def sortedByPlace(self,metatype):
         """updates SQL databases using fm.jar"""          """find metatype and sort by place"""
         fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')          def sort(x,y):
         xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
         zLOG.LOG("MPIWG Web",zLOG.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))  
         ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()  
     zLOG.LOG("MPIWG Web",zLOG.INFO,"result convert: %s"%ret)  
         return 1  
           
     def patchProjects(self,RESPONSE):          founds=self.ZopeFind(self,obj_metatypes=[metatype]);
         """patch"""  
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])  
         for project in projects:  
         tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]  
                 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.lstrip()==''):  
             return format%field  
         else:  
             return ""  
                   
           founds.sort(sort)
   
     def isActual(self,project):          return founds
         """checke if project is actual"""  
         actualTime=time.localtime()  
         obj= project.getObject()  
                   
         if getattr(obj,'archiveTime',actualTime)< actualTime:  
             return False  
         else:  
             return True  
                   
     def redirectIndex_html(self,request):      def copyPublicationsToList(self,RESPONSE=None):
         #return request['URL1']+'/index_html'          """copy publications in to list"""
                   
         return urllib.urlopen(request['URL1']+'/index_html').read()          publicationTxt=self.getContent('WEB_related_pub')
   
           pubSplits=publicationTxt.split("<p>")
           
     def formatBibliography(self,here,found):          for pubSplit in pubSplits:
         """format"""              pubSplit=pubSplit.replace("</p>","")
         return formatBibliography(here,found)              self.addPublication(pubSplit)
           
     def getValue(self,fieldStr):          if RESPONSE:
         """Inhalt des Feldes"""              RESPONSE.redirect('managePublications')
                   
         if type(fieldStr)==StringType:  
             field=fieldStr  
         else:  
             field=fieldStr[0]  
         try:  
             if field[len(field)-1]==";":  
                 field=field[0:len(field)-1]  
         except:  
   
             """nothing"""      def copyImageToMargin(self,RESPONSE=None):  
         field=re.sub(r';([^\s])','; \g<1>',field)          """copy inline images to marginal images"""
         return field.encode('utf-8')  
   
   
           #getImages from WEB_project_description
           description=self.getContent('WEB_project_description')
           
     def sortedNames(self,list):          text2=description
         """sort names"""          splitted=text2.split("""<p class="picture">""")
   
         def sortLastName(x_c,y_c):          imageURLs=[]
             try:          imageCaptions=[]
                 x=urllib.unquote(x_c).encode('utf-8','ignore')          for split in  splitted[1:]:
             except:                  tmp=split.split("</p>")
                 x=urllib.unquote(x_c)                  #return repr(splitted[1])
   
             try:              try:
                 y=urllib.unquote(y_c).encode('utf-8','ignore')                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
             except:              except:
                 x=urllib.unquote(y_c)  
                   
   
                           
             try:              try:
                 last_x=x.split()[len(x.split())-1]                          imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
                 last_y=y.split()[len(y.split())-1]  
   
             except:              except:
                           imageURLs.append("")
   
                 last_x=""                  split2="</p>".join(tmp[1:])
                 last_y=""  
               
               
               
             if last_x<last_y:  
                 return 1  
             elif last_x>last_y:  
                 return -1  
             else:  
                 return 0  
               
         list.sort(sortLastName)  
         list.reverse()  
           
         return list  
       
     def __init__(self, id, title):  
         """init"""  
         self.id=id  
         self.title=title  
   
     def urlQuote(self,str):  
         """quote"""  
         return urllib.quote(str)  
   
     def urlUnQuote(self,str):                  splitted=split2.split("""<p class="picturetitle">""")
         """quote"""                  if len(splitted)>1:
         return urllib.unquote(str)                      tmp=splitted[1].split("</p>")
                       imageCaptions.append(tmp[0].encode('utf-8'))
           
     def harvestHistoricalPersons(self):  
         """erstelle liste aller erwaehnten actors"""  
   
         def normalize(str):  
             """loesche fuhrendes space"""  
             if (len(str)>1) and (str[0]==" "):  
                 ret=str[1:]  
             else:              else:
                 ret=str                      #keine caption
             return ret  
           
         list={}  
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])  
           
         for project in projects:  
             lg=len(project[1].xdata_03[0])-1  
   
             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:              except:
                 zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot annalyize: %s"%repr(project))                  try:#absolute
                       data=urllib.urlopen(self.imageURL).read()
                   
         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:  
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])  
   
         if RESPONSE is not None:  
             RESPONSE.redirect("showHistoricalPersons")  
               
   
     def getPersonDict(self,name):  
         """name von dict"""  
   
         try:  
             return self.personDict[name][0].encode('utf-8')  
         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(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)  
         return pt()  
   
                   
     def editHistoricalPersonsForm(self):      def manageImages(self,imageName=None,op=None):
         """edit historical persons for consistency"""          """managage images"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)  
         return pt()  
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):  
         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""  
         def sort(x,y):  
         return cmp(x.WEB_title[0],y.WEB_title[0])  
   
     if type(fieldContentsEntry) is StringType:          if imageName and op:
             fieldContents=[fieldContentsEntry]              if op=='up':
         else:                  images=self.getImages()
             fieldContents=fieldContentsEntry                  for image in images:
                       if image[0]==imageName:
                           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  
     ret=[x for x in projects]  
     ret.sort(sort)  
         return ret  
   
     def changeMPIWGRootForm(self):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
         """edit"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)  
         return pt()          return pt()
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):      def managePublications(self,pubName=None,op=None):
         """change"""          """managage images"""
         self.title=title  
         self.connection_id=connection_id  
         self.disciplineList=disciplineList  
         self.themesList=themesList  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def getDisciplineList(self):  
         """get disciplines as list"""  
         list= self.disciplineList.split("\n")  
         return [x.rstrip().lstrip() for x in list]  
       
     def getThemeList(self):  
         """get themes as list"""  
         list= self.themesList.split("\n")  
         return [x.rstrip().lstrip() for x in list]  
       
     def test(self):  
         """test"""  
         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url  
   
     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'):  
                 if project[1]==parentId:  
                     ret.append(project)  
   
         if childs:  
             for project in self.getProjectFields('xdata_05',sort='int'):  
                 searchStr=childs+"(\..*)"  
                 if re.match(searchStr,project[1]):  
                       
                     if depth:  
   
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):  
                       
                             ret.append(project)  
                     else:  
                         ret.append(project)  
         return ret  
       
     def getProjectFields(self,fieldName,actual="yes",folder=None,sort=None):  
         """getListofFieldNames"""  
         ret=[]  
           
         objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)  
   
                           if pubName and op:
         for object in objects:              if op=='up':
             obj=object[1]                  publications=self.getPublications()
                               for publication in publications:
             if (not getattr(obj,'invisible',None)) and (obj.isActual()):                      if publication[0]==pubName:
                 if fieldName=="WEB_title_or_short":                          nr=publications.index(publication)
                           if not nr==0:
                     if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer                              publications[nr-1][1].place+=1
                         fieldNameTmp="WEB_title"                              publications[nr][1].place-=1
                     else:                          pass
                         fieldNameTmp="xdata_07"              elif op=='down':
                 else:                  publications=self.getPublications()
                     fieldNameTmp=fieldName                  for publication in publications:
                       if publication[0]==pubName:
                 ret.append((obj,obj.getContent(fieldNameTmp)))                          nr=publications.index(publication)
                           if not (nr==len(publications)-1):
                                       publications[nr+1][1].place-=1
         if sort=="int":                              publications[nr][1].place+=1
             ret.sort(sortI)                          pass
         else:  
             ret.sort(sortF)  
           
         return ret  
   
     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)  
                   
         return projects  
           
                   
     manage_options = Folder.manage_options+(          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
         {'label':'Update Personal Homepages','action':'updateHomepages'},  
         {'label':'Main config','action':'changeMPIWGRootForm'},  
         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},  
         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},  
         )  
       
     def importNamesForm(self):  
         """Form"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)  
         return pt()          return pt()
   
     def importNames(self,fileupload,folderName,RESPONSE=None):      def getPublications(self):
         """import komma-sep list email,lastName,firstName"""          """get all Publications"""
         project=getattr(self,folderName)          def sort_images(x,y):
         load=fileupload.read()              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                   
         for line in load.split('\r'):          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
                           
           publications.sort(sort_images)
           return publications
                           
             splitted=line.split(",")      def addPublication(self,text,RESPONSE=None):
            # print splitted          """add an MPIWG_Publication"""
                   
             if not (splitted[0]==""):          name="publication_"+str(self.getLastPublicationNumber()+1)
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])  
                                   
                 try:          newPublication=MPIWGProject_publication(name)
                     project._setObject(splitted[0],newObj)  
                     #print "done:",splitted[0]  
                 except:  
                     zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])  
   
           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:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('managePublications')
   
     def updateHomepages(self,RESPONSE):  
         """lege members an"""  
                   
         self.upDateSQL('personalwww.xml')  
         founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')  
         project=getattr(self,'members')  
         for found in founds:  
                           
             if not (found.e_mail==""):      def getLastPublicationNumber(self):
                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)          publications=self.getPublications()
                                   
                 try:          if not publications:
                     project._setObject(found.username,newObj)              return 0
                     RESPONSE.write("<p>new:%s</p>\n"%found.username)          else:
                 except:              return getattr(publications[-1][1],'place',0)
                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))  
   
       def deletePublication(self,id,RESPONSE=None):
               """delete Publication id"""
               self.manage_delObjects([id])
               if RESPONSE:
                   RESPONSE.redirect('managePublications')
   
         #delete non existing      def getImages(self):
           """get all Images"""
   
           def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
         foundUserNames=[x.username for x in founds]  
         for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):              
                           
             if member[1].getId() not in foundUserNames:          if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
                 member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])  
                 RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())  
         try:          try:
             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])                  self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
         except:          except:
             pass              pass
         self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])              self.imageURL=''
                   self.imagecap=''
                       
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
           
     def getAllMembers(self):  
         """give list of all members"""  
         ret=[]  
   
         #for x in self.members.objectValues('MPIWGStaff'):  
             #print x.title  
         #    ret.append(x.title.decode('utf-8'))  
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):  
                                ret.append(x[1].title.decode('utf-8'))  
               
         ret.sort()  
         #print ret  
     
         return ret  
   
     def printAllMembers(self):          images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
         """prin"""  
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
       
           
     def makeList(self,entry):  
         """makes a list out of one entry or repeat a list"""  
         if type(entry) is StringType:  
             return [entry]  
         else:  
             return entry  
   
   
     def getTree(self):  
         """generate Tree from project list"""  
         returnList=[]  
         for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05  
   
             for idNr in project[1].split(";"): # more than one number  
                 if not idNr=="":  
                     splittedId=idNr.split(".")  
                     depth=len(splittedId)  
                     nr=idNr  
                     #title=project[0].WEB_title  
                     title=[project[0].getContent('WEB_title')]  
                     #print title  
             if idNr[0]!="x":  
                        returnList.append((depth,nr,title,project[0]))  
                   
         return returnList          images.sort(sort_images)
           return images
   
     def formatElementsAsList(self,elements):      def getLastImageNumber(self):
         """formatiere tree als liste"""          images=self.getImages()
                   
         actualDepth=0          if not images:
         ret=""              return 0
         for element in elements:  
             if (element[0]>actualDepth):  
                 #fuege soviele ul ein wie unterschied in tiefe  
                 if element[0]==1:  
                     ret+="""<div class="dept">\n<ul class="liste">\n"""  
                 else:                  else:
                     for i in range(element[0]-actualDepth):              return getattr(images[-1][1],'place',0)
                         if i>0:  
                             ret+="<li>"  
                         ret+="""<ul class="liste">\n"""  
   
                 actualDepth=element[0]  
                   
             elif (element[0]<actualDepth):  
                 #fuege soviele /ul ein wie unterschied in tiefe  
                 for i in range(-element[0]+actualDepth):  
   
                     ret+="<br><br></li></ul>\n"  
   
                     #ret+="<br><br>\n</li>\n</ul>\n</li>\n"  
   
   
                 if element[0]==1:      def deleteImage(self,id,RESPONSE=None):
                     department=int(element[3].getContent('xdata_05'))-1          """delete Image id"""
           self.manage_delObjects([id])
           if RESPONSE:
               RESPONSE.redirect('manageImages')
                                           
                     ret+="""</ul></div>\n"""  
             if department==4: #hack  
             department=3  
   
                     ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>      def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
                     <div class="dept">\n<ul class="liste">\n          """check if project has children"""
                     """%department          ct=self.getContexts(childs=self.getContent('xdata_05'),
                                    depth=1,date=date,onlyActive=onlyActive)
                           
                 actualDepth=element[0]          if ct and len(ct)>0:
                return True
             else:              else:
                 ret+="""\n</li>\n"""               return False
             ret+="""<li>\n"""  
                           
             if actualDepth==1:  
                 departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group'}   
                 department=element[3].getContent('xdata_05')  
                 ret+="""<a href="#top"><img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])  
   
             ret+="""<a href="%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",element[3].getContent('WEB_title'))      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
         return ret          """add an MPIWG_Project_image"""
           
     def formatElementForOverview(self,element):          if not filename:
         """format the element for output in overview"""              filename=fileHd.filename
         if element[0]==1: #department  
             #print element[3].getContent('xdata_05')  
             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'))  
   
         elif element[0]==2: #mainprojects  
             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 """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
   
           
     def changePosition(self,treeId,select,RESPONSE=None):  
         """Change Postion Entry"""  
         numbers=[]  
   
         # 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])  
             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:          if not fileHd:
             highest=max(numbers)              fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
         except:  
             highest=0  
         projects=self.showNewProjects()  
         for i in self.makeList(select):  
             highest+=10  
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)  
   
           newImage=MPIWGProject_image(filename,filename,fileHd)
   
           self._setObject(filename,newImage)
           obj=getattr(self,filename)
           obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('showTree')              RESPONSE.redirect('manageImages')
           
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
           
         for idNr in form.keys():  
             fields[int(idNr)][3].xdata_05=form[idNr]  
   
       def PrincipiaSearchSource(self):
           """Return cataloguable key for ourselves."""
           return str(self)
                   
       def versionHeader(self):
           """version Header, gibt header text entsprechend der aktuellen version aus"""
   
         if RESPONSE is not None:          actualTime=time.localtime()
             RESPONSE.redirect('showTree')          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 getProjectWithId(self,id):      def getActualVersion(self,date=None):
         fields=self.getProjectFields('xdata_05')          """actuelle version"""
         for field in fields:          def sortProjectsByTime(x,y):
             if field[1]==id:              return cmp(x[1].archiveTime,y[1].archiveTime)
                 return field[0]  
   
           if not date:
               if self.isActual():
                   return self
               else:
         return None          return None
                           
           #suche ob aeltere versionen vorhanden sind
                   
                       finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
                   if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
     def getRelativeUrlFromPerson(self,list):              ad=getattr(self,'creationTime','20050101000000')
         """get urls to person list"""              if int(date)>int(ad):
         ret=[]                  return self
         persons=list.split(";")  
         for person in persons:  
               
             if len(person)>1: #nicht nur Trennzeichen  
                 splitted=person.split(",")  
                 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=='':  
   
                     try:  
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 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'))                  return None
                     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  
                 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:  
             if person =="Otto Sibum" : person="H. Otto Sibum"  
             if person =="Norton Wise" : person="M. Norton Wise"  
                     #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+"/index.html",person))  
                 else:  
                     #ret.append("%s"%person.encode('utf-8'))  
                     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 getProjectsOfMember(self,name=None,email=None):  
         """get project of a member"""  
         def sortP(x,y):  
             """sort by sorting number"""  
             #print x.xdata_05,y.xdata_05  
             return cmp(x.WEB_title,y.WEB_title)  
           
          
         ret=[]  
         splitNeu=[]  
         if email:  
             print "IIII:",self.getId()  
             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)  
             name =  members[0][1].title.decode('utf-8')  
   
         y=name  
         splitted=y.split(",")  
         #XXXX  
         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]  
           
         #for s in splitted:  
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
           
         proj=self.ProjectCatalog({'xdata_01':search})  
   
         if proj:  
             proj2=[]  
             for x in proj:  
   
                 if not getattr(x.getObject(),'invisible',None):  
                     if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):  
                        proj2.append(x)  
   
         else:          else:
             proj2=[]              finds.sort(sortProjectsByTime)
               
         proj=self.ProjectCatalog({'xdata_08':search})  
         if proj:  
             names=[x.WEB_title for x in proj]  
             for x in proj:  
   
                 if not x.WEB_title in names:  
                     proj2.append(x)  
   
   
         proj2.sort(sortP)  
   
         if len(proj2)>0:  
             ret.append((y,proj2))  
   
         return ret  
             
     def givePersonList(self,name):          for find in finds:
         """check if person is in personfolder and return list of person objects"""              #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 find[1]
                   
         splitted=name.split(",")          #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
         if len(splitted)==1:          ad=getattr(self,'creationTime','20050101000000')
             splitted=name.lstrip().rstrip().split(" ")  
         splittedNew=[split.lstrip() for split in splitted]  
                   
         if splittedNew[0]=='':          if int(date)>int(ad):
             del splittedNew[0]  
         search=string.join(splittedNew,' AND ')  
         if not search=='':  
             proj=self.MembersCatalog({'title':search})  
   
         if proj:              return self
             return [[x.lastName,x.firstName] for x in proj]  
         else:          else:
             return []              return None
               
 ##         splitted=name.split(",") # version nachname, vorname...  
 ##         if len(splitted)>1:  
 ##             lastName=splitted[0]   
 ##             firstName=splitted[1]  
 ##         else:   
 ##             splitted=name.split(" ") #version vorname irgenwas nachnamae  
           
 ##             lastName=splitted[len(splitted)-1]  
 ##             firstName=string.join(splitted[0:len(splitted)-1])  
   
 ##         objs=[]  
   
         #print  self.members   
       ##   for x in self.members.__dict__:  
 ##             obj=getattr(self.members,x)  
 ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):  
                   
 ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):  
                       
 ##                     objs.append((obj,lastName+", "+firstName))  
   
           
         return objs  
   
   
     def personCheck(self,names):  
         """all persons for list"""  
         #print "names",names  
         splitted=names.split(";")  
         ret={}  
         for name in splitted:  
   
             if not (name==""):  
                 try:  
                     ret[name]=self.givePersonList(name)  
                 except:  
                     """NOTHIHN"""  
         #print "RET",ret  
         return ret  
   
     def giveCheckList(self,person,fieldname):  
         """return checklist"""  
         #print "GCL",fieldname  
         if fieldname=='xdata_01':  
             x=self.personCheck(person.getContent(fieldname))  
             #print "GCLBACKX",x  
             return x  
           
   
     def isCheckField(self,fieldname):  
         """return chechfield"""  
           
         return (fieldname in checkFields)  
   
   
       
       
           
 def manage_addMPIWGRootForm(self):  
     """form for adding the root"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)  
     return pt()  
   
 def manage_addMPIWGRoot(self,id,title,connection_id="",RESPONSE=None):  
     """add a root folder"""  
     newObj=MPIWGRoot(id,title)  
     self._setObject(id,newObj)  
     ob=getattr(self,id)  
     setattr(ob,'connection_id',connection_id)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
           
   
 class MPIWGProject(CatalogAware,Folder):  
     """Class for Projects"""  
   
     meta_type='MPIWGProject'  
     default_catalog='ProjectCatalog'  
       
     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 isActual(self):      def isActual(self):
         """gibt 1 zurueck wenn aktuell, 0 sonst"""          """gibt 1 zurueck wenn aktuell, 0 sonst"""
         actualTime=time.localtime()          actualTime=time.localtime()
Line 1078  class MPIWGProject(CatalogAware,Folder): Line 481  class MPIWGProject(CatalogAware,Folder):
   
   
     def generateTemplate(self,RESPONSE=None):      def generateTemplate(self,RESPONSE=None):
         """Erzeuge Template für defined fields not_used"""          """Erzeuge Template fuer defined fields not_used"""
   
         id="index_html"          id="index_html"
         title=id          title=id
Line 1093  class MPIWGProject(CatalogAware,Folder): Line 496  class MPIWGProject(CatalogAware,Folder):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def __init__(self, id, argv=None):      def __init__(self, id, argv=None):
         """initieriere classe"""          """initiere classe"""
                   
           self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
         self.id=id          self.id=id
         self.title=id          self.title=id
           self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
           self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
           
         if argv:          if argv:
             for arg in definedFields:              for arg in definedFields:
         try:          try:
Line 1117  class MPIWGProject(CatalogAware,Folder): Line 524  class MPIWGProject(CatalogAware,Folder):
         )          )
   
   
       def isActiveProject(self):
           """check if the project is still active, default is true, set to false is the project is accomplished"""
           return getattr(self,'isActiveFlag',True)
    
       def isArchivedProject(self):
           """check if the project is archived"""
           
           completed=getattr(self,'completedAt',0)
          
          #completed leer 
           if completed=="" :
               return False;
           if completed == 0:
               return False;
           
           
           return True
           
           
       def setActiveFlag(self,status=True):
           """set the active flag"""
           self.isActiveFlag=status
           
       def setCompletedAt(self,date):
           """set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
           logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"completedAt",transformedDate)
               return True;
           else:
               return False;
       
       def getCompletedAt(self):
           """gibt das transformierte Datum zurŸck"""
           date=getattr(self,'completedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
           
       def reTransformDate(self,date):
           """transformiert , transformdate zurueck"""
           year=int(date/10000)
           month=int((date-year*10000)/100)
           day=int((date-year*10000-month*100))
           return """%s.%s.%s"""%(day,month,year);
           
           
       def transformDate(self,date):
           """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach  YYYYMMDD, alle nicht angebebenn Werte
           werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist""" 
           
           if (date=="" ) :
               return "";
           
           if (date==None):
               return None;
           
           splitted=date.split(".")
           length=len(splitted)
           year=0
           month=0
           day=0
           if length > 3:
               return "";
           if length==3:
               day = int(splitted[0])
           if length>1:
               month=int(splitted[length-2])
           
           if length > 0:
               try:
                   year = int(splitted[length-1])
               except:
                   pass
           
          ## logging.info("month:"+(month))
           if not (0<=month<13):
               return None;
           
           if not(0<=day<32):
               return None;
           
           if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
               year=2000+year;
           return year*10000+month*100+day
           
           
       
     def checkDate(self,date):      def checkDate(self,date):
         """teste ob zum Zeitpunkt date eine andere version existierte"""          """teste ob zum Zeitpunkt date eine andere version existierte"""
                   
Line 1124  class MPIWGProject(CatalogAware,Folder): Line 622  class MPIWGProject(CatalogAware,Folder):
         def sortProjectsByTime(x,y):          def sortProjectsByTime(x,y):
             return cmp(x[1].archiveTime,y[1].archiveTime)              return cmp(x[1].archiveTime,y[1].archiveTime)
                   
           #suche ob aeltere versionen vorhanden sind
   
         finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])          finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
         if not finds:          if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
             return self.absolute_url()              ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self.REQUEST['URL1']+"/"+self.getId()
               else:
                   return self.REQUEST['URL1']+"/no_project"
   
   
         else:          else:
             finds.sort(sortProjectsByTime)              finds.sort(sortProjectsByTime)
   
         for find in finds:          for find in finds:
             if int(find[1].archiveTime) > int(date):              #gehe durch die alten Projekte und finde das entprechende
                 return find[1].absolute_url()              if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                   return self.REQUEST['URL1']+"/"+find[1].getId()
   
         return self.absolute_url()          #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 index_html(self):  
         """show homepage"""  
                   
       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
               
               @param nr: Position die geprueft werden soll
               @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
                   
           # 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]
               
           txt=self.harvest_page()
           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
   
               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:
                       break;
                   
           # 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())()
   
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
   
   
                return pt()
            
       def index_html(self,request=True,context=None):
           """show homepage"""
           if not context:
               context=self
           if request:
         if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:          if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
             self.REQUEST.SESSION['MPI_redirected']=1              self.REQUEST.SESSION['MPI_redirected']=1
             self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date']))                  self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
         else:          else:
             self.REQUEST.SESSION['MPI_redirected']=None              self.REQUEST.SESSION['MPI_redirected']=None
                   
     ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])          #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(os.path.join(package_home(globals()),'zpt','project_main')).__of__(self)  
         return pt()          return pt()
   
           
Line 1213  class MPIWGProject(CatalogAware,Folder): Line 836  class MPIWGProject(CatalogAware,Folder):
                 try:                  try:
             self.imageURL=tmp[0].split("\"")[1].encode('utf-8')              self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
         except:          except:
                       try:
             self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')              self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                       except:
                           self.imageURL=""
                   
                 split2="</p>".join(tmp[1:])                  split2="</p>".join(tmp[1:])
   
Line 1236  class MPIWGProject(CatalogAware,Folder): Line 862  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             text5=text2              text5=text2
   
         #teste ob WEB_project_description und keine führenden p tags          #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'):          if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
             text5= "<p>"+text5+"</p>"              text5= "<p>"+text5+"</p>"
   
   
         #filter image          #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
   
         return text5.encode('utf-8')  
   
     def showImagesOfPage(self,imageUrl=None):      def showImagesOfPage(self,imageUrl=None):
         """show Images of project"""          """show Images of project"""
Line 1259  class MPIWGProject(CatalogAware,Folder): Line 891  class MPIWGProject(CatalogAware,Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'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(os.path.join(package_home(globals()),'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):
           """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"""          """edit the project and archive the old version"""
                   
         self.copyObjectToArchive() # archive the object          self.copyObjectToArchive() # archive the object
Line 1277  class MPIWGProject(CatalogAware,Folder): Line 1054  class MPIWGProject(CatalogAware,Folder):
   
   
                   
   
           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(os.path.join(package_home(globals()),'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 1302  class MPIWGProject(CatalogAware,Folder): Line 1126  class MPIWGProject(CatalogAware,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')
   
Line 1318  class MPIWGProject(CatalogAware,Folder): Line 1146  class MPIWGProject(CatalogAware,Folder):
         splitted=[y.rstrip().lstrip() for y in 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(os.path.join(package_home(globals()),'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(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
Removed from v.1.47.2.12  
changed lines
  Added in v.1.47.2.84

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