projects / civicrm-core.git / blob
? search:


62d397c05d1cecaabe841ec6b4b179c608a6d33d
[civicrm-core.git] / CRM / Member / BAO / Membership.php
1 <?php
2 /*
3 +--------------------------------------------------------------------+
4 | CiviCRM version 4.7 |
5 +--------------------------------------------------------------------+
6 | Copyright CiviCRM LLC (c) 2004-2015 |
7 +--------------------------------------------------------------------+
8 | This file is a part of CiviCRM. |
9 | |
10 | CiviCRM is free software; you can copy, modify, and distribute it |
11 | under the terms of the GNU Affero General Public License |
12 | Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
13 | |
14 | CiviCRM is distributed in the hope that it will be useful, but |
15 | WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
17 | See the GNU Affero General Public License for more details. |
18 | |
19 | You should have received a copy of the GNU Affero General Public |
20 | License and the CiviCRM Licensing Exception along |
21 | with this program; if not, contact CiviCRM LLC |
22 | at info[AT]civicrm[DOT]org. If you have questions about the |
23 | GNU Affero General Public License or the licensing of CiviCRM, |
24 | see the CiviCRM license FAQ at http://civicrm.org/licensing |
25 +--------------------------------------------------------------------+
26 */
27
28 /**
29 *
30 * @package CRM
31 * @copyright CiviCRM LLC (c) 2004-2015
32 */
33 class CRM_Member_BAO_Membership extends CRM_Member_DAO_Membership {
34
35 /**
36 * Static field for all the membership information that we can potentially import.
37 *
38 * @var array
39 */
40 static $_importableFields = NULL;
41
42 static $_renewalActType = NULL;
43
44 static $_signupActType = NULL;
45
46 /**
47 * Class constructor.
48 */
49 public function __construct() {
50 parent::__construct();
51 }
52
53 /**
54 * Takes an associative array and creates a membership object.
55 *
56 * the function extracts all the params it needs to initialize the created
57 * membership object. The params array could contain additional unused name/value
58 * pairs
59 *
60 * @param array $params
61 * (reference ) an assoc array of name/value pairs.
62 * @param array $ids
63 * The array that holds all the db ids.
64 *
65 * @return CRM_Member_BAO_Membership
66 */
67 public static function add(&$params, $ids = array()) {
68 $oldStatus = $oldType = NULL;
69 $params['id'] = CRM_Utils_Array::value('id', $params, CRM_Utils_Array::value('membership', $ids));
70 if ($params['id']) {
71 CRM_Utils_Hook::pre('edit', 'Membership', $params['id'], $params);
72 }
73 else {
74 CRM_Utils_Hook::pre('create', 'Membership', NULL, $params);
75 }
76 $id = $params['id'];
77 // we do this after the hooks are called in case it has been altered
78 if ($id) {
79 $membershipObj = new CRM_Member_DAO_Membership();
80 $membershipObj->id = $id;
81 $membershipObj->find();
82 while ($membershipObj->fetch()) {
83 $oldStatus = $membershipObj->status_id;
84 $oldType = $membershipObj->membership_type_id;
85 }
86 }
87
88 if (array_key_exists('is_override', $params) && !$params['is_override']) {
89 $params['is_override'] = 'null';
90 }
91
92 $membership = new CRM_Member_BAO_Membership();
93 $membership->copyValues($params);
94 $membership->id = $id;
95
96 $membership->save();
97 $membership->free();
98
99 if (empty($membership->contact_id) || empty($membership->status_id)) {
100 // this means we are in renewal mode and are just updating the membership
101 // record or this is an API update call and all fields are not present in the update record
102 // however the hooks don't care and want all data CRM-7784
103 $tempMembership = new CRM_Member_DAO_Membership();
104 $tempMembership->id = $membership->id;
105 $tempMembership->find(TRUE);
106 $membership = $tempMembership;
107 }
108
109 //get the log start date.
110 //it is set during renewal of membership.
111 $logStartDate = CRM_Utils_Array::value('log_start_date', $params);
112 $logStartDate = ($logStartDate) ? CRM_Utils_Date::isoToMysql($logStartDate) : CRM_Utils_Date::isoToMysql($membership->start_date);
113 $values = self::getStatusANDTypeValues($membership->id);
114
115 $membershipLog = array(
116 'membership_id' => $membership->id,
117 'status_id' => $membership->status_id,
118 'start_date' => $logStartDate,
119 'end_date' => CRM_Utils_Date::isoToMysql($membership->end_date),
120 'modified_date' => date('Ymd'),
121 'membership_type_id' => $values[$membership->id]['membership_type_id'],
122 'max_related' => $membership->max_related,
123 );
124
125 $session = CRM_Core_Session::singleton();
126 // If we have an authenticated session, set modified_id to that user's contact_id, else set to membership.contact_id
127 if ($session->get('userID')) {
128 $membershipLog['modified_id'] = $session->get('userID');
129 }
130 elseif (!empty($ids['userId'])) {
131 $membershipLog['modified_id'] = $ids['userId'];
132 }
133 else {
134 $membershipLog['modified_id'] = $membership->contact_id;
135 }
136
137 CRM_Member_BAO_MembershipLog::add($membershipLog, CRM_Core_DAO::$_nullArray);
138
139 // reset the group contact cache since smart groups might be affected due to this
140 CRM_Contact_BAO_GroupContactCache::remove();
141
142 if ($id) {
143 if ($membership->status_id != $oldStatus) {
144 $allStatus = CRM_Member_BAO_Membership::buildOptions('status_id', 'get');
145 $activityParam = array(
146 'subject' => "Status changed from {$allStatus[$oldStatus]} to {$allStatus[$membership->status_id]}",
147 'source_contact_id' => $membershipLog['modified_id'],
148 'target_contact_id' => $membership->contact_id,
149 'source_record_id' => $membership->id,
150 'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Change Membership Status'),
151 'status_id' => 2,
152 'priority_id' => 2,
153 'activity_date_time' => date('Y-m-d H:i:s'),
154 );
155 civicrm_api3('activity', 'create', $activityParam);
156 }
157 if (isset($membership->membership_type_id) && $membership->membership_type_id != $oldType) {
158 $membershipTypes = CRM_Member_BAO_Membership::buildOptions('membership_type_id', 'get');
159 $activityParam = array(
160 'subject' => "Type changed from {$membershipTypes[$oldType]} to {$membershipTypes[$membership->membership_type_id]}",
161 'source_contact_id' => $membershipLog['modified_id'],
162 'target_contact_id' => $membership->contact_id,
163 'source_record_id' => $membership->id,
164 'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Change Membership Type'),
165 'status_id' => 2,
166 'priority_id' => 2,
167 'activity_date_time' => date('Y-m-d H:i:s'),
168 );
169 civicrm_api3('activity', 'create', $activityParam);
170 }
171 CRM_Utils_Hook::post('edit', 'Membership', $membership->id, $membership);
172 }
173 else {
174 CRM_Utils_Hook::post('create', 'Membership', $membership->id, $membership);
175 }
176
177 return $membership;
178 }
179
180 /**
181 * Fetch the object and store the values in the values array.
182 *
183 * @param array $params
184 * Input parameters to find object.
185 * @param array $values
186 * Output values of the object.
187 * @param bool $active
188 * Do you want only active memberships to.
189 * be returned
190 * @param bool $relatedMemberships
191 *
192 * @return CRM_Member_BAO_Membership|null
193 * The found object or null
194 */
195 public static function &getValues(&$params, &$values, $active = FALSE, $relatedMemberships = FALSE) {
196 if (empty($params)) {
197 return NULL;
198 }
199 $membership = new CRM_Member_BAO_Membership();
200
201 $membership->copyValues($params);
202 $membership->find();
203 $memberships = array();
204 while ($membership->fetch()) {
205 if ($active &&
206 (!CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipStatus',
207 $membership->status_id,
208 'is_current_member'
209 ))
210 ) {
211 continue;
212 }
213
214 CRM_Core_DAO::storeValues($membership, $values[$membership->id]);
215 $memberships[$membership->id] = $membership;
216 if ($relatedMemberships && !empty($membership->owner_membership_id)) {
217 $values['owner_membership_ids'][] = $membership->owner_membership_id;
218 }
219 }
220
221 return $memberships;
222 }
223
224 /**
225 * Takes an associative array and creates a membership object.
226 *
227 * @param array $params
228 * (reference ) an assoc array of name/value pairs.
229 * @param array $ids
230 * The array that holds all the db ids.
231 * @param bool $skipRedirect
232 * @param string $activityType
233 *
234 * @throws CRM_Core_Exception
235 *
236 * @return CRM_Member_BAO_Membership|CRM_Core_Error
237 */
238 public static function create(&$params, &$ids, $skipRedirect = FALSE, $activityType = 'Membership Signup') {
239 // always calculate status if is_override/skipStatusCal is not true.
240 // giving respect to is_override during import. CRM-4012
241
242 // To skip status calculation we should use 'skipStatusCal'.
243 // eg pay later membership, membership update cron CRM-3984
244
245 if (empty($params['is_override']) && empty($params['skipStatusCal'])) {
246 $dates = array('start_date', 'end_date', 'join_date');
247 // Declare these out of courtesy as IDEs don't pick up the setting of them below.
248 $start_date = $end_date = $join_date = NULL;
249 foreach ($dates as $date) {
250 $$date = $params[$date] = CRM_Utils_Date::processDate(CRM_Utils_Array::value($date, $params), NULL, TRUE, 'Ymd');
251 }
252
253 //fix for CRM-3570, during import exclude the statuses those having is_admin = 1
254 $excludeIsAdmin = CRM_Utils_Array::value('exclude_is_admin', $params, FALSE);
255
256 //CRM-3724 always skip is_admin if is_override != true.
257 if (!$excludeIsAdmin && empty($params['is_override'])) {
258 $excludeIsAdmin = TRUE;
259 }
260
261 $calcStatus = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($start_date, $end_date, $join_date,
262 'today', $excludeIsAdmin, CRM_Utils_Array::value('membership_type_id', $params), $params
263 );
264 if (empty($calcStatus)) {
265 // Redirect the form in case of error
266 // @todo this redirect in the BAO layer is really bad & should be moved to the form layer
267 // however since we have no idea how (if) this is triggered we can't safely move / remove it
268 // NB I tried really hard to trigger this error from backoffice membership form in order to test it
269 // and am convinced form validation is complete on that form WRT this error.
270 $errorParams = array(
271 'message_title' => ts('No valid membership status for given dates.'),
272 'legacy_redirect_path' => 'civicrm/contact/view',
273 'legacy_redirect_query' => "reset=1&force=1&cid={$params['contact_id']}&selectedChild=member",
274 );
275 throw new CRM_Core_Exception(ts(
276 "The membership cannot be saved because the status cannot be calculated for start_date: $start_date end_date $end_date join_date $join_date as at " . date('Y-m-d H:i:s')),
277 0,
278 $errorParams
279 );
280 }
281 $params['status_id'] = $calcStatus['id'];
282 }
283
284 // data cleanup only: all verifications on number of related memberships are done upstream in:
285 // CRM_Member_BAO_Membership::createRelatedMemberships()
286 // CRM_Contact_BAO_Relationship::relatedMemberships()
287 if (isset($params['owner_membership_id'])) {
288 unset($params['max_related']);
289 }
290 else {
291 // if membership allows related, default max_related to value in membership_type
292 if (!array_key_exists('max_related', $params) && !empty($params['membership_type_id'])) {
293 $membershipType = CRM_Member_BAO_MembershipType::getMembershipTypeDetails($params['membership_type_id']);
294 if (isset($membershipType['relationship_type_id'])) {
295 $params['max_related'] = CRM_Utils_Array::value('max_related', $membershipType);
296 }
297 }
298 }
299
300 $transaction = new CRM_Core_Transaction();
301
302 $membership = self::add($params, $ids);
303
304 if (is_a($membership, 'CRM_Core_Error')) {
305 $transaction->rollback();
306 return $membership;
307 }
308
309 // add custom field values
310 if (!empty($params['custom']) && is_array($params['custom'])
311 ) {
312 CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_membership', $membership->id);
313 }
314
315 $params['membership_id'] = $membership->id;
316 if (isset($ids['membership'])) {
317 $ids['contribution'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipPayment',
318 $membership->id,
319 'contribution_id',
320 'membership_id'
321 );
322 }
323
324 $params['skipLineItem'] = TRUE;
325
326 //record contribution for this membership
327 if (!empty($params['contribution_status_id']) && empty($params['relate_contribution_id'])) {
328 $memInfo = array_merge($params, array('membership_id' => $membership->id));
329 $params['contribution'] = self::recordMembershipContribution($memInfo, $ids);
330 }
331
332 if (!empty($params['lineItems'])) {
333 $params['line_item'] = $params['lineItems'];
334 }
335
336 //do cleanup line items if membership edit the Membership type.
337 if (empty($ids['contribution']) && !empty($ids['membership'])) {
338 CRM_Price_BAO_LineItem::deleteLineItems($ids['membership'], 'civicrm_membership');
339 }
340
341 if (!empty($params['line_item']) && empty($ids['contribution'])) {
342 CRM_Price_BAO_LineItem::processPriceSet($membership->id, $params['line_item'], CRM_Utils_Array::value('contribution', $params));
343 }
344
345 //insert payment record for this membership
346 if (!empty($params['relate_contribution_id'])) {
347 CRM_Member_BAO_MembershipPayment::create(array(
348 'membership_id' => $membership->id,
349 'membership_type_id' => $membership->membership_type_id,
350 'contribution_id' => $params['relate_contribution_id'],
351 ));
352 }
353
354 // add activity record only during create mode and renew mode
355 // also add activity if status changed CRM-3984 and CRM-2521
356 if (empty($ids['membership']) ||
357 $activityType == 'Membership Renewal' || !empty($params['createActivity'])
358 ) {
359 if (!empty($ids['membership'])) {
360 $data = array();
361 CRM_Core_DAO::commonRetrieveAll('CRM_Member_DAO_Membership',
362 'id',
363 $membership->id,
364 $data,
365 array('contact_id', 'membership_type_id', 'source')
366 );
367
368 $membership->contact_id = $data[$membership->id]['contact_id'];
369 $membership->membership_type_id = $data[$membership->id]['membership_type_id'];
370 $membership->source = CRM_Utils_Array::value('source', $data[$membership->id]);
371 }
372
373 // since we are going to create activity record w/
374 // individual contact as a target in case of on behalf signup,
375 // so get the copy of organization id, CRM-5551
376 $realMembershipContactId = $membership->contact_id;
377
378 // create activity source = individual, target = org CRM-4027
379 $targetContactID = NULL;
380 if (!empty($params['is_for_organization'])) {
381 $targetContactID = $membership->contact_id;
382 $membership->contact_id = CRM_Utils_Array::value('userId', $ids);
383 }
384
385 if (empty($membership->contact_id) && (!empty($membership->owner_membership_id))) {
386 $membership->contact_id = $realMembershipContactId;
387 }
388
389 if (!empty($ids['membership']) && $activityType != 'Membership Signup') {
390 CRM_Activity_BAO_Activity::addActivity($membership, $activityType, $targetContactID);
391 }
392 elseif (empty($ids['membership'])) {
393 CRM_Activity_BAO_Activity::addActivity($membership, $activityType, $targetContactID);
394 }
395
396 // we might created activity record w/ individual
397 // contact as target so update membership object w/
398 // original organization id, CRM-5551
399 $membership->contact_id = $realMembershipContactId;
400 }
401
402 $transaction->commit();
403
404 self::createRelatedMemberships($params, $membership);
405
406 // do not add to recent items for import, CRM-4399
407 if (empty($params['skipRecentView'])) {
408 $url = CRM_Utils_System::url('civicrm/contact/view/membership',
409 "action=view&reset=1&id={$membership->id}&cid={$membership->contact_id}&context=home"
410 );
411 if (empty($membership->membership_type_id)) {
412 // ie in an update situation.
413 $membership->find(TRUE);
414 }
415 $membershipTypes = CRM_Member_PseudoConstant::membershipType();
416 $title = CRM_Contact_BAO_Contact::displayName($membership->contact_id) . ' - ' . ts('Membership Type:') . ' ' . $membershipTypes[$membership->membership_type_id];
417
418 $recentOther = array();
419 if (CRM_Core_Permission::checkActionPermission('CiviMember', CRM_Core_Action::UPDATE)) {
420 $recentOther['editUrl'] = CRM_Utils_System::url('civicrm/contact/view/membership',
421 "action=update&reset=1&id={$membership->id}&cid={$membership->contact_id}&context=home"
422 );
423 }
424 if (CRM_Core_Permission::checkActionPermission('CiviMember', CRM_Core_Action::DELETE)) {
425 $recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/contact/view/membership',
426 "action=delete&reset=1&id={$membership->id}&cid={$membership->contact_id}&context=home"
427 );
428 }
429
430 // add the recently created Membership
431 CRM_Utils_Recent::add($title,
432 $url,
433 $membership->id,
434 'Membership',
435 $membership->contact_id,
436 NULL,
437 $recentOther
438 );
439 }
440
441 return $membership;
442 }
443
444 /**
445 * Check the membership extended through relationship.
446 *
447 * @param int $membershipId
448 * Membership id.
449 * @param int $contactId
450 * Contact id.
451 *
452 * @param int $action
453 *
454 * @return array
455 * array of contact_id of all related contacts.
456 */
457 public static function checkMembershipRelationship($membershipId, $contactId, $action = CRM_Core_Action::ADD) {
458 $contacts = array();
459 $membershipTypeID = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership', $membershipId, 'membership_type_id');
460
461 $membershipType = CRM_Member_BAO_MembershipType::getMembershipTypeDetails($membershipTypeID);
462 $relationships = array();
463 if (isset($membershipType['relationship_type_id'])) {
464 $relationships = CRM_Contact_BAO_Relationship::getRelationship($contactId,
465 CRM_Contact_BAO_Relationship::CURRENT
466 );
467 if ($action & CRM_Core_Action::UPDATE) {
468 $pastRelationships = CRM_Contact_BAO_Relationship::getRelationship($contactId,
469 CRM_Contact_BAO_Relationship::PAST
470 );
471 $relationships = array_merge($relationships, $pastRelationships);
472 }
473 }
474
475 if (!empty($relationships)) {
476 // check for each contact relationships
477 foreach ($relationships as $values) {
478 //get details of the relationship type
479 $relType = array('id' => $values['civicrm_relationship_type_id']);
480 $relValues = array();
481 CRM_Contact_BAO_RelationshipType::retrieve($relType, $relValues);
482 // Check if contact's relationship type exists in membership type
483 $relTypeDirs = array();
484 $relTypeIds = explode(CRM_Core_DAO::VALUE_SEPARATOR, $membershipType['relationship_type_id']);
485 $relDirections = explode(CRM_Core_DAO::VALUE_SEPARATOR, $membershipType['relationship_direction']);
486 $bidirectional = FALSE;
487 foreach ($relTypeIds as $key => $value) {
488 $relTypeDirs[] = $value . '_' . $relDirections[$key];
489 if (in_array($value, $relType) &&
490 $relValues['name_a_b'] == $relValues['name_b_a']
491 ) {
492 $bidirectional = TRUE;
493 break;
494 }
495 }
496 $relTypeDir = $values['civicrm_relationship_type_id'] . '_' . $values['rtype'];
497 if ($bidirectional || in_array($relTypeDir, $relTypeDirs)) {
498 // $values['status'] is going to have value for
499 // current or past relationships.
500 $contacts[$values['cid']] = $values['status'];
501 }
502 }
503 }
504
505 // Sort by contact_id ascending
506 ksort($contacts);
507 return $contacts;
508 }
509
510 /**
511 * Retrieve DB object based on input parameters.
512 *
513 * It also stores all the retrieved values in the default array.
514 *
515 * @param array $params
516 * (reference ) an assoc array of name/value pairs.
517 * @param array $defaults
518 * (reference ) an assoc array to hold the name / value pairs.
519 * in a hierarchical manner
520 *
521 * @return CRM_Member_BAO_Membership
522 */
523 public static function retrieve(&$params, &$defaults) {
524 $membership = new CRM_Member_DAO_Membership();
525
526 $membership->copyValues($params);
527
528 if ($membership->find(TRUE)) {
529 CRM_Core_DAO::storeValues($membership, $defaults);
530
531 //get the membership status and type values.
532 $statusANDType = self::getStatusANDTypeValues($membership->id);
533 foreach (array(
534 'status',
535 'membership_type',
536 ) as $fld) {
537 $defaults[$fld] = CRM_Utils_Array::value($fld, $statusANDType[$membership->id]);
538 }
539 if (!empty($statusANDType[$membership->id]['is_current_member'])) {
540 $defaults['active'] = TRUE;
541 }
542
543 $membership->free();
544
545 return $membership;
546 }
547
548 return NULL;
549 }
550
551 /**
552 * Get membership status and membership type values.
553 *
554 * @param int $membershipId
555 * Membership id of values to return.
556 *
557 * @return array
558 * Array of key value pairs
559 */
560 public static function getStatusANDTypeValues($membershipId) {
561 $values = array();
562 if (!$membershipId) {
563 return $values;
564 }
565 $sql = '
566 SELECT membership.id as id,
567 status.id as status_id,
568 status.label as status,
569 status.is_current_member as is_current_member,
570 type.id as membership_type_id,
571 type.name as membership_type,
572 type.relationship_type_id as relationship_type_id
573 FROM civicrm_membership membership
574 INNER JOIN civicrm_membership_status status ON ( status.id = membership.status_id )
575 INNER JOIN civicrm_membership_type type ON ( type.id = membership.membership_type_id )
576 WHERE membership.id = %1';
577 $dao = CRM_Core_DAO::executeQuery($sql, array(1 => array($membershipId, 'Positive')));
578 $properties = array(
579 'status',
580 'status_id',
581 'membership_type',
582 'membership_type_id',
583 'is_current_member',
584 'relationship_type_id',
585 );
586 while ($dao->fetch()) {
587 foreach ($properties as $property) {
588 $values[$dao->id][$property] = $dao->$property;
589 }
590 }
591
592 return $values;
593 }
594
595 /**
596 * Delete membership.
597 *
598 * Wrapper for most delete calls. Use this unless you JUST want to delete related memberships w/o deleting the parent.
599 *
600 * @param int $membershipId
601 * Membership id that needs to be deleted.
602 *
603 * @return int
604 * Id of deleted Membership on success, false otherwise.
605 */
606 public static function del($membershipId) {
607 //delete related first and then delete parent.
608 self::deleteRelatedMemberships($membershipId);
609 return self::deleteMembership($membershipId);
610 }
611
612 /**
613 * Delete membership.
614 *
615 * @param int $membershipId
616 * Membership id that needs to be deleted.
617 *
618 * @return int
619 * Id of deleted Membership on success, false otherwise.
620 */
621 public static function deleteMembership($membershipId) {
622 // CRM-12147, retrieve membership data before we delete it for hooks
623 $params = array('id' => $membershipId);
624 $memValues = array();
625 $memberships = self::getValues($params, $memValues);
626
627 $membership = $memberships[$membershipId];
628
629 CRM_Utils_Hook::pre('delete', 'Membership', $membershipId, $memValues);
630
631 $transaction = new CRM_Core_Transaction();
632
633 $results = NULL;
634 //delete activity record
635 $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, FALSE, FALSE, 'name');
636
637 $params = array();
638 $deleteActivity = FALSE;
639 $membershipActivities = array(
640 'Membership Signup',
641 'Membership Renewal',
642 'Change Membership Status',
643 'Change Membership Type',
644 'Membership Renewal Reminder',
645 );
646 foreach ($membershipActivities as $membershipActivity) {
647 $activityId = array_search($membershipActivity, $activityTypes);
648 if ($activityId) {
649 $params['activity_type_id'][] = $activityId;
650 $deleteActivity = TRUE;
651 }
652 }
653 if ($deleteActivity) {
654 $params['source_record_id'] = $membershipId;
655 CRM_Activity_BAO_Activity::deleteActivity($params);
656 }
657 self::deleteMembershipPayment($membershipId);
658
659 $results = $membership->delete();
660 $transaction->commit();
661
662 CRM_Utils_Hook::post('delete', 'Membership', $membership->id, $membership);
663
664 // delete the recently created Membership
665 $membershipRecent = array(
666 'id' => $membershipId,
667 'type' => 'Membership',
668 );
669 CRM_Utils_Recent::del($membershipRecent);
670
671 return $results;
672 }
673
674 /**
675 * Delete related memberships.
676 *
677 * @param int $ownerMembershipId
678 * @param int $contactId
679 *
680 * @return null
681 */
682 public static function deleteRelatedMemberships($ownerMembershipId, $contactId = NULL) {
683 if (!$ownerMembershipId && !$contactId) {
684 return FALSE;
685 }
686
687 $membership = new CRM_Member_DAO_Membership();
688 $membership->owner_membership_id = $ownerMembershipId;
689
690 if ($contactId) {
691 $membership->contact_id = $contactId;
692 }
693
694 $membership->find();
695 while ($membership->fetch()) {
696 //delete related first and then delete parent.
697 self::deleteRelatedMemberships($membership->id);
698 self::deleteMembership($membership->id);
699 }
700 $membership->free();
701 }
702
703 /**
704 * Obtain active/inactive memberships from the list of memberships passed to it.
705 *
706 * @param array $memberships
707 * Membership records.
708 * @param string $status
709 * Active or inactive.
710 *
711 * @return array
712 * array of memberships based on status
713 */
714 public static function activeMembers($memberships, $status = 'active') {
715 $actives = array();
716 if ($status == 'active') {
717 foreach ($memberships as $f => $v) {
718 if (!empty($v['active'])) {
719 $actives[$f] = $v;
720 }
721 }
722 return $actives;
723 }
724 elseif ($status == 'inactive') {
725 foreach ($memberships as $f => $v) {
726 if (empty($v['active'])) {
727 $actives[$f] = $v;
728 }
729 }
730 return $actives;
731 }
732 return NULL;
733 }
734
735 /**
736 * Return Membership Block info in Contribution Pages.
737 *
738 * @param int $pageID
739 * Contribution page id.
740 *
741 * @return array|null
742 */
743 public static function getMembershipBlock($pageID) {
744 $membershipBlock = array();
745 $dao = new CRM_Member_DAO_MembershipBlock();
746 $dao->entity_table = 'civicrm_contribution_page';
747
748 $dao->entity_id = $pageID;
749 $dao->is_active = 1;
750 if ($dao->find(TRUE)) {
751 CRM_Core_DAO::storeValues($dao, $membershipBlock);
752 if (!empty($membershipBlock['membership_types'])) {
753 $membershipTypes = unserialize($membershipBlock['membership_types']);
754 if (!is_array($membershipTypes)) {
755 return $membershipBlock;
756 }
757 $memTypes = array();
758 foreach ($membershipTypes as $key => $value) {
759 $membershipBlock['auto_renew'][$key] = $value;
760 $memTypes[$key] = $key;
761 }
762 $membershipBlock['membership_types'] = implode(',', $memTypes);
763 }
764 }
765 else {
766 return NULL;
767 }
768
769 return $membershipBlock;
770 }
771
772 /**
773 * Return a current membership of given contact.
774 *
775 * NB: if more than one membership meets criteria, a randomly selected one is returned.
776 *
777 * @param int $contactID
778 * Contact id.
779 * @param int $memType
780 * Membership type, null to retrieve all types.
781 * @param int $isTest
782 * @param int $membershipId
783 * If provided, then determine if it is current.
784 * @param bool $onlySameParentOrg
785 * True if only Memberships with same parent org as the $memType wanted, false otherwise.
786 *
787 * @return array|bool
788 */
789 public static function getContactMembership($contactID, $memType, $isTest, $membershipId = NULL, $onlySameParentOrg = FALSE) {
790 //check for owner membership id, if it exists update that membership instead: CRM-15992
791 if ($membershipId) {
792 $ownerMemberId = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
793 $membershipId,
794 'owner_membership_id', 'id'
795 );
796 if ($ownerMemberId) {
797 $membershipId = $ownerMemberId;
798 $contactID = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
799 $membershipId,
800 'contact_id', 'id'
801 );
802 }
803 }
804
805 $dao = new CRM_Member_DAO_Membership();
806 if ($membershipId) {
807 $dao->id = $membershipId;
808 }
809 $dao->contact_id = $contactID;
810 $dao->membership_type_id = $memType;
811
812 //fetch proper membership record.
813 if ($isTest) {
814 $dao->is_test = $isTest;
815 }
816 else {
817 $dao->whereAdd('is_test IS NULL OR is_test = 0');
818 }
819
820 //avoid pending membership as current membership: CRM-3027
821 $statusIds[] = array_search('Pending', CRM_Member_PseudoConstant::membershipStatus());
822 if (!$membershipId) {
823 // CRM-15475
824 $statusIds[] = array_search(
825 'Cancelled',
826 CRM_Member_PseudoConstant::membershipStatus(
827 NULL,
828 " name = 'Cancelled' ",
829 'name',
830 FALSE,
831 TRUE
832 )
833 );
834 }
835 $dao->whereAdd('status_id NOT IN ( ' . implode(',', $statusIds) . ')');
836
837 // order by start date to find most recent membership first, CRM-4545
838 $dao->orderBy('start_date DESC');
839
840 // CRM-8141
841 if ($onlySameParentOrg && $memType) {
842 // require the same parent org as the $memType
843 $params = array('id' => $memType);
844 $membershipType = array();
845 if (CRM_Member_BAO_MembershipType::retrieve($params, $membershipType)) {
846 $memberTypesSameParentOrg = CRM_Member_BAO_MembershipType::getMembershipTypesByOrg($membershipType['member_of_contact_id']);
847 $memberTypesSameParentOrgList = implode(',', array_keys($memberTypesSameParentOrg));
848 $dao->whereAdd('membership_type_id IN (' . $memberTypesSameParentOrgList . ')');
849 }
850 }
851
852 if ($dao->find(TRUE)) {
853 $membership = array();
854 CRM_Core_DAO::storeValues($dao, $membership);
855 $membership['is_current_member'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipStatus',
856 $membership['status_id'],
857 'is_current_member', 'id'
858 );
859 $ownerMemberId = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
860 $membership['id'],
861 'owner_membership_id', 'id'
862 );
863 if ($ownerMemberId) {
864 $membership['id'] = $membership['membership_id'] = $ownerMemberId;
865 $membership['membership_contact_id'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
866 $membership['id'],
867 'contact_id', 'id'
868 );
869 }
870 return $membership;
871 }
872
873 // CRM-8141
874 if ($onlySameParentOrg && $memType) {
875 // see if there is a membership that has same parent as $memType but different parent than $membershipID
876 if ($dao->id && CRM_Core_Permission::check('edit memberships')) {
877 // CRM-10016, This is probably a backend renewal, and make sure we return the same membership thats being renewed.
878 $dao->whereAdd();
879 }
880 else {
881 unset($dao->id);
882 }
883
884 unset($dao->membership_type_id);
885 if ($dao->find(TRUE)) {
886 $membership = array();
887 CRM_Core_DAO::storeValues($dao, $membership);
888 $membership['is_current_member'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipStatus',
889 $membership['status_id'],
890 'is_current_member', 'id'
891 );
892 return $membership;
893 }
894 }
895 return FALSE;
896 }
897
898 /**
899 * Combine all the importable fields from the lower levels object.
900 *
901 * @param string $contactType
902 * Contact type.
903 * @param bool $status
904 *
905 * @return array
906 * array of importable Fields
907 */
908 public static function &importableFields($contactType = 'Individual', $status = TRUE) {
909 if (!self::$_importableFields) {
910 if (!self::$_importableFields) {
911 self::$_importableFields = array();
912 }
913
914 if (!$status) {
915 $fields = array('' => array('title' => '- ' . ts('do not import') . ' -'));
916 }
917 else {
918 $fields = array('' => array('title' => '- ' . ts('Membership Fields') . ' -'));
919 }
920
921 $tmpFields = CRM_Member_DAO_Membership::import();
922 $contactFields = CRM_Contact_BAO_Contact::importableFields($contactType, NULL);
923
924 // Using new Dedupe rule.
925 $ruleParams = array(
926 'contact_type' => $contactType,
927 'used' => 'Unsupervised',
928 );
929 $fieldsArray = CRM_Dedupe_BAO_Rule::dedupeRuleFields($ruleParams);
930
931 $tmpContactField = array();
932 if (is_array($fieldsArray)) {
933 foreach ($fieldsArray as $value) {
934 $customFieldId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
935 $value,
936 'id',
937 'column_name'
938 );
939 $value = $customFieldId ? 'custom_' . $customFieldId : $value;
940 $tmpContactField[trim($value)] = CRM_Utils_Array::value(trim($value), $contactFields);
941 if (!$status) {
942 $title = $tmpContactField[trim($value)]['title'] . " " . ts('(match to contact)');
943 }
944 else {
945 $title = $tmpContactField[trim($value)]['title'];
946 }
947 $tmpContactField[trim($value)]['title'] = $title;
948 }
949 }
950 $tmpContactField['external_identifier'] = $contactFields['external_identifier'];
951 $tmpContactField['external_identifier']['title'] = $contactFields['external_identifier']['title'] . " " . ts('(match to contact)');
952
953 $tmpFields['membership_contact_id']['title'] = $tmpFields['membership_contact_id']['title'] . " " . ts('(match to contact)');;
954
955 $fields = array_merge($fields, $tmpContactField);
956 $fields = array_merge($fields, $tmpFields);
957 $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Membership'));
958 self::$_importableFields = $fields;
959 }
960 return self::$_importableFields;
961 }
962
963 /**
964 * Get all exportable fields.
965 *
966 * @return array return array of all exportable fields
967 */
968 public static function &exportableFields() {
969 $expFieldMembership = CRM_Member_DAO_Membership::export();
970
971 $expFieldsMemType = CRM_Member_DAO_MembershipType::export();
972 $fields = array_merge($expFieldMembership, $expFieldsMemType);
973 $fields = array_merge($fields, $expFieldMembership);
974 $membershipStatus = array(
975 'membership_status' => array(
976 'title' => 'Membership Status',
977 'name' => 'membership_status',
978 'type' => CRM_Utils_Type::T_STRING,
979 'where' => 'civicrm_membership_status.name',
980 ),
981 );
982 //CRM-6161 fix for customdata export
983 $fields = array_merge($fields, $membershipStatus, CRM_Core_BAO_CustomField::getFieldsForImport('Membership'));
984 return $fields;
985 }
986
987 /**
988 * Get membership joins/renewals for a specified membership type.
989 *
990 * Specifically, retrieves a count of memberships whose "Membership
991 * Signup" or "Membership Renewal" activity falls in the given date range.
992 * Dates match the pattern "yyyy-mm-dd".
993 *
994 * @param int $membershipTypeId
995 * Membership type id.
996 * @param int $startDate
997 * Date on which to start counting.
998 * @param int $endDate
999 * Date on which to end counting.
1000 * @param bool|int $isTest if true, membership is for a test site
1001 * @param bool|int $isOwner if true, only retrieve membership records for owners //LCD
1002 *
1003 * @return int
1004 * the number of members of type $membershipTypeId whose
1005 * start_date is between $startDate and $endDate
1006 */
1007 public static function getMembershipStarts($membershipTypeId, $startDate, $endDate, $isTest = 0, $isOwner = 0) {
1008
1009 $testClause = 'membership.is_test = 1';
1010 if (!$isTest) {
1011 $testClause = '( membership.is_test IS NULL OR membership.is_test = 0 )';
1012 }
1013
1014 if (!self::$_signupActType || !self::$_renewalActType) {
1015 self::_getActTypes();
1016 }
1017
1018 if (!self::$_signupActType || !self::$_renewalActType) {
1019 return 0;
1020 }
1021
1022 $query = "
1023 SELECT COUNT(DISTINCT membership.id) as member_count
1024 FROM civicrm_membership membership
1025 INNER JOIN civicrm_activity activity ON (activity.source_record_id = membership.id AND activity.activity_type_id in (%1, %2))
1026 INNER JOIN civicrm_membership_status status ON ( membership.status_id = status.id AND status.is_current_member = 1 )
1027 INNER JOIN civicrm_contact contact ON ( contact.id = membership.contact_id AND contact.is_deleted = 0 )
1028 WHERE membership.membership_type_id = %3
1029 AND activity.activity_date_time >= '$startDate' AND activity.activity_date_time <= '$endDate 23:59:59'
1030 AND {$testClause}";
1031
1032 $query .= ($isOwner) ? ' AND owner_membership_id IS NULL' : '';
1033
1034 $params = array(
1035 1 => array(self::$_signupActType, 'Integer'),
1036 2 => array(self::$_renewalActType, 'Integer'),
1037 3 => array($membershipTypeId, 'Integer'),
1038 );
1039
1040 $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
1041 return (int) $memberCount;
1042 }
1043
1044 /**
1045 * Get a count of membership for a specified membership type, optionally for a specified date.
1046 *
1047 * The date must have the form yyyy-mm-dd.
1048 *
1049 * If $date is omitted, this function counts as a member anyone whose
1050 * membership status_id indicates they're a current member.
1051 * If $date is given, this function counts as a member anyone who:
1052 * -- Has a start_date before $date and end_date after $date, or
1053 * -- Has a start_date before $date and is currently a member, as indicated
1054 * by the the membership's status_id.
1055 * The second condition takes care of records that have no end_date. These
1056 * are assumed to be lifetime memberships.
1057 *
1058 * @param int $membershipTypeId
1059 * Membership type id.
1060 * @param string $date
1061 * The date for which to retrieve the count.
1062 * @param bool|int $isTest if true, membership is for a test site
1063 * @param bool|int $isOwner if true, only retrieve membership records for owners //LCD
1064 *
1065 * @return int
1066 * the number of members of type $membershipTypeId as of $date.
1067 */
1068 public static function getMembershipCount($membershipTypeId, $date = NULL, $isTest = 0, $isOwner = 0) {
1069 if (!CRM_Utils_Rule::date($date)) {
1070 CRM_Core_Error::fatal(ts('Invalid date "%1" (must have form yyyy-mm-dd).', array(1 => $date)));
1071 }
1072
1073 $params = array(
1074 1 => array($membershipTypeId, 'Integer'),
1075 2 => array($isTest, 'Boolean'),
1076 );
1077 $query = "SELECT count(civicrm_membership.id ) as member_count
1078 FROM civicrm_membership left join civicrm_membership_status on ( civicrm_membership.status_id = civicrm_membership_status.id )
1079 WHERE civicrm_membership.membership_type_id = %1
1080 AND civicrm_membership.contact_id NOT IN (SELECT id FROM civicrm_contact WHERE is_deleted = 1)
1081 AND civicrm_membership.is_test = %2";
1082 if (!$date) {
1083 $query .= " AND civicrm_membership_status.is_current_member = 1";
1084 }
1085 else {
1086 $query .= " AND civicrm_membership.start_date <= '$date' AND civicrm_membership_status.is_current_member = 1";
1087 }
1088 // LCD
1089 $query .= ($isOwner) ? ' AND owner_membership_id IS NULL' : '';
1090 $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
1091 return (int) $memberCount;
1092 }
1093
1094 /**
1095 * Function check the status of the membership before adding membership for a contact.
1096 *
1097 * @param int $contactId
1098 * Contact id.
1099 *
1100 * @return int
1101 */
1102 public static function statusAvailabilty($contactId) {
1103 $membership = new CRM_Member_DAO_MembershipStatus();
1104 $membership->whereAdd('is_active=1');
1105 return $membership->count();
1106 }
1107
1108 /**
1109 * Function for updating a membership record's contribution_recur_id.
1110 *
1111 * @param CRM_Member_DAO_Membership $membership
1112 * @param \CRM_Contribute_BAO_Contribution|\CRM_Contribute_DAO_Contribution $contribution
1113 */
1114 static public function updateRecurMembership(CRM_Member_DAO_Membership $membership, CRM_Contribute_BAO_Contribution $contribution) {
1115
1116 if (empty($contribution->contribution_recur_id)) {
1117 return;
1118 }
1119
1120 $params = array(
1121 1 => array($contribution->contribution_recur_id, 'Integer'),
1122 2 => array($membership->id, 'Integer'),
1123 );
1124
1125 $sql = "UPDATE civicrm_membership SET contribution_recur_id = %1 WHERE id = %2";
1126 CRM_Core_DAO::executeQuery($sql, $params);
1127 }
1128
1129 /**
1130 * Method to fix membership status of stale membership.
1131 *
1132 * This method first checks if the membership is stale. If it is,
1133 * then status will be updated based on existing start and end
1134 * dates and log will be added for the status change.
1135 *
1136 * @param array $currentMembership
1137 * Reference to the array.
1138 * containing all values of
1139 * the current membership
1140 * @param array $changeToday
1141 * Array of month, day, year.
1142 * values in case today needs
1143 * to be customised, null otherwise
1144 */
1145 public static function fixMembershipStatusBeforeRenew(&$currentMembership, $changeToday) {
1146 $today = NULL;
1147 if ($changeToday) {
1148 $today = CRM_Utils_Date::processDate($changeToday, NULL, FALSE, 'Y-m-d');
1149 }
1150
1151 $status = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate(
1152 CRM_Utils_Array::value('start_date', $currentMembership),
1153 CRM_Utils_Array::value('end_date', $currentMembership),
1154 CRM_Utils_Array::value('join_date', $currentMembership),
1155 $today,
1156 TRUE,
1157 $currentMembership['membership_type_id'],
1158 $currentMembership
1159 );
1160
1161 if (empty($status) ||
1162 empty($status['id'])
1163 ) {
1164 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.'));
1165 }
1166
1167 $currentMembership['today_date'] = $today;
1168
1169 if ($status['id'] !== $currentMembership['status_id']) {
1170 $memberDAO = new CRM_Member_DAO_Membership();
1171 $memberDAO->id = $currentMembership['id'];
1172 $memberDAO->find(TRUE);
1173
1174 $memberDAO->status_id = $status['id'];
1175 $memberDAO->join_date = CRM_Utils_Date::isoToMysql($memberDAO->join_date);
1176 $memberDAO->start_date = CRM_Utils_Date::isoToMysql($memberDAO->start_date);
1177 $memberDAO->end_date = CRM_Utils_Date::isoToMysql($memberDAO->end_date);
1178 $memberDAO->save();
1179 CRM_Core_DAO::storeValues($memberDAO, $currentMembership);
1180 $memberDAO->free();
1181
1182 $currentMembership['is_current_member'] = CRM_Core_DAO::getFieldValue(
1183 'CRM_Member_DAO_MembershipStatus',
1184 $currentMembership['status_id'],
1185 'is_current_member'
1186 );
1187 $format = '%Y%m%d';
1188
1189 $logParams = array(
1190 'membership_id' => $currentMembership['id'],
1191 'status_id' => $status['id'],
1192 'start_date' => CRM_Utils_Date::customFormat(
1193 $currentMembership['start_date'],
1194 $format
1195 ),
1196 'end_date' => CRM_Utils_Date::customFormat(
1197 $currentMembership['end_date'],
1198 $format
1199 ),
1200 'modified_date' => CRM_Utils_Date::customFormat(
1201 $currentMembership['today_date'],
1202 $format
1203 ),
1204 'membership_type_id' => $currentMembership['membership_type_id'],
1205 'max_related' => CRM_Utils_Array::value('max_related', $currentMembership, 0),
1206 );
1207
1208 $session = CRM_Core_Session::singleton();
1209 // If we have an authenticated session, set modified_id to that user's contact_id, else set to membership.contact_id
1210 if ($session->get('userID')) {
1211 $logParams['modified_id'] = $session->get('userID');
1212 }
1213 else {
1214 $logParams['modified_id'] = $currentMembership['contact_id'];
1215 }
1216 CRM_Member_BAO_MembershipLog::add($logParams, CRM_Core_DAO::$_nullArray);
1217 }
1218 }
1219
1220 /**
1221 * Get the contribution page id from the membership record.
1222 *
1223 * @param int $membershipID
1224 *
1225 * @return int
1226 * contribution page id
1227 */
1228 public static function getContributionPageId($membershipID) {
1229 $query = "
1230 SELECT c.contribution_page_id as pageID
1231 FROM civicrm_membership_payment mp, civicrm_contribution c
1232 WHERE mp.contribution_id = c.id
1233 AND c.contribution_page_id IS NOT NULL
1234 AND mp.membership_id = " . CRM_Utils_Type::escape($membershipID, 'Integer')
1235 . " ORDER BY mp.id DESC";
1236
1237 return CRM_Core_DAO::singleValueQuery($query,
1238 CRM_Core_DAO::$_nullArray
1239 );
1240 }
1241
1242 /**
1243 * Updated related memberships.
1244 *
1245 * @param int $ownerMembershipId
1246 * Owner Membership Id.
1247 * @param array $params
1248 * Formatted array of key => value.
1249 */
1250 public static function updateRelatedMemberships($ownerMembershipId, $params) {
1251 $membership = new CRM_Member_DAO_Membership();
1252 $membership->owner_membership_id = $ownerMembershipId;
1253 $membership->find();
1254
1255 while ($membership->fetch()) {
1256 $relatedMembership = new CRM_Member_DAO_Membership();
1257 $relatedMembership->id = $membership->id;
1258 $relatedMembership->copyValues($params);
1259 $relatedMembership->save();
1260 $relatedMembership->free();
1261 }
1262
1263 $membership->free();
1264 }
1265
1266 /**
1267 * Get list of membership fields for profile.
1268 *
1269 * For now we only allow custom membership fields to be in
1270 * profile
1271 *
1272 * @param null $mode
1273 * FIXME: This param is ignored
1274 *
1275 * @return array
1276 * the list of membership fields
1277 */
1278 public static function getMembershipFields($mode = NULL) {
1279 $fields = CRM_Member_DAO_Membership::export();
1280
1281 unset($fields['membership_contact_id']);
1282 $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Membership'));
1283
1284 $membershipType = CRM_Member_DAO_MembershipType::export();
1285
1286 $membershipStatus = CRM_Member_DAO_MembershipStatus::export();
1287
1288 $fields = array_merge($fields, $membershipType, $membershipStatus);
1289
1290 return $fields;
1291 }
1292
1293 /**
1294 * Get the sort name of a contact for a particular membership.
1295 *
1296 * @param int $id
1297 * Id of the membership.
1298 *
1299 * @return null|string
1300 * sort name of the contact if found
1301 */
1302 public static function sortName($id) {
1303 $id = CRM_Utils_Type::escape($id, 'Integer');
1304
1305 $query = "
1306 SELECT civicrm_contact.sort_name
1307 FROM civicrm_membership, civicrm_contact
1308 WHERE civicrm_membership.contact_id = civicrm_contact.id
1309 AND civicrm_membership.id = {$id}
1310 ";
1311 return CRM_Core_DAO::singleValueQuery($query, CRM_Core_DAO::$_nullArray);
1312 }
1313
1314 /**
1315 * Create memberships for related contacts, taking into account the maximum related memberships.
1316 *
1317 * @param array $params
1318 * Array of key - value pairs.
1319 * @param CRM_Core_DAO $dao
1320 * Membership object.
1321 *
1322 * @param bool $reset
1323 *
1324 * @return array|null
1325 * Membership details, if created.
1326 *
1327 * @throws \CRM_Core_Exception
1328 */
1329 public static function createRelatedMemberships(&$params, &$dao, $reset = FALSE) {
1330 static $relatedContactIds = array();
1331 if ($reset) {
1332 // not sure why a static var is in use here - we need a way to reset it from the test suite
1333 $relatedContactIds = array();
1334 return FALSE;
1335 }
1336
1337 $membership = new CRM_Member_DAO_Membership();
1338 $membership->id = $dao->id;
1339
1340 // required since create method doesn't return all the
1341 // parameters in the returned membership object
1342 if (!$membership->find(TRUE)) {
1343 return;
1344 }
1345 $deceasedStatusId = array_search('Deceased', CRM_Member_PseudoConstant::membershipStatus());
1346 // FIXME : While updating/ renewing the
1347 // membership, if the relationship is PAST then
1348 // the membership of the related contact must be
1349 // expired.
1350 // For that, getting Membership Status for which
1351 // is_current_member is 0. It works for the
1352 // generated data as there is only one membership
1353 // status having is_current_member = 0.
1354 // But this wont work exactly if there will be
1355 // more than one status having is_current_member = 0.
1356 $membershipStatus = new CRM_Member_DAO_MembershipStatus();
1357 $membershipStatus->is_current_member = 0;
1358 if ($membershipStatus->find(TRUE)) {
1359 $expiredStatusId = $membershipStatus->id;
1360 }
1361 else {
1362 $expiredStatusId = array_search('Expired', CRM_Member_PseudoConstant::membershipStatus());
1363 }
1364
1365 $allRelatedContacts = array();
1366 $relatedContacts = array();
1367 if (!is_a($membership, 'CRM_Core_Error')) {
1368 $allRelatedContacts = CRM_Member_BAO_Membership::checkMembershipRelationship($membership->id,
1369 $membership->contact_id,
1370 CRM_Utils_Array::value('action', $params)
1371 );
1372 }
1373
1374 // check for loops. CRM-4213
1375 // remove repeated related contacts, which already inherited membership.
1376 $relatedContactIds[$membership->contact_id] = TRUE;
1377 foreach ($allRelatedContacts as $cid => $status) {
1378 if (empty($relatedContactIds[$cid])) {
1379 $relatedContactIds[$cid] = TRUE;
1380
1381 //don't create membership again for owner contact.
1382 $nestedRelationship = FALSE;
1383 if ($membership->owner_membership_id) {
1384 $nestedRelMembership = new CRM_Member_DAO_Membership();
1385 $nestedRelMembership->id = $membership->owner_membership_id;
1386 $nestedRelMembership->contact_id = $cid;
1387 $nestedRelationship = $nestedRelMembership->find(TRUE);
1388 $nestedRelMembership->free();
1389 }
1390 if (!$nestedRelationship) {
1391 $relatedContacts[$cid] = $status;
1392 }
1393 }
1394 }
1395
1396 //lets cleanup related membership if any.
1397 if (empty($relatedContacts)) {
1398 self::deleteRelatedMemberships($membership->id);
1399 }
1400 else {
1401 // Edit the params array
1402 unset($params['id']);
1403 // Reminder should be sent only to the direct membership
1404 unset($params['reminder_date']);
1405 // unset the custom value ids
1406 if (is_array(CRM_Utils_Array::value('custom', $params))) {
1407 foreach ($params['custom'] as $k => $v) {
1408 unset($params['custom'][$k]['id']);
1409 }
1410 }
1411 if (!isset($params['membership_type_id'])) {
1412 $params['membership_type_id'] = $membership->membership_type_id;
1413 }
1414
1415 // max_related should be set in the parent membership
1416 unset($params['max_related']);
1417 // Number of inherited memberships available - NULL is interpreted as unlimited, '0' as none
1418 $available = ($membership->max_related == NULL ? PHP_INT_MAX : $membership->max_related);
1419 // will be used to queue potential memberships to be created.
1420 $queue = array();
1421
1422 foreach ($relatedContacts as $contactId => $relationshipStatus) {
1423 //use existing membership record.
1424 $relMembership = new CRM_Member_DAO_Membership();
1425 $relMembership->contact_id = $contactId;
1426 $relMembership->owner_membership_id = $membership->id;
1427 $relMemIds = array();
1428 if ($relMembership->find(TRUE)) {
1429 $params['id'] = $relMemIds['membership'] = $relMembership->id;
1430 }
1431 $params['contact_id'] = $contactId;
1432 $params['owner_membership_id'] = $membership->id;
1433
1434 // set status_id as it might have been changed for
1435 // past relationship
1436 $params['status_id'] = $membership->status_id;
1437
1438 if ($deceasedStatusId &&
1439 CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $contactId, 'is_deceased')
1440 ) {
1441 $params['status_id'] = $deceasedStatusId;
1442 }
1443 elseif ((CRM_Utils_Array::value('action', $params) & CRM_Core_Action::UPDATE) &&
1444 ($relationshipStatus == CRM_Contact_BAO_Relationship::PAST)
1445 ) {
1446 $params['status_id'] = $expiredStatusId;
1447 }
1448
1449 //don't calculate status again in create( );
1450 $params['skipStatusCal'] = TRUE;
1451
1452 //do create activity if we changed status.
1453 if ($params['status_id'] != $relMembership->status_id) {
1454 $params['createActivity'] = TRUE;
1455 }
1456
1457 // we should not created contribution record for related contacts, CRM-3371
1458 unset($params['contribution_status_id']);
1459
1460 //CRM-16857: Do not create multiple line-items for inherited membership through priceset.
1461 unset($params['lineItems']);
1462 unset($params['line_item']);
1463
1464 if (($params['status_id'] == $deceasedStatusId) || ($params['status_id'] == $expiredStatusId)) {
1465 // related membership is not active so does not count towards maximum
1466 CRM_Member_BAO_Membership::create($params, $relMemIds);
1467 }
1468 else {
1469 // related membership already exists, so this is just an update
1470 if (isset($params['id'])) {
1471 if ($available > 0) {
1472 CRM_Member_BAO_Membership::create($params, $relMemIds);
1473 $available--;
1474 }
1475 else {
1476 // we have run out of inherited memberships, so delete extras
1477 self::deleteMembership($params['id']);
1478 }
1479 // we need to first check if there will remain inherited memberships, so queue it up
1480 }
1481 else {
1482 $queue[] = $params;
1483 }
1484 }
1485 }
1486 // now go over the queue and create any available related memberships
1487 reset($queue);
1488 while (($available > 0) && ($params = each($queue))) {
1489 CRM_Member_BAO_Membership::create($params['value'], $relMemIds);
1490 $available--;
1491 }
1492 }
1493 }
1494
1495 /**
1496 * Delete the record that are associated with this Membership Payment.
1497 *
1498 * @param int $membershipId
1499 *
1500 * @return object
1501 * $membershipPayment deleted membership payment object
1502 */
1503 public static function deleteMembershipPayment($membershipId) {
1504
1505 $membershipPayment = new CRM_Member_DAO_MembershipPayment();
1506 $membershipPayment->membership_id = $membershipId;
1507 $membershipPayment->find();
1508
1509 while ($membershipPayment->fetch()) {
1510 CRM_Contribute_BAO_Contribution::deleteContribution($membershipPayment->contribution_id);
1511 CRM_Utils_Hook::pre('delete', 'MembershipPayment', $membershipPayment->id, $membershipPayment);
1512 $membershipPayment->delete();
1513 CRM_Utils_Hook::post('delete', 'MembershipPayment', $membershipPayment->id, $membershipPayment);
1514 }
1515 return $membershipPayment;
1516 }
1517
1518 /**
1519 * Build an array of available membership types.
1520 *
1521 * @param CRM_Core_Form $form
1522 * @param array $membershipTypeID
1523 * @param bool $activeOnly
1524 * Do we only want active ones?
1525 * (probably this should default to TRUE but as a newly added parameter we are leaving default b
1526 * behaviour unchanged).
1527 *
1528 * @return array
1529 */
1530 public static function buildMembershipTypeValues(&$form, $membershipTypeID = array(), $activeOnly = FALSE) {
1531 $whereClause = " WHERE domain_id = " . CRM_Core_Config::domainID();
1532 $membershipTypeIDS = (array) $membershipTypeID;
1533
1534 if ($activeOnly) {
1535 $whereClause .= " AND is_active = 1 ";
1536 }
1537 if (!empty($membershipTypeIDS)) {
1538 $allIDs = implode(',', $membershipTypeIDS);
1539 $whereClause .= " AND id IN ( $allIDs )";
1540 }
1541 CRM_Financial_BAO_FinancialType::getAvailableFinancialTypes($financialTypes, CRM_Core_Action::ADD);
1542
1543 if ($financialTypes) {
1544 $whereClause .= " AND financial_type_id IN (" . implode(',', array_keys($financialTypes)) . ")";
1545 }
1546 else {
1547 $whereClause .= " AND financial_type_id IN (0)";
1548 }
1549
1550 $query = "
1551 SELECT *
1552 FROM civicrm_membership_type
1553 $whereClause;
1554 ";
1555 $dao = CRM_Core_DAO::executeQuery($query);
1556
1557 $membershipTypeValues = array();
1558 $membershipTypeFields = array(
1559 'id',
1560 'minimum_fee',
1561 'name',
1562 'is_active',
1563 'description',
1564 'financial_type_id',
1565 'auto_renew',
1566 'member_of_contact_id',
1567 'relationship_type_id',
1568 'relationship_direction',
1569 'max_related',
1570 'duration_unit',
1571 'duration_interval',
1572 );
1573
1574 while ($dao->fetch()) {
1575 $membershipTypeValues[$dao->id] = array();
1576 foreach ($membershipTypeFields as $mtField) {
1577 $membershipTypeValues[$dao->id][$mtField] = $dao->$mtField;
1578 }
1579 }
1580 $dao->free();
1581
1582 CRM_Utils_Hook::membershipTypeValues($form, $membershipTypeValues);
1583
1584 if (is_numeric($membershipTypeID) &&
1585 $membershipTypeID > 0
1586 ) {
1587 return $membershipTypeValues[$membershipTypeID];
1588 }
1589 else {
1590 return $membershipTypeValues;
1591 }
1592 }
1593
1594 /**
1595 * Get membership record count for a Contact.
1596 *
1597 * @param int $contactID
1598 * @param bool $activeOnly
1599 *
1600 * @return null|string
1601 */
1602 public static function getContactMembershipCount($contactID, $activeOnly = FALSE) {
1603 CRM_Financial_BAO_FinancialType::getAvailableMembershipTypes($membershipTypes);
1604 $addWhere = " AND membership_type_id IN (0)";
1605 if (!empty($membershipTypes)) {
1606 $addWhere = " AND membership_type_id IN (" . implode(',', array_keys($membershipTypes)) . ")";
1607 }
1608 $select = "SELECT count(*) FROM civicrm_membership ";
1609 $where = "WHERE civicrm_membership.contact_id = {$contactID} AND civicrm_membership.is_test = 0 ";
1610
1611 // CRM-6627, all status below 3 (active, pending, grace) are considered active
1612 if ($activeOnly) {
1613 $select .= " INNER JOIN civicrm_membership_status ON civicrm_membership.status_id = civicrm_membership_status.id ";
1614 $where .= " and civicrm_membership_status.is_current_member = 1";
1615 }
1616
1617 $query = $select . $where . $addWhere;
1618 return CRM_Core_DAO::singleValueQuery($query);
1619 }
1620
1621 /**
1622 * Check whether payment processor supports cancellation of membership subscription.
1623 *
1624 * @param int $mid
1625 * Membership id.
1626 *
1627 * @param bool $isNotCancelled
1628 *
1629 * @return bool
1630 */
1631 public static function isCancelSubscriptionSupported($mid, $isNotCancelled = TRUE) {
1632 $cacheKeyString = "$mid";
1633 $cacheKeyString .= $isNotCancelled ? '_1' : '_0';
1634
1635 static $supportsCancel = array();
1636
1637 if (!array_key_exists($cacheKeyString, $supportsCancel)) {
1638 $supportsCancel[$cacheKeyString] = FALSE;
1639 $isCancelled = FALSE;
1640
1641 if ($isNotCancelled) {
1642 $isCancelled = self::isSubscriptionCancelled($mid);
1643 }
1644
1645 $paymentObject = CRM_Financial_BAO_PaymentProcessor::getProcessorForEntity($mid, 'membership', 'obj');
1646 if (!empty($paymentObject)) {
1647 $supportsCancel[$cacheKeyString] = $paymentObject->isSupported('cancelSubscription') && !$isCancelled;
1648 }
1649 }
1650 return $supportsCancel[$cacheKeyString];
1651 }
1652
1653 /**
1654 * Check whether subscription is already cancelled.
1655 *
1656 * @param int $mid
1657 * Membership id.
1658 *
1659 * @return string
1660 * contribution status
1661 */
1662 public static function isSubscriptionCancelled($mid) {
1663 $sql = "
1664 SELECT cr.contribution_status_id
1665 FROM civicrm_contribution_recur cr
1666 LEFT JOIN civicrm_membership mem ON ( cr.id = mem.contribution_recur_id )
1667 WHERE mem.id = %1 LIMIT 1";
1668 $params = array(1 => array($mid, 'Integer'));
1669 $statusId = CRM_Core_DAO::singleValueQuery($sql, $params);
1670 $status = CRM_Contribute_PseudoConstant::contributionStatus($statusId, 'name');
1671 if ($status == 'Cancelled') {
1672 return TRUE;
1673 }
1674 return FALSE;
1675 }
1676
1677 /**
1678 * Get membership joins for a specified membership type.
1679 *
1680 * Specifically, retrieves a count of still current memberships whose
1681 * join_date and start_date are within a specified date range. Dates match
1682 * the pattern "yyyy-mm-dd".
1683 *
1684 * @param int $membershipTypeId
1685 * Membership type id.
1686 * @param int $startDate
1687 * Date on which to start counting.
1688 * @param int $endDate
1689 * Date on which to end counting.
1690 * @param bool|int $isTest if true, membership is for a test site
1691 *
1692 * @return int
1693 * the number of members of type $membershipTypeId
1694 * whose join_date is between $startDate and $endDate and
1695 * whose start_date is between $startDate and $endDate
1696 */
1697 public static function getMembershipJoins($membershipTypeId, $startDate, $endDate, $isTest = 0) {
1698 $testClause = 'membership.is_test = 1';
1699 if (!$isTest) {
1700 $testClause = '( membership.is_test IS NULL OR membership.is_test = 0 )';
1701 }
1702 if (!self::$_signupActType) {
1703 self::_getActTypes();
1704 }
1705
1706 if (!self::$_signupActType) {
1707 return 0;
1708 }
1709
1710 $query = "
1711 SELECT COUNT(DISTINCT membership.id) as member_count
1712 FROM civicrm_membership membership
1713 INNER JOIN civicrm_activity activity ON (activity.source_record_id = membership.id AND activity.activity_type_id = %1)
1714 INNER JOIN civicrm_membership_status status ON ( membership.status_id = status.id AND status.is_current_member = 1 )
1715 INNER JOIN civicrm_contact contact ON ( contact.id = membership.contact_id AND contact.is_deleted = 0 )
1716 WHERE membership.membership_type_id = %2
1717 AND activity.activity_date_time >= '$startDate' AND activity.activity_date_time <= '$endDate 23:59:59'
1718 AND {$testClause}";
1719
1720 $params = array(
1721 1 => array(self::$_signupActType, 'Integer'),
1722 2 => array($membershipTypeId, 'Integer'),
1723 );
1724
1725 $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
1726
1727 return (int) $memberCount;
1728 }
1729
1730 /**
1731 * Get membership renewals for a specified membership type.
1732 *
1733 * Specifically, retrieves a count of still current memberships
1734 * whose join_date is before and start_date is within a specified date
1735 * range. Dates match the pattern "yyyy-mm-dd".
1736 *
1737 * @param int $membershipTypeId
1738 * Membership type id.
1739 * @param int $startDate
1740 * Date on which to start counting.
1741 * @param int $endDate
1742 * Date on which to end counting.
1743 * @param bool|int $isTest if true, membership is for a test site
1744 *
1745 * @return int
1746 * returns the number of members of type $membershipTypeId
1747 * whose join_date is before $startDate and
1748 * whose start_date is between $startDate and $endDate
1749 */
1750 public static function getMembershipRenewals($membershipTypeId, $startDate, $endDate, $isTest = 0) {
1751 $testClause = 'membership.is_test = 1';
1752 if (!$isTest) {
1753 $testClause = '( membership.is_test IS NULL OR membership.is_test = 0 )';
1754 }
1755 if (!self::$_renewalActType) {
1756 self::_getActTypes();
1757 }
1758
1759 if (!self::$_renewalActType) {
1760 return 0;
1761 }
1762
1763 $query = "
1764 SELECT COUNT(DISTINCT membership.id) as member_count
1765 FROM civicrm_membership membership
1766 INNER JOIN civicrm_activity activity ON (activity.source_record_id = membership.id AND activity.activity_type_id = %1)
1767 INNER JOIN civicrm_membership_status status ON ( membership.status_id = status.id AND status.is_current_member = 1 )
1768 INNER JOIN civicrm_contact contact ON ( contact.id = membership.contact_id AND contact.is_deleted = 0 )
1769 WHERE membership.membership_type_id = %2
1770 AND activity.activity_date_time >= '$startDate' AND activity.activity_date_time <= '$endDate 23:59:59'
1771 AND {$testClause}";
1772
1773 $params = array(
1774 1 => array(self::$_renewalActType, 'Integer'),
1775 2 => array($membershipTypeId, 'Integer'),
1776 );
1777 $memberCount = CRM_Core_DAO::singleValueQuery($query, $params);
1778
1779 return (int) $memberCount;
1780 }
1781
1782 /**
1783 * Create linkages between membership & contribution - note this is the wrong place for this code but this is a
1784 * refactoring step. This should be BAO functionality
1785 * @param $membership
1786 * @param $membershipContribution
1787 */
1788 public static function linkMembershipPayment($membership, $membershipContribution) {
1789 CRM_Member_BAO_MembershipPayment::create(array(
1790 'membership_id' => $membership->id,
1791 'membership_type_id' => $membership->membership_type_id,
1792 'contribution_id' => $membershipContribution->id,
1793 ));
1794 }
1795
1796 /**
1797 * @param int $contactID
1798 * @param int $membershipTypeID
1799 * @param bool $is_test
1800 * @param $changeToday
1801 * @param int $modifiedID
1802 * @param $customFieldsFormatted
1803 * @param $numRenewTerms
1804 * @param int $membershipID
1805 * @param $pending
1806 * @param int $contributionRecurID
1807 * @param $membershipSource
1808 * @param $isPayLater
1809 * @param int $campaignId
1810 * @param array $formDates
1811 *
1812 * @throws CRM_Core_Exception
1813 * @return array
1814 */
1815 public static function renewMembership($contactID, $membershipTypeID, $is_test, $changeToday, $modifiedID, $customFieldsFormatted, $numRenewTerms, $membershipID, $pending, $contributionRecurID, $membershipSource, $isPayLater, $campaignId, $formDates = array()) {
1816 $renewalMode = $updateStatusId = FALSE;
1817 $allStatus = CRM_Member_PseudoConstant::membershipStatus();
1818 $format = '%Y%m%d';
1819 $statusFormat = '%Y-%m-%d';
1820 $membershipTypeDetails = CRM_Member_BAO_MembershipType::getMembershipTypeDetails($membershipTypeID);
1821 $dates = array();
1822 // CRM-7297 - allow membership type to be be changed during renewal so long as the parent org of new membershipType
1823 // is the same as the parent org of an existing membership of the contact
1824 $currentMembership = CRM_Member_BAO_Membership::getContactMembership($contactID, $membershipTypeID,
1825 $is_test, $membershipID, TRUE
1826 );
1827 if ($currentMembership) {
1828 $activityType = 'Membership Renewal';
1829 $renewalMode = TRUE;
1830
1831 // Do NOT do anything.
1832 //1. membership with status : PENDING/CANCELLED (CRM-2395)
1833 //2. Paylater/IPN renew. CRM-4556.
1834 if ($pending || in_array($currentMembership['status_id'], array(
1835 array_search('Pending', $allStatus),
1836 // CRM-15475
1837 array_search('Cancelled', CRM_Member_PseudoConstant::membershipStatus(NULL, " name = 'Cancelled' ", 'name', FALSE, TRUE)),
1838 ))
1839 ) {
1840 $membership = new CRM_Member_DAO_Membership();
1841 $membership->id = $currentMembership['id'];
1842 $membership->find(TRUE);
1843
1844 // CRM-8141 create a membership_log entry so that we will know the membership_type_id to change to when payment completed
1845 $format = '%Y%m%d';
1846 // note that we are logging the requested new membership_type_id that may be different than current membership_type_id
1847 // it will be used when payment is received to update the membership_type_id to what was paid for
1848 $logParams = array(
1849 'membership_id' => $membership->id,
1850 'status_id' => $membership->status_id,
1851 'start_date' => CRM_Utils_Date::customFormat(
1852 $membership->start_date,
1853 $format
1854 ),
1855 'end_date' => CRM_Utils_Date::customFormat(
1856 $membership->end_date,
1857 $format
1858 ),
1859 'modified_date' => CRM_Utils_Date::customFormat(
1860 date('Ymd'),
1861 $format
1862 ),
1863 'membership_type_id' => $membershipTypeID,
1864 'max_related' => !empty($membershipTypeDetails['max_related']) ? $membershipTypeDetails['max_related'] : NULL,
1865 );
1866 $session = CRM_Core_Session::singleton();
1867 // If we have an authenticated session, set modified_id to that user's contact_id, else set to membership.contact_id
1868 if ($session->get('userID')) {
1869 $logParams['modified_id'] = $session->get('userID');
1870 }
1871 else {
1872 $logParams['modified_id'] = $membership->contact_id;
1873 }
1874 CRM_Member_BAO_MembershipLog::add($logParams);
1875
1876 if ($contributionRecurID) {
1877 CRM_Core_DAO::setFieldValue('CRM_Member_DAO_Membership', $membership->id,
1878 'contribution_recur_id', $contributionRecurID
1879 );
1880 }
1881
1882 return array($membership, $renewalMode, $dates);
1883 }
1884
1885 // Check and fix the membership if it is STALE
1886 self::fixMembershipStatusBeforeRenew($currentMembership, $changeToday);
1887
1888 // Now Renew the membership
1889 if (!$currentMembership['is_current_member']) {
1890 // membership is not CURRENT
1891
1892 // CRM-7297 Membership Upsell - calculate dates based on new membership type
1893 $dates = CRM_Member_BAO_MembershipType::getRenewalDatesForMembershipType($currentMembership['id'],
1894 $changeToday,
1895 $membershipTypeID,
1896 $numRenewTerms
1897 );
1898
1899 $currentMembership['join_date'] = CRM_Utils_Date::customFormat($currentMembership['join_date'], $format);
1900 foreach (array('start_date', 'end_date') as $dateType) {
1901 $currentMembership[$dateType] = CRM_Utils_Array::value($dateType, $formDates);
1902 if (empty($currentMembership[$dateType])) {
1903 $currentMembership[$dateType] = CRM_Utils_Array::value($dateType, $dates);
1904 }
1905 }
1906 $currentMembership['is_test'] = $is_test;
1907
1908 if (!empty($membershipSource)) {
1909 $currentMembership['source'] = $membershipSource;
1910 }
1911 else {
1912 $currentMembership['source'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
1913 $currentMembership['id'],
1914 'source'
1915 );
1916 }
1917
1918 if (!empty($currentMembership['id'])) {
1919 $ids['membership'] = $currentMembership['id'];
1920 }
1921 $memParams = $currentMembership;
1922 $memParams['membership_type_id'] = $membershipTypeID;
1923
1924 //set the log start date.
1925 $memParams['log_start_date'] = CRM_Utils_Date::customFormat($dates['log_start_date'], $format);
1926 }
1927 else {
1928
1929 // CURRENT Membership
1930 $membership = new CRM_Member_DAO_Membership();
1931 $membership->id = $currentMembership['id'];
1932 $membership->find(TRUE);
1933 // CRM-7297 Membership Upsell - calculate dates based on new membership type
1934 $dates = CRM_Member_BAO_MembershipType::getRenewalDatesForMembershipType($membership->id,
1935 $changeToday,
1936 $membershipTypeID,
1937 $numRenewTerms
1938 );
1939
1940 // Insert renewed dates for CURRENT membership
1941 $memParams = array();
1942 $memParams['join_date'] = CRM_Utils_Date::isoToMysql($membership->join_date);
1943 $memParams['start_date'] = CRM_Utils_Date::isoToMysql($membership->start_date);
1944 $memParams['end_date'] = CRM_Utils_Array::value('end_date', $formDates);
1945 if (empty($memParams['end_date'])) {
1946 $memParams['end_date'] = CRM_Utils_Array::value('end_date', $dates);
1947 }
1948 $memParams['membership_type_id'] = $membershipTypeID;
1949
1950 //set the log start date.
1951 $memParams['log_start_date'] = CRM_Utils_Date::customFormat($dates['log_start_date'], $format);
1952 if (empty($membership->source)) {
1953 if (!empty($membershipSource)) {
1954 $memParams['source'] = $membershipSource;
1955 }
1956 else {
1957 $memParams['source'] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership',
1958 $currentMembership['id'],
1959 'source'
1960 );
1961 }
1962 }
1963
1964 if (!empty($currentMembership['id'])) {
1965 $ids['membership'] = $currentMembership['id'];
1966 }
1967 }
1968 //CRM-4555
1969 if ($pending) {
1970 $updateStatusId = array_search('Pending', $allStatus);
1971 }
1972 }
1973 else {
1974 // NEW Membership
1975
1976 $activityType = 'Membership Signup';
1977 $memParams = array(
1978 'contact_id' => $contactID,
1979 'membership_type_id' => $membershipTypeID,
1980 );
1981
1982 if (!$pending) {
1983 $dates = CRM_Member_BAO_MembershipType::getDatesForMembershipType($membershipTypeID, NULL, NULL, NULL, $numRenewTerms);
1984
1985 foreach (array('join_date', 'start_date', 'end_date') as $dateType) {
1986 $memParams[$dateType] = CRM_Utils_Array::value($dateType, $formDates);
1987 if (empty($memParams[$dateType])) {
1988 $memParams[$dateType] = CRM_Utils_Array::value($dateType, $dates);
1989 }
1990 }
1991
1992 $status = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate(CRM_Utils_Date::customFormat($dates['start_date'],
1993 $statusFormat
1994 ),
1995 CRM_Utils_Date::customFormat($dates['end_date'],
1996 $statusFormat
1997 ),
1998 CRM_Utils_Date::customFormat($dates['join_date'],
1999 $statusFormat
2000 ),
2001 'today',
2002 TRUE,
2003 $membershipTypeID,
2004 $memParams
2005 );
2006 $updateStatusId = CRM_Utils_Array::value('id', $status);
2007 }
2008 else {
2009 // if IPN/Pay-Later set status to: PENDING
2010 $updateStatusId = array_search('Pending', $allStatus);
2011 }
2012
2013 if (!empty($membershipSource)) {
2014 $memParams['source'] = $membershipSource;
2015 }
2016 $memParams['is_test'] = $is_test;
2017 $memParams['is_pay_later'] = $isPayLater;
2018 }
2019 // Putting this in an IF is precautionary as it seems likely that it would be ignored if empty, but
2020 // perhaps shouldn't be?
2021 if ($contributionRecurID) {
2022 $memParams['contribution_recur_id'] = $contributionRecurID;
2023 }
2024 //CRM-4555
2025 //if we decided status here and want to skip status
2026 //calculation in create( ); then need to pass 'skipStatusCal'.
2027 if ($updateStatusId) {
2028 $memParams['status_id'] = $updateStatusId;
2029 $memParams['skipStatusCal'] = TRUE;
2030 }
2031
2032 //since we are renewing,
2033 //make status override false.
2034 $memParams['is_override'] = FALSE;
2035
2036 //CRM-4027, create log w/ individual contact.
2037 if ($modifiedID) {
2038 $ids['userId'] = $modifiedID;
2039 $memParams['is_for_organization'] = TRUE;
2040 }
2041 else {
2042 $ids['userId'] = $contactID;
2043 }
2044
2045 //inherit campaign from contrib page.
2046 if (isset($campaignId)) {
2047 $memParams['campaign_id'] = $campaignId;
2048 }
2049
2050 $memParams['custom'] = $customFieldsFormatted;
2051 $membership = self::create($memParams, $ids, FALSE, $activityType);
2052
2053 // not sure why this statement is here, seems quite odd :( - Lobo: 12/26/2010
2054 // related to: http://forum.civicrm.org/index.php/topic,11416.msg49072.html#msg49072
2055 $membership->find(TRUE);
2056
2057 return array($membership, $renewalMode, $dates);
2058 }
2059
2060 /**
2061 * Get line items representing the default price set.
2062 *
2063 * @param int $membershipOrg
2064 * @param int $membershipTypeID
2065 * @param float $total_amount
2066 * @param int $priceSetId
2067 *
2068 * @return array
2069 */
2070 public static function setQuickConfigMembershipParameters($membershipOrg, $membershipTypeID, $total_amount, $priceSetId) {
2071 $priceSets = current(CRM_Price_BAO_PriceSet::getSetDetail($priceSetId));
2072
2073 // The name of the price field corresponds to the membership_type organization contact.
2074 $params = array(
2075 'price_set_id' => $priceSetId,
2076 'name' => $membershipOrg,
2077 );
2078 $results = array();
2079 CRM_Price_BAO_PriceField::retrieve($params, $results);
2080
2081 if (!empty($results)) {
2082 $fields[$results['id']] = $priceSets['fields'][$results['id']];
2083 $fid = $results['id'];
2084 $editedFieldParams = array(
2085 'price_field_id' => $results['id'],
2086 'membership_type_id' => $membershipTypeID,
2087 );
2088 $results = array();
2089 CRM_Price_BAO_PriceFieldValue::retrieve($editedFieldParams, $results);
2090 $fields[$fid]['options'][$results['id']] = $priceSets['fields'][$fid]['options'][$results['id']];
2091 if (!empty($total_amount)) {
2092 $fields[$fid]['options'][$results['id']]['amount'] = $total_amount;
2093 }
2094 }
2095
2096 $fieldID = key($fields);
2097 $returnParams = array(
2098 'price_set_id' => $priceSetId,
2099 'price_sets' => $priceSets,
2100 'fields' => $fields,
2101 'price_fields' => array(
2102 'price_' . $fieldID => CRM_Utils_Array::value('id', $results),
2103 ),
2104 );
2105 return $returnParams;
2106 }
2107
2108 /**
2109 * Process price set and line items.
2110 *
2111 * @param int $membershipId
2112 * @param array $lineItem
2113 */
2114 public function processPriceSet($membershipId, $lineItem) {
2115 //FIXME : need to move this too
2116 if (!$membershipId || !is_array($lineItem)
2117 || CRM_Utils_System::isNull($lineItem)
2118 ) {
2119 return;
2120 }
2121
2122 foreach ($lineItem as $priceSetId => $values) {
2123 if (!$priceSetId) {
2124 continue;
2125 }
2126 foreach ($values as $line) {
2127 $line['entity_table'] = 'civicrm_membership';
2128 $line['entity_id'] = $membershipId;
2129 CRM_Price_BAO_LineItem::create($line);
2130 }
2131 }
2132 }
2133
2134 /**
2135 * Retrieve the contribution id for the associated Membership id.
2136 * @todo we should get this off the line item
2137 *
2138 * @param int $membershipId
2139 * Membership id.
2140 *
2141 * @return int
2142 * contribution id
2143 */
2144 public static function getMembershipContributionId($membershipId) {
2145
2146 $membershipPayment = new CRM_Member_DAO_MembershipPayment();
2147 $membershipPayment->membership_id = $membershipId;
2148 if ($membershipPayment->find(TRUE)) {
2149 return $membershipPayment->contribution_id;
2150 }
2151 return NULL;
2152 }
2153
2154 /**
2155 * The function checks and updates the status of all membership records for a given domain using the
2156 * calc_membership_status and update_contact_membership APIs.
2157 *
2158 * IMPORTANT:
2159 * Sending renewal reminders has been migrated from this job to the Scheduled Reminders function as of 4.3.
2160 *
2161 * @return array
2162 */
2163 public static function updateAllMembershipStatus() {
2164
2165 //get all active statuses of membership, CRM-3984
2166 $allStatus = CRM_Member_PseudoConstant::membershipStatus();
2167 $statusLabels = CRM_Member_PseudoConstant::membershipStatus(NULL, NULL, 'label');
2168 $allTypes = CRM_Member_PseudoConstant::membershipType();
2169
2170 // get only memberships with active membership types
2171 $query = "
2172 SELECT civicrm_membership.id as membership_id,
2173 civicrm_membership.is_override as is_override,
2174 civicrm_membership.membership_type_id as membership_type_id,
2175 civicrm_membership.status_id as status_id,
2176 civicrm_membership.join_date as join_date,
2177 civicrm_membership.start_date as start_date,
2178 civicrm_membership.end_date as end_date,
2179 civicrm_membership.source as source,
2180 civicrm_contact.id as contact_id,
2181 civicrm_contact.is_deceased as is_deceased,
2182 civicrm_membership.owner_membership_id as owner_membership_id,
2183 civicrm_membership.contribution_recur_id as recur_id
2184 FROM civicrm_membership
2185 INNER JOIN civicrm_contact ON ( civicrm_membership.contact_id = civicrm_contact.id )
2186 INNER JOIN civicrm_membership_type ON
2187 (civicrm_membership.membership_type_id = civicrm_membership_type.id AND civicrm_membership_type.is_active = 1)
2188 WHERE civicrm_membership.is_test = 0";
2189
2190 $params = array();
2191 $dao = CRM_Core_DAO::executeQuery($query, $params);
2192
2193 $processCount = 0;
2194 $updateCount = 0;
2195
2196 $smarty = CRM_Core_Smarty::singleton();
2197
2198 while ($dao->fetch()) {
2199 // echo ".";
2200 $processCount++;
2201
2202 // Put common parameters into array for easy access
2203 $memberParams = array(
2204 'id' => $dao->membership_id,
2205 'status_id' => $dao->status_id,
2206 'contact_id' => $dao->contact_id,
2207 'membership_type_id' => $dao->membership_type_id,
2208 'membership_type' => $allTypes[$dao->membership_type_id],
2209 'join_date' => $dao->join_date,
2210 'start_date' => $dao->start_date,
2211 'end_date' => $dao->end_date,
2212 'source' => $dao->source,
2213 'skipStatusCal' => TRUE,
2214 'skipRecentView' => TRUE,
2215 );
2216
2217 $smarty->assign_by_ref('memberParams', $memberParams);
2218
2219 //update membership record to Deceased if contact is deceased
2220 if ($dao->is_deceased) {
2221 // check for 'Deceased' membership status, CRM-5636
2222 $deceaseStatusId = array_search('Deceased', $allStatus);
2223 if (!$deceaseStatusId) {
2224 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'))));
2225 }
2226
2227 //process only when status change.
2228 if ($dao->status_id != $deceaseStatusId) {
2229 //take all params that need to save.
2230 $deceasedMembership = $memberParams;
2231 $deceasedMembership['status_id'] = $deceaseStatusId;
2232 $deceasedMembership['createActivity'] = TRUE;
2233 $deceasedMembership['version'] = 3;
2234
2235 //since there is change in status.
2236 $statusChange = array('status_id' => $deceaseStatusId);
2237 $smarty->append_by_ref('memberParams', $statusChange, TRUE);
2238 unset(
2239 $deceasedMembership['contact_id'],
2240 $deceasedMembership['membership_type_id'],
2241 $deceasedMembership['membership_type'],
2242 $deceasedMembership['join_date'],
2243 $deceasedMembership['start_date'],
2244 $deceasedMembership['end_date'],
2245 $deceasedMembership['source']
2246 );
2247
2248 //process membership record.
2249 civicrm_api('membership', 'create', $deceasedMembership);
2250 }
2251 continue;
2252 }
2253
2254 //we fetch related, since we need to check for deceased
2255 //now further processing is handle w/ main membership record.
2256 if ($dao->owner_membership_id) {
2257 continue;
2258 }
2259
2260 //update membership records where status is NOT - Pending OR Cancelled.
2261 //as well as membership is not override.
2262 //skipping Expired membership records -> reduced extra processing( kiran )
2263 if (!$dao->is_override &&
2264 !in_array($dao->status_id, array(
2265 array_search('Pending', $allStatus),
2266 // CRM-15475
2267 array_search(
2268 'Cancelled',
2269 CRM_Member_PseudoConstant::membershipStatus(NULL, " name = 'Cancelled' ", 'name', FALSE, TRUE)
2270 ),
2271 array_search('Expired', $allStatus),
2272 ))
2273 ) {
2274
2275 // CRM-7248: added excludeIsAdmin param to the following fn call to prevent moving to admin statuses
2276 //get the membership status as per id.
2277 $newStatus = civicrm_api('membership_status', 'calc',
2278 array(
2279 'membership_id' => $dao->membership_id,
2280 'version' => 3,
2281 'ignore_admin_only' => FALSE,
2282 ), TRUE
2283 );
2284 $statusId = CRM_Utils_Array::value('id', $newStatus);
2285
2286 //process only when status change.
2287 if ($statusId &&
2288 $statusId != $dao->status_id
2289 ) {
2290 //take all params that need to save.
2291 $memParams = $memberParams;
2292 $memParams['status_id'] = $statusId;
2293 $memParams['createActivity'] = TRUE;
2294 $memParams['version'] = 3;
2295
2296 // Unset columns which should remain unchanged from their current saved
2297 // values. This avoids race condition in which these values may have
2298 // been changed by other processes.
2299 unset(
2300 $memParams['contact_id'],
2301 $memParams['membership_type_id'],
2302 $memParams['membership_type'],
2303 $memParams['join_date'],
2304 $memParams['start_date'],
2305 $memParams['end_date'],
2306 $memParams['source']
2307 );
2308 //since there is change in status.
2309 $statusChange = array('status_id' => $statusId);
2310 $smarty->append_by_ref('memberParams', $statusChange, TRUE);
2311
2312 //process member record.
2313 civicrm_api('membership', 'create', $memParams);
2314 $updateCount++;
2315 }
2316 }
2317 }
2318 $result['is_error'] = 0;
2319 $result['messages'] = ts('Processed %1 membership records. Updated %2 records.', array(
2320 1 => $processCount,
2321 2 => $updateCount,
2322 ));
2323 return $result;
2324 }
2325
2326 /**
2327 * Returns the membership types for a particular contact
2328 * who has lifetime membership without end date.
2329 *
2330 * @param int $contactID
2331 * @param bool $isTest
2332 * @param bool $onlyLifeTime
2333 *
2334 * @return array
2335 */
2336 public static function getAllContactMembership($contactID, $isTest = FALSE, $onlyLifeTime = FALSE) {
2337 $contactMembershipType = array();
2338 if (!$contactID) {
2339 return $contactMembershipType;
2340 }
2341
2342 $dao = new CRM_Member_DAO_Membership();
2343 $dao->contact_id = $contactID;
2344 $pendingStatusId = array_search('Pending', CRM_Member_PseudoConstant::membershipStatus());
2345 $dao->whereAdd("status_id != $pendingStatusId");
2346
2347 if ($isTest) {
2348 $dao->is_test = $isTest;
2349 }
2350 else {
2351 $dao->whereAdd('is_test IS NULL OR is_test = 0');
2352 }
2353
2354 if ($onlyLifeTime) {
2355 $dao->whereAdd('end_date IS NULL');
2356 }
2357
2358 $dao->find();
2359 while ($dao->fetch()) {
2360 $membership = array();
2361 CRM_Core_DAO::storeValues($dao, $membership);
2362 $contactMembershipType[$dao->membership_type_id] = $membership;
2363 }
2364 return $contactMembershipType;
2365 }
2366
2367 /**
2368 * Record contribution record associated with membership.
2369 *
2370 * @param array $params
2371 * Array of submitted params.
2372 * @param array $ids
2373 * (param in process of being removed - try to use params) array of ids.
2374 *
2375 * @return CRM_Contribute_BAO_Contribution
2376 */
2377 public static function recordMembershipContribution(&$params, $ids = array()) {
2378 $membershipId = $params['membership_id'];
2379 $contributionParams = array();
2380 $config = CRM_Core_Config::singleton();
2381 $contributionParams['currency'] = $config->defaultCurrency;
2382 $contributionParams['receipt_date'] = (CRM_Utils_Array::value('receipt_date', $params)) ? $params['receipt_date'] : 'null';
2383 $contributionParams['source'] = CRM_Utils_Array::value('contribution_source', $params);
2384 $contributionParams['non_deductible_amount'] = 'null';
2385 $contributionParams['payment_processor'] = CRM_Utils_Array::value('payment_processor_id', $params);
2386 $contributionSoftParams = CRM_Utils_Array::value('soft_credit', $params);
2387 $recordContribution = array(
2388 'contact_id',
2389 'fee_amount',
2390 'total_amount',
2391 'receive_date',
2392 'financial_type_id',
2393 'payment_instrument_id',
2394 'trxn_id',
2395 'invoice_id',
2396 'is_test',
2397 'contribution_status_id',
2398 'check_number',
2399 'campaign_id',
2400 'is_pay_later',
2401 'membership_id',
2402 'tax_amount',
2403 'skipLineItem',
2404 'contribution_recur_id',
2405 );
2406 foreach ($recordContribution as $f) {
2407 $contributionParams[$f] = CRM_Utils_Array::value($f, $params);
2408 }
2409
2410 // make entry in batch entity batch table
2411 if (!empty($params['batch_id'])) {
2412 $contributionParams['batch_id'] = $params['batch_id'];
2413 }
2414
2415 if (!empty($params['contribution_contact_id'])) {
2416 // deal with possibility of a different person paying for contribution
2417 $contributionParams['contact_id'] = $params['contribution_contact_id'];
2418 }
2419
2420 if (!empty($params['processPriceSet']) &&
2421 !empty($params['lineItems'])
2422 ) {
2423 $contributionParams['line_item'] = CRM_Utils_Array::value('lineItems', $params, NULL);
2424 }
2425
2426 $contribution = CRM_Contribute_BAO_Contribution::create($contributionParams, $ids);
2427
2428 //CRM-13981, create new soft-credit record as to record payment from different person for this membership
2429 if (!empty($contributionSoftParams)) {
2430 if (!empty($params['batch_id'])) {
2431 foreach ($contributionSoftParams as $contributionSoft) {
2432 $contributionSoft['contribution_id'] = $contribution->id;
2433 $contributionSoft['currency'] = $contribution->currency;
2434 CRM_Contribute_BAO_ContributionSoft::add($contributionSoft);
2435 }
2436 }
2437 else {
2438 $contributionSoftParams['contribution_id'] = $contribution->id;
2439 $contributionSoftParams['currency'] = $contribution->currency;
2440 $contributionSoftParams['amount'] = $contribution->total_amount;
2441 CRM_Contribute_BAO_ContributionSoft::add($contributionSoftParams);
2442 }
2443 }
2444
2445 // store contribution id
2446 $params['contribution_id'] = $contribution->id;
2447
2448 //insert payment record for this membership
2449 if (empty($ids['contribution']) || !empty($params['is_recur'])) {
2450 CRM_Member_BAO_MembershipPayment::create(array(
2451 'membership_id' => $membershipId,
2452 'contribution_id' => $contribution->id,
2453 ));
2454 }
2455 return $contribution;
2456 }
2457
2458 /**
2459 * @todo document me - I seem a bit out of date....
2460 */
2461 public static function _getActTypes() {
2462 $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, FALSE, FALSE, 'name');
2463 self::$_renewalActType = CRM_Utils_Array::key('Membership Renewal', $activityTypes);
2464 self::$_signupActType = CRM_Utils_Array::key('Membership Signup', $activityTypes);
2465 }
2466
2467 /**
2468 * Get all Cancelled Membership(s) for a contact
2469 *
2470 * @param int $contactID
2471 * Contact id.
2472 * @param bool $isTest
2473 * Mode of payment.
2474 *
2475 * @return array
2476 * Array of membership type
2477 */
2478 public static function getContactsCancelledMembership($contactID, $isTest = FALSE) {
2479 if (!$contactID) {
2480 return array();
2481 }
2482 $query = 'SELECT membership_type_id FROM civicrm_membership WHERE contact_id = %1 AND status_id = %2 AND is_test = %3';
2483 $queryParams = array(
2484 1 => array($contactID, 'Integer'),
2485 2 => array(
2486 // CRM-15475
2487 array_search(
2488 'Cancelled',
2489 CRM_Member_PseudoConstant::membershipStatus(
2490 NULL,
2491 " name = 'Cancelled' ",
2492 'name',
2493 FALSE,
2494 TRUE
2495 )
2496 ),
2497 'Integer',
2498 ),
2499 3 => array($isTest, 'Boolean'),
2500 );
2501
2502 $dao = CRM_Core_DAO::executeQuery($query, $queryParams);
2503 $cancelledMembershipIds = array();
2504 while ($dao->fetch()) {
2505 $cancelledMembershipIds[] = $dao->membership_type_id;
2506 }
2507 return $cancelledMembershipIds;
2508 }
2509
2510 }