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

Diff for /MPIWGWeb/MPIWGStaff.py between versions 1.4 and 1.10.2.3

version 1.4, 2004/07/29 07:36:16 version 1.10.2.3, 2005/10/10 19:10:13
Line 1 Line 1
 """This file contains the classes for the organization of the staff"""  """This file contains the classes for the organization of the staff"""
   # TODO: pruefe ob die id der einzelnen tabellen, wie id in publications noch benutzt werden
   # TODO: pruefe ob die bibliographischen felder in publications noch benutzt werden
   # TODO: auswahl der ausgewaehlten publication auf der ersten seite der homepage
   
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder  from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
 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.ZCatalog.CatalogPathAwareness import CatalogAware
   import os
   import bibliography
   from Globals import package_home
   from Products.PythonScripts.standard import sql_quote
   from types import *
   
 class MPIWGStaff(ZSQLExtendFolder):  
   def getTemplate(self, tpName):
       """get a template file either form the instance or from the product"""
       ext=self.ZopeFind(self.aq_parent,obj_ids=[tpName])
       if ext:
           pt = getattr(self,ext[0][1].getId())
       else:
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/'+tpName)).__of__(self)
       assert(pt)
       return pt
   
   class MPIWGStaff(CatalogAware,ZSQLExtendFolder):
     """Staff"""      """Staff"""
   
     meta_type="MPIWGStaff"      meta_type="MPIWGStaff"
       default_catalog='MembersCatalog'
       
       def PrincipiaSearchSource(self):
           """Return cataloguable key for ourselves."""
           return str(self)
   
       manage_options = Folder.manage_options+(
           {'label':'Edit','action':'changeMPIWGStaffForm'},
           {'label':'Change Publications Special','action':'changePublications_specialForm'},
           )
   
     def __init__(self,id, lastName,firstName):      def __init__(self,id, lastName,firstName):
         """init"""          """init"""
Line 17  class MPIWGStaff(ZSQLExtendFolder): Line 47  class MPIWGStaff(ZSQLExtendFolder):
         self.lastName=lastName          self.lastName=lastName
         self.firstName=firstName          self.firstName=firstName
   
     manage_options = Folder.manage_options+(  
         {'label':'Edit','action':'changeMPIWGStaffForm'},  
         )  
     def index_html(self):      def index_html(self):
         """show homepage"""          """show homepage"""
     ext=self.ZopeFind(self.aq_parent,obj_ids=["members_main"])          pt = getTemplate(self, "members_main")
           return pt()
         if ext:  
             return getattr(self,ext[0][1].getId())()  
   
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/members_main').__of__(self)      def changePublications_specialForm(self):
           """Priority publications manual field"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changePublications_special.zpt')).__of__(self)
         return pt()          return pt()
   
       def changePublications_special(self,usePublicationsSpecial=None,specialPublicationsField=None,RESPONSE=None):
           """change publications special params"""
           if usePublicationsSpecial:
             self.usePublicationsSpecial=True
            
           else:
             self.usePublicationsSpecial=False
   
           self.specialPublicationsField=specialPublicationsField[0:]
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
           
     def publications_full(self):      def publications_full(self):
         """show publication"""          """show publication"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/publications_full').__of__(self)          pt=getTemplate(self, "publications_full_main")
         return pt()          return pt()
   
     def talks_full(self):      def talks_full(self):
         """show talks"""          """show talks"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/talks_full').__of__(self)          pt=getTemplate(self, 'talks_full_main')
         return pt()          return pt()
   
     def teaching_full(self):      def teaching_full(self):
         """show talks"""          """show talks"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/teaching_full').__of__(self)          pt=getTemplate(self, 'teaching_full_main')
         return pt()          return pt()
           
     def changeMPIWGStaffForm(self):      def changeMPIWGStaffForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGStaff.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGStaff.zpt')).__of__(self)
         return pt()          return pt()
   
     def changeMPIWGStaff(self,lastName,firstName,RESPONSE=None):      def changeMPIWGStaff(self,lastName,firstName,RESPONSE=None):
Line 59  class MPIWGStaff(ZSQLExtendFolder): Line 101  class MPIWGStaff(ZSQLExtendFolder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       def edit(self):
           """Edit the pages"""
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff.zpt')).__of__(self)
           return pt()
   
       mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff_main.zpt'))
   
       def changeResearch(self,noredirect=None):
           """change the research entries"""
           newEntries={}
           id_main=self.REQUEST.form['id_main']
   
           mainfieldL=self.REQUEST.form['main_fields'].split(",")
           mainfield={}
           for x in mainfieldL:
               tmp=x.split('__')
               mainfield[tmp[0]]=tmp[1]
           for field in self.REQUEST.form.keys():
               splittedField=field.split("__")
               if len(splittedField)<3:
                   pass #kein datenbank eintrag
   
               elif splittedField[2]=='new': # store new entries
                   if not newEntries.has_key(splittedField[0]):
                       newEntries[splittedField[0]]={}
                       
                   newEntries[splittedField[0]][splittedField[1]]=self.REQUEST.form[field]
   
               else:
                   query="UPDATE %s "%splittedField[0]
                   query+="SET %s = '%s' "%(splittedField[1],sql_quote(self.REQUEST.form[field]))
                   query+="WHERE oid = '%s' "%sql_quote(splittedField[2])
   
                   self.ZSQLQuery(query)
   
   
           #new entries
           for newEntry in newEntries.keys():
               query="INSERT INTO %s "%newEntry
               keys=['id_main']
               values=["'"+id_main+"'"]
               for key in newEntries[newEntry].keys():
                   keys.append(key)
                   values.append("'"+newEntries[newEntry][key]+"'")
   
   
               keystring=",".join(keys)
                   
               valuestring=",".join(values)
                   
               query+=" (%s) "%keystring
               query+="VALUES (%s)"%valuestring
               if not (newEntries[newEntry][mainfield[newEntry]].lstrip().rstrip()==""):
                   self.ZSQLQuery(query)
   
           if not noredirect:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
           
       def editCV(self,cv=None,oid=None,RESPONSE=None):
            """edit Cv"""
   
            if (not cv):
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editCV.zpt')).__of__(self)
                return pt()
           
            query="UPDATE personal_www SET cv ='%s' WHERE oid='%s'"
   
            self.ZSQLQuery(query%(cv,oid))
           
            if RESPONSE:
               RESPONSE.redirect("editCV")
   
       def editAwards(self,awards=None,oid=None,RESPONSE=None):
            """edit a awards"""
   
            if (not awards):
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)
                return pt()
           
            query="UPDATE personal_www SET awards ='%s' WHERE oid='%s'"
   
            self.ZSQLQuery(query%(awards,oid))
           
            if RESPONSE:
               RESPONSE.redirect("editAwards")
   
       def editTalks(self):
           """edit talks"""
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)
           return pt()
           
            
       def editTeaching(self):
           """edit Teaching"""
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTeaching.zpt')).__of__(self)
           return pt()
           
       def editBibliography(self):
           """edit the bibliography"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)
           return pt()
       
         
           
       def editPublications(self):
           """edit the bibliographie"""
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editPublications.zpt')).__of__(self)
           return pt()
       
       def changeSortingMode(self,sortingMode,RESPONSE=None,REQUEST=None):
           """change sorting mode"""
           self.sortingMode=sortingMode
           
           if RESPONSE and REQUEST:
               REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER'])
   
           return True
   
       def getSortingMode(self):
           """get sorting mode"""
           return getattr(self,'sortingMode','priority')
       
       def changePublications(self):
           """change the publication list"""
           
           self.updatePublicationDB(personId=self.getDBId())
           self.changeResearch(noredirect=True)
           self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
   
   
       def addPublications(self,submit=None,REQUEST=None,noredirect=None):
           """add publications"""
   
           #setzte flag ob aufruf aus suchformular
           
           if REQUEST.get("QUERY_STRING",None) and (not submit):
               self.REQUEST.set('fromSearch','1')
           else:
               self.REQUEST.set('fromSearch','0')
                
           if not submit or (not (submit == "add")):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublications.zpt')).__of__(self)
               return pt()
           
           #new entries
           entries = REQUEST.form.get('addEntries',None)
           if not (type(entries) is ListType):
               entries=[entries]
               
           for bibId in entries: 
               query="INSERT INTO %s " % "publications"
               query+="(id_main,id_institutsbibliographie) "
               query+="VALUES ('%s','%s')" %(sql_quote(self.getDBId()),sql_quote(bibId))
               
               self.ZSQLQuery(query)
        
           self.updatePublicationDB(personId=self.getDBId())
           
           if not noredirect:
               
               self.REQUEST.RESPONSE.redirect("./editPublications")
               
               return True
           
       
       def getDBId(self):
           """get id from the personal database"""
           search=self.ZSQLInlineSearch(_table='personal_www',username=self.getId())
           if search:
               return search[0].id
           else:
               return None
           
       
       
       formatBiblHelp=bibliography.formatBiblHelp
       
       def sortBibliography(self,list):
           sortingMode=self.getSortingMode()
           if sortingMode == "year":
               return self.sortYear(list)
           else:
               return self.sortPriority(list)
           
       def sortPriority(self,list):
           def sort(x,y):
               try:
                   xInt=int(x.priority)
               except:
                   xInt=0
               try:
                   yInt=int(y.priority)
               except:
                   yInt=0
   
               return cmp(xInt,yInt)
   
           tmp=[x for x in list]
           tmp.sort(sort)           
           return tmp
   
       def sortYear(self,list):
           #TODO: sort TO APPEAR and TO BE PUBLISHED etc...
           
           def sort(x,y):
               try:
                   xInt=int(x.year)
               except:
                   xInt=0
               try:
                   yInt=int(y.year)
               except:
                   yInt=0
   
               return cmp(yInt,xInt)
               
               
           tmp=[x for x in list]
           
           tmp.sort(sort)           
           return tmp
       
       def deleteField(self,table,oid):
           """delete entry"""
           query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)
           print "query"
           self.ZSQLQuery(query)
           self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
           
   
 def manage_addMPIWGStaffForm(self):  def manage_addMPIWGStaffForm(self):
     """form for adding the project"""      """form for adding the project"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGStaffForm.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGStaffForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGStaff(self,id,lastName,firstName,RESPONSE=None):  def manage_addMPIWGStaff(self,id,lastName,firstName,RESPONSE=None):
Removed from v.1.4  
changed lines
  Added in v.1.10.2.3

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