Odoo18-Base/addons/spreadsheet/utils/validate_data.py
2025-01-06 10:57:38 +07:00

201 lines
6.7 KiB
Python

from collections import defaultdict
from itertools import chain
import json
import re
markdown_link_regex = r"^\[([^\[]+)\]\((.+)\)$"
xml_id_url_prefix = "odoo://ir_menu_xml_id/"
odoo_view_link_prefix = "odoo://view/"
def odoo_charts(data):
"""return all odoo chart definition in the spreadsheet"""
figures = []
for sheet in data.get("sheets", []):
figures += [
dict(figure["data"], id=figure["id"])
for figure in sheet.get("figures", [])
if figure["tag"] == "chart" and figure["data"]["type"].startswith("odoo_")
]
return figures
def links_urls(data):
"""return all markdown links in cells"""
urls = []
link_prefix = "odoo://view/"
for sheet in data.get("sheets", []):
for cell in sheet.get("cells", {}).values():
content = cell.get("content", "")
match = re.match(markdown_link_regex, content)
if match and match.group(2).startswith(link_prefix):
urls.append(match.group(2))
return urls
def odoo_view_links(data):
"""return all view definitions embedded in link cells.
urls looks like odoo://view/{... view data...}
"""
return [
json.loads(url[len(odoo_view_link_prefix):])
for url in links_urls(data)
if url.startswith(odoo_view_link_prefix)
]
def remove_aggregator(field_name):
"""remove the group operator
>>> remove_aggregator("amount:sum")
>>> "amount"
"""
return field_name.split(":")[0]
def domain_fields(domain):
"""return all field names used in the domain"""
fields = []
for leaf in domain:
if len(leaf) == 3:
fields.append(leaf[0])
return fields
def pivot_measure_fields(pivot):
measures = [
measure if isinstance(measure, str)
# "field" has been renamed to "name" and "name" to "fieldName"
else measure["field"] if "field" in measure
else measure["name"] if "name" in measure
else measure["fieldName"]
for measure in pivot["measures"]
if "computedBy" not in measure
]
return [
measure
for measure in measures
if measure != "__count"
]
def pivot_fields(pivot):
"""return all field names used in a pivot definition"""
model = pivot["model"]
fields = set(
# colGroupBys and rowGroupBys were renamed to columns and rows, name to fieldName
pivot.get("colGroupBys", []) + [col.get("name", col.get("fieldName")) for col in pivot.get("columns", [])]
+ pivot.get("rowGroupBys", []) + [row.get("name", row.get("fieldName")) for row in pivot.get("rows", [])]
+ pivot_measure_fields(pivot)
+ domain_fields(pivot["domain"])
)
measure = pivot.get("sortedColumn") and pivot["sortedColumn"]["measure"]
if measure and measure != "__count":
fields.add(measure)
return model, fields
def list_order_fields(list_definition):
return [order["name"] for order in list_definition["orderBy"]]
def list_fields(list_definition):
"""return all field names used in a list definitions"""
model = list_definition["model"]
fields = set(
list_definition["columns"]
+ list_order_fields(list_definition)
+ domain_fields(list_definition["domain"])
)
return model, fields
def chart_fields(chart):
"""return all field names used in a chart definitions"""
model = chart["metaData"]["resModel"]
fields = set(
chart["metaData"]["groupBy"]
+ chart["searchParams"]["groupBy"]
+ domain_fields(chart["searchParams"]["domain"])
)
measure = chart["metaData"]["measure"]
if measure != "__count":
fields.add(measure)
return model, fields
def filter_fields(data):
"""return all field names used in global filter definitions"""
fields_by_model = defaultdict(set)
charts = odoo_charts(data)
odoo_version = data.get("odooVersion", 1)
if odoo_version < 5:
for filter_definition in data.get("globalFilters", []):
for pivot_id, matching in filter_definition.get("pivotFields", dict()).items():
model = data["pivots"][pivot_id]["model"]
fields_by_model[model].add(matching["field"])
for list_id, matching in filter_definition.get("listFields", dict()).items():
model = data["lists"][list_id]["model"]
fields_by_model[model].add(matching["field"])
for chart_id, matching in filter_definition.get("graphFields", dict()).items():
chart = next((chart for chart in charts if chart["id"] == chart_id), None)
model = chart["metaData"]["resModel"]
fields_by_model[model].add(matching["field"])
else:
for pivot in data["pivots"].values():
if pivot.get("type", "ODOO") == "ODOO":
model = pivot["model"]
field = pivot.get("fieldMatching", {}).get("chain")
if field:
fields_by_model[model].add(field)
for _list in data["lists"].values():
model = _list["model"]
field = _list.get("fieldMatching", {}).get("chain")
if field:
fields_by_model[model].add(field)
for chart in charts:
model = chart["metaData"]["resModel"]
field = chart.get("fieldMatching", {}).get("chain")
if field:
fields_by_model[model].add(field)
return dict(fields_by_model)
def odoo_view_fields(view):
return view["action"]["modelName"], set(domain_fields(view["action"]["domain"]))
def extract_fields(extract_fn, items):
fields_by_model = defaultdict(set)
for item in items:
model, fields = extract_fn(item)
fields_by_model[model] |= {remove_aggregator(field) for field in fields}
return dict(fields_by_model)
def fields_in_spreadsheet(data):
"""return all fields, grouped by model, used in the spreadsheet"""
odoo_pivots = (pivot for pivot in data.get("pivots", dict()).values() if pivot.get("type", "ODOO") == "ODOO")
all_fields = chain(
extract_fields(list_fields, data.get("lists", dict()).values()).items(),
extract_fields(pivot_fields, odoo_pivots).items(),
extract_fields(chart_fields, odoo_charts(data)).items(),
extract_fields(odoo_view_fields, odoo_view_links(data)).items(),
filter_fields(data).items(),
)
fields_by_model = defaultdict(set)
for model, fields in all_fields:
fields_by_model[model] |= fields
return dict(fields_by_model)
def menus_xml_ids_in_spreadsheet(data):
return set(data.get("chartOdooMenusReferences", {}).values()) | {
url[len(xml_id_url_prefix):]
for url in links_urls(data)
if url.startswith(xml_id_url_prefix)
}