diff --git a/.copier-answers.yml b/.copier-answers.yml index 59536024e..56c1a45ab 100644 --- a/.copier-answers.yml +++ b/.copier-answers.yml @@ -16,7 +16,7 @@ odoo_test_flavor: Both odoo_version: 20.0 org_name: Odoo Community Association (OCA) org_slug: OCA -postgres_image: '' +postgres_image: postgis/postgis:16-3.4 rebel_module_groups: [] repo_description: geospatial repo_name: geospatial diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index ade459d20..19bd824dd 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -46,7 +46,7 @@ jobs: makepot: "true" services: postgres: - image: postgres:16 + image: postgis/postgis:16-3.4 env: POSTGRES_USER: odoo POSTGRES_PASSWORD: odoo diff --git a/base_geoengine/__manifest__.py b/base_geoengine/__manifest__.py index b620bf7b8..59e3a657a 100644 --- a/base_geoengine/__manifest__.py +++ b/base_geoengine/__manifest__.py @@ -4,7 +4,7 @@ # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). { "name": "Geospatial support for Odoo", - "version": "19.0.1.0.2", + "version": "20.0.1.0.0", "category": "GeoBI", "author": "Camptocamp,ACSONE SA/NV,Odoo Community Association (OCA)", "license": "AGPL-3", @@ -17,7 +17,7 @@ "views/ir_view_view.xml", "views/geo_raster_layer_view.xml", "views/geo_vector_layer_view.xml", - "security/ir.model.access.csv", + "security/ir.access.csv", ], "assets": { "web.assets_backend": [ diff --git a/base_geoengine/domains.py b/base_geoengine/domains.py index 53253a7c4..d32ff172a 100644 --- a/base_geoengine/domains.py +++ b/base_geoengine/domains.py @@ -1,149 +1,18 @@ -import contextlib -import logging -import warnings - +# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). from odoo.fields import Domain -from odoo.models import BaseModel -from odoo.orm import domains -from odoo.orm.domains import ( - CONDITION_OPERATORS, - NEGATIVE_CONDITION_OPERATORS, - SQL, - DomainCondition, - OptimizationLevel, - Query, -) -from odoo.orm.identifiers import NewId - -_logger = logging.getLogger(__name__) - -GEO_OPERATORS = frozenset( - [ - "geo_greater", - "geo_lesser", - "geo_equal", - "geo_touch", - "geo_within", - "geo_contains", - "geo_intersect", - ] -) - - -def checked(self) -> DomainCondition: - """Validate `self` and return it if correct, otherwise raise an exception.""" - if not isinstance(self.field_expr, str) or not self.field_expr: - self._raise("Empty field name", error=TypeError) - operator = self.operator.lower() - if operator != self.operator: - warnings.warn( - ( - f"Deprecated since 19.0, the domain condition " - f"{(self.field_expr, self.operator, self.value)!r} " - f"should have a lower-case operator" - ), - DeprecationWarning, - # - stacklevel=2, - # - ) - return DomainCondition(self.field_expr, operator, self.value).checked() - if operator not in CONDITION_OPERATORS: - # - if operator not in GEO_OPERATORS: - # - self._raise("Invalid operator") - - # check already the consistency for domain manipulation - # these are common mistakes and optimizations, - # do them here to avoid recreating the domain - # - NewId is not a value - # - records are not accepted, use values - # - Query and Domain values should be using a relational operator - # - # from .models import BaseModel - # - - value = self.value - if value is None: - value = False - elif isinstance(value, NewId): - _logger.warning( - "Domains don't support NewId, use .ids instead, for %r", - (self.field_expr, self.operator, self.value), - ) - operator = "not in" if operator in NEGATIVE_CONDITION_OPERATORS else "in" - value = [] - elif isinstance(value, BaseModel): - _logger.warning( - "The domain condition %r should not have a value which is a model", - (self.field_expr, self.operator, self.value), - ) - value = value.ids - elif isinstance(value, (Domain, Query, SQL)) and operator not in ( - "any", - "not any", - "any!", - "not any!", - "in", - "not in", - ): - # accept SQL object in the right part for simple operators - # use case: compare 2 fields - _logger.warning( - "The domain condition %r should use the 'any' or 'not any' operator.", - (self.field_expr, self.operator, self.value), - ) - if value is not self.value: - return DomainCondition(self.field_expr, operator, value) - return self - - -def _to_sql(self, model: BaseModel, alias: str, query: Query) -> SQL: - """Enhanced _to_sql that handles geospatial operators.""" - field_expr, operator, value = self.field_expr, self.operator, self.value - - # Only handle geospatial operators here, delegate everything else to original method - if operator in GEO_OPERATORS: - # Ensure geospatial conditions are fully optimized - assert self._opt_level >= OptimizationLevel.FULL, ( - "Must fully optimize before generating the query " - f"{(field_expr, operator, value)}" - ) - - field = self._field(model) - model._check_field_access(field, "read") - return field.condition_to_sql(field_expr, operator, value, model, alias, query) - - # For all other operators, use the original method - return original__to_sql(self, model, alias, query) - - -def _optimize_step(self, model: BaseModel, level: OptimizationLevel) -> Domain: - """Optimization step for geospatial operators.""" - # For geospatial operators, we need to handle them specially during optimization - # If this is a geospatial operator, mark it as optimized at FULL level - if self.operator in GEO_OPERATORS: - # Perform basic validation and normalization - with contextlib.suppress(Exception): - field = self._field(model) - # Basic geospatial operator validation - if hasattr(field, "geo_type"): # It's a geospatial field - # Create optimized version with FULL level - optimized = DomainCondition(self.field_expr, self.operator, self.value) - object.__setattr__(optimized, "_opt_level", OptimizationLevel.FULL) - return optimized - - # Fall back to original optimization for non-geo operators - return original__optimize_step(self, model, level) - - -# Store original methods before monkey patching -original__optimize_step = DomainCondition._optimize_step -original__to_sql = DomainCondition._to_sql - -DomainCondition.checked = checked -DomainCondition._to_sql = _to_sql -DomainCondition._optimize_step = _optimize_step - -domains.CONDITION_OPERATORS = domains.CONDITION_OPERATORS.union(GEO_OPERATORS) +from odoo.orm.domains import OptimizationLevel, operator_optimization + +from .expressions import GEO_OPERATORS, spatial_condition_sql + + +@operator_optimization(GEO_OPERATORS, level=OptimizationLevel.FULL) +def optimize_spatial_condition(condition, model): + """Compile geo operators after core field and relational path validation.""" + field_expr, operator, value = ( + condition.field_expr, + condition.operator, + condition.value, + ) + return Domain.custom( + to_sql=lambda table: spatial_condition_sql(table, field_expr, operator, value) + ) diff --git a/base_geoengine/expressions.py b/base_geoengine/expressions.py index 934515df5..1e79c8ee0 100644 --- a/base_geoengine/expressions.py +++ b/base_geoengine/expressions.py @@ -1,33 +1,15 @@ # Copyright 2023 ACSONE SA/NV # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). +# Odoo 20 port: compile spatial domains with TableSQL and parameterized SQL. +from uuid import uuid4 -import logging -import random -import string - -from odoo import fields from odoo.fields import Domain -from odoo.models import BaseModel -from odoo.tools import SQL, Query +from odoo.orm.query import Query +from odoo.tools import SQL from .fields import GeoField -from .geo_operators import GeoOperator - -logger = logging.getLogger(__name__) - -original___condition_to_sql = fields.Field._condition_to_sql GEO_OPERATORS = { - "geo_greater": ">", - "geo_lesser": "<", - "geo_equal": "=", - "geo_touch": "ST_Touches", - "geo_within": "ST_Within", - "geo_contains": "ST_Contains", - "geo_intersect": "ST_Intersects", -} - -GEO_SQL_OPERATORS = { "geo_greater": SQL(">"), "geo_lesser": SQL("<"), "geo_equal": SQL("="), @@ -38,154 +20,75 @@ } -def _condition_to_sql( - self, - field_expr: str, - operator: str, - value, - model: BaseModel, - alias: str, - query: Query, -) -> SQL: - """ - This method has been monkey patched in order to be able to include - geo_operators into the Odoo search method. - """ - if operator in GEO_OPERATORS: - current_field = model._fields.get(field_expr) - current_operator = GeoOperator(current_field) - if current_field and isinstance(current_field, GeoField): - params = [] - if isinstance(value, dict): - # We are having indirect geo_operator like (‘geom’, ‘geo_...’, - # {‘res.zip.poly’: [‘id’, ‘in’, [1,2,3]] }) - ref_search = value - sub_queries = [] - for key in ref_search: - i = key.rfind(".") - rel_model_name = key[0:i] - rel_col = key[i + 1 :] - rel_model = model.env[rel_model_name] - # we compute the attributes search on spatial rel - if ref_search[key]: - rel_alias = ( - rel_model._table - + "_" - + "".join(random.choices(string.ascii_lowercase, k=5)) - ) - rel_query = where_calc( - rel_model, - ref_search[key], - active_test=True, - alias=rel_alias, - ) - # Record rules (ir.rule) on the related model are applied - # inside where_calc(), mirroring BaseModel._search(). - if operator == "geo_equal": - rel_query.add_where( - f'"{alias}"."{field_expr}" {GEO_OPERATORS[operator]} ' - f"{rel_alias}.{rel_col}" - ) - elif operator in ("geo_greater", "geo_lesser"): - rel_query.add_where( - f"ST_Area({alias}.{field_expr}) " - f"{GEO_OPERATORS[operator]} " - f"ST_Area({rel_alias}.{rel_col})" - ) - else: - rel_query.add_where( - f'{GEO_OPERATORS[operator]}("{alias}"."{field_expr}", ' - f"{rel_alias}.{rel_col})" - ) - - subquery_sql = rel_query.subselect("1") - sub_query_mogrified = ( - model.env.cr.mogrify(subquery_sql.code, subquery_sql.params) - .decode("utf-8") - .replace(f"'{rel_model._table}'", f'"{rel_model._table}"') - .replace("%", "%%") - ) - sub_queries.append(f"EXISTS({sub_query_mogrified})") - query_str = " AND ".join(sub_queries) - else: - query_str = get_geo_func( - current_operator, operator, field_expr, value, params, model._table - ) - return SQL(query_str, *params) - return original___condition_to_sql( - self, - field_expr=field_expr, - operator=operator, - value=value, - model=model, - alias=alias, - query=query, - ) - - -fields.Field._condition_to_sql = _condition_to_sql - - -def get_geo_func(current_operator, operator, left, value, params, table): - """ - This method will call the SQL query corresponding to the requested geo operator - """ - match operator: - case "geo_greater": - query = current_operator.get_geo_greater_sql(table, left, value, params) - case "geo_lesser": - query = current_operator.get_geo_lesser_sql(table, left, value, params) - case "geo_equal": - query = current_operator.get_geo_equal_sql(table, left, value, params) - case "geo_touch": - query = current_operator.get_geo_touch_sql(table, left, value, params) - case "geo_within": - query = current_operator.get_geo_within_sql(table, left, value, params) - case "geo_contains": - query = current_operator.get_geo_contains_sql(table, left, value, params) - case "geo_intersect": - query = current_operator.get_geo_intersect_sql(table, left, value, params) - case _: - raise NotImplementedError(f"The operator {operator} is not supported") - return query - - def where_calc(model, domain, active_test=True, alias=None): - """ - This method is copied from base, we need to create our own query. - - It mirrors ``BaseModel._search``: besides ``active_test`` filtering, it also - applies record rules (``ir.rule``) to the resulting query. This matters for - the indirect geo-operators, whose spatial sub-query is built here: without - it, the sub-query would match related records the user is not allowed to - read (row-level security bypass). - """ - # if the object has an active field ('active', 'x_active'), filter out all - # inactive records unless they were explicitly asked for - if model._active_name and active_test and model._context.get("active_test", True): - # the item[0] trick below works for domain items and '&'/'|'/'!' - # operators too - if not any(item[0] == model._active_name for item in domain): - domain = [(model._active_name, "=", 1)] + domain - - query = Query(model.env, alias, model._table) - if domain: - # In Odoo 19, create Domain object and use its _to_sql method - domain_obj = Domain(domain) - optimized_domain = domain_obj.optimize_full(model) - sql_condition = optimized_domain._to_sql(model, alias, query) - query.add_where(sql_condition) - - # Apply record rules, like BaseModel._search does. Skipped for the - # superuser (env.su), exactly as in core. - if not model.env.su: + """Build an aliased related query while preserving Odoo 20 access restrictions.""" + domain = Domain(domain) + if ( + model._active_name + and active_test + and model.env.context.get("active_test", True) + and not any( + c.field_expr == model._active_name for c in domain.iter_conditions() + ) + ): + domain &= Domain(model._active_name, "=", True) + security = Domain.TRUE if model.env.su else model._access_domain("read") + if security.is_false(): model.browse().check_access("read") + domain = domain.optimize_full(model) + query = Query(model, alias=alias) + query.add_where(domain._to_sql(query.table)) + if not security.is_true(): model_sudo = model.sudo().with_context(active_test=False) - sec_domain = model.env["ir.rule"]._compute_domain(model._name, "read") - sec_domain = sec_domain.optimize_full(model_sudo) - if sec_domain.is_false(): - query.add_where(SQL("FALSE")) - elif not sec_domain.is_true(): - query.add_where(sec_domain._to_sql(model_sudo, alias, query)) - + query.add_where( + security.optimize_full(model_sudo, search_domain=domain)._to_sql( + query.table._with_model(model_sudo) + ) + ) return query + + +def spatial_condition_sql(table, field_expr, operator, value): + model = table._model + field = model._fields[field_expr] + if not isinstance(field, GeoField): + # Invalid domain operands follow the ORM's ValueError convention. + raise ValueError(f"{field_expr} is not a spatial field") # noqa: TRY004 + model.check_field_access(field, "read") + left = table[field_expr] + sql_operator = GEO_OPERATORS[operator] + + def compare(right): + if operator in ("geo_greater", "geo_lesser"): + return SQL("ST_Area(%s) %s ST_Area(%s)", left, sql_operator, right) + if operator == "geo_equal": + return SQL("%s = %s", left, right) + return SQL("%s(%s, %s)", sql_operator, left, right) + + if isinstance(value, dict): + if not value: + raise ValueError( + f"Missing geo reference for {field_expr!r}: expected " + f"{{'.': }}" + ) + conditions = [] + for key, domain in value.items(): + related_name, _, related_field = ( + key.rpartition(".") if isinstance(key, str) else ("", "", "") + ) + if related_name not in model.env or not isinstance( + model.env[related_name]._fields.get(related_field), GeoField + ): + raise ValueError( + f"Invalid geo reference {key!r}: expected '.'" + ) + related = model.env[related_name] + related.check_field_access(related._fields[related_field], "read") + query = where_calc(related, domain, alias="geo_" + uuid4().hex) + query.add_where(compare(query.table[related_field])) + conditions.append(SQL("EXISTS(%s)", query.subselect(SQL("1")))) + return SQL(" AND ").join(conditions) + if operator in ("geo_greater", "geo_lesser") and isinstance(value, int | float): + return SQL("ST_Area(%s) %s %s", left, sql_operator, value) + shape = field.entry_to_shape(value, same_type=False) + return compare(SQL("ST_GeomFromText(%s, %s)", shape.wkt, field.srid)) diff --git a/base_geoengine/fields.py b/base_geoengine/fields.py index 1cd79f843..465873780 100644 --- a/base_geoengine/fields.py +++ b/base_geoengine/fields.py @@ -65,7 +65,7 @@ def convert_to_cache(self, value, record, validate=True): if isinstance(val, bytes | str): try: int(val, 16) - except Exception: + except ValueError: # not an hex value -> try to load from a sting # representation of a geometry value = convert.value_to_shape(value, use_wkb=False) @@ -112,15 +112,18 @@ def load_geo(cls, wkb): def entry_to_shape(self, value, same_type=False): """Transform input into an object""" shape = convert.value_to_shape(value) - if same_type and not shape.is_empty: - if shape.geom_type.lower() != self.geo_type.lower(): - msg = self.env._( - "Geo Value %(geom_type)s must be of the same type %(geo_type)s \ - as fields", - geom_type=shape.geom_type.lower(), - geo_type=self.geo_type.lower(), - ) - raise TypeError(msg) + if ( + same_type + and not shape.is_empty + and shape.geom_type.lower() != self.geo_type.lower() + ): + msg = self.env._( + "Geo Value %(geom_type)s must be of the same type %(geo_type)s \ + as fields", + geom_type=shape.geom_type.lower(), + geo_type=self.geo_type.lower(), + ) + raise TypeError(msg) return shape def update_geo_db_column(self, model): diff --git a/base_geoengine/geo_convertion_helper.py b/base_geoengine/geo_convertion_helper.py index f1d8de753..bc090b2b7 100644 --- a/base_geoengine/geo_convertion_helper.py +++ b/base_geoengine/geo_convertion_helper.py @@ -9,6 +9,7 @@ try: import geojson from shapely import wkb, wkt + from shapely.errors import ShapelyError from shapely.geometry import shape from shapely.geometry.base import BaseGeometry except ImportError: @@ -32,8 +33,17 @@ def value_to_shape(value, use_wkb=False): try: int(value, 16) return wkb.loads(value, hex=True) - except Exception: - return wkt.loads(value) + except (ValueError, ShapelyError): + # not a WKB hex value -> try to load it as WKT + try: + return wkt.loads(value) + except ShapelyError as exc: + # Raise a ValueError so callers like the domain validator + # treat it as invalid input instead of a server error + raise ValueError( + f"Invalid geometry value (expected WKT, WKB or GeoJSON): " + f"{value!r}" + ) from exc elif hasattr(value, "wkt"): if isinstance(value, BaseGeometry): return value diff --git a/base_geoengine/geo_db.py b/base_geoengine/geo_db.py index 65221a019..9de341781 100644 --- a/base_geoengine/geo_db.py +++ b/base_geoengine/geo_db.py @@ -5,7 +5,7 @@ import logging from odoo.exceptions import MissingError -from odoo.tools import sql +from odoo.tools import SQL, sql logger = logging.getLogger("geoengine.sql") _schema = logging.getLogger("odoo.schema") @@ -84,6 +84,12 @@ def create_geo_index(cr, columnname, tablename): indexname = _postgis_index_name(tablename, columnname) if sql.index_exists(cr, indexname): return - # pylint: disable=E8103 - cr.execute(f"CREATE INDEX {indexname} ON {tablename} USING GIST ( {columnname} )") + cr.execute( + SQL( + "CREATE INDEX %s ON %s USING GIST (%s)", + SQL.identifier(indexname), + SQL.identifier(tablename), + SQL.identifier(columnname), + ) + ) _schema.debug("Table %r: created index %r", tablename, indexname) diff --git a/base_geoengine/geo_operators.py b/base_geoengine/geo_operators.py index 8be01f44e..df1d79d24 100644 --- a/base_geoengine/geo_operators.py +++ b/base_geoengine/geo_operators.py @@ -10,11 +10,11 @@ def __init__(self, geo_field): def _get_direct_como_op_sql(self, table, col, value, params, op=""): """provide raw sql for geater and lesser operators""" if isinstance(value, int | float): - return f" ST_Area({table}.{col}) {op} {value}" + return f' ST_Area("{table}"."{col}") {op} {value}' else: base = self.geo_field.entry_to_shape(value, same_type=False) params.append(base.wkt) - return f" ST_Area({table}.{col}) {op} ST_Area(ST_GeomFromText(%s))" + return f' ST_Area("{table}"."{col}") {op} ST_Area(ST_GeomFromText(%s))' def _get_postgis_comp_sql(self, table, col, value, params, op=""): """return raw sql for all search based on St_**(a, b) posgis operator""" @@ -22,7 +22,7 @@ def _get_postgis_comp_sql(self, table, col, value, params, op=""): srid = self.geo_field.srid params.append(base.wkt) params.append(srid) - return f"{op}({table}.{col}, ST_GeomFromText(%s, %s))" + return f'{op}("{table}"."{col}", ST_GeomFromText(%s, %s))' def get_geo_greater_sql(self, table, col, value, params): """Returns raw sql for geo_greater operator @@ -48,7 +48,7 @@ def get_geo_equal_sql( base = self.geo_field.entry_to_shape(value, same_type=False) compare_to = "ST_GeomFromText(%s)" params.append(base.wkt) - return f" {table}.{col} = {compare_to}" + return f' "{table}"."{col}" = {compare_to}' def get_geo_intersect_sql(self, table, col, value, params): """Returns raw sql for geo_intersec operator diff --git a/base_geoengine/models/__init__.py b/base_geoengine/models/__init__.py index 7436a36f5..1a78543ab 100644 --- a/base_geoengine/models/__init__.py +++ b/base_geoengine/models/__init__.py @@ -20,6 +20,7 @@ """Module that manages map view and vector/raster layer""" from . import base +from . import ir_actions_act_window_view from . import geo_raster_layer from . import geo_vector_layer from . import ir_view diff --git a/base_geoengine/models/base.py b/base_geoengine/models/base.py index 3bbe96188..ad0c5b306 100644 --- a/base_geoengine/models/base.py +++ b/base_geoengine/models/base.py @@ -21,7 +21,7 @@ class Base(models.AbstractModel): _inherit = "base" # Array of ash that define layer and data to use - _georepr = [] + _georepr = () @api.model def fields_get(self, allfields=None, attributes=None): @@ -131,6 +131,36 @@ def get_edit_info_for_geo_column(self, column): "default_zoom": view.default_zoom, } + @api.model + def get_geo_reference_models(self): + """Return the readable models having stored geo fields, used by the + domain editor to build indirect geo conditions like + ``('geo_point', 'geo_within', {'res.partner.the_geom': [...]})``.""" + result = [] + for model_name in self.env.registry: + model = self.env[model_name] + if model._abstract or model._transient or not model.has_access("read"): + continue + geo_field_ids = [ + field + for field in model._fields.values() + if isinstance(field, geo_fields.GeoField) and field.store + ] + if not geo_field_ids: + continue + result.append( + { + "model": model_name, + "name": self.env["ir.model"].sudo()._get(model_name).name + or model._description, + "fields": [ + [field.name, field._description_string(self.env)] + for field in geo_field_ids + ], + } + ) + return sorted(result, key=lambda info: info["name"]) + @api.model def geo_search( self, domain=None, geo_domain=None, offset=0, limit=None, order=None diff --git a/base_geoengine/models/geo_vector_layer.py b/base_geoengine/models/geo_vector_layer.py index b0cc6cdf1..1b7723552 100644 --- a/base_geoengine/models/geo_vector_layer.py +++ b/base_geoengine/models/geo_vector_layer.py @@ -62,7 +62,7 @@ class GeoVectorLayer(models.Model): domain=[("ttype", "ilike", "geo_")], ) - attribute_field_id_domain = fields.Binary( + attribute_field_id_domain = fields.Json( compute="_compute_attribute_field_id_domain", readonly=True, store=False ) attribute_field_id = fields.Many2one("ir.model.fields", "Attribute field") @@ -99,14 +99,13 @@ class GeoVectorLayer(models.Model): @api.constrains("geo_field_id", "model_id") def _check_geo_field_id(self): for rec in self: - if rec.model_id: - if not rec.geo_field_id.model_id == rec.model_id: - raise ValidationError( - self.env._( - "The geo_field_id must be a field in %s model", - rec.model_id.display_name, - ) + if rec.model_id and rec.geo_field_id.model_id != rec.model_id: + raise ValidationError( + self.env._( + "The geo_field_id must be a field in %s model", + rec.model_id.display_name, ) + ) @api.constrains("geo_repr", "attribute_field_id") def _check_geo_repr(self): @@ -114,29 +113,32 @@ def _check_geo_repr(self): if ( rec.attribute_field_id and rec.attribute_field_id.ttype not in NUMBER_ATT - ): - if ( + and ( rec.geo_repr == "colored" and rec.classification != "unique" or rec.geo_repr == "proportion" - ): - raise ValidationError( - self.env._( - "You need to select a numeric field", - ) + ) + ): + raise ValidationError( + self.env._( + "You need to select a numeric field", ) + ) @api.constrains("attribute_field_id", "geo_field_id") def _check_if_attribute_in_geo_field(self): for rec in self: - if rec.attribute_field_id and rec.geo_field_id: - if rec.attribute_field_id.model != rec.geo_field_id.model: - raise ValidationError( - self.env._( - "You need to provide an attribute that exists in %s model", - rec.geo_field_id.model_id.display_name, - ) + if ( + rec.attribute_field_id + and rec.geo_field_id + and rec.attribute_field_id.model != rec.geo_field_id.model + ): + raise ValidationError( + self.env._( + "You need to provide an attribute that exists in %s model", + rec.geo_field_id.model_id.display_name, ) + ) @api.depends("model_id") def _compute_model_view_id(self): diff --git a/base_geoengine/models/ir_actions_act_window_view.py b/base_geoengine/models/ir_actions_act_window_view.py new file mode 100644 index 000000000..8ec13ba77 --- /dev/null +++ b/base_geoengine/models/ir_actions_act_window_view.py @@ -0,0 +1,11 @@ +# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). +from odoo import fields, models + + +class IrActionsActWindowView(models.Model): + _inherit = "ir.actions.act_window.view" + + view_mode = fields.Selection( + selection_add=[("geoengine", "GeoEngine")], + ondelete={"geoengine": "cascade"}, + ) diff --git a/base_geoengine/models/ir_model.py b/base_geoengine/models/ir_model.py index ba3f44218..946bf3fb7 100644 --- a/base_geoengine/models/ir_model.py +++ b/base_geoengine/models/ir_model.py @@ -3,11 +3,6 @@ # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). from odoo import fields, models -from odoo.addons import base - -if "geoengine" not in base.models.ir_actions.VIEW_TYPES: - base.models.ir_actions.VIEW_TYPES.append(("geoengine", "Geoengine")) - GEO_TYPES = [ ("geo_polygon", "geo_polygon"), ("geo_multi_polygon", "geo_multi_polygon"), diff --git a/base_geoengine/models/ir_view.py b/base_geoengine/models/ir_view.py index aaec60ac7..3c76bdec4 100644 --- a/base_geoengine/models/ir_view.py +++ b/base_geoengine/models/ir_view.py @@ -35,5 +35,5 @@ def _is_qweb_based_view(self, view_type): def _get_view_info(self): res = super()._get_view_info() - res.update({"geoengine": {"icon": "fa fa-globe"}}) + res.update({"geoengine": {"icon": "map"}}) return res diff --git a/base_geoengine/security/ir.model.access.csv b/base_geoengine/security/ir.access.csv similarity index 75% rename from base_geoengine/security/ir.model.access.csv rename to base_geoengine/security/ir.access.csv index 44559f50e..3faa86171 100644 --- a/base_geoengine/security/ir.model.access.csv +++ b/base_geoengine/security/ir.access.csv @@ -1,9 +1,9 @@ -id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink -access_geo_user_vector_user,geoengine.user.vector.layer,base_geoengine.model_geoengine_vector_layer,base_geoengine.group_geoengine_user,1,0,0,0 -access_geo_admin_vector_user,geoengine.admin.vector.layer,base_geoengine.model_geoengine_vector_layer,base_geoengine.group_geoengine_admin,1,1,1,1 -access_geo_user_raster_user,geoengine.user.raster.layer,base_geoengine.model_geoengine_raster_layer,base_geoengine.group_geoengine_user,1,0,0,0 -access_geo_admin_raster_user,geoengine.admin.raster.layer,base_geoengine.model_geoengine_raster_layer,base_geoengine.group_geoengine_admin,1,1,1,1 -access_geo_user_raster_type_user,geoengine.user.raster.layer.type,base_geoengine.model_geoengine_raster_layer_type,base_geoengine.group_geoengine_user,1,0,0,0 -access_geo_admin_raster_type_user,geoengine.admin.raster.layer.type,base_geoengine.model_geoengine_raster_layer_type,base_geoengine.group_geoengine_admin,1,1,1,1 -access_geo_user_allmodels,ir.model,base.model_ir_model,base_geoengine.group_geoengine_user,1,0,0,0 -access_geo_user_allviews,ir.ui.view,base.model_ir_ui_view,base_geoengine.group_geoengine_user,1,0,0,0 +id,name,model_id:id,group_id:id,operation,domain +access_geo_user_vector_user,geoengine.user.vector.layer,base_geoengine.model_geoengine_vector_layer,base_geoengine.group_geoengine_user,r, +access_geo_admin_vector_user,geoengine.admin.vector.layer,base_geoengine.model_geoengine_vector_layer,base_geoengine.group_geoengine_admin,crud, +access_geo_user_raster_user,geoengine.user.raster.layer,base_geoengine.model_geoengine_raster_layer,base_geoengine.group_geoengine_user,r, +access_geo_admin_raster_user,geoengine.admin.raster.layer,base_geoengine.model_geoengine_raster_layer,base_geoengine.group_geoengine_admin,crud, +access_geo_user_raster_type_user,geoengine.user.raster.layer.type,base_geoengine.model_geoengine_raster_layer_type,base_geoengine.group_geoengine_user,r, +access_geo_admin_raster_type_user,geoengine.admin.raster.layer.type,base_geoengine.model_geoengine_raster_layer_type,base_geoengine.group_geoengine_admin,crud, +access_geo_user_allmodels,ir.model,base.model_ir_model,base_geoengine.group_geoengine_user,r, +access_geo_user_allviews,ir.ui.view,base.model_ir_ui_view,base_geoengine.group_geoengine_user,r, diff --git a/base_geoengine/static/src/js/raster_layers_store.esm.js b/base_geoengine/static/src/js/raster_layers_store.esm.js index 9de3a69d0..8dba0981c 100644 --- a/base_geoengine/static/src/js/raster_layers_store.esm.js +++ b/base_geoengine/static/src/js/raster_layers_store.esm.js @@ -1,6 +1,6 @@ /** @odoo-module */ -import {reactive} from "@odoo/owl"; +import {proxy} from "@odoo/owl"; class RasterLayersStore { /** @@ -39,4 +39,4 @@ class RasterLayersStore { return this.rasters.length; } } -export const rasterLayersStore = reactive(new RasterLayersStore()); +export const rasterLayersStore = proxy(new RasterLayersStore()); diff --git a/base_geoengine/static/src/js/vector_layers_store.esm.js b/base_geoengine/static/src/js/vector_layers_store.esm.js index 5ce7ba81b..2e3037967 100644 --- a/base_geoengine/static/src/js/vector_layers_store.esm.js +++ b/base_geoengine/static/src/js/vector_layers_store.esm.js @@ -1,5 +1,5 @@ /** @odoo-module */ -import {reactive} from "@odoo/owl"; +import {proxy} from "@odoo/owl"; class VectorLayersStore { /** @@ -33,4 +33,4 @@ class VectorLayersStore { } } -export const vectorLayersStore = reactive(new VectorLayersStore()); +export const vectorLayersStore = proxy(new VectorLayersStore()); diff --git a/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.esm.js b/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.esm.js index 44a360253..61fb283fa 100644 --- a/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.esm.js +++ b/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.esm.js @@ -4,7 +4,7 @@ * Copyright 2023 ACSONE SA/NV */ -import {Component, useState} from "@odoo/owl"; +import {Component, proxy, t, useProps} from "@odoo/owl"; import {FormViewDialog} from "@web/views/view_dialogs/form_view_dialog"; import {Layout} from "@web/search/layout"; import {SearchBar} from "@web/search/search_bar/search_bar"; @@ -19,19 +19,24 @@ import {usePager} from "@web/search/pager_hook"; import {useSearchBarToggler} from "@web/search/search_bar/search_bar_toggler"; export class GeoengineController extends Component { + props = useProps({ + ...standardViewProps, + Model: t.function(), + Renderer: t.function(), + archInfo: t.object(), + }); + /** * Setup the controller by using the useModel hook. */ setup() { - this.state = useState({isSavedOrDiscarded: false}); + this.state = proxy({isSavedOrDiscarded: false}); this.actionService = useService("action"); this.view = useService("view"); this.addDialog = useOwnedDialogs(); this.editable = this.props.archInfo.editable; this.archInfo = this.props.archInfo; - this.model = useState( - useModelWithSampleData(this.props.Model, this.modelParams) - ); + this.model = useModelWithSampleData(this.props.Model, this.modelParams); this.searchBarToggler = useSearchBarToggler(); /** * Allow you to display records on the map thanks to the paging located @@ -83,7 +88,9 @@ export class GeoengineController extends Component { activeFields: activeFields, openGroupsByDefault: true, }; - this.props.searchMenuTypes = this.props.searchMenuTypes || []; + // `this.props` is owned by the parent and must not be mutated; keep + // the fallback in a local variable instead of writing it back onto props. + const searchMenuTypes = this.props.searchMenuTypes || []; return { config: modelConfig, @@ -94,7 +101,7 @@ export class GeoengineController extends Component { limit: archInfo.limit || limit, countLimit: archInfo.countLimit, defaultOrderBy: archInfo.defaultOrder, - defaultGroupBy: this.props.searchMenuTypes.includes("groupBy") + defaultGroupBy: searchMenuTypes.includes("groupBy") ? defaultGroupBy : false, groupsLimit: archInfo.groupsLimit, @@ -206,9 +213,3 @@ export class GeoengineController extends Component { GeoengineController.template = "base_geoengine.GeoengineController"; GeoengineController.components = {Layout, SearchBar}; -GeoengineController.props = { - ...standardViewProps, - Model: Function, - Renderer: Function, - archInfo: Object, -}; diff --git a/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.xml b/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.xml index a2df97349..3b3bd4a95 100644 --- a/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.xml +++ b/base_geoengine/static/src/js/views/geoengine/geoengine_controller/geoengine_controller.xml @@ -1,20 +1,20 @@ - + - + @@ -22,23 +22,23 @@ type="button" class="btn btn-secondary o_list_button_discard" data-hotkey="j" - t-on-click.stop="onClickDiscard" + t-on-click.stop="this.onClickDiscard" > Discard diff --git a/base_geoengine/static/src/js/views/geoengine/geoengine_record/geoengine_record.xml b/base_geoengine/static/src/js/views/geoengine/geoengine_record/geoengine_record.xml index dc527ea37..fde184044 100644 --- a/base_geoengine/static/src/js/views/geoengine/geoengine_record/geoengine_record.xml +++ b/base_geoengine/static/src/js/views/geoengine/geoengine_record/geoengine_record.xml @@ -2,11 +2,11 @@
diff --git a/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.esm.js b/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.esm.js index 17e9e8fe7..874877b32 100644 --- a/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.esm.js +++ b/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.esm.js @@ -2,7 +2,6 @@ /* global document */ /* global localStorage */ -/* global console */ // Libraries loaded dynamically via geoengine_libs.esm.js let ol = null; @@ -14,14 +13,16 @@ let geostats = null; */ import { - App, Component, onMounted, onPatched, onWillStart, onWillUpdateProps, - reactive, - useState, + proxy, + t, + useEffect, + useProps, + useScope, } from "@odoo/owl"; import {GeoengineRecord} from "../geoengine_record/geoengine_record.esm"; import {LayersPanel} from "../layers_panel/layers_panel.esm"; @@ -33,8 +34,6 @@ import { } from "@web/model/relational_model/utils"; import {evaluateExpr} from "@web/core/py_js/py"; import {loadGeoengineLibs} from "../../../geoengine_libs.esm"; -import {getTemplate} from "@web/core/templates"; -import {customDirectives} from "@web/env"; import {parseXML} from "@web/core/utils/xml"; import {rasterLayersStore} from "../../../raster_layers_store.esm"; import {registry} from "@web/core/registry"; @@ -52,19 +51,48 @@ const DEFAULT_NUM_CLASSES = 5; const LEGEND_MAX_ITEMS = 10; export class GeoengineRenderer extends Component { + props = useProps({ + isSavedOrDiscarded: t.boolean(), + archInfo: t.object(), + data: t.object(), + openRecord: t.function(), + editable: t.boolean().optional(), + updateRecord: t.function(), + onClickDiscard: t.function(), + createRecord: t.function(), + onDrawStart: t.function(), + }); + setup() { - this.state = useState({selectedFeatures: [], isModified: false, isFit: false}); + // Captured so `loadView()` can construct RelationalModel instances from + // deep inside an async callback: its constructor calls Owl hooks + // (usePlugin), which require an active scope, no longer implicitly + // available past the first `await` of an onWillStart callback. + this.scope = useScope(); + this.state = proxy({ + selectedFeatures: [], + isModified: false, + isFit: false, + popupRecord: null, + }); this.models = []; this.cfg_models = []; this.vectorModel = {}; this.legends = []; - // When a change is issued in the rasterLayersStore or the vectorLayersStore the LayerChanged method is called. - this.rasterLayersStore = reactive(rasterLayersStore, () => - this.onRasterLayerChanged() + this.rasterLayersStore = rasterLayersStore; + this.vectorLayersStore = vectorLayersStore; + // When a change is issued in the rasterLayersStore or the vectorLayersStore the + // LayerChanged method is called. `useEffect` auto-tracks the reactive reads + // performed while it runs (here, inside `onRasterLayerChanged`/ + // `onVectorLayerChanged`) and re-runs whenever they change; the store read is + // passed in explicitly so it is always tracked, even before `this.map` exists + // (the methods themselves no-op until the map is mounted). + useEffect(() => + this.onRasterLayerChanged(this.rasterLayersStore.rastersLayers) ); - this.vectorLayersStore = reactive(vectorLayersStore, () => - this.onVectorLayerChanged() + useEffect(() => + this.onVectorLayerChanged(this.vectorLayersStore.vectorsLayers) ); this.orm = useService("orm"); @@ -295,7 +323,7 @@ export class GeoengineRenderer extends Component { createEditControl() { const {element, button} = this.createHtmlControl( - '', + '', "edit-control ol-unselectable ol-control" ); @@ -341,7 +369,7 @@ export class GeoengineRenderer extends Component { createDrawControl() { const {element, button} = this.createHtmlControl( - '', + '', "draw-control ol-unselectable ol-control" ); button.addEventListener("click", () => { @@ -383,7 +411,7 @@ export class GeoengineRenderer extends Component { createSelectControl() { const {element, button} = this.createHtmlControl( - '', + '', "select-control ol-unselectable ol-control" ); this.addSelectedClassToButton(button); @@ -511,72 +539,61 @@ export class GeoengineRenderer extends Component { updateInfoBox(features) { const feature = features.item(0); if (feature !== undefined) { - const popup = this.getPopup(); - if (feature !== undefined) { - var attributes = feature.get("attributes"); - - if (this.cfg_models.includes(feature.get("model"))) { - const model = this.models.find( - (el) => el.model.resModel === feature.get("model") - ); - this.mountGeoengineRecord({ - popup, - archInfo: model.archInfo, - templateDocs: model.archInfo.templateDocs, - model: model.model, - attributes, - }); - } else { - this.mountGeoengineRecord({ - popup, - archInfo: this.props.archInfo, - templateDocs: this.props.archInfo.templateDocs, - model: this.props.data, - attributes, - }); - } + var attributes = feature.get("attributes"); - var coord = ol.extent.getCenter(feature.getGeometry().getExtent()); - this.overlay.setPosition(coord); + if (this.cfg_models.includes(feature.get("model"))) { + const model = this.models.find( + (el) => el.model.resModel === feature.get("model") + ); + this.mountGeoengineRecord({ + archInfo: model.archInfo, + templateDocs: model.archInfo.templateDocs, + model: model.model, + attributes, + }); + } else { + this.mountGeoengineRecord({ + archInfo: this.props.archInfo, + templateDocs: this.props.archInfo.templateDocs, + model: this.props.data, + attributes, + }); } + + var coord = ol.extent.getCenter(feature.getGeometry().getExtent()); + this.overlay.setPosition(coord); } else { this.hidePopup(); } } - getPopup() { - const popup = document.getElementById("popup-content"); - if (popup.firstChild !== null) { - popup.removeChild(popup.firstChild); - } - return popup; - } - /** - * Allow you to mount geoengine record. This displays the record in the info box template. - * @param {*} popup + * Allow you to display the record in the info box template. + * + * The info box's content is a normal child component (GeoengineRecord), + * portaled into the `#popup-content` DOM node with `t-custom-portal` + * rather than mounted as a separate Owl App: a separate App would need + * its own full plugin set (core widgets like use several + * plugins internally) and starting a second one alongside the + * already-running app causes duplicate service/plugin registration + * errors. Being part of the same component tree means it shares the + * existing env/services/plugins for free. * @param {*} archInfo * @param {*} templateDocs * @param {*} model * @param {*} attributes * @param {*} record */ - mountGeoengineRecord({popup, archInfo, templateDocs, model, attributes, record}) { + mountGeoengineRecord({archInfo, templateDocs, model, attributes, record}) { this.record = record === undefined ? model.records.find((element) => element._values.id === attributes.id) : record; - const app = new App(GeoengineRecord, { - env: this.env, - props: { - archInfo, - record: this.record, - templates: templateDocs, - }, - getTemplate, - customDirectives, - }); - app.mount(popup); + this.state.popupRecord = { + archInfo, + record: this.record, + templates: templateDocs, + }; } /** @@ -584,11 +601,9 @@ export class GeoengineRenderer extends Component { * @param {*} record */ onDisplayPopupRecord(record) { - const popup = this.getPopup(); const feature = this.vectorSource.getFeatureById(record.resId); if (feature) { this.mountGeoengineRecord({ - popup, archInfo: this.props.archInfo, templateDocs: this.props.archInfo.templateDocs, record, @@ -640,6 +655,7 @@ export class GeoengineRenderer extends Component { hidePopup() { this.overlay.setPosition(undefined); + this.state.popupRecord = null; } /** @@ -660,7 +676,21 @@ export class GeoengineRenderer extends Component { * Allows you to change the visibility of layers. This method is called * when the user changes raster layers. */ - onRasterLayerChanged() { + onRasterLayerChanged(rasters) { + // Read every raster's mutable properties unconditionally so this effect + // keeps depending on them even on runs that return early below (e.g. the + // very first run, before `this.map` exists): Owl's reactivity only + // re-runs an effect for properties it actually read on a previous run, + // so skipping this on the early runs would mean a later mutation (like + // toggling a raster's visibility) is never noticed again. + this.primedRasters = (rasters || []).map((raster) => [ + raster.name, + raster.isVisible, + raster.opacity, + ]); + if (!this.map || !rasters) { + return; + } this.map .getLayers() .getArray() @@ -668,7 +698,7 @@ export class GeoengineRenderer extends Component { .getLayers() .getArray() .forEach((layer) => { - this.rasterLayersStore.rastersLayers.forEach((raster) => { + rasters.forEach((raster) => { if (raster.name === layer.get("title")) { layer.setVisible(raster.isVisible); layer.setOpacity(raster.opacity); @@ -681,7 +711,24 @@ export class GeoengineRenderer extends Component { * Allows you to change the visibility of layers. This method is called * when the user changes vector layers. */ - async onVectorLayerChanged() { + async onVectorLayerChanged(vectors) { + // Read every vector's mutable properties unconditionally so this effect + // keeps depending on them even on runs that return early below (e.g. the + // very first run, before `this.map` exists): Owl's reactivity only + // re-runs an effect for properties it actually read on a previous run, + // so skipping this on the early runs would mean a later mutation (like + // toggling a layer's visibility) is never noticed again. + this.primedVectors = (vectors || []).map((vector) => [ + vector.name, + vector.isVisible, + vector.onVisibleChanged, + vector.onDomainChanged, + vector.onLayerChanged, + vector.onSequenceChanged, + ]); + if (!this.map || !vectors) { + return; + } await this.map .getLayers() .getArray() @@ -689,7 +736,7 @@ export class GeoengineRenderer extends Component { .getLayers() .getArray() .forEach((layer) => { - this.vectorLayersStore.vectorsLayers.forEach(async (vector) => { + vectors.forEach(async (vector) => { if (vector.name === layer.get("title")) { if (vector.onVisibleChanged) { this.onVisibleChanged(vector, layer); @@ -1009,10 +1056,14 @@ export class GeoengineRenderer extends Component { }; if (model === "geoengine.vector.layer") { - this.vectorModel = new Model(this.env, searchParams, this.services); + this.vectorModel = this.scope.run( + () => new Model(this.env, searchParams, this.services) + ); await this.vectorModel.load(searchParams); } else if (this.models.find((e) => e.model.resModel === model) === undefined) { - const toLoadModel = new Model(this.env, searchParams, this.services); + const toLoadModel = this.scope.run( + () => new Model(this.env, searchParams, this.services) + ); await toLoadModel.load().then(() => { this.models.push({model: toLoadModel.root, archInfo}); }); @@ -1064,6 +1115,18 @@ export class GeoengineRenderer extends Component { } styleVectorLayer(cfg, data) { + // Geostats cannot build a serie without values: a layer where no record + // has a usable value (e.g. its domain matches no record, or the attribute + // is unset everywhere) gets the default style instead of aborting the + // rendering of all the layers. + if ( + ["colored", "proportion"].includes(cfg.geo_repr) && + !this.extractLayerValues(cfg, data).some( + (value) => value !== undefined && value !== null && value !== false + ) + ) { + return this.styleVectorLayerDefault(cfg); + } switch (cfg.geo_repr) { case "colored": return this.styleVectorLayerColored(cfg, data); @@ -1077,8 +1140,16 @@ export class GeoengineRenderer extends Component { styleVectorLayerColored(cfg, data) { var indicator = cfg.attribute_field_id[1]; var values = this.extractLayerValues(cfg, data); - var nb_class = cfg.nb_class || DEFAULT_NUM_CLASSES; + // Geostats requires strictly fewer classes than the number of values + // in the serie (`pop()`), otherwise `_classificationCheck` throws a + // TypeError. Clamp the requested number of classes so quantile/interval + // classifications never exceed what the current serie can support. + var nb_class = Math.max( + 1, + Math.min(cfg.nb_class || DEFAULT_NUM_CLASSES, values.length - 1) + ); var opacity = cfg.layer_opacity; + var begin_color_hex = cfg.begin_color || DEFAULT_BEGIN_COLOR; var end_color_hex = cfg.end_color || DEFAULT_END_COLOR; var begin_color = chroma(begin_color_hex).alpha(opacity).css(); @@ -1131,7 +1202,6 @@ export class GeoengineRenderer extends Component { if (label_text === false) { label_text = ""; } - console.log(feature.get("attributes").id); styles_map[colors[color_idx]][0].text_.text_ = label_text.toString(); return styles_map[colors[color_idx]]; }, @@ -1312,15 +1382,4 @@ export class GeoengineRenderer extends Component { } GeoengineRenderer.template = "base_geoengine.GeoengineRenderer"; -GeoengineRenderer.props = { - isSavedOrDiscarded: {type: Boolean}, - archInfo: {type: Object}, - data: {type: Object}, - openRecord: {type: Function}, - editable: {type: Boolean, optional: true}, - updateRecord: {type: Function}, - onClickDiscard: {type: Function}, - createRecord: {type: Function}, - onDrawStart: {type: Function}, -}; GeoengineRenderer.components = {LayersPanel, GeoengineRecord, RecordsPanel}; diff --git a/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.xml b/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.xml index 7bd1a10fb..c5c808ff5 100644 --- a/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.xml +++ b/base_geoengine/static/src/js/views/geoengine/geoengine_renderer/geoengine_renderer.xml @@ -2,7 +2,10 @@
- +