/**
* {@inheritdoc}
*/
public function load()
{
// It is not possible to use the standard load method, because this needs
// all field instance entities only for the given baseEntityType.
$ids = \Drupal::entityQuery('field_instance_config')->condition('id', $this->baseEntityType . '.', 'STARTS_WITH')->execute();
return $this->storage->loadMultiple($ids);
}
/**
* Tests creating a product via the admin.
*/
function testAddProductAdmin()
{
$title = $this->randomMachineName();
$store_ids = array_map(function ($store) {
return $store->id();
}, $this->stores);
$this->drupalGet('admin/commerce/products');
$this->clickLink('Add product');
$product_variation_values = ['variations[form][inline_entity_form][sku][0][value]' => $this->randomMachineName(), 'variations[form][inline_entity_form][status][value]' => 1];
$this->drupalPostForm(NULL, $product_variation_values, t('Create variation'));
$edit = ['title[0][value]' => $title];
foreach ($store_ids as $store_id) {
$edit['stores[target_id][value][' . $store_id . ']'] = $store_id;
}
$this->drupalPostForm(NULL, $edit, t('Save and publish'));
$result = \Drupal::entityQuery('commerce_product')->condition("title", $edit['title[0][value]'])->range(0, 1)->execute();
$product_id = reset($result);
$product = Product::load($product_id);
$this->assertNotNull($product, 'The new product has been created in the database.');
$this->assertText(t('The product @title has been successfully saved', ['@title' => $title]), 'Product success text is shown');
$this->assertText($title, 'Created product name exists on this page.');
$this->assertFieldValues($product->getStores(), $this->stores, 'Created product has the correct associated stores.');
$this->assertFieldValues($product->getStoreIds(), $store_ids, 'Created product has the correct associated store ids.');
// Assert that the frontend product page is displaying.
$this->drupalGet('product/' . $product->id());
$this->assertResponse(200);
$this->assertText($product->getTitle(), 'Product title exists');
// Test product variations
$product_variation = \Drupal::entityQuery('commerce_product_variation')->condition("sku", $product_variation_values['variations[form][inline_entity_form][sku][0][value]'])->range(0, 1)->execute();
$product_variation = ProductVariation::load(current($product_variation));
$this->assertNotNull($product_variation, 'The new product variation has been created in the database.');
}
/**
* {@inheritdoc}
*/
public function build()
{
$query = \Drupal::entityQuery('node')->condition('status', 1)->condition('type', 'team_member')->sort('field_order', 'ASC');
$nids = $query->execute();
$nodes = node_load_multiple($nids);
//$nodes = entity_load_multiple('node', $nids);
$ind = 1;
$output = '<div class="tabbable tabs-left tabcordion">
<ul class="nav nav-tabs">';
foreach ($nodes as $node) {
$class = $ind == 1 ? 'active' : '';
$output .= '<li class="' . $class . '"><a data-target="#team_member_tab' . $ind . '" data-toggle="tab">' . $node->title->value . '<span>' . $node->get('field_designation')->value . '</span></a></li>';
$ind++;
}
$ind = 1;
$output .= '</ul>
<div class="tab-content">';
foreach ($nodes as $node) {
$class = $ind == 1 ? 'active' : '';
if (is_object($node->field_image->entity)) {
$path = $node->field_image->entity->getFileUri();
$url = ImageStyle::load('person_picture')->buildUrl($path);
$tab_content_html = '<div class="row"><div class="col-md-3"><img src="' . $url . '" alt=""></div><div class="col-md-9">' . $node->get('body')->value . '</div> </div>';
} else {
$tab_content_html = '<div>' . $node->get('body')->value . '</div>';
}
$output .= '<div class="tab-pane ' . $class . '" id="team_member_tab' . $ind . '"> ' . $tab_content_html . ' </div>';
$ind++;
}
$output .= '</div>
</div>';
return array('#type' => 'markup', '#markup' => $output, '#attached' => array('library' => array('barney_river_utilities/tabcordion', 'barney_river_utilities/tabcordion_hook')));
}
/**
* {@inheritdoc}
*/
public function validate($items, Constraint $constraint)
{
$bundles = $constraint->bundles;
if (!($item = $items->first())) {
return;
}
$field_name = $items->getFieldDefinition()->getName();
/** @var \Drupal\Core\Entity\EntityInterface $entity */
$entity = $items->getEntity();
$bundle = $entity->bundle();
if (!in_array($bundle, $bundles)) {
// The constraint does not apply to this bundle.
return;
}
$bundle_key = $entity->getEntityType()->getKey('bundle');
$entity_type_id = $entity->getEntityTypeId();
$id_key = $entity->getEntityType()->getKey('id');
$query = \Drupal::entityQuery($entity_type_id)->condition($field_name, $item->value)->condition($bundle_key, $bundles, 'IN');
if (!empty($entity->id())) {
$query->condition($id_key, $items->getEntity()->id(), '<>');
}
$value_taken = (bool) $query->range(0, 1)->count()->execute();
if ($value_taken) {
$this->context->addViolation($constraint->message, ['%value' => $item->value, '@entity_type' => $entity->getEntityType()->getLowercaseLabel(), '@field_name' => Unicode::strtolower($items->getFieldDefinition()->getLabel())]);
}
}
/**
* Lists the feed items belonging to a feed.
*/
public function listItems(FeedInterface $feeds_feed, Request $request)
{
$processor = $feeds_feed->getType()->getProcessor();
$header = ['title' => $this->t('Label'), 'imported' => $this->t('Imported'), 'guid' => ['data' => $this->t('GUID'), 'class' => [RESPONSIVE_PRIORITY_LOW]], 'url' => ['data' => $this->t('URL'), 'class' => [RESPONSIVE_PRIORITY_LOW]]];
$build = [];
$build['table'] = ['#type' => 'table', '#header' => $header, '#rows' => [], '#empty' => $this->t('There are no items yet.')];
// @todo Allow processors to create their own entity listings.
if (!$processor instanceof EntityProcessorInterface) {
return $build;
}
$entity_ids = \Drupal::entityQuery($processor->entityType())->condition('feeds_item.target_id', $feeds_feed->id())->pager(50)->sort('feeds_item.imported', 'DESC')->execute();
$storage = $this->entityManager()->getStorage($processor->entityType());
foreach ($storage->loadMultiple($entity_ids) as $entity) {
$ago = \Drupal::service('date.formatter')->formatInterval(REQUEST_TIME - $entity->get('feeds_item')->imported);
$row = [];
// Entity link.
$row[] = ['data' => $entity->link(Unicode::truncate($entity->label(), 75, TRUE, TRUE)), 'title' => $entity->label()];
// Imported ago.
$row[] = $this->t('@time ago', ['@time' => $ago]);
// Item GUID.
$row[] = ['data' => SafeMarkup::checkPlain(Unicode::truncate($entity->get('feeds_item')->guid, 30, FALSE, TRUE)), 'title' => $entity->get('feeds_item')->guid];
// Item URL.
$row[] = ['data' => SafeMarkup::checkPlain(Unicode::truncate($entity->get('feeds_item')->url, 30, FALSE, TRUE)), 'title' => $entity->get('feeds_item')->url];
$build['table']['#rows'][] = $row;
}
$build['pager'] = ['#type' => 'pager'];
$build['#title'] = $this->t('%title items', ['%title' => $feeds_feed->label()]);
return $build;
}
/**
* Removes Simplenews fields.
*/
public static function removeFields()
{
$simplenews_fields_ids = \Drupal::entityQuery('field_config')->condition('field_type', 'simplenews_', 'STARTS_WITH')->execute();
$simplenews_fields = \Drupal::entityManager()->getStorage('field_config')->loadMultiple($simplenews_fields_ids);
$field_config_storage = \Drupal::entityManager()->getStorage('field_config');
$field_config_storage->delete($simplenews_fields);
}
/**
* Returns the entity_form_display object used to build an entity form.
*
* Depending on the configuration of the form mode for the entity bundle, this
* can be either the display object associated with the form mode, or the
* 'default' display.
*
* This method should only be used internally when rendering an entity form.
* When assigning suggested display options for a component in a given form
* mode, entity_get_form_display() should be used instead, in order to avoid
* inadvertently modifying the output of other form modes that might happen to
* use the 'default' display too. Those options will then be effectively
* applied only if the form mode is configured to use them.
*
* hook_entity_form_display_alter() is invoked on each display, allowing 3rd
* party code to alter the display options held in the display before they are
* used to generate render arrays.
*
* @param \Drupal\Core\Entity\FieldableEntityInterface $entity
* The entity for which the form is being built.
* @param string $form_mode
* The form mode.
*
* @return \Drupal\Core\Entity\Display\EntityFormDisplayInterface
* The display object that should be used to build the entity form.
*
* @see entity_get_form_display()
* @see hook_entity_form_display_alter()
*/
public static function collectRenderDisplay(FieldableEntityInterface $entity, $form_mode)
{
$entity_type = $entity->getEntityTypeId();
$bundle = $entity->bundle();
// Check the existence and status of:
// - the display for the form mode,
// - the 'default' display.
if ($form_mode != 'default') {
$candidate_ids[] = $entity_type . '.' . $bundle . '.' . $form_mode;
}
$candidate_ids[] = $entity_type . '.' . $bundle . '.default';
$results = \Drupal::entityQuery('entity_form_display')->condition('id', $candidate_ids)->condition('status', TRUE)->execute();
// Load the first valid candidate display, if any.
$storage = \Drupal::entityManager()->getStorage('entity_form_display');
foreach ($candidate_ids as $candidate_id) {
if (isset($results[$candidate_id])) {
$display = $storage->load($candidate_id);
break;
}
}
// Else create a fresh runtime object.
if (empty($display)) {
$display = $storage->create(array('targetEntityType' => $entity_type, 'bundle' => $bundle, 'mode' => $form_mode, 'status' => TRUE));
}
// Let the display know which form mode was originally requested.
$display->originalMode = $form_mode;
// Let modules alter the display.
$display_context = array('entity_type' => $entity_type, 'bundle' => $bundle, 'form_mode' => $form_mode);
\Drupal::moduleHandler()->alter('entity_form_display', $display, $display_context);
return $display;
}
/**
* Rolls back the configured migrations.
*/
public function rollback()
{
static::$messages = new DrushLogMigrateMessage();
$query = \Drupal::entityQuery('migration');
$names = $query->execute();
// Order the migrations according to their dependencies.
/** @var MigrationInterface[] $migrations */
$migrations = \Drupal::entityManager()->getStorage('migration')->loadMultiple($names);
// Assume we want all those tagged 'Drupal %'.
foreach ($migrations as $migration_id => $migration) {
$keep = FALSE;
$tags = $migration->get('migration_tags');
foreach ($tags as $tag) {
if (strpos($tag, 'Drupal ') === 0) {
$keep = TRUE;
break;
}
}
if (!$keep) {
unset($migrations[$migration_id]);
}
}
// Roll back in reverse order.
$this->migrationList = array_reverse($migrations);
foreach ($this->migrationList as $migration_id => $migration) {
drush_print(dt('Rolling back @migration', ['@migration' => $migration_id]));
$executable = new MigrateExecutable($migration, static::$messages);
// drush_op() provides --simulate support.
drush_op([$executable, 'rollback']);
$migration->delete();
}
}
/**
* Load an entity by it's label.
*
* @param string $label
* The label of the entity to load.
* @param string $entity_type
* The entity type to load.
*
* @return \Drupal\Core\Entity\EntityInterface
* A loaded entity.
*/
protected function loadEntityByLabel($label, $entity_type = 'node')
{
$type_manager = \Drupal::entityTypeManager();
$label_key = $type_manager->getDefinition($entity_type)->getKey('label');
$entities = \Drupal::entityQuery($entity_type)->condition($label_key, $label, '=')->execute();
return $type_manager->getStorage($entity_type)->load(array_shift($entities));
}
/**
* Test importing address formats using service.
*/
function testAddressFormatImport()
{
$externalRepository = new AddressFormatRepository();
$externalCount = count($externalRepository->getAll());
$count = \Drupal::entityQuery('address_format')->count()->execute();
$this->assertEqual($externalCount, $count, 'All address formats imported at installation.');
}
/**
* {@inheritdoc}
*/
public function content()
{
// Get the list of the reservation node ids.
$storage = \Drupal::entityManager()->getStorage('node');
$reserved_list = \Drupal::entityQuery('node')->condition('status', 1)->condition('type', 'balagan_reservation')->condition('field_balagan_reserv_accom', 'NULL', '<>')->condition('field_balagan_reserv_customer', 'NULL', '<>')->execute();
$reserved_accom = array();
$build = array();
foreach ($reserved_list as $nid) {
$reserved_accom[] = $storage->load($nid)->field_balagan_reserv_accom->getValue()[0]['target_id'];
}
if (!empty($reserved_accom)) {
$accommodations = \Drupal::entityQuery('node')->condition('status', 1)->condition('type', 'balagan_accommodation')->condition('nid', $reserved_accom, 'NOT IN')->execute();
foreach ($accommodations as $item) {
$node = node_load($item);
$locality = $node->field_balagan_accom_address->getValue()[0]['locality'];
$start = $node->field_balagan_accom_date->getValue()[0]['value'];
$end = $node->field_balagan_accom_date->getValue()[1]['value'];
$people = $node->field_balagan_accom_people->getValue()[0]['value'];
$link = $node->toLink()->toRenderable();
$build[] = $link;
$build[] = array('markup' => array('#type' => 'markup', '#markup' => ' ' . $locality . ' ' . $start . ' - ' . $end . ' ' . 'Room for: ' . $people . '<BR>'));
}
}
return $build;
}
/**
* Tests that a basic taxonomy entity query works.
*/
function testTaxonomyEfq()
{
$terms = array();
for ($i = 0; $i < 5; $i++) {
$term = $this->createTerm($this->vocabulary);
$terms[$term->id()] = $term;
}
$result = \Drupal::entityQuery('taxonomy_term')->execute();
sort($result);
$this->assertEqual(array_keys($terms), $result, 'Taxonomy terms were retrieved by entity query.');
$tid = reset($result);
$ids = (object) array('entity_type' => 'taxonomy_term', 'entity_id' => $tid, 'bundle' => $this->vocabulary->id());
$term = _field_create_entity_from_ids($ids);
$this->assertEqual($term->id(), $tid, 'Taxonomy term can be created based on the IDs.');
// Create a second vocabulary and five more terms.
$vocabulary2 = $this->createVocabulary();
$terms2 = array();
for ($i = 0; $i < 5; $i++) {
$term = $this->createTerm($vocabulary2);
$terms2[$term->id()] = $term;
}
$result = \Drupal::entityQuery('taxonomy_term')->condition('vid', $vocabulary2->id())->execute();
sort($result);
$this->assertEqual(array_keys($terms2), $result, format_string('Taxonomy terms from the %name vocabulary were retrieved by entity query.', array('%name' => $vocabulary2->label())));
$tid = reset($result);
$ids = (object) array('entity_type' => 'taxonomy_term', 'entity_id' => $tid, 'bundle' => $vocabulary2->id());
$term = _field_create_entity_from_ids($ids);
$this->assertEqual($term->id(), $tid, 'Taxonomy term can be created based on the IDs.');
}
/**
* {@inheritdoc}
*/
protected function checkAccess(EntityInterface $entity, $operation, AccountInterface $account)
{
/** @var \Drupal\crm_core_contact\Entity\ContactType $entity */
// First check permission.
if (parent::checkAccess($entity, $operation, $account)->isForbidden()) {
return AccessResult::forbidden();
}
switch ($operation) {
case 'enable':
// Only disabled contact type can be enabled.
return AccessResult::allowedIf(!$entity->status());
case 'disable':
return AccessResult::allowedIf($entity->status());
case 'delete':
// If contact instance of this contact type exist, you can't delete it.
$results = \Drupal::entityQuery('crm_core_contact')->condition('type', $entity->id())->execute();
return AccessResult::allowedIf(empty($results));
// @todo Which is it?
// @todo Which is it?
case 'edit':
case 'update':
// If the contact type is locked, you can't edit it.
return AccessResult::allowed();
}
}
/**
* Tests the widget.
*/
protected function testWidget()
{
/** @var \Drupal\currency\ConfigImporterInterface $config_importer */
$config_importer = \Drupal::service('currency.config_importer');
$config_importer->importCurrency('EUR');
$user = $this->drupalCreateUser(['administer user fields']);
$this->drupalLogin($user);
// Test the widget when setting a default field value.
$field_name = strtolower($this->randomMachineName());
$this->drupalPostForm('admin/config/people/accounts/fields/add-field', ['label' => $this->randomString(), 'field_name' => $field_name, 'new_storage_type' => 'payment_form'], t('Save and continue'));
$this->drupalPostForm(NULL, [], t('Save field settings'));
$this->drupalPostForm(NULL, [], t('Add and configure a new line item'));
$this->drupalPostForm(NULL, ['default_value_input[field_' . $field_name . '][line_items][line_items][payment_basic][plugin_form][description]' => $this->randomString()], t('Save settings'));
// Get all payment_form fields.
$field_names = \Drupal::entityQuery('field_storage_config')->condition('type', 'payment_form')->execute();
$this->assertTrue(in_array('user.field_' . $field_name, $field_names));
// Test the widget when creating an entity.
$this->drupalPostForm('user/' . $user->id() . '/edit', ['field_' . $field_name . '[line_items][add_more][type]' => 'payment_basic'], t('Add and configure a new line item'));
$description = $this->randomString();
$this->drupalPostForm(NULL, ['field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][amount][amount]' => '9,87', 'field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][amount][currency_code]' => 'EUR', 'field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][description]' => $description, 'field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][quantity]' => 37], t('Save'));
// Test whether the widget displays field values.
$this->drupalGet('user/' . $user->id() . '/edit');
$this->assertFieldByName('field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][amount][amount]', '9.87');
$this->assertFieldByName('field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][amount][currency_code]', 'EUR');
$this->assertFieldByName('field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][description]', $description);
$this->assertFieldByName('field_' . $field_name . '[line_items][line_items][payment_basic][plugin_form][quantity]', 37);
}
/**
* Tests that the autocomplete input element appears and the creation of a new
* entity.
*/
public function testAutoCreate()
{
$this->drupalGet('node/add/' . $this->referencingType);
$this->assertFieldByXPath('//input[@id="edit-test-field-0-target-id" and contains(@class, "form-autocomplete")]', NULL, 'The autocomplete input element appears.');
$new_title = $this->randomMachineName();
// Assert referenced node does not exist.
$base_query = \Drupal::entityQuery('node');
$base_query->condition('type', $this->referencedType)->condition('title', $new_title);
$query = clone $base_query;
$result = $query->execute();
$this->assertFalse($result, 'Referenced node does not exist yet.');
$edit = array('title[0][value]' => $this->randomMachineName(), 'test_field[0][target_id]' => $new_title);
$this->drupalPostForm("node/add/{$this->referencingType}", $edit, 'Save');
// Assert referenced node was created.
$query = clone $base_query;
$result = $query->execute();
$this->assertTrue($result, 'Referenced node was created.');
$referenced_nid = key($result);
$referenced_node = Node::load($referenced_nid);
// Assert the referenced node is associated with referencing node.
$result = \Drupal::entityQuery('node')->condition('type', $this->referencingType)->execute();
$referencing_nid = key($result);
$referencing_node = Node::load($referencing_nid);
$this->assertEqual($referenced_nid, $referencing_node->test_field->target_id, 'Newly created node is referenced from the referencing node.');
// Now try to view the node and check that the referenced node is shown.
$this->drupalGet('node/' . $referencing_node->id());
$this->assertText($referencing_node->label(), 'Referencing node label found.');
$this->assertText($referenced_node->label(), 'Referenced node label found.');
}
/**
* @{inheritdoc}
*/
public function render(ResultRow $values)
{
$card = $values->_entity;
$query = \Drupal::entityQuery('card_instance')->condition('field_card_base.entity.id', $card->id())->count();
$count = $query->execute();
return $count;
}
/**
* Tests using entity query with ContentEntityNullStorage.
*
* @see \Drupal\Core\Entity\Query\Null\Query
*/
public function testEntityQuery()
{
$this->assertIdentical(0, \Drupal::entityQuery('contact_message')->count()->execute(), 'Counting a null storage returns 0.');
$this->assertIdentical([], \Drupal::entityQuery('contact_message')->execute(), 'Querying a null storage returns an empty array.');
$this->assertIdentical([], \Drupal::entityQuery('contact_message')->condition('contact_form', 'test')->execute(), 'Querying a null storage returns an empty array and conditions are ignored.');
$this->assertIdentical([], \Drupal::entityQueryAggregate('contact_message')->aggregate('name', 'AVG')->execute(), 'Aggregate querying a null storage returns an empty array');
}
/**
* Implement getEmails($states, $subscribed, $newsletters)
*/
function getEmails($states, $subscribed, $newsletters)
{
// Build conditions for active state, subscribed state and newsletter selection.
if (isset($states['active'])) {
$condition_active[] = SubscriberInterface::ACTIVE;
}
if (isset($states['inactive'])) {
$condition_active[] = SubscriberInterface::INACTIVE;
}
if (isset($subscribed['subscribed'])) {
$condition_subscribed[] = SIMPLENEWS_SUBSCRIPTION_STATUS_SUBSCRIBED;
}
if (isset($subscribed['unsubscribed'])) {
$condition_subscribed[] = SIMPLENEWS_SUBSCRIPTION_STATUS_UNSUBSCRIBED;
}
if (isset($subscribed['unconfirmed'])) {
$condition_subscribed[] = SIMPLENEWS_SUBSCRIPTION_STATUS_UNCONFIRMED;
}
// Get emails from the database.
$query = \Drupal::entityQuery('simplenews_subscriber')->condition('status', $condition_active)->condition('subscriptions.status', $condition_subscribed)->condition('subscriptions.target_id', (array) $newsletters, 'IN');
$subscriber_ids = $query->execute();
$mails = array();
foreach ($subscriber_ids as $id) {
$subscriber = simplenews_subscriber_load($id);
$mails[] = $subscriber->getMail();
}
// Return comma separated array of emails or empty text.
if ($mails) {
return implode(", ", $mails);
}
return t('No addresses were found.');
}
/**
* Search.
*
* @return json
* Return json.
*/
public function search($searched, $operation) {
$idsEntities = \Drupal::entityQuery('ps_product', 'OR')
->condition('name', $searched, 'CONTAINS')
->condition('detail', $searched, 'CONTAINS')
->execute();
$entities = Product::loadMultiple($idsEntities);
$i = 0;
$result = array();
foreach ($entities as $entity) {
if ($entity->getType() == $operation) {
$result[$i] = array(
'id' => $entity->getId(),
'name' => $entity->get('name')->value,
'phone' => $entity->get('phone')->value,
'cellphone' => $entity->get('cellphone')->value,
'email' => $entity->get('email')->value,
'webpage' => $entity->get('webpage')->value,
'address' => $entity->get('address')->value,
'detail' => $entity->get('detail')->value,
);
$i++;
}
}
$response = new Response();
$response->setContent(json_encode($result));
$response->headers->set('Content-Type', 'application/json');
return $response;
}
/**
* Checks the number of available RDF entities filtered by bundle.
*
* @param int $number
* The expected number of RDF entities.
* @param string $type
* The RDF type.
*
* @throws \Exception
* Thrown when the number of RDF entities does not
* match the expectation.
*/
protected function assertRdfEntityCount($number, $type)
{
$actual = \Drupal::entityQuery('rdf_entity')->condition('rid', $type)->count()->execute();
if ($actual != $number) {
throw new \Exception("Wrong number of {$type} entities. Expected number: {$number}, actual number: {$actual}.");
}
}
/**
* {@inheritdoc}
*/
public function query()
{
if (is_array($this->value) && in_array('_active', $this->value)) {
$active = \Drupal::entityQuery('uc_order_status')->condition('weight', 0, '>=')->execute();
$this->value = array_merge($this->value, $active);
}
parent::query();
}
public static function getPretEntity(Node $benzinarie, Term $tip_carburant)
{
$preturi_ids = \Drupal::entityQuery('node')->condition('type', 'pret')->condition('field_benzinarie.target_id', $benzinarie->id())->condition('field_tip_carburant.target_id', $tip_carburant->id())->condition('status', 1)->sort('created', 'DESC')->execute();
if (count($preturi_ids)) {
$pret_id = array_shift($preturi_ids);
return Node::load($pret_id);
}
}
private static function _gen_hash($field = '')
{
do {
$hash = DT::random_string(6, true);
$entity_ids = \Drupal::entityQuery('node')->condition($field . '.value', $hash, '=')->execute();
} while ($entity_ids);
return $hash;
}
public function __construct(Request $request, $container)
{
$type = 'node';
// Get the entity type from the request.
$this->query = \Drupal::entityQuery($type);
$this->storage = $container->get('entity.manager')->getStorage($type);
$this->container = $container;
$this->params = $this->getRequestParams($request);
}
/**
* {@inheritdoc}
*/
public function __construct(array $settings, $plugin_id, array $plugin_definition)
{
parent::__construct($settings, $plugin_id, $plugin_definition);
// Calculate the upload directory.
// $this->availableEntities = \Drupal::service('plugin.manager.entity_reference.selection')
// ->getInstance(array('field_definition' => $this->settings['instance']))
// ->getReferenceableEntities();
$this->entityQuery = \Drupal::entityQuery($this->getEntityType());
}
/**
* Deletes Paragraphs datas.
*/
public static function deleteParagraphs(&$context)
{
$paragraph_ids = \Drupal::entityQuery('paragraph')->range(0, 100)->execute();
$storage = \Drupal::entityTypeManager()->getStorage('paragraph');
if ($paragraphs = $storage->loadMultiple($paragraph_ids)) {
$storage->delete($paragraphs);
}
$context['finished'] = (int) count($paragraph_ids) < 100;
}
/**
* {@inheritdoc}
*/
public function validate($value, Constraint $constraint)
{
$field = $this->context->getMetadata()->getTypedData()->getParent();
$uid = $field->getParent()->id();
$value_taken = (bool) \Drupal::entityQuery('user')->condition('uid', (int) $uid, '<>')->condition($field->getName(), $value)->range(0, 1)->count()->execute();
if ($value_taken) {
$this->context->addViolation($constraint->message, array("%value" => $value));
}
}
/**
* Checks whether a node with the same brafton ID exists in drupal database.
*
* @param int $brafton_id The Brafton ID.
*
* @return array $nids An array of node ids (nids) that have matching Brafton Id.
*/
public function brafton_post_exists($brafton_id)
{
$loop_section = $this->errors->get_section();
$this->errors->set_section('Checking for existing Brafton ID ' . $brafton_id);
$query = \Drupal::entityQuery('node')->condition('field_brafton_id', $brafton_id);
$nids = $query->execute();
$this->errors->set_section($loop_section);
return $nids;
}
public static function file_get_id_by_uri($uri)
{
$res = \Drupal::entityQuery('file')->condition('uri', $uri)->execute();
if ($res) {
$fid = array_shift($res);
return $fid;
}
return false;
}
/**
* {@inheritdoc}
*/
public static function processDefaultValue($default_value, FieldableEntityInterface $entity, FieldDefinitionInterface $definition)
{
$default_value = parent::processDefaultValue($default_value, $entity, $definition);
if ($default_value) {
// Convert UUIDs to numeric IDs.
$uuids = array();
foreach ($default_value as $delta => $properties) {
if (isset($properties['target_uuid'])) {
$uuids[$delta] = $properties['target_uuid'];
}
}
if ($uuids) {
$target_type = $definition->getSetting('target_type');
$entity_ids = \Drupal::entityQuery($target_type)->condition('uuid', $uuids, 'IN')->execute();
$entities = \Drupal::entityManager()->getStorage($target_type)->loadMultiple($entity_ids);
$entity_uuids = array();
foreach ($entities as $id => $entity) {
$entity_uuids[$entity->uuid()] = $id;
}
foreach ($uuids as $delta => $uuid) {
if (isset($entity_uuids[$uuid])) {
$default_value[$delta]['target_id'] = $entity_uuids[$uuid];
unset($default_value[$delta]['target_uuid']);
} else {
unset($default_value[$delta]);
}
}
}
// Ensure we return consecutive deltas, in case we removed unknown UUIDs.
$default_value = array_values($default_value);
}
return $default_value;
}