|
2
|
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
|
