CRM/Case/XMLProcessor/Process.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.3                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2013                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26 */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2013
  32  * $Id$
  33  *
  34  */
  35 class CRM_Case_XMLProcessor_Process extends CRM_Case_XMLProcessor {
  36   function run($caseType, &$params) {
  37     $xml = $this->retrieve($caseType);
  38
  39     if ($xml === FALSE) {
  40       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
  41       CRM_Core_Error::fatal(ts("Configuration file could not be retrieved for case type = '%1' %2.",
  42           array(1 => $caseType, 2 => $docLink)
  43         ));
  44       return FALSE;
  45     }
  46
  47     $xmlProcessorProcess = new CRM_Case_XMLProcessor_Process();
  48     $this->_isMultiClient = $xmlProcessorProcess->getAllowMultipleCaseClients();
  49
  50     $this->process($xml, $params);
  51   }
  52
  53   function get($caseType, $fieldSet, $isLabel = FALSE, $maskAction = FALSE) {
  54     $xml = $this->retrieve($caseType);
  55     if ($xml === FALSE) {
  56       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
  57       CRM_Core_Error::fatal(ts("Unable to load configuration file for the referenced case type: '%1' %2.",
  58           array(1 => $caseType, 2 => $docLink)
  59         ));
  60       return FALSE;
  61     }
  62
  63     switch ($fieldSet) {
  64       case 'CaseRoles':
  65         return $this->caseRoles($xml->CaseRoles);
  66
  67       case 'ActivitySets':
  68         return $this->activitySets($xml->ActivitySets);
  69
  70       case 'ActivityTypes':
  71         return $this->activityTypes($xml->ActivityTypes, FALSE, $isLabel, $maskAction);
  72     }
  73   }
  74
  75   function process($xml, &$params) {
  76     $standardTimeline = CRM_Utils_Array::value('standardTimeline', $params);
  77     $activitySetName  = CRM_Utils_Array::value('activitySetName', $params);
  78     $activityTypeName = CRM_Utils_Array::value('activityTypeName', $params);
  79
  80     if ('Open Case' == CRM_Utils_Array::value('activityTypeName', $params)) {
  81       // create relationships for the ones that are required
  82       foreach ($xml->CaseRoles as $caseRoleXML) {
  83         foreach ($caseRoleXML->RelationshipType as $relationshipTypeXML) {
  84           if ((int ) $relationshipTypeXML->creator == 1) {
  85             if (!$this->createRelationships((string ) $relationshipTypeXML->name,
  86                 $params
  87               )) {
  88               CRM_Core_Error::fatal();
  89               return FALSE;
  90             }
  91           }
  92         }
  93       }
  94     }
  95
  96     if ('Change Case Start Date' == CRM_Utils_Array::value('activityTypeName', $params)) {
  97       // delete all existing activities which are non-empty
  98       $this->deleteEmptyActivity($params);
  99     }
 100
 101     foreach ($xml->ActivitySets as $activitySetsXML) {
 102       foreach ($activitySetsXML->ActivitySet as $activitySetXML) {
 103         if ($standardTimeline) {
 104           if ((boolean ) $activitySetXML->timeline) {
 105             return $this->processStandardTimeline($activitySetXML,
 106               $params
 107             );
 108           }
 109         }
 110         elseif ($activitySetName) {
 111           $name = (string ) $activitySetXML->name;
 112           if ($name == $activitySetName) {
 113             return $this->processActivitySet($activitySetXML,
 114               $params
 115             );
 116           }
 117         }
 118       }
 119     }
 120   }
 121
 122   function processStandardTimeline($activitySetXML, &$params) {
 123     if ('Change Case Type' == CRM_Utils_Array::value('activityTypeName', $params)
 124       && CRM_Utils_Array::value('resetTimeline', $params, TRUE)) {
 125       // delete all existing activities which are non-empty
 126       $this->deleteEmptyActivity($params);
 127     }
 128
 129     foreach ($activitySetXML->ActivityTypes as $activityTypesXML) {
 130       foreach ($activityTypesXML as $activityTypeXML) {
 131         $this->createActivity($activityTypeXML, $params);
 132       }
 133     }
 134   }
 135
 136   function processActivitySet($activitySetXML, &$params) {
 137     foreach ($activitySetXML->ActivityTypes as $activityTypesXML) {
 138       foreach ($activityTypesXML as $activityTypeXML) {
 139         $this->createActivity($activityTypeXML, $params);
 140       }
 141     }
 142   }
 143
 144   function &caseRoles($caseRolesXML, $isCaseManager = FALSE) {
 145     $relationshipTypes = &$this->allRelationshipTypes();
 146
 147     $result = array();
 148     foreach ($caseRolesXML as $caseRoleXML) {
 149       foreach ($caseRoleXML->RelationshipType as $relationshipTypeXML) {
 150         $relationshipTypeName = (string ) $relationshipTypeXML->name;
 151         $relationshipTypeID = array_search($relationshipTypeName,
 152           $relationshipTypes
 153         );
 154         if ($relationshipTypeID === FALSE) {
 155           continue;
 156         }
 157
 158         if (!$isCaseManager) {
 159           $result[$relationshipTypeID] = $relationshipTypeName;
 160         }
 161         elseif ($relationshipTypeXML->manager) {
 162           return $relationshipTypeID;
 163         }
 164       }
 165     }
 166     return $result;
 167   }
 168
 169   function createRelationships($relationshipTypeName, &$params) {
 170     $relationshipTypes = &$this->allRelationshipTypes();
 171     // get the relationship id
 172     $relationshipTypeID = array_search($relationshipTypeName, $relationshipTypes);
 173
 174     if ($relationshipTypeID === FALSE) {
 175       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
 176       CRM_Core_Error::fatal(ts('Relationship type %1, found in case configuration file, is not present in the database %2',
 177           array(1 => $relationshipTypeName, 2 => $docLink)
 178         ));
 179       return FALSE;
 180     }
 181
 182     $client = $params['clientID'];
 183     if (!is_array($client)) {
 184       $client = array($client);
 185     }
 186
 187     foreach ($client as $key => $clientId) {
 188       $relationshipParams = array(
 189         'relationship_type_id' => $relationshipTypeID,
 190         'contact_id_a' => $clientId,
 191         'contact_id_b' => $params['creatorID'],
 192         'is_active' => 1,
 193         'case_id' => $params['caseID'],
 194         'start_date' => date("Ymd"),
 195       );
 196
 197       if (!$this->createRelationship($relationshipParams)) {
 198         CRM_Core_Error::fatal();
 199         return FALSE;
 200       }
 201     }
 202     return TRUE;
 203   }
 204
 205   function createRelationship(&$params) {
 206     $dao = new CRM_Contact_DAO_Relationship();
 207     $dao->copyValues($params);
 208     // only create a relationship if it does not exist
 209     if (!$dao->find(TRUE)) {
 210       $dao->save();
 211     }
 212     return TRUE;
 213   }
 214
 215   function activityTypes($activityTypesXML, $maxInst = FALSE, $isLabel = FALSE, $maskAction = FALSE) {
 216     $activityTypes = &$this->allActivityTypes(TRUE, TRUE);
 217     $result = array();
 218     foreach ($activityTypesXML as $activityTypeXML) {
 219       foreach ($activityTypeXML as $recordXML) {
 220         $activityTypeName = (string ) $recordXML->name;
 221         $maxInstances     = (string ) $recordXML->max_instances;
 222         $activityTypeInfo = CRM_Utils_Array::value($activityTypeName, $activityTypes);
 223
 224         if ($activityTypeInfo['id']) {
 225           if ($maskAction) {
 226             if ($maskAction == 'edit' && '0' === (string ) $recordXML->editable) {
 227               $result[$maskAction][] = $activityTypeInfo['id'];
 228             }
 229           }
 230           else {
 231             if (!$maxInst) {
 232               //if we want,labels of activities should be returned.
 233               if ($isLabel) {
 234                 $result[$activityTypeInfo['id']] = $activityTypeInfo['label'];
 235               }
 236               else {
 237                 $result[$activityTypeInfo['id']] = $activityTypeName;
 238               }
 239             }
 240             else {
 241               if ($maxInstances) {
 242                 $result[$activityTypeName] = $maxInstances;
 243               }
 244             }
 245           }
 246         }
 247       }
 248     }
 249
 250     // call option value hook
 251     CRM_Utils_Hook::optionValues($result, 'case_activity_type');
 252
 253     return $result;
 254   }
 255
 256   function deleteEmptyActivity(&$params) {
 257     $query = "
 258 DELETE a
 259 FROM   civicrm_activity a
 260 INNER JOIN civicrm_activity_target t ON t.activity_id = a.id
 261 WHERE  t.target_contact_id = %1
 262 AND    a.is_auto = 1
 263 AND    a.is_current_revision = 1
 264 ";
 265     $sqlParams = array(1 => array($params['clientID'], 'Integer'));
 266     CRM_Core_DAO::executeQuery($query, $sqlParams);
 267   }
 268
 269   function isActivityPresent(&$params) {
 270     $query = "
 271 SELECT     count(a.id)
 272 FROM       civicrm_activity a
 273 INNER JOIN civicrm_case_activity ca on ca.activity_id = a.id
 274 WHERE      a.activity_type_id  = %1
 275 AND        ca.case_id = %2
 276 AND        a.is_deleted = 0
 277 ";
 278
 279     $sqlParams = array(1 => array($params['activityTypeID'], 'Integer'),
 280       2 => array($params['caseID'], 'Integer'),
 281     );
 282     $count = CRM_Core_DAO::singleValueQuery($query, $sqlParams);
 283
 284     // check for max instance
 285     $caseType = CRM_Case_BAO_Case::getCaseType($params['caseID'], 'name');
 286     $maxInstance = self::getMaxInstance($caseType, $params['activityTypeName']);
 287
 288     return $maxInstance ? ($count < $maxInstance ? FALSE : TRUE) : FALSE;
 289   }
 290
 291   function createActivity($activityTypeXML, &$params) {
 292     $activityTypeName = (string) $activityTypeXML->name;
 293     $activityTypes    = &$this->allActivityTypes(TRUE, TRUE);
 294     $activityTypeInfo = CRM_Utils_Array::value($activityTypeName, $activityTypes);
 295
 296     if (!$activityTypeInfo) {
 297       $docLink = CRM_Utils_System::docURL2("user/case-management/setup");
 298       CRM_Core_Error::fatal(ts('Activity type %1, found in case configuration file, is not present in the database %2',
 299           array(1 => $activityTypeName, 2 => $docLink)
 300         ));
 301       return FALSE;
 302     }
 303
 304     $activityTypeID = $activityTypeInfo['id'];
 305
 306     if (isset($activityTypeXML->status)) {
 307       $statusName = (string) $activityTypeXML->status;
 308     }
 309     else {
 310       $statusName = 'Scheduled';
 311     }
 312
 313     if ($this->_isMultiClient) {
 314       $client = $params['clientID'];
 315     }
 316     else {
 317       $client = array(1 => $params['clientID']);
 318     }
 319
 320     //set order
 321     $orderVal = '';
 322     if (isset($activityTypeXML->order)) {
 323       $orderVal = (string) $activityTypeXML->order;
 324     }
 325
 326     if ($activityTypeName == 'Open Case') {
 327       $activityParams = array(
 328         'activity_type_id' => $activityTypeID,
 329         'source_contact_id' => $params['creatorID'],
 330         'is_auto' => FALSE,
 331         'is_current_revision' => 1,
 332         'subject' => CRM_Utils_Array::value('subject', $params) ? $params['subject'] : $activityTypeName,
 333         'status_id' => CRM_Core_OptionGroup::getValue('activity_status',
 334           $statusName,
 335           'name'
 336         ),
 337         'target_contact_id' => $client,
 338         'medium_id' => CRM_Utils_Array::value('medium_id', $params),
 339         'location' => CRM_Utils_Array::value('location', $params),
 340         'details' => CRM_Utils_Array::value('details', $params),
 341         'duration' => CRM_Utils_Array::value('duration', $params),
 342         'weight' => $orderVal,
 343       );
 344     }
 345     else {
 346       $activityParams = array(
 347         'activity_type_id' => $activityTypeID,
 348         'source_contact_id' => $params['creatorID'],
 349         'is_auto' => TRUE,
 350         'is_current_revision' => 1,
 351         'status_id' => CRM_Core_OptionGroup::getValue('activity_status',
 352           $statusName,
 353           'name'
 354         ),
 355         'target_contact_id' => $client,
 356         'weight' => $orderVal,
 357       );
 358     }
 359
 360     //parsing date to default preference format
 361     $params['activity_date_time'] = CRM_Utils_Date::processDate($params['activity_date_time']);
 362
 363     if ($activityTypeName == 'Open Case') {
 364       // we don't set activity_date_time for auto generated
 365       // activities, but we want it to be set for open case.
 366       $activityParams['activity_date_time'] = $params['activity_date_time'];
 367       if (array_key_exists('custom', $params) && is_array($params['custom'])) {
 368         $activityParams['custom'] = $params['custom'];
 369       }
 370
 371       // Add parameters for attachments
 372
 373       $numAttachments = CRM_Core_BAO_Setting::getItem(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME, 'max_attachments');
 374       for ( $i = 1; $i <= $numAttachments; $i++ ) {
 375         $attachName = "attachFile_$i";
 376         if ( isset( $params[$attachName] ) && !empty( $params[$attachName] ) ) {
 377           $activityParams[$attachName] = $params[$attachName];
 378         }
 379       }
 380     }
 381     else {
 382       $activityDate = NULL;
 383       //get date of reference activity if set.
 384       if ($referenceActivityName = (string) $activityTypeXML->reference_activity) {
 385
 386         //we skip open case as reference activity.CRM-4374.
 387         if (CRM_Utils_Array::value('resetTimeline', $params) && $referenceActivityName == 'Open Case') {
 388           $activityDate = $params['activity_date_time'];
 389         }
 390         else {
 391           $referenceActivityInfo = CRM_Utils_Array::value($referenceActivityName, $activityTypes);
 392           if ($referenceActivityInfo['id']) {
 393             $caseActivityParams = array('activity_type_id' => $referenceActivityInfo['id']);
 394
 395             //if reference_select is set take according activity.
 396             if ($referenceSelect = (string) $activityTypeXML->reference_select) {
 397               $caseActivityParams[$referenceSelect] = 1;
 398             }
 399
 400             $referenceActivity = CRM_Case_BAO_Case::getCaseActivityDates($params['caseID'], $caseActivityParams, TRUE);
 401
 402             if (is_array($referenceActivity)) {
 403               foreach ($referenceActivity as $aId => $details) {
 404                 $activityDate = CRM_Utils_Array::value('activity_date', $details);
 405                 break;
 406               }
 407             }
 408           }
 409         }
 410       }
 411       if (!$activityDate) {
 412         $activityDate = $params['activity_date_time'];
 413       }
 414       list($activity_date, $activity_time) = CRM_Utils_Date::setDateDefaults($activityDate);
 415       $activityDateTime = CRM_Utils_Date::processDate($activity_date, $activity_time);
 416       //add reference offset to date.
 417       if ((int) $activityTypeXML->reference_offset) {
 418         $activityDateTime = CRM_Utils_Date::intervalAdd('day', (int) $activityTypeXML->reference_offset,
 419           $activityDateTime
 420         );
 421       }
 422
 423       $activityParams['activity_date_time'] = CRM_Utils_Date::format($activityDateTime);
 424     }
 425
 426     // if same activity is already there, skip and dont touch
 427     $params['activityTypeID'] = $activityTypeID;
 428     $params['activityTypeName'] = $activityTypeName;
 429     if ($this->isActivityPresent($params)) {
 430       return TRUE;
 431     }
 432     $activityParams['case_id'] = $params['caseID'];
 433     if (CRM_Utils_Array::value('is_auto', $activityParams)) {
 434       $activityParams['skipRecentView'] = TRUE;
 435     }
 436
 437     $activity = CRM_Activity_BAO_Activity::create($activityParams);
 438
 439     if (!$activity) {
 440       CRM_Core_Error::fatal();
 441       return FALSE;
 442     }
 443
 444     // create case activity record
 445     $caseParams = array(
 446       'activity_id' => $activity->id,
 447       'case_id' => $params['caseID'],
 448     );
 449     CRM_Case_BAO_Case::processCaseActivity($caseParams);
 450     return TRUE;
 451   }
 452
 453   function activitySets($activitySetsXML) {
 454     $result = array();
 455     foreach ($activitySetsXML as $activitySetXML) {
 456       foreach ($activitySetXML as $recordXML) {
 457         $activitySetName = (string ) $recordXML->name;
 458         $activitySetLabel = (string ) $recordXML->label;
 459         $result[$activitySetName] = $activitySetLabel;
 460       }
 461     }
 462
 463     return $result;
 464   }
 465
 466   function getMaxInstance($caseType, $activityTypeName = NULL) {
 467     $xml = $this->retrieve($caseType);
 468
 469     if ($xml === FALSE) {
 470       CRM_Core_Error::fatal();
 471       return FALSE;
 472     }
 473
 474     $activityInstances = $this->activityTypes($xml->ActivityTypes, TRUE);
 475     return $activityTypeName ? CRM_Utils_Array::value($activityTypeName, $activityInstances) : $activityInstances;
 476   }
 477
 478   function getCaseManagerRoleId($caseType) {
 479     $xml = $this->retrieve($caseType);
 480     return $this->caseRoles($xml->CaseRoles, TRUE);
 481   }
 482
 483   function getRedactActivityEmail() {
 484     $xml = $this->retrieve("Settings");
 485     return ( string ) $xml->RedactActivityEmail ? 1 : 0;
 486   }
 487
 488   /**
 489    * Retrieves AllowMultipleCaseClients setting
 490    *
 491    * @return string 1 if allowed, 0 if not
 492    */
 493   function getAllowMultipleCaseClients() {
 494     $xml = $this->retrieve("Settings");
 495     if ($xml) {
 496       return ( string ) $xml->AllowMultipleCaseClients ? 1 : 0;
 497     }
 498     return 0;
 499   }
 500
 501   /**
 502    * Retrieves NaturalActivityTypeSort setting
 503    *
 504    * @return string 1 if natural, 0 if alphabetic
 505    */
 506   function getNaturalActivityTypeSort() {
 507     $xml = $this->retrieve("Settings");
 508     return ( string ) $xml->NaturalActivityTypeSort ? 1 : 0;
 509   }
 510 }
 511