Add UI for share by token

DOCUMENTATION.md

@@ -726,6 +726,12 @@ _(>= 3.6.0)_
 
 Verification of a particular item file
 
+##### --verify-sharing
+
+_(>= 3.7.0)_
+
+Verification of local sharing database
+
 ##### -C|--config <file>
 
 Load one or more specified config file(s)
@@ -2043,6 +2049,49 @@ is thrown instead of returning the results.
 
 Default: 10000
 
+#### [sharing]
+
+_(>= 3.7.0)_
+
+##### type
+
+_(>= 3.7.0)_
+
+Sharing database type
+
+One of:
+ * `none`
+ * `csv`
+ * `files`
+
+Default: `none` (implicit disabling the feature)
+
+##### database_path
+
+_(>= 3.7.0)_
+
+Sharing database path
+
+Default:
+ * type `csv`: `(filesystem_folder)/collection-db/sharing.csv`
+ * type `files`: `(filesystem_folder)/collection-db/files`
+
+##### collection_by_token
+
+_(>= 3.7.0)_
+
+Share collection by token
+
+Default: `false`
+
+##### collection_by_map
+
+_(>= 3.7.0)_
+
+Share collection by map
+
+Default: `false`
+
 ## Supported Clients
 
 Radicale has been tested with:

config

@@ -296,6 +296,25 @@
 #predefined_collections =
 
 
+[sharing]
+
+# Sharing database type
+# Value: none | csv | files
+#type = none
+
+# Sharing database path for type 'csv'
+#database_path = (filesystem_folder)/collection-db/sharing.csv
+
+# Sharing database path for type 'files'
+#database_path = (filesystem_folder)/collection-db/files
+
+# Share collection by map
+#collection_by_map = false
+
+# Share collection by token
+#collection_by_token = false
+
+
 [web]
 
 # Web interface backend

integ_tests/common.py

@@ -0,0 +1,95 @@
+import os
+import pathlib
+import socket
+import subprocess
+import sys
+import time
+from typing import Any, Generator
+
+from playwright.sync_api import Page
+
+
+def get_free_port():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def start_radicale_server(tmp_path: pathlib.Path) -> Generator[str, Any, None]:
+    port = get_free_port()
+    config_path = tmp_path / "config"
+    user_path = tmp_path / "users"
+    storage_path = tmp_path / "collections"
+
+    # Create a local config file
+    with open(config_path, "w") as f:
+        f.write(
+            f"""[server]
+hosts = 127.0.0.1:{port}
+[storage]
+filesystem_folder = {storage_path}
+[auth]
+type = htpasswd
+htpasswd_filename = {user_path}
+[web]
+type = internal
+[sharing]
+type = csv
+collection_by_map = true
+collection_by_token = true
+"""
+        )
+    with open(user_path, "w") as f:
+        f.write(
+            """admin:adminpassword
+"""
+        )
+
+    env = os.environ.copy()
+    # Ensure the radicale package is in PYTHONPATH
+    # Assuming this test file is in <repo>/integ_tests/
+    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+    env["PYTHONPATH"] = repo_root + os.pathsep + env.get("PYTHONPATH", "")
+
+    # Run the server
+    process = subprocess.Popen(
+        [sys.executable, "-m", "radicale", "--config", str(config_path)],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    # Wait for the server to start listening
+    start_time = time.time()
+    while time.time() - start_time < 10:
+        try:
+            with socket.create_connection(("127.0.0.1", port), timeout=0.1):
+                break
+        except (OSError, ConnectionRefusedError):
+            if process.poll() is not None:
+                _stdout, stderr = process.communicate()
+                raise RuntimeError(
+                    f"Radicale failed to start (code {process.returncode}):\n{stderr.decode()}"
+                )
+            time.sleep(0.1)
+    else:
+        process.terminate()
+        process.wait()
+        raise RuntimeError("Timeout waiting for Radicale to start")
+
+    yield f"http://127.0.0.1:{port}"
+
+    # Cleanup
+    process.terminate()
+    process.wait()
+
+
+def login(page: Page, radicale_server: str) -> None:
+    page.goto(radicale_server)
+    page.fill('#loginscene input[data-name="user"]', "admin")
+    page.fill('#loginscene input[data-name="password"]', "adminpassword")
+    page.click('button:has-text("Next")')
+
+def create_collection(page: Page, radicale_server: str) -> None:
+    page.click('.fabcontainer a[data-name="new"]')
+    page.click('#createcollectionscene button[data-name="submit"]')

integ_tests/test_basic_operation.py

@@ -1,102 +1,30 @@
-import os
-import socket
-import subprocess
-import sys
-import time
+import pathlib
+from typing import Any, Generator
 
 import pytest
 from playwright.sync_api import Page, expect
 
-
-def get_free_port():
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("127.0.0.1", 0))
-        return s.getsockname()[1]
+from integ_tests.common import login, start_radicale_server
 
 
 @pytest.fixture
-def radicale_server(tmp_path):
-    port = get_free_port()
-    config_path = tmp_path / "config"
-    user_path = tmp_path / "users"
-    storage_path = tmp_path / "collections"
-
-    # Create a local config file
-    with open(config_path, "w") as f:
-        f.write(
-            f"""[server]
-hosts = 127.0.0.1:{port}
-[storage]
-filesystem_folder = {storage_path}
-[auth]
-type = htpasswd
-htpasswd_filename = {user_path}
-[web]
-type = internal
-"""
-        )
-    with open(user_path, "w") as f:
-        f.write(
-            """admin:adminpassword
-"""
-        )
-
-    env = os.environ.copy()
-    # Ensure the radicale package is in PYTHONPATH
-    # Assuming this test file is in <repo>/integ_tests/
-    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-    env["PYTHONPATH"] = repo_root + os.pathsep + env.get("PYTHONPATH", "")
-
-    # Run the server
-    process = subprocess.Popen(
-        [sys.executable, "-m", "radicale", "--config", str(config_path)],
-        env=env,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
+def radicale_server(tmp_path: pathlib.Path) -> Generator[str, Any, None]:
+    yield from start_radicale_server(tmp_path)
 
-    # Wait for the server to start listening
-    start_time = time.time()
-    while time.time() - start_time < 10:
-        try:
-            with socket.create_connection(("127.0.0.1", port), timeout=0.1):
-                break
-        except (OSError, ConnectionRefusedError):
-            if process.poll() is not None:
-                stdout, stderr = process.communicate()
-                raise RuntimeError(
-                    f"Radicale failed to start (code {process.returncode}):\n{stderr.decode()}"
-                )
-            time.sleep(0.1)
-    else:
-        process.terminate()
-        process.wait()
-        raise RuntimeError("Timeout waiting for Radicale to start")
 
-    yield f"http://127.0.0.1:{port}"
-
-    # Cleanup
-    process.terminate()
-    process.wait()
-
-
-def test_index_html_loads(page: Page, radicale_server):
+def test_index_html_loads(page: Page, radicale_server: str) -> None:
     """Test that the index.html loads from the server."""
-    console_msgs = []
+    console_msgs: list[str] = []
     page.on("console", lambda msg: console_msgs.append(msg.text))
     page.goto(radicale_server)
     expect(page).to_have_title("Radicale Web Interface")
     # There should be no errors on the console
     assert len(console_msgs) == 0
 
 
-def test_user_login_works(page: Page, radicale_server):
+def test_user_login_works(page: Page, radicale_server: str) -> None:
     """Test that the login form works."""
-    page.goto(radicale_server)
-    # Fill in the login form
-    page.fill('#loginscene input[data-name="user"]', "admin")
-    page.fill('#loginscene input[data-name="password"]', "adminpassword")
-    page.click('button:has-text("Next")')
+    login(page, radicale_server)
 
     # After login, we should see the collections list (which is empty)
     expect(

integ_tests/test_sharing.py

@@ -0,0 +1,42 @@
+import pathlib
+from typing import Any, Generator
+
+import pytest
+from playwright.sync_api import Page, expect
+
+from integ_tests.common import create_collection, login, start_radicale_server
+
+
+@pytest.fixture
+def radicale_server(tmp_path: pathlib.Path) -> Generator[str, Any, None]:
+    yield from start_radicale_server(tmp_path)
+
+
+def test_create_and_delete_share_by_key(page: Page, radicale_server: str) -> None:
+    login(page, radicale_server)
+    create_collection(page, radicale_server)
+    page.hover("article:not(.hidden)")
+    page.click('article:not(.hidden) a[data-name="share"]', force=True, strict=True)
+
+    expect(
+        page.locator("tr[data-name='sharetokenrowtemplate']:not(.hidden)")
+    ).to_have_count(0)
+
+    page.click('button[data-name="sharebytoken_ro"]')
+    expect(
+        page.locator("tr[data-name='sharetokenrowtemplate']:not(.hidden)")
+    ).to_have_count(1)
+    # TODO: Check for R/O state
+    page.click('tr:not(.hidden) button[data-name="delete"]', strict=True)
+    expect(
+        page.locator("tr[data-name='sharetokenrowtemplate']:not(.hidden)")
+    ).to_have_count(0)
+    page.click('button[data-name="sharebytoken_rw"]')
+    expect(
+        page.locator("tr[data-name='sharetokenrowtemplate']:not(.hidden)")
+    ).to_have_count(1)
+    # TODO: Check for R/W state
+    page.click('tr:not(.hidden) button[data-name="delete"]', strict=True)
+    expect(
+        page.locator("tr[data-name='sharetokenrowtemplate']:not(.hidden)")
+    ).to_have_count(0)

radicale/__main__.py

@@ -1,7 +1,7 @@
 # This file is part of Radicale - CalDAV and CardDAV server
 # Copyright © 2011-2017 Guillaume Ayoub
 # Copyright © 2017-2022 Unrud <unrud@outlook.com>
-# Copyright © 2024-2025 Peter Bieringer <pb@bieringer.de>
+# Copyright © 2024-2026 Peter Bieringer <pb@bieringer.de>
 #
 # This library is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -33,7 +33,8 @@
 from types import FrameType
 from typing import List, Optional, cast
 
-from radicale import VERSION, config, item, log, server, storage, types
+from radicale import (VERSION, config, item, log, server, sharing, storage,
+                      types)
 from radicale.log import logger
 
 
@@ -67,6 +68,8 @@ def exit_signal_handler(signal_number: int,
                         help="check the storage for errors and exit")
     parser.add_argument("--verify-item", action="store", nargs=1,
                         help="check the provided item file for errors and exit")
+    parser.add_argument("--verify-sharing", action="store_true",
+                        help="check the sharing database for errors and exit")
     parser.add_argument("-C", "--config",
                         help="use specific configuration files", nargs="*")
     parser.add_argument("-D", "--debug", action="store_const", const="debug",
@@ -209,6 +212,19 @@ def exit_signal_handler(signal_number: int,
             sys.exit(1)
         return
 
+    if args_ns.verify_sharing:
+        logger.info("Verifying sharing database")
+        try:
+            sharing_ = sharing.load(configuration)
+            if not sharing_.verify():
+                logger.critical("Sharing database verification failed")
+                sys.exit(1)
+        except Exception as e:
+            logger.critical("An exception occurred during sharing database "
+                            "verification: %s", e, exc_info=True)
+            sys.exit(1)
+        return
+
     # Create a socket pair to notify the server of program shutdown
     shutdown_socket, shutdown_socket_out = socket.socketpair()