modules/market/market.module

<?php
//$Id: market.module,v 1.13 2008/03/10 00:48:24 greggles Exp $

// Trade states
define('MARKET_STATE_TRADE_OPEN', 2);
define('MARKET_STATE_TRADE_EXECUTED', 4);
define('MARKET_STATE_TRADE_INVALID', 5);
define('MARKET_STATE_TRADE_PARTIALLY_EXECUTED', 6);
define('MARKET_STATE_TRADE_CANCELLED', 3);

// Portfolio states
define('MARKET_STATE_PORTFOLIO_OPEN', 8);
define('MARKET_STATE_PORTFOLIO_CLOSED', 9);

// Item states
define('MARKET_STATE_ITEM_OPEN', 11);
define('MARKET_STATE_ITEM_PENDING_DECISION', 14);
define('MARKET_STATE_ITEM_CLOSED_SUCCESS', 12);
define('MARKET_STATE_ITEM_CLOSED_FAIL', 13);

// Other random defines
define('MARKET_ROBOT_UID', 2);

/**
 * Implementation of hook_help().
 */
function market_help($section) {
  switch ($section) {
    case 'admin/settings/market':
      $output = t('Configure userpoints moderation and branding translation');
      break;
    case 'admin/help#market':
      $output = t('Users earn !points as they post nodes, comments, and vote on nodes');
  }
  return $output;
}

/**
 * Implementation of hook_menu().
 */
function market_menu($may_cache) {
  
  $items = array();

  if ($may_cache) {
    $items[] = array(
      'path'     => 'admin/settings/market',
      'callback' => 'drupal_get_form',
      'callback arguments' => array('market_admin_settings'),
      'title'    => t('Market settings'),
      'description' => t('Configure market settings'),
      'access'   => user_access('administer markets'),
      'type'     => MENU_NORMAL_ITEM,
    );
  }
  
  return $items;
}

/**
 * Implementation of hook_perm().
 */
function market_perm() {
  return array('administer markets');
}

/**
 * menu callback for settings form.
 */
function market_admin_settings() {
  $form = array();
  $group = 'workflow';
  $form[$group] = array(
    '#type' => 'fieldset',
    '#title' => t('Workflow States'),
    '#collapsible' => TRUE,
    '#collapsed' => TRUE,
    '#weight' => -1,
    '#description' => t('Configure the state IDs for the states of the workflows you have defined.  <br> See the INSTALL.txt for more details'),
  );

  // Trade States
  $form[$group]['trade'] = array(
    '#type' => 'fieldset',
    '#title' => t('Workflow States for Trades'),
    '#collapsible' => FALSE,
    '#collapsed' => FALSE,
    '#weight' => -1,
  );

  $form[$group]['trade']['market_state_trade_open'] = array(
    '#type' => 'textfield',
    '#title' => t('Open State ID'),
    '#default_value' => variable_get('market_state_trade_open', MARKET_STATE_TRADE_OPEN),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );

  $form[$group]['trade']['market_state_trade_executed'] = array(
    '#type' => 'textfield',
    '#title' => t('Executed State ID'),
    '#default_value' => variable_get('market_state_trade_executed', MARKET_STATE_TRADE_EXECUTED),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );

  $form[$group]['trade']['market_state_trade_invalid'] = array(
    '#type' => 'textfield',
    '#title' => t('Invalid State ID'),
    '#default_value' => variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );

  $form[$group]['trade']['market_state_trade_partially_executed'] = array(
    '#type' => 'textfield',
    '#title' => t('Partially Executed State ID'),
    '#default_value' => variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );

  $form[$group]['trade']['market_state_trade_cancelled'] = array(
    '#type' => 'textfield',
    '#title' => t('Cancelled State ID'),
    '#default_value' => variable_get('market_state_trade_cancelled', MARKET_STATE_TRADE_CANCELLED),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );

  // Portfolio states
  $form[$group]['portfolio'] = array(
    '#type' => 'fieldset',
    '#title' => t('Workflow States for Portfolios'),
    '#collapsible' => FALSE,
    '#collapsed' => FALSE,
    '#weight' => -1,
  );

  $form[$group]['portfolio']['market_state_portfolio_open'] = array(
    '#type' => 'textfield',
    '#title' => t('Portfolio Open State ID'),
    '#default_value' => variable_get('market_state_portfolio_open', MARKET_STATE_PORTFOLIO_OPEN),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );
  $form[$group]['portfolio']['market_state_portfolio_closed'] = array(
    '#type' => 'textfield',
    '#title' => t('Portfolio Open State ID'),
    '#default_value' => variable_get('market_state_portfolio_closed', MARKET_STATE_PORTFOLIO_CLOSED),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );


  // Item (contract, stock, option, etc.) states
  $form[$group]['item'] = array(
    '#type' => 'fieldset',
    '#title' => t('Workflow States for Items'),
    '#collapsible' => FALSE,
    '#collapsed' => FALSE,
    '#weight' => -1,
  );
  $form[$group]['item']['market_state_item_open'] = array(
    '#type' => 'textfield',
    '#title' => t('Item Open State ID'),
    '#default_value' => variable_get('market_state_item_open', MARKET_STATE_ITEM_OPEN),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );
  $form[$group]['item']['market_state_item_pending_decision'] = array(
    '#type' => 'textfield',
    '#title' => t('Item Pending Decision State ID'),
    '#default_value' => variable_get('market_state_item_pending_decision', MARKET_STATE_ITEM_PENDING_DECISION),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );
  $form[$group]['item']['market_state_item_closed_success'] = array(
    '#type' => 'textfield',
    '#title' => t('Item Closed Success State ID'),
    '#default_value' => variable_get('market_state_item_closed_success', MARKET_STATE_ITEM_CLOSED_SUCCESS),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );
  $form[$group]['item']['market_state_item_closed_fail'] = array(
    '#type' => 'textfield',
    '#title' => t('Item Closed Fail State ID'),
    '#default_value' => variable_get('market_state_item_closed_fail', MARKET_STATE_ITEM_CLOSED_FAIL),
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
  );

  // General Settings
  $group = 'general';
  $form[$group] = array(
    '#type' => 'fieldset',
    '#title' => t('General Settings'),
    '#collapsible' => TRUE,
    '#collapsed' => TRUE,
    '#weight' => -1,
  );

  $form[$group]['market_robot_uid'] = array(
    '#type' => 'textfield',
    '#title' => t('User ID for the Market State Robot'),
    '#default_value' => variable_get('market_robot_uid', MARKET_ROBOT_UID),
    '#weight' => -1,
    '#size' => 20,
    '#maxlength' => '20',
    '#required' => TRUE,
    '#description' => t('The User ID for the user who will perform state changes.  This user should have an advanced role (i.e. administrator) which is allowed to perform the state changes in your trade workflows.  See INSTALL.txt for more details'),
  );

  return system_settings_form($form);
}  

/**
 * Implementation of hook_block().
 */
function market_block($op = 'list', $delta = 0) {
  if ($op == 'list') {
    $blocks[0]['info'] = t('Market: Item Price (bid/ask)');
    $blocks[1]['info'] = t('Market: Items in This Portfolio');
    return $blocks;
  }
  else if ($op == 'view') {
    switch ($delta) {
      case 0:
        if (arg(0) == 'node' && is_numeric(arg(1)) && arg(2) != 'edit') {
          $node = node_load(arg(1));
          if ($node->type == 'item') {
            $block['subject'] = t('Price (may be delayed)');
            $block['content'] = _market_block_bid_ask(arg(1));
          }
        }
        break;
      case 1:
        if (arg(0) == 'node' && is_numeric(arg(1)) && arg(2) != 'edit') {
          $node = node_load(arg(1));
          if ($node->type == 'portfolio') {
            $block['subject'] = t('Items in this portfolio');
            $block['content'] = _market_block_portfolio_contents(arg(1));
          }
        }
        break;
    }
    return $block;
  }
}


function _market_block_bid_ask($item_nid) {
  // Max bid price (buy orders)
  $max_bid = db_result(db_query("SELECT max(ctt.field_price_value) FROM {content_type_trade} ctt INNER JOIN {workflow_node} wn ON ctt.nid = wn.nid WHERE field_item_nid = %d AND field_action_value = 'buy' AND wn.sid in (%d, %d)", 
                                $item_nid, variable_get('market_state_trade_open', MARKET_STATE_TRADE_OPEN), variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED)));
  if ($max_bid > 0) {
    $items[] = t('Highest buy order: %price.', array('%price' => $max_bid));
  }
  else {
    $items[] = t('There are no open buy orders.');
  }
  // Minimum ask (sell orders)
  $min_ask = db_result(db_query("SELECT min(ctt.field_price_value) FROM {content_type_trade} ctt INNER JOIN {workflow_node} wn ON ctt.nid = wn.nid WHERE field_item_nid = %d AND field_action_value = 'sell' AND wn.sid in (%d, %d)", 
                                $item_nid, variable_get('market_state_trade_open', MARKET_STATE_TRADE_OPEN), variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED)));
  if ($min_ask > 0) {
    $items[] = t('Lowest sell order: %price.', array('%price' => $min_ask));
  }
  else {
    $items[] = t('There are no open sell orders.');
  }
  
  // Last order
  $last_nid = db_result(db_query("SELECT max(ctt.nid) FROM {content_type_trade} ctt INNER JOIN {workflow_node} wn ON ctt.nid = wn.nid WHERE field_item_nid = %d AND wn.sid in (%d, %d)", 
                                 $item_nid, variable_get('market_state_trade_executed', MARKET_STATE_TRADE_EXECUTED), variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED)));
  if ($last_nid) {
    $last_price = db_result(db_query("SELECT ctt.field_price_value FROM {content_type_trade} ctt WHERE ctt.nid = %d", 
                                     $last_nid));
    $items[] = t('Last price: %price.', array('%price' => $last_price));
  }
  else {
    $items[] = t('No transactions yet.');
  }
  
  return theme('item_list', $items);
}

function _market_block_portfolio_contents($portfolio_nid) {
  $results = db_query("SELECT n.nid, n.title, cti.field_price_estimate_value FROM node n INNER JOIN content_type_item cti ON n.vid = cti.vid WHERE field_portfolio_nid = %d", $portfolio_nid);
  while ($result = db_fetch_array($results)) {
    $output = l(t('@title: last price @price', array('@title' => $result['title'], '@price' => $result['field_price_estimate_value'])), 'node/'. $result['nid']);
    if (user_access('create trade content')) {
      $output .= ' '. l('buy', 'node/add/trade', NULL, 'edit[field_item][nids]='. $result['nid'] .'&edit[field_action][key]=buy');
      $output .= ' '. l('sell', 'node/add/trade', NULL, 'edit[field_item][nids]='. $result['nid'] .'&edit[field_action][key]=sell');
    }
    $items[] = $output;
  }
  // TODO get the bid/ask for these - maybe slightly intensive so skipped for now.
  return theme('item_list', $items);
}

/*
* Implementation of hook_cron
*/
function market_cron() {
  // TODO some stuff
  // TODO close trades on time based items
  // TODO If it hasn't been done yet, crunch the numbers on yesterday's high/low/average/volume for all items

}

/**
 *  Implementation of hook_exit
 */
function market_exit() {
  // Save the state change for nodes if someone else set a nid for us
  global $_market_state;
  if (is_array($_market_state) && count($_market_state)) {
    foreach ($_market_state as $key => $state) {
      _market_state_change($state['nid'], $state['state'], $state['comment']);
    }
  }

  // Save the remaining change for nodes if someone else set a nid for us
  // We do this at the end instead of along the way in case a single trade gets updated multiple times
  global $_market_remaining;
  if (is_array($_market_remaining) && count($_market_remaining)) {
    foreach ($_market_remaining as $nid => $remaining) {
      _market_remaining_change($nid, $remaining);
    }
  }
}


function _market_state_change($nid, $state, $comment) {
  // Sneaky robot stuff to make sure we can change the state to executed
  global $user;
  $orig_user = $user;
  $user = user_load(array('uid' => variable_get('market_robot_uid', MARKET_ROBOT_UID)));
  // Actually change the state - copied from workflow module
  $node = node_load($nid, NULL, TRUE);
  $node->workflow = $state;
  $node->workflow_comment = $comment;
  $node->revision = 1;
  node_save($node);

  // Set back the sneaky robot business
  $user = $orig_user;
}

function _market_remaining_change($nid, $remaining) {
  $node = node_load($nid, NULL, TRUE);
  $node->field_remaining[0]['value'] = (string)$remaining;
  $node->revision = 1;
  node_save($node);
}

/*
 * Implementation of hook_workflow
 */
function market_workflow($op, $old_sid, $sid, $node) {
  if ($op == 'transition post' && $node->type == 'item') {
    if ($sid == variable_get('market_state_item_closed_success', MARKET_STATE_ITEM_CLOSED_SUCCESS)) {
      // This is a transition post situation, the node is an "item" and it was closed to success
      // So, we give the owners of this item 100 points for each contract they own
      $users = db_query('SELECT n.uid, ctic.field_item_count_value, ctic.field_owned_items_nid FROM node n INNER JOIN content_type_item_count ctic ON n.vid = ctic.vid WHERE field_owned_items_nid = %d', $node->nid);
      while ($user = db_fetch_array($users)) {
          $params = array(
                  'uid' => $user['uid'],
                  'points' => $user['field_item_count_value'] * 100, // TODO make the 100 variable per site (or better - per portfolio)
                  'description' => t('Success for contract number @contract_nid.  Congrats!', array('@contract_nid' => $user['field_item_count_value'])),
                  'event' => 'trade',
                  'reference' => $trade_nid,
          );
          $status = userpoints_userpointsapi($params);

          // MAYBEDO create a workflow where each item_count is moved from a workflow state of OPEN to CREDITED so we can do this in cron runs as well
      }
    }
  }

}

/*
 * Implementation of hook_nodeapi
 */
function market_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) {  
  // TODO for items:
  // TODO Validate the order prior to submit to make sure they can currently enter it
  //    buy orders need to have enough money
  //    sell orders need to have the shares
  // TODO state the upside/downside of the position prior to submission

  // TODO for portfolios:
  // TODO some ability to open/close trading on a portfolio
  // TODO if it's a portfolio buy/sell set the price to 100 and warn the user

  // TODO for items:
  // TODO On load pull up last price

  switch ($op) {
    case 'validate':
      if ($node->type == 'trade' && !isset($node->nid)) {
        // Set the remaining to the quantity


        // Buying - have enough points?
        if ($node->field_action[0]['value'] == 'buy') {
          if (($node->field_price[0]['value'] * $node->field_quantity[0]['value']) > userpoints_get_current_points($node->uid)) {
            form_set_error('field_quantity', t('Insufficient points to purchase this many portfolios. Consider getting more points or reducing the quantity/price.'));
          }
        }

        $item = node_load($node->field_item[0]['nid']);
        if ($item->type == 'portfolio') {
          if ($node->field_price[0]['value'] != 100) {
            form_set_error('field_price', t('Bids on whole portfolios must have a price of 100.'));
          }
          // Selling - have enough items?
          if ($node->field_action[0]['value'] == 'sell') {
            // Get the list of items in this portfolio
            // Do they own all the items in this portfolio?
            // If so, do they own enough of them?

            $fewest = market_portfolio_minimum_ownership($node->uid, $node->field_item[0]['nid']);
            // return array('items' => $fewest_items, 'item_nid' => $fewest_nid);

            if ($fewest === 0) {
              form_set_error('field_quantity', t('You are trying to sell a portfolio where you do not own any of the items in the portfolio.'));
            }
            else if ($fewest['items'] < $node->field_quantity[0]['value']) {
              form_set_error('field_quantity', t('You are trying to sell more items than you own.  You can only sell %fewest or fewer items.', array('%fewest' => $fewest['items'])));
            }
          }
        }
        if ($item->type == 'item') {
          // Make sure that the item is open for trading
          if ($item->_workflow != variable_get('market_state_item_open', MARKET_STATE_ITEM_OPEN)) {
            form_set_error('field_item_nids', t('You are trying to transact in an item which is not available for sale'));
          }
        }
      }
      break;
    case 'insert':
      if ($node->type == 'trade') {
        $item = node_load($node->field_item[0]['nid']);
        // TODO: instead of loading the node, just do one quick query on the node table to get title and type which is all we need
        if ($item->type == 'portfolio' || $item->type == 'item') {
          $userpoints_display_message = variable_get('userpoints_display_message', '1');
          variable_set('userpoints_display_message', '0');

          // This actually does all the work of changing points and recording item counts
          market_transaction($node->field_action[0]['value'], $node->uid, $node->field_price[0]['value'], $node->field_quantity[0]['value'], $node->nid, $item->nid, $item->title, $item->type);

          variable_set('userpoints_display_message', $userpoints_display_message);
        }
        else {
          // Else: what do we do if it's a trade that's not a portfolio or item
          watchdog('market', t('Something is pretty wrong.  In <a href="!uri">this trade</a> a user traded an item which can not be traded', array('!uri' => url('node/'. $node->nid))));
        }
      }
      break;
    default:
      break;
  }
}

/**
 * Implementation of hook_form_alter
 */
function market_form_alter($form_id, &$form) {
  // TODO Remove the remaining quantity from the input form
  if ($form_id == 'trade_node_form') {
    $form['field_remaining'][0]['value']['#type'] = 'hidden';
  }
}

/**
 * Perform the actual transaction inside of a database transaction
 * WORKHERE
 */
function market_transaction($action, $uid, $price, $quantity, $trade_nid, $item_nid, $title, $type) {
  global $_market_state;
  global $_market_remaining;
  $_market_remaining[$trade_nid] = $quantity; // Default this guy

  $txn = new pressflow_transaction();

  // Determine if the quantity should be positive or negative - buy vs. sell
  if ($action == 'buy') {
    $match_action = 'sell';
    $match_sort = ' ASC ';
    $match_compare_order = ' <= ';
  }
  else {
    $match_action = 'buy';
    $match_sort = ' DESC ';
    $match_compare_order = ' >= ';
  }
  
  // We try to execute the portfolios immediately
  if ($type == 'portfolio') {
    if ($action != 'buy') {  // TODO we are now doing this buy thing 3 times - stop that!
      $quantity = -$quantity;
    }

    // Try to transact the points
    $status = _market_point_transaction($action, $uid, $price, $quantity, $trade_nid, $title);

    // Only try to transact the trade if the points transferred properly
    if ($status) {

      $status = _market_portfolio_transaction($item_nid, $quantity, $uid);
      if ($status) {
        $_market_state[] = array('nid' => $trade_nid, 'state' => variable_get('market_state_trade_executed', MARKET_STATE_TRADE_EXECUTED), 'comment' => t('Trade executed'));
        $_market_remaining[$trade_nid] = '0';
      }
      else {
        $_market_state[] = array('nid' => $trade_nid, 'state' => variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), 'comment' => t('Trade invalid - accounting problem.'));
        $_market_remaining[$trade_nid] = abs($quantity);
      }
    }
    else {
        $_market_state[] = array('nid' => $trade_nid, 'state' => variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), 'comment' => t('Trade invalid - points problem.'));
        $_market_remaining[$trade_nid] = abs($quantity);
    }
  }
  else { 
    // Individual items outside a portfolio are checked against the book.
    // If they match the book - execute now.  If not, store for later
    // MAYBEDO: some locking mechanism?
    
    $match = db_fetch_array(db_query_range("SELECT n.nid, n.uid, ctt.field_price_value, COALESCE(ctt.field_remaining_value, ctt.field_quantity_value) quantity, wn.sid state_id FROM {content_type_trade} ctt INNER JOIN {node} n ON ctt.vid = n.vid INNER JOIN {workflow_node} wn ON ctt.nid = wn.nid WHERE field_item_nid = %d AND field_action_value = '%s' AND field_price_value $match_compare_order %d AND wn.sid in (%d, %d) ORDER BY field_price_value %s, nid ASC", 
                                           $item_nid, $match_action, $price, variable_get('market_state_trade_open', MARKET_STATE_TRADE_OPEN), variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED), $match_sort, 0, 1));
    // Coalesce is probably unnecessary, but just in case...
    drupal_set_message(print_r($match, TRUE));
    if ($match['nid']) {

      // Set the quantity to the right number for this situation
      $exact_match = FALSE;
      $more_in_new = FALSE;
      $more_in_existing = FALSE;

      if (abs($quantity) == abs($match['quantity'])) {
        $exact_match = TRUE;
        $trade_quantity = $quantity;
      }
      else if (abs($quantity) > abs($match['quantity'])) {
        $more_in_new = TRUE;
        $trade_quantity = $match['quantity'];
      }
      else {
        $more_in_existing = TRUE;
        $trade_quantity = $quantity;
      }
      // Now we flip the bits for buy/sell
      if ($action == 'buy') {
        $trade_quantity = abs($trade_quantity);
        $match_quantity = -abs($trade_quantity);
      }
      else {
        $trade_quantity = -abs($trade_quantity);
        $match_quantity = abs($trade_quantity);
      }

      // Great, we got a match, begin the transaction
      // Points for the match first (this tests that their order is still valid as well)
      $status = _market_point_transaction($match_action, $match['uid'], $match['field_price_value'], -$trade_quantity, $trade_nid, $title);
      // And now the initiator of the transaction
      if ($status) {
        // Then the initator
        $status = _market_point_transaction($action, $uid, $match['field_price_value'], $trade_quantity, $trade_nid, $title);
      }
      else {
        // That transaction went bad, mark the trade for workflow changes
        _market_state_change($match['nid'], variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), t('Trade found to be invalid during a transaction due to points problems.'));
        // We do this twice - if it's already in the state, the changer will bail because the workflow doesn't allow that transition?  
        // If the transaction got rolled back then this exit change will still happen.  Kinda weird, may need to rethink this.
        $_market_state[] = array('nid' => $match['nid'], 'state' => variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), 
                                 'comment' => t('Trade found to be invalid during a transaction due to points problems.'));
      }

      // And now the items
      if (!$status) {
        // That transaction went bad, mark the trade for workflow changes
        _market_state_change($trade_nid, variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), t('Trade found to be invalid during a transaction due to points problems.'));
        // We do this twice - if it's already in the state, the changer will bail because the workflow doesn't allow that transition?  
        // If the transaction got rolled back then this exit change will still happen.  Kinda weird, may need to rethink this.
        $_market_state[] = array('nid' => $match['nid'], 'state' => variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), 
                                 'comment' => t('Trade found to be invalid during a transaction due to points problems.'));
      }
      else {
        $status = _market_item_transaction($item_nid, $match_quantity, $match['uid']);
      }

      // If that failed, mark the item as invalid and bail
      if (!$status) {
        // asdf
      }
      else { // First accounting worked, mark it, and try the second one
        if ($exact_match || $more_in_new) {
          // That worked and the amount for the existing was fully filled
          _market_state_change($match['nid'], variable_get('market_state_trade_executed', MARKET_STATE_TRADE_EXECUTED), t('Trade completed.'));
          $_market_remaining[$match['nid']] = '0';
        }
        else {
          // Partial fill, set state and remaining shares
          _market_state_change($match['nid'], variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED), t('Trade completed.'));
          $_market_remaining[$match['nid']] = $match['quantity'] - abs($trade_quantity);
        }
        // Try the new trade
        $status = _market_item_transaction($item_nid, $trade_quantity, $uid);
        if (!$status) {
          // That transaction went bad, mark the trade for workflow changes
          // TODO make sure we break out of the trade - if the original is broken then we don't want to do anything else
          $_market_state[] = array('nid' => $trade_nid, 'state' => variable_get('market_state_trade_invalid', MARKET_STATE_TRADE_INVALID), 'comment' => t('Trade found to be invalid during a transaction.'));
          // TODO break; or something like that?
        }
        else { // Succeded, account, recurse if necessary
          // Update the price on the item
          drupal_set_message('updating price to '. $match['field_price_value']);
          $item_node = node_load($item_nid);
          $item_node->field_price_estimate[0]['value'] = $match['field_price_value'];
          node_save($item_node);

          if ($exact_match || $more_in_existing) {
            $_market_state[] = array('nid' => $trade_nid, 'state' => variable_get('market_state_trade_executed', MARKET_STATE_TRADE_EXECUTED), 'comment' => t('Trade completed.'));
            $_market_remaining[$trade_nid] = 0;
          }
          else {
            $_market_state[] = array('nid' => $trade_nid, 'state' => variable_get('market_state_trade_partially_executed', MARKET_STATE_TRADE_PARTIALLY_EXECUTED), 'comment' => t('Trade partially completed.'));
            $_market_remaining[$trade_nid] = abs($trade_quantity) - abs($quantity);
            // TODO If there are more item on this order unsatisfied then 1)mark this as partial executed 2) recurse on this function again, baby            
            market_transaction($action, $uid, $price, abs($_market_remaining[$trade_nid]), $trade_nid, $item_nid, $title, $type); // Subtle but important difference in quantity - use the updated one
          }
        }
      }
      // TODO be sure we set the $_market_state for success
      // TODO be sure we set the $_market_state for ANY failures
    }
  }
  
  // Rollback or end transaction
  if ($status) {    
    // Commit (pressflow transaction things aren't actually committed, you just don't roll them back)
  }
  else {
    unset($_market_remaining); // Stuff went bad so let's not change the remaining share numbers...
    $txn->rollback();
    drupal_set_message(t('Trade was not executed (maybe never will be).'));
  }
  return $status;
}

/**
 * Helper function to make userpoints transactions
 * We have to do this here instead of hook_nodeapi
 */
function _market_point_transaction($action, $uid, $price, $quantity, $trade_nid, $title) {
  $status = TRUE;

  // Try to debit/credit the account
  // Build the userpoints parameters
  $params = array(
                  'uid' => $uid,
                  'points' => $price * $quantity * -1, // -1 because buying a quantity should decrement the points
                  'description' => t('Trade to @action @quantity items of @title at @price in trade id @nid', 
                                     array('@action' => $action, '@quantity' => $quantity, '@title' => $title, '@nid' => $trade_nid, '@price' => $price)),
                  'event' => 'trade',
                  'reference' => $trade_nid,
  );
  $status = userpoints_userpointsapi($params);
  if (!$status['status']) {
    watchdog('market', t('Problem with points: %reason', array('%reason' => $status['reason'])));
  }
  return $status['status'];
}

/**
 *  Quite a simple function, really.  Maintained for API consistency between portfolios and items and in case we need to do more here later.
 */
function _market_item_transaction($item_nid, $quantity, $uid) {
  // Do some stuff?
  $status = TRUE; // Default to TRUE, if we fail along the way it will get flipped
  // Finds all of the item for a portfolio
  $status = _market_account_items($item_nid, $quantity, $uid);
  return $status;
}

/**
 *  Market portfolio transaction - 
 *  $portfolio_nid is the nid of the portfolio
 *  $quanitity - positive to buy, negative to sell
 *  $uid is the username of the person making the trade
 *  
 *  returns TRUE if the transaction was processed, 
 *  FALSE if something prevented it
 */
function _market_portfolio_transaction($portfolio_nid, $quantity, $uid) {
  $status = TRUE; // Default to TRUE, if we fail along the way it will get flipped

  // Finds all of the item for a portfolio
  $results = db_query("SELECT nid FROM {content_type_item} WHERE field_portfolio_nid = %d", $portfolio_nid);
  while (($result = db_fetch_array($results)) && $status) {
    $status = _market_account_items($result['nid'], $quantity, $uid);
  }
  return $status;
}

function _market_account_items($item_nid, $quantity, $uid) {
  $status = TRUE;
  $accounting_nid = FALSE;
  $accounting_nid = db_result(db_query("SELECT n.nid FROM {content_type_item_count} ct INNER JOIN {node} n ON ct.vid = n.vid WHERE field_owned_items_nid = %d AND n.uid = %d", $item_nid, $uid)); //TODO confirm that this works with revisions and everything - maybe we need more join conditions?
    
  if ($accounting_nid) {
    // Update it
    $accounting_node = node_load($accounting_nid, NULL, TRUE);
    $accounting_node->field_item_count[0][value] += $quantity; 
    $accounting_node->revision = 1;
    
    if ($accounting_node->field_item_count[0][value] >= 0) {
      node_save($accounting_node);
    }
    else {
      $status = FALSE;
      $message = t('Transaction failed, it would sell more items than are currently owned.');
      drupal_set_message($message, 'error');
      watchdog('market', $message);
    }
  }
  else if ($quantity > 0) {
    // They don't currently have a item_count - as long as they are buying, create a new node for this item
    $new_node->type = 'item_count';
    $values = array();
    $trading_user = user_load(array('uid' => $uid));
    $values['name'] = $trading_user->name;
    $values['type'] = 'item_count';
    $values['title'] = 'auto generated title'; // TODO better titles
    
    $values['status'] = 1;
    $values['promote'] = 0;
    $values['sticky'] = 0;
    $values['revision'] = 1;
    $values['comment'] = 2;
    $values['field_credit'][0]['value'] = strip_tags($row->byline);
    
    $values['field_owned_items'] = array('nids' => $item_nid); // Caution: if we change the style of the item field to a different widget this might need to be changed as well
    $values['field_item_count'][0]['value'] = $quantity;
    $return = drupal_execute('item_count_node_form', $values, $new_node);
    $errors = form_get_errors();
    if (count($errors)) {
      watchdog('market', print_r($errors, TRUE), 'error');
      $status = FALSE;
      watchdog('market', 'Something went wrong in creating a new item count for this trade');
    }
  }
  // This should really never happen, but in case it does, at least we block and set the stage for a roll back.
  else {
    $status = FALSE;
    drupal_set_message(t('You tried to sell a something that you do not entirely own: item %item_nid, quantity %quantity, user id %uid, ', array('%item_nid' => $item_nid, '%quantity' => $quantity, '%uid' => $uid)), 'error');
  }
  return $status;
}


/**
 * Checks to see which item a user has the fewest of out of a portfolio
 * Returns an array with the number of items and nid of the item
 * If no items are owned, returns 0;
 */
function market_portfolio_minimum_ownership($uid, $portfolio_nid) {
  // MAYBEDO - 2 queries instead of N queries, 1 for items, 1 for owns, then merge
  $itemss = db_query("SELECT nid FROM {content_type_item} WHERE field_portfolio_nid = %d", $portfolio_nid);
  $owns = array();
  while ($item = db_fetch_array($itemss)) {
    $count = db_result(db_query("SELECT field_item_count_value FROM {content_type_item_count} ctcc INNER JOIN {node} n ON ctcc.vid = n.vid WHERE n.uid = %d AND field_owned_items_nid = %d", $uid, $item['nid']));
    $owns[$item['nid']] = $count ? $count : 0;
    if (!isset($fewest_items) || $fewest_items > $owns[$item['nid']]) {
      $fewest_items = $owns[$item['nid']];
      $fewest_nid = $item['nid'];
    }
  }
  if (isset($fewest_items)) {
    return array('items' => $fewest_items, 'item_nid' => $fewest_nid);
  }
  else {
    return 0;
  }
  
}

/**
 * Some default views
 */ 

function market_views_default_views() {
  // Item count (i.e. ownership of contracts)
  $view = new stdClass();
  $view->name = 'item_counts';
  $view->description = 'counts items - arg for uid owning items';
  $view->access = array ();
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = 'Item Counts';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = '';
  $view->page_empty_format = '1';
  $view->page_type = 'table';
  $view->url = 'item_count';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '100';
  $view->sort = array ();
  $view->argument = array (
    array (
      'type' => 'uid',
      'argdefault' => '2',
      'title' => '',
      'options' => '',
      'wildcard' => '',
      'wildcard_substitution' => '',
    ),
  );
  $view->field = array (
    array (
      'tablename' => 'node_data_field_owned_items',
      'field' => 'field_owned_items_nid',
      'label' => 'Item',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
    array (
      'tablename' => 'node_data_field_item_count',
      'field' => 'field_item_count_value',
      'label' => 'Count',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
    array (
      'tablename' => 'node',
      'field' => 'view',
      'label' => 'View',
    ),
    array (
      'tablename' => 'node',
      'field' => 'edit',
      'label' => 'Edit',
      'handler' => 'views_handler_node_edit_destination',
    ),
    array (
      'tablename' => 'users',
      'field' => 'name',
      'label' => 'Owner',
    ),
    array (
      'tablename' => 'node',
      'field' => 'nid',
      'label' => 'NID of Item Count',
    ),
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'item_count',
),
    ),
  );
  $view->exposed_filter = array (
    array (
      'tablename' => 'users',
      'field' => 'uid',
      'label' => 'Counts by user:',
      'optional' => '1',
      'is_default' => '0',
      'operator' => '1',
      'single' => '1',
    ),
  );
  $view->requires = array(node_data_field_owned_items, node_data_field_item_count, node, users);
  $views[$view->name] = $view;

  // Trades
  $view = new stdClass();
  $view->name = 'trades';
  $view->description = 'trades';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = 'Trades';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = 'No trades match your filter (or none exist)';
  $view->page_empty_format = '1';
  $view->page_type = 'table';
  $view->url = 'trades';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '100';
  $view->sort = array (
  );
  $view->argument = array (
  );
  $view->field = array (
    array (
      'tablename' => 'node',
      'field' => 'view',
      'label' => '',
    ),
    array (
      'tablename' => 'node',
      'field' => 'edit',
      'label' => 'Edit',
      'handler' => 'views_handler_node_edit_destination',
    ),
    array (
      'tablename' => 'node',
      'field' => 'delete',
      'label' => '',
      'handler' => 'views_handler_node_delete_destination',
    ),
    array (
      'tablename' => 'node_data_field_item',
      'field' => 'field_item_nid',
      'label' => 'Item to trade',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
    array (
      'tablename' => 'node_data_field_price',
      'field' => 'field_price_value',
      'label' => 'price',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
    array (
      'tablename' => 'node_data_field_quantity',
      'field' => 'field_quantity_value',
      'label' => 'original quantity',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
    array (
      'tablename' => 'node_data_field_remaining',
      'field' => 'field_remaining_value',
      'label' => 'Remaining Quantity',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
    array (
      'tablename' => 'workflow_states',
      'field' => 'state',
      'label' => 'state',
    ),
    array (
      'tablename' => 'users',
      'field' => 'name',
      'label' => 'trader',
    ),
    array (
      'tablename' => 'node_data_field_action',
      'field' => 'field_action_value',
      'label' => 'action',
      'handler' => 'content_views_field_handler_group',
      'options' => 'default',
    ),
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'trade',
),
    ),
    array (
      'tablename' => 'workflow_node',
      'field' => 'sid',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => '2',
),
    ),
  );
  $view->exposed_filter = array (
    array (
      'tablename' => 'workflow_node',
      'field' => 'sid',
      'label' => 'State',
      'optional' => '1',
      'is_default' => '1',
      'operator' => '1',
      'single' => '0',
    ),
  );
  $view->requires = array(node, node_data_field_item, node_data_field_price, node_data_field_quantity, node_data_field_remaining, workflow_states, users, node_data_field_action, workflow_node);
  $views[$view->name] = $view;

  // Items that are available to trade
  $view = new stdClass();
  $view->name = 'available_items';
  $view->description = '';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = '';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = '';
  $view->page_empty_format = '1';
  $view->page_type = 'table';
  $view->url = 'available_items';
  $view->use_pager = FALSE;
  $view->nodes_per_page = '50';
  $view->sort = array (
    array (
      'tablename' => 'node',
      'field' => 'created',
      'sortorder' => 'DESC',
      'options' => 'normal',
    ),
  );
  $view->argument = array (
  );
  $view->field = array (
    array (
      'tablename' => 'node',
      'field' => 'title',
      'label' => '',
      'handler' => 'views_handler_field_nodelink',
      'options' => 'link',
    ),
  );
  $view->filter = array (
    array (
      'tablename' => 'workflow_node',
      'field' => 'sid',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => '11',
  1 => '8',
),
    ),
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'item',
  1 => 'portfolio',
),
    ),
    array (
      'tablename' => 'node',
      'field' => 'status',
      'operator' => '=',
      'options' => '',
      'value' => '1',
    ),
  );
  $view->exposed_filter = array (
  );
  $view->requires = array(node, workflow_node);
  $views[$view->name] = $view;

  return $views;
}

// TODO _later_

/*
+ Keep track of the original price and the clearing price on the trade nodes (since these can be different)
