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

Diff for /MPIWGWeb/MPIWGStaff.py between versions 1.10.2.33 and 1.10.2.85

version 1.10.2.33, 2007/04/18 10:03:13 version 1.10.2.85, 2012/03/22 13:58:50
Line 7  from OFS.Folder import Folder Line 7  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.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.versionedFile.extVersionedFile import extVersionedFileFolder
   from AccessControl import getSecurityManager
   
 import os  import os
 import logging  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  from AccessControl import ClassSecurityInfo
   import time
 import logging  import logging
   import email
   import re
   from OFS.Cache import Cacheable
   import urllib2
   import transaction
   import SrvTxtUtils
   
   from MPIWGHelper import *
 #ersetzt logging  #ersetzt logging
 def logger(txt,method,txt2):  def logger(txt,method,txt2):
     """logging"""       """logging""" 
     logging.info(txt+ txt2)      logging.info(txt+ txt2)
   
 departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"  departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"
   coneService="http://127.0.0.1:8280/MetaDataManagerRestlet/cone/" # kann in MPIWGRoot konfiguriert werden.
   
   
 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  
   
 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=""):  def createNewDBEntry(self,publish_the_data,key,name,vorname,titles_new,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"""          """lege person in der datenbank an"""
   
         if date_to=="": # wenn date_to leer          if date_to=="": # wenn date_to leer
Line 50  def createNewDBEntry(self,publish_the_da Line 54  def createNewDBEntry(self,publish_the_da
             return False,"ERROR:key%s already exists"%key              return False,"ERROR:key%s already exists"%key
                   
         #eintragen          #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" """          columnlist="""publish_the_data,key,last_name,first_name,titles_new,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)          insertTuple=(publish_the_data,key,name,vorname,titles_new,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=[]          insert=[]
         for element in insertTuple:          for element in insertTuple:
Line 64  def createNewDBEntry(self,publish_the_da Line 68  def createNewDBEntry(self,publish_the_da
         queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertStr)          queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertStr)
         self.ZSQLQuery("SET DATESTYLE TO 'German'")          self.ZSQLQuery("SET DATESTYLE TO 'German'")
         self.ZSQLQuery(queryStr)          self.ZSQLQuery(queryStr)
         logging.error("QQQQ %s:"%queryStr)          logging.info("QQQQ %s:"%queryStr)
         #currentwork          #currentwork
         if not (current_work==""):          #if not (current_work==""):
             queryStr="INSERT INTO current_work (key_main,current,publish) VALUES ('%s',%s,'%s')"%(key,self.ZSQLQuote(current_work),"yes")          #    queryStr="INSERT INTO current_work (key_main,current,publish) VALUES ('%s',%s,'%s')"%(key,self.ZSQLQuote(current_work),"yes")
   
             self.ZSQLQuery(queryStr)          #  self.ZSQLQuery(queryStr)
                   
         return True,msg          return True,msg
 class MPIWGStaff(CatalogAware,ZSQLExtendFolder):  class MPIWGStaff(CatalogAware,ZSQLExtendFolder,Cacheable):
     """Staff"""      """Staff"""
   
     meta_type="MPIWGStaff"      meta_type="MPIWGStaff"
     default_catalog='MembersCatalog'      default_catalog='MembersCatalog'
     departmentList=departmentList      departmentList=departmentList
       #_v_cone=None;
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
       def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
           
           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"""
           logging.debug("KEY - MPIWGStaff:"+self.getKey())
           logging.debug("KEY - MPIWGStaff:"+utf8ify(self.getKey()))
           
           return utf8ify(self.getKey())
       
       def setKey(self,key):
       """set key"""
       self.key=key
   
     def getKey(self):      def getKey(self):
         """get database key"""          """get database key"""
         if hasattr(self,'key'):          if hasattr(self,'key'):
             return self.key.lower()              #logging.error("SAVED KEY:%s"%self.key)
               return unicodify(self.key.lower())
               #return self.key.lower()
                   
         #fuer alt faelle ohne key          #fuer alt faelle ohne key
         return (self.firstName+'_'+self.lastName).lower()          #logging.error("NEW KEY:%s"%(self.firstName+'_'+self.lastName).lower().replace(' ',''))
                   return (self.firstName+'_'+self.lastName).lower().replace(' ','')
     def getConnectionObj(self):#ueberschreibe connection id methode      
                     
             return getattr(self.de,self.de.connection_id)      def getConnectionObj(self):
            """returns connection id (from root)"""
            try:
                root = self.getMPIWGRoot()
                return root.getConnectionObj()
            except:
                return self.en.getConnectionObj()
                   
     def isPublished(self):      def isPublished(self):
         """gib publications status aus der datenbank aus"""          """gib publications status aus der datenbank aus"""
         key=self.getKey()          key=self.getKey()
         query="select count(publish_the_data) from personal_www where key='%s' and publish_the_data='yes'"%key          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 134  class MPIWGStaff(CatalogAware,ZSQLExtend Line 171  class MPIWGStaff(CatalogAware,ZSQLExtend
         """change PublicationSelectionMode"""          """change PublicationSelectionMode"""
                   
         self.publicationSelectionMode=publicationSelectionMode          self.publicationSelectionMode=publicationSelectionMode
           self.ZCacheable_invalidate()
           if RESPONSE:
               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"""
           self.ZCacheable_invalidate()
           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:          if RESPONSE:
             RESPONSE.redirect("editPublications")              self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
                           
                           
     def getPublishImage(self):      def getPublishImage(self):
         """publish the image??, default no"""          """publish the image??, default no"""
         return getattr(self,'publishImage','no')          return getattr(self,'publishImage','no')
           
     def updateImage(self,file,publishImage,rename=None,RESPONSE=None):      def updateImage(self,publishImage,file=None,rename=None,RESPONSE=None):
         """update image"""          """update image"""
   
         if file and not(file.filename==""):          if file and not(file.filename==""):
Line 154  class MPIWGStaff(CatalogAware,ZSQLExtend Line 254  class MPIWGStaff(CatalogAware,ZSQLExtend
         xp = file.filename.rfind('.')          xp = file.filename.rfind('.')
         if xp > 0:          if xp > 0:
             ext = file.filename[xp:]              ext = file.filename[xp:]
             fn = self.getId()+ext                      #fn = self.getId()+ext
                       fn = self.getId()
             logger("MPWIG STAFF", logging.INFO, "new filename: %s"%fn)              logger("MPWIG STAFF", logging.INFO, "new filename: %s"%fn)
             self.getImageFolder().addImage2(file,fileName=fn)              self.getImageFolder().addImage2(file,fileName=fn)
         else:          else:
Line 163  class MPIWGStaff(CatalogAware,ZSQLExtend Line 264  class MPIWGStaff(CatalogAware,ZSQLExtend
         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"""
Line 172  class MPIWGStaff(CatalogAware,ZSQLExtend Line 273  class MPIWGStaff(CatalogAware,ZSQLExtend
         try:          try:
             return self.getPhysicalRoot().www_neu.images.staff_images              return self.getPhysicalRoot().www_neu.images.staff_images
         except:           except: 
             logger("MPWIG STAFF", logging.ERROR, "image folder not found:"," has to be add /www_neu/staff_images")               logger("MPWIG STAFF", logging.ERROR, "image folder not found: has to be add /www_neu/staff_images") 
             return None              return None
                   
     def getImageObj(self):      def getImageObj(self):
Line 206  class MPIWGStaff(CatalogAware,ZSQLExtend Line 307  class MPIWGStaff(CatalogAware,ZSQLExtend
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Edit','action':'changeMPIWGStaffForm'},          {'label':'Edit','action':'changeMPIWGStaffForm'},
         {'label':'Change Publications Special','action':'changePublications_specialForm'},          {'label':'Change Publications Special','action':'changePublications_specialForm'},
         )          ) + Cacheable.manage_options
           
       __manager_id = "ramCache"
     def __init__(self,id, lastName,firstName,key):      def __init__(self,id, lastName,firstName,key):
         """init"""          """init"""
         self.id=id          self.id=id
Line 216  class MPIWGStaff(CatalogAware,ZSQLExtend Line 318  class MPIWGStaff(CatalogAware,ZSQLExtend
         self.firstName=firstName          self.firstName=firstName
         self.key=key          self.key=key
   
     def harvest_page(self):      def getPersonID(self):
           """gibt den ID fuer die Person zurueck"
           im Moment ist personID = id, i.e. e-mail
           """
           return self.id
   
       def getConeUrl(self):
           """gibt coneURL zurueck"""
           
           self.coneService=getattr(self, "coneServiceURL",coneService)
           logging.debug("coneservice:"+self.coneService)
           
           if getattr(self,'_v_cone',None)==None:
               try:  
                   
                   self._v_cone=SrvTxtUtils.getHttpData(self.coneService+self.getPersonID())
                   #cone = urllib2.urlopen(self.coneService+self.getPersonID())              
                   #self._v_cone=cone.read()
                   if self._v_cone==None:
                       self._v_cone=""
               except:
                   self._v_cone=""
                   return ""
               
           return self._v_cone
              
              
           
           
       def harvest_page_old(self,context=None):
         """geharvestete seite = verschlankte version von members_main"""          """geharvestete seite = verschlankte version von members_main"""
         pt = getTemplate(self, "harvest_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()          return pt()
   
     def index_html(self):      def harvest_page(self,mode="normal"):
           """harvest"""
           logging.debug("AAAAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
           if not self.isPublished():
               return 
           st = getattr(self.en.staff.members,self.getId()).index_html(mode)
           
           templates = self.en.getHarvestCache()
           #templates = getattr(self,'getHarvestCache',self.en.getHarvestCache)()
           rendered = st
           templates[self.absolute_url()]=rendered
           transaction.commit()
           return rendered
       
           
       
       def index_html(self,mode="normal"):
         """show homepage"""          """show homepage"""
       
           bound_names={}
           request = self.REQUEST
           if request is not None:
               response = request.response
               if not response.headers.has_key('content-type'):
                   response.setHeader('content-type', 'text/html')
   
           security = getSecurityManager()
           bound_names['user'] = security.getUser()
   
           # Retrieve the value from the cache.
           keyset = None
           if self.ZCacheable_isCachingEnabled():
               
               # Prepare a cache key.
               keyset = {'here': self}
                         
               result = self.ZCacheable_get(keywords=keyset)
              
               if result is not None:
                   # Got a cached value.
                   return result
           
           # look for individual page
           if self.hasObject("index.html"):
               pt = getattr(self, "index.html")
           # else use template
           else:
               if mode=="slim":
                   pt = getTemplate(self, "members_main_slim")
               else:
         pt = getTemplate(self, "members_main")          pt = getTemplate(self, "members_main")
         return pt()          # Execute the template in a new security context.
           security.addContext(self)
   
           try:
               result = pt.pt_render(extra_context=bound_names)
               if keyset is not None:
                   # Store the result in the cache.
                   self.ZCacheable_set(result, keywords=keyset)
                  
               return result
           finally:
               security.removeContext(self)
          
   
   
     def changePublications_specialForm(self):      def changePublications_specialForm(self):
         """Priority publications manual field"""          """Priority publications manual field"""
Line 233  class MPIWGStaff(CatalogAware,ZSQLExtend Line 439  class MPIWGStaff(CatalogAware,ZSQLExtend
                   
     def changePublications_special(self,usePublicationsSpecial=None,specialPublicationsField=None,RESPONSE=None):      def changePublications_special(self,usePublicationsSpecial=None,specialPublicationsField=None,RESPONSE=None):
         """change publications special params"""          """change publications special params"""
           self.ZCacheable_invalidate()
         if usePublicationsSpecial:          if usePublicationsSpecial:
           self.usePublicationsSpecial=True            self.usePublicationsSpecial=True
                     
Line 242  class MPIWGStaff(CatalogAware,ZSQLExtend Line 449  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 266  class MPIWGStaff(CatalogAware,ZSQLExtend Line 473  class MPIWGStaff(CatalogAware,ZSQLExtend
         return pt()          return pt()
           
     security.declareProtected('View management screens','changeMPIWGStaff')      security.declareProtected('View management screens','changeMPIWGStaff')
     def changeMPIWGStaff(self,lastName,firstName,RESPONSE=None):      def changeMPIWGStaff(self,lastName,firstName,key=None,RESPONSE=None):
         """change it"""          """change it"""
           self.ZCacheable_invalidate()
         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')      security.declareProtected('View management screens','edit')
     def edit(self):      def edit(self):
Line 285  class MPIWGStaff(CatalogAware,ZSQLExtend Line 495  class MPIWGStaff(CatalogAware,ZSQLExtend
         #        self.REQUEST.RESPONSE.redirect(redURL)          #        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.debug("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=""):      def getPathStyle(self, path, selected, style=""):
         """returns a string with the given style + 'sel' if path == selected."""          """returns a string with the given style + 'sel' if path == selected."""
Line 297  class MPIWGStaff(CatalogAware,ZSQLExtend Line 511  class MPIWGStaff(CatalogAware,ZSQLExtend
         else:          else:
             return style                  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 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))
           self.ZCacheable_invalidate()
           if RESPONSE:
               self.redirect(RESPONSE,"edit")
           
     security.declareProtected('View management screens','changeResearch')      security.declareProtected('View management screens','changeResearch')
     def changeResearch(self,noredirect=None):      def changeResearch(self,noredirect=None,RESPONSE=None):
         """change the research entries"""          """change the research entries"""
           self.ZCacheable_invalidate()
         newEntries={}          newEntries={}
         key_main=self.REQUEST.form['key_main']          key_main=self.REQUEST.form['key_main']
   
Line 347  class MPIWGStaff(CatalogAware,ZSQLExtend Line 604  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')          security.declareProtected('View management screens','editCV')    
     def editCV(self,cv=None,oid=None,RESPONSE=None):      def editCV(self,cv=None,oid=None,RESPONSE=None):
Line 358  class MPIWGStaff(CatalogAware,ZSQLExtend Line 615  class MPIWGStaff(CatalogAware,ZSQLExtend
              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.ZCacheable_invalidate()
          self.ZSQLQuery(query%(self.ZSQLQuote(cv),oid))           self.ZSQLQuery(query%(self.ZSQLQuote(cv),oid))
                   
          if RESPONSE:           if RESPONSE:
             RESPONSE.redirect("editCV")              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.getKeyUTF8())
           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.ZCacheable_invalidate() 
            
            
            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:
               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.getKeyUTF8())
           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')          security.declareProtected('View management screens','editAwards')    
     def editAwards(self,awards=None,oid=None,RESPONSE=None):      def editAwards(self,awards=None,oid=None,RESPONSE=None):
Line 371  class MPIWGStaff(CatalogAware,ZSQLExtend Line 717  class MPIWGStaff(CatalogAware,ZSQLExtend
          if (not oid):           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()
                    self.ZCacheable_invalidate()
          query="UPDATE personal_www SET awards =%s WHERE oid='%s'"           query="UPDATE personal_www SET awards =%s WHERE oid='%s'"
               
          self.ZSQLQuery(query%(self.ZSQLQuote(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')          security.declareProtected('View management screens','editTalks')    
     def editTalks(self):      def editTalks(self):
Line 402  class MPIWGStaff(CatalogAware,ZSQLExtend Line 748  class MPIWGStaff(CatalogAware,ZSQLExtend
     security.declareProtected('View management screens','editMainData')          security.declareProtected('View management screens','editMainData')    
     def editMainData(self,REQUEST=None,RESPONSE=None):      def editMainData(self,REQUEST=None,RESPONSE=None):
         """edit main data"""          """edit main data"""
                   self.ZCacheable_invalidate()
         argv=REQUEST.form          argv=REQUEST.form
                   
         if not argv.has_key('last_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="lower(key)=%s"%utf8ify(self.getKey().lower()),USE_FORM="yes")
             if RESPONSE:              if RESPONSE:
                 RESPONSE.redirect("editMainData")                  self.redirect(RESPONSE,"editMainData")
                                   
     security.declareProtected('View management screens','newBibliogrpaphy')          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):
Line 435  class MPIWGStaff(CatalogAware,ZSQLExtend Line 781  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,key_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
           
Line 466  class MPIWGStaff(CatalogAware,ZSQLExtend Line 813  class MPIWGStaff(CatalogAware,ZSQLExtend
           
     def changeSortingMode(self,sortingMode,RESPONSE=None,REQUEST=None):      def changeSortingMode(self,sortingMode,RESPONSE=None,REQUEST=None):
         """change sorting mode"""          """change sorting mode"""
           self.ZCacheable_invalidate()
         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
   
Line 479  class MPIWGStaff(CatalogAware,ZSQLExtend Line 827  class MPIWGStaff(CatalogAware,ZSQLExtend
         if mode=="year":          if mode=="year":
             return "year DESC"              return "year DESC"
         else:          else:
             return "mode"              return mode
                   
     def integer(self,value):      def integer(self,value):
         try:          try:
Line 488  class MPIWGStaff(CatalogAware,ZSQLExtend Line 836  class MPIWGStaff(CatalogAware,ZSQLExtend
             return 0              return 0
                   
     security.declareProtected('View management screens','changePublications')          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.ZCacheable_invalidate()
         #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'])
           
                   
   
     security.declareProtected('View management screens','addPublications')          security.declareProtected('View management screens','addPublications')    
     def addPublications(self,submit=None,REQUEST=None,noredirect=None):      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 516  class MPIWGStaff(CatalogAware,ZSQLExtend Line 865  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+="(key_main,id_institutsbibliographie,publish) "              query+="(key_main,id_institutsbibliographie,publish) "
Line 528  class MPIWGStaff(CatalogAware,ZSQLExtend Line 878  class MPIWGStaff(CatalogAware,ZSQLExtend
                   
         if not noredirect:          if not noredirect:
                           
             self.REQUEST.RESPONSE.redirect("./editPublications")              self.redirect(RESPONSE,"./editPublications")
                           
             return True              return True
                   
Line 609  class MPIWGStaff(CatalogAware,ZSQLExtend Line 959  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 630  def manage_addMPIWGStaff(self,id,lastNam Line 980  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.33  
changed lines
  Added in v.1.10.2.85

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