setParameters example

        $header = new ParameterizedHeader('Content-Type', 'text/plain');
        $header->setParameters(['charset' => 'utf-8']);
        $this->assertEquals('text/plain; charset=utf-8', $header->getBodyAsString());
    }

    public function testSpaceInParamResultsInQuotedString()
    {
        $header = new ParameterizedHeader('Content-Type', 'attachment');
        $header->setParameters(['filename' => 'my file.txt']);
        $this->assertEquals('attachment; filename="my file.txt"', $header->getBodyAsString());
    }

    public function testFormDataResultsInQuotedString()
    {

public function persistNewRefreshToken(RefreshTokenEntityInterface $refreshTokenEntity): void
    {
        $this->connection->createQueryBuilder()
            ->insert('refresh_token')
            ->values([
                'id' => ':id',
                'user_id' => ':userId',
                'token_id' => ':tokenId',
                'issued_at' => ':issuedAt',
                'expires_at' => ':expiresAt',
            ])
            ->setParameters([
                'id' => Uuid::randomBytes(),
                'userId' => Uuid::fromHexToBytes($refreshTokenEntity->getAccessToken()->getUserIdentifier()),
                'tokenId' => $refreshTokenEntity->getIdentifier(),
                'issuedAt' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
                'expiresAt' => $refreshTokenEntity->getExpiryDateTime()->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ])
            ->executeStatement();

        $this->cleanUpExpiredRefreshTokens();
    }

    

    private function getAttributeMediaPositions()
    {
        $mediaPositions = [];

        // value is just the media ID         $singleSelectionColumns = $this->connection->createQueryBuilder()
            ->select(['table_name', 'column_name'])
            ->from('s_attribute_configuration')
            ->andWhere('entity = :entityName')
            ->andWhere('column_type = :columnType')
            ->setParameters([
                'entityName' => \Shopware\Models\Media\Media::class,
                'columnType' => TypeMappingInterface::TYPE_SINGLE_SELECTION,
            ])
            ->execute()
            ->fetchAll();

        foreach ($singleSelectionColumns as $attribute) {
            $mediaPositions[] = new MediaPosition($attribute['table_name'], $attribute['column_name']);
        }

        // values are separated by pipes '|'

'LOWER(HEX(`document`.`order_version_id`)) as orderVersionId',
            'LOWER(HEX(`order`.`version_id`)) as versionId',
            '`order`.`deep_link_code` as deepLinkCode',
            '`document`.`config` as config',
        ])->from('`document`', '`document`')
            ->innerJoin('`document`', '`document_type`', '`document_type`', '`document`.`document_type_id` = `document_type`.`id`')
            ->innerJoin('`document`', '`order`', '`order`', '`document`.`order_id` = `order`.`id`');

        $builder->where('`document_type`.`technical_name` = :techName')
            ->andWhere('`document`.`order_id` = :orderId');

        $builder->setParameters([
            'techName' => InvoiceRenderer::TYPE,
            'orderId' => Uuid::fromHexToBytes($orderId),
        ]);

        $builder->orderBy('`document`.`updated_at`', 'DESC');

        if (!empty($referenceDocumentId)) {
            $builder->andWhere('`document`.`id` = :documentId');
            $builder->setParameter('documentId', Uuid::fromHexToBytes($referenceDocumentId));
        }

        

$countParameters = new ArrayCollection();

        /** @var Parameter $parameter */
        foreach ($originalParameters as $parameter) {
            if ($parameter->getName() === 'userCurrencyFactor') {
                continue;
            }

            $countParameters->add($parameter);
        }

        $dataQuery->setParameters($countParameters);
        $totalCount = $this->get('models')->getQueryCount($dataQuery);
        $dataQuery->setParameters($originalParameters);

        return $totalCount;
    }

    /** * Helper to get the from date in the right format */
    private function getFromDate(): DateTime
    {
        

(float) $this->getMaxTaxRate()
        );

        $this->_tax = $positionsTaxSum ?? [];

        $parameters = Shopware()->Container()->get('events')->filter(
            'Shopware_Models_Order_Document_Filter_Parameters',
            $this->getParameters(),
            ['subject' => $this]
        );

        $this->setParameters($parameters);
    }

    /** * Get customer details * * @return void */
    public function getUser()
    {
        $customer = Shopware()->Db()->fetchRow(
            'SELECT u.*, g.id as customergroupID FROM s_user u LEFT JOIN s_core_customergroups g ON u.customergroup = g.groupkey WHERE u.id = ?',

class ScriptIdQuery implements BuilderInterface
{
    use ParametersTrait;

    /** * @param array<mixed> $parameters */
    public function __construct(
        private readonly string $id,
        array $parameters = []
    ) {
        $this->setParameters($parameters);
    }

    public function getType(): string
    {
        return 'script';
    }

    /** * {@inheritdoc} * * @return array<mixed> */

            // child.             // See also https://github.com/symfony/symfony/issues/4359             if ($childrenSynchronized) {
                $clientDataAsString = \is_scalar($form->getViewData())
                    ? (string) $form->getViewData()
                    : get_debug_type($form->getViewData());

                $failure = $form->getTransformationFailure();

                $this->context->setConstraint($formConstraint);
                $this->context->buildViolation($failure->getInvalidMessage() ?? $config->getOption('invalid_message'))
                    ->setParameters(array_replace(
                        ['{{ value }}' => $clientDataAsString],
                        $config->getOption('invalid_message_parameters'),
                        $failure->getInvalidMessageParameters()
                    ))
                    ->setInvalidValue($form->getViewData())
                    ->setCode(Form::NOT_SYNCHRONIZED_ERROR)
                    ->setCause($failure)
                    ->addViolation();
            }
        }

        

foreach ($parameters as $k => $v) {
            $this->setParameter($k, $v);
        }

        if ('content-type' !== strtolower($name)) {
            $this->encoder = new Rfc2231Encoder();
        }
    }

    public function setParameter(string $parameter, ?string $value): void
    {
        $this->setParameters(array_merge($this->getParameters(), [$parameter => $value]));
    }

    public function getParameter(string $parameter): string
    {
        return $this->getParameters()[$parameter] ?? '';
    }

    /** * @param string[] $parameters */
    public function setParameters(array $parameters): void
    {

        $file = new UploadedFile(tempnam(sys_get_temp_dir(), 'file-validator-test-'), 'originalName', 'mime', $error);

        $constraint = new File([
            $message => 'myMessage',
            'maxSize' => $maxSize,
        ]);

        $this->validator->validate($file, $constraint);

        $this->buildViolation('myMessage')
            ->setParameters($params)
            ->setCode($error)
            ->assertRaised();
    }

    public static function uploadedFileErrorProvider()
    {
        $tests = [
            [(string) \UPLOAD_ERR_FORM_SIZE, 'uploadFormSizeErrorMessage'],
            [(string) \UPLOAD_ERR_PARTIAL, 'uploadPartialErrorMessage'],
            [(string) \UPLOAD_ERR_NO_FILE, 'uploadNoFileErrorMessage'],
            [(string) \UPLOAD_ERR_NO_TMP_DIR, 'uploadNoTmpDirErrorMessage'],
            [

    public function getMasterLandingPagesAction()
    {
        $id = $this->Request()->getParam('id');
        $ownId = $this->Request()->getParam('ownId');

        $builder = $this->getRepository()->getListingQuery([], 'onlyLandingPageMasters');

        if ($id) {
            $builder->where('emotions.id = :id')
                ->setParameters(['id' => $id])
                ->setFirstResult(0)
                ->setMaxResults(1);
        }

        if ($ownId) {
            $builder->andWhere('emotions.id != :ownId')
                ->setParameter('ownId', $ownId);
        }

        $builder->andWhere('emotions.is_landingpage = 1')
            ->andWhere('emotions.parent_id IS NULL');

        

$this->validator->validate($entity1, $constraint);

        $this->assertNoViolation();

        $this->validator->validate($entity2, $constraint);

        $this->buildViolation('myMessage')
            ->atPath('property.path.name')
            ->setInvalidValue('Foo')
            ->setCode('23bd9dbf-6b9b-41cd-a99e-4844bcf3077f')
            ->setCause([$entity1])
            ->setParameters(['{{ value }}' => '"Foo"'])
            ->assertRaised();
    }

    public function testInvalidateRepositoryForInheritance()
    {
        $this->expectException(ConstraintDefinitionException::class);
        $this->expectExceptionMessage('The "Symfony\Bridge\Doctrine\Tests\Fixtures\SingleStringIdEntity" entity repository does not support the "Symfony\Bridge\Doctrine\Tests\Fixtures\Person" entity. The entity should be an instance of or extend "Symfony\Bridge\Doctrine\Tests\Fixtures\SingleStringIdEntity".');
        $constraint = new UniqueEntity([
            'message' => 'myMessage',
            'fields' => ['name'],
            'em' => self::EM_NAME,
            

    public function setParameters($parameters)
    {
        trigger_error(sprintf('%s::%s() is deprecated. Please use setParameter().', __CLASS__, __METHOD__), E_USER_DEPRECATED);

        $existingParameters = $this->getParameters();

        if (\count($existingParameters) && \is_array($parameters)) {
            return $this->addParameters($parameters);
        }

        return parent::setParameters($parameters);
    }

    /** * Temporary helper method to use instead of {@link setParameters()}, * when you really want old Doctrine parameter behavior. * * Warning: This method will be removed in Shopware 5+ and you * should only use it to quickly move backwards to the old * {@link setParameters()} behavior. * * @deprecated This method is deprecated since 5.4. and will be removed with Shopware 5.8 * * @return QueryBuilder this QueryBuilder instance */

    /** * @dataProvider provideInvalidConstraints */
    public function testThePasswordIsWeak(PasswordStrength $constraint, string $password, string $expectedMessage, string $expectedCode, array $parameters = [])
    {
        $this->validator->validate($password, $constraint);

        $this->buildViolation($expectedMessage)
            ->setCode($expectedCode)
            ->setParameters($parameters)
            ->assertRaised();
    }

    public static function provideInvalidConstraints(): iterable
    {
        yield [
            new PasswordStrength(),
            'password',
            'The password strength is too low. Please use a stronger password.',
            PasswordStrength::PASSWORD_STRENGTH_ERROR,
        ];
        

$builder->from('s_articles_details', 'details');
        $builder->innerJoin('details', 's_articles', 'product', 'details.articleID = product.id');
        $builder->innerJoin('product', 's_articles_supplier', 'supplier', 'supplier.id = product.supplierID');
        $builder->leftJoin('details', 's_articles_prices', 'default_prices',
            'details.id = default_prices.articledetailsID AND default_prices.pricegroup = :defaultCustomerGroup AND (:quantity >= default_prices.from AND (default_prices.to = :placeholderUpTo OR :quantity <= default_prices.to))');
        $builder->leftJoin('details', 's_articles_prices', 'customer_group_prices',
            'details.id = customer_group_prices.articledetailsID AND customer_group_prices.pricegroup = :customerGroup AND (:quantity >= customer_group_prices.from AND (customer_group_prices.to = :placeholderUpTo OR :quantity <= customer_group_prices.to))');
        $builder->setParameters([
            'defaultCustomerGroup' => self::DEFAULT_CUSTOMER_GROUP,
            'customerGroup' => $customerGroupKey,
            'quantity' => self::DEFAULT_PRODUCT_QUANTITY,
            'placeholderUpTo' => self::PLACEHOLDER_UP_TO,
        ]);

        foreach ($this->Request()->getParam('filter', []) as $filter) {
            if ($filter['property'] === 'free') {
                $builder->andWhere(
                    $builder->expr()->or(
                        'details.ordernumber LIKE :free',