File:  [Repository] / MPIWGWeb / MPIWGStaff.py
Revision 1.10.2.63: download - view: text, annotated - select for diffs - revision graph
Thu Oct 23 07:53:50 2008 UTC (15 years, 7 months ago) by dwinter
Branches: r2
caches for project added

    1: """This file contains the classes for the organization of the staff"""
    2: # TODO: pruefe ob die id der einzelnen tabellen, wie id in publications noch benutzt werden
    3: # TODO: pruefe ob die bibliographischen felder in publications noch benutzt werden
    4: # TODO: wird username gebraucht?
    5: 
    6: from OFS.Folder import Folder
    7: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
    8: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    9: from Products.PageTemplates.PageTemplate import PageTemplate
   10: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   11: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   12: from Products.versionedFile.extVersionedFile import extVersionedFileFolder
   13: from AccessControl import getSecurityManager
   14: 
   15: import os
   16: import logging
   17: import bibliography
   18: import email
   19: from Globals import package_home
   20: from Products.PythonScripts.standard import sql_quote
   21: from types import *
   22: from AccessControl import ClassSecurityInfo
   23: import time
   24: import logging
   25: import email
   26: import re
   27: from OFS.Cache import Cacheable
   28: 
   29: from MPIWGHelper import *
   30: #ersetzt logging
   31: def logger(txt,method,txt2):
   32:     """logging""" 
   33:     logging.info(txt+ txt2)
   34: 
   35: departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"
   36: 
   37: 
   38: 
   39: 
   40: 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=""):
   41:         """lege person in der datenbank an"""
   42: 
   43:         if date_to=="": # wenn date_to leer
   44:              date_to="date_none"
   45:         
   46:         if date_from=="": # wenn date_fromleer
   47:              date_from="date_none"
   48:         msg=""
   49:         #test ob id schon existiert
   50:         if self.ZSQLQuery("select key from personal_www where key='%s'"%id):
   51:             return False,"ERROR:key%s already exists"%key
   52:         
   53:         #eintragen
   54:         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 """
   55:         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")
   56:         
   57:         insert=[]
   58:         for element in insertTuple:
   59:             if element=="date_none": # date_none eintrag wird zu null uebersetzt
   60:                 insert.append('null')
   61:             else:
   62:                 insert.append("%s"%self.ZSQLQuote(element))
   63:             
   64:         insertStr=",".join(insert)
   65:         queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertStr)
   66:         self.ZSQLQuery("SET DATESTYLE TO 'German'")
   67:         self.ZSQLQuery(queryStr)
   68:         logging.info("QQQQ %s:"%queryStr)
   69:         #currentwork
   70:         #if not (current_work==""):
   71:         #    queryStr="INSERT INTO current_work (key_main,current,publish) VALUES ('%s',%s,'%s')"%(key,self.ZSQLQuote(current_work),"yes")
   72: 
   73:         #  self.ZSQLQuery(queryStr)
   74:         
   75:         return True,msg
   76: class MPIWGStaff(CatalogAware,ZSQLExtendFolder,Cacheable):
   77:     """Staff"""
   78: 
   79:     meta_type="MPIWGStaff"
   80:     default_catalog='MembersCatalog'
   81:     departmentList=departmentList
   82:     security=ClassSecurityInfo()
   83:     
   84:     def redirect(self,RESPONSE,url):
   85:         """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
   86:         
   87:         timeStamp=time.time()
   88:         
   89:         if url.find("?")>-1: #giebt es schon parameter
   90:             addStr="&time=%s"
   91:         else:
   92:             addStr="?time=%s"
   93:             
   94:         RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
   95:         logging.error(email.Utils.formatdate()+' GMT')
   96:         RESPONSE.redirect(url+addStr%timeStamp)
   97:         
   98:     def getKeyUTF8(self):
   99:         """get db_key utf8"""
  100:         return utf8ify(self.getKey())
  101:     
  102:     def getKey(self):
  103:         """get database key"""
  104:         if hasattr(self,'key'):
  105:             #logging.error("SAVED KEY:%s"%self.key)
  106:             return unicodify(self.key.lower())
  107:             #return self.key.lower()
  108:         
  109:         #fuer alt faelle ohne key
  110:         #logging.error("NEW KEY:%s"%(self.firstName+'_'+self.lastName).lower().replace(' ',''))
  111:         return (self.firstName+'_'+self.lastName).lower().replace(' ','')
  112:         
  113:     def getConnectionObj(self):
  114:          """returns connection id (from root)"""
  115:          root = self.getMPIWGRoot()
  116:          return root.getConnectionObj()
  117:         
  118:     def isPublished(self):
  119:         """gib publications status aus der datenbank aus"""
  120:         key=self.getKey()
  121:         query="select count(publish_the_data) from personal_www where lower(key)='%s' and publish_the_data='yes'"%key
  122:         
  123:         res = self.ZSQLQuery(query)
  124:         
  125:         if res and res[0].count>0:
  126:             return True
  127:         else:
  128:             return False
  129:         
  130:  
  131:   
  132:     def updateDBEntry(self,publish_the_data,date_from,date_to,DBid=None,stay_at_mpiwg="",position="",abteilung=""): 
  133:         """zpddatedb"""
  134:         if not DBid:
  135:                     DBid=self.getDBId()
  136:         
  137:  
  138:         self.ZSQLQuery("SET DATESTYLE TO 'German'")
  139: 
  140:         test=self.ZSQLQuery("select id from personal_www where id='%s' "%DBid)
  141: 
  142:         
  143:         if test and (len(test)>0): #dataset exists
  144:             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)
  145:             self.ZSQLChange(_table="personal_www",_identify="id=%s"%DBid,publish_the_data=publish_the_data,
  146:                                    date_from=date_from,
  147:                                    date_to=date_to,stay_at_mpiwg=stay_at_mpiwg,position=position,abteilung=abteilung)
  148:             return True
  149:         else:
  150:             return False
  151:           
  152:     def getPublicationSelectionMode(self):
  153:         """get publication selection mode, default 'priority'"""
  154:         return getattr(self,'publicationSelectionMode','priority')
  155:         
  156:     def changePublicationSelectionMode(self,publicationSelectionMode,RESPONSE=None):
  157:         """change PublicationSelectionMode"""
  158:         
  159:         self.publicationSelectionMode=publicationSelectionMode
  160:         self.ZCacheable_invalidate()
  161:         if RESPONSE:
  162:             self.redirect(RESPONSE,"editPublications")
  163:             
  164:     
  165:     def downloadCV(self,RESPONSE):
  166:         """download cv file"""
  167:         ob=self._getOb("downloadableFiles")._getOb("cv.pdf")
  168:         
  169:         RESPONSE.redirect(ob.absolute_url()+"/download")
  170:     
  171:     def getLastUpdateCV(self):
  172:         """getDate of Last Update"""
  173:         try:
  174:                 ob=self._getOb("downloadableFiles")._getOb("cv.pdf")
  175:                 return ob.getLastChangeDate()
  176:         except:
  177:                 return "No file yet!"
  178:     def getLastUpdatePublications(self):
  179:         """getDate of Last Update"""
  180:         try:
  181:                 ob=self._getOb("downloadableFiles")._getOb("publications.pdf")
  182:                 return ob.getLastChangeDate()
  183:         except:
  184:                 return "No file yet!"
  185:     def downloadPublications(self,RESPONSE):
  186:         """download publications"""
  187:         ob=self._getOb("downloadableFiles")._getOb("publications.pdf")
  188:         
  189:         RESPONSE.redirect(ob.absolute_url()+"/download")
  190:    
  191:     def changeDownloads(self,cv_pdf=None,cv_publish=None,publications_pdf=None,publications_publish=None,RESPONSE=None):
  192:         """"change the downloadable files"""
  193:         self.ZCacheable_invalidate()
  194:         if not hasattr(self,'downloadableFiles'):
  195:            
  196:             extFolder =  extVersionedFileFolder()
  197:             extFolder.id = "downloadableFiles"
  198:             self._setObject(extFolder.id,extFolder)
  199:             
  200:         ob = self._getOb("downloadableFiles")
  201:         
  202:         if cv_publish:
  203:             self.cv_publish=cv_publish
  204:             
  205:         if publications_publish:
  206:             self.publications_publish=publications_publish
  207:             
  208:         if cv_pdf:
  209:             if not hasattr(ob,"cv.pdf"):
  210:                 ob.addFile("",cv_pdf,newName="cv.pdf")
  211:             
  212:             else:
  213:                 cvFile = getattr(ob,"cv.pdf")
  214:                 cvFile.addContentObject("","",file=cv_pdf)
  215:         
  216:         if publications_pdf:
  217:             if not hasattr(ob,"publications.pdf"):
  218:                 ob.addFile("",cv_pdf,newName="publications.pdf")
  219:             
  220:             else:
  221:                 cvFile = getattr(ob,"publications.pdf")
  222:                 cvFile.addContentObject("","",file=publications_pdf)
  223:         
  224:         if RESPONSE:
  225:             self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
  226:     
  227: 
  228:     def getPublishImage(self):
  229:         """publish the image??, default no"""
  230:         return getattr(self,'publishImage','no')
  231:     
  232:     def updateImage(self,file,publishImage,rename=None,RESPONSE=None):
  233:         """update image"""
  234: 
  235:         if file and not(file.filename==""):
  236:             if self.getImageObj():
  237:                               self.getImageObj().updateImage(file,_rename=None,RESPONSE=None)
  238:             else:
  239:                 # create new image object
  240:                 xp = file.filename.rfind('.')
  241:                 if xp > 0:
  242:                     ext = file.filename[xp:]
  243:                     #fn = self.getId()+ext
  244:                     fn = self.getId()
  245:                     logger("MPWIG STAFF", logging.INFO, "new filename: %s"%fn)
  246:                     self.getImageFolder().addImage2(file,fileName=fn)
  247:                 else:
  248:                     logger("MPWIG STAFF", logging.ERROR, "uploaded filename %s has no extension!"%file.filename)
  249:             
  250:         self.publishImage=publishImage
  251:         
  252:         if RESPONSE:
  253:             self.redirect(RESPONSE,"edit")
  254:             
  255:     def getImageFolder(self):
  256:         """getImageFolder"""
  257:         #TODO: make place of staff image folder configurable
  258:         
  259:         try:
  260:             return self.getPhysicalRoot().www_neu.images.staff_images
  261:         except: 
  262:             logger("MPWIG STAFF", logging.ERROR, "image folder not found: has to be add /www_neu/staff_images") 
  263:             return None
  264:         
  265:     def getImageObj(self):
  266:         """getImage"""
  267:         imageFolder=self.getImageFolder()
  268:         
  269:         if not imageFolder: return None
  270:         
  271:         image=getattr(imageFolder,self.getId(),None)
  272: 
  273:         if not image:
  274:             for suffix in ['jpg','tif']:
  275:                 
  276:                 image=getattr(imageFolder,self.getId()+"."+suffix,None)
  277:                 if image:
  278:                     break
  279:         return image
  280:             
  281:     def getImageUrl(self):
  282:         """getImageUrl"""
  283:         image=self.getImageObj()
  284:         if not image:
  285:             return None
  286:         else:
  287:             return self.getImageObj().absolute_url()+"/image"
  288:     
  289:     def PrincipiaSearchSource(self):
  290:         """Return cataloguable key for ourselves."""
  291:         return str(self)
  292: 
  293:     manage_options = Folder.manage_options+(
  294:         {'label':'Edit','action':'changeMPIWGStaffForm'},
  295:         {'label':'Change Publications Special','action':'changePublications_specialForm'},
  296:         ) + Cacheable.manage_options
  297:     
  298:     __manager_id = "ramCache"
  299:     def __init__(self,id, lastName,firstName,key):
  300:         """init"""
  301:         self.id=id
  302:         self.title=key
  303:         self.lastName=lastName
  304:         self.firstName=firstName
  305:         self.key=key
  306:     
  307:     def getPersonID(self):
  308:         """gibt den ID fuer die Person zurueck"
  309:         im Moment ist personID = id, i.e. e-mail
  310:         """
  311:         return self.id
  312: 
  313:     def harvest_page_old(self,context=None):
  314:         """geharvestete seite = verschlankte version von members_main"""
  315:         #pt = getTemplate(self, "harvest_members_main")
  316:         
  317:         if not self.isPublished():
  318:             return ""
  319:         if not context:
  320:             context=self
  321:             
  322:         
  323:         ext=getattr(self,"harvest_members_main",None)
  324:         if ext:
  325:             return getattr(self,ext.getId())()
  326:         
  327:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_members_main')).__of__(context)    
  328: 
  329: 
  330:         return pt()
  331: 
  332:     def harvest_page(self):
  333:         """harvest"""
  334:         if not self.isPublished():
  335:             return ""
  336:         return getattr(self.en.staff.members,self.getId()).index_html()
  337:         
  338:     
  339:     def index_html(self):
  340:         """show homepage"""
  341:     
  342:         bound_names={}
  343:         request = self.REQUEST
  344:         if request is not None:
  345:             response = request.response
  346:             if not response.headers.has_key('content-type'):
  347:                 response.setHeader('content-type', 'text/html')
  348: 
  349:         security = getSecurityManager()
  350:         bound_names['user'] = security.getUser()
  351: 
  352:         # Retrieve the value from the cache.
  353:         keyset = None
  354:         if self.ZCacheable_isCachingEnabled():
  355:             
  356:             # Prepare a cache key.
  357:             keyset = {'here': self}
  358:                       
  359:             result = self.ZCacheable_get(keywords=keyset)
  360:            
  361:             if result is not None:
  362:                 # Got a cached value.
  363:                 return result
  364:       
  365:         pt = getTemplate(self, "members_main")
  366:          # Execute the template in a new security context.
  367:         security.addContext(self)
  368: 
  369:         try:
  370:             result = pt.pt_render(extra_context=bound_names)
  371:             if keyset is not None:
  372:                 # Store the result in the cache.
  373:                 self.ZCacheable_set(result, keywords=keyset)
  374:                
  375:             return result
  376:         finally:
  377:             security.removeContext(self)
  378:        
  379: 
  380:    
  381:     def changePublications_specialForm(self):
  382:         """Priority publications manual field"""
  383:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changePublications_special.zpt')).__of__(self)
  384:         return pt()
  385:         
  386:     def changePublications_special(self,usePublicationsSpecial=None,specialPublicationsField=None,RESPONSE=None):
  387:         """change publications special params"""
  388:         self.ZCacheable_invalidate()
  389:         if usePublicationsSpecial:
  390:           self.usePublicationsSpecial=True
  391:          
  392:         else:
  393:           self.usePublicationsSpecial=False
  394: 
  395:         self.specialPublicationsField=specialPublicationsField[0:]
  396: 
  397:         if RESPONSE is not None:
  398:             self.redirect(RESPONSE,'manage_main')
  399: 
  400:         
  401:     def publications_full(self):
  402:         """show publication"""
  403:         pt=getTemplate(self, "publications_full_main")
  404:         return pt()
  405: 
  406:     def talks_full(self):
  407:         """show talks"""
  408:         pt=getTemplate(self, 'talks_full_main')
  409:         return pt()
  410: 
  411:     def teaching_full(self):
  412:         """show talks"""
  413:         pt=getTemplate(self, 'teaching_full_main')
  414:         return pt()
  415:     
  416:     def changeMPIWGStaffForm(self):
  417:         """change form"""
  418:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGStaff.zpt')).__of__(self)
  419:         return pt()
  420:     
  421:     security.declareProtected('View management screens','changeMPIWGStaff')
  422:     def changeMPIWGStaff(self,lastName,firstName,key=None,RESPONSE=None):
  423:         """change it"""
  424:         self.ZCacheable_invalidate()
  425:         self.title="%s, %s"%(lastName,firstName)
  426:         self.lastName=lastName
  427:         self.firstName=firstName
  428:         if key:
  429:             self.key = key
  430: 
  431:         if RESPONSE is not None:
  432:             self.redirect(RESPONSE,'manage_main')
  433:             
  434:     security.declareProtected('View management screens','edit')
  435:     def edit(self):
  436:         """Edit the pages"""
  437:         #TODO: zusammenspiel mit apache, redirect auf 18080 rausnehmen bzw. zumindest verallgemeinern
  438:         #if self.REQUEST['SERVER_URL']=="http://www.mpiwg-berlin.mpg.de":
  439:         #        redURL="http://xserve04.mpiwg-berlin.mpg.de:18080/www_neu/de/mitarbeiter/members/%s/edit"%self.getId()
  440:         #
  441:         #        self.REQUEST.RESPONSE.redirect(redURL)
  442: 
  443:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff.zpt')).__of__(self)
  444:         
  445:         
  446:         logging.error("XX:"+email.Utils.formatdate().split("-")[0]+'GMT')
  447:         return pt()
  448: 
  449:     mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff_main.zpt'))
  450:     addPublicationsBib=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublicationsBib.zpt'))
  451: 
  452:     def getPathStyle(self, path, selected, style=""):
  453:         """returns a string with the given style + 'sel' if path == selected."""
  454: 
  455:         if path == selected:
  456:             return style + 'sel'
  457:         else:
  458:             return style    
  459: 
  460: 
  461:     def getLabel(self):
  462:         """returns a label for this object"""
  463:         return self.title
  464: 
  465:     def getBreadcrumbs(self):
  466:         """return list of breadcrumbs from here to the root"""
  467:         crumbs = []
  468:         # skip direct parent Folder /members/
  469:         parent = self.aq_parent.aq_parent
  470:         # get parents breadcrumbs
  471:         logging.debug("getbreadcrumbs-: title=%s self=%s parent=%s"%(self.title, repr(self), repr(parent)))
  472:         if hasattr(parent, 'getBreadcrumbs'):
  473:             logging.debug("getbreadcrumbs: recurse to %s"%parent)
  474:             crumbs = parent.getBreadcrumbs()
  475:         
  476:         # try to get acquisition URL from parent
  477:         if hasattr(parent, 'absolute_url'):
  478:             baseUrl = "%s/%s/"%(parent.absolute_url(), 'members')
  479:         else:
  480:             baseUrl = "/en/staff/members/"
  481:             
  482:         # add this
  483:         crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
  484:             
  485:         return crumbs
  486: 
  487: 
  488:     def changeCurrentWork(self,current_work,key,publish="yes",RESPONSE=None):
  489:         """change current work"""
  490:         
  491:         query="UPDATE personal_www SET current_work =%s WHERE key='%s'"
  492:          
  493:         self.ZSQLQuery(query%(self.ZSQLQuote(current_work),key))
  494:        
  495:         query="UPDATE personal_www SET current_work_p =%s WHERE key='%s'"
  496:          
  497:         self.ZSQLQuery(query%(self.ZSQLQuote(publish),key))
  498:         self.ZCacheable_invalidate()
  499:         if RESPONSE:
  500:             self.redirect(RESPONSE,"edit")
  501:         
  502:     security.declareProtected('View management screens','changeResearch')
  503:     def changeResearch(self,noredirect=None,RESPONSE=None):
  504:         """change the research entries"""
  505:         self.ZCacheable_invalidate()
  506:         newEntries={}
  507:         key_main=self.REQUEST.form['key_main']
  508: 
  509:         mainfieldL=self.REQUEST.form['main_fields'].split(",")
  510:         mainfield={}
  511:         for x in mainfieldL:
  512:             tmp=x.split('__')
  513:             mainfield[tmp[0]]=tmp[1]
  514:         for field in self.REQUEST.form.keys():
  515:             splittedField=field.split("__")
  516:             if len(splittedField)<3:
  517:                 pass #kein datenbank eintrag
  518: 
  519:             elif splittedField[2]=='new': # store new entries
  520:                 if not newEntries.has_key(splittedField[0]):
  521:                     newEntries[splittedField[0]]={}
  522:                     
  523:                 newEntries[splittedField[0]][splittedField[1]]=self.REQUEST.form[field]
  524: 
  525:             else:
  526:                 query="UPDATE %s "%splittedField[0]
  527:                 query+="SET %s = '%s' "%(splittedField[1],sql_quote(self.REQUEST.form[field]))
  528:                 query+="WHERE oid = '%s' "%sql_quote(splittedField[2])
  529:                 
  530:                 self.ZSQLQuery(query)
  531: 
  532: 
  533:         #new entries
  534:         for newEntry in newEntries.keys():
  535:             query="INSERT INTO %s "%newEntry
  536:             keys=['key_main']
  537:             values=["'"+sql_quote(key_main)+"'"]
  538:             for key in newEntries[newEntry].keys():
  539:                 keys.append(key)
  540:                 values.append("'"+sql_quote(newEntries[newEntry][key])+"'")
  541: 
  542: 
  543:             keystring=",".join(keys)
  544:                 
  545:             valuestring=",".join(values)
  546:                 
  547:             query+=" (%s) "%keystring
  548:             query+="VALUES (%s)"%valuestring
  549:             if not (newEntries[newEntry][mainfield[newEntry]].lstrip().rstrip()==""):
  550:                 self.ZSQLQuery(query)
  551: 
  552:         if not noredirect:
  553:             self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
  554:             
  555:     security.declareProtected('View management screens','editCV')    
  556:     def editCV(self,cv=None,oid=None,RESPONSE=None):
  557:          """edit Cv"""
  558: 
  559:          if (not oid):
  560:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editCV.zpt')).__of__(self)
  561:              return pt()
  562:         
  563:          query="UPDATE personal_www SET cv =%s WHERE oid='%s'"
  564:          self.ZCacheable_invalidate()
  565:          self.ZSQLQuery(query%(self.ZSQLQuote(cv),oid))
  566:         
  567:          if RESPONSE:
  568:             self.redirect(RESPONSE,"editCV")
  569:             
  570:     
  571:     def getProfile(self):
  572:         """get the profile"""
  573: 	self.REQUEST.RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
  574:       
  575:         founds=self.ZSQLInlineSearchU(_table='personal_www',key=self.getKey())
  576:         html="""<html><body>%s</body></html>"""
  577:         if founds.profile and founds.profile != "":
  578:            
  579:             return html%founds.profile
  580:         else:
  581:                         
  582:             return html%self.generateProfileForPerson(founds)
  583:             
  584:     def editProfile(self,oid=None,RESPONSE=None, kupu=None, preview=None):
  585:          """edit Profile, new entry replaces CD, current work and research interests"""
  586:         
  587:          if (not oid):
  588:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editProfile.zpt')).__of__(self)
  589:              return pt()
  590:         
  591:          self.ZCacheable_invalidate() 
  592:          
  593:          
  594:          if preview:
  595:              pass
  596:              #TODO: not supported yet
  597:              #kupu=preview
  598:              # find content of body tags
  599:         
  600:          start=kupu.find("<body>")
  601:          end=kupu.find("</body>")
  602:          
  603:          newcontent= kupu[start+6:end]
  604:             
  605:             
  606:          
  607:         
  608:          if preview: 
  609:             #TODO: not supported yet
  610:             if RESPONSE:
  611:                 self.redirect(RESPONSE,"editProfile")
  612:             
  613:             #return self.preview(newcontent)
  614: 
  615:          query="UPDATE personal_www SET profile=%s WHERE oid='%s'"       
  616:          self.ZSQLQuery(query%(self.ZSQLQuote(newcontent),oid))
  617:          logging.error("PROFILE:"+query%(self.ZSQLQuote(newcontent),oid))
  618:          if RESPONSE:
  619:             self.redirect(RESPONSE,"editProfile")
  620: 
  621: 
  622: 
  623:     def generateProfileForPerson(self,person):
  624:         """erzeugt ein automatisches Profil aus den alten Eintraegen  CV, Current work, und research interests"""
  625:         
  626:         ret=""
  627:         founds=self.ZSQLInlineSearch(_table='research_interest',key_main=person.key)
  628:         if founds:
  629:             ret="<p class=\"bio_section_header\">Research interests: </p><br/>"
  630:         for found in self.sortPriority(founds):
  631:             ret+=found.interest+"<br/>"
  632:         
  633:         
  634:         if (person.current_work) and (not person.current_work==""):
  635:             ret+="<p class=\"bio_section_header\">Current work: </p><br/>"
  636:       
  637:             ret+=person.current_work+"<br/>"
  638:     	if (person.cv) and (not person.cv==""):
  639:             ret+="<p class=\"bio_section_header\">Curriculum Vitae: </p><br/>"
  640: 	    ret+=self.formatAscii(person.cv)
  641:         
  642:         return ret
  643:     security.declareProtected('View management screens','editDownloads')
  644:     def editDownloads(self):    
  645:         """editiere die Downloads von der Webseite"""
  646:         
  647:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editDownloads.zpt')).__of__(self)
  648:         return pt()
  649:     
  650:     security.declareProtected('View management screens','editAdditionalLinks.zpt')
  651:     def editAdditionalLinks(self):    
  652:         """editiere die Downloads von der Webseite"""
  653:         
  654:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAdditionalLinks.zpt')).__of__(self)
  655:         return pt()
  656:     
  657:     
  658:     security.declareProtected('View management screens','editAwards')    
  659:     def editAwards(self,awards=None,oid=None,RESPONSE=None):
  660:          """edit a awards"""
  661:      
  662:          if (not oid):
  663:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)
  664:              return pt()
  665:          self.ZCacheable_invalidate()
  666:          query="UPDATE personal_www SET awards =%s WHERE oid='%s'"
  667:       
  668:          self.ZSQLQuery(query%(self.ZSQLQuote(awards),oid))
  669:         
  670:          if RESPONSE:
  671:             self.redirect(RESPONSE,"editAwards")
  672: 
  673:     security.declareProtected('View management screens','editTalks')    
  674:     def editTalks(self):
  675:         """edit talks"""
  676: 
  677:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)
  678:         return pt()
  679:         
  680:     security.declareProtected('View management screens','editTeaching')    
  681:     def editTeaching(self):
  682:         """edit Teaching"""
  683: 
  684:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTeaching.zpt')).__of__(self)
  685:         return pt()
  686:         
  687:     def getDocTypes(self):
  688:         finds = self.ZopeFind(self.metadata.main.meta.bib,obj_metatypes=["OSAS_MetadataMapping__neu"])
  689: 
  690:         list= [x[0] for x in finds]
  691:         return "\n".join(list)
  692: 
  693:     security.declareProtected('View management screens','editMainData')    
  694:     def editMainData(self,REQUEST=None,RESPONSE=None):
  695:         """edit main data"""
  696:         self.ZCacheable_invalidate()
  697:         argv=REQUEST.form
  698:         
  699:         if not argv.has_key('last_name'):
  700:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMainData.zpt')).__of__(self)
  701:             return pt() 
  702:         else:
  703:             self.ZSQLChange(argv,_table="personal_www",_identify="key=%s"%self.getKey(),USE_FORM="yes")
  704:             if RESPONSE:
  705:                 self.redirect(RESPONSE,"editMainData")
  706:                 
  707:     security.declareProtected('View management screens','newBibliogrpaphy')    
  708:     def newBibliography(self,_docType=None, _addEntry=None,RESPONSE=None,**argv):
  709:         
  710:         """add an entry to the bibliography"""
  711:         if not _docType: #kein docType
  712:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntryDocType.zpt')).__of__(self)
  713:             return pt() 
  714:         elif _docType and not _addEntry: #doctype aber keine daten
  715:             self.REQUEST['_docType']=_docType
  716:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntry.zpt')).__of__(self)
  717:             return pt() 
  718:         else: #doctype und daten
  719:             try:
  720:                 newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
  721:             except:#id_raw existiert nich, dann neu erzeugen
  722:                 
  723:                 self.createOrUpdateId_raw()
  724:                 newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
  725:                                 
  726:             bookId="b%06i" % newId
  727:             
  728:             self.ZSQLAdd(argv,_table="bibliography",reference_type=_docType,id=bookId)
  729: 
  730:             self.ZSQLAdd(_useRequest=False,_table="publications",id_gen_bib=bookId,key_main=self.getDBId(),publish='yes')
  731:             self.updatePublicationDB(personId=self.getDBId())
  732:             
  733:         
  734:         if RESPONSE:
  735:             self.redirect(RESPONSE,"editPublications")
  736:             
  737:         return True
  738:     
  739:     security.declareProtected('View management screens','editImage')    
  740:     def editImage(self):
  741:         """edit images"""
  742:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageStaff.zpt')).__of__(self)
  743:         return pt()
  744:     
  745:     security.declareProtected('View management screens','editBibliography')    
  746:     def editBibliography(self):
  747:         """edit the bibliography"""
  748:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)
  749:         return pt()
  750:     
  751:       
  752:     security.declareProtected('View management screens','editPublications')    
  753:     def editPublications(self):
  754:         """edit the bibliographie"""
  755: 
  756:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editPublications.zpt')).__of__(self)
  757:         return pt()
  758:     
  759:     def changeSortingMode(self,sortingMode,RESPONSE=None,REQUEST=None):
  760:         """change sorting mode"""
  761:         self.ZCacheable_invalidate()
  762:         self.sortingMode=sortingMode
  763:         
  764:         if RESPONSE and REQUEST:
  765:             self.redirect(RESPONSE,REQUEST['HTTP_REFERER'])
  766: 
  767:         return True
  768: 
  769:     def getSortingMode(self):
  770:         """get sorting mode"""
  771:         mode=getattr(self,'sortingMode','priority')
  772:         if mode=="year":
  773:             return "year DESC"
  774:         else:
  775:             return mode
  776:         
  777:     def integer(self,value):
  778:         try:
  779:             return int(value)
  780:         except:
  781:             return 0
  782:         
  783:     security.declareProtected('View management screens','changePublications')    
  784:     def changePublications(self,RESPONSE=None):
  785:         """change the publication list"""
  786:         self.changeResearch(noredirect=True)
  787:         self.ZCacheable_invalidate()
  788:         #self.updatePublicationDB(personId=self.getDBId())
  789:         self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
  790:         
  791: 
  792:   
  793:     security.declareProtected('View management screens','addPublications')    
  794:     def addPublications(self,submit=None,REQUEST=None,noredirect=None,RESPONSE=None):
  795:         """add publications"""
  796: 
  797:         #setzte flag ob aufruf aus suchformular
  798:         
  799:         if REQUEST.get("QUERY_STRING",None) and (not submit):
  800:             self.REQUEST.set('fromSearch','1')
  801:         else:
  802:             self.REQUEST.set('fromSearch','0')
  803:              
  804:         if not submit or (not (submit == "add")):
  805:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublications.zpt')).__of__(self)
  806:             return pt()
  807:         
  808:         #new entries
  809:         entries = REQUEST.form.get('addEntries',None)
  810:         if not (type(entries) is ListType):
  811:             entries=[entries]
  812:         
  813:         
  814:         for bibId in entries: 
  815:             query="INSERT INTO %s " % "publications"
  816:             query+="(key_main,id_institutsbibliographie,publish) "
  817:             query+="VALUES ('%s','%s','yes')" %(sql_quote(self.getKey()),sql_quote(bibId))
  818:             
  819:             #self.ZSQLAdd(_table="publications",id_institutsbibliographie=bibId,id_main=self.getDBId(),publish='yes')
  820:             self.ZSQLQuery(query)
  821:      
  822:         self.updatePublicationDB(personId=self.getKey())
  823:         
  824:         if not noredirect:
  825:             
  826:             self.redirect(RESPONSE,"./editPublications")
  827:             
  828:             return True
  829:         
  830:     
  831:     def getDBId(self):
  832:         """get id from the personal database"""
  833:         
  834:         #in der neuen version ist definitions gemaess der key der Datenbank gleich dem key im Object.
  835:         # TODO: remove all occurences of getDBId and replaces it by getKey
  836:         return self.getKey()
  837:         
  838: #        search=self.ZSQLInlineSearch(_table='personal_www',key=self.getKey(),publish_the_data='yes')
  839: #        if search:#name existiert und published, dann nimm diesen falls es mehrereeventuell nich publizierte datensaetze gibt.
  840: #            return search[0].id
  841: #        else:#nicht publiziert dann nimm einen davon
  842: #            search2=self.ZSQLInlineSearch(_table='personal_www',username=self.getId())
  843: #            if search2:
  844: #                return search2[0].id
  845: #            else:
  846: #                return None
  847:         
  848:     
  849:     
  850:     formatBiblHelp=bibliography.formatBiblHelp
  851:     
  852:     def sortBibliography(self,list,sortingMode=None,max=None):
  853:         if not sortingMode:
  854:             sortingMode=self.getSortingMode()
  855:     
  856:         if sortingMode == "year":
  857:             l= self.sortYear(list)
  858:         else:
  859:             l=self.sortPriority(list)
  860:         
  861:         if max:
  862:             return l[0:min(len(l),max)]
  863:         else:
  864:             return l
  865:         
  866:     def sortPriority(self,list):
  867:         def sort(x,y):
  868:             try:
  869:                 xInt=int(x.priority)
  870:             except:
  871:                 xInt=0
  872:             try:
  873:                 yInt=int(y.priority)
  874:             except:
  875:                 yInt=0
  876: 
  877:             return cmp(xInt,yInt)
  878: 
  879:         if not list:
  880:             return []
  881:         tmp=[x for x in list]
  882:         tmp.sort(sort)           
  883:         
  884:         return tmp
  885: 
  886:     def sortYear(self,list):
  887:         #TODO: sort TO APPEAR and TO BE PUBLISHED etc...
  888:         
  889:         def sort(x,y):
  890:             try:
  891:                 xInt=int(x.year)
  892:             except:
  893:                 xInt=0
  894:             try:
  895:                 yInt=int(y.year)
  896:             except:
  897:                 yInt=0
  898: 
  899:             return cmp(yInt,xInt)
  900:             
  901:             
  902:         tmp=[x for x in list]
  903:         
  904:         tmp.sort(sort)           
  905:         return tmp
  906:     
  907:     def deleteField(self,table,oid,RESPONSE=None):
  908:         """delete entry"""
  909:         query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)
  910: 
  911:         self.ZSQLQuery(query)
  912:         self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
  913:         
  914:     
  915: def manage_addMPIWGStaffForm(self):
  916:     """form for adding the project"""
  917:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGStaffForm.zpt')).__of__(self)
  918:     return pt()
  919: 
  920: def manage_addMPIWGStaff(self,id,lastName,firstName,RESPONSE=None):
  921:     """add it"""
  922:     newObj=MPIWGStaff(id,lastName,firstName)
  923: 
  924:     self._setObject(id,newObj)
  925: 
  926: 
  927:     if RESPONSE is not None:
  928:         self.redirect(RESPONSE,'manage_main')
  929: 
  930:     

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