--- a/MPIWGRoot.py	Tue Apr 30 16:31:57 2013 +0200
+++ b/MPIWGRoot.py	Tue Apr 30 16:35:52 2013 +0200
@@ -121,23 +121,6 @@
         return bt
 
 
-    def versionHeaderEN(self):
-        """version header text"""
-        
-        date= self.REQUEST.get('date',None)
-        if date:
-            txt="""<h2>This pages shows the project which existed at %s</h2>"""%str(date)
-            return txt
-        return ""
-
-    def versionHeaderDE(self):
-        """version header text"""
-        date= self.REQUEST.get('date',None)
-        if date:
-            txt="""<h2>Auf dieser Seite finden Sie die Projekte mit Stand vom %s</h2>"""%str(date)
-        return ""
-    
-        
     def createOrUpdateId_raw(self):
         """create sequence to create ids for bibliography"""
         debug=None
@@ -165,22 +148,6 @@
         splitted=url.split("/")
         return splitted[4]
 
-    def generateUrlProject(self,url,project=None):
-        """erzeuge aus absoluter url, relative des Projektes"""
-        if project:
-            splitted=url.split("/")
-            length=len(splitted)
-            short=splitted[length-2:length]
-            
-            base=self.REQUEST['URL3']+"/"+"/".join(short)
-
-        else:
-            findPart=url.find("/projects/")
-            base=self.REQUEST['URL1']+"/"+url[findPart:]
-
-                
-        return base
-    
     def isNewCapital(self,text=None,reset=None):
         
         if text:
@@ -250,6 +217,13 @@
         else:
             return style    
 
+    def getPathStyle(self, path, selected, style=""):
+        """returns a string with the given style + 'sel' if path == selected."""
+        if path == selected:
+            return style + 'sel'
+        else:
+            return style    
+
     def getFeatures(self, num=None):
         """returns a list of the last num Features"""
         dir = getattr(self, 'features', None)
@@ -324,35 +298,6 @@
             return ""
         
 
-    # TODO: remove
-    def isActiveMember(self,key):
-        """tested ob Mitarbeiter key ist aktiv"""
-        key=utf8ify(key)
-        ret=getAt(self.ZSQLInlineSearch(_table='personal_www',
-                                            _op_key='eq',key=key,
-                                            _op_publish_the_data='eq',
-                                            publish_the_data='yes'), 0)
-        
-        logging.info("MPIWGROOT ACTIVE_MEMBER  %s"%ret)
-        if ret:
-            return True
-        else:
-            return False
-        
-    # TODO: remove
-    def isActual(self,project):
-        """checke if project is actual"""
-        actualTime=time.localtime()
-        
-        if hasattr(project,'getObject'): #obj ist aus einer catalogTrefferList
-            obj=project.getObject()
-        else:
-            obj=project
-            
-        if getattr(obj,'archiveTime',actualTime)< actualTime:
-            return False
-        else:
-            return True
         
     def redirectIndex_html(self,request):
         #return request['URL1']+'/index_html'
@@ -435,34 +380,6 @@
         """quote"""
         return urllib.unquote(str)
     
-        
-
-    def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):
-        """gib alle Projekte aus mit Value von field mit fieldName enthaelt ein Element der Liste fieldContents"""
-        def sort(x,y):
-                return cmp(x.WEB_title[0],y.WEB_title[0])
-
-        if type(fieldContentsEntry) is StringType:
-            fieldContentsTmp=[fieldContentsEntry]
-        else:
-            fieldContentsTmp=fieldContentsEntry
-
-        fieldContents=[]
-        for x in fieldContentsTmp:
-            fieldContents.append(" AND ".join(x.split()))
-        projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})
-        #print projects
-        #ret=[x for x in projects]
-        ret=[]
-        for x in projects:
-            obj=x.getObject()
-            obj=obj.getActualVersion(date)
-            if obj and (not getattr(obj,'invisible',None)):
-                #if not (x in ret):
-                    ret.append(x)
-
-        ret.sort(sort)
-        return ret
 
     def changeMPIWGRootForm(self):
         """edit"""
@@ -484,128 +401,6 @@
         if RESPONSE is not None:
             RESPONSE.redirect('manage_main')
 
-
-    def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
-        """childs alle childs, alle parents"""
-        ret=[]
-    
-        if parents:
-            pnums=parents.split(".")
-            while len(pnums) > 1:
-                pnums.pop()
-                parentId=string.join(pnums,".")
-        
-                for project in self.getProjectFields('xdata_05',sort='int',date=date):
-                    if project[1]==parentId:
-                        ret.append(project)
-                
-                if (depth is not None) and (len(ret) >= depth):
-                    break
-
-        if childs:
-            for project in self.getProjectFields('xdata_05',sort='int',date=date):
-                searchStr=childs+"(\..*)"
-               
-                if (onlyActive and project[0].isActiveProject()) or (not onlyActive):
-                    if re.match(searchStr,project[1]):
-                        
-                        if depth:
-    
-                            if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
-                        
-                                ret.append(project)
-                        else:
-                            ret.append(project)
-        
-        #logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))
-     
-        return ret
-
-
-    def getAllProjectsAndTagsAsCSV(self,archived=1,RESPONSE=None):
-        """alle projekte auch die nicht getaggten"""
-        retList=[]
-        headers=['projectId','sortingNumber','projectName','scholars','startedAt','completedAt','lastChangeThesaurusAt','lastChangeProjectAt','projectCreatedAt','persons','places','objects']
-        headers.extend(list(self.thesaurus.tags.keys()))
-        retList.append("\t".join(headers))
-        if not hasattr(self,'thesaurus'):
-            return "NON thesaurus (there have to be a MPIWGthesaurus object, with object ID thesaurus)"
-        
-        projectTags = self.thesaurus.getProjectsAndTags()
-        for project in self.getProjectFields('WEB_title_or_short'):
-            proj = project[0]
-            p_name = project[1]
-            retProj=[]
-            #if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2):
-            retProj.append(self.utf8ify(proj.getId()))
-            retProj.append(self.utf8ify(proj.getContent('xdata_05')))
-            retProj.append(self.utf8ify(p_name))  
-            retProj.append(self.utf8ify(proj.getContent('xdata_01')))
-            retProj.append(self.utf8ify(proj.getStartedAt()))
-            retProj.append(self.utf8ify(proj.getCompletedAt()))
-            changeDate=self.thesaurus.lastChangeInThesaurus.get(proj.getId(),'') 
-            n = re.sub("[:\- ]","",str(changeDate))
-            retProj.append(n)
-            retProj.append(self.utf8ify(getattr(proj,'creationTime','20050101000000')))  
-            retProj.append("")#TODO: project created at   
-            retProj.append(";".join([person[1] for person in self.thesaurus.getPersonsFromProject(proj.getId())]))
-            retProj.append(";".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())]))
-            retProj.append(";".join([person[1] for person in self.thesaurus.getObjectsFromProject(proj.getId())]))
-            retProj+=self.thesaurus.getTags(proj.getId(),projectTags)
-            retList.append("\t".join(retProj))
-        
-        if RESPONSE:
-            
-            RESPONSE.setHeader('Content-Disposition','attachment; filename="ProjectsAndTags.tsv"')
-            RESPONSE.setHeader('Content-Type', "application/octet-stream")
-      
-        return "\n".join(retList);
-    
-    
-    
-  
-    def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
-        """getListofFieldNames"""
-        ret=[]
-    
-        objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)
-
-                
-        for object in objects:
-            obj=object[1]
-            obj=obj.getActualVersion(date)
-            if obj and (not getattr(obj,'invisible',None)):
-                if fieldName=="WEB_title_or_short":
-
-                    if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
-                        fieldNameTmp="WEB_title"
-                    else:
-                        fieldNameTmp="xdata_07"
-                else:
-                    fieldNameTmp=fieldName
-
-                ret.append((obj,obj.getContent(fieldNameTmp)))
-
-        
-        if sort=="int":
-            ret.sort(sortI)
-        elif sort=="stopWords":
- 
-            ret.sort(sortStopWords(self))
-            
-        else:
-            ret.sort(sortF)
-        
-        return ret
-
-    def showNewProjects(self):
-        projects=[]
-        for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
-            if objs[0].xdata_05 and (objs[0].xdata_05[0] == ""):
-                
-                projects.append(objs)
-                
-        return projects
     
         
     def updatePublicationDB(self,personId=None):
@@ -843,43 +638,6 @@
     
 
      
-    def reindexCatalogs(self,RESPONSE=None):
-        """reindex members and project catalog"""
-        
-        
-        try:
-            
-            self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
-            logger("MPIWG Root (reindexCatalog: projects)",logging.INFO,"DONE")
-        except:
-            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])
-#            
-#        
-#        
-#        
-        
-        
-        if RESPONSE:
-            RESPONSE.redirect('manage_main')
-
-        
-        
 
     def getAllMembers(self):
         #ret=[]
@@ -923,177 +681,14 @@
             rss+=linkStr%obj[3].getId()
             rss+="""</item>"""
             if hasattr(obj[3],'publicationList'):
-	        rss+="""<item>"""
+            rss+="""<item>"""
                 rss+=linkStr%(obj[3].getId()+"/publicationList");
                 rss+="""</item>"""
         rss+="""</channel>
         </rss>"""
 
-        
         return rss
 
-    def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
-        """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
-        
-        department fuer das Tree geholt werden soll
-        """
-        logging.debug("MPIWGRoot.getTree()")
-
-        returnListTmp=[]
-        returnList=[]
-        
-        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
-                if not idNr=="":
-                    splittedId=idNr.split(".")
-                    depth=len(splittedId)
-                    nr=idNr
-                    #title=project[0].WEB_title
-                    title=[project[0].getContent('WEB_title')]
-                    #print title
-                    
-                    if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive
-                        project[0].setActiveFlag(False)
-                   
-                    if (not dep) or (splittedId[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.
-                        
-                        if (onlyActive==0):
-                            returnListTmp.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
-
-
-        
-    def changePosition(self,treeId,select,RESPONSE=None):
-        """Change Postion Entry"""
-        numbers=[]
-
-        # Suche hoechste bisherige nummer
-        projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
-        #print "pj",projects
-        for project in projects: #suche alle subtrees der treeId
-            #print treeId
-            
-            founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
-            if founds:
-                #print "x",founds.group(0),len(founds.group(0).split("."))
-                if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
-                    try:
-                        numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
-                    except:
-                        numbers.append(int(0))
-
-        try:
-            highest=max(numbers)
-        except:
-            highest=0
-        projects=self.showNewProjects()
-        for i in self.makeList(select):
-            highest+=10
-            projects[int(i)][0].xdata_05=treeId+"."+str(highest)
-
-
-        if RESPONSE is not None:
-            RESPONSE.redirect('showTree')
-        
-    def changeTree(self,RESPONSE=None):
-        """change the complete tree"""
-        form=self.REQUEST.form
-        hashList={}
-        onlyArchived=int(form.get("onlyArchived",0))
-        onlyActive=int(form.get("onlyActive",0))
-        dep=form.get("dep",None)
-        
-        fields=self.getTree(dep=dep,onlyArchived=onlyArchived,onlyActive=onlyActive)
-        
-        logging.info("GOT TREE!----------------------------------------------------")
-        for field in form.keys():
-            
-            splitted=field.split('_')
-            if (len(splitted)>1) and (splitted[1]=="runningNumber"): #feld hat die Form Nummer_name und runnignNumber
-            
-                
-                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:
-                    fields[nr][3].setActiveFlag(False)
-                    
-                #nummer hat sich geaendert
-                
-                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']):
-                    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']
-                    entryChanged = True
-                    
-                #completed har sich geaendert
-                          
-                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'])
-                    logging.info(repr(td(fields[nr][3].getCompletedAt()))+" ---> "+ repr(td(form[str(nr)+'_completed'])))
-                    logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
-                    entryChanged = True
-                
-                if not (td(fields[nr][3].getStartedAt())==td(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+++++++++++++++++++++++++++++++++")
-                    entryChanged = True
-                
-                
-                if entryChanged:
-                    logging.info("Changed!+++++++++++++++++++++++++++++++++")
-                    fields[nr][3].copyObjectToArchive()
-                
-                    
-        if RESPONSE is not None:
-            RESPONSE.redirect('showTree')
-
-    def getProjectWithId(self,id):
-        fields=self.getProjectFields('xdata_05')
-        for field in fields:
-            if field[1]==id:
-                return field[0]
-
-        return None
-            
-        
-            
         
     def getRelativeUrlFromPerson(self,list):
         """get urls to person list"""
@@ -1143,202 +738,7 @@
 
             
 
-    def getProjectsOfMembers(self,date=None):
-        """give tuple member /projects"""
-        ret=[]
-        members=self.getAllMembers()
-        logging.debug("X %s"%repr(members))
-        #return str(members)
-        for x in members:
-            #logging.debug("X %s"%repr(x))
-            projects=self.getProjectsOfMember(key=x[1],date=date)
-            if len(projects)>0:
-                ret.append((x[0],projects))
-            
-        return ret
-
-    def getProjectsOfMember(self,key=None,date=None,onlyArchived=1,onlyActive=1):
-        """get projects of a member
-    
-        @param key: (optional) Key zur Idenfikation des Benutzer
-        @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
-        def sortP(x,y):
-            """sort by sorting number"""
-            return cmp(x.WEB_title,y.WEB_title)
-        
-        ret=[]  
-        if key:     
-            logging.debug("MPIWGROOT (getProjectsOfMember):"+key)
-            proj=self.ProjectCatalog({'getPersonKeyList':utf8ify(key)})
-        else:
-            return ret # key muss definiert sein
-        
-        #logging.debug("MPIWGROOT (getProjectsOfMember):"+repr(proj))
-        if proj:
-            proj2=[]
-            for x in proj:
-                #logging.error("proj:%s"%repr(x.getPath()))
-                if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):   
-                      proj2.append(x)
-
-        else:
-            proj2=[]
-            
-       
-       
-        proj2.sort(sortP)
-
-        projectListe=[]
-        #logging.error("getprojectsofmember proj2: %s"%repr(proj2))
-        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)
-                
-        #logging.error("getprojectsofmember projectliste: %s"%repr(projectListe))
-        return projectListe
      
-    def givePersonList(self,name):
-        """check if person is in personfolder and return list of person objects"""
-        
-        splitted=name.split(",")
-        if len(splitted)==1:
-            splitted=name.lstrip().rstrip().split(" ")
-        splittedNew=[split.lstrip() for split in splitted]
-        
-        if splittedNew[0]=='':
-            del splittedNew[0]
-        search=string.join(splittedNew,' AND ')
-        
-        if not search=='':
-            proj=self.MembersCatalog({'title':search})
-
-        if proj:
-            return [[x.lastName,x.firstName] for x in proj]
-        else:
-            return []
-            
-##         splitted=name.split(",") # version nachname, vorname...
-##         if len(splitted)>1:
-##             lastName=splitted[0] 
-##             firstName=splitted[1]
-##         else: 
-##             splitted=name.split(" ") #version vorname irgenwas nachnamae
-        
-##             lastName=splitted[len(splitted)-1]
-##             firstName=string.join(splitted[0:len(splitted)-1])
-
-##         objs=[]
-
-        #print  self.members 
-      ##   for x in self.members.__dict__:
-##             obj=getattr(self.members,x)
-##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
-                
-##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
-                    
-##                     objs.append((obj,lastName+", "+firstName))
-
-        
-##        return objs
-
-
-    def personCheck(self,names):
-        """all persons for list"""
-        #print "names",names
-        splitted=names.split(";")
-        ret={}
-        for name in splitted:
-
-            if not (name==""):
-                try:
-                    ret[name]=self.givePersonList(name)
-                except:
-                    """NOTHIHN"""
-        #print "RET",ret
-        return ret
-
-    def giveCheckList(self,person,fieldname):
-        """return checklist"""
-        #print "GCL",fieldname
-        if fieldname=='xdata_01':
-            x=self.personCheck(person.getContent(fieldname))
-            #print "GCLBACKX",x
-            return x
-        
-
-    # TODO: do we need this here?
-    def isCheckField(self,fieldname):
-        """return chechfield"""
-        return (fieldname in checkFields)
-
-    
-
-    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 getAllProjectPublications(self):
-            """get all publications"""
-            fw=file("/tmp/allProjectPublications","w")
-            projects =self.projects.getProjectsAsList(None,active=0,archived=0)
-           
-            for project in projects:
-                logging.debug(project)
-                if hasattr(project,'publicationList'):
-                    try:
-                        x =project.publicationList.bibliolist.data
-                    
-                    except:
-                        logging.error("Can't do: %s"%project.absolute_url())
-                        continue
-                
-                    id=project.getId()
-                    for l in x.split("\n"):
-                        fw.write("%s,%s\n"%(id,l))
-                    fw.flush()
-                
-            fw.close()
-                
-        
             
 def manage_addMPIWGRootForm(self):
     """form for adding the root"""