CRM/Case/XMLProcessor/Process.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.7                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2015                                |
   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-2015
  32  */
  33 class CRM_Case_XMLProcessor_Process extends CRM_Case_XMLProcessor {
  34   /**
  35    * Run.
  36    *
  37    * @param string $caseType
  38    * @param array $params
  39    *
  40    * @return bool
  41    * @throws Exception
  42    */
  43   public function run($caseType, &$params) {
  44     $xml = $this->retrieve($caseType);
  45
  46     if ($xml === FALSE) {
  47       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
  48       CRM_Core_Error::fatal(ts("Configuration file could not be retrieved for case type = '%1' %2.",
  49         array(1 => $caseType, 2 => $docLink)
  50       ));
  51       return FALSE;
  52     }
  53
  54     $xmlProcessorProcess = new CRM_Case_XMLProcessor_Process();
  55     $this->_isMultiClient = $xmlProcessorProcess->getAllowMultipleCaseClients();
  56
  57     $this->process($xml, $params);
  58   }
  59
  60   /**
  61    * @param $caseType
  62    * @param $fieldSet
  63    * @param bool $isLabel
  64    * @param bool $maskAction
  65    *
  66    * @return array|bool|mixed
  67    * @throws Exception
  68    */
  69   public function get($caseType, $fieldSet, $isLabel = FALSE, $maskAction = FALSE) {
  70     $xml = $this->retrieve($caseType);
  71     if ($xml === FALSE) {
  72       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
  73       CRM_Core_Error::fatal(ts("Unable to load configuration file for the referenced case type: '%1' %2.",
  74         array(1 => $caseType, 2 => $docLink)
  75       ));
  76       return FALSE;
  77     }
  78
  79     switch ($fieldSet) {
  80       case 'CaseRoles':
  81         return $this->caseRoles($xml->CaseRoles);
  82
  83       case 'ActivitySets':
  84         return $this->activitySets($xml->ActivitySets);
  85
  86       case 'ActivityTypes':
  87         return $this->activityTypes($xml->ActivityTypes, FALSE, $isLabel, $maskAction);
  88     }
  89   }
  90
  91   /**
  92    * @param $xml
  93    * @param array $params
  94    *
  95    * @throws Exception
  96    */
  97   public function process($xml, &$params) {
  98     $standardTimeline = CRM_Utils_Array::value('standardTimeline', $params);
  99     $activitySetName = CRM_Utils_Array::value('activitySetName', $params);
 100     $activityTypeName = CRM_Utils_Array::value('activityTypeName', $params);
 101
 102     if ('Open Case' == CRM_Utils_Array::value('activityTypeName', $params)) {
 103       // create relationships for the ones that are required
 104       foreach ($xml->CaseRoles as $caseRoleXML) {
 105         foreach ($caseRoleXML->RelationshipType as $relationshipTypeXML) {
 106           if ((int ) $relationshipTypeXML->creator == 1) {
 107             if (!$this->createRelationships((string ) $relationshipTypeXML->name,
 108               $params
 109             )
 110             ) {
 111               CRM_Core_Error::fatal();
 112               return FALSE;
 113             }
 114           }
 115         }
 116       }
 117     }
 118
 119     if ('Change Case Start Date' == CRM_Utils_Array::value('activityTypeName', $params)) {
 120       // delete all existing activities which are non-empty
 121       $this->deleteEmptyActivity($params);
 122     }
 123
 124     foreach ($xml->ActivitySets as $activitySetsXML) {
 125       foreach ($activitySetsXML->ActivitySet as $activitySetXML) {
 126         if ($standardTimeline) {
 127           if ((boolean ) $activitySetXML->timeline) {
 128             return $this->processStandardTimeline($activitySetXML,
 129               $params
 130             );
 131           }
 132         }
 133         elseif ($activitySetName) {
 134           $name = (string ) $activitySetXML->name;
 135           if ($name == $activitySetName) {
 136             return $this->processActivitySet($activitySetXML,
 137               $params
 138             );
 139           }
 140         }
 141       }
 142     }
 143   }
 144
 145   /**
 146    * @param $activitySetXML
 147    * @param array $params
 148    */
 149   public function processStandardTimeline($activitySetXML, &$params) {
 150     if ('Change Case Type' == CRM_Utils_Array::value('activityTypeName', $params)
 151       && CRM_Utils_Array::value('resetTimeline', $params, TRUE)
 152     ) {
 153       // delete all existing activities which are non-empty
 154       $this->deleteEmptyActivity($params);
 155     }
 156
 157     foreach ($activitySetXML->ActivityTypes as $activityTypesXML) {
 158       foreach ($activityTypesXML as $activityTypeXML) {
 159         $this->createActivity($activityTypeXML, $params);
 160       }
 161     }
 162   }
 163
 164   /**
 165    * @param $activitySetXML
 166    * @param array $params
 167    */
 168   public function processActivitySet($activitySetXML, &$params) {
 169     foreach ($activitySetXML->ActivityTypes as $activityTypesXML) {
 170       foreach ($activityTypesXML as $activityTypeXML) {
 171         $this->createActivity($activityTypeXML, $params);
 172       }
 173     }
 174   }
 175
 176   /**
 177    * @param $caseRolesXML
 178    * @param bool $isCaseManager
 179    *
 180    * @return array|mixed
 181    */
 182   public function &caseRoles($caseRolesXML, $isCaseManager = FALSE) {
 183     $relationshipTypes = &$this->allRelationshipTypes();
 184
 185     $result = array();
 186     foreach ($caseRolesXML as $caseRoleXML) {
 187       foreach ($caseRoleXML->RelationshipType as $relationshipTypeXML) {
 188         $relationshipTypeName = (string ) $relationshipTypeXML->name;
 189         $relationshipTypeID = array_search($relationshipTypeName,
 190           $relationshipTypes
 191         );
 192         if ($relationshipTypeID === FALSE) {
 193           continue;
 194         }
 195
 196         if (!$isCaseManager) {
 197           $result[$relationshipTypeID] = $relationshipTypeName;
 198         }
 199         elseif ($relationshipTypeXML->manager) {
 200           return $relationshipTypeID;
 201         }
 202       }
 203     }
 204     return $result;
 205   }
 206
 207   /**
 208    * @param string $relationshipTypeName
 209    * @param array $params
 210    *
 211    * @return bool
 212    * @throws Exception
 213    */
 214   public function createRelationships($relationshipTypeName, &$params) {
 215     $relationshipTypes = &$this->allRelationshipTypes();
 216     // get the relationship id
 217     $relationshipTypeID = array_search($relationshipTypeName, $relationshipTypes);
 218
 219     if ($relationshipTypeID === FALSE) {
 220       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
 221       CRM_Core_Error::fatal(ts('Relationship type %1, found in case configuration file, is not present in the database %2',
 222         array(1 => $relationshipTypeName, 2 => $docLink)
 223       ));
 224       return FALSE;
 225     }
 226
 227     $client = $params['clientID'];
 228     if (!is_array($client)) {
 229       $client = array($client);
 230     }
 231
 232     foreach ($client as $key => $clientId) {
 233       $relationshipParams = array(
 234         'relationship_type_id' => $relationshipTypeID,
 235         'contact_id_a' => $clientId,
 236         'contact_id_b' => $params['creatorID'],
 237         'is_active' => 1,
 238         'case_id' => $params['caseID'],
 239         'start_date' => date("Ymd"),
 240       );
 241
 242       if (!$this->createRelationship($relationshipParams)) {
 243         CRM_Core_Error::fatal();
 244         return FALSE;
 245       }
 246     }
 247     return TRUE;
 248   }
 249
 250   /**
 251    * @param array $params
 252    *
 253    * @return bool
 254    */
 255   public function createRelationship(&$params) {
 256     $dao = new CRM_Contact_DAO_Relationship();
 257     $dao->copyValues($params);
 258     // only create a relationship if it does not exist
 259     if (!$dao->find(TRUE)) {
 260       $dao->save();
 261     }
 262     return TRUE;
 263   }
 264
 265   /**
 266    * @param $activityTypesXML
 267    * @param bool $maxInst
 268    * @param bool $isLabel
 269    * @param bool $maskAction
 270    *
 271    * @return array
 272    */
 273   public function activityTypes($activityTypesXML, $maxInst = FALSE, $isLabel = FALSE, $maskAction = FALSE) {
 274     $activityTypes = &$this->allActivityTypes(TRUE, TRUE);
 275     $result = array();
 276     foreach ($activityTypesXML as $activityTypeXML) {
 277       foreach ($activityTypeXML as $recordXML) {
 278         $activityTypeName = (string ) $recordXML->name;
 279         $maxInstances = (string ) $recordXML->max_instances;
 280         $activityTypeInfo = CRM_Utils_Array::value($activityTypeName, $activityTypes);
 281
 282         if ($activityTypeInfo['id']) {
 283           if ($maskAction) {
 284             if ($maskAction == 'edit' && '0' === (string ) $recordXML->editable) {
 285               $result[$maskAction][] = $activityTypeInfo['id'];
 286             }
 287           }
 288           else {
 289             if (!$maxInst) {
 290               //if we want,labels of activities should be returned.
 291               if ($isLabel) {
 292                 $result[$activityTypeInfo['id']] = $activityTypeInfo['label'];
 293               }
 294               else {
 295                 $result[$activityTypeInfo['id']] = $activityTypeName;
 296               }
 297             }
 298             else {
 299               if ($maxInstances) {
 300                 $result[$activityTypeName] = $maxInstances;
 301               }
 302             }
 303           }
 304         }
 305       }
 306     }
 307
 308     // call option value hook
 309     CRM_Utils_Hook::optionValues($result, 'case_activity_type');
 310
 311     return $result;
 312   }
 313
 314   /**
 315    * @param SimpleXMLElement $caseTypeXML
 316    * @return array<string> symbolic activity-type names
 317    */
 318   public function getDeclaredActivityTypes($caseTypeXML) {
 319     $result = array();
 320
 321     if (!empty($caseTypeXML->ActivityTypes) && $caseTypeXML->ActivityTypes->ActivityType) {
 322       foreach ($caseTypeXML->ActivityTypes->ActivityType as $activityTypeXML) {
 323         $result[] = (string) $activityTypeXML->name;
 324       }
 325     }
 326
 327     if (!empty($caseTypeXML->ActivitySets) && $caseTypeXML->ActivitySets->ActivitySet) {
 328       foreach ($caseTypeXML->ActivitySets->ActivitySet as $activitySetXML) {
 329         if ($activitySetXML->ActivityTypes && $activitySetXML->ActivityTypes->ActivityType) {
 330           foreach ($activitySetXML->ActivityTypes->ActivityType as $activityTypeXML) {
 331             $result[] = (string) $activityTypeXML->name;
 332           }
 333         }
 334       }
 335     }
 336
 337     $result = array_unique($result);
 338     sort($result);
 339     return $result;
 340   }
 341
 342   /**
 343    * @param SimpleXMLElement $caseTypeXML
 344    * @return array<string> symbolic relationship-type names
 345    */
 346   public function getDeclaredRelationshipTypes($caseTypeXML) {
 347     $result = array();
 348
 349     if (!empty($caseTypeXML->CaseRoles) && $caseTypeXML->CaseRoles->RelationshipType) {
 350       foreach ($caseTypeXML->CaseRoles->RelationshipType as $relTypeXML) {
 351         $result[] = (string) $relTypeXML->name;
 352       }
 353     }
 354
 355     $result = array_unique($result);
 356     sort($result);
 357     return $result;
 358   }
 359
 360   /**
 361    * @param array $params
 362    */
 363   public function deleteEmptyActivity(&$params) {
 364     $activityContacts = CRM_Core_OptionGroup::values('activity_contacts', FALSE, FALSE, FALSE, NULL, 'name');
 365     $targetID = CRM_Utils_Array::key('Activity Targets', $activityContacts);
 366
 367     $query = "
 368 DELETE a
 369 FROM   civicrm_activity a
 370 INNER JOIN civicrm_activity_contact t ON t.activity_id = a.id
 371 INNER JOIN civicrm_case_activity ca on ca.activity_id = a.id
 372 WHERE  t.contact_id = %1
 373 AND    t.record_type_id = $targetID
 374 AND    a.is_auto = 1
 375 AND    a.is_current_revision = 1
 376 AND    ca.case_id = %2
 377 ";
 378     $sqlParams = array(1 => array($params['clientID'], 'Integer'), 2 => array($params['caseID'], 'Integer'));
 379     CRM_Core_DAO::executeQuery($query, $sqlParams);
 380   }
 381
 382   /**
 383    * @param array $params
 384    *
 385    * @return bool
 386    */
 387   public function isActivityPresent(&$params) {
 388     $query = "
 389 SELECT     count(a.id)
 390 FROM       civicrm_activity a
 391 INNER JOIN civicrm_case_activity ca on ca.activity_id = a.id
 392 WHERE      a.activity_type_id  = %1
 393 AND        ca.case_id = %2
 394 AND        a.is_deleted = 0
 395 ";
 396
 397     $sqlParams = array(
 398       1 => array($params['activityTypeID'], 'Integer'),
 399       2 => array($params['caseID'], 'Integer'),
 400     );
 401     $count = CRM_Core_DAO::singleValueQuery($query, $sqlParams);
 402
 403     // check for max instance
 404     $caseType = CRM_Case_BAO_Case::getCaseType($params['caseID'], 'name');
 405     $maxInstance = self::getMaxInstance($caseType, $params['activityTypeName']);
 406
 407     return $maxInstance ? ($count < $maxInstance ? FALSE : TRUE) : FALSE;
 408   }
 409
 410   /**
 411    * @param $activityTypeXML
 412    * @param array $params
 413    *
 414    * @return bool
 415    * @throws CRM_Core_Exception
 416    * @throws Exception
 417    */
 418   public function createActivity($activityTypeXML, &$params) {
 419     $activityTypeName = (string) $activityTypeXML->name;
 420     $activityTypes = &$this->allActivityTypes(TRUE, TRUE);
 421     $activityTypeInfo = CRM_Utils_Array::value($activityTypeName, $activityTypes);
 422
 423     if (!$activityTypeInfo) {
 424       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
 425       CRM_Core_Error::fatal(ts('Activity type %1, found in case configuration file, is not present in the database %2',
 426         array(1 => $activityTypeName, 2 => $docLink)
 427       ));
 428       return FALSE;
 429     }
 430
 431     $activityTypeID = $activityTypeInfo['id'];
 432
 433     if (isset($activityTypeXML->status)) {
 434       $statusName = (string) $activityTypeXML->status;
 435     }
 436     else {
 437       $statusName = 'Scheduled';
 438     }
 439
 440     if ($this->_isMultiClient) {
 441       $client = $params['clientID'];
 442     }
 443     else {
 444       $client = array(1 => $params['clientID']);
 445     }
 446
 447     //set order
 448     $orderVal = '';
 449     if (isset($activityTypeXML->order)) {
 450       $orderVal = (string) $activityTypeXML->order;
 451     }
 452
 453     if ($activityTypeName == 'Open Case') {
 454       $activityParams = array(
 455         'activity_type_id' => $activityTypeID,
 456         'source_contact_id' => $params['creatorID'],
 457         'is_auto' => FALSE,
 458         'is_current_revision' => 1,
 459         'subject' => CRM_Utils_Array::value('subject', $params) ? $params['subject'] : $activityTypeName,
 460         'status_id' => CRM_Core_OptionGroup::getValue('activity_status',
 461           $statusName,
 462           'name'
 463         ),
 464         'target_contact_id' => $client,
 465         'medium_id' => CRM_Utils_Array::value('medium_id', $params),
 466         'location' => CRM_Utils_Array::value('location', $params),
 467         'details' => CRM_Utils_Array::value('details', $params),
 468         'duration' => CRM_Utils_Array::value('duration', $params),
 469         'weight' => $orderVal,
 470       );
 471     }
 472     else {
 473       $activityParams = array(
 474         'activity_type_id' => $activityTypeID,
 475         'source_contact_id' => $params['creatorID'],
 476         'is_auto' => TRUE,
 477         'is_current_revision' => 1,
 478         'status_id' => CRM_Core_OptionGroup::getValue('activity_status',
 479           $statusName,
 480           'name'
 481         ),
 482         'target_contact_id' => $client,
 483         'weight' => $orderVal,
 484       );
 485     }
 486
 487     //parsing date to default preference format
 488     $params['activity_date_time'] = CRM_Utils_Date::processDate($params['activity_date_time']);
 489
 490     if ($activityTypeName == 'Open Case') {
 491       // we don't set activity_date_time for auto generated
 492       // activities, but we want it to be set for open case.
 493       $activityParams['activity_date_time'] = $params['activity_date_time'];
 494       if (array_key_exists('custom', $params) && is_array($params['custom'])) {
 495         $activityParams['custom'] = $params['custom'];
 496       }
 497
 498       // Add parameters for attachments
 499
 500       $numAttachments = CRM_Core_BAO_Setting::getItem(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME, 'max_attachments');
 501       for ($i = 1; $i <= $numAttachments; $i++) {
 502         $attachName = "attachFile_$i";
 503         if (isset($params[$attachName]) && !empty($params[$attachName])) {
 504           $activityParams[$attachName] = $params[$attachName];
 505         }
 506       }
 507     }
 508     else {
 509       $activityDate = NULL;
 510       //get date of reference activity if set.
 511       if ($referenceActivityName = (string) $activityTypeXML->reference_activity) {
 512
 513         //we skip open case as reference activity.CRM-4374.
 514         if (!empty($params['resetTimeline']) && $referenceActivityName == 'Open Case') {
 515           $activityDate = $params['activity_date_time'];
 516         }
 517         else {
 518           $referenceActivityInfo = CRM_Utils_Array::value($referenceActivityName, $activityTypes);
 519           if ($referenceActivityInfo['id']) {
 520             $caseActivityParams = array('activity_type_id' => $referenceActivityInfo['id']);
 521
 522             //if reference_select is set take according activity.
 523             if ($referenceSelect = (string) $activityTypeXML->reference_select) {
 524               $caseActivityParams[$referenceSelect] = 1;
 525             }
 526
 527             $referenceActivity = CRM_Case_BAO_Case::getCaseActivityDates($params['caseID'], $caseActivityParams, TRUE);
 528
 529             if (is_array($referenceActivity)) {
 530               foreach ($referenceActivity as $aId => $details) {
 531                 $activityDate = CRM_Utils_Array::value('activity_date', $details);
 532                 break;
 533               }
 534             }
 535           }
 536         }
 537       }
 538       if (!$activityDate) {
 539         $activityDate = $params['activity_date_time'];
 540       }
 541       list($activity_date, $activity_time) = CRM_Utils_Date::setDateDefaults($activityDate);
 542       $activityDateTime = CRM_Utils_Date::processDate($activity_date, $activity_time);
 543       //add reference offset to date.
 544       if ((int) $activityTypeXML->reference_offset) {
 545         $activityDateTime = CRM_Utils_Date::intervalAdd('day', (int) $activityTypeXML->reference_offset,
 546           $activityDateTime
 547         );
 548       }
 549
 550       $activityParams['activity_date_time'] = CRM_Utils_Date::format($activityDateTime);
 551     }
 552
 553     // if same activity is already there, skip and dont touch
 554     $params['activityTypeID'] = $activityTypeID;
 555     $params['activityTypeName'] = $activityTypeName;
 556     if ($this->isActivityPresent($params)) {
 557       return TRUE;
 558     }
 559     $activityParams['case_id'] = $params['caseID'];
 560     if (!empty($activityParams['is_auto'])) {
 561       $activityParams['skipRecentView'] = TRUE;
 562     }
 563
 564     $activity = CRM_Activity_BAO_Activity::create($activityParams);
 565
 566     if (!$activity) {
 567       CRM_Core_Error::fatal();
 568       return FALSE;
 569     }
 570
 571     // create case activity record
 572     $caseParams = array(
 573       'activity_id' => $activity->id,
 574       'case_id' => $params['caseID'],
 575     );
 576     CRM_Case_BAO_Case::processCaseActivity($caseParams);
 577     return TRUE;
 578   }
 579
 580   /**
 581    * @param $activitySetsXML
 582    *
 583    * @return array
 584    */
 585   public static function activitySets($activitySetsXML) {
 586     $result = array();
 587     foreach ($activitySetsXML as $activitySetXML) {
 588       foreach ($activitySetXML as $recordXML) {
 589         $activitySetName = (string ) $recordXML->name;
 590         $activitySetLabel = (string ) $recordXML->label;
 591         $result[$activitySetName] = $activitySetLabel;
 592       }
 593     }
 594
 595     return $result;
 596   }
 597
 598   /**
 599    * @param $caseType
 600    * @param null $activityTypeName
 601    *
 602    * @return array|bool|mixed
 603    * @throws Exception
 604    */
 605   public function getMaxInstance($caseType, $activityTypeName = NULL) {
 606     $xml = $this->retrieve($caseType);
 607
 608     if ($xml === FALSE) {
 609       CRM_Core_Error::fatal();
 610       return FALSE;
 611     }
 612
 613     $activityInstances = $this->activityTypes($xml->ActivityTypes, TRUE);
 614     return $activityTypeName ? CRM_Utils_Array::value($activityTypeName, $activityInstances) : $activityInstances;
 615   }
 616
 617   /**
 618    * @param $caseType
 619    *
 620    * @return array|mixed
 621    */
 622   public function getCaseManagerRoleId($caseType) {
 623     $xml = $this->retrieve($caseType);
 624     return $this->caseRoles($xml->CaseRoles, TRUE);
 625   }
 626
 627   /**
 628    * @param string $caseType
 629    * @return array<\Civi\CCase\CaseChangeListener>
 630    */
 631   public function getListeners($caseType) {
 632     $xml = $this->retrieve($caseType);
 633     $listeners = array();
 634     if ($xml->Listeners && $xml->Listeners->Listener) {
 635       foreach ($xml->Listeners->Listener as $listenerXML) {
 636         $class = (string) $listenerXML;
 637         $listeners[] = new $class();
 638       }
 639     }
 640     return $listeners;
 641   }
 642
 643   /**
 644    * @return int
 645    */
 646   public function getRedactActivityEmail() {
 647     $xml = $this->retrieve("Settings");
 648     return ( string ) $xml->RedactActivityEmail ? 1 : 0;
 649   }
 650
 651   /**
 652    * Retrieves AllowMultipleCaseClients setting.
 653    *
 654    * @return string
 655    *   1 if allowed, 0 if not
 656    */
 657   public function getAllowMultipleCaseClients() {
 658     $xml = $this->retrieve("Settings");
 659     if ($xml) {
 660       return ( string ) $xml->AllowMultipleCaseClients ? 1 : 0;
 661     }
 662     return 0;
 663   }
 664
 665   /**
 666    * Retrieves NaturalActivityTypeSort setting.
 667    *
 668    * @return string
 669    *   1 if natural, 0 if alphabetic
 670    */
 671   public function getNaturalActivityTypeSort() {
 672     $xml = $this->retrieve("Settings");
 673     return ( string ) $xml->NaturalActivityTypeSort ? 1 : 0;
 674   }
 675
 676 }