Return to MPIWGProjects.py CVS log

Up to [Repository] / MPIWGWeb

prints deleted, bug fixed in name search

"""This files contains the class MPIWG Projects"""
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate

import MPIWGStaff
import string
import re

import xmlhelper # Methoden zur Verwaltung der projekt xmls
from OFS.SimpleItem import SimpleItem
from OFS.Folder import Folder

definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']

checkFields = ['xdata_01']

def sortF(x,y):

    return cmp(x[1],y[1])

class MPIWGRoot(Folder):
    """Stammordner für den Web-Server"""

    folders=['MPIWGProject','Folder']
    meta_type='MPIWGRoot'
    
    def __init__(self, id, title):
        """init"""
        self.id=id
        self.title=title

    def getProjectFields(self,fieldName,folder=None):
        """getListofFieldNames"""
        ret=[]
        #print "FN",fieldName
        if not folder:
            folder=self
        for object in folder.__dict__:

            obj=getattr(folder,object)
            if hasattr(obj,'meta_type'):
                
                if obj.meta_type=='MPIWGProject':
                    
                    ret.append((obj,obj.getContent(fieldName)))
                if obj.meta_type in self.folders:
                    
                    ret += self.getProjectFields(fieldName,obj)
        
        ret.sort(sortF)
        
        return ret

    manage_options = Folder.manage_options+(
        {'label':'Import Persons','action':'importNamesForm'},
        )
    
    def importNamesForm(self):
        """Form"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)
        return pt()

    def importNames(self,fileupload,folderName,RESPONSE=None):
        """import komma-sep list email,lastName,firstName"""
        project=getattr(self,folderName)
        
        for line in fileupload.readlines():
            #print line
            splitted=line.split(",")
            if not (splitted[0]==""):
                newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
                try:
                    project._setObject(splitted[0],newObj)
                except:
                    print "not done:",splitted[0]
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def getAllMembers(self):
        """give list of all members"""
        ret=[]

        for x in self.members.objectValues('MPIWGStaff'):
            #print x.title
            ret.append(x.title)
            
        ret.sort()
        return ret

    def getUrlFromPerson(self,list):
        """get urls to person list"""
        ret=[]
        persons=list.split(";")
        for person in persons:
            
            splitted=person.split(",")
            if len(splitted)==1:
                splitted=person.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:
                ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))
            else:
                ret.append("%s"%person)
        return string.join(ret,";")
                         
    def getProjectsOfMembers(self):
        """give tuple member /projects"""
        ret=[]
        members=self.getAllMembers()
        for x in members:
            splitted=x.split(",")
            
            proj=self.ProjectCatalog({'xdata_01':string.join(splitted,' AND')})
            if proj:
              ret.append((x,proj))
        return ret
    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.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=='':
            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
        

    def isCheckField(self,fieldname):
        """return chechfield"""
        
        return (fieldname in checkFields)

    
    
        
def manage_addMPIWGRootForm(self):
    """form for adding the root"""
    pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)
    return pt()

def manage_addMPIWGRoot(self,id,title,RESPONSE=None):
    """add a root folder"""
    newObj=MPIWGRoot(id,title)
    self._setObject(id,newObj)

    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
        

class MPIWGProject(Folder):
    """Class for Projects"""

    meta_type='MPIWGProject'

    def crossLinker(self):
        """experimental crosslinker"""
        splitted=self.WEB_project_description[0].split()
        new=[]
        for split in splitted:
            try:
                found=self.DescriptionCatalog({'fulltext':split})
          
                if len(found)>1:
             
                    new.append("<a href=%s>%s</a>"%(split,split))
                else:
                    new.append(split)
            except:
                new.append(split)
        return string.join(new)
            
            


    def generateTemplate(self,RESPONSE=None):
        """Erzeuge Template für defined fields not_used"""

        id="index_html"
        title=id
        if self._getOb('index_html'):
            self._delObject('index_html')

        
        newObj=ZopePageTemplate(id,'TEXT')
        self._setObject(id,newObj)
        #self.manage_addPageTemplate(id,title)
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')
            
    def __init__(self, id, argv):
        """initieriere classe"""
        
        self.id=id
        self.title=id
        for arg in definedFields:
            
            setattr(self,arg,argv[arg])
            """NP"""
    manage_options = Folder.manage_options+(
        {'label':'Load New File','action':'loadNewFileForm'},
        {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
        {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
        {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
        )

    def getDataFields(self):
        """giveListofDatafields"""
        ret=[]
        for x in range(1,14):
            ret.append('xdata_%02i'%x)
        return ret
            
    def getDefinedFields(self):
        """show all defined fields"""
        
        return definedFields

    def getAttribute(self,field):
        """get attrbiute"""
        return getattr(self,field)

    def getContent(self,field):
        """Inhalt des Feldes"""
        
        text=u''
        #print "FIELD",field
        for x in getattr(self,field):
            #print "HIHIIII"
            
            try:
                text +=x
            except:
                try:
                    text =x
                except:
                    text="ERROR"
        #print "TEXT",text  
        return text
    
    def show_html(self):
        """simple index"""
        #return "HI"
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)
        return pt()

    def editMPIWGProjectForm(self):
        """editform"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)
        return pt()

    def editMPIWGBasisForm(self):
        """editform"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)
        return pt()
    def editMPIWGRelatedPublicationsForm(self):
        """Edit related Publications"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)
        return pt()
        
    def editMPIWGProject(self,RESPONSE=None):
        """edit the project"""
        
        #return self.REQUEST
        for x in definedFields:
            if self.REQUEST.has_key(x):
                
                setattr(self,x,[self.REQUEST[x]])
            
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

        
    def loadNewFileForm(self):
        """Neues XML-File einlesen"""
        pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)
        return pt()

    def loadNewFile(self,RESPONSE=None):
        """einlesen des neuen files"""
        fileupload=self.REQUEST['fileupload']
        if fileupload:
            file_name=fileupload.filename
            filedata=fileupload.read()

            argv=xmlhelper.proj2hash(filedata)
            #print argv.keys()
            for arg in definedFields:
                
                #print arg,argv[arg],getattr(self,arg)
                try:
                    temp=argv[arg][0:]
                    #old=getattr(self,arg)
                    setattr(self,arg,temp)
                    #print old,getattr(self,arg)
                except:
                    """nothing"""
                    
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

def manage_addMPIWGProjectForm(self):
    """form for adding the project"""
    pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)
    return pt()

def manage_addMPIWGProject(self,id,RESPONSE=None):
    """method to add a project"""
    #print argv
    fileupload=self.REQUEST['fileupload']
    if fileupload:
        file_name=fileupload.filename
	filedata=fileupload.read()
        
        argv=xmlhelper.proj2hash(filedata)

        #print argv

    newObj=MPIWGProject(id,argv)

    self._setObject(id,newObj)


    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')