CRM/Member/BAO/Membership.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.6                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2015                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2015
  32  * $Id$
  33  *
  34  */
  35 class CRM_Member_BAO_Membership extends CRM_Member_DAO_Membership {
  36
  37   /**
  38    * Static field for all the membership information that we can potentially import.
  39    *
  40    * @var array
  41    */
  42   static $_importableFields = NULL;
  43
  44   static $_renewalActType = NULL;
  45
  46   static $_signupActType = NULL;
  47
  48   /**
  49    * Class constructor.
  50    *
  51    * @return \CRM_Member_DAO_Membership
  52    */
  53   /**
  54    */
  55   public function __construct() {
  56     parent::__construct();
  57   }
  58
  59   /**
  60    * Takes an associative array and creates a membership object.
  61    *
  62    * the function extracts all the params it needs to initialize the created
  63    * membership object. The params array could contain additional unused name/value
  64    * pairs
  65    *
  66    * @param array $params
  67    *   (reference ) an assoc array of name/value pairs.
  68    * @param array $ids
  69    *   The array that holds all the db ids.
  70    *
  71    * @return CRM_Member_BAO_Membership
  72    */
  73   public static function add(&$params, $ids = array()) {
  74     $oldStatus = $oldType = NULL;
  75     $params['id'] = CRM_Utils_Array::value('id', $params, CRM_Utils_Array::value('membership', $ids));
  76     if ($params['id']) {
  77       CRM_Utils_Hook::pre('edit', 'Membership', $params['id'], $params);
  78     }
  79     else {
  80       CRM_Utils_Hook::pre('create', 'Membership', NULL, $params);
  81     }
  82     $id = $params['id'];
  83     // we do this after the hooks are called in case it has been altered
  84     if ($id) {
  85       $membershipObj = new CRM_Member_DAO_Membership();
  86       $membershipObj->id = $id;
  87       $membershipObj->find();
  88       while ($membershipObj->fetch()) {
  89         $oldStatus = $membershipObj->status_id;
  90         $oldType = $membershipObj->membership_type_id;
  91       }
  92     }
  93
  94     if (array_key_exists('is_override', $params) && !$params['is_override']) {
  95       $params['is_override'] = 'null';
  96     }
  97
  98     $membership = new CRM_Member_BAO_Membership();
  99     $membership->copyValues($params);
 100     $membership->id = $id;
 101
 102     $membership->save();
 103     $membership->free();
 104
 105     if (empty($membership->contact_id) || empty($membership->status_id)) {
 106       // this means we are in renewal mode and are just updating the membership
 107       // record or this is an API update call and all fields are not present in the update record
 108       // however the hooks don't care and want all data CRM-7784
 109       $tempMembership = new CRM_Member_DAO_Membership();
 110       $tempMembership->id = $membership->id;
 111       $tempMembership->find(TRUE);
 112       $membership = $tempMembership;
 113     }
 114
 115     //get the log start date.
 116     //it is set during renewal of membership.
 117     $logStartDate = CRM_Utils_Array::value('log_start_date', $params);
 118     $logStartDate = ($logStartDate) ? CRM_Utils_Date::isoToMysql($logStartDate) : CRM_Utils_Date::isoToMysql($membership->start_date);
 119     $values = self::getStatusANDTypeValues($membership->id);
 120
 121     $membershipLog = array(
 122       'membership_id' => $membership->id,
 123       'status_id' => $membership->status_id,
 124       'start_date' => $logStartDate,
 125       'end_date' => CRM_Utils_Date::isoToMysql($membership->end_date),
 126       'modified_date' => date('Ymd'),
 127       'membership_type_id' => $values[$membership->id]['membership_type_id'],
 128       'max_related' => $membership->max_related,
 129     );
 130
 131     $session = CRM_Core_Session::singleton();
 132     // If we have an authenticated session, set modified_id to that user's contact_id, else set to membership.contact_id
 133     if ($session->get('userID')) {
 134       $membershipLog['modified_id'] = $session->get('userID');
 135     }
 136     elseif (!empty($ids['userId'])) {
 137       $membershipLog['modified_id'] = $ids['userId'];
 138     }
 139     else {
 140       $membershipLog['modified_id'] = $membership->contact_id;
 141     }
 142
 143     CRM_Member_BAO_MembershipLog::add($membershipLog, CRM_Core_DAO::$_nullArray);
 144
 145     // reset the group contact cache since smart groups might be affected due to this
 146     CRM_Contact_BAO_GroupContactCache::remove();
 147
 148     if ($id) {
 149       if ($membership->status_id != $oldStatus) {
 150         $allStatus = CRM_Member_BAO_Membership::buildOptions('status_id', 'get');
 151         $activityParam = array(
 152           'subject' => "Status changed from {$allStatus[$oldStatus]} to {$allStatus[$membership->status_id]}",
 153           'source_contact_id' => $membershipLog['modified_id'],
 154           'target_contact_id' => $membership->contact_id,
 155           'source_record_id' => $membership->id,
 156           'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Change Membership Status'),
 157           'status_id' => 2,
 158           'priority_id' => 2,
 159           'activity_date_time' => date('Y-m-d H:i:s'),
 160         );
 161         civicrm_api3('activity', 'create', $activityParam);
 162       }
 163       if (isset($membership->membership_type_id) && $membership->membership_type_id != $oldType) {
 164         $membershipTypes = CRM_Member_BAO_Membership::buildOptions('membership_type_id', 'get');
 165         $activityParam = array(
 166           'subject' => "Type changed from {$membershipTypes[$oldType]} to {$membershipTypes[$membership->membership_type_id]}",
 167           'source_contact_id' => $membershipLog['modified_id'],
 168           'target_contact_id' => $membership->contact_id,
 169           'source_record_id' => $membership->id,
 170           'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Change Membership Type'),
 171           'status_id' => 2,
 172           'priority_id' => 2,
 173           'activity_date_time' => date('Y-m-d H:i:s'),
 174         );
 175         civicrm_api3('activity', 'create', $activityParam);
 176       }
 177       CRM_Utils_Hook::post('edit', 'Membership', $membership->id, $membership);
 178     }
 179     else {
 180       CRM_Utils_Hook::post('create', 'Membership', $membership->id, $membership);
 181     }
 182
 183     return $membership;
 184   }
 185
 186   /**
 187    * Given the list of params in the params array, fetch the object
 188    * and store the values in the values array
 189    *
 190    * @param array $params
 191    *   Input parameters to find object.
 192    * @param array $values
 193    *   Output values of the object.
 194    * @param bool $active
 195    *   Do you want only active memberships to.
 196    *                        be returned
 197    * @param bool $relatedMemberships
 198    * @return CRM_Member_BAO_Membership|null the found object or null
 199    */
 200   public static function &getValues(&$params, &$values, $active = FALSE, $relatedMemberships = FALSE) {
 201     if (empty($params)) {
 202       return NULL;
 203     }
 204     $membership = new CRM_Member_BAO_Membership();
 205
 206     $membership->copyValues($params);
 207     $membership->find();
 208     $memberships = array();
 209     while ($membership->fetch()) {
 210       if ($active &&
 211         (!CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipStatus',
 212           $membership->status_id,
 213           'is_current_member'
 214         ))
 215       ) {
 216         continue;
 217       }
 218
 219       CRM_Core_DAO::storeValues($membership, $values[$membership->id]);
 220       $memberships[$membership->id] = $membership;
 221       if ($relatedMemberships && !empty($membership->owner_membership_id)) {
 222         $values['owner_membership_ids'][] = $membership->owner_membership_id;
 223       }
 224     }
 225
 226     return $memberships;
 227   }
 228
 229   /**
 230    * Takes an associative array and creates a membership object.
 231    *
 232    * @param array $params
 233    *   (reference ) an assoc array of name/value pairs.
 234    * @param array $ids
 235    *   The array that holds all the db ids.
 236    * @param bool $skipRedirect
 237    * @param string $activityType
 238    *
 239    * @throws CRM_Core_Exception
 240    *
 241    * @return CRM_Member_BAO_Membership|CRM_Core_Error
 242    */
 243   public static function create(&$params, &$ids, $skipRedirect = FALSE, $activityType = 'Membership Signup') {
 244     // always calculate status if is_override/skipStatusCal is not true.
 245     // giving respect to is_override during import.  CRM-4012
 246
 247     // To skip status calculation we should use 'skipStatusCal'.
 248     // eg pay later membership, membership update cron CRM-3984
 249
 250     if (empty($params['is_override']) && empty($params['skipStatusCal'])) {
 251       $dates = array('start_date', 'end_date', 'join_date');
 252       $start_date = $end_date = $join_date = NULL; // declare these out of courtesy as IDEs don't pick up the setting of them below
 253       foreach ($dates as $date) {
 254         $$date = $params[$date] = CRM_Utils_Date::processDate(CRM_Utils_Array::value($date, $params), NULL, TRUE, 'Ymd');
 255       }
 256
 257       //fix for CRM-3570, during import exclude the statuses those having is_admin = 1
 258       $excludeIsAdmin = CRM_Utils_Array::value('exclude_is_admin', $params, FALSE);
 259
 260       //CRM-3724 always skip is_admin if is_override != true.
 261       if (!$excludeIsAdmin && empty($params['is_override'])) {
 262         $excludeIsAdmin = TRUE;
 263       }
 264
 265       //CRM-15829 UPDATES
 266       // When adding memberships to a contact and If a status is pending then there is no need to perform these calculations. Otherwise it will errernously not realise the pending state and set ot to NEW or GRACE depending on the date ranges.
 267       if (isset($params['status_id']) && $params['status_id'] == 5) {
 268         $calcStatus['id'] = $params['status_id'];
 269       }
 270       else {
 271         $calcStatus = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($start_date, $end_date, $join_date,
 272           'today', $excludeIsAdmin, CRM_Utils_Array::value('membership_type_id', $params), $params
 273         );
 274       }
 275
 276       if (empty($calcStatus)) {
 277         // Redirect the form in case of error
 278         // @todo this redirect in the BAO layer is really bad & should be moved to the form layer
 279         // however since we have no idea how (if) this is triggered we can't safely move / remove it
 280         // NB I tried really hard to trigger this error from backoffice membership form in order to test it
 281         // and am convinced form validation is complete on that form WRT this error.
 282         $errorParams = array(
 283           'message_title' => ts('No valid membership status for given dates.'),
 284           'legacy_redirect_path' => 'civicrm/contact/view',
 285           'legacy_redirect_query' => "reset=1&force=1&cid={$params['contact_id']}&selectedChild=member",
 286         );
 287         throw new CRM_Core_Exception(ts('The membership cannot be saved because the status cannot be calculated.'), 0, $errorParams);
 288       }
 289       $params['status_id'] = $calcStatus['id'];
 290     }
 291
 292     // data cleanup only: all verifications on number of related memberships are done upstream in:
 293     //    CRM_Member_BAO_Membership::createRelatedMemberships()
 294     //    CRM_Contact_BAO_Relationship::relatedMemberships()
 295     if (isset($params['owner_membership_id'])) {
 296       unset($params['max_related']);
 297     }
 298     else {
 299       // if membership allows related, default max_related to value in membership_type
 300       if (!array_key_exists('max_related', $params) && !empty($params['membership_type_id'])) {
 301         $membershipType = CRM_Member_BAO_MembershipType::getMembershipTypeDetails($params['membership_type_id']);
 302         if (isset($membershipType['relationship_type_id'])) {
 303           $params['max_related'] = CRM_Utils_Array::value('max_related', $membershipType);
 304         }
 305       }
 306     }
 307
 308     $transaction = new CRM_Core_Transaction();
 309
 310     $membership = self::add($params, $ids);
 311
 312     if (is_a($membership, 'CRM_Core_Error')) {
 313       $transaction->rollback();
 314       return $membership;
 315     }
 316
 317     // add custom field values
 318     if (!empty($params['custom']) && is_array($params['custom'])
 319     ) {
 320       CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_membership', $membership->id);
 321     }
 322
 323     $params['membership_id'] = $membership->id;
 324     if (isset($ids['membership'])) {
 325       $ids['contribution'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipPayment',
 326         $ids['membership'],
 327         'contribution_id',
 328         'membership_id'
 329       );
 330     }
 331
 332     $params['skipLineItem'] = TRUE;
 333
 334     //record contribution for this membership
 335     if (!empty($params['contribution_status_id']) && empty($params['relate_contribution_id'])) {
 336       $memInfo = array_merge($params, array('membership_id' => $membership->id));
 337       $params['contribution'] = self::recordMembershipContribution($memInfo, $ids);
 338     }
 339
 340     if (!empty($params['lineItems'])) {
 341       $params['line_item'] = $params['lineItems'];
 342     }
 343
 344     //do cleanup line  items if membership edit the Membership type.
 345     if (empty($ids['contribution']) && !empty($ids['membership'])) {
 346       CRM_Price_BAO_LineItem::deleteLineItems($ids['membership'], 'civicrm_membership');
 347     }
 348
 349     if (!empty($params['line_item']) && empty($ids['contribution'])) {
 350       CRM_Price_BAO_LineItem::processPriceSet($membership->id, $params['line_item'], CRM_Utils_Array::value('contribution', $params));
 351     }
 352
 353     //insert payment record for this membership
 354     if (!empty($params['relate_contribution_id'])) {
 355       CRM_Member_BAO_MembershipPayment::create(array(
 356         'membership_id' => $membership->id,
 357         'contribution_id' => $params['relate_contribution_id'],
 358       ));
 359     }
 360
 361     // add activity record only during create mode and renew mode
 362     // also add activity if status changed CRM-3984 and CRM-2521
 363     if (empty($ids['membership']) ||
 364       $activityType == 'Membership Renewal' || !empty($params['createActivity'])
 365     ) {
 366       if (!empty($ids['membership'])) {
 367         $data = array();
 368         CRM_Core_DAO::commonRetrieveAll('CRM_Member_DAO_Membership',
 369           'id',
 370           $membership->id,
 371           $data,
 372           array('contact_id', 'membership_type_id', 'source')
 373         );
 374
 375         $membership->contact_id = $data[$membership->id]['contact_id'];
 376         $membership->membership_type_id = $data[$membership->id]['membership_type_id'];
 377         $membership->source = CRM_Utils_Array::value('source', $data[$membership->id]);
 378       }
 379
 380       // since we are going to create activity record w/
 381       // individual contact as a target in case of on behalf signup,
 382       // so get the copy of organization id, CRM-5551
 383       $realMembershipContactId = $membership->contact_id;
 384
 385       // create activity source = individual, target = org CRM-4027
 386       $targetContactID = NULL;
 387       if (!empty($params['is_for_organization'])) {
 388         $targetContactID = $membership->contact_id;
 389         $membership->contact_id = CRM_Utils_Array::value('userId', $ids);
 390       }
 391
 392       if (empty($membership->contact_id) && (!empty($membership->owner_membership_id))) {
 393         $membership->contact_id = $realMembershipContactId;
 394       }
 395
 396       if (!empty($ids['membership']) && $activityType != 'Membership Signup') {
 397         CRM_Activity_BAO_Activity::addActivity($membership, $activityType, $targetContactID);
 398       }
 399       elseif (empty($ids['membership'])) {
 400         CRM_Activity_BAO_Activity::addActivity($membership, $activityType, $targetContactID);
 401       }
 402
 403       // we might created activity record w/ individual
 404       // contact as target so update membership object w/
 405       // original organization id, CRM-5551
 406       $membership->contact_id = $realMembershipContactId;
 407     }
 408
 409     $transaction->commit();
 410
 411     self::createRelatedMemberships($params, $membership);
 412
 413     // do not add to recent items for import, CRM-4399
 414     if (empty($params['skipRecentView'])) {
 415       $url = CRM_Utils_System::url('civicrm/contact/view/membership',
 416         "action=view&reset=1&id={$membership->id}&cid={$membership->contact_id}&context=home"
 417       );
 418       if (empty($membership->membership_type_id)) {// ie in an update situation
 419         $membership->find(TRUE);
 420       }
 421       $membershipTypes = CRM_Member_PseudoConstant::membershipType();
 422       $title = CRM_Contact_BAO_Contact::displayName($membership->contact_id) . ' - ' . ts('Membership Type:') . ' ' . $membershipTypes[$membership->membership_type_id];
 423
 424       $recentOther = array();
 425       if (CRM_Core_Permission::checkActionPermission('CiviMember', CRM_Core_Action::UPDATE)) {
 426         $recentOther['editUrl'] = CRM_Utils_System::url('civicrm/contact/view/membership',
 427           "action=update&reset=1&id={$membership->id}&cid={$membership->contact_id}&context=home"
 428         );
 429       }
 430       if (CRM_Core_Permission::checkActionPermission('CiviMember', CRM_Core_Action::DELETE)) {
 431         $recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/contact/view/membership',
 432           "action=delete&reset=1&id={$membership->id}&cid={$membership->contact_id}&context=home"
 433         );
 434       }
 435
 436       // add the recently created Membership
 437       CRM_Utils_Recent::add($title,
 438         $url,
 439         $membership->id,
 440         'Membership',
 441         $membership->contact_id,
 442         NULL,
 443         $recentOther
 444       );
 445     }
 446
 447     return $membership;
 448   }
 449
 450   /**
 451    * Check the membership extended through relationship.
 452    *
 453    * @param int $membershipId
 454    *   Membership id.
 455    * @param int $contactId
 456    *   Contact id.
 457    *
 458    * @param int $action
 459    *
 460    * @return array
 461    *   array of contact_id of all related contacts.
 462    */
 463   public static function checkMembershipRelationship($membershipId, $contactId, $action = CRM_Core_Action::ADD) {
 464     $contacts = array();
 465     $membershipTypeID = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership', $membershipId, 'membership_type_id');
 466
 467     $membershipType = CRM_Member_BAO_MembershipType::getMembershipTypeDetails($membershipTypeID);
 468     $relationships = array();
 469     if (isset($membershipType['relationship_type_id'])) {
 470       $relationships = CRM_Contact_BAO_Relationship::getRelationship($contactId,
 471         CRM_Contact_BAO_Relationship::CURRENT
 472       );
 473       if ($action & CRM_Core_Action::UPDATE) {
 474         $pastRelationships = CRM_Contact_BAO_Relationship::getRelationship($contactId,
 475           CRM_Contact_BAO_Relationship::PAST
 476         );
 477         $relationships = array_merge($relationships, $pastRelationships);
 478       }
 479     }
 480
 481     if (!empty($relationships)) {
 482       // check for each contact relationships
 483       foreach ($relationships as $values) {
 484         //get details of the relationship type
 485         $relType = array('id' => $values['civicrm_relationship_type_id']);
 486         $relValues = array();
 487         CRM_Contact_BAO_RelationshipType::retrieve($relType, $relValues);
 488         // Check if contact's relationship type exists in membership type
 489         $relTypeDirs = array();
 490         $relTypeIds = explode(CRM_Core_DAO::VALUE_SEPARATOR, $membershipType['relationship_type_id']);
 491         $relDirections = explode(CRM_Core_DAO::VALUE_SEPARATOR, $membershipType['relationship_direction']);
 492         $bidirectional = FALSE;
 493         foreach ($relTypeIds as $key => $value) {
 494           $relTypeDirs[] = $value . '_' . $relDirections[$key];
 495           if (in_array($value, $relType) &&
 496             $relValues['name_a_b'] == $relValues['name_b_a']
 497           ) {
 498             $bidirectional = TRUE;
 499             break;
 500           }
 501         }
 502         $relTypeDir = $values['civicrm_relationship_type_id'] . '_' . $values['rtype'];
 503         if ($bidirectional || in_array($relTypeDir, $relTypeDirs)) {
 504           // $values['status'] is going to have value for
 505           // current or past relationships.
 506           $contacts[$values['cid']] = $values['status'];
 507         }
 508       }
 509     }
 510
 511     // Sort by contact_id ascending
 512     ksort($contacts);
 513     return $contacts;
 514   }
 515
 516   /**
 517    * Retrieve DB object based on input parameters.
 518    *
 519    * It also stores all the retrieved values in the default array.
 520    *
 521    * @param array $params
 522    *   (reference ) an assoc array of name/value pairs.
 523    * @param array $defaults
 524    *   (reference ) an assoc array to hold the name / value pairs.
 525    *                        in a hierarchical manner
 526    *
 527    * @return CRM_Member_BAO_Membership
 528    */
 529   public static function retrieve(&$params, &$defaults) {
 530     $membership = new CRM_Member_DAO_Membership();
 531
 532     $membership->copyValues($params);
 533
 534     if ($membership->find(TRUE)) {
 535       CRM_Core_DAO::storeValues($membership, $defaults);
 536
 537       //get the membership status and type values.
 538       $statusANDType = self::getStatusANDTypeValues($membership->id);
 539       foreach (array(
 540                  'status',
 541                  'membership_type',
 542                ) as $fld) {
 543         $defaults[$fld] = CRM_Utils_Array::value($fld, $statusANDType[$membership->id]);
 544       }
 545       if (!empty($statusANDType[$membership->id]['is_current_member'])) {
 546         $defaults['active'] = TRUE;
 547       }
 548
 549       $membership->free();
 550
 551       return $membership;
 552     }
 553
 554     return NULL;
 555   }
 556
 557   /**
 558    *
 559    * get membership status and membership type values
 560    *
 561    * @param int $membershipId
 562    *   Membership id of values to return.
 563    *
 564    * @return array
 565    *   Array of key value pairs
 566    */
 567   public static function getStatusANDTypeValues($membershipId) {
 568     $values = array();
 569     if (!$membershipId) {
 570       return $values;
 571     }
 572     $sql = '
 573     SELECT  membership.id as id,
 574             status.id as status_id,
 575             status.label as status,
 576             status.is_current_member as is_current_member,
 577             type.id as membership_type_id,
 578             type.name as membership_type,
 579             type.relationship_type_id as relationship_type_id
 580       FROM  civicrm_membership membership
 581 INNER JOIN  civicrm_membership_status status ON ( status.id = membership.status_id )
 582 INNER JOIN  civicrm_membership_type type ON ( type.id = membership.membership_type_id )
 583      WHERE  membership.id = %1';
 584     $dao = CRM_Core_DAO::executeQuery($sql, array(1 => array($membershipId, 'Positive')));
 585     $properties = array(
 586       'status',
 587       'status_id',
 588       'membership_type',
 589       'membership_type_id',
 590       'is_current_member',
 591       'relationship_type_id',
 592     );
 593     while ($dao->fetch()) {
 594       foreach ($properties as $property) {
 595         $values[$dao->id][$property] = $dao->$property;
 596       }
 597     }
 598
 599     return $values;
 600   }
 601
 602   /**
 603    * Delete membership.
 604    * Wrapper for most delete calls. Use this unless you JUST want to delete related memberships w/o deleting the parent.
 605    *
 606    * @param int $membershipId
 607    *   Membership id that needs to be deleted.
 608    *
 609    *
 610    * @return int $results  id of deleted Membership on success, false otherwise
 611    */
 612   public static function del($membershipId) {
 613     //delete related first and then delete parent.
 614     self::deleteRelatedMemberships($membershipId);
 615     return self::deleteMembership($membershipId);
 616   }
 617
 618   /**
 619    * Delete membership.
 620    *
 621    * @param int $membershipId
 622    *   Membership id that needs to be deleted.
 623    *
 624    *
 625    * @return int $results id of deleted Membership on success, false otherwise
 626    */
 627   public static function deleteMembership($membershipId) {
 628     // CRM-12147, retrieve membership data before we delete it for hooks
 629     $params = array('id' => $membershipId);
 630     $memValues = array();
 631     $memberships = self::getValues($params, $memValues);
 632
 633     $membership = $memberships[$membershipId];
 634
 635     CRM_Utils_Hook::pre('delete', 'Membership', $membershipId, $memValues);
 636
 637     $transaction = new CRM_Core_Transaction();
 638
 639     $results = NULL;
 640     //delete activity record
 641     $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, FALSE, FALSE, 'name');
 642
 643     $params = array();
 644     $deleteActivity = FALSE;
 645     $membershipActivities = array(
 646       'Membership Signup',
 647       'Membership Renewal',
 648       'Change Membership Status',
 649       'Change Membership Type',
 650       'Membership Renewal Reminder',
 651     );
 652     foreach ($membershipActivities as $membershipActivity) {
 653       $activityId = array_search($membershipActivity, $activityTypes);
 654       if ($activityId) {
 655         $params['activity_type_id'][] = $activityId;
 656         $deleteActivity = TRUE;
 657       }
 658     }
 659     if ($deleteActivity) {
 660       $params['source_record_id'] = $membershipId;
 661       CRM_Activity_BAO_Activity::deleteActivity($params);
 662     }
 663     self::deleteMembershipPayment($membershipId);
 664
 665     $results = $membership->delete();
 666     $transaction->commit();
 667
 668     CRM_Utils_Hook::post('delete', 'Membership', $membership->id, $membership);
 669
 670     // delete the recently created Membership
 671     $membershipRecent = array(
 672       'id' => $membershipId,
 673       'type' => 'Membership',
 674     );
 675     CRM_Utils_Recent::del($membershipRecent);
 676
 677     return $results;
 678   }
 679
 680   /**
 681    * Delete related memberships.
 682    *
 683    * @param int $ownerMembershipId
 684    * @param int $contactId
 685    *
 686    * @return null
 687    */
 688   public static function deleteRelatedMemberships($ownerMembershipId, $contactId = NULL) {
 689     if (!$ownerMembershipId && !$contactId) {
 690       return FALSE;
 691     }
 692
 693     $membership = new CRM_Member_DAO_Membership();
 694     $membership->owner_membership_id = $ownerMembershipId;
 695
 696     if ($contactId) {
 697       $membership->contact_id = $contactId;
 698     }
 699
 700     $membership->find();
 701     while ($membership->fetch()) {
 702       //delete related first and then delete parent.
 703       self::deleteRelatedMemberships($membership->id);
 704       self::deleteMembership($membership->id);
 705     }
 706     $membership->free();
 707   }
 708
 709   /**
 710    * Obtain active/inactive memberships from the list of memberships passed to it.
 711    *
 712    * @param array $memberships
 713    *   Membership records.
 714    * @param string $status
 715    *   Active or inactive.
 716    *
 717    * @return array
 718    *   array of memberships based on status
 719    */
 720   public static function activeMembers($memberships, $status = 'active') {
 721     $actives = array();
 722     if ($status == 'active') {
 723       foreach ($memberships as $f => $v) {
 724         if (!empty($v['active'])) {
 725           $actives[$f] = $v;
 726         }
 727       }
 728       return $actives;
 729     }
 730     elseif ($status == 'inactive') {
 731       foreach ($memberships as $f => $v) {
 732         if (empty($v['active'])) {
 733           $actives[$f] = $v;
 734         }
 735       }
 736       return $actives;
 737     }
 738     return NULL;
 739   }
 740
 741   /**
 742    * Build Membership  Block in Contribution Pages.
 743    *
 744    * @param CRM_Core_Form $form
 745    *   Form object.
 746    * @param int $pageID
 747    *   Unused?.
 748    * @param int $cid
 749    *   Contact checked for having a current membership for a particular membership.
 750    * @param bool $formItems
 751    * @param int $selectedMembershipTypeID
 752    *   Selected membership id.
 753    * @param bool $thankPage
 754    *   Thank you page.
 755    * @param null $isTest
 756    *
 757    * @return bool
 758    *   Is this a separate membership payment
 759    *
 760    */
 761   public static function buildMembershipBlock(
 762     &$form,
 763     $pageID,
 764     $cid,
 765     $formItems = FALSE,
 766     $selectedMembershipTypeID = NULL,
 767     $thankPage = FALSE,
 768     $isTest = NULL
 769   ) {
 770
 771     $separateMembershipPayment = FALSE;
 772     if ($form->_membershipBlock) {
 773       $form->_currentMemberships = array();
 774
 775       $membershipBlock = $form->_membershipBlock;
 776       $membershipTypeIds = $membershipTypes = $radio = array();
 777       $membershipPriceset = (!empty($form->_priceSetId) && $form->_useForMember) ? TRUE : FALSE;
 778
 779       $allowAutoRenewMembership = $autoRenewOption = FALSE;
 780       $autoRenewMembershipTypeOptions = array();
 781
 782       $paymentProcessor = CRM_Core_PseudoConstant::paymentProcessor(FALSE, FALSE, 'is_recur = 1');
 783
 784       $separateMembershipPayment = CRM_Utils_Array::value('is_separate_payment', $membershipBlock);
 785
 786       if ($membershipPriceset) {
 787         foreach ($form->_priceSet['fields'] as $pField) {
 788           if (empty($pField['options'])) {
 789             continue;
 790           }
 791           foreach ($pField['options'] as $opId => $opValues) {
 792             if (empty($opValues['membership_type_id'])) {
 793               continue;
 794             }
 795             $membershipTypeIds[$opValues['membership_type_id']] = $opValues['membership_type_id'];
 796           }
 797         }
 798       }
 799       elseif (!empty($membershipBlock['membership_types'])) {
 800         $membershipTypeIds = explode(',', $membershipBlock['membership_types']);
 801       }
 802
 803       if (!empty($membershipTypeIds)) {
 804         //set status message if wrong membershipType is included in membershipBlock
 805         if (isset($form->_mid) && !$membershipPriceset) {
 806           $membershipTypeID = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
 807             $form->_mid,
 808             'membership_type_id'
 809           );
 810           if (!in_array($membershipTypeID, $membershipTypeIds)) {
 811             CRM_Core_Session::setStatus(ts("Oops. The membership you're trying to renew appears to be invalid. Contact your site administrator if you need assistance. If you continue, you will be issued a new membership."), ts('Invalid Membership'), 'error');
 812           }
 813         }
 814
 815         $membershipTypeValues = self::buildMembershipTypeValues($form, $membershipTypeIds);
 816         $form->_membershipTypeValues = $membershipTypeValues;
 817         $endDate = NULL;
 818         foreach ($membershipTypeIds as $value) {
 819           $memType = $membershipTypeValues[$value];
 820           if ($selectedMembershipTypeID != NULL) {
 821             if ($memType['id'] == $selectedMembershipTypeID) {
 822               $form->assign('minimum_fee',
 823                 CRM_Utils_Array::value('minimum_fee', $memType)
 824               );
 825               $form->assign('membership_name', $memType['name']);
 826               if (!$thankPage && $cid) {
 827                 $membership = new CRM_Member_DAO_Membership();
 828                 $membership->contact_id = $cid;
 829                 $membership->membership_type_id = $memType['id'];
 830                 if ($membership->find(TRUE)) {
 831                   $form->assign('renewal_mode', TRUE);
 832                   $memType['current_membership'] = $membership->end_date;
 833                   $form->_currentMemberships[$membership->membership_type_id] = $membership->membership_type_id;
 834                 }
 835               }
 836               $membershipTypes[] = $memType;
 837             }
 838           }
 839           elseif ($memType['is_active']) {
 840             $javascriptMethod = NULL;
 841             $allowAutoRenewOpt = 1;
 842             if (is_array($form->_paymentProcessors)) {
 843               foreach ($form->_paymentProcessors as $id => $val) {
 844                 if (!$val['is_recur']) {
 845                   $allowAutoRenewOpt = 0;
 846                   continue;
 847                 }
 848               }
 849             }
 850
 851             $javascriptMethod = array('onclick' => "return showHideAutoRenew( this.value );");
 852             $autoRenewMembershipTypeOptions["autoRenewMembershipType_{$value}"] = (int) $allowAutoRenewOpt * CRM_Utils_Array::value($value, CRM_Utils_Array::value('auto_renew', $form->_membershipBlock));;
 853
 854             if ($allowAutoRenewOpt) {
 855               $allowAutoRenewMembership = TRUE;
 856             }
 857
 858             //add membership type.
 859             $radio[$memType['id']] = $form->createElement('radio', NULL, NULL, NULL,
 860               $memType['id'], $javascriptMethod
 861             );
 862             if ($cid) {
 863               $membership = new CRM_Member_DAO_Membership();
 864               $membership->contact_id = $cid;
 865               $membership->membership_type_id = $memType['id'];
 866
 867               //show current membership, skip pending and cancelled membership records,
 868               //because we take first membership record id for renewal
 869               $membership->whereAdd('status_id != 5 AND status_id !=6');
 870
 871               if (!is_null($isTest)) {
 872                 $membership->is_test = $isTest;
 873               }
 874
 875               //CRM-4297
 876               $membership->orderBy('end_date DESC');
 877
 878               if ($membership->find(TRUE)) {
 879                 if (!$membership->end_date) {
 880                   unset($radio[$memType['id']]);
 881                   $form->assign('islifetime', TRUE);
 882                   continue;
 883                 }
 884                 $form->assign('renewal_mode', TRUE);
 885                 $form->_currentMemberships[$membership->membership_type_id] = $membership->membership_type_id;
 886                 $memType['current_membership'] = $membership->end_date;
 887                 if (!$endDate) {
 888                   $endDate = $memType['current_membership'];
 889                   $form->_defaultMemTypeId = $memType['id'];
 890                 }
 891                 if ($memType['current_membership'] < $endDate) {
 892                   $endDate = $memType['current_membership'];
 893                   $form->_defaultMemTypeId = $memType['id'];
 894                 }
 895               }
 896             }
 897             $membershipTypes[] = $memType;
 898           }
 899         }
 900       }
 901
 902       $form->assign('showRadio', $formItems);
 903       if ($formItems) {
 904         if (!$membershipPriceset) {
 905           if (!$membershipBlock['is_required']) {
 906             $form->assign('showRadioNoThanks', TRUE);
 907             $radio[''] = $form->createElement('radio', NULL, NULL, NULL, 'no_thanks', NULL);
 908             $form->addGroup($radio, 'selectMembership', NULL);
 909           }
 910           elseif ($membershipBlock['is_required'] && count($radio) == 1) {
 911             $temp = array_keys($radio);
 912             $form->add('hidden', 'selectMembership', $temp[0], array('id' => 'selectMembership'));
 913             $form->assign('singleMembership', TRUE);
 914             $form->assign('showRadio', FALSE);
 915           }
 916           else {
 917             $form->addGroup($radio, 'selectMembership', NULL);
 918           }
 919
 920           $form->addRule('selectMembership', ts('Please select one of the memberships.'), 'required');
 921         }
 922         else {
 923           $autoRenewOption = CRM_Price_BAO_PriceSet::checkAutoRenewForPriceSet($form->_priceSetId);
 924           $form->assign('autoRenewOption', $autoRenewOption);
 925         }
 926
 927         if (!$form->_values['is_pay_later'] && is_array($form->_paymentProcessors) && ($allowAutoRenewMembership || $autoRenewOption)) {
 928           $form->addElement('checkbox', 'auto_renew', ts('Please renew my membership automatically.'));
 929         }
 930
 931       }
 932
 933       $form->assign('membershipBlock', $membershipBlock);
 934       $form->assign('membershipTypes', $membershipTypes);
 935       $form->assign('allowAutoRenewMembership', $allowAutoRenewMembership);
 936       $form->assign('autoRenewMembershipTypeOptions', json_encode($autoRenewMembershipTypeOptions));
 937
 938       //give preference to user submitted auto_renew value.
 939       $takeUserSubmittedAutoRenew = (!empty($_POST) || $form->isSubmitted()) ? TRUE : FALSE;
 940       $form->assign('takeUserSubmittedAutoRenew', $takeUserSubmittedAutoRenew);
 941     }
 942
 943     return $separateMembershipPayment;
 944   }
 945
 946   /**
 947    * Return Membership Block info in Contribution Pages.
 948    *
 949    * @param int $pageID
 950    *   Contribution page id.
 951    *
 952    * @return array|null
 953    *
 954    */
 955   public static function getMembershipBlock($pageID) {
 956     $membershipBlock = array();
 957     $dao = new CRM_Member_DAO_MembershipBlock();
 958     $dao->entity_table = 'civicrm_contribution_page';
 959
 960     $dao->entity_id = $pageID;
 961     $dao->is_active = 1;
 962     if ($dao->find(TRUE)) {
 963       CRM_Core_DAO::storeValues($dao, $membershipBlock);
 964       if (!empty($membershipBlock['membership_types'])) {
 965         $membershipTypes = unserialize($membershipBlock['membership_types']);
 966         if (!is_array($membershipTypes)) {
 967           return $membershipBlock;
 968         }
 969         $memTypes = array();
 970         foreach ($membershipTypes as $key => $value) {
 971           $membershipBlock['auto_renew'][$key] = $value;
 972           $memTypes[$key] = $key;
 973         }
 974         $membershipBlock['membership_types'] = implode(',', $memTypes);
 975       }
 976     }
 977     else {
 978       return NULL;
 979     }
 980
 981     return $membershipBlock;
 982   }
 983
 984   /**
 985    * Return a current membership of given contact.
 986    * NB: if more than one membership meets criteria, a randomly selected one is returned.
 987    *
 988    * @param int $contactID
 989    *   Contact id.
 990    * @param int $memType
 991    *   Membership type, null to retrieve all types.
 992    * @param int $isTest
 993    * @param int $membershipId
 994    *   If provided, then determine if it is current.
 995    * @param bool $onlySameParentOrg
 996    *   True if only Memberships with same parent org as the $memType wanted, false otherwise.
 997    *
 998    * @return array|bool
 999    */
1000   public static function getContactMembership($contactID, $memType, $isTest, $membershipId = NULL, $onlySameParentOrg = FALSE) {
1001     $dao = new CRM_Member_DAO_Membership();
1002     if ($membershipId) {
1003       $dao->id = $membershipId;
1004     }
1005     $dao->contact_id = $contactID;
1006     $dao->membership_type_id = $memType;
1007
1008     //fetch proper membership record.
1009     if ($isTest) {
1010       $dao->is_test = $isTest;
1011     }
1012     else {
1013       $dao->whereAdd('is_test IS NULL OR is_test = 0');
1014     }
1015
1016     //avoid pending membership as current membership: CRM-3027
1017     $statusIds[] = array_search('Pending', CRM_Member_PseudoConstant::membershipStatus());
1018     if (!$membershipId) {
1019       // CRM-15475
1020       $statusIds[] = array_search(
1021         'Cancelled',
1022         CRM_Member_PseudoConstant::membershipStatus(
1023           NULL,
1024           " name = 'Cancelled' ",
1025           'name',
1026           FALSE,
1027           TRUE
1028         )
1029       );
1030     }
1031     $dao->whereAdd('status_id NOT IN ( ' . implode(',', $statusIds) . ')');
1032
1033     // order by start date to find most recent membership first, CRM-4545
1034     $dao->orderBy('start_date DESC');
1035
1036     // CRM-8141
1037     if ($onlySameParentOrg && $memType) {
1038       // require the same parent org as the $memType
1039       $params = array('id' => $memType);
1040       $membershipType = array();
1041       if (CRM_Member_BAO_MembershipType::retrieve($params, $membershipType)) {
1042         $memberTypesSameParentOrg = CRM_Member_BAO_MembershipType::getMembershipTypesByOrg($membershipType['member_of_contact_id']);
1043         $memberTypesSameParentOrgList = implode(',', array_keys($memberTypesSameParentOrg));
1044         $dao->whereAdd('membership_type_id IN (' . $memberTypesSameParentOrgList . ')');
1045       }
1046     }
1047
1048     if ($dao->find(TRUE)) {
1049       $membership = array();
1050       CRM_Core_DAO::storeValues($dao, $membership);
1051       $membership['is_current_member'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipStatus',
1052         $membership['status_id'],
1053         'is_current_member', 'id'
1054       );
1055       return $membership;
1056     }
1057
1058     // CRM-8141
1059     if ($onlySameParentOrg && $memType) {
1060       // see if there is a membership that has same parent as $memType but different parent than $membershipID
1061       if ($dao->id && CRM_Core_Permission::check('edit memberships')) {
1062         // CRM-10016, This is probably a backend renewal, and make sure we return the same membership thats being renewed.
1063         $dao->whereAdd();
1064       }
1065       else {
1066         unset($dao->id);
1067       }
1068
1069       unset($dao->membership_type_id);
1070       if ($dao->find(TRUE)) {
1071         $membership = array();
1072         CRM_Core_DAO::storeValues($dao, $membership);
1073         $membership['is_current_member'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipStatus',
1074           $membership['status_id'],
1075           'is_current_member', 'id'
1076         );
1077         return $membership;
1078       }
1079     }
1080     return FALSE;
1081   }
1082
1083   /**
1084    * Combine all the importable fields from the lower levels object.
1085    *
1086    * @param string $contactType
1087    *   Contact type.
1088    * @param bool $status
1089    *
1090    * @return array
1091    *   array of importable Fields
1092    */
1093   public static function &importableFields($contactType = 'Individual', $status = TRUE) {
1094     if (!self::$_importableFields) {
1095       if (!self::$_importableFields) {
1096         self::$_importableFields = array();
1097       }
1098
1099       if (!$status) {
1100         $fields = array('' => array('title' => '- ' . ts('do not import') . ' -'));
1101       }
1102       else {
1103         $fields = array('' => array('title' => '- ' . ts('Membership Fields') . ' -'));
1104       }
1105
1106       $tmpFields = CRM_Member_DAO_Membership::import();
1107       $contactFields = CRM_Contact_BAO_Contact::importableFields($contactType, NULL);
1108
1109       // Using new Dedupe rule.
1110       $ruleParams = array(
1111         'contact_type' => $contactType,
1112         'used' => 'Unsupervised',
1113       );
1114       $fieldsArray = CRM_Dedupe_BAO_Rule::dedupeRuleFields($ruleParams);
1115
1116       $tmpContactField = array();
1117       if (is_array($fieldsArray)) {
1118         foreach ($fieldsArray as $value) {
1119           $customFieldId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
1120             $value,
1121             'id',
1122             'column_name'
1123           );
1124           $value = $customFieldId ? 'custom_' . $customFieldId : $value;
1125           $tmpContactField[trim($value)] = CRM_Utils_Array::value(trim($value), $contactFields);
1126           if (!$status) {
1127             $title = $tmpContactField[trim($value)]['title'] . " " . ts('(match to contact)');
1128           }
1129           else {
1130             $title = $tmpContactField[trim($value)]['title'];
1131           }
1132           $tmpContactField[trim($value)]['title'] = $title;
1133         }
1134       }
1135       $tmpContactField['external_identifier'] = $contactFields['external_identifier'];
1136       $tmpContactField['external_identifier']['title'] = $contactFields['external_identifier']['title'] . " " . ts('(match to contact)');
1137
1138       $tmpFields['membership_contact_id']['title'] = $tmpFields['membership_contact_id']['title'] . " " . ts('(match to contact)');;
1139
1140       $fields = array_merge($fields, $tmpContactField);
1141       $fields = array_merge($fields, $tmpFields);
1142       $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Membership'));
1143       self::$_importableFields = $fields;
1144     }
1145     return self::$_importableFields;
1146   }
1147
1148   /**
1149    * Get all exportable fields.
1150    *
1151    * @retun array return array of all exportable fields
1152    */
1153   public static function &exportableFields() {
1154     $expFieldMembership = CRM_Member_DAO_Membership::export();
1155
1156     $expFieldsMemType = CRM_Member_DAO_MembershipType::export();
1157     $fields = array_merge($expFieldMembership, $expFieldsMemType);
1158     $fields = array_merge($fields, $expFieldMembership);
1159     $membershipStatus = array(
1160       'membership_status' => array(
1161         'title' => 'Membership Status',
1162         'name' => 'membership_status',
1163         'type' => CRM_Utils_Type::T_STRING,
1164         'where' => 'civicrm_membership_status.name',
1165       ),
1166     );
1167     //CRM-6161 fix for customdata export
1168     $fields = array_merge($fields, $membershipStatus, CRM_Core_BAO_CustomField::getFieldsForImport('Membership'));
1169     return $fields;
1170   }
1171
1172   /**
1173    * Get membership joins/renewals for a specified membership
1174    * type.  Specifically, retrieves a count of memberships whose "Membership
1175    * Signup" or "Membership Renewal" activity falls in the given date range.
1176    * Dates match the pattern "yyyy-mm-dd".
1177    *
1178    * @param int $membershipTypeId
1179    *   Membership type id.
1180    * @param int $startDate
1181    *   Date on which to start counting.
1182    * @param int $endDate
1183    *   Date on which to end counting.
1184    * @param bool|int $isTest if true, membership is for a test site
1185    * @param bool|int $isOwner if true, only retrieve membership records for owners //LCD
1186    *
1187    * @return int
1188    *   the number of members of type $membershipTypeId whose
1189    *   start_date is between $startDate and $endDate
1190    */
1191   public static function getMembershipStarts($membershipTypeId, $startDate, $endDate, $isTest = 0, $isOwner = 0) {
1192
1193     $testClause = 'membership.is_test = 1';
1194     if (!$isTest) {
1195       $testClause = '( membership.is_test IS NULL OR membership.is_test = 0 )';
1196     }
1197
1198     if (!self::$_signupActType || !self::$_renewalActType) {
1199       self::_getActTypes();
1200     }
1201
1202     if (!self::$_signupActType || !self::$_renewalActType) {
1203       return 0;
1204     }
1205
1206     $query = "
1207     SELECT  COUNT(DISTINCT membership.id) as member_count
1208       FROM  civicrm_membership membership
1209 INNER JOIN civicrm_activity activity ON (activity.source_record_id = membership.id AND activity.activity_type_id in (%1, %2))
1210 INNER JOIN  civicrm_membership_status status ON ( membership.status_id = status.id AND status.is_current_member = 1 )
1211 INNER JOIN  civicrm_contact contact ON ( contact.id = membership.contact_id AND contact.is_deleted = 0 )
1212      WHERE  membership.membership_type_id = %3
1213        AND  activity.activity_date_time >= '$startDate' AND activity.activity_date_time <= '$endDate 23:59:59'
1214        AND  {$testClause}";
1215
1216     $query .= ($isOwner) ? ' AND owner_membership_id IS NULL' : '';
1217
1218     $params = array(
1219       1 => array(self::$_signupActType, 'Integer'),
1220       2 => array(self::$_renewalActType, 'Integer'),
1221       3 => array($membershipTypeId, 'Integer'),
1222     );
1223
1224     $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
1225     return (int) $memberCount;
1226   }
1227
1228   /**
1229    * Get a count of membership for a specified membership type,
1230    * optionally for a specified date.  The date must have the form yyyy-mm-dd.
1231    *
1232    * If $date is omitted, this function counts as a member anyone whose
1233    * membership status_id indicates they're a current member.
1234    * If $date is given, this function counts as a member anyone who:
1235    *  -- Has a start_date before $date and end_date after $date, or
1236    *  -- Has a start_date before $date and is currently a member, as indicated
1237    *     by the the membership's status_id.
1238    * The second condition takes care of records that have no end_date.  These
1239    * are assumed to be lifetime memberships.
1240    *
1241    * @param int $membershipTypeId
1242    *   Membership type id.
1243    * @param string $date
1244    *   The date for which to retrieve the count.
1245    * @param bool|int $isTest if true, membership is for a test site
1246    * @param bool|int $isOwner if true, only retrieve membership records for owners //LCD
1247    *
1248    * @return int
1249    *   the number of members of type $membershipTypeId as of $date.
1250    */
1251   public static function getMembershipCount($membershipTypeId, $date = NULL, $isTest = 0, $isOwner = 0) {
1252     if (!CRM_Utils_Rule::date($date)) {
1253       CRM_Core_Error::fatal(ts('Invalid date "%1" (must have form yyyy-mm-dd).', array(1 => $date)));
1254     }
1255
1256     $params = array(
1257       1 => array($membershipTypeId, 'Integer'),
1258       2 => array($isTest, 'Boolean'),
1259     );
1260     $query = "SELECT  count(civicrm_membership.id ) as member_count
1261 FROM   civicrm_membership left join civicrm_membership_status on ( civicrm_membership.status_id = civicrm_membership_status.id  )
1262 WHERE  civicrm_membership.membership_type_id = %1
1263 AND civicrm_membership.contact_id NOT IN (SELECT id FROM civicrm_contact WHERE is_deleted = 1)
1264 AND civicrm_membership.is_test = %2";
1265     if (!$date) {
1266       $query .= " AND civicrm_membership_status.is_current_member = 1";
1267     }
1268     else {
1269       $query .= " AND civicrm_membership.start_date <= '$date' AND civicrm_membership_status.is_current_member = 1";
1270     }
1271     // LCD
1272     $query .= ($isOwner) ? ' AND owner_membership_id IS NULL' : '';
1273     $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
1274     return (int) $memberCount;
1275   }
1276
1277   /**
1278    * Function check the status of the membership before adding membership for a contact.
1279    *
1280    * @param int $contactId
1281    *   Contact id.
1282    *
1283    * @return int
1284    */
1285   public static function statusAvailabilty($contactId) {
1286     $membership = new CRM_Member_DAO_MembershipStatus();
1287     $membership->whereAdd('is_active=1');
1288     return $membership->count();
1289   }
1290
1291   /**
1292    * Process the Memberships.
1293    *
1294    * @param array $membershipParams
1295    *   Array of membership fields.
1296    * @param int $contactID
1297    *   Contact id.
1298    * @param CRM_Contribute_Form_Contribution_Confirm $form
1299    *   Confirmation form object.
1300    *
1301    * @param array $premiumParams
1302    * @param null $customFieldsFormatted
1303    * @param null $includeFieldTypes
1304    *
1305    * @param array $membershipDetails
1306    *
1307    * @param array $membershipTypeIDs
1308    *
1309    * @param bool $isPaidMembership
1310    * @param array $membershipID
1311    *
1312    * @param $isProcessSeparateMembershipTransaction
1313    *
1314    * @param int $defaultContributionTypeID
1315    * @param array $membershipLineItems
1316    *   Line items specific to membership payment that is separate to contribution.
1317    * @param $isPayLater
1318    *
1319    * @throws \CRM_Core_Exception
1320    */
1321   public static function postProcessMembership(
1322     $membershipParams, $contactID, &$form, $premiumParams,
1323     $customFieldsFormatted = NULL, $includeFieldTypes = NULL, $membershipDetails, $membershipTypeIDs, $isPaidMembership, $membershipID,
1324     $isProcessSeparateMembershipTransaction, $defaultContributionTypeID, $membershipLineItems, $isPayLater) {
1325     $result = $membershipContribution = NULL;
1326     $isTest = CRM_Utils_Array::value('is_test', $membershipParams, FALSE);
1327     $errors = $createdMemberships = array();
1328
1329     //@todo move this into the calling function & pass in the correct financialTypeID
1330     if (isset($paymentParams['financial_type'])) {
1331       $financialTypeID = $paymentParams['financial_type'];
1332     }
1333     else {
1334       $financialTypeID = $defaultContributionTypeID;
1335     }
1336
1337     if (CRM_Utils_Array::value('membership_source', $form->_params)) {
1338       $membershipParams['contribution_source'] = $form->_params['membership_source'];
1339     }
1340
1341     if ($isPaidMembership) {
1342       $result = CRM_Contribute_BAO_Contribution_Utils::processConfirm($form, $membershipParams,
1343         $premiumParams, $contactID,
1344         $financialTypeID,
1345         'membership',
1346         array(),
1347         $isTest,
1348         $isPayLater
1349       );
1350       if (is_a($result[1], 'CRM_Core_Error')) {
1351         $errors[1] = CRM_Core_Error::getMessages($result[1]);
1352       }
1353       elseif (!empty($result[1])) {
1354         // Save the contribution ID so that I can be used in email receipts
1355         // For example, if you need to generate a tax receipt for the donation only.
1356         $form->_values['contribution_other_id'] = $result[1]->id;
1357         //note that this will be over-written if we are using a separate membership transaction. Otherwise there is only one
1358         $membershipContribution = $result[1];
1359       }
1360     }
1361
1362     if ($isProcessSeparateMembershipTransaction) {
1363       try {
1364         $lineItems = $form->_lineItem = $membershipLineItems;
1365         if (empty($form->_params['auto_renew']) && !empty($membershipParams['is_recur'])) {
1366           unset($membershipParams['is_recur']);
1367         }
1368         $membershipContribution = self::processSecondaryFinancialTransaction($contactID, $form, $membershipParams, $isTest, $membershipLineItems, CRM_Utils_Array::value('minimum_fee', $membershipDetails, 0), CRM_Utils_Array::value('financial_type_id', $membershipDetails));
1369       }
1370       catch (CRM_Core_Exception $e) {
1371         $errors[2] = $e->getMessage();
1372         $membershipContribution = NULL;
1373       }
1374     }
1375
1376     $membership = NULL;
1377     if (!empty($membershipContribution) && !is_a($membershipContribution, 'CRM_Core_Error')) {
1378       $membershipContributionID = $membershipContribution->id;
1379     }
1380
1381     //@todo - why is this nested so deep? it seems like it could be just set on the calling function on the form layer
1382     if (isset($membershipParams['onbehalf']) && !empty($membershipParams['onbehalf']['member_campaign_id'])) {
1383       $form->_params['campaign_id'] = $membershipParams['onbehalf']['member_campaign_id'];
1384     }
1385     //@todo it should no longer be possible for it to get to this point & membership to not be an array
1386     if (is_array($membershipTypeIDs) && !empty($membershipContributionID)) {
1387       $typesTerms = CRM_Utils_Array::value('types_terms', $membershipParams, array());
1388       foreach ($membershipTypeIDs as $memType) {
1389         $numTerms = CRM_Utils_Array::value($memType, $typesTerms, 1);
1390         $createdMemberships[$memType] = self::createOrRenewMembership($membershipParams, $contactID, $customFieldsFormatted, $membershipID, $memType, $isTest, $numTerms, $membershipContribution, $form);
1391       }
1392       if ($form->_priceSetId && !empty($form->_useForMember) && !empty($form->_lineItem)) {
1393         foreach ($form->_lineItem[$form->_priceSetId] as & $priceFieldOp) {
1394           if (!empty($priceFieldOp['membership_type_id']) &&
1395             isset($createdMemberships[$priceFieldOp['membership_type_id']])
1396           ) {
1397             $membershipOb = $createdMemberships[$priceFieldOp['membership_type_id']];
1398             $priceFieldOp['start_date'] = $membershipOb->start_date ? CRM_Utils_Date::customFormat($membershipOb->start_date, '%B %E%f, %Y') : '-';
1399             $priceFieldOp['end_date'] = $membershipOb->end_date ? CRM_Utils_Date::customFormat($membershipOb->end_date, '%B %E%f, %Y') : '-';
1400           }
1401           else {
1402             $priceFieldOp['start_date'] = $priceFieldOp['end_date'] = 'N/A';
1403           }
1404         }
1405         $form->_values['lineItem'] = $form->_lineItem;
1406         $form->assign('lineItem', $form->_lineItem);
1407       }
1408     }
1409
1410     if (!empty($errors)) {
1411       $message = self::compileErrorMessage($errors);
1412       throw new CRM_Core_Exception($message);
1413     }
1414     $form->_params['createdMembershipIDs'] = array();
1415
1416     // CRM-7851 - Moved after processing Payment Errors
1417     //@todo - the reasoning for this being here seems a little outdated
1418     foreach ($createdMemberships as $createdMembership) {
1419       CRM_Core_BAO_CustomValueTable::postProcess(
1420         $form->_params,
1421         CRM_Core_DAO::$_nullArray,
1422         'civicrm_membership',
1423         $createdMembership->id,
1424         'Membership'
1425       );
1426       $form->_params['createdMembershipIDs'][] = $createdMembership->id;
1427     }
1428     if (count($createdMemberships) == 1) {
1429       //presumably this is only relevant for exactly 1 membership
1430       $form->_params['membershipID'] = $createdMembership->id;
1431     }
1432
1433     //CRM-15232: Check if membership is created and on the basis of it use
1434     //membership reciept template to send payment reciept
1435     if (count($createdMemberships)) {
1436       $form->_values['isMembership'] = TRUE;
1437     }
1438     if ($form->_contributeMode == 'notify') {
1439       if ($form->_values['is_monetary'] && $form->_amount > 0.0 && !$form->_params['is_pay_later']) {
1440         // call postProcess hook before leaving
1441         $form->postProcessHook();
1442         // this does not return
1443         $payment = CRM_Core_Payment::singleton($form->_mode, $form->_paymentProcessor, $form);
1444         $payment->doTransferCheckout($form->_params, 'contribute');
1445       }
1446     }
1447
1448     if (isset($membershipContributionID)) {
1449       $form->_values['contribution_id'] = $membershipContributionID;
1450     }
1451
1452     // Do not send an email if Recurring transaction is done via Direct Mode
1453     // Email will we sent when the IPN is received.
1454     if (!empty($form->_params['is_recur']) && $form->_contributeMode == 'direct') {
1455       if (!empty($membershipContribution->trxn_id)) {
1456         try {
1457           civicrm_api3('contribution', 'completetransaction', array(
1458             'id' => $membershipContribution->id,
1459             'trxn_id' => $membershipContribution->trxn_id,
1460           ));
1461         }
1462         catch (CiviCRM_API3_Exception $e) {
1463           // if for any reason it is already completed this will fail - e.g extensions hacking around core not completing transactions prior to CRM-15296
1464           // so let's be gentle here
1465           CRM_Core_Error::debug_log_message('contribution ' . $membershipContribution->id . ' not completed with trxn_id ' . $membershipContribution->trxn_id . ' and message ' . $e->getMessage());
1466         }
1467       }
1468       return;
1469     }
1470
1471     //finally send an email receipt
1472     CRM_Contribute_BAO_ContributionPage::sendMail($contactID,
1473       $form->_values,
1474       $isTest, FALSE,
1475       $includeFieldTypes
1476     );
1477   }
1478
1479   /**
1480    * Function for updating a membership record's contribution_recur_id
1481    *
1482    * @param CRM_Member_DAO_Membership $membership
1483    * @param \CRM_Contribute_BAO_Contribution|\CRM_Contribute_DAO_Contribution $contribution
1484    *
1485    * @return void
1486    */
1487   static public function updateRecurMembership(CRM_Member_DAO_Membership $membership, CRM_Contribute_BAO_Contribution $contribution) {
1488
1489     if (empty($contribution->contribution_recur_id)) {
1490       return;
1491     }
1492
1493     $params = array(
1494       1 => array($contribution->contribution_recur_id, 'Integer'),
1495       2 => array($membership->id, 'Integer'),
1496     );
1497
1498     $sql = "UPDATE civicrm_membership SET contribution_recur_id = %1 WHERE id = %2";
1499     CRM_Core_DAO::executeQuery($sql, $params);
1500   }
1501
1502   /**
1503    * @deprecated
1504    * A wrapper for renewing memberships from a form - including the form in the membership processing adds complexity
1505    * as the forms are being forced to pretend similarity
1506    * Try to call the renewMembership directly
1507    * @todo - this form method needs to have the interaction with the form layer removed from it
1508    * as a BAO function. Note that the api now supports membership renewals & it is not clear this function does anything
1509    * not done by the membership.create api (with a lot less unit tests)
1510    *
1511    * This method will renew / create the membership depending on
1512    * whether the given contact has a membership or not. And will add
1513    * the modified dates for membership and in the log table.
1514    *
1515    * @param int $contactID
1516    *   Id of the contact.
1517    * @param int $membershipTypeID
1518    *   Id of the new membership type.
1519    * @param bool $is_test
1520    *   If this is test contribution or live contribution.
1521    * @param CRM_Core_Form $form
1522    *   Form object.
1523    * @param null $changeToday
1524    * @param int $modifiedID
1525    *   Individual contact id in case of On Behalf signup (CRM-4027 ).
1526    * @param null $customFieldsFormatted
1527    * @param int $numRenewTerms
1528    *   How many membership terms are being added to end date (default is 1).
1529    * @param int $membershipID
1530    *   Membership ID, this should always be passed in & optionality should be removed.
1531    *
1532    * @throws CRM_Core_Exception
1533    *
1534    */
1535   public static function renewMembershipFormWrapper(
1536     $contactID,
1537     $membershipTypeID,
1538     $is_test,
1539     &$form,
1540     $changeToday = NULL,
1541     $modifiedID = NULL,
1542     $customFieldsFormatted = NULL,
1543     $numRenewTerms = 1,
1544     $membershipID = NULL,
1545     $pending = FALSE
1546   ) {
1547     $statusFormat = '%Y-%m-%d';
1548     $format = '%Y%m%d';
1549     $ids = array();
1550     //@todo would be better to make $membershipID a compulsory function param & make form layer responsible for extracting it
1551     if (!$membershipID && isset($form->_membershipId)) {
1552       $membershipID = $form->_membershipId;
1553     }
1554
1555     //get all active statuses of membership.
1556     $allStatus = CRM_Member_PseudoConstant::membershipStatus();
1557
1558     $membershipTypeDetails = CRM_Member_BAO_MembershipType::getMembershipTypeDetails($membershipTypeID);
1559
1560     // check is it pending. - CRM-4555
1561     list($pending, $contributionRecurID, $changeToday, $membershipSource, $isPayLater, $campaignId) = self::extractFormValues($form, $changeToday, $membershipTypeDetails, $pending);
1562     list($membership, $renewalMode, $dates) = self::renewMembership($contactID, $membershipTypeID, $is_test, $changeToday, $modifiedID, $customFieldsFormatted, $numRenewTerms, $membershipID, $pending, $allStatus, $membershipTypeDetails, $contributionRecurID, $format, $membershipSource, $ids, $statusFormat, $isPayLater, $campaignId);
1563     $form->set('renewal_mode', $renewalMode);
1564     if (!empty($dates)) {
1565       $form->assign('mem_start_date',
1566         CRM_Utils_Date::customFormat($dates['start_date'], $format)
1567       );
1568       $form->assign('mem_end_date',
1569         CRM_Utils_Date::customFormat($dates['end_date'], $format)
1570       );
1571     }
1572     return $membership;
1573
1574   }
1575
1576   /**
1577    * Method to fix membership status of stale membership.
1578    *
1579    * This method first checks if the membership is stale. If it is,
1580    * then status will be updated based on existing start and end
1581    * dates and log will be added for the status change.
1582    *
1583    * @param array $currentMembership
1584    *   Reference to the array.
1585    *   containing all values of
1586    *   the current membership
1587    * @param array $changeToday
1588    *   Array of month, day, year.
1589    *   values in case today needs
1590    *   to be customised, null otherwise
1591    *
1592    * @return void
1593    */
1594   public static function fixMembershipStatusBeforeRenew(&$currentMembership, $changeToday) {
1595     $today = NULL;
1596     if ($changeToday) {
1597       $today = CRM_Utils_Date::processDate($changeToday, NULL, FALSE, 'Y-m-d');
1598     }
1599
1600     $status = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate(
1601       CRM_Utils_Array::value('start_date', $currentMembership),
1602       CRM_Utils_Array::value('end_date', $currentMembership),
1603       CRM_Utils_Array::value('join_date', $currentMembership),
1604       $today,
1605       TRUE,
1606       $currentMembership['membership_type_id'],
1607       $currentMembership
1608     );
1609
1610     if (empty($status) ||
1611       empty($status['id'])
1612     ) {
1613       CRM_Core_Error::fatal(ts('Oops, it looks like there is no valid membership status corresponding to the membership start and end dates for this membership. Contact the site administrator for assistance.'));
1614     }
1615
1616     $currentMembership['today_date'] = $today;
1617
1618     if ($status['id'] !== $currentMembership['status_id']) {
1619       $memberDAO = new CRM_Member_DAO_Membership();
1620       $memberDAO->id = $currentMembership['id'];
1621       $memberDAO->find(TRUE);
1622
1623       $memberDAO->status_id = $status['id'];
1624       $memberDAO->join_date = CRM_Utils_Date::isoToMysql($memberDAO->join_date);
1625       $memberDAO->start_date = CRM_Utils_Date::isoToMysql($memberDAO->start_date);
1626       $memberDAO->end_date = CRM_Utils_Date::isoToMysql($memberDAO->end_date);
1627       $memberDAO->save();
1628       CRM_Core_DAO::storeValues($memberDAO, $currentMembership);
1629       $memberDAO->free();
1630
1631       $currentMembership['is_current_member'] = CRM_Core_DAO::getFieldValue(
1632         'CRM_Member_DAO_MembershipStatus',
1633         $currentMembership['status_id'],
1634         'is_current_member'
1635       );
1636       $format = '%Y%m%d';
1637
1638       $logParams = array(
1639         'membership_id' => $currentMembership['id'],
1640         'status_id' => $status['id'],
1641         'start_date' => CRM_Utils_Date::customFormat(
1642           $currentMembership['start_date'],
1643           $format
1644         ),
1645         'end_date' => CRM_Utils_Date::customFormat(
1646           $currentMembership['end_date'],
1647           $format
1648         ),
1649         'modified_date' => CRM_Utils_Date::customFormat(
1650           $currentMembership['today_date'],
1651           $format
1652         ),
1653         'membership_type_id' => $currentMembership['membership_type_id'],
1654         'max_related' => CRM_Utils_Array::value('max_related', $currentMembership, 0),
1655       );
1656
1657       $session = CRM_Core_Session::singleton();
1658       // If we have an authenticated session, set modified_id to that user's contact_id, else set to membership.contact_id
1659       if ($session->get('userID')) {
1660         $logParams['modified_id'] = $session->get('userID');
1661       }
1662       else {
1663         $logParams['modified_id'] = $currentMembership['contact_id'];
1664       }
1665       CRM_Member_BAO_MembershipLog::add($logParams, CRM_Core_DAO::$_nullArray);
1666     }
1667   }
1668
1669   /**
1670    * Get the contribution page id from the membership record.
1671    *
1672    * @param int $membershipID
1673    *
1674    * @return int
1675    *   contribution page id
1676    */
1677   public static function getContributionPageId($membershipID) {
1678     $query = "
1679 SELECT c.contribution_page_id as pageID
1680   FROM civicrm_membership_payment mp, civicrm_contribution c
1681  WHERE mp.contribution_id = c.id
1682    AND c.contribution_page_id IS NOT NULL
1683    AND mp.membership_id = " . CRM_Utils_Type::escape($membershipID, 'Integer')
1684       . " ORDER BY mp.id DESC";
1685
1686     return CRM_Core_DAO::singleValueQuery($query,
1687       CRM_Core_DAO::$_nullArray
1688     );
1689   }
1690
1691   /**
1692    * Updated related memberships.
1693    *
1694    * @param int $ownerMembershipId
1695    *   Owner Membership Id.
1696    * @param array $params
1697    *   Formatted array of key => value.
1698    */
1699   public static function updateRelatedMemberships($ownerMembershipId, $params) {
1700     $membership = new CRM_Member_DAO_Membership();
1701     $membership->owner_membership_id = $ownerMembershipId;
1702     $membership->find();
1703
1704     while ($membership->fetch()) {
1705       $relatedMembership = new CRM_Member_DAO_Membership();
1706       $relatedMembership->id = $membership->id;
1707       $relatedMembership->copyValues($params);
1708       $relatedMembership->save();
1709       $relatedMembership->free();
1710     }
1711
1712     $membership->free();
1713   }
1714
1715   /**
1716    * Get list of membership fields for profile.
1717    * For now we only allow custom membership fields to be in
1718    * profile
1719    *
1720    * @param null $mode
1721    *   FIXME: This param is ignored
1722    *
1723    * @return array
1724    *   the list of membership fields
1725    */
1726   public static function getMembershipFields($mode = NULL) {
1727     $fields = CRM_Member_DAO_Membership::export();
1728
1729     unset($fields['membership_contact_id']);
1730     $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Membership'));
1731
1732     $membershipType = CRM_Member_DAO_MembershipType::export();
1733
1734     $membershipStatus = CRM_Member_DAO_MembershipStatus::export();
1735
1736     $fields = array_merge($fields, $membershipType, $membershipStatus);
1737
1738     return $fields;
1739   }
1740
1741   /**
1742    * Get the sort name of a contact for a particular membership.
1743    *
1744    * @param int $id
1745    *   Id of the membership.
1746    *
1747    * @return null|string
1748    *   sort name of the contact if found
1749    */
1750   public static function sortName($id) {
1751     $id = CRM_Utils_Type::escape($id, 'Integer');
1752
1753     $query = "
1754 SELECT civicrm_contact.sort_name
1755 FROM   civicrm_membership, civicrm_contact
1756 WHERE  civicrm_membership.contact_id = civicrm_contact.id
1757   AND  civicrm_membership.id = {$id}
1758 ";
1759     return CRM_Core_DAO::singleValueQuery($query, CRM_Core_DAO::$_nullArray);
1760   }
1761
1762   /**
1763    * Create memberships for related contacts.
1764    * takes into account the maximum related memberships
1765    *
1766    * @param array $params
1767    *   Array of key - value pairs.
1768    * @param CRM_Core_DAO $dao
1769    *   Membership object.
1770    *
1771    * @return null|array
1772    *   array of memberships if created
1773    */
1774   public static function createRelatedMemberships(&$params, &$dao, $reset = FALSE) {
1775     static $relatedContactIds = array();
1776     if ($reset) {
1777       // not sure why a static var is in use here - we need a way to reset it from the test suite
1778       $relatedContactIds = array();
1779       return FALSE;
1780     }
1781
1782     $membership = new CRM_Member_DAO_Membership();
1783     $membership->id = $dao->id;
1784
1785     // required since create method doesn't return all the
1786     // parameters in the returned membership object
1787     if (!$membership->find(TRUE)) {
1788       return;
1789     }
1790     $deceasedStatusId = array_search('Deceased', CRM_Member_PseudoConstant::membershipStatus());
1791     // FIXME : While updating/ renewing the
1792     // membership, if the relationship is PAST then
1793     // the membership of the related contact must be
1794     // expired.
1795     // For that, getting Membership Status for which
1796     // is_current_member is 0. It works for the
1797     // generated data as there is only one membership
1798     // status having is_current_member = 0.
1799     // But this wont work exactly if there will be
1800     // more than one status having is_current_member = 0.
1801     $membershipStatus = new CRM_Member_DAO_MembershipStatus();
1802     $membershipStatus->is_current_member = 0;
1803     if ($membershipStatus->find(TRUE)) {
1804       $expiredStatusId = $membershipStatus->id;
1805     }
1806     else {
1807       $expiredStatusId = array_search('Expired', CRM_Member_PseudoConstant::membershipStatus());
1808     }
1809
1810     $allRelatedContacts = array();
1811     $relatedContacts = array();
1812     if (!is_a($membership, 'CRM_Core_Error')) {
1813       $allRelatedContacts = CRM_Member_BAO_Membership::checkMembershipRelationship($membership->id,
1814         $membership->contact_id,
1815         CRM_Utils_Array::value('action', $params)
1816       );
1817     }
1818
1819     // check for loops. CRM-4213
1820     // remove repeated related contacts, which already inherited membership.
1821     $relatedContactIds[$membership->contact_id] = TRUE;
1822     foreach ($allRelatedContacts as $cid => $status) {
1823       if (empty($relatedContactIds[$cid])) {
1824         $relatedContactIds[$cid] = TRUE;
1825
1826         //don't create membership again for owner contact.
1827         $nestedRelationship = FALSE;
1828         if ($membership->owner_membership_id) {
1829           $nestedRelMembership = new CRM_Member_DAO_Membership();
1830           $nestedRelMembership->id = $membership->owner_membership_id;
1831           $nestedRelMembership->contact_id = $cid;
1832           $nestedRelationship = $nestedRelMembership->find(TRUE);
1833           $nestedRelMembership->free();
1834         }
1835         if (!$nestedRelationship) {
1836           $relatedContacts[$cid] = $status;
1837         }
1838       }
1839     }
1840
1841     //lets cleanup related membership if any.
1842     if (empty($relatedContacts)) {
1843       self::deleteRelatedMemberships($membership->id);
1844     }
1845     else {
1846       // Edit the params array
1847       unset($params['id']);
1848       // Reminder should be sent only to the direct membership
1849       unset($params['reminder_date']);
1850       // unset the custom value ids
1851       if (is_array(CRM_Utils_Array::value('custom', $params))) {
1852         foreach ($params['custom'] as $k => $v) {
1853           unset($params['custom'][$k]['id']);
1854         }
1855       }
1856       if (!isset($params['membership_type_id'])) {
1857         $params['membership_type_id'] = $membership->membership_type_id;
1858       }
1859
1860       // max_related should be set in the parent membership
1861       unset($params['max_related']);
1862       // Number of inherited memberships available - NULL is interpreted as unlimited, '0' as none
1863       $available = ($membership->max_related == NULL ? PHP_INT_MAX : $membership->max_related);
1864       $queue = array(); // will be used to queue potential memberships to be created
1865
1866       foreach ($relatedContacts as $contactId => $relationshipStatus) {
1867         //use existing membership record.
1868         $relMembership = new CRM_Member_DAO_Membership();
1869         $relMembership->contact_id = $contactId;
1870         $relMembership->owner_membership_id = $membership->id;
1871         $relMemIds = array();
1872         if ($relMembership->find(TRUE)) {
1873           $params['id'] = $relMemIds['membership'] = $relMembership->id;
1874         }
1875         $params['contact_id'] = $contactId;
1876         $params['owner_membership_id'] = $membership->id;
1877
1878         // set status_id as it might have been changed for
1879         // past relationship
1880         $params['status_id'] = $membership->status_id;
1881
1882         if ($deceasedStatusId &&
1883           CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $contactId, 'is_deceased')
1884         ) {
1885           $params['status_id'] = $deceasedStatusId;
1886         }
1887         elseif ((CRM_Utils_Array::value('action', $params) & CRM_Core_Action::UPDATE) &&
1888           ($relationshipStatus == CRM_Contact_BAO_Relationship::PAST)
1889         ) {
1890           $params['status_id'] = $expiredStatusId;
1891         }
1892
1893         //don't calculate status again in create( );
1894         $params['skipStatusCal'] = TRUE;
1895
1896         //do create activity if we changed status.
1897         if ($params['status_id'] != $relMembership->status_id) {
1898           $params['createActivity'] = TRUE;
1899         }
1900
1901         // we should not created contribution record for related contacts, CRM-3371
1902         unset($params['contribution_status_id']);
1903
1904         if (($params['status_id'] == $deceasedStatusId) || ($params['status_id'] == $expiredStatusId)) {
1905           // related membership is not active so does not count towards maximum
1906           CRM_Member_BAO_Membership::create($params, $relMemIds);
1907         }
1908         else {
1909           // related membership already exists, so this is just an update
1910           if (isset($params['id'])) {
1911             if ($available > 0) {
1912               CRM_Member_BAO_Membership::create($params, $relMemIds);
1913               $available--;
1914             }
1915             else {
1916               // we have run out of inherited memberships, so delete extras
1917               self::deleteMembership($params['id']);
1918             }
1919             // we need to first check if there will remain inherited memberships, so queue it up
1920           }
1921           else {
1922             $queue[] = $params;
1923           }
1924         }
1925       }
1926       // now go over the queue and create any available related memberships
1927       reset($queue);
1928       while (($available > 0) && ($params = each($queue))) {
1929         CRM_Member_BAO_Membership::create($params['value'], $relMemIds);
1930         $available--;
1931       }
1932     }
1933   }
1934
1935   /**
1936    * Delete the record that are associated with this Membership Payment.
1937    *
1938    * @param int $membershipId
1939    *
1940    * @return object
1941    *   $membershipPayment deleted membership payment object
1942    */
1943   public static function deleteMembershipPayment($membershipId) {
1944
1945     $membershipPayment = new CRM_Member_DAO_MembershipPayment();
1946     $membershipPayment->membership_id = $membershipId;
1947     $membershipPayment->find();
1948
1949     while ($membershipPayment->fetch()) {
1950       CRM_Contribute_BAO_Contribution::deleteContribution($membershipPayment->contribution_id);
1951       CRM_Utils_Hook::pre('delete', 'MembershipPayment', $membershipPayment->id, $membershipPayment);
1952       $membershipPayment->delete();
1953       CRM_Utils_Hook::post('delete', 'MembershipPayment', $membershipPayment->id, $membershipPayment);
1954     }
1955     return $membershipPayment;
1956   }
1957
1958   /**
1959    * @param CRM_Core_Form $form
1960    * @param int $membershipTypeID
1961    *
1962    * @return array
1963    */
1964   public static function &buildMembershipTypeValues(&$form, $membershipTypeID = NULL) {
1965     $whereClause = " WHERE domain_id = " . CRM_Core_Config::domainID();
1966
1967     if (is_array($membershipTypeID)) {
1968       $allIDs = implode(',', $membershipTypeID);
1969       $whereClause .= " AND id IN ( $allIDs )";
1970     }
1971     elseif (is_numeric($membershipTypeID) &&
1972       $membershipTypeID > 0
1973     ) {
1974       $whereClause .= " AND id = $membershipTypeID";
1975     }
1976
1977     $query = "
1978 SELECT *
1979 FROM   civicrm_membership_type
1980        $whereClause;
1981 ";
1982     $dao = CRM_Core_DAO::executeQuery($query);
1983
1984     $membershipTypeValues = array();
1985     $membershipTypeFields = array(
1986       'id',
1987       'minimum_fee',
1988       'name',
1989       'is_active',
1990       'description',
1991       'financial_type_id',
1992       'auto_renew',
1993       'member_of_contact_id',
1994       'relationship_type_id',
1995       'relationship_direction',
1996       'max_related',
1997     );
1998
1999     while ($dao->fetch()) {
2000       $membershipTypeValues[$dao->id] = array();
2001       foreach ($membershipTypeFields as $mtField) {
2002         $membershipTypeValues[$dao->id][$mtField] = $dao->$mtField;
2003       }
2004     }
2005     $dao->free();
2006
2007     CRM_Utils_Hook::membershipTypeValues($form, $membershipTypeValues);
2008
2009     if (is_numeric($membershipTypeID) &&
2010       $membershipTypeID > 0
2011     ) {
2012       return $membershipTypeValues[$membershipTypeID];
2013     }
2014     else {
2015       return $membershipTypeValues;
2016     }
2017   }
2018
2019   /**
2020    * Get membership record count for a Contact.
2021    *
2022    * @param int $contactID
2023    * @param bool $activeOnly
2024    *
2025    * @return null|string
2026    */
2027   public static function getContactMembershipCount($contactID, $activeOnly = FALSE) {
2028     $select = "SELECT count(*) FROM civicrm_membership ";
2029     $where = "WHERE civicrm_membership.contact_id = {$contactID} AND civicrm_membership.is_test = 0 ";
2030
2031     // CRM-6627, all status below 3 (active, pending, grace) are considered active
2032     if ($activeOnly) {
2033       $select .= " INNER JOIN civicrm_membership_status ON civicrm_membership.status_id = civicrm_membership_status.id ";
2034       $where .= " and civicrm_membership_status.is_current_member = 1";
2035     }
2036
2037     $query = $select . $where;
2038     return CRM_Core_DAO::singleValueQuery($query);
2039   }
2040
2041   /**
2042    * Check whether payment processor supports
2043    * cancellation of membership subscription
2044    *
2045    * @param int $mid
2046    *   Membership id.
2047    *
2048    * @param bool $isNotCancelled
2049    *
2050    * @return bool
2051    */
2052   public static function isCancelSubscriptionSupported($mid, $isNotCancelled = TRUE) {
2053     $cacheKeyString = "$mid";
2054     $cacheKeyString .= $isNotCancelled ? '_1' : '_0';
2055
2056     static $supportsCancel = array();
2057
2058     if (!array_key_exists($cacheKeyString, $supportsCancel)) {
2059       $supportsCancel[$cacheKeyString] = FALSE;
2060       $isCancelled = FALSE;
2061
2062       if ($isNotCancelled) {
2063         $isCancelled = self::isSubscriptionCancelled($mid);
2064       }
2065
2066       $paymentObject = CRM_Financial_BAO_PaymentProcessor::getProcessorForEntity($mid, 'membership', 'obj');
2067       if (!empty($paymentObject)) {
2068         $supportsCancel[$cacheKeyString] = $paymentObject->isSupported('cancelSubscription') && !$isCancelled;
2069       }
2070     }
2071     return $supportsCancel[$cacheKeyString];
2072   }
2073
2074   /**
2075    * Check whether subscription is already cancelled.
2076    *
2077    * @param int $mid
2078    *   Membership id.
2079    *
2080    * @return string
2081    *   contribution status
2082    */
2083   public static function isSubscriptionCancelled($mid) {
2084     $sql = "
2085    SELECT cr.contribution_status_id
2086      FROM civicrm_contribution_recur cr
2087 LEFT JOIN civicrm_membership mem ON ( cr.id = mem.contribution_recur_id )
2088     WHERE mem.id = %1 LIMIT 1";
2089     $params = array(1 => array($mid, 'Integer'));
2090     $statusId = CRM_Core_DAO::singleValueQuery($sql, $params);
2091     $status = CRM_Contribute_PseudoConstant::contributionStatus($statusId, 'name');
2092     if ($status == 'Cancelled') {
2093       return TRUE;
2094     }
2095     return FALSE;
2096   }
2097
2098   /**
2099    * Get membership joins for a specified membership
2100    * type.  Specifically, retrieves a count of still current memberships whose
2101    * join_date and start_date are within a specified date range.  Dates match
2102    * the pattern "yyyy-mm-dd".
2103    *
2104    * @param int $membershipTypeId
2105    *   Membership type id.
2106    * @param int $startDate
2107    *   Date on which to start counting.
2108    * @param int $endDate
2109    *   Date on which to end counting.
2110    * @param bool|int $isTest if true, membership is for a test site
2111    *
2112    * @return int
2113    *   the number of members of type $membershipTypeId
2114    *   whose join_date is between $startDate and $endDate and
2115    *   whose start_date is between $startDate and $endDate
2116    */
2117   public static function getMembershipJoins($membershipTypeId, $startDate, $endDate, $isTest = 0) {
2118     $testClause = 'membership.is_test = 1';
2119     if (!$isTest) {
2120       $testClause = '( membership.is_test IS NULL OR membership.is_test = 0 )';
2121     }
2122     if (!self::$_signupActType) {
2123       self::_getActTypes();
2124     }
2125
2126     if (!self::$_signupActType) {
2127       return 0;
2128     }
2129
2130     $query = "
2131     SELECT  COUNT(DISTINCT membership.id) as member_count
2132       FROM  civicrm_membership membership
2133 INNER JOIN civicrm_activity activity ON (activity.source_record_id = membership.id AND activity.activity_type_id = %1)
2134 INNER JOIN  civicrm_membership_status status ON ( membership.status_id = status.id AND status.is_current_member = 1 )
2135 INNER JOIN  civicrm_contact contact ON ( contact.id = membership.contact_id AND contact.is_deleted = 0 )
2136      WHERE  membership.membership_type_id = %2
2137        AND  activity.activity_date_time >= '$startDate' AND activity.activity_date_time <= '$endDate 23:59:59'
2138        AND  {$testClause}";
2139
2140     $params = array(
2141       1 => array(self::$_signupActType, 'Integer'),
2142       2 => array($membershipTypeId, 'Integer'),
2143     );
2144
2145     $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
2146
2147     return (int) $memberCount;
2148   }
2149
2150   /**
2151    * Get membership renewals for a specified membership
2152    * type.  Specifically, retrieves a count of still current memberships
2153    * whose join_date is before and start_date is within a specified date
2154    * range.  Dates match the pattern "yyyy-mm-dd".
2155    *
2156    * @param int $membershipTypeId
2157    *   Membership type id.
2158    * @param int $startDate
2159    *   Date on which to start counting.
2160    * @param int $endDate
2161    *   Date on which to end counting.
2162    * @param bool|int $isTest if true, membership is for a test site
2163    *
2164    * @return int
2165    *   returns the number of members of type $membershipTypeId
2166    *   whose join_date is before $startDate and
2167    *   whose start_date is between $startDate and $endDate
2168    */
2169   public static function getMembershipRenewals($membershipTypeId, $startDate, $endDate, $isTest = 0) {
2170     $testClause = 'membership.is_test = 1';
2171     if (!$isTest) {
2172       $testClause = '( membership.is_test IS NULL OR membership.is_test = 0 )';
2173     }
2174     if (!self::$_renewalActType) {
2175       self::_getActTypes();
2176     }
2177
2178     if (!self::$_renewalActType) {
2179       return 0;
2180     }
2181
2182     $query = "
2183     SELECT  COUNT(DISTINCT membership.id) as member_count
2184       FROM  civicrm_membership membership
2185 INNER JOIN civicrm_activity activity ON (activity.source_record_id = membership.id AND activity.activity_type_id = %1)
2186 INNER JOIN  civicrm_membership_status status ON ( membership.status_id = status.id AND status.is_current_member = 1 )
2187 INNER JOIN  civicrm_contact contact ON ( contact.id = membership.contact_id AND contact.is_deleted = 0 )
2188      WHERE  membership.membership_type_id = %2
2189        AND  activity.activity_date_time >= '$startDate' AND activity.activity_date_time <= '$endDate 23:59:59'
2190        AND  {$testClause}";
2191
2192     $params = array(
2193       1 => array(self::$_renewalActType, 'Integer'),
2194       2 => array($membershipTypeId, 'Integer'),
2195     );
2196     $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
2197
2198     return (int) $memberCount;
2199   }
2200
2201   /**
2202    * Where a second separate financial transaction is supported we will process it here.
2203    *
2204    * @param int $contactID
2205    * @param CRM_Contribute_Form_Contribution_Confirm $form
2206    * @param array $tempParams
2207    * @param $isTest
2208    * @param array $lineItems
2209    * @param $minimumFee
2210    * @param int $financialTypeID
2211    *
2212    * @throws CRM_Core_Exception
2213    * @throws Exception
2214    * @return CRM_Contribute_BAO_Contribution
2215    */
2216   public static function processSecondaryFinancialTransaction($contactID, &$form, $tempParams, $isTest, $lineItems, $minimumFee, $financialTypeID) {
2217     $financialType = new CRM_Financial_DAO_FinancialType();
2218     $financialType->id = $financialTypeID;
2219     if (!$financialType->find(TRUE)) {
2220       CRM_Core_Error::fatal(ts("Could not find a system table"));
2221     }
2222     $tempParams['amount'] = $minimumFee;
2223     $tempParams['invoiceID'] = md5(uniqid(rand(), TRUE));
2224
2225     $result = NULL;
2226     if ($form->_values['is_monetary'] && !$form->_params['is_pay_later'] && $minimumFee > 0.0) {
2227       $payment = CRM_Core_Payment::singleton($form->_mode, $form->_paymentProcessor, $form);
2228
2229       if ($form->_contributeMode == 'express') {
2230         $result = $payment->doExpressCheckout($tempParams);
2231         if (is_a($result, 'CRM_Core_Error')) {
2232           throw new CRM_Core_Exception(CRM_Core_Error::getMessages($result));
2233         }
2234       }
2235       else {
2236         $result = $payment->doPayment($tempParams, 'contribute');
2237       }
2238     }
2239
2240     //assign receive date when separate membership payment
2241     //and contribution amount not selected.
2242     if ($form->_amount == 0) {
2243       $now = date('YmdHis');
2244       $form->_params['receive_date'] = $now;
2245       $receiveDate = CRM_Utils_Date::mysqlToIso($now);
2246       $form->set('params', $form->_params);
2247       $form->assign('receive_date', $receiveDate);
2248     }
2249
2250     $form->set('membership_trx_id', $result['trxn_id']);
2251     $form->set('membership_amount', $minimumFee);
2252
2253     $form->assign('membership_trx_id', $result['trxn_id']);
2254     $form->assign('membership_amount', $minimumFee);
2255
2256     // we don't need to create the user twice, so lets disable cms_create_account
2257     // irrespective of the value, CRM-2888
2258     $tempParams['cms_create_account'] = 0;
2259
2260     //CRM-16165, scenarios are
2261     // 1) If contribution is_pay_later and if contribution amount is > 0.0 we set pending = TRUE, vice-versa FALSE
2262     // 2) If not pay later but auto-renewal membership is chosen then pending = TRUE as it later triggers
2263     //   pending recurring contribution, vice-versa FALSE
2264     $pending = $form->_params['is_pay_later'] ? (($minimumFee > 0.0) ? TRUE : FALSE) : (!empty($form->_params['auto_renew']) ? TRUE : FALSE);
2265
2266     //set this variable as we are not creating pledge for
2267     //separate membership payment contribution.
2268     //so for differentiating membership contribution from
2269     //main contribution.
2270     $form->_params['separate_membership_payment'] = 1;
2271     $membershipContribution = CRM_Contribute_Form_Contribution_Confirm::processContribution($form,
2272       $tempParams,
2273       $result,
2274       $contactID,
2275       $financialType,
2276       $pending,
2277       TRUE,
2278       $isTest,
2279       $lineItems
2280     );
2281     return $membershipContribution;
2282   }
2283
2284   /**
2285    * Create linkages between membership & contribution - note this is the wrong place for this code but this is a
2286    * refactoring step. This should be BAO functionality
2287    * @param $membership
2288    * @param $membershipContribution
2289    */
2290   public static function linkMembershipPayment($membership, $membershipContribution) {
2291     CRM_Member_BAO_MembershipPayment::create(array(
2292       'membership_id' => $membership->id,
2293       'contribution_id' => $membershipContribution->id,
2294     ));
2295   }
2296
2297   /**
2298    * @param array $membershipParams
2299    * @param int $contactID
2300    * @param $customFieldsFormatted
2301    * @param int $membershipID
2302    * @param $memType
2303    * @param $isTest
2304    * @param $numTerms
2305    * @param $membershipContribution
2306    * @param CRM_Core_Form $form
2307    *
2308    * @return array
2309    */
2310   public static function createOrRenewMembership($membershipParams, $contactID, $customFieldsFormatted, $membershipID, $memType, $isTest, $numTerms, $membershipContribution, &$form) {
2311     if (!empty($membershipContribution)) {
2312       $pending = ($membershipContribution->contribution_status_id == 2) ? TRUE : FALSE;
2313     }
2314     $membership = self::renewMembershipFormWrapper($contactID, $memType,
2315       $isTest, $form, NULL,
2316       CRM_Utils_Array::value('cms_contactID', $membershipParams),
2317       $customFieldsFormatted, $numTerms,
2318       $membershipID, $pending
2319     );
2320
2321     if (!empty($membershipContribution)) {
2322       // update recurring id for membership record
2323       self::updateRecurMembership($membership, $membershipContribution);
2324
2325       self::linkMembershipPayment($membership, $membershipContribution);
2326     }
2327     return $membership;
2328   }
2329
2330   /**
2331    * Turn array of errors into message string.
2332    *
2333    * @param array $errors
2334    *
2335    * @return string
2336    */
2337   public static function compileErrorMessage($errors) {
2338     foreach ($errors as $error) {
2339       if (is_string($error)) {
2340         $message[] = $error;
2341       }
2342     }
2343     return ts('Payment Processor Error message') . ': ' . implode('<br/>', $message);
2344   }
2345
2346   /**
2347    * Extract relevant values from the form so we can separate form logic from BAO logcis.
2348    *
2349    * @param CRM_Core_Form $form
2350    * @param $changeToday
2351    * @param $membershipTypeDetails
2352    *
2353    * @return array
2354    */
2355   public static function extractFormValues($form, $changeToday, $membershipTypeDetails, $pending = FALSE) {
2356     //@todo this is a BAO function & should not inspect the form - the form should do this
2357     // & pass required params to the BAO
2358     if (CRM_Utils_Array::value('minimum_fee', $membershipTypeDetails) > 0.0) {
2359       if (((isset($form->_contributeMode) && $form->_contributeMode == 'notify') || !empty($form->_params['is_pay_later'])
2360         ) &&
2361         (($form->_values['is_monetary'] && $form->_amount > 0.0) ||
2362           CRM_Utils_Array::value('record_contribution', $form->_params)
2363         )
2364       ) {
2365         $pending = TRUE;
2366       }
2367     }
2368     $contributionRecurID = isset($form->_params['contributionRecurID']) ? $form->_params['contributionRecurID'] : NULL;
2369
2370     //we renew expired membership, CRM-6277
2371     if (!$changeToday) {
2372       if ($form->get('renewalDate')) {
2373         $changeToday = $form->get('renewalDate');
2374       }
2375       elseif (get_class($form) == 'CRM_Contribute_Form_Contribution_Confirm') {
2376         $changeToday = date('YmdHis');
2377       }
2378     }
2379
2380     $membershipSource = NULL;
2381     if (!empty($form->_params['membership_source'])) {
2382       $membershipSource = $form->_params['membership_source'];
2383     }
2384     elseif (isset($form->_values['title']) && !empty($form->_values['title'])) {
2385       $membershipSource = ts('Online Contribution:') . ' ' . $form->_values['title'];
2386     }
2387     $isPayLater = NULL;
2388     if (isset($form->_params)) {
2389       $isPayLater = CRM_Utils_Array::value('is_pay_later', $form->_params);
2390     }
2391     $campaignId = NULL;
2392     if (isset($form->_values) && is_array($form->_values) && !empty($form->_values)) {
2393       $campaignId = CRM_Utils_Array::value('campaign_id', $form->_params);
2394       if (!array_key_exists('campaign_id', $form->_params)) {
2395         $campaignId = CRM_Utils_Array::value('campaign_id', $form->_values);
2396       }
2397     }
2398     return array($pending, $contributionRecurID, $changeToday, $membershipSource, $isPayLater, $campaignId);
2399   }
2400
2401   /**
2402    * @param int $contactID
2403    * @param int $membershipTypeID
2404    * @param bool $is_test
2405    * @param $changeToday
2406    * @param int $modifiedID
2407    * @param $customFieldsFormatted
2408    * @param $numRenewTerms
2409    * @param int $membershipID
2410    * @param $pending
2411    * @param $allStatus
2412    * @param array $membershipTypeDetails
2413    * @param int $contributionRecurID
2414    * @param $format
2415    * @param $membershipSource
2416    * @param $ids
2417    * @param $statusFormat
2418    * @param $isPayLater
2419    * @param int $campaignId
2420    *
2421    * @throws CRM_Core_Exception
2422    * @return array
2423    */
2424   public static function renewMembership($contactID, $membershipTypeID, $is_test, $changeToday, $modifiedID, $customFieldsFormatted, $numRenewTerms, $membershipID, $pending, $allStatus, $membershipTypeDetails, $contributionRecurID, $format, $membershipSource, $ids, $statusFormat, $isPayLater, $campaignId) {
2425     $renewalMode = $updateStatusId = FALSE;
2426     $dates = array();
2427     // CRM-7297 - allow membership type to be be changed during renewal so long as the parent org of new membershipType
2428     // is the same as the parent org of an existing membership of the contact
2429     $currentMembership = CRM_Member_BAO_Membership::getContactMembership($contactID, $membershipTypeID,
2430       $is_test, $membershipID, TRUE
2431     );
2432     if ($currentMembership) {
2433       $activityType = 'Membership Renewal';
2434       $renewalMode = TRUE;
2435
2436       // Do NOT do anything.
2437       //1. membership with status : PENDING/CANCELLED (CRM-2395)
2438       //2. Paylater/IPN renew. CRM-4556.
2439       if ($pending || in_array($currentMembership['status_id'], array(
2440           array_search('Pending', $allStatus),
2441           // CRM-15475
2442           array_search('Cancelled', CRM_Member_PseudoConstant::membershipStatus(NULL, " name = 'Cancelled' ", 'name', FALSE, TRUE)),
2443         ))
2444       ) {
2445         $membership = new CRM_Member_DAO_Membership();
2446         $membership->id = $currentMembership['id'];
2447         $membership->find(TRUE);
2448
2449         // CRM-8141 create a membership_log entry so that we will know the membership_type_id to change to when payment completed
2450         $format = '%Y%m%d';
2451         // note that we are logging the requested new membership_type_id that may be different than current membership_type_id
2452         // it will be used when payment is received to update the membership_type_id to what was paid for
2453         $logParams = array(
2454           'membership_id' => $membership->id,
2455           'status_id' => $membership->status_id,
2456           'start_date' => CRM_Utils_Date::customFormat(
2457             $membership->start_date,
2458             $format
2459           ),
2460           'end_date' => CRM_Utils_Date::customFormat(
2461             $membership->end_date,
2462             $format
2463           ),
2464           'modified_date' => CRM_Utils_Date::customFormat(
2465             date('Ymd'),
2466             $format
2467           ),
2468           'membership_type_id' => $membershipTypeID,
2469           'max_related' => !empty($membershipTypeDetails['max_related']) ? $membershipTypeDetails['max_related'] : NULL,
2470         );
2471         $session = CRM_Core_Session::singleton();
2472         // If we have an authenticated session, set modified_id to that user's contact_id, else set to membership.contact_id
2473         if ($session->get('userID')) {
2474           $logParams['modified_id'] = $session->get('userID');
2475         }
2476         else {
2477           $logParams['modified_id'] = $membership->contact_id;
2478         }
2479         CRM_Member_BAO_MembershipLog::add($logParams, CRM_Core_DAO::$_nullArray);
2480
2481         if (!empty($contributionRecurID)) {
2482           CRM_Core_DAO::setFieldValue('CRM_Member_DAO_Membership', $membership->id,
2483             'contribution_recur_id', $contributionRecurID
2484           );
2485         }
2486
2487         return array($membership, $renewalMode, $dates);
2488       }
2489
2490       // Check and fix the membership if it is STALE
2491       self::fixMembershipStatusBeforeRenew($currentMembership, $changeToday);
2492
2493       // Now Renew the membership
2494       if (!$currentMembership['is_current_member']) {
2495         // membership is not CURRENT
2496
2497         // CRM-7297 Membership Upsell - calculate dates based on new membership type
2498         $dates = CRM_Member_BAO_MembershipType::getRenewalDatesForMembershipType($currentMembership['id'],
2499           $changeToday,
2500           $membershipTypeID,
2501           $numRenewTerms
2502         );
2503
2504         $currentMembership['join_date'] = CRM_Utils_Date::customFormat($currentMembership['join_date'], $format);
2505         $currentMembership['start_date'] = CRM_Utils_Array::value('start_date', $dates);
2506         $currentMembership['end_date'] = CRM_Utils_Array::value('end_date', $dates);
2507         $currentMembership['is_test'] = $is_test;
2508
2509         if (!empty($membershipSource)) {
2510           $currentMembership['source'] = $membershipSource;
2511         }
2512         else {
2513           $currentMembership['source'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
2514             $currentMembership['id'],
2515             'source'
2516           );
2517         }
2518
2519         if (!empty($currentMembership['id'])) {
2520           $ids['membership'] = $currentMembership['id'];
2521         }
2522         $memParams = $currentMembership;
2523         $memParams['membership_type_id'] = $membershipTypeID;
2524
2525         //set the log start date.
2526         $memParams['log_start_date'] = CRM_Utils_Date::customFormat($dates['log_start_date'], $format);
2527       }
2528       else {
2529
2530         // CURRENT Membership
2531         $membership = new CRM_Member_DAO_Membership();
2532         $membership->id = $currentMembership['id'];
2533         $membership->find(TRUE);
2534         // CRM-7297 Membership Upsell - calculate dates based on new membership type
2535         $dates = CRM_Member_BAO_MembershipType::getRenewalDatesForMembershipType($membership->id,
2536           $changeToday,
2537           $membershipTypeID,
2538           $numRenewTerms
2539         );
2540
2541         // Insert renewed dates for CURRENT membership
2542         $memParams = array();
2543         $memParams['join_date'] = CRM_Utils_Date::isoToMysql($membership->join_date);
2544         $memParams['start_date'] = CRM_Utils_Date::isoToMysql($membership->start_date);
2545         $memParams['end_date'] = CRM_Utils_Array::value('end_date', $dates);
2546         $memParams['membership_type_id'] = $membershipTypeID;
2547
2548         //set the log start date.
2549         $memParams['log_start_date'] = CRM_Utils_Date::customFormat($dates['log_start_date'], $format);
2550         if (empty($membership->source)) {
2551           if (!empty($membershipSource)) {
2552             $memParams['source'] = $membershipSource;
2553           }
2554           else {
2555             $memParams['source'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
2556               $currentMembership['id'],
2557               'source'
2558             );
2559           }
2560         }
2561
2562         if (!empty($currentMembership['id'])) {
2563           $ids['membership'] = $currentMembership['id'];
2564         }
2565       }
2566       //CRM-4555
2567       if ($pending) {
2568         $updateStatusId = array_search('Pending', $allStatus);
2569       }
2570     }
2571     else {
2572       // NEW Membership
2573
2574       $activityType = 'Membership Signup';
2575       $memParams = array(
2576         'contact_id' => $contactID,
2577         'membership_type_id' => $membershipTypeID,
2578       );
2579
2580       if (!$pending) {
2581         $dates = CRM_Member_BAO_MembershipType::getDatesForMembershipType($membershipTypeID, NULL, NULL, NULL, $numRenewTerms);
2582
2583         $memParams['join_date'] = CRM_Utils_Array::value('join_date', $dates);
2584         $memParams['start_date'] = CRM_Utils_Array::value('start_date', $dates);
2585         $memParams['end_date'] = CRM_Utils_Array::value('end_date', $dates);
2586
2587         $status = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate(CRM_Utils_Date::customFormat($dates['start_date'],
2588             $statusFormat
2589           ),
2590           CRM_Utils_Date::customFormat($dates['end_date'],
2591             $statusFormat
2592           ),
2593           CRM_Utils_Date::customFormat($dates['join_date'],
2594             $statusFormat
2595           ),
2596           'today',
2597           TRUE,
2598           $membershipTypeID,
2599           $memParams
2600         );
2601         $updateStatusId = CRM_Utils_Array::value('id', $status);
2602       }
2603       else {
2604         // if IPN/Pay-Later set status to: PENDING
2605         $updateStatusId = array_search('Pending', $allStatus);
2606       }
2607
2608       if (!empty($membershipSource)) {
2609         $memParams['source'] = $membershipSource;
2610       }
2611       $memParams['contribution_recur_id'] = $contributionRecurID;
2612
2613       $memParams['is_test'] = $is_test;
2614       $memParams['is_pay_later'] = $isPayLater;
2615     }
2616
2617     //CRM-4555
2618     //if we decided status here and want to skip status
2619     //calculation in create( ); then need to pass 'skipStatusCal'.
2620     if ($updateStatusId) {
2621       $memParams['status_id'] = $updateStatusId;
2622       $memParams['skipStatusCal'] = TRUE;
2623     }
2624
2625     //since we are renewing,
2626     //make status override false.
2627     $memParams['is_override'] = FALSE;
2628
2629     //CRM-4027, create log w/ individual contact.
2630     if ($modifiedID) {
2631       $ids['userId'] = $modifiedID;
2632       $memParams['is_for_organization'] = TRUE;
2633     }
2634     else {
2635       $ids['userId'] = $contactID;
2636     }
2637
2638     //inherit campaign from contrib page.
2639     if (isset($campaignId)) {
2640       $memParams['campaign_id'] = $campaignId;
2641     }
2642
2643     $memParams['custom'] = $customFieldsFormatted;
2644     $membership = self::create($memParams, $ids, FALSE, $activityType);
2645
2646     // not sure why this statement is here, seems quite odd :( - Lobo: 12/26/2010
2647     // related to: http://forum.civicrm.org/index.php/topic,11416.msg49072.html#msg49072
2648     $membership->find(TRUE);
2649
2650     return array($membership, $renewalMode, $dates);
2651   }
2652
2653   /**
2654    * Process price set and line items.
2655    *
2656    * @param int $membershipId
2657    * @param $lineItem
2658    *
2659    * @return void
2660    */
2661   public function processPriceSet($membershipId, $lineItem) {
2662     //FIXME : need to move this too
2663     if (!$membershipId || !is_array($lineItem)
2664       || CRM_Utils_System::isNull($lineItem)
2665     ) {
2666       return;
2667     }
2668
2669     foreach ($lineItem as $priceSetId => $values) {
2670       if (!$priceSetId) {
2671         continue;
2672       }
2673       foreach ($values as $line) {
2674         $line['entity_table'] = 'civicrm_membership';
2675         $line['entity_id'] = $membershipId;
2676         CRM_Price_BAO_LineItem::create($line);
2677       }
2678     }
2679   }
2680
2681   /**
2682    * Retrieve the contribution id for the associated Membership id.
2683    * @todo we should get this off the line item
2684    *
2685    * @param int $membershipId
2686    *   Membership id.
2687    *
2688    * @return int
2689    *   contribution id
2690    */
2691   public static function getMembershipContributionId($membershipId) {
2692
2693     $membershipPayment = new CRM_Member_DAO_MembershipPayment();
2694     $membershipPayment->membership_id = $membershipId;
2695     if ($membershipPayment->find(TRUE)) {
2696       return $membershipPayment->contribution_id;
2697     }
2698     return NULL;
2699   }
2700
2701   /**
2702    * The function checks and updates the status of all membership records for a given domain using the
2703    * calc_membership_status and update_contact_membership APIs.
2704    *
2705    * IMPORTANT:
2706    * Sending renewal reminders has been migrated from this job to the Scheduled Reminders function as of 4.3.
2707    *
2708    * @return array
2709    */
2710   public static function updateAllMembershipStatus() {
2711
2712     //get all active statuses of membership, CRM-3984
2713     $allStatus = CRM_Member_PseudoConstant::membershipStatus();
2714     $statusLabels = CRM_Member_PseudoConstant::membershipStatus(NULL, NULL, 'label');
2715     $allTypes = CRM_Member_PseudoConstant::membershipType();
2716
2717     // get only memberships with active membership types
2718     $query = "
2719 SELECT     civicrm_membership.id                    as membership_id,
2720            civicrm_membership.is_override           as is_override,
2721            civicrm_membership.membership_type_id    as membership_type_id,
2722            civicrm_membership.status_id             as status_id,
2723            civicrm_membership.join_date             as join_date,
2724            civicrm_membership.start_date            as start_date,
2725            civicrm_membership.end_date              as end_date,
2726            civicrm_membership.source                as source,
2727            civicrm_contact.id                       as contact_id,
2728            civicrm_contact.is_deceased              as is_deceased,
2729            civicrm_membership.owner_membership_id   as owner_membership_id,
2730            civicrm_membership.contribution_recur_id as recur_id
2731 FROM       civicrm_membership
2732 INNER JOIN civicrm_contact ON ( civicrm_membership.contact_id = civicrm_contact.id )
2733 INNER JOIN civicrm_membership_type ON
2734   (civicrm_membership.membership_type_id = civicrm_membership_type.id AND civicrm_membership_type.is_active = 1)
2735 WHERE      civicrm_membership.is_test = 0";
2736
2737     $params = array();
2738     $dao = CRM_Core_DAO::executeQuery($query, $params);
2739
2740     $processCount = 0;
2741     $updateCount = 0;
2742
2743     $smarty = CRM_Core_Smarty::singleton();
2744
2745     while ($dao->fetch()) {
2746       // echo ".";
2747       $processCount++;
2748
2749       // Put common parameters into array for easy access
2750       $memberParams = array(
2751         'id' => $dao->membership_id,
2752         'status_id' => $dao->status_id,
2753         'contact_id' => $dao->contact_id,
2754         'membership_type_id' => $dao->membership_type_id,
2755         'membership_type' => $allTypes[$dao->membership_type_id],
2756         'join_date' => $dao->join_date,
2757         'start_date' => $dao->start_date,
2758         'end_date' => $dao->end_date,
2759         'source' => $dao->source,
2760         'skipStatusCal' => TRUE,
2761         'skipRecentView' => TRUE,
2762       );
2763
2764       $smarty->assign_by_ref('memberParams', $memberParams);
2765
2766       //update membership record to Deceased if contact is deceased
2767       if ($dao->is_deceased) {
2768         // check for 'Deceased' membership status, CRM-5636
2769         $deceaseStatusId = array_search('Deceased', $allStatus);
2770         if (!$deceaseStatusId) {
2771           CRM_Core_Error::fatal(ts("Deceased Membership status is missing or not active. <a href='%1'>Click here to check</a>.", array(1 => CRM_Utils_System::url('civicrm/admin/member/membershipStatus', 'reset=1'))));
2772         }
2773
2774         //process only when status change.
2775         if ($dao->status_id != $deceaseStatusId) {
2776           //take all params that need to save.
2777           $deceasedMembership = $memberParams;
2778           $deceasedMembership['status_id'] = $deceaseStatusId;
2779           $deceasedMembership['createActivity'] = TRUE;
2780           $deceasedMembership['version'] = 3;
2781
2782           //since there is change in status.
2783           $statusChange = array('status_id' => $deceaseStatusId);
2784           $smarty->append_by_ref('memberParams', $statusChange, TRUE);
2785           unset(
2786             $deceasedMembership['contact_id'],
2787             $deceasedMembership['membership_type_id'],
2788             $deceasedMembership['membership_type'],
2789             $deceasedMembership['join_date'],
2790             $deceasedMembership['start_date'],
2791             $deceasedMembership['end_date'],
2792             $deceasedMembership['source']
2793           );
2794
2795           //process membership record.
2796           civicrm_api('membership', 'create', $deceasedMembership);
2797         }
2798         continue;
2799       }
2800
2801       //we fetch related, since we need to check for deceased
2802       //now further processing is handle w/ main membership record.
2803       if ($dao->owner_membership_id) {
2804         continue;
2805       }
2806
2807       //update membership records where status is NOT - Pending OR Cancelled.
2808       //as well as membership is not override.
2809       //skipping Expired membership records -> reduced extra processing( kiran )
2810       if (!$dao->is_override &&
2811         !in_array($dao->status_id, array(
2812           array_search('Pending', $allStatus),
2813           // CRM-15475
2814           array_search(
2815             'Cancelled',
2816             CRM_Member_PseudoConstant::membershipStatus(NULL, " name = 'Cancelled' ", 'name', FALSE, TRUE)
2817           ),
2818           array_search('Expired', $allStatus),
2819         ))
2820       ) {
2821
2822         // CRM-7248: added excludeIsAdmin param to the following fn call to prevent moving to admin statuses
2823         //get the membership status as per id.
2824         $newStatus = civicrm_api('membership_status', 'calc',
2825           array(
2826             'membership_id' => $dao->membership_id,
2827             'version' => 3,
2828             'ignore_admin_only' => FALSE,
2829           ), TRUE
2830         );
2831         $statusId = CRM_Utils_Array::value('id', $newStatus);
2832
2833         //process only when status change.
2834         if ($statusId &&
2835           $statusId != $dao->status_id
2836         ) {
2837           //take all params that need to save.
2838           $memParams = $memberParams;
2839           $memParams['status_id'] = $statusId;
2840           $memParams['createActivity'] = TRUE;
2841           $memParams['version'] = 3;
2842
2843           // Unset columns which should remain unchanged from their current saved
2844           // values. This avoids race condition in which these values may have
2845           // been changed by other processes.
2846           unset(
2847             $memParams['contact_id'],
2848             $memParams['membership_type_id'],
2849             $memParams['membership_type'],
2850             $memParams['join_date'],
2851             $memParams['start_date'],
2852             $memParams['end_date'],
2853             $memParams['source']
2854           );
2855           //since there is change in status.
2856           $statusChange = array('status_id' => $statusId);
2857           $smarty->append_by_ref('memberParams', $statusChange, TRUE);
2858
2859           //process member record.
2860           civicrm_api('membership', 'create', $memParams);
2861           $updateCount++;
2862         }
2863       }
2864     }
2865     $result['is_error'] = 0;
2866     $result['messages'] = ts('Processed %1 membership records. Updated %2 records.', array(
2867       1 => $processCount,
2868       2 => $updateCount,
2869     ));
2870     return $result;
2871   }
2872
2873   /**
2874    * Returns the membership types for a particular contact
2875    * who has lifetime membership without end date.
2876    *
2877    * @param int $contactID
2878    * @param bool $isTest
2879    * @param bool $onlyLifeTime
2880    *
2881    * @return array
2882    */
2883   public static function getAllContactMembership($contactID, $isTest = FALSE, $onlyLifeTime = FALSE) {
2884     $contactMembershipType = array();
2885     if (!$contactID) {
2886       return $contactMembershipType;
2887     }
2888
2889     $dao = new CRM_Member_DAO_Membership();
2890     $dao->contact_id = $contactID;
2891     $pendingStatusId = array_search('Pending', CRM_Member_PseudoConstant::membershipStatus());
2892     $dao->whereAdd("status_id != $pendingStatusId");
2893
2894     if ($isTest) {
2895       $dao->is_test = $isTest;
2896     }
2897     else {
2898       $dao->whereAdd('is_test IS NULL OR is_test = 0');
2899     }
2900
2901     if ($onlyLifeTime) {
2902       $dao->whereAdd('end_date IS NULL');
2903     }
2904
2905     $dao->find();
2906     while ($dao->fetch()) {
2907       $membership = array();
2908       CRM_Core_DAO::storeValues($dao, $membership);
2909       $contactMembershipType[$dao->membership_type_id] = $membership;
2910     }
2911     return $contactMembershipType;
2912   }
2913
2914   /**
2915    * Record contribution record associated with membership.
2916    *
2917    * @param array $params
2918    *   Array of submitted params.
2919    * @param array $ids
2920    *   (param in process of being removed - try to use params) array of ids.
2921    *
2922    * @return CRM_Contribute_BAO_Contribution
2923    */
2924   public static function recordMembershipContribution(&$params, $ids = array()) {
2925     $membershipId = $params['membership_id'];
2926     $contributionParams = array();
2927     $config = CRM_Core_Config::singleton();
2928     $contributionParams['currency'] = $config->defaultCurrency;
2929     $contributionParams['receipt_date'] = (CRM_Utils_Array::value('receipt_date', $params)) ? $params['receipt_date'] : 'null';
2930     $contributionParams['source'] = CRM_Utils_Array::value('contribution_source', $params);
2931     $contributionParams['non_deductible_amount'] = 'null';
2932     $contributionParams['payment_processor'] = CRM_Utils_Array::value('payment_processor_id', $params);
2933     $contributionSoftParams = CRM_Utils_Array::value('soft_credit', $params);
2934     $recordContribution = array(
2935       'contact_id',
2936       'total_amount',
2937       'receive_date',
2938       'financial_type_id',
2939       'payment_instrument_id',
2940       'trxn_id',
2941       'invoice_id',
2942       'is_test',
2943       'contribution_status_id',
2944       'check_number',
2945       'campaign_id',
2946       'is_pay_later',
2947       'membership_id',
2948       'tax_amount',
2949       'skipLineItem',
2950     );
2951     foreach ($recordContribution as $f) {
2952       $contributionParams[$f] = CRM_Utils_Array::value($f, $params);
2953     }
2954
2955     // make entry in batch entity batch table
2956     if (!empty($params['batch_id'])) {
2957       $contributionParams['batch_id'] = $params['batch_id'];
2958     }
2959
2960     if (!empty($params['contribution_contact_id'])) {
2961       // deal with possibility of a different person paying for contribution
2962       $contributionParams['contact_id'] = $params['contribution_contact_id'];
2963     }
2964
2965     if (!empty($params['processPriceSet']) &&
2966       !empty($params['lineItems'])
2967     ) {
2968       $contributionParams['line_item'] = CRM_Utils_Array::value('lineItems', $params, NULL);
2969     }
2970
2971     $contribution = CRM_Contribute_BAO_Contribution::create($contributionParams, $ids);
2972
2973     //CRM-13981, create new soft-credit record as to record payment from different person for this membership
2974     if (!empty($contributionSoftParams)) {
2975       if (!empty($params['batch_id'])) {
2976         foreach ($contributionSoftParams as $contributionSoft) {
2977           $contributionSoft['contribution_id'] = $contribution->id;
2978           $contributionSoft['currency'] = $contribution->currency;
2979           CRM_Contribute_BAO_ContributionSoft::add($contributionSoft);
2980         }
2981       }
2982       else {
2983         $contributionSoftParams['contribution_id'] = $contribution->id;
2984         $contributionSoftParams['currency'] = $contribution->currency;
2985         $contributionSoftParams['amount'] = $contribution->total_amount;
2986         CRM_Contribute_BAO_ContributionSoft::add($contributionSoftParams);
2987       }
2988     }
2989
2990     // store contribution id
2991     $params['contribution_id'] = $contribution->id;
2992
2993     //insert payment record for this membership
2994     if (empty($ids['contribution']) || !empty($params['is_recur'])) {
2995       CRM_Member_BAO_MembershipPayment::create(array(
2996         'membership_id' => $membershipId,
2997         'contribution_id' => $contribution->id,
2998       ));
2999     }
3000     return $contribution;
3001   }
3002
3003   /**
3004    * Record line items for default membership.
3005    *
3006    * @param CRM_Core_Form $qf
3007    * @param array $membershipType
3008    *   Array with membership type and organization.
3009    * @param int $priceSetId
3010    *
3011    */
3012   public static function createLineItems(&$qf, $membershipType, &$priceSetId) {
3013     $qf->_priceSetId = $priceSetId = CRM_Core_DAO::getFieldValue('CRM_Price_DAO_PriceSet', 'default_membership_type_amount', 'id', 'name');
3014     if ($priceSetId) {
3015       $qf->_priceSet = $priceSets = current(CRM_Price_BAO_PriceSet::getSetDetail($priceSetId));
3016     }
3017     $editedFieldParams = array(
3018       'price_set_id' => $priceSetId,
3019       'name' => $membershipType[0],
3020     );
3021     $editedResults = array();
3022     CRM_Price_BAO_PriceField::retrieve($editedFieldParams, $editedResults);
3023
3024     if (!empty($editedResults)) {
3025       unset($qf->_priceSet['fields']);
3026       $qf->_priceSet['fields'][$editedResults['id']] = $priceSets['fields'][$editedResults['id']];
3027       unset($qf->_priceSet['fields'][$editedResults['id']]['options']);
3028       $fid = $editedResults['id'];
3029       $editedFieldParams = array(
3030         'price_field_id' => $editedResults['id'],
3031         'membership_type_id' => $membershipType[1],
3032       );
3033       $editedResults = array();
3034       CRM_Price_BAO_PriceFieldValue::retrieve($editedFieldParams, $editedResults);
3035       $qf->_priceSet['fields'][$fid]['options'][$editedResults['id']] = $priceSets['fields'][$fid]['options'][$editedResults['id']];
3036       if (!empty($qf->_params['total_amount'])) {
3037         $qf->_priceSet['fields'][$fid]['options'][$editedResults['id']]['amount'] = $qf->_params['total_amount'];
3038       }
3039     }
3040
3041     $fieldID = key($qf->_priceSet['fields']);
3042     $qf->_params['price_' . $fieldID] = CRM_Utils_Array::value('id', $editedResults);
3043   }
3044
3045   /**
3046    * @todo document me - I seem a bit out of date....
3047    */
3048   public static function _getActTypes() {
3049     $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, FALSE, FALSE, 'name');
3050     self::$_renewalActType = CRM_Utils_Array::key('Membership Renewal', $activityTypes);
3051     self::$_signupActType = CRM_Utils_Array::key('Membership Signup', $activityTypes);
3052   }
3053
3054   /**
3055    * Get all Cancelled Membership(s) for a contact
3056    *
3057    * @param int $contactID
3058    *   Contact id.
3059    * @param bool $isTest
3060    *   Mode of payment.
3061    *
3062    * @return array
3063    *   Array of membership type
3064    */
3065   public static function getContactsCancelledMembership($contactID, $isTest = FALSE) {
3066     if (!$contactID) {
3067       return array();
3068     }
3069     $query = 'SELECT membership_type_id FROM civicrm_membership WHERE contact_id = %1 AND status_id = %2 AND is_test = %3';
3070     $queryParams = array(
3071       1 => array($contactID, 'Integer'),
3072       2 => array(
3073         // CRM-15475
3074         array_search(
3075           'Cancelled',
3076           CRM_Member_PseudoConstant::membershipStatus(
3077             NULL,
3078             " name = 'Cancelled' ",
3079             'name',
3080             FALSE,
3081             TRUE
3082           )
3083         ),
3084         'Integer',
3085       ),
3086       3 => array($isTest, 'Boolean'),
3087     );
3088
3089     $dao = CRM_Core_DAO::executeQuery($query, $queryParams);
3090     $cancelledMembershipIds = array();
3091     while ($dao->fetch()) {
3092       $cancelledMembershipIds[] = $dao->membership_type_id;
3093     }
3094     return $cancelledMembershipIds;
3095   }
3096
3097 }