CRM/Core/Controller.php

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