getPlugins example

if (!\is_string($version)) {
                throw new RuntimeException('Parameter shopware.release.version has to be an string');
            }
        }

        $plugins = $this->container->get(\Shopware\Bundle\PluginInstallerBundle\Service\PluginLocalService::class)->getPluginsForUpdateCheck();
        $domain = $this->container->get('shopware_plugininstaller.account_manager_service')->getDomain();
        $service = $this->container->get('shopware_plugininstaller.plugin_service_view');
        $request = new UpdateListingRequest('', $version, $domain, $plugins);
        /** @var UpdateResultStruct $updates */
        $updates = $service->getUpdates($request);
        $plugins = $updates->getPlugins();

        $result = [];
        foreach ($plugins as $plugin) {
            $result[] = [
                $plugin->getId(),
                $plugin->getTechnicalName(),
                $plugin->getLabel(),
                $plugin->getVersion(),
                $plugin->getAvailableVersion(),
            ];
        }

        

    public function checkInstalledPluginsAvailableForNewVersion($version)
    {
        $service = $this->container->get(PluginStoreService::class);
        $installedPlugins = $this->getUserInstalledPlugins();
        $technicalNames = array_column($installedPlugins, 'name');
        $locale = $this->getLocale();

        $shopwareVersion = $this->container->getParameter('shopware.release.version');

        $request = new PluginsByTechnicalNameRequest($locale, $shopwareVersion, $technicalNames);
        $storePlugins = $service->getPlugins($request);

        $request = new PluginsByTechnicalNameRequest($locale, $version, $technicalNames);
        $updatesAvailable = $service->getPlugins($request);

        try {
            $results = [];
            foreach ($installedPlugins as $plugin) {
                $technicalName = $plugin['name'];
                $key = strtolower($plugin['name']);
                $name = $plugin['label'];

                

$container
            ->reset('plugins')
            ->reset('front')
            ->reset('router')
            ->reset('system')
            ->reset('modules')
            ->reset(ConditionalLineItemServiceInterface::class);

        $container->load('front');
        $container->load('plugins');

        foreach ($container->get('kernel')->getPlugins() as $plugin) {
            if (!$plugin->isActive()) {
                continue;
            }
            $container->get('events')->addSubscriber($plugin);
        }
        if ($container->initialized('shop')) {
            $container->get(ShopRegistrationServiceInterface::class)->resetTemplate($container->get('shop'));
        }
    }

    /** * Reset the request object * * @return Enlight_Components_Test_Controller_TestCase */

$em = $this->kernel->getContainer()->get(ModelManager::class);

                // Setup doctrine commands                 $helperSet = $this->getHelperSet();
                $helperSet->set(new EntityManagerHelper($em), 'em');
                $helperSet->set(new ConnectionHelper($em->getConnection()), 'db');

                DoctrineConsoleRunner::addCommands($this);

                $this->registerEventCommands();

                foreach ($this->kernel->getPlugins() as $plugin) {
                    if ($plugin->isActive()) {
                        $plugin->registerCommands($this);
                    }
                }
            } catch (Exception $e) {
                $formatter = $this->getHelperSet()->get('formatter');
                $output->writeln($formatter->formatBlock('WARNING! ' . $e->getMessage() . ' in ' . $e->getFile(), 'error'));
            }
        }
    }

    

protected function execute(InputInterface $input, OutputInterface $output)
    {
        $shopwareVersion = $this->container->getParameter('shopware.release.version');
        if (!\is_string($shopwareVersion)) {
            throw new RuntimeException('Parameter shopware.release.version has to be an string');
        }

        $context = new ListingRequest('', $shopwareVersion, 0, 1000, [['property' => 'dummy', 'value' => 1]], []);
        $listing = $this->container->get('shopware_plugininstaller.plugin_service_view')->getStoreListing($context);

        $result = [];
        foreach ($listing->getPlugins() as $plugin) {
            $result[] = [
                'id' => $plugin->getId(),
                'technicalName' => $plugin->getTechnicalName(),
                'label' => $plugin->getLabel(),
                'installed' => ($plugin->getInstallationDate() !== null),
                'version' => $plugin->getVersion(),
                'updateAvailable' => $plugin->isUpdateAvailable(),
            ];
        }

        $table = new Table($output);
        

try {
            $listingResult = $this->get('shopware_plugininstaller.plugin_service_view')->getStoreListing($context);
        } catch (Exception $e) {
            $this->handleException($e);

            return;
        }

        $this->View()->assign([
            'success' => true,
            'data' => array_values($listingResult->getPlugins()),
            'total' => $listingResult->getTotalCount(),
        ]);
    }

    /** * @return void */
    public function refreshPluginListAction()
    {
        $pluginManager = $this->get(InstallerService::class);
        $pluginManager->refreshPluginList();
        

return $this->getAdditionallyLocalData($plugins);
    }

    /** * @param PluginStruct[] $plugins * * @return PluginStruct[] */
    private function getAdditionallyLocalData(array $plugins): array
    {
        $context = new PluginsByTechnicalNameRequest('', '', array_keys($plugins));
        $local = $this->localPluginService->getPlugins($context);

        $merged = [];

        foreach ($plugins as &$plugin) {
            $key = strtolower($plugin->getTechnicalName());

            if (!\array_key_exists($key, $local)) {
                $merged[$key] = $plugin;
                continue;
            }

            

return new ListingResultStruct(
            $plugins,
            $data['total']
        );
    }

    /** * @return PluginStruct|null */
    public function getPlugin(PluginsByTechnicalNameRequest $context)
    {
        $plugins = $this->getPlugins($context);

        return array_shift($plugins);
    }

    /** * @return PluginStruct[] */
    public function getPlugins(PluginsByTechnicalNameRequest $context)
    {
        $params = [
            'locale' => $context->getLocale(),
            

private readonly EntityRepository $languageRepo,
        private readonly PluginFinder $pluginFinder,
        private readonly VersionSanitizer $versionSanitizer
    ) {
    }

    public function refreshPlugins(Context $shopwareContext, IOInterface $composerIO): ExceptionCollection
    {
        $errors = new ExceptionCollection();
        $pluginsFromFileSystem = $this->pluginFinder->findPlugins($this->pluginDir, $this->projectDir, $errors, $composerIO);

        $installedPlugins = $this->getPlugins(new Criteria(), $shopwareContext);

        $plugins = [];
        foreach ($pluginsFromFileSystem as $pluginFromFileSystem) {
            $baseClass = $pluginFromFileSystem->getBaseClass();
            $pluginPath = $pluginFromFileSystem->getPath();
            $info = $pluginFromFileSystem->getComposerPackage();

            $autoload = $info->getAutoload();
            if (empty($autoload) || (empty($autoload['psr-4']) && empty($autoload['psr-0']))) {
                $errors->add(new PluginComposerJsonInvalidException(
                    $pluginPath . '/composer.json',
                    [

$plugins = $this->iteratePlugins($data, $context);

        return new ListingResultStruct($plugins, \count($plugins));
    }

    /** * @return PluginStruct|null */
    public function getPlugin(PluginsByTechnicalNameRequest $context)
    {
        $plugins = $this->getPlugins($context);

        return array_shift($plugins);
    }

    /** * @throws Exception * * @return PluginStruct[] */
    public function getPlugins(PluginsByTechnicalNameRequest $context)
    {
        

$this->hydrator->assignStorePluginStruct($locale, $store);
        }

        return $locale;
    }

    /** * @return array */
    public function getPlugins(PluginsByTechnicalNameRequest $context)
    {
        $localePlugins = $this->localPluginService->getPlugins($context);

        $storePlugins = $this->storePluginService->getPlugins($context);

        $result = [];
        foreach ($context->getTechnicalNames() as $name) {
            $name = strtolower($name);
            $storePlugin = null;
            $localPlugin = null;

            if (\array_key_exists($name, $localePlugins)) {
                $localPlugin = $localePlugins[$name];
            }

public function getCacheMaxAge() {
    return $this->getCacheMetadata()->getCacheMaxAge();
  }

  /** * {@inheritdoc} */
  public function listTopics() {
    // Map the top level help topic plugins to a list of topic links.     return array_map(function DHelpTopicPluginInterface $topic) {
      return $topic->toLink();
    }, $this->getPlugins());
  }

  /** * Gets the top level help topic plugins. * * @return \Drupal\help_topics\HelpTopicPluginInterface[] * The top level help topic plugins. */
  protected function getPlugins() {
    if (!isset($this->topLevelPlugins)) {
      $definitions = $this->pluginManager->getDefinitions();

      

foreach ($presets as $id => $preset) {
            $plugins = json_decode($preset['requiredPlugins'] ?? '', true) ?? [];
            $combinedPlugins = array_combine(array_column($plugins, 'name'), $plugins);
            if (!\is_array($combinedPlugins)) {
                $preset['requiredPlugins'] = [];
            } else {
                $preset['requiredPlugins'] = $combinedPlugins;
            }
            $pluginNames = array_merge($pluginNames, array_keys($preset['requiredPlugins']));
            $presets[$id] = $preset;
        }
        $localPlugins = $this->getPlugins($pluginNames);

        $result = [];
        foreach ($presets as $preset) {
            $data = [
                'id' => $preset['id'],
                'name' => $preset['name'],
                'label' => $preset['name'],
                'description' => $preset['name'],
                'premium' => $preset['premium'],
                'custom' => $preset['custom'],
                'thumbnail' => $preset['thumbnail'],
                

    /** * @param string $pluginName * * @return \Shopware\Components\Plugin|null */
    private function getPlugin($pluginName)
    {
        /** @var Kernel $kernel */
        $kernel = $this->container->get('kernel');
        $plugins = $kernel->getPlugins();

        if (!\array_key_exists($pluginName, $plugins)) {
            return null;
        }

        return $plugins[$pluginName];
    }
}

    /** * @param string $pluginName * * @throws Exception * * @return PluginBootstrap */
    private function getPluginByName($pluginName)
    {
        $plugins = $this->kernel->getPlugins();

        if (!isset($plugins[$pluginName])) {
            throw new InvalidArgumentException(sprintf('Plugin by name "%s" not found.', $pluginName));
        }

        return $plugins[$pluginName];
    }

    /** * @param int $pluginId * * @throws \Doctrine\DBAL\DBALException */