/**
  * Autocomplete the label of an entity.
  *
  * @param \Symfony\Component\HttpFoundation\Request $request
  *   The request object that contains the typed tags.
  * @param string $target_type
  *   The ID of the target entity type.
  * @param string $selection_handler
  *   The plugin ID of the entity reference selection handler.
  * @param string $selection_settings_key
  *   The hashed key of the key/value entry that holds the selection handler
  *   settings.
  *
  * @return \Symfony\Component\HttpFoundation\JsonResponse
  *   The matched entity labels as a JSON response.
  *
  * @throws \Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException
  *   Thrown if the selection settings key is not found in the key/value store
  *   or if it does not match the stored data.
  */
 public function handleAutocomplete(Request $request, $target_type, $selection_handler, $selection_settings_key)
 {
     $matches = array();
     // Get the typed string from the URL, if it exists.
     if ($input = $request->query->get('q')) {
         $typed_string = Tags::explode($input);
         $typed_string = Unicode::strtolower(array_pop($typed_string));
         // Selection settings are passed in as a hashed key of a serialized array
         // stored in the key/value store.
         $selection_settings = $this->keyValue->get($selection_settings_key, FALSE);
         if ($selection_settings !== FALSE) {
             $selection_settings_hash = Crypt::hmacBase64(serialize($selection_settings) . $target_type . $selection_handler, Settings::getHashSalt());
             if ($selection_settings_hash !== $selection_settings_key) {
                 // Disallow access when the selection settings hash does not match the
                 // passed-in key.
                 throw new AccessDeniedHttpException('Invalid selection settings key.');
             }
         } else {
             // Disallow access when the selection settings key is not found in the
             // key/value store.
             throw new AccessDeniedHttpException();
         }
         $matches = $this->matcher->getMatches($target_type, $selection_handler, $selection_settings, $typed_string);
     }
     return new JsonResponse($matches);
 }
Esempio n. 2
0
 /**
  * Implodes a series of tags.
  */
 public function testImplodeTags()
 {
     $tags = array_values($this->validTags);
     // Let's explode and implode to our heart's content.
     for ($i = 0; $i < 10; $i++) {
         $string = Tags::implode($tags);
         $tags = Tags::explode($string);
     }
     $this->assertTags($tags);
 }
 /**
  * Autocomplete the label of an entity.
  *
  * @param \Symfony\Component\HttpFoundation\Request $request
  *   The request object that contains the typed tags.
  * @param string $target_type
  *   The ID of the target entity type.
  * @param string $selection_handler
  *   The plugin ID of the entity reference selection handler.
  * @param string $selection_settings
  *   The settings that will be passed to the selection handler.
  *
  * @return \Symfony\Component\HttpFoundation\JsonResponse
  *   The matched entity labels as a JSON response.
  */
 public function handleAutocomplete(Request $request, $target_type, $selection_handler, $selection_settings = '')
 {
     $matches = array();
     // Get the typed string from the URL, if it exists.
     if ($input = $request->query->get('q')) {
         $typed_string = Tags::explode($input);
         $typed_string = Unicode::strtolower(array_pop($typed_string));
         // Selection settings are passed in as an encoded serialized array.
         $selection_settings = $selection_settings ? unserialize(base64_decode($selection_settings)) : array();
         $matches = $this->matcher->getMatches($target_type, $selection_handler, $selection_settings, $typed_string);
     }
     return new JsonResponse($matches);
 }
 /**
  * Returns autocompletion content for file name textfield.
  *
  * @param \Symfony\Component\HttpFoundation\Request $request
  *   The request of the page.
  *
  * @return \Symfony\Component\HttpFoundation\JsonResponse
  *   A JSON response.
  */
 public function autocompleteFilename(Request $request)
 {
     $matches = array();
     // Get the typed string from the URL, if it exists.
     if ($input = $request->query->get('q')) {
         $typed_string = Tags::explode($input);
         $typed_string = Unicode::strtolower(array_pop($typed_string));
         $filenames = db_select('uc_files', 'f')->fields('f', ['filename'])->condition('filename', '%' . db_like($typed_string) . '%', 'LIKE')->execute();
         while ($name = $filenames->fetchField()) {
             $matches[] = array('value' => $name);
         }
     }
     return new JsonResponse($matches);
 }
Esempio n. 5
0
 /**
  * Tests autocompletion edge cases with slashes in the names.
  */
 function testEntityReferenceAutocompletion()
 {
     // Add an entity with a slash in its name.
     $entity_1 = $this->container->get('entity_type.manager')->getStorage($this->entityType)->create(array('name' => '10/16/2011'));
     $entity_1->save();
     // Add another entity that differs after the slash character.
     $entity_2 = $this->container->get('entity_type.manager')->getStorage($this->entityType)->create(array('name' => '10/17/2011'));
     $entity_2->save();
     // Add another entity that has both a comma, a slash and markup.
     $entity_3 = $this->container->get('entity_type.manager')->getStorage($this->entityType)->create(array('name' => 'label with, and / test'));
     $entity_3->save();
     // Try to autocomplete a entity label that matches both entities.
     // We should get both entities in a JSON encoded string.
     $input = '10/';
     $data = $this->getAutocompleteResult($input);
     $this->assertIdentical($data[0]['label'], Html::escape($entity_1->name->value), 'Autocomplete returned the first matching entity');
     $this->assertIdentical($data[1]['label'], Html::escape($entity_2->name->value), 'Autocomplete returned the second matching entity');
     // Try to autocomplete a entity label that matches the first entity.
     // We should only get the first entity in a JSON encoded string.
     $input = '10/16';
     $data = $this->getAutocompleteResult($input);
     $target = array('value' => $entity_1->name->value . ' (1)', 'label' => Html::escape($entity_1->name->value));
     $this->assertIdentical(reset($data), $target, 'Autocomplete returns only the expected matching entity.');
     // Try to autocomplete a entity label that matches the second entity, and
     // the first entity  is already typed in the autocomplete (tags) widget.
     $input = $entity_1->name->value . ' (1), 10/17';
     $data = $this->getAutocompleteResult($input);
     $this->assertIdentical($data[0]['label'], Html::escape($entity_2->name->value), 'Autocomplete returned the second matching entity');
     // Try to autocomplete a entity label with both a comma, a slash and markup.
     $input = '"label with, and /"';
     $data = $this->getAutocompleteResult($input);
     $n = $entity_3->name->value . ' (3)';
     // Entity labels containing commas or quotes must be wrapped in quotes.
     $n = Tags::encode($n);
     $target = array('value' => $n, 'label' => Html::escape($entity_3->name->value));
     $this->assertIdentical(reset($data), $target, 'Autocomplete returns an entity label containing a comma and a slash.');
 }
 /**
  * Autocomplete the label of an entity.
  *
  * @param Request $request
  *   The request object that contains the typed tags.
  * @param string $type
  *   The widget type (i.e. 'single' or 'tags').
  * @param string $field_name
  *   The name of the entity reference field.
  * @param string $entity_type
  *   The entity type.
  * @param string $bundle_name
  *   The bundle name.
  * @param string $entity_id
  *   (optional) The entity ID the entity reference field is attached to.
  *   Defaults to ''.
  *
  * @throws \Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException
  *   Throws access denied when either the field or field instance does not
  *   exists or the user does not have access to edit the field.
  *
  * @return \Symfony\Component\HttpFoundation\JsonResponse
  *   The matched labels as json.
  */
 public function handleAutocomplete(Request $request, $type, $field_name, $entity_type, $bundle_name, $entity_id)
 {
     $definitions = $this->entityManager()->getFieldDefinitions($entity_type, $bundle_name);
     if (!isset($definitions[$field_name])) {
         throw new AccessDeniedHttpException();
     }
     $field_definition = $definitions[$field_name];
     $access_controller = $this->entityManager()->getAccessController($entity_type);
     if ($field_definition->getType() != 'entity_reference' || !$access_controller->fieldAccess('edit', $field_definition)) {
         throw new AccessDeniedHttpException();
     }
     // Get the typed string, if exists from the URL.
     $items_typed = $request->query->get('q');
     $items_typed = Tags::explode($items_typed);
     $last_item = drupal_strtolower(array_pop($items_typed));
     $prefix = '';
     // The user entered a comma-separated list of entity labels, so we generate
     // a prefix.
     if ($type == 'tags' && !empty($last_item)) {
         $prefix = count($items_typed) ? Tags::implode($items_typed) . ', ' : '';
     }
     $matches = $this->entityReferenceAutocomplete->getMatches($field_definition, $entity_type, $bundle_name, $entity_id, $prefix, $last_item);
     return new JsonResponse($matches);
 }
 /**
  * {@inheritdoc}
  */
 public function elementValidate($element, &$form_state, $form)
 {
     $value = array();
     // If a value was entered into the autocomplete.
     $handler = \Drupal::service('plugin.manager.entity_reference.selection')->getSelectionHandler($this->fieldDefinition);
     $bundles = entity_get_bundles($this->getFieldSetting('target_type'));
     $auto_create = $this->getSelectionHandlerSetting('auto_create');
     if (!empty($element['#value'])) {
         $value = array();
         foreach (Tags::explode($element['#value']) as $input) {
             $match = FALSE;
             // Take "label (entity id)', match the ID from parenthesis when it's a
             // number.
             if (preg_match("/.+\\((\\d+)\\)/", $input, $matches)) {
                 $match = $matches[1];
             } elseif (preg_match("/.+\\(([\\w.]+)\\)/", $input, $matches)) {
                 $match = $matches[1];
             } else {
                 // Try to get a match from the input string when the user didn't use
                 // the autocomplete but filled in a value manually.
                 $match = $handler->validateAutocompleteInput($input, $element, $form_state, $form, !$auto_create);
             }
             if ($match) {
                 $value[] = array('target_id' => $match);
             } elseif ($auto_create && (count($this->getSelectionHandlerSetting('target_bundles')) == 1 || count($bundles) == 1)) {
                 // Auto-create item. See
                 // \Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem::presave().
                 $value[] = array('target_id' => NULL, 'entity' => $this->createNewEntity($input, $element['#autocreate_uid']));
             }
         }
     }
     // Change the element['#parents'], so in form_set_value() we
     // populate the correct key.
     array_pop($element['#parents']);
     form_set_value($element, $value, $form_state);
 }
Esempio n. 8
0
 public function validateExposed(&$form, &$form_state)
 {
     if (empty($this->options['exposed'])) {
         return;
     }
     if (empty($this->options['expose']['identifier'])) {
         return;
     }
     $identifier = $this->options['expose']['identifier'];
     $input = $form_state['values'][$identifier];
     if ($this->options['is_grouped'] && isset($this->options['group_info']['group_items'][$input])) {
         $this->operator = $this->options['group_info']['group_items'][$input]['operator'];
         $input = $this->options['group_info']['group_items'][$input]['value'];
     }
     $values = Tags::explode($input);
     if (!$this->options['is_grouped'] || $this->options['is_grouped'] && $input != 'All') {
         $uids = $this->validate_user_strings($form[$identifier], $form_state, $values);
     } else {
         $uids = FALSE;
     }
     if ($uids) {
         $this->validated_exposed_input = $uids;
     }
 }
 /**
  * Returns matched labels based on a given search string.
  *
  * @param string $target_type
  *   The ID of the target entity type.
  * @param string $selection_handler
  *   The plugin ID of the entity reference selection handler.
  * @param array $selection_settings
  *   An array of settings that will be passed to the selection handler.
  * @param string $string
  *   (optional) The label of the entity to query by.
  *
  * @throws \Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException
  *   Thrown when the current user doesn't have access to the specifies entity.
  *
  * @return array
  *   An array of matched entity labels, in the format required by the AJAX
  *   autocomplete API (e.g. array('value' => $value, 'label' => $label)).
  *
  * @see \Drupal\system\Controller\EntityAutocompleteController
  */
 public function getMatches($target_type, $selection_handler, $selection_settings, $string = '')
 {
     $matches = array();
     $options = array('target_type' => $target_type, 'handler' => $selection_handler, 'handler_settings' => $selection_settings);
     $handler = $this->selectionManager->getInstance($options);
     if (isset($string)) {
         // Get an array of matching entities.
         $match_operator = !empty($selection_settings['match_operator']) ? $selection_settings['match_operator'] : 'CONTAINS';
         $entity_labels = $handler->getReferenceableEntities($string, $match_operator, 10);
         // Loop through the entities and convert them into autocomplete output.
         foreach ($entity_labels as $values) {
             foreach ($values as $entity_id => $label) {
                 $key = "{$label} ({$entity_id})";
                 // Strip things like starting/trailing white spaces, line breaks and
                 // tags.
                 $key = preg_replace('/\\s\\s+/', ' ', str_replace("\n", '', trim(String::decodeEntities(strip_tags($key)))));
                 // Names containing commas or quotes must be wrapped in quotes.
                 $key = Tags::encode($key);
                 $matches[] = array('value' => $key, 'label' => $label);
             }
         }
     }
     return $matches;
 }
 /**
  * Gets terms which matches some typed terms.
  *
  * @param string $tags_typed
  *   The full typed tags string.
  * @param array $vids
  *   An array of vocabulary IDs which
  * @param $tag_last
  *   The lasted typed tag.
  *
  * @return array
  *   Returns an array of matching terms.
  */
 protected function getMatchingTerms($tags_typed, array $vids, $tag_last)
 {
     $matches = array();
     $this->termEntityQuery->addTag('term_access');
     // Do not select already entered terms.
     if (!empty($tags_typed)) {
         $this->termEntityQuery->condition('name', $tags_typed, 'NOT IN');
     }
     // Select rows that match by term name.
     $tids = $this->termEntityQuery->condition('vid', $vids, 'IN')->condition('name', $tag_last, 'CONTAINS')->range(0, 10)->execute();
     $prefix = count($tags_typed) ? Tags::implode($tags_typed) . ', ' : '';
     if (!empty($tids)) {
         $terms = $this->entityManager->getStorage('taxonomy_term')->loadMultiple(array_keys($tids));
         foreach ($terms as $term) {
             // Term names containing commas or quotes must be wrapped in quotes.
             $name = Tags::encode($term->getName());
             $matches[] = array('value' => $prefix . $name, 'label' => String::checkPlain($term->getName()));
         }
         return $matches;
     }
     return $matches;
 }
Esempio n. 11
0
 /**
  * Provide a full array of possible theme functions to try for a given hook.
  *
  * @param string $hook
  *   The hook to use. This is the base theme/template name.
  *
  * @return array
  *   An array of theme hook suggestions.
  */
 public function buildThemeFunctions($hook)
 {
     $themes = array();
     $display = isset($this->display_handler) ? $this->display_handler->display : NULL;
     $id = $this->storage->id();
     if ($display) {
         $themes[] = $hook . '__' . $id . '__' . $display['id'];
         $themes[] = $hook . '__' . $display['id'];
         // Add theme suggestions for each single tag.
         foreach (Tags::explode($this->storage->get('tag')) as $tag) {
             $themes[] = $hook . '__' . preg_replace('/[^a-z0-9]/', '_', strtolower($tag));
         }
         if ($display['id'] != $display['display_plugin']) {
             $themes[] = $hook . '__' . $id . '__' . $display['display_plugin'];
             $themes[] = $hook . '__' . $display['display_plugin'];
         }
     }
     $themes[] = $hook . '__' . $id;
     $themes[] = $hook;
     return $themes;
 }
Esempio n. 12
0
 public function validateExposed(&$form, &$form_state)
 {
     if (empty($this->options['exposed'])) {
         return;
     }
     $identifier = $this->options['expose']['identifier'];
     // We only validate if they've chosen the text field style.
     if ($this->options['type'] != 'textfield') {
         if ($form_state['values'][$identifier] != 'All') {
             $this->validated_exposed_input = (array) $form_state['values'][$identifier];
         }
         return;
     }
     if (empty($this->options['expose']['identifier'])) {
         return;
     }
     $values = Tags::explode($form_state['values'][$identifier]);
     $tids = $this->validate_term_strings($form[$identifier], $values);
     if ($tids) {
         $this->validated_exposed_input = $tids;
     }
 }
 /**
  * {@inheritdoc}
  */
 public function submitConfigurationForm(array &$form, FormStateInterface $form_state)
 {
     $this->configuration['keywords'] = Tags::explode($form_state->getValue('keywords'));
 }
 /**
  * Converts an array of entity objects into a string of entity labels.
  *
  * This method is also responsible for checking the 'view label' access on the
  * passed-in entities.
  *
  * @param \Drupal\Core\Entity\EntityInterface[] $entities
  *   An array of entity objects.
  *
  * @return string
  *   A string of entity labels separated by commas.
  */
 public static function getEntityLabels(array $entities)
 {
     $entity_labels = array();
     foreach ($entities as $entity) {
         // Use the special view label, since some entities allow the label to be
         // viewed, even if the entity is not allowed to be viewed.
         $label = $entity->access('view label') ? $entity->label() : t('- Restricted access -');
         // Take into account "autocreated" entities.
         if (!$entity->isNew()) {
             $label .= ' (' . $entity->id() . ')';
         }
         // Labels containing commas or quotes must be wrapped in quotes.
         $entity_labels[] = Tags::encode($label);
     }
     return implode(', ', $entity_labels);
 }
Esempio n. 15
0
 /**
  * Tests term autocompletion edge cases with slashes in the names.
  */
 function testTermAutocompletion()
 {
     // Add a term with a slash in the name.
     $first_term = $this->createTerm($this->vocabulary);
     $first_term->setName('10/16/2011');
     $first_term->save();
     // Add another term that differs after the slash character.
     $second_term = $this->createTerm($this->vocabulary);
     $second_term->setName('10/17/2011');
     $second_term->save();
     // Add another term that has both a comma and a slash character.
     $third_term = $this->createTerm($this->vocabulary);
     $third_term->setName('term with, a comma and / a slash');
     $third_term->save();
     // Try to autocomplete a term name that matches both terms.
     // We should get both terms in a json encoded string.
     $input = '10/';
     $path = 'taxonomy/autocomplete/node/taxonomy_' . $this->vocabulary->id();
     // The result order is not guaranteed, so check each term separately.
     $result = $this->drupalGet($path, array('query' => array('q' => $input)));
     // Pull the label properties from the array of arrays.
     $data = Json::decode($result);
     $data = array_map(function ($item) {
         return $item['label'];
     }, $data);
     $this->assertTrue(in_array(String::checkPlain($first_term->getName()), $data), 'Autocomplete returned the first matching term');
     $this->assertTrue(in_array(String::checkPlain($second_term->getName()), $data), 'Autocomplete returned the second matching term');
     // Try to autocomplete a term name that matches first term.
     // We should only get the first term in a json encoded string.
     $input = '10/16';
     $path = 'taxonomy/autocomplete/node/taxonomy_' . $this->vocabulary->id();
     $this->drupalGet($path, array('query' => array('q' => $input)));
     $target = array(array('value' => String::checkPlain($first_term->getName()), 'label' => $first_term->getName()));
     $this->assertRaw(Json::encode($target), 'Autocomplete returns only the expected matching term.');
     // Try to autocomplete a term name with both a comma and a slash.
     $input = '"term with, comma and / a';
     $path = 'taxonomy/autocomplete/node/taxonomy_' . $this->vocabulary->id();
     $this->drupalGet($path, array('query' => array('q' => $input)));
     // Term names containing commas or quotes must be wrapped in quotes.
     $n = Tags::encode($third_term->getName());
     $target = array(array('value' => $n, 'label' => String::checkPlain($third_term->getName())));
     $this->assertRaw(Json::encode($target), 'Autocomplete returns a term containing a comma and a slash.');
 }
Esempio n. 16
0
 /**
  * Test term creation with a free-tagging vocabulary from the node form.
  */
 function testNodeTermCreationAndDeletion()
 {
     // Enable tags in the vocabulary.
     $field = $this->field;
     entity_get_form_display($field->getTargetEntityTypeId(), $field->getTargetBundle(), 'default')->setComponent($field->getName(), array('type' => 'entity_reference_autocomplete_tags', 'settings' => array('placeholder' => 'Start typing here.')))->save();
     // Prefix the terms with a letter to ensure there is no clash in the first
     // three letters.
     // @see https://www.drupal.org/node/2397691
     $terms = array('term1' => 'a' . $this->randomMachineName(), 'term2' => 'b' . $this->randomMachineName(), 'term3' => 'c' . $this->randomMachineName() . ', ' . $this->randomMachineName(), 'term4' => 'd' . $this->randomMachineName());
     $edit = array();
     $edit['title[0][value]'] = $this->randomMachineName();
     $edit['body[0][value]'] = $this->randomMachineName();
     // Insert the terms in a comma separated list. Vocabulary 1 is a
     // free-tagging field created by the default profile.
     $edit[$field->getName() . '[target_id]'] = Tags::implode($terms);
     // Verify the placeholder is there.
     $this->drupalGet('node/add/article');
     $this->assertRaw('placeholder="Start typing here."', 'Placeholder is present.');
     // Preview and verify the terms appear but are not created.
     $this->drupalPostForm(NULL, $edit, t('Preview'));
     foreach ($terms as $term) {
         $this->assertText($term, 'The term appears on the node preview.');
     }
     $tree = $this->container->get('entity.manager')->getStorage('taxonomy_term')->loadTree($this->vocabulary->id());
     $this->assertTrue(empty($tree), 'The terms are not created on preview.');
     // taxonomy.module does not maintain its static caches.
     taxonomy_terms_static_reset();
     // Save, creating the terms.
     $this->drupalPostForm('node/add/article', $edit, t('Save'));
     $this->assertRaw(t('@type %title has been created.', array('@type' => t('Article'), '%title' => $edit['title[0][value]'])), 'The node was created successfully.');
     foreach ($terms as $term) {
         $this->assertText($term, 'The term was saved and appears on the node page.');
     }
     // Get the created terms.
     $term_objects = array();
     foreach ($terms as $key => $term) {
         $term_objects[$key] = taxonomy_term_load_multiple_by_name($term);
         $term_objects[$key] = reset($term_objects[$key]);
     }
     // Get the node.
     $node = $this->drupalGetNodeByTitle($edit['title[0][value]']);
     // Test editing the node.
     $this->drupalPostForm('node/' . $node->id() . '/edit', $edit, t('Save'));
     foreach ($terms as $term) {
         $this->assertText($term, 'The term was retained after edit and still appears on the node page.');
     }
     // Delete term 1 from the term edit page.
     $this->drupalGet('taxonomy/term/' . $term_objects['term1']->id() . '/edit');
     $this->clickLink(t('Delete'));
     $this->drupalPostForm(NULL, NULL, t('Delete'));
     // Delete term 2 from the term delete page.
     $this->drupalGet('taxonomy/term/' . $term_objects['term2']->id() . '/delete');
     $this->drupalPostForm(NULL, array(), t('Delete'));
     $term_names = array($term_objects['term3']->getName(), $term_objects['term4']->getName());
     $this->drupalGet('node/' . $node->id());
     foreach ($term_names as $term_name) {
         $this->assertText($term_name, format_string('The term %name appears on the node page after two terms, %deleted1 and %deleted2, were deleted.', array('%name' => $term_name, '%deleted1' => $term_objects['term1']->getName(), '%deleted2' => $term_objects['term2']->getName())));
     }
     $this->assertNoText($term_objects['term1']->getName(), format_string('The deleted term %name does not appear on the node page.', array('%name' => $term_objects['term1']->getName())));
     $this->assertNoText($term_objects['term2']->getName(), format_string('The deleted term %name does not appear on the node page.', array('%name' => $term_objects['term2']->getName())));
 }
Esempio n. 17
0
  public function rowAttributes() {
    $variables = array();
    $active_row_regions = array();
    $config_settings = \Drupal::config($this->theme_name . '.settings')->get('settings');

    // If rows are empty return early.
    if (empty($this->layout_config['rows'])) {
      return;
    }

    // Build array of rows with region values.
    foreach ($this->layout_config['rows'] as $row_name => $row_data) {

      // Set a bool for active regions, assume false.
      $variables[$row_name . '__regions']['active'] = FALSE;

      $i = 1;
      foreach ($row_data['regions'] as $region_key => $region_name) {
        $region_source_order[$row_name][$region_key] = $i++; // Set an increment value for each region for the .hr class (has-regions)
        $row_regions[$row_name][] = $region_key; // Build array to intersect and use for the .arc class (active region count).
      }

      // Pass on row wrapper attributes only for rows with active regions
      $active_row_regions[$row_name]['attributes'] = $row_data['attributes'];

      // Remove inactive regions.
      $active_row_regions[$row_name]['regions'] = array_intersect($row_regions[$row_name], $this->active_regions);

      // Unset inactive rows.
      if (empty($active_row_regions[$row_name]['regions'])) {
        unset($active_row_regions[$row_name]);
      }
    }

    // Set additional attributes for rows.
    foreach ($active_row_regions as $row_key => $row_values) {
      //if (!empty($row_values['regions'])) {}

      // If active regions set to true to print the row, basically a catch all condition.
      $variables[$row_key . '__regions']['active'] = TRUE;

      // Wrapper attributes.
      $variables[$row_key . '__wrapper_attributes'] = new Attribute;
      $variables[$row_key . '__wrapper_attributes']['class'] = array('l-pr', 'page__row', 'pr-' . $row_key);
      foreach ($row_values['attributes'] as $attribute_type => $attribute_values) {
        if (is_array($attribute_values)) {
          $variables[$row_key . '__wrapper_attributes'][$attribute_type] = array(implode(' ', $attribute_values));
        }
        else {
          $variables[$row_key . '__wrapper_attributes'][$attribute_type] = array($attribute_values);
        }
      }

      // Container attributes.
      $variables[$row_key . '__container_attributes'] = new Attribute;
      $variables[$row_key . '__container_attributes']['class'] = array('l-rw', 'regions', 'container', 'pr-'. str_replace('_', '-', $row_key) . '__rw');

      // Active Regions: "arc" is "active region count", this is number of active regions in this row on this page.
      $count = count($row_values['regions']);
      $variables[$row_key . '__container_attributes']['class'][] = 'arc--'. $count;

      // Match each active region with its'corrosponding source order increment.
      foreach ($row_values['regions'] as $region) {
        if (isset($region_source_order[$row_key][$region])) {
          $row_has_regions[$row_key][] = $region_source_order[$row_key][$region];
        }
      }

      // Has Regions: the "hr" class tells us which regions are active by source order (as per the layout markup yml),
      // this allows us to push layout dependant on exactly which regions are active.
      if (isset($row_has_regions[$row_key])) {
        $variables[$row_key . '__container_attributes']['class'][] =  'hr--' . implode('-', $row_has_regions[$row_key]);
      }

      // Shortcode classes.
      if (isset($config_settings['enable_extensions']) && $config_settings['enable_extensions'] === 1) {
        if (isset($config_settings['enable_shortcodes']) && $config_settings['enable_shortcodes'] === 1) {

          // Wrapper codes
          if (!empty($config_settings['page_classes_row_wrapper_' . $row_key])) {
            $shortcodes = Tags::explode($config_settings['page_classes_row_wrapper_' . $row_key]);
            foreach ($shortcodes as $class) {
              $variables[$row_key . '__wrapper_attributes']['class'][] = Html::cleanCssIdentifier($class);
            }
          }

          // Container codes
          if (!empty($config_settings['page_classes_row_container_' . $row_key])) {
            $shortcodes = Tags::explode($config_settings['page_classes_row_container_' . $row_key]);
            foreach ($shortcodes as $class) {
              $variables[$row_key . '__container_attributes']['class'][] = Html::cleanCssIdentifier($class);
            }
          }
        }
      }
    }

    return $variables;
  }
 /**
  * Returns matched labels based on a given field, instance and search string.
  *
  * This function can be used by other modules that wish to pass a mocked
  * definition of the field on instance.
  *
  * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
  *   The field definition.
  * @param string $entity_type
  *   The entity type.
  * @param string $bundle
  *   The entity bundle.
  * @param string $entity_id
  *   (optional) The entity ID the entity reference field is attached to.
  *   Defaults to ''.
  * @param string $prefix
  *   (optional) A prefix for all the keys returned by this function.
  * @param string $string
  *   (optional) The label of the entity to query by.
  *
  * @throws \Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException
  *   Thrown when the current user doesn't have access to the specifies entity.
  *
  * @return array
  *   A list of matched entity labels.
  *
  * @see \Drupal\entity_reference\EntityReferenceController
  */
 public function getMatches(FieldDefinitionInterface $field_definition, $entity_type, $bundle, $entity_id = '', $prefix = '', $string = '')
 {
     $matches = array();
     $entity = NULL;
     if ($entity_id !== 'NULL') {
         $entity = $this->entityManager->getStorage($entity_type)->load($entity_id);
         if (!$entity || !$entity->access('view')) {
             throw new AccessDeniedHttpException();
         }
     }
     $handler = $this->selectionHandlerManager->getSelectionHandler($field_definition, $entity);
     if (isset($string)) {
         // Get an array of matching entities.
         $widget = entity_get_form_display($entity_type, $bundle, 'default')->getComponent($field_definition->getName());
         $match_operator = !empty($widget['settings']['match_operator']) ? $widget['settings']['match_operator'] : 'CONTAINS';
         $entity_labels = $handler->getReferenceableEntities($string, $match_operator, 10);
         // Loop through the entities and convert them into autocomplete output.
         foreach ($entity_labels as $values) {
             foreach ($values as $entity_id => $label) {
                 $key = "{$label} ({$entity_id})";
                 // Strip things like starting/trailing white spaces, line breaks and
                 // tags.
                 $key = preg_replace('/\\s\\s+/', ' ', str_replace("\n", '', trim(decode_entities(strip_tags($key)))));
                 // Names containing commas or quotes must be wrapped in quotes.
                 $key = Tags::encode($key);
                 $matches[] = array('value' => $prefix . $key, 'label' => $label);
             }
         }
     }
     return $matches;
 }
Esempio n. 19
0
 /**
  * Converts an array of entity objects into a string of entity labels.
  *
  * This method is also responsible for checking the 'view' access on the
  * passed-in entities.
  *
  * @param \Drupal\Core\Entity\EntityInterface[] $entities
  *   An array of entity objects.
  *
  * @return string
  *   A string of entity labels separated by commas.
  */
 public static function getEntityLabels(array $entities)
 {
     $entity_labels = array();
     foreach ($entities as $entity) {
         $label = $entity->access('view') ? $entity->label() : t('- Restricted access -');
         // Take into account "autocreated" entities.
         if (!$entity->isNew()) {
             $label .= ' (' . $entity->id() . ')';
         }
         // Labels containing commas or quotes must be wrapped in quotes.
         $entity_labels[] = Tags::encode($label);
     }
     return implode(', ', $entity_labels);
 }
Esempio n. 20
0
 /**
  * {@inheritdoc}
  */
 public function submitConfigurationForm(array &$form, array &$form_state)
 {
     $this->configuration['keywords'] = Tags::explode($form_state['values']['keywords']);
 }
Esempio n. 21
0
  /**
   * {@inheritdoc}
   */
  public function validateExposed(&$form, FormStateInterface $form_state) {
    if (empty($this->options['exposed']) || empty($this->options['expose']['identifier'])) {
      return;
    }

    $identifier = $this->options['expose']['identifier'];
    $input = $form_state->getValues()[$identifier];

    if ($this->options['is_grouped'] && isset($this->options['group_info']['group_items'][$input])) {
      $this->operator = $this->options['group_info']['group_items'][$input]['operator'];
      $input = $this->options['group_info']['group_items'][$input]['value'];
    }

    $values = $this->isMultiValued() ? Tags::explode($input) : array($input);

    if (!$this->options['is_grouped'] || ($this->options['is_grouped'] && ($input != 'All'))) {
      $this->validatedExposedInput = $this->validateEntityStrings($form[$identifier], $values, $form_state);
    }
    else {
      $this->validatedExposedInput = FALSE;
    }
  }
 /**
  * Gets the entity labels.
  */
 protected function getLabels(FieldItemListInterface $items, $delta)
 {
     if ($items->isEmpty()) {
         return array();
     }
     $entity_labels = array();
     // Load those entities and loop through them to extract their labels.
     $entities = entity_load_multiple($this->getFieldSetting('target_type'), $this->getEntityIds($items, $delta));
     foreach ($entities as $entity_id => $entity_item) {
         $label = $entity_item->label();
         $key = "{$label} ({$entity_id})";
         // Labels containing commas or quotes must be wrapped in quotes.
         $key = Tags::encode($key);
         $entity_labels[] = $key;
     }
     return $entity_labels;
 }