Mercurial > hg > MPIWGWeb

comparison MPIWGStaff.py @ 0:bca61e893fcc

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