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

Diff for /MPIWGWeb/Attic/MPIWGRoot.py between versions 1.1.2.3 and 1.1.2.11

version 1.1.2.3, 2008/08/26 14:00:42 version 1.1.2.11, 2008/09/03 11:13:44
Line 30  import updatePersonalWWW Line 30  import updatePersonalWWW
 import MPIWGStaff  import MPIWGStaff
 from MPIWGHelper import *  from MPIWGHelper import *
   
   
   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):  class MPIWGRoot(ZSQLExtendFolder):
     """Stammordner fuer den Web-Server"""      """Stammordner fuer den Web-Server"""
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',      fieldLabels={'WEB_title':'WEB_Title',
              'xdata_03':'Historical Persons','xdata_04':'Time period',                   'xdata_01':'Responsible Scientists',
              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',                   'xdata_02':'Department',
              'xdata_08':'Other involved scholars' ,'xdata_09':'Disciplines','xdata_10':'Themes',                   'xdata_03':'Historical Persons',
              'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',                   'xdata_04':'Time period',
              'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',                   'xdata_05':'Sorting number',
              'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}                   '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']      folders=['MPIWGProject','Folder','ECHO_Navigation']
     meta_type='MPIWGRoot'      meta_type='MPIWGRoot'
   
       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
           
           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=obj.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 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):      def transformProjectsToId(self):
         """trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste          """trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste
         verantwortlicher Personen versieht"""          verantwortlicher Personen versieht"""
         projects=self.getTree()          projects=self.getTree()
         ret=""          ret=""
         for project in projects:          for project in projects:
               
             proj=project[3]              proj=project[3]
             persons=proj.identifyNames(proj.getContent('xdata_01'))              persons=proj.identifyNames(proj.getContent('xdata_01'))
             if not hasattr(proj,'responsibleScientistsList'):              if not hasattr(proj,'responsibleScientistsList'):
Line 68  class MPIWGRoot(ZSQLExtendFolder): Line 183  class MPIWGRoot(ZSQLExtendFolder):
                   
         return ret          return ret
                                   
                   
     def harvestProjects(self):      def harvestProjects(self):
         """harvest"""          """harvest"""
         folder="/tmp"          folder="/tmp"
Line 257  class MPIWGRoot(ZSQLExtendFolder): Line 373  class MPIWGRoot(ZSQLExtendFolder):
         else:          else:
             return None              return None
   
       def isType(self,object,meta_type):
           """teste ob ein object vom meta_type ist."""
           return (object.meta_type==meta_type)
       
     def isActive(self,name):      def isActive(self,name):
         """teste ob subnavigation aktiv"""          """teste ob subnavigation aktiv"""
         for part in self.REQUEST['URL'].split("/"):          for part in self.REQUEST['URL'].split("/"):
Line 264  class MPIWGRoot(ZSQLExtendFolder): Line 384  class MPIWGRoot(ZSQLExtendFolder):
                 return True                  return True
         return False          return False
                   
     def getSection(self):      
         """returns the current section name"""      def getSections(self):
         root = self.absolute_url()          """returns a list of all sections i.e. top-level MPIWGFolders"""
         url = self.REQUEST['URL']          secs = self.objectItems(['MPIWGFolder'])
         if not url:          secs.sort(sortWeight)
             return None          #logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))
         path = string.replace(url, root, '')          return secs
         paths = path.split('/')  
         if len(paths) > 0:  
             sec = paths[1]  
             if sec.find('.') < 0:  
                 return sec  
             else:  
                 return None  
         return None  
   
     def getSectionStyle(self, name, style=""):      def getSectionStyle(self, name, style=""):
         """returns a string with the given style + '-sel' if the current section == name"""          """returns a string with the given style + '-sel' if the current section == name"""
Line 318  class MPIWGRoot(ZSQLExtendFolder): Line 430  class MPIWGRoot(ZSQLExtendFolder):
   
     def isActiveMember(self,key):      def isActiveMember(self,key):
         """tested ob Mitarbeiter key ist aktiv"""          """tested ob Mitarbeiter key ist aktiv"""
           key=utf8ify(key)
         ret=self.getat(self.ZSQLInlineSearch(_table='personal_www',          ret=self.getat(self.ZSQLInlineSearch(_table='personal_www',
                                             _op_key='eq',key=key,                                              _op_key='eq',key=key,
                                             _op_publish_the_data='eq',                                              _op_publish_the_data='eq',
Line 484  class MPIWGRoot(ZSQLExtendFolder): Line 597  class MPIWGRoot(ZSQLExtendFolder):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
   
     def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):      def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
         """childs alle childs, alle parents"""          """childs alle childs, alle parents"""
         ret=[]          ret=[]
                   
         if parents:          if parents:
             splitted=parents.split(".")              pnums=parents.split(".")
             parentId=string.join(splitted[0:len(splitted)-1],".")              while len(pnums) > 1:
                   pnums.pop()
                   parentId=string.join(pnums,".")
                   
             for project in self.getProjectFields('xdata_05',sort='int',date=date):              for project in self.getProjectFields('xdata_05',sort='int',date=date):
                 if project[1]==parentId:                  if project[1]==parentId:
                     ret.append(project)                      ret.append(project)
   
                   if (depth is not None) and (len(ret) >= depth):
                       break
   
         if childs:          if childs:
             for project in self.getProjectFields('xdata_05',sort='int',date=date):              for project in self.getProjectFields('xdata_05',sort='int',date=date):
                 searchStr=childs+"(\..*)"                  searchStr=childs+"(\..*)"
Line 511  class MPIWGRoot(ZSQLExtendFolder): Line 628  class MPIWGRoot(ZSQLExtendFolder):
                                 ret.append(project)                                  ret.append(project)
                         else:                          else:
                             ret.append(project)                              ret.append(project)
           
           #logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))
         return ret          return ret
           
       
     def getProjectFields(self,fieldName,date=None,folder=None,sort=None):      def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
         """getListofFieldNames"""          """getListofFieldNames"""
         ret=[]          ret=[]
Line 770  class MPIWGRoot(ZSQLExtendFolder): Line 890  class MPIWGRoot(ZSQLExtendFolder):
         return "<html><body>DONE</body></html>"          return "<html><body>DONE</body></html>"
   
   
       
   
     def updatePersonalwww_html(self):      def updatePersonalwww_html(self):
         """update form for the homepages web form"""          """update form for the homepages web form"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)
Line 845  class MPIWGRoot(ZSQLExtendFolder): Line 967  class MPIWGRoot(ZSQLExtendFolder):
         else:          else:
             return entry              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://wwwneu.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):      def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
         """generate Tree from project list          """generate Tree from project list
Line 973  class MPIWGRoot(ZSQLExtendFolder): Line 1115  class MPIWGRoot(ZSQLExtendFolder):
                     logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")                      logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
                     entryChanged = True                      entryChanged = True
                                   
                   if not (fields[nr][3].getStartedAt()==fields[nr][3].transformDate(form[str(nr)+'_started'])):
                       fields[nr][3].setStartedAt(form[str(nr)+'_started'])
                       logging.info("Changed!Started+++++++++++++++++++++++++++++++++")
                       entryChanged = True
                   
                                   
                 if entryChanged:                  if entryChanged:
                     logging.info("Changed!+++++++++++++++++++++++++++++++++")                      logging.info("Changed!+++++++++++++++++++++++++++++++++")
Line 1028  class MPIWGRoot(ZSQLExtendFolder): Line 1175  class MPIWGRoot(ZSQLExtendFolder):
                   
         if key=="":          if key=="":
             return ""              return ""
           key=utf8ify(key)
         catalogged=self.MembersCatalog({'getKey':key})          catalogged=self.MembersCatalog({'getKey':key})
         if len(catalogged)==0:          if len(catalogged)==0:
             return ""              return ""
Line 1075  class MPIWGRoot(ZSQLExtendFolder): Line 1223  class MPIWGRoot(ZSQLExtendFolder):
         if proj:          if proj:
             proj2=[]              proj2=[]
             for x in proj:              for x in proj:
                   #logging.error("proj:%s"%repr(x.getPath()))
                 if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):                     if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):   
                       proj2.append(x)                        proj2.append(x)
   
Line 1086  class MPIWGRoot(ZSQLExtendFolder): Line 1235  class MPIWGRoot(ZSQLExtendFolder):
         proj2.sort(sortP)          proj2.sort(sortP)
   
         projectListe=[]          projectListe=[]
                   #logging.error("getprojectsofmember proj2: %s"%repr(proj2))
         for proj in proj2:             for proj in proj2:   
             obj=proj.getObject()              obj=proj.getObject()
             add=False              add=False
Line 1114  class MPIWGRoot(ZSQLExtendFolder): Line 1263  class MPIWGRoot(ZSQLExtendFolder):
             if add:              if add:
                 projectListe.append(obj)                  projectListe.append(obj)
                                   
                #logging.error("getprojectsofmember projectliste: %s"%repr(projectListe))
         return projectListe          return projectListe
             
     def givePersonList(self,name):      def givePersonList(self,name):
Removed from v.1.1.2.3  
changed lines
  Added in v.1.1.2.11

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