File:  [Repository] / MPIWGWeb / MPIWGStaff.py
Revision 1.10.2.71: download - view: text, annotated - select for diffs - revision graph
Wed Sep 30 17:08:40 2009 UTC (14 years, 8 months ago) by casties
Branches: r2
add rendering of index.html inside MPWGStaff objects

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

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