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

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

version 1.47.2.78, 2007/07/02 15:50:22 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 507  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 556  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 1038  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 1061  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 1080  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 1124  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))
   
                   
         for idNr in form.keys():          fields=self.getTree(onlyArchived=onlyArchived,onlyActive=onlyActive)
                           
             splitted=idNr.split('_')          logging.info("GOT TREE!----------------------------------------------------")
           for field in form.keys():
                           
             if len(splitted)==1: # name des Feldes = idNr, dann Aendere id_nr              splitted=field.split('_')
                 if not (fields[int(idNr)][3].xdata_05==form[idNr]):              if (len(splitted)>1) and (splitted[1]=="runningNumber"): #feld hat die Form Nummer_name und runnignNumber
                     fields[int(idNr)][3].xdata_05=form[idNr]  
                     fields[int(idNr)][3].copyObjectToArchive()  
                                           
                 if form.has_key(idNr+'_active'): # active flag is set  
                                       
                     fields[int(splitted[0])][3].setActiveFlag(True)                  nr=int(splitted[0]) # nummer des Datensatzes
                   currentEntry = fields[nr]
               
                   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 1187  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 1261  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 Loesung          # 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 1594  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 1823  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 1993  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 2018  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 2280  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 2387  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 2400  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 2407  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 2472  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.78  
changed lines
  Added in v.1.47.2.83

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