connect.module

<?php
// $Id: connect.module,v 1.7.2.5 2010/02/28 01:12:03 stevem Exp $

/*
 *  connect.module
 *
 *  steve@openconcept.ca
 *
 *  This module uses a couple of GPL-licensed icons from the
 *  Silk icon set 1.3: http://www.famfamfam.com/lab/icons/silk/
 * 
 */


/**
 * Implementation of hook_help
 */
function connect_help($path, $arg) {
  $output = NULL;
  switch ($path) {
    case 'admin/modules#description':
      $output = t("Allows the creation of online actions, petitions, event registration ... anything where you want to associate two kinds of data in a one-to-many way.");
      break;
    case 'admin/help#connect':
      $output = file_get_contents(drupal_get_path('module', 'connect') .'/connect_help.html');
      break;
  }
  return $output;
}


/**
 * Implementation of hook_perm
 */
function connect_perm() {
  return array(
    'access connect',
    'create connect campaign',
    'manage connect',
  );
}


/*
 * Implementation of hook_cron
 */
function connect_cron() {  
  // clear out expired cached data
  require_once(drupal_get_path('module', 'connect') .'/connect_lookup.php');
  $cache_names = _connect_get_cache_names();
  foreach ($cache_names as $name => $title) {
    $lifetime = variable_get("connect_cache_$name", '0 s');
    list($num, $unit) = sscanf($lifetime, '%d %s');
    if ($num == 0) {
      continue;
    }
    switch ($unit) {
    case 'm' :
      $seconds = 60;
      break;
    case 'h' :
      $seconds = 60*60;
      break;
    case 'd' :
      $seconds = 60*60*24;
      break;
    default :
      continue;
      break;
    }
    $sql = "DELETE FROM {connect_cache} WHERE type='%s' AND created < %d;";
    $result = db_query($sql, $name, time() - $num * $seconds);
  }
}


/**
 * Implementation of hook_theme
 */
function connect_theme() {
	// allow actions to register theme functions
	$themes = array();
	$empty  = array();
  $all_actions = connect_get_actions();
  foreach ($all_actions as $action) {
    $action_theme = call_user_func($action, $empty, $empty, 'theme_register');
    if (!empty($action_theme)) $themes = array_merge($themes, $action_theme);
  }
	return $themes; 
}


/**
 * Implementation of hook_menu
 */
function connect_menu() {
  require_once('connect_actions.php');
  
  $items = array();

  // administer module settings
  $items['admin/settings/connect'] = array(
    'title' => 'Connect',
    'description'   => 'Configure your parent and participant node types.',
    'page callback' => 'connect_admin_overview_page',
    'access arguments' => array('manage connect'),
  );
  
  // register callbacks for connect_action functions
  $empty = array();
  $all_actions = connect_get_actions();
  foreach ($all_actions as $action) {
    $action_menu = call_user_func($action, $empty, $empty, 'menu');
    if (!empty($action_menu)) {
      $items = array_merge($items, $action_menu);
    }
  }
  
  $actions = FALSE;
  $node    = menu_get_object();
  if (connect_is_parent_node($node)) $actions = connect_get_actions($node->nid);

  // parent node: select functions
  $items['node/%connect_node/connect/admin/functions'] = array(
    'title'  => 'Functions',
    'type'   => MENU_LOCAL_TASK,
    'weight' => 5,
    'page callback'    => 'connect_node_config_functions',
		'page arguments'	=> array(1),
    'access callback'  => 'connect_menuitem_admin_access',
		'access arguments'	=> array(1),
  );

  // parent node: configure functions
  $items['node/%connect_node/connect/admin/settings'] = array(
    'title'  => 'Settings',
    'type'   => MENU_LOCAL_TASK,
    'weight' => 6,
    'page callback'    => 'connect_node_config_settings',
		'page arguments'	=> array(1),
    'access callback'  => 'connect_menuitem_admin_access',
		'access arguments'	=> array(1),
  );

/*
 *
 * MOVE to action itself, only use connect_menuitem_admin_access to determine access
 * 
 * 
  // action: cache report tab
  $items['node/%connect_node/connect/cache'] = array(
    'title'  => 'Cache report',
    'type'   => MENU_LOCAL_TASK,
    'weight' => 8,
    'load arguments'   => array($actions),
    'page callback'    => 'connect_node_list_page',
    'access callback'  => 'connect_menuitem_show_cachereport',
  );

  //action: re-send emails tab
  $items['node/%connect_node/connect/resend_failed_mail'] = array(
    'title' => 'Re-send emails',
    'type'   => MENU_LOCAL_TASK,
    'weight' => 10,
    'load arguments'   => array($actions, 'connect_action_send_email'),
    'page callback'    => '_connect_action_send_email_resend_failed',
    'access callback'  => 'connect_menuitem_admin_task',
  );
*/

  /*
  //embedded function  
  $items[] = array(
    'path' => 'connect/embed/'. arg(2),
    'title' => t('Connect Embed'),
    'access'   => TRUE,
    'callback' => '_connect_embed',
    'callback arguments' => array(arg(2)),
    'type'     => MENU_CALLBACK,
  );
  */
 
  return $items;
}



/** connect_menu callbacks **/

// add local tasks to connect campaign nodes only
function connect_node_load($nid = 0) {
  return (connect_is_parent_node_byid($nid)) ? node_load($nid) : FALSE;
}

// allow access to admin items
function connect_menuitem_admin_access(&$node = FALSE) {
	
  return ($GLOBALS['user']->uid == 1 || $GLOBALS['user']->uid == $node->uid || user_access('manage connect'));
}

// generic test for presence of specific action
function connect_menuitem_admin_task(&$node = FALSE, $actions = array(), $task = '') {
  // respect basic connect access control
  if (!connect_menuitem_admin_access($node)) return FALSE;

  // test for presence of given action
  return (in_array($task, $actions));
}

// present a cache report menu item?
function connect_menuitem_show_cachereport(&$node = FALSE, $actions) {
  // respect basic connect access control
  if (!connect_menuitem_admin_access($node)) return FALSE;

  // do we have any cached data?
  foreach ($actions as $action) {
    $desc = call_user_func($action, $node, $child, 'describe', 'parent');
  }
  return (isset($desc['cache']) && $desc['cache'] == TRUE);
}


/**
 *  Implementation of hook_block
 */
function connect_block($op = 'list', $delta = 0, $edit = array()) {
  require_once('connect_blocks.php');
  switch ($op) {
    case 'list':
      return connect_block_list();
      break;
      
    case 'view':
      return connect_block_view($delta);
      break;
  }
}


/**
 *  Implementation of hook_nodeapi
 */
function connect_nodeapi(&$node, $op, $teaser = NULL, $page = NULL) {
  $is_parent = connect_is_parent_node($node);
  $is_child  = $is_parent ? FALSE : connect_is_participant_node($node);
  if (!$is_parent && !$is_child) return;
  require_once('connect_actions.php');

  // prevent PHP4 from throwing a fit
  if (PHP_VERSION < 5) error_reporting(E_ALL ^ E_NOTICE ^ E_WARNING);

  // child nodes
  if ($is_child) {
    // prevent looping
    $lock = "connect_child_lock_$op";
    if (!isset($_SESSION[$lock])) {
      $_SESSION[$lock] = TRUE;
    }
    else {
      return $_SESSION[$lock];
    }

    // call hooks
    $parent =& _connect_parent_node();
    if (!$parent) {
      $temp   = node_load(connect_get_parent($node));
      $parent =& _connect_parent_node($temp);
    }
    connect_call_hooks($parent, $node, $op, 'child');
    
    // release lock
    unset($_SESSION[$lock]);
    return;
  }

  // don't cache me
  global $conf;
  $conf['cache'] = FALSE;
  
  // parent nodes
  switch ($op) {
    case 'delete' :
      // TODO: delete all child nodes too?
      $sql = "DELETE FROM {connect_data} WHERE pid=%d;";
      db_query($sql, $node->nid);
      break;

    case 'view':
			unset($_SESSION["connect_child_lock_insert"]);
			
      if ($teaser == TRUE || !user_access('access connect') || !_connect_captcha_test()) {
        break;
      }
      
      drupal_add_css(drupal_get_path('module', 'connect') .'/connect.css');
      $parent =& _connect_parent_node($node); // save a reference to this node
      $child  = NULL;

      // allow actions to add display items to the node
      $weight = 5; // arbitrary
      $additions = connect_call_hooks($parent, $child, 'display', 'parent');
      foreach ($additions as $function => $add) {
        $node->content[$function] = array(
          '#value'  => t($add['data']),
          '#weight' => $weight++,
        );
      }

      // display messages, forms, etc. depending on status
      $show_form = TRUE;
      $status = connect_call_hooks($parent, $child, 'status', 'parent');
      foreach ($status as $add) {
        if ( isset($add['show_form']) && $add['show_form'] === FALSE ) {
          $show_form = FALSE;
        }
        if ( isset($add['status']) && !empty($add['status']) ) {
          drupal_set_message(t($add['status']));
        }
      }

      // add form
      if ($show_form) {
        $form = drupal_get_form('connect_form_page');
        $node->content['connect_form_page'] = array(
          '#value' => $form,
          '#weight' => 20,
        );
      }
      
      break;
  }
}

/*
 *  Implementation of hook_user
 *
 */
function connect_user($op, &$edit, &$account, $category = NULL) {
  switch ($op) {
  //clear session info on login/out
    case 'logout':
    case 'login':
      foreach ($_SESSION as $key => $value) {
        if (strpos($key, 'connect_') !== FALSE) unset($_SESSION[$key]);
      }
      break;
  }
}


/**
 * Menu callback: cache report
 */
function connect_node_list_page() {
  $nid = arg(1);
  $parent = node_load($nid);
  _connect_parent_node($parent); // cache the parent
  return drupal_get_form('connect_campaign_cache_report_form');
}


/**
 * Menu callback: displays function selection page
 */
function connect_node_config_functions(&$node = FALSE) {
	if ($node) $discard = _connect_parent_node($node);
  require_once('connect_admin.php');
  drupal_set_title(t('Select functions'));
  return drupal_get_form('connect_node_functions_form', $node);
}

/**
 * Menu callback: displays function configuration page
 */
function connect_node_config_settings(&$node = FALSE) {
	if ($node) $discard = _connect_parent_node($node);
  require_once('connect_admin.php');
  drupal_set_title(t('Function settings'));
  return drupal_get_form('connect_node_settings_form', $node);
}

/**
 * Menu callback; displays the connect administration page.
 */
function connect_admin_overview_page() {
  require_once('connect_admin.php');
  drupal_set_title(t('Connect settings'));
  return drupal_get_form('connect_admin_form');
}


/**** FORM: participate ****/

function connect_forms() {
  $forms['connect_form_page'] = array(
    'callback' => 'connect_form',
    'callback arguments' => array('page'),
  );
  $forms['connect_form_block'] = array(
    'callback' => 'connect_form',
    'callback arguments' => array('block'),
  );
  return $forms;
}

/** wrappers for page and block form processing **/

function connect_form_page_validate($form, &$form_state) {
  connect_form_validate($form, $form_state);
}

function connect_form_page_submit($form, &$form_state) {
  connect_form_submit($form, $form_state);
}

function connect_form_block_submit($form, &$form_state) {
  connect_form_submit($form, $form_state);
}

function connect_form_block_validate($form, &$form_state) {
  connect_form_validate($form, $form_state);
}


/** added argument for block view **/

function connect_form($type = 'page') {
  $parent =& _connect_parent_node();
  if (!$parent || !isset($parent->nid)) return;
  
  $participant_type = connect_node_options($parent->nid, 'participant_type');
  if (!$participant_type) return;

  // generate form using CCK function
  module_load_include('inc', 'content', 'includes/content.node_form');
  $child_form_state = array();
  $child_form['type']['#value'] = $participant_type;
  $form = content_form($child_form, $child_form_state);

	// remove default admin fields (leaving only data fields)
  unset($form['type']);
  unset($form['#field_info']);
  unset($form['#cache']);
  
  // remove some fields (hidden, computed)
  $cck_type = content_types($participant_type);
  foreach ($cck_type["fields"] as $field) {
    if ($field['display_settings']["teaser"]["format"] == "hidden" || $field['display_settings']["full"]["format"] == "hidden" || $field["type"] == "computed") {
      unset($form[ $field['field_name'] ]);
    }
  }

  // allow action functions to alter the form
  connect_call_hooks($parent, $form, 'form_alter', 'child');

  // add call to action
  $form['call_to_action'] = array(
    '#prefix' => '<div id="connect-form-title">',
    '#value' => t(connect_node_options($parent->nid, 'call_to_action')),
    '#suffix' => '</div>',
    '#weight' => -10,
  );

  // pass the participant type along so that a custom form can be generated in the template, if desired
  $form['participant_type'] = array(
    '#type' => 'hidden',
    '#value' => "$participant_type",
  );

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Submit'),
    '#weight' => 15,
  );
  
  return $form;
}


function connect_form_validate($form, &$form_state) {
  // call connect functions validation
  $parent =& _connect_parent_node();
  $results = connect_call_hooks($parent, $form_state['values'], 'validate', 'child');
  if (!empty($results)) {
    foreach ($results as $result) {
      if ($result['value'] == FALSE) form_set_error('', $result['message']);
    }
  }

  // call cck fields validation
  $return       = array();
  $nothing      = array();
  $cck_type     = content_types($form_state['values']['participant_type']);
  $cck_fields   = $cck_type['fields'];
  $widget_types = _content_widget_types();  
  foreach ($form_state['values'] as $form_field => $field_value) {
    $module   = $widget_types[$cck_fields[$form_field]['widget']['type']]['module'];
    $function = $module .'_field'; 
    if (function_exists($function)) {
      $result = $function('validate', $nothing, $cck_fields[$form_field], $form_state['values'][$form_field], '', '');
    }
  }
}

function connect_form_submit($form, &$form_state) {
  // build CCK node
  foreach ($form_state['values'] as $key => $value) {
    // simple form elements
    if (isset($value[0])) {
      $node_cck->$key = array($value[0]);
    }
    // single-value elements
    elseif (isset($value['key'])) {
      $node_cck->$key = array(array('value' => $value['key']));
    }
    // multi-value elements
    elseif (isset($value['keys'])) {
      // select lists
      if (is_array($value['keys'])) {
        foreach ($value['keys'] as $item_key => $item_value) {
          if ($item_key === $item_value) {
            $temp_array[] = array('value' => $item_value);
          }
        }
        $node_cck->$key = $temp_array;
      }
      // checkboxes
      else {
        $node_cck->$key = array(array('value' => $value['keys']));
      }
    }
  }

  $parent          =& _connect_parent_node();
  $node_cck->nid   = NULL;
  $node_cck->type  = connect_node_options($parent->nid, 'participant_type');
  $node_cck->title = 'participant in \''. $parent->title .'\'';
  node_save($node_cck);
  
  // allow actions to change redirected page
  $target   = 'node/'. $parent->nid;
  $redirect = connect_call_hooks($parent, $node_cck, 'redirect', 'parent');
  if (!empty($redirect)) {
    // just grab first one ... yech, but necessary
    $keys = array_keys($redirect);
    $target = $redirect[$keys[0]];
  }
  
  $form_state['redirect'] = $target;
}


/********************************
 *   UTILITY FUNCTIONS
 ********************************/

// is this node a participant node?
function connect_is_participant_node(&$node) {
  $participant_nodes = variable_get('connect_participant_nodes', array());
  $return = in_array($node->type, $participant_nodes);
  if ( $return ) {
    $sql = 'SELECT pid FROM {connect_data} WHERE nid = %d';
    $parent = db_result(db_query($sql, $node->nid));
    if ($parent) $node->parent_id[0]['value'] = $parent;
  }
  return $return;
}


// is this node type a parent node type?
function connect_is_parent_node(&$node = FALSE) {
  if (!$node) return FALSE;
  $parent_nodes = variable_get('connect_parent_nodes', array());
  return (in_array($node->type, $parent_nodes));
}


// is this nid a parent node type?
function connect_is_parent_node_byid($nid = FALSE) {
  if (!$nid) return FALSE;
  $node = node_load($nid);
  return connect_is_parent_node($node);
}


// test for valid canadian postal code
function connect_is_postalcode($code) {
  $regexp = '/^[a-zA-Z][0-9][a-zA-Z]\s*[0-9][a-zA-Z][0-9]$/';
  return preg_match($regexp, $code);
}


// get db info for CCK field
function _connect_get_cck_db_info($type) {
  $field   = content_fields($type);
  $db_info = content_database_info($field);
  return $db_info;
}


// gets form value key(s) for cck field
function connect_get_field_keys($field) {
  if ($field == 'title' || $field == 'body' ) {
    return array('value');
  }
  $test_db = _connect_get_cck_db_info($field);
  if (isset($test_db['columns'])) {
    return array_keys($test_db['columns']);
  }
  else {
    return array();
  }
}


// counts the participants for a parent
function connect_participant_count(&$parent) {
  $sql   = "SELECT count(*) FROM {connect_data} WHERE pid = %d";
  $count = db_result(db_query($sql, $parent->nid));
  return $count;
}



// return an array of participant node types suitable for use in forms
function connect_participant_types_options() {
  $array = array();
  $values = variable_get('connect_participant_nodes', array() );
  foreach ($values as $value) {
    $array[$value] = $value;
  }
  return $array;
}


/**
 * Returns an array of action functions
 * if an nid is passed in, returns the declared functions for that parent
 * otherwise, it returns all the available actions
 */
function connect_get_actions($parent_id = FALSE) {
	static $functions = array();
	
	$key = $parent_id ? (int)$parent_id : 'all';
	
  if (!isset($functions[$key])) {
		if ($key == 'all') {
			$actions = module_invoke_all('connect');
			$array   = array_keys($actions);
		}
		else {
      $array = connect_node_options($key, 'connect_actions');
      if (empty($array)) $array = array('connect_action_basic');
		}
    $functions[$key] = $array;
	}
  return $functions[$key];
}


/**
 * returns an array of arrays mapping action variables onto CCK fields
 * array( 'parent' => array( action => cck, ... ), 'child' => array( action => cck, ... ) )
 */
function connect_get_map($parent_id = 0) {
  static $maps = array();
  if ( !isset($maps[$parent_id]) ) {
    $maps[$parent_id] = connect_node_options($parent_id, 'connect_map');
  }
  return $maps[$parent_id];
}


/**
 * determines all the required variables for a given campaign node
 * @ return
 *  array( 'parent' => array(), 'child' => array(), 'variables' => array() )
 */
function connect_get_required_vars(&$parent_node, &$child_node) {
  if (empty($parent_node)) return;
  
  $parent = $child = $variables = array();
  $vars_done = array();

  $function_vars = connect_call_hooks($parent_node, $child_node, 'requires', 'parent');  
  foreach ($function_vars as $fn_name =>  $fn_requires) {
    foreach (array('parent', 'child') as $target ) {
      if (isset($fn_requires[$target])) {
        $$target = array_merge( $$target,  $fn_requires[$target] );
      }
    }
    if (isset($fn_requires['variables'])) {
      foreach ($fn_requires['variables'] as $name => $item) {
        if (!isset($vars_done[$name])) {
          $vars_done[$name] = TRUE;
          $variables[$fn_name][$name] = $item;
        }
      }
    }
  }
  
  return array(
    'parent'    => $parent,
    'child'     => $child,
    'variables' => $variables,
  );
}


/**
 *  determine the content fields in a node type and
 *  return as an array for use in admin forms
 */
function connect_get_node_fields( $typename ) {
  $options = array( 0 => '', 'title' => 'Title' );
  // body?
  $type = node_get_types('type', $typename);
  if ($type->has_body) $options['body'] = 'Body';
  $cck_type = content_types($typename);
  $fields   = $cck_type["fields"];
  if (!empty($fields)) {
    foreach ($fields as $field) {
      $options[$field['field_name']] = $field['widget']['label'];
    }
  }
  //asort($options);
  return $options;
}


/**
 * returns or sets the required value from $target = child | parent
  if $value is set, this is a setter, otherwise, it's a getter
 */
function connect_value($variable = '', &$parent, &$child, $target = '', $value=FALSE) {
  $return = '';
  if (!empty($variable) && isset($parent->nid) && ($target == 'child' || $target == 'parent')) {
    $map  = connect_get_map($parent->nid);
    $var  = $map[$variable];
    $path = _connect_get_field_path($$target, $var);
    if (!$path) return FALSE;
    
    if (!$value) {
      $exp = '$return = stripslashes($'. $target . $path .');';
      eval($exp);
    }
    else {
      $exp = '$'. $target . $path .' = "'. addslashes(trim($value)) .'";';
      eval($exp);
    }
  }
  return $return;
}


/**
 * Returns the correct object or array path to retrieve a node field value
 */
function _connect_get_field_path( $target = FALSE, $var = FALSE) {
  if (!$target || !$var) return FALSE;

  $path = '';
  // standard fields
  if ($var == 'body' || $var == 'title') {
    if (is_object($target)) {
      $path = "->$var";
    }
    else {
      $path = "['$var'][0]['value']";
    }

  // cck fields
  }
  elseif (!empty($var)) {
    $key  = connect_get_field_keys($var);
    if (is_object($target)) {
      $var = "->$var";
    }
    else {
      $var = "['$var']";
    }
    $path = $var .'[0][\''. $key[0] .'\']';
  }
  return $path;
}


/**
 * Returns the admin options for a parent node
 * @param $nid: the node id of the parent
 * @param $field: the name of the option to retrieve | NULL to retrieve all
 * @param $value: if provided, sets $field to $value
 *
 */
function connect_node_options($nid = 0, $field = NULL, $value = NULL) {
  if (empty($nid)) return FALSE;

  // cache this info
  static $options = array();
  if (!isset($options[$nid])) {
    $temp = variable_get('connect_'. $nid .'_options', FALSE);
    $options[$nid] = $temp ? unserialize($temp) : array();
  }

  // setter
  if ($value !== NULL && $field !== NULL) {
    $options[$nid][$field] = $value;
    variable_set( 'connect_'. $nid .'_options', serialize($options[$nid]) );
  }

  // getter
  if ($field !== NULL) {
    $return = isset($options[$nid][$field]) ? $options[$nid][$field]: '';
  }
  else {
    $return = $options[$nid];
  }

  return $return;
}


/**
 * Iterates through connect action functions and calls them for the current operation and target
 */
function connect_call_hooks(&$parent, &$child, $op = '', $target = 'child') {
  $return = array();

  // parent always required, child only if acting on child, operation always required
  if (!$op || !$parent || ($target=='child' && !$child)) return $return;

  // make sure we have a child array, even if empty
  if (empty($child)) $child = array();

  // display what hooks are called in what order
  $debug_hooks = (connect_node_options($parent->nid, 'debug_hooks') == 'yes'); 
  if ($debug_hooks) {
    $debug_parent = empty($parent) ? 'empty' : gettype($parent);
    $debug_child  = empty($child)  ? 'empty' : gettype($child);
    drupal_set_message("$op ($target | $debug_parent | $debug_child)");
  }

	$actions     = connect_get_actions($parent->nid);
  $actions_all = module_invoke_all('connect');
  
  foreach ($actions as $action) {
    // make sure we have the required vars before calling the function
    // skip check for purely informational $op values
    $skip_check = array('requires', 'admin-validate');
    if (!in_array($op, $skip_check)) {
      if (_connect_hook_check_requirements($parent, $child, $action, $target) !== TRUE) {
        continue;
      }
    }

    // call the hook
    $action_return = call_user_func($action, $parent, &$child, $op, $target);
    if ($action_return) $return[$action] = $action_return;
    
    // debug return value
    if ($debug_hooks) drupal_set_message("$action $op : " . print_r($action_return, TRUE)); 
  }
  
  return $return;
}


/*
 *  tests to see that the required settings are present for a given action
 */
function _connect_hook_check_requirements(&$parent, &$child, $action, $target) {
  static $requirements_ok = array();
  if (!isset($requirements_ok[$action])) {
    $required = call_user_func($action, $parent, $child, 'requires', $target);   
    if (empty($required)) return TRUE; // no settings = no requirements, but let's not cache that

    // default to true, test for exceptions
    $requirements_ok[$action] = '';
    
    // parent + child fields, all required
    $map = connect_get_map($parent->nid);
    if (is_array($map)) {
      $map_keys = array_keys($map);
      foreach (array('parent', 'child') as $type) {
        if (isset($required[$type])) {
          foreach ($required[$type] as $name => $desc) {
            if (!in_array($name, $map_keys) || empty($map[$name])) {
              $requirements_ok[$action] .= "'$desc' (required field in $type node)<br />\n";
            }
          }
        }
      }
    }
    
    // settings, might be optional
    if (isset($required['variables'])) {
      foreach ($required['variables'] as $name => $desc) {
        $value = connect_node_options($parent->nid, $name);
        if ($desc['#required'] == TRUE && empty($value)) {
            $requirements_ok[$action] .= $desc['#title'] . "<br />\n";
        }
      }
    }

    // return TRUE or a message
    if (empty($requirements_ok[$action])) $requirements_ok[$action] = TRUE;
  }
  return $requirements_ok[$action];
}

/*
 *  determine parent nid for child node
 */
function connect_get_parent(&$child) {
  if (empty($child->nid)) return 0;
  
  static $parents = array();
  if (!isset( $parents[$child->nid])) {
    $sql = "SELECT pid FROM {connect_data} WHERE nid = %d;";
    $parents[$child->nid]= db_result(db_query($sql, $child->nid));
  }
  $child->connect_parent_id = $parents[$child->nid];
  return $parents[$child->nid];
}


/*
 *  determines if connect_form captcha is required, and if so, if it's enabled
 */
function _connect_captcha_test($form_id = 'connect_form_page') {
  $captcha_required = variable_get('connect_captcha_required', 'yes');
  if ($captcha_required == 'yes') {
    $captcha = db_result(db_query("SELECT type FROM {captcha_points} WHERE form_id = '%s'", $form_id));
    if (!$captcha) {
      if (!user_access('skip CAPTCHA')) {
        watchdog('connect', 'connect form cannot be displayed: no CAPTCHA defined', array(), WATCHDOG_DEBUG);
        return FALSE;
      }
      else {
        drupal_set_message('Warning: CAPTCHA has not been configured for connect forms yet.');
      }
    }
  }
  return TRUE;
}


/*
 *  use this wherever it's necessary to load the parent
 *  enforces a singleton pattern to solve reference problems in PHP4
 *
 *  made it an array to fix problems with displaying the form in a block
 *  (it is called twice when a block is visible and the current node is also a campaign)
 */
function &_connect_parent_node($node = NULL) {
  static $parent_node = array( 0 => NULL );
  if ($node == NULL) $node = menu_get_object();
  $nid = isset($node->nid) ? $node->nid : 0;
  if (!isset($parent_node[$nid])) {
    $parent_node[$nid] = $node;
  }
  return $parent_node[$nid];
}


/*
 *  returns cck fields in array for use in forms
 */
function _connect_get_child_fields($child_type = NULL) {
  $cck_options = array();
  if ($child_type) {
    $cck_info = _content_type_info();
    $cck_vars = $cck_info['content types'][$child_type]['fields'];
    foreach ($cck_vars as $name => $field) {
      if ($field['display_settings']['teaser']['format'] != 'hidden' && $field['display_settings']['full']['format'] != 'hidden') {
        $cck_options[$name] = $field['widget']['label'];
      }
    }
    $cck_options[''] = '';
    asort($cck_options);
  }
  return $cck_options;
}


/*
 * accept a range of values that mean 'yes'/true
 */
function _connect_positive_value($in) {
  $positive_strings = array('y', 'yes', 'true', 'ok', '1');
  if ( $in === TRUE || in_array(strtolower($in), $positive_strings)) {
    return TRUE;
  }
  else {
    return FALSE;
  }
  //if (empty($in) || strtolower($in) == 'no' || strtolower($in) == 'n') {
  //  return FALSE;
  //}
  //else {
  //  return TRUE;
  //}
}


/*
 *  menu callback: display the participants
 */
function _connect_action_display_participants($parent_nid = NULL) {
  $output = FALSE;
  if (is_numeric($parent_nid)) {
    $parent = node_load($parent_nid);
    drupal_set_title('"'. $parent->title .'" '. connect_node_options($parent->nid, 'participant_title'));

    // determine display field names
    $header = array();
    $display_fields = variable_get('connect_'. $parent->nid .'_options', FALSE);
    if (!$display_fields) return;
  
    $display_fields = unserialize($display_fields);
    foreach ($display_fields as $key => $value) {
      if (empty($value) || strpos($key, 'display_participants_fields_') === FALSE) {
        unset($display_fields[$key]);
      }
    }
    
    // set header
    $child_type  = connect_node_options($parent->nid, 'participant_type');
    $cck_options = _connect_get_child_fields($child_type);
    foreach ($display_fields as $key => $value) {
      $header[] = $cck_options[$value];
    }

    // double opt-in? 
    $double_opt_in = (in_array('connect_action_double_optin', connect_get_actions($parent->nid)));
    
    // walk through participants
    $pager  = connect_node_options($parent->nid, 'display_participants_pager');
    if (!$pager) $pager = 25; 
    $data   = array();
    $sql    = "SELECT nid FROM {connect_data} WHERE pid = %d";
    $result = pager_query($sql, $pager, 0, NULL, $parent->nid);
    while ($row = db_fetch_object($result)) {
      $this_item = array();
      $child   = node_load($row->nid);
      $display = connect_value('display_participants_displayme', $parent, $child, 'child');
      
      // double opt-in?
      if ($double_opt_in) {
        $opt_in = connect_value('double_optin_token', $parent, $child, 'child');
        if (!_connect_positive_value($opt_in)) continue;
      }
      
      if (_connect_positive_value($display)) {
        foreach ($display_fields as $key => $value) {
          $path = _connect_get_field_path($child, $value);
          $exp = '$this_item[] = $child'. $path .';';
          eval($exp);
        }
        $data[] = $this_item;
      }
    }
    if (empty($data)) return theme('page', '<p>no participants</p>');
  }

  $link    = theme('connect_action_display_participants_return', $parent->title, $parent->nid);
  $output  = theme_table($header, $data) . $link;
  $output .= theme('pager', NULL, $pager);
  return $output;
}


/** report for admins **/

function connect_campaign_cache_report_form() {
  $parent =& _connect_parent_node();
  $form = array();

  // intro
  $form['report_intro'] = array(
    '#value' => 'This form allows you to create reports based on when participant data was cached by connect. If you keep persistent caches, this offers a rough measurement of the number of participants who are new to your system. Note that this assumes you are using a connect feature that uses caching (such as email target lookups) and that caching has been turned on.',
  );
  
  // date
  $form['report_date'] = array(
    '#type' => 'date',
    '#title' => 'Date',
  );
  
  // operator
  $form['report_operator'] = array(
    '#type' => 'radios',
    '#title' => 'Date range',
    '#options' => array('Before this date', 'On or after this date'),
  );

  // type of report
  $form['report_type'] = array(
    '#type' => 'radios',
    '#title' => 'Type of report',
    '#options' => array('Numeric report', 'CSV'),
  );

  // cache to test
  require_once(drupal_get_path('module', 'connect') .'/connect_lookup.php');
  $cache_names = _connect_get_cache_names();
  $form['report_cache'] = array(
    '#type' => 'radios',
    '#title' => 'Cache to query',
    '#description' => 'Connect maintains a number of caches, each of which can be set to expire independently. Please select the cache that will be the basis of your query.',
    '#options' => $cache_names,
  );

  // relevant participant field
  $child_type  = connect_node_options($parent->nid, 'participant_type');
  $cck_options = _connect_get_child_fields($child_type);
  unset($cck_options['']);
  $form['report_field'] = array(
    '#type' => 'radios',
    '#title' => 'Cached participant field',
    '#description' => 'Please select the participant item that is cached as the "source" of the lookup (i.e., if the chosen cache stores the results of "Postal code to riding" lookups, select the participant field holding the postal code).',
    '#options' => $cck_options,
  );

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Submit'),
  );

  return $form;
}


function connect_campaign_cache_report_form_submit($form, &$form_state) {
  $output = '';
  $parent =& _connect_parent_node();
  
  // date
  $date = sprintf('%04d%02d%02d 00:00:00', $form_state['values']['report_date']['year'], $form_state['values']['report_date']['month'], $form_state['values']['report_date']['day']);
  $date = strtotime($date);
  
  // participant field
  $cck_db     = _connect_get_cck_db_info($form_state['values']['report_field']);
  $cck_table  = $cck_db['table'];
  $cck_column = $cck_db['columns']['value']['column'];

  // date operator
  $modal = ($form_state['values']['report_operator'] == 0) ? '<': '>=';

  // CSV reports: set header
  if ($form_state['values']['report_type'] > 0) {
    $child_type   = connect_node_options($parent->nid, 'participant_type');
    $child_fields = _connect_get_child_fields($child_type);
    unset($child_fields['']);
    $output = join(',', array_values($child_fields)) ."\n";
  }
    
  // loop through all children
  $path = FALSE;
  $sql  = "SELECT d.nid from {connect_data} d WHERE d.pid=%d;";
  $result = db_query($sql, $parent->nid);
  while ($row = db_fetch_object($result)) {
    $child = node_load($row->nid);
    if (!$path) {
      $path = _connect_get_field_path($child, $form_state['values']['report_field']);
    }
    eval('$value = strtoupper($child'. $path .');');
    $value = preg_replace('/[^0-9A-Z]/', '', $value);

    // match value, date parameters
    $sql = "SELECT count(*) as total FROM {connect_cache} WHERE type='%s' AND source='%s' AND created $modal %d;";
    $count  = db_query($sql, $form_state['values']['report_cache'], $value, $date);
    $number = db_result($count);
    if ($number > 0) {
      $cached_total++;
      if ($form_state['values']['report_type'] > 0) {
        foreach ($child_fields as $field => $title) {
          $path = _connect_get_field_path($child, $field);
          eval('$item = $child'. $path .';');
          $line[] = '"'. str_replace('"', '""', $item) .'"';
        }
        if (!empty($line)) {
          $output .= join(',', $line) ."\n";
          $line = '';
        }
      }
    }
  }
  
  // display numeric report
  if ($form_state['values']['report_type'] == 0) {
    $total = connect_participant_count($parent);
    drupal_set_message("total participants: $total");
    drupal_set_message("cached since ". date('d M Y', $date) .": $cached_total");
    return;
  }
  // CSV reports
  else {
    header("Expires: 0");
    header("Cache-control: private");
    header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
    header("Content-Description: File Transfer");
    header("Content-Type: application/vnd.ms-excel");
    header("Content-disposition: attachment; filename=report.csv");
    echo $output;
    die();
  }
}


/** VIEWS **/
/*
function connect_views_tables() {
  $tables = array();
  $table  = array(
    'name' => 'connect_data',
    'join' => array(
      'inner' => array(
        'table' => 'node',
        'field' => 'nid',
      ),
      'extra' => array(
        'pid' => $parent_id
      ),
    ),
    'filters' => array(
      'connect_data' => array(
        'name' => t('Connect: participant in action'), 
        'help' => t('Specify the nid of a connect campaign to restrict the display to participants in that campaign'),
        'field' => '',
      ),
    ),
  );
  $tables['connect_data'] = $table;
  return $tables;
}
*/