File size: 8,269 Bytes
d5b6238 81a8217 d5b6238 81a8217 d5b6238 81a8217 d5b6238 81a8217 c2aa70d d5b6238 81a8217 d5b6238 c2aa70d d5b6238 9e15897 d5b6238 b2aa446 82f0f29 d5b6238 9e15897 b2aa446 9e15897 b2aa446 d5b6238 b2aa446 d5b6238 b2aa446 d5b6238 b2aa446 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | """First-connection choices, stored before a credential can dispatch a sync."""
from __future__ import annotations
def choices(provider):
if provider == "odoo":
import odoo_relational as rel
defaults = {"invoices", "orders", "order_lines", "stock_moves", "stock_valuation", "stock_quant"}
return ([{"key": "customer_data", "label": "Customers", "selected": True},
{"key": "product_data", "label": "Products", "selected": True},
{"key": rel.SALESPEOPLE_KEY, "label": "Odoo salespeople", "selected": True}]
+ [{"key": key, "label": label, "selected": bucket in defaults}
for bucket, key, label, _ in rel.TABLES])
if provider == "amazon_sp":
from harness import amazon_store
return [{"key": "ut_amzn_" + key, "label": key.replace("_", " ").capitalize(),
"selected": key in {"orders", "order_items", "inventory", "settlements"}}
for key in amazon_store.DATABASE_TABLES]
return []
def install_selection(rt, provider, selected, *, existing=False):
"""Explicit first-save intent only; preserve every pre-existing connector configuration.
This runs before add_entry, so an automatic runner cannot see a credential with all-on defaults.
A failed credential save leaves a safe, resumable choice document, never an unselected sync.
"""
offered = {row["key"] for row in choices(provider)}
if not offered or not isinstance(selected, list) or any(type(key) is not str for key in selected):
raise ValueError("Choose databases from this connector's setup list.")
if len(set(selected)) != len(selected) or not set(selected) <= offered:
raise ValueError("The database selection contains an unknown or duplicate database.")
if existing:
raise ValueError("This connection already exists. Change its databases in Settings.")
if provider == "odoo":
import odoo_relational as rel
key, member = rel.CONFIG_KEY, "grids"
if rel.ORDERS_KEY in selected:
selected = [*selected, rel.SALESPEOPLE_KEY]
else:
import connectors_amazon as amazon
key, member = amazon.ENABLEMENT_KEY, "databases"
def install(current):
if current is None:
current = {}
if not isinstance(current, dict):
raise ValueError("The stored connector settings are unavailable.")
# Only our own incomplete setup can be retried. Older selections are never repurposed.
if current and current.get("initialSetup") != "selected":
raise ValueError("This workspace already has database choices. Use Settings to change them.")
return {**current, member: {name: name in selected for name in sorted(offered)},
"initialSetup": "selected"}
rt.update(key, install, flush="sync")
def seal_selection(rt, provider):
from odoo_relational import CONFIG_KEY
from connectors_amazon import ENABLEMENT_KEY
key = CONFIG_KEY if provider == "odoo" else ENABLEMENT_KEY
def seal(current):
if not isinstance(current, dict) or current.get("initialSetup") != "selected":
raise ValueError("The first-connection selection was not saved.")
return {**current, "initialSetup": "configured"}
rt.update(key, seal, flush="sync")
def ensure_salespeople_selection(rt, *, namespace=None):
"""Selected orders require their native discovered res.users link target."""
import odoo_relational as rel
orders = rel.table_key_for(rel.ORDERS_KEY, namespace)
staff = rel.table_key_for(rel.SALESPEOPLE_KEY, namespace)
def admit(current):
config = dict(current or {})
grids = dict(config.get("grids") or {})
default = namespace is not None or config.get("initialSetup") not in {"selected", "configured"}
if grids.get(orders, default) and grids.get(staff) is not True:
config["grids"] = {**grids, staff: True}
return config
current = rt.get(rel.CONFIG_KEY)
if admit(current) != (current or {}):
rt.update(rel.CONFIG_KEY, admit, flush="sync")
#: Every mirror table the product pool reads. A selected tenant with product data syncs all of them.
PRODUCT_DATA_ENTITIES = ("product_product", "product_pricelist", "product_pricelist_item",
"product_tag", "stock_quant", "stock_location", "sale_order",
"sale_order_line", "res_partner")
def selected_mirror_entities(rt):
"""None preserves old sync policy; an explicit setup limits source pulls to selected dependencies."""
import odoo_relational as rel
config = rt.get(rel.CONFIG_KEY)
if isinstance(config, dict) and config:
ensure_salespeople_selection(rt)
config = rt.get(rel.CONFIG_KEY)
if not isinstance(config, dict) or config.get("initialSetup") not in {"selected", "configured"}:
return None
grids = config.get("grids")
if not isinstance(grids, dict) or any(type(v) is not bool for v in grids.values()):
raise ValueError("The first-connection database selection is unavailable.")
import routes_odoo_tables as route
from harness import datastore
sources = route._odoo_sources()
entities = set()
for key, enabled in grids.items():
if not enabled:
continue
if key == "customer_data":
entities.add("res_partner")
continue
if key == "product_data":
# The product pool reads only the mirror, so its data pulls every table the pool reads.
entities.update(PRODUCT_DATA_ENTITIES)
continue
if key not in sources:
continue
source = sources[key]
if source.get("table"):
entities.add(source["table"])
entities.update(source.get("tables", {}).values())
if source.get("needs_excluded"):
entities.add("res_partner")
return sorted(entities & set(datastore.ENTITIES))
def mirror_cursor(rt, table_key=None):
"""A source waits for its first sync before a reader can use its mirror."""
from harness import datastore
if rt is None:
return datastore.ro_con()
rt.assert_datastore_matches()
mirror = rt.mirror_handle()
if str(table_key or "").startswith("ut_odoo_model_"):
import odoo_relational as rel
config = rt.get(rel.CONFIG_KEY)
if not config.get("grids", {}).get(table_key, False):
raise RuntimeError("Enable this database in connection settings before reading it.")
cur = mirror.ro_cursor()
try:
if rel.dynamic_model_source(cur, table_key, tenant_key=rt.key) is None:
raise RuntimeError("The selected database is completing its first sync. Try again shortly.")
return cur
except Exception:
cur.close()
raise
entities = selected_mirror_entities(rt)
if entities is None:
import odoo_relational as rel
if (table_key is not None
and rel.base_table_key(table_key) in rel.stock_source_specs()
and not mirror.entity_live("stock_quant")):
raise RuntimeError("The selected database is completing its first sync. Try again shortly.")
return mirror.ro_con()
if table_key is not None:
import odoo_relational as rel
import routes_odoo_tables as route
config = rt.get(rel.CONFIG_KEY)
if not config.get("grids", {}).get(table_key, False):
raise RuntimeError("Enable this database in connection settings before reading it.")
source = route._odoo_sources().get(table_key)
if source is None:
return mirror.ro_con()
entities = set(source.get("tables", {}).values())
if source.get("table"):
entities.add(source["table"])
if source.get("needs_excluded"):
entities.add("res_partner")
if any(not mirror.entity_live(key) for key in entities):
raise RuntimeError("The selected database is completing its first sync. Try again shortly.")
# An empty first selection has no readers to run and need not create a mirror file.
return mirror.ro_cursor() if entities else None
|