advance example

'INSERT INTO s_customer_streams_mapping (stream_id, customer_id) VALUES (:streamId, :customerId)'
            );

            while ($customers->getCustomers()) {
                foreach ($customers->getIds() as $customerId) {
                    $insert->execute([
                        ':streamId' => $streamId,
                        ':customerId' => $customerId,
                    ]);
                }

                $helper->advance((int) $criteria->getLimit());
                $criteria->offset($criteria->getOffset() + $criteria->getLimit());
                $customers = $this->numberSearch->search($criteria);
            }

            $helper->finish();
        });
    }

    /** * @param int $streamId * * @return CustomerNumberSearchResult */

public function progressStart(int $max = 0)
    {
        $this->progressBar = $this->createProgressBar($max);
        $this->progressBar->start();
    }

    /** * @return void */
    public function progressAdvance(int $step = 1)
    {
        $this->getProgressBar()->advance($step);
    }

    /** * @return void */
    public function progressFinish()
    {
        $this->getProgressBar()->finish();
        $this->newLine(2);
        unset($this->progressBar);
    }

    

private function setVisibility(FilesystemOperator $filesystem, ShopwareStyle $style, string $visibility): void
    {
        $files = array_filter($filesystem->listContents('/', true)->toArray(), fn (StorageAttributes $object): bool => $object->type() === 'file');
        ProgressBar::setFormatDefinition('custom', '[%bar%] %current%/%max% -- %message%');
        $progressBar = new ProgressBar($style, \count((array) $files));
        $progressBar->setFormat('custom');
        $progressBar->setMessage('');

        foreach ($files as $file) {
            $filesystem->setVisibility($file->path(), $visibility);

            $progressBar->advance();
            $progressBar->setMessage($file->path());
        }

        $progressBar->finish();
    }
}

$this->progress = $this->io->createProgressBar($event->getTotal());
        $this->progress->setFormat("<info>[%message%]</info>\n%current%/%max% [%bar%] %percent:3s%% %elapsed:6s%/%estimated:-6s% %memory:6s%");
        $this->progress->setMessage($event->getMessage());
    }

    public function advanceProgress(ProgressAdvancedEvent $event): void
    {
        if (!$this->progress) {
            return;
        }

        $this->progress->advance($event->getStep());
    }

    public function finishProgress(ProgressFinishedEvent $event): void
    {
        if (!$this->io) {
            return;
        }

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

        

$progressBar->start();

            // Warm URL-List             while ($offset < $totalResultCount) {
                $sliceUrls = \array_slice($urls, $offset, $limit, true);
                $cacheWarmer->warmUpUrls($sliceUrls, $context, $concurrentRequests);

                $sliceCount = \count($sliceUrls);
                if ($sliceCount === 0) {
                    break;
                }
                $progressBar->advance($sliceCount);
                $offset += $sliceCount;
            }
            $progressBar->finish();
            $io->newLine();
        }
        $io->newLine();
        $io->success('The HttpCache is now warmed up');

        return 0;
    }

    

$value['shipping_method_id'] = Uuid::fromHexToBytes($value['shipping_method_id']);
            $value['payment_method_id'] = Uuid::fromHexToBytes($value['payment_method_id']);
            $value['country_id'] = Uuid::fromHexToBytes($value['country_id']);
            $value['sales_channel_id'] = Uuid::fromHexToBytes($value['sales_channel_id']);

            $queue->addInsert('cart', $value);

            if ($index % 50 === 0) {
                $queue->execute();
            }

            $this->progress->advance();
        }

        $queue->execute();

        $this->progress->finish();

        $this->io->success('Migration from Redis to SQL was successful');

        $this->io->newLine(2);

        return self::SUCCESS;
    }

foreach ($contents as $item) {
            if ($item['type'] === 'dir') {
                $this->optimizeFiles($item['path'], $input, $mediaService, $optimizerService, $progressBar, $output);
                continue;
            }

            if ($item['type'] === 'file') {
                if ($input->getOption('modified')) {
                    $modifiedDateTime = new DateTime($input->getOption('modified'));

                    if ($modifiedDateTime->getTimestamp() > $item['timestamp']) {
                        $progressBar->advance();
                        continue;
                    }
                }

                if (strpos($item['basename'], '.') === 0) {
                    $progressBar->advance();
                    continue;
                }

                $progressBar->setMessage($item['path'], 'filename');

                

$iterableResult = $query->toIterable();

        $progressBar = $io->createProgressBar($count);

        try {
            foreach ($iterableResult as $key => $media) {
                $em->remove($media);
                if ($key % 100 === 0) {
                    $em->flush();
                    $em->clear();
                }
                $progressBar->advance();
            }
            $em->flush();
            $em->clear();
        } catch (ORMException $e) {
            $count = 0;
        }

        $progressBar->finish();
        $io->newLine(2);

        return $count;
    }

$progressBar->start();

        do {
            $selectStatement->execute([':lastId' => $lastId, ':maxId' => $maxId]);
            $rows = $selectStatement->fetchAll(PDO::FETCH_ASSOC);

            if (empty($rows)) {
                continue;
            }

            $this->migrateTranslations($rows);
            $progressBar->advance(\count($rows));

            $lastId = array_pop($rows)['id'];
        } while (!empty($rows));

        $progressBar->finish();
    }

    /** * @return string[] */
    private function getColumns()
    {

foreach ($contents as $item) {
            if ($item['type'] === 'dir') {
                $this->processFilesIn($item['path'], $filesystem, $progressBar);
            }

            if ($item['type'] === 'file') {
                if (str_starts_with($item['basename'], '.')) {
                    continue;
                }

                $this->indexFile($item['path']);
                $progressBar->advance();
            }
        }
    }

    private function indexFile(string $file): void
    {
        $baseName = pathinfo($file, PATHINFO_FILENAME);
        $fileName = pathinfo($file, PATHINFO_BASENAME);

        // check if the filename matches thumbnail syntax like "*_200x200" or "*_200x200@2x"         if (preg_match('/(_[0-9]+x[0-9]+(@2x)?)$/', $baseName)) {
            

    private function populateEntity(string $index, EsAwareRepository $repository, ProgressHelperInterface $progress): void
    {
        $iterator = $repository->getIterator();

        $progress->start($iterator->fetchCount(), 'Start indexing: ' . $repository->getDomainName());

        while ($ids = $iterator->fetch()) {
            $this->indexEntities($index, $repository, $ids);

            $progress->advance(\count($ids));
        }

        $this->client->indices()->refresh(['index' => $index]);

        $progress->finish();
        $this->evaluation->finish();
    }

    private function createAlias(string $index, string $alias): void
    {
        $exist = $this->client->indices()->existsAlias(['name' => $alias]);

        

$this->progress->setFormat('very_verbose');
    }

    /** * {@inheritdoc} */
    public function advance($step = 1)
    {
        if ($this->current + $step > $this->count) {
            $step = $this->count - $this->current;
        }
        $this->progress->advance($step);
        $this->current += $step;
    }

    /** * {@inheritdoc} */
    public function finish()
    {
        $this->progress->finish();
        $this->output->writeln('');
    }
}

$finder = new Finder();

        // Find all files in Administration/Resources/app/administration/src/module except for de-DE.json and en-GB.json         $finder->in($adminDir . '/Resources/app/administration/src/module')
            ->notName('de-DE.json')
            ->notName('en-GB.json')
            ->files();

        foreach ($finder as $file) {
            unlink($file->getRealPath());
        }
        $progressBar->advance(25);

        $this->deleteEmptyDirectories($adminDir . '/Resources/app/administration/src/module');
        $progressBar->advance(25);

        // Find all the following directories and files and delete them         $this->removeDirectory($adminDir . '/Resources/app/administration/src/app/adapter');
        $this->removeDirectory($adminDir . '/Resources/app/administration/src/app/assets');
        $this->removeDirectory($adminDir . '/Resources/app/administration/src/app/asyncComponent');
        $this->removeDirectory($adminDir . '/Resources/app/administration/src/app/component');
        $this->removeDirectory($adminDir . '/Resources/app/administration/src/app/decorator');
        $this->removeDirectory($adminDir . '/Resources/app/administration/src/app/directive');
        

$progress->start($idQuery->fetchCount(), 'Indexing products');

        while ($ids = $idQuery->fetch()) {
            if (!$this->variantHelper->getVariantFacet()) {
                $query = $this->queryFactory->createProductIdQuery($ids);
                $numbers = $query->fetch();
            } else {
                $numbers = $ids;
            }

            $this->indexProducts($index, $numbers);
            $progress->advance(\count(array_unique($ids)));
        }
        $progress->finish();
    }

    /** * {@inheritdoc} */
    public function supports()
    {
        return ProductMapping::TYPE;
    }

    

$this->provider = $provider;
        $this->queryFactory = $queryFactory;
    }

    public function populate(ShopIndex $index, ProgressHelperInterface $progress)
    {
        $query = $this->queryFactory->createQuery(100);
        $progress->start($query->fetchCount(), 'Indexing properties');

        while ($ids = $query->fetch()) {
            $this->indexProperties($index, $ids);
            $progress->advance(\count($ids));
        }
        $progress->finish();
    }

    /** * @param int[] $groupIds */
    public function indexProperties(ShopIndex $index, $groupIds)
    {
        if (empty($groupIds)) {
            return;
        }