File:  [Repository] / MPIWGWeb / MPIWGStaff.py
Revision 1.10.2.66: download - view: text, annotated - select for diffs - revision graph
Fri Apr 17 14:29:13 2009 UTC (15 years, 2 months ago) by dwinter
Branches: r2
bug in getconnectionid
(only work around)

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

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