Skip to content

D
dic-global-dev
Commit 85061060 by Manzar Hussain
Options

quartly results exposed remove

parent 6822c2ca
Showing with 2 additions and 1517 deletions
modules/taxonomy_menu/.travis.yml deleted 100644 → 0
language: php
php:
- 5.5
- 5.6
sudo: false
env:
global:
- PATH="$PATH:$HOME/.composer/vendor/bin"
- TESTDIR=$(pwd)
- DRUPAL_TI_MODULE_NAME="taxonomy_menu"
- DRUPAL_TI_SIMPLETEST_GROUP="taxonomy_menu"
- DRUPAL_TI_DB="drupal_travis_$$"
- DRUPAL_TI_DB_URL="mysql://root@127.0.0.1/$DRUPAL_TI_DB"
- DRUPAL_TI_WEBSERVER_URL="http://127.0.0.1"
- DRUPAL_TI_WEBSERVER_PORT="8080"
- DRUPAL_TI_SIMPLETEST_ARGS="--verbose --color --url $DRUPAL_TI_WEBSERVER_URL:$DRUPAL_TI_WEBSERVER_PORT"
# - DRUPAL_TI_PHPUNIT_CORE_SRC_DIRECTORY="./tests/src"
- DRUPAL_TI_ENVIRONMENT="drupal-8"
matrix:
# - DRUPAL_TI_RUNNERS="simpletest phpunit-core"
- DRUPAL_TI_RUNNERS="simpletest"
before_install:
- composer self-update
- composer global require "lionsad/drupal_ti:1.*"
- drupal-ti before_install
install:
- drupal-ti install
before_script:
- drupal-ti before_script
# - DRUPAL_TI_PHPUNIT_ARGS="-c $DRUPAL_TI_DRUPAL_DIR/modules/key/phpunit.xml --coverage-text"
script:
- drupal-ti script
after_script:
- drupal-ti after_script
notifications:
email: false
modules/taxonomy_menu/README.md deleted 100644 → 0
CONTENTS OF THIS FILE
---------------------
* Introduction
* Requirements
* Installation
* Configuration
* Maintainers
INTRODUCTION
------------
The Taxonomy Menu transforms your taxonomy vocabularies into menus.
* For a full description of the module visit:
https://www.drupal.org/project/taxonomy_menu
* To submit bug reports and feature suggestions, or to track changes visit:
https://www.drupal.org/project/issues/taxonomy_menu
* If you prefer GitHub or GitLab, feel free to send a pull/merge request:
https://github.com/unn/taxonomy_menu https://gitlab.com/dstol/taxonomy_menu
REQUIREMENTS
------------
This module requires no modules outside of Drupal core.
INSTALLATION
------------
* Install the Taxonomy Menu module as you would normally install a contributed
Drupal module. Visit https://www.drupal.org/node/1897420 for further
information.
CONFIGURATION
-------------
1. Navigate to Administration > Extend and enable the module.
2. Navigate to Administration > Structure > Taxonomy menu to add a new
taxonomy menu.
3. From the appropriate dropdown, assign a vocabulary.
4. From the appropriate dropdown, assign a menu.
5. Save.
6. Clear caches.
Modify the menu:
Please note - once the taxonomy menu is created, the menu items are decoupled
from the taxonomy.
You can adjust the weight/order of the menu items, the ability to expand, and if
the item is enabled or disabled.
We have built some constraints to ensure the menu items resemble it's associated
taxonomy. First, you cannot adjust the parents. This ensures the original
taxonomy tree stays somewhat in tact. Second, you cannot change the title or
description for taxonomy-generated menu items. This is rendered dynamically from
the original taxonomy.
Caching:
Menu items are heavily cached. Upon making changes to menus and/or taxonomy,
please clear the cache before submitting an issue.
MAINTAINERS
-----------
* Adam Bergstein (nerdstein) - https://www.drupal.org/u/nerdstein
* Andrey Troeglazov (andrey.troeglazov) -
https://www.drupal.org/u/andreytroeglazov
* David Stoline (dstol) - https://www.drupal.org/u/dstol
* Nick Wilde (NickWilde) - https://www.drupal.org/u/nickwilde
Supporting organization
* Hook 42 - https://www.drupal.org/hook-42
Development proudly supported through a PhpStorm license from JetBrains.
modules/taxonomy_menu/Tests/Controller/TaxonomyMenuTest.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Tests;
use Drupal\simpletest\WebTestBase;
/**
* Provides automated tests for the taxonomy_menu module.
*/
class TaxonomyMenuTest extends WebTestBase {
/**
* {@inheritdoc}
*/
public static function getInfo() {
return [
'name' => "taxonomy_menu TaxonomyMenu's controller functionality",
'description' => 'Test Unit for module taxonomy_menu and controller TaxonomyMenu.',
'group' => 'Other',
];
}
/**
* {@inheritdoc}
*/
public function setUp() {
parent::setUp();
}
/**
* Tests taxonomy_menu functionality.
*/
public function testTaxonomyMenu() {
// Check that the basic functions of module taxonomy_menu.
$this->assertEqual(TRUE, TRUE, 'Test Unit Generated via App Console.');
}
}
modules/taxonomy_menu/composer.json deleted 100644 → 0
{
"name": "drupal/taxonomy_menu",
"type": "drupal-module",
"description": "Creates menu items based on associations to taxonomy vocabularies",
"keywords": ["Drupal"],
"license": "GPL-2.0+",
"homepage": "http://drupal.org/project/taxonomy_menu",
"minimum-stability": "dev",
"support": {
"issues": "http://drupal.org/project/taxonomy_menu",
"source": "http://cgit.drupalcode.org/taxonomy_menu"
},
"require": { }
}
modules/taxonomy_menu/config/schema/taxonomy_menu.schema.yml deleted 100644 → 0
taxonomy_menu.taxonomy_menu.*:
type: config_entity
label: 'Taxonomy Menu config'
mapping:
id:
type: string
label: 'ID'
label:
type: label
label: 'Label'
vocabulary:
type: string
label: 'Vocabulary'
menu:
type: string
label: 'Menu'
expanded:
type: boolean
label: 'Expanded'
depth:
type: integer
label: 'Depth'
menu_parent:
type: string
label: 'Menu parent'
description_field_name:
type: string
label: 'Description field name'
use_term_weight_order:
type: boolean
label: 'Use term weight order'
modules/taxonomy_menu/src/Controller/TaxonomyMenu.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Controller;
use Drupal\Core\Controller\ControllerBase;
/**
* Class TaxonomyMenu.
*
* @package Drupal\taxonomy_menu\Controller
*/
class TaxonomyMenu extends ControllerBase {
/**
* Render taxonomy links.
*
* @return string
* Return Hello string.
*/
public function renderTaxonomyLinks() {
$markup = '';
// Load taxonomy menus.
$storage = \Drupal::entityTypeManager()->getStorage('taxonomy_menu');
$taxonomy_menus = $storage->loadMultiple();
$links = [];
// Get taxonomy and create menu links from vocabularies.
foreach ($taxonomy_menus as $taxonomy_menu) {
$links += $taxonomy_menu->generateTaxonomyLinks([]);
}
return [
'#type' => 'markup',
'#markup' => $this->t($markup),
];
}
}
modules/taxonomy_menu/src/Controller/TaxonomyMenuListBuilder.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Controller;
use Drupal\Core\Config\Entity\ConfigEntityListBuilder;
use Drupal\Core\Entity\EntityInterface;
/**
* Provides a listing of TaxonomyMenu.
*/
class TaxonomyMenuListBuilder extends ConfigEntityListBuilder {
/**
* {@inheritdoc}
*/
public function buildHeader() {
$header['label'] = $this->t('Taxonomy Menu');
$header['id'] = $this->t('Machine name');
$header['expanded'] = $this->t('Expanded');
return $header + parent::buildHeader();
}
/**
* {@inheritdoc}
*/
public function buildRow(EntityInterface $entity) {
$row['label'] = $entity->label();
$row['id'] = $entity->id();
$row['expanded'] = ($entity->expanded) ? $this->t('Yes') : $this->t('No');
// You probably want a few more properties here...
return $row + parent::buildRow($entity);
}
}
modules/taxonomy_menu/src/Entity/TaxonomyMenu.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Entity;
use Drupal\Core\Config\Entity\ConfigEntityBase;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\taxonomy\Entity\Term;
use Drupal\taxonomy\TermInterface;
use Drupal\taxonomy_menu\TaxonomyMenuInterface;
/**
* Defines the TaxonomyMenu entity.
*
* @ConfigEntityType(
* id = "taxonomy_menu",
* label = @Translation("Taxonomy menu"),
* handlers = {
* "list_builder" = "Drupal\taxonomy_menu\Controller\TaxonomyMenuListBuilder",
* "form" = {
* "add" = "Drupal\taxonomy_menu\Form\TaxonomyMenuForm",
* "edit" = "Drupal\taxonomy_menu\Form\TaxonomyMenuForm",
* "delete" = "Drupal\Core\Entity\EntityDeleteForm"
* }
* },
* config_prefix = "taxonomy_menu",
* admin_permission = "administer site configuration",
* entity_keys = {
* "id" = "id",
* "label" = "label",
* "uuid" = "uuid"
* },
* links = {
* "edit-form" = "/admin/structure/taxonomy_menu/{taxonomy_menu}",
* "delete-form" = "/admin/structure/taxonomy_menu/{taxonomy_menu}/delete",
* "collection" = "/admin/structure/taxonomy_menu"
* }
* )
*/
class TaxonomyMenu extends ConfigEntityBase implements TaxonomyMenuInterface {
/**
* The TaxonomyMenu ID.
*
* @var string
*/
protected $id;
/**
* The TaxonomyMenu label.
*
* @var string
*/
protected $label;
/**
* The taxonomy vocabulary.
*
* @var string
* The machine name of the vocabulary this entity represents.
*/
protected $vocabulary;
/**
* The depth to generate menu items.
*
* @var int
*/
protected $depth;
/**
* The menu to embed the vocabulary.
*
* @var string
* The machine name of the menu entity.
*/
protected $menu;
/**
* The expanded mode.
*
* @var bool
*/
public $expanded;
/**
* The menu parent.
*
* @var string
*/
protected $menu_parent;
/**
* The name of the description field.
*
* @var string
* The machine name of the field to be used as the description.
*/
protected $description_field_name;
/**
* {@inheritdoc}
*/
public function getVocabulary() {
return $this->vocabulary;
}
/**
* {@inheritdoc}
*/
public function getDepth() {
return $this->depth;
}
/**
* {@inheritdoc}
*/
public function getMenu() {
return $this->menu;
}
/**
* {@inheritdoc}
*/
public function getMenuParent() {
return $this->menu_parent;
}
/**
* Return if menu items should be ordered by the terms weight.
*
* Default value is TRUE.
*
* @return bool
* True or false.
*/
public function useTermWeightOrder() {
return isset($this->use_term_weight_order) ? $this->use_term_weight_order : TRUE;
}
/**
* {@inheritdoc}
*/
public function getDescriptionFieldName() {
return $this->description_field_name;
}
/**
* {@inheritdoc}
*/
public function preSave(EntityStorageInterface $storage) {
parent::preSave($storage);
if (!$this->isNew()) {
foreach (array_keys($this->getLinks([], TRUE)) as $link_key) {
$this->getMenuLinkManager()->removeDefinition($link_key, FALSE);
}
}
$this->addDependency('config', 'system.menu.' . $this->getMenu());
$this->addDependency('config', 'taxonomy.vocabulary.' . $this->getVocabulary());
}
/**
* {@inheritdoc}
*/
public function save() {
// Make sure we don't have any save exceptions before building menu
// definitions.
$return = parent::save();
foreach ($this->getLinks([], TRUE) as $link_key => $link_def) {
$this->getMenuLinkManager()->addDefinition($link_key, $link_def);
}
return $return;
}
/**
* {@inheritdoc}
*/
public function delete() {
foreach (array_keys($this->getLinks([], TRUE)) as $link_key) {
$this->getMenuLinkManager()->removeDefinition($link_key, FALSE);
}
parent::delete();
}
/**
* {@inheritdoc}
*/
public function getLinks($base_plugin_definition = [], $include_base_plugin_id = FALSE) {
/** @var $termStorage \Drupal\taxonomy\TermStorageInterface */
$termStorage = $this->entityTypeManager()->getStorage('taxonomy_term');
// Load taxonomy terms for tax menu vocab.
$terms = $termStorage->loadTree($this->getVocabulary(), 0, $this->getDepth() + 1);
$links = [];
// Create menu links for each term in the vocabulary.
foreach ($terms as $term) {
if (!$term instanceof TermInterface) {
$term = Term::load($term->tid);
}
$mlid = $this->buildMenuPluginId($term, $include_base_plugin_id);
$links[$mlid] = $this->buildMenuDefinition($term, $base_plugin_definition);
}
return $links;
}
/**
* Get the Menu Link Manager
*
* @return \Drupal\Core\Menu\MenuLinkManagerInterface
* The Menu Link Manager Service
*/
protected function getMenuLinkManager() {
return \Drupal::service('plugin.manager.menu.link');
}
/**
* {@inheritdoc}
*/
public function buildMenuPluginId(TermInterface $term, $include_base_plugin_id = TRUE) {
$plugin_id = '';
if ($include_base_plugin_id) {
$plugin_id .= 'taxonomy_menu.menu_link:';
}
$plugin_id .= 'taxonomy_menu.menu_link.' . $this->id() . '.' . $term->id();
return $plugin_id;
}
/**
* Generate a menu link plugin definition for a taxonomy term.
*
* @param \Drupal\taxonomy\TermInterface $term
* The taxonomy term for which to build a menu link render array.
* @param array $base_plugin_definition
* The base plugin definition to merge the link with.
*
* @return array
* The menu link plugin definition.
*/
protected function buildMenuDefinition(TermInterface $term, array $base_plugin_definition) {
$term_id = $term->id();
$term_url = $term->toUrl();
$taxonomy_menu_id = $this->id();
$menu_id = $this->getMenu();
// Determine parent link.
// TODO: Evaluate use case of multiple parents (should we make many menu items?)
$menu_parent_id = NULL;
/* @var $termStorage \Drupal\taxonomy\TermStorageInterface */
$termStorage = $this->entityTypeManager()->getStorage('taxonomy_term');
$parents = $termStorage->loadParents($term_id);
$parents = array_values($parents);
if (is_array($parents) && count($parents) && !is_null($parents[0]) && $parents[0] != '0') {
$menu_parent_id = $this->buildMenuPluginId($parents[0]);
}
// Note: if menu_parent_id is NULL, it will not update the hierarchy properly.
if (empty($menu_parent_id)) {
$menu_parent_id = str_replace($this->getMenu() . ':', '', $this->getMenuParent());
}
// TODO: Consider implementing a forced weight based on taxonomy tree.
// Generate link.
$arguments = ['taxonomy_term' => $term_id];
$link = $base_plugin_definition;
$link += [
'id' => $this->buildMenuPluginId($term),
'title' => $term->label(),
'description' => $term->getDescription(),
'menu_name' => $menu_id,
'expanded' => $this->expanded,
'metadata' => [
'taxonomy_menu_id' => $taxonomy_menu_id,
'taxonomy_term_id' => $term_id,
],
'route_name' => $term_url->getRouteName(),
'route_parameters' => $term_url->getRouteParameters(),
'load arguments' => $arguments,
'parent' => $menu_parent_id,
'provider' => 'taxonomy_menu',
'class' => 'Drupal\taxonomy_menu\Plugin\Menu\TaxonomyMenuMenuLink',
];
// Order by terms weight if configured for this taxonomy_menu.
if ($this->useTermWeightOrder()) {
$link['weight'] = $term->getWeight();
}
\Drupal::moduleHandler()->alter('taxonomy_menu_link', $link, $term);
return $link;
}
}
modules/taxonomy_menu/src/Form/TaxonomyMenuForm.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Form;
use Drupal\Core\Entity\EntityForm;
use Drupal\Core\Form\FormStateInterface;
use Drupal\system\Entity\Menu;
/**
* Class TaxonomyMenuForm.
*
* @package Drupal\taxonomy_menu\Form
*/
class TaxonomyMenuForm extends EntityForm {
/**
* {@inheritdoc}
*/
public function form(array $form, FormStateInterface $form_state) {
$form = parent::form($form, $form_state);
/* @var $taxonomy_menu \Drupal\taxonomy_menu\Entity\TaxonomyMenu */
$taxonomy_menu = $this->entity;
$form['label'] = [
'#type' => 'textfield',
'#title' => $this->t('Label'),
'#maxlength' => 255,
'#default_value' => $taxonomy_menu->label(),
'#description' => $this->t("Label for the Taxonomy Menu."),
'#required' => TRUE,
];
$form['id'] = [
'#type' => 'machine_name',
'#default_value' => $taxonomy_menu->id(),
'#machine_name' => [
'exists' => '\Drupal\taxonomy_menu\Entity\TaxonomyMenu::load',
],
'#disabled' => !$taxonomy_menu->isNew(),
];
// Vocabulary selection.
$options = [];
$vocabulary_storage = \Drupal::entityTypeManager()->getStorage('taxonomy_vocabulary');
foreach ($vocabulary_storage->loadMultiple() as $vocabulary) {
$options[$vocabulary->id()] = $vocabulary->label();
}
$form['vocabulary'] = [
'#type' => 'select',
'#title' => $this->t('Vocabulary'),
'#options' => $options,
'#default_value' => $taxonomy_menu->getVocabulary(),
'#ajax' => [
'callback' => '::ajaxReplaceDescriptionFieldForm',
'wrapper' => 'description-field-container',
'method' => 'replace',
],
];
// Description field selection.
$form['description_container'] = [
'#type' => 'container',
'#prefix' => '<div id="description-field-container">',
'#suffix' => '</div>',
];
$selected_vocabulary = $taxonomy_menu->getVocabulary();
if ($selected_vocabulary) {
$field_definitions = $this->entityManager->getFieldDefinitions('taxonomy_term', $selected_vocabulary);
// Build a field options array.
$field_options = ['' => $this->t('none')];
if (count($field_definitions)) {
foreach ($field_definitions as $field_name => $field_definition) {
$field_options[$field_name] = $field_definition->getName();
}
}
if (count($field_options)) {
$form['description_container']['description_field_name'] = [
'#type' => 'select',
'#title' => $this->t('Description field'),
'#description' => $this->t('Select the field to be used for the menu item description.'),
'#options' => $field_options,
'#default_value' => $taxonomy_menu->getDescriptionFieldName(),
];
}
}
// Menu selection.
$options = [];
$menu_storage = \Drupal::entityTypeManager()->getStorage('menu');
foreach ($menu_storage->loadMultiple() as $menu) {
$options[$menu->id()] = $menu->label();
}
$form['menu'] = [
'#type' => 'select',
'#title' => $this->t('Menu'),
'#options' => $options,
'#default_value' => $taxonomy_menu->getMenu(),
];
$form['expanded'] = [
'#type' => 'checkbox',
'#title' => $this->t('All menus entries expanded'),
'#default_value' => $taxonomy_menu->expanded,
];
$form['depth'] = [
'#type' => 'select',
'#title' => $this->t('Depth'),
'#default_value' => $taxonomy_menu->getDepth(),
'#options' => range(1, 9),
];
// Menu selection.
$custom_menus = Menu::loadMultiple();
foreach ($custom_menus as $menu_name => $menu) {
$custom_menus[$menu_name] = $menu->label();
}
asort($custom_menus);
$menu_parent_selector = \Drupal::service('menu.parent_form_selector');
$available_menus = $custom_menus;
$menu_options = $menu_parent_selector->getParentSelectOptions(NULL, $available_menus);
$form['menu_parent'] = [
'#type' => 'select',
'#title' => $this->t('Parent menu link'),
'#options' => $menu_options,
'#default_value' => $taxonomy_menu->getMenuParent(),
];
// If this checkbox is active, use the term weight for the menu item order.
// Otherwise the menu items will be sorted alphabetically.
// The default is order by weight.
$form['use_term_weight_order'] = [
'#type' => 'checkbox',
'#title' => $this->t('Use term weight order'),
'#default_value' => isset($taxonomy_menu->use_term_weight_order) ? $taxonomy_menu->use_term_weight_order : TRUE,
];
return $form;
}
/**
* AJAX callback; Builds the description field selector.
*/
public static function ajaxReplaceDescriptionFieldForm(array &$form, FormStateInterface $form_state) {
return $form['description_container'];
}
/**
* {@inheritdoc}
*/
public function save(array $form, FormStateInterface $form_state) {
$taxonomy_menu = $this->entity;
$status = $taxonomy_menu->save();
if ($status) {
drupal_set_message($this->t('Saved the %label Taxonomy Menu.', [
'%label' => $taxonomy_menu->label(),
]));
}
else {
drupal_set_message($this->t('The %label Taxonomy Menu was not saved.', [
'%label' => $taxonomy_menu->label(),
]));
}
$form_state->setRedirectUrl($taxonomy_menu->toUrl('collection'));
}
}
modules/taxonomy_menu/src/Plugin/Derivative/TaxonomyMenuMenuLink.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Plugin\Derivative;
use Drupal\Component\Plugin\Derivative\DeriverBase;
use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
use Drupal\Core\Entity\EntityStorageInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
/**
* Provides menu links for Taxonomy Menus.
*
* @see \Drupal\taxonomy_menu\Plugin\Menu\TaxonomyMenuMenuLink
*/
class TaxonomyMenuMenuLink extends DeriverBase implements ContainerDeriverInterface {
/**
* The taxonomy menu storage.
*
* @var \Drupal\Core\Entity\EntityStorageInterface
*/
protected $taxonomyMenuStorage;
/**
* Sets up the storage handler.
*
* @param \Drupal\Core\Entity\EntityStorageInterface $taxonomy_menu_storage
* The taxonomy menu storage.
*/
public function __construct(EntityStorageInterface $taxonomy_menu_storage) {
$this->taxonomyMenuStorage = $taxonomy_menu_storage;
}
/**
* {@inheritdoc}
*/
public static function create(ContainerInterface $container, $base_plugin_id) {
return new static(
$container->get('entity.manager')->getStorage('taxonomy_menu')
);
}
/**
* {@inheritdoc}
*/
public function getDerivativeDefinitions($base_plugin_definition) {
$links = [];
/* @var $taxonomy_menus \Drupal\taxonomy_menu\TaxonomyMenuInterface[] */
$taxonomy_menus = $this->taxonomyMenuStorage->loadMultiple();
//MenuLinkContent entity, menulinkcontent table, look for data
foreach ($taxonomy_menus as $taxonomy_menu) {
/* @var $taxonomy_menu \Drupal\taxonomy_menu\TaxonomyMenuInterface */
$taxonomy_menu->getMenu();
$links = array_merge($links, $taxonomy_menu->getLinks($base_plugin_definition));
}
return $links;
}
}
modules/taxonomy_menu/src/Plugin/Menu/TaxonomyMenuMenuLink.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Plugin\Menu;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Menu\MenuLinkBase;
use Drupal\Core\Menu\StaticMenuLinkOverridesInterface;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
/**
* Defines menu links provided by taxonomy menu.
*
* @see \Drupal\taxonony_menu\Plugin\Derivative\TaxonomyMenuMenuLink
*/
class TaxonomyMenuMenuLink extends MenuLinkBase implements ContainerFactoryPluginInterface {
/**
* {@inheritdoc}
*
* Other possible overrides:
* - 'menu_name' => 1,
* - 'parent' => 1,
* - 'title' => 1,
* - 'description' => 1,
* - 'metadata' => 1,
*/
protected $overrideAllowed = [
'weight' => 1,
'expanded' => 1,
'enabled' => 1,
'parent' => 1,
];
/**
* The entity type manager.
*
* @var \Drupal\Core\Entity\EntityTypeManagerInterface
*/
protected $entityTypeManager;
/**
* The static menu link service used to store updates to weight/parent etc.
*
* @var \Drupal\Core\Menu\StaticMenuLinkOverridesInterface
*/
protected $staticOverride;
/**
* Constructs a new TaxonomyMenuMenuLink.
*
* @param array $configuration
* A configuration array containing information about the plugin instance.
* @param string $plugin_id
* The plugin_id for the plugin instance.
* @param mixed $plugin_definition
* The plugin implementation definition.
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
* The entity type manager.
* @param \Drupal\Core\Menu\StaticMenuLinkOverridesInterface $static_override
* The static menu override.
*/
public function __construct(
array $configuration,
$plugin_id,
$plugin_definition,
EntityTypeManagerInterface $entity_type_manager,
StaticMenuLinkOverridesInterface $static_override
) {
$this->configuration = $configuration;
$this->pluginId = $plugin_id;
$this->pluginDefinition = $plugin_definition;
$this->entityTypeManager = $entity_type_manager;
$this->staticOverride = $static_override;
}
/**
* {@inheritdoc}
*/
public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
return new static(
$configuration,
$plugin_id,
$plugin_definition,
$container->get('entity_type.manager'),
$container->get('menu_link.static.overrides')
);
}
/**
* {@inheritdoc}
*/
public function getTitle() {
/* @var $link \Drupal\taxonomy\Entity\Term. */
$link = $this->entityTypeManager->getStorage('taxonomy_term')
->load($this->pluginDefinition['metadata']['taxonomy_term_id']);
$language = \Drupal::languageManager()->getCurrentLanguage()->getId();
if ($link->hasTranslation($language)) {
$translation = $link->getTranslation($language);
return $translation->label();
}
else {
return $link->label();
}
return NULL;
}
/**
* {@inheritdoc}
*/
public function getDescription() {
/* @var $link \Drupal\taxonomy\Entity\Term. */
$link = $this->entityTypeManager->getStorage('taxonomy_term')
->load($this->pluginDefinition['metadata']['taxonomy_term_id']);
// Get the description field name.
$taxonomy_menu = $this->entityTypeManager->getStorage('taxonomy_menu')->load($this->pluginDefinition['metadata']['taxonomy_menu_id']);
$description_field_name = $taxonomy_menu->getDescriptionFieldName();
$language = \Drupal::languageManager()->getCurrentLanguage()->getId();
if ($link->hasTranslation($language)) {
$translation = $link->getTranslation($language);
if (!empty($translation) && $translation->hasField($description_field_name)) {
return $translation->{$description_field_name}->value;
}
}
elseif (!empty($link) && $link->hasField($description_field_name)) {
return $link->{$description_field_name}->value;
}
return NULL;
}
/**
* {@inheritdoc}
*/
public function updateLink(array $new_definition_values, $persist) {
$overrides = array_intersect_key($new_definition_values, $this->overrideAllowed);
// Update the definition.
$this->pluginDefinition = $overrides + $this->pluginDefinition;
if ($persist) {
// TODO - consider any "persistence" back to TaxonomyMenu and/or Taxonomy
// upon menu link update.
// Always save the menu name as an override to avoid defaulting to tools.
$overrides['menu_name'] = $this->pluginDefinition['menu_name'];
$this->staticOverride->saveOverride($this->getPluginId(), $this->pluginDefinition);
}
return $this->pluginDefinition;
}
/**
* {@inheritdoc}
*/
public function isDeletable() {
return TRUE;
}
/**
* {@inheritdoc}
*/
public function deleteLink() {
}
}
modules/taxonomy_menu/src/TaxonomyMenuHelper.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Menu\MenuLinkManagerInterface;
use Drupal\taxonomy\TermInterface;
/**
* Class TaxonomyMenu.
*
* @package Drupal\taxonomy_menu
*/
class TaxonomyMenuHelper {
/**
* Taxonomy Menu storage.
*
* @var \Drupal\Core\Entity\EntityStorageInterface
*/
protected $menuStorage;
/**
* Menu Link Manager.
*
* @var \Drupal\Core\Menu\MenuLinkManagerInterface
*/
protected $manager;
/**
* Constructor.
*
* @param EntityTypeManagerInterface $entity_type_manager
* @param \Drupal\Core\Menu\MenuLinkManagerInterface $manager
* The menu link manager.
* @internal param EntityTypeManagerInterface $entity_manager The storage interface.* The storage interface.
*/
public function __construct(EntityTypeManagerInterface $entity_type_manager, MenuLinkManagerInterface $manager) {
$this->menuStorage = $entity_type_manager->getStorage('taxonomy_menu');
$this->manager = $manager;
}
/**
* A reverse lookup of a taxonomy term menus by vocabulary.
*
* @param string $vid
* The vocabulary id.
*
* @return \Drupal\taxonomy_menu\TaxonomyMenuInterface[]
* The Taxonomy Menu
*/
public function getTermMenusByVocabulary($vid) {
return $this->menuStorage->loadByProperties(['vocabulary'=>$vid]);
}
/**
* Create menu entries associate with the vocabulary of this term.
*
* @param \Drupal\taxonomy\TermInterface $term
* Term
*/
public function generateTaxonomyMenuEntries(TermInterface $term, $rebuild_all = TRUE) {
// Load relevant taxonomy menus.
$tax_menus = $this->getTermMenusByVocabulary($term->getVocabularyId());
foreach ($tax_menus as $menu) {
foreach ($menu->getLinks([], TRUE) as $plugin_id => $plugin_def) {
if (!$rebuild_all) {
$plugin_id_parts = explode('.', $plugin_id);
$term_id = array_pop($plugin_id_parts);
if ($term->id() != $term_id) {
continue;
}
}
if ($this->manager->hasDefinition($plugin_id)) {
$this->manager->updateDefinition($plugin_id, $plugin_def);
}
else {
$this->manager->addDefinition($plugin_id, $plugin_def);
}
}
}
}
/**
* Update menu entries associate with the vocabulary of this term.
*
* @param \Drupal\taxonomy\TermInterface $term
* Term
*/
public function updateTaxonomyMenuEntries(TermInterface $term, $rebuild_all = TRUE) {
// Load relevant taxonomy menus.
$tax_menus = $this->getTermMenusByVocabulary($term->getVocabularyId());
/** @var $menu \Drupal\taxonomy_menu\TaxonomyMenuInterface */
foreach ($tax_menus as $menu) {
$links = $menu->getLinks([], TRUE);
foreach ($links as $plugin_id => $plugin_def) {
if (!$rebuild_all) {
$plugin_id_explode = explode('.', $plugin_id);
$term_id = array_pop($plugin_id_explode);
if ($term->id() != $term_id) {
continue;
}
}
if ($this->manager->hasDefinition($plugin_id)) {
$this->manager->updateDefinition($plugin_id, $plugin_def, FALSE);
}
else {
// Remove specific menu link if vid term is different to this old vid.
if ($term->original->getVocabularyId() != $term->getVocabularyId()) {
$this->removeTaxonomyMenuEntries($term->original);
}
$this->manager->addDefinition($plugin_id, $plugin_def);
}
}
}
}
/**
* Remove menu entries associate with the vocabulary of this term.
*
* @param \Drupal\taxonomy\TermInterface $term
* Term.
* @param bool $rebuild_all
* Whether to rebuild all links or not.
*/
public function removeTaxonomyMenuEntries(TermInterface $term, $rebuild_all = TRUE) {
// Load relevant taxonomy menus.
$tax_menus = $this->getTermMenusByVocabulary($term->getVocabularyId());
/** @var $menu \Drupal\taxonomy_menu\TaxonomyMenuInterface */
foreach ($tax_menus as $menu) {
// Remove all links.
if ($rebuild_all) {
$links = array_keys($menu->getLinks([], TRUE));
foreach ($links as $plugin_id) {
$this->manager->removeDefinition($plugin_id, FALSE);
}
// Remove specific term link. Note - this link does not exist in the taxonomy menu and is not in $links.
} else if (!empty($term)) {
$this->manager->removeDefinition($menu->buildMenuPluginId($term), FALSE);
}
}
}
}
modules/taxonomy_menu/src/TaxonomyMenuInterface.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu;
use Drupal\Core\Config\Entity\ConfigEntityInterface;
use Drupal\taxonomy\TermInterface;
/**
* Provides an interface defining a TaxonomyMenu entity.
*/
interface TaxonomyMenuInterface extends ConfigEntityInterface {
/**
* Get the menu that the menu items are being created in.
*
* @return string
* The machine name of the menu entity holding the vocabulary's menu items.
*/
public function getMenu();
/**
* Get the vocabulary being used.
*
* @return string
* The vocabulary whose terms will be used to generate a menu.
*/
public function getVocabulary();
/**
* Get the depth of terms to generate menu items for.
*
* @return int
* The depth.
*/
public function getDepth();
/**
* Get the menu item to use as the parent for the taxonomy menu.
*
* @return string
* The menu item id string.
*/
public function getMenuParent();
/**
* @return string
* The machine name of the field to be used as the description.
*/
public function getDescriptionFieldName();
/**
* Get menu link plugin definitions
*
* @param array $base_plugin_definition
*
* @param bool $include_base_plugin_id
* If true, 'taxonomy_menu.menu_link:' will be prepended to the returned
* plugin ids.
*
* @return array
* Associative array of menu links ids and definitions.
*/
public function getLinks($base_plugin_definition = [], $include_base_plugin_id = FALSE);
/**
* Generates a menu link id for the taxonomy term.
*
* @param \Drupal\taxonomy\TermInterface $term
* Term to build menu item for.
* @param bool $include_base_plugin_id
* Include base plugin id in menu item id.
* @return string
* A unique string id for the menu item.
*/
public function buildMenuPluginId(TermInterface $term, $include_base_plugin_id = TRUE);
}
modules/taxonomy_menu/src/Tests/TaxonomyMenuOperations.php deleted 100644 → 0
<?php
namespace Drupal\taxonomy_menu\Tests;
use Drupal\simpletest\WebTestBase;
/**
* Tests the operations of Taxonomy Menu.
*
* @group taxonomy_menu
*/
class TaxonomyMenuOperations extends WebTestBase {
public static $modules = ['taxonomy_menu', 'system', 'menu_ui', 'taxonomy', 'dblog'];
/**
* Set up for all tests.
*/
function setUp() {
parent::setUp();
// Create user with permission to create policy.
$user1 = $this->drupalCreateUser(['administer site configuration', 'administer taxonomy']);
$this->drupalLogin($user1);
// Create a testing taxonomy vocabulary.
$this->drupalGet('admin/structure/taxonomy/add');
$edit = [
'vid' => 'test_tax_vocab',
'name' => 'Test',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
// Create logged in user.
$perms = [
'administer site configuration',
'administer taxonomy',
'administer menu'
//'delete terms in test',
//'edit terms in test'
];
$admin_user = $this->drupalCreateUser($perms);
$this->drupalLogin($admin_user);
// Add sample terms to the vocabulary.
$this->drupalGet('admin/structure/taxonomy/manage/test_tax_vocab/add');
$edit = [
'name[0][value]' => 'test term 1',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
$this->drupalGet('admin/structure/taxonomy/manage/test_tax_vocab/add');
$edit = [
'name[0][value]' => 'test term 1-A',
'parent[]' => '1',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
$this->drupalGet('admin/structure/taxonomy/manage/test_tax_vocab/add');
$edit = [
'name[0][value]' => 'test term 2',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
// Create a testing menu.
$this->drupalGet('admin/structure/menu/add');
$edit = [
'id' => 'test-menu',
'label' => 'Test',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
// Create new taxonomy menu.
$this->drupalGet('admin/structure/taxonomy_menu/add');
$edit = [
'id' => 'test_tax_menu',
'label' => 'test tax menu',
'vocabulary' => 'test_tax_vocab',
'menu' => 'test-menu',
'expanded' => 1,
'depth' => '1',
'menu_parent' => 'test-menu:',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
}
/**
* Test creation of taxonomy menu functions.
*/
function testTaxMenuCreate() {
// Check menu for taxonomy-based menu items keyed 1, 2, and 3.
$this->drupalGet('admin/structure/menu/manage/test-menu');
$this->assertFieldByName(
'links[menu_plugin_id:taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.1][enabled]',
NULL,
'I should expect to see enabled field for taxonomy term 1'
);
$this->assertFieldByName(
'links[menu_plugin_id:taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.2][enabled]',
NULL,
'I should expect to see enabled field for taxonomy term 2'
);
$this->assertFieldByName(
'links[menu_plugin_id:taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.3][enabled]',
NULL,
'I should expect to see enabled field for taxonomy term 3'
);
// Check 2 is a parent of 1.
$this->assertFieldByName(
'links[menu_plugin_id:taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.2][parent]',
'taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.1',
'I should expect to see taxonomy term 2 have a parent of taxonomy term 1'
);
}
/**
* Test creation of taxonomy term.
*/
function testTaxTermCreate() {
// Create a new term.
$this->drupalGet('admin/structure/taxonomy/manage/test_tax_vocab/add');
$edit = [
'name[0][value]' => 'test term 3',
];
$this->drupalPostForm(NULL, $edit, t('Save'));
$this->drupalGet('admin/structure/menu/manage/test-menu');
// Check for it within the menu.
$this->assertFieldByName(
'links[menu_plugin_id:taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.4][enabled]',
NULL,
'I should expect to see enabled field for taxonomy term 4'
);
}
/**
* Test deletion of taxonomy term.
*/
function testTaxTermDelete() {
// Delete a term.
$this->drupalGet('taxonomy/term/3/delete');
$edit = [
];
$this->drupalPostForm(NULL, $edit, t('Delete'));
// Check for it within the menu.
$this->assertNoFieldByName(
'links[menu_plugin_id:taxonomy_menu.menu_link.test.3][enabled]',
NULL,
'I should not expect to see enabled field for taxonomy term 3'
);
}
/**
* Tests if of menu links from taxonony_menu is expanded.
*/
function testTaxMenuLinkExpanded() {
$this->drupalGet('admin/structure/menu/link/taxonomy_menu.menu_link:taxonomy_menu.menu_link.test_tax_menu.1/edit');
$this->assertFieldByName(
'expanded',
1,
'I should expect to see expanded value for menu based on taxonomy term 1'
);
}
}
modules/taxonomy_menu/taxonomy_menu.info.yml deleted 100644 → 0
name: Taxonomy Menu
type: module
description: Embed a taxonomy tree into a menu
# core: 8.x
package: Menu
configure: entity.taxonomy_menu.collection
# Information added by Drupal.org packaging script on 2018-12-22
version: '8.x-3.4'
core: '8.x'
project: 'taxonomy_menu'
datestamp: 1545492795
modules/taxonomy_menu/taxonomy_menu.links.action.yml deleted 100644 → 0
entity.taxonomy_menu.add_form:
route_name: 'entity.taxonomy_menu.add_form'
title: 'Add Taxonomy menu'
appears_on:
- entity.taxonomy_menu.collection
modules/taxonomy_menu/taxonomy_menu.links.menu.yml deleted 100644 → 0
# Taxonomy Menu menu items definition
entity.taxonomy_menu.collection:
title: 'Taxonomy Menu'
route_name: entity.taxonomy_menu.collection
description: 'List Taxonomy Menus'
parent: system.admin_structure
taxonomy_menu.menu_link:
class: Drupal\taxonomy_menu\Plugin\Menu\TaxonomyMenuMenuLink
deriver: Drupal\taxonomy_menu\Plugin\Derivative\TaxonomyMenuMenuLink
modules/taxonomy_menu/taxonomy_menu.module deleted 100644 → 0
<?php
/**
* @file
* Contains taxonomy_menu.module.
*/
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Routing\RouteMatchInterface;
/**
* Implements taxonomy_menu_help().
*/
function taxonomy_menu_help($route_name, RouteMatchInterface $route_match) {
switch ($route_name) {
case 'help.page.taxonomy_menu':
return t('<p>The Taxonomy Menu module transforms your taxonomy vocabularies into menus.</p>
<p>See the <a href=":project_page">project page on Drupal.org</a> for more details.</p>',
[
':project_page' => 'https://www.drupal.org/project/taxonomy_menu',
]);
}
}
/**
* Implements hook_entity_insert().
*
* Check for taxonomy term insert.
*/
function taxonomy_menu_taxonomy_term_insert(EntityInterface $entity) {
\Drupal::service('taxonomy_menu.helper')->generateTaxonomyMenuEntries($entity, FALSE);
}
/**
* Implements hook_entity_delete().
*
* Check for taxonomy term deletion.
*/
function taxonomy_menu_taxonomy_term_delete(EntityInterface $entity) {
\Drupal::service('taxonomy_menu.helper')->removeTaxonomyMenuEntries($entity, FALSE);
}
/**
* Implements hook_entity_update().
*
* Check for taxonomy term updates.
*/
function taxonomy_menu_taxonomy_term_update(EntityInterface $entity) {
\Drupal::service('taxonomy_menu.helper')->updateTaxonomyMenuEntries($entity, FALSE);
}
modules/taxonomy_menu/taxonomy_menu.routing.yml deleted 100644 → 0
# Taxonomy Menu Entity routing definition
entity.taxonomy_menu.collection:
path: '/admin/structure/taxonomy_menu'
defaults:
_entity_list: 'taxonomy_menu'
_title: 'Taxonomy menu Configuration'
requirements:
_permission: 'administer site configuration'
entity.taxonomy_menu.add_form:
path: '/admin/structure/taxonomy_menu/add'
defaults:
_entity_form: 'taxonomy_menu.add'
_title: 'Add Taxonomy menu'
requirements:
_permission: 'administer site configuration'
entity.taxonomy_menu.edit_form:
path: '/admin/structure/taxonomy_menu/{taxonomy_menu}'
defaults:
_entity_form: 'taxonomy_menu.edit'
_title: 'Edit Taxonomy menu'
requirements:
_permission: 'administer site configuration'
entity.taxonomy_menu.delete_form:
path: '/admin/structure/taxonomy_menu/{taxonomy_menu}/delete'
defaults:
_entity_form: 'taxonomy_menu.delete'
_title: 'Delete Taxonomy menu'
requirements:
_permission: 'administer site configuration'
taxonomy_menu.test:
path: '/taxonomy-menu/render-taxonomy-links'
defaults:
_controller: '\Drupal\taxonomy_menu\Controller\TaxonomyMenu::renderTaxonomyLinks'
_title: 'Debugging'
requirements:
_permission: 'administer site configuration'
modules/taxonomy_menu/taxonomy_menu.services.yml deleted 100644 → 0
services:
taxonomy_menu.helper:
class: Drupal\taxonomy_menu\TaxonomyMenuHelper
arguments: ['@entity.manager', '@plugin.manager.menu.link']
themes/custom/envigo/templates/views/views-view-unformatted--investor_reports--block_2.html.twig
......@@ -18,12 +18,7 @@
*/
#}
{%
set classes = [
dom_id ? 'js-view-dom-id-' ~ dom_id,
'any-other-custom-class-you-want',
]
%}
{%
set row_classes = [
......@@ -37,11 +32,7 @@
<h1 class="ineves_det_h_m pr_padd">Quarterly Results</h1>
<div class="id_filter_con">
<div class="id_inner_filter-detail">
{% if exposed %}
<div {{ attributes.addClass(classes) }}>
{{ exposed }}
</div>
{% endif %}
</div>
</div>
<div class="a_r_c_b">
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment