Transaction.php

Go to the documentation of this file.

<?php
// {{{ license

// +----------------------------------------------------------------------+
// | FastFrame Application Framework                                      |
// +----------------------------------------------------------------------+
// | Copyright (c) 2002-2006 The Codejanitor Transaction                        |
// +----------------------------------------------------------------------+
// | This source file is subject to the GNU Lesser Public License (LGPL), |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.fsf.org/copyleft/lesser.html                              |
// | If you did not receive a copy of the LGPL and are unable to          |
// | obtain it through the world-wide-web, you can get it by writing the  |
// | Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, |
// | MA 02111-1307, USA.                                                  |
// +----------------------------------------------------------------------+
// | Authors: Jason Rust <jrust@codejanitor.com>                          |
// | Authors: Greg Gilbert <ggilbert@codejanitor.com>                     |
// +----------------------------------------------------------------------+

// }}}
// {{{ requires

require_once FASTFRAME_ROOT . 'lib/FastFrame/DataAccess.php';
require_once dirname(__FILE__) . '/Loan.php';

// }}}
// {{{ class FF_DataAccess_Transaction 

// }}}
class FF_DataAccess_Transaction_mysql extends FF_DataAccess {
    // {{{ properties

    var $itemsTable;

    var $groupsTable;

    var $loansTable;

    // }}}
    // {{{ constructor

    function FF_DataAccess_Transaction_mysql()
    {
        FF_DataAccess::FF_DataAccess();
        $this->table = $this->o_registry->getConfigParam('data/transaction_items_table');
        $this->itemsTable = $this->o_registry->getConfigParam('data/items_table');
        $this->groupsTable = $this->o_registry->getConfigParam('data/groups_table');
        $this->loansTable = $this->o_registry->getConfigParam('data/loans_table');
    }

    // }}}
    // {{{ removeItemInTransaction()

    function removeItemInTransaction($in_transactionId, $in_itemId, $in_limit, $in_isGroup = false)
    {
        $o_result = new FF_Result();
        $s_stmt = $this->o_data->prepare("DELETE FROM $this->table 
                                          WHERE transaction_id=? AND item_id=? AND is_group=? LIMIT $in_limit");

        $a_data = array($in_transactionId, $in_itemId, $in_isGroup);
        if (DB::isError($result = $this->o_data->execute($s_stmt, $a_data))) {
            $o_result->addMessage($result->getMessage());
            $o_result->setSuccess(false);
        }

        return $o_result;
    }

    // }}}
    // {{{ returnItemsInTransaction()

    function &returnItemsInTransaction($in_items)
    {
        require_once dirname(__FILE__) . '/../../Model/Log.php';
        $o_log =& new FF_Model_Log();
        $o_result = new FF_Result();
        $s_itemList = '';
        $a_items = array();
        $in_items = $this->_matchItemsToTransaction($in_items);
        // Time needs to be exactly same for both log and return date so we can match them up.
        $s_timestamp = time();
        foreach ($in_items as $a_data) {
            $s_itemList .= sprintf('(item_id = %s AND transaction_id = %s) OR ',
                    $this->o_data->quoteSmart($a_data['item_id']),
                    $this->o_data->quoteSmart($a_data['transaction_id']));

            $a_items[] = $a_data['item_id'];
            $o_log->newLogEntry('ITEM_RETURNED', $a_data['item_id'], $this->table, $s_timestamp, $a_data['transaction_id']);
        }

        $s_itemList .= '0=1';
        $s_query = "UPDATE $this->table SET return_date = ? WHERE $s_itemList"; 
        if (DB::isError($result = $this->o_data->query($s_query, array($this->timestampToISODate($s_timestamp))))) {
            $o_result->addMessage($result->getMessage());
            $o_result->setSuccess(false);
        }

        require_once dirname(__FILE__) . '/../../Model/Item.php';
        $o_itemDataAccess =& FF_DataAccess::factory('Item');
        $tmp_result =& $o_itemDataAccess->updateStatusOfItems($a_items, ITEM_STATUS_AVAILABLE);
        if (!$tmp_result->isSuccess()) {
            $o_result->addMessage($tmp_result->getMessages());
            $o_result->setSuccess(false);
        }

        return $o_result;
    }

    // }}}
    // {{{ getBorrowersFromReturnItems()

    function getBorrowersFromReturnItems($in_items)
    {
        $s_itemList = '';
        $a_items = array();
        foreach ($in_items as $a_data) {
            if (!is_null($a_data['itemId'])) {
                $s_itemList .= 'item_id=' . $this->o_data->quoteSmart($a_data['itemId']) . " OR \n";
                $a_items[] = $a_data['itemId'];
            }
        }

        $s_itemList .= '0=1';
        // NOTE: Assuming items were returned in the last 120 seconds,
        // so basically returnItemsInTransaction() and this method should
        // be called side by side.
        $s_query = "SELECT t2.borrower_id, COUNT(t1.item_id) 
                    FROM $this->table AS t1
                    INNER JOIN $this->loansTable AS t2 ON t1.transaction_id = t2.id
                    WHERE t1.return_date + 0 >= NOW() - 120 AND t1.is_group = 0 
                    AND t2.type = ? AND ($s_itemList)
                    GROUP BY t2.borrower_id";

        return $this->o_data->getAssoc($s_query, false, LOANS_TYPE_LOAN);
    }

    // }}}
    // {{{ getReturnItemsForBorrower()

    function getReturnItemsForBorrower($in_borrowerId, $in_timestamp)
    {
        // :NOTE: Assuming items were returned within 120 seconds of the timestamp,
        settype($in_timestamp, 'int');
        $s_query = "SELECT t.item_id, UNIX_TIMESTAMP(t.return_date) AS return_date, i.name, i.barcode
                    FROM $this->table AS t
                    INNER JOIN $this->loansTable AS l ON t.transaction_id=l.id
                    INNER JOIN $this->itemsTable AS i ON t.item_id=i.id
                    WHERE l.borrower_id=? AND UNIX_TIMESTAMP(t.return_date) >= $in_timestamp - 120 AND t.is_group=0
                    ORDER BY i.name";

        return $this->o_data->getAll($s_query, array($in_borrowerId));
    }

    // }}}
    //{{{ getItemIdsByTransactionId()

    function getItemIdsByTransactionId($in_transactionId, $in_onlyNonReturned = false)
    {
        $s_query = "SELECT item_id, is_group FROM $this->table WHERE transaction_id=?";
        if ($in_onlyNonReturned) {
            $s_query .= ' AND return_date=0';
        }

        return $this->o_data->getAssoc($s_query, false, $in_transactionId);
    }
    
    // }}}
    //{{{ getItemsByTransactionId()

    function getItemsByTransactionId($in_transactionId, $in_excludeReturned = false)
    {
        $s_excludeReturned = '';
        if ($in_excludeReturned) {
            $s_excludeReturned = ' AND return_date = 0';
        }

        $s_query = "SELECT t.transaction_id, t.item_id, 
                    UNIX_TIMESTAMP(t.return_date) AS return_date, 
                    IF(t.is_group = 1, 1, 0) AS is_group, 
                    IF(i.name IS NULL, g.name, i.name) AS name,
                    IF(t.is_group = 1, g.is_kit, 0) AS is_kit,
                    IF(i.description IS NULL, g.description, i.description) AS description,
                    i.barcode, i.status
                    FROM $this->table AS t
                    LEFT JOIN $this->itemsTable AS i ON t.item_id = i.id
                    LEFT JOIN $this->groupsTable AS g ON t.item_id = g.id
                    WHERE t.transaction_id = ? $s_excludeReturned
                    ORDER BY t.return_date, i.name, g.name";

        if (DB::isError($result = $this->o_data->getAll($s_query, array($in_transactionId)))) {
            return array();
        }
        else {
            return $result;
        }
    }
    
    // }}}
    //{{{ getItems()

    function getItems($in_items)
    {
        $s_itemList = '';
        $s_groupList = '';
        $a_groupCount = array();
        foreach ($in_items as $a_item) {
            if (!is_null($a_item['itemId'])) {
                if ($a_item['isGroup']) {
                    if (!isset($a_groupCount[$a_item['itemId']])) {
                        $a_groupCount[$a_item['itemId']] = array(0, false);
                    }

                    $a_groupCount[$a_item['itemId']][0]++;
                    $s_groupList .= sprintf('id = %s OR ', $this->o_data->quoteSmart($a_item['itemId']));
                }
                else {
                    $s_itemList .= sprintf('id = %s OR ', $this->o_data->quoteSmart($a_item['itemId']));
                }
            }
        }

        $s_itemList .= '0=1';
        $s_groupList .= '0=1';
        $s_query = "SELECT id AS item_id, name, barcode, status FROM $this->itemsTable WHERE $s_itemList";
        $a_items = $this->o_data->getAll($s_query);
        foreach (array_keys($a_items) as $s_key) {
            $a_items[$s_key]['transaction_id'] = null;
            $a_items[$s_key]['return_date'] = 0; 
            $a_items[$s_key]['is_kit'] = false; 
            $a_items[$s_key]['is_group'] = false;
            $a_items[$s_key]['notSaved'] = true;
        }

        $s_query = "SELECT id AS item_id, name, is_kit FROM $this->groupsTable WHERE $s_groupList";
        $tmp_items = $this->o_data->getAll($s_query);
        foreach (array_keys($tmp_items) as $s_key) {
            $tmp_items[$s_key]['transaction_id'] = null;
            $tmp_items[$s_key]['return_date'] = 0; 
            $tmp_items[$s_key]['is_group'] = true;
            $tmp_items[$s_key]['notSaved'] = true;
            $a_groupCount[$tmp_items[$s_key]['item_id']][1] = $s_key;
        }
        
        // Because the above query for groups will only return 1
        // instance of a group even if X requests for the same group were
        // made we need to add the requested number of groups back in
        foreach ($a_groupCount as $s_id => $a_vals) {
            if ($a_vals[0] > 1 && $a_vals[1] !== false) {
                for ($i = 1; $i < $a_vals[0]; $i++) {
                    $tmp_items[] = $tmp_items[$a_vals[1]];
                }
            }
        }

        $a_items = array_merge($a_items, $tmp_items);
        return $a_items;
    }
    
    // }}}
    // {{{ updateItemReturnDates()

    function &updateItemReturnDates($in_items, $in_id, $in_timestamp)
    {
        $o_result = new FF_Result();
        $s_itemList = '';
        foreach ($in_items as $s_itemId) {
            $s_itemList .= 'item_id = ' . $this->o_data->quoteSmart($s_itemId) . " OR \n";
        }

        $s_itemList .= '0=1';
        $s_stmt = $this->o_data->prepare("UPDATE $this->table SET return_date = ? 
                                          WHERE transaction_id = ? AND ($s_itemList)");

        $a_data = array($this->timestampToISODate($in_timestamp), $in_id);
        if (DB::isError($result = $this->o_data->execute($s_stmt, $a_data))) {
            $o_result->addMessage($result->getMessage());
            $o_result->setSuccess(false);
        }

        return $o_result;
    }

    // }}}
    // {{{ filterOutReturnedItems()

    function filterOutReturnedItems($in_items, $in_transactionId)
    {
        $s_itemList = '';
        foreach ($in_items as $s_itemId) {
            $s_itemList .= 'item_id = ' . $this->o_data->quoteSmart($s_itemId) . " OR \n";
        }

        $s_itemList .= '0=1';
        $s_query = "SELECT item_id FROM $this->table WHERE transaction_id = ? AND return_date = 0 AND ($s_itemList)";
        return (array) $this->o_data->getCol($s_query, 0, $in_transactionId);
    }

    // }}}
    // {{{ getMostRecentBorrower()

    function getMostRecentBorrower($in_id)
    {
        $s_query = "SELECT l.borrower_id FROM $this->table AS t 
                    INNER JOIN $this->loansTable AS l ON t.transaction_id = l.id
                    WHERE t.item_id = ? 
                    ORDER BY l.due_date DESC LIMIT 1";

        return $this->o_data->getOne($s_query, $in_id);

    }

    // }}}
    // {{{ _matchItemsToTransaction()

    function _matchItemsToTransaction($in_items)
    {
        $s_itemList = '';
        foreach ($in_items as $a_data) {
            if (!is_null($a_data['itemId'])) {
                $s_itemList .= sprintf('t1.item_id = %s OR ', $this->o_data->quoteSmart($a_data['itemId']));
            }
        }

        $s_itemList .= '0=1';
        $s_query = "SELECT t1.item_id, t1.transaction_id
                    FROM $this->table AS t1 
                    INNER JOIN $this->loansTable AS t2 ON t1.transaction_id = t2.id
                    WHERE t1.return_date = 0 AND t1.is_group = 0 AND t2.type = ? AND ($s_itemList)";
        
        return $this->o_data->getAll($s_query, array(LOANS_TYPE_LOAN));
    }

    // }}}
}
?>

---