orm2.ui.ORMMode.ORMMode

253 """ 254 This object type allows you to call ORM 'mode' functions from within 255 your Zope application. 256 """ 257 258 meta_type = "ORM Mode" 259 manage_main = PageTemplateFile("www/ORMMode.pt", globals()) 260 261 manage_options = ( 262 ( 263 {"label": "Edit", "action": "manage_main"}, 264 {"label": "Test", "action": "test"}, 265 {"label": "Security", "action": "manage_access"} 266 ) + Item.manage_options + Cacheable.manage_options ) 267 268 # The same permissions like External Methods 269 __ac_permissions__ = ( 270 ('View management screens', ('manage_main',)), 271 ('Change External Methods', ('manage_edit',)), 272 ('Call ORM mode function', ('__call__','index_html')), 273 ) 274 275 ZopeTime=Acquired 276 HelpSys=Acquired 277 278 security = ClassSecurityInfo() 279

280 - def __init__(self, id, module_name, mode_function_name, 281 db_connection_name, db_charset, session_on, 282 path_variables_on, path_variables, 283 REQUEST=None):

284 self.id = id 285 self.manage_edit(module_name, mode_function_name, 286 db_connection_name, db_charset, session_on, 287 path_variables_on, path_variables, 288 REQUEST)

289

290 - def manage_edit(self, module_name, mode_function_name, 291 db_connection_name, db_charset, session_on=False, 292 path_variables_on=False, path_variables="", 293 REQUEST=None):

294 """ 295 Modify the ORMMode object. 296 """ 297 298 if getattr(self, "_module_name", 299 None) != module_name: 300 self._module_name = module_name 301 self._v_module = None 302 self.module() 303 304 if getattr(self, "_mode_function_name", 305 None) != mode_function_name: 306 self._mode_function_name = mode_function_name 307 self._v_mode_functions = {} 308 self.mode_function() 309 310 self._db_connection_name = db_connection_name 311 self._db_charset = db_charset 312 313 self._session_on = session_on 314 315 self._path_variables_on = path_variables_on 316 self._path_variables = split(path_variables, "/") 317 318 self.ZCacheable_invalidate() 319 320 if REQUEST is not None: 321 message="ORM Mode updated." 322 return self.manage_main(self, REQUEST, manage_tabs_message=message)

323 324

325 - def __call__(self, *args, **kw):

326 """ 327 Call the mode function and do cache management. 328 """ 329 result = self.ZCacheable_get(default=None) 330 331 if result is None: 332 data = self.om_exec(*args, **kw) 333 mime_type = self.REQUEST.RESPONSE.headers.get( 334 "content-type", "text/plain") 335 self.ZCacheable_set(data=(data, mime_type)) 336 else: 337 data, mime_type = result 338 self.REQUEST.RESPONSE.setHeader("Content-Type", mime_type) 339 340 return data

341 342

343 - def om_exec(self, *args, **kw):

344 formdata = kw 345 346 # figure out which charset was used to post the formdata. 347 # This assumes, that the charset of the last REQUEST is the 348 # same as that of the RESPONSE. 349 # The data is actually sent url encoded and Zope converts it 350 # to a string with a specific charset somewhere. I was unable 351 # to figure out where and this is the best thing I came up 352 # with... :-( 353 354 # from ZPublisher/HTTPResponse.py 355 356 encoding = sys.getdefaultencoding() # reasonable default 357 358 # Try to figure out which encoding the request uses 359 if self.REQUEST.RESPONSE.headers.has_key('content-type'): 360 match = charset_re.match( 361 self.REQUEST.RESPONSE.headers['content-type']) 362 if match: 363 encoding = match.group(1) 364 365 # REQUEST contains tons of stuff that has not been passed by the 366 # browser but which needs to be calculated for each request. 367 # This is sorted out here. 368 for key in self.REQUEST.keys(): 369 if unwanted_request_keys.has_key(key): 370 continue 371 else: 372 value = self.REQUEST[key] 373 374 # convert to Unicode using sys.defaultencoding(). 375 # This must be set properly 376 if type(value) == StringType: 377 try: 378 value = unicode(value, encoding) 379 except UnicodeDecodeError: 380 pass 381 382 formdata[key] = value 383 384 385 ds = self._ds() 386 387 # put together the stuff needed by the mode functions 388 formdata["ds"] = ds 389 formdata["base_url"] = self.absolute_url() 390 formdata["request"] = self.REQUEST 391 formdata["response"] = self.REQUEST.RESPONSE 392 formdata["REQUEST"] = self.REQUEST 393 formdata["RESPONSE"] = self.REQUEST.RESPONSE 394 formdata["context"] = self.aq_parent 395 formdata["header"] = _header(self.REQUEST.RESPONSE) 396 formdata["form"] = formdata.copy() 397 formdata["formdata"] = formdata["form"] 398 399 if self.session_on(): 400 formdata["session"] = self.REQUEST.SESSION 401 402 #if self.mode_function_name(): 403 # mode = self.mode_function_name() 404 #else: 405 406 mode = formdata.get("mode", self.mode_function_name()) 407 408 function = self.mode_function(mode) 409 410 ret = function(*args, **formdata) 411 412 # dispose any uncommitted transactions from the current ds 413 # that hace not been commited. 414 if ds is not None: 415 ds.rollback() 416 417 return ret

418

419 - def session_on(self):

420 """ 421 Return True if this adapter provied the mode functions with a 422 session object 423 """ 424 return self._session_on

425

426 - def path_variables_on(self):

427 """ 428 Accessor. 429 """ 430 # use getattr() to ensure backward compatibility 431 # (I'd hate to redo all these objects! ;-) 432 return getattr(self, "_path_variables_on", False)

433

434 - def path_variables(self):

435 """ 436 Accessor. 437 """ 438 # use getattr() to ensure backward compatibility 439 # (I'd hate to redo all these objects! ;-) 440 return join(getattr(self, "_path_variables", []), "/")

441

442 - def module_name(self):

443 """ 444 Accessor. Return the name of the Python module where the 445 mode function resides. 446 """ 447 return self._module_name

448

449 - def mode_function_name(self):

450 """ 451 Accessor. Return the name of the mode function. 452 """ 453 return self._mode_function_name

454

455 - def db_connection_name(self):

456 """ 457 Return the name of the databse connection used for this 458 mode. 459 """ 460 return self._db_connection_name

461

462 - def db_charset(self):

463 """ 464 Accessor. 465 """ 466 return self._db_charset

467

468 - def _ds(self):

469 """ 470 Return an ORM datasource object or None if self._db_connection_name 471 is not set. 472 """ 473 if self._db_connection_name: 474 # FIXME: Currently this only works with PostgreSQL. 475 # We need to figure out a way of telling what kind of 476 # database connection we're dealing with so we know what 477 # kind of orm.datasource we need to create. 478 479 ds = zpsycopg_db_conn(self.aq_parent, 480 self.db_connection_name(), 481 self.db_charset()) 482 return ds 483 else: 484 return None

485

486 - def module(self):

487 """ 488 Return the module object of the modes module 489 """ 490 module = getattr(self, "_v_module", None) 491 if module is None: 492 name = self.module_name() 493 try: 494 module = __import__(name, globals(), locals(), 495 split(name, ".")[1:]) 496 497 # Save the modification time of the file, the module 498 # is loaded from 499 if DevelopmentMode: 500 self._v_module_mtime = self._module_mtime(module) 501 502 except ImportError, e: 503 msg = "Error importing module %s: %s" % (name, str(e)) 504 raise NoSuchModule(msg) 505 506 self._v_module = module 507 else: 508 # If the file the module has been loaded from has been modified 509 # reload the module and reset the mode functions dict. 510 if DevelopmentMode: 511 512 # print >> sys.stderr, "Module modification times", self._v_module_mtime, self._module_mtime(self._v_module) 513 514 if self._v_module_mtime != self._module_mtime(self._v_module): 515 print >> sys.stderr, "reloading ", self._v_module 516 reload(self._v_module) 517 self._v_module_mtime = self._module_mtime(self._v_module) 518 self._v_mode_functions = {} 519 520 # A modes module may provide a special function, 521 # __reload__(), which is called each time we reload the 522 # module. It may then reload modules the mode module 523 # is depending on. Use with care and watch recursion ;-) 524 # 525 # This calles for a generic mechanism to reload modules 526 # on demand i.e. when they have been modified. 527 reload_function = getattr(self._v_module, "__reload__", 528 None) 529 if reload_function is not None: 530 reload_function() 531 532 533 return self._v_module

534

535 - def mode_function(self, name=None):

536 """ 537 Return the mode_function function object 538 """ 539 if name is None: name = self.mode_function_name() 540 541 # Perform a check of the module's source file date if in 542 # development mode 543 if DevelopmentMode: self.module() 544 545 functions_dict = getattr(self, "_v_mode_functions", {}) 546 547 if functions_dict.has_key(name): 548 return functions_dict[name] 549 else: 550 module = self.module() 551 if not module.__dict__.has_key(name): 552 msg = "No Such function %s:" % (name) 553 raise NoSuchFunction(msg) 554 else: 555 functions_dict[name] = module.__dict__[name] 556 557 self._v_mode_functions = functions_dict 558 return functions_dict[name]

559 560

561 - def _module_mtime(self, module):

562 """ 563 Return the modification time of the module's source(!) file. 564 The time is returned as the number of seconds since the epoch. 565 """ 566 module_file = module.__file__ 567 568 # look at the .py file instead of .pyc 569 parts = split(module_file, ".") 570 fname = join(parts[:-1], ".") 571 try: 572 py_file = fname + ".py" 573 py_mtime = os.stat(py_file).st_mtime 574 except OSError: 575 py_mtime = 0 576 577 try: 578 pyc_file = fname + ".pyc" 579 pyc_mtime = os.stat(pyc_file).st_mtime 580 except OSError: 581 pyc_mtime = 0 582 583 return max(py_mtime, pyc_mtime)

584 585

586 - def __before_publishing_traverse__(self, object, REQUEST):

587 if self.path_variables_on(): 588 # if one of our mathods is called ... 589 if len(REQUEST.path) > 0 and \ 590 hasattr(object, REQUEST.path[0]): 591 return 592 else: 593 path = REQUEST.path[:] # a copy of the path. With the current 594 # implementation of Zope this is not 595 # necessary, but just in case the Zope 596 # team changes things... 597 # See: BaseRequest.traverse() method 598 599 for variable in self._path_variables: 600 try: 601 value = path.pop() 602 try: 603 value = unicode(value) 604 except UnicodeDecodeError: 605 try: 606 value = unicode(value, "iso-8859-1") 607 except UnicodeDecodeError: 608 value = unicode(repr(value)) 609 610 REQUEST.set(variable, value) 611 except IndexError: # IndexError: pop from empty list 612 pass 613 614 # Stop traversal of the path 615 REQUEST['TraversalRequestNameStack'] = []

616

617 - def index_html(self, *args, **kw):

618 "Just call self" 619 return self(*args, **kw)

620

621 - def PUT(self, *args, **kw):

622 "Just call self" 623 return self(*args, **kw)

Source Code for Module orm2.ui.ORMMode.ORMMode