mirror of
https://github.com/lrnselfreliance/wrolpi.git
synced 2026-11-19 14:36:22 -05:00
Legacy inventory items stored date fields as Unix epoch seconds. The table showed the raw numbers, and sorting and expired highlighting did not treat them as dates. - Frontend parses date values as YYYY-MM-DD or legacy epoch seconds; display, mobile view, export, search, sort and the expired check all use calendar dates with no timezone shift. - The legacy migration converts epoch seconds to YYYY-MM-DD, and import repairs already-migrated files once. - Jest runs with a pinned timezone; the expiry tests pass under any process timezone. Closes #41 Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
204 lines
8.4 KiB
Python
204 lines
8.4 KiB
Python
"""Default field schemas and category lists for the inventory module.
|
|
|
|
An inventory's ``type`` only seeds its initial ``fields`` — afterwards the user owns the schema and may
|
|
add/remove/reorder/retype fields freely. Quantity-field default units use mathjs-compatible names (e.g. ``lb``,
|
|
not ``pound``); all unit math happens in the frontend via mathjs.
|
|
"""
|
|
import re
|
|
from datetime import datetime, timezone
|
|
|
|
# Supported field types. The backend treats every value as an opaque string/number; only the frontend interprets
|
|
# `quantity` (magnitude + `<key>_unit`), `date`, `select` (enum `options`), `location`, and `calories` (a number of
|
|
# kcal-per-unit that the Summary's ration estimate detects by type).
|
|
FIELD_TYPES = ('text', 'number', 'quantity', 'date', 'select', 'location', 'calories')
|
|
|
|
|
|
_DATE_ONLY_RE = re.compile(r'^\d{4}-\d{2}-\d{2}$')
|
|
# Legacy inventory dates were stored as Unix epoch seconds (optionally ``str(float)``, e.g. ``1893456000.0``).
|
|
_EPOCH_SECONDS_RE = re.compile(r'^\d{9,10}(\.0+)?$')
|
|
|
|
|
|
def normalize_date_value(value):
|
|
"""Normalize a ``date``-field value: legacy epoch seconds become ``YYYY-MM-DD`` (UTC); anything else is
|
|
returned unchanged (stripped if a string)."""
|
|
if value is None or value == '':
|
|
return value
|
|
s = value.strip() if isinstance(value, str) else str(value)
|
|
if _DATE_ONLY_RE.match(s):
|
|
return s
|
|
if _EPOCH_SECONDS_RE.match(s):
|
|
return datetime.fromtimestamp(int(float(s)), tz=timezone.utc).strftime('%Y-%m-%d')
|
|
return s
|
|
|
|
|
|
def date_field_keys(fields_) -> set:
|
|
"""The keys of every ``date``-type field in a field schema."""
|
|
return {f['key'] for f in fields_ or [] if isinstance(f, dict) and f.get('type') == 'date'}
|
|
|
|
|
|
def normalize_item_dates(items: list, fields_: list) -> bool:
|
|
"""Normalize every date-field value of ``items`` in place. Returns True if anything changed."""
|
|
changed = False
|
|
for key in date_field_keys(fields_):
|
|
for item in items or []:
|
|
if isinstance(item, dict) and key in item:
|
|
new = normalize_date_value(item[key])
|
|
if new != item[key]:
|
|
item[key] = new
|
|
changed = True
|
|
return changed
|
|
|
|
|
|
def _field(key, label, type_, order, **kwargs):
|
|
d = dict(key=key, label=label, type=type_, order=order)
|
|
d.update({k: v for k, v in kwargs.items() if v is not None})
|
|
return d
|
|
|
|
|
|
# Food storage categories (subcategory, category). Used to seed the `category` select field's options and for
|
|
# category suggestions in the UI.
|
|
DEFAULT_FOOD_CATEGORIES = [
|
|
('salt', 'cooking ingredients'),
|
|
('dry milk', 'dairy'),
|
|
('evaporated milk', 'dairy'),
|
|
('freeze dried', 'dairy'),
|
|
('shortening', 'fats'),
|
|
('vegetable oil', 'fats'),
|
|
('canned', 'fruits'),
|
|
('dehydrated', 'fruits'),
|
|
('freeze-dried', 'fruits'),
|
|
('corn meal', 'grains'),
|
|
('flour', 'grains'),
|
|
('oats', 'grains'),
|
|
('pasta', 'grains'),
|
|
('rice', 'grains'),
|
|
('wheat', 'grains'),
|
|
('dry beans', 'legumes'),
|
|
('lentils', 'legumes'),
|
|
('canned', 'meats'),
|
|
('dried', 'meats'),
|
|
('freeze dried', 'meals'),
|
|
('brown sugar', 'sugars'),
|
|
('corn syrup', 'sugars'),
|
|
('honey', 'sugars'),
|
|
('juice mix', 'sugars'),
|
|
('white sugar', 'sugars'),
|
|
('canned', 'vegetables'),
|
|
('dehydrated', 'vegetables'),
|
|
('freeze dried', 'vegetables'),
|
|
('water', 'water'),
|
|
('bottled', 'water'),
|
|
('barrel', 'water'),
|
|
]
|
|
|
|
_FOOD_CATEGORY_OPTIONS = sorted({category for _, category in DEFAULT_FOOD_CATEGORIES})
|
|
|
|
DEFAULT_FIELD_SETS = {
|
|
# `mobile=True` marks the columns shown in the condensed, read-only portrait-mobile view; the user can change
|
|
# which fields are mobile in the field-schema editor.
|
|
'food': [
|
|
_field('brand', 'Brand', 'text', 0),
|
|
_field('name', 'Name', 'text', 1, required=True, mobile=True),
|
|
_field('category', 'Category', 'select', 2, options=_FOOD_CATEGORY_OPTIONS),
|
|
_field('subcategory', 'Subcategory', 'text', 3, mobile=True),
|
|
_field('item_size', 'Size', 'quantity', 4, unit='lb', mobile=True),
|
|
_field('count', 'Count', 'number', 5, mobile=True),
|
|
_field('calories', 'kcal per unit', 'calories', 6),
|
|
_field('expiration_date', 'Expires', 'date', 7),
|
|
],
|
|
'fuel': [
|
|
_field('name', 'Name', 'text', 0, required=True, mobile=True),
|
|
_field('fuel_type', 'Fuel Type', 'select', 1,
|
|
options=['gasoline', 'diesel', 'propane', 'kerosene', 'oil'], mobile=True),
|
|
_field('container', 'Container', 'text', 2),
|
|
_field('item_size', 'Size', 'quantity', 3, unit='gallon', mobile=True),
|
|
_field('count', 'Count', 'number', 4, mobile=True),
|
|
_field('purchase_date', 'Purchased', 'date', 5),
|
|
_field('location', 'Location', 'location', 6),
|
|
],
|
|
'tool': [
|
|
_field('name', 'Name', 'text', 0, required=True, mobile=True),
|
|
_field('brand', 'Brand', 'text', 1),
|
|
_field('category', 'Category', 'select', 2,
|
|
options=['hand', 'power', 'garden', 'automotive', 'measuring', 'safety'], mobile=True),
|
|
_field('count', 'Count', 'number', 3, mobile=True),
|
|
_field('condition', 'Condition', 'select', 4, options=['new', 'good', 'worn', 'broken']),
|
|
_field('location', 'Location', 'location', 5, mobile=True),
|
|
_field('notes', 'Notes', 'text', 6),
|
|
],
|
|
}
|
|
|
|
# The first/default type used when a type is not specified (e.g. legacy migration).
|
|
DEFAULT_TYPE = 'food'
|
|
|
|
|
|
# Recommended package counts for a one-adult, one-year (~3,000 kcal/day) food supply, keyed by the shipped
|
|
# food-catalog id (see catalog_defaults.yaml). Transcribed from the same "One-Year Emergency Food Supply for One
|
|
# Adult" source list. `seed_defaults()` joins these counts with the catalog's per-package data to populate the
|
|
# example "Food Storage" inventory on a fresh install (e.g. id 1 = white rice: 70 lb stored as 14 x 5 lb bags).
|
|
RECOMMENDED_ONE_YEAR_FOOD_COUNTS = {
|
|
# Grains
|
|
1: 14, 2: 14, 3: 6, 4: 4, 5: 4, 6: 36, 7: 4, 8: 12,
|
|
# Dairy
|
|
9: 12, 10: 24, 11: 3,
|
|
# Fats
|
|
12: 12, 13: 5, 14: 2, 15: 12,
|
|
# Sugars
|
|
16: 5, 17: 12, 18: 12, 19: 6, 20: 6, 21: 9, 22: 8, 23: 12,
|
|
# Meats
|
|
24: 48, 25: 12, 26: 24, 27: 24, 28: 24,
|
|
# Meals (prepared / canned)
|
|
29: 12, 30: 24, 31: 24, 32: 24, 33: 24, 34: 18, 35: 24,
|
|
# Legumes
|
|
36: 96,
|
|
# Vegetables
|
|
37: 24, 38: 36, 39: 12, 40: 180, 41: 12,
|
|
# Fruits
|
|
42: 48,
|
|
# Cooking ingredients
|
|
43: 12, 44: 12, 45: 24, 46: 6, 47: 12, 48: 24, 49: 6, 50: 12, 51: 12, 52: 12,
|
|
53: 2, 54: 2, 55: 2, 56: 1, 57: 2, 58: 1, 59: 48, 60: 48,
|
|
}
|
|
|
|
# Per-package fields copied from a food-catalog entry onto a seeded inventory item (its `count` is added from
|
|
# RECOMMENDED_ONE_YEAR_FOOD_COUNTS).
|
|
_RECOMMENDED_ITEM_KEYS = ('name', 'category', 'subcategory', 'item_size', 'item_size_unit', 'calories')
|
|
|
|
|
|
def recommended_food_storage_items() -> list:
|
|
"""Build the example one-adult/one-year Food Storage items.
|
|
|
|
Joins the shipped food catalog (per-package nutrition in ``catalog_defaults.yaml``) with
|
|
``RECOMMENDED_ONE_YEAR_FOOD_COUNTS`` (how many packages to store), so the per-package nutritional data keeps a
|
|
single source of truth and this layer only adds quantities. Items are kept generic (no brand).
|
|
"""
|
|
from .catalog import load_catalog_defaults
|
|
by_id = {e.get('id'): e for e in load_catalog_defaults()}
|
|
items = []
|
|
for catalog_id, count in RECOMMENDED_ONE_YEAR_FOOD_COUNTS.items():
|
|
entry = by_id.get(catalog_id)
|
|
if not entry:
|
|
continue
|
|
item = {key: entry.get(key, '') for key in _RECOMMENDED_ITEM_KEYS}
|
|
item['count'] = str(count)
|
|
items.append(item)
|
|
return items
|
|
|
|
|
|
# A brand-new install seeds one example inventory of each kind so the feature is discoverable. The food example
|
|
# is populated with the recommended one-adult/one-year supply; `items_factory` is called lazily at seed time.
|
|
DEFAULT_INVENTORIES = [
|
|
dict(name='Food Storage', type='food', items_factory=recommended_food_storage_items),
|
|
]
|
|
|
|
|
|
def default_fields(inventory_type: str) -> list:
|
|
"""Return a fresh copy of the default field set for the given type (falls back to food)."""
|
|
from copy import deepcopy
|
|
return deepcopy(DEFAULT_FIELD_SETS.get(inventory_type, DEFAULT_FIELD_SETS[DEFAULT_TYPE]))
|
|
|
|
|
|
def slugify(name: str) -> str:
|
|
"""Convert an inventory name to a filesystem-safe slug used as its config file stem."""
|
|
slug = re.sub(r'[^a-z0-9]+', '-', (name or '').strip().lower()).strip('-')
|
|
return slug or 'inventory'
|