CodeExplorer

cleanup example

    public function __construct(
        \Traversable $profilers,
        array $activeProfilers
    ) {
        $profilers = iterator_to_array($profilers);
        self::$profilers = array_intersect_key($profilers, array_flip($activeProfilers));
        self::$tags = [];

        register_shutdown_function(fn () => self::cleanup());
    }

    /** * @template TReturn of mixed * * @param \Closure(): TReturn $closure * @param array<string> $tags * * @return TReturn */
    public static function trace(string $name, \Closure $closure, string $category = 'shopware', array $tags = [])
    {

    public static function getSubscribedEvents()
    {
        return [
            'Shopware_CronJob_RegistrationCleanup' => 'cleanup',
        ];
    }

    public function cleanup()
    {
        return $this->cleanupService->cleanup();
    }
}

    public function __construct(HttpKernelInterface $kernel, StoreInterface $store, SurrogateInterface $surrogate = null, array $options = [])
    {
        $this->store = $store;
        $this->kernel = $kernel;
        $this->surrogate = $surrogate;

        // needed in case there is a fatal error because the backend is too slow to respond         register_shutdown_function($this->store->cleanup(...));

        $this->options = array_merge([
            'debug' => false,
            'default_ttl' => 0,
            'private_headers' => ['Authorization', 'Cookie'],
            'skip_response_headers' => ['Set-Cookie'],
            'allow_reload' => false,
            'allow_revalidate' => false,
            'stale_while_revalidate' => 2,
            'stale_if_error' => 60,
            'trace_level' => 'none',

public function update(): void
    {
        $this->connection->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');

        $this->lock(function D): void {
            /** @var list<array{name: string, fields: string}> $tables */
            $tables = $this->connection->fetchAllAssociative('SELECT name, fields FROM custom_entity');

            $schema = $this->connection->createSchemaManager()->introspectSchema();

            $this->cleanup($schema);

            $this->schemaUpdater->applyCustomEntities($schema, $tables);

            $this->applyNewSchema($schema);
        });
    }

    private function lock(\Closure $closure): void
    {
        $lock = $this->lockFactory->createLock('custom-entity::schema-update', 30);

return $this->changed;
    }

    /** * @param string|null $number * * @return Order */
    public function setNumber($number)
    {
        if (\is_string($number)) {
            $number = $this->cleanup($number);
        }
        $this->number = $number;

        return $this;
    }

    /** * @return string|null */
    public function getNumber()
    {

                if ($horizontal) {
                    $this->renderRow($row, $this->style->getCellRowFormat(), $this->style->getCellHeaderFormat());
                } else {
                    $this->renderRow($row, $isHeader ? $this->style->getCellHeaderFormat() : $this->style->getCellRowFormat());
                }
            }
        }
        $this->renderRowSeparator(self::SEPARATOR_BOTTOM, $this->footerTitle, $this->style->getFooterTitleFormat());

        $this->cleanup();
        $this->rendered = true;
    }

    /** * Renders horizontal header separator. * * Example: * * +-----+-----------+-------+ */
    private function renderRowSeparator(int $type = self::SEPARATOR_MID, string $title = null, string $titleFormat = null): void
    {

    public static function getSubscribedEvents()
    {
        return [
            'Shopware_CronJob_OptinCleanup' => 'cleanup',
        ];
    }

    public function cleanup()
    {
        return $this->cleanupService->cleanup();
    }
}

$nonce = 'plugin-upload';
        $url   = add_query_arg( array( 'package' => $file_upload->id ), 'update.php?action=upload-plugin' );
        $type  = 'upload'; // Install plugin type, From Web or an Upload.
        $overwrite = isset( $_GET['overwrite'] ) ? sanitize_text_field( $_GET['overwrite'] ) : '';
        $overwrite = in_array( $overwrite, array( 'update-plugin', 'downgrade-plugin' ), true ) ? $overwrite : '';

        $upgrader = new Plugin_Upgrader( new Plugin_Installer_Skin( compact( 'type', 'title', 'nonce', 'url', 'overwrite' ) ) );
        $result   = $upgrader->install( $file_upload->package, array( 'overwrite_package' => $overwrite ) );

        if ( $result || is_wp_error( $result ) ) {
            $file_upload->cleanup();
        }

        require_once ABSPATH . 'wp-admin/admin-footer.php';

    } elseif ( 'upload-plugin-cancel-overwrite' === $action ) {
        if ( ! current_user_can( 'upload_plugins' ) ) {
            wp_die( __( 'Sorry, you are not allowed to install plugins on this site.' ) );
        }

        check_admin_referer( 'plugin-upload-cancel-overwrite' );

/** * @internal * * @package system-settings */
class SnippetServiceTest extends TestCase
{
    use IntegrationTestBehaviour;

    protected function tearDown(): void
    {
        MockSnippetFile::cleanup();
    }

    public function testGetStorefrontSnippetsForNotExistingSnippetSet(): void
    {
        $this->expectException(\InvalidArgumentException::class);

        $service = $this->getSnippetService();

        $service->getStorefrontSnippets($this->getCatalog([], 'en-GB'), Uuid::randomHex());
    }

$this->locallySkippedLineNumbers = [];
            $this->totalNumberOfLines = null;
        }

        return $data;
    }

    private function doParse(string $value, int $flags): mixed
    {
        $this->currentLineNb = -1;
        $this->currentLine = '';
        $value = $this->cleanup($value);
        $this->lines = explode("\n", $value);
        $this->numberOfParsedLines = \count($this->lines);
        $this->locallySkippedLineNumbers = [];
        $this->totalNumberOfLines ??= $this->numberOfParsedLines;

        if (!$this->moveToNextLine()) {
            return null;
        }

        $data = [];
        $context = null;

    /** * Setter function for the company column property * * @param string $company * * @return Shipping */
    public function setCompany($company)
    {
        $this->company = $this->cleanup($company);

        return $this;
    }

    /** * Getter function for the company column property. * * @return string */
    public function getCompany()
    {

'currentShopwareVersion' => $currentShopwareVersion,
            'isFlexProject' => $this->recoveryManager->isFlexProject($shopwarePath),
            'versions' => $latestVersions,
        ]);
    }

    #[Route('/update/_migrate-template', name: 'migrate-template', methods: ['POST'])]     public function migrateTemplate(): Response
    {
        $shopwarePath = $this->recoveryManager->getShopwareLocation();

        $this->flexMigrator->cleanup($shopwarePath);
        $this->flexMigrator->patchRootComposerJson($shopwarePath);
        $this->flexMigrator->copyNewTemplateFiles($shopwarePath);
        $this->flexMigrator->migrateEnvFile($shopwarePath);

        return new Response('', Response::HTTP_NO_CONTENT);
    }

    #[Route('/update/_run', name: 'update_run', methods: ['POST'])]     public function run(Request $request): Response
    {
        $version = $request->query->get('shopwareVersion', '');

if ($backlog['entity'] === Article::class) {
                $this->indexArticle($backlog['entity_id']);
            } else {
                $index = $this->getIndexName($repository->getDomainName());
                $indexer->indexEntities($index, $repository, [$backlog['entity_id']]);
            }
        }

        $ids = array_column($backlogs, 'id');

        $backlogService->cleanup($ids);

        return 0;
    }

    private function indexArticle($id)
    {
        $query = $this->container->get(\Doctrine\DBAL\Connection::class)->createQueryBuilder();
        $query = $query
            ->select(['products.id', 'products.ordernumber'])
            ->from('s_articles_details', 'products')
            ->andWhere('products.id > :lastId')