generate example

/** * {@inheritdoc} */
  public static function getLabel() {
    return t("Account's permissions");
  }

  /** * {@inheritdoc} */
  public function getContext() {
    return $this->permissionsHashGenerator->generate($this->user);
  }

  /** * {@inheritdoc} */
  public function getCacheableMetadata() {
    $cacheable_metadata = new CacheableMetadata();

    // The permissions hash changes when:     // - a user is updated to have different roles;     $tags = ['user:' . $this->user->id()];
    

parent::setUp();
    $this->fileUrlGenerator = $this->container->get('file_url_generator');
  }

  /** * Tests missing stream handler. * * @covers ::generate */
  public function testGenerateMissingStreamWrapper() {
    $this->expectException(InvalidStreamWrapperException::class);
    $result = $this->fileUrlGenerator->generate("foo://bar");
  }

  /** * Tests missing stream handler. * * @covers ::generateString */
  public function testGenerateStringMissingStreamWrapper() {
    $this->expectException(InvalidStreamWrapperException::class);
    $result = $this->fileUrlGenerator->generateString("foo://bar");
  }

  

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $validatorURL = $input->getArgument('validatorUrl');
        $apiType = match ($input->getOption('api-type')) {
            DefinitionService::API => DefinitionService::API,
            DefinitionService::STORE_API => DefinitionService::STORE_API,
            default => throw new \InvalidArgumentException('Invalid --api-type, must be one of "api" or "store-api"'),
        };

        $schema = $this->definitionService->generate(
            OpenApi3Generator::FORMAT,
            $apiType,
        );

        $response = $this->client->request('POST', $validatorURL, [
            'json' => $schema,
            'headers' => [
                'Accept' => 'application/json',
            ],
        ]);
        $content = $response->toArray();

        

        $criteria = new Criteria();
        $criteria->addFilter(new EqualsFilter('technicalName', DeliveryNoteRenderer::TYPE));

        $operation = new DocumentGenerateOperation(
            $orderId,
            FileTypes::PDF,
            ['documentNumber' => '1001', 'displayInCustomerAccount' => $showInCustomerAccount],
        );

        $document = $this->getContainer()->get(DocumentGenerator::class)
            ->generate(DeliveryNoteRenderer::TYPE, [$orderId => $operation], Context::createDefaultContext())->getSuccess()->first();

        static::assertNotNull($document);

        $this->getContainer()->get('document.repository')->update([
            [
                'id' => $document->getId(),
                'sent' => $sent,
            ],
        ], Context::createDefaultContext());
    }

    

    }

    public function testGenerateReplace(): void
    {
        $productId = Uuid::randomHex();
        $host = 'http://foo.text';
        $template = 'Test content with url %s.';

        $salesChannelContext = $this->createStorefrontSalesChannelContext(Uuid::randomHex(), 'test storefront');

        $generated = $this->seoUrlPlaceholderHandler->generate('frontend.detail.page', ['productId' => $productId]);

        $content = sprintf($template, $generated);
        $actual = $this->seoUrlPlaceholderHandler->replace($content, $host, $salesChannelContext);

        $expectedUrl = $host . '/detail/' . $productId;
        $expected = sprintf($template, $expectedUrl);
        static::assertSame($expected, $actual);
    }

    public function testGenerateReplaceWithPrefixPath(): void
    {
        

$orderRepository->upsert([$order], $context);

        return $orderId;
    }

    private function createDocumentWithFile(string $orderId, Context $context, string $documentType = InvoiceRenderer::TYPE): string
    {
        $documentGenerator = $this->getContainer()->get(DocumentGenerator::class);

        $operation = new DocumentGenerateOperation($orderId, FileTypes::PDF, []);
        /** @var DocumentEntity $document */
        $document = $documentGenerator->generate($documentType, [$orderId => $operation], $context)->getSuccess()->first();

        static::assertNotNull($document);

        return $document->getId();
    }

    private static function getDocIdByType(string $documentType): ?string
    {
        $document = KernelLifecycleManager::getConnection()->fetchFirstColumn(
            'SELECT LOWER(HEX(`id`)) FROM `document_type` WHERE `technical_name` = :documentType',
            [
                

private function runExport(
        ProductExportEntity $productExport,
        int $offset,
        Context $context
    ): ?ProductExportResult {
        $this->productExportRepository->update([[
            'id' => $productExport->getId(),
            'isRunning' => true,
        ]], $context);

        return $this->productExportGenerator->generate(
            $productExport,
            new ExportBehavior(
                false,
                false,
                true,
                false,
                false,
                $offset
            )
        );
    }

    

$this->eventDispatcherMock->expects(static::once())->method('dispatch')->with(static::callback(static function DAttachmentLoaderCriteriaEvent $event) {
            $criteria = $event->getCriteria();

            return $criteria->hasAssociation('documentMediaFile') && $criteria->hasAssociation('documentType');
        }));

        $cart = $this->generateDemoCart(2);
        $orderId = $this->persistCart($cart);

        $operation = new DocumentGenerateOperation($orderId);

        $document = $this->documentGenerator->generate(InvoiceRenderer::TYPE, [$orderId => $operation], $this->context)->getSuccess()->first();

        static::assertNotNull($document);

        $attachments = $this->attachmentLoader->load([$document->getId()], Context::createDefaultContext());
        static::assertCount(1, $attachments);
        static::assertIsArray($attachments[0]);
        static::assertArrayHasKey('content', $attachments[0]);

        $criteria = new Criteria([$document->getId()]);
        $criteria->addAssociation('documentMediaFile');

        

  protected function _doCreateFromStorageRecord(array $values, $is_syncing = FALSE) {
    // Assign a new UUID if there is none yet.     if ($this->uuidKey && $this->uuidService && !isset($values[$this->uuidKey])) {
      $values[$this->uuidKey] = $this->uuidService->generate();
    }
    $data = $this->mapFromStorageRecords([$values]);
    /** @var \Drupal\Core\Config\Entity\ConfigEntityInterface $entity */
    $entity = current($data);
    $entity->original = clone $entity;
    $entity->setSyncing($is_syncing);
    $entity->enforceIsNew();
    $entity->postCreate($this);

    // Modules might need to add or change the data initially held by the new     // entity object, for instance to fill-in default values.

    private function createDocuments(string $orderId, array $documentTypes, Context $context): DocumentIdCollection
    {
        $operations = [];

        $collection = new DocumentIdCollection();

        foreach ($documentTypes as $documentType => $config) {
            $operation = new DocumentGenerateOperation($orderId, FileTypes::PDF, $config);
            $operations[$orderId] = $operation;

            $result = $this->documentGenerator->generate($documentType, $operations, $context)->getSuccess()->first();

            static::assertNotNull($result);
            $collection->add($result);
        }

        return $collection;
    }
}

    }

    /** * Regenerate sitemap cache */
    public function buildSitemapCacheAction()
    {
        $shops = $this->getModelManager()->getRepository(Shop::class)->getActiveShopsFixed();

        foreach ($shops as $shop) {
            $this->container->get(SitemapExporter::class)->generate($shop);
        }

        $this->View()->assign('success', true);
    }

    protected function initAcl()
    {
    }

    /** * Reads all config data and prepares it for our models * * @return array */

'system',
  ];

  /** * Runs test methods for each module within a single test run. */
  public function testConfigUpdateImport() {
    $this->installConfig(['action', 'block', 'filter', 'image']);
    $this->container->get('theme_installer')->install(['olivero']);
    $config_storage = $this->container->get('config.storage');
    // Ensure the 'system.site' config.     $config_storage->write('system.site', ['uuid' => (new Php())->generate()]);
    $this->copyConfig($config_storage, $this->container->get('config.storage.sync'));

    $this->doActionUpdate();
    $this->doBlockUpdate();
    $this->doFilterFormatUpdate();
    $this->doImageStyleUpdate();
    $this->doSearchPageUpdate();
    $this->doThirdPartySettingsUpdate();
  }

  /** * Tests updating an action during import. */

    public function onKernelResponse(ResponseEvent $event): void
    {
        $response = $event->getResponse();
        $request = $event->getRequest();

        if ($response->headers->has('X-Debug-Token') && null !== $this->urlGenerator) {
            try {
                $response->headers->set(
                    'X-Debug-Token-Link',
                    $this->urlGenerator->generate('_profiler', ['token' => $response->headers->get('X-Debug-Token')], UrlGeneratorInterface::ABSOLUTE_URL)
                );
            } catch (\Exception $e) {
                $response->headers->set('X-Debug-Error', $e::class.': '.preg_replace('/\s+/', ' ', $e->getMessage()));
            }
        }

        if (!$event->isMainRequest()) {
            return;
        }

        $nonces = [];
        

if (!$event->getThrowable() instanceof CustomerNotLoggedInException) {
            return;
        }

        $request = $event->getRequest();

        $parameters = [
            'redirectTo' => $request->attributes->get('_route'),
            'redirectParameters' => json_encode($request->attributes->get('_route_params'), \JSON_THROW_ON_ERROR),
        ];

        $redirectResponse = new RedirectResponse($this->router->generate('frontend.account.login.page', $parameters));

        $event->setResponse($redirectResponse);
    }

    public function maintenanceResolver(RequestEvent $event): void
    {
        if ($this->maintenanceModeResolver->shouldRedirect($event->getRequest())) {
            $event->setResponse(
                new RedirectResponse(
                    $this->router->generate('frontend.maintenance.page'),
                    RedirectResponse::HTTP_TEMPORARY_REDIRECT
                )

try {
                $this->tokenStorage->setToken($this->attemptSwitchUser($request, $username));
            } catch (AuthenticationException $e) {
                // Generate 403 in any conditions to prevent user enumeration vulnerabilities                 throw new AccessDeniedException('Switch User failed: '.$e->getMessage(), $e);
            }
        }

        if (!$this->stateless) {
            $request->query->remove($this->usernameParameter);
            $request->server->set('QUERY_STRING', http_build_query($request->query->all(), '', '&'));
            $response = new RedirectResponse($this->urlGenerator && $this->targetRoute ? $this->urlGenerator->generate($this->targetRoute) : $request->getUri(), 302);

            $event->setResponse($response);
        }
    }

    /** * Attempts to switch to another user and returns the new token if successfully switched. * * @throws \LogicException * @throws AccessDeniedException */