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

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

version 1.1.2.11, 2008/09/03 11:13:44 version 1.1.2.33, 2012/01/06 08:23:10
Line 29  import copy Line 29  import copy
 import updatePersonalWWW  import updatePersonalWWW
 import MPIWGStaff  import MPIWGStaff
 from MPIWGHelper import *  from MPIWGHelper import *
   from BeautifulSoup import BeautifulSoup, Comment
   
 def sortWeight(x,y):  def sortWeight(x,y):
     x1=int(getattr(x[1],'weight','0'))      x1=int(getattr(x[1],'weight','0'))
Line 40  def sortWeight(x,y): Line 40  def sortWeight(x,y):
 class MPIWGRoot(ZSQLExtendFolder):  class MPIWGRoot(ZSQLExtendFolder):
     """Stammordner fuer den Web-Server"""      """Stammordner fuer den Web-Server"""
   
       meta_type='MPIWGRoot'
   
     fieldLabels={'WEB_title':'WEB_Title',      fieldLabels={'WEB_title':'WEB_Title',
                  'xdata_01':'Responsible Scientists',                   'xdata_01':'Responsible Scientists',
                  'xdata_02':'Department',                   'xdata_02':'Department',
Line 58  class MPIWGRoot(ZSQLExtendFolder): Line 60  class MPIWGRoot(ZSQLExtendFolder):
                  'WEB_project_description':'WEB_project_description',                   'WEB_project_description':'WEB_project_description',
                  'WEB_related_pub':'WEB_related_pub'}                   'WEB_related_pub':'WEB_related_pub'}
           
       # (is this used?)
     folders=['MPIWGProject','Folder','ECHO_Navigation']      folders=['MPIWGProject','Folder','ECHO_Navigation']
     meta_type='MPIWGRoot'      # 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 getGetNeighbourhood(self,obj, wordStr, length=100,tagging=True):      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          """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
Line 74  class MPIWGRoot(ZSQLExtendFolder): Line 91  class MPIWGRoot(ZSQLExtendFolder):
         ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird          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          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):          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,               """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              -1, wenn kein Treffer
Line 103  class MPIWGRoot(ZSQLExtendFolder): Line 122  class MPIWGRoot(ZSQLExtendFolder):
         txt=obj.harvest_page()          txt=obj.harvest_page()
         if not txt:          if not txt:
             return ret              return ret
         txt=re.sub("<.*?>", "", txt) # loesche alle Tags          
           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:          for word in words:
             word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "              word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
             pos=0              pos=0
Line 125  class MPIWGRoot(ZSQLExtendFolder): Line 153  class MPIWGRoot(ZSQLExtendFolder):
                         y=max(ranges[nr][1],y)                          y=max(ranges[nr][1],y)
                               
                     str=txt[x: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                      if nr >=0: # word ist in einer schon gefunden Umgebung
                         ranges[nr]=(x,y) # neue Position der Umgebung                          ranges[nr]=(x,y) # neue Position der Umgebung
Line 222  class MPIWGRoot(ZSQLExtendFolder): Line 257  class MPIWGRoot(ZSQLExtendFolder):
         else:          else:
             return array[idx]              return array[idx]
                   
       def getLang(self):
           """returns the default language"""
           return self.lang
   
     def browserCheck(self):      def browserCheck(self):
         """check the browsers request to find out the browser type"""          """check the browsers request to find out the browser type"""
Line 324  class MPIWGRoot(ZSQLExtendFolder): Line 362  class MPIWGRoot(ZSQLExtendFolder):
           
     def subNavStatic(self,obj):      def subNavStatic(self,obj):
         """subnav" von self"""          """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'])          subs=self.ZopeFind(obj,obj_metatypes=['MPIWGTemplate','MPIWGLink'])
         subret=[]          subret=[]
   
Line 339  class MPIWGRoot(ZSQLExtendFolder): Line 372  class MPIWGRoot(ZSQLExtendFolder):
         return subret          return subret
           
     def subNav(self,obj):      def subNav(self,obj):
         """return subnav elemente"""          """return sub-navigation elements i.e. below sections"""
         def sortWeight(x,y):          # get section -> parent should be MPIWGRoot
             x1=int(getattr(x[1],'weight','0'))          p = obj
             y1=int(getattr(y[1],'weight','0'))          sec = None
             return cmp(x1,y1)          # descend parents to the root (and remember the last id)
         #if obj.meta_type in ['MPIWGTemplate','MPIWGLink']:          while p is not None and p.meta_type != 'MPIWGRoot':
         #    id=obj.aq_parent.getId()              sec = p
         #else:              p = p.aq_parent
       
         #id=obj.getId()          subsecs = sec.objectItems(self.nav_meta_types)
           subsecs = [s for s in subsecs if s[1].title != ""]
                   subsecs.sort(sortWeight)
         #suche die zweite ebene          return subsecs
           
         if not obj.aq_parent.getId() in ['de','en']:  
             obj=obj.aq_parent  
           
         while not self.ZopeFind(self,obj_ids=[obj.getId()]):  
             obj=obj.aq_parent  
           
         
         if hasattr(self,obj.getId()):  
               
             subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])  
             subret=[]  
   
             for x in subs:  
                 if not(x[1].title==""):  
                     subret.append(x)  
             subret.sort(sortWeight)  
             return subret  
         else:  
             return None  
   
     def isType(self,object,meta_type):      def isType(self,object,meta_type):
         """teste ob ein object vom meta_type ist."""          """teste ob ein object vom meta_type ist."""
Line 390  class MPIWGRoot(ZSQLExtendFolder): Line 403  class MPIWGRoot(ZSQLExtendFolder):
         secs = self.objectItems(['MPIWGFolder'])          secs = self.objectItems(['MPIWGFolder'])
         secs.sort(sortWeight)          secs.sort(sortWeight)
         #logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))          #logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))
         return secs          # return pure list of objects
           return [s[1] for s in secs]
   
     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 399  class MPIWGRoot(ZSQLExtendFolder): Line 413  class MPIWGRoot(ZSQLExtendFolder):
         else:          else:
             return style                  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):      def MPIWGrootURL(self):
         """returns the URL to the root"""          """returns the URL to the root"""
         return self.absolute_url()          return self.absolute_url()
Line 586  class MPIWGRoot(ZSQLExtendFolder): Line 616  class MPIWGRoot(ZSQLExtendFolder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
         return pt()          return pt()
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):      def changeMPIWGRoot(self,title,connection_id,coneServiceURL,lang=None,autocommit=None,RESPONSE=None):
         """change"""          """change"""
         self.title=title          self.title=title
         self.connection_id=connection_id          self.connection_id=connection_id
         self.disciplineList=disciplineList          #self.disciplineList=disciplineList
         self.themesList=themesList          #self.themesList=themesList
           self.coneServiceURL=coneServiceURL
   
           if lang is not None:
               self.lang = lang
   
           self.autocommit = (autocommit == "on")
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
Line 630  class MPIWGRoot(ZSQLExtendFolder): Line 665  class MPIWGRoot(ZSQLExtendFolder):
                             ret.append(project)                              ret.append(project)
                   
         #logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))          #logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))
        
         return ret          return ret
   
           
Line 677  class MPIWGRoot(ZSQLExtendFolder): Line 713  class MPIWGRoot(ZSQLExtendFolder):
         return projects          return projects
           
                   
     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 updatePublicationDB(self,personId=None):      def updatePublicationDB(self,personId=None):
         """updates the publication db, i.e. copy year and type into the main table"""          """updates the publication db, i.e. copy year and type into the main table"""
                   
Line 773  class MPIWGRoot(ZSQLExtendFolder): Line 798  class MPIWGRoot(ZSQLExtendFolder):
                   
                   
         result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],          result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],
                                   data['first_name'],data['title'],data['status'],"",                                    data['first_name'],data['titles_new'],data['status'],"",
                                   "",data['date_from'],data['date_to'],                                    "",data['date_from'],data['date_to'],
                                   data['department'],data['home_inst'],data['funded_by'],                                    data['department'],'',data['funded_by'],
                                   data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])                                    data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])
                   
         return result,msg          return result,msg
     
     def updatePersonEntry(self,data,ignoreEntries=[]):      def updatePersonEntry(self,data,ignoreEntries=None):
         """update an person entry from data. but ignore all fields in ignore Entries"""          """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          #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          if data['date_to']=="": # wenn date_to leer
              data['date_to']="date_none"               data['date_to']="date_none"
Line 797  class MPIWGRoot(ZSQLExtendFolder): Line 825  class MPIWGRoot(ZSQLExtendFolder):
                     
         columns=data.keys()          columns=data.keys()
         for x in ignoreEntries:          for x in ignoreEntries:
             logging.info("ign rem: %s"%x)              logging.debug("updatePersonEntry: ignoring %s"%x)
             try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab              try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab
              columns.remove(x)               columns.remove(x)
             except:              except:
Line 831  class MPIWGRoot(ZSQLExtendFolder): Line 859  class MPIWGRoot(ZSQLExtendFolder):
         resultSet=self.REQUEST.SESSION['personal_www']['resultSet']          resultSet=self.REQUEST.SESSION['personal_www']['resultSet']
         news=self.REQUEST.SESSION['personal_www']['news']          news=self.REQUEST.SESSION['personal_www']['news']
         conflicts=self.REQUEST.SESSION['personal_www']['conflicts']          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>"          ret="<html><body>"
         # generate the new entry          # generate the new entry
               
Line 838  class MPIWGRoot(ZSQLExtendFolder): Line 868  class MPIWGRoot(ZSQLExtendFolder):
             ret+="<h2>Hinzugef&uuml;gt</h2>"              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+="<p>Neueintr&auml;ge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
             ret+="<ul>"              ret+="<ul>"
         for new in news:  
               
           for new in news:
             if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected              if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected
                 result,msg=self.generateNewPersonEntry(resultSet[new])                  result,msg=self.generateNewPersonEntry(resultSet[new])
                 if not result:                  if not result:
Line 847  class MPIWGRoot(ZSQLExtendFolder): Line 877  class MPIWGRoot(ZSQLExtendFolder):
                     ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)                      ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)
                 else:                  else:
                     ret+="<li>OK: %s"%(new.encode('utf-8'))                      ret+="<li>OK: %s"%(new.encode('utf-8'))
                       
         if news and (len(news)>0):          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+="<p>Neueintr&auml;ge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
             ret+="</ul>"                   ret+="</ul>"     
Line 865  class MPIWGRoot(ZSQLExtendFolder): Line 896  class MPIWGRoot(ZSQLExtendFolder):
                 if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one                  if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one
                     ignoreEntries.append(cf[0])  #so ignore field cf[0]                             ignoreEntries.append(cf[0])  #so ignore field cf[0]       
                     displayIgnored.append(cf)                      displayIgnored.append(cf)
                       
             if len(displayIgnored)>0:              if len(displayIgnored)>0:
                 ret+="<h3>%s</h3>"%conflict.encode('utf-8')                  ret+="<h3>%s</h3>"%conflict.encode('utf-8')
                   
                 ret+="<table border='1'>"                  ret+="<table border='1'>"
                 for iE in displayIgnored:                  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+="<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+="</tabel>"                  ret+="</table>"
                                   
             self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)              self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)
                     
Line 924  class MPIWGRoot(ZSQLExtendFolder): Line 955  class MPIWGRoot(ZSQLExtendFolder):
         try:          try:
                           
             self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])              self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
               logger("MPIWG Root (reindexCatalog: projects)",logging.INFO,"DONE")
         except:          except:
             logger("MPIWG Root (updatehomepage)",logging.WARNING," %s %s"%sys.exc_info()[:2])              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])
                           
                   
           
Line 945  class MPIWGRoot(ZSQLExtendFolder): Line 991  class MPIWGRoot(ZSQLExtendFolder):
                                           
         results=self.MembersCatalog({'isPublished':True})          results=self.MembersCatalog({'isPublished':True})
     
         ret=[(", ".join([proj.lastName, proj.firstName]).decode('utf-8'),proj.getKey) for proj in results]          ret=[(unicodify(", ".join([proj.lastName, proj.firstName])), proj.getKey) for proj in results]
                   
         ret.sort(sorter)          ret.sort(sorter)
         return ret          return ret
Line 974  class MPIWGRoot(ZSQLExtendFolder): Line 1020  class MPIWGRoot(ZSQLExtendFolder):
                    <channel>"""                     <channel>"""
                   
         for obj in self.getTree(dep, date, onlyActive, onlyArchived):          for obj in self.getTree(dep, date, onlyActive, onlyArchived):
             linkStr="""<link>http://wwwneu.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""              linkStr="""<link>http://www.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""
             rss+="""<item>"""              rss+="""<item>"""
             rss+=linkStr%obj[3].getId()              rss+=linkStr%obj[3].getId()
             rss+="""</item>"""              rss+="""</item>"""
Line 998  class MPIWGRoot(ZSQLExtendFolder): Line 1044  class MPIWGRoot(ZSQLExtendFolder):
         onlyArchived=0: alle Projekte          onlyArchived=0: alle Projekte
         onlyArchived= 1 : nur aktuelle Projekte          onlyArchived= 1 : nur aktuelle Projekte
         onlyArchived = 2: nur archivierte Projekte          onlyArchived = 2: nur archivierte Projekte
           
           department fuer das Tree geholt werden soll
         """          """
   
         returnListTmp=[]          returnListTmp=[]
Line 1017  class MPIWGRoot(ZSQLExtendFolder): Line 1065  class MPIWGRoot(ZSQLExtendFolder):
                     if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive                      if idNr[0]=="x": # kompatibilitaet 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 hinzufuegen.                      if (not dep) or (splittedId[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.
                                                   
                         if (onlyActive==0):                          if (onlyActive==0):
                             returnListTmp.append((depth,nr,title,project[0]))                              returnListTmp.append((depth,nr,title,project[0]))
Line 1079  class MPIWGRoot(ZSQLExtendFolder): Line 1127  class MPIWGRoot(ZSQLExtendFolder):
         hashList={}          hashList={}
         onlyArchived=int(form.get("onlyArchived",0))          onlyArchived=int(form.get("onlyArchived",0))
         onlyActive=int(form.get("onlyActive",0))          onlyActive=int(form.get("onlyActive",0))
           dep=form.get("dep",None)
                   
                   fields=self.getTree(dep=dep,onlyArchived=onlyArchived,onlyActive=onlyActive)
         fields=self.getTree(onlyArchived=onlyArchived,onlyActive=onlyActive)  
                   
         logging.info("GOT TREE!----------------------------------------------------")          logging.info("GOT TREE!----------------------------------------------------")
         for field in form.keys():          for field in form.keys():
Line 1098  class MPIWGRoot(ZSQLExtendFolder): Line 1146  class MPIWGRoot(ZSQLExtendFolder):
                 else:                  else:
                     fields[nr][3].setActiveFlag(False)                      fields[nr][3].setActiveFlag(False)
                                           
                 #nummer hat sich geŠndert                  #nummer hat sich geaendert
                                   
                 entryChanged = False;                  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']):                  if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):
                     logging.info("Changed!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']                      fields[nr][3].xdata_05=form[str(nr)+'_number']
                     entryChanged = True                      entryChanged = True
                                           
                 #completed har sich geaendert                  #completed har sich geaendert
                                                           
                 if not (fields[nr][3].getCompletedAt()==fields[nr][3].transformDate(form[str(nr)+'_completed'])):                  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'])                      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+++++++++++++++++++++++++++++++++")                      logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
                     entryChanged = True                      entryChanged = True
                                   
                 if not (fields[nr][3].getStartedAt()==fields[nr][3].transformDate(form[str(nr)+'_started'])):                  if not (td(fields[nr][3].getStartedAt())==td(form[str(nr)+'_started'])):
                     fields[nr][3].setStartedAt(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+++++++++++++++++++++++++++++++++")                      logging.info("Changed!Started+++++++++++++++++++++++++++++++++")
                     entryChanged = True                      entryChanged = True
                                   
Line 1175  class MPIWGRoot(ZSQLExtendFolder): Line 1231  class MPIWGRoot(ZSQLExtendFolder):
                   
         if key=="":          if key=="":
             return ""              return ""
           try:
         key=utf8ify(key)          key=utf8ify(key)
         catalogged=self.MembersCatalog({'getKey':key})          catalogged=self.MembersCatalog({'getKey':key})
         if len(catalogged)==0:          if len(catalogged)==0:
Line 1182  class MPIWGRoot(ZSQLExtendFolder): Line 1239  class MPIWGRoot(ZSQLExtendFolder):
         else:          else:
             return catalogged[0].getObject().getId()              return catalogged[0].getObject().getId()
                   
           except:
               return ""
   
                           
   
Line 1189  class MPIWGRoot(ZSQLExtendFolder): Line 1248  class MPIWGRoot(ZSQLExtendFolder):
         """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 1215  class MPIWGRoot(ZSQLExtendFolder): Line 1275  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 1460  class MPIWGRoot(ZSQLExtendFolder): Line 1520  class MPIWGRoot(ZSQLExtendFolder):
         return "done"          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):  def manage_addMPIWGRootForm(self):
     """form for adding the root"""      """form for adding the root"""
Removed from v.1.1.2.11  
changed lines
  Added in v.1.1.2.33

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