domain_prefix.module in Domain Access 5

Same filename and directory in other branches
6.2 domain_prefix/domain_prefix.module
Interface for selective table prefixing for use with Domain Access. For this module to work correctly, you will need to follow the INSTALL.txt instructions for editing your settings.php file.
File

domain_prefix/domain_prefix.module
View source
<?php

/**
 * @defgroup domain_prefix Domain Prefix: dynamic table prefixing
 *
 * Allows for the dynamic table prefixing of selected database tables.
 */

/**
 * @file
 * Interface for selective table prefixing for use with Domain Access.
 * For this module to work correctly, you will need to follow the INSTALL.txt
 * instructions for editing your settings.php file.
 *
 * @ingroup domain_prefix
 */

/**
 * Constant definitions for the various actions.
 */
define('DOMAIN_PREFIX_IGNORE', 1);
define('DOMAIN_PREFIX_CREATE', 2);
define('DOMAIN_PREFIX_COPY', 4);
define('DOMAIN_PREFIX_DROP', 8);
define('DOMAIN_PREFIX_UPDATE', 16);

/**
 * Implement hook_menu()
 */
function domain_prefix_menu($may_cache) {
  $items = array();
  if ($may_cache) {
    $items[] = array(
      'title' => t('Table prefixing'),
      'path' => 'admin/build/domain/prefix',
      'access' => user_access('administer table prefixing'),
      'type' => MENU_LOCAL_TASK,
      'callback' => 'drupal_get_form',
      'callback arguments' => array(
        'domain_prefix_configure_form',
      ),
    );
  }
  else {
    $items[] = array(
      'title' => t('Domain prefix settings'),
      'path' => 'admin/build/domain/prefix/' . arg(4),
      'access' => user_access('administer table prefixing'),
      'type' => MENU_CALLBACK,
      'callback' => 'drupal_get_form',
      'callback arguments' => array(
        'domain_prefix_form',
        arg(4),
      ),
    );
    $items[] = array(
      'title' => t('Domain prefix update'),
      'path' => 'domain_prefix_update',
      'access' => user_access('administer table prefixing'),
      'type' => MENU_CALLBACK,
      'callback' => 'domain_prefix_update',
    );
  }
  return $items;
}

/**
 * Implement hook_perm
 */
function domain_prefix_perm() {
  return array(
    'administer table prefixing',
  );
}

/**
 * Check for existing table prefixing.
 */
function domain_prefix_get_prefix() {
  global $db_prefix;

  // Check for existing table prefixing.
  $prefix = NULL;
  if (!empty($db_prefix)) {
    if (is_array($db_prefix)) {
      $prefix = $db_prefix['default'];
    }
    else {
      $prefix = $db_prefix;
    }
  }
  return $prefix;
}

/**
 * Get the tables with the active prefix
 *
 * @param $prefix
 *   The table prefix used with this domain. Optional.
 */
function domain_prefix_get_tables($prefix = NULL) {

  // Check for default prefix settings.
  if (empty($prefix)) {
    $prefix = domain_prefix_get_prefix();
  }
  switch ($GLOBALS['db_type']) {
    case 'pgsql':
      if (empty($prefix)) {
        $result = db_query("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'");
      }
      else {
        $result = db_query("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_name LIKE '{$prefix}%%'");
      }
      break;
    default:

      // MySQL and MySQLi implementation.
      if (empty($prefix)) {
        $result = db_query("SHOW TABLES");
      }
      else {
        $result = db_query("SHOW TABLES LIKE '{$prefix}%%'");
      }
      break;
  }
  $tables = array();
  $disallow = domain_prefix_disallow();
  while ($data = db_fetch_array($result)) {

    // Chop table prefixes.
    $str = current($data);
    if (!empty($prefix)) {
      $str = preg_replace('/' . $prefix . '/', '', $str, 1);
    }
    if (!in_array($str, $disallow) && substr($str, 0, 7) != 'domain_') {
      $tables[$str]['tablename'] = $str;
      $tables[$str]['module'] = domain_prefix_module_lookup($str);
    }
  }

  // Sort them by module
  uasort($tables, '_domain_prefix_sort');
  return $tables;
}

/**
 * Helper sort function
 */
function _domain_prefix_sort($a, $b) {
  $_a = str_replace('_', '', $a['tablename']);
  $_b = str_replace('_', '', $b['tablename']);
  if ($a['module'] == $b['module']) {
    return strcmp($_a, $_b);
  }
  return strcmp($a['module'], $b['module']);
}

/**
 * FormsAPI for generating the configuration form
 */
function domain_prefix_configure_form() {

  // We must be on the root domain!
  $default = domain_default();
  domain_goto($default);

  // Get the tables for the root installation.
  $tables = domain_prefix_get_tables($prefix);

  // Remove the disallowed tables.
  $disallow = domain_prefix_disallow();

  // Get the current settings.
  $info = unserialize(variable_get('domain_prefix', NULL));
  $settings = $info['settings'];
  $source_defaults = $info['sources'];
  $form = array();
  $form['domain'] = array(
    '#type' => 'fieldset',
    '#title' => t('Domain creation rules'),
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
  );
  $form['domain']['domain_prefix_options'] = array(
    '#type' => 'radios',
    '#title' => t('Domain creation options'),
    '#description' => t('Determines what actions to take when creating new domain records.'),
    '#options' => array(
      1 => t('Generate tables as defined below'),
      0 => t('Do not generate any tables'),
    ),
    '#default_value' => variable_get('domain_prefix_options', 1),
    '#required' => TRUE,
  );
  $last = '';

  // Flag for module grouping.
  // Get the source table data.
  $root = domain_default();
  foreach ($tables as $table => $info) {
    if (!in_array($table, $disallow) && substr($table, 0, 7) != 'domain_') {
      if (empty($settings[$table])) {
        $settings[$table] = DOMAIN_PREFIX_IGNORE;
        $source_defaults['_source_' . $table] = 0;
      }
      $module = $info['module'];
      if ($last != $module) {
        $last = $module;
      }
      else {
        $module = '';
      }
      $options = array();
      $options[DOMAIN_PREFIX_IGNORE] = t('ignore');
      $options[DOMAIN_PREFIX_CREATE] = t('create');
      $options[DOMAIN_PREFIX_COPY] = t('copy');
      $form['domain_prefix'][$table] = array(
        '#type' => 'radios',
        '#title' => $table,
        '#options' => $options,
        '#default_value' => $settings[$table],
        '#description' => $module,
      );

      // Get the table copying options for this entry.
      // Can't pass a zero through FormAPI select.
      $sources = array();
      $sources[0] = $root['sitename'];

      // Check to see if other table prefixes have been created.
      $result = db_query("SELECT dp.domain_id, d.sitename FROM {domain_prefix} dp INNER JOIN {domain} d ON dp.domain_id = d.domain_id WHERE dp.tablename = '%s' AND dp.status > 1", $table);
      while ($data = db_fetch_array($result)) {
        $sources[$data['domain_id']] = $data['sitename'];
      }
      $form['domain_source']['_source_' . $table] = array(
        '#type' => 'select',
        '#title' => '',
        '#options' => $sources,
        '#default_value' => $source_defaults['_source_' . $table],
      );
    }
  }
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Save prefix settings'),
  );
  $form['restore'] = array(
    '#type' => 'submit',
    '#value' => t('Restore defaults'),
  );
  return $form;
}

/**
 * Implement hook_domainlinks()
 *
 * @param $domain
 *  The currently active $domain array, provided by domain_lookup().
 */
function domain_prefix_domainlinks($domain) {
  if (user_access('administer table prefixing')) {
    $links[] = array(
      'title' => t('tables'),
      'path' => 'admin/build/domain/prefix/' . $domain['domain_id'],
    );
    return $links;
  }
}

/**
 * FormsAPI for the domain_prefix_configure_form.
 */
function domain_prefix_configure_form_submit($form_id, $form_values) {

  // Throw away what we don't need.
  $options = $form_values['domain_prefix_options'];
  $unset = array(
    'op',
    'submit',
    'restore',
    'form_token',
    'form_id',
    'domain_prefix_options',
  );
  $data = $form_values;
  foreach ($unset as $key) {
    unset($data[$key]);
  }
  if ($form_values['op'] == $form_values['restore']) {
    variable_del('domain_prefix');
    drupal_set_message(t('Default prefix settings reset.'));
  }
  else {

    // Process the source data.
    foreach ($data as $key => $value) {
      if (substr($key, 0, 8) == '_source_') {
        $info['sources'][$key] = $value;
      }
      else {
        $info['settings'][$key] = $value;
      }
    }
    $settings = serialize($info);
    variable_set('domain_prefix', $settings);
    drupal_set_message(t('Default prefix settings changed.'));
  }
  variable_set('domain_prefix_options', $options);
}

/**
 * FormsAPI theming for domain_prefix_configure_form.
 */
function theme_domain_prefix_configure_form($form) {
  $output = t('<p>These settings control advanced functions.  Please read the documentation carefully.</p>');
  $header = array(
    t('Table'),
    t('Source'),
    t('Ignore'),
    t('Create'),
    t('Copy'),
  );
  if ($form['prefix_theme']['#value'] > 0) {
    $header[] = t('Update');
    $header[] = t('Drop');
    unset($form['prefix_theme']);
  }
  $output = drupal_render($form['domain']);
  foreach (element_children($form['domain_prefix']) as $key) {
    if ($form['domain_prefix'][$key]['#description']) {
      $rows[] = array(
        '<b>' . $form['domain_prefix'][$key]['#description'] . '</b>',
        array(
          '',
          'colspan' => 4,
        ),
      );
    }
    $row = array();
    $row[] = ' - ' . $form['domain_prefix'][$key]['#title'];

    // Insert the source selection element.
    $row[] = drupal_render($form['domain_source']['_source_' . $key]);
    foreach (element_children($form['domain_prefix'][$key]) as $option) {
      $row[] = drupal_render($form['domain_prefix'][$key][$option]);
    }

    // Throw the rest away, since we already rendered what we want from it.
    $render = drupal_render($form['domain_prefix'][$key]);
    $rows[] = $row;
  }
  $output .= theme('table', $header, $rows);
  $output .= drupal_render($form);
  return $output;
}

/**
 * The table prefixing page for a domain.
 *
 * @param $domain_id
 *  The domain_id taken from {domain}.
 * @param $arguments
 *  An array of additional hidden key/value pairs to pass to the form.
 *  Used by child modules to control behaviors.
 */
function domain_prefix_form($domain_id, $arguments = array()) {

  // We must be on the root domain!
  $default = domain_default();
  domain_goto($default);
  $domain = domain_lookup($domain_id);
  drupal_set_title(t('Table prefixing for @domain', array(
    '@domain' => $domain['sitename'],
  )));

  // Remove the disallowed tables.
  $disallow = domain_prefix_disallow();

  // Get the default table set and settings.
  $default = domain_prefix_get_tables();

  // Get the current settings.
  $info = unserialize(variable_get('domain_prefix', NULL));
  $settings = $info['settings'];
  $source_defaults = $info['sources'];

  // Check the defaults against those saved for this domain.
  $result = db_query("SELECT tablename, source FROM {domain_prefix} WHERE domain_id = %d", $domain['domain_id']);
  while ($sourcedata = db_fetch_array($result)) {
    $source_defaults['_source_' . $sourcedata['tablename']] = $sourcedata['source'];
  }

  // Get the root source table data.
  $root = domain_default();
  if (empty($settings) && !$_POST) {
    drupal_set_message(t('There are no default settings configured.'));
  }

  // Get the stored table data for this domain.
  $tables = domain_prefix_lookup($domain_id);
  $submit = t('Update domain tables');
  if (empty($tables)) {
    if (!$_POST && !$form_values['execute'] && !$arguments['user_submitted']) {
      drupal_set_message(t('The table creation sequence has not run for this domain.'));
    }
    $submit = t('Generate domain tables');
    $table_options = $default;
  }
  else {
    $table_options = array();
    $settings = array();
    foreach ($tables as $name => $table) {
      if (array_key_exists($name, $default)) {
        $table_options[$table['tablename']] = $table;
        $settings[$table['tablename']] = $table['status'];
      }
    }
  }

  // Sort them by module
  uasort($table_options, '_domain_prefix_sort');

  // All tables are prefixed as 'domain_#_'
  $prefix = domain_prefix_string($domain_id);

  // Generate the form.
  $form = array();

  // The $arguments arrray allows other modules to pass values to change the bahavior
  // of submit and validate functions.
  if (!empty($arguments)) {
    $form['domain_arguments'] = array(
      '#type' => 'value',
      '#value' => $arguments,
    );
  }
  $delete_flag = 0;

  // Flag for the theme function delete column
  $last = '';

  // Flag for module groupings.
  foreach ($table_options as $table => $info) {
    if (!in_array($table, $disallow)) {
      if (empty($settings[$table])) {
        $settings[$table] = DOMAIN_PREFIX_IGNORE;
      }
      $options = array();
      $options[DOMAIN_PREFIX_IGNORE] = t('ignore');
      $options[DOMAIN_PREFIX_CREATE] = t('create');
      $options[DOMAIN_PREFIX_COPY] = t('copy');
      if ($settings[$table] > 0) {
        $exists = domain_prefix_table_exists($prefix, $table);
        if ($exists > 0) {
          $options[DOMAIN_PREFIX_UPDATE] = t('update');
          $options[DOMAIN_PREFIX_DROP] = t('drop');
          $delete_flag++;
        }
      }
      $module = $info['module'];
      if ($last != $module) {
        $last = $module;
      }
      else {
        $module = '';
      }
      $form['domain_prefix'][$table] = array(
        '#type' => 'radios',
        '#title' => $table,
        '#options' => $options,
        '#default_value' => $settings[$table],
        '#description' => $module,
      );

      // Get the table copying options for this entry.
      // Can't pass a zero through FormAPI select.
      $sources = array();
      $sources[0] = $root['sitename'];

      // Check to see if other table prefixes have been created.
      $result = db_query("SELECT dp.domain_id, d.sitename FROM {domain_prefix} dp INNER JOIN {domain} d ON dp.domain_id = d.domain_id WHERE dp.tablename = '%s' AND dp.status > 1", $table);
      while ($data = db_fetch_array($result)) {

        // Cannot copy onto itself.
        if ($data['domain_id'] != $domain['domain_id']) {
          $sources[$data['domain_id']] = $data['sitename'];
        }
      }
      $form['domain_source']['_source_' . $table] = array(
        '#type' => 'select',
        '#title' => '',
        '#options' => $sources,
        '#default_value' => $source_defaults['_source_' . $table],
      );
    }
  }
  $form['#theme'] = 'domain_prefix_configure_form';
  $form['prefix_theme'] = array(
    '#type' => 'value',
    '#value' => $delete_flag,
  );
  $form['domain_id'] = array(
    '#type' => 'value',
    '#value' => $domain_id,
  );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => $submit,
  );
  return $form;
}

/**
 * Does a table exist -- we use this to bypass Drupal's default table prefixing check.
 *
 * @param $prefix
 *   The table prefix used with this domain. Optional.
 * @param $table
 *   The name of the table being acted upon.
 */
function domain_prefix_table_exists($prefix, $table) {
  global $db_type;
  $string = db_escape_table($prefix . $table);
  switch ($db_type) {
    case 'pgsql':
      $query = "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_name = '{%s}'";
      break;
    default:
      $query = "SHOW TABLES LIKE '{%s}'";
      break;
  }
  return db_num_rows(db_query($query, $string));
}

/**
 * FormsAPI for domain_prefix_form.
 */
function domain_prefix_form_submit($form_id, $form_values) {

  // Flag messages for the administrative user only.
  $msg = TRUE;
  $create = TRUE;
  if ($form_values['domain_arguments']['user_submitted']) {
    $msg = FALSE;

    // Should we create tables for user domains?
    $create = variable_get('domain_user_prefixing', 0);
  }
  if ($create) {

    // Throw away what we don't need.
    $prefix = domain_prefix_string($form_values['domain_id']);
    $unset = array(
      'prefix_theme',
      'domain_id',
      'op',
      'submit',
      'restore',
      'form_token',
      'form_id',
      'execute',
    );
    $data = $form_values;
    foreach ($unset as $key) {
      unset($data[$key]);
    }

    // Delete existing records, but get the existing values first.
    $current = domain_prefix_lookup($form_values['domain_id']);
    db_query("DELETE FROM {domain_prefix} WHERE domain_id = %d", $form_values['domain_id']);

    // Get the database type.
    $db_type = $GLOBALS['db_type'];
    foreach ($data as $key => $value) {

      // Do not process tables for the source elements.
      // But be sure to set the proper source table prefix for copying data.
      if (substr($key, 0, 8) != '_source_') {
        $source = $data['_source_' . $key];
        if ($source > 0) {
          $source_prefix = domain_prefix_string($source);
        }
        else {
          $source_prefix = '';
        }
        $update = FALSE;
        if (empty($value)) {
          $value = DOMAIN_PREFIX_IGNORE;
          $update = TRUE;
        }
        $newtable = db_escape_table($prefix . $key);
        $module = domain_prefix_module_lookup($key);
        $exists = domain_prefix_table_exists($prefix, $key);
        $oldtable = db_escape_table($key);
        $sourcetable = db_escape_table($source_prefix . $key);
        if ($value == DOMAIN_PREFIX_CREATE) {
          if (!$exists) {
            if ($db_type == 'pgsql') {
              db_query("CREATE TABLE {%s} AS SELECT * FROM {%s}", $newtable, $sourcetable);
              db_query("TRUNCATE TABLE {%s}", $newtable);
            }
            else {
              db_query("CREATE TABLE {%s} LIKE {%s}", $newtable, $sourcetable);
            }
            if ($msg) {
              drupal_set_message(t('!string table created.', array(
                '!string' => $newtable,
              )));
            }
            $update = TRUE;
          }
          else {
            if ($current[$oldtable]['status'] == DOMAIN_PREFIX_COPY) {
              drupal_set_message(t('!string table cannot be created, since it already exists.', array(
                '!string' => $newtable,
              )));
            }
          }
        }
        else {
          if ($value == DOMAIN_PREFIX_COPY) {
            if (!$exists) {
              if ($db_type == 'pgsql') {
                db_query("CREATE TABLE {%s} AS SELECT * FROM {%s}", $newtable, $sourcetable);
              }
              else {
                db_query("CREATE TABLE {%s} LIKE {%s}", $newtable, $sourcetable);
                db_query("INSERT INTO {%s} SELECT * FROM {%s}", $newtable, $sourcetable);
              }

              // Update {sequences} table.
              domain_prefix_update_sequences('update', $newtable, $sourcetable);
              if ($msg) {
                drupal_set_message(t('!string table copied.', array(
                  '!string' => $newtable,
                )));
              }
              $update = TRUE;
            }
            else {
              if ($current[$oldtable]['status'] == DOMAIN_PREFIX_CREATE) {
                drupal_set_message(t('!string table cannot be copied, since it already exists.', array(
                  '!string' => $newtable,
                )));
              }
            }
          }
          else {
            if ($value == DOMAIN_PREFIX_UPDATE) {
              if ($exists > 0) {
                db_query("TRUNCATE TABLE {%s}", $newtable);
                db_query("INSERT INTO {%s} SELECT * FROM {%s}", $newtable, $sourcetable);

                // Update {sequences} table.
                domain_prefix_update_sequences('update', $newtable, $sourcetable);
                if ($msg) {
                  drupal_set_message(t('!string table updated from source.', array(
                    '!string' => $newtable,
                  )));
                }
                $update = TRUE;

                // Set the stored value to "copy" for record keeping.
                $value = DOMAIN_PREFIX_COPY;
              }
            }
            else {
              if ($value == DOMAIN_PREFIX_DROP) {
                if ($exists > 0) {
                  db_query("DROP TABLE {%s}", $newtable);
                  $value = DOMAIN_PREFIX_IGNORE;

                  // Update {sequences} table.
                  domain_prefix_update_sequences('drop', $newtable, $sourcetable);
                  if ($msg) {
                    drupal_set_message(t('!string table dropped.', array(
                      '!string' => $newtable,
                    )));
                  }
                  $update = TRUE;
                }
                else {
                  drupal_set_message(t('!string table does not exist.', array(
                    '!string' => $newtable,
                  )));
                }
              }
            }
          }
        }

        // Update our records.
        if (!$update && $value != 1) {
          $value = $current[$oldtable]['status'];
        }
        db_query("INSERT INTO {domain_prefix} (domain_id, status, tablename, module, source) VALUES (%d, %d, '%s', '%s', %d)", $form_values['domain_id'], $value, $key, $module, $form_values['_source_' . $key]);
      }
    }
  }

  // Clear the cache.
  cache_clear_all();
}

/**
 * Correct the {sequences} table if doing an update.
 *
 * @param $op
 * The operation to perform, either 'update' or 'drop.'
 * @param $newtable
 * The name of the table being updated.
 * @param $sourcetable
 * The name of the table providing the tempalte for the update
 */
function domain_prefix_update_sequences($op, $newtable, $sourcetable) {
  $result = db_query("SELECT name, id FROM {sequences} WHERE name LIKE '{%s%}'", $sourcetable);
  $dbprefix = domain_prefix_get_prefix();
  $source = explode('_', $dbprefix . $sourcetable);
  while ($variable = db_fetch_array($result)) {

    // We have to match the variable source name, to prevent duplicates.
    $var = explode('_', $variable['name']);
    array_pop($var);

    // Toss out the last element.
    $diff = array_diff($var, $source);
    if (empty($diff)) {
      $newvariable = $newtable . substr($variable['name'], strlen($dbprefix . $sourcetable));
      $target = db_result(db_query("SELECT id FROM {sequences} WHERE name = '{%s}'", $newvariable));
      if (!$target) {
        if ($op == 'update') {
          db_query("INSERT INTO {sequences} (name, id) VALUES ('{%s}', %d)", $newvariable, $variable['id']);
        }
      }
      else {
        if ($op == 'update') {
          db_query("UPDATE {sequences} SET id = %d WHERE name = '{%s}'", $variable['id'], $newvariable);
        }
        else {
          db_query("DELETE FROM {sequences} WHERE name = '{%s}'", $newvariable);
        }
      }
    }
  }
}

/**
 * Derive a module name from the table name
 *
 * In future, SchemaAPI will do this for us.
 * For now, we will have to map core tables.
 *
 * @param $table
 *   The name of the table being acted upon.
 */
function domain_prefix_module_lookup($table) {
  $match = explode('_', $table);
  $module = $match[0];
  switch ($table) {
    default:
      break;
    case 'boxes':
      $module = 'blocks';
      break;
    case 'file_revisions':
      $module = 'files';
      break;
    case 'cache_menu':
      $module = 'menu';
      break;
    case 'filter_formats':
      $module = 'filters';
      break;
    case 'access':
    case 'permission':
    case 'role':
    case 'users':
    case 'users_roles':
      $module = 'users';
      break;
    case 'url_alias':
      $module = 'path';
      break;
    case 'variable':
      $module = 'cache';
      break;
    case 'client':
    case 'client_system':
      $module = 'drupal';
      break;
    case 'accesslog':
      $module = 'statistics';
      break;
    case 'term_data':
    case 'term_hierarchy':
    case 'term_node':
    case 'term_relation':
    case 'term_synonym':
      $module = 'taxonomy';
      break;
  }
  return $module;
}

/**
 * Lookup stored table information for a domain.
 *
 * @param $domain_id
 *  The domain_id taken from {domain}.
 */
function domain_prefix_lookup($domain_id, $clear = FALSE) {
  static $domain_prefix;
  if ($clear || !isset($domain_prefix[$domain_id])) {
    $domain_prefix[$domain_id] = array();
    $result = db_query("SELECT domain_id, status, tablename, module, source FROM {domain_prefix} WHERE domain_id = %d", $domain_id);
    while ($data = db_fetch_array($result)) {
      $domain_prefix[$domain_id][$data['tablename']] = $data;
    }
  }
  return $domain_prefix[$domain_id];
}

/**
 * Names of tables explicitly not allowed to be copied
 */
function domain_prefix_disallow() {
  return array(
    'domain',
    'domain_conf',
    'domain_prefix',
    'domain_theme',
    'domain_user',
  );
}

/**
 * Implement hook_domainupdate().
 */
function domain_prefix_domainupdate($op, $domain = array(), $edit = array()) {
  switch ($op) {
    case 'create':
      $rule = variable_get('domain_prefix_options', 1);
      if ($rule) {

        // Get the current settings.
        $settings = unserialize(variable_get('domain_prefix', NULL));
        if (!empty($settings)) {
          $settings['domain_id'] = $domain['domain_id'];
          drupal_execute('domain_prefix_form', $settings, $domain['domain_id'], $edit['domain_arguments']);
        }
      }
      break;
    case 'delete':
      domain_prefix_drop_records($domain['domain_id']);
      break;
  }
}

/**
 * Drop tables created by this module.
 *
 * @param $domain_id
 *  The domain_id taken from {domain}.
 */
function domain_prefix_drop_records($domain_id) {
  $result = db_query("SELECT tablename FROM {domain_prefix} WHERE domain_id = %d AND status > 1", $domain_id);
  $prefix = domain_prefix_string($domain_id);
  while ($tables = db_fetch_array($result)) {
    $table = db_escape_table($prefix . $tables['tablename']);
    $exists = domain_prefix_table_exists($prefix, $tables['tablename']);
    if ($exists > 0) {
      db_query("DROP TABLE {%s}", $table);
      drupal_set_message(t('!string table dropped.', array(
        '!string' => $table,
      )));
    }
  }
  db_query("DELETE FROM {domain_prefix} WHERE domain_id = %d", $domain_id);
}

/**
 * Uniform prefix string
 *
 * @param $domain_id
 *  The domain_id taken from {domain}.
 */
function domain_prefix_string($domain_id) {
  return 'domain_' . $domain_id . '_';
}

/**
 * Implement hook_domaininstall()
 */
function domain_prefix_domaininstall() {

  // If Domain Prefix is being used, check to see that it is installed correctly.
  if (module_exists('domain_prefix') && !function_exists('_domain_prefix_load')) {
    drupal_set_message(t('The Domain Prefix module is not installed correctly.  Please edit your settings.php file as described in <a href="!url">INSTALL.txt</a>', array(
      '!url' => base_path() . drupal_get_path('module', 'domain_prefix') . '/INSTALL.txt',
    )));
  }
}
Functions

Name	Description
domain_prefix_configure_form	FormsAPI for generating the configuration form
domain_prefix_configure_form_submit	FormsAPI for the domain_prefix_configure_form.
domain_prefix_disallow	Names of tables explicitly not allowed to be copied
domain_prefix_domaininstall	Implement hook_domaininstall()
domain_prefix_domainlinks	Implement hook_domainlinks()
domain_prefix_domainupdate	Implement hook_domainupdate().
domain_prefix_drop_records	Drop tables created by this module.
domain_prefix_form	The table prefixing page for a domain.
domain_prefix_form_submit	FormsAPI for domain_prefix_form.
domain_prefix_get_prefix	Check for existing table prefixing.
domain_prefix_get_tables	Get the tables with the active prefix
domain_prefix_lookup	Lookup stored table information for a domain.
domain_prefix_menu	Implement hook_menu()
domain_prefix_module_lookup	Derive a module name from the table name
domain_prefix_perm	Implement hook_perm
domain_prefix_string	Uniform prefix string
domain_prefix_table_exists	Does a table exist -- we use this to bypass Drupal's default table prefixing check.
domain_prefix_update_sequences	Correct the {sequences} table if doing an update.
theme_domain_prefix_configure_form	FormsAPI theming for domain_prefix_configure_form.
_domain_prefix_sort	Helper sort function
Constants

Name	Description
DOMAIN_PREFIX_COPY
DOMAIN_PREFIX_CREATE
DOMAIN_PREFIX_DROP
DOMAIN_PREFIX_IGNORE	Constant definitions for the various actions.
DOMAIN_PREFIX_UPDATE
You are here

domain_prefix.module in Domain Access 5

File

Related topics

Functions

Constants

API Navigation
