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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.47.2.73 and 1.47.2.83

version 1.47.2.73, 2007/04/19 12:18:50 version 1.47.2.83, 2008/06/24 07:55:05
Line 110  def sortI(x,y): Line 110  def sortI(x,y):
     except:      except:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
   
   
   def unicodify(str):
       """decode str (utf-8 or latin-1 representation) into unicode object"""
       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 utf8ify(str):
       """encode unicode object or string into byte string in utf-8 representation"""
       if not str:
           return ""
       if type(str) is StringType:
           return str
       else:
           return str.encode('utf-8')
   
   
 class MPIWGLink(SimpleItem):  class MPIWGLink(SimpleItem):
     """create a symbolic link to another page"""      """create a symbolic link to another page"""
   
Line 307  class MPIWGRoot(ZSQLExtendFolder): Line 330  class MPIWGRoot(ZSQLExtendFolder):
     folders=['MPIWGProject','Folder','ECHO_Navigation']      folders=['MPIWGProject','Folder','ECHO_Navigation']
     meta_type='MPIWGRoot'      meta_type='MPIWGRoot'
   
       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():
                   logging.info("XXXX"+repr(person))
                   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):      def harvestProjects(self):
         """harvest"""          """harvest"""
Line 335  class MPIWGRoot(ZSQLExtendFolder): Line 381  class MPIWGRoot(ZSQLExtendFolder):
         except:          except:
         return str.decode('latin-1')          return str.decode('latin-1')
         else:          else:
               
             return str              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 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"""
     bt = {}      bt = {}
Line 500  class MPIWGRoot(ZSQLExtendFolder): Line 553  class MPIWGRoot(ZSQLExtendFolder):
         """returns the current section name"""          """returns the current section name"""
         root = self.absolute_url()          root = self.absolute_url()
         url = self.REQUEST['URL']          url = self.REQUEST['URL']
           if not url:
               return None
         path = string.replace(url, root, '')          path = string.replace(url, root, '')
         paths = path.split('/')          paths = path.split('/')
         if len(paths) > 0:          if len(paths) > 0:
Line 549  class MPIWGRoot(ZSQLExtendFolder): Line 604  class MPIWGRoot(ZSQLExtendFolder):
     def isActual(self,project):      def isActual(self,project):
         """checke if project is actual"""          """checke if project is actual"""
         actualTime=time.localtime()          actualTime=time.localtime()
           
           if hasattr(project,'getObject'): #obj ist aus einer catalogTrefferList
         obj= project.getObject()          obj= project.getObject()
           else:
               obj=project
                   
         if getattr(obj,'archiveTime',actualTime)< actualTime:          if getattr(obj,'archiveTime',actualTime)< actualTime:
             return False              return False
Line 830  class MPIWGRoot(ZSQLExtendFolder): Line 889  class MPIWGRoot(ZSQLExtendFolder):
                 #create the object                  #create the object
                 e_mail=args[key]                  e_mail=args[key]
                 try:                  try:
                     newObj=MPIWGStaff.MPIWGStaff(e_mail,res.last_name.encode('utf-8'),res.first_name.encode('utf-8'),k)                      newObj=MPIWGStaff.MPIWGStaff(e_mail,res.last_name,res.first_name,k)
                     memberFolder._setObject(e_mail,newObj)                      memberFolder._setObject(e_mail,newObj)
                     obj=getattr(memberFolder,e_mail)                      obj=getattr(memberFolder,e_mail)
                     obj.reindex_object()                      obj.reindex_object()
                     ret+="Created %s \n"%e_mail                      ret+="Created %s \n"%e_mail
                     created=True                      created=True
                 except:                  except:
   
                     msg="Cannot create new user %s (%s %s)"%(e_mail,sys.exc_info()[0],sys.exc_info()[1])                      msg="Cannot create new user %s (%s %s)"%(e_mail,sys.exc_info()[0],sys.exc_info()[1])
                     logging.error(msg)                      logging.error(msg)
                     ret+=msg+"\n"                      ret+=msg+"\n"
                     created=False                      created=False
                                   
                 if created:                  if created:
                     qstr="update personal_www set web_object_created='yes',e_mail='%s' where key=%s"%(e_mail,self.ZSQLQuote(k))                      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)                      self.ZSQLQuery(qstr)
                   
         return ret          return ret
Line 891  class MPIWGRoot(ZSQLExtendFolder): Line 949  class MPIWGRoot(ZSQLExtendFolder):
                     
         columns=data.keys()          columns=data.keys()
         for x in ignoreEntries:          for x in ignoreEntries:
               logging.info("ign rem: %s"%x)
               try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab
             columns.remove(x)              columns.remove(x)
                           except:
                   pass
   
                   
         insert=[]          insert=[]
Line 914  class MPIWGRoot(ZSQLExtendFolder): Line 975  class MPIWGRoot(ZSQLExtendFolder):
         #    self.ZSQLQuery(queryStr)          #    self.ZSQLQuery(queryStr)
                   
         return True,msg          return True,msg
   
   
     def updatePersonalwww_doIt(self):      def updatePersonalwww_doIt(self):
         """do the update"""          """do the update"""
         args=self.REQUEST.form          args=self.REQUEST.form
Line 924  class MPIWGRoot(ZSQLExtendFolder): Line 987  class MPIWGRoot(ZSQLExtendFolder):
         # generate the new entry          # generate the new entry
               
         if news and (len(news)>0):          if news and (len(news)>0):
             ret+="<h2>HinzugefŸgt</h2>"              ret+="<h2>Hinzugef&uuml;gt</h2>"
             ret+="<p>NeueintrŠ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:
               
Line 937  class MPIWGRoot(ZSQLExtendFolder): Line 1000  class MPIWGRoot(ZSQLExtendFolder):
                 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Š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>"     
                   
         # update          # update
   
         if len(conflicts.keys())>0:          if len(conflicts.keys())>0:
             ret+="<h2>Bei €nderung belassen</h2>"              ret+="<h2>&Auml;nderung des Benutzers &uuml;bernehmen</h2>"
             ret+="<p>Bitte die Filemaker-db entsprehchend Šndern</p>"              ret+="<p>Wenn n&ouml;tig in Filemaker-db &auml;ndern:</p>"
               
                           
           # konflicte   
         for conflict in conflicts.keys():          for conflict in conflicts.keys():
             ignoreEntries=[]              ignoreEntries=[]
             displayIgnored=[]              displayIgnored=[]
Line 964  class MPIWGRoot(ZSQLExtendFolder): Line 1027  class MPIWGRoot(ZSQLExtendFolder):
                                   
             self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)              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>"          return ret+"</body></html>"
                                             
   
     def updateInstitutsbiliography(self):      def updateInstitutsbiliography(self):
         """update the Institutsbibliogrpahy"""          """update the Institutsbibliogrpahy"""
         self.upDateSQL('personalwww.xml')          self.upDateSQL('personalwww.xml')
         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)
         return pt()          return pt()
           
       
     def updatePersonalwww(self,uploadfile):      def updatePersonalwww(self,uploadfile):
         """update personalwww          """update personalwww
         @param uploadfile: file handle auf das file          @param uploadfile: file handle auf das file
Line 1017  class MPIWGRoot(ZSQLExtendFolder): Line 1090  class MPIWGRoot(ZSQLExtendFolder):
     def getAllMembers(self):      def getAllMembers(self):
         #ret=[]          #ret=[]
                   
           def sorter(x,y):
               return cmp(x[0],y[0])
                       
         results=self.MembersCatalog({'isPublished':True})          results=self.MembersCatalog({'isPublished':True})
     
         ret=[", ".join([proj.lastName, proj.firstName]).decode('utf-8') for proj in results]          ret=[(", ".join([proj.lastName, proj.firstName]).decode('utf-8'),proj.getKey) for proj in results]
                   
     ret.sort()          ret.sort(sorter)
         return ret          return ret
       
       
     def printAllMembers(self):      def printAllMembers(self):
         """print"""          """print"""
         members=self.getAllMembers()          members=self.getAllMembers()
Line 1040  class MPIWGRoot(ZSQLExtendFolder): Line 1118  class MPIWGRoot(ZSQLExtendFolder):
             return entry              return entry
   
   
     def getTree(self,dep=None,date=None,onlyActive=None):      def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
         """generate Tree from project list"""          """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
           """
   
           returnListTmp=[]
         returnList=[]          returnList=[]
           
         for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05          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              for idNr in project[1].split(";"): # more than one number
Line 1059  class MPIWGRoot(ZSQLExtendFolder): Line 1148  class MPIWGRoot(ZSQLExtendFolder):
                         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 (idNr[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.
                         if onlyActive and project[0].isActiveProject(): #nur active projekte                          
                            returnList.append((depth,nr,title,project[0]))                          if (onlyActive==0):
                         elif not onlyActive:                              returnListTmp.append((depth,nr,title,project[0]))
                           returnList.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          return returnList
   
   
Line 1103  class MPIWGRoot(ZSQLExtendFolder): Line 1207  class MPIWGRoot(ZSQLExtendFolder):
         """change the complete tree"""          """change the complete tree"""
         form=self.REQUEST.form          form=self.REQUEST.form
         hashList={}          hashList={}
         fields=self.getTree()          onlyArchived=int(form.get("onlyArchived",0))
           onlyActive=int(form.get("onlyActive",0))
           
   
           fields=self.getTree(onlyArchived=onlyArchived,onlyActive=onlyActive)
                   
         for idNr in form.keys():          logging.info("GOT TREE!----------------------------------------------------")
           for field in form.keys():
                           
             splitted=idNr.split('_')              splitted=field.split('_')
               if (len(splitted)>1) and (splitted[1]=="runningNumber"): #feld hat die Form Nummer_name und runnignNumber
                           
             if len(splitted)==1: # name des Feldes = idNr, dann Aendere id_nr  
                 if not (fields[int(idNr)][3].xdata_05==form[idNr]):  
                     fields[int(idNr)][3].xdata_05=form[idNr]  
                     fields[int(idNr)][3].copyObjectToArchive()  
                                           
                 if form.has_key(idNr+'_active'): # active flag is set                  nr=int(splitted[0]) # nummer des Datensatzes
                   currentEntry = fields[nr]
                                       
                     fields[int(splitted[0])][3].setActiveFlag(True)                  if form.has_key(str(nr)+'_active'): # active flag is set
                       fields[nr][3].setActiveFlag(True)
                 else:                  else:
                       fields[nr][3].setActiveFlag(False)
                       
                   #nummer hat sich geŠndert
                   
                   entryChanged = False;
                   
                   
                   if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):
                       logging.info("Changed!Number+++++++++++++++++++++++++++++++++")
                       fields[nr][3].xdata_05=form[str(nr)+'_number']
                       entryChanged = True
                       
                   #completed har sich geaendert
                               
                   if not (fields[nr][3].getCompletedAt()==fields[nr][3].transformDate(form[str(nr)+'_completed'])):
                       fields[nr][3].setCompletedAt(form[str(nr)+'_completed'])
                       logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
                       entryChanged = True
                   
                   
                   if entryChanged:
                       logging.info("Changed!+++++++++++++++++++++++++++++++++")
                       fields[nr][3].copyObjectToArchive()
                                       
                     fields[int(splitted[0])][3].setActiveFlag(False)  
                                           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('showTree')              RESPONSE.redirect('showTree')
Line 1166  class MPIWGRoot(ZSQLExtendFolder): Line 1295  class MPIWGRoot(ZSQLExtendFolder):
                     ret.append("%s"%person)                      ret.append("%s"%person)
         return string.join(ret,";")          return string.join(ret,";")
                   
       def getMemberIdFromKey(self,key):
           """gibt die ensprechende id  im members Ordner zum key"""
                           
     def getMembersFromList(self,list):          if key=="":
         """get member names from person full text list"""              return ""
         memberlist=[]          catalogged=self.MembersCatalog({'getKey':key})
         persons=list.split(";")          if len(catalogged)==0:
         for person in persons:              return ""
             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 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:                  else:
                     #memberlist.append("%s"%person.encode('utf-8'))              return catalogged[0].getObject().getId()
                     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()):  #    def getMembersFromList(self,list):
                     if person =="Otto Sibum" : person="H. Otto Sibum"  #        """get member names from person full text list"""
                     if person =="Norton Wise" : person="M. Norton Wise"  #        memberlist=[]
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))  #        persons=list.split(";")
             if self.MPIWGrootURL().split("/")[-1]=='en':  #        for person in persons:
             tmpPath="/en/staff/members/"  #            if len(person)>1: #nicht nur Trennzeichen
             else:  #                splitted=person.split(",")
                         tmpPath="/de/mitarbeiter/members/"  #                if len(splitted)==1:
                     ret.append("<a href=%s >%s</a>"%(tmpPath+proj[0].getObject().getId()+"/index.html",person))  #                    splitted=person.lstrip().rstrip().split(" ")
                 else:  #                splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
                     #ret.append("%s"%person.encode('utf-8'))  #                if splittedNew[0]=='':
                     ret.append("%s"%person)  #                    del splittedNew[0]
         return string.join(ret,";")  #                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=[]
Line 1240  class MPIWGRoot(ZSQLExtendFolder): Line 1385  class MPIWGRoot(ZSQLExtendFolder):
                 
         #return str(members)          #return str(members)
         for x in members:          for x in members:
                        projects=self.getProjectsOfMember(key=x[1],date=date)
             ret+=self.getProjectsOfMember(name=x,date=date)              if len(projects)>0:
                   ret.append((x[0],projects))
                           
         return ret          return ret
   
     def getProjectsOfMember(self,name=None,key=None,date=None):      def getProjectsOfMember(self,key=None,date=None,onlyArchived=1,onlyActive=1):
         """get projects of a member          """get projects of a member
         @param name: (optional)Vorname + Nachname      
         @param key: (optional) Key zur Idenfikation des Benutzer          @param key: (optional) Key zur Idenfikation des Benutzer
         @param date: (optional) Version die zum Zeitpunkt date gueltig war          @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 Lšsung          # TODO: Die ganze Loesung
         def sortP(x,y):          def sortP(x,y):
             """sort by sorting number"""              """sort by sorting number"""
             #print x.xdata_05,y.xdata_05  
             return cmp(x.WEB_title,y.WEB_title)              return cmp(x.WEB_title,y.WEB_title)
                   
          
         ret=[]          ret=[]
         logging.error("XXXXXXXXXXXXXXXXX")  
         if key:          if key:
                           proj=self.ProjectCatalog({'getPersonKeyList':key})
             #members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)  
             members=self.MembersCatalog({'getKey':key})  
             if len(members)==0:  
                 return ret  
               
             splitted =  [members[0].lastName,members[0].firstName]  
           
         elif name:  
               
             splitted=name.split(",")  
         else:          else:
             return ret # name oder key mussen definiert sein              return ret # key muss definiert sein
                   
         #XXXX  
         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]  
                   
         #for s in splitted:  
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
           
         proj=self.ProjectCatalog({'xdata_01':search})  
         logging.error("XXXXXXXXXXX %s"%proj)  
         if proj:          if proj:
             proj2=[]              proj2=[]
             for x in proj:              for x in proj:
                 if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):                  if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):
                     # furchtbarer hack um sicher zustellen dass christoph hoffmann nicht mit Dieter Hoffmann verwechselt wird.  
                     if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):   
                        proj2.append(x)                         proj2.append(x)
   
         else:          else:
             proj2=[]              proj2=[]
                           
         proj=self.ProjectCatalog({'xdata_08':search})  
         if proj:  
             names=[x.WEB_title for x in proj]  
             for x in proj:  
                   
                 if (not x.WEB_title in names) and (getattr(x.getObject(),'archiveTime','')==''):  
                     proj2.append(x)  
   
   
         proj2.sort(sortP)          proj2.sort(sortP)
   
         if len(proj2)>0:          projectListe=[]
             ret.append((name,proj2))  
   
         return ret          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)
                   
        
           return projectListe
             
     def givePersonList(self,name):      def givePersonList(self,name):
         """check if person is in personfolder and return list of person objects"""          """check if person is in personfolder and return list of person objects"""
Line 1573  class MPIWGProject(CatalogAware,Folder): Line 1720  class MPIWGProject(CatalogAware,Folder):
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
     default_catalog='ProjectCatalog'      default_catalog='ProjectCatalog'
   
       def decode(self,str):
           """return unicode object"""
           return unicodify(str)
     
     def sortedByPlace(self,metatype):      def sortedByPlace(self,metatype):
         """find metatype and sort by place"""          """find metatype and sort by place"""
Line 1802  class MPIWGProject(CatalogAware,Folder): Line 1952  class MPIWGProject(CatalogAware,Folder):
             RESPONSE.redirect('manageImages')              RESPONSE.redirect('manageImages')
   
     
     def hasChildren(self,date=None,onlyActive=True):      def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
         """check if project has children"""          """check if project has children"""
         ct=self.getContexts(childs=self.getContent('xdata_05'),          ct=self.getContexts(childs=self.getContent('xdata_05'),
                                  depth=1,date=date,onlyActive=onlyActive)                                   depth=1,date=date,onlyActive=onlyActive)
Line 1972  class MPIWGProject(CatalogAware,Folder): Line 2122  class MPIWGProject(CatalogAware,Folder):
         self.id=id          self.id=id
         self.title=id          self.title=id
         self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished          self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
           self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
                   
         if argv:          if argv:
             for arg in definedFields:              for arg in definedFields:
Line 1997  class MPIWGProject(CatalogAware,Folder): Line 2148  class MPIWGProject(CatalogAware,Folder):
         """check if the project is still active, default is true, set to false is the project is accomplished"""          """check if the project is still active, default is true, set to false is the project is accomplished"""
         return getattr(self,'isActiveFlag',True)          return getattr(self,'isActiveFlag',True)
                   
       def isArchivedProject(self):
           """check if the project is archived"""
           
           completed=getattr(self,'completedAt',0)
          
          #completed leer 
           if completed=="" :
               return False;
           if completed == 0:
               return False;
           
           
           return True
           
           
     def setActiveFlag(self,status=True):      def setActiveFlag(self,status=True):
         """set the active flag"""          """set the active flag"""
         self.isActiveFlag=status          self.isActiveFlag=status
                   
       def setCompletedAt(self,date):
           """set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
           logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"completedAt",transformedDate)
               return True;
           else:
               return False;
       
       def getCompletedAt(self):
           """gibt das transformierte Datum zurŸck"""
           date=getattr(self,'completedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
           
       def reTransformDate(self,date):
           """transformiert , transformdate zurueck"""
           year=int(date/10000)
           month=int((date-year*10000)/100)
           day=int((date-year*10000-month*100))
           return """%s.%s.%s"""%(day,month,year);
           
           
       def transformDate(self,date):
           """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach  YYYYMMDD, alle nicht angebebenn Werte
           werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist""" 
           
           if (date=="" ) :
               return "";
           
           if (date==None):
               return None;
           
           splitted=date.split(".")
           length=len(splitted)
           year=0
           month=0
           day=0
           if length > 3:
               return "";
           if length==3:
               day = int(splitted[0])
           if length>1:
               month=int(splitted[length-2])
           
           if length > 0:
               try:
                   year = int(splitted[length-1])
               except:
                   pass
           
          ## logging.info("month:"+(month))
           if not (0<=month<13):
               return None;
           
           if not(0<=day<32):
               return None;
           
           if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
               year=2000+year;
           return year*10000+month*100+day
           
           
       
     def checkDate(self,date):      def checkDate(self,date):
         """teste ob zum Zeitpunkt date eine andere version existierte"""          """teste ob zum Zeitpunkt date eine andere version existierte"""
                   
Line 2259  class MPIWGProject(CatalogAware,Folder): Line 2493  class MPIWGProject(CatalogAware,Folder):
     if (text5=="<br>") or (text5=="<br/>"):      if (text5=="<br>") or (text5=="<br/>"):
         text5=""          text5=""
   
         return text5.encode('utf-8')      logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
           #return unicodify(text5)
           return utf8ify(text5) # return as utf-8 byte string
   
   
     def showImagesOfPage(self,imageUrl=None):      def showImagesOfPage(self,imageUrl=None):
         """show Images of project"""          """show Images of project"""
Line 2366  class MPIWGProject(CatalogAware,Folder): Line 2603  class MPIWGProject(CatalogAware,Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
         return pt()          return pt()
   
       def isResponsibleScientist(self,key):
           """teste ob eine Person in der Liste der respl. scientists auftaucht"""
           #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
     
           
           keys = [x[1] for x in getattr(self,"responsibleScientistsList",[])]
               
           if key in keys:
               return True
           else:
               return False
           
       def getPersonKeyList(self):
           """gibt die key Lister der beteiligten Personen zurŸck"""
           return [x[1] for x in getattr(self,'responsibleScientistsList',[])]
          
           
          
               
       def identifyNames(self,nameList):
           """Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
           und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
           @param nameList
           """
           nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
           names=nameList.split(",")
           
           returnNamesDict={}
   
          
           for name in names:
               name=name.lstrip().rstrip()
               nameSplitted = name.split(" ")
               if len(nameSplitted)>1:  #vor und nachname angegeben)
                 
                   lastname=nameSplitted[-1]
                   firstname=nameSplitted[0]
               else:
                   firstname =""
                   lastname=nameSplitted[0]
                  
               #finde Mitarbeiter mit den entsprechenden Name
               logging.info("Search: %s %s %s"%(name,firstname,lastname))
               cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
               
               #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
               #if not hasattr(self,'responsibleScientistsList'):
               #     self.responsibleScientistsList={}
               # 
               # if name in self.responsibleScientistsList.values()
               
               if len(cataloggedNames)>0:
                  returnNamesDict[name]=cataloggedNames
               else:
                   returnNamesDict[name]=[]
          
           return returnNamesDict
           
     def editMPIWGProject(self,RESPONSE=None,fromEdit=None):      def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
         """edit the project and archive the old version"""          """edit the project and archive the old version"""
Line 2379  class MPIWGProject(CatalogAware,Folder): Line 2673  class MPIWGProject(CatalogAware,Folder):
                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])                  setattr(self,x,[self.REQUEST[x].decode('utf-8')])
   
   
          
   
           completedAt = self.REQUEST.get('completedAt')
           if not self.setCompletedAt(completedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
           
         if self.REQUEST.has_key('historicalNames'):          if self.REQUEST.has_key('historicalNames'):
             self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))              self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
                   
Line 2386  class MPIWGProject(CatalogAware,Folder): Line 2686  class MPIWGProject(CatalogAware,Folder):
             self.setActiveFlag(True)              self.setActiveFlag(True)
         else:          else:
             self.setActiveFlag(False)              self.setActiveFlag(False)
           
           self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
           
           names={}
           keys={}
           tmpList=[]
           for key in self.REQUEST.keys(): #gehe durch das Formular
               splitted=key.split("_")
               if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
                   nr=splitted[2]
                   if splitted[1]=="name":
                       names[nr]=self.REQUEST[key]
                   elif splitted[1]=="key":
                       keys[nr]=self.REQUEST[key]
                   
            
           for nr in names.keys():
                tmpList.append((names[nr],keys.get(nr,"")))
                
           self.responsibleScientistsList=tmpList
         if fromEdit and (RESPONSE is not None):          if fromEdit and (RESPONSE is not None):
             RESPONSE.redirect('./editMPIWGBasisEditor')              #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.REQUEST.get('xdata_01','')))
   
         else:          else:
             if RESPONSE is not None:              if RESPONSE is not None:
Line 2451  class MPIWGProject(CatalogAware,Folder): Line 2772  class MPIWGProject(CatalogAware,Folder):
         return 0          return 0
   
     security.declareProtected('View management screens','editMPIWGBasisEditor')      security.declareProtected('View management screens','editMPIWGBasisEditor')
     def editMPIWGBasisEditor(self):      def editMPIWGBasisEditor(self, identifiedNames=None):
                               
         """editform"""          """editform"""
           if not identifiedNames:
               identifiedNames=self.identifyNames(self.getContent('xdata_01'))
              # identifiedNames=self.getFullNameEntries()
               
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
         return pt()          return pt(identifiedNames=identifiedNames)
   
     security.declareProtected('View management screens','editMPIWGBasisForm')      security.declareProtected('View management screens','editMPIWGBasisForm')
     def editMPIWGBasisForm(self):      def editMPIWGBasisForm(self):
Removed from v.1.47.2.73  
changed lines
  Added in v.1.47.2.83

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