CRM/Core/BAO/Dashboard.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.7                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2016                                |
   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  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2016
  32  */
  33
  34 /**
  35  * Class contains Contact dashboard related functions.
  36  */
  37 class CRM_Core_BAO_Dashboard extends CRM_Core_DAO_Dashboard {
  38   /**
  39    * Add Dashboard.
  40    *
  41    * @param array $params
  42    *   Values.
  43    *
  44    *
  45    * @return object
  46    */
  47   public static function create($params) {
  48     $hook = empty($params['id']) ? 'create' : 'edit';
  49     CRM_Utils_Hook::pre($hook, 'Dashboard', CRM_Utils_Array::value('id', $params), $params);
  50     $dao = self::addDashlet($params);
  51     CRM_Utils_Hook::post($hook, 'Dashboard', $dao->id, $dao);
  52     return $dao;
  53   }
  54
  55   /**
  56    * Get the list of dashlets enabled by admin.
  57    *
  58    * @param bool $all
  59    *   All or only active.
  60    * @param bool $checkPermission
  61    *   All or only authorized for the current user.
  62    *
  63    * @return array
  64    *   array of dashlets
  65    */
  66   public static function getDashlets($all = TRUE, $checkPermission = TRUE) {
  67     $dashlets = array();
  68     $dao = new CRM_Core_DAO_Dashboard();
  69
  70     if (!$all) {
  71       $dao->is_active = 1;
  72     }
  73
  74     $dao->domain_id = CRM_Core_Config::domainID();
  75
  76     $dao->find();
  77     while ($dao->fetch()) {
  78       if ($checkPermission && !self::checkPermission($dao->permission, $dao->permission_operator)) {
  79         continue;
  80       }
  81
  82       $values = array();
  83       CRM_Core_DAO::storeValues($dao, $values);
  84       $dashlets[$dao->id] = $values;
  85     }
  86
  87     return $dashlets;
  88   }
  89
  90   /**
  91    * Get the list of dashlets for the current user or the specified user.
  92    *
  93    * Additionlly, initializes the dashboard with defaults if this is the
  94    * user's first visit to their dashboard.
  95    *
  96    * @param bool $flatFormat
  97    *   This is true if you want simple associated.
  98    *   array of all the contact's dashlets whether or not they are enabled.
  99    *
 100    * @param int $contactID
 101    *   Provide the dashlets for the contact id.
 102    *   passed rather than the current user.
 103    *
 104    * @return array
 105    *   array of dashlets
 106    */
 107   public static function getContactDashlets($flatFormat = FALSE, $contactID = NULL) {
 108     $dashlets = array();
 109
 110     // Get contact dashboard dashlets.
 111     $hasDashlets = FALSE;
 112     $dao = new CRM_Contact_DAO_DashboardContact();
 113     $dao->contact_id = $contactID ? $contactID : CRM_Core_Session::singleton()->getLoggedInContactID();
 114     $dao->orderBy('column_no asc, weight asc');
 115     $dao->find();
 116
 117     // The available list will only include those which are valid for the domain.
 118     $availableDashlets = self::getDashlets();
 119     while ($dao->fetch()) {
 120       // When a dashlet is removed, it stays in the table with status disabled,
 121       // so even if a user decides not to have any dashlets show, they will still
 122       // have records in the table to indicate that we are not newly initializing.
 123       if ((!empty($availableDashlets[$dao->dashboard_id]) && $availableDashlets[$dao->dashboard_id]['is_active'])) {
 124         $hasDashlets = TRUE;
 125         if (!$flatFormat) {
 126           if ($dao->is_active) {
 127             // append weight so that order is preserved.
 128             $dashlets[$dao->column_no]["{$dao->weight}-{$dao->dashboard_id}"] = $dao->is_minimized;
 129           }
 130         }
 131         else {
 132           $dashlets[$dao->dashboard_id] = $dao->dashboard_id;
 133         }
 134       }
 135     }
 136
 137     if ($flatFormat) {
 138       return $dashlets;
 139     }
 140
 141     // If empty, then initialize contact dashboard for this user.
 142     if (!$hasDashlets) {
 143       return self::initializeDashlets($flatFormat);
 144     }
 145     return $dashlets;
 146   }
 147
 148   /**
 149    * Setup default dashlets for new users.
 150    *
 151    * When a user accesses their dashboard for the first time, set up
 152    * the default dashlets.
 153    *
 154    * @param bool $flatFormat
 155    *
 156    * @return array
 157    *    Array of dashboard_id's
 158    * @throws \CiviCRM_API3_Exception
 159    */
 160   public static function initializeDashlets($flatFormat = FALSE) {
 161     $dashlets = array();
 162     $getDashlets = civicrm_api3("Dashboard", "get", array(
 163         'domain_id' => CRM_Core_Config::domainID(),
 164         'option.limit' => 0,
 165       ));
 166     $contactID = CRM_Core_Session::singleton()->getLoggedInContactID();
 167     $allDashlets = CRM_Utils_Array::index(array('name'), $getDashlets['values']);
 168     $defaultDashlets = array();
 169     $defaults = array('blog' => 1, 'getting-started' => '0');
 170     foreach ($defaults as $name => $column) {
 171       if (!empty($allDashlets[$name])) {
 172         $defaultDashlets[$name] = array(
 173           'dashboard_id' => $allDashlets[$name]['id'],
 174           'is_active' => 1,
 175           'column_no' => $column,
 176           'contact_id' => $contactID,
 177         );
 178       }
 179     }
 180     CRM_Utils_Hook::dashboard_defaults($allDashlets, $defaultDashlets);
 181     if (is_array($defaultDashlets) && !empty($defaultDashlets)) {
 182       foreach ($defaultDashlets as $id => $defaultDashlet) {
 183         $dashboard_id = $defaultDashlet['dashboard_id'];
 184         if (!self::checkPermission($getDashlets['values'][$dashboard_id]['permission'],
 185           CRM_Utils_Array::value('permission_operator', $getDashlets['values'][$dashboard_id]))
 186         ) {
 187           continue;
 188         }
 189         else {
 190           $assignDashlets = civicrm_api3("dashboard_contact", "create", $defaultDashlet);
 191           if (!$flatFormat) {
 192             $values = $assignDashlets['values'][$assignDashlets['id']];
 193             $dashlets[$values['column_no']][$values['weight'] - $values['dashboard_id']] = $values['is_minimized'];
 194           }
 195           else {
 196             $dashlets[$dashboard_id] = $defaultDashlet['dashboard_id'];
 197           }
 198         }
 199       }
 200     }
 201     return $dashlets;
 202   }
 203
 204
 205   /**
 206    * Check dashlet permission for current user.
 207    *
 208    * @param string $permission
 209    *   Comma separated list.
 210    * @param string $operator
 211    *
 212    * @return bool
 213    *   true if use has permission else false
 214    */
 215   public static function checkPermission($permission, $operator) {
 216     if ($permission) {
 217       $permissions = explode(',', $permission);
 218       $config = CRM_Core_Config::singleton();
 219
 220       static $allComponents;
 221       if (!$allComponents) {
 222         $allComponents = CRM_Core_Component::getNames();
 223       }
 224
 225       $hasPermission = FALSE;
 226       foreach ($permissions as $key) {
 227         $showDashlet = TRUE;
 228
 229         $componentName = NULL;
 230         if (strpos($key, 'access') === 0) {
 231           $componentName = trim(substr($key, 6));
 232           if (!in_array($componentName, $allComponents)) {
 233             $componentName = NULL;
 234           }
 235         }
 236
 237         // hack to handle case permissions
 238         if (!$componentName && in_array($key, array(
 239             'access my cases and activities',
 240             'access all cases and activities',
 241           ))
 242         ) {
 243           $componentName = 'CiviCase';
 244         }
 245
 246         //hack to determine if it's a component related permission
 247         if ($componentName) {
 248           if (!in_array($componentName, $config->enableComponents) ||
 249             !CRM_Core_Permission::check($key)
 250           ) {
 251             $showDashlet = FALSE;
 252             if ($operator == 'AND') {
 253               return $showDashlet;
 254             }
 255           }
 256           else {
 257             $hasPermission = TRUE;
 258           }
 259         }
 260         elseif (!CRM_Core_Permission::check($key)) {
 261           $showDashlet = FALSE;
 262           if ($operator == 'AND') {
 263             return $showDashlet;
 264           }
 265         }
 266         else {
 267           $hasPermission = TRUE;
 268         }
 269       }
 270
 271       if (!$showDashlet && !$hasPermission) {
 272         return FALSE;
 273       }
 274       else {
 275         return TRUE;
 276       }
 277     }
 278     else {
 279       // if permission is not set consider everyone has permission to access it.
 280       return TRUE;
 281     }
 282   }
 283
 284   /**
 285    * Get details of each dashlets.
 286    *
 287    * @param int $dashletID
 288    *   Widget ID.
 289    *
 290    * @return array
 291    *   associted array title and content
 292    */
 293   public static function getDashletInfo($dashletID) {
 294     $dashletInfo = array();
 295
 296     $params = array(1 => array($dashletID, 'Integer'));
 297     $query = "SELECT name, label, url, fullscreen_url, is_fullscreen FROM civicrm_dashboard WHERE id = %1";
 298     $dashboadDAO = CRM_Core_DAO::executeQuery($query, $params);
 299     $dashboadDAO->fetch();
 300
 301     // build the content
 302     $dao = new CRM_Contact_DAO_DashboardContact();
 303
 304     $session = CRM_Core_Session::singleton();
 305     $dao->contact_id = $session->get('userID');
 306     $dao->dashboard_id = $dashletID;
 307     $dao->find(TRUE);
 308
 309     //reset content based on the cache time set in config
 310     $createdDate = strtotime($dao->created_date);
 311     $dateDiff = round(abs(time() - $createdDate) / 60);
 312
 313     $config = CRM_Core_Config::singleton();
 314     if ($config->dashboardCacheTimeout <= $dateDiff) {
 315       $dao->content = NULL;
 316     }
 317
 318     // if content is empty and url is set, retrieve it from url
 319     if (!$dao->content && $dashboadDAO->url) {
 320       $url = $dashboadDAO->url;
 321
 322       // CRM-7087
 323       // -lets use relative url for internal use.
 324       // -make sure relative url should not be htmlize.
 325       if (substr($dashboadDAO->url, 0, 4) != 'http') {
 326         $urlParam = explode('?', $dashboadDAO->url);
 327         $url = CRM_Utils_System::url($urlParam[0], $urlParam[1], TRUE, NULL, FALSE);
 328       }
 329
 330       //get content from url
 331       $dao->content = CRM_Utils_System::getServerResponse($url);
 332       $dao->created_date = date("YmdHis");
 333       $dao->save();
 334     }
 335
 336     $dashletInfo = array(
 337       'title' => $dashboadDAO->label,
 338       'name' => $dashboadDAO->name,
 339       'content' => $dao->content,
 340     );
 341
 342     if ($dashboadDAO->is_fullscreen) {
 343       $fullscreenUrl = $dashboadDAO->fullscreen_url;
 344       if (substr($fullscreenUrl, 0, 4) != 'http') {
 345         $urlParam = explode('?', $dashboadDAO->fullscreen_url);
 346         $fullscreenUrl = CRM_Utils_System::url($urlParam[0], $urlParam[1], TRUE, NULL, FALSE);
 347       }
 348       $dashletInfo['fullscreenUrl'] = $fullscreenUrl;
 349     }
 350     return $dashletInfo;
 351   }
 352
 353   /**
 354    * Save changes made by use to the Dashlet.
 355    *
 356    * @param array $columns
 357    *
 358    * @param int $contactID
 359    *
 360    * @throws RuntimeException
 361    */
 362   public static function saveDashletChanges($columns, $contactID = NULL) {
 363     $session = CRM_Core_Session::singleton();
 364     if (!$contactID) {
 365       $contactID = $session->get('userID');
 366     }
 367
 368     if (empty($contactID)) {
 369       throw new RuntimeException("Failed to determine contact ID");
 370     }
 371
 372     //we need to get existing dashlets, so we know when to update or insert
 373     $contactDashlets = self::getContactDashlets(TRUE, $contactID);
 374
 375     $dashletIDs = array();
 376     if (is_array($columns)) {
 377       foreach ($columns as $colNo => $dashlets) {
 378         if (!is_int($colNo)) {
 379           continue;
 380         }
 381         $weight = 1;
 382         foreach ($dashlets as $dashletID => $isMinimized) {
 383           $isMinimized = (int) $isMinimized;
 384           if (in_array($dashletID, $contactDashlets)) {
 385             $query = " UPDATE civicrm_dashboard_contact
 386                                         SET weight = {$weight}, is_minimized = {$isMinimized}, column_no = {$colNo}, is_active = 1
 387                                       WHERE dashboard_id = {$dashletID} AND contact_id = {$contactID} ";
 388           }
 389           else {
 390             $query = " INSERT INTO civicrm_dashboard_contact
 391                                         ( weight, is_minimized, column_no, is_active, dashboard_id, contact_id )
 392                                      VALUES( {$weight},  {$isMinimized},  {$colNo}, 1, {$dashletID}, {$contactID} )";
 393           }
 394           // fire update query for each column
 395           $dao = CRM_Core_DAO::executeQuery($query);
 396
 397           $dashletIDs[] = $dashletID;
 398           $weight++;
 399         }
 400       }
 401     }
 402
 403     if (!empty($dashletIDs)) {
 404       // we need to disable widget that removed
 405       $updateQuery = " UPDATE civicrm_dashboard_contact
 406                                SET is_active = 0
 407                                WHERE dashboard_id NOT IN  ( " . implode(',', $dashletIDs) . ") AND contact_id = {$contactID}";
 408     }
 409     else {
 410       // this means all widgets are disabled
 411       $updateQuery = " UPDATE civicrm_dashboard_contact
 412                                SET is_active = 0
 413                                WHERE contact_id = {$contactID}";
 414     }
 415
 416     CRM_Core_DAO::executeQuery($updateQuery);
 417   }
 418
 419   /**
 420    * Add dashlets.
 421    *
 422    * @param array $params
 423    *
 424    * @return object
 425    *   $dashlet returns dashlet object
 426    */
 427   public static function addDashlet(&$params) {
 428
 429     // special case to handle duplicate entries for report instances
 430     $dashboardID = CRM_Utils_Array::value('id', $params);
 431
 432     if (!empty($params['instanceURL'])) {
 433       $query = "SELECT id
 434                         FROM `civicrm_dashboard`
 435                         WHERE url LIKE '" . CRM_Utils_Array::value('instanceURL', $params) . "&%'";
 436       $dashboardID = CRM_Core_DAO::singleValueQuery($query);
 437     }
 438
 439     $dashlet = new CRM_Core_DAO_Dashboard();
 440
 441     if (!$dashboardID) {
 442       // check url is same as exiting entries, if yes just update existing
 443       if (!empty($params['name'])) {
 444         $dashlet->name = CRM_Utils_Array::value('name', $params);
 445         $dashlet->find(TRUE);
 446       }
 447       else {
 448         $dashlet->url = CRM_Utils_Array::value('url', $params);
 449         $dashlet->find(TRUE);
 450       }
 451       if (empty($params['domain_id'])) {
 452         $dashlet->domain_id = CRM_Core_Config::domainID();
 453       }
 454     }
 455     else {
 456       $dashlet->id = $dashboardID;
 457     }
 458
 459     if (is_array(CRM_Utils_Array::value('permission', $params))) {
 460       $params['permission'] = implode(',', $params['permission']);
 461     }
 462     $dashlet->copyValues($params);
 463     $dashlet->save();
 464
 465     // now we need to make dashlet entries for each contact
 466     self::addContactDashlet($dashlet);
 467
 468     return $dashlet;
 469   }
 470
 471   /**
 472    * @param $url
 473    *
 474    * @return string
 475    */
 476   public static function getDashletName($url) {
 477     $urlElements = explode('/', $url);
 478     if ($urlElements[1] == 'dashlet') {
 479       return $urlElements[2];
 480     }
 481     elseif ($urlElements[1] == 'report') {
 482       return 'report/' . $urlElements[3];
 483     }
 484     return $url;
 485   }
 486
 487   /**
 488    * Update contact dashboard with new dashlet.
 489    *
 490    * @param object $dashlet
 491    */
 492   public static function addContactDashlet($dashlet) {
 493     $admin = CRM_Core_Permission::check('administer CiviCRM');
 494
 495     // if dashlet is created by admin then you need to add it all contacts.
 496     // else just add to contact who is creating this dashlet
 497     $contactIDs = array();
 498     if ($admin) {
 499       $query = "SELECT distinct( contact_id )
 500                         FROM civicrm_dashboard_contact
 501                         WHERE contact_id NOT IN (
 502                             SELECT distinct( contact_id )
 503                             FROM civicrm_dashboard_contact WHERE dashboard_id = {$dashlet->id}
 504                             )";
 505
 506       $dao = CRM_Core_DAO::executeQuery($query);
 507       while ($dao->fetch()) {
 508         $contactIDs[] = $dao->contact_id;
 509       }
 510     }
 511     else {
 512       //Get the id of Logged in User
 513       $session = CRM_Core_Session::singleton();
 514       $contactID = $session->get('userID');
 515       if (!empty($contactID)) {
 516         $contactIDs[] = $session->get('userID');
 517       }
 518     }
 519
 520     if (!empty($contactIDs)) {
 521       foreach ($contactIDs as $contactID) {
 522         $valuesArray[] = " ( {$dashlet->id}, {$contactID} )";
 523       }
 524
 525       $valuesString = implode(',', $valuesArray);
 526       $query = "
 527                   INSERT INTO civicrm_dashboard_contact ( dashboard_id, contact_id )
 528                   VALUES {$valuesString}";
 529
 530       CRM_Core_DAO::executeQuery($query);
 531     }
 532   }
 533
 534   /**
 535    * @param array $params
 536    *   Each item is a spec for a dashlet on the contact's dashboard.
 537    * @return bool
 538    */
 539   public static function addContactDashletToDashboard(&$params) {
 540     $valuesString = NULL;
 541     $columns = array();
 542     foreach ($params as $dashboardIDs) {
 543       $contactID = CRM_Utils_Array::value('contact_id', $dashboardIDs);
 544       $dashboardID = CRM_Utils_Array::value('dashboard_id', $dashboardIDs);
 545       $column = CRM_Utils_Array::value('column_no', $dashboardIDs, 0);
 546       $columns[$column][$dashboardID] = 0;
 547     }
 548     self::saveDashletChanges($columns, $contactID);
 549     return TRUE;
 550   }
 551
 552   /**
 553    * Reset dashlet cache.
 554    *
 555    * @param int $contactID
 556    *   Reset cache only for specific contact.
 557    */
 558   public static function resetDashletCache($contactID = NULL) {
 559     $whereClause = NULL;
 560     $params = array();
 561     if ($contactID) {
 562       $whereClause = "WHERE contact_id = %1";
 563       $params[1] = array($contactID, 'Integer');
 564     }
 565     $query = "UPDATE civicrm_dashboard_contact SET content = NULL $whereClause";
 566     $dao = CRM_Core_DAO::executeQuery($query, $params);
 567   }
 568
 569   /**
 570    * Delete Dashlet.
 571    *
 572    * @param int $dashletID
 573    *
 574    * @return bool
 575    */
 576   public static function deleteDashlet($dashletID) {
 577     $dashlet = new CRM_Core_DAO_Dashboard();
 578     $dashlet->id = $dashletID;
 579     $dashlet->delete();
 580     return TRUE;
 581   }
 582
 583 }