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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.3 and 1.9

version 1.3, 2004/02/09 08:57:27 version 1.9, 2004/06/28 18:47:14
Line 1 Line 1
 """This files contains the class MPIWG Projects"""  """This contains the class MPIWG Projects
   for organizing and maintaining the different projectspages
   
   """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
Line 6  from Products.PageTemplates.ZopePageTemp Line 9  from Products.PageTemplates.ZopePageTemp
 import MPIWGStaff  import MPIWGStaff
 import string  import string
 import re  import re
   from types import *
   
 import xmlhelper # Methoden zur Verwaltung der projekt xmls  import xmlhelper # Methoden zur Verwaltung der projekt xmls
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
Line 15  definedFields=['WEB_title','xdata_01','x Line 19  definedFields=['WEB_title','xdata_01','x
   
 checkFields = ['xdata_01']  checkFields = ['xdata_01']
   
   
   
 def sortF(x,y):  def sortF(x,y):
       try:
           return cmp(x[1],y[1])
       except:
           return 0
   
   def sortI(x,y):
       xsplit=x[1].split(".")
       ysplit=y[1].split(".")
       xret=""
       yret=""
       try:
           for i in range(5):
               try:
                   yret=yret+"%04i"%int(xsplit[i])
               except:
                   yret=yret+"%04i"%0
   
               try:
                   xret=xret+"%04i"%int(ysplit[i])
               except:
                   xret=xret+"%04i"%0
                   
           
           return cmp(int(yret),int(xret))
       except:
     return cmp(x[1],y[1])      return cmp(x[1],y[1])
   
       
 class MPIWGRoot(Folder):  class MPIWGRoot(Folder):
     """Stammordner für den Web-Server"""      """Stammordner für den Web-Server"""
   
       fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
                'xdata_03':'Historical Persons','xdata_04':'Time period',
                'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
                'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',
                'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
                'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
                'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
       
     folders=['MPIWGProject','Folder']      folders=['MPIWGProject','Folder']
     meta_type='MPIWGRoot'      meta_type='MPIWGRoot'
           
       def getValue(self,field):
           """Inhalt des Feldes"""
   
           if type(field)==StringType:
               try:
                   if field[len(field)-1]==";":
                       field=field[0:len(text)-1]
               except:
                       """nothing"""
               
               return field.encode('utf-8')
           
           else:
               return field[0].encode('utf-8')
   
       
       def sortedNames(self,list):
           """sort names"""
   
           def sortLastName(x,y):
               try:
                   last_x=x.split()[len(x.split())-1]
                   last_y=y.split()[len(y.split())-1]
   
               except:
   
                   last_x=""
                   last_y=""
               
               
               
               if last_x<last_y:
                   return 1
               elif last_x>last_y:
                   return -1
               else:
                   return 0
               
           list.sort(sortLastName)
           list.reverse()
           
           return list
       
     def __init__(self, id, title):      def __init__(self, id, title):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title=title          self.title=title
   
     def getProjectFields(self,fieldName,folder=None):      def harvestHistoricalPersons(self):
           """erstelle liste aller erwaehnten actors"""
   
           def normalize(str):
               """loesche fuhrendes space"""
               if (len(str)>1) and (str[0]==" "):
                   ret=str[1:]
               else:
                   ret=str
               return ret
           
           list={}
           projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
           
           for project in projects:
               lg=len(project[1].xdata_03[0])-1
   
               if (lg>1) and (project[1].xdata_03[0][lg]==";"):
                   project[1].xdata_03[0]=project[1].xdata_03[0][0:lg-1]
   
             
        
                   
               try:
                   if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
                       for person in project[1].xdata_03[0].split(";"):
                           personNormal=normalize(person)
                           if personNormal in list.keys():
                               list[personNormal].append(project[1])
                           else:
                               list[personNormal]=[project[1]]
                   else: #guess , is sepeator
                       for person in project[1].xdata_03[0].split(","):
                           personNormal=normalize(person)
                           if personNormal in list.keys():
                               list[personNormal].append(project[1])
                           else:
                               list[personNormal]=[project[1]]
   
               except:
                   print "ERROR",project
                   
           return list
   
       def storeHistoricalPersons(self,RESPONSE=None):
           """store persons"""
           self.personDict={}
           personDict=self.harvestHistoricalPersons()
           for person in personDict.keys():
               for project in personDict[person]:
                   if person in self.personDict.keys():
                       self.personDict[person].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
                   else:
                       self.personDict[person]=[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])]
   
           if RESPONSE is not None:
               RESPONSE.redirect("showHistoricalPersons")
               
   
       def showHistoricalPersons(self):
           """show persons"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)
           return pt()
   
           
       def editHistoricalPersonsForm(self):
           """edit historical persons for consistency"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)
           return pt()
   
       def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):
           """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
           if type(fieldContentsEntry) is StringType:
               fieldContents=[fieldContentsEntry]
           else:
               fieldContents=fieldContentsEntry
               
           projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})
           #print projects
           return projects
   
       def changeMPIWGRootForm(self):
           """edit"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)
           return pt()
   
       def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):
           """change"""
           self.title=title
           self.disciplineList=disciplineList
           self.themesList=themesList
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def getDisciplineList(self):
           """get disciplines as list"""
           return self.disciplineList.split("\n")
       
       def getThemeList(self):
           """get themes as list"""
           return self.themesList.split("\n")
       
       def test(self):
           """test"""
           return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
   
       def getContexts(self,childs=None,parents=None,depth=None):
           """childs alle childs, alle parents"""
           ret=[]
           if parents:
               splitted=parents.split(".")
               parentId=string.join(splitted[0:len(splitted)-1],".")
           
               for project in self.getProjectFields('xdata_05',sort='int'):
                   if project[1]==parentId:
                       ret.append(project)
   
           if childs:
               for project in self.getProjectFields('xdata_05',sort='int'):
                   searchStr=childs+"(\..*)"
                   if re.match(searchStr,project[1]):
                       
                       if depth:
                           print "ho"
                           if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
                       
                               ret.append(project)
                       else:
                           ret.append(project)
           return ret
       
       def getProjectFields(self,fieldName,folder=None,sort=None):
         """getListofFieldNames"""          """getListofFieldNames"""
         ret=[]          ret=[]
         #print "FN",fieldName          #print "FN",fieldName
Line 40  class MPIWGRoot(Folder): Line 254  class MPIWGRoot(Folder):
   
             obj=getattr(folder,object)              obj=getattr(folder,object)
             if hasattr(obj,'meta_type'):              if hasattr(obj,'meta_type'):
                                   #print obj.meta_type
                 if obj.meta_type=='MPIWGProject':                  if obj.meta_type=='MPIWGProject':
                       if fieldName=="WEB_title_or_short":
                           #print "HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
                           #print len(obj.getContent('xdata_07'))
                           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)))
                                           
                     ret.append((obj,obj.getContent(fieldName)))  
                 if obj.meta_type in self.folders:                  if obj.meta_type in self.folders:
                                           
                     ret += self.getProjectFields(fieldName,obj)                      ret += self.getProjectFields(fieldName,obj)
                   
           if sort=="int":
               ret.sort(sortI)
           else:
         ret.sort(sortF)          ret.sort(sortF)
                   
         return ret          return ret
   
       def showNewProjects(self):
           projects=[]
           for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
               if objs[0].xdata_05[0] == "":
                   
                   projects.append(objs)
                   
           return projects
       
           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Import Persons','action':'importNamesForm'},          {'label':'Import Persons','action':'importNamesForm'},
           {'label':'Main config','action':'changeMPIWGRootForm'},
           {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
           {'label':'Store Historical Persons','action':'storeHistoricalPersons'},
         )          )
           
     def importNamesForm(self):      def importNamesForm(self):
Line 64  class MPIWGRoot(Folder): Line 304  class MPIWGRoot(Folder):
     def importNames(self,fileupload,folderName,RESPONSE=None):      def importNames(self,fileupload,folderName,RESPONSE=None):
         """import komma-sep list email,lastName,firstName"""          """import komma-sep list email,lastName,firstName"""
         project=getattr(self,folderName)          project=getattr(self,folderName)
           load=fileupload.read()
           
           for line in load.split('\r'):
               
                   
         for line in fileupload.readlines():  
             print line  
             splitted=line.split(",")              splitted=line.split(",")
               print splitted
           
             if not (splitted[0]==""):              if not (splitted[0]==""):
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])                  newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
                   
                 try:                  try:
                     project._setObject(splitted[0],newObj)                      project._setObject(splitted[0],newObj)
                       print "done:",splitted[0]
                 except:                  except:
                     print "not done:",splitted[0]                      print "not done:",splitted[0]
                       
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
Line 81  class MPIWGRoot(Folder): Line 328  class MPIWGRoot(Folder):
         """give list of all members"""          """give list of all members"""
         ret=[]          ret=[]
   
         for x in self.members.objectValues('MPIWGStaff'):          #for x in self.members.objectValues('MPIWGStaff'):
             print x.title              #print x.title
             ret.append(x.title)          #    ret.append(x.title.decode('utf-8'))
   
           for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
                                  ret.append(x[1].title.decode('utf-8'))
                           
         ret.sort()          #ret.sort()
           #print ret
     
           return ret
   
       def printAllMembers(self):
           """prin"""
           members=self.getAllMembers()
           ret=""
           for x in members:
               ret+="<p>%s</p>"%x
         return ret          return ret
   
           
       def makeList(self,entry):
           """makes a list out of one entry or repeat a list"""
           if type(entry) is StringType:
               return [entry]
           else:
               return entry
   
   
       def getTree(self):
           """generate Tree from project list"""
           returnList=[]
           for project in self.getProjectFields('xdata_05',sort="int"): # 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
                       
                       returnList.append((depth,nr,title,project[0]))
           
           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={}
           fields=self.getTree()
   
           
           for idNr in form.keys():
               fields[int(idNr)][3].xdata_05=form[idNr]
   
           
   
           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 getUrlFromPerson(self,list):      def getUrlFromPerson(self,list):
         """get urls to person list"""          """get urls to person list"""
         ret=[]          ret=[]
         persons=list.split(";")          persons=list.split(";")
         for person in persons:          for person in persons:
                           
               if len(person)>1: #nicht nur Trennzeichen
             splitted=person.split(",")              splitted=person.split(",")
             if len(splitted)==1:              if len(splitted)==1:
                 splitted=person.split(" ")                  splitted=person.split(" ")
Line 101  class MPIWGRoot(Folder): Line 446  class MPIWGRoot(Folder):
             if splittedNew[0]=='':              if splittedNew[0]=='':
                 del splittedNew[0]                  del splittedNew[0]
             search=string.join(splittedNew,' AND ')              search=string.join(splittedNew,' AND ')
                   
             if not search=='':              if not search=='':
   
                       try:
                 proj=self.MembersCatalog({'title':search})                  proj=self.MembersCatalog({'title':search})
                 print search,"PER",person,splittedNew,proj                      except:
                           proj=None
                   
             if proj:              if proj:
                 ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))                  ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))
Line 115  class MPIWGRoot(Folder): Line 464  class MPIWGRoot(Folder):
         """give tuple member /projects"""          """give tuple member /projects"""
         ret=[]          ret=[]
         members=self.getAllMembers()          members=self.getAllMembers()
           #return str(members)
         for x in members:          for x in members:
             splitted=x.split(",")              y=x.encode('utf-8')
               splitted=y.split(",")
               splitNeu=[]
               for s in splitted:
           
                   splitNeu.append("\""+s+"\"")
                   search=string.join(splitNeu,' AND ')
                   proj=self.ProjectCatalog({'xdata_01':search})
                           
             proj=self.ProjectCatalog({'xdata_01':string.join(splitted,' AND')})              print "Search:",search,"Found:",proj
             if proj:              if proj:
               ret.append((x,proj))                  ret.append((y,proj))
               else:
                   ret.append((y,None))
         return ret          return ret
     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 167  class MPIWGRoot(Folder): Line 526  class MPIWGRoot(Folder):
   
     def personCheck(self,names):      def personCheck(self,names):
         """all persons for list"""          """all persons for list"""
         print "names",names          #print "names",names
         splitted=names.split(";")          splitted=names.split(";")
         ret={}          ret={}
         for name in splitted:          for name in splitted:
Line 177  class MPIWGRoot(Folder): Line 536  class MPIWGRoot(Folder):
                     ret[name]=self.givePersonList(name)                      ret[name]=self.givePersonList(name)
                 except:                  except:
                     """NOTHIHN"""                      """NOTHIHN"""
         print "RET",ret          #print "RET",ret
         return ret          return ret
   
     def giveCheckList(self,person,fieldname):      def giveCheckList(self,person,fieldname):
Line 185  class MPIWGRoot(Folder): Line 544  class MPIWGRoot(Folder):
         #print "GCL",fieldname          #print "GCL",fieldname
         if fieldname=='xdata_01':          if fieldname=='xdata_01':
             x=self.personCheck(person.getContent(fieldname))              x=self.personCheck(person.getContent(fieldname))
             print "GCLBACKX",x              #print "GCLBACKX",x
             return x              return x
                   
   
Line 197  class MPIWGRoot(Folder): Line 556  class MPIWGRoot(Folder):
           
           
                   
           
 def manage_addMPIWGRootForm(self):  def manage_addMPIWGRootForm(self):
     """form for adding the root"""      """form for adding the root"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)      pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)
Line 251  class MPIWGProject(Folder): Line 611  class MPIWGProject(Folder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def __init__(self, id, argv):      def __init__(self, id, argv=None):
         """initieriere classe"""          """initieriere classe"""
                   
         self.id=id          self.id=id
         self.title=id          self.title=id
           if argv:
         for arg in definedFields:          for arg in definedFields:
                       try:
             setattr(self,arg,argv[arg])              setattr(self,arg,argv[arg])
             """NP"""          except:
               setattr(self,arg,"")
           else:
               for arg in definedFields:
                   setattr(self,arg,'')
               
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Load New File','action':'loadNewFileForm'},          {'label':'Load New File','action':'loadNewFileForm'},
         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},          {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},          {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},          {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
           {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
         )          )
   
     def getDataFields(self):      def getDataFields(self):
Line 292  class MPIWGProject(Folder): Line 659  class MPIWGProject(Folder):
             #print "HIHIIII"              #print "HIHIIII"
                           
             try:              try:
                 text +=x                  text +=x.encode('utf-8')
             except:              except:
                 try:                  try:
                     text =x                      text =x.encode('utf-8')
                 except:                  except:
                     text="ERROR"                      text="ERROR"
         #print "TEXT",text            
           #delete separator (;) if  is there is one
           try:
               if text[len(text)-1]==";":
                   text=text[0:len(text)-1]
           except:
               """nothing"""
               
         return text          return text
           
       
     def show_html(self):      def show_html(self):
         """simple index"""          """simple index"""
         #return "HI"          #return "HI"
Line 312  class MPIWGProject(Folder): Line 687  class MPIWGProject(Folder):
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)          pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)
         return pt()          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):      def editMPIWGProject(self,RESPONSE=None):
         """edit the project"""          """edit the project"""
                   
Line 328  class MPIWGProject(Folder): Line 694  class MPIWGProject(Folder):
         for x in definedFields:          for x in definedFields:
             if self.REQUEST.has_key(x):              if self.REQUEST.has_key(x):
                                   
                 setattr(self,x,[self.REQUEST[x]])                  setattr(self,x,[self.REQUEST[x].decode('utf-8')])
                           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       def editMPIWGDisciplinesThemesForm(self):
           """edit the disciplines and themes Form"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)
           return pt()
   
       def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):
           """edit disciplin and form"""
           if disciplines:
               if type(disciplines) is StringType:
                   self.xdata_09=disciplines
               else:
                   self.xdata_09=string.join(disciplines,";")
           else:
                   self.xdata_09=""
           if themes:
               if type(themes) is StringType:
                   self.xdata_10=themes
               else:
                   self.xdata_10=string.join(themes,";")
           else:
               self.xdata_10=""
               
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def isChecked(self,wert,list):
           """check if wert is in ; seperated list"""
           print "W:",wert
           print "L:",list,type(list)
           #felder sind manchmnal als liste mit einem element definiert
           if type(list) is StringType or UnicodeType: 
               splitted=list.split(";")
           else:
               splitted=list[0].split(";")
   
           print splitted
           for x in splitted:
               if (not x==u'') and x in wert:
                   return 1
           return 0
       
       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 loadNewFileForm(self):      def loadNewFileForm(self):
         """Neues XML-File einlesen"""          """Neues XML-File einlesen"""
Line 370  def manage_addMPIWGProjectForm(self): Line 787  def manage_addMPIWGProjectForm(self):
 def manage_addMPIWGProject(self,id,RESPONSE=None):  def manage_addMPIWGProject(self,id,RESPONSE=None):
     """method to add a project"""      """method to add a project"""
     #print argv      #print argv
       if self.REQUEST.has_key('fileupload'):
     fileupload=self.REQUEST['fileupload']      fileupload=self.REQUEST['fileupload']
     if fileupload:      if fileupload:
         file_name=fileupload.filename          file_name=fileupload.filename
Line 378  def manage_addMPIWGProject(self,id,RESPO Line 796  def manage_addMPIWGProject(self,id,RESPO
         argv=xmlhelper.proj2hash(filedata)          argv=xmlhelper.proj2hash(filedata)
   
         #print argv          #print argv
   
     newObj=MPIWGProject(id,argv)      newObj=MPIWGProject(id,argv)
       else:
           newObj=MPIWGProject(id)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Removed from v.1.3  
changed lines
  Added in v.1.9

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