Personal/drupal-civicrm
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

First commit

Browse source
This commit is contained in:
Theodotos Andreou 2018-01-14 13:10:16 +00:00
commit c6e2478c40
13918 changed files with 2303184 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2531
sites/all/modules/civicrm/CRM/Member/BAO/Membership.php Normal file
View file

File diff suppressed because it is too large Load diff

81
sites/all/modules/civicrm/CRM/Member/BAO/MembershipBlock.php Normal file
View file

@ -0,0 +1,81 @@
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
* $Id$
*
*/
class CRM_Member_BAO_MembershipBlock extends CRM_Member_DAO_MembershipBlock {
/**
* Class constructor.
*/
public function __construct() {
parent::__construct();
}
/**
* Add the membership Blocks.
*
* @param array $params
* Reference array contains the values submitted by the form.
*
*
* @return object
*/
public static function create(&$params) {
$hook = empty($params['id']) ? 'create' : 'edit';
CRM_Utils_Hook::pre($hook, 'MembershipBlock', CRM_Utils_Array::value('id', $params), $params);
$dao = new CRM_Member_DAO_MembershipBlock();
$dao->copyValues($params);
$dao->id = CRM_Utils_Array::value('id', $params);
$dao->save();
CRM_Utils_Hook::post($hook, 'MembershipBlock', $dao->id, $dao);
return $dao;
}
/**
* Delete membership Blocks.
*
* @param int $id
*
* @return bool
*/
public static function del($id) {
$dao = new CRM_Member_DAO_MembershipBlock();
$dao->id = $id;
$result = FALSE;
if ($dao->find(TRUE)) {
$dao->delete();
$result = TRUE;
}
return $result;
}
}

82
sites/all/modules/civicrm/CRM/Member/BAO/MembershipLog.php Normal file
View file

@ -0,0 +1,82 @@
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
* $Id$
*
*/
class CRM_Member_BAO_MembershipLog extends CRM_Member_DAO_MembershipLog {
/**
* Add the membership log record.
*
* @param array $params
* Properties of the log item.
*
* @return CRM_Member_DAO_MembershipLog|CRM_Core_Error
*/
public static function add($params) {
$membershipLog = new CRM_Member_DAO_MembershipLog();
$membershipLog->copyValues($params);
$membershipLog->save();
$membershipLog->free();
return $membershipLog;
}
/**
* Delete membership log record.
*
* @param int $membershipID
*
* @return mixed
*/
public static function del($membershipID) {
$membershipLog = new CRM_Member_DAO_MembershipLog();
$membershipLog->membership_id = $membershipID;
return $membershipLog->delete();
}
/**
* Reset the modified ID to NULL for log items by the given contact ID.
*
* @param int $contactID
*/
public static function resetModifiedID($contactID) {
$query = "
UPDATE civicrm_membership_log
SET modified_id = null
WHERE modified_id = %1";
$params = array(1 => array($contactID, 'Integer'));
CRM_Core_DAO::executeQuery($query, $params);
}
}

116
sites/all/modules/civicrm/CRM/Member/BAO/MembershipPayment.php Normal file
View file

@ -0,0 +1,116 @@
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
* $Id$
*
*/
class CRM_Member_BAO_MembershipPayment extends CRM_Member_DAO_MembershipPayment {
/**
* Class constructor.
*/
public function __construct() {
parent::__construct();
}
/**
* Add the membership Payments.
*
* @param array $params
* Reference array contains the values submitted by the form.
*
*
* @return object
*/
public static function create($params) {
$hook = empty($params['id']) ? 'create' : 'edit';
CRM_Utils_Hook::pre($hook, 'MembershipPayment', CRM_Utils_Array::value('id', $params), $params);
$dao = new CRM_Member_DAO_MembershipPayment();
$dao->copyValues($params);
// We check for membership_id in case we are being called too early in the process. This is
// cludgey but is part of the deprecation process (ie. we are trying to do everything
// from LineItem::create with a view to eventually removing this fn & the table.
if (!civicrm_api3('Membership', 'getcount', array('id' => $params['membership_id']))) {
return $dao;
}
//Fixed for avoiding duplicate entry error when user goes
//back and forward during payment mode is notify
if (!$dao->find(TRUE)) {
$dao->save();
}
CRM_Utils_Hook::post($hook, 'MembershipPayment', $dao->id, $dao);
// CRM-14197 we are in the process on phasing out membershipPayment in favour of storing both contribution_id & entity_id (membership_id) on the line items
// table. However, at this stage we have both - there is still quite a bit of refactoring to do to set the line_iten entity_id right the first time
// however, we can assume at this stage that any contribution id will have only one line item with that membership type in the line item table
// OR the caller will have taken responsibility for updating the line items themselves so we will update using SQL here
if (!isset($params['membership_type_id'])) {
$membership_type_id = civicrm_api3('membership', 'getvalue', array(
'id' => $dao->membership_id,
'return' => 'membership_type_id',
));
}
else {
$membership_type_id = $params['membership_type_id'];
}
$sql = "UPDATE civicrm_line_item li
LEFT JOIN civicrm_price_field_value pv ON pv.id = li.price_field_value_id
SET entity_table = 'civicrm_membership', entity_id = %1
WHERE pv.membership_type_id = %2
AND contribution_id = %3";
CRM_Core_DAO::executeQuery($sql, array(
1 => array($dao->membership_id, 'Integer'),
2 => array($membership_type_id, 'Integer'),
3 => array($dao->contribution_id, 'Integer'),
));
return $dao;
}
/**
* Delete membership Payments.
*
* @param int $id
*
* @return bool
*/
public static function del($id) {
$dao = new CRM_Member_DAO_MembershipPayment();
$dao->id = $id;
$result = FALSE;
if ($dao->find(TRUE)) {
$dao->delete();
$result = TRUE;
}
return $result;
}
}

401
sites/all/modules/civicrm/CRM/Member/BAO/MembershipStatus.php Normal file
View file

@ -0,0 +1,401 @@
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
* $Id$
*
*/
class CRM_Member_BAO_MembershipStatus extends CRM_Member_DAO_MembershipStatus {
/**
* Static holder for the default LT.
*/
static $_defaultMembershipStatus = NULL;
/**
* Class constructor.
*/
public function __construct() {
parent::__construct();
}
/**
* Fetch object based on array of properties.
*
* @param array $params
* (reference ) an assoc array of name/value pairs.
* @param array $defaults
* (reference ) an assoc array to hold the flattened values.
*
* @return CRM_Member_BAO_MembershipStatus
*/
public static function retrieve(&$params, &$defaults) {
$membershipStatus = new CRM_Member_DAO_MembershipStatus();
$membershipStatus->copyValues($params);
if ($membershipStatus->find(TRUE)) {
CRM_Core_DAO::storeValues($membershipStatus, $defaults);
return $membershipStatus;
}
return NULL;
}
/**
* Update the is_active flag in the db.
*
* @param int $id
* Id of the database record.
* @param bool $is_active
* Value we want to set the is_active field.
*
* @return Object
* DAO object on success, null otherwise
*/
public static function setIsActive($id, $is_active) {
return CRM_Core_DAO::setFieldValue('CRM_Member_DAO_MembershipStatus', $id, 'is_active', $is_active);
}
/**
* Takes an associative array and creates a membership Status object.
* See http://wiki.civicrm.org/confluence/display/CRM/Database+layer
*
* @param array $params
* (reference ) an assoc array of name/value pairs.
*
* @throws Exception
* @return CRM_Member_BAO_MembershipStatus
*/
public static function create($params) {
$ids = array();
if (!empty($params['id'])) {
$ids['membershipStatus'] = $params['id'];
}
else {
//don't allow duplicate names - if id not set
$status = new CRM_Member_DAO_MembershipStatus();
$status->name = $params['name'];
if ($status->find(TRUE)) {
throw new Exception('A membership status with this name already exists.');
}
}
$membershipStatusBAO = CRM_Member_BAO_MembershipStatus::add($params, $ids);
return $membershipStatusBAO;
}
/**
* Add the membership types.
*
* @param array $params
* Reference array contains the values submitted by the form.
* @param array $ids
* Array contains the id - this param is deprecated.
*
*
* @return object
*/
public static function add(&$params, $ids = array()) {
$id = CRM_Utils_Array::value('id', $params, CRM_Utils_Array::value('membershipStatus', $ids));
if (!$id) {
CRM_Core_DAO::setCreateDefaults($params, self::getDefaults());
//copy name to label when not passed.
if (empty($params['label']) && !empty($params['name'])) {
$params['label'] = $params['name'];
}
if (empty($params['name']) && !empty($params['label'])) {
$params['name'] = $params['label'];
}
}
// set all other defaults to false.
if (!empty($params['is_default'])) {
$query = "UPDATE civicrm_membership_status SET is_default = 0";
CRM_Core_DAO::executeQuery($query,
CRM_Core_DAO::$_nullArray
);
}
// action is taken depending upon the mode
$membershipStatus = new CRM_Member_DAO_MembershipStatus();
$membershipStatus->copyValues($params);
$membershipStatus->id = $id;
$membershipStatus->save();
CRM_Member_PseudoConstant::flush('membershipStatus');
return $membershipStatus;
}
/**
* Get defaults for new entity.
* @return array
*/
public static function getDefaults() {
return array(
'is_active' => FALSE,
'is_current_member' => FALSE,
'is_admin' => FALSE,
'is_default' => FALSE,
);
}
/**
* Get membership status.
*
* @param int $membershipStatusId
*
* @return array
*/
public static function getMembershipStatus($membershipStatusId) {
$statusDetails = array();
$membershipStatus = new CRM_Member_DAO_MembershipStatus();
$membershipStatus->id = $membershipStatusId;
if ($membershipStatus->find(TRUE)) {
CRM_Core_DAO::storeValues($membershipStatus, $statusDetails);
}
return $statusDetails;
}
/**
* Delete membership Types.
*
* @param int $membershipStatusId
*
* @throws CRM_Core_Exception
*/
public static function del($membershipStatusId) {
//check dependencies
//checking if membership status is present in some other table
$check = FALSE;
$dependency = array('Membership', 'MembershipLog');
foreach ($dependency as $name) {
$baoString = 'CRM_Member_BAO_' . $name;
$dao = new $baoString();
$dao->status_id = $membershipStatusId;
if ($dao->find(TRUE)) {
throw new CRM_Core_Exception(ts('This membership status cannot be deleted as memberships exist with this status'));
}
}
CRM_Utils_Weight::delWeight('CRM_Member_DAO_MembershipStatus', $membershipStatusId);
//delete from membership Type table
$membershipStatus = new CRM_Member_DAO_MembershipStatus();
$membershipStatus->id = $membershipStatusId;
if (!$membershipStatus->find()) {
throw new CRM_Core_Exception(ts('Cannot delete membership status ' . $membershipStatusId));
}
$membershipStatus->delete();
CRM_Member_PseudoConstant::flush('membershipStatus');
$membershipStatus->free();
}
/**
* Find the membership status based on start date, end date, join date & status date.
*
* @param string $startDate
* Start date of the member whose membership status is to be calculated.
* @param string $endDate
* End date of the member whose membership status is to be calculated.
* @param string $joinDate
* Join date of the member whose membership status is to be calculated.
* @param \date|string $statusDate status date of the member whose membership status is to be calculated.
* @param bool $excludeIsAdmin the statuses those having is_admin = 1.
* Exclude the statuses those having is_admin = 1.
* @param int $membershipTypeID
* @param array $membership
* Membership params as available to calling function - passed to the hook.
*
* @return array
*/
public static function getMembershipStatusByDate(
$startDate, $endDate, $joinDate,
$statusDate = 'today', $excludeIsAdmin = FALSE, $membershipTypeID, $membership = array()
) {
$membershipDetails = array();
if (!$statusDate || $statusDate == 'today') {
$statusDate = getdate();
$statusDate = date('Ymd',
mktime($statusDate['hours'],
$statusDate['minutes'],
$statusDate['seconds'],
$statusDate['mon'],
$statusDate['mday'],
$statusDate['year']
)
);
}
else {
$statusDate = CRM_Utils_Date::customFormat($statusDate, '%Y%m%d');
}
$dates = array('start', 'end', 'join');
$events = array('start', 'end');
foreach ($dates as $dat) {
if (${$dat . 'Date'} && ${$dat . 'Date'} != "null") {
${$dat . 'Date'} = CRM_Utils_Date::customFormat(${$dat . 'Date'}, '%Y%m%d');
${$dat . 'Year'} = substr(${$dat . 'Date'}, 0, 4);
${$dat . 'Month'} = substr(${$dat . 'Date'}, 4, 2);
${$dat . 'Day'} = substr(${$dat . 'Date'}, 6, 2);
}
else {
${$dat . 'Date'} = '';
}
}
//fix for CRM-3570, if we have statuses with is_admin=1,
//exclude these statuses from calculatation during import.
$where = "is_active = 1";
if ($excludeIsAdmin) {
$where .= " AND is_admin != 1";
}
$query = "
SELECT *
FROM civicrm_membership_status
WHERE {$where}
ORDER BY weight ASC";
$membershipStatus = CRM_Core_DAO::executeQuery($query);
$hour = $minute = $second = 0;
while ($membershipStatus->fetch()) {
$startEvent = NULL;
$endEvent = NULL;
foreach ($events as $eve) {
foreach ($dates as $dat) {
// calculate start-event/date and end-event/date
if (($membershipStatus->{$eve . '_event'} == $dat . '_date') &&
${$dat . 'Date'}
) {
if ($membershipStatus->{$eve . '_event_adjust_unit'} &&
$membershipStatus->{$eve . '_event_adjust_interval'}
) {
// add in months
if ($membershipStatus->{$eve . '_event_adjust_unit'} == 'month') {
${$eve . 'Event'} = date('Ymd', mktime($hour, $minute, $second,
${$dat . 'Month'} + $membershipStatus->{$eve . '_event_adjust_interval'},
${$dat . 'Day'},
${$dat . 'Year'}
));
}
// add in days
if ($membershipStatus->{$eve . '_event_adjust_unit'} == 'day') {
${$eve . 'Event'} = date('Ymd', mktime($hour, $minute, $second,
${$dat . 'Month'},
${$dat . 'Day'} + $membershipStatus->{$eve . '_event_adjust_interval'},
${$dat . 'Year'}
));
}
// add in years
if ($membershipStatus->{$eve . '_event_adjust_unit'} == 'year') {
${$eve . 'Event'} = date('Ymd', mktime($hour, $minute, $second,
${$dat . 'Month'},
${$dat . 'Day'},
${$dat . 'Year'} + $membershipStatus->{$eve . '_event_adjust_interval'}
));
}
// if no interval and unit, present
}
else {
${$eve . 'Event'} = ${$dat . 'Date'};
}
}
}
}
// check if statusDate is in the range of start & end events.
if ($startEvent && $endEvent) {
if (($statusDate >= $startEvent) && ($statusDate <= $endEvent)) {
$membershipDetails['id'] = $membershipStatus->id;
$membershipDetails['name'] = $membershipStatus->name;
}
}
elseif ($startEvent) {
if ($statusDate >= $startEvent) {
$membershipDetails['id'] = $membershipStatus->id;
$membershipDetails['name'] = $membershipStatus->name;
}
}
elseif ($endEvent) {
if ($statusDate <= $endEvent) {
$membershipDetails['id'] = $membershipStatus->id;
$membershipDetails['name'] = $membershipStatus->name;
}
}
// returns FIRST status record for which status_date is in range.
if ($membershipDetails) {
break;
}
}
//end fetch
$membershipStatus->free();
//we bundle the arguments into an array as we can't pass 8 variables to the hook otherwise
// the membership array might contain the pre-altered settings so we don't want to merge this
$arguments = array(
'start_date' => $startDate,
'end_date' => $endDate,
'join_date' => $joinDate,
'status_date' => $statusDate,
'exclude_is_admin' => $endDate,
'membership_type_id' => $membershipTypeID,
'start_event' => $startEvent,
'end_event' => $endEvent,
);
CRM_Utils_Hook::alterCalculatedMembershipStatus($membershipDetails, $arguments, $membership);
return $membershipDetails;
}
/**
* Function that return the status ids whose is_current_member is set.
*
* @return array
*/
public static function getMembershipStatusCurrent() {
$statusIds = array();
$membershipStatus = new CRM_Member_DAO_MembershipStatus();
$membershipStatus->is_current_member = 1;
$membershipStatus->find();
$membershipStatus->selectAdd();
$membershipStatus->selectAdd('id');
while ($membershipStatus->fetch()) {
$statusIds[] = $membershipStatus->id;
}
$membershipStatus->free();
return $statusIds;
}
}

831
sites/all/modules/civicrm/CRM/Member/BAO/MembershipType.php Normal file
View file

@ -0,0 +1,831 @@
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
* $Id$
*
*/
class CRM_Member_BAO_MembershipType extends CRM_Member_DAO_MembershipType {
/**
* Static holder for the default Membership Type.
*/
static $_defaultMembershipType = NULL;
static $_membershipTypeInfo = array();
/**
* Class constructor.
*/
public function __construct() {
parent::__construct();
}
/**
* Fetch object based on array of properties.
*
* @param array $params
* (reference ) an assoc array of name/value pairs.
* @param array $defaults
* (reference ) an assoc array to hold the flattened values.
*
* @return CRM_Member_BAO_MembershipType
*/
public static function retrieve(&$params, &$defaults) {
$membershipType = new CRM_Member_DAO_MembershipType();
$membershipType->copyValues($params);
if ($membershipType->find(TRUE)) {
CRM_Core_DAO::storeValues($membershipType, $defaults);
return $membershipType;
}
return NULL;
}
/**
* Update the is_active flag in the db.
*
* @param int $id
* Id of the database record.
* @param bool $is_active
* Value we want to set the is_active field.
*
* @return Object
* DAO object on success, null otherwise
*/
public static function setIsActive($id, $is_active) {
return CRM_Core_DAO::setFieldValue('CRM_Member_DAO_MembershipType', $id, 'is_active', $is_active);
}
/**
* Add the membership types.
*
* @param array $params
* Reference array contains the values submitted by the form.
* @param array $ids
* Array contains the id (deprecated).
*
*
* @return object
*/
public static function add(&$params, $ids = array()) {
$id = CRM_Utils_Array::value('id', $params, CRM_Utils_Array::value('membershipType', $ids));
if (!$id) {
if (!isset($params['is_active'])) {
// do we need this?
$params['is_active'] = FALSE;
}
if (!isset($params['domain_id'])) {
$params['domain_id'] = CRM_Core_Config::domainID();
}
}
// action is taken depending upon the mode
$membershipType = new CRM_Member_DAO_MembershipType();
$membershipType->copyValues($params);
$membershipType->id = $id;
// $previousID is the old organization id for membership type i.e 'member_of_contact_id'. This is used when an organization is changed.
$previousID = NULL;
if ($id) {
$previousID = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipType', $id, 'member_of_contact_id');
}
$membershipType->save();
if ($id) {
// on update we may need to retrieve some details for the price field function - otherwise we get e-notices on attempts to retrieve
// name etc - the presence of previous id tells us this is an update
$params = array_merge(civicrm_api3('membership_type', 'getsingle', array('id' => $membershipType->id)), $params);
}
self::createMembershipPriceField($params, $previousID, $membershipType->id);
// update all price field value for quick config when membership type is set CRM-11718
if ($id) {
self::updateAllPriceFieldValue($id, $params);
}
self::flush();
return $membershipType;
}
/**
* Flush anywhere that membership types might be cached.
*
* @throws \CiviCRM_API3_Exception
*/
public static function flush() {
CRM_Member_PseudoConstant::membershipType(NULL, TRUE);
civicrm_api3('membership', 'getfields', array('cache_clear' => 1, 'fieldname' => 'membership_type_id'));
civicrm_api3('profile', 'getfields', array('action' => 'submit', 'cache_clear' => 1));
}
/**
* Delete membership Types.
*
* @param int $membershipTypeId
*
* @throws CRM_Core_Exception
* @return bool|mixed
*/
public static function del($membershipTypeId) {
// Check dependencies.
$check = FALSE;
$status = array();
$dependency = array(
'Membership' => 'membership_type_id',
'MembershipBlock' => 'membership_type_default',
);
foreach ($dependency as $name => $field) {
$baoString = 'CRM_Member_BAO_' . $name;
$dao = new $baoString();
$dao->$field = $membershipTypeId;
/** @noinspection PhpUndefinedMethodInspection */
if ($dao->find(TRUE)) {
$check = TRUE;
$status[] = $name;
}
}
if ($check) {
$cnt = 1;
$message = ts('This membership type cannot be deleted due to following reason(s):');
if (in_array('Membership', $status)) {
$findMembersURL = CRM_Utils_System::url('civicrm/member/search', 'reset=1');
$deleteURL = CRM_Utils_System::url('civicrm/contact/search/advanced', 'reset=1');
$message .= '<br/>' . ts('%3. There are some contacts who have this membership type assigned to them. Search for contacts with this membership type from <a href=\'%1\'>Find Members</a>. If you are still getting this message after deleting these memberships, there may be contacts in the Trash (deleted) with this membership type. Try using <a href="%2">Advanced Search</a> and checking "Search in Trash".', array(
1 => $findMembersURL,
2 => $deleteURL,
3 => $cnt,
));
$cnt++;
}
if (in_array('MembershipBlock', $status)) {
$deleteURL = CRM_Utils_System::url('civicrm/admin/contribute', 'reset=1');
$message .= ts('%2. This Membership Type is used in an <a href=\'%1\'>Online Contribution page</a>. Uncheck this membership type in the Memberships tab.', array(
1 => $deleteURL,
2 => $cnt,
));
throw new CRM_Core_Exception($message);
}
}
CRM_Utils_Weight::delWeight('CRM_Member_DAO_MembershipType', $membershipTypeId);
//delete from membership Type table
$membershipType = new CRM_Member_DAO_MembershipType();
$membershipType->id = $membershipTypeId;
//fix for membership type delete api
$result = FALSE;
if ($membershipType->find(TRUE)) {
return $membershipType->delete();
}
return $result;
}
/**
* Convert membership type's 'start day' & 'rollover day' to human readable formats.
*
* @param array $membershipType
* An array of membershipType-details.
*/
public static function convertDayFormat(&$membershipType) {
$periodDays = array(
'fixed_period_start_day',
'fixed_period_rollover_day',
);
foreach ($membershipType as $id => $details) {
foreach ($periodDays as $pDay) {
if (!empty($details[$pDay])) {
if ($details[$pDay] > 31) {
$month = substr($details[$pDay], 0, strlen($details[$pDay]) - 2);
$day = substr($details[$pDay], -2);
$monthMap = array(
'1' => 'Jan',
'2' => 'Feb',
'3' => 'Mar',
'4' => 'Apr',
'5' => 'May',
'6' => 'Jun',
'7' => 'Jul',
'8' => 'Aug',
'9' => 'Sep',
'10' => 'Oct',
'11' => 'Nov',
'12' => 'Dec',
);
$membershipType[$id][$pDay] = $monthMap[$month] . ' ' . $day;
}
else {
$membershipType[$id][$pDay] = $details[$pDay];
}
}
}
}
}
/**
* Get membership Types.
*
* @param bool $public
*
* @return array
*/
public static function getMembershipTypes($public = TRUE) {
$membershipTypes = array();
$membershipType = new CRM_Member_DAO_MembershipType();
$membershipType->is_active = 1;
if ($public) {
$membershipType->visibility = 'Public';
}
$membershipType->orderBy(' weight');
$membershipType->find();
while ($membershipType->fetch()) {
$membershipTypes[$membershipType->id] = $membershipType->name;
}
$membershipType->free();
return $membershipTypes;
}
/**
* Get membership Type Details.
*
* @param int $membershipTypeId
*
* @return array|null
*/
public static function getMembershipTypeDetails($membershipTypeId) {
$membershipTypeDetails = array();
$membershipType = new CRM_Member_DAO_MembershipType();
$membershipType->is_active = 1;
$membershipType->id = $membershipTypeId;
if ($membershipType->find(TRUE)) {
CRM_Core_DAO::storeValues($membershipType, $membershipTypeDetails);
$membershipType->free();
return $membershipTypeDetails;
}
else {
return NULL;
}
}
/**
* Calculate start date and end date for new membership.
*
* @param int $membershipTypeId
* Membership type id.
* @param string $joinDate
* Member since ( in mysql date format ).
* @param string $startDate
* Start date ( in mysql date format ).
* @param null $endDate
* @param int $numRenewTerms
* How many membership terms are being added to end date (default is 1).
*
* @return array
* associated array with start date, end date and join date for the membership
*/
public static function getDatesForMembershipType($membershipTypeId, $joinDate = NULL, $startDate = NULL, $endDate = NULL, $numRenewTerms = 1) {
$membershipTypeDetails = self::getMembershipTypeDetails($membershipTypeId);
// Convert all dates to 'Y-m-d' format.
foreach (array(
'joinDate',
'startDate',
'endDate',
) as $dateParam) {
if (!empty($$dateParam)) {
$$dateParam = CRM_Utils_Date::processDate($$dateParam, NULL, FALSE, 'Y-m-d');
}
}
if (!$joinDate) {
$joinDate = date('Y-m-d');
}
$actualStartDate = $joinDate;
if ($startDate) {
$actualStartDate = $startDate;
}
$fixed_period_rollover = FALSE;
if (CRM_Utils_Array::value('period_type', $membershipTypeDetails) == 'rolling') {
if (!$startDate) {
$startDate = $joinDate;
}
$actualStartDate = $startDate;
}
elseif (CRM_Utils_Array::value('period_type', $membershipTypeDetails) == 'fixed') {
// calculate start date
// if !$startDate then use $joinDate
$toDay = explode('-', (empty($startDate) ? $joinDate : $startDate));
$year = $toDay[0];
$month = $toDay[1];
$day = $toDay[2];
if ($membershipTypeDetails['duration_unit'] == 'year') {
//get start fixed day
$startMonth = substr($membershipTypeDetails['fixed_period_start_day'], 0,
strlen($membershipTypeDetails['fixed_period_start_day']) - 2
);
$startDay = substr($membershipTypeDetails['fixed_period_start_day'], -2);
if (date('Y-m-d', mktime(0, 0, 0, $startMonth, $startDay, $year)) <= date('Y-m-d', mktime(0, 0, 0, $month, $day, $year))) {
$actualStartDate = date('Y-m-d', mktime(0, 0, 0, $startMonth, $startDay, $year));
}
else {
$actualStartDate = date('Y-m-d', mktime(0, 0, 0, $startMonth, $startDay, $year - 1));
}
$fixed_period_rollover = self::isDuringFixedAnnualRolloverPeriod($joinDate, $membershipTypeDetails, $year, $actualStartDate);
if (!$startDate) {
$startDate = $actualStartDate;
}
}
elseif ($membershipTypeDetails['duration_unit'] == 'month') {
// Check if we are on or after rollover day of the month - CRM-10585
// If so, set fixed_period_rollover TRUE so we increment end_date month below.
$dateParts = explode('-', $actualStartDate);
if ($dateParts[2] >= $membershipTypeDetails['fixed_period_rollover_day']) {
$fixed_period_rollover = TRUE;
}
// Start date is always first day of actualStartDate month
if (!$startDate) {
$actualStartDate = $startDate = $year . '-' . $month . '-01';
}
}
}
// Calculate end date if it is not passed by user.
if (!$endDate) {
//end date calculation
$date = explode('-', $actualStartDate);
$year = $date[0];
$month = $date[1];
$day = $date[2];
switch ($membershipTypeDetails['duration_unit']) {
case 'year':
$year = $year + ($numRenewTerms * $membershipTypeDetails['duration_interval']);
//extend membership date by duration interval.
if ($fixed_period_rollover) {
$year += 1;
}
break;
case 'month':
$month = $month + ($numRenewTerms * $membershipTypeDetails['duration_interval']);
//duration interval is month
if ($fixed_period_rollover) {
//CRM-10585
$month += 1;
}
break;
case 'day':
$day = $day + ($numRenewTerms * $membershipTypeDetails['duration_interval']);
if ($fixed_period_rollover) {
//Fix Me: Currently we don't allow rollover if
//duration interval is day
}
break;
}
if ($membershipTypeDetails['duration_unit'] == 'lifetime') {
$endDate = NULL;
}
else {
$endDate = date('Y-m-d', mktime(0, 0, 0, $month, $day - 1, $year));
}
}
$membershipDates = array(
'start_date' => CRM_Utils_Date::customFormat($startDate, '%Y%m%d'),
'end_date' => CRM_Utils_Date::customFormat($endDate, '%Y%m%d'),
'join_date' => CRM_Utils_Date::customFormat($joinDate, '%Y%m%d'),
);
return $membershipDates;
}
/**
* Does this membership start between the rollover date and the start of the next period.
* (in which case they will get an extra membership period)
* ie if annual memberships run June - May & the rollover is in May memberships between
* May and June will return TRUE and between June and May will return FALSE
*
* @param string $startDate start date of current membership period
* @param array $membershipTypeDetails
* @param int $year
* @param string $actualStartDate
* @return bool is this in the window where the membership gets an extra part-period added
*/
public static function isDuringFixedAnnualRolloverPeriod($startDate, $membershipTypeDetails, $year, $actualStartDate) {
$rolloverMonth = substr($membershipTypeDetails['fixed_period_rollover_day'], 0,
strlen($membershipTypeDetails['fixed_period_rollover_day']) - 2
);
$rolloverDay = substr($membershipTypeDetails['fixed_period_rollover_day'], -2);
$calculatedRolloverDate = date('Y-m-d', mktime(0, 0, 0, $rolloverMonth, $rolloverDay, $year));
//CRM-7825 -membership date rules are :
//1. Membership should not be start in future.
//2. rollover window should be subset of membership window.
//get the fixed end date here.
$dateParts = explode('-', $actualStartDate);
$endDateOfFirstYearMembershipPeriod = date('Y-m-d', mktime(0, 0, 0,
$dateParts[1],
$dateParts[2] - 1,
$dateParts[0] + 1
));
//we know the month and day of the rollover date but not the year (we're just
//using the start date year at the moment. So if it's after the end
// of the first year of membership then it's the next period & we'll adjust back a year. If it's
// before the start_date then it's too early & we'll adjust forward.
if ($endDateOfFirstYearMembershipPeriod < $calculatedRolloverDate) {
$calculatedRolloverDate = date('Y-m-d', mktime(0, 0, 0, $rolloverMonth, $rolloverDay, $year - 1));
}
if ($calculatedRolloverDate < $actualStartDate) {
$calculatedRolloverDate = date('Y-m-d', mktime(0, 0, 0, $rolloverMonth, $rolloverDay, $year + 1));
}
if ($calculatedRolloverDate <= $startDate) {
return TRUE;
}
return FALSE;
}
/**
* Calculate start date and end date for membership updates.
*
* Note that this function is called by the api for any membership update although it was
* originally written for renewal (which feels a bit fragile but hey....).
*
* @param int $membershipId
* @param $changeToday
* @param int $membershipTypeID
* If provided, overrides the membership type of the $membershipID membership.
* @param int $numRenewTerms
* How many membership terms are being added to end date (default is 1).
*
* CRM-7297 Membership Upsell - Added $membershipTypeID param to facilitate calculations of dates when membership type changes
*
* @return array
* array fo the start date, end date and join date of the membership
*/
public static function getRenewalDatesForMembershipType($membershipId, $changeToday = NULL, $membershipTypeID = NULL, $numRenewTerms = 1) {
$params = array('id' => $membershipId);
$membershipDetails = CRM_Member_BAO_Membership::getValues($params, $values);
$membershipDetails = $membershipDetails[$membershipId];
$statusID = $membershipDetails->status_id;
$membershipDates = array();
if (!empty($membershipDetails->join_date)) {
$membershipDates['join_date'] = CRM_Utils_Date::customFormat($membershipDetails->join_date, '%Y%m%d');
}
$oldPeriodType = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipType',
CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership', $membershipId, 'membership_type_id'), 'period_type');
// CRM-7297 Membership Upsell
if (is_null($membershipTypeID)) {
$membershipTypeDetails = self::getMembershipTypeDetails($membershipDetails->membership_type_id);
}
else {
$membershipTypeDetails = self::getMembershipTypeDetails($membershipTypeID);
}
$statusDetails = CRM_Member_BAO_MembershipStatus::getMembershipStatus($statusID);
if ($statusDetails['is_current_member'] == 1) {
$startDate = $membershipDetails->start_date;
// CRM=7297 Membership Upsell: we need to handle null end_date in case we are switching
// from a lifetime to a different membership type
if (is_null($membershipDetails->end_date)) {
$date = date('Y-m-d');
}
else {
$date = $membershipDetails->end_date;
}
$date = explode('-', $date);
$logStartDate = date('Y-m-d', mktime(0, 0, 0,
(double) $date[1],
(double) ($date[2] + 1),
(double) $date[0]
));
$date = explode('-', $logStartDate);
$year = $date[0];
$month = $date[1];
$day = $date[2];
switch ($membershipTypeDetails['duration_unit']) {
case 'year':
//need to check if the upsell is from rolling to fixed and adjust accordingly
if ($membershipTypeDetails['period_type'] == 'fixed' && $oldPeriodType == 'rolling') {
$month = substr($membershipTypeDetails['fixed_period_start_day'], 0, strlen($membershipTypeDetails['fixed_period_start_day']) - 2);
$day = substr($membershipTypeDetails['fixed_period_start_day'], -2);
$year += 1;
}
else {
$year = $year + ($numRenewTerms * $membershipTypeDetails['duration_interval']);
}
break;
case 'month':
$month = $month + ($numRenewTerms * $membershipTypeDetails['duration_interval']);
break;
case 'day':
$day = $day + ($numRenewTerms * $membershipTypeDetails['duration_interval']);
break;
}
if ($membershipTypeDetails['duration_unit'] == 'lifetime') {
$endDate = NULL;
}
else {
$endDate = date('Y-m-d', mktime(0, 0, 0,
$month,
$day - 1,
$year
));
}
$today = date('Y-m-d');
$membershipDates['today'] = CRM_Utils_Date::customFormat($today, '%Y%m%d');
$membershipDates['start_date'] = CRM_Utils_Date::customFormat($startDate, '%Y%m%d');
$membershipDates['end_date'] = CRM_Utils_Date::customFormat($endDate, '%Y%m%d');
$membershipDates['log_start_date'] = CRM_Utils_Date::customFormat($logStartDate, '%Y%m%d');
}
else {
$today = date('Y-m-d');
if ($changeToday) {
$today = CRM_Utils_Date::processDate($changeToday, NULL, FALSE, 'Y-m-d');
}
// Calculate new start/end dates when join date is today
$renewalDates = self::getDatesForMembershipType($membershipTypeDetails['id'],
$today, NULL, NULL, $numRenewTerms
);
$membershipDates['today'] = CRM_Utils_Date::customFormat($today, '%Y%m%d');
$membershipDates['start_date'] = $renewalDates['start_date'];
$membershipDates['end_date'] = $renewalDates['end_date'];
$membershipDates['log_start_date'] = $renewalDates['start_date'];
// CRM-18503 - set join_date as today in case the membership type is fixed.
if ($membershipTypeDetails['period_type'] == 'fixed' && !isset($membershipDates['join_date'])) {
$membershipDates['join_date'] = $renewalDates['join_date'];
}
}
if (!isset($membershipDates['join_date'])) {
$membershipDates['join_date'] = $membershipDates['start_date'];
}
return $membershipDates;
}
/**
* @deprecated Please use the Membership API
* Retrieve all Membership Types associated with an Organization
*
* @param int $orgID
* Id of Organization.
*
* @return array
* array of the details of membership types
*/
public static function getMembershipTypesByOrg($orgID) {
Civi::log()->warning('Deprecated function getMembershipTypesByOrg, please user membership_type api', array('civi.tag' => 'deprecated'));
$memberTypesSameParentOrg = civicrm_api3('MembershipType', 'get', array(
'member_of_contact_id' => $orgID,
'options' => array(
'limit' => 0,
),
));
return CRM_Utils_Array::value('values', $memberTypesSameParentOrg, array());
}
/**
* Retrieve all Membership Types with Member of Contact id.
*
* @param array $membershipTypes
* array of membership type ids
* @return array
* array of the details of membership types with Member of Contact id
*/
public static function getMemberOfContactByMemTypes($membershipTypes) {
$memTypeOrganizations = array();
if (empty($membershipTypes)) {
return $memTypeOrganizations;
}
$result = CRM_Core_DAO::executeQuery("SELECT id, member_of_contact_id FROM civicrm_membership_type WHERE id IN (" . implode(',', $membershipTypes) . ")");
while ($result->fetch()) {
$memTypeOrganizations[$result->id] = $result->member_of_contact_id;
}
return $memTypeOrganizations;
}
/**
* The function returns all the Organization for all membershipTypes .
*
* @param int $membershipTypeId
*
* @return array
*/
public static function getMembershipTypeOrganization($membershipTypeId = NULL) {
$allMembershipTypes = array();
$membershipType = new CRM_Member_DAO_MembershipType();
if (isset($membershipTypeId)) {
$membershipType->id = $membershipTypeId;
}
$membershipType->find();
while ($membershipType->fetch()) {
$allMembershipTypes[$membershipType->id] = $membershipType->member_of_contact_id;
}
return $allMembershipTypes;
}
/**
* Function to retrieve organization and associated membership
* types
*
* @return array
* arrays of organization and membership types
*
*/
public static function getMembershipTypeInfo() {
if (!self::$_membershipTypeInfo) {
$orgs = $types = array();
$query = 'SELECT memType.id, memType.name, memType.member_of_contact_id, c.sort_name
FROM civicrm_membership_type memType INNER JOIN civicrm_contact c ON c.id = memType.member_of_contact_id
WHERE memType.is_active = 1 ';
$dao = CRM_Core_DAO::executeQuery($query);
while ($dao->fetch()) {
$orgs[$dao->member_of_contact_id] = $dao->sort_name;
$types[$dao->member_of_contact_id][$dao->id] = $dao->name;
}
self::$_membershipTypeInfo = array($orgs, $types);
}
return self::$_membershipTypeInfo;
}
/**
* @param array $params
* @param int $previousID
* @param int $membershipTypeId
*/
public static function createMembershipPriceField($params, $previousID, $membershipTypeId) {
$priceSetId = CRM_Core_DAO::getFieldValue('CRM_Price_DAO_PriceSet', 'default_membership_type_amount', 'id', 'name');
if (!empty($params['member_of_contact_id'])) {
$fieldName = $params['member_of_contact_id'];
}
else {
$fieldName = $previousID;
}
$fieldLabel = 'Membership Amount';
$optionsIds = NULL;
$fieldParams = array(
'price_set_id ' => $priceSetId,
'name' => $fieldName,
);
$results = array();
CRM_Price_BAO_PriceField::retrieve($fieldParams, $results);
if (empty($results)) {
$fieldParams = array();
$fieldParams['label'] = $fieldLabel;
$fieldParams['name'] = $fieldName;
$fieldParams['price_set_id'] = $priceSetId;
$fieldParams['html_type'] = 'Radio';
$fieldParams['is_display_amounts'] = $fieldParams['is_required'] = 0;
$fieldParams['weight'] = $fieldParams['option_weight'][1] = 1;
$fieldParams['option_label'][1] = $params['name'];
$fieldParams['option_description'][1] = CRM_Utils_Array::value('description', $params);
$fieldParams['membership_type_id'][1] = $membershipTypeId;
$fieldParams['option_amount'][1] = empty($params['minimum_fee']) ? 0 : $params['minimum_fee'];
$fieldParams['financial_type_id'] = CRM_Utils_Array::value('financial_type_id', $params);
if ($previousID) {
CRM_Member_Form_MembershipType::checkPreviousPriceField($previousID, $priceSetId, $membershipTypeId, $optionsIds);
$fieldParams['option_id'] = CRM_Utils_Array::value('option_id', $optionsIds);
}
CRM_Price_BAO_PriceField::create($fieldParams);
}
else {
$fieldID = $results['id'];
$fieldValueParams = array(
'price_field_id' => $fieldID,
'membership_type_id' => $membershipTypeId,
);
$results = array();
CRM_Price_BAO_PriceFieldValue::retrieve($fieldValueParams, $results);
if (!empty($results)) {
$results['label'] = $results['name'] = $params['name'];
$results['amount'] = empty($params['minimum_fee']) ? 0 : $params['minimum_fee'];
$optionsIds['id'] = $results['id'];
}
else {
$results = array(
'price_field_id' => $fieldID,
'name' => $params['name'],
'label' => $params['name'],
'amount' => empty($params['minimum_fee']) ? 0 : $params['minimum_fee'],
'membership_type_id' => $membershipTypeId,
'is_active' => 1,
);
}
if ($previousID) {
CRM_Member_Form_MembershipType::checkPreviousPriceField($previousID, $priceSetId, $membershipTypeId, $optionsIds);
if (!empty($optionsIds['option_id'])) {
$optionsIds['id'] = current(CRM_Utils_Array::value('option_id', $optionsIds));
}
}
$results['financial_type_id'] = CRM_Utils_Array::value('financial_type_id', $params);
$results['description'] = CRM_Utils_Array::value('description', $params);
CRM_Price_BAO_PriceFieldValue::add($results, $optionsIds);
}
}
/**
* This function updates all price field value for quick config
* price set which has membership type
*
* @param int $membershipTypeId membership type id
*
* @param array $params
*/
public static function updateAllPriceFieldValue($membershipTypeId, $params) {
$updateFields = array();
if (!empty($params['minimum_fee'])) {
$amount = $params['minimum_fee'];
}
else {
$amount = 0;
}
$updateValues = array(
2 => array('financial_type_id', 'financial_type_id', 'Integer'),
3 => array('label', 'name', 'String'),
4 => array('amount', 'minimum_fee', 'Float'),
5 => array('description', 'description', 'String'),
);
$queryParams = array(1 => array($membershipTypeId, 'Integer'));
foreach ($updateValues as $key => $value) {
if (array_key_exists($value[1], $params)) {
$updateFields[] = "cpfv." . $value[0] . " = %$key";
if ($value[1] == 'minimum_fee') {
$fieldValue = $amount;
}
else {
$fieldValue = $params[$value[1]];
}
$queryParams[$key] = array($fieldValue, $value[2]);
}
}
$query = "UPDATE `civicrm_price_field_value` cpfv
INNER JOIN civicrm_price_field cpf on cpf.id = cpfv.price_field_id
INNER JOIN civicrm_price_set cps on cps.id = cpf.price_set_id
SET " . implode(' , ', $updateFields) . " WHERE cpfv.membership_type_id = %1
AND cps.is_quick_config = 1 AND cps.name != 'default_membership_type_amount'";
CRM_Core_DAO::executeQuery($query, $queryParams);
}
}

569
sites/all/modules/civicrm/CRM/Member/BAO/Query.php Normal file
View file

@ -0,0 +1,569 @@
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
*/
class CRM_Member_BAO_Query extends CRM_Core_BAO_Query {
/**
* Get available fields.
*
* @return array
*/
public static function &getFields() {
$fields = CRM_Member_BAO_Membership::exportableFields();
return $fields;
}
/**
* If membership are involved, add the specific membership fields.
*
* @param CRM_Contact_BAO_Query $query
*/
public static function select(&$query) {
// if membership mode add membership id
if ($query->_mode & CRM_Contact_BAO_Query::MODE_MEMBER ||
CRM_Contact_BAO_Query::componentPresent($query->_returnProperties, 'membership_')
) {
$query->_select['membership_id'] = "civicrm_membership.id as membership_id";
$query->_element['membership_id'] = 1;
$query->_tables['civicrm_membership'] = 1;
$query->_whereTables['civicrm_membership'] = 1;
//add membership type
if (!empty($query->_returnProperties['membership_type'])) {
$query->_select['membership_type'] = "civicrm_membership_type.name as membership_type";
$query->_element['membership_type'] = 1;
$query->_tables['civicrm_membership_type'] = 1;
$query->_whereTables['civicrm_membership_type'] = 1;
}
//add join date
if (!empty($query->_returnProperties['join_date'])) {
$query->_select['join_date'] = "civicrm_membership.join_date as join_date";
$query->_element['join_date'] = 1;
}
//add source
if (!empty($query->_returnProperties['membership_source'])) {
$query->_select['membership_source'] = "civicrm_membership.source as membership_source";
$query->_element['membership_source'] = 1;
}
//add status
if (!empty($query->_returnProperties['membership_status'])) {
$query->_select['membership_status'] = "civicrm_membership_status.label as membership_status";
$query->_element['membership_status'] = 1;
$query->_tables['civicrm_membership_status'] = 1;
$query->_whereTables['civicrm_membership_status'] = 1;
}
if (!empty($query->_returnProperties['membership_is_current_member'])) {
$query->_select['is_current_member'] = "civicrm_membership_status.is_current_member as is_current_member";
$query->_element['is_current_member'] = 1;
$query->_tables['civicrm_membership_status'] = 1;
$query->_whereTables['civicrm_membership_status'] = 1;
}
if (!empty($query->_returnProperties['membership_status_id'])) {
$query->_select['status_id'] = "civicrm_membership_status.id as status_id";
$query->_element['status_id'] = 1;
$query->_tables['civicrm_membership_status'] = 1;
$query->_whereTables['civicrm_membership_status'] = 1;
}
//add start date / end date
if (!empty($query->_returnProperties['membership_start_date'])) {
$query->_select['membership_start_date'] = "civicrm_membership.start_date as membership_start_date";
$query->_element['membership_start_date'] = 1;
}
if (!empty($query->_returnProperties['membership_end_date'])) {
$query->_select['membership_end_date'] = "civicrm_membership.end_date as membership_end_date";
$query->_element['membership_end_date'] = 1;
}
//add owner_membership_id
if (!empty($query->_returnProperties['owner_membership_id'])) {
$query->_select['owner_membership_id'] = "civicrm_membership.owner_membership_id as owner_membership_id";
$query->_element['owner_membership_id'] = 1;
}
//add max_related
if (!empty($query->_returnProperties['max_related'])) {
$query->_select['max_related'] = "civicrm_membership.max_related as max_related";
$query->_element['max_related'] = 1;
}
//add recur id w/o taking contribution table in join.
if (!empty($query->_returnProperties['membership_recur_id'])) {
$query->_select['membership_recur_id'] = "civicrm_membership.contribution_recur_id as membership_recur_id";
$query->_element['membership_recur_id'] = 1;
}
//add campaign id.
if (!empty($query->_returnProperties['member_campaign_id'])) {
$query->_select['member_campaign_id'] = 'civicrm_membership.campaign_id as member_campaign_id';
$query->_element['member_campaign_id'] = 1;
}
}
}
/**
* Generate where clause.
*
* @param CRM_Contact_BAO_Query $query
*/
public static function where(&$query) {
foreach (array_keys($query->_params) as $id) {
if (empty($query->_params[$id][0])) {
continue;
}
if (substr($query->_params[$id][0], 0, 7) == 'member_' || substr($query->_params[$id][0], 0, 11) == 'membership_') {
if ($query->_mode == CRM_Contact_BAO_QUERY::MODE_CONTACTS) {
$query->_useDistinct = TRUE;
}
self::whereClauseSingle($query->_params[$id], $query);
}
}
}
/**
* Generate where for a single parameter.
*
* @param array $values
* @param CRM_Contact_BAO_Query $query
*/
public static function whereClauseSingle(&$values, &$query) {
list($name, $op, $value, $grouping) = $values;
switch ($name) {
case 'member_join_date_low':
case 'member_join_date_high':
$query->dateQueryBuilder($values,
'civicrm_membership', 'member_join_date', 'join_date',
'Member Since'
);
return;
case 'membership_start_date':
case 'member_start_date_low':
case 'member_start_date_high':
$fldName = str_replace(array('_low', '_high'), '', $name);
$query->dateQueryBuilder($values,
'civicrm_membership', $fldName, 'start_date',
'Start Date'
);
return;
case 'membership_end_date':
case 'member_end_date_low':
case 'member_end_date_high':
$fldName = str_replace(array('_low', '_high'), '', $name);
$query->dateQueryBuilder($values,
'civicrm_membership', $fldName, 'end_date',
'End Date'
);
return;
case 'member_join_date':
$op = '>=';
$date = CRM_Utils_Date::format($value);
if ($date) {
$query->_where[$grouping][] = "civicrm_membership.join_date {$op} {$date}";
$format = CRM_Utils_Date::customFormat(CRM_Utils_Date::format(array_reverse($value), '-'));
$query->_qill[$grouping][] = ts('Member Since %2 %1', array(1 => $format, 2 => $op));
}
return;
case 'member_source':
case 'membership_source':
$strtolower = function_exists('mb_strtolower') ? 'mb_strtolower' : 'strtolower';
$value = $strtolower(CRM_Core_DAO::escapeString(trim($value)));
$query->_where[$grouping][] = "civicrm_membership.source $op '{$value}'";
$query->_qill[$grouping][] = ts('Source %2 %1', array(1 => $value, 2 => $op));
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
// CRM-17011 These 2 variants appear in some smart groups saved at some time prior to 4.6.6.
case 'member_status_id':
case 'member_membership_type_id':
if (is_array($value)) {
$op = 'IN';
$value = array_keys($value);
}
case 'membership_status':
case 'membership_status_id':
case 'membership_type':
case 'membership_type_id':
// CRM-17075 we are specifically handling the possibility we are dealing with the entity reference field
// for membership_type_id here (although status would be handled if converted). The unhandled pathway at the moment
// is from groupContactCache::load and this is a small fix to get the entity reference field to work.
// However, it would seem the larger fix would be to NOT invoke the form formValues for
// the load function. The where clause and the whereTables are saved so they should suffice to generate the query
// to get a contact list. But, better to deal with in 4.8 now...
if (is_string($value) && strpos($value, ',') && $op == '=') {
$value = array('IN' => explode(',', $value));
}
case 'membership_id':
case 'member_id': // CRM-18523 Updated to membership_id but kept member_id case for backwards compatibility
case 'member_campaign_id':
if (strpos($name, 'status') !== FALSE) {
$name = 'status_id';
$qillName = ts('Membership Status');
}
elseif ($name == 'membership_id' || $name == 'member_id') {
$name = 'id';
$qillName = ts('Membership ID');
}
elseif ($name == 'member_campaign_id') {
$name = 'campaign_id';
$qillName = ts('Campaign');
}
else {
$name = 'membership_type_id';
$qillName = ts('Membership Type');
}
$query->_where[$grouping][] = CRM_Contact_BAO_Query::buildClause("civicrm_membership.$name",
$op,
$value,
"Integer"
);
list($op, $value) = CRM_Contact_BAO_Query::buildQillForFieldValue('CRM_Member_DAO_Membership', $name, $value, $op);
$query->_qill[$grouping][] = $qillName . ' ' . $op . ' ' . $value;
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
case 'membership_is_current_member':
// We don't want to include all tests for sql OR CRM-7827
$query->_where[$grouping][] = CRM_Contact_BAO_Query::buildClause("civicrm_membership_status.is_current_member", $op, $value, "Boolean");
$query->_qill[$grouping][] = $value ? ts('Is a current member') : ts('Is a non-current member');
$query->_tables['civicrm_membership_status'] = $query->_whereTables['civicrm_membership_status'] = 1;
return;
case 'member_test':
// We don't want to include all tests for sql OR CRM-7827
if (!$value || $query->getOperator() != 'OR') {
$query->_where[$grouping][] = CRM_Contact_BAO_Query::buildClause("civicrm_membership.is_test", $op, $value, "Boolean");
if ($value) {
$query->_qill[$grouping][] = ts('Membership is a Test');
}
}
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
case 'member_auto_renew':
$op = '=';
$where = $qill = array();
foreach ($value as $val) {
if ($val == 1) {
$where[] = ' civicrm_membership.contribution_recur_id IS NULL';
$qill[] = ts('Membership is NOT Auto-Renew');
}
elseif ($val == 2) {
$where[] = ' civicrm_membership.contribution_recur_id IS NOT NULL AND ' . CRM_Contact_BAO_Query::buildClause(
'ccr.contribution_status_id',
$op,
array_search(
'In Progress',
CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name')
),
'Integer'
);
$qill[] = ts('Membership is Auto-Renew and In Progress');
}
elseif ($val == 3) {
$where[] = ' civicrm_membership.contribution_recur_id IS NOT NULL AND ' .
CRM_Contact_BAO_Query::buildClause(
'ccr.contribution_status_id',
$op,
array_search(
'Failed',
CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name')
),
'Integer'
);
$qill[] = ts('Membership is Auto-Renew and Failed');
}
elseif ($val == 4) {
$where[] = ' civicrm_membership.contribution_recur_id IS NOT NULL AND ' .
CRM_Contact_BAO_Query::buildClause(
'ccr.contribution_status_id',
$op,
array_search(
'Cancelled',
CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name')
),
'Integer'
);
$qill[] = ts('Membership is Auto-Renew and Cancelled');
}
elseif ($val == 5) {
$where[] = ' civicrm_membership.contribution_recur_id IS NOT NULL AND ccr.end_date IS NOT NULL AND ccr.end_date < NOW()';
$qill[] = ts('Membership is Auto-Renew and Ended');
}
elseif ($val == 6) {
$where[] = ' civicrm_membership.contribution_recur_id IS NOT NULL';
$qill[] = ts('Membership is Auto-Renew');
}
}
if (!empty($where)) {
$query->_where[$grouping][] = implode(' OR ', $where);
$query->_qill[$grouping][] = implode(' OR ', $qill);
}
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
case 'member_pay_later':
$query->_where[$grouping][] = CRM_Contact_BAO_Query::buildClause("civicrm_membership.is_pay_later",
$op,
$value,
"Integer"
);
if ($value) {
$query->_qill[$grouping][] = ts("Membership is Pay Later");
}
else {
$query->_qill[$grouping][] = ts("Membership is NOT Pay Later");
}
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
case 'member_is_primary':
if ($value) {
$query->_where[$grouping][] = " civicrm_membership.owner_membership_id IS NULL";
$query->_qill[$grouping][] = ts("Primary Members Only");
}
else {
$query->_where[$grouping][] = " civicrm_membership.owner_membership_id IS NOT NULL";
$query->_qill[$grouping][] = ts("Related Members Only");
}
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
case 'member_is_override':
$query->_where[$grouping][] = CRM_Contact_BAO_Query::buildClause("civicrm_membership.is_override", $op, $value, "Boolean");
$query->_qill[$grouping][] = $value ? ts("Membership Status Is Overriden") : ts("Membership Status Is NOT Overriden");
$query->_tables['civicrm_membership'] = $query->_whereTables['civicrm_membership'] = 1;
return;
}
}
/**
* Generate from clause.
*
* @param string $name
* @param int $mode
* @param string $side
*
* @return string
*/
public static function from($name, $mode, $side) {
$from = NULL;
switch ($name) {
case 'civicrm_membership':
$from = " $side JOIN civicrm_membership ON civicrm_membership.contact_id = contact_a.id ";
$from .= " $side JOIN civicrm_contribution_recur ccr ON ( civicrm_membership.contribution_recur_id = ccr.id )";
break;
case 'civicrm_membership_type':
if ($mode & CRM_Contact_BAO_Query::MODE_MEMBER) {
$from = " INNER JOIN civicrm_membership_type ON civicrm_membership.membership_type_id = civicrm_membership_type.id ";
}
else {
$from = " $side JOIN civicrm_membership_type ON civicrm_membership.membership_type_id = civicrm_membership_type.id ";
}
break;
case 'civicrm_membership_status':
if ($mode & CRM_Contact_BAO_Query::MODE_MEMBER) {
$from = " INNER JOIN civicrm_membership_status ON civicrm_membership.status_id = civicrm_membership_status.id ";
}
else {
$from = " $side JOIN civicrm_membership_status ON civicrm_membership.status_id = civicrm_membership_status.id ";
}
break;
case 'civicrm_membership_payment':
$from = " $side JOIN civicrm_membership_payment ON civicrm_membership_payment.membership_id = civicrm_membership.id ";
break;
}
return $from;
}
/**
* Get default return properties.
*
* @param string $mode
* @param bool $includeCustomFields
*
* @return array|null
*/
public static function defaultReturnProperties(
$mode,
$includeCustomFields = TRUE
) {
$properties = NULL;
if ($mode & CRM_Contact_BAO_Query::MODE_MEMBER) {
$properties = array(
'contact_type' => 1,
'contact_sub_type' => 1,
'sort_name' => 1,
'display_name' => 1,
'membership_type' => 1,
'member_is_test' => 1,
'member_is_pay_later' => 1,
'join_date' => 1,
'membership_start_date' => 1,
'membership_end_date' => 1,
'membership_source' => 1,
'membership_status' => 1,
'membership_id' => 1,
'owner_membership_id' => 1,
'max_related' => 1,
'membership_recur_id' => 1,
'member_campaign_id' => 1,
'member_is_override' => 1,
'member_auto_renew' => 1,
);
if ($includeCustomFields) {
// also get all the custom membership properties
$fields = CRM_Core_BAO_CustomField::getFieldsForImport('Membership');
if (!empty($fields)) {
foreach ($fields as $name => $dontCare) {
$properties[$name] = 1;
}
}
}
}
return $properties;
}
/**
* Build the search form.
*
* @param CRM_Core_Form $form
*/
public static function buildSearchForm(&$form) {
$membershipStatus = CRM_Member_PseudoConstant::membershipStatus(NULL, NULL, 'label', FALSE, FALSE);
$form->add('select', 'membership_status_id', ts('Membership Status'), $membershipStatus, FALSE, array(
'id' => 'membership_status_id',
'multiple' => 'multiple',
'class' => 'crm-select2',
));
$form->addEntityRef('membership_type_id', ts('Membership Type'), array(
'entity' => 'MembershipType',
'multiple' => TRUE,
'placeholder' => ts('- any -'),
'select' => array('minimumInputLength' => 0),
));
$form->addElement('text', 'member_source', ts('Source'));
$form->add('number', 'membership_id', ts('Membership ID'), array('class' => 'four', 'min' => 1));
CRM_Core_Form_Date::buildDateRange($form, 'member_join_date', 1, '_low', '_high', ts('From'), FALSE);
$form->addElement('hidden', 'member_join_date_range_error');
CRM_Core_Form_Date::buildDateRange($form, 'member_start_date', 1, '_low', '_high', ts('From'), FALSE);
$form->addElement('hidden', 'member_start_date_range_error');
CRM_Core_Form_Date::buildDateRange($form, 'member_end_date', 1, '_low', '_high', ts('From'), FALSE);
$form->addElement('hidden', 'member_end_date_range_error');
$form->addFormRule(array('CRM_Member_BAO_Query', 'formRule'), $form);
$form->addYesNo('membership_is_current_member', ts('Current Member?'), TRUE);
$form->addYesNo('member_is_primary', ts('Primary Member?'), TRUE);
$form->addYesNo('member_pay_later', ts('Pay Later?'), TRUE);
$form->add('select', 'member_auto_renew',
ts('Auto-Renew Subscription Status?'),
array(
'1' => ts('- None -'),
'2' => ts('In Progress'),
'3' => ts('Failed'),
'4' => ts('Cancelled'),
'5' => ts('Ended'),
'6' => ts('Any'),
),
FALSE, array('class' => 'crm-select2', 'multiple' => 'multiple', 'placeholder' => ts('- any -'))
);
$form->addYesNo('member_test', ts('Membership is a Test?'), TRUE);
$form->addYesNo('member_is_override', ts('Membership Status Is Overriden?'), TRUE);
self::addCustomFormFields($form, array('Membership'));
CRM_Campaign_BAO_Campaign::addCampaignInComponentSearch($form, 'member_campaign_id');
$form->assign('validCiviMember', TRUE);
$form->setDefaults(array('member_test' => 0));
}
/**
* Add membership table.
*
* @param array $tables
*/
public static function tableNames(&$tables) {
if (!empty($tables['civicrm_membership_log']) || !empty($tables['civicrm_membership_status']) || CRM_Utils_Array::value('civicrm_membership_type', $tables)) {
$tables = array_merge(array('civicrm_membership' => 1), $tables);
}
}
/**
* Custom form rules.
*
* @param array $fields
* @param array $files
* @param CRM_Core_Form $form
*
* @return bool|array
*/
public static function formRule($fields, $files, $form) {
$errors = array();
if ((empty($fields['member_join_date_low']) || empty($fields['member_join_date_high'])) && (empty($fields['member_start_date_low']) || empty($fields['member_start_date_high'])) && (empty($fields['member_end_date_low']) || empty($fields['member_end_date_high']))) {
return TRUE;
}
CRM_Utils_Rule::validDateRange($fields, 'member_join_date', $errors, ts('Member Since'));
CRM_Utils_Rule::validDateRange($fields, 'member_start_date', $errors, ts('Start Date'));
CRM_Utils_Rule::validDateRange($fields, 'member_end_date', $errors, ts('End Date'));
return empty($errors) ? TRUE : $errors;
}
}