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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.47.2.54 and 1.47.2.60

version 1.47.2.54, 2006/07/14 09:14:17 version 1.47.2.60, 2006/09/14 18:28:27
Line 33  from Ft.Xml.XPath import Evaluate Line 33  from Ft.Xml.XPath import Evaluate
 from Ft.Xml.XPath.Context import Context  from Ft.Xml.XPath.Context import Context
 from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print  from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
 from Ft.Xml import EMPTY_NAMESPACE  from Ft.Xml import EMPTY_NAMESPACE
   import psycopg
   
 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']  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']
   
Line 47  def getTextFromNode(nodename): Line 48  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
   
   def sortStopWordsF(self,xo,yo):
       if not hasattr(self,'_v_stopWords'):
           self._v_stopWords=self.stopwords_en.data.split("\n")
       
       x=str(xo[1])
       y=str(yo[1])
       
       strx=x.split(" ")
       stry=y.split(" ")
       
       for tmp in strx:
           if tmp.lower() in self._v_stopWords:
               del strx[strx.index(tmp)]
       
       for tmp in stry:
           if tmp.lower() in self._v_stopWords:
               del stry[stry.index(tmp)]
               
       return cmp(" ".join(strx)," ".join(stry))
       
   def sortStopWords(self):
       return lambda x,y : sortStopWordsF(self,x,y)
       
 def sortF(x,y):  def sortF(x,y):
     try:      try:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
Line 270  class MPIWGRoot(ZSQLExtendFolder): Line 295  class MPIWGRoot(ZSQLExtendFolder):
     folders=['MPIWGProject','Folder','ECHO_Navigation']      folders=['MPIWGProject','Folder','ECHO_Navigation']
     meta_type='MPIWGRoot'      meta_type='MPIWGRoot'
   
       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):      def decode(self,str):
         """decoder"""          """decoder"""
         if not str:          if not str:
Line 354  class MPIWGRoot(ZSQLExtendFolder): Line 396  class MPIWGRoot(ZSQLExtendFolder):
             else:              else:
                 return False                  return False
                   
       def subNavStatic(self,obj):
           """subnav" von self"""
           def sortWeight(x,y):
               x1=int(getattr(x[1],'weight','0'))
               y1=int(getattr(y[1],'weight','0'))
               return cmp(x1,y1)
         
           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):      def subNav(self,obj):
         """return subnav elemente"""          """return subnav elemente"""
         def sortWeight(x,y):          def sortWeight(x,y):
Line 368  class MPIWGRoot(ZSQLExtendFolder): Line 426  class MPIWGRoot(ZSQLExtendFolder):
   
                   
         #suche die zweite ebene          #suche die zweite ebene
           
         if not obj.aq_parent.getId() in ['de','en']:          if not obj.aq_parent.getId() in ['de','en']:
             obj=obj.aq_parent              obj=obj.aq_parent
                           
         while not self.ZopeFind(self,obj_ids=[obj.getId()]):          while not self.ZopeFind(self,obj_ids=[obj.getId()]):
             obj=obj.aq_parent              obj=obj.aq_parent
                   
         
         if hasattr(self,obj.getId()):          if hasattr(self,obj.getId()):
                           
             subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])              subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])
Line 502  class MPIWGRoot(ZSQLExtendFolder): Line 562  class MPIWGRoot(ZSQLExtendFolder):
         self.id=id          self.id=id
         self.title=title          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):      def urlQuote(self,str):
         """quote"""          """quote"""
         return urllib.quote(str)          return urllib.quote(str)
Line 700  class MPIWGRoot(ZSQLExtendFolder): Line 776  class MPIWGRoot(ZSQLExtendFolder):
                   
         if sort=="int":          if sort=="int":
             ret.sort(sortI)              ret.sort(sortI)
           elif sort=="stopWords":
    
               ret.sort(sortStopWords(self))
               
         else:          else:
             ret.sort(sortF)              ret.sort(sortF)
                   
Line 997  class MPIWGRoot(ZSQLExtendFolder): Line 1077  class MPIWGRoot(ZSQLExtendFolder):
             return entry              return entry
   
   
     def getTree(self,date=None,onlyActive=None):      def getTree(self,dep=None,date=None,onlyActive=None):
         """generate Tree from project list"""          """generate Tree from project list"""
   
         returnList=[]          returnList=[]
Line 1015  class MPIWGRoot(ZSQLExtendFolder): Line 1095  class MPIWGRoot(ZSQLExtendFolder):
                     if idNr[0]=="x": # kompatibilitŠt mit alter Konvention, x vor der Nummer macht project inactive                      if idNr[0]=="x": # kompatibilitŠt mit alter Konvention, x vor der Nummer macht project inactive
                         project[0].setActiveFlag(False)                          project[0].setActiveFlag(False)
                                         
                       if (not dep) or (idNr[0]==dep): #falls dep gesetzt ist nur dieses hinzufŸgen.
                     if onlyActive and project[0].isActiveProject(): #nur active projekte                      if onlyActive and project[0].isActiveProject(): #nur active projekte
                        returnList.append((depth,nr,title,project[0]))                         returnList.append((depth,nr,title,project[0]))
                     elif not onlyActive:                      elif not onlyActive:
                       returnList.append((depth,nr,title,project[0]))                        returnList.append((depth,nr,title,project[0]))
         return returnList          return returnList
   
     def formatElementsAsList(self,elements):      def formatElementsAsList(self,elements,onlyOneDept=False):
         """formatiere tree als liste"""          """formatiere tree als liste"""
                   
         actualDepth=0          actualDepth=0
Line 1067  class MPIWGRoot(ZSQLExtendFolder): Line 1148  class MPIWGRoot(ZSQLExtendFolder):
             if actualDepth==1:              if actualDepth==1:
                 departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group','6':'Ind. Research Group','7':'Research Network'}                   departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group','6':'Ind. Research Group','7':'Research Network'} 
                 department=element[3].getContent('xdata_05')                  department=element[3].getContent('xdata_05')
                   if not onlyOneDept:
                 ret+="""<a href="#top"><img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])                  ret+="""<a href="#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'):              if self.REQUEST.has_key('date'):
Line 1366  class MPIWGRoot(ZSQLExtendFolder): Line 1448  class MPIWGRoot(ZSQLExtendFolder):
         return (fieldname in checkFields)          return (fieldname in checkFields)
   
                   
       def generateNameIndex(self):
           """erzeuge einen index verwendeter personen"""
           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 "added %s for %s"%(id,objId)    
                                       results[id].append(objId)    
               self.nameIndex=results
           return results
                       
 def manage_addMPIWGRootForm(self):  def manage_addMPIWGRootForm(self):
     """form for adding the root"""      """form for adding the root"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
Line 1433  class MPIWGProject(CatalogAware,Folder): Line 1569  class MPIWGProject(CatalogAware,Folder):
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
     default_catalog='ProjectCatalog'      default_catalog='ProjectCatalog'
   
    
     def sortedByPlace(self,metatype):      def sortedByPlace(self,metatype):
         """find metatype and sort by place"""          """find metatype and sort by place"""
         def sort(x,y):          def sort(x,y):
Line 1889  class MPIWGProject(CatalogAware,Folder): Line 2026  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, zurŸckgegeben 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 grš§e der Umgebung
           @param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false
           """
           
           ret=[] # nimmt das Array auf, dass spŠter zurŸckgegeben 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 zurŸck, 
               -1, wenn kein Treffer
               
               @param nr: Position die geprŸft werden soll
               @param length: LŠnge des Wortes das geprŸft 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 vergrš§ere 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 hinzufŸgen
                           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:
Removed from v.1.47.2.54  
changed lines
  Added in v.1.47.2.60

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