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