commerce_product_bundle-8.x-1.x-dev/src/Plugin/Field/FieldWidget/ProductBundleItemsWidget.php
src/Plugin/Field/FieldWidget/ProductBundleItemsWidget.php
<?php
namespace Drupal\commerce_product_bundle\Plugin\Field\FieldWidget;
use Drupal\commerce_order\Entity\OrderItemInterface;
use Drupal\commerce_product\ProductAttributeFieldManagerInterface;
use Drupal\commerce_product\Entity\ProductVariationInterface;
use Drupal\commerce_product_bundle\Entity\BundleItemInterface;
use Drupal\Component\Utility\Html;
use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Field\FieldItemListInterface;
use Drupal\Core\Form\FormStateInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
/**
* Plugin implementation of the 'commerce_product_bundle_items' widget.
*
* @FieldWidget(
* id = "commerce_product_bundle_items",
* label = @Translation("Product bundle items"),
* field_types = {
* "entity_reference"
* }
* )
*/
class ProductBundleItemsWidget extends ProductBundleWidgetBase {
/**
* NOTES:.
*
* 1. This is based off of ProductVariationAttributesWidget which handled
* product -> (1) VARIATION selection based on available attributes.
* 2. This widget will need to handle
* bundle -> (products) -> (MANY) VARIATIONS selections based on attributes
* So it will need to do everything ProductVariationAttributesWidget does
* but also handle multiple selections.
*/
/**
* The product attribute storage.
*
* @var \Drupal\Core\Entity\EntityStorageInterface
*/
protected $attributeStorage;
/**
* The attribute field manager.
*
* @var \Drupal\commerce_product\ProductAttributeFieldManagerInterface
*/
protected $attributeFieldManager;
/**
* Constructs a new ProductBundleItemsWidget object.
*
* @param string $plugin_id
* The plugin_id for the widget.
* @param mixed $plugin_definition
* The plugin implementation definition.
* @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
* The definition of the field to which the widget is associated.
* @param array $settings
* The widget settings.
* @param array $third_party_settings
* Any third party settings.
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
* The entity type manager.
* @param \Drupal\commerce_product\ProductAttributeFieldManagerInterface $attribute_field_manager
* The attribute field manager.
*/
public function __construct($plugin_id, $plugin_definition, FieldDefinitionInterface $field_definition, array $settings, array $third_party_settings, EntityTypeManagerInterface $entity_type_manager, ProductAttributeFieldManagerInterface $attribute_field_manager) {
parent::__construct($plugin_id, $plugin_definition, $field_definition, $settings, $third_party_settings, $entity_type_manager);
$this->attributeStorage = $entity_type_manager->getStorage('commerce_product_attribute');
$this->attributeFieldManager = $attribute_field_manager;
}
/**
* {@inheritdoc}
*/
public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
return new static(
$plugin_id,
$plugin_definition,
$configuration['field_definition'],
$configuration['settings'],
$configuration['third_party_settings'],
$container->get('entity_type.manager'),
$container->get('commerce_product.attribute_field_manager')
);
}
/**
* {@inheritdoc}
*/
public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
/** @var \Drupal\commerce_product_bundle\Entity\BundleInterface $product_bundle */
$bundle = $form_state->get('product_bundle');
$element['bundle'] = [
'#type' => 'value',
'#value' => $bundle->id(),
];
$element['bundle_items'] = [];
/** @var \Drupal\commerce_product_bundle\Entity\BundleItemInterface $bundle_item */
foreach ($bundle->getBundleItems() as $bundle_item) {
$parents = [$items->getName(), $delta, 'bundle_items', $bundle_item->id()];
$element['bundle_items'][$bundle_item->id()] = $this->getBundleItemForm($bundle_item, $form, $form_state, $parents);
}
$form['#entity_builders'][] = [$this, 'addBundleItemSelections'];
return $element;
}
/**
* Gets the child form element for a given bundle item.
*
* @param \Drupal\commerce_product_bundle\Entity\BundleItemInterface $bundle_item
* The bundle item.
* @param array $form
* The complete form array.
* @param \Drupal\Core\Form\FormStateInterface $form_state
* The current state of the form.
* @param array $parents
* The parents of the bundle item form element in the form structure.
*
* @return array
* A renderable form array for the given bundle item.
*/
private function getBundleItemForm(BundleItemInterface $bundle_item, array &$form, FormStateInterface $form_state, array $parents) {
$bundle_item_form = [
'bundle_item' => [
'#type' => 'value',
'#value' => $bundle_item,
],
];
/** @var \Drupal\commerce_product\Entity\ProductInterface $product */
$product = $bundle_item->getProduct();
/** @var \Drupal\commerce_product\Entity\ProductVariationInterface[] $variations */
$variations = $bundle_item->getVariations();
$min_qty = $bundle_item->getMinimumQuantity();
$max_qty = $bundle_item->getMaximumQuantity();
if ($min_qty === $max_qty) {
$bundle_item_form['qty'] = [
'#type' => 'value',
'#value' => $bundle_item->getQuantity(),
];
}
else {
$bundle_item_form['qty'] = [
'#type' => 'number',
'#title' => $this->t('Quantity'),
'#min' => $min_qty,
'#max' => $max_qty,
'#default_value' => $min_qty,
'#step' => 1,
];
}
if (count($variations) === 0) {
// Nothing to purchase, tell the parent form to hide itself.
$form_state->set('hide_form', TRUE);
$bundle_item_form['variation'] = [
'#type' => 'value',
'#value' => 0,
];
return $bundle_item_form;
}
elseif (count($variations) === 1) {
/** @var \Drupal\commerce_product\Entity\ProductVariationInterface $selected_variation */
$selected_variation = reset($variations);
// For regular products, from which this logic was adapted, the variation
// form is only hidden (with simply this value stored) when the variation
// has no attribute fields (to show the customer which variation they are
// purchasing). But since the product bundle is expected to indicate the
// items in the bundle, and to avoid unnecessary UI clutter, we hide all
// attribute widgets when there is only one variation.
// Compare this with ProductVariationAttributesWidget::formElement.
$bundle_item_form['variation'] = [
'#type' => 'value',
'#value' => $selected_variation->id(),
];
$bundle_item->setCurrentVariation($selected_variation);
$bundle_item_form['title'] = [
'#type' => 'markup',
'#markup' => $bundle_item->getTitle(),
'#prefix' => '<p>',
'#suffix' => '</p>',
];
return $bundle_item_form;
}
// Build the bundle item's full attribute form.
$wrapper_id = Html::getUniqueId('commerce-product-bundle-item-add-to-cart-form');
$bundle_item_form += [
'#wrapper_id' => $wrapper_id,
'#prefix' => '<div id="' . $wrapper_id . '">',
'#suffix' => '</div>',
];
$user_input = (array) NestedArray::getValue($form_state->getUserInput(), $parents);
if (!empty($user_input)) {
$selected_variation = $this->selectVariationFromUserInput($variations, $user_input);
}
else {
$selected_variation = $this->variationStorage->loadFromContext($product);
// The returned variation must also be enabled.
if (!in_array($selected_variation, $variations)) {
$selected_variation = reset($variations);
}
}
$bundle_item_form['variation'] = [
'#type' => 'value',
'#value' => $selected_variation->id(),
];
$bundle_item->setCurrentVariation($selected_variation);
// Set the selected variation in the form state for our AJAX callback.
$form_state->set('purchased_entity][widget][0][bundle_items][' . $bundle_item->id() . '][selected_variation', $selected_variation->id());
$bundle_item_form['attributes'] = [
'#type' => 'container',
'#attributes' => [
'class' => ['attribute-widgets'],
],
];
foreach ($this->getItemAttributeInfo($selected_variation, $variations) as $field_name => $attribute) {
$bundle_item_form['attributes'][$field_name] = [
'#type' => $attribute['element_type'],
'#title' => $attribute['title'],
'#options' => $attribute['values'],
'#required' => $attribute['required'],
'#default_value' => $selected_variation->getAttributeValueId($field_name),
'#ajax' => [
'callback' => [get_class($this), 'ajaxRefresh'],
'wrapper' => $bundle_item_form['#wrapper_id'],
],
];
// Convert the _none option into #empty_value.
if (isset($bundle_item_form['attributes'][$field_name]['#options']['_none'])) {
if (!$bundle_item_form['attributes'][$field_name]['#required']) {
$bundle_item_form['attributes'][$field_name]['#empty_value'] = '';
}
unset($bundle_item_form['attributes'][$field_name]['#options']['_none']);
}
// 1 required value -> Disable the bundle_item_variations to skip unneeded ajax calls.
if ($attribute['required'] && count($attribute['values']) === 1) {
$bundle_item_form['attributes'][$field_name]['#disabled'] = TRUE;
}
// Optimize the UX of optional attributes:
// - Hide attributes that have no values.
// - Require attributes that have a value on each variation.
if (empty($bundle_item_form['attributes'][$field_name]['#options'])) {
$bundle_item_form['attributes'][$field_name]['#access'] = FALSE;
}
if (!isset($bundle_item_form['attributes'][$field_name]['#empty_value'])) {
$bundle_item_form['attributes'][$field_name]['#required'] = TRUE;
}
}
return $bundle_item_form;
}
/**
* Selects a product variation from user input.
*
* If there's no user input (form viewed for the first time), the default
* variations are returned.
*
* @param \Drupal\commerce_product\Entity\ProductVariationInterface[] $variations
* An array of product variations.
* @param array $user_input
* The user input.
*
* @return \Drupal\commerce_product\Entity\ProductVariationInterface
* The selected variation.
*/
protected function selectVariationFromUserInput(array $variations, array $user_input) {
$current_variation = reset($variations);
if (!empty($user_input)) {
$attributes = $user_input['attributes'];
foreach ($variations as $variation) {
$match = TRUE;
foreach ($attributes as $field_name => $value) {
if ($variation->getAttributeValueId($field_name) != $value) {
$match = FALSE;
}
}
if ($match) {
$current_variation = $variation;
break;
}
}
}
return $current_variation;
}
/**
* Gets the attribute information for the selected product variation.
*
* @param \Drupal\commerce_product\Entity\ProductVariationInterface $selected_variation
* The selected product variation.
* @param \Drupal\commerce_product\Entity\ProductVariationInterface[] $variations
* The available product variations.
*
* @return array[]
* The attribute information, keyed by field name.
*/
protected function getItemAttributeInfo(ProductVariationInterface $selected_variation, array $variations) {
$attributes = [];
$field_definitions = $this->attributeFieldManager->getFieldDefinitions($selected_variation->bundle());
$field_map = $this->attributeFieldManager->getFieldMap($selected_variation->bundle());
$field_names = array_column($field_map, 'field_name');
$index = 0;
foreach ($field_names as $field_name) {
/** @var \Drupal\commerce_product\Entity\ProductAttributeInterface $attribute_type */
$attribute_type = $this->attributeStorage->load(substr($field_name, 10));
$field = $field_definitions[$field_name];
$attributes[$field_name] = [
'field_name' => $field_name,
'title' => $field->getLabel(),
'required' => $field->isRequired(),
'element_type' => $attribute_type->getElementType(),
];
// The first attribute gets all values. Every next attribute gets only
// the values from variations matching the previous attribute value.
// For 'Color' and 'Size' attributes that means getting the colors of all
// variations, but only the sizes of variations with the selected color.
$callback = NULL;
if ($index > 0) {
$previous_field_name = $field_names[$index - 1];
$previous_field_value = $selected_variation->getAttributeValueId($previous_field_name);
$callback = function ($variation) use ($previous_field_name, $previous_field_value) {
/** @var \Drupal\commerce_product\Entity\ProductVariationInterface $variation */
return $variation->getAttributeValueId($previous_field_name) == $previous_field_value;
};
}
$attributes[$field_name]['values'] = $this->getAttributeValues($variations, $field_name, $callback);
$index++;
}
// Filter out attributes with no values.
$attributes = array_filter($attributes, function ($attribute) {
return !empty($attribute['values']);
});
return $attributes;
}
/**
* Gets the attribute values of a given set of variations.
*
* @param \Drupal\commerce_product\Entity\ProductVariationInterface[] $variations
* The variations.
* @param string $field_name
* The field name of the attribute.
* @param callable|null $callback
* An optional callback to use for filtering the list.
*
* @return array[]
* The attribute values, keyed by attribute ID.
*/
protected function getAttributeValues(array $variations, $field_name, callable $callback = NULL) {
$values = [];
foreach ($variations as $variation) {
if (is_null($callback) || call_user_func($callback, $variation)) {
$attribute_value = $variation->getAttributeValue($field_name);
if ($attribute_value) {
$values[$attribute_value->id()] = $attribute_value->label();
}
else {
$values['_none'] = '';
}
}
}
return $values;
}
/**
* Entity builder: updates the order item with the bundle item selections.
*
* @param string $entity_type
* The entity type.
* @param \Drupal\commerce_order\Entity\OrderItemInterface $order_item
* The entity updated with the submitted values.
* @param array $form
* The complete form array.
* @param \Drupal\Core\Form\FormStateInterface $form_state
* The current state of the form.
*/
public function addBundleItemSelections($entity_type, OrderItemInterface $order_item, array $form, FormStateInterface $form_state) {
$bundle_order_items = [];
foreach ($form_state->getValue('purchased_entity')[0]['bundle_items'] as $item => $selection) {
// Cast values to string like OrderItem does for other fields.
// Value type (string) and order are required when matching order items.
// @see \Drupal\commerce_cart\OrderItemMatcher
/** @var \Drupal\commerce_product\Entity\ProductVariationInterface $variation */
$variation = $this->variationStorage->load($selection['variation']);
/** @var \Drupal\commerce_product_bundle\Entity\BundleItemInterface $bundle_item */
$bundle_item = $selection['bundle_item'];
$bundle_order_item = $this->bundleItemOrderItemStorage->create([
'title' => $bundle_item->getTitle(),
'bundle_item' => $bundle_item,
'purchased_entity' => $variation,
'unit_price' => $bundle_item->getUnitPrice(),
'quantity' => (string) $selection['qty'],
]);
$bundle_order_items[] = $bundle_order_item;
}
$order_item->set('bundle_item_order_items', $bundle_order_items);
}
}
