modules/book_manager/book_manager.module

<?php
// $Id: book_manager.module 1134 2008-10-30 23:18:53Z jgraham $
// @file
define('BOOK_MANAGER_IS_BOOK', 1);          // indicates this node is the top-level in a book (includes personal books)
define('BOOK_MANAGER_IS_IN_BOOK', 2);       // indicates this node is in A book (includes personal books)
define('BOOK_MANAGER_IS_IN_PERSONAL', 4);   // indicates this node is in a personal book

/**
 * Menu callback; prints a listing of all personal books.
 * 
 * @param $user
 *   User whose personal books are being rendered.  If NULL, show all personal books.
 */
function book_manager_render($user = NULL) {
  if ($user) {
    drupal_set_title(t('Personal books for !name', array('!name' => $user->name)));
  }
  
  $header = array(t('Book'), t('Author'));
  $rows = array();
  foreach (book_manager_get_books($user) as $book) {
    $row = array();
    $row[] = l($book->title, $book->href, $book->options);
    $row[] = theme('username', $book);
    $rows[] = $row;
  }
  return theme('table', $header, $rows, array('id' => 'personal-books'));
}

/**
 * Implementatin of hook_link()
 */
function book_manager_link($type, $node = NULL, $teaser = FALSE) {
  global $user;
  $links = array();
  
  if ($type == 'node' && isset($node->book) && !$teaser) {
    $book = node_load($node->book['bid']);

    if (_book_manager_outline_access($book)) {
      $links['book_manager_outline'] = array(
        'title' => t('Customize Book'),
        'href' => "personal-outline/". $book->nid,
      );
    }
    
  }
  return $links;
}

/**
 * Returns an array of all personal books for the specified user.
 *
 * This list may be used for generating a list of all the books, or for building
 * the options for a form select.
 * 
 * @param $user
 *   User object whose personal books are being rendered.  Defaults to 0 for all personal books.
 */
function book_manager_get_books($user = NULL) {
  $books = array();
  if ($user) {
    $result = db_query("SELECT pb.bid FROM {book_manager} pb JOIN {node} n ON pb.bid = n.nid WHERE n.uid = %d", $user->uid);
  }
  else {
    $result = db_query("SELECT pb.bid FROM {book_manager} pb");
  }
  $nids = array();
  while ($book = db_fetch_array($result)) {
    $nids[] = $book['bid'];
  }
  if ($nids) {
    // This differs from the book module's query -- we added n.uid, which should be the same as book_manager.uid,
    // and u.name for the owner's name
    $result2 = db_query(db_rewrite_sql("SELECT n.type, n.title, n.uid, u.name, b.*, ml.* FROM {book} b INNER JOIN {node} n ON b.nid = n.nid INNER JOIN {users} u ON n.uid = u.uid INNER JOIN {menu_links} ml ON b.mlid = ml.mlid WHERE n.nid IN (". implode(',', $nids) .") AND n.status = 1 ORDER BY ml.weight, ml.link_title"));
    while ($book = db_fetch_object($result2)) {
      $book->href = $book->link_path;
      $book->options = unserialize($book->options);
      $books[$book->bid] = $book;
    }
  }
  return $books;
}

/**
 * Implementation of hook_perm()
 */
function book_manager_perm() {
  return array('add content to personal books', 'create personal books');
}

/**
 * Implementation of hook_menu().
 */
function book_manager_menu() {
  $items['book_manager'] = array(
    'title' => 'Book Manager',
    'page callback' => 'book_manager_render',
    'page arguments' => array(NULL),
    'access arguments' => array('access content'),
    'type' => MENU_SUGGESTED_ITEM
  );
  
  $items['book_manager/%user_uid_optional'] = array(
    'title' => 'Book Manager',
    'page callback' => 'book_manager_render',
    'page arguments' => array(1),
    'access arguments' => array('access content'),
    'type' => MENU_SUGGESTED_ITEM
  );
  
  // we could adjust the access routine for books standard outline feature, but it is nested under admin
  $items['personal-outline/%node'] = array(
    'title' => 'Re-order personal book pages',
    'page callback' => 'book_manager_outline_edit',
    'page arguments' => array(1),
    'access callback' => '_book_manager_outline_access',
    'access arguments' => array(1),
    'type' => MENU_CALLBACK,
  );

  return $items;
}

function book_manager_menu_alter(&$callbacks) {
  $callbacks['node/%node/outline']['access callback'] = '_book_manager_outline_access_menu_callback';
  $callbacks['node/%node/outline/remove']['access callback'] = '_book_manager_outline_remove_access_menu_callback';
}

/**
 * This is a helper function used as a replacement callback for book's standard access to
 * 'node/%node/outline' 
 * @see book_manager_menu_alter()
 */
function _book_manager_outline_access_menu_callback($node) {
  return (_book_manager_outline_access($node) || _book_outline_access($node));
}

/**
 * This is a helper function used as a replacement callback for book's standard access to
 * 'node/%node/outline/remove' 
 * @see book_manager_menu_alter()
 */
function _book_manager_outline_remove_access_menu_callback($node) {
  return (_book_manager_outline_remove_access($node) || _book_outline_remove_access($node));
}

/**
 * Menu item access callback - determine if the user should be able to outline the book the node belongs to
 * @param $node object the node in question 
 * @param $noadministeroutlines if TRUE then return TRUE only if the user does not have access to "administer book outlines"
 */
function _book_manager_outline_access($node) {
  global $user;
  // if this is in a personal book AND this is their node
  if (book_type_is_allowed($node->type) && (($node->book_manager & BOOK_MANAGER_IS_IN_PERSONAL) && 
      ((isset($node->book) && 
      _book_manager_get_book_owner($node->book['bid']) && $node->uid == $user->uid)) ||
      (!isset($node->book) && $node->uid == $user->uid && user_access('add content to personal books')))) {
      return TRUE;
  }
  else {
    return FALSE;
  }
}

/**
 * Menu item access callback - determine if the user can remove nodes from the outline.
 */
function _book_manager_outline_remove_access($node) {
  return isset($node->book) && ($node->book['bid'] != $node->nid) && _book_manager_outline_access($node);
}

/**
 * This function returns the uid of the author of the book corresponding to $bid
 * @param int $bid The book id to find the author for
 * @return int The uid of the bid author or 0 if this is not a book
 */
function _book_manager_get_book_owner($bid) {
  if ($result = db_query("SELECT n.uid FROM {book} b LEFT JOIN {node} n ON n.nid = b.bid WHERE n.nid = %d GROUP BY n.nid", $bid)) {
    $row = db_fetch_array($result);
    return $row['uid'];
  }
  return 0;
}

/**
 * implementation of hook_nodeapi()
 */
function book_manager_nodeapi(&$node, $op, $teaser, $page) {
  global $user;
  switch ($op) {
  case 'load':
    $node->book_manager = book_manager_status($node->nid);
    break;
  case 'prepare':
    // this is necessary because book_nodeapi checks for book permissions and the parent select widget population 
    // fails without this pre-loaded data
    // Prepare defaults for the add/edit form.
    if (empty($node->book) && (user_access('add content to personal books'))) {
      $node->book = array();
      if (empty($node->nid) && isset($_GET['parent']) && is_numeric($_GET['parent'])) {
        // Handle "Add child page" links:
        $parent = book_link_load($_GET['parent']);
        if ($parent && $parent['access']) {
          $node->book['bid'] = $parent['bid'];
          $node->book['plid'] = $parent['mlid'];
          $node->book['menu_name'] = $parent['menu_name'];
        }
      }
      // Set defaults.
      $node->book += _book_link_defaults(!empty($node->nid) ? $node->nid : 'new');
    }
    else {
      if (isset($node->book['bid']) && !isset($node->book['original_bid'])) {
        $node->book['original_bid'] = $node->book['bid'];
      }
    }
    // Find the depth limit for the parent select.
    if (isset($node->book['bid']) && !isset($node->book['parent_depth_limit'])) {
      $node->book['parent_depth_limit'] = _book_parent_depth_limit($node->book);
    }
    break;
  case 'insert':
  case 'update':
    if ((!user_access('create new books') && user_access('create personal books')) || $node->book['ispersonal']) {
      // TODO: I think this should cascade as well (think about the implications [if any] for users without book privileges.)
      book_manager_make_personal($node, $user);
    }
    elseif (user_access('create new books') && !$form_state['values']['book']['ispersonal']) {
      book_manager_make_personal($node, $user, FALSE);
    }
    break;
  case 'delete':
    // we only need to do stuff if this was a top-level node in a personal book
    // code partially taken from book module to determine where our top-level bid goes to.
    if (!empty($node->book['bid']) && $node->book['bid'] = $node->nid && $node->book_manager & BOOK_MANAGER_IS_IN_PERSONAL) {
      db_query("DELETE FROM {book_manager} WHERE bid = %d", $node->book['bid']);
      $result = db_query("SELECT b.nid FROM {menu_links} ml INNER JOIN {book} b on b.mlid = ml.mlid WHERE ml.plid = %d", $node->book['mlid']);
      while ($child = db_fetch_array($result)) {
        $child_node = node_load($child['nid']);
        book_manager_make_personal($child_node, $user);
      }
    }
  }
}

/**
 * Implementation of hook_theme()
 */
function book_manager_theme() {
  return array('book_manager_outline_table' => array(
    'arguments' => array('form' => NULL),
    ), 
  );
}

/**
 * This function heavily copied from theme_book_admin_table
 * @see theme_book_admin_table
*/
function theme_book_manager_outline_table($form) {
    drupal_add_tabledrag('book-outline', 'match', 'parent', 'book-plid', 'book-plid', 'book-mlid', TRUE, MENU_MAX_DEPTH - 2);
    drupal_add_tabledrag('book-outline', 'order', 'sibling', 'book-weight');

    $header = array(t('Title'), t('Weight'), t('Parent'), array('data' => t('Operations'), 'colspan' => '3'));

    $rows = array();
    $destination = drupal_get_destination();
    $access = user_access('administer nodes');

    foreach (element_children($form) as $key) {
      $nid = $form[$key]['nid']['#value'];
      $href = $form[$key]['href']['#value'];

      // add links for users with administer nodes permission
      if (!$access) {
        $node = node_load(array('nid' => $nid));
        $edit =  user_access('edit own '. $node->type .' content');
        $delete = user_access('delete own '. $node->type .' content');
      }
      else {
        $edit = TRUE;
        $delete = TRUE;
      }

      // Add special classes to be used with tabledrag.js.
      $form[$key]['plid']['#attributes']['class'] = 'book-plid';
      $form[$key]['mlid']['#attributes']['class'] = 'book-mlid';
      $form[$key]['weight']['#attributes']['class'] = 'book-weight';

      $data = array(
        theme('indentation', $form[$key]['depth']['#value'] - 2) . drupal_render($form[$key]['title']),
        drupal_render($form[$key]['weight']),
        drupal_render($form[$key]['plid']) . drupal_render($form[$key]['mlid']),
        l(t('view'), $href),
        $edit ? l(t('edit'), 'node/'. $nid .'/edit', array('query' => $destination)) : '&nbsp',
        $delete ? l(t('delete'), 'node/'. $nid .'/delete', array('query' => $destination) )  : '&nbsp',
      );
      
      $edit = FALSE;
      $delete = FALSE;
      
      $row = array('data' => $data);
      if (isset($form[$key]['#attributes'])) {
        $row = array_merge($row, $form[$key]['#attributes']);
      }
      $row['class'] = empty($row['class']) ? 'draggable' : $row['class'] .' draggable';
      $rows[] = $row;
    }

    return theme('table', $header, $rows, array('id' => 'book-outline'));
  }

/**
  * Implementation of hook_form_alter()
  */
function book_manager_form_alter(&$form, $form_state, $form_id) {
  if (isset($form['type']) && isset($form['#node']) && $form['type']['#value'] .'_node_form' == $form_id) {
    $node = $form['#node'];
    
    // if the book module did not already add our widgets
    if (!isset($form['book']) && user_access('add content to personal books') && ((!empty($node->book['mlid']) && !empty($node->nid)) || book_type_is_allowed($node->type))) {
      _book_add_form_elements($form, $node);
    }

    if (isset($form['book'])) {
      // remove any options we need to
      _book_manager_outline_alter($form, $node);
    }
  }
  elseif ($form_id == 'book_admin_edit') {
    if (!user_access('administer book outlines')) {
      foreach ($form['table'] as $key => $value) {
        if (strpos($key, '#') !== 0 && isset($form['table'][$key]['#item'])) { // not sure why #theme is getting through the isset check... so there is strpos()
          $form['table'][$key]['title']['#type'] = 'hidden';
          $form['table'][$key]['title']['#prefix'] = $form['table'][$key]['title']['#default_value'];
        }
      }
      
      $form['table']['#theme'] = 'book_manager_outline_table';
      // ensure the user didn't change any values (needs to run before book_admin_edit_submit)
      array_unshift($form['#submit'], 'book_manager_admin_edit_submit');
    }
  }
  elseif ($form_id == 'book_outline_form') {
    $node = $form['#node'];
    _book_manager_outline_alter($form, $node);
  }
}

function _book_manager_outline_alter(&$form, $node) {
  _book_manager_limit_books($form['book']['bid'], $node);
  _book_manager_set_personal($form);

}

/**
 * This function does the appropriate checking to; 
 *    ensure this is a personal book and display appropriate output (either the outline form or "empty book")
 *    if this is in a book, but not the top-level it redirects the user to the top-level
 *    if the above criteria is not met, the user is notified it is not in a personal book
 * @param object $node the node the user is attempting to access
 * @return mixed text to be rendered, or user is redirected
 */
function book_manager_outline_edit($node) {
  if ($node->book_manager & BOOK_MANAGER_IS_BOOK && $node->book_manager & BOOK_MANAGER_IS_IN_PERSONAL) {
    $result = db_query("SELECT count(*) AS pages FROM {book} WHERE bid = %d", $node->book['bid']);
    $row = db_fetch_array($result);
    if ($row['pages'] > 1) {
      module_load_include('inc', 'book', 'book.admin');
      $output = drupal_get_form('book_admin_edit', $node);
    }
    else {
      $output = t('This book is currently empty. You may add content by editing other nodes and adding them to this book via the book fieldset.');
    }
  }
  else if ($node->book_manager & BOOK_MANAGER_IS_IN_PERSONAL) {
    // redirect user to top-level of the book
    drupal_goto('personal-outline/'. $node->book['bid']);
  }
  else {
    // book is not a personal book or in one (should we differentiate whether or not it is in A book?)
    $output = t('This node is not in a personal book.');
  }
  
  return $output;
}

/**
 * Implementation of hook_submit()
 *
 * This function ensures the user did not change any values via the book_admin_edit (outline form)
 * This is necessary because we are leveraging a large amount of book code, and this required using hidden fields,
 * a crafty user could hack the form to change the hidden field values potentially changing the node titles.
 * This "pre-process" submit handler will revert any changes the user made if they shouldn't be allowed to
 */
function book_manager_admin_edit_submit($form, &$form_state) {
  // this function ensures the user did not change any values via the book_admin_edit (outline form);
  foreach (element_children($form['table']) as $key) {
    if ($form['table'][$key]['#item']) {
      $row = $form['table'][$key];
      $values = $form_state['values']['table'][$key];
      if ($row['title']['#default_value'] != $values['title']) {
        $form_state['values']['table'][$key]['title'] = $row['title']['#default_value'];
      }
    }
  }
}

/**
 * Turn an existing book into a personal book, or remove
 * the personal designation.
 * 
 * @param $node
 *   Node that is at the top level of a book
 * @param $user
 *   The new owner of the book.
 * @param $make_personal
 *   If true, then make the book personal, if false, remove
 *   the "personality" so that the book reverts to being a
 *   normal book.
 * @param $cascade
 *   If true, all pages in the book change ownership to the
 *   book's owner.
 */
function book_manager_make_personal($node, $user, $make_personal = TRUE, $cascade = FALSE) {
  // Books are designated as personal by having a row in the
  // {book_manager} table with their top-level nid as bid.
  //
  // If a book is already designated as personal, the INSERT
  // will fail, but there is no need to report anything.
//  $row = db_fetch_array(db_query("SELECT bid FROM {book} WHERE bid = %d", $node->nid));
  if ($node->book['bid'] == $node->nid) {
    if ($make_personal) {
      @db_query('INSERT INTO {book_manager} (bid) VALUES (%d)', $node->nid);
      drupal_set_message(t('The book <a href="@book_url">%book_name</a> is now a personal book.', array('@book_url' => url("node/$node->nid"), '%book_name' => $node->title)));
    }
    else {
      db_query('DELETE FROM {book_manager} WHERE bid = %d', $node->nid);
      drupal_set_message(t('The book <a href="@book_url">%book_name</a> is now a regular book', array('@book_url' => url("node/$node->nid"), '%book_name' => $node->title)));
    }
  }
}

function book_manager_change_node_ownership(&$node, $user) {
  if ($node->nid) {
    $node->uid = $user->uid;
    node_save($node);
  }
  else {
    watchdog('error', t('book_manager_change_node_ownership() called with unpopulated node'), array(), WATCHDOG_ERROR);
  }
}

/**
 * Returns the status of the given node
 *
 * This is used to populate $node->book_manager for easy access later
 *  
 *  BOOK_MANAGER_IS_IN_PERSONAL: The node in question is IN a personal book
 *  BOOK_MANAGER_IS_BOOK: The node in question is the root of a book
 *  BOOK_MANAGER_IS_IN_BOOK: The node in question is in a book
 *
 * @param int $nid the node id to load book status for
 */
function book_manager_status($nid) {
  $return = 0;
  if ($result = db_query("SELECT nid, bid FROM {book} WHERE nid = %d", $nid)) {
    $book = db_fetch_object($result);
    if ($book->nid == $book->bid) {
      $return += BOOK_MANAGER_IS_BOOK;
    }
    $return += BOOK_MANAGER_IS_IN_BOOK;
    
    if ($result = db_query("SELECT bid FROM {book_manager} WHERE bid = %d", $book->bid)) {
      $book = db_fetch_object($result);
      if ($book->bid) {
        $return += BOOK_MANAGER_IS_IN_PERSONAL;
      }
    }
  } 
  return $return;
}

/**
 * returns an array keyed by node pointing to the bid that the nid belongs to 
 * @param bool $personalonly if TRUE only personal books are included, if FALSE all books are included
*/
function _book_manager_nodes_to_books($personalonly = TRUE) {
  if ($personalonly) {
    if ($result = db_query('SELECT bid FROM {book_manager}')) {
      $books = array();
      while ($row = db_fetch_array($result)) {
        $books[$row['bid']] = $row['bid'];
      }
      if (!empty($books)) {
        $in = "WHERE bid IN (". implode(', ', $books) .")";
      }
    }
    
    if (!isset($in)) {
      // something strange happened (let's ensure the next query will return no results)
      $in = "WHERE 1 = -1";
    }
  }
  else {
    $in = '';
  }
  
  $nidstobooks = array();
  $query = "SELECT nid, bid FROM {book}";
  if (!empty($in)) {
    $query .= ' '. $in;
  }
  $result = db_query($query);
  while ($nidbid = db_fetch_array($result)) {
    $nidstobooks[$nidbid['nid']] = $nidbid['bid'];
  }
  
  return $nidstobooks;
}


/**
 * Given an array of book options this function prunes those entries the user should not be allowed to add
 * This also adds the create option if the user should be able to crete books
 *
 * options matching any of the following criteria are removed:
 *      1. node is in a personal book and node->author does not match current nid author
 *      2. user does not have permission to add content from other authors (add_content_to_books)
 *      3. node in question is in a personal book and the author does not match the current node author 
 * @param $bid array form element for the book
 * @param $node node object the user is editing
 */
function _book_manager_limit_books(&$bid, $node) {
  $nidstobids = _book_manager_nodes_to_books(TRUE);
  $addtobooks = user_access('add content to books');
  foreach ($bid['#options'] as $nid => $title) {
    if ((($node->book_manager & BOOK_MANAGER_IS_IN_PERSONAL) && !_book_manager_author_matches($nid, $node->uid)) || // node is in a personal book and node->author does not match current nid author
        (!user_access('add content to books') && !_book_manager_author_matches($nid)) ||                            // user does not have permission to add content from other authors
        (in_array($nid, $nidstobids) && !_book_manager_author_matches($nid, $node->uid))) {                         // node in question is in a personal book and the author does not match the current node author
      unset($bid['#options'][$nid]);
    }
  }

  $nid = isset($node->nid) ? $node->nid : 'new';  
  if (!user_access('create new books') && user_access('create personal books')  && ($nid == 'new' || ($nid != $node->book['original_bid']))) {
    $bid['#options'] = array($nid  => '<'. t('create new book') .'>') + $bid['#options'];
  }

}

/**
 * Returns whether or not the node author for the supplied nid matches the given uid (or the currently logged in user)
 *
 * @param int $nid the node it in question
 * @param int $uid optional, if not supplied then the logged in user's id is used.
 * @return bool whether or not the author for nid matches the given ui
 */
function _book_manager_author_matches($nid, $uid = 0) {
  if ($uid == 0) {
    global $user;
    $uid = $user->uid;
  }

  $result = db_query("SELECT uid FROM {node} WHERE nid = %d", $nid);
  $dbuid = db_fetch_object($result);
  if ($uid != $dbuid->uid) {
    return FALSE;
  }
  else {
    return TRUE;
  }
}

/**
 * Menu callback; show the outline form for a single node.
 */
function book_manager_outline($node) {
  module_load_include('inc', 'book', 'book.pages');
  
  drupal_set_title(check_plain($node->title));
  return drupal_get_form('book_outline_form', $node);
}

/**
 * This function relies on book_outline_form to do the major form building
 * However we need to restrict the books the user can choose to those they are
 * the author for.
*/
function book_manager_outline_form(&$form_state, $node) {
  module_load_include('inc', 'book', 'book.pages');
  $form = book_outline_form(&$form_state, $node);
  
  _book_manager_limit_books($form['book']['bid'], $node);

  _book_manager_set_personal($form);

  return drupal_render($form);
}

/**
 * This function handles the form processing for our modified book_outline_form
 * again we rely on book code to do our processing, checking to see if the user will 
 * be redirected to outline and adjusting to personal-outline
 */
function book_manager_outline_form_submit($form, &$form_state) {
  $node = $form['#node'];
  book_outline_form_submit($form, &$form_state);
  
  if ($form_state['redirect'] == "node/". $node->nid ."/outline") {
    $form_state['redirect'] = "node/". $node->nid ."/personal-outline";
  }
}


/**
 * This function adds a checkbox if the user has both "create new books" and "create personal books"
 * That allows the user to check the box and create a personal book rather than a global book
 */
function _book_manager_set_personal(&$form) {
  if (user_access('create new books') && user_access('create personal books')) {
    $node = $form['#node'];
    if ($node->nid) {
      $bid = db_fetch_array(db_query('SELECT bid FROM {book_manager} WHERE bid = %d', $node->nid));
      if ($bid['bid']) {
        $ispersonal = TRUE;
      }
      else {
        $ispersonal = FALSE;
      }
    }
    else {
      $ispersonal = FALSE;
    }

    // prepare some jquery to hide the ispersonal box unless it makes sense
    if ($node->nid) {
      $jsnid = " || $('#edit-book-bid').val() == ". $node->nid;
    }
    else {
      $jsnid = '';
    }
    
    $jscript = "if (Drupal.jsEnabled) { 
                  function ispersonaljs() {
                    if ($('#edit-book-bid').val() == 'new'". $jsnid .") {
                      $('#edit-book-ispersonal-wrapper').css('display', 'inline');
                    }
                    else {
                      $('#edit-book-ispersonal-wrapper').css('display', 'none'); 
                    }
                  }
                
                  $(document).ready(function() { 
                    ispersonaljs();
                    $('#edit-book-bid').change(ispersonaljs);
                  }); 
                }";
    
      drupal_add_js($jscript, 'inline');
    
    $form['book']['ispersonal'] = array(
      '#type' => 'checkbox',
      '#default_value' => $ispersonal,
      '#title' => t('Make Personal'),
      '#description' => t('If checked this book will be a personal book, and will only be able to contain nodes from a single author'),
    );
  }
}

/**
 * This function just sets whether a book is personal or not
 */
function book_manager_set_personal_submit($form, &$form_state) {
  $node = $form['#node'];
  if ($form_state['values']['book']['ispersonal']) {
    book_manager_make_personal($node, $user);
  }
}

function book_manager_views_data() {
  $data = array();

  $data['book_manager']['table']['group'] = t('Book');
  $data['book_manager']['table']['join'] = array(
    'node' => array(
      'left_field' => 'nid',
      'field' => 'bid'),
  );
  
  $data['book_manager']['bid'] = array(
    'title' => t('Personal Book'),
    'help' => t('Thie personal book the node is in.'),
    'relationship' => array(
      'base' => 'node',
      'field' => 'bid',
      'handler' => 'views_handler_relationship',
      'label' => t('Personal Book'),
    ),
  );
  return $data;
}

/**
* Implementation of hook_book_copy_alter()
*/
function book_manager_book_copy_alter(&$node, $oldbid, $newbid) {
  $oldbook = node_load(array('nid' => $oldbid));
  if ($oldbook->book_manager & BOOK_MANAGER_IS_IN_PERSONAL) {
    @db_query('INSERT INTO {book_manager} (bid) VALUES (%d)', $newbid);
  }
}

/**
 * Implementation of hook_book_copy_goto_alter()
 *  change $node->bookcopydata['url'] to goto location
 *  change $node->bookcopydata['message'] to message to send via drupal_set_message()
 */
function book_manager_book_copy_goto_alter(&$node) {
  if (_book_manager_outline_access_menu_callback($node)) {
    $node->bookcopydata['url'] = 'node/'. $node->nid .'/outline';
  }
  else {
    $node->bookcopydata['url'] = 'node/'. $node->nid;
  }
}

/**
 * Since we overrode the book module's access control to /node/%/outline
 * we need to remove the help as it displays links specific to users 
 * with 'administer book outlines'
 */
function phptemplate_help() {
  if ($help = menu_get_active_help()) {
    if (arg(0) == 'node' && is_numeric(arg(1)) && arg(2) == 'outline') {
      if (user_access('administer book outlines')) {
        return '<div class="help">'. $help .'</div>';
      }
    }
    else {
      return '<div class="help">'. $help .'</div>';
    }
  }
}