<?php declare(strict_types=1);
namespace MoorlForms\Core\Service;
use Doctrine\DBAL\Connection;
use Monolog\Logger;
use MoorlForms\Core\Content\Element\ElementAvailableFilter;
use MoorlForms\Core\Content\Element\ElementCollection;
use MoorlForms\Core\Content\Element\ElementDataStruct;
use MoorlForms\Core\Content\Element\ElementEntity;
use MoorlForms\Core\Content\Element\ElementPriceCalculator;
use MoorlForms\Core\Content\Element\Selection\ElementSelectionInterface;
use MoorlForms\Core\Content\Element\Tree\Tree;
use MoorlForms\Core\Content\Element\Tree\TreeItem;
use MoorlForms\Core\Content\Element\Type\ElementTypeInterface;
use MoorlForms\Core\Content\Element\Type\Fields\ElementTypeUpload;
use MoorlForms\Core\Content\Form\Action\FormActionInterface;
use MoorlForms\Core\Content\Form\FormAvailableFilter;
use MoorlForms\Core\Content\Form\FormCollection;
use MoorlForms\Core\Content\Form\FormDefinition;
use MoorlForms\Core\Content\Form\FormEntity;
use MoorlForms\Core\Content\Form\FormSubmitResponse;
use MoorlForms\Core\Content\Form\Type\FormTypeInterface;
use MoorlForms\Core\Event\SubmitFormEntityEvent;
use MoorlForms\Core\Event\SubmitFormErrorEvent;
use MoorlForms\Core\Event\SubmitFormSuccessEvent;
use MoorlForms\Core\Event\ValidateFormEvent;
use MoorlForms\MoorlForms;
use MoorlFoundation\Core\PluginHelpers;
use Psr\Log\LoggerInterface;
use Shopware\Core\Checkout\Cart\Price\Struct\CalculatedPrice;
use Shopware\Core\Content\Category\CategoryDefinition;
use Shopware\Core\Content\Category\SalesChannel\CachedCategoryRoute;
use Shopware\Core\Content\Category\SalesChannel\CachedNavigationRoute;
use Shopware\Core\Content\Media\MediaCollection;
use Shopware\Core\Content\Media\MediaDefinition;
use Shopware\Core\Content\Media\MediaEntity;
use Shopware\Core\Content\Product\ProductDefinition;
use Shopware\Core\Content\Product\ProductEntity;
use Shopware\Core\Content\Product\SalesChannel\ProductAvailableFilter;
use Shopware\Core\Framework\Adapter\Cache\CacheInvalidator;
use Shopware\Core\Framework\Context;
use Shopware\Core\Framework\DataAbstractionLayer\DefinitionInstanceRegistry;
use Shopware\Core\Framework\DataAbstractionLayer\Entity;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\Filter;
use Shopware\Core\Framework\Log\LoggerFactory;
use Shopware\Core\Framework\Uuid\Uuid;
use Shopware\Core\System\SalesChannel\SalesChannelContext;
use Shopware\Core\System\SystemConfig\SystemConfigService;
use Shopware\Storefront\Framework\Media\StorefrontMediaUploader;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
class FbService
{
private Context $context;
private DefinitionInstanceRegistry $definitionInstanceRegistry;
private SystemConfigService $systemConfigService;
private LoggerInterface $logger;
private Connection $connection;
private EventDispatcherInterface $eventDispatcher;
private ElementPriceCalculator $elementPriceCalculator;
private StorefrontMediaUploader $storefrontMediaUploader;
private CacheInvalidator $cacheInvalidator;
/**
* @var iterable<FormActionInterface>
*/
private iterable $formActions;
/**
* @var iterable<FormTypeInterface>
*/
private iterable $formTypes;
/**
* @var iterable<ElementTypeInterface>
*/
private iterable $elementTypes;
/**
* @var iterable<ElementSelectionInterface>
*/
private iterable $elementSelections;
private TreeItem $treeItem;
private array $messages = [];
public function __construct(
DefinitionInstanceRegistry $definitionInstanceRegistry,
Connection $connection,
LoggerFactory $loggerFactory,
SystemConfigService $systemConfigService,
EventDispatcherInterface $eventDispatcher,
ElementPriceCalculator $elementPriceCalculator,
StorefrontMediaUploader $storefrontMediaUploader,
CacheInvalidator $cacheInvalidator,
iterable $formActions,
iterable $formTypes,
iterable $elementTypes,
iterable $elementSelections
)
{
$this->definitionInstanceRegistry = $definitionInstanceRegistry;
$this->connection = $connection;
$this->systemConfigService = $systemConfigService;
$this->eventDispatcher = $eventDispatcher;
$this->elementPriceCalculator = $elementPriceCalculator;
$this->storefrontMediaUploader = $storefrontMediaUploader;
$this->cacheInvalidator = $cacheInvalidator;
$this->formActions = $formActions;
$this->formTypes = $formTypes;
$this->elementTypes = $elementTypes;
$this->elementSelections = $elementSelections;
$this->logger = $loggerFactory->createRotating(
'moorl_fb',
1,
getenv('APP_ENV') === 'prod' ? Logger::NOTICE : Logger::DEBUG
);
$this->context = Context::createDefaultContext();
$this->treeItem = new TreeItem(null, []);
}
public function getForm(string $formId, bool $withTranslation = false): FormEntity
{
$criteria = new Criteria([$formId]);
$criteria->addAssociation('elements');
$criteria->setLimit(1);
if ($withTranslation) {
$criteria->addAssociation('translations');
$criteria->addAssociation('elements.translations');
}
$formRepository = $this->definitionInstanceRegistry->getRepository(FormDefinition::ENTITY_NAME);
return $formRepository->search($criteria, $this->context)->get($formId);
}
public function saveForm(array $payload): void
{
$formRepository = $this->definitionInstanceRegistry->getRepository(FormDefinition::ENTITY_NAME);
$formRepository->upsert([$payload], $this->context);
}
public function initForm(?string $formId, SalesChannelContext $salesChannelContext): ?FormEntity
{
if (!$formId) {
return null;
}
$criteria = $this->createFormCriteria($salesChannelContext);
$criteria->setLimit(1);
if (Uuid::isValid($formId)) {
$criteria->setIds([$formId]);
} else {
$criteria->addFilter(new EqualsFilter('technicalName', $formId));
}
$formRepository = $this->definitionInstanceRegistry->getRepository(FormDefinition::ENTITY_NAME);
/** @var FormEntity $form */
$form = $formRepository->search($criteria, $salesChannelContext->getContext())->first();
if (!$form) {
return null;
}
$this->initFormComponents($form, $salesChannelContext);
return $form;
}
public function initForms(array $formIds, SalesChannelContext $salesChannelContext): ?FormCollection
{
$criteria = $this->createFormCriteria($salesChannelContext);
$criteria->setIds($formIds);
$formRepository = $this->definitionInstanceRegistry->getRepository(FormDefinition::ENTITY_NAME);
/** @var FormCollection $forms */
$forms = $formRepository->search($criteria, $salesChannelContext->getContext())->getEntities();
foreach ($forms as $form) {
$this->initFormComponents($form, $salesChannelContext);
}
return $forms;
}
public function initFormsByFilter(Filter $filter, SalesChannelContext $salesChannelContext): ?FormCollection
{
$criteria = $this->createFormCriteria($salesChannelContext);
$criteria->addFilter($filter);
$formRepository = $this->definitionInstanceRegistry->getRepository(FormDefinition::ENTITY_NAME);
/** @var FormCollection $forms */
$forms = $formRepository->search($criteria, $salesChannelContext->getContext())->getEntities();
foreach ($forms as $form) {
$this->initFormComponents($form, $salesChannelContext);
}
return $forms;
}
public function initFormsByType(string $formType, SalesChannelContext $salesChannelContext): ?FormCollection
{
return $this->initFormsByFilter(
new EqualsFilter('type', $formType),
$salesChannelContext
);
}
public function initFormsByRelatedEntity(string $relatedEntity, SalesChannelContext $salesChannelContext): ?FormCollection
{
return $this->initFormsByFilter(
new EqualsFilter('relatedEntity', $relatedEntity),
$salesChannelContext
);
}
public function initFormComponents(FormEntity $form, $salesChannelContext): void
{
/* Add services to form actions */
foreach ($this->formActions as $formAction) {
$formAction->setSystemConfigService($this->systemConfigService);
$formAction->setSalesChannelContext($salesChannelContext);
$formAction->setEventDispatcher($this->eventDispatcher);
}
/* Init form actions (test connections etc.) */
foreach ($this->formActions as $formAction) {
try {
$formAction->init($form);
} catch (\Exception $exception) {
$this->addMessage($exception->getMessage(), $exception->getCode());
}
}
/* Init elements */
foreach ($form->getElements() as $element) {
$element->setTaxId($form->getTaxId());
$this->initElement($element, $salesChannelContext);
$this->initElementSelections($element, $form->getElements(), $salesChannelContext);
}
/* Build tree structure for the elements */
$form->setTree($this->getTree(null, $form->getElements()));
}
public function initElement(ElementEntity $element, SalesChannelContext $salesChannelContext): void
{
foreach ($this->elementTypes as $elementType) {
if ($elementType->getName() !== $element->getType()) {
continue;
}
$elementType->setSalesChannelContext($salesChannelContext);
$elementType->setSystemConfigService($this->systemConfigService);
$elementType->init($element);
break;
}
}
public function initElementSelections(
ElementEntity $element,
ElementCollection $elements,
SalesChannelContext $salesChannelContext
): void
{
if (!$element->getSelection()) {
return;
}
foreach ($this->elementTypes as $elementType) {
if ($elementType->getName() !== $element->getType()) {
continue;
}
if ($elementType->getGroup() !== 'multi-fields') {
continue;
}
foreach ($this->elementSelections as $elementSelection) {
if ($elementSelection->getName() !== $element->getSelection()) {
continue;
}
$elementSelection->setSalesChannelContext($salesChannelContext);
$elementSelection->setSystemConfigService($this->systemConfigService);
$elementSelection->init($element, $elements);
break;
}
break;
}
}
public function validateForm(FormEntity $form): void
{
foreach ($this->formActions as $formAction) {
try {
$formAction->validate($form);
} catch (\Exception $exception) {
$this->addMessage(
$exception->getMessage(),
$exception->getCode()
);
}
}
foreach ($form->getDataStruct()->getElements() as $elementData) {
$this->validateElementData($elementData);
}
}
public function validateElementData(ElementDataStruct $elementData): void
{
foreach ($this->elementTypes as $elementType) {
if ($elementType->getName() !== $elementData->getType()) {
continue;
}
try {
$elementType->validate($elementData);
} catch (\Exception $exception) {
$this->handleElementException($exception, $elementData);
}
}
}
public function getFormId(Request $request): string
{
return $request->get('_formId');
}
public function enrichForm(
FormEntity $form,
array $flattenElements,
SalesChannelContext $salesChannelContext
): void
{
/* Convert flatten elements to ElementDataStruct[] */
DataStructFactory::convertFlattenElements($flattenElements);
/** @var ElementDataStruct $flattenElement */
foreach ($flattenElements as $path => $flattenElement) {
$element = $form->getElements()->get($flattenElement->getElementId());
if (!$element) {
continue;
}
$element->setValue($flattenElement->getValue());
/* Enrich media for upload field */
if ($flattenElement->getMediaId()) {
$media = $this->getMedia($flattenElement->getMediaId(), $salesChannelContext->getContext());
$element->setMedia($media);
//$element->setMediaId($flattenElement->getMediaId());
$flattenElement->setMedia($media);
}
}
/* Rebuild data tree without struct branches, inherit conditions */
DataStructFactory::enrichFormDataStruct($form, $this->elementTypes);
$form->getDataStruct()->setFlattenElements($flattenElements);
}
public function getEntity(string $entityName, string $id): ?Entity
{
$repo = $this->definitionInstanceRegistry->getRepository($entityName);
$criteria = new Criteria([$id]);
$criteria->setLimit(1);
return $repo->search($criteria, $this->context)->get($id);
}
public function getEntityFromRequest(Request $request): ?Entity
{
if (
$request->request->get(MoorlForms::ENTITY_ID_KEY) &&
$request->request->get(MoorlForms::ENTITY_NAME_KEY)
) {
return $this->getEntity(
$request->request->get(MoorlForms::ENTITY_NAME_KEY),
$request->request->get(MoorlForms::ENTITY_ID_KEY)
);
}
return null;
}
public function submitForm(
FormEntity $form,
Request $request,
SalesChannelContext $salesChannelContext
): FormSubmitResponse
{
/* Since Shopware captchas need the request */
foreach ($this->elementTypes as $elementType) {
$elementType->setRequest($request);
}
foreach ($this->formActions as $formAction) {
$formAction->setRequest($request);
}
$entity = $this->getEntityFromRequest($request);
if ($entity) {
if (method_exists($entity, 'getEmail')) {
$entityMailDetection = $this->systemConfigService->get('MoorlForms.config.entityMailDetection', $salesChannelContext->getSalesChannelId());
if ($entityMailDetection === 'yes-replace') {
$form->setConfigValue('mailReceiver', $entity->getEmail());
} elseif ($entityMailDetection === 'yes-append') {
$mailReceiver = explode(";", $form->getConfig()['mailReceiver']);
$mailReceiver[] = $entity->getEmail();
$form->setConfigValue('mailReceiver', implode(";", $mailReceiver));
}
}
$event = new SubmitFormEntityEvent($entity, $salesChannelContext, $form, $request);
$this->eventDispatcher->dispatch($event);
/* Clear cache of category page */
if ($request->request->get(MoorlForms::ENTITY_NAME_KEY) === CategoryDefinition::ENTITY_NAME) {
$this->cacheInvalidator->invalidate(
array_map([CachedNavigationRoute::class, 'buildName'], [
$request->request->get(MoorlForms::ENTITY_ID_KEY)
])
);
$this->cacheInvalidator->invalidate(
array_map([CachedCategoryRoute::class, 'buildName'], [
$request->request->get(MoorlForms::ENTITY_ID_KEY)
])
);
$this->cacheInvalidator->run();
}
}
/* Merge files and values */
$values = array_replace_recursive(
$request->files->all(),
$request->request->all()
);
$this->logger->debug("Merge files and values", $values);
/* Rebuild data tree without struct branches, inherit conditions */
DataStructFactory::enrichFormDataStruct($form, $this->elementTypes);
/* Set request values to form */
DataStructFactory::enrichValues($form, $values);
/* Start recursive form validation */
$this->eventDispatcher->dispatch(new ValidateFormEvent($salesChannelContext, $form));
$this->validateForm($form);
/* Early return if validation fails */
if ($this->hasErrorMessage()) {
$this->addMessage($form->getTranslation('errorMessage'), 0, $form->getValues());
return new FormSubmitResponse($form, $this->getMessages());
}
/* Set attachments to form */
DataStructFactory::enrichAttachments($form);
/* Process form actions (send mails etc.) */
foreach ($this->formActions as $formAction) {
if (!in_array($formAction->getName(), $form->getActions())) {
continue;
}
/* Do not catch errors if form in test mode */
if ($form->getType() === 'test') {
$formAction->process($form);
} else {
try {
$formAction->process($form);
} catch (\Exception $exception) {
$this->addMessage("processError");
$this->logger->error($exception->getMessage(), $exception->getTrace());
}
}
}
/* Add success message if no errors count */
if (empty($this->getMessages()) && $form->getTranslation('successMessage')) {
$this->addMessage(
$form->getTranslation('successMessage'),
0,
$form->getValues(),
MoorlForms::SUCCESS
);
$event = new SubmitFormSuccessEvent(
$salesChannelContext,
$form,
$request
);
$this->eventDispatcher->dispatch($event);
} else {
$event = new SubmitFormErrorEvent(
$salesChannelContext,
$form,
$request
);
$this->eventDispatcher->dispatch($event);
}
return new FormSubmitResponse($form, $this->getMessages(), true);
}
public function submit(Request $request, SalesChannelContext $salesChannelContext): FormSubmitResponse
{
$form = $this->initForm($this->getFormId($request), $salesChannelContext);
return $this->submitForm($form, $request, $salesChannelContext);
}
public function handleUploadedFiles(FormEntity $form, SalesChannelContext $salesChannelContext): void
{
/* If the form have a related entity, the upload folder is bound to it */
$folder = $form->getRelatedEntity() ?: 'moorl_fb';
/* Upload files to media system */
foreach ($form->getDataStruct()->getFlattenElements() as $flattenElement) {
if ($flattenElement->getValue() instanceof UploadedFile) {
$mediaId = $this->storefrontMediaUploader->upload(
$flattenElement->getValue(),
$folder,
'moorl_fb',
$salesChannelContext->getContext()
);
$flattenElement->setPlainValue($flattenElement->getValue()->getClientOriginalName());
$flattenElement->setValue($flattenElement->getValue()->getClientOriginalName());
$flattenElement->setMediaId($mediaId);
$flattenElement->setMedia($this->getMedia($mediaId, $salesChannelContext->getContext()));
}
/* Store media id for attachments */
if ($flattenElement->getMediaId()) {
$form->getDataStruct()->addAttachmentMediaId($flattenElement->getMediaId());
}
}
}
public function enrichPrices(
FormEntity $form,
SalesChannelContext $salesChannelContext,
CalculatedPrice $price
): void
{
$this->elementPriceCalculator->calculate($form->getElements(), $salesChannelContext, $price);
}
public function enrichFromEntity(
FormEntity $form,
SalesChannelContext $salesChannelContext,
?Entity $entity = null
): void
{
if (!$entity) {
return;
}
foreach ($form->getElements() as $element) {
if ($element->getEntityMapping()) {
$mapping = explode('.', $element->getEntityMapping());
if ($mapping[0] === 'customFields') {
if (property_exists($entity, 'customFields')) {
if (isset($entity->getCustomFields()[$mapping[1]])) {
$element->setValue($entity->getCustomFields()[$mapping[1]]);
}
}
} else {
if (isset($entity->getTranslated()[$mapping[0]])) {
$element->setValue($entity->getTranslated()[$mapping[0]]);
} else {
$element->setValue($entity->get($mapping[0]));
}
}
if ($element->getValue() && $element->getType() === ElementTypeUpload::NAME && Uuid::isValid($element->getValue())) {
$media = $this->getMedia($element->getValue(), $salesChannelContext->getContext());
$element->setMedia($media);
$element->setMediaId($element->getValue());
}
}
}
}
/**
* @return array
*/
public function getMessages(): array
{
return $this->messages;
}
public function unsetMessages(): void
{
$this->messages = [];
}
public function handleElementException(\Exception $exception, ElementDataStruct $element): void
{
/* Create translatable error message */
$data = array_merge(
$element->getConfig(),
[
'value' => $element->getValue(),
'path' => $element->getPath(),
'name' => $element->getName()
]
);
$this->addMessage(
$exception->getMessage(),
$exception->getCode(),
$data
);
}
public function hasErrorMessage(): bool
{
foreach ($this->messages as $message) {
if ($message['type'] === MoorlForms::DANGER) {
return true;
}
}
return false;
}
public function addMessage(
string $message,
int $code = MoorlForms::MSG_CODE,
array $data = [],
string $type = MoorlForms::DANGER
): void
{
$this->messages[] = [
'type' => $type,
'code' => $code,
'message' => $message,
'data' => $this->getTransPlaceholder($data)
];
}
/**
* @return FormActionInterface[]
*/
public function getFormActions()
{
return $this->formActions;
}
/**
* @return FormTypeInterface[]
*/
public function getFormTypes()
{
return $this->formTypes;
}
/**
* @return ElementTypeInterface[]
*/
public function getElementTypes()
{
return $this->elementTypes;
}
/**
* @return ElementSelectionInterface[]
*/
public function getElementSelections()
{
return $this->elementSelections;
}
private function getTransPlaceholder(array $data, string $wrap = "%"): array
{
$wrapped = [];
foreach ($data as $key => $value) {
/* Not for multidimensional purposes */
if (is_array($value)) {
continue;
}
$wrapped[$wrap.$key.$wrap] = $value;
}
return $wrapped;
}
private function getTree(?string $parentId, ElementCollection $elements): Tree
{
$tree = $this->buildTree($parentId, $elements->getElements());
return new Tree($tree);
}
private function buildTree(?string $parentId, array $elements): array
{
$children = new ElementCollection();
/** @var ?ElementEntity $parent */
$parent = null;
foreach ($elements as $key => $element) {
if ($element->getId() === $parentId) {
$parent = $element;
}
if ($element->getParentId() !== $parentId) {
continue;
}
/* https://account.shopware.com/producer/support/228495 */
//unset($elements[$key]);
$children->add($element);
}
$children->sortByPosition();
/* https://account.shopware.com/producer/support/228495 */
if ($parent && !empty($parent->getConfig()['childrenSort'])) {
$children->sortBy($parent->getConfig()['childrenSort']);
}
$items = [];
foreach ($children as $child) {
if (!$child->getActive()) {
continue;
}
$item = clone $this->treeItem;
$item->setElement($child);
$item->setChildren(
$this->buildTree($child->getId(), $elements)
);
if ($child->has('inheritConfig')) {
foreach ($item->getChildren() as $c) {
$c->getElement()->setConfig(array_replace_recursive(
$child->getConfig() ?: [],
$c->getElement()->getConfig() ?: []
));
}
}
$items[$child->getId()] = $item;
}
return $items;
}
public function createFormCriteria(SalesChannelContext $salesChannelContext): Criteria
{
$criteria = new Criteria();
$criteria->addFilter(new FormAvailableFilter($salesChannelContext));
$criteria->addAssociation('elements');
$criteria->getAssociation('elements')->addFilter(new ElementAvailableFilter($salesChannelContext));
return $criteria;
}
/**
* @param array|string $productIds
* @param SalesChannelContext $salesChannelContext
* @return array|null
* @throws \Shopware\Core\Framework\DataAbstractionLayer\Exception\EntityRepositoryNotFoundException
*/
public function getProductStreamIds($productIds, SalesChannelContext $salesChannelContext): ?array
{
$criteria = new Criteria(is_array($productIds) ? $productIds : [$productIds]);
$criteria->setLimit(is_array($productIds) ? count($productIds) : 1);
$criteria->addFilter(new ProductAvailableFilter($salesChannelContext->getSalesChannelId()));
$productRepository = $this->definitionInstanceRegistry->getRepository(ProductDefinition::ENTITY_NAME);
/** @var ProductEntity $product */
$products = $productRepository->search($criteria, $salesChannelContext->getContext())->getEntities();
if (!$products) {
return null;
}
$productStreamIds = [];
foreach ($products as $product) {
if ($product->getStreamIds()) {
$productStreamIds = array_merge($productStreamIds, $product->getStreamIds());
}
}
return $productStreamIds;
}
public function getMedia(string $mediaId, Context $context): ?MediaEntity
{
$criteria = new Criteria([$mediaId]);
$criteria->setLimit(1);
$mediaRepository = $this->definitionInstanceRegistry->getRepository(MediaDefinition::ENTITY_NAME);
return $mediaRepository->search($criteria, $context)->first();
}
public function upsertEntity(
FormCollection $forms,
SalesChannelContext $salesChannelContext,
?Entity $entity = null,
?string $relatedEntity = null,
array $dataToMerge = []
): void
{
if (!$form = $forms->first()) {
return;
}
/* If an entity is manually defined - e.g. history table, then go on */
if (!$relatedEntity) {
if (!$relatedEntity = $form->getRelatedEntity()) {
return;
}
}
$data = [];
if ($entity) {
$data['id'] = $entity->getId();
} else {
$data['id'] = Uuid::randomHex();
}
$html = '<table class="table">';
$plain = '';
$mediaIds = [];
foreach ($forms as $form) {
$this->handleUploadedFiles($form, $salesChannelContext);
/* Values are technical here */
foreach ($form->getDataStruct()->getFlattenElements() as $flattenElement) {
$element = $form->getElements()->get($flattenElement->getElementId());
if (!$element || !$element->getEntityMapping()) {
continue;
}
if ($flattenElement->getMediaId()) {
$data[$element->getEntityMapping()] = $flattenElement->getMediaId();
} else {
if ($flattenElement->getValue() === MoorlForms::CHECKED_INDICATOR) {
$data[$element->getEntityMapping()] = true;
} else {
$data[$element->getEntityMapping()] = $flattenElement->getValue();
}
}
}
/* Values from here are readable and translated */
$html .= $form->getDataStruct()->getPrettyInline();
$plain .= $form->getDataStruct()->getPrettyInline('plain');
$mediaIds = array_merge($mediaIds, $form->getDataStruct()->getAttachmentMediaIds());
}
$html .= '</table>';
$data["customFields." . MoorlForms::CUSTOM_FIELD_HTML_KEY] = $html;
$data["customFields." . MoorlForms::CUSTOM_FIELD_PLAIN_KEY] = $plain;
$data["customFields." . MoorlForms::CUSTOM_FIELD_MEDIA_IDS_KEY] = $mediaIds;
PluginHelpers::getNestedVar($data);
$data = array_merge($data, $dataToMerge);
$relatedEntityRepository = $this->definitionInstanceRegistry->getRepository($relatedEntity);
try {
$relatedEntityRepository->upsert([$data], $salesChannelContext->getContext());
} catch (\Exception $exception) {
$this->logger->critical(sprintf("Error while writing data to %s", $relatedEntity), $data);
return;
}
if (!$entity) {
return;
}
/* Enrich data for immediately use */
foreach ($data as $key => $value) {
if ($key !== 'id' && !str_contains($key, ".")) {
$entity->__set($key, $value);
}
}
if (method_exists($entity, 'getCustomFields')) {
$customFields = array_merge($entity->getCustomFields() ?: [], $data['customFields']);
$entity->setCustomFields($customFields);
}
}
public function enrichAttachmentsFromEntity(MediaCollection $attachments, Entity $entity, Context $context): void
{
if (!method_exists($entity, 'getCustomFields')) {
return;
}
$customFields = $entity->getCustomFields();
if (!$customFields || empty($customFields[MoorlForms::CUSTOM_FIELD_MEDIA_IDS_KEY])) {
return;
}
foreach ($customFields[MoorlForms::CUSTOM_FIELD_MEDIA_IDS_KEY] as $mediaId) {
$attachments->add($this->getMedia($mediaId, $context));
}
}
}