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

Diff for /MPIWGWeb/Attic/MPIWGRoot.py between versions 1.1 and 1.1.2.39

version 1.1, 2008/06/24 11:16:27 version 1.1.2.39, 2012/03/01 07:46:27
Line 0 Line 1
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   from Products.PageTemplates.PageTemplate import PageTemplate
   from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from OFS.Image import Image
   from Globals import package_home
   import urllib
   import MPIWGStaff
   import string
   import re
   import os
   from types import *
   import logging
   import xmlhelper # Methoden zur Verwaltung der projekt xml
   from OFS.SimpleItem import SimpleItem
   from OFS.Folder import Folder
   from Products.ZSQLMethods.SQL import SQLConnectionIDs
   from AccessControl import ClassSecurityInfo
   from bibliography import *
   import time
   import xml.dom.minidom
   import sys
   import transaction
   
   #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
   from MPIWGHelper import *
   from BeautifulSoup import BeautifulSoup, Comment
   from ZODB import FileStorage, DB
   from ZEO import ClientStorage
   
   def sortWeight(x,y):
       x1=int(getattr(x[1],'weight','0'))
       y1=int(getattr(y[1],'weight','0'))
       return cmp(x1,y1)
   
   
   class MPIWGRoot(ZSQLExtendFolder):
       """Stammordner fuer den Web-Server"""
   
       _v_harvestCache=None
       meta_type='MPIWGRoot'
   
       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'}
       
       # (is this used?)
       folders=['MPIWGProject','Folder','ECHO_Navigation']
       # language of this instance
       lang = 'en'
       # types of objects that show up in navigation
       nav_meta_types = ['MPIWGTemplate','MPIWGLink','MPIWGFolder']
   
       manage_options = Folder.manage_options+(
           {'label':'Update personal homepages','action':'updatePersonalwww_html'},
           {'label':'Reindex catalogs','action':'reindexCatalogs'},
           {'label':'Main config','action':'changeMPIWGRootForm'},
           {'label':'add e-mails','action':'showNewDBEntries'},
           #{'label':'update the institutsbibliography','action':'updateInstitutsbiliography'},
           #{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
           #{'label':'Store Historical Persons','action':'storeHistoricalPersons'},
           )
       
   
       def getHarvestCachePort(self):
           return getattr(self,"harvestPort",29999)
       
       def getHarvestCacheServer(self):
           return getattr(self,"harvestServer","localhost")
      
       
       def getHarvestCache(self):
           logging.debug("CACHE:"+repr(self._v_harvestCache))
           if self._v_harvestCache==None:
                #storage = FileStorage.FileStorage('/tmp/'+self.getId()+'test-filestorage.fs')
                addr = self.getHarvestCacheServer(), self.getHarvestCachePort()
                storage = ClientStorage.ClientStorage(addr)
                db = DB(storage)
                self._v_harvestDV=db
                self._v_harvestDV=db
                conn = db.open()
                dbroot = conn.root()
                if not dbroot.has_key('templates'):
                    from BTrees.OOBTree import OOBTree
                    dbroot['templates'] = OOBTree()
                    
                self._v_harvestCache = dbroot['templates']
           logging.debug("CACHE2:"+repr(self._v_harvestCache))            
           return self._v_harvestCache
       
       
       
       def __del__(self):
            if self._v_harvestCache!=None:
                self._v_harvestDV.close();
                
       def getGetNeighbourhood(self,obj, 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
           
           wordStr=wordStr.lstrip().rstrip()
           
           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]
           
           
           txtCache = self.en.getHarvestCache();
           txt=  txtCache.get(obj.absolute_url(),None)
          
           if txt==None:
               
               logging.debug("NO CACHE for: "+obj.absolute_url())
               txt=obj.harvest_page(mode="slim")
           
           
           if not txt:
               return ret
           
           soup = BeautifulSoup(txt)
           
           comments = soup.findAll(text=lambda text:isinstance(text, Comment))
           [comment.extract() for comment in comments]
           
           txt = ''.join(soup.findAll(text=True))
           
           
           #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 x!=0: #add dots if in the middle of text
                           str="..."+str
                       
                       if y!=len(txt): #add dots if in the middle of text
                           str=str+"..."
                           
                           
                   
                       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 copyAllImagesToMargin(self):
           """tranformiere alle Bilder in die Margins"""
           projects=self.getTree()
           ret=""
           for project in projects:
               proj=project[3]
               try:
                   persons=proj.copyImageToMargin();
               except:
                   logging.error("Cannnot do: %s"%repr(project))
                   
       def transformProjectsToId(self):
           """trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste
           verantwortlicher Personen versieht"""
           projects=self.getTree()
           ret=""
           for project in projects:
               
               proj=project[3]
               persons=proj.identifyNames(proj.getContent('xdata_01'))
               if not hasattr(proj,'responsibleScientistsList'):
                           proj.responsibleScientistsList=[]
                           
               for person in persons.items():
                 
                   if len(person[1]) >1: #nicht eindeutig
                       ret+="nicht eindeutig ---  %s:  %s\n"%(proj.getId(),person[0])
                       
                   elif len(person[1]) ==0: #kein eintrage
                       ret+="kein eintrag---  %s:  %s\n"%(proj.getId(),person[0])
                       proj.responsibleScientistsList.append((person[0],""))
                   else:           
                       proj.responsibleScientistsList.append((person[0],person[1][0].getObject().getKey()))
           
           return ret
             
                   
       def harvestProjects(self):
           """harvest"""
           folder="/tmp"
           try:
               os.mkdir("/tmp/harvest_MPIWG")
           except:
               pass
           founds=self.ZopeFind(self.aq_parent.projects,obj_metatypes=['MPIWGProject'],search_sub=1)
           for found in founds:
               txt=found[1].harvest_page()
           
               if txt and (txt != ""):
                   name=found[0].replace("/","_")
                   fh=file("/tmp/harvest_MPIWG/"+name,"w")
                   fh.write(txt)
                   fh.close()
                   
       def decode(self,str):
           """decoder"""
   
           if not str:
               return ""
           if type(str) is StringType:
               try:            
                   return str.decode('utf-8')
               except:
                   return str.decode('latin-1')
           else:
               return str
   
   
       def getat(self,array,idx=0,default=None):
           """return array element idx or default (but no exception)"""
           if len(array) <= idx:
               return default
           else:
               return array[idx]
           
       def getLang(self):
           """returns the default language"""
           return self.lang
   
       def browserCheck(self):
           """check the browsers request to find out the browser type"""
           bt = {}
           ua = self.REQUEST.get_header("HTTP_USER_AGENT")
           bt['ua'] = ua
           bt['isIE'] = False
           bt['isN4'] = False
           if string.find(ua, 'MSIE') > -1:
               bt['isIE'] = True
           else:
               bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
   
           try:
               nav = ua[string.find(ua, '('):]
               ie = string.split(nav, "; ")[1]
               if string.find(ie, "MSIE") > -1:
                   bt['versIE'] = string.split(ie, " ")[1]
           except: pass
   
           bt['isMac'] = string.find(ua, 'Macintosh') > -1
           bt['isWin'] = string.find(ua, 'Windows') > -1
           bt['isIEWin'] = bt['isIE'] and bt['isWin']
           bt['isIEMac'] = bt['isIE'] and bt['isMac']
           bt['staticHTML'] = False
   
           return bt
   
   
       def versionHeaderEN(self):
           """version header text"""
           
           date= self.REQUEST.get('date',None)
           if date:
               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 createOrUpdateId_raw(self):
           """create sequence to create ids for bibliography"""
           debug=None
           #suche groesste existierende id
           founds=self.ZSQLQuery("select id from bibliography")
           
           if founds:
               ids=[int(x.id[1:]) for x in founds]
               maximum=max(ids)
               
               id_raw=self.ZSQLQuery("select nextval('id_raw')",debug=debug)
               
               if id_raw:
                   self.ZSQLQuery("drop sequence id_raw",debug=debug)
               
               self.ZSQLQuery("create sequence id_raw start %i"%(maximum+1),debug=debug)
           
       
       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)
   
           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 subNavStatic(self,obj):
           """subnav" von self"""
           subs=self.ZopeFind(obj,obj_metatypes=['MPIWGTemplate','MPIWGLink'])
           subret=[]
   
           for x in subs:
               if not(x[1].title==""):
                   subret.append(x)
           subret.sort(sortWeight)
           return subret
       
       def subNav(self,obj):
           """return sub-navigation elements i.e. below sections"""
           # get section -> parent should be MPIWGRoot
           p = obj
           sec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type != 'MPIWGRoot':
               sec = p
               p = p.aq_parent
       
           subsecs = sec.objectItems(self.nav_meta_types)
           subsecs = [s for s in subsecs if s[1].title != ""]
           subsecs.sort(sortWeight)
           return subsecs
                   
       def isType(self,object,meta_type):
           """teste ob ein object vom meta_type ist."""
           return (object.meta_type==meta_type)
       
       def isActive(self,name):
           """teste ob subnavigation aktiv"""
           for part in self.REQUEST['URL'].split("/"):
               if part==name:
                   return True
           return False
           
       
       def getSections(self):
           """returns a list of all sections i.e. top-level MPIWGFolders"""
           secs = self.objectItems(['MPIWGFolder'])
           secs.sort(sortWeight)
           #logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))
           # return pure list of objects
           return [s[1] for s in secs]
   
       def getSectionStyle(self, name, style=""):
           """returns a string with the given style + '-sel' if the current section == name"""
           if self.getSection() == name:
               return style + '-sel'
           else:
               return style    
   
       def getFeatures(self, num=None):
           """returns a list of the last num Features"""
           dir = getattr(self, 'features')
           features = dir.objectItems(['MPIWGFeature'])
           features.sort(sortWeight)
           if num is not None:
               # take only the last num elements
               features = features[-num:]
           # return pure list of objects
           return [f[1] for f in features]
   
   
       def getMPIWGRoot(self):
           """returns the MPIWG root"""
           return self
   
       def MPIWGrootURL(self):
           """returns the URL to the root"""
           return self.absolute_url()
           
       def upDateSQL(self,fileName):
           """updates SQL databases using fm.jar"""
           fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
           xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
           logger("MPIWG Web",logging.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()
           logger("MPIWG Web",logging.INFO,"result convert: %s"%ret)
           return 1
       
       def patchProjects(self,RESPONSE):
           """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 self.decode(format%field)
           else:
               return ""
           
   
       def isActiveMember(self,key):
           """tested ob Mitarbeiter key ist aktiv"""
           key=utf8ify(key)
           ret=self.getat(self.ZSQLInlineSearch(_table='personal_www',
                                               _op_key='eq',key=key,
                                               _op_publish_the_data='eq',
                                               publish_the_data='yes'))
           
           logging.info("ACTIVE_MEMBER  %s"%ret)
           if ret:
               return True
           else:
               return False
           
       def isActual(self,project):
           """checke if project is actual"""
           actualTime=time.localtime()
           
           if hasattr(project,'getObject'): #obj ist aus einer catalogTrefferList
               obj=project.getObject()
           else:
               obj=project
               
           if getattr(obj,'archiveTime',actualTime)< actualTime:
               return False
           else:
               return True
           
       def redirectIndex_html(self,request):
           #return request['URL1']+'/index_html'
           
           return urllib.urlopen(request['URL1']+'/index_html').read()
   
       
       def formatBibliography(self,here,found):
           """format"""
           return formatBibliography(here,found)
       
       def getValue(self,fieldStr):
           """Inhalt des Feldes"""
           
           if type(fieldStr)==StringType:
               field=fieldStr
           else:
               field=fieldStr[0]
           try:
               if field[len(field)-1]==";":
                   field=field[0:len(field)-1]
           except:
   
               """nothing"""
           field=re.sub(r';([^\s])','; \g<1>',field)
           return field.encode('utf-8')
   
   
       
       def sortedNames(self,list):
           """sort names"""
   
           def sortLastName(x_c,y_c):
               try:
                   x=urllib.unquote(x_c).encode('utf-8','ignore')
               except:
                   x=urllib.unquote(x_c)
   
               try:
                   y=urllib.unquote(y_c).encode('utf-8','ignore')
               except:
                   x=urllib.unquote(y_c)
                   
   
               
               try:
                   last_x=x.split()[len(x.split())-1]
                   last_y=y.split()[len(y.split())-1]
   
               except:
   
                   last_x=""
                   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 removeStopWords(self,xo):
           """remove stop words from xo"""
           if not hasattr(self,'_v_stopWords'):
               self._v_stopWords=self.stopwords_en.data.split("\n")
       
           x=str(xo)
       
           strx=x.split(" ")
     
           for tmp in strx:
        
               if tmp.lower() in self._v_stopWords:
                   del strx[strx.index(tmp)]
   
           return " ".join(strx)
       
       def urlQuote(self,str):
           """quote"""
           return urllib.quote(str)
   
       def urlUnQuote(self,str):
           """quote"""
           return urllib.unquote(str)
       
           
   
       def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):
           """gib alle Projekte aus mit Value von field mit fieldName enthaelt 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):
           """edit"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
           return pt()
   
       def changeMPIWGRoot(self,title,connection_id,coneServiceURL,harvestPort,harvestServer,lang=None,autocommit=None,RESPONSE=None):
           """change"""
           self.title=title
           self.connection_id=connection_id
           #self.disciplineList=disciplineList
           #self.themesList=themesList
           self.coneServiceURL=coneServiceURL
           self.harvestServer=harvestServer
           try:
               self.harvestPort=int(harvestPort)
           except:
               logging.error("couldn't change port!: no number:"+harvestPort)
           
           if lang is not None:
               self.lang = lang
   
           self.autocommit = (autocommit == "on")
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
           """childs alle childs, alle parents"""
           ret=[]
       
           if parents:
               pnums=parents.split(".")
               while len(pnums) > 1:
                   pnums.pop()
                   parentId=string.join(pnums,".")
           
                   for project in self.getProjectFields('xdata_05',sort='int',date=date):
                       if project[1]==parentId:
                           ret.append(project)
                   
                   if (depth is not None) and (len(ret) >= depth):
                       break
   
           if childs:
               for project in self.getProjectFields('xdata_05',sort='int',date=date):
                   searchStr=childs+"(\..*)"
                  
                   if (onlyActive and project[0].isActiveProject()) or (not onlyActive):
                       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)
           
           #logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))
        
           return ret
   
       def getAllProjectsAndTagsAsCSV(self,archived=1,RESPONSE=None):
           """alle projekte auch die nicht getaggten"""
           retList=[]
           headers=['projectName','scholars','lastChange thesaurus','last change project','persons','places','objects']
           headers.extend(list(self.thesaurus.tags.keys()))
           retList.append("\t".join(headers))
           if not hasattr(self,'thesaurus'):
               return "NON thesaurus (there have to be a MPIWGthesaurus object, with object ID thesaurus)"
           
           projectTags = self.thesaurus.getProjectsAndTags()
           for project in self.getProjectFields('WEB_title_or_short'):
               proj = project[0]
               p_name = project[1]
               retProj=[]
               if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2):
                   retProj.append(self.utf8ify(p_name))  
                   retProj.append(self.utf8ify(proj.getContent('xdata_01')))
                   retProj.append(self.thesaurus.lastChangeInThesaurus.get(proj.getId(),''))   
                   retProj.append(self.utf8ify(getattr(proj,'creationTime','20050101000000')))  
                   retProj.append(";".join([person[1] for person in self.thesaurus.getPersonsFromProject(proj.getId())]))
                   retProj.append(";".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())]))
                   retProj.append(";".join([person[1] for person in self.thesaurus.getObjectsFromProject(proj.getId())]))
                   retProj+=self.thesaurus.getTags(proj.getId(),projectTags)
                   retList.append("\t".join(retProj))
           
           if RESPONSE:
               RESPONSE.setHeader('Content-Type', "application/octet-stream")
         
           return "\n".join(retList);
       
       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 sort=="int":
               ret.sort(sortI)
           elif sort=="stopWords":
    
               ret.sort(sortStopWords(self))
               
           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)
                   
           return projects
       
           
       def updatePublicationDB(self,personId=None):
           """updates the publication db, i.e. copy year and type into the main table"""
           
           if personId:
               founds = self.ZSQLInlineSearch(_table="publications",key_main=personId)
           else:
               founds = self.ZSQLInlineSearch(_table="publications")
               
           for found in founds:
                           
               if found.id_institutsbibliographie and (not found.id_institutsbibliographie =="") and (not found.id_institutsbibliographie =="0"):
                   
                   entries = self.ZSQLInlineSearch(_table="institutsbiblio",id=found.id_institutsbibliographie)
                   for entry in entries:
                       self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
                       
               if found.id_gen_bib and (not found.id_gen_bib ==""):
                   entries = self.ZSQLInlineSearch(_table="bibliography",id=found.id_gen_bib)
                   for entry in entries:
                       self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
                       
           return True        
       
       def showNewDBEntries(self):
           """zeige neue Eintraege in der Datenbank ohne e-mail adressen bzw. fuer die noch kein Object angelegt wurde"""
           
           qstr="select * from personal_www where web_object_created='no' and not key=''"
           res=self.ZSQLQuery(qstr)
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showNewDBEntries.zpt')).__of__(self)
           return pt(newEntries=res)
      
       def createNewStaffObjects(self,RESPONSE):
           """create new staff object"""
           
           memberFolder=getattr(self,'members')
           args=self.REQUEST.form
           arg_k=args.keys()
           arg_k.remove("submit")
           ret=""
           for key in arg_k:
               k=self.urlUnQuote(key)
             
               qstr="select * from personal_www where key=%s"%self.ZSQLQuote(k)
               res=self.ZSQLQuery(qstr)[0]
               if args[key]!="": #email-adresse wurde eingetragen
                   #create the object
                   e_mail=args[key]
                   try:
                       newObj=MPIWGStaff.MPIWGStaff(e_mail,res.last_name,res.first_name,k)
                       memberFolder._setObject(e_mail,newObj)
                       obj=getattr(memberFolder,e_mail)
                       obj.reindex_object()
                       ret+="Created %s \n"%e_mail
                       created=True
                   except:
                       msg="Cannot create new user %s (%s %s)"%(e_mail,sys.exc_info()[0],sys.exc_info()[1])
                       logging.error(msg)
                       ret+=msg+"\n"
                       created=False
                   
                   if created:
                       qstr="update personal_www set web_object_created='yes',e_mail='%s@mpiwg-berlin.mpg.de' where key=%s"%(e_mail,self.ZSQLQuote(k))
                       self.ZSQLQuery(qstr)
           
           return ret
                      
           
       def generateNewPersonEntry(self,data):
           """generate a new person entry for data, neue personen werden zunaechst nur in der datenbank angelegt """
           
           #memberFolder=getattr(self,'members')
           #create the object
           
   #        try:
   #            newObj=MPIWGStaff.MPIWGStaff(urllib.quote(data['key']),data['last_name'].encode('utf-8'),data['first_name'].encode('utf-8')) 
   #            memberFolder._setObject(urllib.quote(data['key']),newObj)
   #        except:
   #            return False, "Cannot create new user %s (%s %s)"%(data['key'],sys.exc_info()[0],sys.exc_info()[1])
   #        
           
           #create the new entry in the database
           
           
           result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],
                                     data['first_name'],data['titles_new'],data['status'],"",
                                     "",data['date_from'],data['date_to'],
                                     data['department'],'',data['funded_by'],
                                     data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])
           
           return result,msg
    
       def updatePersonEntry(self,data,ignoreEntries=None):
           """update an person entry from data. but ignore all fields in ignore Entries"""
           if ignoreEntries is None:
               ignoreEntries = []
               
           #ignoreEntries.append('current_work') # TODO:updatecurrent work
           logging.debug("updatePersonEntry: data=%s ignoreEntries=%s"%(repr(data),repr(ignoreEntries)))
           
           if data['date_to']=="": # wenn date_to leer
                data['date_to']="date_none"
           
           if data['date_from']=="": # wenn date_fromleer
                data['date_from']="date_none"
           msg=""
      
           
           #eintragen
            
           columns=data.keys()
           for x in ignoreEntries:
               logging.debug("updatePersonEntry: ignoring %s"%x)
               try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab
                   columns.remove(x)
               except:
                   pass
   
           
           insert=[]
           for key in columns:
               if data[key]=="date_none": # date_none eintrag wird zu null uebersetzt
                   insert.append('%s=null'%key)
               else:
                   insert.append(""" "%s"=%s"""%(key,self.ZSQLQuote(data[key])))
               
           insertStr=",".join(insert)
           queryStr="update personal_www SET %s where key='%s'"%(insertStr,data['key'])
           self.ZSQLQuery("SET DATESTYLE TO 'German'")
           self.ZSQLQuery(queryStr)
          
           #currentwork
           #if not (txt==""):
           #    queryStr="INSERT INTO current_work (id_main,current,publish) VALUES ('%s','%s','%s')"%(id,txt,txt_p)
           #
           #    self.ZSQLQuery(queryStr)
           
           return True,msg
   
   
       def updatePersonalwww_doIt(self):
           """do the update"""
           args=self.REQUEST.form
           resultSet=self.REQUEST.SESSION['personal_www']['resultSet']
           news=self.REQUEST.SESSION['personal_www']['news']
           conflicts=self.REQUEST.SESSION['personal_www']['conflicts']
           logging.debug("updatePersonalwww_doIt: args=%s\n  resultSet=%s\n  news=%s\n  conflicts=%s"%(args,resultSet,news,conflicts))
           
           ret="<html><body>"
           # generate the new entry
         
           if news and (len(news)>0):
               ret+="<h2>Hinzugef&uuml;gt</h2>"
               ret+="<p>Neueintr&auml;ge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
               ret+="<ul>"
               
           for new in news:
               if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected
                   result,msg=self.generateNewPersonEntry(resultSet[new])
                   if not result:
                       logging.error("Error (generateNewPersonEntry) %s"%msg)
                       ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)
                   else:
                       ret+="<li>OK: %s"%(new.encode('utf-8'))
                       
           if news and (len(news)>0):
               ret+="<p>Neueintr&auml;ge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
               ret+="</ul>"     
           
           # update
   
           if len(conflicts.keys())>0:
               ret+="<h2>&Auml;nderung des Benutzers &uuml;bernehmen</h2>"
               ret+="<p>Wenn n&ouml;tig in Filemaker-db &auml;ndern:</p>"
               
           # konflicte   
           for conflict in conflicts.keys():
               ignoreEntries=[]
               displayIgnored=[]
               for cf in conflicts[conflict]:
                   if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one
                       ignoreEntries.append(cf[0])  #so ignore field cf[0]       
                       displayIgnored.append(cf)
                       
               if len(displayIgnored)>0:
                   ret+="<h3>%s</h3>"%conflict.encode('utf-8')
                   ret+="<table border='1'>"
                   for iE in displayIgnored:
                       ret+="<tr><td>%s</td><td>%s</td><td>%s</td>"%(iE[0].encode('utf-8'),iE[1].encode('utf-8'),iE[2].encode('utf-8'))
                   ret+="</table>"
                   
               self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)
            
            # rest
           cl=list(conflicts.keys())
           
           for key in resultSet.keys():
                if key not in cl:
                    self.updatePersonEntry(resultSet[key])
           return ret+"</body></html>"
                        
   
       def updateInstitutsbiliography(self):
           """update the Institutsbibliogrpahy"""
           self.upDateSQL('personalwww.xml')
           return "<html><body>DONE</body></html>"
   
   
       
   
       def updatePersonalwww_html(self):
           """update form for the homepages web form"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)
           return pt()
   
       
       def updatePersonalwww(self,uploadfile):
           """update personalwww
           @param uploadfile: file handle auf das file
           """
           dsn=self.getConnectionObj().connection_string
           #dsn="dbname=personalwww"
           resultSet=updatePersonalWWW.importFMPXML(uploadfile)
           news,conflicts=updatePersonalWWW.checkImport(dsn, resultSet)
   
           self.REQUEST.SESSION['personal_www']={}
           self.REQUEST.SESSION['personal_www']['resultSet']=resultSet
           self.REQUEST.SESSION['personal_www']['news']=news
           self.REQUEST.SESSION['personal_www']['conflicts']=conflicts
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww_check.zpt')).__of__(self)
           return pt()
       
   
        
       def reindexCatalogs(self,RESPONSE=None):
           """reindex members and project catalog"""
           
           
           try:
               
               self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
               logger("MPIWG Root (reindexCatalog: projects)",logging.INFO,"DONE")
           except:
               logger("MPIWG Root (reindexCatalog: projects)",logging.WARNING," %s %s"%sys.exc_info()[:2])
           
           try:
               
               self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
               logger("MPIWG Root (reindexCatalog: members)",logging.INFO,"DONE")
           except:
               logger("MPIWG Root (reindexCatalog: members)",logging.WARNING," %s %s"%sys.exc_info()[:2])
           
           try:
               
               self.fulltextProjectsMembers.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
               logger("MPIWG Root (reindexCatalog: fulltextProjectsMembers)",logging.INFO,"DONE")
           except:
               logger("MPIWG Root (reindexCatalog: fulltextProjectsMembers)",logging.WARNING," %s %s"%sys.exc_info()[:2])
               
           
           
           
           
           
           if RESPONSE:
               RESPONSE.redirect('manage_main')
   
           
           
   
       def getAllMembers(self):
           #ret=[]
           
           def sorter(x,y):
               return cmp(x[0],y[0])
                       
           results=self.MembersCatalog({'isPublished':True})
          
           ret=[(unicodify(", ".join([proj.lastName, proj.firstName])), proj.getKey) for proj in results]
           
           ret.sort(sorter)
           return ret
       
       
       def printAllMembers(self):
           """print"""
           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 getTreeRSS(self,dep=None,date=None,onlyActive=1,onlyArchived=0):
           """generateTree"""
           rss="""<?xml version="1.0" encoding="utf-8"?>
                    <rss version="2.0">
                      <channel>"""
           
           for obj in self.getTree(dep, date, onlyActive, onlyArchived):
               linkStr="""<link>http://www.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""
               rss+="""<item>"""
               rss+=linkStr%obj[3].getId()
               rss+="""</item>"""
               if hasattr(obj[3],'publicationList'):
               rss+="""<item>"""
                   rss+=linkStr%(obj[3].getId()+"/publicationList");
                   rss+="""</item>"""
           rss+="""</channel>
           </rss>"""
   
           
           return rss
   
       def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
           """generate Tree from project list
           als Liste, jeder Eintrag ist ein Tupel ,(Tiefe, ProjektNummer,ProjektObject
           onlyActive = 0  : alle Projekte
           onlyActive = 1 : nur active Projekte
           onlyActive = 2: nur inactive Projekte
           
           onlyArchived=0: alle Projekte
           onlyArchived= 1 : nur aktuelle Projekte
           onlyArchived = 2: nur archivierte Projekte
           
           department fuer das Tree geholt werden soll
           """
   
           returnListTmp=[]
           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": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive
                           project[0].setActiveFlag(False)
                      
                       if (not dep) or (splittedId[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.
                           
                           if (onlyActive==0):
                               returnListTmp.append((depth,nr,title,project[0]))
                           elif (onlyActive==1) and project[0].isActiveProject(): #nur active projekte
                               returnListTmp.append((depth,nr,title,project[0]))
                           elif (onlyActive==2) and (not project[0].isActiveProject()): #nur active projekte
                               returnListTmp.append((depth,nr,title,project[0]))
                      
                      
           #filter jetzt die Liste nach Archived oder nicht
           for entry in returnListTmp:
                       if (onlyArchived==0):
                               returnList.append(entry)
                       elif (onlyArchived==1) and (not entry[3].isArchivedProject()): #nur active projekte
                               returnList.append(entry)
                       elif (onlyArchived==2) and (entry[3].isArchivedProject()): #nur active projekte
                               returnList.append(entry)
                      
           
           return returnList
   
   
           
       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:
               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)
   
   
           if RESPONSE is not None:
               RESPONSE.redirect('showTree')
           
       def changeTree(self,RESPONSE=None):
           """change the complete tree"""
           form=self.REQUEST.form
           hashList={}
           onlyArchived=int(form.get("onlyArchived",0))
           onlyActive=int(form.get("onlyActive",0))
           dep=form.get("dep",None)
           
           fields=self.getTree(dep=dep,onlyArchived=onlyArchived,onlyActive=onlyActive)
           
           logging.info("GOT TREE!----------------------------------------------------")
           for field in form.keys():
               
               splitted=field.split('_')
               if (len(splitted)>1) and (splitted[1]=="runningNumber"): #feld hat die Form Nummer_name und runnignNumber
               
                   
                   nr=int(splitted[0]) # nummer des Datensatzes
                   currentEntry = fields[nr]
               
                   if form.has_key(str(nr)+'_active'): # active flag is set
                       fields[nr][3].setActiveFlag(True)
                   else:
                       fields[nr][3].setActiveFlag(False)
                       
                   #nummer hat sich geaendert
                   
                   entryChanged = False;
                   
                   if isinstance(fields[nr][3].xdata_05,list): #for some reasons somtimes the content of the field is a list with one entry.
                       fields[nr][3].xdata_05=fields[nr][3].xdata_05[0]
                       
                   if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):
                       logging.info("Changed!Number+++++++++++++++++++++++++++++++++")
                       logging.info(repr(fields[nr][3].xdata_05)+" ---> "+ repr(form[str(nr)+'_number']))
                       fields[nr][3].xdata_05=form[str(nr)+'_number']
                       entryChanged = True
                       
                   #completed har sich geaendert
                             
                   td = fields[nr][3].transformDate # hole die funktion zum transformieren des datums
                     
                   if not (td(fields[nr][3].getCompletedAt())==td(form[str(nr)+'_completed'])):
                       fields[nr][3].setCompletedAt(form[str(nr)+'_completed'])
                       logging.info(repr(td(fields[nr][3].getCompletedAt()))+" ---> "+ repr(td(form[str(nr)+'_completed'])))
                       logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
                       entryChanged = True
                   
                   if not (td(fields[nr][3].getStartedAt())==td(form[str(nr)+'_started'])):
                       fields[nr][3].setStartedAt(form[str(nr)+'_started'])
               
                       logging.info(repr(td(fields[nr][3].getStartedAt()))+" ---> "+ repr(td(form[str(nr)+'_started'])))
                       logging.info("Changed!Started+++++++++++++++++++++++++++++++++")
                       entryChanged = True
                   
                   
                   if entryChanged:
                       logging.info("Changed!+++++++++++++++++++++++++++++++++")
                       fields[nr][3].copyObjectToArchive()
                   
                       
           if RESPONSE is not None:
               RESPONSE.redirect('showTree')
   
       def getProjectWithId(self,id):
           fields=self.getProjectFields('xdata_05')
           for field in fields:
               if field[1]==id:
                   return field[0]
   
           return None
               
           
               
           
       def 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:
                       #ret.append("%s"%person.encode('utf-8'))
                       ret.append("%s"%person)
           return string.join(ret,";")
           
       def getMemberIdFromKey(self,key):
           """gibt die ensprechende id  im members Ordner zum key"""
           
           if key=="":
               return ""
           try:
               key=utf8ify(key)
               catalogged=self.MembersCatalog({'getKey':key})
               if len(catalogged)==0:
                   return ""
               else:
                   return catalogged[0].getObject().getId()
           
           except:
               return ""
   
               
   
       def getProjectsOfMembers(self,date=None):
           """give tuple member /projects"""
           ret=[]
           members=self.getAllMembers()
           logging.debug("X %s"%repr(members))
           #return str(members)
           for x in members:
               #logging.debug("X %s"%repr(x))
               projects=self.getProjectsOfMember(key=x[1],date=date)
               if len(projects)>0:
                   ret.append((x[0],projects))
               
           return ret
   
       def getProjectsOfMember(self,key=None,date=None,onlyArchived=1,onlyActive=1):
           """get projects of a member
       
           @param key: (optional) Key zur Idenfikation des Benutzer
           @param date: (optional) Version die zum Zeitpunkt date gueltig war
           @param onlyArchived: 
           onlyArchived=0: alle Projekte
           onlyArchived= 1 : nur aktuelle Projekte
           onlyArchived = 2: nur archivierte Projekte
           """
           # TODO: Die ganze Loesung
           def sortP(x,y):
               """sort by sorting number"""
               return cmp(x.WEB_title,y.WEB_title)
           
           ret=[]  
           if key:     
               logging.debug("MPIWGROOT (getProjectsOfMember):"+key)
               proj=self.ProjectCatalog({'getPersonKeyList':utf8ify(key)})
           else:
               return ret # key muss definiert sein
           
           #logging.debug("MPIWGROOT (getProjectsOfMember):"+repr(proj))
           if proj:
               proj2=[]
               for x in proj:
                   #logging.error("proj:%s"%repr(x.getPath()))
                   if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):   
                         proj2.append(x)
   
           else:
               proj2=[]
               
          
          
           proj2.sort(sortP)
   
           projectListe=[]
           #logging.error("getprojectsofmember proj2: %s"%repr(proj2))
           for proj in proj2:   
               obj=proj.getObject()
               add=False
               if onlyArchived==1: #nur aktuell projecte
                   if not obj.isArchivedProject():
                       add=True
               elif onlyArchived==2: #nur archivierte
                   if obj.isArchivedProject():
                       add=True
               else: #alle
                  add=True 
                  
               if onlyActive==1: #nur active projecte
                   if obj.isActiveProject():
                       add=add & True
                   else:
                       add=add & False
                   
               elif onlyArchived==2: #nur nicht aktvive
                   if not obj.isActiveProject():
                       add=add & True
               else: #alle
                  add=add & True
                       
               if add:
                   projectListe.append(obj)
                   
           #logging.error("getprojectsofmember projectliste: %s"%repr(projectListe))
           return projectListe
        
       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:
               return []
               
   ##         splitted=name.split(",") # version nachname, vorname...
   ##         if len(splitted)>1:
   ##             lastName=splitted[0] 
   ##             firstName=splitted[1]
   ##         else: 
   ##             splitted=name.split(" ") #version vorname irgenwas nachnamae
           
   ##             lastName=splitted[len(splitted)-1]
   ##             firstName=string.join(splitted[0:len(splitted)-1])
   
   ##         objs=[]
   
           #print  self.members 
         ##   for x in self.members.__dict__:
   ##             obj=getattr(self.members,x)
   ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
                   
   ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
                       
   ##                     objs.append((obj,lastName+", "+firstName))
   
           
   ##        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 generateNameIndex(self):
           """erzeuge einen index verwendeter personen"""
           import psycopg
           o = psycopg.connect('dbname=authorities user=dwinter password=3333',serialize=0) 
           results={}
           print self.fulltext.historicalNames.items()
           for nameItem in self.fulltext.historicalNames.items(): #gehe durch alle namen des lexikons
               
               c = o.cursor() 
               name=nameItem[0]
               print "check",name
               c.execute("select lastname,firstname from persons where lower(lastname) = '%s'"%quote(name))
               tmpres=c.fetchall()
               firstnames=[result[1] for result in tmpres] # find all firstnames
               if tmpres:
                   lastname=tmpres[0][0]
                   
               for found in self.fulltext({'names':name}):
                   if found.getObject().isActual():
                       for nh in found.getObject().getGetNeighbourhood(name, length=50,tagging=False): #hole umgebung
                           #schaue nun ob der vorname hinter oder vor dem name ist
                           position=nh.find(lastname)
                           # vorher
                           #print "NH",nh
                           bevorS=nh[0:position].split()
                           #print "BV",bevorS
                           if len(bevorS)>1:
                               try:
                                   bevor=[bevorS[-1],bevorS[-2]]
                               except:
                                   bevor=[bevorS[0]]
                           else:
                               bevor=[]
                           #nachher
                           behindS= re.split("[,|;| ]",nh[position:]) 
                           #print "BH",behindS
                           if len(behindS)>2:
                               try:
                                   behind=behindS[1:3]
                               except:
                                   behind=[bevorS[1]]
                           else:
                               behind=[]
                           for firstname in firstnames:
                               if firstname in bevor+behind: #Namen wie mit Adelspraedikaten werden so erstmal nich gefunden
                                   id="%s,%s"%(lastname,firstname)
                                   if not results.has_key(id):
                                       results[id]=[]
                                   objId=found.getObject().getId()
                                   if not (objId in results[id]):
                                       print "d %s for %s"%(id,objId)    
                                       results[id].append(objId)    
               self.nameIndex=results
           return results
                       
       def editNameIndexHTML(self):
           """edit the name index"""
           if not hasattr(self,'nameIndexEdited'): # falls editierter index noch nicht existiert, kopiere automatisch erstellten
               self.nameIndexEdited=copy.copy(self.nameIndex)
               print "huh"
           #self.nameIndexEdited=copy.copy(self.nameIndex)
           #print self.nameIndexEdited
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalNames.zpt')).__of__(self)
           return pt()
       
       def getNamesInProject(self,projectId):
           """get all names ofnameIndexEdited which are references in projec with projectId"""
           
           ret=[]
           for name in self.nameIndexEdited.keys():
               if projectId in self.nameIndexEdited[name]:
                   ret.append(name)
           
           return ret
       
       def editNameIndex(self,RESPONSE=None,name=None,occurrances=None,submit=None):
           """edit the index"""
           nI=self.nameIndexEdited # mI introduced to make sure that changes to nameIndexEdited are know to ZODB
           if submit=="delete":
              
   
               dh=getattr(self,'deletedHistoricalNames',{})
               
               if type(dh) is ListType:
                   dh={}
               if not dh.has_key(name):
                   dh[name]=occurrances.split("\n")
               else:
                   dh[name]+=occurrances.split("\n")
               
               self.deletedHistoricalNames=dh
               
               del self.nameIndexEdited[name]
               
           
           elif (submit=="change"):
               
               nI[name]=occurrances.split("\n")[0:]
               
           elif (submit=="add"):
               if not nI.has_key(name):
                   nI[name]=occurrances.split("\n")
               else:
                   nI[name]+=occurrances.split("\n")
       
           self.nameIndexEdited=nI
      
         
           if RESPONSE is not None:
               RESPONSE.redirect('editNameIndexHTML')
           
       
       
       def restoreIndex(self):
           """restore"""
           self.nameIndexEdited=self.nameIndex
           return "done"
       
   
       def sortResults(self,results):
           """search the catalog and give results back sorted by meta_type"""
           ret = {}
           logging.debug(results())
           for result in results():
               metaType = result.meta_type
               resultList= ret.get(metaType,[])
               resultList.append(result)
               ret[metaType]=resultList
           
           logging.debug(ret)
           return ret
           
               
   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')
           
Removed from v.1.1  
changed lines
  Added in v.1.1.2.39

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