progression.module

<?php
// $Id$

define('PROGRESSION_ENUM_COUNT_UP',   'up');
define('PROGRESSION_ENUM_COUNT_DOWN', 'down');

/**
 * Display help and module information.
 *
 * @param string $path which part of the site we're displaying help in
 * @param array  $arg  an array containing the current path as returned from that arg function
 * @return string help text contextualized by the path parameter
 */
function progression_help($path, $arg) {
    switch ($path) {
    case 'admin/help#progression':
        return '<p>' . t('Facilitates the management and display of user-specified countups and countdowns.') . '</p>';
    }

    return '';
}

/**
 * Defines the human-readable name of node types and other attributes.
 *
 * @return array an array of information concerning this module's node types
 */
function progression_node_info() {
    return array(
        'progression' => array(
            'name' => t('Counter'),
            'module' => 'progression',
            'description' => t('A user-created counter object that counts down to or up from a specified target date.')
        )
    );
}

/**
 * Defines a set of valid permissions for this module.
 *
 * @return array an array of (nonduplicated) valid permissions for this module
 */
function progression_perm() {
    return array('create counter', 'edit own counter');
}

/**
 * Limits access to specific node types based on user privileges.
 *
 * @param string  $op      one of ('create', 'delete', 'update', 'view')
 * @param object  $node    the node on which the operation is to be performed
 * @param array   $account represents the user for whom the operation is to be performed
 * @return boolean TRUE if the operation is allowed based on the node type and account privileges, FALSE if the operation is to be denied,
 *                 and null to not override the settings in the node_access table or access control modules
 */
function progression_access($op, $node, $account) {
    if ($op == 'create') {
        return user_access('create counter', $account);
    }

    if (($op == 'update') || ($op == 'delete')) {
        if (user_access('edit own counter', $account) && ($account->uid == $node->uid)) {
            return TRUE;
        }
    }
}

/**
 * Enables module to register paths, which determines how incoming requests are to be handled. Depending on the type of 
 * registration requested by each path, a link is placed in the navigation block and / or an item appears in the
 * menu administration page.
 *
 * @return array an array of menu items. each menu item has a key corresponding to the path being registered
 */
function progression_menu() {
    $items['counter'] = array(
        'title' => 'Progression',
        'access callback' => TRUE,
        'access arguments' => array('access content'),
        'type' => MENU_CALLBACK,
        'page callback' => 'progression_counter_json'
    );
    $items['admin/settings/progression'] = array(
        'title' => 'Progression',
        'description' => 'Configure settings related to Progression counters.',
        'page callback' => 'drupal_get_form',
        'page arguments' => array('progression_admin_settings'),
        'access arguments' => array('administer progression'),
        'type' => MENU_NORMAL_ITEM,
        'file' => 'progression.admin.inc'
    );

    return $items;
}

/**
 * Generates a JSON representation of the given node.
 */
function progression_counter_json() {
    // if: the counter url suffix has more than one path segment
    // then: we're dealing with a malformed url. throw a 404 and return
    if (func_num_args() > 1) {
        drupal_not_found();
        return;
    }

    // if: there were no suffix path segments
    if (!func_num_args()) {
        progression_output_json_response(progression_fetch());
    }
    // else: there's exactly 1 path segment
    else {
        $param = trim(func_get_arg(0));

        if (is_numeric($param)) {
            progression_output_json_response($param);
        }
        else if (in_array($param, array(PROGRESSION_ENUM_COUNT_UP, PROGRESSION_ENUM_COUNT_DOWN))) {
            progression_output_json_response(progression_fetch($param));
        }
        else {
            drupal_not_found();
        }
    }
}

/**
 * Accepts either a node ID or array of node IDs and prints a JSON representation.
 *
 * @param array/number $param either a node ID or array of node IDs
 */
function progression_output_json_response($param) {
    $data = array();
    $nids = array();

    if (is_array($param)) {
        $nids = $param;
    }
    else if (is_numeric($param)) {
        array_push($nids, $param);
    }

    foreach ($nids as $nid) {
        $jsonNode = progression_build_json_node($nid);
        if ($jsonNode) {
            array_push($data, $jsonNode);
        }
    }

    // if: a callback GET parameter was sent
    // then: output a wrapper around the JSON data to be compatible with JSONP (used for cross-domain AJAX)
    if (isset($_GET['callback']) && strlen($_GET['callback'])) {
        drupal_set_header('Content-Type: text/javascript; charset=utf-8');
        print $_GET['callback'] . '(' . drupal_to_js($data) . ')';
        return;
    }

    drupal_json($data);
}

/**
 * Accepts a single node ID and returns an associative array representing the applicable fields to be included in 
 * the JSON output
 *
 * @return array applicable node fields to be included in the JSON output
 */
 function progression_build_json_node($nodeID) {
    if (!is_numeric($nodeID)) return FALSE;

    $node = node_load(
        array('type' => 'progression', 'nid' => $nodeID)
    );

    if (!$node || !intval($node->status)) return FALSE;

    return array(
        'title' => isset($node->title) ? $node->title : '',
        'counterType' => isset($node->counterType) ? $node->counterType : '',
        'targetDate' => isset($node->targetDate)
            ? strtotime($node->targetDate['year'] . '/' . $node->targetDate['month'] . '/' . $node->targetDate['day']) 
            : '',
        'description' => isset($node->description) ? nl2br(htmlentities($node->description)) : ''
    );
 }

/**
 * Fetches progression counter objects.
 *
 * @return array an array of progression counter node IDs
 */
function progression_fetch() {
    $queryArgs = array();
    $andFilters = array();
    $joinTables = array();

    if (isset($_GET['user']) && strlen($_GET['user'])) {
        array_push($andFilters, "u.name = '%s'");
        array_push($queryArgs, $_GET['user']);
        array_push($joinTables, 'users');
    }
    else if (isset($_GET['uid']) && is_numeric($_GET['uid']) && ($_GET['uid'] > 0)) {
        array_push($andFilters, 'u.uid = %d');
        array_push($queryArgs, $_GET['uid']);
        array_push($joinTables, 'users');
    }

    $joins = array();
    if (in_array('users', $joinTables)) {
        array_push($joins, 'INNER JOIN {users} u ON (u.uid = pc.uid)');
    }

    if (func_num_args()) {
        $param = trim(func_get_arg(0));
        if (in_array($param, array(PROGRESSION_ENUM_COUNT_UP, PROGRESSION_ENUM_COUNT_DOWN))) {
            array_push($andFilters, "pc.counterType = '%s'");
            array_push($queryArgs, $param);
        }
    }

    $query = 'SELECT nid FROM {progression_counter} pc ' . join(' ', $joins) 
             . (count($andFilters) ? ' WHERE ' . join(' AND ', $andFilters) : '');

    $result = count($queryArgs) ? call_user_func_array('db_query', array_merge(array($query), $queryArgs))
                                : db_query($query);
    $nids = array();
    while ($counter = db_fetch_array($result)) {
        $nids[] = $counter['nid'];
    }

    return $nids;
}

/**
 * Generate block content.
 *
 * @param string  $op    one of ('list', 'configure', 'view', 'save')
 * @param integer $delta block identifier
 * @param array   $edit  used in conjunection with the 'save' $op parameter
 * @return string generated block content
 */
function progression_block($op = 'list', $delta = 0, $edit = array()) {
    // TODO: need to address block out put at some point...
    switch ($op) {
    // generate a list of all module blocks for the admin / block page
    case 'list':
        $block[0]['info'] = t('Countdowns');
        $block[1]['info'] = t('Countups');
        return $block;

    case 'configure':
        break;

    case 'view':
        break;

    case 'save':
        break;
    }
}

/**
 * Displays a node editing form.
 * 
 * @param object  $node       the node being added or edited
 * @param array   $form_state the form state array
 * @return array an array containing the form elements to be displayed in the node edit form
 */
 function progression_form(&$node, $form_state) {
    $type = node_get_types('type', $node);

    if ($type->has_title) {
        $form['title'] = array(
            '#type' => 'textfield',
            '#title' => t('Title'),
            '#default_value' => isset($node->title) ? $node->title : '',
            '#description' => t('Human-readable description of the counter.'),
            '#required' => TRUE,
        );
    }

    $form['counterType'] = array(
        '#type' => 'select',
        '#title' => t('Counter Type'),
        '#default_value' => isset($node->counterType) ? $node->counterType : PROGRESSION_ENUM_COUNT_UP,
        '#options' => drupal_map_assoc(array(PROGRESSION_ENUM_COUNT_UP, PROGRESSION_ENUM_COUNT_DOWN)),
        '#description' => t('The type of counter to use (e.g. countup, countdown).'),
        '#required' => TRUE
    );
    $form['targetDate'] = array(
        '#type' => 'date',
        '#title' => t('Target Date'),
        '#default_value' => isset($node->targetDate) ? $node->targetDate : $edit['targetDate'],
        '#description' => t("The date associated with this counter. For countups, this is the start date; for countdowns, this is the date we're counting to."),
        '#required' => TRUE
    );
    $form['description'] = array(
        '#type' => 'textarea',
        '#title' => t('Description'),
        '#default_value' => isset($node->description) ? $node->description : '',
        '#description' => t('A detailed account of what this counter is supposed to represent.'),
        '#rows' => 5,
        '#required' => FALSE
    );

    return $form;
 }

function progression_process_node_for_db($node) {
    return array(
        'nid' => $node->nid,
        'uid' => $node->uid,
        'counterType' => $node->counterType,
        'targetDate' => $node->targetDate['year'] . '-'
                        . (($node->targetDate['month'] < 10) ? '0' . $node->targetDate['month'] : $node->targetDate['month']) . '-'
                        . (($node->targetDate['day'] < 10) ? '0' . $node->targetDate['day'] : $node->targetDate['day']) . ' '
                        . '00:00:00',
        'description' => $node->description
    );
}

function progression_process_db_for_node($dbNode) {
    // input: YYYY-MM-DD hh:mm:ss, output: array('YYYY', 'MM', 'DD')
    $dateChunks = explode(' ', $dbNode->targetDate);
    $dateChunks = explode('-', $dateChunks[0]);

    $dbNode->targetDate = array(
        'year' => intval($dateChunks[0]),  // YYYY
        'month' => intval($dateChunks[1]), // MM
        'day' => intval($dateChunks[2])    // DD
    );

    return $dbNode;
}

 /**
  * Insert hook for progression counter objects.
  *
  * @param object $node the node logically attached to the progression counter being inserted
  */
function progression_insert($node) {
    dd($node);

    $data = progression_process_node_for_db($node);
    db_query(
        "INSERT INTO {progression_counter} (nid, uid, counterType, targetDate, description)"
        . "VALUES (%d, %d, '%s', '%s', '%s')",
        $data['nid'], $data['uid'], $data['counterType'], $data['targetDate'], $data['description']
    );
}

/**
 * Update hook for progression counter objects.
 *
 * @param object $node the node logically attached to the progression counter being updated
 */
function progression_update($node) {
    $data = progression_process_node_for_db($node);
    db_query(
        "UPDATE {progression_counter} SET counterType = '%s', targetDate = '%s', description = '%s' WHERE nid = %d",
        $data['counterType'], $data['targetDate'], $data['description'], $data['nid']
    );
}

/**
 * Delete hook for progression counter objects.
 *
 * @param object $node the node logically attached to the progression counter being deleted
 */
function progression_delete($node) {
    db_query(
        'DELETE FROM {progression_counter} WHERE nid = %d', $node->nid
    );
}

/**
 * Load hook for progression counter objects.
 *
 * @param object $node the node logically attached to the progression counter being updated
 * @return object loaded object corresponding to the node parameter
 */
function progression_load($node) {
    $dbNode = db_fetch_object(
        db_query(
            'SELECT * from {progression_counter} WHERE nid = %d', $node->nid
        )
    );

    return progression_process_db_for_node($dbNode);
}

/**
 * Registers a module theme implementation(s).
 *
 * @param array  $existing an array of existing implementations that may be used for override purposes
 * @param string $type     theme type being processed. one of ('module', 'base_theme_engine', 'theme_engine', 'base_theme', 'theme')
 * @param string $theme    the actual name of the theme being checked
 * @param string $path     the directory path of the theme or module
 * @return array a keyed array of theme hooks
 */
function progression_theme($existing, $type, $theme, $path) {
    return array(
        'progression_info' => array(
            'template' => 'progression_info'
        )
    );
}

/**
 * Generates a display of the given node.
 *
 * @param object  $node   the node to display
 * @param boolean $teaser flag indicating whether to show the teaser only or the full form
 * @param boolean $page   flag indicating whether the node is being displayed by itself as a page
 * @return string html representation of the themed node
 */
function progression_view($node, $teaser = FALSE, $page = FALSE) {
    $node = node_prepare($node, $teaser);

    $node->content['progression_info'] = array(
        '#value' => theme(
            'progression_info', 
            array(
                'title' => $node->title, 
                'counterType' => $node->counterType, 
                'targetDate' => $node->targetDate, 
                'description' => $node->description
            )
        )
    );

    return $node;
}

/**
 * Indicate that this module wraps Views 2 in a warm, loving embrace.
 */
function progression_views_api() {
    return array(
        'api' => 2
    );
}