From a248007192468aeadaca825dbc2e78b0239ae940 Mon Sep 17 00:00:00 2001
From: ailkiv <a.ilkiv.ye@gmail.com>
Date: Thu, 10 Jul 2025 19:38:21 +0000
Subject: [PATCH] feat(files): add support for viewing public links in widget

Signed-off-by: ailkiv <a.ilkiv.ye@gmail.com>
---
 apps/files/src/views/ReferenceFileWidget.vue  |  14 +-
 .../Reference/File/FileReferenceProvider.php  | 132 ++++++--
 .../Reference/FileReferenceProviderTest.php   | 296 ++++++++++++++++++
 3 files changed, 420 insertions(+), 22 deletions(-)
 create mode 100644 tests/lib/Collaboration/Reference/FileReferenceProviderTest.php

diff --git a/apps/files/src/views/ReferenceFileWidget.vue b/apps/files/src/views/ReferenceFileWidget.vue
index 9db346ea35db4..85bdcd9972f09 100644
--- a/apps/files/src/views/ReferenceFileWidget.vue
+++ b/apps/files/src/views/ReferenceFileWidget.vue
@@ -55,7 +55,7 @@
 
 <script lang="ts">
 import { defineComponent, type Component, type PropType } from 'vue'
-import { generateRemoteUrl, generateUrl } from '@nextcloud/router'
+import { generateRemoteUrl, generateUrl, getBaseUrl } from '@nextcloud/router'
 import { getCurrentUser } from '@nextcloud/auth'
 import { getFilePickerBuilder } from '@nextcloud/dialogs'
 import { Node } from '@nextcloud/files'
@@ -73,6 +73,7 @@ type Ressource = {
 	mimetype: string
 	mtime: number // as unix timestamp
 	'preview-available': boolean
+	'is-public-link': boolean
 }
 
 type ViewerHandler = {
@@ -137,8 +138,11 @@ export default defineComponent({
 				.find(handler => handler.mimes.includes(this.richObject.mimetype))
 		},
 		viewerFile(): ViewerFile {
-			const davSource = generateRemoteUrl(`dav/files/${getCurrentUser()?.uid}/${this.richObject.path}`)
-				.replace(/\/\/$/, '/')
+			const davSource = this.richObject['is-public-link']
+				? (getBaseUrl() + `/public.php/dav/files/${this.richObject.path}`)
+				: generateRemoteUrl(`dav/files/${getCurrentUser()?.uid}/${this.richObject.path}`)
+					.replace(/\/\/$/, '/')
+
 			return {
 				filename: this.richObject.path,
 				basename: this.richObject.name,
@@ -200,6 +204,10 @@ export default defineComponent({
 	},
 	methods: {
 		navigate(event) {
+			if (this.richObject['is-public-link']) {
+				return
+			}
+
 			if (this.isFolder) {
 				event.stopPropagation()
 				event.preventDefault()
diff --git a/lib/private/Collaboration/Reference/File/FileReferenceProvider.php b/lib/private/Collaboration/Reference/File/FileReferenceProvider.php
index 3cb174d960717..f070c7ec841be 100644
--- a/lib/private/Collaboration/Reference/File/FileReferenceProvider.php
+++ b/lib/private/Collaboration/Reference/File/FileReferenceProvider.php
@@ -10,6 +10,7 @@
 
 use OC\User\NoUserException;
 use OCP\Collaboration\Reference\ADiscoverableReferenceProvider;
+use OCP\Collaboration\Reference\IPublicReferenceProvider;
 use OCP\Collaboration\Reference\IReference;
 use OCP\Collaboration\Reference\Reference;
 use OCP\Files\IMimeTypeDetector;
@@ -22,8 +23,13 @@
 use OCP\IURLGenerator;
 use OCP\IUserSession;
 use OCP\L10N\IFactory;
+use OCP\Share\Exceptions\ShareNotFound;
+use OCP\Share\IManager as ShareManager;
+
+class FileReferenceProvider extends ADiscoverableReferenceProvider implements IPublicReferenceProvider {
+	private const PREVIEW_WIDTH = 1600;
+	private const PREVIEW_HEIGHT = 630;
 
-class FileReferenceProvider extends ADiscoverableReferenceProvider {
 	private ?string $userId;
 	private IL10N $l10n;
 
@@ -34,13 +40,14 @@ public function __construct(
 		private IMimeTypeDetector $mimeTypeDetector,
 		private IPreview $previewManager,
 		IFactory $l10n,
+		private ShareManager $shareManager,
 	) {
 		$this->userId = $userSession->getUser()?->getUID();
 		$this->l10n = $l10n->get('files');
 	}
 
 	public function matchReference(string $referenceText): bool {
-		return $this->getFilesAppLinkId($referenceText) !== null;
+		return $this->getFilesAppLinkId($referenceText) !== null || $this->getFilesAppPublicLinkToken($referenceText) !== null;
 	}
 
 	private function getFilesAppLinkId(string $referenceText): ?int {
@@ -74,34 +81,105 @@ private function getFilesAppLinkId(string $referenceText): ?int {
 		return $fileId !== null ? (int)$fileId : null;
 	}
 
+	private function getFilesAppPublicLinkToken(string $referenceText): ?string {
+		$prefixes = ['/index.php/s/', '/s/'];
+
+		$token = null;
+
+		foreach ($prefixes as $prefix) {
+			$fullPrefix = $this->urlGenerator->getAbsoluteURL($prefix);
+			if (mb_strpos($referenceText, $fullPrefix) === 0) {
+				$token = substr($referenceText, mb_strlen($fullPrefix));
+				if (($slashPos = strpos($token, '/')) !== false) {
+					$token = substr($token, 0, $slashPos);
+				}
+				break;
+			}
+		}
+
+		return $token;
+	}
+
 	public function resolveReference(string $referenceText): ?IReference {
-		if ($this->matchReference($referenceText)) {
-			$reference = new Reference($referenceText);
-			try {
-				$this->fetchReference($reference);
-			} catch (NotFoundException $e) {
-				$reference->setRichObject('file', null);
-				$reference->setAccessible(false);
+		$reference = new Reference($referenceText);
+		try {
+			$fileId = $this->getFilesAppLinkId($referenceText);
+
+			if ($fileId !== null) {
+				$this->fetchReference($reference, $fileId);
+			} else {
+				$fileToken = $this->getFilesAppPublicLinkToken($referenceText);
+				if ($fileToken !== null) {
+					$this->fetchReferenceForPublicFile($reference, $referenceText, $fileToken);
+				} else {
+					throw new NotFoundException();
+				}
 			}
-			return $reference;
+		} catch (NotFoundException $e) {
+			$reference->setRichObject('file', null);
+			$reference->setAccessible(false);
 		}
+		return $reference;
+	}
 
-		return null;
+	public function resolveReferencePublic(string $referenceText, string $sharingToken): ?IReference {
+		$reference = new Reference($referenceText);
+		try {
+			$fileToken = $this->getFilesAppPublicLinkToken($referenceText);
+			if ($fileToken !== null) {
+				$this->fetchReferenceForPublicFile($reference, $referenceText, $fileToken);
+			} else {
+				throw new NotFoundException();
+			}
+		} catch (NotFoundException $e) {
+			$reference->setRichObject('file', null);
+			$reference->setAccessible(false);
+		}
+		return $reference;
+	}
+
+	private function fetchReferenceForPublicFile(Reference $reference, string $referenceText, string $fileToken): void {
+		try {
+			$share = $this->shareManager->getShareByToken($fileToken);
+			$node = $share->getNode();
+
+			$reference->setTitle($node->getName());
+			$reference->setDescription($node->getMimetype());
+			$reference->setUrl($referenceText);
+			if ($this->previewManager->isMimeSupported($node->getMimeType())) {
+				$reference->setImageUrl($this->urlGenerator->linkToRouteAbsolute(
+					'files_sharing.PublicPreview.getPreview',
+					['x' => self::PREVIEW_WIDTH, 'y' => self::PREVIEW_HEIGHT, 'token' => $fileToken]));
+			} else {
+				$fileTypeIconUrl = $this->mimeTypeDetector->mimeTypeIcon($node->getMimeType());
+				$reference->setImageUrl($fileTypeIconUrl);
+			}
+
+			$reference->setRichObject('file', [
+				'id' => $fileToken, // security, public link should not show file id
+				'name' => $node->getName(),
+				'size' => $node->getSize(),
+				'path' => $fileToken,
+				'link' => $reference->getUrl(),
+				'mimetype' => $node->getMimetype(),
+				'mtime' => $node->getMTime(),
+				'preview-available' => $this->previewManager->isAvailable($node),
+				'is-public-link' => true,
+			]);
+		} catch (ShareNotFound|NotFoundException|InvalidPathException|NotPermittedException $e) {
+			$reference->setRichObject('file', null);
+			$reference->setAccessible(false);
+		}
 	}
 
 	/**
 	 * @throws NotFoundException
 	 */
-	private function fetchReference(Reference $reference): void {
+	private function fetchReference(Reference $reference, int $fileId): void {
 		if ($this->userId === null) {
 			throw new NotFoundException();
 		}
 
-		$fileId = $this->getFilesAppLinkId($reference->getId());
-		if ($fileId === null) {
-			throw new NotFoundException();
-		}
-
 		try {
 			$userFolder = $this->rootFolder->getUserFolder($this->userId);
 			$file = $userFolder->getFirstNodeById($fileId);
@@ -114,7 +192,10 @@ private function fetchReference(Reference $reference): void {
 			$reference->setDescription($file->getMimetype());
 			$reference->setUrl($this->urlGenerator->getAbsoluteURL('/index.php/f/' . $fileId));
 			if ($this->previewManager->isMimeSupported($file->getMimeType())) {
-				$reference->setImageUrl($this->urlGenerator->linkToRouteAbsolute('core.Preview.getPreviewByFileId', ['x' => 1600, 'y' => 630, 'fileId' => $fileId]));
+				$reference->setImageUrl($this->urlGenerator->linkToRouteAbsolute(
+					'core.Preview.getPreviewByFileId',
+					['x' => self::PREVIEW_WIDTH, 'y' => self::PREVIEW_HEIGHT, 'fileId' => $fileId])
+				);
 			} else {
 				$fileTypeIconUrl = $this->mimeTypeDetector->mimeTypeIcon($file->getMimeType());
 				$reference->setImageUrl($fileTypeIconUrl);
@@ -136,13 +217,26 @@ private function fetchReference(Reference $reference): void {
 	}
 
 	public function getCachePrefix(string $referenceId): string {
-		return (string)$this->getFilesAppLinkId($referenceId);
+		$fileId = $this->getFilesAppLinkId($referenceId);
+		if ($fileId !== null) {
+			return (string)$fileId;
+		} else {
+			$fileToken = $this->getFilesAppPublicLinkToken($referenceId);
+			if ($fileToken !== null) {
+				return $fileToken;
+			}
+		}
+		return '';
 	}
 
 	public function getCacheKey(string $referenceId): ?string {
 		return $this->userId ?? '';
 	}
 
+	public function getCacheKeyPublic(string $referenceId, string $sharingToken): ?string {
+		return $sharingToken;
+	}
+
 	public function getId(): string {
 		return 'files';
 	}
diff --git a/tests/lib/Collaboration/Reference/FileReferenceProviderTest.php b/tests/lib/Collaboration/Reference/FileReferenceProviderTest.php
new file mode 100644
index 0000000000000..690fc3da5b5c6
--- /dev/null
+++ b/tests/lib/Collaboration/Reference/FileReferenceProviderTest.php
@@ -0,0 +1,296 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+declare(strict_types=1);
+
+namespace Tests\OC\Collaboration\Reference;
+
+use OC\Collaboration\Reference\File\FileReferenceProvider;
+use OCP\Collaboration\Reference\IReference;
+use OCP\Files\IMimeTypeDetector;
+use OCP\Files\InvalidPathException;
+use OCP\Files\IRootFolder;
+use OCP\Files\NotFoundException;
+use OCP\IL10N;
+use OCP\IPreview;
+use OCP\IURLGenerator;
+use OCP\IUser;
+use OCP\IUserSession;
+use OCP\L10N\IFactory;
+use OCP\Share\IManager as ShareManager;
+use PHPUnit\Framework\MockObject\MockObject;
+use Test\TestCase;
+
+class FileReferenceProviderTest extends TestCase {
+	private FileReferenceProvider $provider;
+	private IURLGenerator|MockObject $urlGenerator;
+	private IRootFolder|MockObject $rootFolder;
+	private IUserSession|MockObject $userSession;
+	private IMimeTypeDetector|MockObject $mimeTypeDetector;
+	private IPreview|MockObject $previewManager;
+	private IFactory|MockObject $l10nFactory;
+	private ShareManager|MockObject $shareManager;
+	private IL10N|MockObject $l10n;
+	private IUser|MockObject $user;
+	private string $host = 'https://example.com';
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->urlGenerator = $this->createMock(IURLGenerator::class);
+		$this->rootFolder = $this->createMock(IRootFolder::class);
+		$this->userSession = $this->createMock(IUserSession::class);
+		$this->mimeTypeDetector = $this->createMock(IMimeTypeDetector::class);
+		$this->previewManager = $this->createMock(IPreview::class);
+		$this->l10nFactory = $this->createMock(IFactory::class);
+		$this->shareManager = $this->createMock(ShareManager::class);
+		$this->l10n = $this->createMock(IL10N::class);
+		$this->user = $this->createMock(IUser::class);
+
+		$this->l10nFactory->method('get')
+			->with('files')
+			->willReturn($this->l10n);
+
+		$this->urlGenerator->method('getAbsoluteURL')
+			->willReturnCallback(function ($path) {
+				return $this->host . $path;
+			});
+
+		$this->userSession->method('getUser')
+			->willReturn($this->user);
+		$this->user->method('getUID')
+			->willReturn('testuser');
+
+		$this->provider = new FileReferenceProvider(
+			$this->urlGenerator,
+			$this->rootFolder,
+			$this->userSession,
+			$this->mimeTypeDetector,
+			$this->previewManager,
+			$this->l10nFactory,
+			$this->shareManager
+		);
+	}
+
+	/**
+	 * @dataProvider matchReferenceDataProvider
+	 */
+	public function testMatchReference(string $referenceText, bool $expected): void {
+		$this->assertEquals($expected, $this->provider->matchReference($referenceText));
+	}
+
+	public function matchReferenceDataProvider(): array {
+		return [
+			'file id in apps/files' => [
+				'referenceText' => $this->host . '/apps/files/?fileid=123',
+				'expected' => true
+			],
+			'file id in index.php/apps/files' => [
+				'referenceText' => $this->host . '/index.php/apps/files/?fileid=123',
+				'expected' => true
+			],
+			'openfile in apps/files' => [
+				'referenceText' => $this->host . '/apps/files/?openfile=123',
+				'expected' => true
+			],
+			'openfile in index.php/apps/files' => [
+				'referenceText' => $this->host . '/index.php/apps/files/?openfile=123',
+				'expected' => true
+			],
+			'public link with s/' => [
+				'referenceText' => $this->host . '/s/abc123',
+				'expected' => true
+			],
+			'public link with index.php/s/' => [
+				'referenceText' => $this->host . '/index.php/s/abc123',
+				'expected' => true
+			],
+			'public link with path' => [
+				'referenceText' => $this->host . '/s/abc123/path/to/file',
+				'expected' => true
+			],
+			'invalid url' => [
+				'referenceText' => $this->host . '/invalid/path',
+				'expected' => false
+			],
+			'empty url' => [
+				'referenceText' => '',
+				'expected' => false
+			],
+			'non-matching domain' => [
+				'referenceText' => 'https://other-domain.com/apps/files/?fileid=123',
+				'expected' => false
+			]
+		];
+	}
+
+	public function testResolveReferenceWithFileId(): void {
+		$userFolder = $this->createMock(\OCP\Files\Folder::class);
+		$file = $this->createMock(\OCP\Files\File::class);
+
+		$this->rootFolder->method('getUserFolder')
+			->with('testuser')
+			->willReturn($userFolder);
+
+		$userFolder->method('getFirstNodeById')
+			->with(123)
+			->willReturn($file);
+
+		$file->method('getName')
+			->willReturn('test.txt');
+		$file->method('getMimetype')
+			->willReturn('text/plain');
+		$file->method('getId')
+			->willReturn(123);
+		$file->method('getSize')
+			->willReturn(1024);
+		$file->method('getMTime')
+			->willReturn(1234567890);
+
+		$this->previewManager->method('isMimeSupported')
+			->with('text/plain')
+			->willReturn(true);
+
+		$this->urlGenerator->method('linkToRouteAbsolute')
+			->willReturn($this->host . '/preview/123');
+
+		$referenceText = $this->host . '/apps/files/?fileid=123';
+		$reference = $this->provider->resolveReference($referenceText);
+
+		$this->assertInstanceOf(IReference::class, $reference);
+		$this->assertEquals('test.txt', $reference->getTitle());
+		$this->assertEquals('text/plain', $reference->getDescription());
+		$this->assertEquals($this->host . '/index.php/f/123', $reference->getUrl());
+		$this->assertEquals($this->host . '/preview/123', $reference->getImageUrl());
+	}
+
+	public function testResolveReferenceWithPublicLink(): void {
+		$share = $this->createMock(\OCP\Share\IShare::class);
+		$node = $this->createMock(\OCP\Files\File::class);
+
+		$this->shareManager->method('getShareByToken')
+			->with('abc123')
+			->willReturn($share);
+
+		$share->method('getNode')
+			->willReturn($node);
+
+		$node->method('getName')
+			->willReturn('public.txt');
+		$node->method('getMimetype')
+			->willReturn('text/plain');
+		$node->method('getSize')
+			->willReturn(2048);
+		$node->method('getMTime')
+			->willReturn(1234567890);
+
+		$this->previewManager->method('isMimeSupported')
+			->with('text/plain')
+			->willReturn(true);
+
+		$this->urlGenerator->method('linkToRouteAbsolute')
+			->willReturn($this->host . '/preview/public/abc123');
+
+		$referenceText = $this->host . '/s/abc123';
+		$reference = $this->provider->resolveReferencePublic($referenceText, 'abc123');
+
+		$this->assertInstanceOf(IReference::class, $reference);
+		$this->assertEquals('public.txt', $reference->getTitle());
+		$this->assertEquals('text/plain', $reference->getDescription());
+		$this->assertEquals($this->host . '/s/abc123', $reference->getUrl());
+		$this->assertEquals($this->host . '/preview/public/abc123', $reference->getImageUrl());
+	}
+
+	public function testResolveReferenceWithNotFoundFile(): void {
+		$userFolder = $this->createMock(\OCP\Files\Folder::class);
+		$this->rootFolder->method('getUserFolder')
+			->with('testuser')
+			->willReturn($userFolder);
+
+		$userFolder->method('getFirstNodeById')
+			->with(123)
+			->willThrowException(new NotFoundException());
+
+		$referenceText = $this->host . '/apps/files/?fileid=123';
+		$reference = $this->provider->resolveReference($referenceText);
+
+		$this->assertInstanceOf(IReference::class, $reference);
+		$this->assertFalse($reference->getAccessible());
+		$this->assertEquals([
+			'id' => $referenceText,
+			'name' => $referenceText,
+			'description' => null,
+			'thumb' => null,
+			'link' => $referenceText
+		], $reference->getRichObject());
+	}
+
+	public function testResolveReferenceWithInvalidPath(): void {
+		$userFolder = $this->createMock(\OCP\Files\Folder::class);
+		$this->rootFolder->method('getUserFolder')
+			->with('testuser')
+			->willReturn($userFolder);
+
+		$userFolder->method('getFirstNodeById')
+			->with(123)
+			->willThrowException(new InvalidPathException());
+
+		$referenceText = $this->host . '/apps/files/?fileid=123';
+		$reference = $this->provider->resolveReference($referenceText);
+
+		$this->assertInstanceOf(IReference::class, $reference);
+		$this->assertFalse($reference->getAccessible());
+		$this->assertEquals([
+			'id' => $referenceText,
+			'name' => $referenceText,
+			'description' => null,
+			'thumb' => null,
+			'link' => $referenceText
+		], $reference->getRichObject());
+	}
+
+	public function testGetCachePrefixWithFileId(): void {
+		$referenceId = $this->host . '/apps/files/?fileid=123';
+		$this->assertEquals('123', $this->provider->getCachePrefix($referenceId));
+	}
+
+	public function testGetCachePrefixWithPublicLink(): void {
+		$referenceId = $this->host . '/s/abc123';
+		$this->assertEquals('abc123', $this->provider->getCachePrefix($referenceId));
+	}
+
+	public function testGetCacheKey(): void {
+		$this->assertEquals('testuser', $this->provider->getCacheKey('any-reference'));
+	}
+
+	public function testGetCacheKeyPublic(): void {
+		$this->assertEquals('abc123', $this->provider->getCacheKeyPublic('any-reference', 'abc123'));
+	}
+
+	public function testGetId(): void {
+		$this->assertEquals('files', $this->provider->getId());
+	}
+
+	public function testGetTitle(): void {
+		$this->l10n->method('t')
+			->with('Files')
+			->willReturn('Files');
+
+		$this->assertEquals('Files', $this->provider->getTitle());
+	}
+
+	public function testGetOrder(): void {
+		$this->assertEquals(0, $this->provider->getOrder());
+	}
+
+	public function testGetIconUrl(): void {
+		$this->urlGenerator->method('imagePath')
+			->with('files', 'folder.svg')
+			->willReturn('/path/to/folder.svg');
+
+		$this->assertEquals('/path/to/folder.svg', $this->provider->getIconUrl());
+	}
+}