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

Diff for /MPIWGWeb/Attic/MPIWGRoot.py between versions 1.1.2.1 and 1.1.2.12

version 1.1.2.1, 2008/06/24 11:16:27 version 1.1.2.12, 2008/09/03 15:12:57
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'):
                         proj.responsibleScientistsList=[]                          proj.responsibleScientistsList=[]
                                                   
             for person in persons.items():              for person in persons.items():
                 logging.info("XXXX"+repr(person))                
                 if len(person[1]) >1: #nicht eindeutig                  if len(person[1]) >1: #nicht eindeutig
                     ret+="nicht eindeutig ---  %s:  %s\n"%(proj.getId(),person[0])                      ret+="nicht eindeutig ---  %s:  %s\n"%(proj.getId(),person[0])
                                           
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 87  class MPIWGRoot(ZSQLExtendFolder): Line 203  class MPIWGRoot(ZSQLExtendFolder):
                                   
     def decode(self,str):      def decode(self,str):
         """decoder"""          """decoder"""
   
         if not str:          if not str:
             return ""              return ""
         if type(str) is StringType:          if type(str) is StringType:
Line 256  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 263  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 310  class MPIWGRoot(ZSQLExtendFolder): Line 423  class MPIWGRoot(ZSQLExtendFolder):
     def replaceNotEmpty(self,format,field):      def replaceNotEmpty(self,format,field):
         """replace not empty"""          """replace not empty"""
         if field and (not field.lstrip()==''):          if field and (not field.lstrip()==''):
             return format%field              return self.decode(format%field)
         else:          else:
             return ""              return ""
                   
   
     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 483  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 510  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 769  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 844  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 972  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 1027  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 1035  class MPIWGRoot(ZSQLExtendFolder): Line 1184  class MPIWGRoot(ZSQLExtendFolder):
                   
   
                           
 #    def getMembersFromList(self,list):  
 #        """get member names from person full text list"""  
 #        memberlist=[]  
 #        persons=list.split(";")  
 #        for person in persons:  
 #            if len(person)>1: #nicht nur Trennzeichen  
 #                splitted=person.split(",")  
 #                if len(splitted)==1:  
 #                    splitted=person.lstrip().rstrip().split(" ")  
 #                splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
 #                if splittedNew[0]=='':  
 #                    del splittedNew[0]  
 #                search=string.join(splittedNew,' AND ')  
 #                  
 #                if not search=='':  
 #                    try:  
 #                         
 #                        member=self.MembersCatalog({'title':search})  
 #                    
 #                    except:  
 #                        member=None  
 #                if member:  
 #                   logging.error("search publ %s:"%member[0].getObject().isPublished())  
 #                if member and (member[0].getObject().isPublished()):  
 #                    if person =="Otto Sibum" : person="H. Otto Sibum"  
 #                    if person =="Norton Wise" : person="M. Norton Wise"  
 #                      
 #                    #memberlist.append("<a href=%s >%s</a>"%(member[0].absolute_url,person.encode('utf-8')))  
 #                    memberlist.append((person, member[0].getObject().getId()))  
 #                else:  
 #                    #memberlist.append("%s"%person.encode('utf-8'))  
 #                    memberlist.append((person,None))  
 #        return memberlist  
                                                     
 #    def getUrlFromPerson(self,list):  
 #        """get urls to person list"""  
 #        ret=[]  
 #        persons=list.split(";")  
 #        for person in persons:  
 #              
 #            if len(person)>1: #nicht nur Trennzeichen  
 #                splitted=person.split(",")  
 #                if len(splitted)==1:  
 #                    splitted=person.lstrip().rstrip().split(" ")  
 #                splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
 #                if splittedNew[0]=='':  
 #                    del splittedNew[0]  
 #                search=string.join(splittedNew,' AND ')  
 #                  
 #                if not search=='':  
 #  
 #                    try:  
 #                        proj=self.MembersCatalog({'title':search})  
 #                    except:  
 #                        proj=None  
 #  
 #                if proj and (proj[0].getObject().isPublished()):  
 #                    if person =="Otto Sibum" : person="H. Otto Sibum"  
 #                    if person =="Norton Wise" : person="M. Norton Wise"  
 #                    #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))  
 #                   if self.MPIWGrootURL().split("/")[-1]=='en':  
 #                       tmpPath="/en/staff/members/"  
 #                   else:  
 #                        tmpPath="/de/mitarbeiter/members/"  
 #                    ret.append("<a href=%s >%s</a>"%(tmpPath+proj[0].getObject().getId()+"/index.html",person))  
 #                else:  
 #                    #ret.append("%s"%person.encode('utf-8'))  
 #                    ret.append("%s"%person)  
 #        return string.join(ret,";")  
 #                           
     def getProjectsOfMembers(self,date=None):      def getProjectsOfMembers(self,date=None):
         """give tuple member /projects"""          """give tuple member /projects"""
         ret=[]          ret=[]
         members=self.getAllMembers()          members=self.getAllMembers()
                  logging.error("X %s"%repr(members))
         #return str(members)          #return str(members)
         for x in members:          for x in members:
               logging.error("X %s"%repr(x))
             projects=self.getProjectsOfMember(key=x[1],date=date)              projects=self.getProjectsOfMember(key=x[1],date=date)
             if len(projects)>0:              if len(projects)>0:
                 ret.append((x[0],projects))                  ret.append((x[0],projects))
Line 1135  class MPIWGRoot(ZSQLExtendFolder): Line 1216  class MPIWGRoot(ZSQLExtendFolder):
                   
         ret=[]            ret=[]  
         if key:               if key:     
             proj=self.ProjectCatalog({'getPersonKeyList':key})              proj=self.ProjectCatalog({'getPersonKeyList':utf8ify(key)})
         else:          else:
             return ret # key muss definiert sein              return ret # key muss definiert sein
                   
Line 1143  class MPIWGRoot(ZSQLExtendFolder): Line 1224  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 1154  class MPIWGRoot(ZSQLExtendFolder): Line 1236  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 1182  class MPIWGRoot(ZSQLExtendFolder): Line 1264  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.1  
changed lines
  Added in v.1.1.2.12

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