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

Diff for /MPIWGWeb/MPIWGStaff.py between versions 1.10.2.7 and 1.10.2.61

version 1.10.2.7, 2005/10/14 15:21:22 version 1.10.2.61, 2008/09/12 15:54:49
Line 8  from Products.ZSQLExtend.ZSQLExtend impo Line 8  from Products.ZSQLExtend.ZSQLExtend impo
 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  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.versionedFile.extVersionedFile import extVersionedFileFolder
   
 import os  import os
   import logging
 import bibliography  import bibliography
   import email
 from Globals import package_home  from Globals import package_home
 from Products.PythonScripts.standard import sql_quote  from Products.PythonScripts.standard import sql_quote
 from types import *  from types import *
   from AccessControl import ClassSecurityInfo
   import time
   import logging
   import email
   import re
   from OFS.Cache import Cacheable
   
   from MPIWGHelper import *
   #ersetzt logging
   def logger(txt,method,txt2):
       """logging""" 
       logging.info(txt+ txt2)
   
 departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"  departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"
   
Line 27  def getTemplate(self, tpName): Line 43  def getTemplate(self, tpName):
     assert(pt)      assert(pt)
     return pt      return pt
   
 class MPIWGStaff(CatalogAware,ZSQLExtendFolder):  def createNewDBEntry(self,publish_the_data,key,name,vorname,title,position,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by="",e_mail2="",txt="",txt_p="no",stay_at_mpiwg="",group="",web_object_created="no",current_work=""):
           """lege person in der datenbank an"""
   
           if date_to=="": # wenn date_to leer
                date_to="date_none"
           
           if date_from=="": # wenn date_fromleer
                date_from="date_none"
           msg=""
           #test ob id schon existiert
           if self.ZSQLQuery("select key from personal_www where key='%s'"%id):
               return False,"ERROR:key%s already exists"%key
           
           #eintragen
           columnlist="""publish_the_data,key,last_name,first_name,title,status,e_mail,e_mail_p,date_from,date_to,department,home_inst,funded_by,e_mail2,date_stay_at_mpiwg,web_object_created,"group",current_work,current_work_p """
           insertTuple=(publish_the_data,key,name,vorname,title,position,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by,e_mail2,stay_at_mpiwg,web_object_created,group,current_work,"yes")
           
           insert=[]
           for element in insertTuple:
               if element=="date_none": # date_none eintrag wird zu null uebersetzt
                   insert.append('null')
               else:
                   insert.append("%s"%self.ZSQLQuote(element))
               
           insertStr=",".join(insert)
           queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertStr)
           self.ZSQLQuery("SET DATESTYLE TO 'German'")
           self.ZSQLQuery(queryStr)
           logging.info("QQQQ %s:"%queryStr)
           #currentwork
           #if not (current_work==""):
           #    queryStr="INSERT INTO current_work (key_main,current,publish) VALUES ('%s',%s,'%s')"%(key,self.ZSQLQuote(current_work),"yes")
   
           #  self.ZSQLQuery(queryStr)
           
           return True,msg
   class MPIWGStaff(CatalogAware,ZSQLExtendFolder,Cacheable):
     """Staff"""      """Staff"""
   
     meta_type="MPIWGStaff"      meta_type="MPIWGStaff"
     default_catalog='MembersCatalog'      default_catalog='MembersCatalog'
     departmentList=departmentList      departmentList=departmentList
       security=ClassSecurityInfo()
           
     def getConnectionObj(self):#ueberschreibe connection id methode          def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
                     
             return getattr(self.de,self.de.connection_id)          timeStamp=time.time()
           
           if url.find("?")>-1: #giebt es schon parameter
               addStr="&time=%s"
           else:
               addStr="?time=%s"
               
           RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
           logging.error(email.Utils.formatdate()+' GMT')
           RESPONSE.redirect(url+addStr%timeStamp)
           
       def getKeyUTF8(self):
           """get db_key utf8"""
           return utf8ify(self.getKey())
       
       def getKey(self):
           """get database key"""
           if hasattr(self,'key'):
               #logging.error("SAVED KEY:%s"%self.key)
               return unicodify(self.key.lower())
               #return self.key.lower()
           
           #fuer alt faelle ohne key
           #logging.error("NEW KEY:%s"%(self.firstName+'_'+self.lastName).lower().replace(' ',''))
           return (self.firstName+'_'+self.lastName).lower().replace(' ','')
           
       def getConnectionObj(self):
            """returns connection id (from root)"""
            root = self.getMPIWGRoot()
            return root.getConnectionObj()
                   
     def isPublished(self):      def isPublished(self):
         """gib publications status aus der datenbank aus"""          """gib publications status aus der datenbank aus"""
         username=self.getId()          key=self.getKey()
         query="select count(publish_the_data) from personal_www where username='%s' and publish_the_data='yes'"%username          query="select count(publish_the_data) from personal_www where lower(key)='%s' and publish_the_data='yes'"%key
                   
         res = self.ZSQLQuery(query)          res = self.ZSQLQuery(query)
                   
Line 50  class MPIWGStaff(CatalogAware,ZSQLExtend Line 133  class MPIWGStaff(CatalogAware,ZSQLExtend
         else:          else:
             return False              return False
                   
     def createNewDBEntry(self,publish_the_data,id,name,vorname,username,title,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by="",e_mail2="",txt="",txt_p="no"):  
         """lege person in der datenbank an"""  
         msg=""  
         #test ob id schon existiert  
         if self.ZSQLQuery("select id from personal_www where id='%s'"%id):  
             return False,"ERROR:id %s already exists"%id  
           
         if self.ZSQLQuery("select username from personal_www where username='%s' and publish_the_data='yes'"%username):  
               
             return False,"ERROR:username %s already exists and has data published, id=%s not added (running update again might solve this problem)"%(username,id)  
           
         if self.ZSQLQuery("select username from personal_www where username='%s' and not publish_the_data='yes'"%username):  
             msg="WARNING:username %s not unique but id=%s added"%(username,id)  
         #eintragen  
         columnlist="publish_the_data,id,name,vorname,username,title,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by,e_mail2"  
         insertTuple=(publish_the_data,id,name,vorname,username,title,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by,e_mail2)  
           
         insert=[]  
         for element in insertTuple:  
             insert.append("'%s'"%element)  
           
         insertStr=",".join(insert)  
         queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertTuple)  
           
         self.ZSQLQuery(queryStr)  
                   
         #currentwork  
         if not (txt==""):  
             queryStr="INSERT INTO current_work (id_main,current,publish) VALUES ('%s','%s','%s')"%(id,txt,txt_p)  
             self.ZSQLQuery(queryStr)  
           
         return True,msg  
           
     def updateDBEntry(self,publish_the_data,date_from,date_to,DBid=None):       def updateDBEntry(self,publish_the_data,date_from,date_to,DBid=None,stay_at_mpiwg="",position="",abteilung=""): 
         """zpddatedb"""          """zpddatedb"""
         if not DBid:          if not DBid:
             DBid=self.getDBId()              DBid=self.getDBId()
                     
    
         self.ZSQLQuery("SET DATESTYLE TO 'German'")          self.ZSQLQuery("SET DATESTYLE TO 'German'")
   
           test=self.ZSQLQuery("select id from personal_www where id='%s' "%DBid)
   
           
           if test and (len(test)>0): #dataset exists
               logger("MPIWG Web",logging.INFO,'UPDATE: _table="personal_www",_identify="id=%s"'%DBid+',publish_the_data=%s'%publish_the_data+',date_from=%s'%date_from+',date_to=%s'%date_to+',stay_at_mpiwg=%s'%stay_at_mpiwg+',position=%s'%position)
         self.ZSQLChange(_table="personal_www",_identify="id=%s"%DBid,publish_the_data=publish_the_data,          self.ZSQLChange(_table="personal_www",_identify="id=%s"%DBid,publish_the_data=publish_the_data,
                                    date_from=date_from,                                     date_from=date_from,
                                    date_to=date_to)                                     date_to=date_to,stay_at_mpiwg=stay_at_mpiwg,position=position,abteilung=abteilung)
                                 return True
           else:
               return False
                       
     def getPublicationSelectionMode(self):      def getPublicationSelectionMode(self):
         """get publication selection mode, default 'priority'"""          """get publication selection mode, default 'priority'"""
Line 104  class MPIWGStaff(CatalogAware,ZSQLExtend Line 165  class MPIWGStaff(CatalogAware,ZSQLExtend
         self.publicationSelectionMode=publicationSelectionMode          self.publicationSelectionMode=publicationSelectionMode
                   
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect("editPublications")              self.redirect(RESPONSE,"editPublications")
               
       
       def downloadCV(self,RESPONSE):
           """download cv file"""
           ob=self._getOb("downloadableFiles")._getOb("cv.pdf")
           
           RESPONSE.redirect(ob.absolute_url()+"/download")
       
       def getLastUpdateCV(self):
           """getDate of Last Update"""
           try:
                   ob=self._getOb("downloadableFiles")._getOb("cv.pdf")
                   return ob.getLastChangeDate()
           except:
                   return "No file yet!"
       def getLastUpdatePublications(self):
           """getDate of Last Update"""
           try:
                   ob=self._getOb("downloadableFiles")._getOb("publications.pdf")
                   return ob.getLastChangeDate()
           except:
                   return "No file yet!"
       def downloadPublications(self,RESPONSE):
           """download publications"""
           ob=self._getOb("downloadableFiles")._getOb("publications.pdf")
           
           RESPONSE.redirect(ob.absolute_url()+"/download")
      
       def changeDownloads(self,cv_pdf=None,cv_publish=None,publications_pdf=None,publications_publish=None,RESPONSE=None):
           """"change the downloadable files"""
           
           if not hasattr(self,'downloadableFiles'):
              
               extFolder =  extVersionedFileFolder()
               extFolder.id = "downloadableFiles"
               self._setObject(extFolder.id,extFolder)
               
           ob = self._getOb("downloadableFiles")
           
           if cv_publish:
               self.cv_publish=cv_publish
               
           if publications_publish:
               self.publications_publish=publications_publish
               
           if cv_pdf:
               if not hasattr(ob,"cv.pdf"):
                   ob.addFile("",cv_pdf,newName="cv.pdf")
               
               else:
                   cvFile = getattr(ob,"cv.pdf")
                   cvFile.addContentObject("","",file=cv_pdf)
           
           if publications_pdf:
               if not hasattr(ob,"publications.pdf"):
                   ob.addFile("",cv_pdf,newName="publications.pdf")
               
               else:
                   cvFile = getattr(ob,"publications.pdf")
                   cvFile.addContentObject("","",file=publications_pdf)
           
           if RESPONSE:
               self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
                           
                           
     def getPublishImage(self):      def getPublishImage(self):
Line 114  class MPIWGStaff(CatalogAware,ZSQLExtend Line 238  class MPIWGStaff(CatalogAware,ZSQLExtend
     def updateImage(self,file,publishImage,rename=None,RESPONSE=None):      def updateImage(self,file,publishImage,rename=None,RESPONSE=None):
         """update image"""          """update image"""
                   
           if file and not(file.filename==""):
         if self.getImageObj():          if self.getImageObj():
             self.getImageObj().updateImage(file,rename=None,RESPONSE=None)                                self.getImageObj().updateImage(file,_rename=None,RESPONSE=None)
               else:
                   # create new image object
                   xp = file.filename.rfind('.')
                   if xp > 0:
                       ext = file.filename[xp:]
                       #fn = self.getId()+ext
                       fn = self.getId()
                       logger("MPWIG STAFF", logging.INFO, "new filename: %s"%fn)
                       self.getImageFolder().addImage2(file,fileName=fn)
         else:          else:
             self.getImageFolder().addImage2(file,fileName=self.getId())                      logger("MPWIG STAFF", logging.ERROR, "uploaded filename %s has no extension!"%file.filename)
                           
         self.publishImage=publishImage          self.publishImage=publishImage
                   
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect("edit")              self.redirect(RESPONSE,"edit")
                           
     def getImageFolder(self):      def getImageFolder(self):
         """getImageFolder"""          """getImageFolder"""
           #TODO: make place of staff image folder configurable
           
           try:
         return self.getPhysicalRoot().www_neu.images.staff_images          return self.getPhysicalRoot().www_neu.images.staff_images
           except: 
               logger("MPWIG STAFF", logging.ERROR, "image folder not found: has to be add /www_neu/staff_images") 
               return None
           
     def getImageObj(self):      def getImageObj(self):
         """getImage"""          """getImage"""
         imageFolder=self.getImageFolder()          imageFolder=self.getImageFolder()
                   
           if not imageFolder: return None
           
         image=getattr(imageFolder,self.getId(),None)          image=getattr(imageFolder,self.getId(),None)
   
         if not image:          if not image:
Line 159  class MPIWGStaff(CatalogAware,ZSQLExtend Line 301  class MPIWGStaff(CatalogAware,ZSQLExtend
         {'label':'Change Publications Special','action':'changePublications_specialForm'},          {'label':'Change Publications Special','action':'changePublications_specialForm'},
         )          )
           
     def __init__(self,id, lastName,firstName):      def __init__(self,id, lastName,firstName,key):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title="%s, %s"%(lastName,firstName)          self.title=key
         self.lastName=lastName          self.lastName=lastName
         self.firstName=firstName          self.firstName=firstName
           self.key=key
       
       def getPersonID(self):
           """gibt den ID fuer die Person zurueck"
           im Moment ist personID = id, i.e. e-mail
           """
           return self.id
   
       def harvest_page_old(self,context=None):
           """geharvestete seite = verschlankte version von members_main"""
           #pt = getTemplate(self, "harvest_members_main")
           
           if not self.isPublished():
               return ""
           if not context:
               context=self
               
           
           ext=getattr(self,"harvest_members_main",None)
           if ext:
               return getattr(self,ext.getId())()
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_members_main')).__of__(context)    
   
   
           return pt()
   
       def harvest_page(self):
           """harvest"""
           if not self.isPublished():
               return ""
           return getattr(self.en.staff.members,self.getId()).index_html()
   
   
     def index_html(self):      def index_html(self):
Line 188  class MPIWGStaff(CatalogAware,ZSQLExtend Line 362  class MPIWGStaff(CatalogAware,ZSQLExtend
         self.specialPublicationsField=specialPublicationsField[0:]          self.specialPublicationsField=specialPublicationsField[0:]
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              self.redirect(RESPONSE,'manage_main')
   
                   
     def publications_full(self):      def publications_full(self):
Line 211  class MPIWGStaff(CatalogAware,ZSQLExtend Line 385  class MPIWGStaff(CatalogAware,ZSQLExtend
         pt=PageTemplateFile(os.path.join(package_home(globals()),'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):      security.declareProtected('View management screens','changeMPIWGStaff')
       def changeMPIWGStaff(self,lastName,firstName,key=None,RESPONSE=None):
         """change it"""          """change it"""
         self.title="%s, %s"%(lastName,firstName)          self.title="%s, %s"%(lastName,firstName)
         self.lastName=lastName          self.lastName=lastName
         self.firstName=firstName          self.firstName=firstName
           if key:
               self.key = key
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              self.redirect(RESPONSE,'manage_main')
   
       security.declareProtected('View management screens','edit')
     def edit(self):      def edit(self):
         """Edit the pages"""          """Edit the pages"""
           #TODO: zusammenspiel mit apache, redirect auf 18080 rausnehmen bzw. zumindest verallgemeinern
           #if self.REQUEST['SERVER_URL']=="http://www.mpiwg-berlin.mpg.de":
           #        redURL="http://xserve04.mpiwg-berlin.mpg.de:18080/www_neu/de/mitarbeiter/members/%s/edit"%self.getId()
           #
           #        self.REQUEST.RESPONSE.redirect(redURL)
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff.zpt')).__of__(self)
           
           
           logging.error("XX:"+email.Utils.formatdate().split("-")[0]+'GMT')
         return pt()          return pt()
   
     mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff_main.zpt'))      mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff_main.zpt'))
       addPublicationsBib=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublicationsBib.zpt'))
   
       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 getLabel(self):
           """returns a label for this object"""
           return self.title
   
       def getBreadcrumbs(self):
           """return list of breadcrumbs from here to the root"""
           crumbs = []
           # skip direct parent Folder /members/
           parent = self.aq_parent.aq_parent
           # get parents breadcrumbs
           logging.debug("getbreadcrumbs-: title=%s self=%s parent=%s"%(self.title, repr(self), repr(parent)))
           if hasattr(parent, 'getBreadcrumbs'):
               logging.debug("getbreadcrumbs: recurse to %s"%parent)
               crumbs = parent.getBreadcrumbs()
           
           # try to get acquisition URL from parent
           if hasattr(parent, 'absolute_url'):
               baseUrl = "%s/%s/"%(parent.absolute_url(), 'members')
           else:
               baseUrl = "/en/staff/members/"
               
           # add this
           crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
               
           return crumbs
   
   
     def changeResearch(self,noredirect=None):      def changeCurrentWork(self,current_work,key,publish="yes",RESPONSE=None):
           """change current work"""
           
           query="UPDATE personal_www SET current_work =%s WHERE key='%s'"
            
           self.ZSQLQuery(query%(self.ZSQLQuote(current_work),key))
          
           query="UPDATE personal_www SET current_work_p =%s WHERE key='%s'"
            
           self.ZSQLQuery(query%(self.ZSQLQuote(publish),key))
          
           if RESPONSE:
               self.redirect(RESPONSE,"edit")
           
       security.declareProtected('View management screens','changeResearch')
       def changeResearch(self,noredirect=None,RESPONSE=None):
         """change the research entries"""          """change the research entries"""
         newEntries={}          newEntries={}
         id_main=self.REQUEST.form['id_main']          key_main=self.REQUEST.form['key_main']
   
         mainfieldL=self.REQUEST.form['main_fields'].split(",")          mainfieldL=self.REQUEST.form['main_fields'].split(",")
         mainfield={}          mainfield={}
Line 260  class MPIWGStaff(CatalogAware,ZSQLExtend Line 498  class MPIWGStaff(CatalogAware,ZSQLExtend
         #new entries          #new entries
         for newEntry in newEntries.keys():          for newEntry in newEntries.keys():
             query="INSERT INTO %s "%newEntry              query="INSERT INTO %s "%newEntry
             keys=['id_main']              keys=['key_main']
             values=["'"+id_main+"'"]              values=["'"+sql_quote(key_main)+"'"]
             for key in newEntries[newEntry].keys():              for key in newEntries[newEntry].keys():
                 keys.append(key)                  keys.append(key)
                 values.append("'"+newEntries[newEntry][key]+"'")                  values.append("'"+sql_quote(newEntries[newEntry][key])+"'")
   
   
             keystring=",".join(keys)              keystring=",".join(keys)
Line 277  class MPIWGStaff(CatalogAware,ZSQLExtend Line 515  class MPIWGStaff(CatalogAware,ZSQLExtend
                 self.ZSQLQuery(query)                  self.ZSQLQuery(query)
   
         if not noredirect:          if not noredirect:
             self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])              self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
                   
       security.declareProtected('View management screens','editCV')    
     def editCV(self,cv=None,oid=None,RESPONSE=None):      def editCV(self,cv=None,oid=None,RESPONSE=None):
          """edit Cv"""           """edit Cv"""
   
          if (not cv):           if (not oid):
              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editCV.zpt')).__of__(self)               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editCV.zpt')).__of__(self)
              return pt()               return pt()
                   
          query="UPDATE personal_www SET cv ='%s' WHERE oid='%s'"           query="UPDATE personal_www SET cv =%s WHERE oid='%s'"
            
            self.ZSQLQuery(query%(self.ZSQLQuote(cv),oid))
           
            if RESPONSE:
               self.redirect(RESPONSE,"editCV")
               
       
       def getProfile(self):
           """get the profile"""
       self.REQUEST.RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
         
           founds=self.ZSQLInlineSearchU(_table='personal_www',key=self.getKey())
           html="""<html><body>%s</body></html>"""
           if founds.profile and founds.profile != "":
              
               return html%founds.profile
           else:
                           
               return html%self.generateProfileForPerson(founds)
               
       def editProfile(self,oid=None,RESPONSE=None, kupu=None, preview=None):
            """edit Profile, new entry replaces CD, current work and research interests"""
   
            if (not oid):
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editProfile.zpt')).__of__(self)
                return pt()
           
   
          self.ZSQLQuery(query%(cv,oid))  
                   
            
            if preview:
                pass
                #TODO: not supported yet
                #kupu=preview
                # find content of body tags
           
            start=kupu.find("<body>")
            end=kupu.find("</body>")
            
            newcontent= kupu[start+6:end]
               
               
            
           
            if preview: 
               #TODO: not supported yet
               if RESPONSE:
                   self.redirect(RESPONSE,"editProfile")
               
               #return self.preview(newcontent)
   
            query="UPDATE personal_www SET profile=%s WHERE oid='%s'"       
            self.ZSQLQuery(query%(self.ZSQLQuote(newcontent),oid))
            logging.error("PROFILE:"+query%(self.ZSQLQuote(newcontent),oid))
          if RESPONSE:           if RESPONSE:
             RESPONSE.redirect("editCV")              self.redirect(RESPONSE,"editProfile")
   
   
   
       def generateProfileForPerson(self,person):
           """erzeugt ein automatisches Profil aus den alten Eintraegen  CV, Current work, und research interests"""
           
           ret=""
           founds=self.ZSQLInlineSearch(_table='research_interest',key_main=person.key)
           if founds:
               ret="<p class=\"bio_section_header\">Research interests: </p><br/>"
           for found in self.sortPriority(founds):
               ret+=found.interest+"<br/>"
           
           
           if (person.current_work) and (not person.current_work==""):
               ret+="<p class=\"bio_section_header\">Current work: </p><br/>"
         
               ret+=person.current_work+"<br/>"
           if (person.cv) and (not person.cv==""):
               ret+="<p class=\"bio_section_header\">Curriculum Vitae: </p><br/>"
           ret+=self.formatAscii(person.cv)
           
           return ret
       security.declareProtected('View management screens','editDownloads')
       def editDownloads(self):    
           """editiere die Downloads von der Webseite"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editDownloads.zpt')).__of__(self)
           return pt()
   
       security.declareProtected('View management screens','editAdditionalLinks.zpt')
       def editAdditionalLinks(self):    
           """editiere die Downloads von der Webseite"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAdditionalLinks.zpt')).__of__(self)
           return pt()
       
       
       security.declareProtected('View management screens','editAwards')    
     def editAwards(self,awards=None,oid=None,RESPONSE=None):      def editAwards(self,awards=None,oid=None,RESPONSE=None):
          """edit a awards"""           """edit a awards"""
   
          if (not awards):           if (not oid):
              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)
              return pt()               return pt()
                   
          query="UPDATE personal_www SET awards ='%s' WHERE oid='%s'"           query="UPDATE personal_www SET awards =%s WHERE oid='%s'"
   
          self.ZSQLQuery(query%(awards,oid))           self.ZSQLQuery(query%(self.ZSQLQuote(awards),oid))
                   
          if RESPONSE:           if RESPONSE:
             RESPONSE.redirect("editAwards")              self.redirect(RESPONSE,"editAwards")
   
       security.declareProtected('View management screens','editTalks')    
     def editTalks(self):      def editTalks(self):
         """edit talks"""          """edit talks"""
   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)
         return pt()          return pt()
                   
                security.declareProtected('View management screens','editTeaching')    
     def editTeaching(self):      def editTeaching(self):
         """edit Teaching"""          """edit Teaching"""
   
Line 326  class MPIWGStaff(CatalogAware,ZSQLExtend Line 655  class MPIWGStaff(CatalogAware,ZSQLExtend
         list= [x[0] for x in finds]          list= [x[0] for x in finds]
         return "\n".join(list)          return "\n".join(list)
   
     def editMainData(self,REQUEST=None,RESPONSE=None,name=None,**argv):      security.declareProtected('View management screens','editMainData')    
       def editMainData(self,REQUEST=None,RESPONSE=None):
         """edit main data"""          """edit main data"""
                   
           argv=REQUEST.form
           
         if not name:          if not argv.has_key('last_name'):
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMainData.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMainData.zpt')).__of__(self)
             return pt()               return pt() 
         else:          else:
                           self.ZSQLChange(argv,_table="personal_www",_identify="key=%s"%self.getKey(),USE_FORM="yes")
             self.ZSQLChange(argv,_table="personal_www",_identify="<%s"%self.getDBId(),USE_FORM="yes")  
             if RESPONSE:              if RESPONSE:
                 RESPONSE.redirect("editMainData")                  self.redirect(RESPONSE,"editMainData")
                   
                               
       security.declareProtected('View management screens','newBibliogrpaphy')    
     def newBibliography(self,_docType=None, _addEntry=None,RESPONSE=None,**argv):      def newBibliography(self,_docType=None, _addEntry=None,RESPONSE=None,**argv):
                   
         """add an entry to the bibliography"""          """add an entry to the bibliography"""
Line 361  class MPIWGStaff(CatalogAware,ZSQLExtend Line 691  class MPIWGStaff(CatalogAware,ZSQLExtend
             bookId="b%06i" % newId              bookId="b%06i" % newId
                           
             self.ZSQLAdd(argv,_table="bibliography",reference_type=_docType,id=bookId)              self.ZSQLAdd(argv,_table="bibliography",reference_type=_docType,id=bookId)
             self.ZSQLAdd(_table="publications",id_gen_bib=bookId,id_main=self.getDBId(),publish='yes')  
               self.ZSQLAdd(_useRequest=False,_table="publications",id_gen_bib=bookId,key_main=self.getDBId(),publish='yes')
             self.updatePublicationDB(personId=self.getDBId())              self.updatePublicationDB(personId=self.getDBId())
                           
                   
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect("editPublications")              self.redirect(RESPONSE,"editPublications")
                           
         return True          return True
           
       security.declareProtected('View management screens','editImage')    
     def editImage(self):      def editImage(self):
         """edit images"""          """edit images"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageStaff.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageStaff.zpt')).__of__(self)
         return pt()          return pt()
           
       security.declareProtected('View management screens','editBibliography')    
     def editBibliography(self):      def editBibliography(self):
         """edit the bibliography"""          """edit the bibliography"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)
         return pt()          return pt()
           
               
               security.declareProtected('View management screens','editPublications')    
     def editPublications(self):      def editPublications(self):
         """edit the bibliographie"""          """edit the bibliographie"""
   
Line 393  class MPIWGStaff(CatalogAware,ZSQLExtend Line 726  class MPIWGStaff(CatalogAware,ZSQLExtend
         self.sortingMode=sortingMode          self.sortingMode=sortingMode
                   
         if RESPONSE and REQUEST:          if RESPONSE and REQUEST:
             REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER'])              self.redirect(RESPONSE,REQUEST['HTTP_REFERER'])
   
         return True          return True
   
     def getSortingMode(self):      def getSortingMode(self):
         """get sorting mode"""          """get sorting mode"""
         return getattr(self,'sortingMode','priority')          mode=getattr(self,'sortingMode','priority')
           if mode=="year":
               return "year DESC"
           else:
               return mode
           
     def integer(self,value):      def integer(self,value):
         try:          try:
Line 407  class MPIWGStaff(CatalogAware,ZSQLExtend Line 744  class MPIWGStaff(CatalogAware,ZSQLExtend
         except:          except:
             return 0              return 0
                   
               security.declareProtected('View management screens','changePublications')    
     def changePublications(self):      def changePublications(self,RESPONSE=None):
         """change the publication list"""          """change the publication list"""
         self.changeResearch(noredirect=True)          self.changeResearch(noredirect=True)
                   
         #self.updatePublicationDB(personId=self.getDBId())          #self.updatePublicationDB(personId=self.getDBId())
         self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])          self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
                   
   
   
     def addPublications(self,submit=None,REQUEST=None,noredirect=None):      security.declareProtected('View management screens','addPublications')    
       def addPublications(self,submit=None,REQUEST=None,noredirect=None,RESPONSE=None):
         """add publications"""          """add publications"""
   
         #setzte flag ob aufruf aus suchformular          #setzte flag ob aufruf aus suchformular
Line 436  class MPIWGStaff(CatalogAware,ZSQLExtend Line 774  class MPIWGStaff(CatalogAware,ZSQLExtend
         if not (type(entries) is ListType):          if not (type(entries) is ListType):
             entries=[entries]              entries=[entries]
                           
           
         for bibId in entries:           for bibId in entries: 
             query="INSERT INTO %s " % "publications"              query="INSERT INTO %s " % "publications"
             query+="(id_main,id_institutsbibliographie,publish) "              query+="(key_main,id_institutsbibliographie,publish) "
             query+="VALUES ('%s','%s','yes')" %(sql_quote(self.getDBId()),sql_quote(bibId))              query+="VALUES ('%s','%s','yes')" %(sql_quote(self.getKey()),sql_quote(bibId))
             print "ADD",query              
             #self.ZSQLAdd(_table="publications",id_institutsbibliographie=bibId,id_main=self.getDBId(),publish='yes')              #self.ZSQLAdd(_table="publications",id_institutsbibliographie=bibId,id_main=self.getDBId(),publish='yes')
             self.ZSQLQuery(query)              self.ZSQLQuery(query)
             
         self.updatePublicationDB(personId=self.getDBId())          self.updatePublicationDB(personId=self.getKey())
                   
         if not noredirect:          if not noredirect:
                           
             self.REQUEST.RESPONSE.redirect("./editPublications")              self.redirect(RESPONSE,"./editPublications")
                           
             return True              return True
                   
           
     def getDBId(self):      def getDBId(self):
         """get id from the personal database"""          """get id from the personal database"""
         search=self.ZSQLInlineSearch(_table='personal_www',username=self.getId(),publish_the_data='yes')          
         if search:#name existiert und published, dann nimm diesen falls es mehrereeventuell nich publizierte datensaetze gibt.          #in der neuen version ist definitions gemaess der key der Datenbank gleich dem key im Object.
             return search[0].id          # TODO: remove all occurences of getDBId and replaces it by getKey
         else:#nicht publiziert dann nimm einen davon          return self.getKey()
             search2=self.ZSQLInlineSearch(_table='personal_www',username=self.getId())          
             if search2:  #        search=self.ZSQLInlineSearch(_table='personal_www',key=self.getKey(),publish_the_data='yes')
                 return search2[0].id  #        if search:#name existiert und published, dann nimm diesen falls es mehrereeventuell nich publizierte datensaetze gibt.
             else:  #            return search[0].id
                 return None  #        else:#nicht publiziert dann nimm einen davon
   #            search2=self.ZSQLInlineSearch(_table='personal_www',username=self.getId())
   #            if search2:
   #                return search2[0].id
   #            else:
   #                return None
                   
           
           
     formatBiblHelp=bibliography.formatBiblHelp      formatBiblHelp=bibliography.formatBiblHelp
           
     def sortBibliography(self,list,sortingMode=None):      def sortBibliography(self,list,sortingMode=None,max=None):
         if not sortingMode:          if not sortingMode:
             sortingMode=self.getSortingMode()              sortingMode=self.getSortingMode()
           
         if sortingMode == "year":          if sortingMode == "year":
             return self.sortYear(list)              l= self.sortYear(list)
         else:          else:
             return self.sortPriority(list)              l=self.sortPriority(list)
           
           if max:
               return l[0:min(len(l),max)]
           else:
               return l
                   
     def sortPriority(self,list):      def sortPriority(self,list):
         def sort(x,y):          def sort(x,y):
Line 491  class MPIWGStaff(CatalogAware,ZSQLExtend Line 840  class MPIWGStaff(CatalogAware,ZSQLExtend
   
             return cmp(xInt,yInt)              return cmp(xInt,yInt)
   
           if not list:
               return []
         tmp=[x for x in list]          tmp=[x for x in list]
         tmp.sort(sort)                     tmp.sort(sort)           
           
         return tmp          return tmp
   
     def sortYear(self,list):      def sortYear(self,list):
Line 516  class MPIWGStaff(CatalogAware,ZSQLExtend Line 868  class MPIWGStaff(CatalogAware,ZSQLExtend
         tmp.sort(sort)                     tmp.sort(sort)           
         return tmp          return tmp
           
     def deleteField(self,table,oid):      def deleteField(self,table,oid,RESPONSE=None):
         """delete entry"""          """delete entry"""
         query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)          query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)
   
         self.ZSQLQuery(query)          self.ZSQLQuery(query)
         self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])          self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
                   
           
 def manage_addMPIWGStaffForm(self):  def manage_addMPIWGStaffForm(self):
Line 537  def manage_addMPIWGStaff(self,id,lastNam Line 889  def manage_addMPIWGStaff(self,id,lastNam
   
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          self.redirect(RESPONSE,'manage_main')
   
           
Removed from v.1.10.2.7  
changed lines
  Added in v.1.10.2.61

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