<?php
// $Id: subdomain.module,v 1.2.2.9 2009-04-03 13:20:57 setvik Exp $

// token.module token prefix
define('SUBDOMAIN_TOKEN_PREFIX', '~');

// Subdomain rewrite type (OG group or Node author)
define('SUBDOMAIN_GROUP', 1);
define('SUBDOMAIN_USER', 2);
define('SUBDOMAIN_VOCAB', 3);
define('SUBDOMAIN_TYPE', 4);

define('SUBDOMAIN_STYLE_NAME', 1);
define('SUBDOMAIN_STYLE_CUSTOM', 2);

// Used internally for custom subdomain rewrites (i.e. not used by token.module)
define('SUBDOMAIN_CUSTOM_TOKEN_NAME', '%name%');
define('SUBDOMAIN_CUSTOM_TOKEN_ID', '%id');

// Used to determine who can change group/user names
define('SUBDOMAIN_ALLOWCHANGE_NO', 0);
define('SUBDOMAIN_ALLOWCHANGE_YES', 1);
define('SUBDOMAIN_ALLOWCHANGE_ADMINONLY', 2);

/**
 * Implementation of hook_menu()
 */
function subdomain_menu($may_cache) {
  if ($may_cache) {
    $items[] = array(
      'path' => 'admin/settings/subdomain',
      'title' => t('Subdomain settings'),
      'description' => t('Configure subdomain settings.'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('subdomain_admin_settings'),
      'access' => user_access('administer site configuration')
    );
    $items[] = array(
      'path' => 'subdomain/test',
      'callback' => 'subdomain_check',
      'access' => TRUE,
    );
    $items[] = array(
      'path' => '~subdomain-test/subdomain/test',
      'callback' => 'subdomain_check',
      'access' => TRUE,
    );
  }
  return $items;
}

/**
 * Loads subdomain_debug.inc and checks installation requirements
 */
function subdomain_check() {
  require_once(drupal_get_path('module','subdomain') .'/subdomain_debug.inc');
  subdomain_check_server();
  exit;
}

/**
 * Implementation of hook_nodeapi()
 */
function subdomain_nodeapi(&$node, $op, $teaser, $page) {
    switch ($op) {
      case 'validate':
        $type = node_get_types('type',$node);
        $type_name = strtolower($type->name);
        $type_title = strtolower($type->title_label);
        if (module_exists('og') && og_is_group_type($node->type)) {
          $node->title = trim($node->title);

          // Allow only letters, numbers, and spaces
          if (variable_get('subdomain_allow_onlyalpha', FALSE) && !preg_match('!^[a-zA-Z0-9 ]+$!', $node->title)) {
            form_set_error('title', "The $type_name's $type_title can contain only letters, numbers and spaces");
          }

          // Disallow reserved subdomain
          elseif (subdomain_reserved($node->title)) {
            form_set_error('title', "Sorry. '$node->title' is not available for use. Please enter a different $type_title for your $type_name.");
          }

          // Ensure group name is unique
          elseif (db_result(db_query("SELECT 1 FROM {node} WHERE nid <> %d AND type = '%s' AND title = '%s'", $node->nid, $node->type, $node->title))) {
            form_set_error('title', "There is already a $type_name with that $type_title. Please enter a different $type_name");
          }

          // Disallow changes to group name (to avoid SEO issues and path alias getting out of sync with group content aliases)
          if ($node->nid) {
            $currentgroupname = db_result(db_query("SELECT title FROM {node} WHERE nid = %d", $node->nid));
            if (strtolower($currentgroupname) != strtolower($node->title)) {
              if (variable_get('subdomain_allowchange', SUBDOMAIN_ALLOWCHANGE_NO) == SUBDOMAIN_ALLOWCHANGE_NO
              || (variable_get('subdomain_allowchange', SUBDOMAIN_ALLOWCHANGE_NO) == SUBDOMAIN_ALLOWCHANGE_ADMINONLY && !user_access('administer site configuration'))) {
                form_set_error('title', "Sorry, $type_name {$type_title}s are permanent and may not be changed. You can change capitalization only.");
              }
            }
          }
        }

        // Disallow node titles that start with the subdomain token prefix character (else they'll be inadvertantly rewritten as subdomains)
        if (substr(trim($node->title), 0, strlen(SUBDOMAIN_TOKEN_PREFIX)) == SUBDOMAIN_TOKEN_PREFIX) {
          form_set_error('title', "Sorry, {$type_title}s can't start with a ". SUBDOMAIN_TOKEN_PREFIX .".");
        }
        break;

      case 'load':
        if (module_exists('og') && og_is_group_type($node->type)) {
          $node->subdomain = subdomain_raw_to_subdomain($node->title);
        }
        break;
    }
}

/**
 * Implementation of hook_user
 */
function subdomain_user($op, &$edit, &$user_edit, $category = NULL) {
  if ($op == 'validate' && variable_get('subdomain_type', SUBDOMAIN_USER) == SUBDOMAIN_USER && $category == 'account') {
    // If configured, disallow username changes if subdomains are set to Node Authors
    if (is_numeric($user_edit->uid) && $user_edit->name != $edit['name']) {
      if (variable_get('subdomain_allowchange', SUBDOMAIN_ALLOWCHANGE_NO) ==  SUBDOMAIN_ALLOWCHANGE_NO
      || (variable_get('subdomain_allowchange', SUBDOMAIN_ALLOWCHANGE_NO) == SUBDOMAIN_ALLOWCHANGE_ADMINONLY && !user_access('administer site configuration'))) {
        form_set_error('name', 'Sorry. Usernames are permanent and cannot be changed');
      }
    }

    // If configured, allow only letters and spaces in usernames
    elseif (variable_get('subdomain_allow_onlyalpha', FALSE) && !preg_match('!^[a-zA-Z0-9 ]+$!', $edit['name'])) {
      form_set_error('name', 'User Names can contain only letters, numbers and spaces');
    }
    
    elseif (subdomain_reserved($edit['name'])) {
      form_set_error('name', 'Sorry. '. check_plain($edit['name']) .' is restricted. Please choose a different username.');
    }
  }
}

/**
 * Implementation of hook_token_list()
 */
function subdomain_token_list($type = 'all') {
  if ($type == 'node') {
    $tokens['node']['subdomain'] = t('Subdomain token (place at the start of the path)');
  }
  if ($type == 'taxonomy') {
    $tokens['taxonomy']['subdomain'] = t('Subdomain token (place at the start of the path)');
  }
  elseif ($type == 'user') {
    $tokens['user']['subdomain'] = t('Subdomain token (place at the start of the path)');
  }
  return $tokens;
}

/**
 * Implementation of hook_token_values()
 */
function subdomain_token_values($type, $object = NULL) {
  $values['subdomain'] = NULL;
  switch ($type) {
    case 'node':
      switch (variable_get('subdomain_type', SUBDOMAIN_USER)) {
        case SUBDOMAIN_GROUP:
          if (module_exists('og') && og_is_group_type($object->type)) {
              $values['subdomain'] = subdomain_build_token($object->title, $object->nid);
          }
          elseif (isset($object->og_groups)) {
            // 1st Group in og_groups array is used for subdomain
            if ($groupname = db_result(db_query("SELECT title FROM {node} WHERE nid = %d", $object->og_groups[0]))) {
              $values['subdomain'] = subdomain_build_token($groupname, $object->og_groups[0]);
            };
          }
          else {
            $values['subdomain'] = '';
          }
          break;

        case SUBDOMAIN_USER:
          if (!empty($object->name)) {
            $values['subdomain'] = subdomain_build_token($object->name, $object->uid);
          }
          break;

        case SUBDOMAIN_TYPE:
          $values['subdomain'] = subdomain_build_token($object->type);
          break;

        case SUBDOMAIN_VOCAB:
          if (is_array($object->taxonomy)) {
            foreach ($object->taxonomy as $tid) {
              $term_name = db_result(db_query("SELECT name FROM {term_data} WHERE tid = %d AND vid = %d", $tid, variable_get('subdomain_vocab', 0)));
              if ($term_name) {
            	  $values['subdomain'] = subdomain_build_token($term_name, $tid);
            	  break;
              }
            }
          }
          break;
      }
      break;

    case 'taxonomy':
      if (variable_get('subdomain_type', SUBDOMAIN_USER) == SUBDOMAIN_VOCAB && $object->vid == variable_get('subdomain_vocab', 0)) {
        $values['subdomain'] = subdomain_build_token($object->name, $object->tid);
      }
      break;
    case 'user':
      if (variable_get('subdomain_type', SUBDOMAIN_USER) == SUBDOMAIN_USER) {
        $values['subdomain'] = subdomain_build_token($object->name, $object->uid);
      }
  }
  return $values;
}

/**
 * Implementation of hook_admin_settings()
 */
function subdomain_admin_settings() {

  require_once(drupal_get_path('module','subdomain') .'/subdomain_debug.inc');
  $check_requirements_result = subdomain_check_requirements();

  drupal_add_js(drupal_get_path('module', 'subdomain') . '/subdomain.js');

  $reserved_default = implode("\n", array('www', 'static'));

  $options[SUBDOMAIN_USER] = 'Node authors and author content';
  $options[SUBDOMAIN_TYPE] = 'Content types';
  if (module_exists('taxonomy')) {
    $vocabs = taxonomy_get_vocabularies();
    if (is_array($vocabs) && count($vocabs)) {
      foreach ($vocabs as $vocab) {
        $vocab_options[$vocab->vid] = $vocab->name;
      }
      if (is_array($vocab_options)) {
        $options[SUBDOMAIN_VOCAB] = 'Taxonomy Vocabulary and associated content';        
      }
    }
  }

  if (module_exists('og')) {
    $options[SUBDOMAIN_GROUP] = 'Organic groups and group content';
  }

  $form['subdomain_settings']['requirements'] = array(
    '#type' => 'fieldset',
    '#title' => 'Subdomain Prerequisites',
    '#description' => 'To enable subdomains on your website, you must first configure the following 4 items. If something isn\'t working, refer to the suggested solutions and make sure you have completed each step outlined in readme.txt.',
  );
  
  $form['subdomain_settings']['requirements']['body'] = array(
    '#type' => 'markup',
    '#value' => $check_requirements_result,
  );

  $form['subdomain_settings']['subdomain_type'] = array(
    '#type' => 'select', 
    '#title' => t('Create subdomains for'), 
    '#description' => !isset($options[SUBDOMAIN_GROUP]) || !isset($options[SUBDOMAIN_VOCAB]) ? 'To use Taxonomy or Organic Group mode, enable and configure those modules' : '',
    '#options' => $options, 
    '#default_value' => variable_get('subdomain_type', SUBDOMAIN_USER)
  );
  if (module_exists('taxonomy') && is_array($vocab_options)) {
    $form['subdomain_settings']['subdomain_vocab'] = array(
      '#type' => 'select',
      '#title' => t('With the selected vocabulary\'s terms'),
      '#options' => $vocab_options,
      '#default_value' => variable_get('subdomain_vocab', NULL),
      '#prefix' => '<div id="vocab" style="display:none;">',
      '#suffix' => '</div>'
    );
  }
  $form['subdomain_settings']['subdomain_style'] = array(
    '#type' => 'select',
    '#title' => t('Using'),
    '#options' => array(SUBDOMAIN_STYLE_NAME => 'Group or Node Author name', SUBDOMAIN_STYLE_CUSTOM => 'Custom...'),
    '#default_value' => variable_get('subdomain_style', SUBDOMAIN_STYLE_NAME)
  );
  $form['subdomain_settings']['subdomain_custom'] = array(
    '#type' => 'textfield',
    '#title' => t('Custom subdomain'),
    '#description' => 'You may use the tokens %name% and %id% for group-name/user-name and group-nid/user-uid respectively',
    '#default_value' => variable_get('subdomain_custom', NULL),
    '#prefix' => '<div id="subdomain_custom">',
    '#suffix' => '</div>'
  );
  $form['subdomain_settings']['subdomain_reserved'] = array(
    '#type' => 'textarea', 
    '#title' => t('But disallow the following subdomains'), 
    '#rows' => 10, 
    '#description' => 'Enter 1 subdomain per line', 
    '#default_value' => variable_get('subdomain_reserved', $reserved_default)
  );
  
  $form['subdomain_settings']['advanced']['subdomain_allow_onlyalpha'] = array(
    '#type' => 'checkbox',
    '#title' => 'Restrict group names to letters and numbers',
    '#default_value' => variable_get('subdomain_allow_onlyalpha', FALSE),
    '#description' => 'Restricting names to letters and numbers ensures the subdomain is the same as the group name, since anything else will be stripped from the URL.',
  );

  $form['subdomain_settings']['advanced']['subdomain_allowchange'] = array(
    '#type' => 'select',
    '#title' => 'Allow changes to group names?',
    '#options' => array(SUBDOMAIN_ALLOWCHANGE_NO => 'No', SUBDOMAIN_ALLOWCHANGE_YES => 'Yes', SUBDOMAIN_ALLOWCHANGE_ADMINONLY => 'Site administrators only'),
    '#default_value' => variable_get('subdomain_allowchange', SUBDOMAIN_ALLOWCHANGE_YES),
    '#description' => "Disallow changes to ensure that the links/URLs to content on your subdomains doesn't change. This will help prevent links from external sites and search engines breaking.",
  );
  
  $form['subdomain_settings']['subdomain_next'] = array(
    '#type' => 'markup',
    '#value' => '<div style="width:500px;">After saving, configure <strong>pathauto</strong> and place the <strong>[subdomain]</strong> token at the start of any paths you want on a subdomain</div>'
  );

  return system_settings_form($form);
}

function subdomain_admin_settings_validate($form_id, $form_values, $form) {
  if ($form_values['subdomain_style'] == SUBDOMAIN_STYLE_CUSTOM) {
    $custom = trim($form_values['subdomain_custom']);
    if (empty($custom)) {
      form_set_error('subdomain_custom', 'You forgot to specify a custom subdomain rewrite');
    }
    else {
      // get valid tokens out of the way
      $custom = str_replace(SUBDOMAIN_CUSTOM_TOKEN_NAME, '', $custom);
      $custom = str_replace(SUBDOMAIN_CUSTOM_TOKEN_ID, '', $custom);

      // Only allow letters and spaces in custom rewrite
      if (!preg_match('!^[a-zA-Z ]+$!', $custom)) {
        form_set_error('subdomain_custom', 'Apart from the ' . SUBDOMAIN_CUSTOM_TOKEN_NAME . ' and ' . SUBDOMAIN_CUSTOM_TOKEN_ID . ' tokens, the custom rewrite can only contain letters and spaces');
      }
    }
  }
  elseif (!empty($form_values['subdomain_custom'])) {
    // Erase custom subdomain token, if "custom" isn't the selected subdomain style
    form_set_value($form['subdomain_settings']['subdomain_custom'], NULL);
  }
  
  if ($form_values['subdomain_type'] != SUBDOMAIN_VOCAB && isset($form['subdomain_settings']['subdomain_vocab'])) {
    // Erase selected vocab if taxonomy vocab isn't the selected subdomain type
    form_set_value($form['subdomain_settings']['subdomain_vocab'], NULL);
  }
}

/**
 * Returns True if $subdomain is reserved
 */
function subdomain_reserved($name = NULL) {
  $subdomain = subdomain_raw_to_subdomain($name);
  $reserved_subdomain = strtolower(ereg_replace(chr(13) . chr(10), "\n", variable_get('subdomain_reserved', '')));
  if (in_array($subdomain, explode("\n", $reserved_subdomain))) {
    return TRUE;
  }
}

function subdomain_base_domain() {
  static $base_domain;
  if (empty($base_domain)) {
    global $cookie_domain;
    $base_domain = ltrim($cookie_domain, '.');
  }
  return $base_domain;
}

/**
 * Looks for subdomain token in Drupal generated URLs; if present, prepends to domain
 * NOTE: Requires a 1-line patch to includes/common.inc (See install.txt)
 */
function subdomain_url_rewrite_outbound(&$path, &$base, &$absolute) {

  $absolute = TRUE;

  if (substr($path, 0, 1) == SUBDOMAIN_TOKEN_PREFIX) {
    $path_parts = explode('/', substr($path, 1));
    $base = 'http://'. array_shift($path_parts) .'.'. subdomain_base_domain();
    $path = implode('/', $path_parts);
  }
  else {
    $base = 'http://'. subdomain_base_domain();
  }
}

function subdomain_url_rewrite_inbound($path) {
  global $cookie_domain;
  static $executed = FALSE;

  if ((!$executed || $path == 'subdomain/test') && $subdomain = _subdomain_get_subdomain()) {
    $executed = TRUE;

    // Don't touch path if subdomain is reserved
    if (subdomain_reserved($subdomain)) {
      return $path;
    }

    // Remove subdomain from $GLOBAL['base_url'] so we don't interfere with other modules like imagecache
    $GLOBALS['base_url'] = 'http://'. substr($cookie_domain, 1);

    // If uri is '/', but drupal rewrote as site frontpage ('node'), overwrite so can look up subdomain path
    if ($path == variable_get('site_frontpage', 'node') && ltrim(request_uri(),'/') != ltrim($path, '/')) {
      $alias_path = '';
    }
    else {
      $alias_path = $path;
    }

    $alias = '~'. $subdomain .($alias_path ? "/$alias_path" : "");

    $result = drupal_lookup_path('source', $alias);

    return $result ? $result : $alias;
  }
  return $path;
}

function _subdomain_get_subdomain() {
  global $cookie_domain;
  $subdomain = '';
  if (strlen($_SERVER['HTTP_HOST']) > strlen($cookie_domain)) {
    $subdomain_length = strpos($_SERVER['HTTP_HOST'], $cookie_domain);
    $subdomain = substr($_SERVER['HTTP_HOST'], 0, $subdomain_length);
  }
  return $subdomain;
}

function subdomain_raw_to_subdomain($groupname) {
  return str_replace(' ', '-', trim(strtolower($groupname)));
}

function subdomain_subdomain_to_token($subdomain) {
  return SUBDOMAIN_TOKEN_PREFIX . $subdomain;
}

function subdomain_build_token($name, $id = '') {
  if (variable_get('subdomain_style', SUBDOMAIN_STYLE_NAME) == SUBDOMAIN_STYLE_NAME) {
    $raw = $name;
  }
  elseif ($custom = variable_get('subdomain_custom', NULL)) {
    $raw = str_replace(SUBDOMAIN_CUSTOM_TOKEN_NAME, $name, $custom);
    $raw = str_replace(SUBDOMAIN_CUSTOM_TOKEN_ID, $id, $raw);
  }
  return subdomain_subdomain_to_token(subdomain_raw_to_subdomain($raw));
}