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

Diff for /MPIWGWeb/MPIWGStaff.py between versions 1.10 and 1.11

version 1.10, 2005/04/25 17:21:48 version 1.11, 2009/02/18 13:01:17
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: wird username gebraucht?
   
 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.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 bibliography
   import email
 from Globals import package_home  from Globals import package_home
   from Products.PythonScripts.standard import sql_quote
   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"
   
   
 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])  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=""):
     if ext:          """lege person in der datenbank an"""
         pt = getattr(self,ext[0][1].getId())  
           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:      else:
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/'+tpName)).__of__(self)                  insert.append("%s"%self.ZSQLQuote(element))
     assert(pt)              
     return pt          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)
   
 class MPIWGStaff(CatalogAware,ZSQLExtendFolder):          return True,msg
   class MPIWGStaff(CatalogAware,ZSQLExtendFolder,Cacheable):
     """Staff"""      """Staff"""
   
     meta_type="MPIWGStaff"      meta_type="MPIWGStaff"
     default_catalog='MembersCatalog'      default_catalog='MembersCatalog'
       departmentList=departmentList
       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"""
           return utf8ify(self.getKey())
       
       def setKey(self,key):
       """set key"""
       self.key=key
   
       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):
           """gib publications status aus der datenbank aus"""
           key=self.getKey()
           query="select count(publish_the_data) from personal_www where lower(key)='%s' and publish_the_data='yes'"%key
           
           res = self.ZSQLQuery(query)
           
           if res and res[0].count>0:
               return True
           else:
               return False
           
    
     
       def updateDBEntry(self,publish_the_data,date_from,date_to,DBid=None,stay_at_mpiwg="",position="",abteilung=""): 
           """zpddatedb"""
           if not DBid:
                       DBid=self.getDBId()
           
    
           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,
                                      date_from=date_from,
                                      date_to=date_to,stay_at_mpiwg=stay_at_mpiwg,position=position,abteilung=abteilung)
               return True
           else:
               return False
             
       def getPublicationSelectionMode(self):
           """get publication selection mode, default 'priority'"""
           return getattr(self,'publicationSelectionMode','priority')
           
       def changePublicationSelectionMode(self,publicationSelectionMode,RESPONSE=None):
           """change 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:
               self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
       
   
       def getPublishImage(self):
           """publish the image??, default no"""
           return getattr(self,'publishImage','no')
       
       def updateImage(self,file,publishImage,rename=None,RESPONSE=None):
           """update image"""
   
           if file and not(file.filename==""):
               if self.getImageObj():
                                 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:
                       logger("MPWIG STAFF", logging.ERROR, "uploaded filename %s has no extension!"%file.filename)
               
           self.publishImage=publishImage
           
           if RESPONSE:
               self.redirect(RESPONSE,"edit")
               
       def getImageFolder(self):
           """getImageFolder"""
           #TODO: make place of staff image folder configurable
           
           try:
               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):
           """getImage"""
           imageFolder=self.getImageFolder()
           
           if not imageFolder: return None
           
           image=getattr(imageFolder,self.getId(),None)
   
           if not image:
               for suffix in ['jpg','tif']:
                   
                   image=getattr(imageFolder,self.getId()+"."+suffix,None)
                   if image:
                       break
           return image
               
       def getImageUrl(self):
           """getImageUrl"""
           image=self.getImageObj()
           if not image:
               return None
           else:
               return self.getImageObj().absolute_url()+"/image"
           
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
         """Return cataloguable key for ourselves."""          """Return cataloguable key for ourselves."""
Line 30  class MPIWGStaff(CatalogAware,ZSQLExtend Line 296  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'},
           ) + Cacheable.manage_options
           
     def __init__(self,id, lastName,firstName):      __manager_id = "ramCache"
       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):
         """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
         
         pt = getTemplate(self, "members_main")          pt = getTemplate(self, "members_main")
            # 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):
           """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"""
           self.ZCacheable_invalidate()
           if usePublicationsSpecial:
             self.usePublicationsSpecial=True
            
           else:
             self.usePublicationsSpecial=False
   
           self.specialPublicationsField=specialPublicationsField[0:]
   
           if RESPONSE is not None:
               self.redirect(RESPONSE,'manage_main')
   
           
     def publications_full(self):      def publications_full(self):
         """show publication"""          """show publication"""
         pt=getTemplate(self, "publications_full_main")          pt=getTemplate(self, "publications_full_main")
Line 64  class MPIWGStaff(CatalogAware,ZSQLExtend Line 422  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.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')
       def edit(self):
           """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)
           
           
           logging.error("XX:"+email.Utils.formatdate().split("-")[0]+'GMT')
           return pt()
   
       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 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')
       def changeResearch(self,noredirect=None,RESPONSE=None):
           """change the research entries"""
           self.ZCacheable_invalidate()
           newEntries={}
           key_main=self.REQUEST.form['key_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=['key_main']
               values=["'"+sql_quote(key_main)+"'"]
               for key in newEntries[newEntry].keys():
                   keys.append(key)
                   values.append("'"+sql_quote(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.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
               
       security.declareProtected('View management screens','editCV')    
       def editCV(self,cv=None,oid=None,RESPONSE=None):
            """edit Cv"""
   
            if (not oid):
                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.ZCacheable_invalidate()
            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.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.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):
            """edit a awards"""
        
            if (not oid):
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)
                return pt()
            self.ZCacheable_invalidate()
            query="UPDATE personal_www SET awards =%s WHERE oid='%s'"
         
            self.ZSQLQuery(query%(self.ZSQLQuote(awards),oid))
           
            if RESPONSE:
               self.redirect(RESPONSE,"editAwards")
   
       security.declareProtected('View management screens','editTalks')    
       def editTalks(self):
           """edit talks"""
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)
           return pt()
           
       security.declareProtected('View management screens','editTeaching')    
       def editTeaching(self):
           """edit Teaching"""
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTeaching.zpt')).__of__(self)
           return pt()
           
       def getDocTypes(self):
           finds = self.ZopeFind(self.metadata.main.meta.bib,obj_metatypes=["OSAS_MetadataMapping__neu"])
   
           list= [x[0] for x in finds]
           return "\n".join(list)
   
       security.declareProtected('View management screens','editMainData')    
       def editMainData(self,REQUEST=None,RESPONSE=None):
           """edit main data"""
           self.ZCacheable_invalidate()
           argv=REQUEST.form
           
           if not argv.has_key('last_name'):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMainData.zpt')).__of__(self)
               return pt() 
           else:
               self.ZSQLChange(argv,_table="personal_www",_identify="key=%s"%self.getKeyUTF8(),USE_FORM="yes")
               if RESPONSE:
                   self.redirect(RESPONSE,"editMainData")
                   
       security.declareProtected('View management screens','newBibliogrpaphy')    
       def newBibliography(self,_docType=None, _addEntry=None,RESPONSE=None,**argv):
           
           """add an entry to the bibliography"""
           if not _docType: #kein docType
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntryDocType.zpt')).__of__(self)
               return pt() 
           elif _docType and not _addEntry: #doctype aber keine daten
               self.REQUEST['_docType']=_docType
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntry.zpt')).__of__(self)
               return pt() 
           else: #doctype und daten
               try:
                   newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
               except:#id_raw existiert nich, dann neu erzeugen
                   
                   self.createOrUpdateId_raw()
                   newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
                                   
               bookId="b%06i" % newId
               
               self.ZSQLAdd(argv,_table="bibliography",reference_type=_docType,id=bookId)
   
               self.ZSQLAdd(_useRequest=False,_table="publications",id_gen_bib=bookId,key_main=self.getDBId(),publish='yes')
               self.updatePublicationDB(personId=self.getDBId())
               
           
           if RESPONSE:
               self.redirect(RESPONSE,"editPublications")
               
           return True
       
       security.declareProtected('View management screens','editImage')    
       def editImage(self):
           """edit images"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageStaff.zpt')).__of__(self)
           return pt()
       
       security.declareProtected('View management screens','editBibliography')    
       def editBibliography(self):
           """edit the bibliography"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)
           return pt()
       
         
       security.declareProtected('View management screens','editPublications')    
       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.ZCacheable_invalidate()
           self.sortingMode=sortingMode
           
           if RESPONSE and REQUEST:
               self.redirect(RESPONSE,REQUEST['HTTP_REFERER'])
   
           return True
   
       def getSortingMode(self):
           """get sorting mode"""
           mode=getattr(self,'sortingMode','priority')
           if mode=="year":
               return "year DESC"
           else:
               return mode
           
       def integer(self,value):
           try:
               return int(value)
           except:
               return 0
           
       security.declareProtected('View management screens','changePublications')    
       def changePublications(self,RESPONSE=None):
           """change the publication list"""
           self.changeResearch(noredirect=True)
           self.ZCacheable_invalidate()
           #self.updatePublicationDB(personId=self.getDBId())
           self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
           
   
     
       security.declareProtected('View management screens','addPublications')    
       def addPublications(self,submit=None,REQUEST=None,noredirect=None,RESPONSE=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+="(key_main,id_institutsbibliographie,publish) "
               query+="VALUES ('%s','%s','yes')" %(sql_quote(self.getKey()),sql_quote(bibId))
               
               #self.ZSQLAdd(_table="publications",id_institutsbibliographie=bibId,id_main=self.getDBId(),publish='yes')
               self.ZSQLQuery(query)
        
           self.updatePublicationDB(personId=self.getKey())
           
           if not noredirect:
               
               self.redirect(RESPONSE,"./editPublications")
               
               return True
           
       
       def getDBId(self):
           """get id from the personal database"""
           
           #in der neuen version ist definitions gemaess der key der Datenbank gleich dem key im Object.
           # TODO: remove all occurences of getDBId and replaces it by getKey
           return self.getKey()
           
   #        search=self.ZSQLInlineSearch(_table='personal_www',key=self.getKey(),publish_the_data='yes')
   #        if search:#name existiert und published, dann nimm diesen falls es mehrereeventuell nich publizierte datensaetze gibt.
   #            return search[0].id
   #        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
       
       def sortBibliography(self,list,sortingMode=None,max=None):
           if not sortingMode:
               sortingMode=self.getSortingMode()
       
           if sortingMode == "year":
               l= self.sortYear(list)
           else:
               l=self.sortPriority(list)
           
           if max:
               return l[0:min(len(l),max)]
           else:
               return l
           
       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)
   
           if not list:
               return []
           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,RESPONSE=None):
           """delete entry"""
           query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)
   
           self.ZSQLQuery(query)
           self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
           
   
 def manage_addMPIWGStaffForm(self):  def manage_addMPIWGStaffForm(self):
Line 88  def manage_addMPIWGStaff(self,id,lastNam Line 929  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  
changed lines
  Added in v.1.11

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