@param \Generated\Shared\Transfer\BrandTransfer $brandTransfer

@return \Orm\Zed\Brand\Persistence\FosBrand
339324
protected function createFosBrandEntity(BrandTransfer $brandTransfer): FosBrand
    {
        $brandEntity = new FosBrand();
        $brandEntity->fromArray($brandTransfer->toArray());

        return $brandEntity;
    }
868281
public function expandWithProductListCustomerRelationTransfer(ProductListTransfer $productListTransfer): ProductListTransfer
    {
        $productListCustomerRelationTransfer = new ProductListCustomerRelationTransfer();

        $productListCustomerRelationTransfer->setIdProductList($productListTransfer->getIdProductList());

        $productListCustomerRelationTransfer = $this->productListCustomerRelationReader
            ->getProductListCustomerRelation($productListCustomerRelationTransfer);

        $productListTransfer->setProductListCustomerRelation($productListCustomerRelationTransfer);

        return $productListTransfer;
    }
266895
public function setParamTransformer(\chilimatic\lib\interfaces\IFlyWeightTransformer $paramTransformer)
    {
        $this->paramTransformer = $paramTransformer;

        return $this;
    }
710988
private function init($sTranslationDir, $sTemplateDir)
    {
        /*
         * Parameters
         */
        // Translation directory
        $this->coreContainer['jaxon.core.translation_dir'] = $sTranslationDir;
        // Template directory
        $this->coreContainer['jaxon.core.template_dir'] = $sTemplateDir;

        /*
         * Core library objects
         */
        // Jaxon Core
        $this->coreContainer[Jaxon::class] = function () {
            return new Jaxon();
        };
        // Global Response
        $this->coreContainer[Response::class] = function () {
            return new Response();
        };
        // Dialog
        $this->coreContainer[Dialog::class] = function () {
            return new Dialog();
        };

        /*
         * Managers
         */
        // Callable objects repository
        $this->coreContainer[CallableRepository::class] = function () {
            return new CallableRepository();
        };
        // Plugin Manager
        $this->coreContainer[PluginManager::class] = function () {
            return new PluginManager();
        };
        // Request Handler
        $this->coreContainer[RequestHandler::class] = function ($c) {
            return new RequestHandler($c[PluginManager::class]);
        };
        // Request Factory
        $this->coreContainer[RequestFactory::class] = function ($c) {
            return new RequestFactory($c[CallableRepository::class]);
        };
        // Response Manager
        $this->coreContainer[ResponseManager::class] = function () {
            return new ResponseManager();
        };
        // Code Generator
        $this->coreContainer[CodeGenerator::class] = function ($c) {
            return new CodeGenerator($c[PluginManager::class]);
        };

        /*
         * Config
         */
        $this->coreContainer[Config::class] = function () {
            return new Config();
        };
        $this->coreContainer[ConfigReader::class] = function () {
            return new ConfigReader();
        };

        /*
         * Services
         */
        // Minifier
        $this->coreContainer[Minifier::class] = function () {
            return new Minifier();
        };
        // Translator
        $this->coreContainer[Translator::class] = function ($c) {
            return new Translator($c['jaxon.core.translation_dir'], $c[Config::class]);
        };
        // Template engine
        $this->coreContainer[Template::class] = function ($c) {
            return new Template($c['jaxon.core.template_dir']);
        };
        // Validator
        $this->coreContainer[Validator::class] = function ($c) {
            return new Validator($c[Translator::class], $c[Config::class]);
        };
        // Pagination Renderer
        $this->coreContainer[PaginationRenderer::class] = function ($c) {
            return new PaginationRenderer($c[Template::class]);
        };
        // Pagination Paginator
        $this->coreContainer[Paginator::class] = function ($c) {
            return new Paginator($c[PaginationRenderer::class]);
        };
        // Event Dispatcher
        $this->coreContainer[EventDispatcher::class] = function () {
            return new EventDispatcher();
        };

        // View Renderer Facade
        // $this->coreContainer[\Jaxon\Sentry\View\Facade::class] = function ($c) {
        //     $aRenderers = $c['jaxon.view.data.renderers'];
        //     $sDefaultNamespace = $c['jaxon.view.data.namespace.default'];
        //     return new \Jaxon\Sentry\View\Facade($aRenderers, $sDefaultNamespace);
        // };
    }
1183292
public function findBrandByName(string $name): ?BrandTransfer
    {
        $spyBrand = $this->getFactory()
            ->createBrandQuery()
            ->filterByName($name)
            ->findOne();

        if ($spyBrand === null) {
            return null;
        }

        $brand = (new BrandTransfer())->fromArray(
            $spyBrand->toArray(),
            true
        );

        return $brand;
    }
714546
public function import(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createMerchantDataImport()->import($dataImporterConfigurationTransfer);
    }
692346
public function add(TypeConverterInterface $converter)
    {
        if ($this->has($converter->getTypeNamespace(), $converter->getTypeName())) {
            throw new \InvalidArgumentException(
                'Converter for this type already exists'
            );
        }

        return $this->set($converter);
    }
792764
public function getBrandCollection(BrandCollectionTransfer $brandCollectionTransfer): BrandCollectionTransfer
    {
        $brandCollectionTransfer = $this->brandRepository->getBrandCollection($brandCollectionTransfer);

        if (!empty($brandCollectionTransfer->getBrands())) {
            foreach ($brandCollectionTransfer->getBrands() as $brandTransfer) {
                $this->brandExpander->expand($brandTransfer);
            }
        }

        return $brandCollectionTransfer;
    }
801100
public function getBrandsByProductAbstractId(int $idProductAbstract): BrandCollectionTransfer
    {
        $productAbstractTransfer = new ProductAbstractTransfer();
        $productAbstractTransfer->setIdProductAbstract($idProductAbstract);

        return $this->getFactory()
            ->createBrandReader()
            ->getBrandCollectionByIdProductAbstractId($productAbstractTransfer);
    }
19723
public function converter(callable $converter, string ...$types): BuilderInterface
    {
        $this->resolver->converter($converter, ...$types);

        return $this;
    }
672034
public function importAddressLabelRelation(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createCompanyUnitAddressLabelRelationDataImport()->import($dataImporterConfigurationTransfer);
    }
229447
public function importProductPackagingUnitTypes(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createProductPackagingUnitTypeDataImport()->import($dataImporterConfigurationTransfer);
    }
416685
public function getProductListCollectionByIdCustomerId(
        CustomerTransfer $customerTransfer
    ): ProductListCollectionTransfer {
        $customerTransfer->requireIdCustomer();

        return $this->productListCustomerRepository
            ->getProductListCollectionByIdCustomer($customerTransfer->getIdCustomer());
    }
1085695
public function getFile(PayoneGetFileTransfer $getFileTransfer)
    {
        $responseContainer = new GetFileResponseContainer();
        $paymentEntity = $this->findPaymentByFileReferenceAndCustomerId(
            $getFileTransfer->getReference(),
            $getFileTransfer->getCustomerId()
        );

        if ($paymentEntity) {
            /** @var \SprykerEco\Zed\Payone\Business\Payment\MethodMapper\DirectDebit $paymentMethodMapper */
            $paymentMethodMapper = $this->getRegisteredPaymentMethodMapper(PayoneApiConstants::PAYMENT_METHOD_DIRECT_DEBIT);
            $requestContainer = $paymentMethodMapper->mapGetFile($getFileTransfer);
            $this->setStandardParameter($requestContainer);
            $rawResponse = $this->executionAdapter->sendRequest($requestContainer);
            $responseContainer->init($rawResponse);
        } else {
            $this->setAccessDeniedError($responseContainer);
        }

        $getFileTransfer->setRawResponse($responseContainer->getRawResponse());
        $getFileTransfer->setStatus($responseContainer->getStatus());
        $getFileTransfer->setErrorCode($responseContainer->getErrorcode());
        $getFileTransfer->setCustomerErrorMessage($responseContainer->getCustomermessage());
        $getFileTransfer->setInternalErrorMessage($responseContainer->getErrormessage());

        return $getFileTransfer;
    }
780100
protected function createMessage(QueueSendMessageTransfer $messageTransfer)
    {
        $message = new AMQPMessage($messageTransfer->getBody(), $this->config->getMessageConfig());
        $headers = $messageTransfer->getHeaders();

        if ($headers !== null) {
            $headersTable = new AMQPTable($headers);
            $message->set('application_headers', $headersTable);
        }

        return $message;
    }
950405
public function import(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createCompanyUnitAddressLabelDataImport()->import($dataImporterConfigurationTransfer);
    }
435840
public function getActiveBrands(): BrandCollectionTransfer
    {
        $query = $this->getFactory()
            ->createBrandQuery()
            ->filterByIsActive(true);

        $brandEntityCollectionTransfer = $this->buildQueryFromCriteria($query)->find();

        return $this->getFactory()->createBrandMapper()->mapCollectionTransfer($brandEntityCollectionTransfer);
    }