domain_field_value.module

<?php

/**
 * Implements hook_theme_registry_alter().
 */
function domain_field_value_theme_registry_alter(&$theme_registry) {
  if (isset($theme_registry['form_element'])) {
    $theme_registry['form_element']['function'] = 'theme_domain_field_value_form_element';
  }
}

/**
 * Duplicate of theme_form_element() with the addition of
 *   drupal_render_children($element, array('domain_field_value'))
 * at the end since widgets from the 'text' module don't render children.
 */
function theme_domain_field_value_form_element($variables) {
  $element = &$variables['element'];

  // This function is invoked as theme wrapper, but the rendered form element
  // may not necessarily have been processed by form_builder().
  $element += array(
    '#title_display' => 'before',
  );

  // Add element #id for #type 'item'.
  if (isset($element['#markup']) && !empty($element['#id'])) {
    $attributes['id'] = $element['#id'];
  }
  // Add element's #type and #name as class to aid with JS/CSS selectors.
  $attributes['class'] = array('form-item');
  if (!empty($element['#type'])) {
    $attributes['class'][] = 'form-type-' . strtr($element['#type'], '_', '-');
  }
  if (!empty($element['#name'])) {
    $attributes['class'][] = 'form-item-' . strtr($element['#name'], array(' ' => '-', '_' => '-', '[' => '-', ']' => ''));
  }
  // Add a class for disabled elements to facilitate cross-browser styling.
  if (!empty($element['#attributes']['disabled'])) {
    $attributes['class'][] = 'form-disabled';
  }
  $output = '<div' . drupal_attributes($attributes) . '>' . "\n";

  // If #title is not set, we don't display any label or required marker.
  if (!isset($element['#title'])) {
    $element['#title_display'] = 'none';
  }
  $prefix = isset($element['#field_prefix']) ? '<span class="field-prefix">' . $element['#field_prefix'] . '</span> ' : '';
  $suffix = isset($element['#field_suffix']) ? ' <span class="field-suffix">' . $element['#field_suffix'] . '</span>' : '';

  switch ($element['#title_display']) {
    case 'before':
    case 'invisible':
      $output .= ' ' . theme('form_element_label', $variables);
      $output .= ' ' . $prefix . $element['#children'] . $suffix . "\n";
      break;

    case 'after':
      $output .= ' ' . $prefix . $element['#children'] . $suffix;
      $output .= ' ' . theme('form_element_label', $variables) . "\n";
      break;

    case 'none':
    case 'attribute':
      // Output no label and no required marker, only the children.
      $output .= ' ' . $prefix . $element['#children'] . $suffix . "\n";
      break;
  }

  if (!empty($element['#description'])) {
    $output .= '<div class="description">' . $element['#description'] . "</div>\n";
  }

  $output .= "</div>\n";

  // Start of this module's addition.
  if ($element['#type'] !== 'managed_file') {
    $output .= drupal_render_children($element, array('domain_field_value'));
  }

  return $output;
}

/**
 * Implements hook_form_alter().
 */
function domain_field_value_form_field_ui_field_edit_form_alter(&$form, $form_state) {
  $instance = $form['#instance'];
  $field = $form['#field'];

  if (empty($form['instance']['settings'])) {
    $form['instance']['settings'] = array();
  }
  $form['instance']['settings'] += domain_field_value_field_instance_settings_form($field, $instance);
}

/**
 * Configuration form for editing insert settings for a field instance.
 */
function domain_field_value_field_instance_settings_form($field, $instance) {
  $form['domain_field_value'] = array(
    '#type' => 'fieldset',
    '#title' => t('Domain Access Field Value Settings'),
    '#weight' => 15,
    '#collapsible' => FALSE,
    '#collapsed' => FALSE,
  );

  $form['domain_field_value']['enabled'] = array(
    '#type' => 'checkbox',
    '#title' => t('Enable Domain Access Field Value'),
    '#default_value' => $instance['settings']['domain_field_value']['enabled'],
    '#description' => t('Adds the option to limit field values to selected domains.'),
    '#weight' => 15,
  );

  foreach (domain_domains() as $data) {
    // The domain must be valid.
    if ($data['valid'] || user_access('access inactive domains')) {
      // Checkboxes must be filtered, select lists should not.
      $options[$data['domain_id']] = empty($format) ? check_plain($data['sitename']) : $data['sitename'];
    }
  }
  $form['domain_field_value']['domain_field_value_default'] = array(
    '#title' => t('Default domain(s)'),
    '#description' => t('The default domains that this field will be restricted to. '),
    '#type' => 'checkboxes',
    '#options' => $options,
    '#default_value' => $instance['settings']['domain_field_value']['domain_field_value_default'],
    '#weight' => 15.1,
    '#states' => array(
      'visible' => array(
        ':input[name="instance[settings][domain_field_value][enabled]"]' => array('checked' => TRUE),
      ),
    ),
  );
  return $form;
}

function domain_field_value_field_widget_form_alter(&$element, &$form_state, $context) {
  // Add display_field setting to field because file_field_widget_form() assumes it is set.
  $instance = $context['instance'];
  $settings = $instance['settings'];
  $field = $context['field'];
  if (isset($settings['domain_field_value']['enabled']) && $settings['domain_field_value']['enabled'] && $form_state['build_info']['form_id'] !== 'field_ui_field_edit_form') {
    if ($field['type'] == 'image' || $field['type'] == 'file') {
      foreach (element_children($element) as $delta) {
        $element[$delta]['#process'][] = 'domain_field_value_widget_process';
        $element[$delta]['#settings']['domain_field_value_default'] = $settings['domain_field_value']['domain_field_value_default'];
      }
    }
    else {
      $element['#process'][] = 'domain_field_value_widget_process';
      $element['#settings']['domain_field_value_default'] = $settings['domain_field_value']['domain_field_value_default'];
    }
  }
}

/**
 * An element #process callback for all field types.
 *
 * Expands all field types to include domain selection.
 */
function domain_field_value_widget_process($element, &$form_state, $form) {
  if (isset($element['#value'])) {
    // image & file
    $item = $element['#value'];
  }
  else {
    $item = isset($element['#entity']->{$element['#field_name']}[LANGUAGE_NONE][$element['#delta']]) ? $element['#entity']->{$element['#field_name']}[LANGUAGE_NONE][$element['#delta']] : array();

    $instance = field_info_instance($element['target_id']['#entity_type'], $element['target_id']['#field_name'], $element['target_id']['#bundle']);

  }

  foreach (domain_domains() as $data) {
    // The domain must be valid.
    if ($data['valid'] || user_access('access inactive domains')) {
      // Checkboxes must be filtered, select lists should not.
      $options[$data['domain_id']] = empty($format) ? check_plain($data['sitename']) : $data['sitename'];
    }
  }

  $element['domain_field_value'] = array(
    '#title' => t('Publish to'),
    '#type' => 'checkboxes',
    '#options' => $options,
    '#weight' => 20,
    '#access' => isset($item['fid']) ? (bool) $item['fid'] : true,
    '#default_value' => isset($item['domain_field_value']) ? $item['domain_field_value'] : $element['#settings']['domain_field_value_default'],
  );
  return $element;
}

/**
 * Implements hook_field_info_alter().
 */
function domain_field_value_field_info_alter(&$info) {
  // Add a setting to all field types.
  foreach ($info as $field_type => $field_type_info) {
    $info[$field_type]['instance_settings'] += array(
      'domain_field_value' => array(
        'enabled' => 0,
        'domain_field_value_default' => array(),
      ),
    );
  }
}






/**
 * Implements hook_field_attach_insert().
 */
function domain_field_value_field_attach_insert($entity_type, $entity) {
  domain_field_value_field_attach_update($entity_type, $entity);
}

/**
 * Implements hook_field_attach_update().
 */
function domain_field_value_field_attach_update($entity_type, $entity) {
  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  if (!isset($vid)) {
    $vid = $id;
  }

  foreach (field_info_instances($entity_type, $bundle) as $field_name => $instance) {

    // Skip the caption when it isn't present, or if it is disabled.
    if (
      !isset($instance['settings']['domain_field_value']) ||
      !$instance['settings']['domain_field_value']['enabled']
    ) { continue; }

    $field = field_info_field($field_name);
    $table_name = 'domain_field_value';
    $revision_name = 'domain_field_value_revision';

    if (!isset($entity->$field_name)) { continue; }

    db_delete($table_name)
      ->condition('field_name', $field_name)
      ->condition('entity_type', $entity_type)
      ->condition('entity_id', $id)
      ->execute();
    db_delete($revision_name)
      ->condition('field_name', $field_name)
      ->condition('entity_type', $entity_type)
      ->condition('entity_id', $id)
      ->condition('revision_id', $vid)
      ->execute();

    // Prepare the multi-insert query.
    $do_insert = FALSE;
    $columns = array('field_name', 'entity_type', 'entity_id', 'revision_id', 'bundle', 'delta', 'gid', 'realm');
    $query = db_insert($table_name)->fields($columns);
    $revision_query = db_insert($revision_name)->fields($columns);

    $items = (array) $entity->{$field_name}[LANGUAGE_NONE];
    $delta_count = 0;
    foreach ($items as $delta => $item) {
      if (empty($item['domain_field_value'])) { continue; }
      // We now know we have something to insert.
      $do_insert = TRUE;
      foreach ($item['domain_field_value'] as $domain_id) {
        // Unset checkboxes are set to (int)0 & checked boxes are a string with the ID.
        if ($domain_id > 0) {
          $record = array(
            'field_name' => $field_name,
            'entity_type' => $entity_type,
            'entity_id' => $id,
            'revision_id' => $vid,
            'bundle' => $bundle,
            'delta' => $delta,
            'gid' => $domain_id,
            'realm' => 'domain_id',
          );
          $query->values($record);
          if (isset($vid)) {
            $revision_query->values($record);
          }
        }
      }

      if ($field['cardinality'] != FIELD_CARDINALITY_UNLIMITED && ++$delta_count == $field['cardinality']) {
        break;
      }
    }

    // Execute the query if we have values to insert.
    if ($do_insert) {
      $query->execute();
      $revision_query->execute();
    }
  }
}

/**
 * Implements hook_field_attach_load().
 */
function domain_field_value_field_attach_load($entity_type, $entities, $age, $options) {
  foreach ($entities as $entity) {
    list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);
    if (!isset($vid)) {
      $vid = $id;
    }

    $load_current = $age == FIELD_LOAD_CURRENT;

    $table = $load_current ? 'domain_field_value' : 'domain_field_value_revision';

    $query = db_select($table, 't')
      ->fields('t')
      ->condition('entity_type', $entity_type)
      ->condition($load_current ? 'entity_id' : 'revision_id', $load_current ? $id : $vid)
      ->orderBy('delta');

    $results = $query->execute();

    foreach ($results as $row) {
      $field = field_info_instance($entity_type, $row->field_name, $bundle);
      if (
        !isset($field['settings']['domain_field_value']) ||
        !$field['settings']['domain_field_value']['enabled']
      ) { continue; }

      // Add the item to the field values for the entity.
      $entities[$row->entity_id]->{$row->field_name}[LANGUAGE_NONE][$row->delta]['domain_field_value'][] = $row->gid;
    }
  }
}

/**
 * Implements MODULE_preprocess_HOOK().
 */
function domain_field_value_preprocess_field(&$variables) {
  $domain = domain_get_domain();

  $instance = field_info_instance($variables['element']['#entity_type'], $variables['element']['#field_name'], $variables['element']['#bundle']);

  if (
    !isset($instance['settings']['domain_field_value']) ||
    !$instance['settings']['domain_field_value']['enabled']
  ) { return; }

  foreach ($variables['element']['#items'] as $key => $value) {
    if (isset($value['domain_field_value']) && !in_array($domain['domain_id'], $value['domain_field_value'])) {
      // Remove the field value that shouldn't be shown on the viewed domain.
      $variables['items'][$key]['#access'] = false;
    }
  }

  // Make sure label is hidden if all values are hidden.
  $preserve_label_setting = false;
  foreach ($variables['items'] as $key => $value) {
    if (!isset($variables['items'][$key]['#access']) || (isset($variables['items'][$key]['#access']) && $variables['items'][$key]['#access'])) {
      $preserve_label_setting = true;
    }
  }
  if (!$preserve_label_setting) {
    $variables['label_hidden'] = true;
  }
}


function domain_field_value_preprocess_node(&$variables) {
  //unset($variables['content']['field_photo_caption']);
  //unset($variables['content']['field_test_book_field_1']);
  //echo '<pre>';var_dump($variables['content']['field_test_book_field_1']);exit;
}

function domain_field_value_views_post_execute(&$view) {
  $domain = domain_get_domain();
  foreach ($view->result as $key=>$result) {
    foreach ($result as $fieldname => $field) {
      foreach ($field as $delta => $fieldinfo) {
        if (isset($fieldinfo['raw']['domain_field_value'])) {
          if (!in_array($domain['domain_id'], $fieldinfo['raw']['domain_field_value'])) {
            // Remove the field value that shouldn't be shown on the viewed domain.
            unset($view->result[$key]->{$fieldname}[$delta]);
            // Alternative way but the item is still counted as existing.
            //$view->result[$key]->{$fieldname}[$delta]['rendered']['#access'] = false;
          }
        }
      }
    }
  }
}