metadata_profiles/src/Controller/MetadataProfileController.php

<?php

namespace Drupal\metadata_profile\Controller;

use Drupal\Core\Config\ConfigFactoryInterface;
use Drupal\Core\Controller\ControllerBase;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\Core\Field\FieldTypePluginManagerInterface;
use Drupal\Core\Link;
use Drupal\Core\Messenger\MessengerTrait;
use Drupal\Core\Config\Config;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\Url;
use Drupal\field_permissions\Plugin\FieldPermissionType\Base;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Drupal\Core\Entity\EntityFieldManagerInterface;

class MetadataProfileController extends ControllerBase {
  use MessengerTrait;

  protected EntityFieldManagerInterface $entityFieldManager;

  protected FieldTypePluginManagerInterface $fieldTypePluginManager;

  protected $configFactory;
  /**
   * The route matcher.
   *
   * @var \Drupal\Core\Routing\RouteMatchInterface
   */
  protected $routeMatch;

  /**
   * The entity type machine name.
   *
   * @var string
   */
  protected $entityType;

  /**
   * The bundle machine name.
   *
   * @var string
   */
  protected $entityBundle;

  /**
   * The entity type that our config entity describes bundles of.
   *
   * @var string
   */
  protected $entityTypeBundleOf;

  public function __construct(EntityFieldManagerInterface $entity_field_manager,
                              FieldTypePluginManagerInterface $field_type_plugin_manager,
                              ConfigFactoryInterface $config_factory,
                              RouteMatchInterface $route_match) {
    $this->entityFieldManager = $entity_field_manager;
    $this->fieldTypePluginManager = $field_type_plugin_manager;
    $this->configFactory = $config_factory;
    $this->routeMatch = $route_match;
    $route_options = $this->routeMatch->getRouteObject()->getOptions();
    $array_keys = array_keys($route_options['parameters']);
    $this->entityType = array_shift($array_keys);
    $entity_type = $this->routeMatch->getParameter($this->entityType);
    $this->entityBundle = $entity_type->id();
    $this->entityTypeBundleOf = $entity_type->getEntityType()->getBundleOf();
  }

  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('entity_field.manager'),
      $container->get('plugin.manager.field.field_type'),
      $container->get('config.factory'),
      $container->get('current_route_match')
    );
  }

  /**
   * Returns a render array displaying the metadata profile for $content_type.
   *
   * @param $content_type
   * @return array
   */
  public function profile($content_type = NULL) {
    if (!$content_type) {
      $content_type = $this->entityBundle;
    }
    // Get core content type information.
    $node_type = $this->config('node.type.' . $content_type);
    if (!$node_type) {
      return ['#markup'=> 'Not a valid content type.'];
    }
    $build = $this->format_bundle($node_type);

    $metadata_profile = $this->getMetadataProfile($content_type);

    $build['summary_table'] = [
      '#type' => 'container',
      '#attributes'=> ['class' => ['scrolling-table-container']],
      'data' => $this->buildSummaryTable($metadata_profile),
    ];

    $build['fields'] = [
      '#type' => 'container',
      '#weight' => '9',
    ];
    // Get field information.
    $field_definitions = $this->entityFieldManager->getFieldDefinitions('node', $content_type);
    foreach ($field_definitions as $field_name => $field_definition) {
      $build['fields'][$field_name] = $this->display_field($field_name, $field_definition, $metadata_profile[$field_name]);
    }

    return $build;
  }

  /**
   * Format information about a bundle.
   */
  protected function format_bundle(Config $bundle) {
    $build = [
      '#type' => 'container',
      '#attached' => ['library' => ['metadata_profile/metadata_profile']],

    'title' => [
        '#plain_text' => $bundle->get('name'),
        '#prefix' => '<h1>',
        '#suffix' => '</h1>',
      ],
      'machine_name' => [
      '#plain_text' => $bundle->get('type'),
      '#prefix' => ' (',
      '#suffix' => ')',
      ],
      'description' => [
        '#plain_text' => $bundle->get('description'),
        '#prefix' => '<p>',
        '#suffix' => '</p>',
      ],
    ];
    return $build;
  }

  public function getMetadataProfile($bundle) {
    // $metadata_profile is an array of arrays. Its keys are the "short" machine names of the fields
    //  such as field_abstract. The values are arrays with the following keys:
    // * 'label' - text. the bundle's human-readable label.
    // * 'machine_name' - text. The short machine name such as 'field_abstract'.
    // * 'id' - text. The long machine name such as 'node.islandora_object.field_abstract'. (same as this array's key)
    // * 'edit_url' - Url object. The link to the edit page for that field (or to the base field override page).
    // * 'type' - text. The human readable type of the field. (e.g. "Entity Reference")
    // * 'type_machine_name' - text. The machine name of the type (e.g. 'entity_reference')
    // * 'required' - 'Required'|'Not required'. Whether the field is required.
    // * 'cardinality' - 'Not repeatable'|'Repeatable'|'Repeatable, limit N'
    // * 'auto_create' - 'Create new'|'Create new #bundle'|'Do not create new'|NULL Whether a relationship field allows new entity creation on the fly.
    // * 'target_bundles' - array. List of bundle names that are the target of this field.
    // * 'search_api' - associative array. Has the following keys:
    //     * 'in_search_api'  - True|False. True if some field matches.
    //     * 'fields' - array. The 'fields' array is keyed by the machine names of the search api fields,
    //                  which are arrays with the following fields:
    //         * 'search_api_field_name' - the machine name of the search api field.
    //         * 'search_api_field_label' - the human readable label of the search api field.
    //         * 'property_path' - the method for getting the values.
    //         * 'index_name' - the name of the Search API index (in case there are more than one)
    //         * 'fields_included' - for aggregate and EDTF processor fields, which fields are in that field.
    //         * 'facets' - associative array. has the following keys
    //             * 'has_facet' - True|False. True if there is a facet, even if not showing up (can use with url alias)
    //             * 'facets' - array. the 'facets' array is keyed by the machine name of the facet. each facet is an
    //                          array with keys:
        //             * 'facet_name'
        //             * 'facet_machine_name'
        //             * 'facet_source'
        //             * 'url_alias'
        //             * 'block_visible'

    $metadata_profile = [];
    $field_definitions = $this->entityFieldManager->getFieldDefinitions('node', $bundle);
    foreach ($field_definitions as $field_name => $field_definition) {
      $metadata_profile[$field_name] = [
        'label' => $field_definition->getLabel(),
        'machine_name' => $field_name,
        'id' => method_exists($field_definition, 'id') ? $field_definition->id() : $field_definition->getUniqueIdentifier(),
        'edit_url' => $this->getFieldEditUrl($field_definition),
        'details_link' => $this->getDetailsFragmentLink($field_name, $field_definition),
        'type' => $this->formatType($field_definition),
        'type_machine_name' => $field_definition->getType(),
        'required' => $this->formatRequired($field_definition),
        'repeatable' => $this->formatCardinality($field_definition),
        'auto_create' => $this->formatCreateNew($field_definition),
        'target_bundles' => $this->formatTargetBundles($field_definition),
      ];
      // Add solr
    }
    return $metadata_profile;
  }

  protected function buildSummaryTable($metadata_profile) {
    $rows = [];
    foreach ($metadata_profile as $field_name => $field_profile) {
      if (str_starts_with( $field_name, 'field_') or $field_name == 'title') {
        $rows[] = [
          $field_profile['details_link'],
          $field_profile['machine_name'],
          $field_profile['type'],
          $field_profile['required'],
          $field_profile['repeatable'],
          $field_profile['auto_create'],
          $this->formatListForTable($field_profile['target_bundles']),
        ];
      }
    }
    return [
      '#type' => 'table',
      '#header' => [
        $this->t('Field'),
        $this->t('Machine name'),
        $this->t('Type'),
        $this->t('Required'),
        $this->t('Repeatable'),
        $this->t('Create new'),
        $this->t('Target bundles')
        // TODO: add more columns
      ],
      '#rows' => $rows,
    ];

  }

  protected function display_field(string $field_name, FieldDefinitionInterface $field_definition, array $field_profile) {
    $render_array = [];

    if (str_starts_with($field_name, 'field_') or $field_name == 'title') {
      $render_array = [
        '#type' => 'container',
        '#attributes' => ['class' => ['field-info']],
        '#weight' => $this->formatWeight($field_definition), // This doesn't work.
        'title' => [
          '#plain_text' => $field_profile['label'],
          '#prefix' => '<h2 id="' . $field_name . '">',
          '#suffix' => '</h2> ',
        ],
        'machine_name' => [
          '#plain_text' => $field_name,
          '#prefix' => '(',
          '#suffix' => ') ',
        ],
        'edit_link' => $field_profile['edit_url'] ? $this->formatFieldEditLink($field_profile['edit_url']) : [],
        'table' => [
          '#type' => 'table',
          '#header' => ['Field Configuration',''],
          '#rows' => $this->getFieldTableRows($field_profile),
          '#attributes' => ['class' => ['field-info-table']],
        ],
        'description' => [
          '#type' => 'markup',
          '#markup' => $field_definition->getDescription() ?: $this->t('[No description]'),
          '#prefix' => '<b>Description:</b> ',
        ],
        'search_api' => $this->formatSearchApi($field_definition),
      ];

    }

    return $render_array;
  }

  protected function getFieldEditUrl(FieldDefinitionInterface $field_definition) {
    $redirect_url = Url::fromRoute('<current>', ['fragment' => $field_definition->getName()]);
    if ($field_definition->getFieldStorageDefinition() instanceof BaseFieldDefinition) {
      if ($this->moduleHandler()->moduleExists('base_field_override_ui')) {
        if (method_exists($field_definition, 'id')) {
          $edit_url = Url::fromRoute('entity.base_field_override.node_base_field_override_edit_form', [
            'node_type' => $field_definition->getTargetBundle(),
            'base_field_override' => $field_definition->id(),
            'destination' => $redirect_url->toString()
          ]);
        }
        else {
          return NULL;
        }

      }
      else {
        return NULL;
      }
    }
    else {
      $edit_url =  Url::fromRoute('entity.field_config.node_field_edit_form', [
        'node_type' => $field_definition->getTargetBundle(),
        'field_config' => $field_definition->id(),
        'destination' => $redirect_url->toString(),
      ]);
    }
    return $edit_url;
  }
  protected function formatFieldEditLink(Url $edit_url) {
    return [
      '#type' => 'link',
      '#url' => $edit_url,
      '#title' => $this->t('Edit'),
      '#attributes' => ['class' => ['edit-link']],
    ];
  }

  protected function getFieldTableRows(array $field_profile) {
      $rows = [
      [$this->t('Type:'), $field_profile['type']],
      [$this->t('Required:'), $field_profile['required']],
      [$this->t('Repeatable:'), $field_profile['repeatable']],
      ];
      if ($field_profile['auto_create']) {
        $rows[] = [$this->t('Create new:'), $field_profile['auto_create']];
      }
      if ($field_profile['target_bundles']) {
        $rows[] = [$this->t('Target bundles:'), $this->formatListForTable($field_profile['target_bundles'])];
       }

    return $rows;
  }

  protected function formatType(FieldDefinitionInterface $field_definition) {
    $type = $field_definition->getType();
    $type_label = $this->fieldTypePluginManager->getDefinition($type)['label'];
    if (in_array($type, ['entity_reference', 'typed_relation'])) {
      $type_label = $type_label . ' > ' . $field_definition->getSetting('target_type');
    }
    return $type_label;
  }
  protected function formatRequired(FieldDefinitionInterface $field_definition) {
    if ($field_definition->isRequired()) {
      return $this->t('Required');
    }
    else {
      return $this->t('Not required');
    }
  }

  /**
   * This does not work - most fields dont have a form weight specified in getDisplayOptions.
   */
  protected function formatWeight(FieldDefinitionInterface $field_definition) {
    return $field_definition->getDisplayOptions('form')['weight'];
  }

  protected function formatCardinality(FieldDefinitionInterface $field_definition) {
    $cardinality = $field_definition->getFieldStorageDefinition()->getCardinality();
    if ($cardinality == 1) {
      return $this->t('Not repeatable');
    } elseif ($cardinality < 0) {
      return $this->t('Repeatable');
    } elseif ($cardinality > 1) {
      return $this->t('Repeatable, limit :limit', [':limit' => $cardinality]);
    }
    return NULL;
  }

  protected function formatCreateNew(FieldDefinitionInterface $field_definition) {
    if (in_array($field_definition->getType(), ['entity_reference', 'typed_relation'])) {
      $create_new_bundle = $field_definition->getSetting('handler_settings')['auto_create_bundle'];
      $create_new = $field_definition->getSetting('handler_settings')['auto_create_bundle'];
      if ($create_new) {
        return $create_new_bundle ? 'Create new (' . $create_new_bundle . ')' : 'Create new';
      }
      else {
        return $this->t('Do not create new');
      }
    }
    else {
      return NULL;
    }

  }

  protected function formatTargetBundles(FieldDefinitionInterface $field_definition) {
    $handler = $field_definition->getSetting('handler');
    $setting = $field_definition->getSetting('handler_settings');
    if (!$setting) {
      return [];
    }
    $target_bundles = $setting['target_bundles'];
    foreach ($target_bundles as $index => $bundle) {
      if ($handler == 'default:taxonomy_term') {
        $bundle_config = $this->entityTypeManager()->getStorage('taxonomy_vocabulary')->load($bundle);
      }
      if ($handler == 'default:node') {
        $bundle_config = $this->entityTypeManager()->getStorage('node_type')->load($bundle);
      }
      // TODO: ADD MEDIA, PARAGRAPHS ETC
      if ($bundle_config) {
        $target_bundles[$index] = $bundle_config->get('name') . ' (' . $bundle . ')';
      }
    }
    return $target_bundles;

    return [
      '#theme' => 'item_list',
      '#title' => $this->t('Target bundles:'),
      '#items' => $target_bundles,
      '#type' => 'ul'
      ];
  }

  protected function formatListForTable(array $list) {
    return ['data' => [
      '#theme' => 'item_list',
      '#items' => array_values($list),
      '#type' => 'ul',
    ]];
  }
  protected function formatSearchApi($field_definition) {
    if ($this->moduleHandler()->moduleExists('search_api')) {
      $build = [
        '#type' => 'table',
        '#header' => [
          'col1' => $this->t('Search API field name'),
          'col2' => $this->t('Search API machine name'),
          'col3' => $this->t('Search API property path'),
          'col4' => $this->t('Search API field type'),
          'col0' => $this->t('Search API index'),
        ],
        '#rows' => [],
      ];
      $storage = $field_definition->getFieldStorageDefinition();
      if ($storage instanceof BaseFieldDefinition) {
        // Use property_path to find related fields.
        $field_id = 'node.' . $storage->getName();
      }
      else {
        $field_id = 'field.storage.' . $storage->get('id');
      }

      $search_api_indexes = $this->configFactory->listAll('search_api.index');
      foreach ($search_api_indexes as $index) {
        $index_config = $this->config($index);
        // Loop over fields.
        foreach ($index_config->get('field_settings') as $field_setting_name => $field_setting) {
          // Check dependencies.
          $field_dependencies = $field_setting['dependencies']['config'] ?: [];
          if (in_array($field_id, $field_dependencies)) {
            $build['#rows'][$field_setting_name] = $this->format_search_api_field($field_setting_name, $field_setting, $index_config);
          }
          // Check by property path.
          if ($field_setting['datasource_id'] == 'entity:node' and $field_setting['property_path'] == $field_definition->getName()) {
            $build['#rows'][$field_setting_name] = $this->format_search_api_field($field_setting_name, $field_setting, $index_config);
          }
          // Get Aggregated Fields.
          if ($field_setting['property_path'] == 'aggregated_field') {
            if (in_array('entity:node/' . $field_definition->getName(), $field_setting['configuration']['fields'])) {
              $build['#rows'][$field_setting_name] = $this->format_search_api_field($field_setting_name, $field_setting, $index_config);
            }
          }
          if ($field_definition->getType() == 'edtf') {
            // Get EDTF year.
            if ($field_setting['property_path'] == 'edtf_year') {
              $edtf_year_fields = $index_config->get('processor_settings')['edtf_year_only']['fields'] ?: [];
              if (in_array(str_replace('.', '|', $field_definition->id()), $edtf_year_fields)) {
                $build['#rows'][$field_setting_name] = $this->format_search_api_field($field_setting_name, $field_setting, $index_config);
              }
            }
            // Get EDTF Date
            if ($field_setting['property_path'] == 'edtf_dates') {
              $edtf_date_fields = $index_config->get('processor_settings')['edtf_date_processor']['fields'] ?: [];
              if (in_array(str_replace('.', '|', $field_definition->id()), $edtf_date_fields)) {
                $build['#rows'][$field_setting_name] = $this->format_search_api_field($field_setting_name, $field_setting, $index_config);
              }
            }
          }

        }
        if (count($build['#rows']) == 0) {
          return [];
        }
      }
      return $build;
    }
    else {
      return [];
    }
  }

  protected function format_search_api_field($field_setting_name, $field_setting, $index_config) {
    $build = [
      'data' => [
        $field_setting['label'],
        $field_setting_name,
        $field_setting['property_path'],
        $field_setting['type'],
        $index_config->get('name'),
      ]
    ];
    if ($field_setting['property_path'] == 'aggregated_field') {
      $list_render_array = [
        '#theme' => 'item_list',
        '#items' => $field_setting['configuration']['fields']
      ];
      $cell_element = [ 'data' => [
        '#type' => 'container',
        'label' => ['#markup' => $build['data'][2]],
        'list' => $list_render_array,
      ]];

      $build['data'][2] = $cell_element;
    }
    if (in_array($field_setting['property_path'], ['edtf_year', 'edtf_dates'])) {
      $list_render_array = [
        '#theme' => 'item_list',
        '#items' => $index_config->get('processor_settings')['edtf_year_only']['fields'] ?: $this->t('No fields avaailable')
      ];
      $cell_element = [ 'data' => [
        '#type' => 'container',
        'label' => ['#markup' => $build['data'][2]],
        'list' => $list_render_array,
      ]];

      $build['data'][2] = $cell_element;
    }
    return $build;
  }

  private function getDetailsFragmentLink(string $field_name, FieldDefinitionInterface $field_definition)
  {
    $url = Url::fromRoute('<current>', [], ['fragment' => $field_name]);
    return Link::fromTextAndUrl($field_definition->getLabel(), $url);
  }
}