aa846de284
git-svn-id: file:///svn-source/pmgr/branches/yafr_20090716/site@479 97e9348a-65ac-dc4b-aefc-98561f571b83
691 lines
24 KiB
PHP
691 lines
24 KiB
PHP
<?php
|
|
class StatementEntry extends AppModel {
|
|
|
|
var $belongsTo = array(
|
|
'Transaction',
|
|
'Customer',
|
|
'Lease',
|
|
'Account',
|
|
|
|
// The charge to which this payment applies (if it is one)
|
|
'ChargeEntry' => array(
|
|
'className' => 'StatementEntry',
|
|
),
|
|
);
|
|
|
|
var $hasMany = array(
|
|
// The payments that apply to this charge (if it is one)
|
|
'PaymentEntry' => array(
|
|
'className' => 'StatementEntry',
|
|
'foreignKey' => 'charge_entry_id',
|
|
),
|
|
|
|
);
|
|
|
|
var $default_log_level = array('log' => 30, 'show' => 15);
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: chargePaymentFields
|
|
*/
|
|
|
|
|
|
function chargePaymentFields($sum = false, $entry_name = 'StatementEntry') {
|
|
$fields = array
|
|
(
|
|
($sum ? 'SUM(' : '') .
|
|
"IF({$entry_name}.type = 'CHARGE'," .
|
|
" {$entry_name}.amount, NULL)" .
|
|
($sum ? ')' : '') . ' AS charge' . ($sum ? 's' : ''),
|
|
|
|
($sum ? 'SUM(' : '') .
|
|
//"IF({$entry_name}.type IN('PAYMENT', 'SURPLUS', 'WAIVE')," .
|
|
"IF({$entry_name}.type NOT IN('CHARGE', 'VOID')," .
|
|
" {$entry_name}.amount, NULL)" .
|
|
($sum ? ')' : '') . ' AS payment' . ($sum ? 's' : ''),
|
|
|
|
($sum ? 'SUM(' : '') .
|
|
//"IF({$entry_name}.type = 'CHARGE', 1," .
|
|
//" IF({$entry_name}.type IN('PAYMENT', 'SURPLUS', 'WAIVE'), -1, 0))" .
|
|
"IF({$entry_name}.type = 'VOID', 0," .
|
|
" IF({$entry_name}.type = 'CHARGE', 1, -1))" .
|
|
" * IF({$entry_name}.amount, {$entry_name}.amount, 0)" .
|
|
($sum ? ')' : '') . ' AS balance',
|
|
);
|
|
|
|
if ($sum)
|
|
$fields[] = "COUNT({$entry_name}.id) AS entries";
|
|
|
|
return $fields;
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: verifyStatementEntry
|
|
* - Verifies consistenty of new statement entry data
|
|
* (not in a pre-existing statement entry)
|
|
*/
|
|
function verifyStatementEntry($entry) {
|
|
$this->prFunctionLevel(10);
|
|
$this->prEnter(compact('entry'));
|
|
|
|
if (empty($entry['type']) ||
|
|
//empty($entry['effective_date']) ||
|
|
empty($entry['account_id']) ||
|
|
empty($entry['amount'])
|
|
) {
|
|
return $this->prReturn(false);
|
|
}
|
|
|
|
return $this->prReturn(true);
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: addStatementEntry
|
|
* - Inserts new Statement Entry into the database
|
|
*/
|
|
function addStatementEntry($entry) {
|
|
$this->prEnter(compact('entry'));
|
|
|
|
$ret = array();
|
|
if (!$this->verifyStatementEntry($entry))
|
|
return array('error' => true, 'verify_data' => $entry) + $ret;
|
|
|
|
$this->pr(20, array('checkpoint' => 'Pre-Save')
|
|
+ compact('entry'));
|
|
|
|
$this->create();
|
|
if (!$this->save($entry))
|
|
return array('error' => true, 'save_data' => $entry) + $ret;
|
|
|
|
$ret['statement_entry_id'] = $this->id;
|
|
return $this->prReturn($ret + array('error' => false));
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: waive
|
|
* - Waives the charges
|
|
*
|
|
*/
|
|
function waive($id, $stamp = null) {
|
|
$this->prEnter(compact('id', 'stamp'));
|
|
|
|
// Get the basic information about the entry to be waived.
|
|
$this->recursive = -1;
|
|
$charge = $this->read(null, $id);
|
|
$charge = $charge['StatementEntry'];
|
|
|
|
// Query the stats to get the remaining balance
|
|
$stats = $this->stats($id);
|
|
|
|
// Build a transaction
|
|
$waiver = array('Transaction' => array(), 'Entry' => array());
|
|
$waiver['Transaction']['stamp'] = $stamp;
|
|
$waiver['Transaction']['comment'] = "Charge Waiver";
|
|
|
|
if ($charge['type'] !== 'CHARGE')
|
|
die("INTERNAL ERROR: WAIVER ITEM IS NOT CHARGE");
|
|
|
|
// Add the charge waiver
|
|
$waiver['Entry'][] =
|
|
array('amount' => $stats['Charge']['balance'],
|
|
'account_id' => $this->Account->waiverAccountID(),
|
|
'comment' => null,
|
|
);
|
|
|
|
// Record the waiver transaction
|
|
return $this->prReturn($this->Transaction->addWaiver
|
|
($waiver, $id, $charge['customer_id'], $charge['lease_id']));
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: reverse
|
|
* - Reverses the charges
|
|
*
|
|
* SAMPLE MOVE IN w/ PRE PAYMENT
|
|
* DEPOSIT RENT A/R RECEIPT CHECK PETTY BANK
|
|
* ------- ------- ------- ------- ------- ------- -------
|
|
* |25 | 25| | | | |
|
|
* | |20 20| | | | |
|
|
* | |20 20| | | | |
|
|
* | |20 20| | | | |
|
|
* | | |25 25| | | |
|
|
* | | |20 20| | | |
|
|
* | | |20 20| | | |
|
|
* | | |20 20| | | |
|
|
* | | | |85 85| | |
|
|
* | | | | |85 | 85|
|
|
|
|
* MOVE OUT and REFUND FINAL MONTH
|
|
* DEPOSIT RENT C/P RECEIPT CHECK PETTY BANK
|
|
* ------- ------- ------- ------- ------- ------- -------
|
|
* 25| | |25 | | | | t20 e20a
|
|
* | 20| |20 | | | | t20 e20b
|
|
|
|
* -ONE REFUND CHECK-
|
|
* | | 25| |25 | | | t30 e30a
|
|
* | | 20| |20 | | | t30 e30b
|
|
* | | | 45| | | |45 t40 e40
|
|
* -OR MULTIPLE-
|
|
* | | 15| |15 | | | t50a e50a
|
|
* | | | 15| | |15 | t60a e60a
|
|
* | | 30| |30 | | | t50b e50b
|
|
* | | | 30| | | |30 t60b e60b
|
|
* | | | | | | |
|
|
|
|
|
|
OPTION 1
|
|
* |-25 | -25| | | | |
|
|
* | |-20 -20| | | | |
|
|
* | | |-25 -25| | | |
|
|
* | | |-20 -20| | | |
|
|
|
|
OPTION 2
|
|
* |-25 | | -25| | | |
|
|
* | |-20 | -20| | | |
|
|
* | | | |-15 | -15| |
|
|
* | | | |-30 | | -30|
|
|
* | | | | | | |
|
|
*
|
|
*/
|
|
function reverse($ledger_entries, $stamp = null) {
|
|
$this->prEnter(compact('ledger_entries', 'stamp'));
|
|
|
|
// If the user only wants to reverse one ID, we'll allow it
|
|
if (!is_array($ledger_entries))
|
|
$ledger_entries = $this->find
|
|
('all', array
|
|
('contain' => false,
|
|
'conditions' => array('Entry.id' => $ledger_entries)));
|
|
|
|
$A = new Account();
|
|
|
|
$ar_account_id = $A->accountReceivableAccountID();
|
|
$receipt_account_id = $A->receiptAccountID();
|
|
|
|
$transaction_id = null;
|
|
foreach ($ledger_entries AS $entry) {
|
|
$entry = $entry['Entry'];
|
|
$amount = -1*$entry['amount'];
|
|
|
|
if (isset($entry['credit_account_id']))
|
|
$refund_account_id = $entry['credit_account_id'];
|
|
elseif (isset($entry['CreditLedger']['Account']['id']))
|
|
$refund_account_id = $entry['CreditLedger']['Account']['id'];
|
|
elseif (isset($entry['credit_ledger_id']))
|
|
$refund_account_id = $this->Ledger->accountID($entry['credit_ledger_id']);
|
|
else
|
|
return $this->prReturn(null);
|
|
|
|
// post new refund in the income account
|
|
$ids = $A->postEntry
|
|
(array('transaction_id' => $transaction_id),
|
|
null,
|
|
array('debit_ledger_id' => $A->currentLedgerID($ar_account_id),
|
|
'credit_ledger_id' => $A->currentLedgerID($refund_account_id),
|
|
'effective_date' => $entry['effective_date'],
|
|
'through_date' => $entry['through_date'],
|
|
'amount' => $amount,
|
|
'lease_id' => $entry['lease_id'],
|
|
'customer_id' => $entry['customer_id'],
|
|
'comment' => "Refund; Entry #{$entry['id']}",
|
|
),
|
|
array('debit' => array
|
|
(array('Entry' =>
|
|
array('id' => $entry['id'],
|
|
'amount' => $amount))),
|
|
)
|
|
);
|
|
|
|
if ($ids['error'])
|
|
return $this->prReturn(null);
|
|
$transaction_id = $ids['transaction_id'];
|
|
|
|
$this->pr(15, compact('ids', 'amount', 'refund_account_id', 'ar_account_id'),
|
|
'Posted Refund Ledger Entry');
|
|
}
|
|
|
|
return $this->prReturn(true);
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: reconciledSet
|
|
* - Returns the set of entries satisfying the given conditions,
|
|
* along with any entries that they reconcile
|
|
*/
|
|
function reconciledSetQuery($set, $query) {
|
|
$this->queryInit($query);
|
|
|
|
if ($set == 'CHARGE' || $set == 'PAYMENT')
|
|
$query['conditions'][] = array('StatementEntry.type' => $set);
|
|
else
|
|
die("INVALID RECONCILE SET");
|
|
|
|
if ($set == 'CHARGE')
|
|
$query['link']['PaymentEntry'] = array('fields' => array("SUM(PaymentEntry.amount) AS reconciled"));
|
|
if ($set == 'PAYMENT')
|
|
$query['link']['ChargeEntry'] = array('fields' => array("SUM(ChargeEntry.amount) AS reconciled"));
|
|
|
|
$query['group'] = 'StatementEntry.id';
|
|
|
|
// REVISIT: TESTING
|
|
//$query['link']['PaymentEntry'] = array('fields' => array("(`PaymentEntry.amount`+0) AS reconciled"));
|
|
//$query['group'] = null;
|
|
// END REVISIT
|
|
|
|
return $query;
|
|
}
|
|
|
|
function reconciledSet($set, $query = null, $unrec = false, $if_rec_include_partial = false) {
|
|
//$this->prFunctionLevel(16);
|
|
$this->prEnter(compact('set', 'query', 'unrec', 'if_rec_include_partial'));
|
|
$lquery = $this->reconciledSetQuery($set, $query);
|
|
$result = $this->find('all', $lquery);
|
|
|
|
$this->pr(20, compact('lquery', 'result'));
|
|
|
|
$resultset = array();
|
|
foreach ($result AS $i => $entry) {
|
|
$this->pr(25, compact('entry'));
|
|
if (!empty($entry[0]))
|
|
$entry['StatementEntry'] = $entry[0] + $entry['StatementEntry'];
|
|
unset($entry[0]);
|
|
|
|
$entry['StatementEntry']['balance'] =
|
|
$entry['StatementEntry']['amount'] - $entry['StatementEntry']['reconciled'];
|
|
|
|
// Since HAVING isn't a builtin feature of CakePHP,
|
|
// we'll have to post-process to get the desired entries
|
|
|
|
if ($entry['StatementEntry']['balance'] == 0)
|
|
$reconciled = true;
|
|
elseif ($entry['StatementEntry']['reconciled'] == 0)
|
|
$reconciled = false;
|
|
else // Partial payment; depends on unrec
|
|
$reconciled = (!$unrec && $if_rec_include_partial);
|
|
|
|
// Add to the set, if it's been requested
|
|
if ($reconciled == !$unrec)
|
|
$resultset[] = $entry;
|
|
}
|
|
|
|
return $this->prReturn(array('entries' => $resultset,
|
|
'summary' => $this->stats(null, $query)));
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: reconciledEntries
|
|
* - Returns a list of entries that reconcile against the given entry.
|
|
* (such as payments towards a charge).
|
|
*/
|
|
function reconciledEntriesQuery($id, $query = null) {
|
|
$this->queryInit($query, false);
|
|
|
|
$this->id = $id;
|
|
$this->recursive = -1;
|
|
$this->read();
|
|
|
|
$query['conditions'][] = array('StatementEntry.id' => $id);
|
|
|
|
if ($this->data['StatementEntry']['type'] == 'CHARGE')
|
|
$query['link']['PaymentEntry'] = array();
|
|
if ($this->data['StatementEntry']['type'] == 'PAYMENT')
|
|
$query['link']['ChargeEntry'] = array();
|
|
|
|
return $query;
|
|
}
|
|
|
|
function reconciledEntries($id, $query = null) {
|
|
$this->prEnter(compact('id', 'query'));
|
|
$lquery = $this->reconciledEntriesQuery($id, $query);
|
|
|
|
$result = $this->find('all', $lquery);
|
|
foreach (array_keys($result) AS $i)
|
|
unset($result[$i]['StatementEntry']);
|
|
|
|
return $this->prReturn(array('entries' => $result));
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: assignCredits
|
|
* - Assigns all credits to existing charges
|
|
*
|
|
* REVISIT <AP>: 20090726
|
|
* This algorithm shouldn't be hardcoded. We need to allow
|
|
* the user to specify how payments should be applied.
|
|
*
|
|
*/
|
|
function assignCredits($query = null, $receipt_id = null,
|
|
$charge_ids = null, $payment_type = null)
|
|
{
|
|
//$this->prFunctionLevel(25);
|
|
$this->prEnter( compact('query', 'receipt_id', 'charge_ids', 'payment_type'));
|
|
$this->queryInit($query);
|
|
|
|
if (empty($payment_type))
|
|
$payment_type = 'PAYMENT';
|
|
|
|
$ret = array();
|
|
|
|
// First, find all known credits
|
|
$lquery = $query;
|
|
$lquery['conditions'][] = array('StatementEntry.type' => 'SURPLUS');
|
|
$lquery['order'][] = 'StatementEntry.effective_date ASC';
|
|
$credits = $this->find('all', $lquery);
|
|
$this->pr(18, compact('credits'),
|
|
"Credits Established");
|
|
|
|
// Next, establish credit from the newly added receipt
|
|
$receipt_credit = null;
|
|
if (!empty($receipt_id)) {
|
|
$lquery = $query;
|
|
$lquery['link'] += array('LedgerEntry' =>
|
|
array('conditions' =>
|
|
//array(LedgerEntry.'crdr'=>'DEBIT'),
|
|
array('LedgerEntry.account_id !=' => $this->Account->accountReceivableAccountID()),
|
|
));
|
|
$lquery['fields'] = array('Transaction.id', 'Transaction.stamp', 'Transaction.amount',
|
|
'LedgerEntry.account_id');
|
|
// Very specific case here... no extra conditions
|
|
unset($lquery['conditions']);
|
|
$this->Transaction->id = $receipt_id;
|
|
$receipt_credit = $this->Transaction->find('first', $lquery);
|
|
if (!$receipt_credit)
|
|
die("INTERNAL ERROR: UNABLE TO LOCATE RECEIPT");
|
|
|
|
$receipt_credit['balance'] = $receipt_credit['Transaction']['amount'];
|
|
|
|
$this->pr(18, compact('receipt_credit'),
|
|
"Receipt Credit Added");
|
|
}
|
|
|
|
// Now find all unpaid charges
|
|
if (isset($charge_ids)) {
|
|
$lquery = array('contain' => false,
|
|
'conditions' => array('StatementEntry.id' => $charge_ids));
|
|
} else {
|
|
$lquery = $query;
|
|
}
|
|
$lquery['order'] = 'StatementEntry.effective_date ASC';
|
|
$charges = $this->reconciledSet('CHARGE', $lquery, true);
|
|
$this->pr(18, compact('charges'),
|
|
"Outstanding Charges Determined");
|
|
|
|
// Initialize our list of used credits
|
|
$used_credits = array();
|
|
|
|
// Work through all unpaid charges, applying payments as we go
|
|
foreach ($charges['entries'] AS $charge) {
|
|
|
|
$this->pr(20, compact('charge'),
|
|
'Process Charge');
|
|
|
|
// Check that we have available credits.
|
|
// Technically, this isn't necessary, since the loop
|
|
// will handle everything just fine. However, this
|
|
// just saves extra processing if/when there is no
|
|
// means to resolve a charge anyway.
|
|
if (count($credits) == 0 && empty($receipt_credit['balance'])) {
|
|
$this->pr(17, 'No more available credits');
|
|
break;
|
|
}
|
|
|
|
$charge['balance'] = $charge['StatementEntry']['balance'];
|
|
while ($charge['balance'] > 0 &&
|
|
(count($credits) || !empty($receipt_credit['balance']))) {
|
|
|
|
$this->pr(20, compact('charge'),
|
|
'Attempt Charge Reconciliation');
|
|
|
|
// Use explicit credits before using implicit credits
|
|
// (Not sure it matters though).
|
|
if (count($credits)) {
|
|
// Peel off the first credit available
|
|
$credit =& $credits[0];
|
|
$payment_date = $credit['StatementEntry']['effective_date'];
|
|
$payment_transaction_id = $credit['StatementEntry']['transaction_id'];
|
|
$payment_account_id = $credit['StatementEntry']['account_id'];
|
|
|
|
if (!isset($credit['balance']))
|
|
$credit['balance'] = $credit['StatementEntry']['amount'];
|
|
}
|
|
elseif (!empty($receipt_credit['balance'])) {
|
|
// Use our only receipt credit
|
|
$credit =& $receipt_credit;
|
|
$payment_date = $credit['Transaction']['stamp'];
|
|
$payment_transaction_id = $credit['Transaction']['id'];
|
|
$payment_account_id = $credit['LedgerEntry']['account_id'];
|
|
}
|
|
else {
|
|
die("HOW DID WE GET HERE WITH NO SURPLUS?");
|
|
}
|
|
|
|
// Set the payment amount to the maximum amount
|
|
// possible without exceeding the charge or credit balance
|
|
$payment_amount = min($charge['balance'], $credit['balance']);
|
|
if (!isset($credit['applied']))
|
|
$credit['applied'] = 0;
|
|
|
|
$credit['applied'] += $payment_amount;
|
|
$credit['balance'] -= $payment_amount;
|
|
|
|
$this->pr(20, compact('credit'),
|
|
($credit['balance'] > 0 ? 'Utilized' : 'Exhausted') .
|
|
(count($credits) ? ' Credit' : ' Receipt'));
|
|
|
|
if ($credit['balance'] < 0)
|
|
die("HOW DID WE END UP WITH NEGATIVE SURPLUS BALANCE?");
|
|
|
|
// If we've exhausted the credit, get it out of the
|
|
// available credit pool (but keep track of it for later).
|
|
if ($credit['balance'] <= 0 && count($credits))
|
|
$used_credits[] = array_shift($credits);
|
|
|
|
// Add a payment that uses the available credit to pay the charge
|
|
$payment = array('type' => $payment_type,
|
|
'account_id' => $payment_account_id,
|
|
'amount' => $payment_amount,
|
|
'effective_date' => $payment_date,
|
|
'transaction_id' => $payment_transaction_id,
|
|
'customer_id' => $charge['StatementEntry']['customer_id'],
|
|
'lease_id' => $charge['StatementEntry']['lease_id'],
|
|
'charge_entry_id' => $charge['StatementEntry']['id'],
|
|
'comment' => null,
|
|
);
|
|
|
|
$this->pr(20, compact('payment'),
|
|
'New Payment Entry');
|
|
|
|
$result = $this->addStatementEntry($payment);
|
|
$ret['Payment'][] = $result;
|
|
if ($result['error'])
|
|
$ret['error'] = true;
|
|
|
|
// Adjust the charge balance to reflect the new payment
|
|
$charge['balance'] -= $payment_amount;
|
|
if ($charge['balance'] < 0)
|
|
die("HOW DID WE GET A NEGATIVE CHARGE AMOUNT?");
|
|
|
|
if ($charge['balance'] <= 0)
|
|
$this->pr(20, 'Fully Paid Charge');
|
|
}
|
|
|
|
}
|
|
|
|
// Partially used credits must be added to the used list
|
|
if (isset($credits[0]['applied']))
|
|
$used_credits[] = array_shift($credits);
|
|
|
|
$this->pr(18, compact('credits', 'used_credits', 'receipt_credit'),
|
|
'Payments added');
|
|
|
|
// Clean up any explicit credits that have been used
|
|
foreach ($used_credits AS $credit) {
|
|
if ($credit['balance'] > 0) {
|
|
$this->pr(20, compact('credit'),
|
|
'Update Credit Entry');
|
|
|
|
$this->id = $credit['StatementEntry']['id'];
|
|
$this->saveField('amount', $credit['balance']);
|
|
}
|
|
else {
|
|
$this->pr(20, compact('credit'),
|
|
'Delete Exhausted Credit Entry');
|
|
|
|
$this->del($credit['StatementEntry']['id'], false);
|
|
}
|
|
}
|
|
|
|
// Convert non-exhausted receipt credit to an explicit one
|
|
if (!empty($receipt_credit['balance'])) {
|
|
$credit =& $receipt_credit;
|
|
|
|
$this->pr(18, compact('credit'),
|
|
'Create Explicit Credit');
|
|
|
|
$result = $this->addStatementEntry
|
|
(array('type' => 'SURPLUS',
|
|
'account_id' => $credit['LedgerEntry']['account_id'],
|
|
'amount' => $credit['balance'],
|
|
'effective_date' => $credit['Transaction']['stamp'],
|
|
'transaction_id' => $credit['Transaction']['id'],
|
|
'customer_id' => $credit['Customer']['id'],
|
|
));
|
|
$ret['Credit'] = $result;
|
|
if ($result['error'])
|
|
$ret['error'] = true;
|
|
}
|
|
|
|
return $this->prReturn($ret + array('error' => false));
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
**************************************************************************
|
|
**************************************************************************
|
|
* function: stats
|
|
* - Returns summary data from the requested statement entry
|
|
*/
|
|
function stats($id = null, $query = null) {
|
|
$this->prEnter(compact('id', 'query'));
|
|
|
|
$this->queryInit($query);
|
|
unset($query['group']);
|
|
|
|
$stats = array();
|
|
if (isset($id))
|
|
$query['conditions'][] = array('StatementEntry.id' => $id);
|
|
|
|
$rquery = $query;
|
|
unset($rquery['link']['ChargeEntry']);
|
|
$rquery['link']['PaymentEntry'] = array('fields' => array());
|
|
|
|
$rquery['fields'] = array();
|
|
$rquery['fields'][] = "StatementEntry.amount";
|
|
$rquery['fields'][] = "SUM(PaymentEntry.amount) AS reconciled";
|
|
|
|
$rquery['conditions'][] = array('StatementEntry.type' => 'CHARGE');
|
|
$rquery['group'] = 'StatementEntry.id';
|
|
|
|
$result = $this->find('all', $rquery);
|
|
$stats['Charge'] = array('total' => 0, 'reconciled' => 0);
|
|
foreach($result AS $charge) {
|
|
$stats['Charge']['total'] += $charge['StatementEntry']['amount'];
|
|
$stats['Charge']['reconciled'] += $charge[0]['reconciled'];
|
|
}
|
|
$stats['Charge']['balance'] =
|
|
$stats['Charge']['total'] - $stats['Charge']['reconciled'];
|
|
|
|
$this->pr(17, compact('rquery', 'result'),
|
|
'Charges');
|
|
|
|
$rquery = $query;
|
|
unset($rquery['link']['ChargeEntry']);
|
|
$rquery['link']['PaymentEntry'] = array('fields' => array(),
|
|
/* 'conditions' => */
|
|
/* array('PaymentEntry.type' => 'WAIVE'), */
|
|
);
|
|
|
|
$rquery['fields'] = array();
|
|
$rquery['fields'][] = "SUM(PaymentEntry.amount) AS reconciled";
|
|
|
|
$rquery['conditions'][] = array('StatementEntry.type' => 'CHARGE');
|
|
$rquery['conditions'][] = array('PaymentEntry.type' => 'WAIVE');
|
|
$rquery['group'] = 'StatementEntry.id';
|
|
|
|
$result = $this->find('first', $rquery);
|
|
$stats['Charge']['waived'] = $result[0]['reconciled'];
|
|
/* $stats['Waiver'] = array('total' => 0, 'reconciled' => 0); */
|
|
/* foreach($result AS $charge) { */
|
|
/* $stats['Waiver']['total'] += $charge['StatementEntry']['amount']; */
|
|
/* $stats['Waiver']['reconciled'] += $charge[0]['reconciled']; */
|
|
/* } */
|
|
/* $stats['Waiver']['balance'] = */
|
|
/* $stats['Waiver']['total'] - $stats['Waiver']['reconciled']; */
|
|
|
|
$this->pr(17, compact('rquery', 'result'),
|
|
'Waived');
|
|
|
|
$rquery = $query;
|
|
unset($rquery['link']['PaymentEntry']);
|
|
$rquery['link']['ChargeEntry'] = array('fields' => array());
|
|
|
|
$rquery['fields'] = array();
|
|
$rquery['fields'][] = "SUM(StatementEntry.amount) AS total";
|
|
$rquery['fields'][] = "SUM(IF(ChargeEntry.id IS NULL, 0, StatementEntry.amount)) AS reconciled";
|
|
$rquery['fields'][] = "SUM(IF(ChargeEntry.id IS NULL, StatementEntry.amount, 0)) AS balance";
|
|
|
|
$rquery['conditions'][] = array('StatementEntry.type' => 'PAYMENT');
|
|
$result = $this->find('first', $rquery);
|
|
if (!isset($result[0]['balance']))
|
|
$result[0]['balance'] = 0;
|
|
$stats['Payment'] = $result[0];
|
|
|
|
$this->pr(17, compact('rquery', 'result'),
|
|
'Payments');
|
|
|
|
$rquery = $query;
|
|
unset($rquery['link']['PaymentEntry']);
|
|
unset($rquery['link']['ChargeEntry']);
|
|
|
|
$rquery['fields'] = array();
|
|
$rquery['fields'][] = "SUM(StatementEntry.amount) AS total";
|
|
$rquery['fields'][] = "SUM(0) AS reconciled";
|
|
|
|
$rquery['conditions'][] = array('StatementEntry.type' => 'SURPLUS');
|
|
$result = $this->find('first', $rquery);
|
|
$result[0]['balance'] = $result[0]['total'] - $result[0]['reconciled'];
|
|
if (!isset($result[0]['balance']))
|
|
$result[0]['balance'] = 0;
|
|
$stats['Surplus'] = $result[0];
|
|
|
|
$this->pr(17, compact('rquery', 'result'),
|
|
'Surplus');
|
|
|
|
|
|
return $this->prReturn($stats);
|
|
}
|
|
|
|
}
|