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

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

version 1.47.2.21, 2005/08/31 08:24:29 version 1.47.2.90, 2008/08/26 15:01:41
Line 1 Line 1
 """This contains the class MPIWG Projects  """This contains the class MPIWG Projects
 for organizing and maintaining the different project pages  for organizing and maintaining the different project pages
   
   $author dwinter   - last change  26.06.2008
   
 """  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder  
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.MPIWGBibliography.BibliographyManager import BibliographyManager
   from OFS.Image import Image
 from Globals import package_home  from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  
 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 AccessControl import ClassSecurityInfo  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
   
 definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']  #import MPIWGStaff
   
 checkFields = ['xdata_01']  
   
   
   
 def sortF(x,y):  
     try:  
         return cmp(x[1],y[1])  
     except:  
         try:  
             return cmp(str(x[1]),str(y[1]))  
         except:             
               
             return 0   
       
 def sortI(x,y):  
     xsplit=x[1].split(".")  
     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:  
                 xret=xret+"%04i"%int(ysplit[i])  
             except:  
                 xret=xret+"%04i"%0  
                   
           
         return cmp(int(yret),int(xret))  
     except:  
         return cmp(x[1],y[1])  
   
 class MPIWGLink(SimpleItem):  from MPIWGHelper import *
     """create a symbolic link to another page"""  
   
     meta_type="MPIWGLink"  import MPIWGRoot
   import MPIWGLink
   import MPIWGTemplate
           
     def isActiveItem(self):  # die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus KompatibilitŠtsgrŸnden, bleiben die Klassen hier noch drin.
         """teste ob ausgewaehlt"""  # Sonst funktionieren die alten Webseiten nicht mehr.
         #url1 beim link anstelle von url1, da link jeweils index_html als url hat.  
         if self.absolute_url()==self.REQUEST['URL1']:  
             return "aktiv"  
         else:  
             return ""  
   
     def __init__(self,id,link,title='',weight=''):  class MPIWGRoot(MPIWGRoot.MPIWGRoot):
         """init mpiwglink"""      """depricated"""
         self.id=id  
         self.link=link  
         self.title=title  
         self.weight=weight  
   
     def getObj(self):  
         """bekomme original"""  
        ##  objpath=self.link.replace("/",".")  
 ##         if objpath[0]!=".":  
 ##             objpath="."+objpath  
   
 ##         print objpath  class MPIWGLink(MPIWGLink.MPIWGLink):
 ##         return eval("self"+objpath)      """depricated"""
   
   class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
       """depricated"""
   
         splitted=self.link.lstrip().split("/")  class MPIWGProject_publication(SimpleItem):
         obj=self      """publications object fuer project"""
         for x in splitted:  
         if not x=="":  
               obj=getattr(obj,x)  
                           
         return obj      meta_type="MPIWGProject_publication"
   
     def getWeight(self):      def editPublication(self,text=None,RESPONSE=None):
         if self.linkWeight and linkWeight!="":          """edit a publication"""
             return self.linkWeight  
         else:  
             return self.getObj().weight  
   
     manage_options=SimpleItem.manage_options+(          if (not text):
         {'label':'main config','action':'changeLinkForm'},              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
         )  
   
   
     def changeLinkForm(self):  
         """change MPIWG link"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGLinkChange.zpt')).__of__(self)  
         return pt()  
   
     def changeLink(self,link,title,weight,RESPONSE=None):  
         """change links"""  
         self.link=link  
         self.title=title  
         self.weight=weight  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage')  
   
     def index_html(self):  
         """index"""  
           
         return self.getObj().pt_render(extra_context={'here':self})  
                                          
   
 def manage_addMPIWGLinkForm(self):  
     """Form for adding link"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGLink.zpt')).__of__(self)  
     return pt()      return pt()
   
 def manage_addMPIWGLink(self,id,link,title,weight,RESPONSE=None):  
     """add link"""  
     newObj=MPIWGLink(id,link,title,weight)  
   
     self._setObject(id,newObj)          self.text=text[0:]
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
           if RESPONSE:
               RESPONSE.redirect("../managePublications")
   
 class MPIWGTemplate(ZopePageTemplate):  class MPIWGProject_image(Image):
     """Create a layout Template for different purposes"""      """Images for Projects"""
   
     meta_type="MPIWGTemplate"      meta_type="MPIWGProject_image"
   
     manage_options=ZopePageTemplate.manage_options+(      def showImage(self,imageUrl=None):
         {'label':'Change Weight','action':'changeWeightForm'},          """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)
     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):      def editImage(self,file=None,caption=None,RESPONSE=None):
         """change weight"""          """edit the Image"""
         self.weight=weight          if (not file) and (not caption):
         if RESPONSE is not None:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
             RESPONSE.redirect('manage')  
   
           
     def __init__(self, id, text=None, content_type=None,MPIWGType=None):  
         self.id = str(id)  
   
   
   
         self.ZBindings_edit(self._default_bindings)  
         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)  
   
       
         """change form"""  
   
     def isActiveItem(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          if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):  
     "Add a Page Template with optional file content."  
     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',  
              'xdata_03':'Historical Persons','xdata_04':'Time period',  
              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',  
              'xdata_08':'Other involved scholars' ,'xdata_09':'Disciplines','xdata_10':'Themes',  
              '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']  
     meta_type='MPIWGRoot'  
   
     def versionHeaderEN(self):          if caption:
         """version header text"""              self.caption=caption[0:]
                   
         date= self.REQUEST.get('date',None)          if RESPONSE:
         if date:              RESPONSE.redirect("../manageImages")
             txt="""<h2>This pages shows the project which existed at %s</h2>"""%str(date)  
             return txt  
         return ""  
   
     def versionHeaderDE(self):  
         """version header text"""  
         date= self.REQUEST.get('date',None)  
         if date:  
             txt="""<h2>Auf dieser Seite finden Sie die Projekte mit Stand vom %s</h2>"""%str(date)  
         return ""  
       
     def queryLink(self,link):  
         """append querystring to the link"""  
         return "%s?%s"%(link,self.REQUEST.get('QUERY_STRING',''))  
   
     def getKategory(self,url):  
     """kategorie"""  
     splitted=url.split("/")  
     return splitted[4]  
   
     def generateUrlProject(self,url,project=None):  
         """erzeuge aus absoluter url, relative des Projektes"""  
     if project:  
             splitted=url.split("/")  
             length=len(splitted)  
             short=splitted[length-2:length]  
                           
             base=self.REQUEST['URL3']+"/"+"/".join(short)  class MPIWGProject(CatalogAware,Folder):
       """Class for Projects"""
     else:  
             findPart=url.find("/projects/")  
             base=self.REQUEST['URL1']+"/"+url[findPart:]  
   
                   
         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,obj):  
         """return subnav elemente"""  
         def sortWeight(x,y):  
             x1=int(getattr(x[1],'weight','0'))  
             y1=int(getattr(y[1],'weight','0'))  
             return cmp(x1,y1)  
         #if obj.meta_type in ['MPIWGTemplate','MPIWGLink']:  
         #    id=obj.aq_parent.getId()  
         #else:  
   
         #id=obj.getId()  
   
           
         #suche die zweite ebene  
         if not obj.aq_parent.getId() in ['de','en']:  
             obj=obj.aq_parent  
               
         while not self.ZopeFind(self,obj_ids=[obj.getId()]):  
             obj=obj.aq_parent  
           
         if hasattr(self,obj.getId()):  
               
             subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])  
             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):      security=ClassSecurityInfo()
         """teste ob subnavigation aktiv"""      meta_type='MPIWGProject'
         for part in self.REQUEST['URL'].split("/"):      default_catalog='ProjectCatalog'
             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')  
           
   
     def showHistoricalPersons(self):  
         """show persons"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)  
         return pt()  
   
           
     def editHistoricalPersonsForm(self):  
         """edit historical persons for consistency"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)  
         return pt()  
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):  
         """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:  
             fieldContentsTmp=[fieldContentsEntry]  
         else:  
             fieldContentsTmp=fieldContentsEntry  
   
         fieldContents=[]  
         for x in fieldContentsTmp:  
             fieldContents.append(" AND ".join(x.split()))  
         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})  
         #print projects  
     #ret=[x for x in projects]  
         ret=[]  
         for x in projects:  
             obj=x.getObject()  
             obj=obj.getActualVersion(date)  
             if obj and (not getattr(obj,'invisible',None)):  
                 #if not (x in ret):  
                     ret.append(x)  
   
     ret.sort(sort)  
         return ret  
   
     def changeMPIWGRootForm(self):              obj=getattr(self,filename)
         """edit"""              obj.update_data(data)
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)  
         return pt()  
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):  
         """change"""  
         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,date=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',date=date):  
                 if project[1]==parentId:  
                     ret.append(project)  
   
         if childs:  
             for project in self.getProjectFields('xdata_05',sort='int',date=date):  
                 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,date=None,folder=None,sort=None):  
         """getListofFieldNames"""  
         ret=[]  
       
         objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)  
   
                   
         for object in objects:  
             obj=object[1]  
             obj=obj.getActualVersion(date)  
             if obj and (not getattr(obj,'invisible',None)):  
                 if fieldName=="WEB_title_or_short":  
   
                     if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer  
                         fieldNameTmp="WEB_title"  
                     else:  
                         fieldNameTmp="xdata_07"  
                 else:  
                     fieldNameTmp=fieldName  
   
                 ret.append((obj,obj.getContent(fieldNameTmp)))  
   
           if RESPONSE:
               RESPONSE.redirect('manageImages')
                   
         if sort=="int":      def manageImages(self,imageName=None,op=None):
             ret.sort(sortI)          """managage images"""
         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 and (objs[0].xdata_05[0] == ""):  
                                   
                 projects.append(objs)          if imageName and op:
                               if op=='up':
         return projects                  images=self.getImages()
                   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
           
                   
     manage_options = Folder.manage_options+(          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.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 managePublications(self,pubName=None,op=None):
         """import komma-sep list email,lastName,firstName"""          """managage images"""
         project=getattr(self,folderName)  
         load=fileupload.read()  
           
         for line in load.split('\r'):  
                           
                           
             splitted=line.split(",")          if pubName and op:
            # print splitted              if op=='up':
                           publications=self.getPublications()
             if not (splitted[0]==""):                  for publication in publications:
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])                      if publication[0]==pubName:
                                           nr=publications.index(publication)
                 try:                          if not nr==0:
                     project._setObject(splitted[0],newObj)                              publications[nr-1][1].place+=1
                     #print "done:",splitted[0]                              publications[nr][1].place-=1
                 except:                          pass
                     zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])              elif op=='down':
                   publications=self.getPublications()
                                       for publication in publications:
         if RESPONSE is not None:                      if publication[0]==pubName:
             RESPONSE.redirect('manage_main')                          nr=publications.index(publication)
                           if not (nr==len(publications)-1):
     def updateHomepages(self,RESPONSE):                              publications[nr+1][1].place-=1
         """lege members an"""                              publications[nr][1].place+=1
           
         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==""):  
                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)  
                   
                 try:  
                     project._setObject(found.username,newObj)  
                     RESPONSE.write("<p>new:%s</p>\n"%found.username)  
                 except:  
                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))  
   
   
         #delete non existing  
   
   
         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:  
                 member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])  
                 RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())  
         try:  
             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])  
         except:  
             pass              pass
         self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])  
       
                       
         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):  
         """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,date=None):  
         """generate Tree from project list"""  
   
         returnList=[]  
         for project in self.getProjectFields('xdata_05',sort="int",date=date): # 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  
   
     def formatElementsAsList(self,elements):  
         """formatiere tree als liste"""  
                   
         actualDepth=0          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
         ret=""          return pt()
         for element in elements:      def hasExtendedPublicationList(self):
             if (element[0]>actualDepth):          """test if extended publication list exists"""
                 #fuege soviele ul ein wie unterschied in tiefe          if not hasattr(self,"publicationList"):
                 if element[0]==1:              return False
                     ret+="""<div class="dept">\n<ul class="liste">\n"""  
                 else:                  else:
                     for i in range(element[0]-actualDepth):              return True
                         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"      def createExtendedPublicationList(self,RESPONSE=None):
           """erzeuge erweiterte publications liste"""
           pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
           self._setObject("publicationList", pl)
   
                     #ret+="<br><br>\n</li>\n</ul>\n</li>\n"  
   
           zt=ZopePageTemplate('index.html')
           pl._setObject('index.html',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                                 'zpt/showExtendedProjectBibliography.zpt')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/html')
   
                 if element[0]==1:  
                     department=int(element[3].getContent('xdata_05'))-1  
                                           
                     ret+="""</ul></div>\n"""          if RESPONSE:
             if department==4: #hack              RESPONSE.redirect("managePublications")
             department=3  
   
                     ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>      def getPublications(self):
                     <div class="dept">\n<ul class="liste">\n          """get all Publications"""
                     """%department          def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                           
                 actualDepth=element[0]          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
             else:  
                 ret+="""\n</li>\n"""  
             ret+="""<li>\n"""  
                           
             if actualDepth==1:          publications.sort(sort_images)
                 departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group'}           return publications
                 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])  
   
             if self.REQUEST.has_key('date'):      def addPublication(self,text,RESPONSE=None):
                 ret+="""<a href="%s?date=%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",self.REQUEST['date'],element[3].getContent('WEB_title'))          """add an MPIWG_Publication"""
             else:  
                 ret+="""<a href="%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",element[3].getContent('WEB_title'))  
         return ret  
           
     def formatElementForOverview(self,element):          name="publication_"+str(self.getLastPublicationNumber()+1)
         """format the element for output in overview"""  
         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:          newPublication=MPIWGProject_publication(name)
             highest=max(numbers)  
         except:  
             highest=0  
         projects=self.showNewProjects()  
         for i in self.makeList(select):  
             highest+=10  
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)  
   
           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('showTree')              RESPONSE.redirect('managePublications')
           
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
                   
         for idNr in form.keys():      def getLastPublicationNumber(self):
             if not (fields[int(idNr)][3].xdata_05==form[idNr]):          publications=self.getPublications()
                 fields[int(idNr)][3].xdata_05=form[idNr]  
                 fields[int(idNr)][3].copyObjectToArchive()  
                   
           if not publications:
         if RESPONSE is not None:              return 0
             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 getRelativeUrlFromPerson(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.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 getattr(publications[-1][1],'place',0)
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                   
       def deletePublication(self,id,RESPONSE=None):
               """delete Publication id"""
               self.manage_delObjects([id])
               if RESPONSE:
                   RESPONSE.redirect('managePublications')
                           
     def getUrlFromPerson(self,list):      def getImages(self):
         """get urls to person list"""          """get all Images"""
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen          def sort_images(x,y):
                 splitted=person.split(",")              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                 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=='':  
   
           if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
                     try:                      try:
                         proj=self.MembersCatalog({'title':search})                  self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
                     except:                      except:
                         proj=None                  pass
               self.imageURL=''
                 if proj:              self.imagecap=''
             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,date=None):  
         """give tuple member /projects"""  
         ret=[]  
         members=self.getAllMembers()  
         #return str(members)  
         for x in members:  
             ret+=self.getProjectsOfMember(name=x,date=date)  
               
         return ret  
   
     def getProjectsOfMember(self,name=None,email=None,date=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:  
               
             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:          images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
                   
         proj=self.ProjectCatalog({'xdata_01':search})          images.sort(sort_images)
           return images
   
         if proj:      def getLastImageNumber(self):
             proj2=[]          images=self.getImages()
             for x in proj:  
                 if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):  
                     if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):  
                        proj2.append(x)  
   
           if not images:
               return 0
         else:          else:
             proj2=[]              return getattr(images[-1][1],'place',0)
               
         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) and (getattr(x.getObject(),'archiveTime','')==''):      def deleteImage(self,id,RESPONSE=None):
                     proj2.append(x)          """delete Image id"""
           self.manage_delObjects([id])
           if RESPONSE:
               RESPONSE.redirect('manageImages')
   
   
         proj2.sort(sortP)      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)
   
         if len(proj2)>0:          if ct and len(ct)>0:
             ret.append((y,proj2))               return True
   
         return ret  
        
     def givePersonList(self,name):  
         """check if person is in personfolder and return list of person objects"""  
           
         splitted=name.split(",")  
         if len(splitted)==1:  
             splitted=name.lstrip().rstrip().split(" ")  
         splittedNew=[split.lstrip() for split in splitted]  
           
         if splittedNew[0]=='':  
             del splittedNew[0]  
         search=string.join(splittedNew,' AND ')  
         if not search=='':  
             proj=self.MembersCatalog({'title':search})  
   
         if proj:  
             return [[x.lastName,x.firstName] for x in proj]  
         else:          else:
             return []               return False
               
 ##         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 addImage(self,fileHd,caption,RESPONSE=None,filename=None):
           """add an MPIWG_Project_image"""
           
           if not filename:
               filename=fileHd.filename
           
           if not fileHd:
               fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
                   
 def manage_addMPIWGRootForm(self):          newImage=MPIWGProject_image(filename,filename,fileHd)
     """form for adding the root"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)          self._setObject(filename,newImage)
     return pt()          obj=getattr(self,filename)
           obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
   
 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:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')              RESPONSE.redirect('manageImages')
           
   
 class MPIWGProject(CatalogAware,Folder):  
     """Class for Projects"""  
     security=ClassSecurityInfo()  
     meta_type='MPIWGProject'  
     default_catalog='ProjectCatalog'  
           
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
         """Return cataloguable key for ourselves."""          """Return cataloguable key for ourselves."""
Line 1254  class MPIWGProject(CatalogAware,Folder): Line 501  class MPIWGProject(CatalogAware,Folder):
                     new.append(split)                      new.append(split)
             except:              except:
                 new.append(split)                  new.append(split)
         return string.join(new)          return " ".join(new)
                           
                           
   
   
     def generateTemplate(self,RESPONSE=None):      def generateTemplate(self,RESPONSE=None):
         """Erzeuge Template für defined fields not_used"""          """Erzeuge Template fuer defined fields not_used"""
   
         id="index_html"          id="index_html"
         title=id          title=id
Line 1280  class MPIWGProject(CatalogAware,Folder): Line 527  class MPIWGProject(CatalogAware,Folder):
         self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]          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 1300  class MPIWGProject(CatalogAware,Folder): Line 550  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 setStartedAt(self,date):
           """set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
           logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"startedAt",transformedDate)
               return True;
           else:
               return False;
       def getCompletedAt(self):
           """gibt das transformierte Datum zurueck, an dem das Projekt beendet wurde."""
           date=getattr(self,'completedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
           
       def getStartedAt(self):
           """gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
           date=getattr(self,'startedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
           
       def reTransformDate(self,date):
           """transformiert , transformdate zurueck"""
           year=int(date/10000)
           month=int((date-year*10000)/100)
           day=int((date-year*10000-month*100))
           if (day==0) and (month==0):
               return """%s"""%year;
           if day==0 :
               return """%s.%s"""%(month,year);
           
           return """%s.%s.%s"""%(day,month,year);
           
           
       def transformDate(self,date):
           """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach  YYYYMMDD, alle nicht angebebenn Werte
           werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist""" 
      
           if (date==None):
               return None;
           
             
           if (date.lstrip().rstrip()=="" ) :
               return "";
           
           splitted=date.split(".")
           length=len(splitted)
           year=0
           month=0
           day=0
           if length > 3:
               return "";
           if length==3:
               day = int(splitted[0])
           if length>1:
               month=int(splitted[length-2])
           
           if length > 0:
               try:
                   year = int(splitted[length-1])
               except:
                   pass
           
          ## logging.info("month:"+(month))
           if not (0<=month<13):
               return None;
           
           if not(0<=day<32):
               return None;
           
           if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
               year=2000+year;
           return year*10000+month*100+day
           
           
       
     def checkDate(self,date):      def checkDate(self,date):
         """teste ob zum Zeitpunkt date eine andere version existierte"""          """teste ob zum Zeitpunkt date eine andere version existierte"""
                   
Line 1341  class MPIWGProject(CatalogAware,Folder): Line 706  class MPIWGProject(CatalogAware,Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
         return pt()          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):      def index_html(self,request=True,context=None):
         """show homepage"""          """show homepage"""
         if not context:          if not context:
Line 1419  class MPIWGProject(CatalogAware,Folder): Line 886  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 1442  class MPIWGProject(CatalogAware,Folder): Line 912  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 1473  class MPIWGProject(CatalogAware,Folder): Line 949  class MPIWGProject(CatalogAware,Folder):
     def saveEditedContent(self,kupu=None,preview=None):      def saveEditedContent(self,kupu=None,preview=None):
         """save Edited content"""          """save Edited content"""
   
           if preview:
         kupu=preview          kupu=preview
         #find content of body tags          #find content of body tags
         start=kupu.find("<body>")          start=kupu.find("<body>")
Line 1480  class MPIWGProject(CatalogAware,Folder): Line 957  class MPIWGProject(CatalogAware,Folder):
         newcontent= kupu[start+6:end]          newcontent= kupu[start+6:end]
   
         if preview:          if preview:
               
             return self.preview(newcontent)              return self.preview(newcontent)
   
           self.copyObjectToArchive()
         self.WEB_project_description=newcontent[0:]          self.WEB_project_description=newcontent[0:]
   
         self.REQUEST.RESPONSE.redirect("./edit")          self.REQUEST.RESPONSE.redirect("./index.html")
                   
         return True          return True
   
     security.declareProtected('View managment screens','edit')      security.declareProtected('View management screens','edit')
     def edit(self):      def edit(self,western=None):
         """Edit pages"""          """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)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
         return pt()          return pt()
   
       edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
   
       def getPathStyle(self, path, selected, style=""):
           """returns a string with the given style + 'sel' if path == selected."""
   
           if path == selected:
               return style + 'sel'
           else:
               return style    
   
     def preview(self,description):      def preview(self,description):
         """preview"""          """preview"""
         tmpPro=getattr(self,"previewTemplate",None)          tmpPro=getattr(self,"previewTemplate",None)
Line 1503  class MPIWGProject(CatalogAware,Folder): Line 996  class MPIWGProject(CatalogAware,Folder):
         for field in definedFields:          for field in definedFields:
             setattr(tmpPro,field,getattr(self,field))              setattr(tmpPro,field,getattr(self,field))
         tmpPro.WEB_project_description=description[0:]          tmpPro.WEB_project_description=description[0:]
                   tmpPro.invisible=True
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
         return pt()          return pt()
   
Line 1512  class MPIWGProject(CatalogAware,Folder): Line 1005  class MPIWGProject(CatalogAware,Folder):
   
     def getWebProject_description(self):      def getWebProject_description(self):
         """get description"""          """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')
                   
         if type(self.WEB_project_description) is ListType:  
             return "<html><body>Hello"+self.WEB_project_description[0]+"</body></html>"  
         else:  
             return self.WEB_project_description  
                   
                   
     def editMPIWGProjectForm(self):      def editMPIWGProjectForm(self):
Line 1524  class MPIWGProject(CatalogAware,Folder): Line 1033  class MPIWGProject(CatalogAware,Folder):
         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 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))
               firstname=firstname.capitalize()
               lastname=lastname.capitalize()
               cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
               
               #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
               #if not hasattr(self,'responsibleScientistsList'):
               #     self.responsibleScientistsList={}
               # 
               # if name in self.responsibleScientistsList.values()
               
               if len(cataloggedNames)>0:
                  returnNamesDict[name]=cataloggedNames
               else:
                   returnNamesDict[name]=[]
          
           return returnNamesDict
           
     def editMPIWGProject(self,RESPONSE=None,fromEdit=None):      def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
         """edit the project and archive the old version"""          """edit the project and archive the old version"""
Line 1536  class MPIWGProject(CatalogAware,Folder): Line 1104  class MPIWGProject(CatalogAware,Folder):
                                   
                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])                  setattr(self,x,[self.REQUEST[x].decode('utf-8')])
   
           
          
   
           completedAt = self.REQUEST.get('completedAt')
           if not self.setCompletedAt(completedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
     
           startedAt = self.REQUEST.get('startedAt')
           if not self.setStartedAt(startedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
           
           if self.REQUEST.has_key('historicalNames'):
               self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
           
           if self.REQUEST.has_key('active'):
               self.setActiveFlag(True)
           else:
               self.setActiveFlag(False)
           
           self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
           
           names={}
           keys={}
           tmpList=[]
           for key in self.REQUEST.keys(): #gehe durch das Formular
               splitted=key.split("_")
               if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
                   nr=splitted[2]
                   if splitted[1]=="name":
                       names[nr]=self.REQUEST[key]
                   elif splitted[1]=="key":
                       keys[nr]=self.REQUEST[key]
                   
            
           for nr in names.keys():
                tmpList.append((names[nr],keys.get(nr,"")))
                
           self.responsibleScientistsList=tmpList
         if fromEdit and (RESPONSE is not None):          if fromEdit and (RESPONSE is not None):
             RESPONSE.redirect('./editMPIWGBasisEditor')              #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.REQUEST.get('xdata_01','')))
   
         else:          else:
             if RESPONSE is not None:              if RESPONSE is not None:
Line 1564  class MPIWGProject(CatalogAware,Folder): Line 1171  class MPIWGProject(CatalogAware,Folder):
             if type(disciplines) is StringType:              if type(disciplines) is StringType:
                 self.xdata_09=disciplines                  self.xdata_09=disciplines
             else:              else:
                 self.xdata_09=string.join(disciplines,";")                  self.xdata_09=";".join(disciplines)
         else:          else:
                 self.xdata_09=""                  self.xdata_09=""
         if themes:          if themes:
             if type(themes) is StringType:              if type(themes) is StringType:
                 self.xdata_10=themes                  self.xdata_10=themes
             else:              else:
                 self.xdata_10=string.join(themes,";")                  self.xdata_10=";".join(themes)
         else:          else:
             self.xdata_10=""              self.xdata_10=""
   
Line 1595  class MPIWGProject(CatalogAware,Folder): Line 1202  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')      security.declareProtected('View management screens','editMPIWGBasisEditor')
     def editMPIWGBasisEditor(self):      def editMPIWGBasisEditor(self, identifiedNames=None):
                               
         """editform"""          """editform"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)          if not identifiedNames:
         return pt()              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.21  
changed lines
  Added in v.1.47.2.90

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