CRM/Event/BAO/Participant.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10
  11  */
  12
  13 /**
  14  * @package CRM
  15  * @copyright CiviCRM LLC https://civicrm.org/licensing
  16  */
  17 class CRM_Event_BAO_Participant extends CRM_Event_DAO_Participant {
  18
  19   /**
  20    * Static field for all the participant information that we can potentially import.
  21    *
  22    * @var array
  23    */
  24   public static $_importableFields = NULL;
  25
  26   /**
  27    * Static field for all the participant information that we can potentially export.
  28    *
  29    * @var array
  30    */
  31   public static $_exportableFields = NULL;
  32
  33   /**
  34    * Static array for valid status transitions rules.
  35    *
  36    * @var array
  37    */
  38   public static $_statusTransitionsRules = [
  39     'Pending from pay later' => ['Registered', 'Cancelled'],
  40     'Pending from incomplete transaction' => ['Registered', 'Cancelled'],
  41     'On waitlist' => ['Cancelled', 'Pending from waitlist'],
  42     'Pending from waitlist' => ['Registered', 'Cancelled'],
  43     'Awaiting approval' => ['Cancelled', 'Pending from approval'],
  44     'Pending from approval' => ['Registered', 'Cancelled'],
  45   ];
  46
  47   /**
  48    */
  49   public function __construct() {
  50     parent::__construct();
  51   }
  52
  53   /**
  54    * Takes an associative array and creates a participant object.
  55    *
  56    * the function extract all the params it needs to initialize the create a
  57    * participant object. the params array could contain additional unused name/value
  58    * pairs
  59    *
  60    * @param array $params
  61    *   (reference ) an assoc array of name/value pairs.
  62    *
  63    * @return CRM_Event_BAO_Participant
  64    */
  65   public static function &add(&$params) {
  66
  67     if (!empty($params['id'])) {
  68       CRM_Utils_Hook::pre('edit', 'Participant', $params['id'], $params);
  69     }
  70     else {
  71       CRM_Utils_Hook::pre('create', 'Participant', NULL, $params);
  72     }
  73
  74     // converting dates to mysql format
  75     if (!empty($params['register_date'])) {
  76       $params['register_date'] = CRM_Utils_Date::isoToMysql($params['register_date']);
  77     }
  78
  79     if (!empty($params['participant_fee_amount'])) {
  80       $params['participant_fee_amount'] = CRM_Utils_Rule::cleanMoney($params['participant_fee_amount']);
  81     }
  82
  83     // ensure that role ids are encoded as a string
  84     if (isset($params['role_id']) && is_array($params['role_id'])) {
  85       if (in_array(key($params['role_id']), CRM_Core_DAO::acceptedSQLOperators(), TRUE)) {
  86         $op = key($params['role_id']);
  87         $params['role_id'] = $params['role_id'][$op];
  88       }
  89       else {
  90         $params['role_id'] = implode(CRM_Core_DAO::VALUE_SEPARATOR, $params['role_id']);
  91       }
  92     }
  93
  94     $participantBAO = new CRM_Event_BAO_Participant();
  95     if (!empty($params['id'])) {
  96       $participantBAO->id = $params['id'] ?? NULL;
  97       $participantBAO->find(TRUE);
  98       $participantBAO->register_date = CRM_Utils_Date::isoToMysql($participantBAO->register_date);
  99     }
 100
 101     $participantBAO->copyValues($params);
 102
 103     //CRM-6910
 104     //1. If currency present, it should be valid one.
 105     //2. We should have currency when amount is not null.
 106     $currency = $participantBAO->fee_currency;
 107     if ($currency ||
 108       !CRM_Utils_System::isNull($participantBAO->fee_amount)
 109     ) {
 110       if (!CRM_Utils_Rule::currencyCode($currency)) {
 111         $config = CRM_Core_Config::singleton();
 112         $currency = $config->defaultCurrency;
 113       }
 114     }
 115     $participantBAO->fee_currency = $currency;
 116
 117     $participantBAO->save();
 118
 119     CRM_Contact_BAO_GroupContactCache::opportunisticCacheFlush();
 120
 121     if (!empty($params['id'])) {
 122       CRM_Utils_Hook::post('edit', 'Participant', $participantBAO->id, $participantBAO);
 123     }
 124     else {
 125       CRM_Utils_Hook::post('create', 'Participant', $participantBAO->id, $participantBAO);
 126     }
 127
 128     return $participantBAO;
 129   }
 130
 131   /**
 132    * Given the list of params in the params array, fetch the object
 133    * and store the values in the values array
 134    *
 135    * @param array $params
 136    *   Input parameters to find object.
 137    * @param array $values
 138    *   Output values of the object.
 139    *
 140    * @param $ids
 141    *
 142    * @return CRM_Event_BAO_Participant|null the found object or null
 143    */
 144   public static function getValues(&$params, &$values = [], &$ids = []) {
 145     if (empty($params)) {
 146       return NULL;
 147     }
 148     $participant = new CRM_Event_BAO_Participant();
 149     $participant->copyValues($params);
 150     $participant->find();
 151     $participants = [];
 152     while ($participant->fetch()) {
 153       $ids['participant'] = $participant->id;
 154       CRM_Core_DAO::storeValues($participant, $values[$participant->id]);
 155       $participants[$participant->id] = $participant;
 156     }
 157     return $participants;
 158   }
 159
 160   /**
 161    * Takes an associative array and creates a participant object.
 162    *
 163    * @param array $params
 164    *   (reference ) an assoc array of name/value pairs.
 165    *
 166    * @return CRM_Event_BAO_Participant
 167    */
 168   public static function create(&$params) {
 169
 170     $transaction = new CRM_Core_Transaction();
 171     $status = NULL;
 172
 173     if (!empty($params['id'])) {
 174       $status = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Participant', $params['id'], 'status_id');
 175     }
 176
 177     $participant = self::add($params);
 178
 179     if (is_a($participant, 'CRM_Core_Error')) {
 180       $transaction->rollback();
 181       return $participant;
 182     }
 183
 184     // Log activity when creating new participant or changing status
 185     if (empty($params['id']) ||
 186       (isset($params['status_id']) && $params['status_id'] != $status)
 187     ) {
 188       // Default status if not specified
 189       $participant->status_id = $participant->status_id ?: self::fields()['participant_status_id']['default'];
 190       CRM_Activity_BAO_Activity::addActivity($participant, 'Event Registration');
 191     }
 192
 193     //CRM-5403
 194     //for update mode
 195     if (self::isPrimaryParticipant($participant->id) && $status) {
 196       self::updateParticipantStatus($participant->id, $status, $participant->status_id);
 197     }
 198
 199     $session = CRM_Core_Session::singleton();
 200     $id = $session->get('userID');
 201     if (!$id) {
 202       $id = $params['contact_id'] ?? NULL;
 203     }
 204
 205     // add custom field values
 206     if (!empty($params['custom']) &&
 207       is_array($params['custom'])
 208     ) {
 209       CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_participant', $participant->id);
 210     }
 211
 212     //process note, CRM-7634
 213     $noteId = NULL;
 214     if (!empty($params['id'])) {
 215       $note = CRM_Core_BAO_Note::getNote($params['id'], 'civicrm_participant');
 216       $noteId = key($note);
 217     }
 218     $noteValue = NULL;
 219     $hasNoteField = FALSE;
 220     foreach ([
 221       'note',
 222       'participant_note',
 223     ] as $noteFld) {
 224       if (array_key_exists($noteFld, $params)) {
 225         $noteValue = $params[$noteFld];
 226         $hasNoteField = TRUE;
 227         break;
 228       }
 229     }
 230     if ($noteId || $noteValue) {
 231       if ($noteValue) {
 232         $noteParams = [
 233           'entity_table' => 'civicrm_participant',
 234           'note' => $noteValue,
 235           'entity_id' => $participant->id,
 236           'contact_id' => $id,
 237         ];
 238         $noteIDs = [];
 239         if ($noteId) {
 240           $noteIDs['id'] = $noteId;
 241         }
 242         CRM_Core_BAO_Note::add($noteParams, $noteIDs);
 243       }
 244       elseif ($noteId && $hasNoteField) {
 245         CRM_Core_BAO_Note::deleteRecord(['id' => $noteId]);
 246       }
 247     }
 248
 249     // Log the information on successful add/edit of Participant data.
 250     $logParams = [
 251       'entity_table' => 'civicrm_participant',
 252       'entity_id' => $participant->id,
 253       'data' => CRM_Event_PseudoConstant::participantStatus($participant->status_id),
 254       'modified_id' => $id,
 255       'modified_date' => date('Ymd'),
 256     ];
 257
 258     CRM_Core_BAO_Log::add($logParams);
 259
 260     $params['participant_id'] = $participant->id;
 261
 262     $transaction->commit();
 263
 264     // do not add to recent items for import, CRM-4399
 265     if (empty($params['skipRecentView'])) {
 266
 267       $url = CRM_Utils_System::url('civicrm/contact/view/participant',
 268         "action=view&reset=1&id={$participant->id}&cid={$participant->contact_id}&context=home"
 269       );
 270
 271       $recentOther = [];
 272       if (CRM_Core_Permission::check('edit event participants')) {
 273         $recentOther['editUrl'] = CRM_Utils_System::url('civicrm/contact/view/participant',
 274           "action=update&reset=1&id={$participant->id}&cid={$participant->contact_id}&context=home"
 275         );
 276       }
 277       if (CRM_Core_Permission::check('delete in CiviEvent')) {
 278         $recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/contact/view/participant',
 279           "action=delete&reset=1&id={$participant->id}&cid={$participant->contact_id}&context=home"
 280         );
 281       }
 282
 283       $participantRoles = CRM_Event_PseudoConstant::participantRole();
 284
 285       if ($participant->role_id) {
 286         $role = explode(CRM_Core_DAO::VALUE_SEPARATOR, $participant->role_id);
 287
 288         foreach ($role as & $roleValue) {
 289           if (isset($roleValue)) {
 290             $roleValue = $participantRoles[$roleValue];
 291           }
 292         }
 293         $roles = implode(', ', $role);
 294       }
 295
 296       $roleString = empty($roles) ? '' : $roles;
 297       $eventTitle = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Event', $participant->event_id, 'title');
 298       $title = CRM_Contact_BAO_Contact::displayName($participant->contact_id) . ' (' . $roleString . ' - ' . $eventTitle . ')';
 299
 300       // add the recently created Participant
 301       CRM_Utils_Recent::add($title,
 302         $url,
 303         $participant->id,
 304         'Participant',
 305         $participant->contact_id,
 306         NULL,
 307         $recentOther
 308       );
 309     }
 310
 311     return $participant;
 312   }
 313
 314   /**
 315    * Check whether the event is full for participation and return as.
 316    * per requirements.
 317    *
 318    * @param int $eventId
 319    *   Event id.
 320    * @param bool $returnEmptySeats
 321    *   Are we require number if empty seats.
 322    * @param bool $includeWaitingList
 323    *   Consider waiting list in event full.
 324    *                 calculation or not. (it is for cron job  purpose)
 325    *
 326    * @param bool $returnWaitingCount
 327    * @param bool $considerTestParticipant
 328    *   When TRUE, include participant records where is_test = 1.
 329    * @param bool $onlyPositiveStatuses
 330    *   When FALSE, count all participant statuses where is_counted = 1.  This includes
 331    *   both "Positive" participants (Registered, Attended, etc.) and waitlisted
 332    *   (and some pending) participants.
 333    *   When TRUE, count only participants with statuses of "Positive".
 334    *
 335    * @return bool|int|null|string
 336    *   1. false                 => If event having some empty spaces.
 337    */
 338   public static function eventFull(
 339     $eventId,
 340     $returnEmptySeats = FALSE,
 341     $includeWaitingList = TRUE,
 342     $returnWaitingCount = FALSE,
 343     $considerTestParticipant = FALSE,
 344     $onlyPositiveStatuses = FALSE
 345   ) {
 346     $result = NULL;
 347     if (!$eventId) {
 348       return $result;
 349     }
 350
 351     // consider event is full when.
 352     // 1. (count(is_counted) >= event_size) or
 353     // 2. (count(participants-with-status-on-waitlist) > 0)
 354     // It might be case there are some empty spaces and still event
 355     // is full, as waitlist might represent group require spaces > empty.
 356
 357     $participantRoles = CRM_Event_PseudoConstant::participantRole(NULL, 'filter = 1');
 358     $countedStatuses = CRM_Event_PseudoConstant::participantStatus(NULL, 'is_counted = 1');
 359     $positiveStatuses = CRM_Event_PseudoConstant::participantStatus(NULL, "class = 'Positive'");
 360     $waitingStatuses = CRM_Event_PseudoConstant::participantStatus(NULL, "class = 'Waiting'");
 361     $onWaitlistStatusId = array_search('On waitlist', $waitingStatuses);
 362
 363     $where = [' event.id = %1 '];
 364     if (!$considerTestParticipant) {
 365       $where[] = ' ( participant.is_test = 0 OR participant.is_test IS NULL ) ';
 366     }
 367
 368     // Only count Participant Roles with the "Counted?" flag.
 369     if (!empty($participantRoles)) {
 370       $escapedRoles = [];
 371       foreach (array_keys($participantRoles) as $participantRole) {
 372         $escapedRoles[] = CRM_Utils_Type::escape($participantRole, 'String');
 373       }
 374
 375       $regexp = "([[:cntrl:]]|^)" . implode('([[:cntrl:]]|$)|([[:cntrl:]]|^)', $escapedRoles) . "([[:cntrl:]]|$)";
 376       $where[] = " participant.role_id REGEXP '{$regexp}'";
 377     }
 378
 379     $eventParams = [1 => [$eventId, 'Positive']];
 380
 381     //in case any waiting, straight forward event is full.
 382     if ($includeWaitingList && $onWaitlistStatusId) {
 383
 384       //build the where clause.
 385       $whereClause = ' WHERE ' . implode(' AND ', $where);
 386       $whereClause .= " AND participant.status_id = $onWaitlistStatusId ";
 387       $eventSeatsWhere = implode(' AND ', $where) . " AND ( participant.status_id = $onWaitlistStatusId )";
 388
 389       $query = "
 390     SELECT  participant.id id,
 391             event.event_full_text as event_full_text
 392       FROM  civicrm_participant participant
 393 INNER JOIN  civicrm_event event ON ( event.id = participant.event_id )
 394             {$whereClause}";
 395
 396       $eventFullText = ts('This event is full.');
 397       $participants = CRM_Core_DAO::executeQuery($query, $eventParams);
 398       while ($participants->fetch()) {
 399         //oops here event is full and we don't want waiting count.
 400         if ($returnWaitingCount) {
 401           return CRM_Event_BAO_Event::eventTotalSeats($eventId, $eventSeatsWhere);
 402         }
 403         else {
 404           return ($participants->event_full_text) ? $participants->event_full_text : $eventFullText;
 405         }
 406       }
 407     }
 408
 409     //Consider only counted participants, or alternatively only registered (not on waitlist) participants.
 410     if ($onlyPositiveStatuses) {
 411       $where[] = ' participant.status_id IN ( ' . implode(', ', array_keys($positiveStatuses)) . ' ) ';
 412     }
 413     else {
 414       $where[] = ' participant.status_id IN ( ' . implode(', ', array_keys($countedStatuses)) . ' ) ';
 415     }
 416     $whereClause = ' WHERE ' . implode(' AND ', $where);
 417     $eventSeatsWhere = implode(' AND ', $where);
 418
 419     $query = "
 420     SELECT  participant.id id,
 421             event.event_full_text as event_full_text,
 422             event.max_participants as max_participants
 423       FROM  civicrm_participant participant
 424 INNER JOIN  civicrm_event event ON ( event.id = participant.event_id )
 425             {$whereClause}";
 426
 427     $eventMaxSeats = NULL;
 428     $eventFullText = ts('This event is full.');
 429     $participants = CRM_Core_DAO::executeQuery($query, $eventParams);
 430     while ($participants->fetch()) {
 431       if ($participants->event_full_text) {
 432         $eventFullText = $participants->event_full_text;
 433       }
 434       $eventMaxSeats = $participants->max_participants;
 435       //don't have limit for event seats.
 436       if ($participants->max_participants == NULL) {
 437         return $result;
 438       }
 439     }
 440
 441     //get the total event seats occupied by these participants.
 442     $eventRegisteredSeats = CRM_Event_BAO_Event::eventTotalSeats($eventId, $eventSeatsWhere);
 443
 444     if ($eventRegisteredSeats) {
 445       if ($eventRegisteredSeats >= $eventMaxSeats) {
 446         $result = $eventFullText;
 447       }
 448       elseif ($returnEmptySeats) {
 449         $result = $eventMaxSeats - $eventRegisteredSeats;
 450       }
 451       return $result;
 452     }
 453     else {
 454       $query = '
 455 SELECT  event.event_full_text,
 456         event.max_participants
 457   FROM  civicrm_event event
 458  WHERE  event.id = %1';
 459       $event = CRM_Core_DAO::executeQuery($query, $eventParams);
 460       while ($event->fetch()) {
 461         $eventFullText = $event->event_full_text;
 462         $eventMaxSeats = $event->max_participants;
 463       }
 464     }
 465
 466     // no limit for registration.
 467     if ($eventMaxSeats == NULL) {
 468       return $result;
 469     }
 470     if ($eventMaxSeats) {
 471       return ($returnEmptySeats) ? (int) $eventMaxSeats : FALSE;
 472     }
 473
 474     return $eventFullText;
 475   }
 476
 477   /**
 478    * Return the array of all price set field options,
 479    * with total participant count that field going to carry.
 480    *
 481    * @param int $eventId
 482    *   Event id.
 483    * @param array $skipParticipantIds
 484    *   An array of participant ids those we should skip.
 485    * @param bool $considerCounted
 486    * @param bool $considerWaiting
 487    * @param bool $considerTestParticipants
 488    *
 489    * @return array
 490    *   an array of each option id and total count
 491    */
 492   public static function priceSetOptionsCount(
 493     $eventId,
 494     $skipParticipantIds = [],
 495     $considerCounted = TRUE,
 496     $considerWaiting = TRUE,
 497     $considerTestParticipants = FALSE
 498   ) {
 499     $optionsCount = [];
 500     if (!$eventId) {
 501       return $optionsCount;
 502     }
 503
 504     $allStatusIds = [];
 505     if ($considerCounted) {
 506       $countedStatuses = CRM_Event_PseudoConstant::participantStatus(NULL, 'is_counted = 1');
 507       $allStatusIds = array_merge($allStatusIds, array_keys($countedStatuses));
 508     }
 509     if ($considerWaiting) {
 510       $waitingStatuses = CRM_Event_PseudoConstant::participantStatus(NULL, "class = 'Waiting'");
 511       $allStatusIds = array_merge($allStatusIds, array_keys($waitingStatuses));
 512     }
 513     $statusIdClause = NULL;
 514     if (!empty($allStatusIds)) {
 515       $statusIdClause = ' AND participant.status_id IN ( ' . implode(', ', array_values($allStatusIds)) . ')';
 516     }
 517
 518     $isTestClause = NULL;
 519     if (!$considerTestParticipants) {
 520       $isTestClause = ' AND ( participant.is_test IS NULL OR participant.is_test = 0 )';
 521     }
 522
 523     $skipParticipantClause = NULL;
 524     if (is_array($skipParticipantIds) && !empty($skipParticipantIds)) {
 525       $skipParticipantClause = ' AND participant.id NOT IN ( ' . implode(', ', $skipParticipantIds) . ')';
 526     }
 527
 528     $sql = "
 529     SELECT  line.id as lineId,
 530             line.entity_id as entity_id,
 531             line.qty,
 532             value.id as valueId,
 533             value.count,
 534             field.html_type
 535       FROM  civicrm_line_item line
 536 INNER JOIN  civicrm_participant participant ON ( line.entity_table  = 'civicrm_participant'
 537                                                  AND participant.id = line.entity_id )
 538 INNER JOIN  civicrm_price_field_value value ON ( value.id = line.price_field_value_id )
 539 INNER JOIN  civicrm_price_field field       ON ( value.price_field_id = field.id )
 540      WHERE  participant.event_id = %1
 541        AND  line.qty > 0
 542             {$statusIdClause}
 543             {$isTestClause}
 544             {$skipParticipantClause}";
 545
 546     $lineItem = CRM_Core_DAO::executeQuery($sql, [1 => [$eventId, 'Positive']]);
 547     while ($lineItem->fetch()) {
 548       $count = $lineItem->count;
 549       if (!$count) {
 550         $count = 1;
 551       }
 552       if ($lineItem->html_type == 'Text') {
 553         $count *= $lineItem->qty;
 554       }
 555       $optionsCount[$lineItem->valueId] = $count + CRM_Utils_Array::value($lineItem->valueId, $optionsCount, 0);
 556     }
 557
 558     return $optionsCount;
 559   }
 560
 561   /**
 562    * Get the empty spaces for event those we can allocate
 563    * to pending participant to become confirm.
 564    *
 565    * @deprecated
 566    *
 567    * @param int $eventId
 568    *   Event id.
 569    *
 570    * @return int
 571    *   $spaces  Number of Empty Seats/null.
 572    */
 573   public static function pendingToConfirmSpaces($eventId) {
 574     CRM_Core_Error::deprecatedFunctionWarning('CRM_Event_BAO_Participant::eventFull');
 575     return CRM_Event_BAO_Participant::eventFull($eventId, TRUE, FALSE, TRUE, FALSE, TRUE);
 576   }
 577
 578   /**
 579    * Combine all the importable fields from the lower levels object.
 580    *
 581    * @param string $contactType
 582    * @param bool $status
 583    * @param bool $onlyParticipant
 584    * @param bool $checkPermission
 585    *   Is this a permissioned retrieval?
 586    *
 587    * @return array
 588    *   array of importable Fields
 589    */
 590   public static function &importableFields($contactType = 'Individual', $status = TRUE, $onlyParticipant = FALSE, $checkPermission = TRUE) {
 591     if (!self::$_importableFields) {
 592       if (!$onlyParticipant) {
 593         if (!$status) {
 594           $fields = ['' => ['title' => ts('- do not import -')]];
 595         }
 596         else {
 597           $fields = ['' => ['title' => ts('- Participant Fields -')]];
 598         }
 599       }
 600       else {
 601         $fields = [];
 602       }
 603
 604       $tmpFields = CRM_Event_DAO_Participant::import();
 605
 606       $note = [
 607         'participant_note' => [
 608           'title' => ts('Participant Note'),
 609           'name' => 'participant_note',
 610           'headerPattern' => '/(participant.)?note$/i',
 611           'data_type' => CRM_Utils_Type::T_TEXT,
 612         ],
 613       ];
 614
 615       // Split status and status id into 2 fields
 616       // Fixme: it would be better to leave as 1 field and intelligently handle both during import
 617       $participantStatus = [
 618         'participant_status' => [
 619           'title' => ts('Participant Status'),
 620           'name' => 'participant_status',
 621           'data_type' => CRM_Utils_Type::T_STRING,
 622         ],
 623       ];
 624       $tmpFields['participant_status_id']['title'] = ts('Participant Status Id');
 625
 626       // Split role and role id into 2 fields
 627       // Fixme: it would be better to leave as 1 field and intelligently handle both during import
 628       $participantRole = [
 629         'participant_role' => [
 630           'title' => ts('Participant Role'),
 631           'name' => 'participant_role',
 632           'data_type' => CRM_Utils_Type::T_STRING,
 633         ],
 634       ];
 635       $tmpFields['participant_role_id']['title'] = ts('Participant Role Id');
 636
 637       $eventType = [
 638         'event_type' => [
 639           'title' => ts('Event Type'),
 640           'name' => 'event_type',
 641           'data_type' => CRM_Utils_Type::T_STRING,
 642         ],
 643       ];
 644
 645       $tmpContactField = $contactFields = [];
 646       $contactFields = [];
 647       if (!$onlyParticipant) {
 648         $contactFields = CRM_Contact_BAO_Contact::importableFields($contactType, NULL);
 649
 650         // Using new Dedupe rule.
 651         $ruleParams = [
 652           'contact_type' => $contactType,
 653           'used' => 'Unsupervised',
 654         ];
 655         $fieldsArray = CRM_Dedupe_BAO_DedupeRule::dedupeRuleFields($ruleParams);
 656
 657         if (is_array($fieldsArray)) {
 658           foreach ($fieldsArray as $value) {
 659             $customFieldId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
 660               $value,
 661               'id',
 662               'column_name'
 663             );
 664             $value = $customFieldId ? 'custom_' . $customFieldId : $value;
 665             $tmpContactField[trim($value)] = $contactFields[trim($value)] ?? NULL;
 666             if (!$status) {
 667               $title = $tmpContactField[trim($value)]['title'] . ' (match to contact)';
 668             }
 669             else {
 670               $title = $tmpContactField[trim($value)]['title'];
 671             }
 672
 673             $tmpContactField[trim($value)]['title'] = $title;
 674           }
 675         }
 676       }
 677       $extIdentifier = $contactFields['external_identifier'] ?? NULL;
 678       if ($extIdentifier) {
 679         $tmpContactField['external_identifier'] = $extIdentifier;
 680         $tmpContactField['external_identifier']['title'] = CRM_Utils_Array::value('title', $extIdentifier) . ' (match to contact)';
 681       }
 682       $tmpFields['participant_contact_id']['title'] = $tmpFields['participant_contact_id']['title'] . ' (match to contact)';
 683
 684       $fields = array_merge($fields, $tmpContactField);
 685       $fields = array_merge($fields, $tmpFields);
 686       $fields = array_merge($fields, $note, $participantStatus, $participantRole, $eventType);
 687       $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Participant', FALSE, FALSE, FALSE, $checkPermission));
 688
 689       self::$_importableFields = $fields;
 690     }
 691
 692     return self::$_importableFields;
 693   }
 694
 695   /**
 696    * Combine all the exportable fields from the lower level objects.
 697    *
 698    * @param bool $checkPermission
 699    *
 700    * @return array
 701    *   array of exportable Fields
 702    */
 703   public static function &exportableFields($checkPermission = TRUE) {
 704     if (!self::$_exportableFields) {
 705       if (!self::$_exportableFields) {
 706         self::$_exportableFields = [];
 707       }
 708
 709       $participantFields = CRM_Event_DAO_Participant::export();
 710       $eventFields = CRM_Event_DAO_Event::export();
 711       $noteField = [
 712         'participant_note' => [
 713           'title' => ts('Participant Note'),
 714           'name' => 'participant_note',
 715           'type' => CRM_Utils_Type::T_STRING,
 716         ],
 717       ];
 718
 719       $participantStatus = [
 720         'participant_status' => [
 721           'title' => ts('Participant Status (label)'),
 722           'name' => 'participant_status',
 723           'type' => CRM_Utils_Type::T_STRING,
 724         ],
 725       ];
 726
 727       $participantRole = [
 728         'participant_role' => [
 729           'title' => ts('Participant Role (label)'),
 730           'name' => 'participant_role',
 731           'type' => CRM_Utils_Type::T_STRING,
 732         ],
 733       ];
 734
 735       $participantFields['participant_role_id']['title'] .= ' (ID)';
 736
 737       $discountFields = CRM_Core_DAO_Discount::export();
 738
 739       $fields = array_merge($participantFields, $participantStatus, $participantRole, $eventFields, $noteField, $discountFields);
 740
 741       // add custom data
 742       $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Participant', FALSE, FALSE, FALSE, $checkPermission));
 743       self::$_exportableFields = $fields;
 744     }
 745
 746     return self::$_exportableFields;
 747   }
 748
 749   /**
 750    * Get the event name/sort name for a particular participation / participant
 751    *
 752    * @param int $participantId
 753    *   Id of the participant.
 754    *
 755    * @return array
 756    *   associated array with sort_name and event title
 757    */
 758   public static function participantDetails($participantId) {
 759     $query = "
 760 SELECT civicrm_contact.sort_name as name, civicrm_event.title as title, civicrm_contact.id as cid
 761 FROM   civicrm_participant
 762    LEFT JOIN civicrm_event   ON (civicrm_participant.event_id = civicrm_event.id)
 763    LEFT JOIN civicrm_contact ON (civicrm_participant.contact_id = civicrm_contact.id)
 764 WHERE  civicrm_participant.id = {$participantId}
 765 ";
 766     $dao = CRM_Core_DAO::executeQuery($query);
 767
 768     $details = [];
 769     while ($dao->fetch()) {
 770       $details['name'] = $dao->name;
 771       $details['title'] = $dao->title;
 772       $details['cid'] = $dao->cid;
 773     }
 774
 775     return $details;
 776   }
 777
 778   /**
 779    * Get the values for pseudoconstants for name->value and reverse.
 780    *
 781    * @param array $defaults
 782    *   (reference) the default values, some of which need to be resolved.
 783    * @param bool $reverse
 784    *   True if we want to resolve the values in the reverse direction (value -> name).
 785    */
 786   public static function resolveDefaults(&$defaults, $reverse = FALSE) {
 787     self::lookupValue($defaults, 'event', CRM_Event_PseudoConstant::event(), $reverse);
 788     self::lookupValue($defaults, 'status', CRM_Event_PseudoConstant::participantStatus(NULL, NULL, 'label'), $reverse);
 789     self::lookupValue($defaults, 'role', CRM_Event_PseudoConstant::participantRole(), $reverse);
 790   }
 791
 792   /**
 793    * Convert associative array names to values and vice-versa.
 794    *
 795    * This function is used by both the web form layer and the api. Note that
 796    * the api needs the name => value conversion, also the view layer typically
 797    * requires value => name conversion
 798    *
 799    * @param array $defaults
 800    * @param string $property
 801    * @param string $lookup
 802    * @param bool $reverse
 803    *
 804    * @return bool
 805    */
 806   public static function lookupValue(&$defaults, $property, $lookup, $reverse) {
 807     $id = $property . '_id';
 808
 809     $src = $reverse ? $property : $id;
 810     $dst = $reverse ? $id : $property;
 811
 812     if (!array_key_exists($src, $defaults)) {
 813       return FALSE;
 814     }
 815
 816     $look = $reverse ? array_flip($lookup) : $lookup;
 817
 818     if (is_array($look)) {
 819       if (!array_key_exists($defaults[$src], $look)) {
 820         return FALSE;
 821       }
 822     }
 823     $defaults[$dst] = $look[$defaults[$src]];
 824     return TRUE;
 825   }
 826
 827   /**
 828    * Delete the records that are associated with this participation.
 829    *
 830    * @param int $id
 831    *   Id of the participation to delete.
 832    *
 833    * @return \CRM_Event_DAO_Participant
 834    */
 835   public static function deleteParticipant($id) {
 836     $participant = new CRM_Event_DAO_Participant();
 837     $participant->id = $id;
 838     if (!$participant->find()) {
 839       return FALSE;
 840     }
 841     CRM_Utils_Hook::pre('delete', 'Participant', $id);
 842
 843     $transaction = new CRM_Core_Transaction();
 844
 845     //delete activity record
 846     $params = [
 847       'source_record_id' => $id,
 848       // activity type id for event registration
 849       'activity_type_id' => 5,
 850     ];
 851
 852     CRM_Activity_BAO_Activity::deleteActivity($params);
 853
 854     // delete the participant payment record
 855     // we need to do this since the cascaded constraints
 856     // dont work with join tables
 857     $p = ['participant_id' => $id];
 858     CRM_Event_BAO_ParticipantPayment::deleteParticipantPayment($p);
 859
 860     // cleanup line items.
 861     $participantsId = [];
 862     $participantsId = self::getAdditionalParticipantIds($id);
 863     $participantsId[] = $id;
 864     CRM_Price_BAO_LineItem::deleteLineItems($participantsId, 'civicrm_participant');
 865
 866     //delete note when participant deleted.
 867     $note = CRM_Core_BAO_Note::getNote($id, 'civicrm_participant');
 868     $noteId = key($note);
 869     if ($noteId) {
 870       CRM_Core_BAO_Note::deleteRecord(['id' => $noteId]);
 871     }
 872
 873     $participant->delete();
 874
 875     $transaction->commit();
 876
 877     CRM_Utils_Hook::post('delete', 'Participant', $participant->id, $participant);
 878
 879     return $participant;
 880   }
 881
 882   /**
 883    * Checks duplicate participants.
 884    *
 885    * @param array $input
 886    *   An assosiative array of name /value pairs.
 887    *   from other function
 888    * @param array $duplicates
 889    *   (reference ) an assoc array of name/value pairs.
 890    *
 891    * @return CRM_Contribute_BAO_Contribution
 892    */
 893   public static function checkDuplicate($input, &$duplicates) {
 894     $eventId = $input['event_id'] ?? NULL;
 895     $contactId = $input['contact_id'] ?? NULL;
 896
 897     $clause = [];
 898     $input = [];
 899
 900     if ($eventId) {
 901       $clause[] = "event_id = %1";
 902       $input[1] = [$eventId, 'Integer'];
 903     }
 904
 905     if ($contactId) {
 906       $clause[] = "contact_id = %2";
 907       $input[2] = [$contactId, 'Integer'];
 908     }
 909
 910     if (empty($clause)) {
 911       return FALSE;
 912     }
 913
 914     $clause = implode(' AND ', $clause);
 915
 916     $query = "SELECT id FROM civicrm_participant WHERE $clause";
 917     $dao = CRM_Core_DAO::executeQuery($query, $input);
 918     $result = FALSE;
 919     while ($dao->fetch()) {
 920       $duplicates[] = $dao->id;
 921       $result = TRUE;
 922     }
 923     return $result;
 924   }
 925
 926   /**
 927    * Fix the event level.
 928    *
 929    * When price sets are used as event fee, fee_level is set as ^A
 930    * separated string. We need to change that string to comma
 931    * separated string before using fee_level in view mode.
 932    *
 933    * @param string $eventLevel
 934    *   Event_level string from db.
 935    */
 936   public static function fixEventLevel(&$eventLevel) {
 937     if ((substr($eventLevel, 0, 1) == CRM_Core_DAO::VALUE_SEPARATOR) &&
 938       (substr($eventLevel, -1, 1) == CRM_Core_DAO::VALUE_SEPARATOR)
 939     ) {
 940       $eventLevel = implode(', ', explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($eventLevel, 1, -1)));
 941       $pos = strrpos($eventLevel, '(multiple participants)', 0);
 942       if ($pos) {
 943         $eventLevel = substr_replace($eventLevel, "", $pos - 3, 1);
 944       }
 945     }
 946     elseif ((substr($eventLevel, 0, 1) == CRM_Core_DAO::VALUE_SEPARATOR)) {
 947       $eventLevel = implode(', ', explode(CRM_Core_DAO::VALUE_SEPARATOR,
 948         substr($eventLevel, 0, 1)
 949       ));
 950     }
 951     elseif ((substr($eventLevel, -1, 1) == CRM_Core_DAO::VALUE_SEPARATOR)) {
 952       $eventLevel = implode(', ', explode(CRM_Core_DAO::VALUE_SEPARATOR,
 953         substr($eventLevel, 0, -1)
 954       ));
 955     }
 956   }
 957
 958   /**
 959    * Get the ID of the default (first) participant role
 960    *
 961    * @return int
 962    * @throws \CiviCRM_API3_Exception
 963    */
 964   public static function getDefaultRoleID() {
 965     return (int) civicrm_api3('OptionValue', 'getvalue', [
 966       'return' => 'value',
 967       'option_group_id' => 'participant_role',
 968       'is_active' => 1,
 969       'options' => ['limit' => 1, 'sort' => 'is_default DESC'],
 970     ]);
 971   }
 972
 973   /**
 974    * Get the additional participant ids.
 975    *
 976    * @param int $primaryParticipantId
 977    *   Primary partycipant Id.
 978    * @param bool $excludeCancel
 979    *   Do not include participant those are cancelled.
 980    *
 981    * @param int $oldStatusId
 982    *
 983    * @return array
 984    */
 985   public static function getAdditionalParticipantIds($primaryParticipantId, $excludeCancel = TRUE, $oldStatusId = NULL) {
 986     $additionalParticipantIds = [];
 987     if (!$primaryParticipantId) {
 988       return $additionalParticipantIds;
 989     }
 990
 991     $where = "participant.registered_by_id={$primaryParticipantId}";
 992     if ($excludeCancel) {
 993       $cancelStatusId = 0;
 994       $negativeStatuses = CRM_Event_PseudoConstant::participantStatus(NULL, "class = 'Negative'");
 995       $cancelStatusId = array_search('Cancelled', $negativeStatuses);
 996       $where .= " AND participant.status_id != {$cancelStatusId}";
 997     }
 998
 999     if ($oldStatusId) {
1000       $where .= " AND participant.status_id = {$oldStatusId}";
1001     }
1002
1003     $query = "
1004   SELECT  participant.id
1005     FROM  civicrm_participant participant
1006    WHERE  {$where}";
1007
1008     $dao = CRM_Core_DAO::executeQuery($query);
1009     while ($dao->fetch()) {
1010       $additionalParticipantIds[$dao->id] = $dao->id;
1011     }
1012     return $additionalParticipantIds;
1013   }
1014
1015   /**
1016    * Get the amount for the undiscounted version of the field.
1017    *
1018    * Note this function is part of the refactoring process rather than the best approach.
1019    *
1020    * @param int $eventID
1021    * @param int $discountedPriceFieldOptionID
1022    * @param string $feeLevel (deprecated)
1023    *
1024    * @return null|string
1025    */
1026   public static function getUnDiscountedAmountForEventPriceSetFieldValue($eventID, $discountedPriceFieldOptionID, $feeLevel) {
1027     $priceSetId = CRM_Price_BAO_PriceSet::getFor('civicrm_event', $eventID, NULL);
1028     $params = [
1029       1 => [$priceSetId, 'Integer'],
1030     ];
1031     if ($discountedPriceFieldOptionID) {
1032       $query = "SELECT cpfv.amount FROM `civicrm_price_field_value` cpfv
1033 LEFT JOIN civicrm_price_field cpf ON cpfv.price_field_id = cpf.id
1034 WHERE cpf.price_set_id = %1 AND cpfv.label = (SELECT label from civicrm_price_field_value WHERE id = %2)";
1035       $params[2] = [$discountedPriceFieldOptionID, 'Integer'];
1036     }
1037     else {
1038       $feeLevel = current($feeLevel);
1039       $query = "SELECT cpfv.amount FROM `civicrm_price_field_value` cpfv
1040 LEFT JOIN civicrm_price_field cpf ON cpfv.price_field_id = cpf.id
1041 WHERE cpf.price_set_id = %1 AND cpfv.label LIKE %2";
1042       $params[2] = [$feeLevel, 'String'];
1043     }
1044     return CRM_Core_DAO::singleValueQuery($query, $params);
1045   }
1046
1047   /**
1048    * Retrieve additional participants display-names and URL to view their participant records.
1049    * (excludes cancelled participants automatically)
1050    *
1051    * @param int $primaryParticipantID
1052    *   Id of primary participant record.
1053    *
1054    * @return array
1055    *   $displayName => $viewUrl
1056    */
1057   public static function getAdditionalParticipants($primaryParticipantID) {
1058     $additionalParticipantIDs = [];
1059     $additionalParticipantIDs = self::getAdditionalParticipantIds($primaryParticipantID);
1060     if (!empty($additionalParticipantIDs)) {
1061       foreach ($additionalParticipantIDs as $additionalParticipantID) {
1062         $additionalContactID = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Participant',
1063           $additionalParticipantID,
1064           'contact_id', 'id'
1065         );
1066         $additionalContactName = CRM_Contact_BAO_Contact::displayName($additionalContactID);
1067         $pViewURL = CRM_Utils_System::url('civicrm/contact/view/participant',
1068           "action=view&reset=1&id={$additionalParticipantID}&cid={$additionalContactID}"
1069         );
1070
1071         $additionalParticipants[$additionalContactName] = $pViewURL;
1072       }
1073     }
1074     return $additionalParticipants;
1075   }
1076
1077   /**
1078    * Function for update primary and additional participant status.
1079    *
1080    * @param int $participantID
1081    *   Primary participant's id.
1082    * @param int $oldStatusID
1083    * @param int $newStatusID
1084    * @param bool $updatePrimaryStatus
1085    *
1086    * @return bool|NULL
1087    */
1088   public static function updateParticipantStatus($participantID, $oldStatusID, $newStatusID = NULL, $updatePrimaryStatus = FALSE) {
1089     if (!$participantID || !$oldStatusID) {
1090       return NULL;
1091     }
1092
1093     if (!$newStatusID) {
1094       $newStatusID = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Participant', $participantID, 'status_id');
1095     }
1096     elseif ($updatePrimaryStatus) {
1097       CRM_Core_DAO::setFieldValue('CRM_Event_DAO_Participant', $participantID, 'status_id', $newStatusID);
1098     }
1099
1100     $cascadeAdditionalIds = self::getValidAdditionalIds($participantID, $oldStatusID, $newStatusID);
1101
1102     if (!empty($cascadeAdditionalIds)) {
1103       try {
1104         foreach ($cascadeAdditionalIds as $id) {
1105           $participantParams = [
1106             'id' => $id,
1107             'status_id' => $newStatusID,
1108           ];
1109           civicrm_api3('Participant', 'create', $participantParams);
1110         }
1111         return TRUE;
1112       }
1113       catch (CiviCRM_API3_Exception $e) {
1114         throw new CRM_Core_Exception('Failed to update additional participant status in database');
1115       }
1116     }
1117     return FALSE;
1118   }
1119
1120   /**
1121    * Function for update status for given participant ids.
1122    *
1123    * @param int $participantIds
1124    *   Array of participant ids.
1125    * @param int $statusId
1126    *   Status id for participant.
1127    * @param bool $updateRegisterDate
1128    */
1129   public static function updateStatus($participantIds, $statusId, $updateRegisterDate = FALSE) {
1130     if (!is_array($participantIds) || empty($participantIds) || !$statusId) {
1131       return;
1132     }
1133
1134     //lets update register date as we update status to keep track
1135     //when we did update status, useful for moving participant
1136     //from pending to expired.
1137     $setClause = "status_id = {$statusId}";
1138     if ($updateRegisterDate) {
1139       $setClause .= ", register_date = NOW()";
1140     }
1141
1142     $participantIdClause = '( ' . implode(',', $participantIds) . ' )';
1143
1144     $query = "
1145 UPDATE  civicrm_participant
1146    SET  {$setClause}
1147  WHERE  id IN {$participantIdClause}";
1148
1149     $dao = CRM_Core_DAO::executeQuery($query);
1150   }
1151
1152   /**
1153    * Function takes participant ids and statuses
1154    * update status from $fromStatusId to $toStatusId
1155    * and send mail + create activities.
1156    *
1157    * @param array $participantIds
1158    *   Participant ids.
1159    * @param int $toStatusId
1160    *   Update status id.
1161    * @param int $fromStatusId
1162    *   From status id.
1163    * @param bool $returnResult
1164    * @param bool $skipCascadeRule
1165    *
1166    * @return array|NULL
1167    */
1168   public static function transitionParticipants(
1169     $participantIds, $toStatusId,
1170     $fromStatusId = NULL, $returnResult = FALSE, $skipCascadeRule = FALSE
1171   ) {
1172     if (!is_array($participantIds) || empty($participantIds) || !$toStatusId) {
1173       return NULL;
1174     }
1175
1176     //thumb rule is if we triggering  primary participant need to triggered additional
1177     $allParticipantIds = $primaryANDAdditonalIds = [];
1178     foreach ($participantIds as $id) {
1179       $allParticipantIds[] = $id;
1180       if (self::isPrimaryParticipant($id)) {
1181         //filter additional as per status transition rules, CRM-5403
1182         if ($skipCascadeRule) {
1183           $additionalIds = self::getAdditionalParticipantIds($id);
1184         }
1185         else {
1186           $additionalIds = self::getValidAdditionalIds($id, $fromStatusId, $toStatusId);
1187         }
1188         if (!empty($additionalIds)) {
1189           $allParticipantIds = array_merge($allParticipantIds, $additionalIds);
1190           $primaryANDAdditonalIds[$id] = $additionalIds;
1191         }
1192       }
1193     }
1194
1195     //get the unique participant ids,
1196     $allParticipantIds = array_unique($allParticipantIds);
1197
1198     //pull required participants, contacts, events  data, if not in hand
1199     static $eventDetails = [];
1200     static $domainValues = [];
1201     static $contactDetails = [];
1202
1203     $contactIds = $eventIds = $participantDetails = [];
1204
1205     $statusTypes = CRM_Event_PseudoConstant::participantStatus();
1206     $participantRoles = CRM_Event_PseudoConstant::participantRole();
1207     $pendingStatuses = CRM_Event_PseudoConstant::participantStatus(NULL,
1208       "class = 'Pending'"
1209     );
1210
1211     //first thing is pull all necessory data from db.
1212     $participantIdClause = '(' . implode(',', $allParticipantIds) . ')';
1213
1214     //get all participants data.
1215     $query = "SELECT * FROM civicrm_participant WHERE id IN {$participantIdClause}";
1216     $dao = CRM_Core_DAO::executeQuery($query);
1217     while ($dao->fetch()) {
1218       $participantDetails[$dao->id] = [
1219         'id' => $dao->id,
1220         'role' => $participantRoles[$dao->role_id],
1221         'is_test' => $dao->is_test,
1222         'event_id' => $dao->event_id,
1223         'status_id' => $dao->status_id,
1224         'fee_amount' => $dao->fee_amount,
1225         'contact_id' => $dao->contact_id,
1226         'register_date' => $dao->register_date,
1227         'registered_by_id' => $dao->registered_by_id,
1228       ];
1229       if (!array_key_exists($dao->contact_id, $contactDetails)) {
1230         $contactIds[$dao->contact_id] = $dao->contact_id;
1231       }
1232
1233       if (!array_key_exists($dao->event_id, $eventDetails)) {
1234         $eventIds[$dao->event_id] = $dao->event_id;
1235       }
1236     }
1237
1238     //get the domain values.
1239     if (empty($domainValues)) {
1240       // making all tokens available to templates.
1241       $domain = CRM_Core_BAO_Domain::getDomain();
1242       $tokens = [
1243         'domain' => ['name', 'phone', 'address', 'email'],
1244         'contact' => CRM_Core_SelectValues::contactTokens(),
1245       ];
1246
1247       foreach ($tokens['domain'] as $token) {
1248         $domainValues[$token] = CRM_Utils_Token::getDomainTokenReplacement($token, $domain);
1249       }
1250     }
1251
1252     //get all required contacts detail.
1253     if (!empty($contactIds)) {
1254       // get the contact details.
1255       list($currentContactDetails) = CRM_Utils_Token::getTokenDetails($contactIds, NULL,
1256         FALSE, FALSE, NULL,
1257         [],
1258         'CRM_Event_BAO_Participant'
1259       );
1260       foreach ($currentContactDetails as $contactId => $contactValues) {
1261         $contactDetails[$contactId] = $contactValues;
1262       }
1263     }
1264
1265     //get all required events detail.
1266     if (!empty($eventIds)) {
1267       foreach ($eventIds as $eventId) {
1268         //retrieve event information
1269         $eventParams = ['id' => $eventId];
1270         CRM_Event_BAO_Event::retrieve($eventParams, $eventDetails[$eventId]);
1271
1272         //get default participant role.
1273         $eventDetails[$eventId]['participant_role'] = $participantRoles[$eventDetails[$eventId]['default_role_id']] ?? NULL;
1274
1275         //get the location info
1276         $locParams = ['entity_id' => $eventId, 'entity_table' => 'civicrm_event'];
1277         $eventDetails[$eventId]['location'] = CRM_Core_BAO_Location::getValues($locParams, TRUE);
1278       }
1279     }
1280
1281     //now we are ready w/ all required data.
1282     //take a decision as per statuses.
1283
1284     $emailType = NULL;
1285     $toStatus = $statusTypes[$toStatusId];
1286     $fromStatus = $statusTypes[$fromStatusId] ?? NULL;
1287
1288     switch ($toStatus) {
1289       case 'Pending from waitlist':
1290       case 'Pending from approval':
1291         switch ($fromStatus) {
1292           case 'On waitlist':
1293           case 'Awaiting approval':
1294             $emailType = 'Confirm';
1295             break;
1296         }
1297         break;
1298
1299       case 'Expired':
1300         //no matter from where u come send expired mail.
1301         $emailType = $toStatus;
1302         break;
1303
1304       case 'Cancelled':
1305         //no matter from where u come send cancel mail.
1306         $emailType = $toStatus;
1307         break;
1308     }
1309
1310     //as we process additional w/ primary, there might be case if user
1311     //select primary as well as additionals, so avoid double processing.
1312     $processedParticipantIds = [];
1313     $mailedParticipants = [];
1314
1315     //send mails and update status.
1316     foreach ($participantDetails as $participantId => $participantValues) {
1317       $updateParticipantIds = [];
1318       if (in_array($participantId, $processedParticipantIds)) {
1319         continue;
1320       }
1321
1322       //check is it primary and has additional.
1323       if (array_key_exists($participantId, $primaryANDAdditonalIds)) {
1324         foreach ($primaryANDAdditonalIds[$participantId] as $additionalId) {
1325
1326           if ($emailType) {
1327             $mail = self::sendTransitionParticipantMail($additionalId,
1328               $participantDetails[$additionalId],
1329               $eventDetails[$participantDetails[$additionalId]['event_id']],
1330               $contactDetails[$participantDetails[$additionalId]['contact_id']],
1331               $domainValues,
1332               $emailType
1333             );
1334
1335             //get the mail participant ids
1336             if ($mail) {
1337               $mailedParticipants[$additionalId] = $contactDetails[$participantDetails[$additionalId]['contact_id']]['display_name'];
1338             }
1339           }
1340           $updateParticipantIds[] = $additionalId;
1341           $processedParticipantIds[] = $additionalId;
1342         }
1343       }
1344
1345       //now send email appropriate mail to primary.
1346       if ($emailType) {
1347         $mail = self::sendTransitionParticipantMail($participantId,
1348           $participantValues,
1349           $eventDetails[$participantValues['event_id']],
1350           $contactDetails[$participantValues['contact_id']],
1351           $domainValues,
1352           $emailType
1353         );
1354
1355         //get the mail participant ids
1356         if ($mail) {
1357           $mailedParticipants[$participantId] = $contactDetails[$participantValues['contact_id']]['display_name'];
1358         }
1359       }
1360
1361       //now update status of group/one at once.
1362       $updateParticipantIds[] = $participantId;
1363
1364       //update the register date only when we,
1365       //move participant to pending class, CRM-6496
1366       $updateRegisterDate = FALSE;
1367       if (array_key_exists($toStatusId, $pendingStatuses)) {
1368         $updateRegisterDate = TRUE;
1369       }
1370       self::updateStatus($updateParticipantIds, $toStatusId, $updateRegisterDate);
1371       $processedParticipantIds[] = $participantId;
1372     }
1373
1374     //return result for cron.
1375     if ($returnResult) {
1376       $results = [
1377         'mailedParticipants' => $mailedParticipants,
1378         'updatedParticipantIds' => $processedParticipantIds,
1379       ];
1380
1381       return $results;
1382     }
1383   }
1384
1385   /**
1386    * Send mail and create activity
1387    * when participant status changed.
1388    *
1389    * @param int $participantId
1390    *   Participant id.
1391    * @param array $participantValues
1392    *   Participant detail values. status id for participants.
1393    * @param array $eventDetails
1394    *   Required event details.
1395    * @param array $contactDetails
1396    *   Required contact details.
1397    * @param array $domainValues
1398    *   Required domain values.
1399    * @param string $mailType
1400    *   (eg 'approval', 'confirm', 'expired' ).
1401    *
1402    * @return bool
1403    */
1404   public static function sendTransitionParticipantMail(
1405     $participantId,
1406     $participantValues,
1407     $eventDetails,
1408     $contactDetails,
1409     &$domainValues,
1410     $mailType
1411   ) {
1412     //send emails.
1413     $mailSent = FALSE;
1414
1415     //don't send confirmation mail to additional
1416     //since only primary able to confirm registration.
1417     if (!empty($participantValues['registered_by_id']) &&
1418       $mailType == 'Confirm'
1419     ) {
1420       return $mailSent;
1421     }
1422     $toEmail = $contactDetails['email'] ?? NULL;
1423     if ($toEmail) {
1424
1425       $contactId = $participantValues['contact_id'];
1426       $participantName = $contactDetails['display_name'];
1427
1428       //calculate the checksum value.
1429       $checksumValue = NULL;
1430       if ($mailType == 'Confirm' && !$participantValues['registered_by_id']) {
1431         $checksumLife = 'inf';
1432         $endDate = $eventDetails['end_date'] ?? NULL;
1433         if ($endDate) {
1434           $checksumLife = (CRM_Utils_Date::unixTime($endDate) - time()) / (60 * 60);
1435         }
1436         $checksumValue = CRM_Contact_BAO_Contact_Utils::generateChecksum($contactId, NULL, $checksumLife);
1437       }
1438
1439       //take a receipt from as event else domain.
1440       $receiptFrom = CRM_Core_BAO_Domain::getFromEmail();
1441
1442       if (!empty($eventDetails['confirm_from_name']) && !empty($eventDetails['confirm_from_email'])) {
1443         $receiptFrom = $eventDetails['confirm_from_name'] . ' <' . $eventDetails['confirm_from_email'] . '>';
1444       }
1445
1446       list($mailSent, $subject, $message, $html) = CRM_Core_BAO_MessageTemplate::sendTemplate(
1447         [
1448           'groupName' => 'msg_tpl_workflow_event',
1449           'valueName' => 'participant_' . strtolower($mailType),
1450           'contactId' => $contactId,
1451           'tplParams' => [
1452             'contact' => $contactDetails,
1453             'domain' => $domainValues,
1454             'participant' => $participantValues,
1455             'event' => $eventDetails,
1456             'paidEvent' => $eventDetails['is_monetary'] ?? NULL,
1457             'isShowLocation' => $eventDetails['is_show_location'] ?? NULL,
1458             'isAdditional' => $participantValues['registered_by_id'],
1459             'isExpired' => $mailType == 'Expired',
1460             'isConfirm' => $mailType == 'Confirm',
1461             'checksumValue' => $checksumValue,
1462           ],
1463           'from' => $receiptFrom,
1464           'toName' => $participantName,
1465           'toEmail' => $toEmail,
1466           'cc' => $eventDetails['cc_confirm'] ?? NULL,
1467           'bcc' => $eventDetails['bcc_confirm'] ?? NULL,
1468         ]
1469       );
1470
1471       // 3. create activity record.
1472       if ($mailSent) {
1473         $now = date('YmdHis');
1474         $activityType = 'Event Registration';
1475         $activityParams = [
1476           'subject' => $subject,
1477           'source_contact_id' => $contactId,
1478           'source_record_id' => $participantId,
1479           'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', $activityType),
1480           'activity_date_time' => CRM_Utils_Date::isoToMysql($now),
1481           'due_date_time' => CRM_Utils_Date::isoToMysql($participantValues['register_date']),
1482           'is_test' => $participantValues['is_test'],
1483           'status_id' => 2,
1484         ];
1485
1486         if (is_a(CRM_Activity_BAO_Activity::create($activityParams), 'CRM_Core_Error')) {
1487           throw new CRM_Core_Exception('Failed creating Activity for expiration mail');
1488         }
1489       }
1490     }
1491
1492     return $mailSent;
1493   }
1494
1495   /**
1496    * Get participant status change message.
1497    *
1498    * @param int $participantId
1499    * @param $statusChangeTo
1500    * @param int $fromStatusId
1501    *
1502    * @return string
1503    */
1504   public function updateStatusMessage($participantId, $statusChangeTo, $fromStatusId) {
1505     $statusMsg = NULL;
1506     $results = self::transitionParticipants([$participantId],
1507       $statusChangeTo, $fromStatusId, TRUE
1508     );
1509
1510     $allStatuses = CRM_Event_PseudoConstant::participantStatus();
1511     //give user message only when mail has sent.
1512     if (is_array($results) && !empty($results)) {
1513       if (is_array($results['updatedParticipantIds']) && !empty($results['updatedParticipantIds'])) {
1514         foreach ($results['updatedParticipantIds'] as $processedId) {
1515           if (is_array($results['mailedParticipants']) &&
1516             array_key_exists($processedId, $results['mailedParticipants'])
1517           ) {
1518             $statusMsg .= '<br /> ' . ts("Participant status has been updated to '%1'. An email has been sent to %2.",
1519                 [
1520                   1 => $allStatuses[$statusChangeTo],
1521                   2 => $results['mailedParticipants'][$processedId],
1522                 ]
1523               );
1524           }
1525         }
1526       }
1527     }
1528
1529     return $statusMsg;
1530   }
1531
1532   /**
1533    * Get event full and waiting list message.
1534    *
1535    * @param int $eventId
1536    * @param int $participantId
1537    *
1538    * @return string
1539    */
1540   public static function eventFullMessage($eventId, $participantId = NULL) {
1541     $eventfullMsg = $dbStatusId = NULL;
1542     $checkEventFull = TRUE;
1543     if ($participantId) {
1544       $dbStatusId = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Participant', $participantId, 'status_id');
1545       if (array_key_exists($dbStatusId, CRM_Event_PseudoConstant::participantStatus(NULL, 'is_counted = 1'))) {
1546         //participant already in counted status no need to check for event full messages.
1547         $checkEventFull = FALSE;
1548       }
1549     }
1550
1551     //early return.
1552     if (!$eventId || !$checkEventFull) {
1553       return $eventfullMsg;
1554     }
1555
1556     //event is truly full.
1557     $emptySeats = self::eventFull($eventId, FALSE, FALSE);
1558     if (is_string($emptySeats) && $emptySeats !== NULL) {
1559       $maxParticipants = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Event', $eventId, 'max_participants');
1560       $eventfullMsg = ts("This event currently has the maximum number of participants registered (%1). However, you can still override this limit and register additional participants using this form.", [
1561         1 => $maxParticipants,
1562       ]) . '<br />';
1563     }
1564
1565     $hasWaiting = FALSE;
1566     $waitListedCount = self::eventFull($eventId, FALSE, TRUE, TRUE);
1567     if (is_numeric($waitListedCount)) {
1568       $hasWaiting = TRUE;
1569       //only current processing participant is on waitlist.
1570       if ($waitListedCount == 1 && CRM_Event_PseudoConstant::participantStatus($dbStatusId) == 'On waitlist') {
1571         $hasWaiting = FALSE;
1572       }
1573     }
1574
1575     if ($hasWaiting) {
1576       $waitingStatusId = array_search('On waitlist',
1577         CRM_Event_PseudoConstant::participantStatus(NULL, "class = 'Waiting'")
1578       );
1579       $viewWaitListUrl = CRM_Utils_System::url('civicrm/event/search',
1580         "reset=1&force=1&event={$eventId}&status={$waitingStatusId}"
1581       );
1582
1583       $eventfullMsg .= ts("There are %2 people currently on the waiting list for this event. You can <a href='%1'>view waitlisted registrations here</a>, or you can continue and register additional participants using this form.",
1584         [
1585           1 => $viewWaitListUrl,
1586           2 => $waitListedCount,
1587         ]
1588       );
1589     }
1590
1591     return $eventfullMsg;
1592   }
1593
1594   /**
1595    * Check for whether participant is primary or not.
1596    *
1597    * @param int $participantId
1598    *
1599    * @return bool
1600    *   true if participant is primary
1601    */
1602   public static function isPrimaryParticipant($participantId) {
1603
1604     $participant = new CRM_Event_DAO_Participant();
1605     $participant->registered_by_id = $participantId;
1606
1607     if ($participant->find(TRUE)) {
1608       return TRUE;
1609     }
1610     return FALSE;
1611   }
1612
1613   /**
1614    * Get additional participant Ids for cascading with primary participant status.
1615    *
1616    * @param int $participantId
1617    *   Participant id.
1618    * @param int $oldStatusId
1619    *   Previous status.
1620    * @param int $newStatusId
1621    *   New status.
1622    *
1623    * @return bool
1624    *   true if allowed
1625    */
1626   public static function getValidAdditionalIds($participantId, $oldStatusId, $newStatusId) {
1627
1628     $additionalParticipantIds = [];
1629
1630     static $participantStatuses = [];
1631
1632     if (empty($participantStatuses)) {
1633       $participantStatuses = CRM_Event_PseudoConstant::participantStatus();
1634     }
1635
1636     if (!empty(self::$_statusTransitionsRules[$participantStatuses[$oldStatusId]]) &&
1637       in_array($participantStatuses[$newStatusId], self::$_statusTransitionsRules[$participantStatuses[$oldStatusId]])
1638     ) {
1639       $additionalParticipantIds = self::getAdditionalParticipantIds($participantId, TRUE, $oldStatusId);
1640     }
1641
1642     return $additionalParticipantIds;
1643   }
1644
1645   /**
1646    * Get participant record count for a Contact.
1647    *
1648    * @param int $contactID
1649    *
1650    * @return int
1651    *   count of participant records
1652    */
1653   public static function getContactParticipantCount($contactID) {
1654     $query = "SELECT count(*)
1655 FROM     civicrm_participant
1656 WHERE    civicrm_participant.contact_id = {$contactID} AND
1657          civicrm_participant.is_test = 0";
1658     return CRM_Core_DAO::singleValueQuery($query);
1659   }
1660
1661   /**
1662    * Get participant ids by contribution id.
1663    *
1664    * @param int $contributionId
1665    *   Contribution Id.
1666    * @param bool $excludeCancelled
1667    *   Exclude cancelled additional participant.
1668    *
1669    * @return array
1670    */
1671   public static function getParticipantIds($contributionId, $excludeCancelled = FALSE) {
1672
1673     $ids = [];
1674     if (!$contributionId) {
1675       return $ids;
1676     }
1677
1678     // get primary participant id
1679     $query = "SELECT participant_id
1680       FROM civicrm_participant cp
1681       LEFT JOIN civicrm_participant_payment cpp ON cp.id = cpp.participant_id
1682       WHERE cpp.contribution_id = {$contributionId}
1683       AND cp.registered_by_id IS NULL";
1684     $participantPayment = CRM_Core_DAO::executeQuery($query);
1685
1686     // get additional participant ids (including cancelled)
1687     while ($participantPayment->fetch()) {
1688       $ids = array_merge($ids, array_merge([
1689         $participantPayment->participant_id,
1690       ], self::getAdditionalParticipantIds($participantPayment->participant_id,
1691         $excludeCancelled
1692       )));
1693     }
1694
1695     return $ids;
1696   }
1697
1698   /**
1699    * Get additional Participant edit & view url .
1700    *
1701    * @param array $participantIds
1702    *   An array of additional participant ids.
1703    *
1704    * @return array
1705    *   Array of Urls.
1706    */
1707   public static function getAdditionalParticipantUrl($participantIds) {
1708     foreach ($participantIds as $value) {
1709       $links = [];
1710       $details = self::participantDetails($value);
1711       $viewUrl = CRM_Utils_System::url('civicrm/contact/view/participant',
1712         "action=view&reset=1&id={$value}&cid={$details['cid']}"
1713       );
1714       $editUrl = CRM_Utils_System::url('civicrm/contact/view/participant',
1715         "action=update&reset=1&id={$value}&cid={$details['cid']}"
1716       );
1717       $links[] = "<td><a href='{$viewUrl}'>" . $details['name'] . "</a></td><td></td><td><a href='{$editUrl}'>" . ts('Edit') . "</a></td>";
1718       $links = "<table><tr>" . implode("</tr><tr>", $links) . "</tr></table>";
1719       return $links;
1720     }
1721   }
1722
1723   /**
1724    * create trxn entry if an event has discount.
1725    *
1726    * @param int $eventID
1727    *   Event id.
1728    * @param array $contributionParams
1729    *   Contribution params.
1730    *
1731    * @param string $feeLevel (deprecated)
1732    * @param int $discountedPriceFieldOptionID
1733    *   ID of the civicrm_price_field_value field for the discount id.
1734    */
1735   public static function createDiscountTrxn($eventID, $contributionParams, $feeLevel, $discountedPriceFieldOptionID = NULL) {
1736     $financialTypeID = $contributionParams['contribution']->financial_type_id;
1737     $total_amount = $contributionParams['total_amount'];
1738
1739     $checkDiscount = CRM_Core_BAO_Discount::findSet($eventID, 'civicrm_event');
1740     if (!empty($checkDiscount)) {
1741       $mainAmount = self::getUnDiscountedAmountForEventPriceSetFieldValue($eventID, $discountedPriceFieldOptionID, $feeLevel);
1742       $transactionParams['from_financial_account_id'] = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount(
1743         $financialTypeID, 'Discounts Account is');
1744       if (!empty($transactionParams['trxnParams']['from_financial_account_id'])) {
1745         $transactionParams['trxnParams']['total_amount'] = $mainAmount - $total_amount;
1746         $transactionParams['trxnParams']['payment_processor_id'] = NULL;
1747         $transactionParams['trxnParams']['payment_instrument_id'] = NULL;
1748         $transactionParams['trxnParams']['check_number'] = NULL;
1749         $transactionParams['trxnParams']['trxn_id'] = NULL;
1750         $transactionParams['trxnParams']['net_amount'] = NULL;
1751         $transactionParams['trxnParams']['fee_amount'] = NULL;
1752         CRM_Core_BAO_FinancialTrxn::create($transactionParams);
1753       }
1754     }
1755   }
1756
1757   /**
1758    * Delete participants of contact.
1759    *
1760    * @see https://issues.civicrm.org/jira/browse/CRM-12155
1761    *
1762    * @param int $contactId
1763    *   Contact id.
1764    *
1765    */
1766   public static function deleteContactParticipant($contactId) {
1767     $participant = new CRM_Event_DAO_Participant();
1768     $participant->contact_id = $contactId;
1769     $participant->find();
1770     while ($participant->fetch()) {
1771       self::deleteParticipant($participant->id);
1772     }
1773   }
1774
1775   /**
1776    * @param int $participantId
1777    * @param $activityType
1778    *
1779    * @throws CRM_Core_Exception
1780    */
1781   public static function addActivityForSelection($participantId, $activityType) {
1782     $eventId = CRM_Core_DAO::getFieldValue('CRM_Event_BAO_Participant', $participantId, 'event_id');
1783     $contactId = CRM_Core_DAO::getFieldValue('CRM_Event_BAO_Participant', $participantId, 'contact_id');
1784
1785     $date = CRM_Utils_Date::currentDBDate();
1786     $event = CRM_Event_BAO_Event::getEvents(0, $eventId);
1787     $subject = sprintf("Registration selections changed for %s", CRM_Utils_Array::value($eventId, $event));
1788
1789     // activity params
1790     $activityParams = [
1791       'source_contact_id' => $contactId,
1792       'source_record_id' => $participantId,
1793       'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', $activityType),
1794       'subject' => $subject,
1795       'activity_date_time' => $date,
1796       'status_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_status_id', 'Completed'),
1797       'skipRecentView' => TRUE,
1798     ];
1799
1800     // create activity with target contacts
1801     $id = CRM_Core_Session::getLoggedInContactID();
1802     if ($id) {
1803       $activityParams['source_contact_id'] = $id;
1804       $activityParams['target_contact_id'][] = $contactId;
1805     }
1806     // @todo use api & also look at duplication of similar methods.
1807     CRM_Activity_BAO_Activity::create($activityParams);
1808   }
1809
1810   /**
1811    * Get options for a given field.
1812    * @see CRM_Core_DAO::buildOptions
1813    *
1814    * @param string $fieldName
1815    * @param string $context
1816    * @see CRM_Core_DAO::buildOptionsContext
1817    * @param array $props
1818    *   whatever is known about this dao object.
1819    *
1820    * @return array|bool
1821    */
1822   public static function buildOptions($fieldName, $context = NULL, $props = []) {
1823     $params = ['condition' => []];
1824
1825     if ($fieldName == 'status_id' && $context != 'validate') {
1826       // Get rid of cart-related option if disabled
1827       // FIXME: Why does this option even exist if cart is disabled?
1828       if (!Civi::settings()->get('enable_cart')) {
1829         $params['condition'][] = "name <> 'Pending in cart'";
1830       }
1831     }
1832
1833     return CRM_Core_PseudoConstant::get(__CLASS__, $fieldName, $params, $context);
1834   }
1835
1836   /**
1837    * CRM-17797 -- Format fields and setDefaults for primary and additional participants profile
1838    * @param int $contactId
1839    * @param CRM_Core_Form $form
1840    */
1841   public static function formatFieldsAndSetProfileDefaults($contactId, &$form) {
1842     if (!$contactId) {
1843       return;
1844     }
1845     $fields = [];
1846     if (!empty($form->_fields)) {
1847       $removeCustomFieldTypes = ['Participant'];
1848
1849       foreach ($form->_fields as $name => $fieldInfo) {
1850         if ((substr($name, 0, 7) == 'custom_' && !$form->_allowConfirmation
1851           && !CRM_Core_BAO_CustomGroup::checkCustomField(substr($name, 7), $removeCustomFieldTypes))
1852           || substr($name, 0, 12) == 'participant_') {
1853           continue;
1854         }
1855         $fields[$name] = $fieldInfo;
1856       }
1857
1858       if (!empty($fields)) {
1859         CRM_Core_BAO_UFGroup::setProfileDefaults($contactId, $fields, $form->_defaults);
1860       }
1861     }
1862   }
1863
1864   /**
1865    * Evaluate whether a participant record is eligible for self-service transfer/cancellation.  If so,
1866    * return additional participant/event details.
1867    *
1868    * @param int $participantId
1869    * @param string $url
1870    * @param bool $isBackOffice
1871    */
1872   public static function getSelfServiceEligibility(int $participantId, string $url, bool $isBackOffice) : array {
1873     $optionGroupId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_OptionGroup', 'participant_role', 'id', 'name');
1874     $query = "
1875       SELECT cpst.name as status, cov.name as role, cp.fee_level, cp.fee_amount, cp.register_date, cp.status_id, ce.start_date, ce.title, cp.event_id, ce.allow_selfcancelxfer
1876       FROM civicrm_participant cp
1877       LEFT JOIN civicrm_participant_status_type cpst ON cpst.id = cp.status_id
1878       LEFT JOIN civicrm_option_value cov ON cov.value = cp.role_id and cov.option_group_id = {$optionGroupId}
1879       LEFT JOIN civicrm_event ce ON ce.id = cp.event_id
1880       WHERE cp.id = {$participantId}";
1881     $dao = CRM_Core_DAO::executeQuery($query);
1882     while ($dao->fetch()) {
1883       $details['eligible'] = TRUE;
1884       $details['status']  = $dao->status;
1885       $details['role'] = $dao->role;
1886       $details['fee_level'] = trim($dao->fee_level, CRM_Core_DAO::VALUE_SEPARATOR);
1887       $details['fee_amount'] = $dao->fee_amount;
1888       $details['register_date'] = $dao->register_date;
1889       $details['event_start_date'] = $dao->start_date;
1890       $details['allow_selfcancelxfer'] = $dao->allow_selfcancelxfer;
1891       $eventTitle = $dao->title;
1892       $eventId = $dao->event_id;
1893     }
1894     if (!$details['allow_selfcancelxfer'] && !$isBackOffice) {
1895       $details['eligible'] = FALSE;
1896       $details['ineligible_message'] = ts('This event registration can not be transferred or cancelled. Contact the event organizer if you have questions.');
1897       return $details;
1898     }
1899     //verify participant status is still Registered
1900     if ($details['status'] != 'Registered') {
1901       $details['eligible'] = FALSE;
1902       $details['ineligible_message'] = "You cannot transfer or cancel your registration for " . $eventTitle . ' as you are not currently registered for this event.';
1903       return $details;
1904     }
1905     // Determine if it's too late to self-service cancel/transfer.
1906     $query = "select start_date as start, selfcancelxfer_time as time from civicrm_event where id = " . $eventId;
1907     $dao = CRM_Core_DAO::executeQuery($query);
1908     while ($dao->fetch()) {
1909       $time_limit  = $dao->time;
1910       $start_date = $dao->start;
1911     }
1912     $timenow = new Datetime();
1913     if (!$isBackOffice && isset($time_limit)) {
1914       $cancelHours = abs($time_limit);
1915       $cancelInterval = new DateInterval("PT${cancelHours}H");
1916       $cancelInterval->invert = $time_limit < 0 ? 1 : 0;
1917       $cancelDeadline = (new Datetime($start_date))->sub($cancelInterval);
1918       if ($timenow > $cancelDeadline) {
1919         $details['eligible'] = FALSE;
1920         // Change the language of the status message based on whether the waitlist time limit is positive or negative.
1921         $afterOrPrior = $time_limit <= 0 ? 'after' : 'prior to';
1922         $moreOrLess = $time_limit <= 0 ? 'more' : 'fewer';
1923         $details['ineligible_message'] = ts("Registration for this event cannot be cancelled or transferred %1 than %2 hours %3 the event's start time. Contact the event organizer if you have questions.",
1924         [1 => $moreOrLess, 2 => $cancelHours, 3 => $afterOrPrior]);
1925
1926       }
1927     }
1928     return $details;
1929   }
1930
1931 }