Since #106454 the `isOdooFocused` variable is not updated correctly.
This commit fixes this issue.

closes odoo/odoo#106514

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>

Before this PR, the presence service would crash on cross-origin
iframes. This is due to the fact that accessing the parent document
of a cross origin iframe is forbidden for security concerns.

This error was introduced when trying to synchronize the website iframe
and the window focus state in #102479.

This PR fixes the issue by catching the error and fallbacking to the old
behavior given than task-3006023 has been fixed by #53143 anyway.

task-3073242

closes odoo/odoo#106454

Signed-off-by: Stockbauer Matthieu (tsm) <tsm@odoo.com>

Since the iOS 16.1 update, the WKWebView used in the iOS mobile app
crashes when trying to instanciate a `SharedWorker`... even if this
feature was newly added in iOS 16.0.

Safari iOS doesn't seem to be impacted.

This commit works around this issue by disabling the usage of the
`SharedWorker` in the iOS mobile app, using instead the existing
fallback to a regular `Worker`.

Steps to reproduce:
- On a device running iOS 16.1
- Open Odoo in the iOS mobile app
=> Once connected the app freezes with a gray screen

opw-3045539

closes odoo/odoo#104295

Signed-off-by: Adrien Dieudonné (adr) <adr@odoo.com>

Before this PR, the last notification id known by the client
was not reset after restoring the database. This was an issue
since there can be a gap between the last notification  and the
one that has been restored with the database. In this scenario,
messages are not received after restoring the database since the
client subscribes to higher notification ids that the ones that are
created.

This PR fixes this issue by defaulting to 0 if the one the client
passed is higher.

closes odoo/odoo#103025

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

The `ImDispatch` thread uses the `thread.is_alive` method to check
whether or not the thread should be started. The issue is that, this
method will return `False` after the start method has been called, but
before the run method is invoked leading to the RuntimeError: thread
can only be started once.

This commit fixes this issue by suppressing this error in this case.

closes odoo/odoo#103153

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>

closes odoo/odoo#102902

Related: odoo/enterprise#32633
Signed-off-by: Martin Trigaux (mat) <mat@odoo.com>

Using patcher.start() can easily lead to incorrect cleanup.
-> after a copy paste, patcher is working, but stop is forgotten
-> stop is present, but won't be called if something fails during the
test

This commit add an utility `start(patcher)` to always have the add
cleanup.

Using a standard way to start the patcher with an automated addCleanup
should prevent this kind of mistake. This is why this commit also
replaces all valid patch.start() (followed immediately by a addCleanup)

closes odoo/odoo#101971

Related: odoo/enterprise#32529
Signed-off-by: Christophe Monniez (moc) <moc@odoo.com>

Before this PR, the presence service was relying on window events
blur/focus to determine whether or not odoo was focused. The issue is
that in the website backend, an iframe is used. When this iframe is focused,
the window looses the focus and vice versa.

This commit fixes this issue by using `window.parent.hasFocus` method.

task-3003950

closes odoo/odoo#102479

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>

Before this commit, the `updateBusPresence` method could have been
called many times in a row, resulting in many `update_presence` messages
being sent through the socket. This commit solves this issue by throttling
this method in order for it to only be called once in `UPDATE_BUS_PRESENCE_DELAY`
seconds.

closes odoo/odoo#102251

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

Before this PR, a websocket would wait for the server to close
it with a `SessionExpired` close code to be refreshed after the user
logged in/out. Indeed, the server is responsible to check for outdated
sessions on incoming/outgoing messages.

This is problematic: a user logging in with more than one tab opened,
would have to wait to receive its messages. This PR solves this issue
by refreshing the connection immediately in this scenario.

closes odoo/odoo#101385

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

The session used to call this websocket route needs to have been
initiated with a call to /websocket/peek_notifications first.

closes odoo/odoo#100889

Signed-off-by: Julien Castiaux <juc@odoo.com>

Before this commit, loosing the websocket connection would
have resulted in a toast being displayed. This toast is seen
as degrading the UX experience and is redundant with the already
existing "Connection Lost" toast. This PR removes it.

closes odoo/odoo#101377

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

The original goal here is to remove the warning of the google page
speed but it actually is really better to use 'pagehide' as it is fired
more reliably than the 'unload' event and does not prevent Chrome and
Firefox to use the bfcache (browser optimization that enables instant
back and forward navigation).

The persisted property of the pagehide event is checked before
disconnecting from the worker. As for the presence/multi_tab case, it
was chosen to also consider page freezing as it seems more accurate that
what was done before (the main tab could be throttled/frozen which was
an issue).

Some resources to explain why this is better:
- https://web.dev/bfcache/#never-use-the-unload-event
- https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event



closes odoo/odoo#100976

Signed-off-by: Quentin Smetz (qsm) <qsm@odoo.com>
Co-authored-by: qsm-odoo <qsm@odoo.com>

Since [1] when the bus service was adapted to wowl, the assets watchdog
service was imported in the frontend. Because the assets will be the
right ones on the next visited page, the notification it might trigger
is seen as degrading the website UX.

This commit removes the assets watchdog service from the frontend
pages.

Steps to reproduce:
- Visit a public page in a tab - keep it open.
- From a different browser, log in and rebuild assets.
=> Notification appears in visitor's tab.

[1]: https://github.com/odoo/odoo/commit/3ae11c87e8a395219229416c2777bcdcdacd08ac



task-2922959

closes odoo/odoo#100173

Signed-off-by: Romain Derie (rde) <rde@odoo.com>

Debugging websockets is cumbersome, this commit adds debug
messages to the websocket worker in order to ease debugging.

closes odoo/odoo#101099

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>

The `bus_service` uses the `dbuuid` key from session in order to
know when to drop the last notification id from the local storage:
when the db changes.

The issue is that public pages don't fetch the session, this results
in undefined being added into the local storage. The multi tab service
speculates on the fact that the value stored will always be json
parsable.

This commit fixes the issue by taking into account the fact that session
dbuuid can be undefined. Moreover, the multi tab service has been
updated to return the raw value if it is not parsable.

closes odoo/odoo#100652

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>

Before this PR, the `_mockIrWebsocket__updatePresence` route of the
bus mock server could lead to errors when no im status ids were
provided. This commit fixes this issue by ensuring im status ids
were passed before calling `_mockIrWebsocket__getImStatus` method.

Moreover, old longpolling routes were still present on the bus mock
server. This commit removes these routes.

closes odoo/odoo#100583

closes odoo/odoo#100651

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>
Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

In order to know whether or not the websocket session is up to date,
the session is saved when opening a websocket connection. Then, for
each incoming/outgoing message, we check if the session still exists
on the file system. When it does not exist anymore, the websocket
connection is refreshed. This ensures the session is always up to date.

Odoo sh proxies the websocket connection and needs a way to tell
when a websocket session is expired. This commit adds the same
check that is done for each incoming websocket message in the
websocket peek route in order to raise a `SessionExpiredException`
when the session is outdated.

This will allow odoo sh to catch this error and to refresh their
websocket connection accordingly.

closes odoo/odoo#100416

Signed-off-by: Julien Castiaux <juc@odoo.com>

Transform the /websocket/update_bus_presence route to type='json'
which makes more sense as a POST than a get, seeing it does things with
a parameter and doesn't return anything.

Also fixes the _update_bus_presence method that leads to access errors
when accessed from HTTP when the user is the public one (only portal/
internal users should update their presences).

Part-of: odoo/odoo#100416

closes odoo/odoo#100573

Related: odoo/enterprise#31507
Signed-off-by: Martin Trigaux (mat) <mat@odoo.com>

*: bus, hr_holidays.

The `/bus/im_status` route polls the server every minute in order for
the user im_status to be up to date. This commit removes this poll
by sending the im_status on the bus when updating the current user
presence.

Moreover, before [1], the user bus presence was updated on each poll.
When the user didn't poll for 50 seconds, we assumed the user was
disconnected. Since [1], the bus presence is updated each 30 seconds
by the `im_status` service. This is too frequent: there is no need
to update the user presence so often.

In order not to overhelm the server with unnecessary requests, the update
presence interval as well as the delay to be considered disconnected
have been updated: the former from 30 to 60 seconds, the later from
55 to 65 seconds (assuming that a user that has missed an update
presence tick is disconnected).

[1]: odoo/odoo@a5623d2

closes odoo/odoo#100249

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

Before [1], only string channels were allowed for polling. This
ensured no one could send a server-side channel from the frontend,
this PR restores this behavior.

[1]: odoo/odoo@a5623d2

closes odoo/odoo#100309

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

*: auth_password_policy, bus, calendar, event, mass_mailing, stock,
   survey, web_editor, web_tour, website, website_event, website_forum,
   website_mass_mailing, website_sale

This commit is a first step towards a potential deletion of the
assets_common bundle, although that step would need more work, specs and
discussions as some layouts kinda only use the assets_common bundle
(some take the full assets_common but parts of the assets_backend one
for example).

The main goal of this commit is to have the assets_frontend bundle
directly include the "common" files we need. As a first step, this
commit only blindly duplicates them all into assets_frontend (without
removing the potentially useless ones). The goal is to have those
advantages:

- Reaching a frontend page only calls two main JS files (one normal and
  one lazy-loaded) instead of 4 (two normals and two lazy-loaded). This
  may help reach a better google page speed (which is becoming more and
  more strict).

- The frontend CSS is built as one: the common SCSS which was using
  bootstrap variables, or even Odoo-based SCSS added by mistake in
  common instead of both backend and frontend is now computed with the
  right bootstrap customizations. E.g. the tempusdominus datetimepickers
  use bootstrap grays... after this PR, they use the right grays as
  customized by the user on the website.

It was also chosen to not have a common "sub-asset" which is included in
assets_frontend. Making assets_frontend completely independent makes
sense (as it probably will for other "main" asset bundles): we can focus
on adding the files each layout needs without the need of worrying if it
impacts unrelated layouts. Sub-assets (when not strictly necessary) is
also a source of errors: extending the "main" bundle instead of the
right sub-asset it may use (like it was the case with the sub-assets of
assets_common: _assets_common_scripts and _assets_common_styles as
explained in the previous commit). So this is indeed a small drawback of
not factorizing the code for the inclusion of "common" files in bundles
but it seems more explicit and easier to maintain that way. Note that
adding "common" file is not the most common usecase anyway, apps
generally only need files in backend or frontend.
The __manifest__ declaration will also likely evolve in more and more
uses of wildcards to match entire directories. In the future, adding
"common" web-app files in both backend, frontend and other "main"
bundles could just be about one line duplicated into each bundle.

closes odoo/odoo#100314

Related: odoo/enterprise#31394
Signed-off-by: Romain Derie (rde) <rde@odoo.com>

Before this commit, the `channels subscription after disconnect` bus
test failed randomly. This occured when the websocket reconnection
happened before the first subscription. Indeed, the first subscription
is made only if the resulting channel list differs from the last one
we sent.

This commit fixes the issue by wating for the first subscription
before disconnecting the websocket.

closes odoo/odoo#100391

Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>

Before [1], the web_editor module was auto installed. After that commit,
the bus module has been added to the web_editor dependencies. Since
the bus module is not auto installed, the web_editor module dependencies
are not met which means the login colors are wrong (blue instead of green).

This commit fixes this error by adding the `auto_install` flag to the
bus module.

[1]: odoo@a5623d24b77f523aeeafbb8c2bfaf27241ef3c8e

closes odoo/odoo#100212

Signed-off-by: Adrien Dieudonné (adr) <adr@odoo.com>

When stopping the server, all cursors are closed. The issue is that
the ImDispatch thread is kept alive until the main thread exits.

This can lead to errors during server stop: the ImDispatch thread
could try to poll an already closed connection thus raising a
`psycopg2.InterfaceError` exception.

This commit solves the issue by hiding the interface error when
it occurs during server stop.

closes odoo/odoo#100002

X-original-commit: 83777078
Signed-off-by: Julien Castiaux <juc@odoo.com>

´inactivity_period´ is expected to be an int.

closes odoo/odoo#99874

Signed-off-by: Julien Castiaux <juc@odoo.com>

Before the websocket were introduced, the last notification id was
persisted in the local storage in order to use it even after a page
reload.

The last notification id is now stored on the `SharedWorker` which
means this information is lost if the last opened tab is reloaded.

This commit fixes this issue by storing this information by the mean of
the localStorage. Since the localStorage is not accessible from the
worker global scope, the bus service will store this information and
relay it to the worker when starting. The worker will now wait to
receive the last notification id before subscribing.

closes odoo/odoo#99621

Related: odoo/enterprise#31124
Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

The im status service subscribes to the `become_main_tab`,
`no_longer_main_tab` events.

Since the PR improving the multi tab service, the multi tab
itself is not an event target anymore but exposes a bus instance
that should be used to subscribe to those events.

The im status service is still based on the first version (that was
using env.bus) which means the event will never be received. This
commit fixes this issue.

closes odoo/odoo#99635

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

The `displays reconnect notification` bus test relies on a `nextTick`
to assert that a notification is present after the websocket
disconnection.

The issue is that we can't be sure that the notification will be
displayed after this tick. Indeed, we need to wait for: the `postMessage`
to reach the bus service, the notification to be added, the notification
to be added in the DOM.

This commit solves this issue, by waiting for the next render after the
`simulateConnectionLost` method to occur.

closes odoo/odoo#99590

Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>