eodag 3.1.0b2__py3-none-any.whl → 3.2.1__py3-none-any.whl

eodag/plugins/search/build_search_result.py

@@ -22,15 +22,15 @@ import hashlib
 import logging
 import re
 from collections import OrderedDict
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Annotated, Any, Optional, Union, cast
+from datetime import date, datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 from urllib.parse import quote_plus, unquote_plus
 
 import geojson
 import orjson
 from dateutil.parser import isoparse
 from dateutil.tz import tzutc
-from jsonpath_ng import Child, Fields, Root
+from dateutil.utils import today
 from pydantic import Field
 from pydantic.fields import FieldInfo
 from requests.auth import AuthBase
@@ -40,10 +40,8 @@ from typing_extensions import get_args
 from eodag.api.product import EOProduct
 from eodag.api.product.metadata_mapping import (
     NOT_AVAILABLE,
-    NOT_MAPPED,
+    OFFLINE_STATUS,
     format_metadata,
-    format_query_params,
-    mtd_cfg_as_conversion_and_querypath,
     properties_from_json,
 )
 from eodag.api.search_result import RawSearchResult
@@ -52,6 +50,7 @@ from eodag.plugins.search.qssearch import PostJsonSearch, QueryStringSearch
 from eodag.types import json_field_definition_to_python
 from eodag.types.queryables import Queryables, QueryablesDict
 from eodag.utils import (
+    DEFAULT_MISSION_START_DATE,
     DEFAULT_SEARCH_TIMEOUT,
     deepcopy,
     dict_items_recursive_sort,
@@ -66,9 +65,11 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger("eodag.search.build_search_result")
 
+ECMWF_PREFIX = "ecmwf:"
+
 # keywords from ECMWF keyword database + "dataset" (not part of database but exists)
 # database: https://confluence.ecmwf.int/display/UDOC/Keywords+in+MARS+and+Dissemination+requests
-ECMWF_KEYWORDS = [
+ECMWF_KEYWORDS = {
     "dataset",
     "accuracy",
     "activity",
@@ -132,10 +133,10 @@ ECMWF_KEYWORDS = [
     "truncation",
     "type",
     "use",
-]
+}
 
 # additional keywords from copernicus services
-COP_DS_KEYWORDS = [
+COP_DS_KEYWORDS = {
     "aerosol_type",
     "altitude",
     "product_type",
@@ -190,55 +191,28 @@ COP_DS_KEYWORDS = [
     "variable_type",
     "version",
     "year",
-]
+}
+
+ALLOWED_KEYWORDS = ECMWF_KEYWORDS | COP_DS_KEYWORDS
+
+END = "completionTimeFromAscendingNode"
 
+START = "startTimeFromAscendingNode"
 
-def keywords_to_mdt(
-    keywords: list[str], prefix: Optional[str] = None
-) -> dict[str, Any]:
+
+def ecmwf_mtd() -> dict[str, Any]:
     """
-    Make metadata mapping dict from a list of keywords
+    Make metadata mapping dict from a list of defined ECMWF Keywords
 
-    prefix:keyword:
-        - keyword
-        - $."prefix:keyword"
+    We automatically add the #to_geojson convert to prevent modification of entries by eval() in the metadata mapping.
 
-    >>> keywords_to_mdt(["month", "year"])
-    {'month': ['month', '$."month"'], 'year': ['year', '$."year"']}
-    >>> keywords_to_mdt(["month", "year"], "ecmwf")
-    {'ecmwf:month': ['month', '$."ecmwf:month"'], 'ecmwf:year': ['year', '$."ecmwf:year"']}
+    keyword:
+        - keyword
+        - $."keyword"#to_geojson
 
-    :param keywords: List of keywords to be converted
-    :param prefix: prefix to be added to the parameter in the mapping
     :return: metadata mapping dict
     """
-    mdt: dict[str, Any] = {}
-    for keyword in keywords:
-        key = f"{prefix}:{keyword}" if prefix else keyword
-        mdt[key] = [keyword, f'$."{key}"']
-    return mdt
-
-
-def strip_quotes(value: Any) -> Any:
-    """Strip superfluous quotes from elements (added by mapping converter to_geojson).
-
-    >>> strip_quotes("'abc'")
-    'abc'
-    >>> strip_quotes(["'abc'", '"def'])
-    ['abc', 'def']
-    >>> strip_quotes({"'abc'": 'def"'})
-    {'abc': 'def'}
-
-    :param value: value from which quotes should be removed (should be either str or list)
-    :return: value without quotes
-    :raises: NotImplementedError
-    """
-    if isinstance(value, (list, tuple)):
-        return [strip_quotes(v) for v in value]
-    elif isinstance(value, dict):
-        return {strip_quotes(k): strip_quotes(v) for k, v in value.items()}
-    else:
-        return str(value).strip("'\"")
+    return {k: [k, f'{{$."{k}"#to_geojson}}'] for k in ALLOWED_KEYWORDS}
 
 
 def _update_properties_from_element(
@@ -309,7 +283,126 @@ def _update_properties_from_element(
 
 def ecmwf_format(v: str) -> str:
     """Add ECMWF prefix to value v if v is a ECMWF keyword."""
-    return "ecmwf:" + v if v in ECMWF_KEYWORDS + COP_DS_KEYWORDS else v
+    return ECMWF_PREFIX + v if v in ALLOWED_KEYWORDS else v
+
+
+def get_min_max(
+    value: Optional[Union[str, list[str]]] = None,
+) -> tuple[Optional[str], Optional[str]]:
+    """Returns the min and max from a list of strings or the same string if a single string is given."""
+    if isinstance(value, list):
+        sorted_values = sorted(value)
+        return sorted_values[0], sorted_values[-1]
+    return value, value
+
+
+def append_time(input_date: date, time: Optional[str]) -> datetime:
+    """
+    Parses a time string in format HHMM and appends it to a date.
+
+    if the time string is in format HH:MM we convert it to HHMM
+    """
+    if not time:
+        time = "0000"
+    time = time.replace(":", "")
+    if time == "2400":
+        time = "0000"
+    dt = datetime.combine(input_date, datetime.strptime(time, "%H%M").time())
+    dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def parse_date(
+    date_str: str, time: Optional[Union[str, list[str]]]
+) -> tuple[datetime, datetime]:
+    """Parses a date string in format YYYY-MM-DD or YYYY-MM-DD/YYYY-MM-DD or YYYY-MM-DD/to/YYYY-MM-DD."""
+    if "to" in date_str:
+        start_date_str, end_date_str = date_str.split("/to/")
+    elif "/" in date_str:
+        dates = date_str.split("/")
+        start_date_str = dates[0]
+        end_date_str = dates[-1]
+    else:
+        start_date_str = end_date_str = date_str
+
+    start_date = datetime.fromisoformat(start_date_str.rstrip("Z"))
+    end_date = datetime.fromisoformat(end_date_str.rstrip("Z"))
+
+    if time:
+        start_t, end_t = get_min_max(time)
+        start_date = append_time(start_date.date(), start_t)
+        end_date = append_time(end_date.date(), end_t)
+
+    return start_date, end_date
+
+
+def parse_year_month_day(
+    year: Union[str, list[str]],
+    month: Optional[Union[str, list[str]]] = None,
+    day: Optional[Union[str, list[str]]] = None,
+    time: Optional[Union[str, list[str]]] = None,
+) -> tuple[datetime, datetime]:
+    """Extracts and returns the year, month, day, and time from the parameters."""
+
+    def build_date(year, month=None, day=None, time=None) -> datetime:
+        """Datetime from default_date with updated year, month, day and time."""
+        updated_date = datetime(int(year), 1, 1).replace(
+            month=int(month) if month is not None else 1,
+            day=int(day) if day is not None else 1,
+        )
+        if time is not None:
+            updated_date = append_time(updated_date.date(), time)
+        return updated_date
+
+    start_y, end_y = get_min_max(year)
+    start_m, end_m = get_min_max(month)
+    start_d, end_d = get_min_max(day)
+    start_t, end_t = get_min_max(time)
+
+    start_date = build_date(start_y, start_m, start_d, start_t)
+    end_date = build_date(end_y, end_m, end_d, end_t)
+
+    return start_date, end_date
+
+
+def ecmwf_temporal_to_eodag(
+    params: dict[str, Any]
+) -> tuple[Optional[str], Optional[str]]:
+    """
+    Converts ECMWF temporal parameters to EODAG temporal parameters.
+
+    ECMWF temporal parameters:
+        - **year** or **hyear**: Union[str, list[str]] — Year(s) as a string or list of strings.
+        - **month** or **hmonth**: Union[str, list[str]] — Month(s) as a string or list of strings.
+        - **day** or **hday**: Union[str, list[str]] — Day(s) as a string or list of strings.
+        - **time**: str — A string representing the time in the format `HHMM` (e.g., `0200`, `0800`, `1400`).
+        - **date**: str — A string in one of the formats:
+            - `YYYY-MM-DD`
+            - `YYYY-MM-DD/YYYY-MM-DD`
+            - `YYYY-MM-DD/to/YYYY-MM-DD`
+
+    :param params: Dictionary containing ECMWF temporal parameters.
+    :return: A tuple with:
+        - **start**: A string in the format `YYYY-MM-DDTHH:MM:SSZ`.
+        - **end**: A string in the format `YYYY-MM-DDTHH:MM:SSZ`.
+    """
+    start = end = None
+
+    if date := params.get("date"):
+        start, end = parse_date(date, params.get("time"))
+
+    elif year := params.get("year") or params.get("hyear"):
+        year = params.get("year") or params.get("hyear")
+        month = params.get("month") or params.get("hmonth")
+        day = params.get("day") or params.get("hday")
+        time = params.get("time")
+
+        start, end = parse_year_month_day(year, month, day, time)
+
+    if start and end:
+        return start.strftime("%Y-%m-%dT%H:%M:%SZ"), end.strftime("%Y-%m-%dT%H:%M:%SZ")
+    else:
+        return None, None
 
 
 class ECMWFSearch(PostJsonSearch):
@@ -342,54 +435,25 @@ class ECMWFSearch(PostJsonSearch):
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         config.metadata_mapping = {
-            **keywords_to_mdt(ECMWF_KEYWORDS + COP_DS_KEYWORDS, "ecmwf"),
+            **ecmwf_mtd(),
+            **{
+                "id": "$.id",
+                "title": "$.id",
+                "storageStatus": OFFLINE_STATUS,
+                "downloadLink": "$.null",
+                "geometry": ["feature", "$.geometry"],
+                "defaultGeometry": "POLYGON((180 -90, 180 90, -180 90, -180 -90, 180 -90))",
+            },
             **config.metadata_mapping,
         }
 
         super().__init__(provider, config)
 
+        # ECMWF providers do not feature any api_endpoint or next_page_query_obj.
+        # Searched is faked by EODAG.
         self.config.__dict__.setdefault("api_endpoint", "")
-
-        # needed by QueryStringSearch.build_query_string / format_free_text_search
-        self.config.__dict__.setdefault("free_text_search_operations", {})
-        # needed for compatibility
         self.config.pagination.setdefault("next_page_query_obj", "{{}}")
 
-        # parse jsonpath on init: product type specific metadata-mapping
-        for product_type in self.config.products.keys():
-            if "metadata_mapping" in self.config.products[product_type].keys():
-                self.config.products[product_type][
-                    "metadata_mapping"
-                ] = mtd_cfg_as_conversion_and_querypath(
-                    self.config.products[product_type]["metadata_mapping"]
-                )
-                # Complete and ready to use product type specific metadata-mapping
-                product_type_metadata_mapping = deepcopy(self.config.metadata_mapping)
-
-                # update config using provider product type definition metadata_mapping
-                # from another product
-                other_product_for_mapping = cast(
-                    str,
-                    self.config.products[product_type].get(
-                        "metadata_mapping_from_product", ""
-                    ),
-                )
-                if other_product_for_mapping:
-                    other_product_type_def_params = self.get_product_type_def_params(
-                        other_product_for_mapping,
-                    )
-                    product_type_metadata_mapping.update(
-                        other_product_type_def_params.get("metadata_mapping", {})
-                    )
-                # from current product
-                product_type_metadata_mapping.update(
-                    self.config.products[product_type]["metadata_mapping"]
-                )
-
-                self.config.products[product_type][
-                    "metadata_mapping"
-                ] = product_type_metadata_mapping
-
     def do_search(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
         """Should perform the actual search request.
 
@@ -414,7 +478,7 @@ class ECMWFSearch(PostJsonSearch):
         product_type = prep.product_type
         if not product_type:
             product_type = kwargs.get("productType", None)
-        self._preprocess_search_params(kwargs, product_type)
+        kwargs = self._preprocess_search_params(kwargs, product_type)
         result, num_items = super().query(prep, **kwargs)
         if prep.count and not num_items:
             num_items = 1
@@ -426,34 +490,31 @@ class ECMWFSearch(PostJsonSearch):
         super().clear()
 
     def build_query_string(
-        self, product_type: str, **kwargs: Any
+        self, product_type: str, query_dict: dict[str, Any]
     ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters
 
         :param product_type: product type id
-        :param kwargs: keyword arguments to be used in the query string
+        :param query_dict: keyword arguments to be used in the query string
         :return: formatted query params and encode query string
         """
-        # parse kwargs as properties as they might be needed to build the query
-        parsed_properties = properties_from_json(
-            kwargs,
-            self.config.metadata_mapping,
-        )
-        available_properties = {
-            # We strip values of superfluous quotes (added by mapping converter to_geojson).
-            k: strip_quotes(v)
-            for k, v in parsed_properties.items()
-            if v not in [NOT_AVAILABLE, NOT_MAPPED]
-        }
+        query_dict["_date"] = f"{query_dict.get(START)}/{query_dict.get(END)}"
+
+        # Reorder kwargs to make sure year/month/day/time if set overwrite default datetime.
+        priority_keys = [
+            START,
+            END,
+        ]
+        ordered_kwargs = {k: query_dict[k] for k in priority_keys if k in query_dict}
+        ordered_kwargs.update(query_dict)
 
-        # build and return the query
         return super().build_query_string(
-            product_type=product_type, **available_properties
+            product_type=product_type, query_dict=ordered_kwargs
         )
 
     def _preprocess_search_params(
         self, params: dict[str, Any], product_type: Optional[str]
-    ) -> None:
+    ) -> dict[str, Any]:
         """Preprocess search parameters before making a request to the CDS API.
 
         This method is responsible for checking and updating the provided search parameters
@@ -469,28 +530,20 @@ class ECMWFSearch(PostJsonSearch):
             # if available, update search params using datacube query-string
             _dc_qp = geojson.loads(unquote_plus(unquote_plus(_dc_qs)))
             if "/to/" in _dc_qp.get("date", ""):
-                (
-                    params["startTimeFromAscendingNode"],
-                    params["completionTimeFromAscendingNode"],
-                ) = _dc_qp["date"].split("/to/")
+                params[START], params[END] = _dc_qp["date"].split("/to/")
             elif "/" in _dc_qp.get("date", ""):
-                (
-                    params["startTimeFromAscendingNode"],
-                    params["completionTimeFromAscendingNode"],
-                ) = _dc_qp["date"].split("/")
+                (params[START], params[END],) = _dc_qp[
+                    "date"
+                ].split("/")
             elif _dc_qp.get("date", None):
-                params["startTimeFromAscendingNode"] = params[
-                    "completionTimeFromAscendingNode"
-                ] = _dc_qp["date"]
+                params[START] = params[END] = _dc_qp["date"]
 
             if "/" in _dc_qp.get("area", ""):
                 params["geometry"] = _dc_qp["area"].split("/")
 
-        non_none_params = {k: v for k, v in params.items() if v}
-
-        # productType
-        dataset = params.get("ecmwf:dataset", None)
-        params["productType"] = non_none_params.get("productType", dataset)
+        params = {
+            k.removeprefix(ECMWF_PREFIX): v for k, v in params.items() if v is not None
+        }
 
         # dates
         # check if default dates have to be added
@@ -498,25 +551,23 @@ class ECMWFSearch(PostJsonSearch):
             self._check_date_params(params, product_type)
 
         # adapt end date if it is midnight
-        if "completionTimeFromAscendingNode" in params:
+        if END in params:
             end_date_excluded = getattr(self.config, "end_date_excluded", True)
             is_datetime = True
             try:
-                end_date = datetime.strptime(
-                    params["completionTimeFromAscendingNode"], "%Y-%m-%dT%H:%M:%SZ"
-                )
+                end_date = datetime.strptime(params[END], "%Y-%m-%dT%H:%M:%SZ")
                 end_date = end_date.replace(tzinfo=tzutc())
             except ValueError:
                 try:
                     end_date = datetime.strptime(
-                        params["completionTimeFromAscendingNode"],
+                        params[END],
                         "%Y-%m-%dT%H:%M:%S.%fZ",
                     )
                     end_date = end_date.replace(tzinfo=tzutc())
                 except ValueError:
-                    end_date = isoparse(params["completionTimeFromAscendingNode"])
+                    end_date = isoparse(params[END])
                     is_datetime = False
-            start_date = isoparse(params["startTimeFromAscendingNode"])
+            start_date = isoparse(params[START])
             if (
                 not end_date_excluded
                 and is_datetime
@@ -525,12 +576,72 @@ class ECMWFSearch(PostJsonSearch):
                 == end_date.replace(hour=0, minute=0, second=0, microsecond=0)
             ):
                 end_date += timedelta(days=-1)
-                params["completionTimeFromAscendingNode"] = end_date.isoformat()
+                params[END] = end_date.isoformat()
 
         # geometry
         if "geometry" in params:
             params["geometry"] = get_geometry_from_various(geometry=params["geometry"])
 
+        return params
+
+    def _check_date_params(
+        self, keywords: dict[str, Any], product_type: Optional[str]
+    ) -> None:
+        """checks if start and end date are present in the keywords and adds them if not"""
+
+        if START and END in keywords:
+            return
+
+        product_type_conf = getattr(self.config, "metadata_mapping", {})
+        if (
+            product_type
+            and product_type in self.config.products
+            and "metadata_mapping" in self.config.products[product_type]
+        ):
+            product_type_conf = self.config.products[product_type]["metadata_mapping"]
+
+        # start time given, end time missing
+        if START in keywords:
+            keywords[END] = (
+                keywords[START]
+                if END in product_type_conf
+                else self.get_product_type_cfg_value(
+                    "missionEndDate", today().isoformat()
+                )
+            )
+            return
+
+        if END in product_type_conf:
+            mapping = product_type_conf[START]
+            if not isinstance(mapping, list):
+                mapping = product_type_conf[END]
+            if isinstance(mapping, list):
+                # get time parameters (date, year, month, ...) from metadata mapping
+                input_mapping = mapping[0].replace("{{", "").replace("}}", "")
+                time_params = [
+                    values.split(":")[0].strip() for values in input_mapping.split(",")
+                ]
+                time_params = [
+                    tp.replace('"', "").replace("'", "") for tp in time_params
+                ]
+                # if startTime is not given but other time params (e.g. year/month/(day)) are given,
+                # no default date is required
+                start, end = ecmwf_temporal_to_eodag(keywords)
+                if start is None:
+                    keywords[START] = self.get_product_type_cfg_value(
+                        "missionStartDate", DEFAULT_MISSION_START_DATE
+                    )
+                    keywords[END] = (
+                        keywords[START]
+                        if END in product_type_conf
+                        else self.get_product_type_cfg_value(
+                            "missionEndDate", today().isoformat()
+                        )
+                    )
+                else:
+                    keywords[START] = start
+                    keywords[END] = end
+
     def _get_product_type_queryables(
         self, product_type: Optional[str], alias: Optional[str], filters: dict[str, Any]
     ) -> QueryablesDict:
@@ -555,61 +666,60 @@ class ECMWFSearch(PostJsonSearch):
         :returns: fetched queryable parameters dict
         """
         product_type = kwargs.pop("productType")
-        product_type_config = self.config.products.get(product_type, {})
-        provider_product_type = (
-            product_type_config.get("ecmwf:dataset", None)
-            or product_type_config["productType"]
-        )
-        if "start" in kwargs:
-            kwargs["startTimeFromAscendingNode"] = kwargs.pop("start")
-        if "end" in kwargs:
-            kwargs["completionTimeFromAscendingNode"] = kwargs.pop("end")
+
+        pt_config = self.get_product_type_def_params(product_type)
+
+        default_values = deepcopy(pt_config)
+        default_values.pop("metadata_mapping", None)
+        filters = {**default_values, **kwargs}
+
+        if "start" in filters:
+            filters[START] = filters.pop("start")
+        if "end" in filters:
+            filters[END] = filters.pop("end")
 
         # extract default datetime
-        processed_kwargs = deepcopy(kwargs)
-        self._preprocess_search_params(processed_kwargs, product_type)
+        processed_filters = self._preprocess_search_params(
+            deepcopy(filters), product_type
+        )
 
         constraints_url = format_metadata(
             getattr(self.config, "discover_queryables", {}).get("constraints_url", ""),
-            **kwargs,
+            **filters,
         )
         constraints: list[dict[str, Any]] = self._fetch_data(constraints_url)
 
         form_url = format_metadata(
             getattr(self.config, "discover_queryables", {}).get("form_url", ""),
-            **kwargs,
+            **filters,
         )
         form: list[dict[str, Any]] = self._fetch_data(form_url)
 
-        formated_kwargs = self.format_as_provider_keyword(
-            product_type, processed_kwargs
+        formated_filters = self.format_as_provider_keyword(
+            product_type, processed_filters
         )
         # we re-apply kwargs input to consider override of year, month, day and time.
-        for key in kwargs:
-            if key.startswith("ecmwf:"):
-                formated_kwargs[key.replace("ecmwf:", "")] = kwargs[key]
-            elif key in (
-                "startTimeFromAscendingNode",
-                "completionTimeFromAscendingNode",
+        for k, v in {**default_values, **kwargs}.items():
+            key = k.removeprefix(ECMWF_PREFIX)
+
+            if key not in ALLOWED_KEYWORDS | {
+                START,
+                END,
                 "geom",
-            ):
-                formated_kwargs[key] = kwargs[key]
-            else:
+                "geometry",
+            }:
                 raise ValidationError(
                     f"{key} is not a queryable parameter for {self.provider}"
                 )
 
-        # we use non empty kwargs as default to integrate user inputs
+            formated_filters[key] = v
+
+        # we use non empty filters as default to integrate user inputs
         # it is needed because pydantic json schema does not represent "value"
         # but only "default"
         non_empty_formated: dict[str, Any] = {
             k: v
-            for k, v in formated_kwargs.items()
-            if v and (not isinstance(v, list) or all(v))
-        }
-        non_empty_kwargs: dict[str, Any] = {
-            k: v
-            for k, v in processed_kwargs.items()
+            for k, v in formated_filters.items()
             if v and (not isinstance(v, list) or all(v))
         }
 
@@ -627,15 +737,16 @@ class ECMWFSearch(PostJsonSearch):
             # Pre-compute the required keywords (present in all constraint dicts)
             # when form, required keywords are extracted directly from form
             if not form:
-                required_keywords = set(constraints[0].keys())
-                for constraint in constraints[1:]:
-                    required_keywords.intersection_update(constraint.keys())
+                required_keywords = set.intersection(
+                    *(map(lambda d: set(d.keys()), constraints))
+                )
+
         else:
             values_url = getattr(self.config, "available_values_url", "")
             if not values_url:
                 return self.queryables_from_metadata_mapping(product_type)
             if "{" in values_url:
-                values_url = values_url.format(productType=provider_product_type)
+                values_url = values_url.format(**filters)
             data = self._fetch_data(values_url)
             available_values = data["constraints"]
             required_keywords = data.get("required", [])
@@ -643,18 +754,18 @@ class ECMWFSearch(PostJsonSearch):
         # To check if all keywords are queryable parameters, we check if they are in the
         # available values or the product type config (available values calculated from the
         # constraints might not include all queryables)
-        for keyword in kwargs:
+        for keyword in filters:
             if (
                 keyword
                 not in available_values.keys()
-                | product_type_config.keys()
+                | pt_config.keys()
                 | {
-                    "startTimeFromAscendingNode",
-                    "completionTimeFromAscendingNode",
+                    START,
+                    END,
                     "geom",
                 }
                 and keyword not in [f["name"] for f in form]
-                and keyword.replace("ecmwf:", "")
+                and keyword.removeprefix(ECMWF_PREFIX)
                 not in set(list(available_values.keys()) + [f["name"] for f in form])
             ):
                 raise ValidationError(f"{keyword} is not a queryable parameter")
@@ -668,24 +779,24 @@ class ECMWFSearch(PostJsonSearch):
             )
         else:
             queryables = self.queryables_by_values(
-                available_values, list(required_keywords), non_empty_kwargs
+                available_values, list(required_keywords), non_empty_formated
             )
 
         # ecmwf:date is replaced by start and end.
         # start and end filters are supported whenever combinations of "year", "month", "day" filters exist
         if (
-            queryables.pop("ecmwf:date", None)
-            or "ecmwf:year" in queryables
-            or "ecmwf:hyear" in queryables
+            queryables.pop(f"{ECMWF_PREFIX}date", None)
+            or f"{ECMWF_PREFIX}year" in queryables
+            or f"{ECMWF_PREFIX}hyear" in queryables
         ):
             queryables.update(
                 {
                     "start": Queryables.get_with_default(
-                        "start", non_empty_kwargs.get("startTimeFromAscendingNode")
+                        "start", processed_filters.get(START)
                     ),
                     "end": Queryables.get_with_default(
                         "end",
-                        non_empty_kwargs.get("completionTimeFromAscendingNode"),
+                        processed_filters.get(END),
                     ),
                 }
             )
@@ -746,14 +857,15 @@ class ECMWFSearch(PostJsonSearch):
                 raise ValidationError(
                     f"Parameter value as object is not supported: {keyword}={values}"
                 )
-            filter_v = values if isinstance(values, (list, tuple)) else [values]
 
             # We convert every single value to a list of string
+            filter_v = values if isinstance(values, (list, tuple)) else [values]
+
             # We strip values of superfluous quotes (added by mapping converter to_geojson).
             # ECMWF accept values with /to/. We need to split it to an array
             # ECMWF accept values in format val1/val2. We need to split it to an array
             sep = re.compile(r"/to/|/")
-            filter_v = [i for v in filter_v for i in sep.split(strip_quotes(v))]
+            filter_v = [i for v in filter_v for i in sep.split(str(v))]
 
             # special handling for time 0000 converted to 0 by pre-formating with metadata_mapping
             if keyword.split(":")[-1] == "time":
@@ -772,7 +884,10 @@ class ECMWFSearch(PostJsonSearch):
                 # we assume that if the first value is an interval, all values are intervals
                 present_values = []
                 if keyword == "date" and "/" in entry[keyword][0]:
-                    if any(is_range_in_range(x, values[0]) for x in entry[keyword]):
+                    input_range = values
+                    if isinstance(values, list):
+                        input_range = values[0]
+                    if any(is_range_in_range(x, input_range) for x in entry[keyword]):
                         present_values = filter_v
                 else:
                     present_values = [
@@ -792,12 +907,12 @@ class ECMWFSearch(PostJsonSearch):
                     {value for c in constraints for value in c.get(keyword, [])}
                 )
                 # restore ecmwf: prefix before raising error
-                keyword = f"ecmwf:{keyword}"
+                keyword = ECMWF_PREFIX + keyword
 
                 all_keywords_str = ""
                 if len(parsed_keywords) > 1:
                     keywords = [
-                        f"ecmwf:{k}={pk}"
+                        f"{ECMWF_PREFIX + k}={pk}"
                         for k in parsed_keywords
                         if (pk := input_keywords.get(k))
                     ]
@@ -846,6 +961,8 @@ class ECMWFSearch(PostJsonSearch):
             if name in ("area_group", "global", "warning", "licences"):
                 continue
             if "type" not in element or element["type"] == "FreeEditionWidget":
+                # FreeEditionWidget used to select the whole available region
+                # and to provide comments for the dataset
                 continue
 
             # ordering done by id -> set id to high value if not present -> element will be last
@@ -876,12 +993,8 @@ class ECMWFSearch(PostJsonSearch):
             if name == "area" and isinstance(default, dict):
                 default = list(default.values())
 
-            if default:
-                # We strip values of superfluous quotes (addded by mapping converter to_geojson).
-                default = strip_quotes(default)
-
             # sometimes form returns default as array instead of string
-            if default and prop["type"] == "string" and isinstance(default, list):
+            if default and prop.get("type") == "string" and isinstance(default, list):
                 default = ",".join(default)
 
             is_required = bool(element.get("required"))
@@ -925,13 +1038,11 @@ class ECMWFSearch(PostJsonSearch):
             # Needed to map constraints like "xxxx" to eodag parameter "ecmwf:xxxx"
             key = ecmwf_format(name)
 
-            default = defaults.get(key)
-
             queryables[key] = Annotated[
                 get_args(
                     json_field_definition_to_python(
                         {"type": "string", "title": name, "enum": values},
-                        default_value=strip_quotes(default) if default else None,
+                        default_value=defaults.get(name),
                         required=bool(key in required),
                     )
                 )
@@ -948,16 +1059,26 @@ class ECMWFSearch(PostJsonSearch):
         :param properties: dict of properties to be formatted
         :return: dict of formatted properties
         """
-        parsed_properties = properties_from_json(
-            properties,
-            self.config.metadata_mapping,
+        properties["productType"] = product_type
+
+        # provider product type specific conf
+        product_type_def_params = self.get_product_type_def_params(
+            product_type, format_variables=properties
         )
-        available_properties = {
-            k: v
-            for k, v in parsed_properties.items()
-            if v not in [NOT_AVAILABLE, NOT_MAPPED]
-        }
-        return format_query_params(product_type, self.config, available_properties)
+
+        # Add to the query, the queryable parameters set in the provider product type definition
+        properties.update(
+            {
+                k: v
+                for k, v in product_type_def_params.items()
+                if k not in properties.keys()
+                and k in self.config.metadata_mapping.keys()
+                and isinstance(self.config.metadata_mapping[k], list)
+            }
+        )
+        qp, _ = self.build_query_string(product_type, properties)
+
+        return qp
 
     def _fetch_data(self, url: str) -> Any:
         """
@@ -1045,67 +1166,37 @@ class ECMWFSearch(PostJsonSearch):
             discovery_config=getattr(self.config, "discover_metadata", {}),
         )
 
-        if not product_type:
-            product_type = parsed_properties.get("productType", None)
+        properties = {
+            # use product_type_config as default properties
+            **getattr(self.config, "product_type_config", {}),
+            **{ecmwf_format(k): v for k, v in parsed_properties.items()},
+        }
+
+        def slugify(date_str: str) -> str:
+            return date_str.split("T")[0].replace("-", "")
 
         # build product id
-        id_prefix = (product_type or self.provider).upper()
-        if (
-            "startTimeFromAscendingNode" in parsed_properties
-            and parsed_properties["startTimeFromAscendingNode"] != "Not Available"
-            and "completionTimeFromAscendingNode" in parsed_properties
-            and parsed_properties["completionTimeFromAscendingNode"] != "Not Available"
-        ):
-            product_id = "%s_%s_%s_%s" % (
-                id_prefix,
-                parsed_properties["startTimeFromAscendingNode"]
-                .split("T")[0]
-                .replace("-", ""),
-                parsed_properties["completionTimeFromAscendingNode"]
-                .split("T")[0]
-                .replace("-", ""),
-                query_hash,
-            )
-        elif (
-            "startTimeFromAscendingNode" in parsed_properties
-            and parsed_properties["startTimeFromAscendingNode"] != "Not Available"
-        ):
-            product_id = "%s_%s_%s" % (
-                id_prefix,
-                parsed_properties["startTimeFromAscendingNode"]
-                .split("T")[0]
-                .replace("-", ""),
-                query_hash,
-            )
-        else:
-            product_id = f"{id_prefix}_{query_hash}"
-
-        parsed_properties["id"] = parsed_properties["title"] = product_id
-
-        # update downloadLink and orderLink
-        parsed_properties["_dc_qs"] = quote_plus(qs)
-        if parsed_properties["downloadLink"] != "Not Available":
-            parsed_properties["downloadLink"] += f"?{qs}"
-
-        # parse metadata needing downloadLink
-        dl_path = Fields("downloadLink")
-        dl_path_from_root = Child(Root(), dl_path)
-        for param, mapping in self.config.metadata_mapping.items():
-            if dl_path in mapping or dl_path_from_root in mapping:
-                parsed_properties.update(
-                    properties_from_json(parsed_properties, {param: mapping})
-                )
+        product_id = (product_type or kwargs.get("dataset") or self.provider).upper()
 
-        # use product_type_config as default properties
-        parsed_properties = dict(
-            getattr(self.config, "product_type_config", {}),
-            **parsed_properties,
-        )
+        start = properties.get(START, NOT_AVAILABLE)
+        end = properties.get(END, NOT_AVAILABLE)
+
+        if start != NOT_AVAILABLE:
+            product_id += f"_{slugify(start)}"
+            if end != NOT_AVAILABLE:
+                product_id += f"_{slugify(end)}"
+
+        product_id += f"_{query_hash}"
+
+        properties["id"] = properties["title"] = product_id
+
+        # used by server mode to generate downloadlink href
+        properties["_dc_qs"] = quote_plus(qs)
 
         product = EOProduct(
             provider=self.provider,
             productType=product_type,
-            properties=parsed_properties,
+            properties=properties,
         )
 
         return [
@@ -1182,17 +1273,15 @@ class MeteoblueSearch(ECMWFSearch):
         return [response.json()]
 
     def build_query_string(
-        self, product_type: str, **kwargs: Any
+        self, product_type: str, query_dict: dict[str, Any]
     ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters
 
         :param product_type: product type id
-        :param kwargs: keyword arguments to be used in the query string
+        :param query_dict: keyword arguments to be used in the query string
         :return: formatted query params and encode query string
         """
-        return QueryStringSearch.build_query_string(
-            self, product_type=product_type, **kwargs
-        )
+        return QueryStringSearch.build_query_string(self, product_type, query_dict)
 
 
 class WekeoECMWFSearch(ECMWFSearch):
@@ -1256,25 +1345,3 @@ class WekeoECMWFSearch(ECMWFSearch):
         :return: list containing the results from the provider in json format
         """
         return QueryStringSearch.do_search(self, *args, **kwargs)
-
-    def build_query_string(
-        self, product_type: str, **kwargs: Any
-    ) -> tuple[dict[str, Any], str]:
-        """Build The query string using the search parameters
-
-        :param product_type: product type id
-        :param kwargs: keyword arguments to be used in the query string
-        :return: formatted query params and encode query string
-        """
-        # Reorder kwargs to make sure year/month/day/time if set overwrite default datetime.
-        # strip_quotes to remove duplicated quotes like "'1_1'" produced by convertors like to_geojson.
-        priority_keys = [
-            "startTimeFromAscendingNode",
-            "completionTimeFromAscendingNode",
-        ]
-        ordered_kwargs = {k: kwargs[k] for k in priority_keys if k in kwargs}
-        ordered_kwargs.update({k: strip_quotes(v) for k, v in kwargs.items()})
-
-        return QueryStringSearch.build_query_string(
-            self, product_type=product_type, **ordered_kwargs
-        )