Compare commits

..

47 Commits

Author SHA1 Message Date
lebaudantoine a3c522b21b ♿️(frontend) put the ProConnect link label inside the link
The ProConnect sign-in link was an empty <a> named only by an
aria-label, its wording living in a CSS background image. RGAA
test 6.2.1 asks for a label between <a> and </a>.

Move the label into visually hidden text inside the link and drop
the aria-label, so the accessible name comes from the content.

Fixes #1898
2026-11-16 00:49:25 +01:00
lebaudantoine 906317d93c ♿️(frontend) use a heading for every connection test card title
Only cards with expandable details had an h3, so the titles of the
other cards were missing from the heading structure.

Wrap the row of non-expandable cards in an h3 too. No visual change.

RGAA 9.1

Fixes #1902
2026-11-16 00:49:25 +01:00
lebaudantoine b5820174a1 ♿️(frontend) show the focus ring on connection test detail cards
The global focus rule overrode the trigger's inset outline offset,
pushing the ring outside the card where overflow: hidden clipped it.

Force the inset offset so the ring stays visible.

RGAA 10.7

Fixes #1905
2026-11-16 00:49:25 +01:00
lebaudantoine 896693c147 📝(docs) invite readers to star the repository
Most people using La Suite Meet never land on GitHub, and those
who do had no prompt to star the project. Stars help other people
and public organisations discover it.

Add a single line at the end of the README introduction, kept
discreet to avoid stacking a second callout next to the Matrix one.
2026-11-14 01:34:08 +01:00
lebaudantoine b6b3ce28db ♿️(frontend) name settings tabs on small screens
Below 800px the settings tabs only render their icon, which left
each tab, and the tab panel it labels, without an accessible name.
Screen reader users could not tell which settings section they
were opening.

Set aria-label on each tab with its existing translated label.
On wide screens it matches the visible text, so nothing changes.

Fixes #1855
2026-11-14 01:05:10 +01:00
lebaudantoine f27f2fb7de ♿️(frontend) raise contrast of inactive intro slider dots
Inactive dots of the home intro slider were 1.57:1 on white, below
the 3:1 RGAA 3.3 asks for, so low-vision users could not tell how
many slides exist.

They are now hollow: a primary.100 fill with a primary.500 outline
at 4.22:1 on white. This passes without darkening the dots so much
that they blend with the active one. Dots grow from 6px to 8px to
keep the outline legible.

Fixes #1851
2026-11-14 01:05:10 +01:00
lebaudantoine 061025b928 ♿️(frontend) structure connection test cards as lists
The step cards of each connection test section are a series of
similar items but were rendered as plain divs, so assistive
technologies could not announce them as a list or give the item
count.

Render each series as a ul with one li per card. The heading and
accordion stay inside the li. No visual change.

Fixes #1903
2026-11-14 01:05:10 +01:00
lebaudantoine 100044eeaa ♿️(frontend) warn before language change in settings
Selecting a language in the settings modal translates the whole
interface immediately. Nothing announced this beforehand, so a
screen reader user could end up in a language they don't read,
with the dialog title already announced in it.

Add a visible description under the "Langue de l'application"
field, linked to the select trigger with aria-describedby, stating
that the change applies to the whole interface on selection.

This satisfies RGAA 7.4 (WCAG 3.2.2 On Input) without adding an
extra confirmation step.

Fixes #1859
2026-11-14 01:05:10 +01:00
lebaudantoine e158b4faaf ♿️(frontend) fix grey text contrast on the connection test page
Zero counters, pending and skipped labels and step summaries used
greys below the 4.5:1 minimum of RGAA 3.2. They now use greyscale.600,
which passes on white, hovered and expanded rows.

Fixes #1897
2026-11-14 01:05:10 +01:00
lebaudantoine 3a1f0a342d ♿️(frontend) mark the language of each option in language selects
Language names are listed in their own language ("English",
"Deutsch", "Nederlands"...), but nothing told assistive technologies
so. Screen readers pronounced them with the rules of the interface
language, which can make them hard to recognise.

Select items accept an optional `lang`, rendered on a span around
the label. useLanguageLabels sets it for every language it returns.

RGAA 8.7

Fixes #1861
2026-11-13 23:38:16 +01:00
lebaudantoine 62571cd9fc ♿️(frontend) declare a background color with the body text color
Text colors were set without a matching background on the document.
With custom browser or system colors, the user's background could
end up behind our text color and make it unreadable.

Set both the default background and text colors on body, so they
are always defined as a pair.

RGAA 10.5

Fixes #1863
2026-11-13 23:38:05 +01:00
lebaudantoine 8fccf46429 ♿️(frontend) give the transcript language button an explicit name
In the transcript panel, the button showing the meeting language
opens the transcription settings, but its accessible name was only
the language itself, e.g. "Français (fr)". Screen reader users had no
way to know it changes the meeting language.

Add an aria-label that keeps the language and states the action. The
visible label is unchanged. Translated in all six locales.

RGAA 7.1

Fixes #1868
2026-11-13 23:37:48 +01:00
lebaudantoine 9481350383 ♿️(frontend) use level 2 headings in the recording side panels
The side panel already exposes its title as a level 1 heading. The
transcript and screen recording panels rendered their intro line as a
second h1, so screen reader users navigating by headings could not
tell the panel title from its subtitle.

Render both intro headings as h2 while keeping the h1 visual style,
so the hierarchy is correct and nothing changes on screen.

RGAA 9.1

Fixes #1882
2026-11-13 23:29:39 +01:00
lebaudantoine e9a58d270b 🚸(frontend) bring raised hands into view in the carousel
A raised hand matters as much as someone speaking, but it went
unnoticed when the tile was scrolled out of the carousel. It is now
brought to the top like a new speaker and stays visible while raised.
2026-11-13 23:26:49 +01:00
lebaudantoine e3351075aa 🚸(frontend) bring new speakers to the top of the carousel
In the focus layout, when someone off screen started speaking, their
tile replaced whichever tile was evicted, often at the bottom of the
column. A screen share that started did the same. Users had to scan
the whole column to find who was talking, and the spot changed every
time.

New speakers now always appear at the top, right below the local
camera and the screen shares, and the other tiles slide down by one.
The most relevant tiles are where the eye already is, and the column
moves in a predictable way.

The ordering still relies on LiveKit's sort and stable update; only
the position of the incoming tile changes. This is the enhancement
#1805 was after.
2026-11-13 23:26:48 +01:00
lebaudantoine 68198e9961 🐛(frontend) promote the active speaker in the carousel layout
Regression: in the focus layout, a participant who started speaking
while their tile was outside the visible part of the carousel was no
longer brought into view.

Cause: 81f23aeb moved useTracks in StageLayout to `updateOnlyOn: []`
so the whole stage stops re-rendering on every ActiveSpeakersChanged.
useVisualStableUpdate only promotes speakers when its host renders, so
it needs something to wake it up. The grid layout got that with
useSpeakerPromotionTrigger in the same commit; the carousel did not,
and nothing else re-renders it on speaker events.

Fix: the carousel now uses the same tripwire. Unlike the grid, which
passes its current page, the carousel renders every tile in a scroll
container, so only the first maxVisibleTiles are passed as visible.

The tripwire also takes the full list of tiles the layout shows and
ignores speakers who have none. In the focus layout the pinned camera
is rendered by the focus view, not the carousel: without this, each
speaker event from that participant would force a render that cannot
promote anyone. The grid passes all its tracks, so its behaviour is
unchanged.

Known limit, not addressed here: when a single tile fits, it stays on
the local camera, which useVisualStableUpdate sorts first, so a remote
speaker cannot be promoted and the tripwire keeps firing for them.

This supersedes #1805, which will be closed. On top of this fix, it
pinned the active speaker to a fixed slot next to the local camera,
first with a 2s hold, a reserved slot and an eligibility check
(867a14d0), then simplified to the last remote speaker with no timer
(378e3d01). That is an enhancement rather than part of the fix, and it
is left out here to keep the regression fix small. It can come back in
a dedicated PR; it would also cover the single-tile case above.
2026-11-13 23:26:48 +01:00
lebaudantoine e3140e0300 🐛(frontend) apply the sans font token on every page
Since routes are lazy loaded, the LiveKit stylesheet only ships
with the room chunk. It was the only rule applying `--fonts-sans`
to the document, so pages outside a room fell back to Panda's
preflight system font stack, ignoring custom CSS themes (e.g.
Marianne in the DINUM image) and accessibility fonts.

Point Panda's `--global-font-body` at `--fonts-sans` so the
document font follows the token regardless of which chunks are
loaded.
2026-11-13 23:26:46 +01:00
lebaudantoine eb345610a7 🐛(backend) allow muting when everyone_can_mute is stored as null
A stored null was read as disabled by CanMuteParticipant, since
`.get(key, True)` only defaults when the key is missing, while the
frontend reads null as enabled. Only an explicit `false` now
disables participant muting.

Fixes #1942
Supersedes #1944
2026-11-13 01:31:33 +01:00
lebaudantoine 48d144877a 🍱(frontend) add Portuguese glyphs to Marianne subsetted fonts
The Marianne subsets were generated with a French-only whitelist, so
most Portuguese accented letters were missing. Words like "não",
"ação" or "país" fell back to the system font for single letters,
which looked broken in the middle of Marianne text.

Regenerate the 12 files from the full Marianne sources tracked in
numerique-gouv/lasuite-landingpage (src/fonts/sources), using the
glyphhanger 5.0.0 command documented there, with these characters
added to the whitelist:

- letters: Á Â Ã Í Ó Õ Ú Ü á ã í ó õ ú ü
- ordinal indicators: º ª
- punctuation: – — ‘

The previous files came from an older whitelist, so this also brings
in the characters added upstream since then (ä ł ń $ ~). No glyph
was removed. Each file grows by roughly 1 KB.
2026-11-13 00:29:07 +01:00
Railton Vasconcelos 5b6ed14a31 🌐(i18n) add Portuguese language support
Add Portuguese (pt / pt-BR) localization across the frontend UI
(all 11 i18next namespaces) and backend Django catalog (pt_BR).

Contributed by the Alan Turing Laboratory (ATLab) at the Federal
University of Ceara (UFC), Brazil.
2026-11-13 00:07:32 +01:00
lebaudantoine 6f8f5d0386 🐛(frontend) accept meeting links with query params in join dialog
Meeting links inserted into events by the Outlook calendar add-in carry
tracking query parameters, e.g. `?from=outlook-addin` or `utm_*`.
Pasting such a link into the "Join a meeting" dialog failed: the
validation regex was anchored on the room id, so any trailing query
string made the link invalid, and the submit handler only stripped the
origin, so the query string would have ended up in the room id.

Parse the input with the URL API in a new `extractRoomId` helper, used
by both validation and submit. It accepts a bare room id or a link on
the current origin (trailing slash allowed), reads the room id from the
pathname only, and returns the query string and fragment separately so
they are kept when redirecting to the room (utm tracking is preserved).
2026-11-12 23:50:05 +01:00
lebaudantoine 25122deba2 🔒️(docker) move frontend to nginx/nginx-unprivileged image
The nginxinc/nginx-unprivileged image is no longer rebuilt and
ships libxslt 1.1.43-r3, affected by CVE-2026-125350,
CVE-2026-87636 and CVE-2026-9947.

Use nginx/nginx-unprivileged in both frontend images. Its
packages are up to date, so drop the manual package upgrades.
2026-11-12 23:29:14 +01:00
briquet 9ede799cb9 🔒️(docker) upgrade musl-utils to fix CVE-2026-107891
Update musl-utils in all alpine images
2026-11-07 00:02:49 +01:00
briquet cc4275c23c 👷(ci) ignore sqlite and zlib CVEs in trivy
Ignore CVE-2026-119374 and CVE-2026-119379 (libsqlite3-0) and
CVE-2026-85091 (zlib1g) until 2026-12-05: Debian trixie ships no
fixed version yet.
2026-11-06 22:14:51 +01:00
briquet d1489f8a61 📌(summary) pin kombu to keep celery workers compatible
Pin kombu to 5.6.2 to avoid problem with redis-py that require
a more recent version of Redis >= 6.X
2026-11-06 22:14:51 +01:00
Roee Sivan c6beb8ed3e ♿️(frontend) close the invite dialog with the Escape key
The "Your meeting is ready" dialog is a react-aria Dialog rendered
without a ModalOverlay, so nothing handled Escape. It stays non-modal
on purpose, so the meeting remains usable while it is open.

Reuse useEscapeToClose, as the side panel does, so Escape only closes
the dialog when focus is inside it and does not take the key from the
chat, the side panel or menus.

The dialog opens on its own when joining, so there is no trigger to
restore focus to. Both the close button and Escape now move focus to
the first control bar button instead of letting it fall back to body.
2026-11-05 22:38:01 +01:00
Florent Chehab 505c55d3b9 📝(changelog) document summary privacy improvements
Record signed URL protection, secret-aware validation errors and safer
logging and Sentry capture under Unreleased.

Document the retention of redacted frame locals and application DEBUG
diagnostics.
2026-11-05 20:18:34 +01:00
Florent Chehab 72d964656c 🔒️(summary) scrub Sentry events and breadcrumbs
Redact signed URLs and remove untrusted exception messages, request
bodies and breadcrumb payloads from Sentry events and transactions.

Preserve stack-frame locals after the existing content scrubber runs.
Cover real HTTP failures, chained exceptions and DEBUG breadcrumbs.
2026-11-05 20:18:34 +01:00
Florent Chehab 58bf9a7d82 🔒️(summary) hide sensitive Celery task details
Publish redacted task argument representations and filter task results
and exception details from INFO-and-above Celery trace logs.

Keep task identity and DEBUG diagnostics available.
2026-11-05 20:18:34 +01:00
Florent Chehab 72af9d629e 🔒️(summary) sanitize analytics client failures
Avoid chaining raw analytics client errors or logging feature-flag
exception messages. Preserve event metadata and feature-flag fallback
behavior.
2026-11-05 20:18:34 +01:00
Florent Chehab 3cd2cb5591 🔒️(summary) sanitize LLM failures and summary progress logs
Raise safe LLM errors for upstream failures and invalid structured
responses without retaining the original exception chain.

Keep generated section titles out of INFO progress logs and preserve
the existing DEBUG diagnostics.
2026-11-05 20:18:34 +01:00
Florent Chehab fcd37b0f26 🔒️(summary) sanitize upstream HTTP failures
Replace raw download, transcription, webhook and Docs exceptions with
safe messages while preserving retryable exception categories.

Retain document IDs and DEBUG responses. Give webhook regression tests
their own tenant settings instead of relying on development tenants.
2026-11-05 20:18:34 +01:00
Florent Chehab b6a8ae7d35 🔒️(summary) clean validation errors at application boundaries
Use cleaned validation errors for task execution, prerun signals,
transcription responses and API results. Share the same cleanup with
FastAPI validation responses while retaining ordinary input values.

Verify secret masking, preserved diagnostics and summary retries.
2026-11-05 20:18:34 +01:00
Florent Chehab 68848c0d6f 🔒️(summary) protect signed URL model fields with SecretStr
Validate signed URLs as secrets and reveal them explicitly for file
access, Celery messages, webhook delivery and authorized API responses.

Cover model representations, nested broker payloads and URL consumers.
2026-11-05 20:18:34 +01:00
Florent Chehab 2ea5c85436 🔒️(summary) add secret-aware validation errors
Preserve Pydantic error categories and diagnostics while masking nested
SecretStr inputs and avoiding retained validator exception objects.

Support custom error codes and safe pickling for Celery.
2026-11-05 20:18:34 +01:00
Florent Chehab 57a4446710 🔒️(summary) redact signed URLs in source logs and analytics
Strip URL credentials, query strings and fragments from file-service
logs and analytics source metadata using one shared helper.

Cover malformed URLs, non-string inputs and signed source URLs.
2026-11-05 20:18:34 +01:00
briquet df723e6a0e 🔒️(agents) upgrade python to 3.14.10 to fix CVE-2026-109518
The python:3.14.8-slim base image ships apt 3.0.3, which is affected by
CVE-2026-109518.
2026-11-05 18:30:51 +01:00
briquet 900ebd3edd 👷(ci) ignore zlib CVE-2026-76844 in trivy
Debian hasn't provided a fix yet
2026-11-05 18:30:51 +01:00
briquet c4fbfdd302 🔒️(backend) refuse unregistered rooms whose slug is a UUID
A registered room's LiveKit room is named after its id, and a room slug
can never be a UUID. A lookup such as "<id>!" does not parse as a UUID,
so it was searched as a slug, found nothing and was treated as an
unregistered room. Its slug, normalized back to the bare id, then got a
token for the registered room without going through the lobby, whenever
unregistered rooms are allowed.

Unregistered rooms whose slug is a UUID now return a 404.
2026-11-05 18:30:51 +01:00
briquet 6f1b9ddba7 🐛(frontend) show join errors instead of silently waiting in the lobby
When joining failed with anything but a 404/410, the lobby started
waiting as if entry had to be requested. Requesting entry now fails
uniformly.
2026-11-05 18:30:51 +01:00
briquet e412dec76f 🔥(backend) drop is_administrable from unregistered room payloads
Registered rooms stopped returning is_administrable in v1.25.0, and
nothing reads it for unregistered rooms either: administrable rooms are
detected from their accesses.

The frontend ApiRoom type drops is_administrable as well, which the API
no longer returns.
2026-11-05 18:30:51 +01:00
briquet 6af43ebf1d 🔒️(frontend) send the display name in the join request body
The room query joins the room, creating it first when missing, and keeps
the response, LiveKit credentials included, in the room cache entry. It
joins again to renew the token once its data is 6 hours old.

Conference and Lobby component were simplified by regrouping custom
hooks, states/refs, memo/callback and mutations.
2026-11-05 18:30:51 +01:00
briquet 4e953da226 🔒️(backend) issue room access tokens via a POST join endpoint
Room access tokens were returned by GET /rooms/{id}/, with the LiveKit
display name passed as a query parameter. We want to leverage Django's CSRF
checks and avoid displaying usernames in access logs.

Tokens are now only minted by POST /rooms/{id}/join/, which reads the
display name from the request body and the livekit information have been
removed where they were not required.

Joining an unregistered room now builds its livekit block with
generate_livekit_config, which mints the same token as the dict it
replaces.

The serializer and the lobby now share LobbyService.can_bypass_lobby to
decide who may enter directly to centralize the logic.
2026-11-05 18:30:51 +01:00
leo f45628d881 ⬆️(dependencies) update python dependencies in summary
Update python dependencies in summary.

Co-Authored-By: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
2026-11-03 20:19:34 +01:00
leo 6fb698a63d ⬆️(dependencies) update python dependencies in agents
Update python dependencies in agents.

Co-Authored-By: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
2026-11-03 20:19:34 +01:00
leo 5887795858 ⬆️(dependencies) update python dependencies in backend
Update python dependencies in backend.

Co-Authored-By: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
2026-11-03 20:19:34 +01:00
leo 21b9b42cb1 👷(ci) update trivyignore
The trivy scan fails on HIGH vulnerability CVE-2026-119373
found in the Debian 13 base images. As it has no fixed version,
add an exception to trivyignore. Also add expiry date for all
exceptions.
2026-11-03 19:41:26 +01:00
117 changed files with 5554 additions and 678 deletions
+17 -8
View File
@@ -2,19 +2,28 @@
# Review regularly and remove entries once Debian ships a fix.
# util-linux
CVE-2026-76642
CVE-2026-78408
CVE-2026-78409
CVE-2026-78410
CVE-2026-76642 exp:2026-12-05
CVE-2026-78408 exp:2026-12-05
CVE-2026-78409 exp:2026-12-05
CVE-2026-78410 exp:2026-12-05
# acl
CVE-2026-54369
CVE-2026-54369 exp:2026-12-05
# ncurses
CVE-2025-69720
CVE-2025-69720 exp:2026-12-05
# systemd
CVE-2026-16742
CVE-2026-16742 exp:2026-12-05
# perl-base (fix deferred by Debian)
CVE-2026-9538
CVE-2026-9538 exp:2026-12-05
# libsqlite3-0 (fixed in sid 3.54.1-1; trixie marked no-dsa / minor)
CVE-2026-119373 exp:2026-12-05
CVE-2026-119374 exp:2026-12-05
CVE-2026-119379 exp:2026-12-05
# zlib (fixed in sid 1:1.3.dfsg+really1.3.2-4; trixie still vulnerable)
CVE-2026-76844 exp:2026-12-05
CVE-2026-85091 exp:2026-12-05
+29
View File
@@ -10,6 +10,7 @@ and this project adheres to
### Added
- 🌐(i18n) add Portuguese language support
- ✨(frontend) add jittered exponential backoff to LiveKit reconnections
- ✨(frontend) tell participants when a recording is interrupted
@@ -22,11 +23,32 @@ and this project adheres to
- ⬆️(backend) update python dependencies
- ⬆️(agents) update python dependencies
- ⬆️(summary) update python dependencies
- 🔒️(backend) issue room access tokens via POST rooms/{id}/join/ only
- 🔒️(frontend) send the display name in the join request body
- 🔥(backend) drop is_administrable from unregistered room payloads
- 🍱(frontend) add Portuguese glyphs to Marianne subsetted fonts
- 🚸(frontend) bring new speakers to the top of the carousel
- 🚸(frontend) bring raised hands into view in the carousel
### Fixed
- 📌(summary) pin kombu to keep celery workers compatible with redis 5
- 🐛(frontend) show a page when the connection ends unexpectedly
- 🐛(frontend) show the transcript mic hint when every mic is muted
- 🐛(frontend) show join errors instead of silently waiting in the lobby
- 🐛(frontend) send users who cannot enter directly back to the lobby
- 🔒️(backend) refuse unregistered rooms whose slug is a UUID
- 🔒️(agents) upgrade python to 3.14.10 to fix CVE-2026-109518
- 🔒️(docker) upgrade musl-utils to 1.2.6-r3 to fix CVE-2026-107891
- ♿️(frontend) close the invite dialog with the Escape key #1916
- 🔒️(docker) move frontend to nginx/nginx-unprivileged image
- 🐛(frontend) accept meeting links with query params in join dialog
- 🐛(backend) allow muting when everyone_can_mute is stored as null #1942
- 🐛(frontend) apply the sans font token on every page
- 🐛(frontend) promote the active speaker in the carousel layout
- ♿️(frontend) show the focus ring on connection test detail cards
- ♿️(frontend) use a heading for every connection test card title
- ♿️(frontend) put the ProConnect link label inside the link
## [1.37.0] - 2026-11-01
@@ -38,6 +60,13 @@ and this project adheres to
- ⬆️(backend) upgrade django-lasuite to v1.0.0
- ⚡️(docker) build frontend assets natively for arm64 images
### Fixed
- 🔒️(summary) protect signed URLs in models, source logs and analytics metadata
- 🔒️(summary) mask secret validation inputs and sanitize upstream and task errors
- 🔒️(summary) scrub sensitive Sentry event and breadcrumb content while retaining
redacted frame locals and application DEBUG diagnostics
## [1.36.3] - 2026-10-23
### Fixed
+2 -1
View File
@@ -9,7 +9,8 @@ RUN python -m pip install --upgrade pip
# Upgrade system packages to install security updates
RUN apk update && \
apk upgrade && \
apk add --no-cache --upgrade 'ca-certificates>=20261020-r0' && \
apk add --no-cache --upgrade 'ca-certificates>=20261020-r0' \
'musl-utils>=1.2.6-r3' && \
update-ca-certificates
# ---- Back-end builder image ----
+2
View File
@@ -61,6 +61,8 @@ La Suite Meet is fully self-hostable and released under the MIT License, ensurin
We’re continuously adding new features to enhance your experience, with the latest updates coming soon!
⭐ **Find La Suite Meet useful?** Click the Star button at the top right of this page. It helps other people and public organisations discover the project.
### 🚀 Major roll out to all French public servants
On the 29th of January 2026, Prime Minister Sébastien Lecornu, announced the full deployment of Visio—the French government’s dedicated Meet platform—to all public servants. ([Source in English](https://www.nytimes.com/2026/01/29/world/europe/france-zoom-alternative-visio.html))
+29
View File
@@ -16,6 +16,35 @@ the following command inside your docker container:
## [Unreleased]
### Room access tokens moved to POST /join/
LiveKit access tokens are no longer returned when reading a room. They are henceforth issued by a dedicated `POST
/api/v1.0/rooms/{id}/join/` endpoint, which receives the display name in its JSON body. Display names therefore no
longer appear in URLs and token retrieval by logged-in users is now protected against CSRF.
- `GET /api/v1.0/rooms/{id}/` no longer returns the `livekit` block, and neither do the list, create and update
responses
- The `username` field of `POST /api/v1.0/rooms/{id}/request-entry/` is now limited to 255 characters
- When the caller may enter the room directly, the response contains the room data plus a `livekit` block
- When the caller must go through the lobby, the response has no `livekit` block
- Session-authenticated callers must send the CSRF token (`X-CSRFToken` header and `csrftoken` cookie)
- Every join returning a `livekit` block mints a new token, valid for 6 hours, and anonymous callers get a new
participant identity each time.
- Joining again returns no `livekit` block to callers admitted through the lobby.
- Unregistered rooms are always entered directly: joining one always returns a `livekit` block.
- Unregistered rooms are no longer described with an `is_administrable` field,
### Unregistered rooms can no longer be named after a UUID
When `ALLOW_UNREGISTERED_ROOMS` is enabled, reading or joining a room whose identifier normalizes to an empty slug or to
a UUID now returns a 404 instead of describing or letting callers join the unregistered room.
This closes a lobby bypass since a registered LiveKit room is named after its room id. An identifier crafted to not
parse as a UUID, yet to normalize to an existing room's id, matched no registered room and was treated as an
unregistered one. The token minted for that unregistered room was valid for the registered room: anyone could join a
trusted or restricted room without being admitted through the lobby.
## v1.37.0
### Crisp support chat replaced by the La Suite support form
+2 -8
View File
@@ -58,19 +58,13 @@ RUN npx webpack --mode production
# ---- Front-end image ----
FROM nginxinc/nginx-unprivileged:1.30.6-alpine3.24 AS frontend-production
FROM nginx/nginx-unprivileged:1.30.6-alpine3.24 AS frontend-production
USER root
RUN apk upgrade --no-cache libexpat && \
apk add --no-cache --upgrade 'pcre2>=10.49-r0' 'tiff>=4.7.2-r0' \
'libx11>=1.8.14-r0' 'ca-certificates>=20261020-r0' \
'brotli-libs>=1.2.1-r0' && \
apk del curl && \
RUN apk del curl && \
rm -f /usr/share/nginx/html/50x.html
USER nginx
USER nginx
# Un-privileged user running the application
ARG DOCKER_USER
USER ${DOCKER_USER}
+1 -1
View File
@@ -1,4 +1,4 @@
FROM python:3.14.8-slim AS base
FROM python:3.14.10-slim AS base
# Install system dependencies required by LiveKit, fetching packages over HTTPS only for Bureautix proxy
RUN sed -i "s|^URIs: http://|URIs: https://|" /etc/apt/sources.list.d/debian.sources \
+2 -3
View File
@@ -137,7 +137,7 @@ class CanMuteParticipant(permissions.BasePermission):
- Admins and owners can always mute.
- When `everyone_can_mute` is enabled on the room, any participant
currently in the room (proven by a valid LiveKit token for that room)
can mute.
can mute. It is enabled unless explicitly set to `False`.
"""
def has_object_permission(self, request, view, obj):
@@ -149,8 +149,7 @@ class CanMuteParticipant(permissions.BasePermission):
if not is_livekit_token_auth and obj.is_administrator_or_owner(request.user):
return True
everyone_can_mute = obj.configuration.get("everyone_can_mute", True)
if not everyone_can_mute:
if obj.configuration.get("everyone_can_mute") is False:
return False
if not is_livekit_token_auth:
+29 -27
View File
@@ -27,9 +27,12 @@ from timezone_field.rest_framework import TimeZoneSerializerField
from core import models, utils
from core.api.exceptions import ensure_room_not_deleted
from core.services.lobby import LobbyService
logger = logging.getLogger(__name__)
DISPLAY_NAME_MAX_LENGTH = 255
class UserSerializer(serializers.ModelSerializer):
"""Serialize users."""
@@ -170,17 +173,18 @@ class RoomSerializer(serializers.ModelSerializer):
return value
def to_representation(self, instance):
"""
Add users only for administrator users.
Add LiveKit credentials for public instance or related users/groups
"""
"""Add accesses only for administrator and owner users."""
output = super().to_representation(instance)
request = self.context.get("request")
if not request:
return output
role = instance.get_role(request.user)
if "role" in self.context:
role = self.context["role"]
else:
role = instance.get_role(request.user)
is_admin_or_owner = models.RoleChoices.check_administrator_role(
role
) or models.RoleChoices.check_owner_role(role)
@@ -193,26 +197,9 @@ class RoomSerializer(serializers.ModelSerializer):
)
output["accesses"] = access_serializer.data
should_access_room = (
(
instance.access_level == models.RoomAccessLevel.TRUSTED
and request.user.is_authenticated
)
or role is not None
or instance.is_public
)
if should_access_room:
room_id = f"{instance.id!s}"
username = request.query_params.get("username", None)
output["livekit"] = utils.generate_livekit_config(
room_id=room_id,
user=request.user,
username=username,
configuration=output["configuration"],
role=role,
)
else:
if not LobbyService.can_bypass_lobby(
room=instance, user=request.user, role=role
):
del output["pin_code"]
return output
@@ -355,10 +342,23 @@ class StartRecordingSerializer(BaseValidationOnlySerializer):
return value
class JoinRoomSerializer(BaseValidationOnlySerializer):
"""Validate the data sent to join a room."""
username = serializers.CharField(
required=False,
allow_blank=True,
allow_null=True,
max_length=DISPLAY_NAME_MAX_LENGTH,
help_text="Display name in the room. The default name is used when it "
"is missing, null or blank.",
)
class RequestEntrySerializer(BaseValidationOnlySerializer):
"""Validate request entry data."""
username = serializers.CharField(required=True)
username = serializers.CharField(required=True, max_length=DISPLAY_NAME_MAX_LENGTH)
participant_id = serializers.CharField(
required=False, allow_null=True, max_length=128
)
@@ -675,7 +675,9 @@ class RaiseHandSerializer(BaseValidationOnlySerializer):
class RenameParticipantSerializer(BaseValidationOnlySerializer):
"""Serializer for renaming a participant in a room."""
name = serializers.CharField(min_length=1, max_length=255, allow_blank=False)
name = serializers.CharField(
min_length=1, max_length=DISPLAY_NAME_MAX_LENGTH, allow_blank=False
)
class ExternalProcessEventSerializer(BaseValidationOnlySerializer):
+73 -24
View File
@@ -309,35 +309,35 @@ class RoomViewSet( # pylint: disable=too-many-public-methods
ensure_room_not_deleted(obj)
return obj
def _get_object_or_unregistered_slug(self):
"""Return the requested room, or the slug of an unregistered room."""
try:
return self.get_object(), None
except Http404:
slug = slugify(self.kwargs["pk"])
if not settings.ALLOW_UNREGISTERED_ROOMS or not slug or utils.is_uuid(slug):
raise
return None, slug
@staticmethod
def _get_unregistered_room_data(slug):
"""Describe an unregistered room, which only exists by its slug."""
return {
"id": None,
"slug": slug,
"access_level": RoomAccessLevel.PUBLIC,
}
def retrieve(self, request, *args, **kwargs):
"""
Allow unregistered rooms when activated.
For unregistered rooms we only return a null id and the livekit room and token.
LiveKit credentials are never returned: they are obtained by joining.
"""
try:
instance = self.get_object()
except Http404:
if not settings.ALLOW_UNREGISTERED_ROOMS:
raise
slug = slugify(self.kwargs["pk"])
username = request.query_params.get("username", None)
data = {
"id": None,
"slug": slug,
"is_administrable": False,
"access_level": RoomAccessLevel.PUBLIC,
"livekit": {
"url": settings.LIVEKIT_CONFIGURATION["url"],
"room": slug,
"token": utils.generate_token(
room=slug, user=request.user, username=username
),
},
}
else:
data = self.get_serializer(instance).data
room, slug = self._get_object_or_unregistered_slug()
if room is None:
return drf_response.Response(self._get_unregistered_room_data(slug))
return drf_response.Response(data)
return drf_response.Response(self.get_serializer(room).data)
def list(self, request, *args, **kwargs):
"""Limit listed rooms to the ones related to the authenticated user."""
@@ -572,6 +572,55 @@ class RoomViewSet( # pylint: disable=too-many-public-methods
{"message": f"Recording stopped for room {room.slug}."}
)
@decorators.action(
detail=True,
methods=["post"],
url_path="join",
permission_classes=[],
)
def join(self, request, pk=None): # pylint: disable=unused-argument
"""
Join a room, getting LiveKit credentials when allowed to enter directly.
The response contains the room with a livekit object holding the url,
room and token to connect with when the requester may enter without
going through the lobby. Otherwise, it has no livekit object and the
client should request entry through the lobby.
Unregistered rooms, when allowed, are always joined directly.
"""
serializer = serializers.JoinRoomSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
username = serializer.validated_data.get("username") or None
room, slug = self._get_object_or_unregistered_slug()
if room is None:
return drf_response.Response(
{
**self._get_unregistered_room_data(slug),
"livekit": utils.generate_livekit_config(
room_id=slug, user=request.user, username=username
),
}
)
role = room.get_role(request.user)
data = self.get_serializer(
room, context={**self.get_serializer_context(), "role": role}
).data
if LobbyService.can_bypass_lobby(room=room, user=request.user, role=role):
data["livekit"] = utils.generate_livekit_config(
room_id=str(room.id),
user=request.user,
username=username,
configuration=data["configuration"],
role=role,
)
return drf_response.Response(data)
@decorators.action(
detail=True,
methods=["post"],
@@ -66,6 +66,8 @@ def test_api_rooms_create_authenticated(reset_cache):
assert room.name == "my room"
assert room.slug == "my-room"
assert room.accesses.filter(role="owner", user=user).exists() is True
assert "livekit" not in response.json()
assert response.json()["pin_code"] == room.pin_code
rooms_data = cache.keys("room-creation-callback_*")
assert not rooms_data
@@ -495,3 +497,4 @@ def test_api_rooms_create_authenticated_with_user_access_token():
assert response.status_code == 201
room = Room.objects.get()
assert room.accesses.filter(role="owner", user=user).exists()
assert "livekit" not in response.json()
@@ -0,0 +1,580 @@
"""
Test rooms API endpoints in the Meet core app: join.
"""
# pylint: disable=redefined-outer-name
from unittest import mock
from django.conf import settings
from django.contrib.auth.models import AnonymousUser
from django.utils.crypto import get_random_string
import jwt
import pytest
from faker import Faker
from rest_framework.test import APIClient
from ...factories import (
RoomFactory,
UserFactory,
UserResourceAccessFactory,
)
from ...models import RoleChoices, RoomAccessLevel
from ..utils import generate_user_access_token
fake = Faker()
pytestmark = pytest.mark.django_db
livekit_token = fake.sha256()
ANONYMOUS = "anonymous"
NO_ROLE = "no-role"
# Who may join a room directly, without going through the lobby
# room.get_role(user) returns None both for an anonymous user and for an
# authenticated user without access, hence the NO_ROLE
ACCESS_MATRIX = [
(RoomAccessLevel.PUBLIC, ANONYMOUS, True),
(RoomAccessLevel.TRUSTED, ANONYMOUS, False),
(RoomAccessLevel.RESTRICTED, ANONYMOUS, False),
(RoomAccessLevel.PUBLIC, NO_ROLE, True),
(RoomAccessLevel.TRUSTED, NO_ROLE, True),
(RoomAccessLevel.RESTRICTED, NO_ROLE, False),
*[
(access_level, role, True)
for access_level in RoomAccessLevel
for role in RoleChoices
],
]
def decode_token(token):
"""Decode a LiveKit access token for inspection."""
return jwt.decode(
token,
settings.LIVEKIT_CONFIGURATION["api_secret"],
algorithms=["HS256"],
)
def join_url(room_id):
"""Return the url to join a room."""
return f"/api/v1.0/rooms/{room_id!s}/join/"
@pytest.mark.parametrize(
("access_level", "requester", "can_join_directly"), ACCESS_MATRIX
)
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_access(mock_token, access_level, requester, can_join_directly):
"""
Joining a room should return LiveKit credentials and the pin code only to
users who may enter without going through the lobby, and the accesses
only to the room's administrators and owners.
"""
room = RoomFactory(
access_level=access_level,
configuration={"can_publish_sources": ["camera"]},
)
client = APIClient()
user = AnonymousUser()
username = fake.user_name()
role = None
if requester != ANONYMOUS:
user = UserFactory()
client.force_login(user)
if requester != NO_ROLE:
role = requester
UserResourceAccessFactory(resource=room, user=user, role=role)
response = client.post(join_url(room.id), {"username": username}, format="json")
assert response.status_code == 200
content = response.json()
accesses = content.pop("accesses", None)
if role in (RoleChoices.ADMIN, RoleChoices.OWNER):
assert {access["id"] for access in accesses} == {
str(access.id) for access in room.accesses.all()
}
else:
assert accesses is None
expected = {
"id": str(room.id),
"name": room.name,
"slug": room.slug,
"configuration": {"can_publish_sources": ["camera"]},
"access_level": str(access_level),
}
if can_join_directly:
expected["pin_code"] = room.pin_code
expected["livekit"] = {
"url": settings.LIVEKIT_CONFIGURATION["url"],
"room": str(room.id),
"token": livekit_token,
}
assert content == expected
if can_join_directly:
mock_token.assert_called_once_with(
room=str(room.id),
user=user,
username=username,
color=None,
sources=["camera"],
role=role,
participant_id=None,
)
else:
mock_token.assert_not_called()
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_by_slug(mock_token):
"""It should be possible to join a room by its slug, not normalized."""
room = RoomFactory(name="Réunion", access_level=RoomAccessLevel.PUBLIC)
response = APIClient().post(join_url("Réunion"), {}, format="json")
assert response.status_code == 200
assert response.json()["id"] == str(room.id)
assert response.json()["livekit"]["room"] == str(room.id)
mock_token.assert_called_once()
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_members_num_queries(mock_token, django_assert_num_queries):
"""The role of the requester should only be looked up once."""
user = UserFactory()
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
UserResourceAccessFactory(resource=room, user=user, role=RoleChoices.MEMBER)
client = APIClient()
client.force_login(user)
with django_assert_num_queries(3):
response = client.post(join_url(room.id), {}, format="json")
assert response.status_code == 200
assert "livekit" in response.json()
assert mock_token.call_args.kwargs["role"] == RoleChoices.MEMBER
@pytest.mark.parametrize("role", [RoleChoices.ADMIN, RoleChoices.OWNER])
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_administrators_num_queries(
mock_token, role, django_assert_num_queries
):
"""Only the accesses should be queried on top of the role for administrators."""
user = UserFactory()
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
UserResourceAccessFactory(resource=room, user=user, role=role)
client = APIClient()
client.force_login(user)
with django_assert_num_queries(4):
response = client.post(join_url(room.id), {}, format="json")
assert response.status_code == 200
assert "livekit" in response.json()
assert "accesses" in response.json()
assert mock_token.call_args.kwargs["role"] == role
def test_api_rooms_join_get_not_allowed():
"""Joining a room should only be possible with a POST request."""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
response = APIClient().get(join_url(room.id))
assert response.status_code == 405
@pytest.mark.parametrize("authenticated", [False, True])
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_unregistered_allowed(mock_token, authenticated, settings):
"""
Joining an unregistered room should return LiveKit credentials for the
room named after the slug, when unregistered rooms are allowed.
"""
settings.ALLOW_UNREGISTERED_ROOMS = True
client = APIClient()
user = AnonymousUser()
username = fake.user_name()
if authenticated:
user = UserFactory()
client.force_login(user)
response = client.post(
join_url("unregistered-room"), {"username": username}, format="json"
)
assert response.status_code == 200
assert response.json() == {
"id": None,
"slug": "unregistered-room",
"access_level": "public",
"livekit": {
"url": settings.LIVEKIT_CONFIGURATION["url"],
"room": "unregistered-room",
"token": livekit_token,
},
}
mock_token.assert_called_once_with(
room="unregistered-room",
user=user,
username=username,
color=None,
sources=None,
role=None,
participant_id=None,
)
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_unregistered_allowed_not_normalized(mock_token, settings):
"""
Joining an unregistered room by a slug that is not normalized should use
the LiveKit room named after the url-safe slug.
"""
settings.ALLOW_UNREGISTERED_ROOMS = True
response = APIClient().post(join_url("Réunion"), {}, format="json")
assert response.status_code == 200
assert response.json() == {
"id": None,
"slug": "reunion",
"access_level": "public",
"livekit": {
"url": settings.LIVEKIT_CONFIGURATION["url"],
"room": "reunion",
"token": livekit_token,
},
}
mock_token.assert_called_once_with(
room="reunion",
user=AnonymousUser(),
username=None,
color=None,
sources=None,
role=None,
participant_id=None,
)
def test_api_rooms_join_unregistered_token_claims(settings):
"""The token of an unregistered room should be scoped to it and carry the name."""
settings.ALLOW_UNREGISTERED_ROOMS = True
username = fake.user_name()
response = APIClient().post(
join_url("unregistered-room"), {"username": username}, format="json"
)
assert response.status_code == 200
claims = decode_token(response.json()["livekit"]["token"])
assert claims["name"] == username
assert claims["video"]["room"] == "unregistered-room"
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_unregistered_not_allowed(mock_token, settings):
"""
Joining an unregistered room should return a 404 if unregistered rooms
are not allowed.
"""
settings.ALLOW_UNREGISTERED_ROOMS = False
response = APIClient().post(join_url("unregistered-room"), {}, format="json")
assert response.status_code == 404
assert response.json() == {"detail": "No Room matches the given query."}
mock_token.assert_not_called()
@pytest.mark.parametrize("lookup", ["---", "!!!", "_"])
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_unregistered_empty_slug(mock_token, lookup, settings):
"""
Joining an unregistered room whose slug is empty once normalized should
return a 404 rather than credentials for a room with no name.
"""
settings.ALLOW_UNREGISTERED_ROOMS = True
response = APIClient().post(join_url(lookup), {}, format="json")
assert response.status_code == 404
assert response.json() == {"detail": "No Room matches the given query."}
mock_token.assert_not_called()
@pytest.mark.parametrize("template", ["{}!", "_{}", "{}~", "{}!!"])
@pytest.mark.parametrize(
"access_level", [RoomAccessLevel.TRUSTED, RoomAccessLevel.RESTRICTED]
)
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_unregistered_uuid_slug(
mock_token, access_level, template, settings
):
"""
Joining an unregistered room whose slug is a UUID once normalized should
return a 404 rather than credentials for the registered room with that id.
"""
settings.ALLOW_UNREGISTERED_ROOMS = True
room = RoomFactory(access_level=access_level)
response = APIClient().post(
join_url(template.format(str(room.id).upper())), {}, format="json"
)
assert response.status_code == 404
assert response.json() == {"detail": "No Room matches the given query."}
mock_token.assert_not_called()
@pytest.mark.parametrize("allow_unregistered_rooms", [True, False])
@pytest.mark.parametrize("lookup", ["id", "slug"])
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_soft_deleted(
mock_token, lookup, allow_unregistered_rooms, settings
):
"""
Joining a soft-deleted room should return a 410, and never fall back
to an unregistered room with the same slug.
"""
settings.ALLOW_UNREGISTERED_ROOMS = allow_unregistered_rooms
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
room.soft_delete()
response = APIClient().post(join_url(getattr(room, lookup)), {}, format="json")
assert response.status_code == 410
assert response.json() == {"detail": "This room has been deleted."}
mock_token.assert_not_called()
@pytest.mark.parametrize(
("payload", "expected_username"),
[
({"username": "Jean Bon"}, "Jean Bon"),
({"username": " Jean Bon "}, "Jean Bon"),
({"username": "x" * 255}, "x" * 255),
({}, None),
({"username": None}, None),
({"username": ""}, None),
({"username": " "}, None),
],
)
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_username(mock_token, payload, expected_username):
"""
The trimmed display name should be passed on to the token, a missing or
blank one leaving the default name to the token generation.
"""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
response = APIClient().post(join_url(room.id), payload, format="json")
assert response.status_code == 200
assert response.json()["livekit"]["token"] == livekit_token
assert mock_token.call_args.kwargs["username"] == expected_username
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_username_too_long(mock_token):
"""A display name exceeding 255 characters should be rejected."""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
response = APIClient().post(
join_url(room.id), {"username": "a" * 256}, format="json"
)
assert response.status_code == 400
assert response.json() == {
"username": ["Ensure this field has no more than 255 characters."]
}
mock_token.assert_not_called()
@mock.patch("core.utils.generate_token", return_value=livekit_token)
def test_api_rooms_join_username_in_query_string_ignored(mock_token):
"""The display name should only be read from the request body."""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
username = fake.user_name()
response = APIClient().post(
f"{join_url(room.id)}?username={username}", {}, format="json"
)
assert response.status_code == 200
assert mock_token.call_args.kwargs["username"] is None
def test_api_rooms_join_token_claims_anonymous():
"""The token should carry the submitted display name and be scoped to the room."""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
username = fake.user_name()
response = APIClient().post(
join_url(room.id), {"username": username}, format="json"
)
assert response.status_code == 200
claims = decode_token(response.json()["livekit"]["token"])
assert claims["name"] == username
assert claims["video"]["room"] == str(room.id)
assert claims["video"]["roomAdmin"] is False
def test_api_rooms_join_token_claims_anonymous_default_name():
"""An anonymous user joining without a display name should get the default one."""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
response = APIClient().post(join_url(room.id), {"username": ""}, format="json")
assert response.status_code == 200
claims = decode_token(response.json()["livekit"]["token"])
assert claims["name"] == "Anonymous"
def test_api_rooms_join_token_claims_owner():
"""The token of an owner should carry the submitted name and the room admin grant."""
username = fake.user_name()
user = UserFactory(full_name=fake.name())
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, users=[(user, "owner")])
client = APIClient()
client.force_login(user)
response = client.post(join_url(room.id), {"username": username}, format="json")
assert response.status_code == 200
claims = decode_token(response.json()["livekit"]["token"])
assert claims["name"] == username
assert claims["sub"] == str(user.sub)
assert claims["video"]["roomAdmin"] is True
def test_api_rooms_join_display_name_edit_disabled(settings):
"""
An authenticated user should keep their account's name when display name
edition is disabled, whatever name they submit.
"""
settings.AUTHENTICATED_PARTICIPANTS_CAN_EDIT_DISPLAY_NAME = False
full_name = f"{fake.first_name()} {fake.last_name()}"
user = UserFactory(full_name=full_name)
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
client = APIClient()
client.force_login(user)
response = client.post(join_url(room.id), {"username": "Impostor"}, format="json")
assert response.status_code == 200
claims = decode_token(response.json()["livekit"]["token"])
assert claims["name"] == full_name
def test_api_rooms_join_display_name_edit_disabled_anonymous(settings):
"""Anonymous users should still choose their display name when edition is disabled."""
settings.AUTHENTICATED_PARTICIPANTS_CAN_EDIT_DISPLAY_NAME = False
username = fake.user_name()
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
response = APIClient().post(
join_url(room.id), {"username": username}, format="json"
)
assert response.status_code == 200
claims = decode_token(response.json()["livekit"]["token"])
assert claims["name"] == username
def test_api_rooms_join_session_without_csrf_token():
"""A session-authenticated request without a CSRF token should be rejected."""
user = UserFactory()
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
client = APIClient(enforce_csrf_checks=True)
client.force_login(user)
response = client.post(join_url(room.id), {"username": "Jane"}, format="json")
assert response.status_code == 403
assert response.json()["detail"].startswith("CSRF Failed")
def test_api_rooms_join_session_with_csrf_token():
"""A session-authenticated request with a valid CSRF token should be accepted."""
user = UserFactory()
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
client = APIClient(enforce_csrf_checks=True)
client.force_login(user)
csrf_secret = get_random_string(32)
client.cookies[settings.CSRF_COOKIE_NAME] = csrf_secret
response = client.post(
join_url(room.id),
{"username": "Jane"},
format="json",
HTTP_X_CSRFTOKEN=csrf_secret,
)
assert response.status_code == 200
assert "livekit" in response.json()
def test_api_rooms_join_session_with_csrf_token_foreign_origin():
"""A session-authenticated request from a foreign origin should be rejected."""
user = UserFactory()
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
client = APIClient(enforce_csrf_checks=True)
client.force_login(user)
csrf_secret = get_random_string(32)
client.cookies[settings.CSRF_COOKIE_NAME] = csrf_secret
response = client.post(
join_url(room.id),
{"username": "Jane"},
format="json",
HTTP_X_CSRFTOKEN=csrf_secret,
HTTP_ORIGIN="https://evil.example",
)
assert response.status_code == 403
assert response.json()["detail"].startswith("CSRF Failed: Origin checking failed")
def test_api_rooms_join_anonymous_without_csrf_token():
"""
An anonymous request carries no ambient credential, so it should not be
subject to CSRF checks.
"""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
client = APIClient(enforce_csrf_checks=True)
response = client.post(join_url(room.id), {"username": "Anonymous"}, format="json")
assert response.status_code == 200
assert "livekit" in response.json()
def test_api_rooms_join_user_access_token_without_csrf_token():
"""
A request authenticated with a user access token carries no ambient
credential, so it should not be subject to CSRF checks.
"""
username = fake.user_name()
user = UserFactory()
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, users=[(user, "owner")])
client = APIClient(enforce_csrf_checks=True)
client.credentials(HTTP_AUTHORIZATION=f"Bearer {generate_user_access_token(user)}")
response = client.post(join_url(room.id), {"username": username}, format="json")
assert response.status_code == 200
assert response.json()["pin_code"] == room.pin_code
assert "accesses" in response.json()
claims = decode_token(response.json()["livekit"]["token"])
assert claims["sub"] == str(user.sub)
@@ -61,6 +61,7 @@ def test_api_rooms_list_authenticated():
}
results_id = {result["id"] for result in results}
assert expected_ids == results_id
assert all("livekit" not in result for result in results)
@mock.patch.object(PageNumberPagination, "get_page_size", return_value=2)
@@ -172,3 +173,4 @@ def test_api_rooms_list_authenticated_with_user_access_token():
assert response.status_code == 200
assert response.data["count"] == 1
assert response.data["results"][0]["id"] == str(room.id)
assert "livekit" not in response.data["results"][0]
@@ -2,7 +2,7 @@
Test rooms API endpoints in the Meet core app: lobby functionality.
"""
# pylint: disable=W0621,W0613,W0212
# pylint: disable=W0621,W0613,W0212,too-many-lines
import uuid
from unittest import mock
@@ -360,6 +360,40 @@ def test_request_entry_invalid_data():
assert response.status_code == 400
def test_request_entry_username_too_long():
"""Should return 400 for a username exceeding 255 characters."""
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
client = APIClient()
with mock.patch.object(utils, "notify_participants") as mock_notify:
response = client.post(
f"/api/v1.0/rooms/{room.id}/request-entry/",
{"username": "a" * 256},
)
assert response.status_code == 400
assert response.json() == {
"username": ["Ensure this field has no more than 255 characters."]
}
mock_notify.assert_not_called()
assert not LobbyService()._index_members(room.id)
def test_request_entry_username_at_max_length():
"""Should accept a username of exactly 255 characters."""
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
client = APIClient()
with mock.patch.object(utils, "notify_participants", return_value=None):
response = client.post(
f"/api/v1.0/rooms/{room.id}/request-entry/",
{"username": "a" * 255},
)
assert response.status_code == 200
assert response.json()["username"] == "a" * 255
def test_request_entry_room_not_found():
"""Should return 404 for non-existent room."""
client = APIClient()
@@ -166,6 +166,30 @@ def test_mute_participant_everyone_can_mute_disabled_blocks_non_admin(
mock_livekit_client.room.mute_published_track.assert_not_called()
def test_mute_participant_everyone_can_mute_null_allows_non_admin(
mock_livekit_client,
):
"""Should treat a stored null everyone_can_mute as unset, hence enabled."""
client = APIClient()
room = RoomFactory(configuration={"everyone_can_mute": None})
user = AnonymousUser()
token = utils.generate_token(str(room.id), user)
url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
response = client.post(
url,
{"participant_identity": str(uuid4()), "track_sid": "test-track-sid"},
format="json",
HTTP_AUTHORIZATION=f"X-LiveKit-Token {token}",
)
assert response.status_code == status.HTTP_200_OK
assert response.data == {"status": "success"}
mock_livekit_client.room.mute_published_track.assert_called_once()
def test_mute_participant_everyone_can_mute_disabled_allows_admin(mock_livekit_client):
"""Should allow admins and owners to mute when everyone_can_mute is False."""
client = APIClient()
@@ -366,6 +366,22 @@ def test_rename_participant_name_too_long(room, token):
assert "name" in response.data
def test_rename_participant_name_at_max_length(mock_livekit_client, room, token):
"""Test rename accepts a name of exactly 255 characters."""
client = APIClient()
url = reverse("rooms-rename", kwargs={"pk": room.id})
response = client.post(
url,
{"name": "a" * 255},
format="json",
HTTP_AUTHORIZATION=f"X-LiveKit-Token {token}",
)
assert response.status_code == status.HTTP_200_OK
call_kwargs = mock_livekit_client.room.update_participant.call_args
assert call_kwargs[0][0].name == "a" * 255
def test_rename_participant_forbidden_without_token(room):
"""Test rename returns 403 when no LiveKit token is provided."""
client = APIClient()
@@ -1,11 +1,8 @@
"""
Test rooms API endpoints in the Meet core app: retrieve.
"""
"""Test rooms API endpoints in the Meet core app: retrieve."""
import random
from unittest import mock
from django.contrib.auth.models import AnonymousUser
from django.test.utils import override_settings
from django.utils import timezone as dj_timezone
@@ -112,18 +109,11 @@ def test_api_rooms_retrieve_anonymous_private_slug_not_normalized():
@override_settings(ALLOW_UNREGISTERED_ROOMS=True)
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
@mock.patch("core.utils.generate_token", return_value="foo")
def test_api_rooms_retrieve_anonymous_unregistered_allowed(mock_token):
"""
Retrieving an unregistered room should return a Livekit token
if unregistered rooms are allowed.
Retrieving an unregistered room should describe it if unregistered rooms
are allowed, without any LiveKit token: those are obtained by joining.
"""
client = APIClient()
response = client.get("/api/v1.0/rooms/unregistered-room/")
@@ -133,32 +123,17 @@ def test_api_rooms_retrieve_anonymous_unregistered_allowed(mock_token):
"id": None,
"slug": "unregistered-room",
"access_level": "public",
"is_administrable": False,
"livekit": {
"url": "test_url_value",
"room": "unregistered-room",
"token": "foo",
},
}
mock_token.assert_called_once_with(
room="unregistered-room", user=AnonymousUser(), username=None
)
mock_token.assert_not_called()
@override_settings(ALLOW_UNREGISTERED_ROOMS=True)
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
@mock.patch("core.utils.generate_token", return_value="foo")
def test_api_rooms_retrieve_anonymous_unregistered_allowed_not_normalized(mock_token):
"""
Getting an unregistered room by a slug that is not normalized should work
and use the Livekit room on the url-safe name.
and return the url-safe slug.
"""
client = APIClient()
response = client.get("/api/v1.0/rooms/Réunion/")
@@ -168,17 +143,9 @@ def test_api_rooms_retrieve_anonymous_unregistered_allowed_not_normalized(mock_t
"id": None,
"slug": "reunion",
"access_level": "public",
"is_administrable": False,
"livekit": {
"url": "test_url_value",
"room": "reunion",
"token": "foo",
},
}
mock_token.assert_called_once_with(
room="reunion", user=AnonymousUser(), username=None
)
mock_token.assert_not_called()
@override_settings(ALLOW_UNREGISTERED_ROOMS=False)
@@ -193,6 +160,36 @@ def test_api_rooms_retrieve_anonymous_unregistered_not_allowed():
assert response.json() == {"detail": "No Room matches the given query."}
@override_settings(ALLOW_UNREGISTERED_ROOMS=True)
@pytest.mark.parametrize("lookup", ["---", "!!!", "_"])
def test_api_rooms_retrieve_anonymous_unregistered_empty_slug(lookup):
"""
Retrieving an unregistered room whose slug is empty once normalized should
return a 404.
"""
client = APIClient()
response = client.get(f"/api/v1.0/rooms/{lookup}/")
assert response.status_code == 404
assert response.json() == {"detail": "No Room matches the given query."}
@override_settings(ALLOW_UNREGISTERED_ROOMS=True)
@pytest.mark.parametrize("template", ["{}!", "_{}", "{}~"])
def test_api_rooms_retrieve_anonymous_unregistered_uuid_slug(template):
"""
Retrieving an unregistered room whose slug is a UUID once normalized should
return a 404.
"""
room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
client = APIClient()
response = client.get(f"/api/v1.0/rooms/{template.format(room.id)}/")
assert response.status_code == 404
assert response.json() == {"detail": "No Room matches the given query."}
@pytest.mark.parametrize("allow_unregistered_rooms", [True, False])
@pytest.mark.parametrize("lookup", ["id", "slug"])
@mock.patch("core.utils.generate_token", return_value="foo")
@@ -216,52 +213,33 @@ def test_api_rooms_retrieve_soft_deleted(
@mock.patch("core.utils.generate_token", return_value="foo")
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
def test_api_rooms_retrieve_anonymous_public(mock_token):
"""
Anonymous users should be able to retrieve a room with a token provided, if the room is public.
Anonymous users should be able to retrieve a public room with its pin code,
but should not be given any token: those are obtained by joining.
"""
room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
client = APIClient()
response = client.get(f"/api/v1.0/rooms/{room.id!s}/")
assert response.status_code == 200
expected_name = f"{room.id!s}"
assert response.json() == {
"configuration": {},
"access_level": str(room.access_level),
"id": str(room.id),
"livekit": {
"url": "test_url_value",
"room": expected_name,
"token": "foo",
},
"name": room.name,
"pin_code": room.pin_code,
"slug": room.slug,
}
mock_token.assert_called_once()
mock_token.assert_not_called()
@mock.patch("core.utils.generate_token", return_value="foo")
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
def test_api_rooms_retrieve_authenticated_public(mock_token):
"""
Authenticated users should be allowed to retrieve a room and get a token for a room to
which they are not related, provided the room is public.
Authenticated users should be allowed to retrieve a public room to which
they are not related, with its pin code but without any token.
They should not see related users.
"""
room = RoomFactory(
@@ -278,44 +256,23 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
)
assert response.status_code == 200
expected_name = f"{room.id!s}"
assert response.json() == {
"configuration": {"can_publish_sources": ["camera"]},
"access_level": str(room.access_level),
"id": str(room.id),
"livekit": {
"url": "test_url_value",
"room": expected_name,
"token": "foo",
},
"name": room.name,
"pin_code": room.pin_code,
"slug": room.slug,
}
mock_token.assert_called_once_with(
room=expected_name,
user=user,
username=None,
color=None,
sources=["camera"],
role=None,
participant_id=None,
)
mock_token.assert_not_called()
@mock.patch("core.utils.generate_token", return_value="foo")
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
def test_api_rooms_retrieve_authenticated_trusted(mock_token):
"""
Authenticated users should be allowed to retrieve a room and get a token for a room to
which they are not related, provided the room has a trusted access_level.
Authenticated users should be allowed to retrieve a trusted room to which
they are not related, with its pin code but without any token.
They should not see related users.
"""
room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
@@ -329,30 +286,16 @@ def test_api_rooms_retrieve_authenticated_trusted(mock_token):
)
assert response.status_code == 200
expected_name = f"{room.id!s}"
assert response.json() == {
"configuration": {},
"access_level": str(room.access_level),
"id": str(room.id),
"livekit": {
"url": "test_url_value",
"room": expected_name,
"token": "foo",
},
"name": room.name,
"pin_code": room.pin_code,
"slug": room.slug,
}
mock_token.assert_called_once_with(
room=expected_name,
user=user,
username=None,
color=None,
sources=None,
role=None,
participant_id=None,
)
mock_token.assert_not_called()
def test_api_rooms_retrieve_authenticated():
@@ -381,13 +324,6 @@ def test_api_rooms_retrieve_authenticated():
@mock.patch("core.utils.generate_token", return_value="foo")
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries, settings):
"""
Users who are members of a room should not be allowed to see related users.
@@ -415,40 +351,19 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries, setti
assert "accesses" not in content_dict
expected_name = str(room.id)
assert content_dict == {
"configuration": {"can_publish_sources": ["camera"]},
"access_level": str(room.access_level),
"id": str(room.id),
"livekit": {
"url": "test_url_value",
"room": expected_name,
"token": "foo",
},
"name": room.name,
"pin_code": room.pin_code,
"slug": room.slug,
}
mock_token.assert_called_once_with(
room=expected_name,
user=user,
username=None,
color=None,
sources=["camera"],
role=str(RoleChoices.MEMBER),
participant_id=None,
)
mock_token.assert_not_called()
@mock.patch("core.utils.generate_token", return_value="foo")
@override_settings(
LIVEKIT_CONFIGURATION={
"api_key": "key",
"api_secret": "secret",
"url": "test_url_value",
}
)
def test_api_rooms_retrieve_administrators(
mock_token, django_assert_num_queries, settings
):
@@ -511,30 +426,16 @@ def test_api_rooms_retrieve_administrators(
],
key=lambda x: x["id"],
)
expected_name = str(room.id)
assert content_dict == {
"access_level": str(room.access_level),
"id": str(room.id),
"configuration": {},
"livekit": {
"url": "test_url_value",
"room": expected_name,
"token": "foo",
},
"name": room.name,
"pin_code": room.pin_code,
"slug": room.slug,
}
mock_token.assert_called_once_with(
room=expected_name,
user=user,
username=None,
color=None,
sources=None,
role=str(user_access.role),
participant_id=None,
)
mock_token.assert_not_called()
@pytest.mark.parametrize("access_level", RoomAccessLevel)
@@ -567,3 +468,77 @@ def test_api_rooms_retrieve_authenticated_with_user_access_token():
assert response.data["id"] == str(room.id)
assert response.data["pin_code"] == room.pin_code
assert "accesses" in response.data
assert "livekit" not in response.data
@pytest.mark.parametrize("access_level", RoomAccessLevel)
@pytest.mark.parametrize("role", [None, *RoleChoices])
@mock.patch("core.utils.generate_token", return_value="foo")
def test_api_rooms_retrieve_never_returns_livekit_credentials(
mock_token, role, access_level
):
"""Retrieving a room should never mint a LiveKit token."""
room = RoomFactory(access_level=access_level)
user = UserFactory()
if role is not None:
UserResourceAccessFactory(resource=room, user=user, role=role)
client = APIClient()
client.force_login(user)
response = client.get(f"/api/v1.0/rooms/{room.id!s}/")
assert response.status_code == 200
assert "livekit" not in response.json()
mock_token.assert_not_called()
@pytest.mark.parametrize("access_level", RoomAccessLevel)
@mock.patch("core.utils.generate_token", return_value="foo")
def test_api_rooms_retrieve_anonymous_never_returns_livekit_credentials(
mock_token, access_level
):
"""An anonymous user should never get a LiveKit token by retrieving a room."""
room = RoomFactory(access_level=access_level)
response = APIClient().get(f"/api/v1.0/rooms/{room.id!s}/")
assert response.status_code == 200
assert "livekit" not in response.json()
mock_token.assert_not_called()
@pytest.mark.parametrize(
("access_level", "authenticated", "role", "pin_code_exposed"),
[
(RoomAccessLevel.PUBLIC, False, None, True),
(RoomAccessLevel.TRUSTED, False, None, False),
(RoomAccessLevel.RESTRICTED, False, None, False),
(RoomAccessLevel.PUBLIC, True, None, True),
(RoomAccessLevel.TRUSTED, True, None, True),
(RoomAccessLevel.RESTRICTED, True, None, False),
(RoomAccessLevel.RESTRICTED, True, RoleChoices.MEMBER, True),
(RoomAccessLevel.RESTRICTED, True, RoleChoices.ADMIN, True),
(RoomAccessLevel.RESTRICTED, True, RoleChoices.OWNER, True),
],
)
def test_api_rooms_retrieve_pin_code_exposure(
access_level, authenticated, role, pin_code_exposed
):
"""
The pin code should only be exposed to users who may join the room
without going through the lobby.
"""
room = RoomFactory(access_level=access_level)
client = APIClient()
if authenticated:
user = UserFactory()
if role is not None:
UserResourceAccessFactory(resource=room, user=user, role=role)
client.force_login(user)
response = client.get(f"/api/v1.0/rooms/{room.id!s}/")
assert response.status_code == 200
assert ("pin_code" in response.json()) is pin_code_exposed
if pin_code_exposed:
assert response.json()["pin_code"] == room.pin_code
@@ -113,6 +113,7 @@ def test_api_rooms_update_administrators(mock_update_metadata):
format="json",
)
assert response.status_code == 200
assert "livekit" not in response.json()
room.refresh_from_db()
assert room.name == "New name"
assert room.slug == "new-name"
@@ -467,6 +468,7 @@ def test_api_rooms_update_authenticated_with_user_access_token(privileged_role):
room.accesses.filter(user=user).update(role=privileged_role)
response = client.patch(f"/api/v1.0/rooms/{room.id!s}/", {"name": "new name"})
assert response.status_code == 200
assert "livekit" not in response.json()
room.refresh_from_db()
assert room.name == "new name"
@@ -0,0 +1,38 @@
"""
Test utils.is_uuid
"""
import pytest
from faker import Faker
from core import utils
fake = Faker()
UUID = fake.uuid4()
@pytest.mark.parametrize(
"value",
[
UUID,
UUID.upper(),
UUID.replace("-", ""),
f"{{{UUID}}}",
f"urn:uuid:{UUID}",
],
ids=["canonical", "uppercase", "hex", "braces", "urn"],
)
def test_utils_is_uuid_true(value):
"""Strings that parse as a UUID should be recognized."""
assert utils.is_uuid(value) is True
@pytest.mark.parametrize(
"value",
["", "my-room", "abc-defg-hij", f"{UUID}!", f"_{UUID}", UUID[:-1]],
ids=["empty", "slug", "room-slug", "suffix", "prefix", "truncated"],
)
def test_utils_is_uuid_false(value):
"""Strings that do not parse as a UUID should not be recognized."""
assert utils.is_uuid(value) is False
+10 -1
View File
@@ -16,7 +16,7 @@ import string
from datetime import timedelta
from functools import lru_cache
from typing import List, Optional
from uuid import uuid4
from uuid import UUID, uuid4
from django.conf import settings
from django.core.files.storage import default_storage
@@ -336,6 +336,15 @@ def generate_room_slug():
return "-".join(parts)
def is_uuid(value: str) -> bool:
"""Tell whether a value parses as a UUID."""
try:
UUID(value)
except ValueError:
return False
return True
def detect_mimetype(file_buffer: bytes, filename: str | None = None) -> str:
"""
Detect MIME type using multiple methods for better accuracy.
@@ -708,3 +708,7 @@ msgstr "Deutsch"
#: meet/settings.py:242
msgid "Spanish"
msgstr "Spanisch"
#: meet/settings.py:243
msgid "Portuguese"
msgstr "Portugiesisch"
@@ -703,3 +703,7 @@ msgstr "German"
#: meet/settings.py:242
msgid "Spanish"
msgstr "Spanish"
#: meet/settings.py:243
msgid "Portuguese"
msgstr "Portuguese"
@@ -705,3 +705,7 @@ msgstr "Alemán"
#: meet/settings.py:242
msgid "Spanish"
msgstr "Español"
#: meet/settings.py:243
msgid "Portuguese"
msgstr "Portugués"
@@ -709,3 +709,7 @@ msgstr "Allemand"
#: meet/settings.py:242
msgid "Spanish"
msgstr "Espagnol"
#: meet/settings.py:243
msgid "Portuguese"
msgstr "Portugais"
@@ -703,3 +703,7 @@ msgstr "Duits"
#: meet/settings.py:242
msgid "Spanish"
msgstr "Spaans"
#: meet/settings.py:243
msgid "Portuguese"
msgstr "Portugees"
@@ -0,0 +1,699 @@
# Portuguese (Brazil) translation for La Suite numérique Meet.
# Copyright (C) 2026 La Suite numérique
# This file is distributed under the same license as the Meet package.
# Contributed by Alan Turing Laboratory (ATLab) - Federal University of Ceará (UFC), Brazil.
# Railton Vasconcelos <railton.vasconcelos14@gmail.com>, 2026.
#
msgid ""
msgstr ""
"Project-Id-Version: lasuite-meet\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-02 22:52+0000\n"
"PO-Revision-Date: 2026-11-07 21:00-0300\n"
"Last-Translator: Railton Vasconcelos <railton.vasconcelos14@gmail.com> (ATLab - UFC)\n"
"Language-Team: Alan Turing Laboratory (ATLab) - Federal University of Ceará (UFC)\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: core/admin.py:67
msgid "Personal info"
msgstr "Informações pessoais"
#: core/admin.py:80
msgid "Permissions"
msgstr "Permissões"
#: core/admin.py:92
msgid "Important dates"
msgstr "Datas importantes"
#: core/admin.py:206
msgid "Content"
msgstr "Conteúdo"
#: core/admin.py:217
msgid "Deletion"
msgstr "Exclusão"
#: core/admin.py:226
msgid "Derived info"
msgstr "Informações derivadas"
#: core/admin.py:237
msgid "Timestamps"
msgstr "Carimbos de data e hora"
#: core/admin.py:240
msgid "File preview"
msgstr "Pré-visualização do arquivo"
#: core/admin.py:300 core/admin.py:450
msgid "No owner"
msgstr "Sem proprietário"
#: core/admin.py:303 core/admin.py:453
msgid "Multiple owners"
msgstr "Vários proprietários"
#: core/admin.py:316
msgid "Resend notification to external service"
msgstr "Reenviar notificação ao serviço externo"
#: core/admin.py:339
#, python-format
msgid "Failed to notify for recording %(id)s"
msgstr "Falha ao notificar sobre a gravação %(id)s"
#: core/admin.py:347
#, python-format
msgid "Failed to notify for recording %(id)s: %(error)s"
msgstr "Falha ao notificar sobre a gravação %(id)s: %(error)s"
#: core/admin.py:355
#, python-format
msgid "Successfully sent notifications for %(count)s recording(s)."
msgstr "Notificações enviadas com sucesso para %(count)s gravação(ões)."
#: core/admin.py:363
#, python-format
msgid "Skipped %(count)s expired recording(s)."
msgstr "%(count)s gravação(ões) expirada(s) ignorada(s)."
#: core/admin.py:368
msgid "Mark selected recordings as 'Failed to Stop'"
msgstr "Marcar gravações selecionadas como 'Falha ao parar'"
#: core/admin.py:386
#, python-format
msgid "%(count)s recording(s) successfully marked as 'Failed to Stop'."
msgstr "%(count)s gravação(ões) marcada(s) com sucesso como 'Falha ao parar'."
#: core/admin.py:394
#, python-format
msgid "Skipped %(count)s recording(s) with an ineligible status."
msgstr "%(count)s gravação(ões) com status inelegível ignorada(s)."
#: core/admin.py:517
msgid "No scopes"
msgstr "Sem escopos"
#: core/admin.py:519
msgid "Scopes"
msgstr "Escopos"
#: core/api/filters.py:25
msgid "Creator is me"
msgstr "Criado por mim"
#: core/api/serializers.py:108
msgid "You must be administrator or owner of a room to add accesses to it."
msgstr "Você deve ser administrador ou proprietário de uma sala para adicionar acessos a ela."
#: core/api/serializers.py:560
msgid "This file extension is not allowed."
msgstr "Esta extensão de arquivo não é permitida."
#: core/api/viewsets.py:1268
msgid "You have reached the maximum number of files for this type."
msgstr "Você atingiu o número máximo de arquivos para este tipo."
#: core/models.py:38
msgid "Member"
msgstr "Membro"
#: core/models.py:39
msgid "Administrator"
msgstr "Administrador"
#: core/models.py:40
msgid "Owner"
msgstr "Proprietário"
#: core/models.py:56
msgid "Initiated"
msgstr "Iniciada"
#: core/models.py:57
msgid "Active"
msgstr "Ativa"
#: core/models.py:58
msgid "Stopped"
msgstr "Parada"
#: core/models.py:59
msgid "Saved"
msgstr "Salva"
#: core/models.py:60
msgid "Aborted"
msgstr "Cancelada"
#: core/models.py:61
msgid "Failed to Start"
msgstr "Falha ao iniciar"
#: core/models.py:62
msgid "Failed to Stop"
msgstr "Falha ao parar"
#: core/models.py:63
msgid "Notification succeeded"
msgstr "Notificação enviada com sucesso"
#: core/models.py:66
msgid "External process successful"
msgstr "Processo externo concluído com sucesso"
#: core/models.py:68
msgid "External process failed"
msgstr "Falha no processo externo"
#: core/models.py:97
msgid "SCREEN_RECORDING"
msgstr "GRAVAÇÃO_DE_TELA"
#: core/models.py:98
msgid "TRANSCRIPT"
msgstr "TRANSCRIÇÃO"
#: core/models.py:104
msgid "Public Access"
msgstr "Acesso público"
#: core/models.py:105
msgid "Trusted Access"
msgstr "Acesso confiável"
#: core/models.py:106
msgid "Restricted Access"
msgstr "Acesso restrito"
#: core/models.py:118
msgid "id"
msgstr "id"
#: core/models.py:119
msgid "primary key for the record as UUID"
msgstr "chave primária do registro como UUID"
#: core/models.py:125
msgid "created on"
msgstr "criado em"
#: core/models.py:126
msgid "date and time at which a record was created"
msgstr "data e hora em que o registro foi criado"
#: core/models.py:131
msgid "updated on"
msgstr "atualizado em"
#: core/models.py:132
msgid "date and time at which a record was last updated"
msgstr "data e hora da última atualização do registro"
#: core/models.py:150
msgid "sub"
msgstr "sub"
#: core/models.py:152
msgid ""
"Optional for pending users; required upon account activation. 255 characters "
"or fewer. Printable ASCII characters only."
msgstr ""
"Opcional para usuários pendentes; obrigatório na ativação da conta. Até 255 "
"caracteres. Apenas caracteres ASCII imprimíveis."
#: core/validators.py:22
msgid "Enter a valid sub. This value should be printable ASCII only."
msgstr "Insira um sub válido. Este valor deve conter apenas caracteres ASCII imprimíveis."
#: core/models.py:161
msgid "identity email address"
msgstr "endereço de e-mail de identidade"
#: core/models.py:166
msgid "admin email address"
msgstr "endereço de e-mail administrativo"
#: core/models.py:168
msgid "full name"
msgstr "nome completo"
#: core/models.py:170
msgid "short name"
msgstr "nome curto"
#: core/models.py:176
msgid "language"
msgstr "idioma"
#: core/models.py:177
msgid "The language in which the user wants to see the interface."
msgstr "O idioma no qual o usuário deseja visualizar a interface."
#: core/models.py:183
msgid "The timezone in which the user wants to see times."
msgstr "O fuso horário no qual o usuário deseja visualizar os horários."
#: core/models.py:190
msgid "default room access level"
msgstr "nível de acesso padrão da sala"
#: core/models.py:192
msgid ""
"Access level applied by default to new rooms created by this user. When "
"empty, the instance default is used."
msgstr ""
"Nível de acesso aplicado por padrão às novas salas criadas por este usuário. "
"Quando vazio, o padrão da instância é utilizado."
#: core/models.py:199
msgid "default room configuration"
msgstr "configuração padrão da sala"
#: core/models.py:201
msgid "Configurations applied by default to new rooms created by this user."
msgstr "Configurações aplicadas por padrão às novas salas criadas por este usuário."
#: core/models.py:205
msgid "device"
msgstr "dispositivo"
#: core/models.py:207
msgid "Whether the user is a device or a real user."
msgstr "Define se o usuário é um dispositivo ou um usuário real."
#: core/models.py:210
msgid "staff status"
msgstr "status da equipe"
#: core/models.py:212
msgid "Whether the user can log into this admin site."
msgstr "Define se o usuário pode acessar este painel de administração."
#: core/models.py:215
msgid "active"
msgstr "ativo"
#: core/models.py:218
msgid ""
"Whether this user should be treated as active. Unselect this instead of "
"deleting accounts."
msgstr ""
"Define se este usuário deve ser tratado como ativo. Desmarque esta opção em "
"vez de excluir contas."
#: core/models.py:231
msgid "user"
msgstr "usuário"
#: core/models.py:232
msgid "users"
msgstr "usuários"
#: core/models.py:298
msgid "Resource"
msgstr "Recurso"
#: core/models.py:299
msgid "Resources"
msgstr "Recursos"
#: core/models.py:357
msgid "Resource access"
msgstr "Acesso a recurso"
#: core/models.py:358
msgid "Resource accesses"
msgstr "Acessos a recursos"
#: core/models.py:364
msgid "Resource access with this User and Resource already exists."
msgstr "Já existe um acesso para este usuário e este recurso."
#: core/models.py:421
msgid "Visio room configuration"
msgstr "Configuração da sala de videoconferência"
#: core/models.py:422
msgid "Values for Visio parameters to configure the room."
msgstr "Valores dos parâmetros de videoconferência para configurar a sala."
#: core/models.py:429
msgid "Room PIN code"
msgstr "Código PIN da sala"
#: core/models.py:430
msgid "Unique n-digit code that identifies this room in telephony mode."
msgstr "Código único de n dígitos que identifica esta sala no modo telefonia."
#: core/models.py:436 core/models.py:597
msgid "Room"
msgstr "Sala"
#: core/models.py:437
msgid "Rooms"
msgstr "Salas"
#: core/models.py:608
msgid "Worker ID"
msgstr "ID do worker"
#: core/models.py:610
msgid ""
"Enter an identifier for the worker recording.This ID is retained even when "
"the worker stops, allowing for easy tracking."
msgstr ""
"Insira um identificador para a gravação do worker. Este ID é mantido mesmo "
"quando o worker para, facilitando o rastreamento."
#: core/models.py:618
msgid "Recording mode"
msgstr "Modo de gravação"
#: core/models.py:619
msgid "Defines the mode of recording being called."
msgstr "Define o modo de gravação utilizado."
#: core/models.py:624 core/models.py:625
msgid "Recording options"
msgstr "Opções de gravação"
#: core/models.py:632
msgid "External Process ID"
msgstr "ID do processo externo"
#: core/models.py:633
msgid "ID of the external process associated with the recording."
msgstr "ID do processo externo associado à gravação."
#: core/models.py:639
msgid "Recording"
msgstr "Gravação"
#: core/models.py:640
msgid "Recordings"
msgstr "Gravações"
#: core/models.py:750
msgid "Recording/user relation"
msgstr "Relação gravação/usuário"
#: core/models.py:751
msgid "Recording/user relations"
msgstr "Relações gravação/usuário"
#: core/models.py:757
msgid "This user is already in this recording."
msgstr "Este usuário já está nesta gravação."
#: core/models.py:763
msgid "This team is already in this recording."
msgstr "Esta equipe já está nesta gravação."
#: core/models.py:769
msgid "Either user or team must be set, not both."
msgstr "Deve ser definido o usuário ou a equipe, mas não ambos."
#: core/models.py:786
msgid "Create rooms"
msgstr "Criar salas"
#: core/models.py:787
msgid "List rooms"
msgstr "Listar salas"
#: core/models.py:788
msgid "Retrieve room details"
msgstr "Obter detalhes da sala"
#: core/models.py:789
msgid "Update rooms"
msgstr "Atualizar salas"
#: core/models.py:790
msgid "Delete rooms"
msgstr "Excluir salas"
#: core/models.py:803
msgid "Application name"
msgstr "Nome da aplicação"
#: core/models.py:804
msgid "Descriptive name for this application."
msgstr "Nome descritivo para esta aplicação."
#: core/models.py:814
msgid "Hashed on Save. Copy it now if this is a new secret."
msgstr "Criptografado ao salvar. Copie agora se este for um novo segredo."
#: core/models.py:825
msgid "Application"
msgstr "Aplicação"
#: core/models.py:826
msgid "Applications"
msgstr "Aplicações"
#: core/models.py:849
msgid "Enter a valid domain"
msgstr "Insira um domínio válido"
#: core/models.py:852
msgid "Domain"
msgstr "Domínio"
#: core/models.py:853
msgid "Email domain this application can act on behalf of."
msgstr "Domínio de e-mail em nome do qual esta aplicação pode atuar."
#: core/models.py:865
msgid "Application domain"
msgstr "Domínio da aplicação"
#: core/models.py:866
msgid "Application domains"
msgstr "Domínios da aplicação"
#: core/models.py:884
msgid "Pending"
msgstr "Pendente"
#: core/models.py:885
msgid "Analyzing"
msgstr "Analisando"
#: core/models.py:892
msgid "Ready"
msgstr "Pronto"
#: core/models.py:898
msgid "Background image"
msgstr "Imagem de fundo"
#: core/models.py:910
msgid "title"
msgstr "título"
#: core/models.py:934
msgid "Malware detection info when the analysis status is unsafe."
msgstr "Informações de detecção de malware quando o status da análise não for seguro."
#: core/models.py:939
msgid "File"
msgstr "Arquivo"
#: core/models.py:940
msgid "Files"
msgstr "Arquivos"
#: core/models.py:1060
msgid "This file is already hard deleted."
msgstr "Este arquivo já foi excluído permanentemente."
#: core/models.py:1070
msgid "To hard delete a file, it must first be soft deleted."
msgstr "Para excluir permanentemente um arquivo, ele deve primeiro ser marcado para exclusão."
#: core/recording/event/notification.py:124
msgid "Your recording is ready"
msgstr "Sua gravação está pronta"
#: core/recording/event/notification.py:195
msgid "Transcription"
msgstr "Transcrição"
#: core/recording/event/notification.py:206
#, python-brace-format
msgid "Meeting \"{room}\" on {room_recording_date} at {room_recording_time}"
msgstr "Reunião \"{room}\" em {room_recording_date} às {room_recording_time}"
#: core/services/invitation.py:44
#, python-brace-format
msgid "Video call in progress: {sender.email} is waiting for you to connect"
msgstr "Videochamada em andamento: {sender.email} está aguardando você se conectar"
#: core/templates/mail/html/invitation.html:151
#: core/templates/mail/html/screen_recording.html:151
#: core/templates/mail/text/invitation.txt:4
#: core/templates/mail/text/screen_recording.txt:4
msgid "Logo email"
msgstr "Logotipo do e-mail"
#: core/templates/mail/html/invitation.html:181
#: core/templates/mail/text/invitation.txt:6
msgid "invites you to join an ongoing video call"
msgstr "convida você para participar de uma videochamada em andamento"
#: core/templates/mail/html/invitation.html:192
#: core/templates/mail/text/invitation.txt:8
msgid "JOIN THE CALL"
msgstr "ENTRAR NA CHAMADA"
#: core/templates/mail/html/invitation.html:219
#: core/templates/mail/text/invitation.txt:14
msgid ""
"If you can't click the button, copy and paste the URL into your browser to "
"join the call."
msgstr ""
"Se não conseguir clicar no botão, copie e cole a URL no seu navegador para "
"entrar na chamada."
#: core/templates/mail/html/invitation.html:227
#: core/templates/mail/text/invitation.txt:16
msgid "Tips for a better experience:"
msgstr "Dicas para uma melhor experiência:"
#: core/templates/mail/html/invitation.html:229
#: core/templates/mail/text/invitation.txt:18
msgid "Use Chrome or Firefox for better call quality"
msgstr "Use o Chrome ou o Firefox para melhor qualidade de chamada"
#: core/templates/mail/html/invitation.html:230
#: core/templates/mail/text/invitation.txt:19
msgid "Test your microphone and camera before joining"
msgstr "Teste seu microfone e sua câmera antes de entrar"
#: core/templates/mail/html/invitation.html:231
#: core/templates/mail/text/invitation.txt:20
msgid "Make sure you have a stable internet connection"
msgstr "Certifique-se de ter uma conexão de internet estável"
#: core/templates/mail/html/invitation.html:240
#: core/templates/mail/html/screen_recording.html:237
#: core/templates/mail/text/invitation.txt:22
#: core/templates/mail/text/screen_recording.txt:24
#, python-format
msgid " Thank you for using %(brandname)s. "
msgstr " Obrigado por usar o %(brandname)s. "
#: core/templates/mail/html/invitation.html:271
#, python-format
msgid ""
"This mail has been sent to %(email)s by <a href=\"%(href)s\">%(name)s</a>"
msgstr ""
"Este e-mail foi enviado para %(email)s por <a href=\"%(href)s\">%(name)s</a>"
#: core/templates/mail/html/screen_recording.html:180
#: core/templates/mail/text/screen_recording.txt:7
msgid "Your recording is ready!"
msgstr "Sua gravação está pronta!"
#: core/templates/mail/html/screen_recording.html:187
#: core/templates/mail/text/screen_recording.txt:9
#, python-format
msgid ""
" Your recording of \"%(room_name)s\" on %(recording_date)s at "
"%(recording_time)s is now ready to download. "
msgstr ""
" Sua gravação de \"%(room_name)s\" em %(recording_date)s às "
"%(recording_time)s já está pronta para download. "
#: core/templates/mail/html/screen_recording.html:187
#: core/templates/mail/text/screen_recording.txt:9
#, python-format
msgid " The recording will expire in %(days)s days. "
msgstr " A gravação expirará em %(days)s dias. "
#: core/templates/mail/html/screen_recording.html:192
#: core/templates/mail/text/screen_recording.txt:10
msgid ""
" Sharing the recording via link is not yet available. Only organizers can "
"download it. "
msgstr ""
" O compartilhamento da gravação por link ainda não está disponível. Apenas "
"os organizadores podem baixá-la. "
#: core/templates/mail/html/screen_recording.html:198
#: core/templates/mail/text/screen_recording.txt:12
msgid "To keep this recording permanently:"
msgstr "Para manter esta gravação permanentemente:"
#: core/templates/mail/html/screen_recording.html:200
#, python-format
msgid "Click the \"<a href=\"%(link)s\">Open</a>\" link below "
msgstr "Clique no link \"<a href=\"%(link)s\">Abrir</a>\" abaixo "
#: core/templates/mail/html/screen_recording.html:201
#: core/templates/mail/text/screen_recording.txt:15
msgid "Use the \"Download\" button in the interface "
msgstr "Use o botão \"Baixar\" na interface "
#: core/templates/mail/html/screen_recording.html:202
#: core/templates/mail/text/screen_recording.txt:16
msgid "Save the file to your preferred location"
msgstr "Salve o arquivo no local de sua preferência"
#: core/templates/mail/html/screen_recording.html:213
#: core/templates/mail/text/screen_recording.txt:18
msgid "Open"
msgstr "Abrir"
#: core/templates/mail/html/screen_recording.html:222
#: core/templates/mail/text/screen_recording.txt:20
#, python-format
msgid ""
" If you have any questions or need assistance, please contact our support "
"team at %(support_email)s. "
msgstr ""
" Se tiver alguma dúvida ou precisar de ajuda, entre em contato com nossa "
"equipe de suporte em %(support_email)s. "
#: core/templates/mail/text/invitation.txt:24
#, python-format
msgid "This mail has been sent to %(email)s by %(name)s [%(href)s]"
msgstr "Este e-mail foi enviado para %(email)s por %(name)s [%(href)s]"
#: core/templates/mail/text/screen_recording.txt:14
#, python-format
msgid "Click the \"Open [%(link)s]\" link below "
msgstr "Clique no link \"Abrir [%(link)s]\" abaixo "
#: meet/settings.py:238
msgid "English"
msgstr "Inglês"
#: meet/settings.py:239
msgid "French"
msgstr "Francês"
#: meet/settings.py:240
msgid "Dutch"
msgstr "Holandês"
#: meet/settings.py:241
msgid "German"
msgstr "Alemão"
#: meet/settings.py:242
msgid "Spanish"
msgstr "Espanhol"
#: meet/settings.py:243
msgid "Portuguese"
msgstr "Português"
+1
View File
@@ -302,6 +302,7 @@ class Base(Configuration):
("nl-nl", _("Dutch")),
("de-de", _("German")),
("es-es", _("Spanish")),
("pt-br", _("Portuguese")),
)
)
+2 -6
View File
@@ -47,14 +47,10 @@ ENV VITE_MEDIA_BASE_URL=${VITE_MEDIA_BASE_URL}
RUN npm run build
# ---- Front-end image ----
FROM nginxinc/nginx-unprivileged:1.30.6-alpine3.24 AS frontend-production
FROM nginx/nginx-unprivileged:1.30.6-alpine3.24 AS frontend-production
USER root
RUN apk upgrade --no-cache libexpat && \
apk add --no-cache --upgrade 'pcre2>=10.49-r0' 'tiff>=4.7.2-r0' \
'libx11>=1.8.14-r0' 'ca-certificates>=20261020-r0' \
'brotli-libs>=1.2.1-r0' && \
apk del curl && \
RUN apk del curl && \
rm -f /usr/share/nginx/html/50x.html
USER nginx
+1 -1
View File
@@ -3,6 +3,6 @@
"input": ["src/**/*.{ts,tsx}", "!src/styled-system/**/*", "!src/**/*.d.ts"],
"output": "src/locales/$LOCALE/$NAMESPACE.json",
"createOldCatalogs": false,
"locales": ["en", "fr", "de", "nl", "es"],
"locales": ["en", "fr", "de", "nl", "es", "pt"],
"sort": true
}
+3
View File
@@ -36,6 +36,9 @@ const config: Config = {
jsxFramework: 'react',
outdir: 'src/styled-system',
globalFontface: {},
globalVars: {
'--global-font-body': 'var(--fonts-sans)',
},
theme: {
...pandaPreset.theme,
// media queries are defined in em so that zooming with text-only mode triggers breakpoints
@@ -4,6 +4,7 @@ import { cva } from '@/styled-system/css'
import { useTranslation } from 'react-i18next'
import { VStack } from '@/styled-system/jsx'
import { Link } from '@/primitives'
import { srOnly } from '@/styles/a11y'
// Styles per their documentation https://github.com/numerique-gouv/agentconnect-documentation/blob/main/doc_fs/bouton_proconnect.md
const proConnectButtonRecipe = cva({
@@ -35,7 +36,11 @@ export const ProConnectButton = ({ hint = true }: ProConnectButtonProps) => {
aria-label={t('proconnectButtonLabel')}
href={authUrl()}
data-attr="login"
/>
>
{/* The label must sit between <a> and </a> (RGAA 6.2.1): the
visible wording only exists in the CSS background image. */}
<span className={srOnly}>{t('proconnectButtonLabel')}</span>
</RALink>
{hint && (
<Link
to="https://agentconnect.gouv.fr/"
@@ -7,7 +7,11 @@ import {
} from 'react-aria-components'
import { RiArrowDownSFill } from '@remixicon/react'
import { css, cx } from '@/styled-system/css'
import type { ConnectionTestStepResult } from '../types'
import {
DIAGNOSTIC_OUTPUT_LANG,
getSummaryLang,
type ConnectionTestStepResult,
} from '../types'
import { StepStatusIndicator } from './StepStatusIndicator'
/** Each step is its own bounded card, collapsed or not. */
@@ -46,7 +50,7 @@ const triggerClass = css({
_hover: { backgroundColor: 'greyscale.50' },
'&[data-focus-visible]': {
outline: '2px solid {colors.focusRing}',
outlineOffset: '-2px',
outlineOffset: '-2px!',
},
})
@@ -65,7 +69,7 @@ const labelClass = css({
const valueClass = css({
fontFamily: 'mono',
textStyle: 'xs',
color: 'greyscale.500',
color: 'greyscale.600',
overflowWrap: 'anywhere',
})
@@ -110,7 +114,11 @@ const StepRowContent = ({ step }: { step: ConnectionTestStepResult }) => {
<>
<span className={identityClass}>
<span className={labelClass}>{t(`steps.${step.id}`)}</span>
{step.summary && <span className={valueClass}>{step.summary}</span>}
{step.summary && (
<span className={valueClass} lang={getSummaryLang(step)}>
{step.summary}
</span>
)}
</span>
<StepStatusIndicator
status={step.status}
@@ -131,10 +139,12 @@ export const ConnectionTestStepRow = ({
if (!hasLogs) {
return (
<div className={cx(cardClass, rowClass)}>
<StepRowContent step={step} />
{/* Empty chevron column keeps non-expandable rows aligned. */}
<span />
<div className={cardClass}>
<Heading level={3} className={cx(headingResetClass, rowClass)}>
<StepRowContent step={step} />
{/* Empty chevron column keeps non-expandable rows aligned. */}
<span />
</Heading>
</div>
)
}
@@ -170,7 +180,7 @@ export const ConnectionTestStepRow = ({
{/* Collapsed panels stay in the DOM for aria-controls, but the log
lines themselves are only mounted when actually visible. */}
{isExpanded && (
<ul className={logListClass}>
<ul className={logListClass} lang={DIAGNOSTIC_OUTPUT_LANG}>
{step.logs?.map((log, index) => (
<li key={`${log.level}-${index}`} className={logItemClass}>
{log.message}
@@ -153,7 +153,7 @@ const counterValueClass = css({
})
/** A zero count is context, not a result: it recedes instead of shouting. */
const emptyCounterClass = css({ color: 'greyscale.400' })
const emptyCounterClass = css({ color: 'greyscale.600' })
const emptySquareClass = css({
backgroundColor: 'transparent!',
border: '1px solid {colors.greyscale.250}',
@@ -25,10 +25,10 @@ export const statusSquareClass: Record<ConnectionTestStepStatus, string> = {
* failure and warning.
*/
export const statusTextClass: Record<ConnectionTestStepStatus, string> = {
pending: css({ color: 'greyscale.500' }),
pending: css({ color: 'greyscale.600' }),
running: css({ color: 'greyscale.700' }),
success: css({ color: 'greyscale.1000' }),
warning: css({ color: 'warning', fontWeight: 'medium' }),
failed: css({ color: 'danger.600', fontWeight: 'medium' }),
skipped: css({ color: 'greyscale.500' }),
skipped: css({ color: 'greyscale.600' }),
}
@@ -136,14 +136,16 @@ const ConnectionTest = () => {
<h2 className={sectionTitleClass}>
{t(`groups.${group.id}`)}
</h2>
<div className={rowsClass}>
<ul className={rowsClass}>
{group.steps.map((id) => {
const step = stepsById.get(id)
return step ? (
<ConnectionTestStepRow key={id} step={step} />
<li key={id}>
<ConnectionTestStepRow step={step} />
</li>
) : null
})}
</div>
</ul>
</section>
))}
@@ -32,6 +32,23 @@ export type ConnectionTestStepResult = {
data?: Record<string, unknown>
}
export const DIAGNOSTIC_OUTPUT_LANG = 'en'
const LANGUAGE_NEUTRAL_STEPS: ReadonlySet<ConnectionTestStepId> = new Set([
'browser',
'microphone',
'camera',
'devices',
])
export const getSummaryLang = ({
id,
status,
}: Pick<ConnectionTestStepResult, 'id' | 'status'>) =>
LANGUAGE_NEUTRAL_STEPS.has(id) && status === 'success'
? undefined
: DIAGNOSTIC_OUTPUT_LANG
export type ConnectionTestGroupId = 'local' | 'network'
/** Display order: everything local first, then everything that leaves the machine. */
@@ -9,12 +9,8 @@ import { useState } from 'react'
import { menuRecipe } from '@/primitives/menuRecipe'
import { ApiRoom } from '@/features/rooms/api/ApiRoom'
import { useSnapshot } from 'valtio'
import { userStore } from '@/stores/user'
export const CreateMeetingMenu = () => {
const { username } = useSnapshot(userStore)
const { t } = useTranslation('home')
const { mutateAsync: createRoom } = useCreateRoom()
const [laterRoom, setLaterRoom] = useState<null | ApiRoom>(null)
@@ -30,9 +26,9 @@ export const CreateMeetingMenu = () => {
className={menuRecipe({ icon: true, variant: 'light' }).item}
onAction={() => {
const slug = generateRoomId()
createRoom({ slug, username }).then((data) =>
createRoom({ slug }).then((data) =>
navigateTo('room', data.slug, {
state: { create: true, initialRoomData: data },
state: { create: true },
})
)
}}
@@ -45,7 +41,7 @@ export const CreateMeetingMenu = () => {
className={menuRecipe({ icon: true, variant: 'light' }).item}
onAction={() => {
const slug = generateRoomId()
createRoom({ slug, username }).then(setLaterRoom)
createRoom({ slug }).then(setLaterRoom)
}}
data-attr="create-option-later"
>
@@ -41,18 +41,23 @@ const Image = styled('img', {
const Dot = styled('div', {
base: {
borderRadius: '50%',
borderStyle: 'solid',
borderWidth: '1px',
boxSizing: 'border-box',
display: 'inline-block',
height: '.375rem',
height: '.5rem',
margin: '0 .25rem',
width: '.375rem',
width: '.5rem',
},
variants: {
selected: {
true: {
backgroundColor: 'primary.800',
borderColor: 'primary.800',
},
false: {
backgroundColor: 'primary.300',
backgroundColor: 'primary.100',
borderColor: 'primary.500',
},
},
},
@@ -1,22 +1,21 @@
import { useTranslation } from 'react-i18next'
import { Field, Ul, H, P, Form, Dialog } from '@/primitives'
import { navigateTo } from '@/navigation/navigateTo'
import { isRoomValid } from '@/features/rooms'
import { extractRoomId } from '@/features/rooms'
export const JoinMeetingDialog = () => {
const { t } = useTranslation('home')
const handleSubmit = (data: { roomId?: FormDataEntryValue }) => {
const roomId = (data.roomId as string)
.trim()
.replace(`${window.location.origin}/`, '')
navigateTo('room', roomId)
const extracted = extractRoomId(data.roomId as string)
if (!extracted) return
navigateTo('room', `${extracted.roomId}${extracted.suffix}`)
}
const validateRoomId = (value: string) => {
const trimmed = value.trim()
if (!trimmed) return null
return !isRoomValid(trimmed) ? (
return !extractRoomId(trimmed) ? (
<>
<p>{t('joinInputError')}</p>
<Ul>
@@ -1,8 +1,10 @@
import type { TrackReferenceOrPlaceholder } from '@livekit/components-core'
import { getScrollBarWidth } from '@livekit/components-core'
import * as React from 'react'
import { TrackLoop, useVisualStableUpdate } from '@livekit/components-react'
import { TrackLoop } from '@livekit/components-react'
import { useSize } from '@/features/rooms/livekit/hooks/useResizeObserver'
import { useCarouselTiles } from '../hooks/useCarouselTiles'
import { useSpeakerPromotionTrigger } from '../hooks/useSpeakerPromotionTrigger'
const MIN_HEIGHT = 130
const MIN_WIDTH = 140
@@ -23,8 +25,9 @@ export interface CarouselLayoutProps extends React.HTMLAttributes<HTMLMediaEleme
* The `CarouselLayout` component displays a list of tracks in a scroll container.
* It will display as many tiles as possible and overflow the rest.
* @remarks
* To ensure visual stability when tiles are reordered due to track updates,
* the component uses the `useVisualStableUpdate` hook.
* Tiles are ordered by `useCarouselTiles`: screen shares, new speakers and
* raised hands enter at the top, right below the local camera, and the other
* tiles keep their order.
* @example
* ```tsx
* const tracks = useTracks([Track.Source.Camera]);
@@ -66,7 +69,11 @@ export function CarouselLayout({
setPrevTiles(tilesThatFit)
}
const sortedTiles = useVisualStableUpdate(tracks, maxVisibleTiles)
const sortedTiles = useCarouselTiles(tracks, maxVisibleTiles)
// The carousel scrolls, so only the first tiles are guaranteed on screen.
useSpeakerPromotionTrigger(sortedTiles.slice(0, maxVisibleTiles), tracks, {
raisedHands: true,
})
React.useLayoutEffect(() => {
if (asideEl.current) {
@@ -46,7 +46,7 @@ export function GridLayout({ tracks, ...props }: GridLayoutProps) {
const { layout } = useGridLayout(gridEl, tracks.length)
const pagination = usePagination(layout.maxTiles, tracks)
useSpeakerPromotionTrigger(pagination.tracks)
useSpeakerPromotionTrigger(pagination.tracks, tracks)
useSwipe(gridEl, {
onLeftSwipe: pagination.nextPage,
@@ -0,0 +1,23 @@
import type { TrackReferenceOrPlaceholder } from '@livekit/components-core'
import { useRef } from 'react'
import { orderCarouselTiles } from '../utils/orderCarouselTiles'
/**
* Carousel counterpart of LiveKit's `useVisualStableUpdate`: same sort, same
* stable update, but screen shares and new speakers end up at the top. See
* `orderCarouselTiles`.
*
* Like `useVisualStableUpdate`, it only reorders when its host renders.
*/
export function useCarouselTiles(
tracks: TrackReferenceOrPlaceholder[],
maxVisibleTiles: number
) {
const previous = useRef<TrackReferenceOrPlaceholder[]>([])
previous.current = orderCarouselTiles(
previous.current,
tracks,
maxVisibleTiles
)
return previous.current
}
@@ -8,41 +8,65 @@ import { useEffect, useReducer, useRef } from 'react'
* Tripwire for speaker promotion.
*
* Listens to `RoomEvent.ActiveSpeakersChanged` imperatively and forces ONE
* re-render of the host component only when an active speaker has none of
* their tiles are within the visible span (`maxVisibleTiles`). That render
* re-runs `useVisualStableUpdate`, which reads live `participant.isSpeaking`
* state and performs the actual swap.
* re-render of the host when a speaker has a tile in `allTiles` but none in
* `visibleTiles`. That render re-runs the host's tile ordering, which reads
* live `participant.isSpeaking` state and performs the actual swap.
*
* Speakers already visible are ignored. Everything else costs zero React work.
* Speakers already visible cost nothing, nor do speakers the layout doesn't
* show at all (e.g. the pinned participant, rendered by the focus view).
*
* Requires the parent to NOT re-render on speaker events itself, i.e.
* With `raisedHands`, it also trips when a hand goes up or down while a
* raised hand is hidden: the hand that just went up, or the next one waiting
* for the slot of a hand that went down. Only for hosts whose ordering
* promotes raised hands; others would render for nothing.
*
* Requires the parent to NOT re-render on these events itself, i.e.
* `useTracks(..., { updateOnlyOn: [] })` upstream.
*/
export function useSpeakerPromotionTrigger(
sortedTiles: TrackReferenceOrPlaceholder[]
/** Tiles inside the span the layout guarantees to speakers. */
visibleTiles: TrackReferenceOrPlaceholder[],
/** Every tile the layout shows, visible or not. */
allTiles: TrackReferenceOrPlaceholder[],
{ raisedHands = false }: { raisedHands?: boolean } = {}
) {
const room = useRoomContext()
const [, forceRender] = useReducer((n: number) => n + 1, 0)
// Refs so the listener reads current values without re-subscribing
// and without itself being a render dependency.
const tilesRef = useRef(sortedTiles)
tilesRef.current = sortedTiles
// Read by the listeners at event time, so they never re-subscribe.
const tilesRef = useRef({ visibleTiles, allTiles })
tilesRef.current = { visibleTiles, allTiles }
useEffect(() => {
const onActiveSpeakersChanged = (speakers: Participant[]) => {
const tiles = tilesRef.current
const hiddenSpeakerExists = speakers.some(
(speaker) =>
!tiles.some((t) => t.participant.identity === speaker.identity)
const renderIfHidden = (participants: Participant[]) => {
const { visibleTiles, allTiles } = tilesRef.current
const visible = new Set(visibleTiles.map((t) => t.participant.identity))
const shown = new Set(allTiles.map((t) => t.participant.identity))
const hidden = participants.some(
({ identity }) => shown.has(identity) && !visible.has(identity)
)
if (hiddenSpeakerExists) {
if (hidden) {
forceRender()
}
}
room.on(RoomEvent.ActiveSpeakersChanged, onActiveSpeakersChanged)
return () => {
room.off(RoomEvent.ActiveSpeakersChanged, onActiveSpeakersChanged)
const onAttributesChanged = (changed: Record<string, string>) => {
if ('handRaisedAt' in changed) {
renderIfHidden(
tilesRef.current.allTiles
.map((t) => t.participant)
.filter((p) => !!p.attributes.handRaisedAt)
)
}
}
}, [room])
room.on(RoomEvent.ActiveSpeakersChanged, renderIfHidden)
if (raisedHands) {
room.on(RoomEvent.ParticipantAttributesChanged, onAttributesChanged)
}
return () => {
room.off(RoomEvent.ActiveSpeakersChanged, renderIfHidden)
room.off(RoomEvent.ParticipantAttributesChanged, onAttributesChanged)
}
}, [room, raisedHands])
}
@@ -0,0 +1,201 @@
import type { TrackReferenceOrPlaceholder } from '@livekit/components-core'
import { Track } from 'livekit-client'
import { describe, expect, it } from 'vitest'
import { orderCarouselTiles } from './orderCarouselTiles'
type Tile = TrackReferenceOrPlaceholder
// Placeholder tiles are enough: the real LiveKit sort and update run on them.
const tile = (
identity: string,
joinedAt: number,
{
source = Track.Source.Camera,
isLocal = false,
isSpeaking = false,
hasSpoken = isSpeaking,
handRaisedAt,
}: {
source?: Track.Source
isLocal?: boolean
isSpeaking?: boolean
hasSpoken?: boolean
handRaisedAt?: string
} = {}
) =>
({
participant: {
identity,
isLocal,
isSpeaking,
audioLevel: isSpeaking ? 1 : 0,
lastSpokeAt: hasSpoken ? new Date(joinedAt) : undefined,
joinedAt: new Date(joinedAt),
isCameraEnabled: false,
attributes: handRaisedAt ? { handRaisedAt } : {},
},
source,
}) as unknown as Tile
const names = (tiles: Tile[]) =>
tiles.map((t) =>
t.source === Track.Source.ScreenShare
? `${t.participant.identity}:screen`
: t.participant.identity
)
const me = tile('me', 0, { isLocal: true })
const [a, b, c, d, e] = ['a', 'b', 'c', 'd', 'e'].map((id, i) =>
tile(id, i + 1)
)
const speaking = (t: Tile) =>
tile(t.participant.identity, t.participant.joinedAt!.getTime(), {
isSpeaking: true,
})
const quietAgain = (t: Tile) =>
tile(t.participant.identity, t.participant.joinedAt!.getTime(), {
hasSpoken: true,
})
const handUp = (t: Tile, minute = 0) =>
tile(t.participant.identity, t.participant.joinedAt!.getTime(), {
isLocal: t.participant.isLocal,
handRaisedAt: new Date(Date.UTC(2026, 0, 1, 10, minute)).toISOString(),
})
const screenOf = (t: Tile) =>
tile(t.participant.identity, t.participant.joinedAt!.getTime(), {
source: Track.Source.ScreenShare,
})
describe('orderCarouselTiles', () => {
it('follows the LiveKit sort on the first render', () => {
expect(names(orderCarouselTiles([], [d, c, b, a, me], 3))).toEqual([
'me',
'a',
'b',
'c',
'd',
])
})
it('puts a new speaker right below the local camera', () => {
const previous = orderCarouselTiles([], [me, a, b, c, d, e], 4)
const next = orderCarouselTiles(previous, [me, a, b, c, d, speaking(e)], 4)
// LiveKit alone would give me, a, b, e: `e` takes the slot of `c`.
expect(names(next).slice(0, 4)).toEqual(['me', 'e', 'a', 'b'])
})
it('keeps the order of the tiles that stay visible', () => {
let tiles = orderCarouselTiles([], [me, a, b, c, d, e], 4)
tiles = orderCarouselTiles(tiles, [me, a, b, c, speaking(d), e], 4)
expect(names(tiles).slice(0, 4)).toEqual(['me', 'd', 'a', 'b'])
// `d` went quiet, `e` speaks: `d` stays ahead of `a`, `b` is evicted.
tiles = orderCarouselTiles(
tiles,
[me, a, b, c, quietAgain(d), speaking(e)],
4
)
expect(names(tiles).slice(0, 4)).toEqual(['me', 'e', 'd', 'a'])
})
it('does not move a visible participant who speaks', () => {
const previous = orderCarouselTiles([], [me, a, b, c, d], 4)
const next = orderCarouselTiles(previous, [me, a, b, speaking(c), d], 4)
expect(names(next)).toEqual(['me', 'a', 'b', 'c', 'd'])
})
it('keeps screen shares above a new speaker', () => {
const previous = orderCarouselTiles([], [me, screenOf(a), a, b, c, d], 4)
expect(names(previous).slice(0, 4)).toEqual(['me', 'a:screen', 'a', 'b'])
const next = orderCarouselTiles(
previous,
[me, screenOf(a), a, b, c, speaking(d)],
4
)
expect(names(next).slice(0, 4)).toEqual(['me', 'a:screen', 'd', 'a'])
})
it('puts a screen share that starts below the local camera', () => {
const previous = orderCarouselTiles([], [me, a, b, c, d], 4)
const next = orderCarouselTiles(previous, [me, a, b, c, d, screenOf(d)], 4)
expect(names(next).slice(0, 4)).toEqual(['me', 'd:screen', 'a', 'b'])
})
it('fills the slot of a participant who left without reordering', () => {
const previous = orderCarouselTiles([], [me, a, b, c, d], 4)
const next = orderCarouselTiles(previous, [me, b, c, d], 4)
expect(names(next)).toEqual(['me', 'd', 'b', 'c'])
})
it('brings a raised hand to the top like a speaker', () => {
const previous = orderCarouselTiles([], [me, a, b, c, d, e], 4)
const next = orderCarouselTiles(previous, [me, a, b, c, d, handUp(e)], 4)
expect(names(next).slice(0, 4)).toEqual(['me', 'e', 'a', 'b'])
})
it('keeps a raised hand visible when others speak', () => {
let tiles = orderCarouselTiles([], [me, a, b, c, d, e], 3)
tiles = orderCarouselTiles(tiles, [me, a, b, c, d, handUp(e)], 3)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'e', 'a'])
// `d` speaks: it evicts `a`, not the raised hand.
tiles = orderCarouselTiles(tiles, [me, a, b, c, speaking(d), handUp(e)], 3)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'd', 'e'])
})
it('lets the current speaker in when hands fill the carousel', () => {
let tiles = orderCarouselTiles([], [me, handUp(a, 1), handUp(b, 2), c], 3)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'a', 'b'])
// The last hand raised gives way to the speaker.
tiles = orderCarouselTiles(
tiles,
[me, handUp(a, 1), handUp(b, 2), speaking(c)],
3
)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'c', 'a'])
})
it('gives the slot of a lowered hand to the next one waiting', () => {
let tiles = orderCarouselTiles(
[],
[me, handUp(a, 1), handUp(b, 2), handUp(c, 3)],
3
)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'a', 'b'])
// `a` lowers their hand: `c` was waiting and takes over.
tiles = orderCarouselTiles(tiles, [me, a, handUp(b, 2), handUp(c, 3)], 3)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'c', 'b'])
})
it('shows the first hands raised when there are too many', () => {
const tiles = orderCarouselTiles(
[],
[me, a, handUp(b, 3), handUp(c, 1), handUp(d, 2)],
3
)
expect(names(tiles).slice(0, 3)).toEqual(['me', 'c', 'd'])
})
it('keeps the local camera first when the local hand is raised', () => {
const tiles = orderCarouselTiles([], [a, screenOf(a), b, handUp(me)], 3)
expect(names(tiles)).toEqual(['me', 'a:screen', 'a', 'b'])
})
it('is stable when run twice on the same input', () => {
const tracks = [me, a, b, c, d, speaking(e)]
const previous = orderCarouselTiles([], [me, a, b, c, d, e], 4)
const once = orderCarouselTiles(previous, tracks, 4)
expect(names(orderCarouselTiles(once, tracks, 4))).toEqual(names(once))
})
})
@@ -0,0 +1,88 @@
import {
log,
sortTrackReferences,
updatePages,
type TrackReferenceOrPlaceholder,
} from '@livekit/components-core'
import { Track } from 'livekit-client'
// LiveKit's track reference id changes when a placeholder gets its track;
// this key doesn't, so turning a camera on is not seen as a new tile.
const keyOf = (tile: TrackReferenceOrPlaceholder) =>
`${tile.participant.identity}_${tile.source}`
/** When the participant raised their hand, if it is still raised. */
const handRaisedAt = (tile: TrackReferenceOrPlaceholder) => {
if (tile.source !== Track.Source.Camera) return undefined
const time = Date.parse(tile.participant.attributes.handRaisedAt ?? '')
return Number.isNaN(time) ? undefined : time
}
/**
* LiveKit's sort knows nothing about raised hands. This moves them right
* after the tiles that must stay ahead (local camera, screen shares, whoever
* is speaking now), first raised first, so they are among the first tiles
* picked as visible for as long as the hand is up.
*/
const sortWithRaisedHands = (tracks: TrackReferenceOrPlaceholder[]) => {
const rank = (tile: TrackReferenceOrPlaceholder) => {
const { isLocal, isSpeaking } = tile.participant
if (isLocal || isSpeaking || tile.source === Track.Source.ScreenShare) {
return 0
}
return handRaisedAt(tile) === undefined ? 2 : 1
}
return sortTrackReferences(tracks).sort((a, b) => {
if (rank(a) !== rank(b)) return rank(a) - rank(b)
// Equal ranks keep LiveKit's order, except raised hands: first come first.
return rank(a) === 1 ? handRaisedAt(a)! - handRaisedAt(b)! : 0
})
}
/**
* Orders the carousel tiles; the first `maxVisibleTiles` are the visible ones.
*
* This is what LiveKit's `useVisualStableUpdate` does, plus one step:
* 1. `sortTrackReferences` decides which tiles deserve to be visible, with
* raised hands added to it, see `sortWithRaisedHands`;
* 2. `updatePages` applies that to the `previous` order with as few moves as
* possible: an incoming tile is swapped with the outgoing one;
* 3. added here: within the visible tiles, the local camera goes first, then
* the screen shares, then the speakers and raised hands that step 2 just
* brought in. The other tiles keep the order step 2 gave them.
*
* Step 2 alone leaves an incoming tile wherever the evicted one happened to
* be, often at the bottom of the column.
*/
export function orderCarouselTiles(
previous: TrackReferenceOrPlaceholder[],
tracks: TrackReferenceOrPlaceholder[],
maxVisibleTiles: number
): TrackReferenceOrPlaceholder[] {
const sorted = sortWithRaisedHands(tracks)
let stable = sorted
try {
stable = updatePages(previous, sorted, maxVisibleTiles)
} catch (error) {
log.error('Error while running updatePages(): ', error)
}
const previouslyVisible = new Set(
previous.slice(0, maxVisibleTiles).map(keyOf)
)
const rank = (tile: TrackReferenceOrPlaceholder) => {
if (tile.source === Track.Source.ScreenShare) return 1
if (tile.participant.isLocal) return 0
const justCameIn = !previouslyVisible.has(keyOf(tile))
const wantsAttention =
tile.participant.isSpeaking || handRaisedAt(tile) !== undefined
return justCameIn && wantsAttention ? 2 : 3
}
return [
// Array.prototype.sort is stable: tiles of equal rank keep their order.
...stable.slice(0, maxVisibleTiles).sort((a, b) => rank(a) - rank(b)),
...stable.slice(maxVisibleTiles),
]
}
@@ -1,4 +1,4 @@
import { Button, Div, H, Text } from '@/primitives'
import { Button, Div, Text } from '@/primitives'
import { css } from '@/styled-system/css'
import { useRoomId } from '@/features/rooms/livekit/hooks/useRoomId'
@@ -189,9 +189,9 @@ export const ScreenRecordingSidePanel = () => {
})}
/>
<VStack gap={0} marginBottom={15}>
<H lvl={1} margin={'sm'} fullWidth>
<Text as="h2" variant="h1" margin="sm" fullWidth>
{t('heading')}
</H>
</Text>
<LimitDescription
keyPrefix={'screenRecording'}
supportArticleLink={data?.support?.help_article_recording}
@@ -1,4 +1,4 @@
import { A, Button, Div, H, Text } from '@/primitives'
import { A, Button, Div, Text } from '@/primitives'
import { css } from '@/styled-system/css'
import { useRoomId } from '@/features/rooms/livekit/hooks/useRoomId'
@@ -203,9 +203,9 @@ export const TranscriptSidePanel = () => {
})}
/>
<VStack gap={0} marginBottom={15}>
<H lvl={1} margin={'sm'}>
<Text as="h2" variant="h1" margin="sm" fullWidth>
{t('heading')}
</H>
</Text>
<LimitDescription
keyPrefix={'transcript'}
supportArticleLink={data?.support?.help_article_transcript}
@@ -240,6 +240,9 @@ export const TranscriptSidePanel = () => {
<Button
variant="text"
size="xs"
aria-label={t('details.languageAriaLabel', {
language: selectedLanguageLabel,
})}
onPress={() =>
openSettingsDialog(SettingsDialogExtendedKey.TRANSCRIPTION)
}
@@ -31,7 +31,6 @@ export type ApiRoom = {
name: string
slug: string
pin_code?: string
is_administrable: boolean
access_level: ApiAccessLevel
livekit?: ApiLiveKit
configuration?: RoomConfiguration
@@ -6,15 +6,13 @@ import type { ApiRoom } from './ApiRoom'
export interface CreateRoomParams {
slug: string
callbackId?: string
username?: string
}
const createRoom = ({
slug,
callbackId,
username = '',
}: CreateRoomParams): Promise<ApiRoom> => {
return fetchApi(`rooms/?username=${encodeURIComponent(username)}`, {
return fetchApi('rooms/', {
method: 'POST',
body: JSON.stringify({
name: slug,
@@ -1,14 +1,6 @@
import { type ApiRoom } from './ApiRoom'
import { fetchApi } from '@/api/fetchApi'
export const fetchRoom = ({
roomId,
username,
}: {
roomId: string
username?: string
}) => {
const query = username ? `?username=${encodeURIComponent(username)}` : ''
return fetchApi<ApiRoom>(`/rooms/${roomId}/${query}`)
export const fetchRoom = ({ roomId }: { roomId: string }) => {
return fetchApi<ApiRoom>(`/rooms/${roomId}/`)
}
@@ -0,0 +1,14 @@
import { type ApiRoom } from './ApiRoom'
import { fetchApi } from '@/api/fetchApi'
export type JoinRoomParams = {
roomId: string
username?: string
}
export const joinRoom = ({ roomId, username }: JoinRoomParams) => {
return fetchApi<ApiRoom>(`/rooms/${roomId}/join/`, {
method: 'POST',
body: JSON.stringify({ username }),
})
}
@@ -1,4 +1,4 @@
import { useEffect, useMemo, useRef, useState } from 'react'
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
import { useQuery } from '@tanstack/react-query'
import { useTranslation } from 'react-i18next'
import {
@@ -10,17 +10,16 @@ import {
ConnectionErrorReason,
DisconnectReason,
MediaDeviceFailure,
type Room,
type RoomOptions,
VideoPresets,
} from 'livekit-client'
import { getMediaDeviceFailure } from '@/features/rooms/livekit/utils/mediaPermissions'
import { keys } from '@/api/queryKeys'
import { queryClient } from '@/api/queryClient'
import { Screen } from '@/layout/Screen'
import { QueryAware } from '@/components/QueryAware'
import { ErrorScreen } from '@/components/ErrorScreen'
import { fetchRoom } from '../api/fetchRoom'
import type { ApiRoom } from '../api/ApiRoom'
import { joinRoom } from '../api/joinRoom'
import { useCreateRoom } from '../api/createRoom'
import { InviteDialog } from './InviteDialog'
import { VideoConference } from '../livekit/prefabs/VideoConference'
@@ -32,7 +31,7 @@ import {
captureMediaEvent,
reportError,
} from '@/features/analytics/telemetry'
import { useConfig } from '@/api/useConfig'
import { type ApiConfig, useConfig } from '@/api/useConfig'
import { isFireFox } from '@/utils/livekit'
import { useIsMobile } from '@/utils/useIsMobile'
import { navigateTo } from '@/navigation/navigateTo'
@@ -48,6 +47,13 @@ import { resolveAudioOutputDeviceId } from '@/features/rooms/utils/resolveAudioO
import { ConnectionEndReason } from '@/features/rooms/utils/connectionEndReason'
import { createLiveKitRoom } from '@/features/rooms/livekit/utils/reconnectPolicy'
// Some clients (like DINUM) operate in bandwidth-constrained environments
// These settings help ensure successful connections in poor network conditions
const connectOptions = {
maxRetries: 5, // Default: 1. Only for unreachable server scenarios
peerConnectionTimeout: 60000, // Default: 15s. Extended for slow TURN/TLS negotiation
}
const handleError = (e: Error) => {
const failure = getMediaDeviceFailure(e)
if (failure && failure !== MediaDeviceFailure.Other) return
@@ -66,65 +72,111 @@ const handleError = (e: Error) => {
})
}
/**
* Warm up connection to LiveKit server before joining room
* This prefetch helps reduce initial connection latency by establishing
* an early HTTP connection to the WebRTC signaling server
*
* It should cache DNS and TLS keys.
*/
const warmUpConnection = async (room: Room, livekit: ApiConfig['livekit']) => {
await room.prepareConnection(livekit.url)
if (isFireFox() && livekit.enable_firefox_proxy_workaround) {
try {
const wssUrl =
livekit.url.replace('https://', 'wss://').replace(/\/$/, '') + '/rtc'
/**
* FIREFOX + PROXY WORKAROUND:
*
* Issue: On Firefox behind proxy configurations, WebSocket signaling fails to establish.
* Symptom: Client receives HTTP 200 instead of expected 101 (Switching Protocols).
* Root Cause: Certificate/security issue where the initial request is considered insecure.
*
* Solution: Pre-establish a WebSocket connection to the signaling server, which fails.
* This "primes" the connection, allowing subsequent WebSocket establishments to work correctly.
*
* Note: This issue is reproducible on LiveKit's demo app.
* Reference: livekit-examples/meet/issues/466
*/
const ws = new WebSocket(wssUrl)
// 401 unauthorized response is expected
ws.onerror = () => ws.readyState <= 1 && ws.close()
} catch (e) {
console.debug('Firefox WebSocket workaround failed.', e)
}
}
}
const getConnectionEndReason = (
reason: DisconnectReason | undefined,
hasConnected: boolean
) => {
switch (reason) {
case DisconnectReason.CLIENT_INITIATED:
return undefined
case DisconnectReason.DUPLICATE_IDENTITY:
case DisconnectReason.PARTICIPANT_REMOVED:
case DisconnectReason.ROOM_DELETED:
return reason
default:
// Reconnecting gave up, or the join itself failed
return hasConnected
? ConnectionEndReason.Lost
: ConnectionEndReason.Failed
}
}
export const Conference = ({
roomId,
initialRoomData,
mode = 'join',
onLobbyRequired,
}: {
roomId: string
mode?: 'join' | 'create'
initialRoomData?: ApiRoom
onLobbyRequired: () => void
}) => {
const { t } = useTranslation('rooms')
const { data: apiConfig } = useConfig()
const { userChoices: userConfig } = usePersistentUserChoices() as {
userChoices: LocalUserChoices
}
const { username } = useSnapshot(userStore)
useEffect(() => {
void captureMediaEvent('visit-room', { slug: roomId })
}, [roomId])
const fetchKey = [keys.room, roomId]
const [isConnectionWarmedUp, setIsConnectionWarmedUp] = useState(false)
const userPreferencesSnap = useSnapshot(userPreferencesStore)
const isMobile = useIsMobile()
const {
mutateAsync: createRoom,
status: createStatus,
isError: isCreateError,
} = useCreateRoom({
onSuccess: (data) => {
queryClient.setQueryData(fetchKey, data)
},
})
const [hasJoined, setHasJoined] = useState(false)
const [isConnectionWarmedUp, setIsConnectionWarmedUp] = useState(false)
const hasAutoMutedRef = useRef(false)
const hasConnectedRef = useRef(false)
const { mutateAsync: createRoom, isError: isCreateError } = useCreateRoom()
const {
status: fetchStatus,
isError: isFetchError,
error: fetchError,
data,
data: createRoomData,
} = useQuery({
queryKey: fetchKey,
queryKey: [keys.room, roomId],
staleTime: 6 * 60 * 60 * 1000, // By default, LiveKit access tokens expire 6 hours after generation
initialData: initialRoomData,
queryFn: () =>
fetchRoom({
roomId: roomId as string,
username: username,
}).catch((error) => {
if (error.statusCode == '404') {
createRoom({ slug: roomId, username })
}
// A deleted room can't be recreated, surface the error instead
if (error.statusCode == '410') throw error
joinRoom({ roomId, username }).catch(async (error) => {
if (error.statusCode != 404) throw error
await createRoom({ slug: roomId })
return joinRoom({ roomId, username })
}),
retry: false,
})
const isLobbyRequired =
!!createRoomData && !createRoomData.livekit && !hasJoined
const status =
createRoomData?.livekit || hasJoined
? 'success'
: isLobbyRequired
? 'pending'
: fetchStatus
const roomOptions = useMemo((): RoomOptions => {
return {
adaptiveStream: true,
@@ -155,62 +207,11 @@ export const Conference = ({
apiConfig?.livekit.default_video_codec,
])
const reconnect = apiConfig?.livekit.reconnect
const room = useMemo(
() => createLiveKitRoom(roomOptions, reconnect),
[roomOptions, reconnect]
() => createLiveKitRoom(roomOptions, apiConfig?.livekit.reconnect),
[roomOptions, apiConfig?.livekit.reconnect]
)
useEffect(() => {
/**
* Warm up connection to LiveKit server before joining room
* This prefetch helps reduce initial connection latency by establishing
* an early HTTP connection to the WebRTC signaling server
*
* It should cache DNS and TLS keys.
*/
const prepareConnection = async () => {
if (!apiConfig || isConnectionWarmedUp) return
await room.prepareConnection(apiConfig.livekit.url)
if (isFireFox() && apiConfig.livekit.enable_firefox_proxy_workaround) {
try {
const wssUrl =
apiConfig.livekit.url
.replace('https://', 'wss://')
.replace(/\/$/, '') + '/rtc'
/**
* FIREFOX + PROXY WORKAROUND:
*
* Issue: On Firefox behind proxy configurations, WebSocket signaling fails to establish.
* Symptom: Client receives HTTP 200 instead of expected 101 (Switching Protocols).
* Root Cause: Certificate/security issue where the initial request is considered insecure.
*
* Solution: Pre-establish a WebSocket connection to the signaling server, which fails.
* This "primes" the connection, allowing subsequent WebSocket establishments to work correctly.
*
* Note: This issue is reproducible on LiveKit's demo app.
* Reference: livekit-examples/meet/issues/466
*/
const ws = new WebSocket(wssUrl)
// 401 unauthorized response is expected
ws.onerror = () => ws.readyState <= 1 && ws.close()
} catch (e) {
console.debug('Firefox WebSocket workaround failed.', e)
}
}
setIsConnectionWarmedUp(true)
}
prepareConnection()
}, [room, apiConfig, isConnectionWarmedUp])
const isMobile = useIsMobile()
const hasAutoMutedRef = useRef(false)
const hasConnectedRef = useRef(false)
/*
* Ensure stable WebSocket connection URL. This is critical for legacy browser compatibility
* (Firefox <124, Chrome <125, Edge <125) where HTTPS URLs in WebSocket() constructor
@@ -225,7 +226,61 @@ export const Conference = ({
return livekit_url
}, [apiConfig?.livekit])
const { t } = useTranslation('rooms')
const handleConnected = useCallback(async () => {
hasConnectedRef.current = true
if (!apiConfig) return
if (
userPreferencesSnap.is_auto_mute_large_room_enabled &&
!hasAutoMutedRef.current &&
userConfig.audioEnabled &&
room.numParticipants > apiConfig.auto_mute_on_join_threshold
) {
hasAutoMutedRef.current = true
await room.localParticipant.setMicrophoneEnabled(false)
notifyAutoMutedOnJoin()
}
}, [
apiConfig,
room,
userConfig.audioEnabled,
userPreferencesSnap.is_auto_mute_large_room_enabled,
])
const handleDisconnected = useCallback(
(reason?: DisconnectReason) => {
navigateTo(
'feedback',
{},
{
state: {
reason: getConnectionEndReason(reason, hasConnectedRef.current),
room_id: roomId,
},
}
)
},
[roomId]
)
useEffect(() => {
void captureMediaEvent('visit-room', { slug: roomId })
}, [roomId])
useEffect(() => {
if (createRoomData?.livekit) setHasJoined(true)
}, [createRoomData?.livekit])
useEffect(() => {
if (isLobbyRequired) onLobbyRequired()
}, [isLobbyRequired, onLobbyRequired])
useEffect(() => {
if (!apiConfig || isConnectionWarmedUp) return
warmUpConnection(room, apiConfig.livekit).then(() =>
setIsConnectionWarmedUp(true)
)
}, [room, apiConfig, isConnectionWarmedUp])
if (fetchError?.statusCode == 410) {
return (
<ErrorScreen
@@ -245,20 +300,13 @@ export const Conference = ({
)
}
// Some clients (like DINUM) operate in bandwidth-constrained environments
// These settings help ensure successful connections in poor network conditions
const connectOptions = {
maxRetries: 5, // Default: 1. Only for unreachable server scenarios
peerConnectionTimeout: 60000, // Default: 15s. Extended for slow TURN/TLS negotiation
}
return (
<QueryAware status={isFetchError ? createStatus : fetchStatus}>
<QueryAware status={status}>
<Screen header={false} footer={false}>
<LiveKitRoom
room={room}
serverUrl={serverUrl}
token={data?.livekit?.token}
token={createRoomData?.livekit?.token}
connect={isConnectionWarmedUp}
audio={userConfig.audioEnabled}
video={
@@ -273,65 +321,8 @@ export const Conference = ({
backgroundColor: 'primaryDark.50 !important',
})}
onError={handleError}
onConnected={async () => {
hasConnectedRef.current = true
if (!apiConfig) return
if (
userPreferencesSnap.is_auto_mute_large_room_enabled &&
!hasAutoMutedRef.current &&
userConfig.audioEnabled &&
room.numParticipants > apiConfig.auto_mute_on_join_threshold
) {
hasAutoMutedRef.current = true
await room.localParticipant.setMicrophoneEnabled(false)
notifyAutoMutedOnJoin()
}
}}
onDisconnected={(e) => {
const metadata = {
room_id: roomId,
}
switch (e) {
case DisconnectReason.CLIENT_INITIATED:
navigateTo(
'feedback',
{},
{
state: { ...metadata },
}
)
return
case DisconnectReason.DUPLICATE_IDENTITY:
case DisconnectReason.PARTICIPANT_REMOVED:
case DisconnectReason.ROOM_DELETED:
navigateTo(
'feedback',
{},
{
state: {
reason: e,
...metadata,
},
}
)
return
default:
// Reconnecting gave up, or the join itself failed
navigateTo(
'feedback',
{},
{
state: {
reason: hasConnectedRef.current
? ConnectionEndReason.Lost
: ConnectionEndReason.Failed,
...metadata,
},
}
)
}
}}
onConnected={handleConnected}
onDisconnected={handleDisconnected}
>
<WatchMediaDeviceErrors />
<VideoConference />
@@ -10,13 +10,16 @@ import {
RiFileCopyLine,
RiSpam2Fill,
} from '@remixicon/react'
import { useMemo, useState } from 'react'
import { useMemo, useRef, useState } from 'react'
import { css } from '@/styled-system/css'
import { useRoomData } from '@/features/rooms/livekit/hooks/useRoomData'
import { ApiAccessLevel } from '@/features/rooms/api/ApiRoom'
import { useTelephony } from '@/features/rooms/livekit/hooks/useTelephony'
import { formatPinCode } from '@/features/rooms/utils/telephony'
import { useCopyRoomToClipboard } from '@/features/rooms/livekit/hooks/useCopyRoomToClipboard'
import { useEscapeToClose } from '@/hooks/useEscapeToClose'
import { getFirstControlBarFocusable } from '@/utils/dom'
import { CONTROL_BAR_REGION_ID } from '@/features/layout/components/ControlBarRegion'
// fixme - extract in a proper primitive this dialog without overlay
const StyledRACDialog = styled(Dialog, {
@@ -64,9 +67,20 @@ export const InviteDialog = ({ mode }: { mode: 'join' | 'create' }) => {
copyRoomUrlToClipboard,
} = useCopyRoomToClipboard(roomData)
const dialogRef = useRef<HTMLElement>(null)
const dismiss = () => {
// The dialog opens on its own when joining, so there is no trigger to
// restore focus to: move it to the control bar instead of body.
getFirstControlBarFocusable(CONTROL_BAR_REGION_ID)?.focus()
setIsDismissed(true)
}
useEscapeToClose(showInviteDialog, dialogRef, dismiss)
if (!showInviteDialog) return null
return (
<StyledRACDialog>
<StyledRACDialog ref={dialogRef}>
<VStack
alignItems="left"
justify="start"
@@ -81,9 +95,7 @@ export const InviteDialog = ({ mode }: { mode: 'join' | 'create' }) => {
invisible
variant="tertiaryText"
size="xs"
onPress={() => {
setIsDismissed(true)
}}
onPress={dismiss}
aria-label={t('closeDialog')}
>
<RiCloseLine />
@@ -1,6 +1,6 @@
import { useEffect } from 'react'
import { type ReactNode } from 'react'
import { useTranslation } from 'react-i18next'
import { useQuery } from '@tanstack/react-query'
import { useMutation } from '@tanstack/react-query'
import { useSnapshot } from 'valtio'
import { css } from '@/styled-system/css'
import { VStack } from '@/styled-system/jsx'
@@ -10,15 +10,40 @@ import { Form, Text } from '@/primitives'
import { Spinner } from '@/primitives/Spinner'
import { keys } from '@/api/queryKeys'
import { queryClient } from '@/api/queryClient'
import type { ApiError } from '@/api/ApiError'
import { useLoginHint } from '@/hooks/useLoginHint'
import { useUser } from '@/features/auth/api/useUser'
import { useConfig } from '@/api/useConfig'
import { saveUsername, userStore } from '@/stores/user'
import { fetchRoom } from '../api/fetchRoom'
import { ApiAccessLevel } from '../api/ApiRoom'
import { ApiLobbyStatus, type ApiRequestEntry } from '../api/requestEntry'
import { joinRoom, type JoinRoomParams } from '../api/joinRoom'
import { ApiAccessLevel, type ApiRoom } from '../api/ApiRoom'
import { ApiLobbyStatus } from '../api/requestEntry'
import { useLobby } from '../hooks/useLobby'
const LobbyMessage = ({
title,
body,
children,
}: {
title: string
body: string
children?: ReactNode
}) => (
<VStack alignItems="center" textAlign="center">
<H lvl={1} margin={false} centered>
{title}
</H>
<Text
as="p"
variant="note"
className={children ? css({ marginBottom: '1.5rem' }) : undefined}
>
{body}
</Text>
{children}
</VStack>
)
export const Lobby = ({
roomId,
enterRoom,
@@ -27,124 +52,92 @@ export const Lobby = ({
enterRoom: () => void
}) => {
const { t } = useTranslation('rooms', { keyPrefix: 'join' })
const { data: configData } = useConfig()
const { isLoggedIn, user } = useUser()
const { username } = useSnapshot(userStore)
const { openLoginHint } = useLoginHint()
// Room data strategy:
// 1. Initial fetch is performed to check access and get LiveKit configuration
// 2. Data remains valid for 6 hours to avoid unnecessary refetches
// 3. State is manually updated via queryClient when a waiting participant is accepted
// 4. No automatic refetching or revalidation occurs during this period
const displayName = username || user?.full_name
// Join strategy:
// 1. Submitting the form asks to join the room, which checks access
// 2. The response is written to the [keys.room] cache entry, which
// Conference reuses without refetching. It holds the LiveKit credentials
// when the user may bypass the lobby
// 3. Otherwise the user waits in the lobby, and the credentials returned
// once accepted are added to it
const {
mutate: join,
data: roomData,
error,
isError,
refetch: refetchRoom,
} = useQuery({
queryKey: [keys.room, roomId],
queryFn: () => fetchRoom({ roomId, username: username || user?.full_name }),
staleTime: 6 * 60 * 60 * 1000, // By default, LiveKit access tokens expire 6 hours after generation
retry: false,
enabled: false,
})
useEffect(() => {
if (isError && error?.statusCode == 404) {
} = useMutation<ApiRoom, ApiError, JoinRoomParams>({
mutationFn: joinRoom,
onSuccess: (room) => {
queryClient.setQueryData([keys.room, roomId], room)
},
onError: ({ statusCode }) => {
// The room component will handle the room creation if the user is authenticated
enterRoom()
}
}, [isError, error, enterRoom])
const handleAccepted = (response: ApiRequestEntry) => {
queryClient.setQueryData([keys.room, roomId], {
...roomData,
livekit: response.livekit,
})
enterRoom()
}
if (statusCode == 404) enterRoom()
},
})
const { status, startWaiting } = useLobby({
roomId,
username: username || user?.full_name || 'anonymous',
onAccepted: handleAccepted,
username: displayName || 'anonymous',
onAccepted: (response) => {
queryClient.setQueryData([keys.room, roomId], {
...roomData,
livekit: response.livekit,
})
enterRoom()
},
})
const { openLoginHint } = useLoginHint()
const handleSubmit = async () => {
const { data, error } = await refetchRoom()
if (error?.statusCode == 410) return
if (!data?.livekit) {
// Display a message to inform the user that by logging in, they won't have to wait for room entry approval.
if (data?.access_level == ApiAccessLevel.TRUSTED) {
openLoginHint()
}
startWaiting()
return
}
enterRoom()
}
const isRoomDeleted = isError && error?.statusCode == 410
const lobbyStatus = isRoomDeleted ? ApiLobbyStatus.DELETED : status
const hasJoinFailed = isError && !isRoomDeleted && error?.statusCode != 404
const handleSubmit = () => {
join(
{ roomId, username: displayName || undefined },
{
onSuccess: (data) => {
if (data.livekit) {
enterRoom()
return
}
if (data.access_level == ApiAccessLevel.TRUSTED) {
openLoginHint()
}
startWaiting()
},
}
)
}
switch (lobbyStatus) {
case ApiLobbyStatus.DELETED:
return (
<VStack alignItems="center" textAlign="center">
<H lvl={1} margin={false} centered>
{t('deleted.title')}
</H>
<Text as="p" variant="note">
{t('deleted.body')}
</Text>
</VStack>
<LobbyMessage title={t('deleted.title')} body={t('deleted.body')} />
)
case ApiLobbyStatus.TIMEOUT:
return (
<VStack alignItems="center" textAlign="center">
<H lvl={1} margin={false} centered>
{t('timeoutInvite.title')}
</H>
<Text as="p" variant="note">
{t('timeoutInvite.body')}
</Text>
</VStack>
<LobbyMessage
title={t('timeoutInvite.title')}
body={t('timeoutInvite.body')}
/>
)
case ApiLobbyStatus.DENIED:
return (
<VStack alignItems="center" textAlign="center">
<H lvl={1} margin={false} centered>
{t('denied.title')}
</H>
<Text as="p" variant="note">
{t('denied.body')}
</Text>
</VStack>
)
return <LobbyMessage title={t('denied.title')} body={t('denied.body')} />
case ApiLobbyStatus.WAITING:
return (
<VStack alignItems="center" textAlign="center">
<H lvl={1} margin={false} centered>
{t('waiting.title')}
</H>
<Text
as="p"
variant="note"
className={css({ marginBottom: '1.5rem' })}
>
{t('waiting.body')}
</Text>
<LobbyMessage title={t('waiting.title')} body={t('waiting.body')}>
<Spinner />
</VStack>
</LobbyMessage>
)
default:
@@ -168,7 +161,7 @@ export const Lobby = ({
label={t('usernameLabel')}
aria-label={t('usernameLabel')}
id="input-name"
defaultValue={username || user?.full_name}
defaultValue={displayName}
validate={(value) => !value && t('errors.usernameEmpty')}
wrapperProps={{
noMargin: true,
@@ -178,6 +171,11 @@ export const Lobby = ({
maxLength={50}
/>
)}
{hasJoinFailed && (
<Text variant="warning" role="alert" margin={false} centered>
{t('errors.joinFailed')}
</Text>
)}
</VStack>
</Form>
)
+1
View File
@@ -1,6 +1,7 @@
export {
roomIdPattern,
isRoomValid,
extractRoomId,
flexibleRoomIdPattern,
} from './utils/isRoomValid'
export { generateRoomId } from './utils/generateRoomId'
@@ -3,13 +3,11 @@ import { css } from '@/styled-system/css'
import { Separator as RACSeparator } from 'react-aria-components'
import { useTranslation } from 'react-i18next'
import { usePatchRoom } from '@/features/rooms/api/patchRoom'
import { fetchRoom } from '@/features/rooms/api/fetchRoom'
import { ApiAccessLevel } from '@/features/rooms/api/ApiRoom'
import { keys } from '@/api/queryKeys'
import { useQuery } from '@tanstack/react-query'
import { useParams } from 'wouter'
import { usePublishSourcesManager } from '../hooks/usePublishSourcesManager'
import { usePermissionsManager } from '../hooks/usePermissionsManager'
import { useRoomData } from '../hooks/useRoomData'
import { useEffect } from 'react'
import { closeSidePanel } from '@/stores/layout'
import { useIsAdminOrOwner } from '../hooks/useIsAdminOrOwner'
@@ -34,12 +32,10 @@ export const Admin = () => {
}
}, [isAdminOrOwner])
const { data: readOnlyData } = useQuery({
queryKey: [keys.room, roomId],
queryFn: () => fetchRoom({ roomId }),
retry: false,
enabled: false,
})
// Read the cached room only: an observer with its own queryFn could serve
// the refetch that follows a setting change with a GET, which returns no
// LiveKit credentials
const readOnlyData = useRoomData()
const {
toggleMicrophone,
@@ -32,10 +32,12 @@ const BaseRoom = ({ children }: { children: ReactNode }) => {
const Room = () => {
const { isLoggedIn } = useUser()
const [hasSubmittedEntry, setHasSubmittedEntry] = useState(false)
// Set by the conference when the user turns out to have to go through the
// lobby, even when the join screen was skipped
const [isLobbyRequired, setIsLobbyRequired] = useState(false)
const { roomId } = useParams()
const [location, setLocation] = useLocation()
const initialRoomData = history.state?.initialRoomData
const mode = isLoggedIn && history.state?.create ? 'create' : 'join'
const skipJoinScreen = isLoggedIn && mode === 'create'
@@ -75,10 +77,16 @@ const Room = () => {
return <ErrorScreen />
}
if (!hasSubmittedEntry && !skipJoinScreen) {
if (isLobbyRequired || (!hasSubmittedEntry && !skipJoinScreen)) {
return (
<BaseRoom>
<Join enterRoom={() => setHasSubmittedEntry(true)} roomId={roomId} />
<Join
enterRoom={() => {
setIsLobbyRequired(false)
setHasSubmittedEntry(true)
}}
roomId={roomId}
/>
</BaseRoom>
)
}
@@ -86,9 +94,10 @@ const Room = () => {
return (
<BaseRoom>
<Conference
initialRoomData={initialRoomData}
key={roomId}
roomId={roomId}
mode={mode}
onLobbyRequired={() => setIsLobbyRequired(true)}
/>
</BaseRoom>
)
@@ -1,5 +1,45 @@
import { describe, expect, it } from 'vitest'
import { normalizeRoomId } from './isRoomValid'
import { extractRoomId, normalizeRoomId } from './isRoomValid'
describe('extractRoomId', () => {
const origin = 'https://meet.example.com'
const plain = { roomId: 'abc-defg-hij', suffix: '' }
it('accepts a bare room id', () => {
expect(extractRoomId('abc-defg-hij', origin)).toEqual(plain)
expect(extractRoomId(' abc-defg-hij ', origin)).toEqual(plain)
})
it('accepts a meeting URL on this origin', () => {
expect(extractRoomId(`${origin}/abc-defg-hij`, origin)).toEqual(plain)
expect(extractRoomId(`${origin}/abc-defg-hij/`, origin)).toEqual(plain)
})
it('keeps query strings and fragments in the suffix', () => {
expect(
extractRoomId(`${origin}/abc-defg-hij?from=outlook-addin`, origin)
).toEqual({ roomId: 'abc-defg-hij', suffix: '?from=outlook-addin' })
expect(
extractRoomId(
`${origin}/abc-defg-hij/?utm_source=mail&utm_medium=email#x`,
origin
)
).toEqual({
roomId: 'abc-defg-hij',
suffix: '?utm_source=mail&utm_medium=email#x',
})
})
it('rejects other origins and invalid ids', () => {
expect(
extractRoomId('https://evil.example/abc-defg-hij', origin)
).toBeNull()
expect(extractRoomId(`${origin}/not-a-room`, origin)).toBeNull()
expect(extractRoomId(`${origin}/abc-defg-hij/extra`, origin)).toBeNull()
expect(extractRoomId('abc-defg-hij?from=x', origin)).toBeNull()
})
})
describe('normalizeRoomId', () => {
it('lowercases and re-inserts the hyphens of a ten-letter id', () => {
@@ -10,6 +10,28 @@ export const isRoomValid = (roomIdOrUrl: string) =>
roomRegex.test(roomIdOrUrl) ||
new RegExp(`^${window.location.origin}/${roomIdPattern}$`).test(roomIdOrUrl)
export const extractRoomId = (
input: string,
origin: string = window.location.origin
): { roomId: string; suffix: string } | null => {
const value = input.trim()
if (roomRegex.test(value)) return { roomId: value, suffix: '' }
let url: URL
try {
url = new URL(value)
} catch {
return null
}
if (url.origin !== origin) return null
const path = url.pathname.slice(1)
const roomId = path.endsWith('/') ? path.slice(0, -1) : path
return roomRegex.test(roomId)
? { roomId, suffix: `${url.search}${url.hash}` }
: null
}
export const normalizeRoomId = (roomId: string) => {
const cleanId = roomId.toLowerCase().replace(/-/g, '')
if (cleanId.length === 10) {
@@ -102,46 +102,93 @@ export const SettingsDialogExtended = (props: SettingsDialogExtended) => {
</Heading>
)}
<TabList border={false}>
<Tab icon highlight id={SettingsDialogExtendedKey.ACCOUNT}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.ACCOUNT}
aria-label={t(`tabs.${SettingsDialogExtendedKey.ACCOUNT}`)}
>
<RiAccountCircleLine />
{isWideScreen && t(`tabs.${SettingsDialogExtendedKey.ACCOUNT}`)}
</Tab>
<Tab icon highlight id={SettingsDialogExtendedKey.AUDIO}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.AUDIO}
aria-label={t(`tabs.${SettingsDialogExtendedKey.AUDIO}`)}
>
<RiSpeakerLine />
{isWideScreen && t(`tabs.${SettingsDialogExtendedKey.AUDIO}`)}
</Tab>
<Tab icon highlight id={SettingsDialogExtendedKey.VIDEO}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.VIDEO}
aria-label={t(`tabs.${SettingsDialogExtendedKey.VIDEO}`)}
>
<RiVideoOnLine />
{isWideScreen && t(`tabs.${SettingsDialogExtendedKey.VIDEO}`)}
</Tab>
<Tab icon highlight id={SettingsDialogExtendedKey.GENERAL}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.GENERAL}
aria-label={t(`tabs.${SettingsDialogExtendedKey.GENERAL}`)}
>
<RiSettings3Line />
{isWideScreen && t(`tabs.${SettingsDialogExtendedKey.GENERAL}`)}
</Tab>
<Tab icon highlight id={SettingsDialogExtendedKey.NOTIFICATIONS}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.NOTIFICATIONS}
aria-label={t(`tabs.${SettingsDialogExtendedKey.NOTIFICATIONS}`)}
>
<RiNotification3Line />
{isWideScreen &&
t(`tabs.${SettingsDialogExtendedKey.NOTIFICATIONS}`)}
</Tab>
<Tab icon highlight id={SettingsDialogExtendedKey.SHORTCUTS}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.SHORTCUTS}
aria-label={t(`tabs.${SettingsDialogExtendedKey.SHORTCUTS}`)}
>
<RiKeyboardBoxLine />
{isWideScreen && t(`tabs.${SettingsDialogExtendedKey.SHORTCUTS}`)}
</Tab>
{isAdminOrOwner && (
<Tab icon highlight id={SettingsDialogExtendedKey.TRANSCRIPTION}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.TRANSCRIPTION}
aria-label={t(
`tabs.${SettingsDialogExtendedKey.TRANSCRIPTION}`
)}
>
<Icon name="speech_to_text" />
{isWideScreen &&
t(`tabs.${SettingsDialogExtendedKey.TRANSCRIPTION}`)}
</Tab>
)}
{showRecordingTab && (
<Tab icon highlight id={SettingsDialogExtendedKey.RECORDING}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.RECORDING}
aria-label={t(`tabs.${SettingsDialogExtendedKey.RECORDING}`)}
>
<RiRecordCircleLine />
{isWideScreen &&
t(`tabs.${SettingsDialogExtendedKey.RECORDING}`)}
</Tab>
)}
<Tab icon highlight id={SettingsDialogExtendedKey.ACCESSIBILITY}>
<Tab
icon
highlight
id={SettingsDialogExtendedKey.ACCESSIBILITY}
aria-label={t(`tabs.${SettingsDialogExtendedKey.ACCESSIBILITY}`)}
>
<RiEyeLine />
{isWideScreen &&
t(`tabs.${SettingsDialogExtendedKey.ACCESSIBILITY}`)}
+1 -1
View File
@@ -15,7 +15,7 @@ i18n
.use(initReactI18next)
.use(LanguageDetector)
.init({
supportedLngs: ['en', 'fr', 'nl', 'de', 'es'],
supportedLngs: ['en', 'fr', 'nl', 'de', 'es', 'pt'],
fallbackLng,
ns: i18nDefaultNamespace,
detection: {
@@ -6,6 +6,7 @@ const languageLabels: Record<string, string> = {
de: 'Deutsch',
nl: 'Nederlands',
es: 'Español',
pt: 'Português',
}
export const useLanguageLabels = () => {
@@ -18,6 +19,7 @@ export const useLanguageLabels = () => {
key: lang,
value: lang,
label: languageLabels[lang],
lang,
}))
return {
languagesList,
+2
View File
@@ -70,6 +70,7 @@
"usernameHint": "Wird anderen Teilnehmenden angezeigt",
"usernameLabel": "Dein Name",
"errors": {
"joinFailed": "Beitritt zum Meeting nicht möglich. Bitte versuche es erneut.",
"usernameEmpty": "Dein Name darf nicht leer sein"
},
"cameraDisabled": "Kamera ist deaktiviert.",
@@ -491,6 +492,7 @@
"destination": "Ein neues Dokument wird erstellt auf",
"destinationUnknown": "Ein neues Dokument wird erstellt",
"language": "Meeting-Sprache:",
"languageAriaLabel": "{{language}}, Meeting-Sprache ändern",
"recording": "Auch eine Videoaufzeichnung starten"
},
"button": {
+2
View File
@@ -70,6 +70,7 @@
"usernameHint": "Shown to other participants",
"usernameLabel": "Your name",
"errors": {
"joinFailed": "Unable to join the meeting. Please try again.",
"usernameEmpty": "Your name cannot be empty"
},
"cameraDisabled": "Camera is disabled.",
@@ -491,6 +492,7 @@
"destination": "A new document will be created on",
"destinationUnknown": "A new document will be created",
"language": "Meeting language:",
"languageAriaLabel": "{{language}}, change the meeting language",
"recording": "Also start a video recording"
},
"button": {
+2
View File
@@ -70,6 +70,7 @@
"usernameHint": "Se muestra a los demás participantes",
"usernameLabel": "Tu nombre",
"errors": {
"joinFailed": "No se ha podido acceder a la reunión. Inténtalo de nuevo.",
"usernameEmpty": "Tu nombre no puede estar vacío"
},
"cameraDisabled": "La cámara está desactivada.",
@@ -490,6 +491,7 @@
"destination": "Se creará un nuevo documento en",
"destinationUnknown": "Se creará un nuevo documento",
"language": "Idioma de la reunión:",
"languageAriaLabel": "{{language}}, cambiar el idioma de la reunión",
"recording": "Iniciar también una grabación de vídeo"
},
"button": {
+2
View File
@@ -70,6 +70,7 @@
"usernameHint": "Affiché aux autres participants",
"usernameLabel": "Votre nom",
"errors": {
"joinFailed": "Impossible de rejoindre la réunion. Veuillez réessayer.",
"usernameEmpty": "Votre nom ne peut pas être vide"
},
"cameraDisabled": "La caméra est désactivée.",
@@ -491,6 +492,7 @@
"destination": "Un nouveau document sera créé sur",
"destinationUnknown": "Un nouveau document sera créé",
"language": "Langue de la réunion :",
"languageAriaLabel": "{{language}}, modifier la langue de la réunion",
"recording": "Démarrer aussi un enregistrement vidéo"
},
"button": {
+2
View File
@@ -70,6 +70,7 @@
"usernameHint": "Getoond aan andere deelnemers",
"usernameLabel": "Uw naam",
"errors": {
"joinFailed": "Deelnemen aan de vergadering is niet gelukt. Probeer het opnieuw.",
"usernameEmpty": "Uw naam kan niet leeg zijn"
},
"cameraDisabled": "Camera is uitgeschakeld.",
@@ -491,6 +492,7 @@
"destination": "Er wordt een nieuw document aangemaakt op",
"destinationUnknown": "Een nieuw document wordt aangemaakt",
"language": "Vergadertalen:",
"languageAriaLabel": "{{language}}, vergadertaal wijzigen",
"recording": "Start ook een video-opname"
},
"button": {
@@ -0,0 +1,34 @@
{
"accessibility": {
"title": "Acessibilidade",
"introduction": "O <i>Visio</i> está comprometido em tornar seus serviços digitais acessíveis, em conformidade com o Artigo 47 da Lei nº 2005-102, de 11 de fevereiro de 2005.",
"declaration": {
"title": "Declaração de Acessibilidade",
"date": "Estabelecida em 4 de dezembro de 2024."
},
"scope": "Esta declaração de acessibilidade aplica-se ao site visio.numerique.gouv.fr",
"complianceStatus": {
"title": "Status de Conformidade",
"body": "O site visio.numerique.gouv.fr não está em conformidade com o RGAA 4.1. O site ainda não foi auditado. No entanto, a equipe se esforça para criar um site acessível a todos, seguindo as recomendações do RGAA."
},
"improvement": {
"title": "Melhoria e Contato",
"body": "Se você não conseguir acessar um conteúdo ou serviço, pode entrar em contato com o responsável por lasuite.numerique.gouv.fr para ser direcionado a uma alternativa acessível ou obter o conteúdo de outra forma.",
"contact": {
"email": "E-mail: visio@numerique.gouv.fr",
"address": "Endereço: DINUM, 20 avenue de Ségur 75007 Paris"
},
"response": "Tentamos responder em até 2 dias úteis."
},
"recourse": {
"title": "Meios de Recurso",
"introduction": "Este procedimento deve ser utilizado no seguinte caso: você relatou ao responsável pelo site um problema de acessibilidade que o impede de acessar um conteúdo ou um dos serviços do portal e não recebeu uma resposta satisfatória.",
"options": {
"intro": "Você pode:",
"option1": "Enviar uma mensagem ao Defensor dos Direitos",
"option2": "Entrar em contato com o delegado do Defensor dos Direitos em sua região",
"option3": "Enviar uma carta pelo correio (gratuito, não precisa de selo): </br> Défenseur des droits Libre réponse 71120 75342 Paris CEDEX 07"
}
}
}
}
@@ -0,0 +1,62 @@
{
"title": "Testar sua configuração",
"runTest": "Iniciar teste",
"runAgain": "Testar novamente",
"cancel": "Cancelar",
"detailsFor": "Detalhes de {{step}}",
"downloadReport": "Baixar relatório",
"homeLink": "Testar sua configuração",
"progress": "{{done}}/{{total}}",
"progressLabel": "Progresso do teste de conexão",
"groups": {
"local": "Navegador e dispositivos",
"network": "Conectividade com o servidor"
},
"steps": {
"browser": "Navegador",
"microphone": "Microfone",
"camera": "Câmera",
"devices": "Dispositivos de mídia",
"websocket": "WebSocket",
"webrtc": "WebRTC",
"turn": "TURN",
"reconnect": "Reconexão",
"selectedCandidate": "Rota selecionada",
"publishAudio": "Publicação de áudio",
"publishVideo": "Publicação de vídeo"
},
"status": {
"pending": "Pendente",
"running": "Em execução…",
"success": "Aprovado",
"warning": "Não ideal",
"failed": "Falhou",
"skipped": "Ignorado"
},
"counts": {
"passed": "aprovados",
"warnings": "não ideais",
"failed": "falharam",
"skipped": "ignorados"
},
"summary": {
"idle": "Pronto para testar",
"idleHint": "O teste leva cerca de um minuto. Sua câmera e microfone são usados apenas durante a execução.",
"running": "Testando…",
"runningHint": "Mantenha esta página aberta até que todas as verificações terminem.",
"passed": "Tudo funciona perfeitamente",
"passedHint": "Seu navegador, seus dispositivos e sua rede estão prontos para uma reunião.",
"partial": "Parcialmente testado",
"partialHint": "Algumas verificações foram ignoradas. Permita o acesso à sua câmera e ao microfone para testá-los.",
"warning": "Conexão abaixo do ideal",
"warningHint": "Você pode participar das reuniões, mas a qualidade de vídeo e áudio pode ser reduzida devido às configurações da sua rede. Sua equipe de TI pode melhorar isso.",
"warningDocLink": "Requisitos de rede para sua equipe de TI",
"warningDocLinkAriaLabel": "Abrir os requisitos de rede para sua equipe de TI - abre em uma nova janela",
"failed_one": "{{count}} verificação falhou",
"failed_other": "{{count}} verificações falharam",
"failedHint": "Abra as verificações que falharam abaixo para ver os detalhes e envie o relatório para sua equipe de TI."
},
"help": {
"firewall": "Se os testes de rede falharem, verifique as permissões do navegador e as regras de filtragem de rede (WebRTC, WebSocket, TURN) com sua equipe de TI."
}
}
+71
View File
@@ -0,0 +1,71 @@
{
"backToHome": "Voltar para a tela inicial",
"cancel": "Cancelar",
"closeDialog": "Fechar diálogo",
"error": {
"heading": "Ocorreu um erro ao carregar a página"
},
"feedback": {
"context": "Sua opinião ajuda a melhorar o produto!",
"cta": "Compartilhar sua opinião - nova aba"
},
"forbidden": {
"heading": "Você não tem permissão para ver esta página"
},
"loading": "Carregando…",
"loggedInUserTooltip": "Conectado como ",
"login": {
"buttonLabel": "Entrar",
"proconnectButtonLabel": "Entrar com ProConnect",
"proconnectLinkLabel": "O que é ProConnect? - nova aba",
"proconnectLink": "O que é ProConnect?"
},
"logout": "Sair",
"notFound": {
"heading": "Verifique o código da reunião",
"body": "Verifique se você digitou corretamente o código da reunião na URL. Exemplo:"
},
"selected": "selecionado",
"submit": "OK",
"support": {
"buttonLabel": "Contatar suporte",
"openError": "Não foi possível abrir o formulário de contato. Tente novamente mais tarde.",
"sent": {
"title": "Mensagem enviada",
"body": "A equipe de suporte recebeu sua mensagem.",
"close": "Fechar"
}
},
"footer": {
"links": {
"legifrance": "legifrance.gouv.fr",
"infogouv": "info.gouv.fr",
"servicepublic": "service-public.fr",
"datagouv": "data.gouv.fr",
"legalsTerms": "Aviso Legal",
"data": "Dados Pessoais e Cookies",
"accessibility": "Acessibilidade: não conforme",
"connectionTest": "Testar sua configuração",
"ariaLabel": "nova janela",
"codeAnnotation": "Nosso código é aberto e disponível neste",
"code": "Repositório de Código Aberto",
"technicalDetails": "Aviso Técnico",
"termsOfService": "Termos de serviço"
},
"mentions": "Salvo indicação em contrário, os conteúdos deste site estão disponíveis sob",
"license": "licença etalab 2.0"
},
"loginHint": {
"title": "Entre com sua conta",
"body": "Em vez de esperar, entre com sua conta.",
"button": {
"ariaLabel": "Fechar a sugestão",
"label": "OK"
}
},
"skipLink": "Ir para o conteúdo principal",
"clipboardContent": {
"url": "Para entrar na videoconferência, clique neste link: {{roomUrl}}",
"numberAndPin": "Para entrar por telefone, ligue para {{phoneNumber}} e digite o código: {{pinCode}}"
}
}
+63
View File
@@ -0,0 +1,63 @@
{
"createMeeting": "Criar uma reunião",
"heading": "Videoconferência Simples e Segura",
"intro": "Comunique-se e trabalhe com facilidade, sem comprometer sua soberania",
"joinInputError": "Use um link ou código de reunião. Exemplos:",
"joinInputExample": "URL ou código de 10 letras",
"joinInputLabel": "Link da reunião",
"joinInputSubmit": "Entrar na reunião",
"joinMeeting": "Entrar em uma reunião",
"joinMeetingTipContent": "Você pode entrar em uma reunião colando o link completo na barra de endereços do navegador.",
"joinMeetingTipHeading": "Você sabia?",
"loginToCreateMeeting": "Faça login para criar uma reunião",
"moreLinkLabel": "Saiba mais sobre {{appTitle}} - nova aba",
"moreLink": "Saiba mais",
"moreAbout": "sobre {{appTitle}}",
"connectionTestLink": "Testar sua configuração",
"createMenu": {
"laterOption": "Criar uma reunião para depois",
"instantOption": "Iniciar uma reunião instantânea"
},
"laterMeetingDialog": {
"heading": "Seus dados de conexão",
"description": "Compartilhe essas informações com os convidados. Eles poderão entrar na reunião sem precisar se autenticar. Esta reunião é permanente e pode ser reutilizada.",
"permissions": "Pessoas com este link não precisam de sua permissão para entrar nesta reunião.",
"copy": "Copiar informações",
"copied": "Informações copiadas para a área de transferência",
"copyUrl": "Copiar o link da reunião",
"phone": {
"call": "Ligar:",
"pinCode": "Código:"
}
},
"introSlider": {
"previous": {
"label": "Slide anterior",
"labelWithPosition": "Slide anterior ({{current}} de {{total}})",
"tooltip": "Slide anterior"
},
"next": {
"label": "Próximo slide",
"labelWithPosition": "Próximo slide ({{current}} de {{total}})",
"tooltip": "Próximo slide"
},
"beta": {
"text": "Participar do beta",
"tooltip": "Preencher o formulário"
},
"slide1": {
"title": "Mude para a simplicidade. Experimente agora!",
"body": "Descubra uma solução intuitiva e acessível, projetada para todos os agentes públicos, seus parceiros e muito mais."
},
"slide2": {
"title": "Faça chamadas em grupo sem limites",
"body": "Reuniões sem limite de tempo, com comunicação fluida e de alta qualidade, independentemente do tamanho do grupo."
},
"slide3": {
"title": "Transforme suas reuniões com IA",
"body": "Obtenha transcrições precisas e acionáveis para aumentar sua produtividade. Recurso em beta — experimente agora!"
},
"carouselLabel": "Apresentação de slides introdutória",
"slidePosition": "Slide {{current}} de {{total}}"
}
}
+37
View File
@@ -0,0 +1,37 @@
{
"title": "Aviso Legal",
"creator": {
"title": "Editor",
"body": "O serviço Visio é publicado pela Direção Interministerial do Digital do Estado (DINUM), localizada em:",
"contact": {
"title": "Informações de Contato",
"address": "20 avenue de Ségur",
"city": "75007 Paris",
"phone": "Tel. da recepção: 01.71.21.01.70",
"siret": "SIRET: 12000101100010 (secretaria-geral do governo)",
"siren": "SIREN: 120 001 011"
}
},
"director": {
"title": "Diretor de Publicação",
"body": "A diretora de publicação é Madame Stéphanie Schaer, Diretora Interministerial do Digital."
},
"hosting": {
"title": "Hospedagem",
"body": "O serviço é hospedado pela Outscale West-1 CloudGouv SecNumCloud, localizada na França."
},
"accessibility": {
"title": "Acessibilidade",
"body": "A conformidade com os padrões de acessibilidade digital é um objetivo futuro. O site ainda não foi auditado. No entanto, a equipe se esforça para criar um site acessível a todos, seguindo as recomendações do RGAA.",
"more": "Para mais informações: ",
"link": "link para a página de acessibilidade",
"status": "Status de acessibilidade: não conforme"
},
"reuse": {
"title": "Reutilização de Conteúdo e Links",
"body1": "Salvo menção explícita de propriedade intelectual detida por terceiros, os conteúdos deste site são disponibilizados sob a ",
"license": "licença aberta Etalab 2.0",
"body2": "Você é livre, em especial, para reproduzir, copiar, modificar, extrair, transformar, comunicar, distribuir, redistribuir, publicar, transmitir e explorar os conteúdos, desde que mencione a fonte, a data de sua última atualização e não induza terceiros a erro quanto às informações neles contidas.",
"body3": "Qualquer site público ou privado está autorizado a estabelecer, sem autorização prévia, um link (inclusive link direto) para as informações divulgadas neste site."
}
}
@@ -0,0 +1,74 @@
{
"defaultName": "Um colaborador",
"joined": {
"description": "{{name}} entrou na sala"
},
"raised": {
"description": "{{name}} levantou a mão.",
"cta": "Abrir lista de espera"
},
"muted": "{{name}} silenciou seu microfone. Nenhum participante pode ouvi-lo.",
"openChat": "Abrir chat",
"chatMessageReceived": "{{name}} diz: {{message}}",
"lowerHand": {
"auto": "Parece que você começou a falar, então sua mão será abaixada.",
"dismiss": "Manter mão levantada"
},
"autoMuteLargeRoom": {
"auto": "Você entrou em uma reunião grande. Seu microfone foi silenciado automaticamente.",
"dismiss": "Ativar microfone"
},
"reaction": {
"description": "{{name}} reagiu com {{emoji}}"
},
"permissionsRemoved": {
"camera": "O anfitrião desativou o vídeo para todos os participantes.",
"microphone": "O anfitrião desativou o microfone para todos os participantes.",
"screen_share": "O anfitrião desativou o compartilhamento de tela para todos os participantes."
},
"waitingParticipants": {
"one": "Uma pessoa quer entrar nesta chamada.",
"several": "Várias pessoas querem entrar nesta chamada.",
"open": "Abrir",
"accept": "Aceitar"
},
"transcript": {
"waitingForTracks": "A transcrição está aguardando um microfone. Ative seu microfone para que a transcrição possa começar.",
"started": "{{name}} iniciou a transcrição da reunião.",
"stopped": "{{name}} parou a transcrição da reunião.",
"limitReached": "A transcrição excedeu a duração máxima permitida e será salva automaticamente.",
"interrupted": "A transcrição foi interrompida inesperadamente; a parte já registrada será salva.",
"failed": "A transcrição foi interrompida inesperadamente e não pôde ser salva.",
"aborted": "Não foi possível iniciar a transcrição.",
"requested": "{{name}} quer iniciar a transcrição da reunião."
},
"screenRecording": {
"waitingForTracks": "A gravação está aguardando áudio ou vídeo. Ative seu microfone ou câmera, ou compartilhe sua tela, para que a gravação possa começar.",
"started": "{{name}} iniciou a gravação da reunião.",
"stopped": "{{name}} parou a gravação da reunião.",
"limitReached": "A gravação excedeu a duração máxima permitida e será salva automaticamente.",
"interrupted": "A gravação foi interrompida inesperadamente; a parte já gravada será salva.",
"failed": "A gravação foi interrompida inesperadamente e não pôde ser salva.",
"aborted": "Não foi possível iniciar a gravação.",
"requested": "{{name}} quer iniciar a gravação da reunião."
},
"recordingSave": {
"transcript": {
"message": "Sua gravação está sendo salva! Enviaremos a transcrição para <strong>{{email}}</strong> assim que estiver pronta.",
"default": "Sua gravação está sendo salva! Enviaremos a transcrição para seu email assim que estiver pronta."
},
"screenRecording": {
"message": "Sua gravação está sendo salva! Enviaremos uma notificação para <strong>{{email}}</strong> assim que estiver pronta.",
"default": "Sua gravação está sendo salva! Enviaremos uma notificação para seu email assim que estiver pronta."
}
},
"roleChanged": {
"body": "Seu papel mudou. Agora você é {{role}}.",
"roles": {
"owner": "Anfitrião",
"administrator": "Co-anfitrião",
"member": "Membro"
}
},
"openMenu": "Abrir menu"
}
@@ -0,0 +1,28 @@
{
"error": {
"title": "Gravação indisponível",
"body": "A gravação está indisponível ou pode ter sido excluída. Apenas o anfitrião da reunião pode acessá-la. Sinta-se à vontade para contatá-lo se necessário."
},
"expired": {
"title": "Gravação expirada",
"body": "Esta gravação foi excluída em {{date}}."
},
"authentication": {
"title": "Autenticação necessária",
"body": "Por favor, faça login para acessar esta gravação."
},
"unsaved": {
"title": "Download Indisponível",
"body": "Esta gravação ainda não está pronta para download. Tente novamente mais tarde."
},
"success": {
"title": "Sua gravação está pronta!",
"body": "Gravação da reunião {{room}} de {{created_at}}.",
"expiration": "Atenção, esta gravação expirará após {{expiration_days}} dia(s).",
"button": "Baixar",
"warning": {
"title": "Compartilhamento de link desativado",
"body": "O compartilhamento da gravação via link ainda não está disponível. Apenas anfitriões podem baixá-la."
}
}
}
+876
View File
@@ -0,0 +1,876 @@
{
"feedback": {
"heading": {
"normal": "Você saiu da reunião",
"duplicateIdentity": "Você entrou na reunião de outro dispositivo",
"participantRemoved": "Você foi removido da reunião por um anfitrião",
"roomDeleted": "Esta reunião foi excluída",
"connectionLost": "A conexão com a reunião foi perdida",
"connectionFailed": "Não foi possível entrar na reunião"
},
"home": "Voltar para o início",
"back": "Reentrar na reunião"
},
"selectDevice": {
"loading": "Carregando…",
"select": "Selecione um valor",
"permissionsNeeded": "Permissão necessária",
"deviceNotFound": {
"videoinput": "Nenhuma câmera detectada. Verifique se está conectada corretamente.",
"audioinput": "Nenhum microfone detectado. Verifique se está conectado corretamente."
},
"deviceInUse": {
"videoinput": "Câmera indisponível: provavelmente está sendo usada por outro aplicativo ou guia do navegador.",
"audioinput": "Microfone indisponível: provavelmente está sendo usado por outro aplicativo ou guia do navegador."
},
"settings": {
"audio": "Configurações de áudio",
"video": "Configurações de vídeo"
},
"effects": "Planos de fundo e Efeitos",
"videoinput": {
"choose": "Selecionar câmera",
"permissionsNeeded": "Selecionar câmera - permissão necessária",
"disable": "Desativar câmera",
"enable": "Ativar câmera",
"turnedOff": "Câmera desligada",
"turnedOn": "Câmera ligada",
"label": "Câmera",
"placeholder": "Ative a câmera para ver a pré-visualização"
},
"audioinput": {
"choose": "Selecionar microfone",
"level": "Nível de entrada do microfone",
"muteTest": "Ative seu microfone para testá-lo",
"permissionsNeeded": "Selecionar microfone - permissão necessária",
"disable": "Desativar microfone",
"enable": "Ativar microfone",
"turnedOff": "Microfone desligado",
"turnedOn": "Microfone ligado",
"label": "Microfone"
},
"audiooutput": {
"choose": "Selecionar alto-falante",
"permissionsNeeded": "Selecionar alto-falante - permissão necessária",
"test": "Testar alto-falantes",
"testing": "Reproduzindo som de teste…"
}
},
"join": {
"effects": {
"description": "Aplicar planos de fundo e efeitos",
"title": "Efeitos",
"subTitle": "Configure os efeitos da sua câmera."
},
"heading": "Entrar na reunião?",
"joinLabel": "Entrar",
"joinMeeting": "Entrar na reunião",
"toggleOff": "Clique para desligar",
"toggleOn": "Clique para ligar",
"usernameHint": "Visível para outros participantes",
"usernameLabel": "Seu nome",
"errors": {
"joinFailed": "Não foi possível entrar na reunião. Tente novamente.",
"usernameEmpty": "Seu nome não pode estar vazio"
},
"cameraDisabled": "Câmera desativada.",
"cameraNotFound": "Nenhuma câmera detectada. Verifique se está conectada corretamente.",
"cameraInUse": "Sua câmera está indisponível. Provavelmente está sendo usada por outro aplicativo ou guia do navegador.",
"cameraStarting": "Câmera iniciando…",
"cameraNotGranted": "Deseja que os outros possam ver você durante a reunião?",
"cameraAndMicNotGranted": "Deseja que os outros possam ver e ouvir você durante a reunião?",
"permissionsButton": {
"cameraAndMicNotGranted": "Permitir acesso à câmera e microfone",
"cameraNotGranted": "Permitir acesso à câmera"
},
"videoPreview": {
"enabled": "Pré-visualização de vídeo ativada",
"disabled": "Pré-visualização de vídeo desativada"
},
"waiting": {
"title": "Solicitando entrada...",
"body": "Você poderá entrar nesta chamada quando alguém autorizar"
},
"denied": {
"title": "Você não pode entrar nesta chamada",
"body": "Sua solicitação de entrada foi negada."
},
"timeoutInvite": {
"title": "Você não pode entrar nesta chamada",
"body": "Ninguém respondeu à sua solicitação"
},
"deleted": {
"title": "Você não pode entrar nesta chamada",
"body": "Esta reunião foi excluída."
}
},
"leaveRoomPrompt": "Isso fará você sair da reunião.",
"shareDialog": {
"copy": "Copiar informações",
"copyUrl": "Copiar link",
"copied": "Informações copiadas para a área de transferência",
"heading": "Sua reunião está pronta",
"description": "Compartilhe este link com as pessoas que deseja convidar para a reunião.",
"permissions": "Pessoas com este link não precisam de sua permissão para entrar nesta reunião.",
"closeDialog": "Fechar diálogo",
"phone": {
"call": "Ligar:",
"pinCode": "Código:"
}
},
"pagination": {
"label": "Páginas de participantes",
"count": "{{currentPage}} de {{totalPageCount}}",
"next": "próxima página",
"previous": "página anterior"
},
"mediaErrorDialog": {
"DeviceInUse": {
"title": {
"audioinput": "Falha ao ativar microfone",
"videoinput": "Falha ao ativar câmera"
},
"body": {
"audioinput": "Seu microfone já está em uso por outra aba ou aplicativo, o que impede sua ativação nesta chamada. Se desejar, feche a outra aba ou aplicativo para usá-lo aqui.",
"videoinput": "Sua câmera já está em uso por outra aba ou aplicativo, o que impede sua ativação nesta chamada. Se desejar, feche a outra aba ou aplicativo para usá-la aqui."
}
},
"NotFound": {
"title": {
"audioinput": "Nenhum microfone detectado",
"videoinput": "Nenhuma câmera detectada"
},
"body": {
"audioinput": "Nenhum microfone foi detectado no seu dispositivo. Verifique se está conectado corretamente e se não está desativado por um botão físico de mudo, depois tente novamente.",
"videoinput": "Nenhuma câmera foi detectada no seu dispositivo. Verifique se está conectada corretamente e se não está bloqueada por uma tampa ou botão físico, depois tente novamente."
}
},
"close": "OK"
},
"permissionErrorDialog": {
"heading": {
"camera": "{{appTitle}} não tem permissão para usar sua câmera",
"microphone": "{{appTitle}} não tem permissão para usar seu microfone",
"cameraAndMicrophone": "{{appTitle}} não tem permissão para usar seu microfone ou câmera",
"default": "{{appTitle}} não tem permissão para usar certas funcionalidades"
},
"body": {
"openMenu": {
"others": "Clique no ícone de configurações ICON_PLACEHOLDER na barra de endereços do navegador",
"safari": "Clique no menu 'Safari' e abra 'Configurações para {{appDomain}}'."
},
"details": {
"camera": "Permita o acesso à câmera",
"microphone": "Permita o acesso ao microfone",
"cameraAndMicrophone": "Permita o acesso à câmera e ao microfone",
"default": "Ative as permissões necessárias."
}
}
},
"systemPermissionDialog": {
"heading": {
"camera": "Permitir que o navegador use sua câmera",
"microphone": "Permitir que o navegador use seu microfone",
"cameraAndMicrophone": "Permitir que o navegador use sua câmera e seu microfone"
},
"device": {
"camera": "câmera",
"microphone": "microfone",
"cameraAndMicrophone": "câmera e microfone"
},
"intro": "Seu navegador já tem permissão, mas as configurações do sistema do computador estão bloqueando o acesso à sua {{device}}.",
"steps": {
"macos": {
"1": "Nos Ajustes do Sistema, abra “Privacidade e Segurança”.",
"2": "Permita que o navegador acesse sua {{device}}."
},
"windows": {
"1": "Nas Configurações do Windows, abra “Privacidade e segurança”.",
"2": "Ative o acesso a {{device}} e permita que aplicativos da área de trabalho o utilizem."
},
"android": {
"1": "Nas Configurações do Android, abra “Apps” e selecione seu navegador.",
"2": "Em “Permissões”, permita o acesso a {{device}} e recarregue esta página."
},
"other": {
"1": "Nas configurações de privacidade do sistema, permita que o navegador acesse sua {{device}}.",
"2": "Depois, tente novamente."
}
},
"openSettings": "Abrir configurações do sistema"
},
"silentMic": {
"tooltip": "Seu microfone está ativado, mas nenhum som está sendo detectado. Clique para saber mais.",
"dialog": {
"title": "Nenhum som detectado",
"intro": "Seu microfone está ativado, mas não detectamos nenhum som há algum tempo. Verifique o seguinte:",
"causes": {
"system": "As configurações de privacidade do seu sistema podem estar bloqueando o acesso ao microfone.",
"hardware": "Um botão de mudo pode estar ativado, ou seu microfone pode estar desconectado ou com defeito.",
"wrongDevice": "O microfone incorreto pode estar selecionado. Tente escolher outro no menu de microfone."
},
"hint": "Fale novamente após verificar essas configurações. Este aviso desaparecerá assim que o som for detectado.",
"close": "Entendi",
"discard": "Desativar detecção de microfone silencioso"
}
},
"permissionsButton": {
"tooltip": "Mais informações",
"ariaLabel": "Problema de permissões. Mostrar mais informações"
},
"error": {
"createRoom": {
"heading": "Autenticação Necessária",
"body": "Esta sala ainda não foi criada. Por favor, autentique-se para criá-la ou aguarde um usuário autenticado fazer isso."
},
"deletedRoom": {
"heading": "Reunião excluída",
"body": "Esta reunião foi excluída e não é mais possível entrar nela."
},
"screenShare": {
"title": "Não foi possível compartilhar sua tela",
"ariaLabel": "Não foi possível compartilhar sua tela",
"message": "Seu navegador pode não ter permissão para gravar a tela no seu computador.",
"settingsInstructions": "Acesse",
"settingsLabel": {
"macos": "Ajustes do Sistema",
"windows": "Configurações de privacidade do Windows"
},
"helpLinkText": "Para saber mais, veja",
"helpLinkLabel": "Problema de apresentação",
"closeButton": "Fechar",
"newTab": "Nova janela"
}
},
"isIdleDisconnectModal": {
"title": "Você ainda está aí?",
"body": "Você é o único participante. Esta chamada será encerrada em {{duration}}. Deseja continuar?",
"settingsPrefix": "Para parar de ver esta mensagem, vá em",
"settingsLink": "Configurações > Geral",
"settingsSuffix": ".",
"stayButton": "Continuar a chamada",
"leaveButton": "Sair agora",
"countdownAnnouncement": "Chamada encerra em {{duration}}."
},
"controls": {
"region": "Controles da chamada",
"microphone": "Microfone",
"camera": "Câmera",
"chat": {
"open": "Fechar o chat",
"closed": "Abrir o chat",
"input": {
"textArea": {
"label": "Digite uma mensagem",
"placeholder": "Digite uma mensagem"
},
"button": {
"label": "Enviar mensagem"
}
}
},
"info": {
"open": "Ocultar informações",
"closed": "Mostrar informações"
},
"hand": {
"raise": "Levantar a mão",
"lower": "Abaixar a mão"
},
"subtitles": {
"closed": "Mostrar legendas",
"open": "Ocultar legendas"
},
"screenShare": {
"start": "Compartilhar tela",
"stop": "Parar compartilhamento de tela"
},
"leave": "Sair",
"participants": {
"open": "Ocultar todos",
"closed": "Ver todos",
"count_one": "{{count}} participante",
"count_other": "{{count}} participantes"
},
"tools": {
"open": "Ocultar mais ferramentas",
"closed": "Mostrar mais ferramentas"
},
"admin": {
"open": "Ocultar admin",
"closed": "Abrir admin"
},
"moreOptions": "Mais opções",
"reactions": {
"button": "Enviar reação",
"toolbar": "Enviar reação",
"announce": "{{name}} : {{emoji}}",
"you": "você",
"emojis": {
"thumbs-up": "joinha",
"thumbs-down": "negativo",
"clapping-hands": "palmas",
"red-heart": "coração vermelho",
"face-with-tears-of-joy": "rindo às lágrimas",
"face-with-open-mouth": "rosto surpreso",
"party-popper": "festa",
"folded-hands": "mãos unidas"
}
}
},
"pictureInPicture": {
"placeholder": {
"title": "Sua chamada está em outra janela.",
"description": "O modo Picture-in-Picture permite que você continue conectado à chamada enquanto realiza outras tarefas.",
"bringBack": "Trazer a chamada de volta aqui"
},
"stage": "Participantes",
"controlBar": "Controles da reunião",
"title": "Reunião em picture-in-picture"
},
"options": {
"buttonLabel": "Mais Opções",
"items": {
"feedback": "Nos dê sua opinião",
"settings": "Configurações",
"screenRecording": "Gravação de tela",
"transcript": "Transcrição",
"username": "Atualizar seu nome",
"effects": "Planos de fundo e Efeitos",
"switchCamera": "Trocar câmera",
"pictureInPicture": {
"enter": "Picture-in-picture",
"exit": "Fechar picture-in-picture"
},
"fullscreen": {
"enter": "Tela cheia",
"exit": "Sair do modo tela cheia"
},
"support": "Contatar suporte",
"documentation": "Documentação"
}
},
"effects": {
"activateCamera": "Sua câmera está desativada. Escolha uma opção para ativá-la.",
"cameraDisabled": "Sua câmera está desativada.",
"notAvailable": "Efeitos de vídeo estarão disponíveis em breve no seu navegador. Estamos trabalhando nisso! Enquanto isso, use o Google Chrome para melhor desempenho ou Firefox :(",
"heading": "Desfoque",
"clear": "Desativar efeito",
"blur": {
"title": "Desfoque de fundo",
"status": {
"none": "Fundo limpo.",
"light": "Fundo levemente desfocado.",
"strong": "Fundo fortemente desfocado."
},
"light": {
"apply": "Desfocar levemente o fundo",
"clear": "Desativar desfoque"
},
"normal": {
"apply": "Desfocar o fundo",
"clear": "Desativar desfoque"
}
},
"virtual": {
"title": "Planos de fundo virtuais",
"selectedLabel": "Plano de fundo aplicado:",
"apply": "Substituir seu plano de fundo:",
"personal": {
"title": "Meus planos de fundo",
"selectedLabel": "Desmarcar plano de fundo (está atualmente aplicado).",
"apply": "Usar como plano de fundo.",
"selectFileTooltip": "Selecione um arquivo de imagem para usar como plano de fundo pessoal",
"notLoggedInWarning": "Você não está logado, os planos de fundo pessoais não serão salvos entre reuniões.",
"warningUploadDisabled": "Planos de fundo pessoais não são salvos entre reuniões no momento.",
"uploadLimitReached": "Você não pode enviar mais planos de fundo pessoais.",
"uploadInProgress": "Imagem sendo enviada…",
"deleteLabel": "Excluir plano de fundo.",
"errors": {
"close": "Fechar",
"file_too_large": {
"title": "Arquivo muito grande",
"description": "O arquivo é muito grande. Escolha um arquivo menor que {{maxSize, number}} MB."
},
"invalid_file_type": {
"title": "Tipo de arquivo inválido",
"description": "O tipo de arquivo não é suportado. Escolha um arquivo {{allowedExtension, list(type: 'disjunction')}}."
}
}
},
"presets": {
"title": "Sugestões",
"descriptions": {
"0": "Móvel de madeira canelada",
"1": "Sala de reuniões",
"2": "Loft com divisória de vidro preto",
"3": "Sala de jantar",
"4": "Prateleiras de madeira",
"5": "Escada de madeira",
"6": "Biblioteca cinza",
"7": "Balcão de café"
}
}
},
"faceLandmarks": {
"title": "Efeitos Visuais",
"glasses": {
"apply": "Adicionar Óculos",
"clear": "Remover Óculos"
},
"french": {
"apply": "Adicionar toque francês",
"clear": "Remover toque francês"
}
}
},
"sidePanel": {
"ariaLabel": "Painel lateral - {{title}}",
"backToTools": "Voltar às ferramentas da reunião",
"heading": {
"participants": "Participantes",
"effects": "Planos de fundo e Efeitos",
"chat": "Mensagens no chat",
"transcript": "Transcrever",
"screenRecording": "Gravar",
"admin": "Configurações do anfitrião",
"tools": "Mais ferramentas",
"info": "Informações da reunião"
},
"content": {
"participants": "participantes",
"effects": "Planos de fundo e Efeitos",
"chat": "mensagens",
"transcript": "transcrever",
"screenRecording": "gravar",
"admin": "configurações do anfitrião",
"tools": "mais ferramentas",
"info": "informações da reunião"
},
"closeButton": "Ocultar {{content}}",
"escapeHint": "Pressione Escape para fechar"
},
"chat": {
"disclaimer": "As mensagens são visíveis apenas para os participantes no momento em que são enviadas. Todas as mensagens são excluídas ao final da chamada.",
"messagesLog": "Mensagens do chat"
},
"moreTools": {
"body": "Acesse mais ferramentas para melhorar suas reuniões.",
"linkAriaLabel": "Abrir documentação sobre ferramentas - abre em nova janela",
"moreLink": "Abrir documentação",
"tools": {
"transcript": {
"title": "Transcrever",
"body": "Transforme reuniões em texto."
},
"screenRecording": {
"title": "Gravar",
"body": "Salve reuniões como vídeo."
}
}
},
"info": {
"roomInformation": {
"title": "Informações de Conexão",
"button": {
"ariaLabel": "Copiar as informações da sua reunião",
"copy": "Copiar informações",
"copied": "Informações copiadas"
},
"phone": {
"call": "Ligar:",
"pinCode": "Código:"
}
}
},
"transcript": {
"heading": "Transcreva sua reunião com o Assistente de IA",
"body": "Transcreva até {{max_duration}} de reunião.",
"bodyWithoutMaxDuration": "Transcreva sua reunião sem limites.",
"details": {
"receiver": "A transcrição será enviada ao anfitrião e co-anfitriões.",
"destination": "Um novo documento será criado em",
"destinationUnknown": "Um novo documento será criado",
"language": "Idioma da reunião:",
"languageAriaLabel": "{{language}}, alterar o idioma da reunião",
"recording": "Também iniciar uma gravação"
},
"button": {
"start": "Iniciar transcrição da reunião",
"stop": "Parar transcrição da reunião",
"saving": "Salvando…",
"starting": "Iniciando…",
"anotherModeStarted": "Gravação de tela em andamento. Troque de painel e pare-a."
},
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre transcrição - abre em nova janela",
"notAdminOrOwner": {
"heading": "Acesso Restrito",
"body": "Por motivos de segurança, apenas o criador da reunião ou um admin pode iniciar uma transcrição (beta).",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre acesso à transcrição - abre em nova janela",
"dividerLabel": "OU",
"login": {
"heading": "Login Necessário",
"body": "Apenas o criador da reunião ou um admin pode iniciar uma transcrição. Faça login para verificar suas permissões."
},
"request": {
"heading": "Solicitar Transcrição",
"body": "O anfitrião será notificado e poderá ativar a transcrição para você.",
"buttonLabel": "Solicitar"
}
},
"notLoggedIn": {
"heading": "Faça login para transcrever",
"body": "Nesta reunião, qualquer participante conectado pode iniciar uma transcrição (beta).",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre acesso à transcrição - abre em uma nova janela",
"dividerLabel": "OU",
"login": {
"heading": "Login necessário",
"body": "Faça login e volte a este painel para iniciar a transcrição."
},
"request": {
"heading": "Solicitar transcrição",
"body": "O anfitrião será notificado e poderá ativar a transcrição para você.",
"buttonLabel": "Solicitar"
}
},
"premium": {
"heading": "Recurso avançado",
"body": "Este recurso não está disponível para você. Entre em contato com o suporte para mais informações.",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre acesso avançado - abre em nova janela",
"dividerLabel": "OU",
"login": {
"heading": "Você não está logado!",
"body": "Você precisa estar logado para usar este recurso. Faça login e tente novamente."
},
"request": {
"heading": "Solicitar Transcrição",
"body": "O anfitrião será notificado e poderá ativar a transcrição para você.",
"buttonLabel": "Solicitar"
}
}
},
"screenRecording": {
"heading": "Grave esta chamada para depois",
"body": "Grave até {{max_duration}} de reunião.",
"bodyWithoutMaxDuration": "Grave sua reunião sem limite.",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre gravação - abre em nova janela",
"details": {
"receiver": "A gravação será enviada ao anfitrião e co-anfitriões.",
"destination": "Esta gravação será armazenada temporariamente em nossos servidores",
"loading": "Iniciando gravação",
"linkMore": "Saiba mais",
"transcription": "Transcrever esta gravação",
"quality": "Qualidade de vídeo ajustável.",
"qualityEdit": "Alterar"
},
"button": {
"start": "Iniciar gravação da reunião",
"stop": "Parar gravação da reunião",
"saving": "Salvando…",
"starting": "Iniciando…",
"anotherModeStarted": "Transcrição em andamento. <br/> Troque de painel e pare-a."
},
"notAdminOrOwner": {
"heading": "Acesso Restrito",
"body": "Por motivos de segurança, apenas o criador da reunião ou um admin pode iniciar uma gravação (beta).",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre acesso à gravação - abre em nova janela",
"dividerLabel": "OU",
"login": {
"heading": "Login Necessário",
"body": "Apenas o criador da reunião ou um admin pode iniciar a gravação. Faça login para verificar suas permissões."
},
"request": {
"heading": "Solicitar Gravação",
"body": "O anfitrião será notificado e poderá ativar a gravação para você.",
"buttonLabel": "Solicitar"
}
},
"notLoggedIn": {
"heading": "Faça login para gravar",
"body": "Nesta reunião, qualquer participante conectado pode iniciar uma gravação (beta).",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre acesso à gravação - abre em uma nova janela",
"dividerLabel": "OU",
"login": {
"heading": "Login necessário",
"body": "Faça login e volte a este painel para iniciar a gravação."
},
"request": {
"heading": "Solicitar gravação",
"body": "O anfitrião será notificado e poderá ativar a gravação para você.",
"buttonLabel": "Solicitar"
}
},
"premium": {
"heading": "Recurso avançado",
"body": "Este recurso não está disponível para você. Entre em contato com o suporte para mais informações.",
"linkMore": "Abrir documentação",
"linkAriaLabel": "Abrir documentação sobre acesso avançado - abre em nova janela",
"dividerLabel": "OU",
"login": {
"heading": "Você não está logado!",
"body": "Você precisa estar logado para usar este recurso. Faça login e tente novamente."
},
"request": {
"heading": "Solicitar Gravação",
"body": "O anfitrião será notificado e poderá ativar a gravação para você.",
"buttonLabel": "Solicitar"
}
},
"durationMessage": "(limitado a {{max_duration}}) "
},
"errorRecordingAlertDialog": {
"title": "Falha na Gravação",
"body": {
"stop": "Não foi possível parar a gravação. Tente novamente em instantes.",
"start": "Não foi possível iniciar a gravação. Tente novamente em instantes."
},
"button": "OK"
},
"admin": {
"description": "Estas configurações de anfitrião permitem que você mantenha o controle da reunião. Apenas anfitriões podem acessar estes controles.",
"access": {
"title": "Acesso à sala",
"description": "Estas configurações também se aplicarão a futuras ocorrências desta reunião.",
"type": "Tipos de acesso à reunião",
"levels": {
"public": {
"label": "Aberta",
"description": "Ninguém precisa solicitar para entrar na reunião."
},
"trusted": {
"label": "Aberta para pessoas confiáveis",
"description": "Pessoas autenticadas não precisam solicitar para entrar na reunião."
},
"restricted": {
"label": "Restrita",
"description": "Pessoas que não foram convidadas para a reunião devem solicitar para entrar."
}
}
},
"moderation": {
"title": "Moderação da Reunião",
"description": "Estas configurações restringem as ações que os participantes podem realizar durante a reunião.",
"microphone": {
"label": "Ligar microfone",
"description": ""
},
"camera": {
"label": "Ativar vídeo",
"description": ""
},
"screenshare": {
"label": "Compartilhar tela",
"description": "Desativar esta opção impedirá que participantes compartilhem sua tela, e qualquer compartilhamento em andamento será interrompido imediatamente."
},
"mute": {
"label": "Silenciar outros",
"description": "Quando desativado, participantes não poderão mais silenciar outros participantes."
}
}
},
"rating": {
"submit": "Enviar",
"question": "O que você achou da qualidade da sua chamada?",
"levels": {
"min": "muito ruim",
"max": "excelente"
}
},
"openFeedback": {
"question": "O que podemos fazer para melhorar?",
"placeholder": "Descreva seus bugs ou compartilhe suas sugestões…",
"submit": "Enviar",
"skip": "Pular"
},
"confirmationMessage": {
"heading": "Obrigado pelo seu envio",
"body": "Nossa equipe de produto analisa cuidadosamente seu feedback. Retornaremos o mais breve possível."
},
"authenticationMessage": {
"heading": "Como podemos entrar em contato?",
"placeholder": "Seu email",
"submit": "Enviar",
"ignore": "Ignorar"
},
"participants": {
"subheading": "Na sala",
"you": "Você",
"unknown": "Participante desconhecido",
"host": "Anfitrião",
"cohost": "Co-anfitrião",
"member": "Membro",
"contributors": "Colaboradores",
"collapsable": {
"open": "Abrir lista {{name}}",
"close": "Fechar lista {{name}}"
},
"unauthenticated": {
"badge": "Usuário não autenticado"
},
"muteYourself": "Fechar seu microfone",
"muteParticipant": "Fechar o microfone de {{name}}",
"muteParticipantAlert": {
"heading": "Silenciar {{name}}",
"description": "Silenciar {{name}} para todos os participantes? {{name}} será o único que poderá reativar seu microfone.",
"confirm": "Silenciar",
"cancel": "Cancelar"
},
"raisedHands": "Mãos levantadas",
"lowerParticipantHand": "Abaixar a mão de {{name}}",
"lowerParticipantsHand": "Abaixar todas as mãos",
"muteParticipants": "Silenciar todos os microfones",
"waiting": {
"title": "Sala de espera",
"accept": {
"button": "Aceitar",
"label": "Aceitar {{name}} na reunião",
"all": "Aceitar todos"
},
"deny": {
"button": "Negar",
"label": "Negar {{name}} na reunião",
"all": "Negar todos"
}
},
"moreOptions": "Mais opções"
},
"participantMenu": {
"remove": {
"label": "Remover da chamada",
"ariaLabel": "Remover {{name}} da chamada"
},
"unpin": {
"label": "Desafixar",
"ariaLabel": "Desafixar {{name}}"
},
"pin": {
"label": "Fixar",
"ariaLabel": "Fixar {{name}}"
},
"promote": {
"label": "Tornar co-anfitrião",
"ariaLabel": "Tornar {{name}} co-anfitrião"
},
"demote": {
"label": "Remover papel de co-anfitrião",
"ariaLabel": "Remover papel de co-anfitrião de {{name}}"
}
},
"pinAnnouncements": {
"pin": "O vídeo de {{name}} está fixado.",
"unpin": "O vídeo de {{name}} não está mais fixado.",
"self": {
"pin": "Seu vídeo está fixado.",
"unpin": "Seu vídeo não está mais fixado."
}
},
"recordingStateToast": {
"transcript": {
"started": "Transcrevendo",
"starting": "Transcrição iniciando",
"stopping": "Transcrição parando"
},
"screen_recording": {
"started": "Gravação em andamento",
"starting": "Iniciando gravação",
"stopping": "Parando gravação"
},
"any": {
"started": "Gravação em andamento"
},
"limitReachedAlert": {
"title": "Limite de gravação excedido",
"description": "A gravação excedeu a duração máxima permitida{{duration_message}}. Será salva automaticamente.",
"durationMessage": " de {{duration}}",
"button": "OK"
}
},
"participantTileFocus": {
"containerLabel": "Opções para {{name}}",
"toolbarHint": "{{shortcut}}: acessar atalhos diretamente.",
"pin": {
"enable": "Fixar",
"disable": "Desafixar"
},
"effects": "Aplicar planos de fundo e efeitos",
"muteParticipant": "Silenciar {{name}}",
"fullScreen": "Tela cheia"
},
"screenShareZoom": {
"toolbarLabel": "Controles de zoom do compartilhamento de tela",
"zoomIn": "Aumentar zoom",
"zoomInWithShortcut": "Aumentar zoom ({{shortcut}})",
"zoomOut": "Diminuir zoom",
"zoomOutWithShortcut": "Diminuir zoom ({{shortcut}})",
"wheelShortcut": "Control mais roda do mouse",
"wheelShortcutMac": "⌘+roda do mouse",
"wheelShortcutHint": "Atalho: Control mais roda do mouse para aumentar ou diminuir o zoom.",
"wheelShortcutHintMac": "Atalho: Command mais roda do mouse para aumentar ou diminuir o zoom.",
"fitToWindow": "Ajustar à janela",
"fullScreen": "Tela cheia",
"exitFullScreen": "Sair da tela cheia",
"currentZoomLevel": "Zoom {{level}} %",
"panHint": "Zoom {{level}} %. Arraste com o mouse ou volte o foco para o compartilhamento de tela e use as setas do teclado para navegar pela imagem.",
"fullScreenEntered": "Tela cheia ativada",
"fullScreenExited": "Tela cheia desativada"
},
"shortcutsPanel": {
"title": "Atalhos de teclado",
"categories": {
"navigation": "Navegação",
"media": "Mídia",
"interaction": "Interação"
},
"actions": {
"open-shortcuts": "Abrir ajuda de atalhos",
"focus-toolbar": "Focar barra inferior",
"focus-pagination": "Focar na paginação de participantes",
"toggle-microphone": "Alternar microfone",
"toggle-camera": "Alternar câmera",
"push-to-talk": "Pressionar para falar (segure para ativar)",
"reaction": "Painel de reações",
"fullscreen": "Alternar tela cheia",
"recording": "Alternar painel de gravação",
"raise-hand": "Levantar ou abaixar a mão",
"toggle-chat": "Alternar chat",
"toggle-participants": "Alternar participantes",
"open-shortcuts-settings": "Abrir configurações de atalhos",
"zoom-in": "Aumentar zoom na tela compartilhada",
"zoom-out": "Diminuir zoom na tela compartilhada",
"zoom-reset": "Redefinir o zoom da tela compartilhada",
"zoom-pan": "Mover pela tela compartilhada com zoom"
},
"sr": {
"control": "Control",
"command": "Command",
"alt": "Alt",
"option": "Option",
"shift": "Shift",
"plus": "mais",
"hold": "Segure {{key}}",
"arrows": "Teclas de seta",
"plusKey": "Tecla de mais",
"minusKey": "Tecla de menos",
"noShortcut": "Sem atalho"
},
"visual": {
"hold": "Segure {{key}}",
"arrows": "↑ ↓ ← →"
}
},
"fullScreenWarning": {
"message": "Para evitar exibição em loop infinito, não compartilhe sua tela inteira. Em vez disso, compartilhe uma aba ou outra janela.",
"stop": "Parar apresentação",
"ignore": "Ignorar"
},
"participantTile": {
"screenShare": "Tela de {{name}}"
}
}
+18
View File
@@ -0,0 +1,18 @@
{
"createMeeting": {
"createButton": "Criar",
"joinButton": "Entrar com o Visio",
"copyLinkTooltip": "Copiar link",
"resetLabel": "Redefinir",
"participantLimit": "Até 150 participantes.",
"popupBlocked": "O pop-up foi bloqueado. Por favor, permita pop-ups para este site.",
"settingsTooltip": "Configurações da reunião"
},
"roomSettings": {
"title": "Configurações da reunião",
"description": "Configurar a reunião {{roomSlug}}.",
"notAllowed": "Você não tem permissão para modificar as configurações desta reunião.",
"error": "Não foi possível carregar as configurações da reunião.",
"closeButton": "Fechar"
}
}
+229
View File
@@ -0,0 +1,229 @@
{
"account": {
"currentlyLoggedAs": "Você está conectado como <0>{{user}}</0>",
"heading": "Conta",
"youAreNotLoggedIn": "Você não está conectado.",
"nameLabel": "Seu Nome",
"authentication": "Autenticação",
"nameError": "Seu nome não pode estar vazio"
},
"preferences": {
"title": "Preferências",
"idleDisconnectModal": {
"label": "Sair de chamadas sem participantes",
"description": "Sai automaticamente de uma chamada após alguns minutos se nenhum outro participante entrar"
},
"autoMuteLargeRoom": {
"label": "Silenciar meu microfone automaticamente",
"description": "Silencia automaticamente seu microfone ao entrar em uma reunião grande."
}
},
"audio": {
"microphone": {
"heading": "Microfone",
"label": "Selecione sua entrada de áudio",
"disabled": "Microfone desativado"
},
"noiseReduction": {
"label": "Otimização avançada de voz",
"heading": "Filtros de áudio",
"ariaLabel": {
"enable": "Ativar redução de ruído",
"disable": "Desativar redução de ruído"
}
},
"speakers": {
"heading": "Alto-falantes",
"label": "Selecione sua saída de áudio",
"test": "Testar",
"ongoingTest": "Testando som…",
"safariWarning": "A seleção de alto-falante ainda não está disponível no Safari devido a limitações do navegador."
},
"permissionsRequired": "Permissões necessárias"
},
"video": {
"camera": {
"heading": "Câmera",
"label": "Selecione sua entrada de vídeo",
"disabled": "Câmera desativada",
"previewAriaLabel": {
"enabled": "Pré-visualização de vídeo ativada",
"disabled": "Pré-visualização de vídeo desativada"
}
},
"resolution": {
"heading": "Resolução",
"publish": {
"label": "Selecione sua resolução de envio (máx.)",
"items": {
"veryHigh": "Definição muito alta",
"high": "Alta definição",
"medium": "Definição padrão",
"low": "Baixa definição"
}
},
"subscribe": {
"label": "Selecione sua resolução de recepção (máx.)",
"items": {
"high": "Alta definição (automática)",
"medium": "Definição padrão",
"low": "Baixa definição"
}
}
},
"permissionsRequired": "Permissões necessárias"
},
"transcription": {
"heading": "Transcrição",
"language": {
"label": "Idioma da reunião",
"options": {
"french": "Francês (fr)",
"english": "Inglês (en)",
"dutch": "Holandês (nl)",
"german": "Alemão (de)",
"auto": "Automático"
}
}
},
"notifications": {
"heading": "Notificações sonoras",
"label": "notificações sonoras para",
"actions": {
"disable": "Desativar",
"enable": "Ativar"
},
"items": {
"participantJoined": {
"label": "Participante entrou"
},
"handRaised": {
"label": "Mão levantada"
},
"messageReceived": {
"label": "Mensagem recebida"
},
"participantWaiting": {
"label": "Participante aguardando"
}
}
},
"shortcuts": {
"listLabel": "Atalhos de teclado",
"columnAction": "Ação",
"columnShortcut": "Atalho"
},
"dialog": {
"heading": "Configurações"
},
"language": {
"heading": "Idioma",
"label": "Idioma"
},
"settingsButtonLabel": "Configurações",
"accessibility": {
"announceReactions": {
"label": "Anunciar reações em voz alta"
},
"font": {
"label": "Fonte de exibição",
"description": "Personalize a fonte usada na interface para melhorar seu conforto de leitura.",
"options": {
"default": "Padrão",
"lexend": "Lexend (legibilidade melhorada)",
"atkinson-hyperlegible": "Atkinson Hyperlegible (baixa visão)",
"opendyslexic": "OpenDyslexic (dislexia)"
}
},
"captions": {
"heading": "Legendas",
"textSize": {
"label": "Tamanho do texto das legendas",
"options": {
"small": "Pequeno",
"medium": "Médio",
"large": "Grande"
}
},
"fontColor": {
"label": "Cor da fonte",
"options": {
"default": "Padrão",
"white": "Branco",
"black": "Preto",
"blue": "Azul",
"green": "Verde",
"red": "Vermelho",
"yellow": "Amarelo",
"cyan": "Ciano",
"magenta": "Magenta"
}
},
"backgroundColor": {
"label": "Cor de fundo",
"options": {
"default": "Padrão",
"white": "Branco",
"black": "Preto",
"blue": "Azul",
"green": "Verde",
"red": "Vermelho",
"yellow": "Amarelo",
"cyan": "Ciano",
"magenta": "Magenta"
}
}
}
},
"tabs": {
"account": "Perfil",
"audio": "Áudio",
"video": "Vídeo",
"general": "Geral",
"notifications": "Notificações",
"accessibility": "Acessibilidade",
"transcription": "Transcrição",
"shortcuts": "Atalhos",
"rooms": "Salas",
"recording": "Gravação"
},
"roomDefaults": {
"heading": "Configurações padrão de sala",
"description": "Escolha as configurações aplicadas por padrão às novas salas que você criar. Você ainda pode alterá-las para cada reunião nas configurações de anfitrião."
},
"recording": {
"heading": "Qualidade da gravação",
"locked": "Essas configurações não podem ser alteradas enquanto uma gravação estiver iniciando ou em andamento.",
"profile": {
"label": "Tipo de conteúdo",
"options": {
"talking_heads": {
"label": "Pessoas falando",
"description": "Otimizado para pessoas falando na câmera com slides ocasionais. Menores arquivos."
},
"text": {
"label": "Apresentações e texto",
"description": "Mantém o texto nítido ao compartilhar slides, documentos ou código."
},
"mixed": {
"label": "Conteúdo misto",
"description": "Equilibrado para uma combinação de câmeras, compartilhamento de tela e movimento moderado."
},
"full": {
"label": "Qualidade máxima",
"description": "Maior fidelidade e movimento mais suave. Maiores arquivos."
}
}
},
"resolution": {
"label": "Resolução",
"description": "Resoluções mais altas geram arquivos maiores.",
"options": {
"540p": "540p (qHD)",
"720p": "720p (HD)",
"1080p": "1080p (Full HD)"
}
},
"defaultOption": "Padrão"
}
}
@@ -0,0 +1,130 @@
{
"title": "Termos de Uso do Visio",
"articles": {
"article1": {
"title": "1. Escopo",
"content": "Este documento define os termos de uso do Visio (doravante “Visio” ou “o aplicativo”), um aplicativo de videoconferência projetado especificamente para administrações estatais e órgãos sob sua supervisão."
},
"article2": {
"title": "2. Objetivo do aplicativo",
"content": "O Visio ajuda a promover a cooperação entre equipes de administrações estatais e órgãos sob sua supervisão, apoia o trabalho remoto e facilita a organização de reuniões, conferências ou sessões de treinamento.",
"paragraphs": [
"O Visio é desenvolvido e operado pela Direção Interministerial do Digital (DINUM).",
"O aplicativo é disponibilizado pela DINUM às administrações estatais e órgãos sob sua supervisão, para uso por seus agentes, parceiros e prestadores de serviços convidados.",
"Qualquer uso do Visio deve estar em conformidade com estes termos de uso e, quando aplicável, com a política de uso da respectiva administração supervisora."
]
},
"article3": {
"title": "3. Definições",
"paragraphs": [
"O Visio é o produto cujo uso é descrito nestes termos e apresentado na seguinte página: https://visio.numerique.gouv.fr.",
"Usuários do Visio são quaisquer pessoas que utilizem o Visio para fins de comunicação por videoconferência, sejam elas agentes, parceiros ou prestadores de serviços das administrações pertinentes. A administração supervisora é a administração estatal ou órgão sob sua supervisão que disponibiliza o Visio aos seus agentes, parceiros ou prestadores de serviços.",
"Organizadores de sala são os usuários responsáveis por uma sala de videoconferência após se autenticarem via ProConnect.",
"A administração supervisora é a administração integrante do sistema de informação e comunicação do Estado que disponibiliza o Visio aos seus agentes, parceiros ou prestadores de serviços."
]
},
"article4": {
"title": "4. Acesso ao serviço",
"definition": "O Visio é disponibilizado aos usuários por sua administração supervisora. Os organizadores podem então compartilhar um link concedendo acesso à sala com qualquer pessoa, sob sua responsabilidade."
},
"article5": {
"title": "5. Funcionalidades",
"sections": {
"section1": {
"title": "5.1. Funcionalidades disponíveis para organizadores",
"content": "O Visio permite que agentes de administrações estatais e órgãos sob sua supervisão criem uma sala de videoconferência a partir de uma estação de trabalho padrão, vinculada à sua conta ProConnect.",
"paragraph1": "Eles podem então compartilhar o link da reunião com outras pessoas, usuários, pertencentes ou não à administração.",
"paragraph2": "Para esta finalidade, cada organizador de sala pode:",
"capabilities": [
"Proteger o acesso à sala com uma sala de espera;",
"Autorizar a entrada de cada usuário na sala;",
"Silenciar microfones e câmeras dos usuários;",
"Remover um usuário da sala;",
"Utilizar a ferramenta de transcrição de reunião após obter o consentimento dos usuários, sob sua responsabilidade."
],
"paragraph3": "Os agentes devem entrar em contato com sua administração supervisora para garantir o enquadramento adequado para o uso do Visio, especialmente em reuniões sujeitas a requisitos elevados de confidencialidade.",
"paragraph4": "A ferramenta de transcrição automática pode ser utilizada pelos organizadores a partir do menu de configurações da sala. Os organizadores são responsáveis por garantir o consentimento dos usuários que participam da reunião transcrita. O idioma da transcrição pode ser alterado no mesmo menu. Ao final da reunião, um link é enviado ao organizador para acessar a transcrição armazenada na ferramenta chamada Docs, operada pela DINUM."
},
"section2": {
"title": "5.2. Funcionalidades disponíveis para usuários",
"content": "O Visio permite que qualquer usuário, seja agente público ou não, participe de qualquer sala do Visio para a qual tenha sido convidado por um organizador e usufrua de suas funcionalidades.",
"paragraph": "Para esta finalidade, cada usuário pode:",
"capabilities": [
"Fornecer um nome de exibição ao entrar na sala;",
"Comunicar-se remotamente por áudio e/ou vídeo;",
"Compartilhar sua tela;",
"Trocar mensagens publicamente durante a sessão com todos os usuários na sala;",
"Acessar informações técnicas sobre a sala e recursos de acessibilidade;",
"Ativar ou desativar sua câmera e/ou microfone a qualquer momento;",
"Proteger a privacidade do seu ambiente quando a câmera estiver ligada, selecionando e ativando um plano de fundo antes de entrar na sala ou durante a videoconferência."
]
}
}
},
"article6": {
"title": "6. Compromissos e responsabilidades dos usuários",
"sections": {
"section1": {
"title": "6.1 Usos permitidos",
"paragraphs": [
"O Visio é fornecido para facilitar trocas profissionais entre agentes de administrações estatais e órgãos sob sua supervisão e colaboradores externos.",
"Os usuários são responsáveis pelas imagens e sons que disponibilizam na sala de videoconferência. Essa responsabilidade aplica-se tanto ao que sua câmera ou microfone possa transmitir quanto ao que seu dispositivo possa tornar acessível a terceiros. Para tanto, os usuários devem utilizar o aplicativo em ambiente profissional e não devem divulgar a terceiros informações protegidas por sigilo profissional (por exemplo: uso de filtros de privacidade, fones de ouvido, etc.).",
"Os usuários são responsáveis pelos dados ou conteúdos que inserem no serviço de mensagens da sala, devendo garantir que apenas mensagens apropriadas sejam enviadas."
]
},
"section2": {
"title": "6.2 Usos proibidos",
"paragraphs": [
"Os usuários comprometem-se a não inserir no serviço de mensagens da sala do Visio, nem tornar acessível por imagem ou som, qualquer conteúdo ou informação que viole as leis e regulamentos aplicáveis."
]
}
}
},
"article7": {
"title": "7. Compromissos e responsabilidades da DINUM",
"sections": {
"section1": {
"title": "7.1. Segurança do aplicativo",
"paragraphs": [
"A DINUM compromete-se a proteger o Visio, em especial adotando todas as medidas necessárias para garantir a segurança e a confidencialidade das comunicações.",
"O aplicativo é homologado nas condições previstas pelo Decreto nº 2010-112 alterado."
]
},
"section2": {
"title": "7.2. Acesso ao aplicativo",
"paragraphs": [
"A DINUM compromete-se a fornecer os meios necessários e razoáveis para garantir o acesso contínuo ao aplicativo.",
"O aplicativo está disponível 24 horas por dia, 7 dias por semana, exceto durante períodos de manutenção.",
"A DINUM busca atingir uma taxa anual de disponibilidade do aplicativo de 99,5%, excluindo manutenções programadas. Em caso de incidente ou manutenção, busca um tempo de restabelecimento de 72 horas fora do horário comercial.",
"No âmbito da manutenção do ambiente de execução do aplicativo, a DINUM reserva-se o direito de suspender temporariamente o funcionamento do aplicativo. Sempre que possível, os usuários serão informados com pelo menos 48 horas de antecedência. Em situações de emergência, essa suspensão poderá ocorrer sem aviso prévio.",
"Essas interrupções excepcionais podem ser necessárias, por exemplo, para operações de gerenciamento de dados, atualizações em produção ou mudanças arquiteturais.",
"A indisponibilidade do aplicativo não confere aos usuários direito a qualquer forma de compensação."
]
},
"section3": {
"title": "7.3. Gestão de suporte",
"paragraphs": [
"A DINUM fornece suporte de primeiro nível aos usuários, exclusivamente sobre aspectos técnicos do aplicativo.",
"Esse suporte pode ser acionado por meio do formulário de contato online.",
"O prazo-meta de resposta às solicitações é de dois dias úteis a partir do envio do e-mail; esse prazo pode variar conforme a complexidade e o volume de solicitações a serem processadas."
]
},
"section4": {
"title": "7.4. Monitoramento do uso do aplicativo",
"paragraphs": [
"A DINUM reserva-se o direito de suspender ou excluir a conta de um usuário que tenha descumprido estes termos de uso, sem prejuízo de eventuais ações de responsabilidade civil ou penal cabíveis contra o interessado. As informações poderão ser transmitidas à administração supervisora do usuário, responsável pela disponibilização do aplicativo.",
"A suspensão ou revogação de uma ou mais contas não gera direito a indenização de qualquer natureza."
]
},
"section5": {
"title": "7.5. Código Aberto e Licenças",
"content": "O código-fonte do serviço é aberto e está disponível aqui: https://github.com/suitenumerique/meet. O conteúdo fornecido pela DINUM é licenciado sob a Licença Aberta 2.0 (Licence Ouverte 2.0), com exceção de logotipos e representações iconográficas ou fotográficas, que podem ser regidos por licenças próprias."
}
}
},
"article8": {
"title": "8. Alterações nos termos de uso",
"content": "Os termos destas condições de uso podem ser modificados ou complementados a qualquer momento, sem aviso prévio, em função de alterações realizadas no serviço, evolução da legislação ou por qualquer outro motivo considerado necessário.\nEssas alterações e atualizações vinculam o usuário, que deve, portanto, consultar regularmente esta seção para verificar os termos vigentes."
}
}
}
+6 -2
View File
@@ -95,7 +95,7 @@ export type SelectProps<T> = Omit<
> & {
iconComponent?: RemixiconComponentType
label: ReactNode
items: Array<{ value: T; label: ReactNode }>
items: Array<{ value: T; label: ReactNode; lang?: string }>
errors?: ReactNode
placement?: Placement
variant?: 'light' | 'dark'
@@ -150,7 +150,11 @@ export const Select = <T extends string | number>({
>
{({ isSelected }) => (
<>
{item.label}
{item.lang ? (
<span lang={item.lang}>{item.label}</span>
) : (
item.label
)}
{isSelected && (
<VisuallyHidden>, {t('selected')}</VisuallyHidden>
)}
+7
View File
@@ -6,6 +6,13 @@ body,
height: 100%;
}
/* RGAA 10.5: every text color must be paired with a declared background
color, so custom browser or system colors cannot make text unreadable. */
body {
background-color: var(--colors-default-bg);
color: var(--colors-default-text);
}
:root {
--avatar-cap-height: 0.7;
}
+9 -2
View File
@@ -1,7 +1,13 @@
// Map frontend language codes to backend language codes
export type BackendLanguage = 'en-us' | 'fr-fr' | 'nl-nl' | 'de-de' | 'es-es'
export type FrontendLanguage = 'en' | 'fr' | 'nl' | 'de' | 'es'
export type BackendLanguage =
| 'en-us'
| 'fr-fr'
| 'nl-nl'
| 'de-de'
| 'es-es'
| 'pt-br'
export type FrontendLanguage = 'en' | 'fr' | 'nl' | 'de' | 'es' | 'pt'
const frontendToBackendMap: Record<FrontendLanguage, BackendLanguage> = {
en: 'en-us',
@@ -9,6 +15,7 @@ const frontendToBackendMap: Record<FrontendLanguage, BackendLanguage> = {
nl: 'nl-nl',
de: 'de-de',
es: 'es-es',
pt: 'pt-br',
}
export const convertToBackendLanguage = (
+2 -1
View File
@@ -1,6 +1,7 @@
FROM python:3.13.16-alpine3.24 AS base
RUN apk add --no-cache --upgrade 'ca-certificates>=20261020-r0'
RUN apk add --no-cache --upgrade 'ca-certificates>=20261020-r0' \
'musl-utils>=1.2.6-r3'
# Install ffmpeg for audio/video processing (format conversion, extraction, compression)
+1
View File
@@ -10,6 +10,7 @@ dependencies = [
"pydantic>=2.5.0",
"pydantic-settings>=2.1.0",
"celery==5.6.3",
"kombu==5.6.2",
"redis==5.2.1",
"boto3==1.43.118",
"dockerflow==2026.3.4",
+14 -3
View File
@@ -5,6 +5,7 @@ from datetime import datetime, timezone
from celery.result import AsyncResult
from fastapi import APIRouter, Depends, HTTPException, Request, status
from pydantic import ValidationError
from summary.core.analytics import get_analytics
from summary.core.celery_worker import (
@@ -13,7 +14,9 @@ from summary.core.celery_worker import (
summarize_v2_task,
)
from summary.core.config import AuthorizedTenant, get_settings
from summary.core.exceptions import CleanedValidationError
from summary.core.models import SummarizeTaskApiRequest, TranscribeTaskApiRequest
from summary.core.privacy import dump_for_transport
from summary.core.security import verify_tenant_api_key_v2
from summary.core.shared_models import (
SummarizeWebhookFailurePayload,
@@ -52,7 +55,7 @@ async def create_transcribe_task_v2(
task = process_audio_transcribe_v2_task.apply_async(
args=[
{
**request.model_dump(),
**dump_for_transport(request),
"tenant_id": request_tenant.id,
"received_at": datetime.now(timezone.utc),
}
@@ -125,7 +128,11 @@ async def get_transcribe_job_status(
if task.status == "SUCCESS":
result = task.result
return TranscribeWebhookSuccessPayload.model_validate(result).model_dump()
try:
payload = TranscribeWebhookSuccessPayload.model_validate(result)
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
return dump_for_transport(payload)
if task.status == "FAILURE":
return TranscribeWebhookFailurePayload(
@@ -155,7 +162,11 @@ async def get_summarize_job_status(
if task.status == "SUCCESS":
result = task.result
return SummarizeWebhookSuccessPayload.model_validate(result).model_dump()
try:
payload = SummarizeWebhookSuccessPayload.model_validate(result)
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
return dump_for_transport(payload)
if task.status == "FAILURE":
return SummarizeWebhookFailurePayload(
+6 -7
View File
@@ -5,7 +5,6 @@ import socket
import time
from collections import Counter
from functools import cached_property, lru_cache
from urllib.parse import urlsplit, urlunsplit
import redis
from celery.utils.log import get_task_logger
@@ -13,6 +12,7 @@ from posthog import Posthog
from summary.core.config import get_settings
from summary.core.models import SummarizeTaskJob, TranscribeTaskJob
from summary.core.privacy import redact_url
logger = get_task_logger(__name__)
settings = get_settings()
@@ -54,8 +54,8 @@ class Analytics:
self._client.capture(
event_name, distinct_id=distinct_id, properties=properties
)
except Exception as e:
raise AnalyticsException("Failed to capture analytics event") from e
except Exception:
raise AnalyticsException("Failed to capture analytics event") from None
def is_feature_enabled(self, feature_name: str, distinct_id: str = None) -> bool:
"""Check if a feature flag is enabled for a user."""
@@ -64,8 +64,8 @@ class Analytics:
try:
return self._client.feature_enabled(feature_name, distinct_id)
except Exception as e:
logger.error("Error checking feature flag %s: %s", feature_name, e)
except Exception:
logger.error("Error checking feature flag %s", feature_name)
return False
@@ -133,8 +133,7 @@ class MetadataManager:
}
if isinstance(task_payload, TranscribeTaskJob):
parts = urlsplit(task_payload.cloud_storage_url)
clean_url = urlunsplit((parts.scheme, parts.netloc, parts.path, "", ""))
clean_url = redact_url(task_payload.cloud_storage_url.get_secret_value())
initial_metadata["source_url"] = clean_url
initial_metadata["asr_model"] = settings.whisperx_asr_model
elif isinstance(task_payload, SummarizeTaskJob):
+105 -40
View File
@@ -3,20 +3,23 @@
# ruff: noqa: PLR0913
import json
import logging
import time
from datetime import datetime, timezone
from typing import Any
from urllib.parse import urljoin
import requests
from celery import Celery, signals
from celery import Celery, Task, signals
from celery.utils.log import get_task_logger
from openai.types.audio import Transcription
from pydantic import SecretStr, ValidationError
from requests import exceptions
from summary.core.analytics import MetadataManager, get_analytics
from summary.core.config import get_settings
from summary.core.docs_service import create_document_in_lasuite_docs
from summary.core.exceptions import CleanedValidationError
from summary.core.file_service import (
CorruptedAudioFile,
FileService,
@@ -31,6 +34,7 @@ from summary.core.models import (
SummarizeTaskJob,
TranscribeTaskJob,
)
from summary.core.privacy import dump_for_transport, redact_url
from summary.core.prompt import (
FORMAT_NEXT_STEPS,
FORMAT_PLAN,
@@ -63,8 +67,24 @@ metadata_manager = MetadataManager()
logger = get_task_logger(__name__)
def _reveal(secret: SecretStr | None) -> str | None:
"""Return the underlying value of an optional secret."""
return secret.get_secret_value() if secret is not None else None
class PrivateTask(Task):
"""Hide task arguments in Celery logs and monitoring events."""
def apply_async(self, args=None, kwargs=None, **options):
"""Publish with redacted display representations."""
options.update(argsrepr="[Filtered]", kwargsrepr="[Filtered]")
return super().apply_async(args=args, kwargs=kwargs, **options)
celery = Celery(
__name__,
task_cls=PrivateTask,
broker=settings.celery_broker_url,
backend=settings.celery_result_backend,
broker_connection_retry_on_startup=True,
@@ -76,10 +96,28 @@ celery = Celery(
celery.config_from_object("summary.core.celery_config")
class CeleryLogPrivacyFilter(logging.Filter):
"""Prevent Celery trace logs from serializing task results or exceptions."""
def filter(self, record):
"""Keep task identity and state without upstream values."""
if record.levelno < logging.INFO:
return True
data = getattr(record, "data", None)
if isinstance(data, dict):
record.msg = "Task %s[%s] finished or retried (details omitted)"
record.args = (data.get("name", "unknown"), data.get("id", "unknown"))
record.data = {}
record.exc_info = None
record.exc_text = None
return True
@signals.celeryd_init.connect
def init_celery_sentry(**_kwargs):
"""Initialize Sentry in the Celery worker."""
init_sentry()
logging.getLogger("celery.app.trace").addFilter(CeleryLogPrivacyFilter())
file_service = FileService()
@@ -162,9 +200,9 @@ def transcribe_audio(
try:
res.raise_for_status()
except requests.exceptions.HTTPError:
logger.exception("WhisperX transcription failed")
logger.error("WhisperX transcription failed")
# We reraise the error so that it can be retried by celery
raise
raise requests.exceptions.HTTPError("WhisperX request failed") from None
transcription_json: dict[str, Any] = res.json()
# We remove the "usage" key from the transcription_json dictionary
@@ -175,13 +213,16 @@ def transcribe_audio(
# We force the use of the Transcription model here
# to avoid changing too much code for now.
# Note that it should be WhisperXResponse instead.
transcription = Transcription.model_validate(
# We add a dummy "text" to make the model validate,
# Some API responses lack the "text" key.
{"text": "", **transcription_json},
extra="allow",
strict=False,
)
try:
transcription = Transcription.model_validate(
# We add a dummy "text" to make the model validate,
# Some API responses lack the "text" key.
{"text": "", **transcription_json},
extra="allow",
strict=False,
)
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
# Logging
transcription_duration = round(time.time() - transcription_start_time, 2)
@@ -199,9 +240,9 @@ def transcribe_audio(
if raises:
raise e
redacted_cloud_storage_url = (
cloud_storage_url.split("?", 1)[0] if cloud_storage_url else None
redact_url(cloud_storage_url) if cloud_storage_url else None
)
logger.exception(
logger.error(
("Unexpected error while preparing file %s "),
redacted_cloud_storage_url,
)
@@ -230,7 +271,7 @@ def resolve_speaker_identities_and_apply_to(
logger.debug("Running resolve_speaker_identities")
try:
metadata = file_service.read_cloud_storage_json(
recording_metadata.cloud_storage_url
recording_metadata.cloud_storage_url.get_secret_value()
)
speaker_mapping = resolve_speaker_identities(
metadata,
@@ -241,21 +282,18 @@ def resolve_speaker_identities_and_apply_to(
new_transcription = speaker_mapping.apply_to(transcription.model_dump())
return WhisperXResponse.model_validate(new_transcription)
except FileServiceException as exc:
except FileServiceException:
logger.error(
"Error reading metadata for task %s; skipping speaker assignment."
" Error: %s",
"Error reading metadata for task %s; skipping speaker assignment.",
task_id,
exc,
)
return transcription
except Exception as exc:
logger.exception(
except Exception:
logger.error(
"resolve_speaker_identities failed for task %s; skipping"
" speaker assignment. Error: %s",
" speaker assignment.",
task_id,
exc,
)
return transcription
@@ -302,6 +340,17 @@ def format_actions(llm_output: dict) -> str:
return ""
def parse_llm_json(value: str) -> dict:
"""Parse an LLM response without exposing it in decoding errors."""
try:
result = json.loads(value)
if not isinstance(result, dict):
raise ValueError
return result
except (TypeError, ValueError):
raise LLMException("Invalid LLM response") from None
def summarize_transcription_internals(
*, distinct_id: str, transcript: str, session_id: str
) -> str:
@@ -342,13 +391,13 @@ def summarize_transcription_internals(
)
logger.info("Plan generated")
res = json.loads(parts)
res = parse_llm_json(parts)
parts = res.get("titles", [])
logger.info("Parts to summarize: %s", parts)
logger.info("Parts to summarize: %s", len(parts))
parts_summarized = []
for part in parts:
for i, part in enumerate(parts):
prompt_user_part = PROMPT_USER_PART.format(part=part, transcript=transcript)
logger.info("Summarizing part: %s", part)
logger.info("Summarizing part %s", i + 1)
parts_summarized.append(
llm_service.call(PROMPT_SYSTEM_PART, prompt_user_part, name="part")
)
@@ -364,7 +413,7 @@ def summarize_transcription_internals(
response_format=FORMAT_NEXT_STEPS,
)
next_steps = format_actions(json.loads(next_steps))
next_steps = format_actions(parse_llm_json(next_steps))
logger.info("Next steps generated")
@@ -437,9 +486,11 @@ def call_webhook_v2_task(
tenant_id: str,
):
"""Calls a webhook asynchrously (retry handled by celery)."""
call_webhook_v2(
payload=webhook_payload_adapter.validate_python(payload), tenant_id=tenant_id
)
try:
validated_payload = webhook_payload_adapter.validate_python(payload)
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
call_webhook_v2(payload=validated_payload, tenant_id=tenant_id)
@celery.task(
@@ -465,7 +516,10 @@ def process_audio_transcribe_v2_task(
self: Celery task instance (passed on with bind=True)
payload: Serialized dictionary of TranscribeSummarizeTaskCreationV2
"""
payload = TranscribeTaskJob.model_validate(payload)
try:
payload = TranscribeTaskJob.model_validate(payload)
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
logger.info(
"Transcribing for object received | Owner: %s",
payload.user_sub,
@@ -477,7 +531,7 @@ def process_audio_transcribe_v2_task(
transcription_res = WhisperXResponse(
**transcribe_audio( # type: ignore
task_id=job_id,
cloud_storage_url=payload.cloud_storage_url,
cloud_storage_url=payload.cloud_storage_url.get_secret_value(),
language=payload.language,
raises=True,
).model_dump()
@@ -514,8 +568,8 @@ def process_audio_transcribe_v2_task(
transcription_res.model_dump(),
payload.context_language,
payload.language,
payload.push_to_docs_config.download_link,
payload.push_to_docs_config.form_link,
_reveal(payload.push_to_docs_config.download_link),
_reveal(payload.push_to_docs_config.form_link),
)
create_document_in_lasuite_docs(
@@ -556,18 +610,22 @@ def process_audio_transcribe_v2_task(
transcription_data_url=file_service.get_transcript_signed_url(job_id),
)
call_webhook_v2_task.apply_async(
args=[success_payload.model_dump(), payload.tenant_id]
args=[dump_for_transport(success_payload), payload.tenant_id]
)
metadata_manager.capture(job_id, settings.posthog_transcript_success)
return success_payload.model_dump()
return dump_for_transport(success_payload)
@signals.task_prerun.connect(sender=process_audio_transcribe_v2_task)
def task_started_transcript(task_id=None, task=None, args=None, **kwargs):
"""Signal handler called before task execution begins."""
if args:
metadata_manager.create(task_id, TranscribeTaskJob.model_validate(args[0]))
try:
payload = TranscribeTaskJob.model_validate(args[0])
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
metadata_manager.create(task_id, payload)
@signals.task_retry.connect(sender=process_audio_transcribe_v2_task)
@@ -627,7 +685,10 @@ def summarize_v2_task(
1. Run summary internals
2. Sends the final summary via webhook.
"""
payload = SummarizeTaskJob.model_validate(payload)
try:
payload = SummarizeTaskJob.model_validate(payload)
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
summary = summarize_transcription_internals(
distinct_id=payload.user_sub,
transcript=payload.content,
@@ -652,18 +713,22 @@ def summarize_v2_task(
summary_data_url=file_service.get_summary_signed_url(job_id),
)
call_webhook_v2_task.apply_async(
args=[success_payload.model_dump(), payload.tenant_id]
args=[dump_for_transport(success_payload), payload.tenant_id]
)
metadata_manager.capture(job_id, settings.posthog_summary_success)
return success_payload.model_dump()
return dump_for_transport(success_payload)
@signals.task_prerun.connect(sender=summarize_v2_task)
def task_started_summary(task_id=None, task=None, args=None, **kwargs):
"""Signal handler called before task execution begins."""
if args:
metadata_manager.create(task_id, SummarizeTaskJob.model_validate(args[0]))
try:
payload = SummarizeTaskJob.model_validate(args[0])
except ValidationError as exc:
raise CleanedValidationError(exc, secret_input=True) from None
metadata_manager.create(task_id, payload)
@signals.task_retry.connect(sender=summarize_v2_task)
+3 -1
View File
@@ -4,7 +4,7 @@ import json
import logging
from urllib.parse import urljoin
from requests import Session
from requests import RequestException, Session
from requests.adapters import HTTPAdapter
from urllib3.util import Retry
@@ -43,6 +43,8 @@ def _post_with_retries(*, url, data, api_key: str | None = None):
response = session.post(url, json=data, timeout=(20, 3 * 60))
response.raise_for_status()
return response
except RequestException:
raise RequestException("Docs delivery failed") from None
finally:
session.close()
+62
View File
@@ -0,0 +1,62 @@
"""Validation errors suitable for logging and transport."""
from typing import get_args
from pydantic import SecretStr, ValidationError
from pydantic_core import ErrorType, PydanticCustomError
_BUILTIN_ERROR_TYPES = frozenset(get_args(ErrorType))
def clean_validation_errors(errors: list[dict]) -> list[dict]:
"""Mask SecretStr values, including those nested in validation input."""
def clean(value):
if isinstance(value, SecretStr):
return "[redacted]"
if isinstance(value, Exception):
# Do not retain validator exception objects, whose args may hold secrets.
return str(value)
if isinstance(value, dict):
return {key: clean(item) for key, item in value.items()}
if isinstance(value, list):
return [clean(item) for item in value]
if isinstance(value, tuple):
return tuple(clean(item) for item in value)
return value
return clean(errors)
class CleanedValidationError(ValidationError):
"""A new Pydantic exception with secret inputs replaced by a marker."""
def __init__(self, error, *args, secret_input=False, **kwargs):
"""State is initialized by Pydantic during __new__."""
def __new__(cls, error, *args, secret_input=False, **kwargs):
"""Accept an original error, or Pydantic's native construction arguments."""
if not isinstance(error, ValidationError):
# Pydantic uses this path when constructing or unpickling the error.
return super().__new__(cls, error, *args, **kwargs)
details = clean_validation_errors(error.errors(include_url=False))
for detail in details:
if secret_input:
# An adapter may have received the unwrapped value of a SecretStr.
detail["input"] = "[redacted]"
return cls._from_details(error.title, details)
@classmethod
def _from_details(cls, title, details):
"""Reconstruct builtin and custom Pydantic error codes."""
for detail in details:
if detail["type"] not in _BUILTIN_ERROR_TYPES:
detail["type"] = PydanticCustomError(
detail["type"], detail["msg"], detail.get("ctx")
)
return cls.from_exception_data(title, details, hide_input=True)
def __reduce__(self):
"""Preserve custom error codes when Celery pickles the exception."""
return self._from_details, (self.title, self.errors(include_url=False))

Some files were not shown because too many files have changed in this diff Show More