CRM/Pledge/BAO/Pledge.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.5                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2014                                |
   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-2014
  32  * $Id$
  33  *
  34  */
  35 class CRM_Pledge_BAO_Pledge extends CRM_Pledge_DAO_Pledge {
  36
  37   /**
  38    * static field for all the pledge information that we can potentially export
  39    *
  40    * @var array
  41    * @static
  42    */
  43   static $_exportableFields = NULL;
  44
  45   /**
  46    * class constructor
  47    */
  48   function __construct() {
  49     parent::__construct();
  50   }
  51
  52   /**
  53    * Takes a bunch of params that are needed to match certain criteria and
  54    * retrieves the relevant objects. Typically the valid params are only
  55    * pledge id. We'll tweak this function to be more full featured over a period
  56    * of time. This is the inverse function of create. It also stores all the retrieved
  57    * values in the default array
  58    *
  59    * @param array $params   (reference ) an assoc array of name/value pairs
  60    * @param array $defaults (reference ) an assoc array to hold the flattened values
  61    *
  62    * @return object CRM_Pledge_BAO_Pledge object
  63    * @access public
  64    * @static
  65    */
  66   static function retrieve(&$params, &$defaults) {
  67     $pledge = new CRM_Pledge_DAO_Pledge();
  68     $pledge->copyValues($params);
  69     if ($pledge->find(TRUE)) {
  70       CRM_Core_DAO::storeValues($pledge, $defaults);
  71       return $pledge;
  72     }
  73     return NULL;
  74   }
  75
  76   /**
  77    * function to add pledge
  78    *
  79    * @param array $params reference array contains the values submitted by the form
  80    *
  81    * @access public
  82    * @static
  83    *
  84    * @return object
  85    */
  86   static function add(&$params) {
  87     if (!empty($params['id'])) {
  88       CRM_Utils_Hook::pre('edit', 'Pledge', $params['id'], $params);
  89     }
  90     else {
  91       CRM_Utils_Hook::pre('create', 'Pledge', NULL, $params);
  92     }
  93
  94     $pledge = new CRM_Pledge_DAO_Pledge();
  95
  96     // if pledge is complete update end date as current date
  97     if ($pledge->status_id == 1) {
  98       $pledge->end_date = date('Ymd');
  99     }
 100
 101     $pledge->copyValues($params);
 102
 103     // set currency for CRM-1496
 104     if (!isset($pledge->currency)) {
 105       $config = CRM_Core_Config::singleton();
 106       $pledge->currency = $config->defaultCurrency;
 107     }
 108
 109     $result = $pledge->save();
 110
 111     if (!empty($params['id'])) {
 112       CRM_Utils_Hook::post('edit', 'Pledge', $pledge->id, $pledge);
 113     }
 114     else {
 115       CRM_Utils_Hook::post('create', 'Pledge', $pledge->id, $pledge);
 116     }
 117
 118     return $result;
 119   }
 120
 121   /**
 122    * Given the list of params in the params array, fetch the object
 123    * and store the values in the values array
 124    *
 125    * @param array $params input parameters to find object
 126    * @param array $values output values of the object
 127    * @param array $returnProperties  if you want to return specific fields
 128    *
 129    * @return array associated array of field values
 130    * @access public
 131    * @static
 132    */
 133   static function &getValues(&$params, &$values, $returnProperties = NULL) {
 134     if (empty($params)) {
 135       return NULL;
 136     }
 137     CRM_Core_DAO::commonRetrieve('CRM_Pledge_BAO_Pledge', $params, $values, $returnProperties);
 138     return $values;
 139   }
 140
 141   /**
 142    * takes an associative array and creates a pledge object
 143    *
 144    * @param array $params (reference ) an assoc array of name/value pairs
 145    *
 146    * @return object CRM_Pledge_BAO_Pledge object
 147    * @access public
 148    * @static
 149    */
 150   static function &create(&$params) {
 151     //FIXME: a cludgy hack to fix the dates to MySQL format
 152     $dateFields = array('start_date', 'create_date', 'acknowledge_date', 'modified_date', 'cancel_date', 'end_date');
 153     foreach ($dateFields as $df) {
 154       if (isset($params[$df])) {
 155         $params[$df] = CRM_Utils_Date::isoToMysql($params[$df]);
 156       }
 157     }
 158
 159     $transaction = new CRM_Core_Transaction();
 160
 161     $paymentParams = array();
 162     $paymentParams['status_id'] = CRM_Utils_Array::value('status_id', $params);
 163     if (!empty($params['installment_amount'])) {
 164       $params['amount'] = $params['installment_amount'] * $params['installments'];
 165     }
 166
 167     //get All Payments status types.
 168     $paymentStatusTypes = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 169
 170     //update the pledge status only if it does NOT come from form
 171     if (!isset($params['pledge_status_id'])) {
 172       if (isset($params['contribution_id'])) {
 173         if ($params['installments'] > 1) {
 174           $params['status_id'] = array_search('In Progress', $paymentStatusTypes);
 175         }
 176       }
 177       else {
 178         if (!empty($params['id'])) {
 179           $params['status_id'] = CRM_Pledge_BAO_PledgePayment::calculatePledgeStatus($params['id']);
 180         }
 181         else {
 182           $params['status_id'] = array_search('Pending', $paymentStatusTypes);
 183         }
 184       }
 185     }
 186
 187     $pledge = self::add($params);
 188     if (is_a($pledge, 'CRM_Core_Error')) {
 189       $pledge->rollback();
 190       return $pledge;
 191     }
 192
 193     //handle custom data.
 194     if (!empty($params['custom']) &&
 195       is_array($params['custom'])
 196     ) {
 197       CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_pledge', $pledge->id);
 198     }
 199
 200     // skip payment stuff inedit mode
 201     if (!isset($params['id']) || !empty($params['is_pledge_pending'])) {
 202
 203
 204       //if pledge is pending delete all payments and recreate.
 205       if (!empty($params['is_pledge_pending'])) {
 206         CRM_Pledge_BAO_PledgePayment::deletePayments($pledge->id);
 207       }
 208
 209       //building payment params
 210       $paymentParams['pledge_id'] = $pledge->id;
 211       $paymentKeys = array(
 212         'amount', 'installments', 'scheduled_date', 'frequency_unit', 'currency',
 213         'frequency_day', 'frequency_interval', 'contribution_id', 'installment_amount', 'actual_amount',
 214       );
 215       foreach ($paymentKeys as $key) {
 216         $paymentParams[$key] = CRM_Utils_Array::value($key, $params, NULL);
 217       }
 218       CRM_Pledge_BAO_PledgePayment::create($paymentParams);
 219     }
 220
 221     $transaction->commit();
 222
 223     $url = CRM_Utils_System::url('civicrm/contact/view/pledge',
 224       "action=view&reset=1&id={$pledge->id}&cid={$pledge->contact_id}&context=home"
 225     );
 226
 227     $recentOther = array();
 228     if (CRM_Core_Permission::checkActionPermission('CiviPledge', CRM_Core_Action::UPDATE)) {
 229       $recentOther['editUrl'] = CRM_Utils_System::url('civicrm/contact/view/pledge',
 230         "action=update&reset=1&id={$pledge->id}&cid={$pledge->contact_id}&context=home"
 231       );
 232     }
 233     if (CRM_Core_Permission::checkActionPermission('CiviPledge', CRM_Core_Action::DELETE)) {
 234       $recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/contact/view/pledge',
 235         "action=delete&reset=1&id={$pledge->id}&cid={$pledge->contact_id}&context=home"
 236       );
 237     }
 238
 239     $contributionTypes = CRM_Contribute_PseudoConstant::financialType();
 240     $title = CRM_Contact_BAO_Contact::displayName($pledge->contact_id) . ' - (' . ts('Pledged') . ' ' . CRM_Utils_Money::format($pledge->amount, $pledge->currency) . ' - ' . CRM_Utils_Array::value($pledge->financial_type_id, $contributionTypes) . ')';
 241
 242     // add the recently created Pledge
 243     CRM_Utils_Recent::add($title,
 244       $url,
 245       $pledge->id,
 246       'Pledge',
 247       $pledge->contact_id,
 248       NULL,
 249       $recentOther
 250     );
 251
 252     return $pledge;
 253   }
 254
 255   /**
 256    * Function to delete the pledge
 257    *
 258    * @param int $id pledge id
 259    *
 260    * @return mixed
 261    * @access public
 262    * @static
 263    *
 264    */
 265   static function deletePledge($id) {
 266     CRM_Utils_Hook::pre('delete', 'Pledge', $id, CRM_Core_DAO::$_nullArray);
 267
 268     $transaction = new CRM_Core_Transaction();
 269
 270     //check for no Completed Payment records with the pledge
 271     $payment = new CRM_Pledge_DAO_PledgePayment();
 272     $payment->pledge_id = $id;
 273     $payment->find();
 274
 275     while ($payment->fetch()) {
 276       //also delete associated contribution.
 277       if ($payment->contribution_id) {
 278         CRM_Contribute_BAO_Contribution::deleteContribution($payment->contribution_id);
 279       }
 280       $payment->delete();
 281     }
 282
 283     $dao     = new CRM_Pledge_DAO_Pledge();
 284     $dao->id = $id;
 285     $results = $dao->delete();
 286
 287     $transaction->commit();
 288
 289     CRM_Utils_Hook::post('delete', 'Pledge', $dao->id, $dao);
 290
 291     // delete the recently created Pledge
 292     $pledgeRecent = array(
 293       'id' => $id,
 294       'type' => 'Pledge',
 295     );
 296     CRM_Utils_Recent::del($pledgeRecent);
 297
 298     return $results;
 299   }
 300
 301   /**
 302    * function to get the amount details date wise.
 303    *
 304    * @param string $status
 305    * @param string $startDate
 306    * @param string $endDate
 307    *
 308    * @return array|null
 309    */
 310   static function getTotalAmountAndCount($status = NULL, $startDate = NULL, $endDate = NULL) {
 311     $where = array();
 312     $select = $from = $queryDate = NULL;
 313     //get all status
 314     $allStatus = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 315     $statusId = array_search($status, $allStatus);
 316
 317     switch ($status) {
 318       case 'Completed':
 319         $statusId = array_search('Cancelled', $allStatus);
 320         $where[] = 'status_id != ' . $statusId;
 321         break;
 322
 323       case 'Cancelled':
 324         $where[] = 'status_id = ' . $statusId;
 325         break;
 326
 327       case 'In Progress':
 328         $where[] = 'status_id = ' . $statusId;
 329         break;
 330
 331       case 'Pending':
 332         $where[] = 'status_id = ' . $statusId;
 333         break;
 334
 335       case 'Overdue':
 336         $where[] = 'status_id = ' . $statusId;
 337         break;
 338     }
 339
 340     if ($startDate) {
 341       $where[] = "create_date >= '" . CRM_Utils_Type::escape($startDate, 'Timestamp') . "'";
 342     }
 343     if ($endDate) {
 344       $where[] = "create_date <= '" . CRM_Utils_Type::escape($endDate, 'Timestamp') . "'";
 345     }
 346
 347     $whereCond = implode(' AND ', $where);
 348
 349     $query = "
 350 SELECT sum( amount ) as pledge_amount, count( id ) as pledge_count, currency
 351 FROM   civicrm_pledge
 352 WHERE  $whereCond AND is_test=0
 353 GROUP BY  currency
 354 ";
 355     $start   = substr($startDate, 0, 8);
 356     $end     = substr($endDate, 0, 8);
 357     $pCount  = 0;
 358     $pamount = array();
 359     $dao     = CRM_Core_DAO::executeQuery($query, CRM_Core_DAO::$_nullArray);
 360     while ($dao->fetch()) {
 361       $pCount += $dao->pledge_count;
 362       $pamount[] = CRM_Utils_Money::format($dao->pledge_amount, $dao->currency);
 363     }
 364
 365     $pledge_amount = array('pledge_amount' => implode(', ', $pamount),
 366       'pledge_count' => $pCount,
 367       'purl' => CRM_Utils_System::url('civicrm/pledge/search',
 368         "reset=1&force=1&pstatus={$statusId}&pstart={$start}&pend={$end}&test=0"
 369       ),
 370     );
 371
 372     $where = array();
 373     $statusId = array_search($status, $allStatus);
 374     switch ($status) {
 375       case 'Completed':
 376         $select    = 'sum( total_amount ) as received_pledge , count( cd.id ) as received_count';
 377         $where[]   = 'cp.status_id = ' . $statusId . ' AND cp.contribution_id = cd.id AND cd.is_test=0';
 378         $queryDate = 'receive_date';
 379         $from      = ' civicrm_contribution cd, civicrm_pledge_payment cp';
 380         break;
 381
 382       case 'Cancelled':
 383         $select    = 'sum( total_amount ) as received_pledge , count( cd.id ) as received_count';
 384         $where[]   = 'cp.status_id = ' . $statusId . ' AND cp.contribution_id = cd.id AND cd.is_test=0';
 385         $queryDate = 'receive_date';
 386         $from      = ' civicrm_contribution cd, civicrm_pledge_payment cp';
 387         break;
 388
 389       case 'Pending':
 390         $select    = 'sum( scheduled_amount )as received_pledge , count( cp.id ) as received_count';
 391         $where[]   = 'cp.status_id = ' . $statusId . ' AND pledge.is_test=0';
 392         $queryDate = 'scheduled_date';
 393         $from      = ' civicrm_pledge_payment cp INNER JOIN civicrm_pledge pledge on cp.pledge_id = pledge.id';
 394         break;
 395
 396       case 'Overdue':
 397         $select    = 'sum( scheduled_amount ) as received_pledge , count( cp.id ) as received_count';
 398         $where[]   = 'cp.status_id = ' . $statusId . ' AND pledge.is_test=0';
 399         $queryDate = 'scheduled_date';
 400         $from      = ' civicrm_pledge_payment cp INNER JOIN civicrm_pledge pledge on cp.pledge_id = pledge.id';
 401         break;
 402     }
 403
 404     if ($startDate) {
 405       $where[] = " $queryDate >= '" . CRM_Utils_Type::escape($startDate, 'Timestamp') . "'";
 406     }
 407     if ($endDate) {
 408       $where[] = " $queryDate <= '" . CRM_Utils_Type::escape($endDate, 'Timestamp') . "'";
 409     }
 410
 411     $whereCond = implode(' AND ', $where);
 412
 413     $query = "
 414  SELECT $select, cp.currency
 415  FROM $from
 416  WHERE  $whereCond
 417  GROUP BY  cp.currency
 418 ";
 419     if ($select) {
 420       // CRM_Core_Error::debug($status . ' start:' . $startDate . '- end:' . $endDate, $query);
 421       $dao    = CRM_Core_DAO::executeQuery($query, CRM_Core_DAO::$_nullArray);
 422       $amount = array();
 423       $count  = 0;
 424
 425       while ($dao->fetch()) {
 426         $count += $dao->received_count;
 427         $amount[] = CRM_Utils_Money::format($dao->received_pledge, $dao->currency);
 428       }
 429
 430       if ($count) {
 431         return array_merge($pledge_amount, array('received_amount' => implode(', ', $amount),
 432             'received_count' => $count,
 433             'url' => CRM_Utils_System::url('civicrm/pledge/search',
 434               "reset=1&force=1&status={$statusId}&start={$start}&end={$end}&test=0"
 435             ),
 436           ));
 437       }
 438     }
 439     else {
 440       return $pledge_amount;
 441     }
 442     return NULL;
 443   }
 444
 445   /**
 446    * Function to get list of pledges In Honor of contact Ids
 447    *
 448    * @param int $honorId In Honor of Contact ID
 449    *
 450    * @return array return the list of pledge fields
 451    *
 452    * @access public
 453    * @static
 454    */
 455   static function getHonorContacts($honorId) {
 456     $params = array();
 457     $honorDAO = new CRM_Contribute_DAO_ContributionSoft();
 458     $honorDAO->contact_id = $honorId;
 459     $honorDAO->find();
 460
 461     //get all status.
 462     while ($honorDAO->fetch()) {
 463       $pledgePaymentDAO = new CRM_Pledge_DAO_PledgePayment();
 464       $pledgePaymentDAO->contribution_id = $honorDAO->contribution_id;
 465       if ($pledgePaymentDAO->find(TRUE)) {
 466         $pledgeDAO = new CRM_Pledge_DAO_Pledge();
 467         $pledgeDAO->id = $pledgePaymentDAO->pledge_id;
 468         if ($pledgeDAO->find(TRUE)) {
 469           $params[$pledgeDAO->id] = array(
 470             'honor_type' => CRM_Core_OptionGroup::getLabel('soft_credit_type', $honorDAO->soft_credit_type_id, 'value'),
 471             'honorId' => $pledgeDAO->contact_id,
 472             'amount' => $pledgeDAO->amount,
 473             'status' => CRM_Contribute_PseudoConstant::contributionStatus($pledgeDAO->status_id),
 474             'create_date' => $pledgeDAO->create_date,
 475             'acknowledge_date' => $pledgeDAO->acknowledge_date,
 476             'type' => CRM_Core_DAO::getFieldValue('CRM_Financial_DAO_FinancialType',
 477               $pledgeDAO->financial_type_id, 'name'
 478             ),
 479             'display_name' => CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact',
 480               $pledgeDAO->contact_id, 'display_name'
 481             ),
 482           );
 483         }
 484       }
 485     }
 486
 487     return $params;
 488   }
 489
 490   /**
 491    * Function to send Acknowledgment and create activity.
 492    *
 493    * @param object $form form object.
 494    * @param array  $params (reference ) an assoc array of name/value pairs.
 495    * @access public
 496    *
 497    * @return void.
 498    */
 499   static function sendAcknowledgment(&$form, $params) {
 500     //handle Acknowledgment.
 501     $allPayments = $payments = array();
 502
 503     //get All Payments status types.
 504     $paymentStatusTypes = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 505     $returnProperties = array('status_id', 'scheduled_amount', 'scheduled_date', 'contribution_id');
 506     //get all paymnets details.
 507     CRM_Core_DAO::commonRetrieveAll('CRM_Pledge_DAO_PledgePayment', 'pledge_id', $params['id'], $allPayments, $returnProperties);
 508
 509     if (!empty($allPayments)) {
 510       foreach ($allPayments as $payID => $values) {
 511         $contributionValue = $contributionStatus = array();
 512         if (isset($values['contribution_id'])) {
 513           $contributionParams = array('id' => $values['contribution_id']);
 514           $returnProperties = array('contribution_status_id', 'receive_date');
 515           CRM_Core_DAO::commonRetrieve('CRM_Contribute_DAO_Contribution',
 516             $contributionParams, $contributionStatus, $returnProperties
 517           );
 518           $contributionValue = array(
 519             'status' => CRM_Utils_Array::value('contribution_status_id', $contributionStatus),
 520             'receive_date' => CRM_Utils_Array::value('receive_date', $contributionStatus),
 521           );
 522         }
 523         $payments[$payID] = array_merge($contributionValue,
 524           array('amount' => CRM_Utils_Array::value('scheduled_amount', $values),
 525             'due_date' => CRM_Utils_Array::value('scheduled_date', $values),
 526           )
 527         );
 528
 529         //get the first valid payment id.
 530         if (!isset($form->paymentId) && ($paymentStatusTypes[$values['status_id']] == 'Pending' ||
 531             $paymentStatusTypes[$values['status_id']] == 'Overdue'
 532           )) {
 533           $form->paymentId = $values['id'];
 534         }
 535       }
 536     }
 537     //end
 538
 539     //assign pledge fields value to template.
 540     $pledgeFields = array(
 541       'create_date', 'total_pledge_amount', 'frequency_interval', 'frequency_unit',
 542       'installments', 'frequency_day', 'scheduled_amount', 'currency',
 543     );
 544     foreach ($pledgeFields as $field) {
 545       if (!empty($params[$field])) {
 546         $form->assign($field, $params[$field]);
 547       }
 548     }
 549
 550     //assign all payments details.
 551     if ($payments) {
 552       $form->assign('payments', $payments);
 553     }
 554
 555     //handle domain token values
 556     $domain = CRM_Core_BAO_Domain::getDomain();
 557     $tokens = array('domain' => array('name', 'phone', 'address', 'email'),
 558       'contact' => CRM_Core_SelectValues::contactTokens(),
 559     );
 560     $domainValues = array();
 561     foreach ($tokens['domain'] as $token) {
 562       $domainValues[$token] = CRM_Utils_Token::getDomainTokenReplacement($token, $domain);
 563     }
 564     $form->assign('domain', $domainValues);
 565
 566     //handle contact token values.
 567     $ids = array($params['contact_id']);
 568     $fields = array_merge(array_keys(CRM_Contact_BAO_Contact::importableFields()),
 569       array('display_name', 'checksum', 'contact_id')
 570     );
 571     foreach ($fields as $key => $val) {
 572       $returnProperties[$val] = TRUE;
 573     }
 574     $details = CRM_Utils_Token::getTokenDetails($ids,
 575       $returnProperties,
 576       TRUE, TRUE, NULL,
 577       $tokens,
 578       get_class($form)
 579     );
 580     $form->assign('contact', $details[0][$params['contact_id']]);
 581
 582     //handle custom data.
 583     if (!empty($params['hidden_custom'])) {
 584       $groupTree    = CRM_Core_BAO_CustomGroup::getTree('Pledge', CRM_Core_DAO::$_nullObject, $params['id']);
 585       $pledgeParams = array(array('pledge_id', '=', $params['id'], 0, 0));
 586       $customGroup  = array();
 587       // retrieve custom data
 588       foreach ($groupTree as $groupID => $group) {
 589         $customFields = $customValues = array();
 590         if ($groupID == 'info') {
 591           continue;
 592         }
 593         foreach ($group['fields'] as $k => $field) {
 594           $field['title'] = $field['label'];
 595           $customFields["custom_{$k}"] = $field;
 596         }
 597
 598         //to build array of customgroup & customfields in it
 599         CRM_Core_BAO_UFGroup::getValues($params['contact_id'], $customFields, $customValues, FALSE, $pledgeParams);
 600         $customGroup[$group['title']] = $customValues;
 601       }
 602
 603       $form->assign('customGroup', $customGroup);
 604     }
 605
 606     //handle acknowledgment email stuff.
 607     list($pledgerDisplayName,
 608       $pledgerEmail
 609     ) = CRM_Contact_BAO_Contact_Location::getEmailDetails($params['contact_id']);
 610
 611     //check for online pledge.
 612     $session = CRM_Core_Session::singleton();
 613     if (!empty($params['receipt_from_email'])) {
 614       $userName = CRM_Utils_Array::value('receipt_from_name', $params);
 615       $userEmail = CRM_Utils_Array::value('receipt_from_email', $params);
 616     }
 617     elseif (!empty($params['from_email_id'])) {
 618       $receiptFrom = $params['from_email_id'];
 619     }
 620     elseif ($userID = $session->get('userID')) {
 621       //check for logged in user.
 622       list($userName, $userEmail) = CRM_Contact_BAO_Contact_Location::getEmailDetails($userID);
 623     }
 624     else {
 625       //set the domain values.
 626       $userName = CRM_Utils_Array::value('name', $domainValues);
 627       $userEmail = CRM_Utils_Array::value('email', $domainValues);
 628     }
 629
 630     if (!isset($receiptFrom)) {
 631       $receiptFrom = "$userName <$userEmail>";
 632     }
 633
 634     list($sent, $subject, $message, $html) = CRM_Core_BAO_MessageTemplate::sendTemplate(
 635       array(
 636         'groupName' => 'msg_tpl_workflow_pledge',
 637         'valueName' => 'pledge_acknowledge',
 638         'contactId' => $params['contact_id'],
 639         'from' => $receiptFrom,
 640         'toName' => $pledgerDisplayName,
 641         'toEmail' => $pledgerEmail,
 642       )
 643     );
 644
 645     //check if activity record exist for this pledge
 646     //Acknowledgment, if exist do not add activity.
 647     $activityType = 'Pledge Acknowledgment';
 648     $activity = new CRM_Activity_DAO_Activity();
 649     $activity->source_record_id = $params['id'];
 650     $activity->activity_type_id = CRM_Core_OptionGroup::getValue('activity_type',
 651       $activityType,
 652       'name'
 653     );
 654     $config = CRM_Core_Config::singleton();
 655
 656     // FIXME: Translate
 657     $details = 'Total Amount ' . CRM_Utils_Money::format($params['total_pledge_amount'], CRM_Utils_Array::value('currency', $params)) . ' To be paid in ' . $params['installments'] . ' installments of ' . CRM_Utils_Money::format($params['scheduled_amount'], CRM_Utils_Array::value('currency', $params)) . ' every ' . $params['frequency_interval'] . ' ' . $params['frequency_unit'] . '(s)';
 658
 659     if (!$activity->find()) {
 660       $activityParams = array(
 661         'subject' => $subject,
 662         'source_contact_id' => $params['contact_id'],
 663         'source_record_id' => $params['id'],
 664         'activity_type_id' => CRM_Core_OptionGroup::getValue('activity_type',
 665           $activityType,
 666           'name'
 667         ),
 668         'activity_date_time' => CRM_Utils_Date::isoToMysql($params['acknowledge_date']),
 669         'is_test' => $params['is_test'],
 670         'status_id' => 2,
 671         'details' => $details,
 672         'campaign_id' => CRM_Utils_Array::value('campaign_id', $params),
 673       );
 674
 675       //lets insert assignee record.
 676       if (!empty($params['contact_id'])) {
 677         $activityParams['assignee_contact_id'] = $params['contact_id'];
 678       }
 679
 680       if (is_a(CRM_Activity_BAO_Activity::create($activityParams), 'CRM_Core_Error')) {
 681         CRM_Core_Error::fatal("Failed creating Activity for acknowledgment");
 682       }
 683     }
 684   }
 685
 686   /**
 687    * combine all the exportable fields from the lower levels object
 688    *
 689    * @return array array of exportable Fields
 690    * @access public
 691    * @static
 692    */
 693   static function &exportableFields() {
 694     if (!self::$_exportableFields) {
 695       if (!self::$_exportableFields) {
 696         self::$_exportableFields = array();
 697       }
 698
 699       $fields = CRM_Pledge_DAO_Pledge::export();
 700
 701       $fields = array_merge($fields, CRM_Pledge_DAO_PledgePayment::export());
 702
 703       //set title to calculated fields
 704       $calculatedFields = array('pledge_total_paid' => array('title' => ts('Total Paid')),
 705         'pledge_balance_amount' => array('title' => ts('Balance Amount')),
 706         'pledge_next_pay_date' => array('title' => ts('Next Payment Date')),
 707         'pledge_next_pay_amount' => array('title' => ts('Next Payment Amount')),
 708         'pledge_payment_paid_amount' => array('title' => ts('Paid Amount')),
 709         'pledge_payment_paid_date' => array('title' => ts('Paid Date')),
 710         'pledge_payment_status' => array('title' => ts('Pledge Payment Status'),
 711           'name' => 'pledge_payment_status',
 712           'data_type' => CRM_Utils_Type::T_STRING,
 713         ),
 714       );
 715
 716
 717       $pledgeFields = array(
 718         'pledge_status' => array('title' => 'Pledge Status',
 719           'name' => 'pledge_status',
 720           'data_type' => CRM_Utils_Type::T_STRING,
 721         ),
 722         'pledge_frequency_unit' => array(
 723           'title' => 'Pledge Frequency Unit',
 724           'name' => 'pledge_frequency_unit',
 725           'data_type' => CRM_Utils_Type::T_ENUM,
 726         ),
 727         'pledge_frequency_interval' => array(
 728           'title' => 'Pledge Frequency Interval',
 729           'name' => 'pledge_frequency_interval',
 730           'data_type' => CRM_Utils_Type::T_INT,
 731         ),
 732         'pledge_contribution_page_id' => array(
 733           'title' => 'Pledge Contribution Page Id',
 734           'name' => 'pledge_contribution_page_id',
 735           'data_type' => CRM_Utils_Type::T_INT,
 736         ),
 737       );
 738
 739       $fields = array_merge($fields, $pledgeFields, $calculatedFields);
 740
 741       // add custom data
 742       $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Pledge'));
 743       self::$_exportableFields = $fields;
 744     }
 745
 746     return self::$_exportableFields;
 747   }
 748
 749   /**
 750    * Function to get pending or in progress pledges
 751    *
 752    * @param int $contactID contact id
 753    *
 754    * @return array associated array of pledge id(s)
 755    * @static
 756    */
 757   static function getContactPledges($contactID) {
 758     $pledgeDetails = array();
 759     $pledgeStatuses = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 760
 761     $status = array();
 762
 763     //get pending and in progress status
 764     foreach (array(
 765       'Pending', 'In Progress', 'Overdue') as $name) {
 766       if ($statusId = array_search($name, $pledgeStatuses)) {
 767         $status[] = $statusId;
 768       }
 769     }
 770     if (empty($status)) {
 771       return $pledgeDetails;
 772     }
 773
 774     $statusClause = " IN (" . implode(',', $status) . ")";
 775
 776     $query = "
 777  SELECT civicrm_pledge.id id
 778  FROM civicrm_pledge
 779  WHERE civicrm_pledge.status_id  {$statusClause}
 780   AND civicrm_pledge.contact_id = %1
 781 ";
 782
 783     $params[1] = array($contactID, 'Integer');
 784     $pledge = CRM_Core_DAO::executeQuery($query, $params);
 785
 786     while ($pledge->fetch()) {
 787       $pledgeDetails[] = $pledge->id;
 788     }
 789
 790     return $pledgeDetails;
 791   }
 792
 793   /**
 794    * Function to get pledge record count for a Contact
 795    *
 796    * @param $contactID
 797    *
 798    * @internal param int $contactId Contact ID
 799    *
 800    * @return int count of pledge records
 801    * @access public
 802    * @static
 803    */
 804   static function getContactPledgeCount($contactID) {
 805     $query = "SELECT count(*) FROM civicrm_pledge WHERE civicrm_pledge.contact_id = {$contactID} AND civicrm_pledge.is_test = 0";
 806     return CRM_Core_DAO::singleValueQuery($query);
 807   }
 808
 809   /**
 810    * @param $params
 811    *
 812    * @return array
 813    */
 814   public static function updatePledgeStatus($params) {
 815
 816     $returnMessages = array();
 817
 818     $sendReminders = CRM_Utils_Array::value('send_reminders', $params, FALSE);
 819
 820     $allStatus = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 821
 822     //unset statues that we never use for pledges
 823     foreach (array(
 824       'Completed', 'Cancelled', 'Failed') as $statusKey) {
 825       if ($key = CRM_Utils_Array::key($statusKey, $allStatus)) {
 826         unset($allStatus[$key]);
 827       }
 828     }
 829
 830     $statusIds = implode(',', array_keys($allStatus));
 831     $updateCnt = 0;
 832
 833     $query = "
 834 SELECT  pledge.contact_id              as contact_id,
 835         pledge.id                      as pledge_id,
 836         pledge.amount                  as amount,
 837         payment.scheduled_date         as scheduled_date,
 838         pledge.create_date             as create_date,
 839         payment.id                     as payment_id,
 840         pledge.currency                as currency,
 841         pledge.contribution_page_id    as contribution_page_id,
 842         payment.reminder_count         as reminder_count,
 843         pledge.max_reminders           as max_reminders,
 844         payment.reminder_date          as reminder_date,
 845         pledge.initial_reminder_day    as initial_reminder_day,
 846         pledge.additional_reminder_day as additional_reminder_day,
 847         pledge.status_id               as pledge_status,
 848         payment.status_id              as payment_status,
 849         pledge.is_test                 as is_test,
 850         pledge.campaign_id             as campaign_id,
 851         SUM(payment.scheduled_amount)  as amount_due,
 852         ( SELECT sum(civicrm_pledge_payment.actual_amount)
 853         FROM civicrm_pledge_payment
 854         WHERE civicrm_pledge_payment.status_id = 1
 855         AND  civicrm_pledge_payment.pledge_id = pledge.id
 856         ) as amount_paid
 857         FROM      civicrm_pledge pledge, civicrm_pledge_payment payment
 858         WHERE     pledge.id = payment.pledge_id
 859         AND     payment.status_id IN ( {$statusIds} ) AND pledge.status_id IN ( {$statusIds} )
 860         GROUP By  payment.id
 861         ";
 862
 863     $dao = CRM_Core_DAO::executeQuery($query);
 864
 865     $now = date('Ymd');
 866     $pledgeDetails = $contactIds = $pledgePayments = $pledgeStatus = array();
 867     while ($dao->fetch()) {
 868       $checksumValue = CRM_Contact_BAO_Contact_Utils::generateChecksum($dao->contact_id);
 869
 870       $pledgeDetails[$dao->payment_id] = array(
 871         'scheduled_date' => $dao->scheduled_date,
 872         'amount_due' => $dao->amount_due,
 873         'amount' => $dao->amount,
 874         'amount_paid' => $dao->amount_paid,
 875         'create_date' => $dao->create_date,
 876         'contact_id' => $dao->contact_id,
 877         'pledge_id' => $dao->pledge_id,
 878         'checksumValue' => $checksumValue,
 879         'contribution_page_id' => $dao->contribution_page_id,
 880         'reminder_count' => $dao->reminder_count,
 881         'max_reminders' => $dao->max_reminders,
 882         'reminder_date' => $dao->reminder_date,
 883         'initial_reminder_day' => $dao->initial_reminder_day,
 884         'additional_reminder_day' => $dao->additional_reminder_day,
 885         'pledge_status' => $dao->pledge_status,
 886         'payment_status' => $dao->payment_status,
 887         'is_test' => $dao->is_test,
 888         'currency' => $dao->currency,
 889         'campaign_id' => $dao->campaign_id,
 890       );
 891
 892       $contactIds[$dao->contact_id] = $dao->contact_id;
 893       $pledgeStatus[$dao->pledge_id] = $dao->pledge_status;
 894
 895       if (CRM_Utils_Date::overdue(CRM_Utils_Date::customFormat($dao->scheduled_date, '%Y%m%d'),
 896           $now
 897         ) && $dao->payment_status != array_search('Overdue', $allStatus)) {
 898         $pledgePayments[$dao->pledge_id][$dao->payment_id] = $dao->payment_id;
 899       }
 900     }
 901
 902     // process the updating script...
 903
 904     foreach ($pledgePayments as $pledgeId => $paymentIds) {
 905       // 1. update the pledge /pledge payment status. returns new status when an update happens
 906       $returnMessages[] = "Checking if status update is needed for Pledge Id: {$pledgeId} (current status is {$allStatus[$pledgeStatus[$pledgeId]]})";
 907
 908       $newStatus = CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($pledgeId, $paymentIds,
 909         array_search('Overdue', $allStatus), NULL, 0, FALSE, TRUE
 910       );
 911       if ($newStatus != $pledgeStatus[$pledgeId]) {
 912         $returnMessages[] = "- status updated to: {$allStatus[$newStatus]}";
 913         $updateCnt += 1;
 914       }
 915     }
 916
 917     if ($sendReminders) {
 918       // retrieve domain tokens
 919       $domain = CRM_Core_BAO_Domain::getDomain();
 920       $tokens = array('domain' => array('name', 'phone', 'address', 'email'),
 921         'contact' => CRM_Core_SelectValues::contactTokens(),
 922       );
 923
 924       $domainValues = array();
 925       foreach ($tokens['domain'] as $token) {
 926         $domainValues[$token] = CRM_Utils_Token::getDomainTokenReplacement($token, $domain);
 927       }
 928
 929       //get the domain email address, since we don't carry w/ object.
 930       $domainValue = CRM_Core_BAO_Domain::getNameAndEmail();
 931       $domainValues['email'] = $domainValue[1];
 932
 933       // retrieve contact tokens
 934
 935       // this function does NOT return Deceased contacts since we don't want to send them email
 936       list($contactDetails) = CRM_Utils_Token::getTokenDetails($contactIds,
 937         NULL,
 938         FALSE, FALSE, NULL,
 939         $tokens, 'CRM_UpdatePledgeRecord'
 940       );
 941
 942       // assign domain values to template
 943       $template = CRM_Core_Smarty::singleton();
 944       $template->assign('domain', $domainValues);
 945
 946       //set receipt from
 947       $receiptFrom = '"' . $domainValues['name'] . '" <' . $domainValues['email'] . '>';
 948
 949       foreach ($pledgeDetails as $paymentId => $details) {
 950         if (array_key_exists($details['contact_id'], $contactDetails)) {
 951           $contactId = $details['contact_id'];
 952           $pledgerName = $contactDetails[$contactId]['display_name'];
 953         }
 954         else {
 955           continue;
 956         }
 957
 958         if (empty($details['reminder_date'])) {
 959           $nextReminderDate = new DateTime($details['scheduled_date']);
 960           $nextReminderDate->modify("-" . $details['initial_reminder_day'] . "day");
 961           $nextReminderDate = $nextReminderDate->format("Ymd");
 962         }
 963         else {
 964           $nextReminderDate = new DateTime($details['reminder_date']);
 965           $nextReminderDate->modify("+" . $details['additional_reminder_day'] . "day");
 966           $nextReminderDate = $nextReminderDate->format("Ymd");
 967         }
 968         if (($details['reminder_count'] < $details['max_reminders'])
 969           && ($nextReminderDate <= $now)
 970         ) {
 971
 972           $toEmail = $doNotEmail = $onHold = NULL;
 973
 974           if (!empty($contactDetails[$contactId]['email'])) {
 975             $toEmail = $contactDetails[$contactId]['email'];
 976           }
 977
 978           if (!empty($contactDetails[$contactId]['do_not_email'])) {
 979             $doNotEmail = $contactDetails[$contactId]['do_not_email'];
 980           }
 981
 982           if (!empty($contactDetails[$contactId]['on_hold'])) {
 983             $onHold = $contactDetails[$contactId]['on_hold'];
 984           }
 985
 986           // 2. send acknowledgement mail
 987           if ($toEmail && !($doNotEmail || $onHold)) {
 988             //assign value to template
 989             $template->assign('amount_paid', $details['amount_paid'] ? $details['amount_paid'] : 0);
 990             $template->assign('contact', $contactDetails[$contactId]);
 991             $template->assign('next_payment', $details['scheduled_date']);
 992             $template->assign('amount_due', $details['amount_due']);
 993             $template->assign('checksumValue', $details['checksumValue']);
 994             $template->assign('contribution_page_id', $details['contribution_page_id']);
 995             $template->assign('pledge_id', $details['pledge_id']);
 996             $template->assign('scheduled_payment_date', $details['scheduled_date']);
 997             $template->assign('amount', $details['amount']);
 998             $template->assign('create_date', $details['create_date']);
 999             $template->assign('currency', $details['currency']);
1000             list($mailSent, $subject, $message, $html) = CRM_Core_BAO_MessageTemplate::sendTemplate(
1001               array(
1002                 'groupName' => 'msg_tpl_workflow_pledge',
1003                 'valueName' => 'pledge_reminder',
1004                 'contactId' => $contactId,
1005                 'from' => $receiptFrom,
1006                 'toName' => $pledgerName,
1007                 'toEmail' => $toEmail,
1008               )
1009             );
1010
1011             // 3. update pledge payment details
1012             if ($mailSent) {
1013               CRM_Pledge_BAO_PledgePayment::updateReminderDetails($paymentId);
1014               $activityType = 'Pledge Reminder';
1015               $activityParams = array(
1016                 'subject' => $subject,
1017                 'source_contact_id' => $contactId,
1018                 'source_record_id' => $paymentId,
1019                 'assignee_contact_id' => $contactId,
1020                 'activity_type_id' => CRM_Core_OptionGroup::getValue('activity_type',
1021                   $activityType,
1022                   'name'
1023                 ),
1024                 'activity_date_time' => CRM_Utils_Date::isoToMysql($now),
1025                 'due_date_time' => CRM_Utils_Date::isoToMysql($details['scheduled_date']),
1026                 'is_test' => $details['is_test'],
1027                 'status_id' => 2,
1028                 'campaign_id' => $details['campaign_id'],
1029               );
1030               if (is_a(civicrm_api('activity', 'create', $activityParams), 'CRM_Core_Error')) {
1031                 $returnMessages[] = "Failed creating Activity for acknowledgment";
1032                 return array('is_error' => 1, 'message' => $returnMessages);
1033               }
1034               $returnMessages[] = "Payment reminder sent to: {$pledgerName} - {$toEmail}";
1035             }
1036           }
1037         }
1038       }
1039       // end foreach on $pledgeDetails
1040     }
1041     // end if ( $sendReminders )
1042     $returnMessages[] = "{$updateCnt} records updated.";
1043
1044     return array('is_error' => 0, 'messages' => implode("\n\r", $returnMessages));
1045   }
1046
1047   /**
1048    * Mark a pledge (and any outstanding payments) as cancelled.
1049    *
1050    * @param int $pledgeID
1051    */
1052   public static function cancel($pledgeID) {
1053     $statuses = array_flip(CRM_Contribute_PseudoConstant::contributionStatus());
1054     $paymentIDs = self::findCancelablePayments($pledgeID);
1055     CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($pledgeID, $paymentIDs, NULL,
1056       $statuses['Cancelled'], 0, FALSE, TRUE
1057     );
1058   }
1059
1060   /**
1061    * Find payments which can be safely canceled.
1062    *
1063    * @param int $pledgeID
1064    * @return array of int (civicrm_pledge_payment.id)
1065    */
1066   public static function findCancelablePayments($pledgeID) {
1067     $statuses = array_flip(CRM_Contribute_PseudoConstant::contributionStatus());
1068
1069     $paymentDAO = new CRM_Pledge_DAO_PledgePayment();
1070     $paymentDAO->pledge_id = $pledgeID;
1071     $paymentDAO->whereAdd(sprintf("status_id IN (%d,%d)",
1072       $statuses['Overdue'],
1073       $statuses['Pending']
1074     ));
1075     $paymentDAO->find();
1076
1077     $paymentIDs = array();
1078     while ($paymentDAO->fetch()) {
1079       $paymentIDs[] = $paymentDAO->id;
1080     }
1081     return $paymentIDs;
1082   }
1083
1084   /**
1085    * Is this pledge free from financial transactions (this is important to know as we allow editing
1086    * when no transactions have taken place - the editing process currently involves deleting all pledge payments & contributions
1087    * & recreating so we want to block that if appropriate
1088    *
1089    * @param integer $pledgeID
1090    * @param integer $pledgeStatusID
1091    * @return bool do financial transactions exist for this pledge?
1092    */
1093    static function pledgeHasFinancialTransactions($pledgeID, $pledgeStatusID) {
1094     if (empty($pledgeStatusID)) {
1095       //why would this happen? If we can see where it does then we can see if we should look it up
1096       //but assuming from form code it CAN be empty
1097       return TRUE;
1098     }
1099     if (self::isTransactedStatus($pledgeStatusID)) {
1100       return TRUE;
1101     }
1102
1103     return civicrm_api3('pledge_payment', 'getcount', array('pledge_id' => $pledgeID, 'status_id' => array('IN' => self::getTransactionalStatus())));
1104     }
1105
1106   /**
1107    * Does this pledge / pledge payment status mean that a financial transaction has taken place?
1108    * @param int $statusID pledge status id
1109    *
1110    * @return bool is it a transactional status?
1111    */
1112   protected static function isTransactedStatus($statusID) {
1113     if (!in_array($statusID, self::getNonTransactionalStatus())) {
1114       return TRUE;
1115     }
1116     return FALSE;
1117   }
1118
1119   /**
1120    * Get array of non transactional statuses
1121    * @return array non transactional status ids
1122    */
1123   protected static function getNonTransactionalStatus() {
1124     $paymentStatus = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
1125     return array_flip(array_intersect($paymentStatus, array('Overdue', 'Pending')));
1126   }
1127
1128   /**
1129    * Get array of non transactional statuses
1130    * @return array non transactional status ids
1131    */
1132   protected static function getTransactionalStatus() {
1133     $paymentStatus = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
1134     return array_diff(array_flip($paymentStatus), self::getNonTransactionalStatus());
1135   }
1136 }
1137