getFileName example

        if (null === $this->fileLinkFormatter) {
            return '';
        }

        try {
            $r = new \ReflectionClass($class);
        } catch (\ReflectionException) {
            return '';
        }

        return (string) $this->fileLinkFormatter->format($r->getFileName(), $r->getStartLine());
    }
}

        return $this->connection;
    }

    public function getLabel(): string
    {
        $result = [];

        $regexPattern = '/[\d]*-(.+)\.php$/i';

        $rc = new ReflectionClass(\get_class($this));
        $fileName = basename((string) $rc->getFileName());

        preg_match($regexPattern, $fileName, $result);

        return $result[1];
    }

    public function getVersion(): int
    {
        $result = [];
        $regexPattern = '/[\d]*$/';

        

    public function __construct(private readonly iterable $metadataLoader)
    {
    }

    public function loadFromFile(MediaFile $mediaFile, MediaType $mediaType): ?array
    {
        foreach ($this->metadataLoader as $loader) {
            if ($loader->supports($mediaType)) {
                $metaData = $loader->extractMetadata($mediaFile->getFileName());

                if ($mediaFile->getHash()) {
                    $metaData['hash'] = $mediaFile->getHash();
                }

                return $metaData;
            }
        }

        return null;
    }
}

/** * Returns the converted file name. * * @return string */
    public function getFileName()
    {
        if (!$this->getMedia() instanceof \Shopware\Models\Media\Media) {
            return 'Media not found';
        }

        return $this->getMedia()->getFileName();
    }

    /** * Returns the media description. * * @return string */
    public function getDescription()
    {
        if (!$this->getMedia() instanceof \Shopware\Models\Media\Media) {
            return '';
        }

throw new RuntimeException('Parameter shopware.product_export.cache_dir has to be an string');
        }

        if (!is_dir($cacheDir)) {
            if (@mkdir($cacheDir, 0777, true) === false) {
                throw new RuntimeException(sprintf("Unable to create the %s directory (%s)\n", 'Productexport', $cacheDir));
            }
        } elseif (!is_writable($cacheDir)) {
            throw new RuntimeException(sprintf("Unable to write in the %s directory (%s)\n", 'Productexport', $cacheDir));
        }

        $fileName = $productFeed->getHash() . '_' . $productFeed->getFileName();
        $filePath = $cacheDir . $fileName;
        if (file_exists($filePath)) {
            unlink($filePath);
        }
        $productFeed->setCacheRefreshed('2000-01-01');

        try {
            $this->get('models')->persist($productFeed);
            $this->get('models')->flush();

            $data = $this->getFeed($productFeed->getId());
            

ControllerArguments::class => new ServiceClosureArgument(new Reference('.service_locator.foo')),
            ]])
        ;
        $container->register('argument_resolver.service')
            ->setArguments([new Reference('.service_locator.bar')])
        ;

        $pass = new TranslatorPathsPass();
        $pass->process($container);

        $expectedPaths = [
            $container->getReflectionClass(ServiceArguments::class)->getFileName(),
            $container->getReflectionClass(ServiceProperties::class)->getFileName(),
            $container->getReflectionClass(ServiceMethodCalls::class)->getFileName(),
            $container->getReflectionClass(ControllerArguments::class)->getFileName(),
            $container->getReflectionClass(ServiceSubscriber::class)->getFileName(),
        ];

        $this->assertSame($expectedPaths, $debugCommand->getArgument(6));
        $this->assertSame($expectedPaths, $updateCommand->getArgument(7));
    }
}

private function parseControllerDefinition(callable $controller): ?array
    {
        if (\is_string($controller) && str_contains($controller, '::')) {
            $controller = explode('::', $controller);
        }

        if (\is_array($controller)) {
            try {
                $r = new \ReflectionMethod($controller[0], $controller[1]);

                return [
                    'file' => $r->getFileName(),
                    'line' => $r->getEndLine(),
                ];
            } catch (\ReflectionException) {
                return null;
            }
        }

        if ($controller instanceof \Closure) {
            $r = new \ReflectionFunction($controller);

            return [
                

private function parseControllerDefinition(callable $controller): ?array
    {
        if (\is_string($controller) && str_contains($controller, '::')) {
            $controller = explode('::', $controller);
        }

        if (\is_array($controller)) {
            try {
                $r = new \ReflectionMethod($controller[0], $controller[1]);

                return [
                    'file' => $r->getFileName(),
                    'line' => $r->getEndLine(),
                ];
            } catch (\ReflectionException) {
                return null;
            }
        }

        if ($controller instanceof \Closure) {
            $r = new \ReflectionFunction($controller);

            return [
                

$line = $trace[$i];
        $this->triggeringFile = $file;

        for ($j = 1; $j < $i; ++$j) {
            if (!isset($trace[$j]['function'], $trace[1 + $j]['class'], $trace[1 + $j]['args'][0])) {
                continue;
            }

            if ('trigger_error' === $trace[$j]['function'] && !isset($trace[$j]['class'])) {
                if (DebugClassLoader::class === $trace[1 + $j]['class']) {
                    $class = $trace[1 + $j]['args'][0];
                    $this->triggeringFile = isset($trace[1 + $j]['args'][1]) ? realpath($trace[1 + $j]['args'][1]) : (new \ReflectionClass($class))->getFileName();
                    $this->getOriginalFilesStack();
                    array_splice($this->originalFilesStack, 0, $j, [$this->triggeringFile]);

                    if (preg_match('/(?|"([^"]++)" that is deprecated|should implement method "(?:static )?([^:]++))/', $message, $m) || (false === strpos($message, '()" will return') && false === strpos($message, 'native return type declaration') && preg_match('/^(?:The|Method) "([^":]++)/', $message, $m))) {
                        $this->triggeringFile = (new \ReflectionClass($m[1]))->getFileName();
                        array_unshift($this->originalFilesStack, $this->triggeringFile);
                    }
                }

                break;
            }
        }

    protected function getDestination(Media $media, $suffix)
    {
        $thumbnailDir = $this->getThumbnailDir($media);

        $fileName = str_replace(
            '.' . $media->getExtension(),
            '_' . $suffix . '.jpg',
            $media->getFileName()
        );

        $fileNames = [
            'jpg' => $thumbnailDir . $fileName,
        ];

        // Create native extension thumbnail         if ($media->getExtension() !== 'jpg') {
            $fileName = str_replace(
                '.' . $media->getExtension(),
                '_' . $suffix . '.' . $media->getExtension(),
                

/** * @throws Exception */
    private function createThumbnailsForMovedMedia(Media $media): void
    {
        $albumRepository = $this->get(ModelManager::class)->getRepository(Album::class);

        $album = $albumRepository->find($media->getAlbumId());

        if ($album instanceof Album) {
            $media->removeAlbumThumbnails($album->getSettings()->getThumbnailSize(), $media->getFileName());
            $media->createAlbumThumbnails($album);
        }
    }

    /** * The internal toTree method iterates the given model and converts it into an array. * At the same time number of associated media is determined to the album. * If an album have sub-albums, the number of associated media of the sub-album added to the * media count of the parent album. * * @param array<string, mixed>|ArrayCollection $data * @param array<string, mixed>|null $parent * * @return array<int, array<string, mixed>> */

$fieldConfig->add(new FieldConfig('media', FieldConfig::SOURCE_DEFAULT, 'core/assets/default/cms/shopware.jpg'));

        $slot = new CmsSlotEntity();
        $slot->setFieldConfig($fieldConfig);

        $this->imageResolver->enrich($slot, $resolverContext, $result);

        /** @var ImageStruct|null $imageStruct */
        $imageStruct = $slot->getData();
        $media = $imageStruct->getMedia();

        static::assertEquals('shopware', $media->getFileName());
        static::assertEquals('image/jpeg', $media->getMimeType());
        static::assertEquals('jpg', $media->getFileExtension());
    }

    public function testMediaWithRemote(): void
    {
        $resolverContext = new ResolverContext($this->createMock(SalesChannelContext::class), new Request());

        $media = new MediaEntity();
        $media->setUniqueIdentifier('media123');

        

    private function findClassInPath(string $path, string $class, string $prefix): array
    {
        if (!$path = realpath($path.'/'.strtr($prefix, '\\_', '//')) ?: realpath($path.'/'.\dirname(strtr($prefix, '\\_', '//'))) ?: realpath($path)) {
            return [];
        }

        $classes = [];
        $filename = $class.'.php';
        foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path, \RecursiveDirectoryIterator::SKIP_DOTS), \RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
            if ($filename == $file->getFileName() && $class = $this->convertFileToClass($path, $file->getPathName(), $prefix)) {
                $classes[] = $class;
            }
        }

        return $classes;
    }

    private function convertFileToClass(string $path, string $file, string $prefix): ?string
    {
        $candidates = [
            // namespaced class

$this->imageSliderResolver->enrich($slot, $resolverContext, $result);
        $imageSliderStruct = $slot->getData();

        static::assertInstanceOf(ImageSliderStruct::class, $imageSliderStruct);

        $imageSliderItems = $imageSliderStruct->getSliderItems() ?? [];
        static::assertCount(2, $imageSliderItems);

        $firstSliderItem = $imageSliderItems[0];
        $firstSliderItemMedia = $firstSliderItem->getMedia();
        static::assertInstanceOf(MediaEntity::class, $firstSliderItemMedia);
        static::assertEquals('animated', $firstSliderItemMedia->getFileName());
        static::assertEquals('image/gif', $firstSliderItemMedia->getMimeType());
        static::assertEquals('gif', $firstSliderItemMedia->getFileExtension());

        $secondSliderItem = $imageSliderItems[1];
        $secondSliderItemMedia = $secondSliderItem->getMedia();
        static::assertInstanceOf(MediaEntity::class, $secondSliderItemMedia);
        static::assertEquals('shopware', $secondSliderItemMedia->getFileName());
        static::assertEquals('image/jpeg', $secondSliderItemMedia->getMimeType());
        static::assertEquals('jpg', $secondSliderItemMedia->getFileExtension());
    }

    

'jpe|jpg|jpeg' => ['image/jpeg'],
            'png' => ['image/png'],
            'gif' => ['image/gif'],
        ]);

        if (!$valid) {
            throw new FileTypeNotAllowedException($file->getMimeType() ?? '', $this->getType());
        }

        // additional mime type validation         // we detect the mime type over the `getimagesize` extension         $imageSize = getimagesize($file->getPath() . '/' . $file->getFileName());
        if (!isset($imageSize['mime']) || $imageSize['mime'] !== $file->getMimeType()) {
            throw new FileTypeNotAllowedException($file->getMimeType() ?? '', $this->getType());
        }
    }
}