CRM/Core/Controller.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.4                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2013                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26 */
  27
  28 /**
  29  * This class acts as our base controller class and adds additional
  30  * functionality and smarts to the base QFC. Specifically we create
  31  * our own action classes and handle the transitions ourselves by
  32  * simulating a state machine. We also create direct jump links to any
  33  * page that can be used universally.
  34  *
  35  * This concept has been discussed on the PEAR list and the QFC FAQ
  36  * goes into a few details. Please check
  37  * http://pear.php.net/manual/en/package.html.html-quickform-controller.faq.php
  38  * for other useful tips and suggestions
  39  *
  40  * @package CRM
  41  * @copyright CiviCRM LLC (c) 2004-2013
  42  * $Id$
  43  *
  44  */
  45
  46 require_once 'HTML/QuickForm/Controller.php';
  47 require_once 'HTML/QuickForm/Action/Direct.php';
  48
  49 class CRM_Core_Controller extends HTML_QuickForm_Controller {
  50
  51   /**
  52    * the title associated with this controller
  53    *
  54    * @var string
  55    */
  56   protected $_title;
  57
  58   /**
  59    * The key associated with this controller
  60    *
  61    * @var string
  62    */
  63   public $_key;
  64
  65   /**
  66    * the name of the session scope where values are stored
  67    *
  68    * @var object
  69    */
  70   protected $_scope;
  71
  72   /**
  73    * the state machine associated with this controller
  74    *
  75    * @var object
  76    */
  77   protected $_stateMachine;
  78
  79   /**
  80    * Is this object being embedded in another object. If
  81    * so the display routine needs to not do any work. (The
  82    * parent object takes care of the display)
  83    *
  84    * @var boolean
  85    */
  86   protected $_embedded = FALSE;
  87
  88   /**
  89    * After entire form execution complete,
  90    * do we want to skip control redirection.
  91    * Default - It get redirect to user context.
  92    *
  93    * Useful when we run form in non civicrm context
  94    * and we need to transfer control back.(eg. drupal)
  95    *
  96    * @var boolean
  97    */
  98   protected $_skipRedirection = FALSE;
  99
 100   /**
 101    * Are we in print mode? if so we need to modify the display
 102    * functionality to do a minimal display :)
 103    *
 104    * @var boolean
 105    */
 106   public $_print = 0;
 107
 108   /**
 109    * Should we generate a qfKey, true by default
 110    *
 111    * @var boolean
 112    */
 113   public $_generateQFKey = TRUE;
 114
 115   /**
 116    * QF response type
 117    */
 118   public $_QFResponseType = 'html';
 119
 120   /**
 121    * cache the smarty template for efficiency reasons
 122    *
 123    * @var CRM_Core_Smarty
 124    */
 125   static protected $_template;
 126
 127   /**
 128    * cache the session for efficiency reasons
 129    *
 130    * @var CRM_Core_Session
 131    */
 132   static protected $_session;
 133
 134   /**
 135    * The parent of this form if embedded
 136    *
 137    * @var object
 138    */
 139   protected $_parent = NULL;
 140
 141   /**
 142    * The destination if set will override the destination the code wants to send it to
 143    *
 144    * @var string;
 145    */
 146   public $_destination = NULL;
 147
 148   /**
 149    * The entry url for a top level form or wizard. Typically the URL with a reset=1
 150    * used to redirect back to when we land into some session wierdness
 151    *
 152    * @var string
 153    */
 154   public $_entryURL = NULL;
 155
 156   /**
 157    * All CRM single or multi page pages should inherit from this class.
 158    *
 159    * @param string  title        descriptive title of the controller
 160    * @param boolean whether      controller is modal
 161    * @param string  scope        name of session if we want unique scope, used only by Controller_Simple
 162    * @param boolean addSequence  should we add a unique sequence number to the end of the key
 163    * @param boolean ignoreKey    should we not set a qfKey for this controller (for standalone forms)
 164    *
 165    * @access public
 166    *
 167    * @return void
 168    *
 169    */
 170   function __construct(
 171     $title = NULL,
 172     $modal = TRUE,
 173     $mode = NULL,
 174     $scope = NULL,
 175     $addSequence = FALSE,
 176     $ignoreKey = FALSE
 177   ) {
 178     // this has to true for multiple tab session fix
 179     $addSequence = TRUE;
 180
 181     // let the constructor initialize this, should happen only once
 182     if (!isset(self::$_template)) {
 183       self::$_template = CRM_Core_Smarty::singleton();
 184       self::$_session = CRM_Core_Session::singleton();
 185     }
 186
 187     // lets try to get it from the session and/or the request vars
 188     // we do this early on in case there is a fatal error in retrieving the
 189     // key and/or session
 190     $this->_entryURL =
 191       CRM_Utils_Request::retrieve('entryURL', 'String', $this);
 192
 193     // add a unique validable key to the name
 194     $name = CRM_Utils_System::getClassName($this);
 195     if ($name == 'CRM_Core_Controller_Simple' && !empty($scope)) {
 196       // use form name if we have, since its a lot better and
 197       // definitely different for different forms
 198       $name = $scope;
 199     }
 200     $name         = $name . '_' . $this->key($name, $addSequence, $ignoreKey);
 201     $this->_title = $title;
 202     if ($scope) {
 203       $this->_scope = $scope;
 204     }
 205     else {
 206       $this->_scope = CRM_Utils_System::getClassName($this);
 207     }
 208     $this->_scope = $this->_scope . '_' . $this->_key;
 209
 210     // only use the civicrm cache if we have a valid key
 211     // else we clash with other users CRM-7059
 212     if (!empty($this->_key)) {
 213       CRM_Core_Session::registerAndRetrieveSessionObjects(array(
 214         "_{$name}_container",
 215           array('CiviCRM', $this->_scope),
 216         ));
 217     }
 218
 219     $this->HTML_QuickForm_Controller($name, $modal);
 220
 221     $snippet = CRM_Utils_Array::value('snippet', $_REQUEST);
 222     if ($snippet) {
 223       if ($snippet == 3) {
 224         $this->_print = CRM_Core_Smarty::PRINT_PDF;
 225       }
 226       elseif ($snippet == 4) {
 227         // this is used to embed fragments of a form
 228         $this->_print = CRM_Core_Smarty::PRINT_NOFORM;
 229         self::$_template->assign('suppressForm', TRUE);
 230         $this->_generateQFKey = FALSE;
 231       }
 232       elseif ($snippet == 5) {
 233         // this is used for popups and inlined ajax forms
 234         // also used for the various tabs via TabHeader
 235         $this->_print = CRM_Core_Smarty::PRINT_NOFORM;
 236       }
 237       elseif ($snippet == 6) {
 238         $this->_print = CRM_Core_Smarty::PRINT_NOFORM;
 239         $this->_QFResponseType = 'json';
 240       }
 241       else {
 242         $this->_print = CRM_Core_Smarty::PRINT_SNIPPET;
 243       }
 244     }
 245
 246    // if the request has a reset value, initialize the controller session
 247     if (CRM_Utils_Array::value('reset', $_GET)) {
 248       $this->reset();
 249
 250       // in this case we'll also cache the url as a hidden form variable, this allows us to
 251       // redirect in case the session has disappeared on us
 252       $this->_entryURL = CRM_Utils_System::makeURL(NULL, TRUE, FALSE, NULL, TRUE);
 253       $this->set('entryURL', $this->_entryURL);
 254     }
 255
 256     // set the key in the session
 257     // do this at the end so we have initialized the object
 258     // and created the scope etc
 259     $this->set('qfKey', $this->_key);
 260
 261
 262     // also retrieve and store destination in session
 263     $this->_destination = CRM_Utils_Request::retrieve(
 264       'civicrmDestination',
 265       'String',
 266       $this,
 267       FALSE,
 268       NULL,
 269       $_REQUEST
 270     );
 271   }
 272
 273   function fini() {
 274     CRM_Core_BAO_Cache::storeSessionToCache(array(
 275       "_{$this->_name}_container",
 276         array('CiviCRM', $this->_scope),
 277       ),
 278       TRUE
 279     );
 280   }
 281
 282   function key($name, $addSequence = FALSE, $ignoreKey = FALSE) {
 283     $config = CRM_Core_Config::singleton();
 284
 285     if (
 286       $ignoreKey ||
 287       (isset($config->keyDisable) && $config->keyDisable)
 288     ) {
 289       return NULL;
 290     }
 291
 292     $key = CRM_Utils_Array::value('qfKey', $_REQUEST, NULL);
 293     if (!$key && $_SERVER['REQUEST_METHOD'] === 'GET') {
 294       $key = CRM_Core_Key::get($name, $addSequence);
 295     }
 296     else {
 297       $key = CRM_Core_Key::validate($key, $name, $addSequence);
 298     }
 299
 300     if (!$key) {
 301       $this->invalidKey();
 302     }
 303
 304     $this->_key = $key;
 305
 306     return $key;
 307   }
 308
 309   /**
 310    * Process the request, overrides the default QFC run method
 311    * This routine actually checks if the QFC is modal and if it
 312    * is the first invalid page, if so it call the requested action
 313    * if not, it calls the display action on the first invalid page
 314    * avoids the issue of users hitting the back button and getting
 315    * a broken page
 316    *
 317    * This run is basically a composition of the original run and the
 318    * jump action
 319    *
 320    */
 321   function run() {
 322     // the names of the action and page should be saved
 323     // note that this is split into two, because some versions of
 324     // php 5.x core dump on the triple assignment :)
 325     $this->_actionName = $this->getActionName();
 326     list($pageName, $action) = $this->_actionName;
 327
 328     if ($this->isModal()) {
 329       if (!$this->isValid($pageName)) {
 330         $pageName = $this->findInvalid();
 331         $action = 'display';
 332       }
 333     }
 334
 335     // note that based on action, control might not come back!!
 336     // e.g. if action is a valid JUMP, u basically do a redirect
 337     // to the appropriate place
 338     $this->wizardHeader($pageName);
 339     return $this->_pages[$pageName]->handle($action);
 340   }
 341
 342   function validate() {
 343     $this->_actionName = $this->getActionName();
 344     list($pageName, $action) = $this->_actionName;
 345
 346     $page = &$this->_pages[$pageName];
 347
 348     $data = &$this->container();
 349     $this->applyDefaults($pageName);
 350     $page->isFormBuilt() or $page->buildForm();
 351     // We use defaults and constants as if they were submitted
 352     $data['values'][$pageName] = $page->exportValues();
 353     $page->loadValues($data['values'][$pageName]);
 354     // Is the page now valid?
 355     if (TRUE === ($data['valid'][$pageName] = $page->validate())) {
 356       return TRUE;
 357     }
 358     return $page->_errors;
 359   }
 360
 361   /**
 362    * Helper function to add all the needed default actions. Note that the framework
 363    * redefines all of the default QFC actions
 364    *
 365    * @param string   directory to store all the uploaded files
 366    * @param array    names for the various upload buttons (note u can have more than 1 upload)
 367    *
 368    * @access private
 369    *
 370    * @return void
 371    *
 372    */
 373   function addActions($uploadDirectory = NULL, $uploadNames = NULL) {
 374     $names = array(
 375       'display' => 'CRM_Core_QuickForm_Action_Display',
 376       'next' => 'CRM_Core_QuickForm_Action_Next',
 377       'back' => 'CRM_Core_QuickForm_Action_Back',
 378       'process' => 'CRM_Core_QuickForm_Action_Process',
 379       'cancel' => 'CRM_Core_QuickForm_Action_Cancel',
 380       'refresh' => 'CRM_Core_QuickForm_Action_Refresh',
 381       'reload' => 'CRM_Core_QuickForm_Action_Reload',
 382       'done' => 'CRM_Core_QuickForm_Action_Done',
 383       'jump' => 'CRM_Core_QuickForm_Action_Jump',
 384       'submit' => 'CRM_Core_QuickForm_Action_Submit',
 385     );
 386
 387     foreach ($names as $name => $classPath) {
 388       $action = new $classPath($this->_stateMachine);
 389       $this->addAction($name, $action);
 390     }
 391
 392     $this->addUploadAction($uploadDirectory, $uploadNames);
 393   }
 394
 395   /**
 396    * getter method for stateMachine
 397    *
 398    * @return object
 399    * @access public
 400    */
 401   function getStateMachine() {
 402     return $this->_stateMachine;
 403   }
 404
 405   /**
 406    * setter method for stateMachine
 407    *
 408    * @param object a stateMachineObject
 409    *
 410    * @return void
 411    * @access public
 412    */
 413   function setStateMachine($stateMachine) {
 414     $this->_stateMachine = $stateMachine;
 415   }
 416
 417   /**
 418    * add pages to the controller. Note that the controller does not really care
 419    * the order in which the pages are added
 420    *
 421    * @param object $stateMachine  the state machine object
 422    * @param int    $action        the mode in which the state machine is operating
 423    *                              typicaly this will be add/view/edit
 424    *
 425    * @return void
 426    * @access public
 427    *
 428    */
 429   function addPages(&$stateMachine, $action = CRM_Core_Action::NONE) {
 430     $pages = $stateMachine->getPages();
 431     foreach ($pages as $name => $value) {
 432       $className = CRM_Utils_Array::value('className', $value, $name);
 433       $title     = CRM_Utils_Array::value('title', $value);
 434       $options   = CRM_Utils_Array::value('options', $value);
 435       $stateName = CRM_Utils_String::getClassName($className);
 436       if (CRM_Utils_Array::value('className', $value)) {
 437         $formName = $name;
 438       }
 439       else {
 440         $formName = CRM_Utils_String::getClassName($name);
 441       }
 442
 443       $ext = CRM_Extension_System::singleton()->getMapper();
 444       if ($ext->isExtensionClass($className)) {
 445         require_once ($ext->classToPath($className));
 446       }
 447       else {
 448         require_once (str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php');
 449       }
 450       $$stateName = new $className($stateMachine->find($className), $action, 'post', $formName);
 451       if ($title) {
 452         $$stateName->setTitle($title);
 453       }
 454       if ($options) {
 455         $$stateName->setOptions($options);
 456       }
 457       $this->addPage($$stateName);
 458       $this->addAction($stateName, new HTML_QuickForm_Action_Direct());
 459
 460       //CRM-6342 -we need kill the reference here,
 461       //as we have deprecated reference object creation.
 462       unset($$stateName);
 463     }
 464   }
 465
 466   /**
 467    * QFC does not provide native support to have different 'submit' buttons.
 468    * We introduce this notion to QFC by using button specific data. Thus if
 469    * we have two submit buttons, we could have one displayed as a button and
 470    * the other as an image, both are of type 'submit'.
 471    *
 472    * @return string the name of the button that has been pressed by the user
 473    * @access public
 474    */
 475   function getButtonName() {
 476     $data = &$this->container();
 477     return CRM_Utils_Array::value('_qf_button_name', $data);
 478   }
 479
 480   /**
 481    * function to destroy all the session state of the controller.
 482    *
 483    * @access public
 484    *
 485    * @return void
 486    */
 487   function reset() {
 488     $this->container(TRUE);
 489     self::$_session->resetScope($this->_scope);
 490   }
 491
 492   /**
 493    * virtual function to do any processing of data.
 494    * Sometimes it is useful for the controller to actually process data.
 495    * This is typically used when we need the controller to figure out
 496    * what pages are potentially involved in this wizard. (this is dynamic
 497    * and can change based on the arguments
 498    *
 499    * @return void
 500    * @access public
 501    */
 502   function process() {}
 503
 504   /**
 505    * Store the variable with the value in the form scope
 506    *
 507    * @param  string|array $name  name  of the variable or an assoc array of name/value pairs
 508    * @param  mixed        $value value of the variable if string
 509    *
 510    * @access public
 511    *
 512    * @return void
 513    *
 514    */
 515   function set($name, $value = NULL) {
 516     self::$_session->set($name, $value, $this->_scope);
 517   }
 518
 519   /**
 520    * Get the variable from the form scope
 521    *
 522    * @param  string name  : name  of the variable
 523    *
 524    * @access public
 525
 526    *
 527    * @return mixed
 528    *
 529    */
 530   function get($name) {
 531     return self::$_session->get($name, $this->_scope);
 532   }
 533
 534   /**
 535    * Create the header for the wizard from the list of pages
 536    * Store the created header in smarty
 537    *
 538    * @param string $currentPageName name of the page being displayed
 539    *
 540    * @return array
 541    * @access public
 542    */
 543   function wizardHeader($currentPageName) {
 544     $wizard          = array();
 545     $wizard['steps'] = array();
 546     $count           = 0;
 547     foreach ($this->_pages as $name => $page) {
 548       $count++;
 549       $wizard['steps'][] = array(
 550         'name' => $name,
 551         'title' => $page->getTitle(),
 552         //'link'      => $page->getLink ( ),
 553         'link' => NULL,
 554         'step' => TRUE,
 555         'valid' => TRUE,
 556         'stepNumber' => $count,
 557         'collapsed' => FALSE,
 558       );
 559
 560       if ($name == $currentPageName) {
 561         $wizard['currentStepNumber'] = $count;
 562         $wizard['currentStepName'] = $name;
 563         $wizard['currentStepTitle'] = $page->getTitle();
 564       }
 565     }
 566
 567     $wizard['stepCount'] = $count;
 568
 569     $this->addWizardStyle($wizard);
 570
 571     $this->assign('wizard', $wizard);
 572     return $wizard;
 573   }
 574
 575   function addWizardStyle(&$wizard) {
 576     $wizard['style'] = array(
 577       'barClass' => '',
 578       'stepPrefixCurrent' => '&raquo;',
 579       'stepPrefixPast' => '&radic;',
 580       'stepPrefixFuture' => ' ',
 581       'subStepPrefixCurrent' => '&nbsp;&nbsp;',
 582       'subStepPrefixPast' => '&nbsp;&nbsp;',
 583       'subStepPrefixFuture' => '&nbsp;&nbsp;',
 584       'showTitle' => 1,
 585     );
 586   }
 587
 588   /**
 589    * assign value to name in template
 590    *
 591    * @param array|string $name  name  of variable
 592    * @param mixed $value value of varaible
 593    *
 594    * @return void
 595    * @access public
 596    */
 597   function assign($var, $value = NULL) {
 598     self::$_template->assign($var, $value);
 599   }
 600
 601   /**
 602    * assign value to name in template by reference
 603    *
 604    * @param array|string $name  name  of variable
 605    * @param mixed $value (reference) value of varaible
 606    *
 607    * @return void
 608    * @access public
 609    */
 610   function assign_by_ref($var, &$value) {
 611     self::$_template->assign_by_ref($var, $value);
 612   }
 613
 614   /**
 615    * appends values to template variables
 616    *
 617    * @param array|string $tpl_var the template variable name(s)
 618    * @param mixed $value the value to append
 619    * @param bool $merge
 620    */
 621   function append($tpl_var, $value=NULL, $merge=FALSE) {
 622     self::$_template->append($tpl_var, $value, $merge);
 623   }
 624
 625   /**
 626    * Returns an array containing template variables
 627    *
 628    * @param string $name
 629    * @param string $type
 630    * @return array
 631    */
 632   function get_template_vars($name=null) {
 633     return self::$_template->get_template_vars($name);
 634   }
 635
 636   /**
 637    * setter for embedded
 638    *
 639    * @param boolean $embedded
 640    *
 641    * @return void
 642    * @access public
 643    */
 644   function setEmbedded($embedded) {
 645     $this->_embedded = $embedded;
 646   }
 647
 648   /**
 649    * getter for embedded
 650    *
 651    * @return boolean return the embedded value
 652    * @access public
 653    */
 654   function getEmbedded() {
 655     return $this->_embedded;
 656   }
 657
 658   /**
 659    * setter for skipRedirection
 660    *
 661    * @param boolean $skipRedirection
 662    *
 663    * @return void
 664    * @access public
 665    */
 666   function setSkipRedirection($skipRedirection) {
 667     $this->_skipRedirection = $skipRedirection;
 668   }
 669
 670   /**
 671    * getter for skipRedirection
 672    *
 673    * @return boolean return the skipRedirection value
 674    * @access public
 675    */
 676   function getSkipRedirection() {
 677     return $this->_skipRedirection;
 678   }
 679
 680   function setWord($fileName = NULL) {
 681     //Mark as a CSV file.
 682     header('Content-Type: application/vnd.ms-word');
 683
 684     //Force a download and name the file using the current timestamp.
 685     if (!$fileName) {
 686       $fileName = 'Contacts_' . $_SERVER['REQUEST_TIME'] . '.doc';
 687     }
 688     header("Content-Disposition: attachment; filename=Contacts_$fileName");
 689   }
 690
 691   function setExcel($fileName = NULL) {
 692     //Mark as an excel file.
 693     header('Content-Type: application/vnd.ms-excel');
 694
 695     //Force a download and name the file using the current timestamp.
 696     if (!$fileName) {
 697       $fileName = 'Contacts_' . $_SERVER['REQUEST_TIME'] . '.xls';
 698     }
 699
 700     header("Content-Disposition: attachment; filename=Contacts_$fileName");
 701   }
 702
 703   /**
 704    * setter for print
 705    *
 706    * @param boolean $print
 707    *
 708    * @return void
 709    * @access public
 710    */
 711   function setPrint($print) {
 712     if ($print == "xls") {
 713       $this->setExcel();
 714     }
 715     elseif ($print == "doc") {
 716       $this->setWord();
 717     }
 718     $this->_print = $print;
 719   }
 720
 721   /**
 722    * getter for print
 723    *
 724    * @return boolean return the print value
 725    * @access public
 726    */
 727   function getPrint() {
 728     return $this->_print;
 729   }
 730
 731   function getTemplateFile() {
 732     if ($this->_print) {
 733       if ($this->_print == CRM_Core_Smarty::PRINT_PAGE) {
 734         return 'CRM/common/print.tpl';
 735       }
 736       elseif ($this->_print == 'xls' || $this->_print == 'doc') {
 737         return 'CRM/Contact/Form/Task/Excel.tpl';
 738       }
 739       else {
 740         return 'CRM/common/snippet.tpl';
 741       }
 742     }
 743     else {
 744       $config = CRM_Core_Config::singleton();
 745       return 'CRM/common/' . strtolower($config->userFramework) . '.tpl';
 746     }
 747   }
 748
 749   public function addUploadAction($uploadDir, $uploadNames) {
 750     if (empty($uploadDir)) {
 751       $config = CRM_Core_Config::singleton();
 752       $uploadDir = $config->uploadDir;
 753     }
 754
 755     if (empty($uploadNames)) {
 756       $uploadNames = $this->get('uploadNames');
 757       if (!empty($uploadNames)) {
 758         $uploadNames = array_merge($uploadNames,
 759           CRM_Core_BAO_File::uploadNames()
 760         );
 761       }
 762       else {
 763         $uploadNames = CRM_Core_BAO_File::uploadNames();
 764       }
 765     }
 766
 767     $action = new CRM_Core_QuickForm_Action_Upload($this->_stateMachine,
 768       $uploadDir,
 769       $uploadNames
 770     );
 771     $this->addAction('upload', $action);
 772   }
 773
 774   public function setParent($parent) {
 775     $this->_parent = $parent;
 776   }
 777
 778   public function getParent() {
 779     return $this->_parent;
 780   }
 781
 782   public function getDestination() {
 783     return $this->_destination;
 784   }
 785
 786   public function setDestination($url = NULL, $setToReferer = FALSE) {
 787     if (empty($url)) {
 788       if ($setToReferer) {
 789         $url = $_SERVER['HTTP_REFERER'];
 790       }
 791       else {
 792         $config = CRM_Core_Config::singleton();
 793         $url = $config->userFrameworkBaseURL;
 794       }
 795     }
 796
 797     $this->_destination = $url;
 798     $this->set('civicrmDestination', $this->_destination);
 799   }
 800
 801   public function cancelAction() {
 802     $actionName = $this->getActionName();
 803     list($pageName, $action) = $actionName;
 804     return $this->_pages[$pageName]->cancelAction();
 805   }
 806
 807   /**
 808    * Write a simple fatal error message. Other controllers can decide to do something else
 809    * and present the user a better message and/or redirect to the same page with a reset url
 810    *
 811    * @return void
 812    *
 813    */
 814   public function invalidKey() {
 815     self::invalidKeyCommon();
 816   }
 817
 818   public function invalidKeyCommon() {
 819     $msg = ts('We can\'t load the requested web page. This page requires cookies to be enabled in your browser settings. Please check this setting and enable cookies (if they are not enabled). Then try again. If this error persists, contact the site adminstrator for assistance.') . '<br /><br />' . ts('Site Administrators: This error may indicate that users are accessing this page using a domain or URL other than the configured Base URL. EXAMPLE: Base URL is http://example.org, but some users are accessing the page via http://www.example.org or a domain alias like http://myotherexample.org.') . '<br /><br />' . ts('Error type: Could not find a valid session key.');
 820     CRM_Core_Error::fatal($msg);
 821   }
 822
 823   /**
 824    * Instead of outputting a fatal error message, we'll just redirect to the entryURL if present
 825    *
 826    * @return void
 827    */
 828   public function invalidKeyRedirect() {
 829     if ($this->_entryURL) {
 830       CRM_Core_Session::setStatus(ts('Your browser session has expired and we are unable to complete your form submission. We have returned you to the initial step so you can complete and resubmit the form. If you experience continued difficulties, please contact us for assistance.'));
 831       return CRM_Utils_System::redirect($this->_entryURL);
 832     }
 833     else {
 834       self::invalidKeyCommon();
 835     }
 836   }
 837
 838 }