432 lines
15 KiB
Python
432 lines
15 KiB
Python
"""Field validation. Every message shown to the user is Norwegian Nynorsk.
|
|
|
|
Functions return a (value, error) pair where exactly one of the two is None.
|
|
`validate_transaction`, `validate_market` and `validate_settings` return the
|
|
parsed object together with a dict of {field: message}.
|
|
"""
|
|
|
|
from datetime import datetime
|
|
|
|
import auth
|
|
import rates
|
|
|
|
TRANSACTION_TYPES = (
|
|
"trade",
|
|
"income",
|
|
"spend",
|
|
"loss",
|
|
"transfer_out",
|
|
"transfer_in",
|
|
"gift_received",
|
|
"gift_given",
|
|
"admin_cost",
|
|
)
|
|
# transfer_in is generated by Skuld and can never be chosen in the form.
|
|
SELECTABLE_TYPES = tuple(name for name in TRANSACTION_TYPES if name != "transfer_in")
|
|
MARKET_KINDS = ("exchange", "wallet", "other")
|
|
LOT_METHODS = ("FIFO", "LIFO", "HIFO")
|
|
|
|
SATS_FIELDS = ("leg_in_sats", "leg_out_sats", "fee_sats")
|
|
# fee_ore is deliberately absent: a fee is entered in sats only, and the column
|
|
# stays 0 (docs/spec.md section 3.2).
|
|
ORE_FIELDS = ("leg_in_ore", "leg_out_ore", "value_ore")
|
|
|
|
_REQUIRED = {
|
|
"income": (
|
|
("leg_in_sats", "Fyll ut antal sats du fekk."),
|
|
("value_ore", "Fyll ut prisen i kroner."),
|
|
),
|
|
"spend": (
|
|
("leg_out_sats", "Fyll ut antal sats du betalte med."),
|
|
("value_ore", "Fyll ut utgangsverdien i kroner."),
|
|
),
|
|
"loss": (("leg_out_sats", "Fyll ut antal sats som gjekk tapt."),),
|
|
"gift_received": (
|
|
("leg_in_sats", "Fyll ut antal sats du fekk."),
|
|
("value_ore", "Fyll ut prisen i kroner."),
|
|
),
|
|
"gift_given": (("leg_out_sats", "Fyll ut antal sats du gav."),),
|
|
"admin_cost": (("leg_out_sats", "Fyll ut kostnaden i sats."),),
|
|
}
|
|
|
|
_ALLOWED_LEGS = {
|
|
"trade": ("leg_in_sats", "leg_in_ore", "leg_out_sats", "leg_out_ore"),
|
|
"income": ("leg_in_sats",),
|
|
"spend": ("leg_out_sats",),
|
|
"loss": ("leg_out_sats",),
|
|
"transfer_out": ("leg_out_sats",),
|
|
"gift_received": ("leg_in_sats",),
|
|
"gift_given": ("leg_out_sats",),
|
|
"admin_cost": ("leg_out_sats",),
|
|
}
|
|
|
|
NO_FEE_TYPES = ("gift_received", "admin_cost")
|
|
|
|
|
|
def _blank(value):
|
|
return value is None or (isinstance(value, str) and not value.strip())
|
|
|
|
|
|
def _boolean(value, default=1):
|
|
"""Return 1 or 0, or None when the value cannot be read as a flag."""
|
|
if _blank(value):
|
|
return default
|
|
if isinstance(value, bool):
|
|
return 1 if value else 0
|
|
if isinstance(value, int) and value in (0, 1):
|
|
return value
|
|
text = str(value).strip().lower()
|
|
if text in ("1", "true", "ja", "on"):
|
|
return 1
|
|
if text in ("0", "false", "nei", "off"):
|
|
return 0
|
|
return None
|
|
|
|
|
|
def validate_date(value):
|
|
"""Return a stored date, 'YYYY-MM-DD'."""
|
|
if _blank(value):
|
|
return None, "Dato må fyllast ut."
|
|
text = str(value).strip()
|
|
try:
|
|
return datetime.strptime(text, "%Y-%m-%d").strftime("%Y-%m-%d"), None
|
|
except ValueError:
|
|
return None, "Datoen må vere på forma ÅÅÅÅ-MM-DD, t.d. 2025-01-31."
|
|
|
|
|
|
def validate_sats(value, optional=False):
|
|
"""Return a whole number of sats from what the owner typed."""
|
|
if _blank(value):
|
|
return (None, None) if optional else (None, "Antal må fyllast ut.")
|
|
try:
|
|
sats = rates.parse_sats(value)
|
|
except ValueError:
|
|
return None, "Antal må vere eit heiltal i sats."
|
|
if sats <= 0:
|
|
return None, "Antal må vere større enn null."
|
|
return sats, None
|
|
|
|
|
|
def validate_ore(value, optional=False):
|
|
"""Return an amount of øre from a NOK amount written by the user."""
|
|
if _blank(value):
|
|
return (None, None) if optional else (None, "Beløp må fyllast ut.")
|
|
try:
|
|
ore = rates.nok_to_ore(value)
|
|
except ValueError as error:
|
|
if "2 decimals" in str(error):
|
|
return None, "Beløp kan ha høgst 2 desimalar."
|
|
return None, "Beløp må vere eit tal, t.d. 200 000."
|
|
if ore <= 0:
|
|
return None, "Beløp må vere større enn null."
|
|
return ore, None
|
|
|
|
|
|
def validate_type(value):
|
|
"""Return a transaction type that the owner may choose."""
|
|
if _blank(value):
|
|
return None, "Type må veljast."
|
|
text = str(value).strip()
|
|
if text == "transfer_in":
|
|
return None, "Overføring inn kan ikkje veljast; ho vert laga automatisk."
|
|
if text not in TRANSACTION_TYPES:
|
|
return None, "Ukjend type."
|
|
return text, None
|
|
|
|
|
|
def validate_market_id(value, markets, field="market_id"):
|
|
"""Return an account id that exists."""
|
|
if _blank(value):
|
|
return None, "Vel konto."
|
|
try:
|
|
market_id = int(value)
|
|
except (TypeError, ValueError):
|
|
return None, "Ukjend konto."
|
|
if market_id not in markets:
|
|
return None, "Ukjend konto."
|
|
return market_id, None
|
|
|
|
|
|
def validate_lot_picks(value):
|
|
"""Return the hand-picked lots as a list of dicts, in the given order."""
|
|
if _blank(value):
|
|
return [], None
|
|
if not isinstance(value, list):
|
|
return None, "Parti-utvalet må vere ei liste."
|
|
picks = []
|
|
for item in value:
|
|
if not isinstance(item, dict):
|
|
return None, "Parti-utvalet er ugyldig."
|
|
try:
|
|
origin_tx_id = int(item.get("origin_tx_id"))
|
|
origin_seq = int(item.get("origin_seq") or 0)
|
|
sats = int(item.get("sats"))
|
|
except (TypeError, ValueError):
|
|
return None, "Parti-utvalet er ugyldig."
|
|
if origin_tx_id <= 0 or origin_seq < 0 or sats <= 0:
|
|
return None, "Parti-utvalet er ugyldig."
|
|
picks.append(
|
|
{"origin_tx_id": origin_tx_id, "origin_seq": origin_seq, "sats": sats}
|
|
)
|
|
return picks, None
|
|
|
|
|
|
def _check_trade(legs, errors):
|
|
received = [name for name in ("leg_in_sats", "leg_in_ore") if legs[name] is not None]
|
|
given = [name for name in ("leg_out_sats", "leg_out_ore") if legs[name] is not None]
|
|
if len(received) > 1 or len(given) > 1:
|
|
errors["leg_in_ore" if len(received) > 1 else "leg_out_ore"] = (
|
|
"Berre éi side kan førast i kvar valuta."
|
|
)
|
|
return
|
|
if not received or not given:
|
|
errors["leg_in_sats" if not received else "leg_out_sats"] = (
|
|
"Fyll ut både den sida du får og den sida du gjev."
|
|
)
|
|
return
|
|
if received[0].endswith("_sats") == given[0].endswith("_sats"):
|
|
errors[given[0]] = (
|
|
"For ein handel må den eine sida vere i sats og den andre i kroner."
|
|
)
|
|
|
|
|
|
def _check_admin_cost(legs, errors):
|
|
"""admin_cost takes sats only and stands on its own (docs/spec.md section 3.10)."""
|
|
if legs["leg_out_sats"] is None or legs["leg_out_ore"] is not None:
|
|
errors["leg_out_sats"] = "Fyll ut kostnaden i sats."
|
|
|
|
|
|
def _check_fee(legs, tx_type, errors):
|
|
if tx_type in NO_FEE_TYPES:
|
|
for name in ("fee_sats", "fee_ore"):
|
|
if legs[name] is not None:
|
|
errors[name] = "Denne typen tek ikkje avgift."
|
|
return
|
|
if legs["fee_sats"] is not None and legs["fee_ore"] is not None:
|
|
errors["fee_ore"] = "Avgifta kan berre førast i éin valuta."
|
|
return
|
|
fee_sats = legs["fee_sats"] or 0
|
|
if not fee_sats:
|
|
return
|
|
limit = legs["leg_in_sats"] if legs["leg_in_sats"] is not None else legs["leg_out_sats"]
|
|
if limit is not None and fee_sats >= limit:
|
|
errors["fee_sats"] = "Avgifta kan ikkje vere like stor som eller større enn antalet."
|
|
|
|
|
|
def validate_transaction(payload, markets):
|
|
"""Return (transaction, errors) for a transaction to be stored.
|
|
|
|
`markets` maps account id to its row, so that the taxable flag can default
|
|
from the account and a transfer destination can be checked.
|
|
"""
|
|
data = payload if isinstance(payload, dict) else {}
|
|
errors = {}
|
|
transaction = {}
|
|
|
|
date, error = validate_date(data.get("date"))
|
|
if error:
|
|
errors["date"] = error
|
|
transaction["date"] = date
|
|
|
|
tx_type, error = validate_type(data.get("type"))
|
|
if error:
|
|
errors["type"] = error
|
|
transaction["type"] = tx_type
|
|
|
|
market_id = None
|
|
if tx_type == "admin_cost":
|
|
# admin_cost stands on its own, so there is no account to look up.
|
|
market_id = None
|
|
else:
|
|
market_id, error = validate_market_id(data.get("market_id"), markets)
|
|
if error:
|
|
errors["market_id"] = error
|
|
transaction["market_id"] = market_id
|
|
|
|
# The flag defaults from the account; admin_cost has none, so it defaults to 1.
|
|
account = markets.get(market_id) if market_id is not None else None
|
|
taxable = _boolean(data.get("taxable"), account["taxable"] if account else 1)
|
|
if taxable is None:
|
|
errors["taxable"] = "Skattepliktig må vere av eller på."
|
|
transaction["taxable"] = 1 if taxable is None else taxable
|
|
|
|
note = data.get("note")
|
|
transaction["note"] = "" if note is None else str(note).strip()
|
|
|
|
legs = {}
|
|
for name in SATS_FIELDS:
|
|
value, error = validate_sats(data.get(name), optional=True)
|
|
if error:
|
|
errors[name] = error
|
|
legs[name] = value
|
|
for name in ORE_FIELDS:
|
|
value, error = validate_ore(data.get(name), optional=True)
|
|
if error:
|
|
errors[name] = error
|
|
legs[name] = value
|
|
|
|
to_market_id = None
|
|
if tx_type is not None:
|
|
if tx_type == "admin_cost":
|
|
_check_admin_cost(legs, errors)
|
|
if tx_type == "trade":
|
|
_check_trade(legs, errors)
|
|
else:
|
|
for name, message in _REQUIRED.get(tx_type, ()):
|
|
if legs[name] is None and name not in errors:
|
|
errors[name] = message
|
|
for name in SATS_FIELDS + ORE_FIELDS:
|
|
if name.startswith("leg_") and legs[name] is not None:
|
|
if name not in _ALLOWED_LEGS.get(tx_type, ()):
|
|
errors[name] = "Feltet høyrer ikkje til denne typen."
|
|
if tx_type == "transfer_out":
|
|
to_market_id, error = validate_market_id(
|
|
data.get("to_market_id"), markets, "to_market_id"
|
|
)
|
|
if error:
|
|
errors["to_market_id"] = error
|
|
elif to_market_id == market_id:
|
|
errors["to_market_id"] = "Overføringa må gå til ein annan konto."
|
|
_check_fee(legs, tx_type, errors)
|
|
|
|
transaction["leg_in_sats"] = legs["leg_in_sats"]
|
|
transaction["leg_in_ore"] = legs["leg_in_ore"]
|
|
transaction["leg_out_sats"] = legs["leg_out_sats"]
|
|
transaction["leg_out_ore"] = legs["leg_out_ore"]
|
|
transaction["value_ore"] = legs["value_ore"]
|
|
transaction["fee_sats"] = legs["fee_sats"] or 0
|
|
transaction["fee_ore"] = legs["fee_ore"] or 0
|
|
transaction["to_market_id"] = to_market_id
|
|
return transaction, errors
|
|
|
|
|
|
def validate_market(payload, markets, current_id=None):
|
|
"""Return (market, errors) for an account to be stored."""
|
|
data = payload if isinstance(payload, dict) else {}
|
|
errors = {}
|
|
market = {}
|
|
|
|
name = "" if _blank(data.get("name")) else str(data.get("name")).strip()
|
|
if not name:
|
|
errors["name"] = "Namn må fyllast ut."
|
|
elif any(
|
|
row["name"].lower() == name.lower() and row["id"] != current_id
|
|
for row in markets.values()
|
|
):
|
|
errors["name"] = "Namnet er alt i bruk."
|
|
market["name"] = name
|
|
|
|
kind = "" if _blank(data.get("kind")) else str(data.get("kind")).strip()
|
|
if kind not in MARKET_KINDS:
|
|
errors["kind"] = "Vel type: børs, lommebok eller anna."
|
|
market["kind"] = kind
|
|
|
|
taxable = _boolean(data.get("taxable"), 1)
|
|
if taxable is None:
|
|
errors["taxable"] = "Skattepliktig må vere av eller på."
|
|
market["taxable"] = 1 if taxable is None else taxable
|
|
|
|
custody_market_id = None
|
|
if not _blank(data.get("custody_market_id")):
|
|
custody_market_id, error = validate_market_id(
|
|
data.get("custody_market_id"), markets, "custody_market_id"
|
|
)
|
|
if error:
|
|
errors["custody_market_id"] = error
|
|
elif custody_market_id == current_id:
|
|
errors["custody_market_id"] = "Ein konto kan ikkje ha seg sjølv som oppbevarar."
|
|
market["custody_market_id"] = custody_market_id
|
|
|
|
note = data.get("note")
|
|
market["note"] = "" if note is None else str(note).strip()
|
|
|
|
sort_order = data.get("sort_order")
|
|
try:
|
|
market["sort_order"] = 0 if _blank(sort_order) else int(sort_order)
|
|
except (TypeError, ValueError):
|
|
errors["sort_order"] = "Rekkjefølgja må vere eit heiltal."
|
|
market["sort_order"] = 0
|
|
|
|
archived = _boolean(data.get("archived"), 0)
|
|
if archived is None:
|
|
errors["archived"] = "Arkivert må vere av eller på."
|
|
market["archived"] = 0 if archived is None else archived
|
|
|
|
return market, errors
|
|
|
|
|
|
def validate_settings(payload):
|
|
"""Return (settings, errors) for the settings to be stored."""
|
|
data = payload if isinstance(payload, dict) else {}
|
|
errors = {}
|
|
settings = {}
|
|
|
|
for key in ("tax_rate_percent", "wealth_tax_rate_percent"):
|
|
if key not in data:
|
|
continue
|
|
try:
|
|
percent = int(str(data[key]).strip().replace(",", "."))
|
|
except (TypeError, ValueError):
|
|
errors[key] = "Satsen må vere eit heiltal mellom 0 og 100."
|
|
continue
|
|
if percent < 0 or percent > 100:
|
|
errors[key] = "Satsen må vere eit heiltal mellom 0 og 100."
|
|
continue
|
|
settings[key] = str(percent)
|
|
|
|
if "lot_method" in data:
|
|
method = str(data["lot_method"]).strip().upper()
|
|
if method not in LOT_METHODS:
|
|
errors["lot_method"] = "Vel metoden FIFO, LIFO eller HIFO."
|
|
else:
|
|
settings["lot_method"] = method
|
|
|
|
for key in ("wealth_tax_enabled", "deduct_admin_costs"):
|
|
if key not in data:
|
|
continue
|
|
flag = _boolean(data[key])
|
|
if flag is None:
|
|
errors[key] = "Verdien må vere av eller på."
|
|
else:
|
|
settings[key] = str(flag)
|
|
|
|
if "wealth_tax_threshold_ore" in data:
|
|
text = str(data["wealth_tax_threshold_ore"] or "").strip()
|
|
if not text:
|
|
settings["wealth_tax_threshold_ore"] = "0"
|
|
else:
|
|
try:
|
|
ore = rates.nok_to_ore(text)
|
|
except ValueError as error:
|
|
errors["wealth_tax_threshold_ore"] = (
|
|
"Beløp kan ha høgst 2 desimalar."
|
|
if "2 decimals" in str(error)
|
|
else "Beløp må vere eit tal, t.d. 1 000 000."
|
|
)
|
|
else:
|
|
if ore < 0:
|
|
errors["wealth_tax_threshold_ore"] = "Botnen kan ikkje vere negativ."
|
|
else:
|
|
settings["wealth_tax_threshold_ore"] = str(ore)
|
|
|
|
if "year_end_price_source" in data:
|
|
settings["year_end_price_source"] = str(data["year_end_price_source"]).strip()
|
|
|
|
return settings, errors
|
|
|
|
|
|
def validate_username(value):
|
|
"""Return a username."""
|
|
if _blank(value):
|
|
return None, "Brukarnamn må fyllast ut."
|
|
return str(value).strip(), None
|
|
|
|
|
|
def validate_password(value):
|
|
"""Return a password that is long enough."""
|
|
if _blank(value):
|
|
return None, "Passord må fyllast ut."
|
|
if len(str(value)) < auth.MIN_PASSWORD_LENGTH:
|
|
return None, "Passordet må ha minst %d teikn." % auth.MIN_PASSWORD_LENGTH
|
|
return str(value), None
|