CRM/Utils/System/Base.php

   1 <?php
   2
   3 /**
   4  * Base class for UF system integrations
   5  */
   6 abstract class CRM_Utils_System_Base {
   7
   8   /**
   9    * Deprecated property to check if this is a drupal install.
  10    *
  11    * The correct method is to have functions on the UF classes for all UF specific
  12    * functions and leave the codebase oblivious to the type of CMS
  13    *
  14    * @deprecated
  15    * @var bool
  16    *   TRUE, if the CMS is Drupal.
  17    */
  18   var $is_drupal = FALSE;
  19
  20   /**
  21    * Deprecated property to check if this is a joomla install. The correct method is to have functions on the UF classes for all UF specific
  22    * functions and leave the codebase oblivious to the type of CMS
  23    *
  24    * @deprecated
  25    * @var bool
  26    *   TRUE, if the CMS is Joomla!.
  27    */
  28   var $is_joomla = FALSE;
  29
  30   /**
  31    * deprecated property to check if this is a wordpress install. The correct method is to have functions on the UF classes for all UF specific
  32    * functions and leave the codebase oblivious to the type of CMS
  33    *
  34    * @deprecated
  35    * @var bool
  36    *   TRUE, if the CMS is WordPress.
  37    */
  38   var $is_wordpress = FALSE;
  39
  40   /**
  41    * Does this CMS / UF support a CMS specific logging mechanism?
  42    * @todo - we should think about offering up logging mechanisms in a way that is also extensible by extensions
  43    * @var bool
  44    */
  45   var $supports_UF_Logging = FALSE;
  46
  47   /**
  48    * @var bool
  49    *   TRUE, if the CMS allows CMS forms to be extended by hooks.
  50    */
  51   var $supports_form_extensions = FALSE;
  52
  53   public function initialize() {
  54     if (\CRM_Utils_System::isSSL()) {
  55       $this->mapConfigToSSL();
  56     }
  57   }
  58
  59   /**
  60    * Append an additional breadcrumb tag to the existing breadcrumb.
  61    *
  62    * @param array $breadCrumbs
  63    */
  64   public function appendBreadCrumb($breadCrumbs) {
  65   }
  66
  67   /**
  68    * Reset an additional breadcrumb tag to the existing breadcrumb.
  69    */
  70   public function resetBreadCrumb() {
  71   }
  72
  73   /**
  74    * Append a string to the head of the html file.
  75    *
  76    * @param string $head
  77    *   The new string to be appended.
  78    */
  79   public function addHTMLHead($head) {
  80   }
  81
  82   /**
  83    * Rewrite various system urls to https.
  84    */
  85   public function mapConfigToSSL() {
  86     // dont need to do anything, let CMS handle their own switch to SSL
  87   }
  88
  89   /**
  90    * Figure out the post url for QuickForm.
  91    *
  92    * @param string $action
  93    *   The default url if one is pre-specified.
  94    *
  95    * @return string
  96    *   The url to post the form.
  97    */
  98   public function postURL($action) {
  99     $config = CRM_Core_Config::singleton();
 100     if (!empty($action)) {
 101       return $action;
 102     }
 103
 104     return $this->url(CRM_Utils_Array::value($config->userFrameworkURLVar, $_GET),
 105       NULL, TRUE, NULL, FALSE
 106     );
 107   }
 108
 109   /**
 110    * Generate the url string to a CiviCRM path.
 111    *
 112    * @param string $path
 113    *   The path being linked to, such as "civicrm/add".
 114    * @param string $query
 115    *   A query string to append to the link.
 116    * @param bool $absolute
 117    *   Whether to force the output to be an absolute link (beginning with http).
 118    *   Useful for links that will be displayed outside the site, such as in an RSS feed.
 119    * @param string $fragment
 120    *   A fragment identifier (named anchor) to append to the link.
 121    * @param bool $htmlize
 122    *   Whether to encode special html characters such as &.
 123    * @param bool $frontend
 124    *   This link should be to the CMS front end (applies to WP & Joomla).
 125    * @param bool $forceBackend
 126    *   This link should be to the CMS back end (applies to WP & Joomla).
 127    *
 128    * @return string
 129    */
 130   public function url(
 131     $path = NULL,
 132     $query = NULL,
 133     $absolute = FALSE,
 134     $fragment = NULL,
 135     $htmlize = TRUE,
 136     $frontend = FALSE,
 137     $forceBackend = FALSE
 138   ) {
 139     return NULL;
 140   }
 141
 142   /**
 143    * Authenticate the user against the CMS db.
 144    *
 145    * @param string $name
 146    *   The user name.
 147    * @param string $password
 148    *   The password for the above user.
 149    * @param bool $loadCMSBootstrap
 150    *   Load cms bootstrap?.
 151    * @param string $realPath
 152    *   Filename of script
 153    *
 154    * @return array|bool
 155    *   [contactID, ufID, unique string] else false if no auth
 156    */
 157   public function authenticate($name, $password, $loadCMSBootstrap = FALSE, $realPath = NULL) {
 158     return FALSE;
 159   }
 160
 161   /**
 162    * Set a message in the CMS to display to a user.
 163    *
 164    * @param string $message
 165    *   The message to set.
 166    */
 167   public function setMessage($message) {
 168   }
 169
 170   /**
 171    * Load user into session.
 172    *
 173    * @param obj $user
 174    *
 175    * @return bool
 176    */
 177   public function loadUser($user) {
 178     return TRUE;
 179   }
 180
 181   /**
 182    * Immediately stop script execution and display a 401 "Access Denied" page.
 183    */
 184   public function permissionDenied() {
 185     CRM_Core_Error::fatal(ts('You do not have permission to access this page.'));
 186   }
 187
 188   /**
 189    * Immediately stop script execution, log out the user and redirect to the home page.
 190    *
 191    * @deprecated
 192    *   This function should be removed in favor of linking to the CMS's logout page
 193    */
 194   public function logout() {
 195   }
 196
 197   /**
 198    * Clear CMS caches related to the user registration/profile forms.
 199    * Used when updating/embedding profiles on CMS user forms.
 200    * @see CRM-3600
 201    */
 202   public function updateCategories() {
 203   }
 204
 205   /**
 206    * Get the locale set in the CMS.
 207    *
 208    * @return string|null
 209    *   Locale or null for none
 210    */
 211   public function getUFLocale() {
 212     return NULL;
 213   }
 214
 215   /**
 216    * If we are using a theming system, invoke theme, else just print the content.
 217    *
 218    * @param string $content
 219    *   The content that will be themed.
 220    * @param bool $print
 221    *   Are we displaying to the screen or bypassing theming?.
 222    * @param bool $maintenance
 223    *   For maintenance mode.
 224    *
 225    * @throws Exception
 226    * @return string|null
 227    *   NULL, If $print is FALSE, and some other criteria match up.
 228    *   The themed string, otherwise.
 229    *
 230    * @todo The return value is inconsistent.
 231    * @todo Better to always return, and never print.
 232    */
 233   public function theme(&$content, $print = FALSE, $maintenance = FALSE) {
 234     $ret = FALSE;
 235
 236     // TODO: Split up; this was copied verbatim from CiviCRM 4.0's multi-UF theming function
 237     // but the parts should be copied into cleaner subclass implementations
 238     $config = CRM_Core_Config::singleton();
 239     if (
 240       $config->userSystem->is_drupal &&
 241       function_exists('theme') &&
 242       !$print
 243     ) {
 244       if ($maintenance) {
 245         drupal_set_breadcrumb('');
 246         drupal_maintenance_theme();
 247         if ($region = CRM_Core_Region::instance('html-header', FALSE)) {
 248           CRM_Utils_System::addHTMLHead($region->render(''));
 249         }
 250         print theme('maintenance_page', array('content' => $content));
 251         exit();
 252       }
 253       // TODO: Figure out why D7 returns but everyone else prints
 254       $ret = TRUE;
 255     }
 256     $out = $content;
 257
 258     $config = &CRM_Core_Config::singleton();
 259     if (
 260       !$print &&
 261       $config->userFramework == 'WordPress'
 262     ) {
 263       if (!function_exists('is_admin')) {
 264         throw new \Exception('Function "is_admin()" is missing, even though WordPress is the user framework.');
 265       }
 266       if (!defined('ABSPATH')) {
 267         throw new \Exception('Constant "ABSPATH" is not defined, even though WordPress is the user framework.');
 268       }
 269       if (is_admin()) {
 270         require_once ABSPATH . 'wp-admin/admin-header.php';
 271       }
 272       else {
 273         // FIXME: we need to figure out to replace civicrm content on the frontend pages
 274       }
 275     }
 276
 277     if ($ret) {
 278       return $out;
 279     }
 280     else {
 281       print $out;
 282       return NULL;
 283     }
 284   }
 285
 286   /**
 287    * @return string
 288    */
 289   public function getDefaultBlockLocation() {
 290     return 'left';
 291   }
 292
 293   public function getAbsoluteBaseURL() {
 294     if (!defined('CIVICRM_UF_BASEURL')) {
 295       return FALSE;
 296     }
 297
 298     $url = CRM_Utils_File::addTrailingSlash(CIVICRM_UF_BASEURL, '/');
 299
 300     //format url for language negotiation, CRM-7803
 301     $url = $this->languageNegotiationURL($url);
 302
 303     if (CRM_Utils_System::isSSL()) {
 304       $url = str_replace('http://', 'https://', $url);
 305     }
 306
 307     return $url;
 308   }
 309
 310   public function getRelativeBaseURL() {
 311     $absoluteBaseURL = $this->getAbsoluteBaseURL();
 312     if ($absoluteBaseURL === FALSE) {
 313       return FALSE;
 314     }
 315     $parts = parse_url($absoluteBaseURL);
 316     return $parts['path'];
 317     //$this->useFrameworkRelativeBase = empty($base['path']) ? '/' : $base['path'];
 318   }
 319
 320   /**
 321    * Get CMS Version.
 322    *
 323    * @return string
 324    */
 325   public function getVersion() {
 326     return 'Unknown';
 327   }
 328
 329   /**
 330    * Format the url as per language Negotiation.
 331    *
 332    * @param string $url
 333    * @param bool $addLanguagePart
 334    * @param bool $removeLanguagePart
 335    *
 336    * @return string
 337    *   Formatted url.
 338    */
 339   public function languageNegotiationURL(
 340     $url,
 341     $addLanguagePart = TRUE,
 342     $removeLanguagePart = FALSE
 343   ) {
 344     return $url;
 345   }
 346
 347   /**
 348    * Determine the location of the CMS root.
 349    *
 350    * @return string|null
 351    *   Local file system path to CMS root, or NULL if it cannot be determined
 352    */
 353   public function cmsRootPath() {
 354     return NULL;
 355   }
 356
 357   /**
 358    * Create a user in the CMS.
 359    *
 360    * @param array $params
 361    * @param string $mail
 362    *   Email id for cms user.
 363    *
 364    * @return int|bool
 365    *   uid if user exists, false otherwise
 366    */
 367   public function createUser(&$params, $mail) {
 368     return FALSE;
 369   }
 370
 371   /**
 372    * Update a user's email address in the CMS.
 373    *
 374    * @param int $ufID
 375    *   User ID in CMS.
 376    * @param string $email
 377    *   Primary contact email address.
 378    */
 379   public function updateCMSName($ufID, $email) {
 380   }
 381
 382   /**
 383    * Check if user is logged in to the CMS.
 384    *
 385    * @return bool
 386    */
 387   public function isUserLoggedIn() {
 388     return FALSE;
 389   }
 390
 391   /**
 392    * Get user login URL for hosting CMS (method declared in each CMS system class)
 393    *
 394    * @param string $destination
 395    *   If present, add destination to querystring (works for Drupal only).
 396    *
 397    * @return string
 398    *   loginURL for the current CMS
 399    */
 400   public abstract function getLoginURL($destination = '');
 401
 402   /**
 403    * Get the login destination string.
 404    *
 405    * When this is passed in the URL the user will be directed to it after filling in the CMS form.
 406    *
 407    * @param CRM_Core_Form $form
 408    *   Form object representing the 'current' form - to which the user will be returned.
 409    *
 410    * @return string|NULL
 411    *   destination value for URL
 412    */
 413   public function getLoginDestination(&$form) {
 414     return NULL;
 415   }
 416
 417   /**
 418    * Determine the native ID of the CMS user.
 419    *
 420    * @param string $username
 421    *
 422    * @throws CRM_Core_Exception
 423    */
 424   public function getUfId($username) {
 425     $className = get_class($this);
 426     throw new CRM_Core_Exception("Not implemented: {$className}->getUfId");
 427   }
 428
 429   public function setUFLocale($civicrm_language) {
 430     return TRUE;
 431   }
 432
 433   /**
 434    * Set a init session with user object.
 435    *
 436    * @param array $data
 437    *   Array with user specific data
 438    */
 439   public function setUserSession($data) {
 440     list($userID, $ufID) = $data;
 441     $session = CRM_Core_Session::singleton();
 442     $session->set('ufID', $ufID);
 443     $session->set('userID', $userID);
 444   }
 445
 446   /**
 447    * Reset any system caches that may be required for proper CiviCRM integration.
 448    */
 449   public function flush() {
 450     // nullop by default
 451   }
 452
 453   /**
 454    * Flush css/js caches.
 455    */
 456   public function clearResourceCache() {
 457     // nullop by default
 458   }
 459
 460   /**
 461    * Add a script file.
 462    *
 463    * Note: This function is not to be called directly
 464    * @see CRM_Core_Region::render()
 465    *
 466    * @param string $url absolute path to file
 467    * @param string $region
 468    *   location within the document: 'html-header', 'page-header', 'page-footer'.
 469    *
 470    * @return bool
 471    *   TRUE if we support this operation in this CMS, FALSE otherwise
 472    */
 473   public function addScriptUrl($url, $region) {
 474     return FALSE;
 475   }
 476
 477   /**
 478    * Add an inline script.
 479    *
 480    * Note: This function is not to be called directly
 481    * @see CRM_Core_Region::render()
 482    *
 483    * @param string $code javascript code
 484    * @param string $region
 485    *   location within the document: 'html-header', 'page-header', 'page-footer'.
 486    *
 487    * @return bool
 488    *   TRUE if we support this operation in this CMS, FALSE otherwise
 489    */
 490   public function addScript($code, $region) {
 491     return FALSE;
 492   }
 493
 494   /**
 495    * Add a css file.
 496    *
 497    * Note: This function is not to be called directly
 498    * @see CRM_Core_Region::render()
 499    *
 500    * @param string $url absolute path to file
 501    * @param string $region
 502    *   location within the document: 'html-header', 'page-header', 'page-footer'.
 503    *
 504    * @return bool
 505    *   TRUE if we support this operation in this CMS, FALSE otherwise
 506    */
 507   public function addStyleUrl($url, $region) {
 508     return FALSE;
 509   }
 510
 511   /**
 512    * Add an inline style.
 513    *
 514    * Note: This function is not to be called directly
 515    * @see CRM_Core_Region::render()
 516    *
 517    * @param string $code css code
 518    * @param string $region
 519    *   location within the document: 'html-header', 'page-header', 'page-footer'.
 520    *
 521    * @return bool
 522    *   TRUE if we support this operation in this CMS, FALSE otherwise
 523    */
 524   public function addStyle($code, $region) {
 525     return FALSE;
 526   }
 527
 528   /**
 529    * Sets the title of the page.
 530    *
 531    * @param string $title
 532    *   Title to set in html header
 533    * @param string|null $pageTitle
 534    *   Title to set in html body (if different)
 535    */
 536   public function setTitle($title, $pageTitle = NULL) {
 537   }
 538
 539   /**
 540    * Return default Site Settings.
 541    *
 542    * @param string $dir
 543    *
 544    * @return array
 545    *   - $url, (Joomla - non admin url)
 546    *   - $siteName,
 547    *   - $siteRoot
 548    */
 549   public function getDefaultSiteSettings($dir) {
 550     $config = CRM_Core_Config::singleton();
 551     $url = $config->userFrameworkBaseURL;
 552     return array($url, NULL, NULL);
 553   }
 554
 555   /**
 556    * Determine the default location for file storage.
 557    *
 558    * FIXME:
 559    *  1. This was pulled out from a bigger function. It should be split
 560    *     into even smaller pieces and marked abstract.
 561    *  2. This would be easier to compute by a calling a CMS API, but
 562    *     for whatever reason Civi gets it from config data.
 563    *
 564    * @return array
 565    *   - url: string. ex: "http://example.com/sites/foo.com/files/civicrm"
 566    *   - path: string. ex: "/var/www/sites/foo.com/files/civicrm"
 567    */
 568   public function getDefaultFileStorage() {
 569     global $civicrm_root;
 570     $config = CRM_Core_Config::singleton();
 571     $baseURL = CRM_Utils_System::languageNegotiationURL($config->userFrameworkBaseURL, FALSE, TRUE);
 572
 573     $filesURL = NULL;
 574     $filesPath = NULL;
 575
 576     if ($config->userFramework == 'Joomla') {
 577       // gross hack
 578       // we need to remove the administrator/ from the end
 579       $tempURL = str_replace("/administrator/", "/", $baseURL);
 580       $filesURL = $tempURL . "media/civicrm/";
 581     }
 582     elseif ($config->userFramework == 'WordPress') {
 583       //for standalone no need of sites/defaults directory
 584       $filesURL = $baseURL . "wp-content/plugins/files/civicrm/";
 585     }
 586     elseif ($this->is_drupal) {
 587       $siteName = $config->userSystem->parseDrupalSiteName($civicrm_root);
 588       if ($siteName) {
 589         $filesURL = $baseURL . "sites/$siteName/files/civicrm/";
 590       }
 591       else {
 592         $filesURL = $baseURL . "sites/default/files/civicrm/";
 593       }
 594     }
 595     elseif ($config->userFramework == 'UnitTests') {
 596       $filesURL = $baseURL . "sites/default/files/civicrm/";
 597     }
 598     else {
 599       throw new CRM_Core_Exception("Failed to locate default file storage ($config->userFramework)");
 600     }
 601
 602     return array(
 603       'url' => $filesURL,
 604       'path' => CRM_Utils_File::baseFilePath(),
 605     );
 606   }
 607
 608   /**
 609    * Determine the location of the CiviCRM source tree.
 610    *
 611    * FIXME:
 612    *  1. This was pulled out from a bigger function. It should be split
 613    *     into even smaller pieces and marked abstract.
 614    *  2. This would be easier to compute by a calling a CMS API, but
 615    *     for whatever reason we take the hard way.
 616    *
 617    * @return array
 618    *   - url: string. ex: "http://example.com/sites/all/modules/civicrm"
 619    *   - path: string. ex: "/var/www/sites/all/modules/civicrm"
 620    */
 621   public function getCiviSourceStorage() {
 622     global $civicrm_root;
 623     $config = CRM_Core_Config::singleton();
 624
 625     // Don't use $config->userFrameworkBaseURL; it has garbage on it.
 626     // More generally, w shouldn't be using $config here.
 627     if (!defined('CIVICRM_UF_BASEURL')) {
 628       throw new RuntimeException('Undefined constant: CIVICRM_UF_BASEURL');
 629     }
 630     $baseURL = CRM_Utils_File::addTrailingSlash(CIVICRM_UF_BASEURL, '/');
 631     if (CRM_Utils_System::isSSL()) {
 632       $baseURL = str_replace('http://', 'https://', $baseURL);
 633     }
 634
 635     if ($config->userFramework == 'Joomla') {
 636       $userFrameworkResourceURL = $baseURL . "components/com_civicrm/civicrm/";
 637     }
 638     elseif ($config->userFramework == 'WordPress') {
 639       $userFrameworkResourceURL = $baseURL . "wp-content/plugins/civicrm/civicrm/";
 640     }
 641     elseif ($this->is_drupal) {
 642       // Drupal setting
 643       // check and see if we are installed in sites/all (for D5 and above)
 644       // we dont use checkURL since drupal generates an error page and throws
 645       // the system for a loop on lobo's macosx box
 646       // or in modules
 647       $cmsPath = $config->userSystem->cmsRootPath();
 648       $userFrameworkResourceURL = $baseURL . str_replace("$cmsPath/", '',
 649           str_replace('\\', '/', $civicrm_root)
 650         );
 651
 652       $siteName = $config->userSystem->parseDrupalSiteName($civicrm_root);
 653       if ($siteName) {
 654         $civicrmDirName = trim(basename($civicrm_root));
 655         $userFrameworkResourceURL = $baseURL . "sites/$siteName/modules/$civicrmDirName/";
 656       }
 657     }
 658     else {
 659       $userFrameworkResourceURL = NULL;
 660     }
 661
 662     return array(
 663       'url' => CRM_Utils_File::addTrailingSlash($userFrameworkResourceURL),
 664       'path' => CRM_Utils_File::addTrailingSlash($civicrm_root),
 665     );
 666   }
 667
 668   /**
 669    * Perform any post login activities required by the CMS.
 670    *
 671    * e.g. for drupal: records a watchdog message about the new session, saves the login timestamp,
 672    * calls hook_user op 'login' and generates a new session.
 673    *
 674    * @param array $params
 675    *
 676    * FIXME: Document values accepted/required by $params
 677    */
 678   public function userLoginFinalize($params = array()) {
 679   }
 680
 681   /**
 682    * Set timezone in mysql so that timestamp fields show the correct time.
 683    */
 684   public function setMySQLTimeZone() {
 685     $timeZoneOffset = $this->getTimeZoneOffset();
 686     if ($timeZoneOffset) {
 687       $sql = "SET time_zone = '$timeZoneOffset'";
 688       CRM_Core_DAO::executequery($sql);
 689     }
 690   }
 691
 692
 693   /**
 694    * Get timezone from CMS.
 695    *
 696    * @return string|false|null
 697    */
 698   public function getTimeZoneOffset() {
 699     $timezone = $this->getTimeZoneString();
 700     if ($timezone) {
 701       if ($timezone == 'UTC') {
 702         // CRM-17072 Let's short-circuit all the zero handling & return it here!
 703         return '+00:00';
 704       }
 705       $tzObj = new DateTimeZone($timezone);
 706       $dateTime = new DateTime("now", $tzObj);
 707       $tz = $tzObj->getOffset($dateTime);
 708
 709       if (empty($tz)) {
 710         return FALSE;
 711       }
 712
 713       $timeZoneOffset = sprintf("%02d:%02d", $tz / 3600, abs(($tz / 60) % 60));
 714
 715       if ($timeZoneOffset > 0) {
 716         $timeZoneOffset = '+' . $timeZoneOffset;
 717       }
 718       return $timeZoneOffset;
 719     }
 720     return NULL;
 721   }
 722
 723   /**
 724    * Get timezone as a string.
 725    * @return string
 726    *   Timezone string e.g. 'America/Los_Angeles'
 727    */
 728   public function getTimeZoneString() {
 729     return date_default_timezone_get();
 730   }
 731
 732   /**
 733    * Get Unique Identifier from UserFramework system (CMS).
 734    *
 735    * @param object $user
 736    *   Object as described by the User Framework.
 737    *
 738    * @return mixed
 739    *   Unique identifier from the user Framework system
 740    */
 741   public function getUniqueIdentifierFromUserObject($user) {
 742     return NULL;
 743   }
 744
 745   /**
 746    * Get User ID from UserFramework system (CMS).
 747    *
 748    * @param object $user
 749    *
 750    *   Object as described by the User Framework.
 751    * @return null|int
 752    */
 753   public function getUserIDFromUserObject($user) {
 754     return NULL;
 755   }
 756
 757   /**
 758    * Get an array of user details for a contact, containing at minimum the user ID & name.
 759    *
 760    * @param int $contactID
 761    *
 762    * @return array
 763    *   CMS user details including
 764    *   - id
 765    *   - name (ie the system user name.
 766    */
 767   public function getUser($contactID) {
 768     $ufMatch = civicrm_api3('UFMatch', 'getsingle', array(
 769       'contact_id' => $contactID,
 770       'domain_id' => CRM_Core_Config::domainID(),
 771     ));
 772     return array(
 773       'id' => $ufMatch['uf_id'],
 774       'name' => $ufMatch['uf_name'],
 775     );
 776   }
 777
 778   /**
 779    * Get currently logged in user uf id.
 780    *
 781    * @return int|null
 782    *   logged in user uf id.
 783    */
 784   public function getLoggedInUfID() {
 785     return NULL;
 786   }
 787
 788   /**
 789    * Get currently logged in user unique identifier - this tends to be the email address or user name.
 790    *
 791    * @return string|null
 792    *   logged in user unique identifier
 793    */
 794   public function getLoggedInUniqueIdentifier() {
 795     return NULL;
 796   }
 797
 798   /**
 799    * Return a UFID (user account ID from the UserFramework / CMS system.
 800    *
 801    * ID is based on the user object passed, defaulting to the logged in user if not passed.
 802    *
 803    * Note that ambiguous situation occurs in CRM_Core_BAO_UFMatch::synchronize - a cleaner approach would
 804    * seem to be resolving the user id before calling the function.
 805    *
 806    * Note there is already a function getUFId which takes $username as a param - we could add $user
 807    * as a second param to it but it seems messy - just overloading it because the name is taken.
 808    *
 809    * @param object $user
 810    *
 811    * @return int
 812    *   User ID of UF System
 813    */
 814   public function getBestUFID($user = NULL) {
 815     if ($user) {
 816       return $this->getUserIDFromUserObject($user);
 817     }
 818     return $this->getLoggedInUfID();
 819   }
 820
 821   /**
 822    * Return a unique identifier (usually an email address or username) from the UserFramework / CMS system.
 823    *
 824    * This is based on the user object passed, defaulting to the logged in user if not passed.
 825    *
 826    * Note that ambiguous situation occurs in CRM_Core_BAO_UFMatch::synchronize - a cleaner approach would seem to be
 827    * resolving the unique identifier before calling the function.
 828    *
 829    * @param object $user
 830    *
 831    * @return string
 832    *   unique identifier from the UF System
 833    */
 834   public function getBestUFUniqueIdentifier($user = NULL) {
 835     if ($user) {
 836       return $this->getUniqueIdentifierFromUserObject($user);
 837     }
 838     return $this->getLoggedInUniqueIdentifier();
 839   }
 840
 841   /**
 842    * List modules installed in the CMS, including enabled and disabled ones.
 843    *
 844    * @return array
 845    *   [CRM_Core_Module]
 846    */
 847   public function getModules() {
 848     return array();
 849   }
 850
 851   /**
 852    * Get Url to view user record.
 853    *
 854    * @param int $contactID
 855    *   Contact ID.
 856    *
 857    * @return string|null
 858    */
 859   public function getUserRecordUrl($contactID) {
 860     return NULL;
 861   }
 862
 863   /**
 864    * Is the current user permitted to add a user.
 865    *
 866    * @return bool
 867    */
 868   public function checkPermissionAddUser() {
 869     return FALSE;
 870   }
 871
 872   /**
 873    * Output code from error function.
 874    *
 875    * @param string $content
 876    */
 877   public function outputError($content) {
 878     echo CRM_Utils_System::theme($content);
 879   }
 880
 881   /**
 882    * Log error to CMS.
 883    *
 884    * $param string $message
 885    */
 886   public function logger($message) {
 887   }
 888
 889   /**
 890    * Append to coreResourcesList.
 891    *
 892    * @param array $list
 893    */
 894   public function appendCoreResources(&$list) {
 895   }
 896
 897   /**
 898    * @param string $name
 899    * @param string $value
 900    */
 901   public function setHttpHeader($name, $value) {
 902     header("$name: $value");
 903   }
 904
 905 }