Consider the following setting:
- on model A, field F is computed, stored, and depends on field G
- on model A, field one2many G to model B, with inverse field H
- on model B, field many2one H is inherited (_inherits) from model C
- on model C, field many2one H is stored
When adding records of model B, the field F must be recomputed. In order to
determine which records to recompute, one searches model A with a domain like
[(G, 'in', ids)]. In expression.py, this is resolved with an SQL query like
select H from B where id in {ids}
This query fails, since the field H is not stored in model B. This happens in
general if H is not stored (it may be any computed field). In that case, one
should instead browse records from B, and read field H through the ORM.
A test case has been added: it introduces a many2one field in a parent model,
and a one2many field using the inherited many2one on a child model. The test
checks whether one can search on the one2many field.
* run tours as public users since these screens should be accessible to
and used by public users
* fix access rights issues in website_crm tour (default value of team_id
when creating a crm.lead requiring read access on crm.team, which the
public user does not have)
* remove duplicated crm.lead field (phone declared as char(size=64) then
as char() a few lines below, removed first instance)
To check for result of a tour, would run a second tour performing
JSON-RPC calls to check if the first tour had correctly impacted the
database.
Tours are expensive, an empty tour takes ~6s without doing anything.
Replace second tour by regular ORM calls.
The `check` decorator expects the context to be in the `kwargs`
or to be the last arguments of the method.
The `call_kw` route, which is decorated by the `check` decorator,
like every route,
expands its kwargs arguments.
Therefore, once in the `check` decorator,
the context is located in the `kwargs` key
of the kwargs.
(More simply, instead of
`kwargs.get('context', {})`
it's
`kwargs.get('kwargs', {}).get('context', {})`
As the context is not retrieved correctly,
the lang is not set correctly either,
and the sql constraints were not translated.
In 7.0, it worked, because there was a double
check, as the call_kw was called trough an rpc
(`dispatch_rpc`) call,
which was decorated by the `check` as well.
As a fix for 8.0, we apply the same logic,
we perform a double check, with an indirection.
The check decorator should probably be
refactored, but this cannot be done
in a stable release such as 8.0.
Closes#3634
To compute start and end date of a working interval this function replaced
hour in datetime object without taking into account the time zone. The start and end date
taking respectively from calendar_working_day.hour_from and calendar_working_day.hour_to are
in the time zone of the user and the datetime object are compared in UTC to avoid schedule's gap.
This is why the start and end must be converted in UTC after being replaced by these hours.
The tz_info must be removed from dates because it's forbidden to compare naive and aware dates.
opw:648349
When creating a record from a many2many_kanban, it did not contain all
the data the kanban view asked to render itself. This fix extends the
record data with undefined value for unknown (but asked) data.
Can use 'add' or 'remove' on attribute tag.
'add' values are stripped and add to the current value preceded with a space.
'remove' may contain more than one value separate by spaces.
'separator' by default space the string are splited by spaces.
E.g.:
<attribute name="thing">bob tata lolo</attribute>
<attribute name="thing" add="bibi" remove="tata"/>
thing contains: bob lolo bibi
This was confusing because some users were clicking on it in edit mode, the selection
was disappearing and logged in the chatter, when the user didn't know what happened
With 3e82c94d we use the timezone in the context to format date
sequences when formatting an ir.sequence.
This commit adds the other missing context when getting a sequence, so
these sequences are also dependant on the timezone.
closes#8351
opw-646487
Barcodes are detected by catching keypresses. When a keypress is not
part of a barcode, it is 'released' by forging a keypress event.
For security reasons, a non-native keypress doesn't trigger the native
input mechanism. So in order to make both barcode-scanning and manual
keypresses work in a field, it is necessary to have a handler listen
to the 'false' keypresses and simulate the native input behaviour.
Nicolas Lempereur