Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python

Show recipients only the share-reason tag/folder (foreign, non-filterable, leftmost) and prevent foreign folder-filter lockout (#314)

Murtaza Nasire92e2a85f9ad
diff --git a/src/api/folders.py b/src/api/folders.py
index 296aa99a..1298cbb5 100644
--- a/src/api/folders.py
+++ b/src/api/folders.py
@@ -647,7 +647,8 @@ def _apply_folder_auto_shares(recording, folder):
can_edit=(membership.role == 'admin'),
can_reshare=False,
source_type='group_folder',
- source_tag_id=None # We don't use this field for folders
+ source_tag_id=None,
+ source_folder_id=folder.id # share-reason folder, surfaced to the recipient (#314)
)
db.session.add(share)
diff --git a/src/api/recordings.py b/src/api/recordings.py
index c2ec6325..579187a1 100644
--- a/src/api/recordings.py
+++ b/src/api/recordings.py
@@ -1849,10 +1849,21 @@ def get_recordings_paginated():
# Execute query
recordings = db.session.execute(stmt).scalars().all()
+ # Batch-load this viewer's shares for the page so serialization can resolve
+ # the #314 share-reason tag/folder without an N+1 query.
+ page_rec_ids = [r.id for r in recordings]
+ share_map = {}
+ if page_rec_ids:
+ for s in InternalShare.query.filter(
+ InternalShare.recording_id.in_(page_rec_ids),
+ InternalShare.shared_with_user_id == current_user.id
+ ).all():
+ share_map[s.recording_id] = s
+
# Enrich recordings with sharing metadata
enriched_recordings = []
for recording in recordings:
- rec_dict = recording.to_list_dict(viewer_user=current_user)
+ rec_dict = recording.to_list_dict(viewer_user=current_user, share_map=share_map)
# Add sharing metadata
is_owner = recording.user_id == current_user.id
@@ -1878,11 +1889,8 @@ def get_recordings_paginated():
rec_dict['shared_with_count'] = 0
rec_dict['public_share_count'] = 0
- # Get share permissions
- share = InternalShare.query.filter_by(
- recording_id=recording.id,
- shared_with_user_id=current_user.id
- ).first()
+ # Get share permissions (reuse the batched map)
+ share = share_map.get(recording.id)
if share:
rec_dict['share_info'] = {
diff --git a/src/init_db.py b/src/init_db.py
index a0737437..7e842171 100644
--- a/src/init_db.py
+++ b/src/init_db.py
@@ -376,6 +376,9 @@ def initialize_database(app):
if add_column_if_not_exists(engine, 'internal_share', 'source_type', "VARCHAR(20) DEFAULT 'manual'"):
app.logger.info("Added source_type column to internal_share table")
+ if add_column_if_not_exists(engine, 'internal_share', 'source_folder_id', 'INTEGER'):
+ app.logger.info("Added source_folder_id column to internal_share table")
+
if add_column_if_not_exists(engine, 'internal_share', 'source_tag_id', 'INTEGER'):
app.logger.info("Added source_tag_id column to internal_share table")
diff --git a/src/models/recording.py b/src/models/recording.py
index 3fc32a37..195a8c57 100644
--- a/src/models/recording.py
+++ b/src/models/recording.py
@@ -268,12 +268,57 @@ class Recording(db.Model):
}
return None
- def to_list_dict(self, viewer_user=None, duplicate_info_map=None):
+ def _serialize_tags_and_folder(self, viewer_user, share_map=None):
+ """Build (tags, folder, folder_id) for a viewer, applying #314 rules.
+
+ For a recording the viewer does NOT own, only the tag/folder that GRANTED
+ access (the share-reason, from the InternalShare row) is surfaced, each
+ flagged ``is_foreign: True`` so the UI can mark it and keep it
+ non-filterable. The owner's other tags/folder are never leaked. Owners
+ (and the no-viewer backward-compat case) see their tags/folder normally.
+
+ share_map: optional {recording_id: InternalShare} to avoid an N+1 query
+ in list views; falls back to a per-recording lookup when not provided.
+ """
+ visible_tags = self.get_visible_tags(viewer_user)
+ is_foreign = viewer_user is not None and self.user_id != viewer_user.id
+
+ if not is_foreign:
+ tags = [tag.to_dict() for tag in visible_tags] if visible_tags else []
+ folder = self.folder.to_dict() if self.folder else None
+ return tags, folder, self.folder_id
+
+ from src.models.sharing import InternalShare
+ if share_map is not None:
+ share = share_map.get(self.id)
+ else:
+ share = InternalShare.query.filter_by(
+ recording_id=self.id, shared_with_user_id=viewer_user.id
+ ).first()
+ reason_tag_id = share.source_tag_id if share else None
+ reason_folder_id = getattr(share, 'source_folder_id', None) if share else None
+
+ tags = []
+ if reason_tag_id:
+ for tag in visible_tags:
+ if tag.id == reason_tag_id:
+ td = tag.to_dict()
+ td['is_foreign'] = True
+ tags.append(td)
+ if reason_folder_id and self.folder_id == reason_folder_id and self.folder:
+ folder = self.folder.to_dict()
+ folder['is_foreign'] = True
+ return tags, folder, self.folder_id
+ return tags, None, None
+
+ def to_list_dict(self, viewer_user=None, duplicate_info_map=None, share_map=None):
"""
Lightweight dict for list views - excludes expensive HTML conversions.
Args:
viewer_user: User viewing the recording (for tag visibility filtering)
+ share_map: optional {recording_id: InternalShare} for #314 share-reason
+ resolution without an N+1 query.
"""
# Import here to avoid circular dependencies
from src.models.sharing import InternalShare, Share
@@ -288,8 +333,7 @@ class Recording(db.Model):
Share.recording_id == self.id
).scalar() or 0
- # Get visible tags for this viewer
- visible_tags = self.get_visible_tags(viewer_user)
+ tags_ser, folder_ser, folder_id_ser = self._serialize_tags_and_folder(viewer_user, share_map)
return {
'id': self.id,
@@ -307,9 +351,9 @@ class Recording(db.Model):
'audio_deleted_at': self.audio_deleted_at.isoformat() if self.audio_deleted_at else None,
'audio_available': self.audio_deleted_at is None,
'deletion_exempt': self.deletion_exempt,
- 'folder_id': self.folder_id,
- 'folder': self.folder.to_dict() if self.folder else None,
- 'tags': [tag.to_dict() for tag in visible_tags] if visible_tags else [],
+ 'folder_id': folder_id_ser,
+ 'folder': folder_ser,
+ 'tags': tags_ser,
'duplicate_info': self._dup_from_map_or_query(duplicate_info_map),
'shared_with_count': shared_with_count,
'public_share_count': public_share_count,
@@ -337,13 +381,15 @@ class Recording(db.Model):
return {'total_copies': entry['total_copies'], 'copies': copies}
return self.get_duplicate_info()
- def to_dict(self, include_html=True, viewer_user=None, duplicate_info_map=None):
+ def to_dict(self, include_html=True, viewer_user=None, duplicate_info_map=None, share_map=None):
"""
Full dict with optional HTML conversion for notes/summary.
Args:
include_html: Whether to include HTML-rendered markdown fields
viewer_user: User viewing the recording (for tag visibility filtering)
+ share_map: optional {recording_id: InternalShare} for #314 share-reason
+ resolution without an N+1 query.
"""
# Import here to avoid circular dependencies
from src.models.sharing import InternalShare, Share
@@ -358,8 +404,7 @@ class Recording(db.Model):
Share.recording_id == self.id
).scalar() or 0
- # Get visible tags for this viewer
- visible_tags = self.get_visible_tags(viewer_user)
+ tags_ser, folder_ser, folder_id_ser = self._serialize_tags_and_folder(viewer_user, share_map)
# Get user-specific notes
user_notes = self.get_user_notes(viewer_user)
@@ -388,9 +433,9 @@ class Recording(db.Model):
'audio_available': self.audio_deleted_at is None,
'audio_duration': self.get_audio_duration(allow_probe_fallback=False),
'deletion_exempt': self.deletion_exempt,
- 'folder_id': self.folder_id,
- 'folder': self.folder.to_dict() if self.folder else None,
- 'tags': [tag.to_dict() for tag in visible_tags] if visible_tags else [],
+ 'folder_id': folder_id_ser,
+ 'folder': folder_ser,
+ 'tags': tags_ser,
'events': [event.to_dict() for event in self.events] if self.events else [],
'prompt_variables': self.prompt_variables or {},
'resolved_hotwords': self.resolved_hotwords,
diff --git a/src/models/sharing.py b/src/models/sharing.py
index b58282ba..9c986b1e 100644
--- a/src/models/sharing.py
+++ b/src/models/sharing.py
@@ -58,8 +58,11 @@ class InternalShare(db.Model):
can_reshare = db.Column(db.Boolean, default=False) # Can share with others
# Source tracking for share cleanup
- source_type = db.Column(db.String(20), default='manual') # 'manual' or 'group_tag'
+ source_type = db.Column(db.String(20), default='manual') # 'manual', 'group_tag', or 'group_folder'
source_tag_id = db.Column(db.Integer, db.ForeignKey('tag.id', ondelete='SET NULL'), nullable=True)
+ # The group folder that auto-shared this recording (when source_type='group_folder').
+ # Lets a recipient be shown only the share-reason folder, not the owner's other metadata (#314).
+ source_folder_id = db.Column(db.Integer, db.ForeignKey('folder.id', ondelete='SET NULL'), nullable=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
diff --git a/static/js/app.modular.js b/static/js/app.modular.js
index f7867118..2a991b48 100644
--- a/static/js/app.modular.js
+++ b/static/js/app.modular.js
@@ -3255,6 +3255,18 @@ document.addEventListener('DOMContentLoaded', async () => {
recordingsComposable.loadRecordings(1, false, searchQuery.value);
});
+ // Guard against being stuck filtering by a folder the user can't
+ // access — e.g. a foreign folder ID persisted from a shared recording
+ // (#314). Once folders load, drop any filter that isn't a real,
+ // owned/accessible folder so "All Recordings" is always reachable.
+ watch(availableFolders, (folders) => {
+ const f = filterFolder.value;
+ if (f && f !== 'none' && Array.isArray(folders) &&
+ !folders.some(folder => String(folder.id) === String(f))) {
+ filterFolder.value = '';
+ }
+ });
+
watch(sortBy, (newValue) => {
localStorage.setItem('recordingsSortBy', newValue);
recordingsComposable.loadRecordings(1, false, searchQuery.value);
diff --git a/templates/components/sidebar.html b/templates/components/sidebar.html
index cc94925f..d5b30246 100644
--- a/templates/components/sidebar.html
+++ b/templates/components/sidebar.html
@@ -470,9 +470,19 @@
visible recording is in it and the pill would be
redundant. Hidden for incognito recordings (no
folder association). -->
- <div v-if="(foldersEnabled && !filterFolder && recording.folder_id && !recording.incognito) || getRecordingTags(recording).length > 0 || recording.duplicate_info || (recording.mime_type && recording.mime_type.startsWith('video/') && !recording.audio_deleted_at && !recording.incognito)"
+ <div v-if="(foldersEnabled && !filterFolder && recording.folder_id && !recording.incognito) || (recording.folder && recording.folder.is_foreign) || getRecordingTags(recording).length > 0 || recording.duplicate_info || (recording.mime_type && recording.mime_type.startsWith('video/') && !recording.audio_deleted_at && !recording.incognito)"
class="flex flex-wrap items-center gap-1 mt-1">
- <button v-if="foldersEnabled && !filterFolder && recording.folder_id && !recording.incognito"
+ <!-- Foreign (shared-in) folder: the folder that granted access. Shown
+ leftmost, marked, and NOT clickable — it isn't a folder you own,
+ so it must never become a sticky filter (#314). -->
+ <span v-if="recording.folder && recording.folder.is_foreign && !recording.incognito"
+ class="chip"
+ :style="{ backgroundColor: recording.folder.color || '#6B7280', color: getContrastTextColor(recording.folder.color || '#6B7280') }"
+ :title="t('sharing.sharedBadge') + ': ' + recording.folder.name">
+ <i class="fas fa-share-nodes"></i>
+ <span class="chip__label" v-text="recording.folder.name"></span>
+ </span>
+ <button v-if="foldersEnabled && !filterFolder && recording.folder_id && !recording.incognito && !(recording.folder && recording.folder.is_foreign)"
@click.stop="filterFolder = recording.folder_id"
class="chip chip--clickable"
:style="{ backgroundColor: getFolderColor(recording.folder_id), color: getContrastTextColor(getFolderColor(recording.folder_id)) }"
@@ -480,14 +490,24 @@
<i class="fas fa-folder"></i>
<span class="chip__label" v-text="getFolderName(recording.folder_id)"></span>
</button>
- <button v-for="tag in getRecordingTags(recording).slice(0, 4)" :key="tag.id"
- @click.stop="filterByTag(tag)"
- class="chip chip--clickable"
- :style="{ backgroundColor: tag.color, color: getContrastTextColor(tag.color) }"
- :title="tag.group_id ? ('Group: ' + tag.group_name) : ('Filter by ' + tag.name)">
- <i v-if="tag.group_id" class="fas fa-users"></i>
- <span class="chip__label" v-text="tag.name"></span>
- </button>
+ <template v-for="tag in getRecordingTags(recording).slice(0, 4)" :key="tag.id">
+ <!-- Foreign (share-reason) tag: marked, not clickable (#314) -->
+ <span v-if="tag.is_foreign"
+ class="chip"
+ :style="{ backgroundColor: tag.color, color: getContrastTextColor(tag.color) }"
+ :title="t('sharing.sharedBadge') + ': ' + tag.name">
+ <i class="fas fa-share-nodes"></i>
+ <span class="chip__label" v-text="tag.name"></span>
+ </span>
+ <button v-else
+ @click.stop="filterByTag(tag)"
+ class="chip chip--clickable"
+ :style="{ backgroundColor: tag.color, color: getContrastTextColor(tag.color) }"
+ :title="tag.group_id ? ('Group: ' + tag.group_name) : ('Filter by ' + tag.name)">
+ <i v-if="tag.group_id" class="fas fa-users"></i>
+ <span class="chip__label" v-text="tag.name"></span>
+ </button>
+ </template>
<span v-if="getRecordingTags(recording).length > 4"
class="inline-flex items-center px-1.5 py-0.5 rounded-md text-xs text-[var(--text-muted)]"
:title="'More tags...'">
diff --git a/tests/test_share_reason_visibility.py b/tests/test_share_reason_visibility.py
new file mode 100644
index 00000000..900e1bd0
--- /dev/null
+++ b/tests/test_share_reason_visibility.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+#314: a recipient of a shared recording must only see the tag/folder that
+GRANTED access (the share-reason), flagged foreign — never the owner's other
+tags/folder. Owners see their own metadata unchanged.
+
+Run:
+ docker run --rm -v $PWD:/app:ro -e UPLOAD_FOLDER=/tmp/up \
+ -e ASR_BASE_URL=http://x:9999 speakr-test:cov \
+ sh -c "cd /app && python -m pytest tests/test_share_reason_visibility.py -q"
+"""
+
+import uuid
+
+import pytest
+
+from src.app import app, db
+from src.models import (
+ User, Recording, Folder, Group, GroupMembership, Tag, RecordingTag,
+)
+from src.models.sharing import InternalShare
+
+
+def _u():
+ s = uuid.uuid4().hex[:8]
+ u = User(username=f"u_{s}", email=f"{s}@local.test", password="x")
+ db.session.add(u)
+ db.session.commit()
+ return u
+
+
+def ctx():
+ with app.app_context():
+ yield
+
+
+def _tag_recording(rec, tag):
+ db.session.add(RecordingTag(recording_id=rec.id, tag_id=tag.id, order=0))
+ db.session.commit()
+
+
+def test_foreign_recording_shows_only_share_reason_tag(ctx):
+ owner, viewer = _u(), _u()
+ grp = Group(name=f"g_{uuid.uuid4().hex[:6]}")
+ db.session.add(grp)
+ db.session.commit()
+ db.session.add(GroupMembership(group_id=grp.id, user_id=viewer.id, role='member'))
+ db.session.add(GroupMembership(group_id=grp.id, user_id=owner.id, role='admin'))
+
+ group_tag = Tag(name="ShareTag", user_id=owner.id, group_id=grp.id)
+ personal_tag = Tag(name="OwnerPrivate", user_id=owner.id)
+ personal_folder = Folder(name="OwnerFolder", user_id=owner.id)
+ db.session.add_all([group_tag, personal_tag, personal_folder])
+ db.session.commit()
+
+ rec = Recording(user_id=owner.id, title="R", audio_path="local://r.mp3",
+ status="COMPLETED", folder_id=personal_folder.id)
+ db.session.add(rec)
+ db.session.commit()
+ _tag_recording(rec, group_tag)
+ _tag_recording(rec, personal_tag)
+
+ db.session.add(InternalShare(
+ recording_id=rec.id, owner_id=owner.id, shared_with_user_id=viewer.id,
+ source_type='group_tag', source_tag_id=group_tag.id))
+ db.session.commit()
+
+ # Viewer (recipient): only the share-reason group tag, flagged foreign; no
+ # personal tag, and no folder (the share was via a tag, not a folder).
+ vd = rec.to_dict(viewer_user=viewer)
+ assert [t['name'] for t in vd['tags']] == ["ShareTag"]
+ assert vd['tags'][0]['is_foreign'] is True
+ assert vd['folder'] is None and vd['folder_id'] is None
+
+ # Owner: sees their own personal tag + group tag and their folder, no foreign flag.
+ od = rec.to_dict(viewer_user=owner)
+ names = sorted(t['name'] for t in od['tags'])
+ assert names == ["OwnerPrivate", "ShareTag"]
+ assert all('is_foreign' not in t for t in od['tags'])
+ assert od['folder']['name'] == "OwnerFolder"
+
+
+def test_foreign_recording_shows_only_share_reason_folder(ctx):
+ owner, viewer = _u(), _u()
+ grp = Group(name=f"g_{uuid.uuid4().hex[:6]}")
+ db.session.add(grp)
+ db.session.commit()
+ db.session.add(GroupMembership(group_id=grp.id, user_id=viewer.id, role='member'))
+ db.session.commit()
+
+ group_folder = Folder(name="TeamFolder", user_id=owner.id, group_id=grp.id)
+ db.session.add(group_folder)
+ db.session.commit()
+
+ rec = Recording(user_id=owner.id, title="R2", audio_path="local://r2.mp3",
+ status="COMPLETED", folder_id=group_folder.id)
+ db.session.add(rec)
+ db.session.commit()
+
+ db.session.add(InternalShare(
+ recording_id=rec.id, owner_id=owner.id, shared_with_user_id=viewer.id,
+ source_type='group_folder', source_folder_id=group_folder.id))
+ db.session.commit()
+
+ vd = rec.to_dict(viewer_user=viewer)
+ assert vd['folder']['name'] == "TeamFolder"
+ assert vd['folder']['is_foreign'] is True
+ assert vd['folder_id'] == group_folder.id
+ assert vd['tags'] == []
+
+
+def test_manual_share_hides_owner_tags_and_folder(ctx):
+ owner, viewer = _u(), _u()
+ personal_tag = Tag(name="Private", user_id=owner.id)
+ personal_folder = Folder(name="Mine", user_id=owner.id)
+ db.session.add_all([personal_tag, personal_folder])
+ db.session.commit()
+ rec = Recording(user_id=owner.id, title="R3", audio_path="local://r3.mp3",
+ status="COMPLETED", folder_id=personal_folder.id)
+ db.session.add(rec)
+ db.session.commit()
+ _tag_recording(rec, personal_tag)
+ db.session.add(InternalShare(
+ recording_id=rec.id, owner_id=owner.id, shared_with_user_id=viewer.id,
+ source_type='manual'))
+ db.session.commit()
+
+ # A manually shared recording exposes none of the owner's tags/folder.
+ vd = rec.to_dict(viewer_user=viewer)
+ assert vd['tags'] == []
+ assert vd['folder'] is None and vd['folder_id'] is None