tests/phpunit/CRM/Activity/BAO/ActivityTest.php

   1 <?php
   2
   3 /**
   4  * Class CRM_Activity_BAO_ActivityTest
   5  * @group headless
   6  */
   7 class CRM_Activity_BAO_ActivityTest extends CiviUnitTestCase {
   8
   9   private $allowedContactsACL = [];
  10
  11   public function setUp() {
  12     parent::setUp();
  13     $this->prepareForACLs();
  14     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['view all contacts', 'access CiviCRM'];
  15     $this->setupForSmsTests();
  16   }
  17
  18   /**
  19    * Clean up after tests.
  20    */
  21   public function tearDown() {
  22     $tablesToTruncate = [
  23       'civicrm_activity',
  24       'civicrm_activity_contact',
  25       'civicrm_uf_match',
  26       'civicrm_campaign',
  27       'civicrm_email',
  28     ];
  29     $this->quickCleanup($tablesToTruncate);
  30     $this->cleanUpAfterACLs();
  31     $this->setupForSmsTests(TRUE);
  32     parent::tearDown();
  33   }
  34
  35   /**
  36    * Test case for create() method.
  37    */
  38   public function testCreate() {
  39     $contactId = $this->individualCreate();
  40
  41     $params = [
  42       'source_contact_id' => $contactId,
  43       'subject' => 'Scheduling Meeting',
  44       'activity_type_id' => 2,
  45     ];
  46
  47     CRM_Activity_BAO_Activity::create($params);
  48
  49     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
  50       'subject', 'Database check for created activity.'
  51     );
  52
  53     // Now call create() to modify an existing Activity.
  54     $params = [
  55       'id' => $activityId,
  56       'source_contact_id' => $contactId,
  57       'subject' => 'Scheduling Interview',
  58       'activity_type_id' => 3,
  59     ];
  60
  61     CRM_Activity_BAO_Activity::create($params);
  62
  63     $activityTypeId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Interview',
  64       'activity_type_id',
  65       'subject', 'Database check on updated activity record.'
  66     );
  67     $this->assertEquals($activityTypeId, 3, 'Verify activity type id is 3.');
  68
  69     $this->contactDelete($contactId);
  70   }
  71
  72   /**
  73    * Test case for getContactActivity() method.
  74    *
  75    * getContactActivity() method get activities detail for given target contact id.
  76    */
  77   public function testGetContactActivity() {
  78     $contactId = $this->individualCreate();
  79     $params = [
  80       'first_name' => 'liz',
  81       'last_name' => 'hurleey',
  82     ];
  83     $targetContactId = $this->individualCreate($params);
  84
  85     $params = [
  86       'source_contact_id' => $contactId,
  87       'subject' => 'Scheduling Meeting',
  88       'activity_type_id' => 2,
  89       'target_contact_id' => [$targetContactId],
  90       'activity_date_time' => date('Ymd'),
  91     ];
  92
  93     $this->callAPISuccess('Activity', 'create', $params);
  94
  95     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting',
  96       'id',
  97       'subject', 'Database check for created activity.'
  98     );
  99
 100     // @todo - remove this deprecated functions
 101     $activities = CRM_Activity_BAO_Activity::getContactActivity($targetContactId);
 102
 103     $this->assertEquals($activities[$activityId]['subject'], 'Scheduling Meeting', 'Verify activity subject is correct.');
 104
 105     $this->contactDelete($contactId);
 106     $this->contactDelete($targetContactId);
 107   }
 108
 109   /**
 110    * Test case for retrieve() method.
 111    *
 112    * Retrieve($params, $defaults) method return activity detail for given params
 113    *                              and set defaults.
 114    */
 115   public function testRetrieve() {
 116     $contactId = $this->individualCreate();
 117     $params = [
 118       'first_name' => 'liz',
 119       'last_name' => 'hurleey',
 120     ];
 121     $targetContactId = $this->individualCreate($params);
 122
 123     $params = [
 124       'source_contact_id' => $contactId,
 125       'subject' => 'Scheduling Meeting',
 126       'activity_type_id' => 2,
 127       'target_contact_id' => [$targetContactId],
 128       'activity_date_time' => date('Ymd'),
 129     ];
 130
 131     CRM_Activity_BAO_Activity::create($params);
 132
 133     $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 134       'subject', 'Database check for created activity.'
 135     );
 136
 137     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact', $targetContactId,
 138       'id', 'contact_id',
 139       'Database check for created activity target.'
 140     );
 141
 142     $defaults = [];
 143     $activity = CRM_Activity_BAO_Activity::retrieve($params, $defaults);
 144
 145     $this->assertEquals($activity->subject, 'Scheduling Meeting', 'Verify activity subject is correct.');
 146     $this->assertEquals($activity->activity_type_id, 2, 'Verify activity type id is correct.');
 147     $this->assertEquals($defaults['source_contact_id'], $contactId, 'Verify source contact id is correct.');
 148
 149     $this->assertEquals($defaults['subject'], 'Scheduling Meeting', 'Verify activity subject is correct.');
 150     $this->assertEquals($defaults['activity_type_id'], 2, 'Verify activity type id is correct.');
 151
 152     $this->assertEquals($defaults['target_contact'][0], $targetContactId, 'Verify target contact id is correct.');
 153
 154     $this->contactDelete($contactId);
 155     $this->contactDelete($targetContactId);
 156   }
 157
 158   /**
 159    * Test Assigning a target contact but then the logged in user cannot see the contact
 160    */
 161   public function testTargetContactNotavaliable() {
 162     $contactId = $this->individualCreate();
 163     $params = [
 164       'first_name' => 'liz',
 165       'last_name' => 'hurleey',
 166     ];
 167     $targetContactId = $this->individualCreate($params);
 168
 169     $params = [
 170       'source_contact_id' => $contactId,
 171       'subject' => 'Scheduling Meeting',
 172       'activity_type_id' => 2,
 173       'target_contact_id' => [$targetContactId],
 174       'activity_date_time' => date('Ymd'),
 175     ];
 176
 177     CRM_Activity_BAO_Activity::create($params);
 178
 179     // set custom hook
 180     $this->hookClass->setHook('civicrm_aclWhereClause', [$this, 'hook_civicrm_aclWhereClause']);
 181
 182     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['access CiviCRM'];
 183
 184     $this->allowedContactsACL = [$contactId];
 185
 186     // get logged in user
 187     $user_id = $this->createLoggedInUser();
 188     $activityGetParams = CRM_Core_Page_AJAX::defaultSortAndPagerParams();
 189     $activityGetParams += ['contact_id' => $contactId];
 190     $activities = CRM_Activity_BAO_Activity::getContactActivitySelector($activityGetParams);
 191     // Aseert that we have sensible data to display in the contact tab
 192     $this->assertEquals('Anderson, Anthony', $activities['data'][0]['source_contact_name']);
 193     // Note that becasue there is a target contact but it is not accessable the output is an empty string not n/a
 194     $this->assertEquals('', $activities['data'][0]['target_contact_name']);
 195     // verify that doing the underlying query shows we get a target contact_id
 196     $this->assertEquals(1, CRM_Activity_BAO_Activity::getActivities(['contact_id' => $contactId])[1]['target_contact_count']);
 197     $this->cleanUpAfterACLs();
 198   }
 199
 200   /**
 201    * Test case for deleteActivity() method.
 202    *
 203    * deleteActivity($params) method deletes activity for given params.
 204    */
 205   public function testDeleteActivity() {
 206     $contactId = $this->individualCreate();
 207     $params = [
 208       'first_name' => 'liz',
 209       'last_name' => 'hurleey',
 210     ];
 211     $targetContactId = $this->individualCreate($params);
 212
 213     $params = [
 214       'source_contact_id' => $contactId,
 215       'source_record_id' => $contactId,
 216       'subject' => 'Scheduling Meeting',
 217       'activity_type_id' => 2,
 218       'target_contact_id' => [$targetContactId],
 219       'activity_date_time' => date('Ymd'),
 220     ];
 221
 222     CRM_Activity_BAO_Activity::create($params);
 223
 224     $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 225       'subject', 'Database check for created activity.'
 226     );
 227
 228     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact', $targetContactId,
 229       'id', 'contact_id',
 230       'Database check for created activity target.'
 231     );
 232     $params = [
 233       'source_contact_id' => $contactId,
 234       'source_record_id' => $contactId,
 235       'subject' => 'Scheduling Meeting',
 236       'activity_type_id' => 2,
 237     ];
 238
 239     CRM_Activity_BAO_Activity::deleteActivity($params);
 240
 241     $this->assertDBNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 242       'subject', 'Database check for deleted activity.'
 243     );
 244     $this->contactDelete($contactId);
 245     $this->contactDelete($targetContactId);
 246   }
 247
 248   /**
 249    * Test case for deleteActivityTarget() method.
 250    *
 251    * deleteActivityTarget($activityId) method deletes activity target for given activity id.
 252    */
 253   public function testDeleteActivityTarget() {
 254     $contactId = $this->individualCreate();
 255     $params = [
 256       'first_name' => 'liz',
 257       'last_name' => 'hurleey',
 258     ];
 259     $targetContactId = $this->individualCreate($params);
 260
 261     $params = [
 262       'source_contact_id' => $contactId,
 263       'subject' => 'Scheduling Meeting',
 264       'activity_type_id' => 2,
 265       'target_contact_id' => [$targetContactId],
 266       'activity_date_time' => date('Ymd'),
 267     ];
 268
 269     CRM_Activity_BAO_Activity::create($params);
 270
 271     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 272       'subject', 'Database check for created activity.'
 273     );
 274
 275     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact', $targetContactId,
 276       'id', 'contact_id',
 277       'Database check for created activity target.'
 278     );
 279
 280     CRM_Activity_BAO_Activity::deleteActivityContact($activityId, 3);
 281
 282     $this->assertDBNull('CRM_Activity_DAO_ActivityContact', $targetContactId, 'id',
 283       'contact_id', 'Database check for deleted activity target.'
 284     );
 285
 286     $this->contactDelete($contactId);
 287     $this->contactDelete($targetContactId);
 288   }
 289
 290   /**
 291    * Test case for deleteActivityAssignment() method.
 292    *
 293    * deleteActivityAssignment($activityId) method deletes activity assignment for given activity id.
 294    */
 295   public function testDeleteActivityAssignment() {
 296     $contactId = $this->individualCreate();
 297     $params = [
 298       'first_name' => 'liz',
 299       'last_name' => 'hurleey',
 300     ];
 301     $assigneeContactId = $this->individualCreate($params);
 302
 303     $params = [
 304       'source_contact_id' => $contactId,
 305       'subject' => 'Scheduling Meeting',
 306       'activity_type_id' => 2,
 307       'assignee_contact_id' => [$assigneeContactId],
 308       'activity_date_time' => date('Ymd'),
 309     ];
 310
 311     CRM_Activity_BAO_Activity::create($params);
 312
 313     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 314       'subject', 'Database check for created activity.'
 315     );
 316
 317     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact',
 318       $assigneeContactId, 'id', 'contact_id',
 319       'Database check for created activity assignment.'
 320     );
 321
 322     CRM_Activity_BAO_Activity::deleteActivityContact($activityId, 1);
 323
 324     $this->assertDBNull('CRM_Activity_DAO_ActivityContact', $assigneeContactId, 'id',
 325       'contact_id', 'Database check for deleted activity assignment.'
 326     );
 327
 328     $this->contactDelete($contactId);
 329     $this->contactDelete($assigneeContactId);
 330   }
 331
 332   /**
 333    * Test getActivities BAO method for getting count.
 334    */
 335   public function testGetActivitiesCountForAdminDashboard() {
 336     $this->setUpForActivityDashboardTests();
 337     $activityCount = CRM_Activity_BAO_Activity::getActivitiesCount($this->_params);
 338     $this->assertEquals(8, $activityCount);
 339   }
 340
 341   /**
 342    * Test getActivities BAO method for getting count
 343    */
 344   public function testGetActivitiesCountforNonAdminDashboard() {
 345     $this->createTestActivities();
 346
 347     $params = [
 348       'contact_id' => 9,
 349       'admin' => FALSE,
 350       'caseId' => NULL,
 351       'context' => 'home',
 352       'activity_type_id' => NULL,
 353       // for dashlet the Scheduled status is set by default
 354       'activity_status_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'status_id', 'Scheduled'),
 355       'offset' => 0,
 356       'rowCount' => 0,
 357       'sort' => NULL,
 358     ];
 359
 360     //since we are loading activities from dataset, we know total number of activities for this contact
 361     // 5 activities ( 2 scheduled, 3 Completed ), note that dashboard shows only scheduled activities
 362     $this->assertEquals(2, CRM_Activity_BAO_Activity::getActivitiesCount($params));
 363   }
 364
 365   /**
 366    * Test getActivities BAO method for getting count
 367    */
 368   public function testGetActivitiesCountforContactSummary() {
 369     $this->createTestActivities();
 370
 371     $params = [
 372       'contact_id' => 9,
 373       'admin' => FALSE,
 374       'caseId' => NULL,
 375       'context' => 'activity',
 376       'activity_type_id' => NULL,
 377       'offset' => 0,
 378       'rowCount' => 0,
 379       'sort' => NULL,
 380     ];
 381
 382     //since we are loading activities from dataset, we know total number of activities for this contact
 383     // 5 activities, Contact Summary should show all activities
 384     $this->assertEquals(5, CRM_Activity_BAO_Activity::getActivitiesCount($params));
 385   }
 386
 387   /**
 388    * CRM-18706 - Test Include/Exclude Activity Filters
 389    */
 390   public function testActivityFilters() {
 391     $this->createTestActivities();
 392     Civi::settings()->set('preserve_activity_tab_filter', 1);
 393     $this->createLoggedInUser();
 394
 395     global $_GET;
 396     $_GET = [
 397       'cid' => 9,
 398       'context' => 'activity',
 399       'activity_type_id' => 1,
 400       'is_unit_test' => 1,
 401     ];
 402     $expectedFilters = [
 403       'activity_type_filter_id' => 1,
 404     ];
 405
 406     list($activities, $activityFilter) = CRM_Activity_Page_AJAX::getContactActivity();
 407     //Assert whether filters are correctly set.
 408     $this->checkArrayEquals($expectedFilters, $activityFilter);
 409     // This should include activities of type Meeting only.
 410     foreach ($activities['data'] as $value) {
 411       $this->assertContains('Meeting', $value['activity_type']);
 412     }
 413     unset($_GET['activity_type_id']);
 414
 415     $_GET['activity_type_exclude_id'] = $expectedFilters['activity_type_exclude_filter_id'] = 1;
 416     list($activities, $activityFilter) = CRM_Activity_Page_AJAX::getContactActivity();
 417     $this->assertEquals(['activity_type_exclude_filter_id' => 1], $activityFilter);
 418     // None of the activities should be of type Meeting.
 419     foreach ($activities['data'] as $value) {
 420       $this->assertNotContains('Meeting', $value['activity_type']);
 421     }
 422   }
 423
 424   /**
 425    * Test getActivities BAO method for getting count
 426    */
 427   public function testGetActivitiesCountforContactSummaryWithNoActivities() {
 428     $this->createTestActivities();
 429
 430     $params = [
 431       'contact_id' => 17,
 432       'admin' => FALSE,
 433       'caseId' => NULL,
 434       'context' => 'home',
 435       'activity_type_id' => NULL,
 436       'offset' => 0,
 437       'rowCount' => 0,
 438       'sort' => NULL,
 439     ];
 440
 441     //since we are loading activities from dataset, we know total number of activities for this contact
 442     // this contact does not have any activity
 443     $this->assertEquals(0, CRM_Activity_BAO_Activity::getActivitiesCount($params));
 444   }
 445
 446   /**
 447    * Test getActivities BAO method.
 448    */
 449   public function testGetActivitiesForAdminDashboard() {
 450     $this->setUpForActivityDashboardTests();
 451     $activitiesNew = CRM_Activity_BAO_Activity::getActivities($this->_params);
 452     // $this->assertEquals($activities, $activitiesDeprecatedFn);
 453
 454     //since we are loading activities from dataset, we know total number of activities
 455     // with no contact ID and there should be 8 schedule activities shown on dashboard
 456     $count = 8;
 457     foreach ([$activitiesNew] as $activities) {
 458       $this->assertEquals($count, count($activities));
 459
 460       foreach ($activities as $key => $value) {
 461         $this->assertEquals($value['subject'], "subject {$key}", 'Verify activity subject is correct.');
 462         $this->assertEquals($value['activity_type_id'], 2, 'Verify activity type is correct.');
 463         $this->assertEquals($value['status_id'], 1, 'Verify all activities are scheduled.');
 464       }
 465     }
 466   }
 467
 468   /**
 469    * Test getActivities BAO method.
 470    */
 471   public function testGetActivitiesForAdminDashboardNoViewContacts() {
 472     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['access CiviCRM'];
 473     $this->setUpForActivityDashboardTests();
 474     foreach ([CRM_Activity_BAO_Activity::getActivities($this->_params)] as $activities) {
 475       // Skipped until we get back to the upgraded version properly.
 476       $this->assertEquals(0, count($activities));
 477     }
 478   }
 479
 480   /**
 481    * Test getActivities BAO method.
 482    */
 483   public function testGetActivitiesForAdminDashboardAclLimitedViewContacts() {
 484     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['access CiviCRM'];
 485     $this->allowedContacts = [1, 3, 4, 5];
 486     $this->hookClass->setHook('civicrm_aclWhereClause', [$this, 'aclWhereMultipleContacts']);
 487     $this->setUpForActivityDashboardTests();
 488     $this->assertEquals(7, count(CRM_Activity_BAO_Activity::getActivities($this->_params)));
 489   }
 490
 491   /**
 492    * Test getActivities BAO method.
 493    */
 494   public function testGetActivitiesforNonAdminDashboard() {
 495     $this->createTestActivities();
 496
 497     $contactID = 9;
 498     $params = [
 499       'contact_id' => $contactID,
 500       'admin' => FALSE,
 501       'caseId' => NULL,
 502       'context' => 'home',
 503       'activity_type_id' => NULL,
 504       // for dashlet the Scheduled status is set by default
 505       'activity_status_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'status_id', 'Scheduled'),
 506       'offset' => 0,
 507       'rowCount' => 0,
 508       'sort' => NULL,
 509     ];
 510
 511     foreach ([CRM_Activity_BAO_Activity::getActivities($params)] as $activities) {
 512       //since we are loading activities from dataset, we know total number of activities for this contact
 513       // 5 activities ( 2 scheduled, 3 Completed ), note that dashboard shows only scheduled activities
 514       $count = 2;
 515       $this->assertEquals($count, count($activities));
 516
 517       foreach ($activities as $key => $value) {
 518         $this->assertEquals($value['subject'], "subject {$key}", 'Verify activity subject is correct.');
 519         $this->assertEquals($value['activity_type_id'], 2, 'Verify activity type is correct.');
 520         $this->assertEquals($value['status_id'], 1, 'Verify all activities are scheduled.');
 521
 522         if ($key == 3) {
 523           $this->assertArrayHasKey($contactID, $value['target_contact_name']);
 524         }
 525         elseif ($key == 4) {
 526           $this->assertArrayHasKey($contactID, $value['assignee_contact_name']);
 527         }
 528       }
 529     }
 530   }
 531
 532   /**
 533    * Test target contact count.
 534    */
 535   public function testTargetCountforContactSummary() {
 536     $targetCount = 5;
 537     $contactId = $this->individualCreate();
 538     $targetContactIDs = [];
 539     for ($i = 0; $i < $targetCount; $i++) {
 540       $targetContactIDs[] = $this->individualCreate([], $i);
 541     }
 542     // Create activities with 5 target contacts.
 543     $activityParams = [
 544       'source_contact_id' => $contactId,
 545       'target_contact_id' => $targetContactIDs,
 546     ];
 547     $this->activityCreate($activityParams);
 548
 549     $params = [
 550       'contact_id' => $contactId,
 551       'context' => 'activity',
 552     ];
 553     $activities = CRM_Activity_BAO_Activity::getActivities($params);
 554     //verify target count
 555     $this->assertEquals($targetCount, $activities[1]['target_contact_count']);
 556     $this->assertEquals([$targetContactIDs[0] => 'Anderson, Anthony'], $activities[1]['target_contact_name']);
 557     $this->assertEquals('Anderson, Anthony', $activities[1]['source_contact_name']);
 558     $this->assertEquals('Anderson, Anthony', $activities[1]['assignee_contact_name'][4]);
 559   }
 560
 561   /**
 562    * Test getActivities BAO method.
 563    */
 564   public function testGetActivitiesforContactSummaryWithSortOptions() {
 565     $this->createTestActivities();
 566     $params = [
 567       'contact_id' => 9,
 568       'admin' => FALSE,
 569       'caseId' => NULL,
 570       'context' => 'activity',
 571       'activity_type_id' => NULL,
 572       'offset' => 0,
 573       'rowCount' => 0,
 574       'sort' => 'source_contact_name desc',
 575     ];
 576
 577     $activities = CRM_Activity_BAO_Activity::getActivities($params);
 578     $alphaOrder = ['Test Contact 11', 'Test Contact 12', 'Test Contact 3', 'Test Contact 4', 'Test Contact 9'];
 579     foreach ($activities as $activity) {
 580       $this->assertEquals(array_pop($alphaOrder), $activity['source_contact_name']);
 581     }
 582
 583   }
 584
 585   /**
 586    * Test getActivities BAO method.
 587    */
 588   public function testGetActivitiesForContactSummary() {
 589     $this->createTestActivities();
 590
 591     $contactID = 9;
 592     $params = [
 593       'contact_id' => $contactID,
 594       'admin' => FALSE,
 595       'caseId' => NULL,
 596       'context' => 'activity',
 597       'activity_type_id' => NULL,
 598       'offset' => 0,
 599       'rowCount' => 0,
 600     ];
 601
 602     //since we are loading activities from dataset, we know total number of activities for this contact
 603     // 5 activities, Contact Summary should show all activities
 604     $count = 5;
 605     $activities = CRM_Activity_BAO_Activity::getActivities($params);
 606     $this->assertEquals($count, count($activities));
 607     foreach ($activities as $key => $value) {
 608       $this->assertEquals($value['subject'], "subject {$key}", 'Verify activity subject is correct.');
 609
 610       if ($key > 8) {
 611         $this->assertEquals($value['status_id'], 2, 'Verify all activities are scheduled.');
 612       }
 613       else {
 614         $this->assertEquals($value['status_id'], 1, 'Verify all activities are scheduled.');
 615       }
 616
 617       if ($key === 12) {
 618         $this->assertEquals($value['activity_type'], 'Bulk Email', 'Verify activity type is correct.');
 619         $this->assertEquals('(2 recipients)', $value['recipients']);
 620         $targetContactID = key($value['target_contact_name']);
 621         // The 2 targets have ids 10 & 11. Since they are not sorted it could be either on some systems.
 622         $this->assertTrue(in_array($targetContactID, [10, 11]));
 623       }
 624       elseif ($key > 8) {
 625         $this->assertEquals($value['activity_type_id'], 1, 'Verify activity type is correct.');
 626       }
 627       else {
 628         $this->assertEquals($value['activity_type_id'], 2, 'Verify activity type is correct.');
 629       }
 630
 631       if ($key == 3) {
 632         $this->assertEquals([$contactID => 'Test Contact ' . $contactID], $value['target_contact_name']);
 633       }
 634       elseif ($key == 4) {
 635         $this->assertArrayHasKey($contactID, $value['assignee_contact_name']);
 636       }
 637     }
 638   }
 639
 640   /**
 641    * Test getActivities BAO method.
 642    */
 643   public function testGetActivitiesforContactSummaryWithActivities() {
 644     $this->createTestActivities();
 645
 646     // parameters for different test cases, check each array key for the specific test-case
 647     $testCases = [
 648       'with-no-activity' => [
 649         'params' => [
 650           'contact_id' => 17,
 651           'admin' => FALSE,
 652           'caseId' => NULL,
 653           'context' => 'home',
 654           'activity_type_id' => NULL,
 655           'offset' => 0,
 656           'rowCount' => 0,
 657           'sort' => NULL,
 658         ],
 659       ],
 660       'with-activity' => [
 661         'params' => [
 662           'contact_id' => 1,
 663           'admin' => FALSE,
 664           'caseId' => NULL,
 665           'context' => 'home',
 666           'activity_type_id' => NULL,
 667           'offset' => 0,
 668           'rowCount' => 0,
 669           'sort' => NULL,
 670         ],
 671       ],
 672       'with-activity_type' => [
 673         'params' => [
 674           'contact_id' => 3,
 675           'admin' => FALSE,
 676           'caseId' => NULL,
 677           'context' => 'home',
 678           'activity_type_id' => 2,
 679           'offset' => 0,
 680           'rowCount' => 0,
 681           'sort' => NULL,
 682         ],
 683       ],
 684       'exclude-all-activity_type' => [
 685         'params' => [
 686           'contact_id' => 3,
 687           'admin' => FALSE,
 688           'caseId' => NULL,
 689           'context' => 'home',
 690           'activity_type_exclude_id' => [1, 2],
 691           'offset' => 0,
 692           'rowCount' => 0,
 693           'sort' => NULL,
 694         ],
 695       ],
 696       'sort-by-subject' => [
 697         'params' => [
 698           'contact_id' => 1,
 699           'admin' => FALSE,
 700           'caseId' => NULL,
 701           'context' => 'home',
 702           'activity_type_id' => NULL,
 703           'offset' => 0,
 704           'rowCount' => 0,
 705           'sort' => 'subject DESC',
 706         ],
 707       ],
 708     ];
 709
 710     foreach ($testCases as $caseName => $testCase) {
 711       $activityCount = CRM_Activity_BAO_Activity::getActivitiesCount($testCase['params']);
 712       $activitiesNew = CRM_Activity_BAO_Activity::getActivities($testCase['params']);
 713
 714       foreach ([$activitiesNew] as $activities) {
 715         //$this->assertEquals($activityCount, CRM_Activity_BAO_Activity::getActivitiesCount($testCase['params']));
 716         if ($caseName == 'with-no-activity') {
 717           $this->assertEquals(0, count($activities));
 718           $this->assertEquals(0, $activityCount);
 719         }
 720         elseif ($caseName == 'with-activity') {
 721           // contact id 1 is assigned as source, target and assignee for activity id 1, 7 and 8 respectively
 722           $this->assertEquals(3, count($activities));
 723           $this->assertEquals(3, $activityCount);
 724           $this->assertEquals(1, $activities[1]['source_contact_id']);
 725           // @todo - this is a discrepancy between old & new - review.
 726           //$this->assertEquals(TRUE, array_key_exists(1, $activities[7]['target_contact_name']));
 727           $this->assertEquals(TRUE, array_key_exists(1, $activities[8]['assignee_contact_name']));
 728         }
 729         elseif ($caseName == 'with-activity_type') {
 730           // contact id 3 for activity type 2 is assigned as assignee, source and target for
 731           // activity id 1, 3 and 8 respectively
 732           $this->assertEquals(3, count($activities));
 733           $this->assertEquals(3, $activityCount);
 734           // ensure activity type id is 2
 735           $this->assertEquals(2, $activities[1]['activity_type_id']);
 736           $this->assertEquals(3, $activities[3]['source_contact_id']);
 737           // @todo review inconsistency between 2 versions.
 738           // $this->assertEquals(TRUE, array_key_exists(3, $activities[8]['target_contact_name']));
 739           $this->assertEquals(TRUE, array_key_exists(3, $activities[1]['assignee_contact_name']));
 740         }
 741         if ($caseName == 'exclude-all-activity_type') {
 742           $this->assertEquals(0, count($activities));
 743           $this->assertEquals(0, $activityCount);
 744         }
 745         if ($caseName == 'sort-by-subject') {
 746           $this->assertEquals(3, count($activities));
 747           $this->assertEquals(3, $activityCount);
 748           // activities should be order by 'subject DESC'
 749           $subjectOrder = [
 750             'subject 8',
 751             'subject 7',
 752             'subject 1',
 753           ];
 754           $count = 0;
 755           foreach ($activities as $activity) {
 756             $this->assertEquals($subjectOrder[$count], $activity['subject']);
 757             $count++;
 758           }
 759         }
 760       }
 761     }
 762   }
 763
 764   /**
 765    * CRM-20793 : Test getActivities by using activity date and status filter
 766    */
 767   public function testByActivityDateAndStatus() {
 768     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['view all contacts', 'access CiviCRM'];
 769     $this->createTestActivities();
 770
 771     // activity IDs catagorised by date
 772     $lastWeekActivities = [1, 2, 3];
 773     $todayActivities = [4, 5, 6, 7];
 774     $lastTwoMonthsActivities = [8, 9, 10, 11];
 775     $lastOrNextYearActivities = [12, 13, 14, 15, 16];
 776
 777     // date values later used to set activity date value
 778     $lastWeekDate = date('YmdHis', strtotime('1 week ago'));
 779     $today = date('YmdHis');
 780     $lastTwoMonthAgoDate = date('YmdHis', strtotime('2 months ago'));
 781     // if current month is Jan then choose next year date otherwise the search result will include
 782     //  the previous week and last two months activities which are still in previous year and hence leads to improper result
 783     $lastOrNextYearDate = (date('M') == 'Jan') ? date('YmdHis', strtotime('+1 year')) : date('YmdHis', strtotime('1 year ago'));
 784     for ($i = 1; $i <= 16; $i++) {
 785       if (in_array($i, $lastWeekActivities)) {
 786         $date = $lastWeekDate;
 787       }
 788       elseif (in_array($i, $lastTwoMonthsActivities)) {
 789         $date = $lastTwoMonthAgoDate;
 790       }
 791       elseif (in_array($i, $lastOrNextYearActivities)) {
 792         $date = $lastOrNextYearDate;
 793       }
 794       elseif (in_array($i, $todayActivities)) {
 795         $date = $today;
 796       }
 797       $this->callAPISuccess('Activity', 'create', [
 798         'id' => $i,
 799         'activity_date_time' => $date,
 800       ]);
 801     }
 802
 803     // parameters for different test cases, check each array key for the specific test-case
 804     $testCases = [
 805       'todays-activity' => [
 806         'params' => [
 807           'contact_id' => 1,
 808           'admin' => TRUE,
 809           'caseId' => NULL,
 810           'context' => 'activity',
 811           'activity_date_time_relative' => 'this.day',
 812           'activity_type_id' => NULL,
 813           'offset' => 0,
 814           'rowCount' => 0,
 815           'sort' => NULL,
 816         ],
 817       ],
 818       'todays-activity-filtered-by-range' => [
 819         'params' => [
 820           'contact_id' => 1,
 821           'admin' => TRUE,
 822           'caseId' => NULL,
 823           'context' => 'activity',
 824           'activity_date_time_low' => date('Y/m/d', strtotime('yesterday')),
 825           'activity_date_time_high' => date('Y/m/d'),
 826           'activity_type_id' => NULL,
 827           'offset' => 0,
 828           'rowCount' => 0,
 829           'sort' => NULL,
 830         ],
 831       ],
 832       'last-week-activity' => [
 833         'params' => [
 834           'contact_id' => 1,
 835           'admin' => TRUE,
 836           'caseId' => NULL,
 837           'context' => 'activity',
 838           'activity_date_time_relative' => 'previous.week',
 839           'activity_type_id' => NULL,
 840           'offset' => 0,
 841           'rowCount' => 0,
 842           'sort' => NULL,
 843         ],
 844       ],
 845       'this-quarter-activity' => [
 846         'params' => [
 847           'contact_id' => 1,
 848           'admin' => TRUE,
 849           'caseId' => NULL,
 850           'context' => 'activity',
 851           'activity_date_time_relative' => 'this.quarter',
 852           'activity_type_id' => NULL,
 853           'offset' => 0,
 854           'rowCount' => 0,
 855           'sort' => NULL,
 856         ],
 857       ],
 858       'activity-of-all-statuses' => [
 859         'params' => [
 860           'contact_id' => 1,
 861           'admin' => TRUE,
 862           'caseId' => NULL,
 863           'context' => 'activity',
 864           'activity_status_id' => '1,2',
 865           'activity_type_id' => NULL,
 866           'offset' => 0,
 867           'rowCount' => 0,
 868           'sort' => NULL,
 869         ],
 870       ],
 871     ];
 872
 873     foreach ($testCases as $caseName => $testCase) {
 874       CRM_Utils_Date::convertFormDateToApiFormat($testCase['params'], 'activity_date_time', FALSE);
 875       $activities = CRM_Activity_BAO_Activity::getActivities($testCase['params']);
 876       $activityCount = CRM_Activity_BAO_Activity::getActivitiesCount($testCase['params']);
 877       asort($activities);
 878       $activityIDs = array_keys($activities);
 879
 880       if ($caseName == 'todays-activity' || $caseName == 'todays-activity-filtered-by-range') {
 881         // Only one of the 4 activities today relates to contact id 1.
 882         $this->assertEquals(1, $activityCount);
 883         $this->assertEquals(1, count($activities));
 884         $this->assertEquals([7], array_keys($activities));
 885       }
 886       elseif ($caseName == 'last-week-activity') {
 887         // Only one of the 3 activities today relates to contact id 1.
 888         $this->assertEquals(1, $activityCount);
 889         $this->assertEquals(1, count($activities));
 890         $this->assertEquals([1], $activityIDs);
 891       }
 892       elseif ($caseName == 'lhis-quarter-activity') {
 893         $this->assertEquals(count($lastTwoMonthsActivities), $activityCount);
 894         $this->assertEquals(count($lastTwoMonthsActivities), count($activities));
 895         $this->checkArrayEquals($lastTwoMonthsActivities, $activityIDs);
 896       }
 897       elseif ($caseName == 'last-or-next-year-activity') {
 898         $this->assertEquals(count($lastOrNextYearActivities), $activityCount);
 899         $this->assertEquals(count($lastOrNextYearActivities), count($activities));
 900         $this->checkArrayEquals($lastOrNextYearActivities, $activityIDs);
 901       }
 902       elseif ($caseName == 'activity-of-all-statuses') {
 903         $this->assertEquals(3, $activityCount);
 904         $this->assertEquals(3, count($activities));
 905       }
 906     }
 907   }
 908
 909   /**
 910    * @dataProvider getActivityDateData
 911    */
 912   public function testActivityRelativeDateFilter($params, $expected) {
 913     $thisYear = date('Y');
 914     $dates = [
 915       date('Y-m-d', strtotime(($thisYear - 1) . '-01-01')),
 916       date('Y-m-d', strtotime(($thisYear - 1) . '-12-31')),
 917       date('Y-m-d', strtotime($thisYear . '-01-01')),
 918       date('Y-m-d', strtotime($thisYear . '-12-31')),
 919       date('Y-m-d', strtotime(($thisYear + 1) . '-01-01')),
 920       date('Y-m-d', strtotime(($thisYear + 1) . '-12-31')),
 921     ];
 922     foreach ($dates as $date) {
 923       $this->activityCreate(['activity_date_time' => $date]);
 924     }
 925     $activitiesDep = CRM_Activity_BAO_Activity::getActivities($params);
 926     $activityCount = CRM_Activity_BAO_Activity::getActivitiesCount($params);
 927     $this->assertEquals(count($activitiesDep), $activityCount);
 928     foreach ($activitiesDep as $activity) {
 929       $this->assertTrue(strtotime($activity['activity_date_time']) >= $expected['earliest'], $activity['activity_date_time'] . ' should be no earlier than ' . date('Y-m-d H:i:s', $expected['earliest']));
 930       $this->assertTrue(strtotime($activity['activity_date_time']) < $expected['latest'], $activity['activity_date_time'] . ' should be before ' . date('Y-m-d H:i:s', $expected['latest']));
 931     }
 932
 933   }
 934
 935   /**
 936    * Get activity date data.
 937    *
 938    * Later we might migrate rework the rest of
 939    * testByActivityDateAndStatus
 940    * to use data provider methodology as it's way complex!
 941    *
 942    * @return array
 943    */
 944   public function getActivityDateData() {
 945     return [
 946       'last-year-activity' => [
 947         'params' => [
 948           'contact_id' => 1,
 949           'admin' => TRUE,
 950           'caseId' => NULL,
 951           'context' => 'activity',
 952           'activity_date_relative' => 'previous.year',
 953           'activity_type_id' => NULL,
 954           'offset' => 0,
 955           'rowCount' => 0,
 956           'sort' => NULL,
 957         ],
 958         'expected' => [
 959           'count' => 2,
 960           'earliest' => strtotime('first day of january last year'),
 961           'latest' => strtotime('first day of january this year'),
 962         ],
 963       ],
 964     ];
 965   }
 966
 967   /**
 968    * CRM-20308: Test from email address when a 'copy of Activity' event occur
 969    */
 970   public function testEmailAddressOfActivityCopy() {
 971     // Case 1: assert the 'From' Email Address of source Actvity Contact ID
 972     // create activity with source contact ID which has email address
 973     $assigneeContactId = $this->individualCreate();
 974     $sourceContactParams = [
 975       'first_name' => 'liz',
 976       'last_name' => 'hurleey',
 977       'email' => substr(sha1(rand()), 0, 7) . '@testemail.com',
 978     ];
 979     $sourceContactID = $this->individualCreate($sourceContactParams);
 980     $sourceDisplayName = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $sourceContactID, 'display_name');
 981
 982     // create an activity using API
 983     $params = [
 984       'source_contact_id' => $sourceContactID,
 985       'subject' => 'Scheduling Meeting ' . substr(sha1(rand()), 0, 4),
 986       'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Meeting'),
 987       'assignee_contact_id' => [$assigneeContactId],
 988       'activity_date_time' => date('Ymd'),
 989     ];
 990     $activity = $this->callAPISuccess('Activity', 'create', $params);
 991
 992     // Check that from address is in "Source-Display-Name <source-email>"
 993     $formAddress = CRM_Case_BAO_Case::getReceiptFrom($activity['id']);
 994     $expectedFromAddress = sprintf("%s <%s>", $sourceDisplayName, $sourceContactParams['email']);
 995     $this->assertEquals($expectedFromAddress, $formAddress);
 996
 997     // Case 2: System Default From Address
 998     //  but first erase the email address of existing source contact ID
 999     $withoutEmailParams = [
1000       'email' => '',
1001     ];
1002     $sourceContactID = $this->individualCreate($withoutEmailParams);
1003     $params = [
1004       'source_contact_id' => $sourceContactID,
1005       'subject' => 'Scheduling Meeting ' . substr(sha1(rand()), 0, 4),
1006       'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Meeting'),
1007       'activity_date_time' => date('Ymd'),
1008     ];
1009     $activity = $this->callAPISuccess('Activity', 'create', $params);
1010     // fetch domain info
1011     $domainInfo = $this->callAPISuccess('Domain', 'getsingle', ['id' => CRM_Core_Config::domainID()]);
1012
1013     $formAddress = CRM_Case_BAO_Case::getReceiptFrom($activity['id']);
1014     if (!empty($domainInfo['from_email'])) {
1015       $expectedFromAddress = sprintf("%s <%s>", $domainInfo['from_name'], $domainInfo['from_email']);
1016     }
1017     // Case 3: fetch default Organization Contact email address
1018     elseif (!empty($domainInfo['domain_email'])) {
1019       $expectedFromAddress = sprintf("%s <%s>", $domainInfo['name'], $domainInfo['domain_email']);
1020     }
1021     $this->assertEquals($expectedFromAddress, $formAddress);
1022
1023     // TODO: Case 4 about checking the $formAddress on basis of logged contact ID respectively needs,
1024     //  to change the domain setting, which isn't straight forward in test environment
1025   }
1026
1027   /**
1028    * Set up for testing activity queries.
1029    */
1030   protected function setUpForActivityDashboardTests() {
1031     $this->createTestActivities();
1032
1033     $this->_params = [
1034       'contact_id' => NULL,
1035       'admin' => TRUE,
1036       'caseId' => NULL,
1037       'context' => 'home',
1038       'activity_type_id' => NULL,
1039     // for dashlet the Scheduled status is set by default
1040       'activity_status_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'status_id', 'Scheduled'),
1041       'offset' => 0,
1042       'rowCount' => 0,
1043       'sort' => NULL,
1044     ];
1045   }
1046
1047   public function testSendEmailBasic() {
1048     $contactId = $this->individualCreate();
1049
1050     // create a logged in USER since the code references it for sendEmail user.
1051     $this->createLoggedInUser();
1052     $session = CRM_Core_Session::singleton();
1053     $loggedInUser = $session->get('userID');
1054
1055     $contact = $this->civicrm_api('contact', 'getsingle', ['id' => $contactId, 'version' => $this->_apiversion]);
1056     $contactDetailsIntersectKeys = [
1057       'contact_id' => '',
1058       'sort_name' => '',
1059       'display_name' => '',
1060       'do_not_email' => '',
1061       'preferred_mail_format' => '',
1062       'is_deceased' => '',
1063       'email' => '',
1064       'on_hold' => '',
1065     ];
1066     $contactDetails = [
1067       array_intersect_key($contact, $contactDetailsIntersectKeys),
1068     ];
1069
1070     $subject = __FUNCTION__ . ' subject';
1071     $html = __FUNCTION__ . ' html';
1072     $text = __FUNCTION__ . ' text';
1073     $userID = $loggedInUser;
1074
1075     list($sent, $activity_id) = $email_result = CRM_Activity_BAO_Activity::sendEmail(
1076       $contactDetails,
1077       $subject,
1078       $text,
1079       $html,
1080       $contact['email'],
1081       $userID,
1082       $from = __FUNCTION__ . '@example.com'
1083     );
1084
1085     $activity = $this->civicrm_api('activity', 'getsingle', ['id' => $activity_id, 'version' => $this->_apiversion]);
1086     $details = "-ALTERNATIVE ITEM 0-
1087 $html
1088 -ALTERNATIVE ITEM 1-
1089 $text
1090 -ALTERNATIVE END-
1091 ";
1092     $this->assertEquals($activity['details'], $details, 'Activity details does not match.');
1093     $this->assertEquals($activity['subject'], $subject, 'Activity subject does not match.');
1094   }
1095
1096   public function testSendEmailWithCampaign() {
1097     // Create a contact and contactDetails array.
1098     $contactId = $this->individualCreate();
1099
1100     // create a logged in USER since the code references it for sendEmail user.
1101     $this->createLoggedInUser();
1102     $session = CRM_Core_Session::singleton();
1103     $loggedInUser = $session->get('userID');
1104
1105     $contact = $this->civicrm_api('contact', 'getsingle', ['id' => $contactId, 'version' => $this->_apiversion]);
1106     $contactDetailsIntersectKeys = [
1107       'contact_id' => '',
1108       'sort_name' => '',
1109       'display_name' => '',
1110       'do_not_email' => '',
1111       'preferred_mail_format' => '',
1112       'is_deceased' => '',
1113       'email' => '',
1114       'on_hold' => '',
1115     ];
1116     $contactDetails = [
1117       array_intersect_key($contact, $contactDetailsIntersectKeys),
1118     ];
1119
1120     // Create a campaign.
1121     $result = $this->civicrm_api('Campaign', 'create', [
1122       'version' => $this->_apiversion,
1123       'title' => __FUNCTION__ . ' campaign',
1124     ]);
1125     $campaign_id = $result['id'];
1126
1127     $subject = __FUNCTION__ . ' subject';
1128     $html = __FUNCTION__ . ' html';
1129     $text = __FUNCTION__ . ' text';
1130     $userID = $loggedInUser;
1131
1132     list($sent, $activity_id) = $email_result = CRM_Activity_BAO_Activity::sendEmail(
1133       $contactDetails,
1134       $subject,
1135       $text,
1136       $html,
1137       $contact['email'],
1138       $userID,
1139       $from = __FUNCTION__ . '@example.com',
1140       $attachments = NULL,
1141       $cc = NULL,
1142       $bcc = NULL,
1143       $contactIds = NULL,
1144       $additionalDetails = NULL,
1145       NULL,
1146       $campaign_id
1147     );
1148     $activity = $this->civicrm_api('activity', 'getsingle', ['id' => $activity_id, 'version' => $this->_apiversion]);
1149     $this->assertEquals($activity['campaign_id'], $campaign_id, 'Activity campaign_id does not match.');
1150   }
1151
1152   /**
1153    * @expectedException CRM_Core_Exception
1154    * @expectedExceptionMessage You do not have the 'send SMS' permission
1155    */
1156   public function testSendSMSWithoutPermission() {
1157     $dummy = NULL;
1158     $session = CRM_Core_Session::singleton();
1159     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['access CiviCRM'];
1160
1161     CRM_Activity_BAO_Activity::sendSMS(
1162       $dummy,
1163       $dummy,
1164       $dummy,
1165       $dummy,
1166       $session->get('userID')
1167     );
1168   }
1169
1170   public function testSendSmsNoPhoneNumber() {
1171     list($sent, $activityId, $success) = $this->createSendSmsTest(0);
1172     $activity = $this->civicrm_api('activity', 'getsingle', ['id' => $activityId, 'version' => $this->_apiversion]);
1173
1174     $outBoundSmsActivityId = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'SMS');
1175     $activityStatusCompleted = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_status_id', 'Completed');
1176     $details = 'createSendSmsTest text';
1177     $this->assertEquals($activity['activity_type_id'], $outBoundSmsActivityId, 'Wrong activity type is set.');
1178     $this->assertEquals($activity['status_id'], $activityStatusCompleted, 'Expected activity status Completed.');
1179     $this->assertEquals($activity['subject'], 'createSendSmsTest subject', 'Activity subject does not match.');
1180     $this->assertEquals($activity['details'], $details, 'Activity details does not match.');
1181     $this->assertEquals("Recipient phone number is invalid or recipient does not want to receive SMS", $sent[0], "Expected error doesn't match");
1182     $this->assertEquals(0, $success, "Expected success to be 0");
1183   }
1184
1185   public function testSendSmsFixedPhoneNumber() {
1186     list($sent, $activityId, $success) = $this->createSendSmsTest(1);
1187     $activity = $this->civicrm_api('activity', 'getsingle', ['id' => $activityId, 'version' => $this->_apiversion]);
1188
1189     $outBoundSmsActivityId = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'SMS');
1190     $activityStatusCompleted = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_status_id', 'Completed');
1191     $details = 'createSendSmsTest text';
1192     $this->assertEquals($activity['activity_type_id'], $outBoundSmsActivityId, 'Wrong activity type is set.');
1193     $this->assertEquals($activity['status_id'], $activityStatusCompleted, 'Expected activity status Completed.');
1194     $this->assertEquals($activity['subject'], 'createSendSmsTest subject', 'Activity subject does not match.');
1195     $this->assertEquals($activity['details'], $details, 'Activity details does not match.');
1196     $this->assertEquals("Recipient phone number is invalid or recipient does not want to receive SMS", $sent[0], "Expected error doesn't match");
1197     $this->assertEquals(0, $success, "Expected success to be 0");
1198   }
1199
1200   public function testSendSmsMobilePhoneNumber() {
1201     list($sent, $activityId, $success) = $this->createSendSmsTest(2);
1202     $activity = $this->civicrm_api('activity', 'getsingle', ['id' => $activityId, 'version' => $this->_apiversion]);
1203
1204     $outBoundSmsActivityId = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'SMS');
1205     $activityStatusCompleted = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_status_id', 'Completed');
1206     $details = 'createSendSmsTest text';
1207     $this->assertEquals($activity['activity_type_id'], $outBoundSmsActivityId, 'Wrong activity type is set.');
1208     $this->assertEquals($activity['status_id'], $activityStatusCompleted, 'Expected activity status Completed.');
1209     $this->assertEquals($activity['subject'], 'createSendSmsTest subject', 'Activity subject does not match.');
1210     $this->assertEquals($activity['details'], $details, 'Activity details does not match.');
1211     $this->assertEquals(TRUE, $sent, "Expected sent should be true");
1212     $this->assertEquals(1, $success, "Expected success to be 1");
1213   }
1214
1215   /**
1216    * Test that when a numbe ris specified in the To Param of the SMS provider parameters that an SMS is sent
1217    * @see dev/core/#273
1218    */
1219   public function testSendSMSMobileInToProviderParam() {
1220     list($sent, $activityId, $success) = $this->createSendSmsTest(2, TRUE);
1221     $this->assertEquals(TRUE, $sent, "Expected sent should be true");
1222     $this->assertEquals(1, $success, "Expected success to be 1");
1223   }
1224
1225   /**
1226    * Test that when a numbe ris specified in the To Param of the SMS provider parameters that an SMS is sent
1227    * @see dev/core/#273
1228    */
1229   public function testSendSMSMobileInToProviderParamWithDoNotSMS() {
1230     list($sent, $activityId, $success) = $this->createSendSmsTest(2, TRUE, ['do_not_sms' => 1]);
1231     foreach ($sent as $error) {
1232       $this->assertEquals('Contact Does not accept SMS', $error);
1233     }
1234     $this->assertEquals(1, count($sent), "Expected sent should a PEAR Error");
1235     $this->assertEquals(0, $success, "Expected success to be 0");
1236   }
1237
1238   /**
1239    * @param int $phoneType (0=no phone, phone_type option group (1=fixed, 2=mobile)
1240    * @param bool $passPhoneTypeInContactDetails
1241    * @param array $additionalContactParams additional contact creation params
1242    */
1243   public function createSendSmsTest($phoneType = 0, $passPhoneTypeInContactDetails = FALSE, $additionalContactParams = []) {
1244     $provider = civicrm_api3('SmsProvider', 'create', [
1245       'name' => "CiviTestSMSProvider",
1246       'api_type' => "1",
1247       "username" => "1",
1248       "password" => "1",
1249       "api_type" => "1",
1250       "api_url" => "1",
1251       "api_params" => "a=1",
1252       "is_default" => "1",
1253       "is_active" => "1",
1254       "domain_id" => "1",
1255     ]);
1256
1257     $smsProviderParams['provider_id'] = $provider['id'];
1258
1259     // Create a contact
1260     $contactId = $this->individualCreate();
1261     if (!empty($additionalContactParams)) {
1262       $this->callAPISuccess('contact', 'create', ['id' => $contactId] + $additionalContactParams);
1263     }
1264     $contactsResult = $this->callApiSuccess('contact', 'get', ['id' => $contactId, 'version' => $this->_apiversion]);
1265     $contactDetails = $contactsResult['values'];
1266
1267     // Get contactIds from contact details
1268     foreach ($contactDetails as $contact) {
1269       $contactIds[] = $contact['contact_id'];
1270     }
1271
1272     $activityParams['sms_text_message'] = __FUNCTION__ . ' text';
1273     $activityParams['activity_subject'] = __FUNCTION__ . ' subject';
1274
1275     // Get a "logged in" user to set as source of Sms.
1276     $session = CRM_Core_Session::singleton();
1277     $sourceContactId = $session->get('userID');
1278
1279     // Create a user
1280     $this->_testSmsContactId = $this->createLoggedInUser();
1281
1282     // Give user permission to 'send SMS'
1283     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['access CiviCRM', 'send SMS'];
1284
1285     // Create a phone number
1286     switch ($phoneType) {
1287       case 0:
1288         // No phone number
1289         break;
1290
1291       case 2:
1292         // Create a mobile phone number
1293         $phone = civicrm_api3('Phone', 'create', [
1294           'contact_id' => $contactId,
1295           'phone' => 123456,
1296           'phone_type_id' => "Mobile",
1297         ]);
1298         if ($passPhoneTypeInContactDetails) {
1299           $contactDetails[$contactId]['phone'] = $phone['values'][$phone['id']]['phone'];
1300           $contactDetails[$contactId]['phone_type_id'] = $phone['values'][$phone['id']]['phone_type_id'];
1301         }
1302         break;
1303
1304       case 1:
1305         // Create a fixed phone number
1306         $phone = civicrm_api3('Phone', 'create', [
1307           'contact_id' => $contactId,
1308           'phone' => 654321,
1309           'phone_type_id' => "Phone",
1310         ]);
1311         if ($passPhoneTypeInContactDetails) {
1312           $contactDetails[$contactId]['phone'] = $phone['values'][$phone['id']]['phone'];
1313           $contactDetails[$contactId]['phone_type_id'] = $phone['values'][$phone['id']]['phone_type_id'];
1314         }
1315         break;
1316     }
1317
1318     // Now run the actual test
1319     list($sent, $activityId, $success) = CRM_Activity_BAO_Activity::sendSms(
1320       $contactDetails,
1321       $activityParams,
1322       $smsProviderParams,
1323       $contactIds,
1324       $sourceContactId
1325     );
1326
1327     return [$sent, $activityId, $success];
1328   }
1329
1330   protected function createTestActivities() {
1331     $this->loadXMLDataSet(dirname(__FILE__) . '/activities_for_dashboard_count.xml');
1332     // Make changes to improve variation in php since the xml method is brittle & relies on option values being unchanged.
1333     $this->callAPISuccess('Activity', 'create', ['id' => 12, 'activity_type_id' => 'Bulk Email']);
1334   }
1335
1336   /**
1337    * ACL HOOK implementation for various tests
1338    */
1339   public function hook_civicrm_aclWhereClause($type, &$tables, &$whereTables, &$contactID, &$where) {
1340     if (!empty($this->allowedContactsACL)) {
1341       $contact_id_list = implode(',', $this->allowedContactsACL);
1342       $where = " contact_a.id IN ($contact_id_list)";
1343     }
1344   }
1345
1346   public function testCaseTokens() {
1347     $caseTest = new CiviCaseTestCase();
1348     $caseTest->setUp();
1349     // Create a contact and contactDetails array.
1350     $contactId = $this->individualCreate();
1351
1352     // create a case for this user
1353     $result = $this->callAPISuccess('Case', 'create', [
1354       'contact_id' => $contactId,
1355       'case_type_id' => '1',
1356       'subject' => "my case",
1357       'status_id' => "Open",
1358     ]);
1359
1360     $caseId = $result['id'];
1361     $html_message = "<p>This is a test case with id: {case.id} and subject: {case.subject}</p>";
1362     $html_message = CRM_Utils_Token::replaceCaseTokens($caseId, $html_message);
1363
1364     $this->assertTrue(strpos($html_message, 'id: ' . $caseId) !== 0);
1365     $this->assertTrue(strpos($html_message, 'subject: my case') !== 0);
1366     $caseTest->tearDown();
1367   }
1368
1369   public function testSendEmailWithCaseId() {
1370     $caseTest = new CiviCaseTestCase();
1371     $caseTest->setUp();
1372     // Create a contact and contactDetails array.
1373     $contactId = $this->individualCreate();
1374     $contact = $this->callAPISuccess('Contact', 'get', ['id' => $contactId]);
1375
1376     // create a logged in USER since the code references it for sendEmail user.
1377     $this->createLoggedInUser();
1378     CRM_Core_Config::singleton()->userPermissionClass->permissions = ['view all contacts', 'access CiviCRM', 'access all cases and activities', 'administer CiviCase'];
1379     $session = CRM_Core_Session::singleton();
1380     $loggedInUser = $session->get('userID');
1381
1382     // create a case for this user
1383     $result = $this->callAPISuccess('Case', 'create', [
1384       'contact_id' => $contactId,
1385       'case_type_id' => 1,
1386       'subject' => "my case",
1387       'status_id' => "Open",
1388     ]);
1389
1390     $caseId = $result['id'];
1391
1392     $subject = __FUNCTION__ . ' subject {case.subject}';
1393     $html = __FUNCTION__ . ' html {case.subject}';
1394     $text = __FUNCTION__ . ' text';
1395
1396     $mut = new CiviMailUtils($this, TRUE);
1397     list($sent, $activity_id) = $email_result = CRM_Activity_BAO_Activity::sendEmail(
1398       $contact['values'],
1399       $subject,
1400       $text,
1401       $html,
1402       $contact['values'][$contactId]['email'],
1403       $loggedInUser,
1404       $from = __FUNCTION__ . '@example.com',
1405       NULL,
1406       NULL,
1407       NULL,
1408       [$contactId],
1409       NULL,
1410       NULL,
1411       NULL,
1412       $caseId
1413     );
1414     $activity = $this->callAPISuccess('Activity', 'getsingle', ['id' => $activity_id, 'return' => ['case_id']]);
1415     $this->assertEquals($caseId, $activity['case_id'][0], 'Activity case_id does not match.');
1416     $mut->checkMailLog(['subject my case']);
1417     $mut->stop();
1418   }
1419
1420 }