From aecbfc6c024af435655151da16059facda38943a Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Thu, 5 Mar 2026 20:06:17 -0600
Subject: [PATCH 01/20] fix: fix Assets column for All Logs subgrid when
 viewing asset

---
 src/wuttafarm/web/views/assets.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/wuttafarm/web/views/assets.py b/src/wuttafarm/web/views/assets.py
index b4e4d31..923108c 100644
--- a/src/wuttafarm/web/views/assets.py
+++ b/src/wuttafarm/web/views/assets.py
@@ -373,6 +373,23 @@ class AssetMasterView(WuttaFarmMasterView):
         g.set_filter("log_type", model.Log.log_type)
         g.set_enum("log_type", get_log_type_enum(self.config, session=session))
 
+        # assets
+        g.set_renderer("assets", self.render_assets_for_grid)
+
+    def render_assets_for_grid(self, log, field, value):
+        assets = getattr(log, field)
+
+        if self.farmos_style_grid_links:
+            links = []
+            for asset in assets:
+                url = self.request.route_url(
+                    f"{asset.asset_type}_assets.view", uuid=asset.uuid
+                )
+                links.append(tags.link_to(str(asset), url))
+            return ", ".join(links)
+
+        return ", ".join([str(a) for a in assets])
+
     def get_row_action_url_view(self, log, i):
         return self.request.route_url(f"logs_{log.log_type}.view", uuid=log.uuid)
 

From 3336294b3b8490f0dfa4ee82bc0b4ea1e292f2df Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Thu, 5 Mar 2026 20:30:39 -0600
Subject: [PATCH 02/20] fix: allow "N/A" option for animal sex

---
 src/wuttafarm/web/views/animals.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/wuttafarm/web/views/animals.py b/src/wuttafarm/web/views/animals.py
index f4c97e2..d8e4edf 100644
--- a/src/wuttafarm/web/views/animals.py
+++ b/src/wuttafarm/web/views/animals.py
@@ -23,6 +23,8 @@
 Master view for Animals
 """
 
+from collections import OrderedDict
+
 from webhelpers2.html import tags
 
 from wuttaweb.forms.schema import WuttaDictEnum
@@ -294,7 +296,9 @@ class AnimalAssetView(AssetMasterView):
         if not (self.creating or self.editing) and animal.sex is None:
             pass  # TODO: dict enum widget does not handle null values well
         else:
-            f.set_node("sex", WuttaDictEnum(self.request, enum.ANIMAL_SEX))
+            # nb. ensure empty option appears like we want
+            sex_enum = OrderedDict([("", "N/A")] + list(enum.ANIMAL_SEX.items()))
+            f.set_node("sex", WuttaDictEnum(self.request, sex_enum))
             f.set_required("sex", False)
 
 

From d46ba43d117405ad93c59ed2ee45aee23f39be55 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Thu, 5 Mar 2026 20:43:44 -0600
Subject: [PATCH 03/20] fix: expose `is_location` and `is_fixed` for editing on
 Animal Asset

---
 src/wuttafarm/farmos/importing/model.py     |  2 ++
 src/wuttafarm/farmos/importing/wuttafarm.py |  4 +++
 src/wuttafarm/web/views/animals.py          | 37 +++++++++------------
 src/wuttafarm/web/views/assets.py           | 18 ++++++++++
 4 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index ad1cb38..54e67ac 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -245,6 +245,8 @@ class AnimalAssetImporter(ToFarmOSAsset):
         "is_sterile",
         "produces_eggs",
         "birthdate",
+        "is_location",
+        "is_fixed",
         "notes",
         "archived",
     ]
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 8394e4c..8cf0e92 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -149,6 +149,8 @@ class AnimalAssetImporter(FromWuttaFarm, farmos_importing.model.AnimalAssetImpor
         "is_sterile",
         "produces_eggs",
         "birthdate",
+        "is_location",
+        "is_fixed",
         "notes",
         "archived",
     ]
@@ -162,6 +164,8 @@ class AnimalAssetImporter(FromWuttaFarm, farmos_importing.model.AnimalAssetImpor
             "is_sterile": animal.is_sterile,
             "produces_eggs": animal.produces_eggs,
             "birthdate": animal.birthdate,
+            "is_location": animal.is_location,
+            "is_fixed": animal.is_fixed,
             "notes": animal.notes,
             "archived": animal.archived,
             "_src_object": animal,
diff --git a/src/wuttafarm/web/views/animals.py b/src/wuttafarm/web/views/animals.py
index d8e4edf..ad9f060 100644
--- a/src/wuttafarm/web/views/animals.py
+++ b/src/wuttafarm/web/views/animals.py
@@ -28,6 +28,7 @@ from collections import OrderedDict
 from webhelpers2.html import tags
 
 from wuttaweb.forms.schema import WuttaDictEnum
+from wuttaweb.forms.widgets import WuttaDateTimeWidget
 from wuttaweb.util import get_form_data
 
 from wuttafarm.db.model import AnimalType, AnimalAsset
@@ -236,27 +237,6 @@ class AnimalAssetView(AssetMasterView):
         "archived",
     ]
 
-    form_fields = [
-        "asset_name",
-        "animal_type",
-        "birthdate",
-        "produces_eggs",
-        "sex",
-        "is_sterile",
-        "notes",
-        "asset_type",
-        "owners",
-        "locations",
-        "groups",
-        "archived",
-        "drupal_id",
-        "farmos_uuid",
-        "thumbnail_url",
-        "image_url",
-        "thumbnail",
-        "image",
-    ]
-
     def configure_grid(self, grid):
         g = grid
         super().configure_grid(g)
@@ -290,9 +270,21 @@ class AnimalAssetView(AssetMasterView):
         animal = f.model_instance
 
         # animal_type
+        f.fields.insert_after("asset_name", "animal_type")
         f.set_node("animal_type", AnimalTypeRef(self.request))
 
+        # birthdate
+        f.fields.insert_after("animal_type", "birthdate")
+        # TODO: why must we assign the widget here?  pretty sure that
+        # was not needed when we declared form_fields directly, i.e.
+        # instead of adding birthdate field in this method
+        f.set_widget("birthdate", WuttaDateTimeWidget(self.request))
+
+        # produces_eggs
+        f.fields.insert_after("birthdate", "produces_eggs")
+
         # sex
+        f.fields.insert_after("produces_eggs", "sex")
         if not (self.creating or self.editing) and animal.sex is None:
             pass  # TODO: dict enum widget does not handle null values well
         else:
@@ -301,6 +293,9 @@ class AnimalAssetView(AssetMasterView):
             f.set_node("sex", WuttaDictEnum(self.request, sex_enum))
             f.set_required("sex", False)
 
+        # is_sterile
+        f.fields.insert_after("sex", "is_sterile")
+
 
 def defaults(config, **kwargs):
     base = globals()
diff --git a/src/wuttafarm/web/views/assets.py b/src/wuttafarm/web/views/assets.py
index 923108c..4345372 100644
--- a/src/wuttafarm/web/views/assets.py
+++ b/src/wuttafarm/web/views/assets.py
@@ -77,6 +77,24 @@ class AssetMasterView(WuttaFarmMasterView):
         "archived": {"active": True, "verb": "is_false"},
     }
 
+    form_fields = [
+        "asset_name",
+        "notes",
+        "asset_type",
+        "owners",
+        "locations",
+        "is_location",
+        "is_fixed",
+        "groups",
+        "archived",
+        "drupal_id",
+        "farmos_uuid",
+        "thumbnail_url",
+        "image_url",
+        "thumbnail",
+        "image",
+    ]
+
     has_rows = True
     row_model_class = Log
     rows_viewable = True

From e61043b9d9fa0ddc66b2e70fdff7f9bdcfa93f57 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Fri, 6 Mar 2026 19:52:20 -0600
Subject: [PATCH 04/20] feat: add edit/sync support for asset parents

plus several changes to API calls, use iterate() instead of get()

also some changes to better share code for asset importers
---
 src/wuttafarm/farmos/importing/model.py       |  54 +++--
 src/wuttafarm/farmos/importing/wuttafarm.py   | 220 ++++++++++--------
 src/wuttafarm/importing/farmos.py             | 143 +++++-------
 src/wuttafarm/normal.py                       |  23 ++
 src/wuttafarm/web/forms/schema.py             |  34 ++-
 src/wuttafarm/web/forms/widgets.py            |  65 +++---
 .../web/templates/deform/assetrefs.pt         |  11 +
 .../web/templates/wuttafarm-components.mako   | 115 ++++++++-
 src/wuttafarm/web/views/assets.py             |  31 ++-
 src/wuttafarm/web/views/groups.py             |  14 +-
 src/wuttafarm/web/views/plants.py             |  20 +-
 11 files changed, 437 insertions(+), 293 deletions(-)
 create mode 100644 src/wuttafarm/web/templates/deform/assetrefs.pt

diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 54e67ac..ac4dc86 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -74,10 +74,11 @@ class ToFarmOSTaxonomy(ToFarmOS):
     ]
 
     def get_target_objects(self, **kwargs):
-        result = self.farmos_client.resource.get(
-            "taxonomy_term", self.farmos_taxonomy_type
+        return list(
+            self.farmos_client.resource.iterate(
+                "taxonomy_term", self.farmos_taxonomy_type
+            )
         )
-        return result["data"]
 
     def get_target_object(self, key):
 
@@ -127,9 +128,9 @@ class ToFarmOSTaxonomy(ToFarmOS):
         normal["_new_object"] = result["data"]
         return normal
 
-    def update_target_object(self, asset, source_data, target_data=None):
+    def update_target_object(self, term, source_data, target_data=None):
         if self.dry_run:
-            return asset
+            return term
 
         payload = self.get_term_payload(source_data)
         payload["id"] = str(source_data["uuid"])
@@ -146,9 +147,12 @@ class ToFarmOSAsset(ToFarmOS):
 
     farmos_asset_type = None
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.normal = self.app.get_normalizer(self.farmos_client)
+
     def get_target_objects(self, **kwargs):
-        assets = self.farmos_client.asset.get(self.farmos_asset_type)
-        return assets["data"]
+        return list(self.farmos_client.asset.iterate(self.farmos_asset_type))
 
     def get_target_object(self, key):
 
@@ -191,18 +195,17 @@ class ToFarmOSAsset(ToFarmOS):
         return self.normalize_target_object(result["data"])
 
     def normalize_target_object(self, asset):
-
-        if notes := asset["attributes"]["notes"]:
-            notes = notes["value"]
-
+        normal = self.normal.normalize_farmos_asset(asset)
         return {
-            "uuid": UUID(asset["id"]),
-            "asset_name": asset["attributes"]["name"],
-            "is_location": asset["attributes"]["is_location"],
-            "is_fixed": asset["attributes"]["is_fixed"],
-            "produces_eggs": asset["attributes"].get("produces_eggs"),
-            "notes": notes,
-            "archived": asset["attributes"]["archived"],
+            "uuid": UUID(normal["uuid"]),
+            "asset_name": normal["asset_name"],
+            "is_location": normal["is_location"],
+            "is_fixed": normal["is_fixed"],
+            # nb. this is only used for certain asset types
+            "produces_eggs": normal["produces_eggs"],
+            "parents": [(p["asset_type"], UUID(p["uuid"])) for p in normal["parents"]],
+            "notes": normal["notes"],
+            "archived": normal["archived"],
         }
 
     def get_asset_payload(self, source_data):
@@ -221,8 +224,18 @@ class ToFarmOSAsset(ToFarmOS):
         if "archived" in self.fields:
             attrs["archived"] = source_data["archived"]
 
-        payload = {"attributes": attrs}
+        rels = {}
+        if "parents" in self.fields:
+            rels["parent"] = {"data": []}
+            for asset_type, uuid in source_data["parents"]:
+                rels["parent"]["data"].append(
+                    {
+                        "id": str(uuid),
+                        "type": f"asset--{asset_type}",
+                    }
+                )
 
+        payload = {"attributes": attrs, "relationships": rels}
         return payload
 
 
@@ -607,8 +620,7 @@ class ToFarmOSLog(ToFarmOS):
         self.normal = self.app.get_normalizer(self.farmos_client)
 
     def get_target_objects(self, **kwargs):
-        result = self.farmos_client.log.get(self.farmos_log_type)
-        return result["data"]
+        return list(self.farmos_client.log.iterate(self.farmos_log_type))
 
     def get_target_object(self, key):
 
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 8cf0e92..f4f4948 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -134,42 +134,68 @@ class FromWuttaFarm(FromWutta):
         return obj
 
 
-class AnimalAssetImporter(FromWuttaFarm, farmos_importing.model.AnimalAssetImporter):
+class FromWuttaFarmAsset(FromWuttaFarm):
+    """
+    Base class for WuttaFarm → farmOS API asset exporters
+    """
+
+    supported_fields = [
+        "uuid",
+        "asset_name",
+        "is_location",
+        "is_fixed",
+        "parents",
+        "notes",
+        "archived",
+    ]
+
+    def normalize_source_object(self, asset):
+        return {
+            "uuid": asset.farmos_uuid or self.app.make_true_uuid(),
+            "asset_name": asset.asset_name,
+            "is_location": asset.is_location,
+            "is_fixed": asset.is_fixed,
+            "parents": [(p.asset_type, p.farmos_uuid) for p in asset.parents],
+            "notes": asset.notes,
+            "archived": asset.archived,
+            "_src_object": asset,
+        }
+
+
+class AnimalAssetImporter(
+    FromWuttaFarmAsset, farmos_importing.model.AnimalAssetImporter
+):
     """
     WuttaFarm → farmOS API exporter for Animal Assets
     """
 
     source_model_class = model.AnimalAsset
 
-    supported_fields = [
-        "uuid",
-        "asset_name",
-        "animal_type_uuid",
-        "sex",
-        "is_sterile",
-        "produces_eggs",
-        "birthdate",
-        "is_location",
-        "is_fixed",
-        "notes",
-        "archived",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "animal_type_uuid",
+                "sex",
+                "is_sterile",
+                "produces_eggs",
+                "birthdate",
+            ]
+        )
+        return fields
 
     def normalize_source_object(self, animal):
-        return {
-            "uuid": animal.farmos_uuid or self.app.make_true_uuid(),
-            "asset_name": animal.asset_name,
-            "animal_type_uuid": animal.animal_type.farmos_uuid,
-            "sex": animal.sex,
-            "is_sterile": animal.is_sterile,
-            "produces_eggs": animal.produces_eggs,
-            "birthdate": animal.birthdate,
-            "is_location": animal.is_location,
-            "is_fixed": animal.is_fixed,
-            "notes": animal.notes,
-            "archived": animal.archived,
-            "_src_object": animal,
-        }
+        data = super().normalize_source_object(animal)
+        data.update(
+            {
+                "animal_type_uuid": animal.animal_type.farmos_uuid,
+                "sex": animal.sex,
+                "is_sterile": animal.is_sterile,
+                "produces_eggs": animal.produces_eggs,
+                "birthdate": animal.birthdate,
+            }
+        )
+        return data
 
 
 class AnimalTypeImporter(FromWuttaFarm, farmos_importing.model.AnimalTypeImporter):
@@ -216,60 +242,56 @@ class UnitImporter(FromWuttaFarm, farmos_importing.model.UnitImporter):
         }
 
 
-class GroupAssetImporter(FromWuttaFarm, farmos_importing.model.GroupAssetImporter):
+class GroupAssetImporter(FromWuttaFarmAsset, farmos_importing.model.GroupAssetImporter):
     """
     WuttaFarm → farmOS API exporter for Group Assets
     """
 
     source_model_class = model.GroupAsset
 
-    supported_fields = [
-        "uuid",
-        "asset_name",
-        "produces_eggs",
-        "notes",
-        "archived",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "produces_eggs",
+            ]
+        )
+        return fields
 
     def normalize_source_object(self, group):
-        return {
-            "uuid": group.farmos_uuid or self.app.make_true_uuid(),
-            "asset_name": group.asset_name,
-            "produces_eggs": group.produces_eggs,
-            "notes": group.notes,
-            "archived": group.archived,
-            "_src_object": group,
-        }
+        data = super().normalize_source_object(group)
+        data.update(
+            {
+                "produces_eggs": group.produces_eggs,
+            }
+        )
+        return data
 
 
-class LandAssetImporter(FromWuttaFarm, farmos_importing.model.LandAssetImporter):
+class LandAssetImporter(FromWuttaFarmAsset, farmos_importing.model.LandAssetImporter):
     """
     WuttaFarm → farmOS API exporter for Land Assets
     """
 
     source_model_class = model.LandAsset
 
-    supported_fields = [
-        "uuid",
-        "asset_name",
-        "land_type_id",
-        "is_location",
-        "is_fixed",
-        "notes",
-        "archived",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "land_type_id",
+            ]
+        )
+        return fields
 
     def normalize_source_object(self, land):
-        return {
-            "uuid": land.farmos_uuid or self.app.make_true_uuid(),
-            "asset_name": land.asset_name,
-            "land_type_id": land.land_type.drupal_id,
-            "is_location": land.is_location,
-            "is_fixed": land.is_fixed,
-            "notes": land.notes,
-            "archived": land.archived,
-            "_src_object": land,
-        }
+        data = super().normalize_source_object(land)
+        data.update(
+            {
+                "land_type_id": land.land_type.drupal_id,
+            }
+        )
+        return data
 
 
 class PlantTypeImporter(FromWuttaFarm, farmos_importing.model.PlantTypeImporter):
@@ -294,34 +316,36 @@ class PlantTypeImporter(FromWuttaFarm, farmos_importing.model.PlantTypeImporter)
         }
 
 
-class PlantAssetImporter(FromWuttaFarm, farmos_importing.model.PlantAssetImporter):
+class PlantAssetImporter(FromWuttaFarmAsset, farmos_importing.model.PlantAssetImporter):
     """
     WuttaFarm → farmOS API exporter for Plant Assets
     """
 
     source_model_class = model.PlantAsset
 
-    supported_fields = [
-        "uuid",
-        "asset_name",
-        "plant_type_uuids",
-        "notes",
-        "archived",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "plant_type_uuids",
+            ]
+        )
+        return fields
 
     def normalize_source_object(self, plant):
-        return {
-            "uuid": plant.farmos_uuid or self.app.make_true_uuid(),
-            "asset_name": plant.asset_name,
-            "plant_type_uuids": [t.plant_type.farmos_uuid for t in plant._plant_types],
-            "notes": plant.notes,
-            "archived": plant.archived,
-            "_src_object": plant,
-        }
+        data = super().normalize_source_object(plant)
+        data.update(
+            {
+                "plant_type_uuids": [
+                    t.plant_type.farmos_uuid for t in plant._plant_types
+                ],
+            }
+        )
+        return data
 
 
 class StructureAssetImporter(
-    FromWuttaFarm, farmos_importing.model.StructureAssetImporter
+    FromWuttaFarmAsset, farmos_importing.model.StructureAssetImporter
 ):
     """
     WuttaFarm → farmOS API exporter for Structure Assets
@@ -329,27 +353,23 @@ class StructureAssetImporter(
 
     source_model_class = model.StructureAsset
 
-    supported_fields = [
-        "uuid",
-        "asset_name",
-        "structure_type_id",
-        "is_location",
-        "is_fixed",
-        "notes",
-        "archived",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "structure_type_id",
+            ]
+        )
+        return fields
 
     def normalize_source_object(self, structure):
-        return {
-            "uuid": structure.farmos_uuid or self.app.make_true_uuid(),
-            "asset_name": structure.asset_name,
-            "structure_type_id": structure.structure_type.drupal_id,
-            "is_location": structure.is_location,
-            "is_fixed": structure.is_fixed,
-            "notes": structure.notes,
-            "archived": structure.archived,
-            "_src_object": structure,
-        }
+        data = super().normalize_source_object(structure)
+        data.update(
+            {
+                "structure_type_id": structure.structure_type.drupal_id,
+            }
+        )
+        return data
 
 
 ##############################
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index 6b21090..ea1fd4b 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -330,21 +330,18 @@ class AnimalAssetImporter(AssetImporterBase):
 
     model_class = model.AnimalAsset
 
-    supported_fields = [
-        "farmos_uuid",
-        "drupal_id",
-        "asset_type",
-        "asset_name",
-        "animal_type_uuid",
-        "sex",
-        "is_sterile",
-        "produces_eggs",
-        "birthdate",
-        "notes",
-        "archived",
-        "image_url",
-        "thumbnail_url",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "animal_type_uuid",
+                "sex",
+                "is_sterile",
+                "produces_eggs",
+                "birthdate",
+            ]
+        )
+        return fields
 
     def setup(self):
         super().setup()
@@ -415,8 +412,7 @@ class AnimalTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        animal_types = self.farmos_client.resource.get("taxonomy_term", "animal_type")
-        return animal_types["data"]
+        return list(self.farmos_client.resource.iterate("taxonomy_term", "animal_type"))
 
     def normalize_source_object(self, animal_type):
         """ """
@@ -444,8 +440,7 @@ class AssetTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        asset_types = self.farmos_client.resource.get("asset_type")
-        return asset_types["data"]
+        return list(self.farmos_client.resource.iterate("asset_type"))
 
     def normalize_source_object(self, asset_type):
         """ """
@@ -464,20 +459,14 @@ class GroupAssetImporter(AssetImporterBase):
 
     model_class = model.GroupAsset
 
-    supported_fields = [
-        "farmos_uuid",
-        "drupal_id",
-        "asset_type",
-        "asset_name",
-        "is_location",
-        "is_fixed",
-        "produces_eggs",
-        "notes",
-        "archived",
-        "image_url",
-        "thumbnail_url",
-        "parents",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "produces_eggs",
+            ]
+        )
+        return fields
 
     def normalize_source_object(self, group):
         """ """
@@ -497,18 +486,14 @@ class LandAssetImporter(AssetImporterBase):
 
     model_class = model.LandAsset
 
-    supported_fields = [
-        "farmos_uuid",
-        "drupal_id",
-        "asset_type",
-        "asset_name",
-        "land_type_uuid",
-        "is_location",
-        "is_fixed",
-        "notes",
-        "archived",
-        "parents",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "land_type_uuid",
+            ]
+        )
+        return fields
 
     def setup(self):
         """ """
@@ -553,8 +538,7 @@ class LandTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        land_types = self.farmos_client.resource.get("land_type")
-        return land_types["data"]
+        return list(self.farmos_client.resource.iterate("land_type"))
 
     def normalize_source_object(self, land_type):
         """ """
@@ -581,8 +565,7 @@ class PlantTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        result = self.farmos_client.resource.get("taxonomy_term", "plant_type")
-        return result["data"]
+        return list(self.farmos_client.resource.iterate("taxonomy_term", "plant_type"))
 
     def normalize_source_object(self, plant_type):
         """ """
@@ -601,17 +584,14 @@ class PlantAssetImporter(AssetImporterBase):
 
     model_class = model.PlantAsset
 
-    supported_fields = [
-        "farmos_uuid",
-        "drupal_id",
-        "asset_type",
-        "asset_name",
-        "plant_types",
-        "notes",
-        "archived",
-        "image_url",
-        "thumbnail_url",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "plant_types",
+            ]
+        )
+        return fields
 
     def setup(self):
         super().setup()
@@ -624,6 +604,8 @@ class PlantAssetImporter(AssetImporterBase):
 
     def normalize_source_object(self, plant):
         """ """
+        data = super().normalize_source_object(plant)
+
         plant_types = []
         if relationships := plant.get("relationships"):
 
@@ -637,7 +619,6 @@ class PlantAssetImporter(AssetImporterBase):
                     else:
                         log.warning("plant type not found: %s", plant_type["id"])
 
-        data = super().normalize_source_object(plant)
         data.update(
             {
                 "plant_types": set(plant_types),
@@ -693,20 +674,14 @@ class StructureAssetImporter(AssetImporterBase):
 
     model_class = model.StructureAsset
 
-    supported_fields = [
-        "farmos_uuid",
-        "drupal_id",
-        "asset_type",
-        "asset_name",
-        "structure_type_uuid",
-        "is_location",
-        "is_fixed",
-        "notes",
-        "archived",
-        "image_url",
-        "thumbnail_url",
-        "parents",
-    ]
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "structure_type_uuid",
+            ]
+        )
+        return fields
 
     def setup(self):
         super().setup()
@@ -752,8 +727,7 @@ class StructureTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        structure_types = self.farmos_client.resource.get("structure_type")
-        return structure_types["data"]
+        return list(self.farmos_client.resource.iterate("structure_type"))
 
     def normalize_source_object(self, structure_type):
         """ """
@@ -791,8 +765,7 @@ class UserImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        users = self.farmos_client.resource.get("user")
-        return users["data"]
+        return list(self.farmos_client.resource.iterate("user"))
 
     def normalize_source_object(self, user):
         """ """
@@ -869,8 +842,7 @@ class UnitImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        result = self.farmos_client.resource.get("taxonomy_term", "unit")
-        return result["data"]
+        return list(self.farmos_client.resource.iterate("taxonomy_term", "unit"))
 
     def normalize_source_object(self, unit):
         """ """
@@ -898,8 +870,7 @@ class QuantityTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        result = self.farmos_client.resource.get("quantity_type")
-        return result["data"]
+        return list(self.farmos_client.resource.iterate("quantity_type"))
 
     def normalize_source_object(self, quantity_type):
         """ """
@@ -927,8 +898,7 @@ class LogTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        log_types = self.farmos_client.resource.get("log_type")
-        return log_types["data"]
+        return list(self.farmos_client.resource.iterate("log_type"))
 
     def normalize_source_object(self, log_type):
         """ """
@@ -1271,8 +1241,7 @@ class QuantityImporterBase(FromFarmOS, ToWutta):
     def get_source_objects(self):
         """ """
         quantity_type = self.get_farmos_quantity_type()
-        result = self.farmos_client.resource.get("quantity", quantity_type)
-        return result["data"]
+        return list(self.farmos_client.resource.iterate("quantity", quantity_type))
 
     def get_quantity_type_by_farmos_uuid(self, uuid):
         if hasattr(self, "quantity_types_by_farmos_uuid"):
diff --git a/src/wuttafarm/normal.py b/src/wuttafarm/normal.py
index 4fc8796..2e38f49 100644
--- a/src/wuttafarm/normal.py
+++ b/src/wuttafarm/normal.py
@@ -90,10 +90,29 @@ class Normalizer(GenericHandler):
         if notes := asset["attributes"]["notes"]:
             notes = notes["value"]
 
+        parent_objects = []
+        parent_uuids = []
         owner_objects = []
         owner_uuids = []
         if relationships := asset.get("relationships"):
 
+            if parents := relationships.get("parent"):
+                for parent in parents["data"]:
+                    parent_uuid = parent["id"]
+                    parent_uuids.append(parent_uuid)
+                    parent_object = {
+                        "uuid": parent_uuid,
+                        "type": parent["type"],
+                        "asset_type": parent["type"].split("--")[1],
+                    }
+                    if parent := included.get(parent_uuid):
+                        parent_object.update(
+                            {
+                                "name": parent["attributes"]["name"],
+                            }
+                        )
+                    parent_objects.append(parent_object)
+
             if owners := relationships.get("owner"):
                 for user in owners["data"]:
                     user_uuid = user["id"]
@@ -114,6 +133,10 @@ class Normalizer(GenericHandler):
             "is_fixed": asset["attributes"]["is_fixed"],
             "archived": asset["attributes"]["archived"],
             "notes": notes,
+            # nb. this is only used for certain asset types
+            "produces_eggs": asset["attributes"].get("produces_eggs"),
+            "parents": parent_objects,
+            "parent_uuids": parent_uuids,
             "owners": owner_objects,
             "owner_uuids": owner_uuids,
         }
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index 6bf434e..bad5670 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -372,37 +372,35 @@ class UsersType(colander.SchemaType):
         return UsersWidget(self.request, **kwargs)
 
 
-class AssetParentRefs(WuttaSet):
-    """
-    Schema type for Parents field which references assets.
-    """
-
-    def serialize(self, node, appstruct):
-        if not appstruct:
-            appstruct = []
-        uuids = [u.hex for u in appstruct]
-        return json.dumps(uuids)
-
-    def widget_maker(self, **kwargs):
-        from wuttafarm.web.forms.widgets import AssetParentRefsWidget
-
-        return AssetParentRefsWidget(self.request, **kwargs)
-
-
 class AssetRefs(WuttaSet):
     """
     Schema type for Assets field (on a Log record)
     """
 
+    def __init__(self, request, for_asset=None, **kwargs):
+        super().__init__(request, **kwargs)
+        self.for_asset = for_asset
+
     def serialize(self, node, appstruct):
         if not appstruct:
             return colander.null
 
-        return {asset.uuid for asset in appstruct}
+        return {asset.uuid.hex for asset in appstruct}
 
     def widget_maker(self, **kwargs):
         from wuttafarm.web.forms.widgets import AssetRefsWidget
 
+        model = self.app.model
+        session = Session()
+
+        if "values" not in kwargs:
+            query = session.query(model.Asset)
+            if self.for_asset:
+                query = query.filter(model.Asset.uuid != self.for_asset.uuid)
+            query = query.order_by(model.Asset.asset_name)
+            values = [(asset.uuid.hex, str(asset)) for asset in query]
+            kwargs["values"] = values
+
         return AssetRefsWidget(self.request, **kwargs)
 
 
diff --git a/src/wuttafarm/web/forms/widgets.py b/src/wuttafarm/web/forms/widgets.py
index 0a14638..d74a436 100644
--- a/src/wuttafarm/web/forms/widgets.py
+++ b/src/wuttafarm/web/forms/widgets.py
@@ -393,42 +393,20 @@ class UsersWidget(Widget):
 ##############################
 
 
-class AssetParentRefsWidget(WuttaCheckboxChoiceWidget):
-    """
-    Widget for Parents field which references assets.
-    """
-
-    def serialize(self, field, cstruct, **kw):
-        """ """
-        model = self.app.model
-        session = Session()
-
-        readonly = kw.get("readonly", self.readonly)
-        if readonly:
-            parents = []
-            for uuid in json.loads(cstruct):
-                parent = session.get(model.Asset, uuid)
-                parents.append(
-                    HTML.tag(
-                        "li",
-                        c=tags.link_to(
-                            str(parent),
-                            self.request.route_url(
-                                f"{parent.asset_type}_assets.view", uuid=parent.uuid
-                            ),
-                        ),
-                    )
-                )
-            return HTML.tag("ul", c=parents)
-
-        return super().serialize(field, cstruct, **kw)
-
-
-class AssetRefsWidget(WuttaCheckboxChoiceWidget):
+class AssetRefsWidget(Widget):
     """
     Widget for Assets field (of various kinds).
     """
 
+    template = "assetrefs"
+    values = ()
+
+    def __init__(self, request, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
     def serialize(self, field, cstruct, **kw):
         """ """
         model = self.app.model
@@ -452,7 +430,28 @@ class AssetRefsWidget(WuttaCheckboxChoiceWidget):
                 )
             return HTML.tag("ul", c=assets)
 
-        return super().serialize(field, cstruct, **kw)
+        values = kw.get("values", self.values)
+        if not isinstance(values, sequence_types):
+            raise TypeError("Values must be a sequence type (list, tuple, or range).")
+
+        kw["values"] = _normalize_choices(values)
+        tmpl_values = self.get_template_values(field, cstruct, kw)
+        return field.renderer(self.template, **tmpl_values)
+
+    def get_template_values(self, field, cstruct, kw):
+        """ """
+        values = super().get_template_values(field, cstruct, kw)
+
+        values["js_values"] = json.dumps(values["values"])
+
+        return values
+
+    def deserialize(self, field, pstruct):
+        """ """
+        if not pstruct:
+            return colander.null
+
+        return set(pstruct.split(","))
 
 
 class LogQuantityRefsWidget(WuttaCheckboxChoiceWidget):
diff --git a/src/wuttafarm/web/templates/deform/assetrefs.pt b/src/wuttafarm/web/templates/deform/assetrefs.pt
new file mode 100644
index 0000000..b2e9660
--- /dev/null
+++ b/src/wuttafarm/web/templates/deform/assetrefs.pt
@@ -0,0 +1,11 @@
+<div tal:define="
+     name name|field.name;
+     oid oid|field.oid;
+     vmodel vmodel|'modelData.'+oid;"
+     tal:omit-tag="">
+
+  <assets-picker tal:attributes="name name;
+                                 v-model vmodel;
+                                 :assets js_values;" />
+
+</div>
diff --git a/src/wuttafarm/web/templates/wuttafarm-components.mako b/src/wuttafarm/web/templates/wuttafarm-components.mako
index 37b176e..1a07690 100644
--- a/src/wuttafarm/web/templates/wuttafarm-components.mako
+++ b/src/wuttafarm/web/templates/wuttafarm-components.mako
@@ -1,9 +1,116 @@
 
 <%def name="make_wuttafarm_components()">
+  ${self.make_assets_picker_component()}
   ${self.make_animal_type_picker_component()}
   ${self.make_plant_types_picker_component()}
 </%def>
 
+<%def name="make_assets_picker_component()">
+  <script type="text/x-template" id="assets-picker-template">
+    <div>
+      <input type="hidden" :name="name" :value="value" />
+
+      <div style="display: flex; gap: 0.5rem; align-items: center;">
+
+        <span>Add:</span>
+
+        <b-autocomplete v-model="addName"
+                        ref="addName"
+                        :data="addNameData"
+                        field="name"
+                        open-on-focus
+                        keep-first
+                        @select="addNameSelected"
+                        clear-on-select
+                        style="flex-grow: 1;">
+          <template #empty>No results found</template>
+        </b-autocomplete>
+
+      </div>
+
+      <${b}-table :data="assetData">
+
+        <${b}-table-column field="name" v-slot="props">
+          <span>{{ props.row.name }}</span>
+        </${b}-table-column>
+
+        <${b}-table-column v-slot="props">
+            <a href="#"
+               class="has-text-danger"
+               @click.prevent="removeAsset(props.row)">
+              <i class="fas fa-trash" /> &nbsp; Remove
+            </a>
+        </${b}-table-column>
+
+      </${b}-table>
+    </div>
+  </script>
+  <script>
+    const AssetsPicker = {
+        template: '#assets-picker-template',
+        props: {
+            name: String,
+            value: Array,
+            assets: Array,
+        },
+        data() {
+            return {
+                addName: '',
+                internalAssets: this.assets.map((asset) => {
+                    return {uuid: asset[0], name: asset[1]}
+                }),
+            }
+        },
+        computed: {
+            assetData() {
+                const data = []
+
+                if (this.value) {
+                    for (let asset of this.internalAssets) {
+                        if (this.value.includes(asset.uuid)) {
+                            data.push(asset)
+                        }
+                    }
+                }
+
+                return data
+            },
+            addNameData() {
+                if (!this.addName) {
+                    return this.internalAssets
+                }
+
+                return this.internalAssets.filter((asset) => {
+                    return asset.name.toLowerCase().indexOf(this.addName.toLowerCase()) >= 0
+                })
+            },
+        },
+        methods: {
+
+            addNameSelected(option) {
+                const value = Array.from(this.value || [])
+
+                if (!value.includes(option.uuid)) {
+                    value.push(option.uuid)
+                    this.$emit('input', value)
+                }
+
+                this.addName = null
+            },
+
+            removeAsset(asset) {
+                let value = Array.from(this.value)
+                const i = value.indexOf(asset.uuid)
+                value.splice(i, 1)
+                this.$emit('input', value)
+            },
+        },
+    }
+    Vue.component('assets-picker', AssetsPicker)
+    <% request.register_component('assets-picker', 'AssetsPicker') %>
+  </script>
+</%def>
+
 <%def name="make_animal_type_picker_component()">
   <script type="text/x-template" id="animal-type-picker-template">
     <div>
@@ -108,7 +215,10 @@
 
             createSave() {
                 this.createSaving = true
+                ## TODO
+                % if not app.is_farmos_wrapper():
                 const url = "${url('animal_types.ajax_create')}"
+                % endif
                 const params = {name: this.createName}
                 this.wuttaPOST(url, params, response => {
                     this.internalAnimalTypes.push([response.data.uuid, response.data.name])
@@ -229,7 +339,6 @@
                     return {uuid: pt[0], name: pt[1]}
                 }),
 
-                addShowDialog: false,
                 addName: '',
 
                 createShowDialog: false,
@@ -243,7 +352,6 @@
 
                 if (this.value) {
                     for (let ptype of this.internalPlantTypes) {
-                        // ptype = {uuid: ptype[0], name: ptype[1]}
                         if (this.value.includes(ptype.uuid)) {
                             data.push(ptype)
                         }
@@ -295,7 +403,10 @@
 
             createSave() {
                 this.createSaving = true
+                ## TODO
+                % if not app.is_farmos_wrapper():
                 const url = "${url('plant_types.ajax_create')}"
+                % endif
                 const params = {name: this.createName}
                 this.wuttaPOST(url, params, response => {
                     this.internalPlantTypes.push(response.data)
diff --git a/src/wuttafarm/web/views/assets.py b/src/wuttafarm/web/views/assets.py
index 4345372..5cc70e5 100644
--- a/src/wuttafarm/web/views/assets.py
+++ b/src/wuttafarm/web/views/assets.py
@@ -32,7 +32,7 @@ from wuttaweb.db import Session
 
 from wuttafarm.web.views import WuttaFarmMasterView
 from wuttafarm.db.model import Asset, Log
-from wuttafarm.web.forms.schema import AssetParentRefs, OwnerRefs, AssetRefs
+from wuttafarm.web.forms.schema import OwnerRefs, AssetRefs
 from wuttafarm.web.forms.widgets import ImageWidget
 from wuttafarm.util import get_log_type_enum
 from wuttafarm.web.util import get_farmos_client_for_user
@@ -79,6 +79,7 @@ class AssetMasterView(WuttaFarmMasterView):
 
     form_fields = [
         "asset_name",
+        "parents",
         "notes",
         "asset_type",
         "owners",
@@ -279,11 +280,11 @@ class AssetMasterView(WuttaFarmMasterView):
             f.set_default("groups", asset_handler.get_groups(asset))
 
         # parents
-        if self.creating or self.editing:
-            f.remove("parents")  # TODO: add support for this
-        else:
-            f.set_node("parents", AssetParentRefs(self.request))
-            f.set_default("parents", [p.uuid for p in asset.parents])
+        f.set_node("parents", AssetRefs(self.request, for_asset=asset))
+        f.set_required("parents", False)
+        if not self.creating:
+            # nb. must explicity declare value for non-standard field
+            f.set_default("parents", asset.parents)
 
         # notes
         f.set_widget("notes", "notes")
@@ -311,11 +312,29 @@ class AssetMasterView(WuttaFarmMasterView):
             f.set_default("image", asset.image_url)
 
     def objectify(self, form):
+        model = self.app.model
+        session = self.Session()
         asset = super().objectify(form)
+        data = form.validated
 
         if self.creating:
             asset.asset_type = self.get_asset_type()
 
+        current = [p.uuid for p in asset.parents]
+        desired = data["parents"] or []
+
+        for uuid in desired:
+            if uuid not in current:
+                parent = session.get(model.Asset, uuid)
+                assert parent
+                asset.parents.append(parent)
+
+        for uuid in current:
+            if uuid not in desired:
+                parent = session.get(model.Asset, uuid)
+                assert parent
+                asset.parents.remove(parent)
+
         return asset
 
     def get_asset_type(self):
diff --git a/src/wuttafarm/web/views/groups.py b/src/wuttafarm/web/views/groups.py
index 4331280..c8cc7f7 100644
--- a/src/wuttafarm/web/views/groups.py
+++ b/src/wuttafarm/web/views/groups.py
@@ -47,15 +47,11 @@ class GroupView(AssetMasterView):
         "archived",
     ]
 
-    form_fields = [
-        "asset_name",
-        "notes",
-        "asset_type",
-        "produces_eggs",
-        "archived",
-        "drupal_id",
-        "farmos_uuid",
-    ]
+    def configure_form(self, f):
+        super().configure_form(f)
+
+        # produces_eggs
+        f.fields.insert_after("asset_type", "produces_eggs")
 
 
 def defaults(config, **kwargs):
diff --git a/src/wuttafarm/web/views/plants.py b/src/wuttafarm/web/views/plants.py
index a114e07..2d4bdce 100644
--- a/src/wuttafarm/web/views/plants.py
+++ b/src/wuttafarm/web/views/plants.py
@@ -220,21 +220,6 @@ class PlantAssetView(AssetMasterView):
         "archived",
     ]
 
-    form_fields = [
-        "asset_name",
-        "plant_types",
-        "season",
-        "notes",
-        "asset_type",
-        "archived",
-        "drupal_id",
-        "farmos_uuid",
-        "thumbnail_url",
-        "image_url",
-        "thumbnail",
-        "image",
-    ]
-
     def configure_grid(self, grid):
         g = grid
         super().configure_grid(g)
@@ -262,14 +247,15 @@ class PlantAssetView(AssetMasterView):
         plant = f.model_instance
 
         # plant_types
+        f.fields.insert_after("asset_name", "plant_types")
         f.set_node("plant_types", PlantTypeRefs(self.request))
         if not self.creating:
             # nb. must explcitly declare value for non-standard field
             f.set_default("plant_types", [pt.uuid for pt in plant.plant_types])
 
         # season
-        if self.creating or self.editing:
-            f.remove("season")  # TODO: add support for this
+        if not (self.creating or self.editing):  # TODO
+            f.fields.insert_after("plant_types", "season")
 
     def objectify(self, form):
         model = self.app.model

From 45fd5556f25bad6a09f9215a6db89969b045b219 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Fri, 6 Mar 2026 21:38:23 -0600
Subject: [PATCH 05/20] feat: add edit/sync support for Plant Seasons

---
 .../c5183b781d34_add_plant_seasons.py         | 205 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   8 +-
 src/wuttafarm/db/model/asset_plant.py         |  99 +++++++++
 src/wuttafarm/farmos/importing/model.py       |  19 ++
 src/wuttafarm/farmos/importing/wuttafarm.py   |  29 ++-
 src/wuttafarm/importing/farmos.py             |  67 ++++++
 src/wuttafarm/normal.py                       |   5 +
 src/wuttafarm/web/forms/schema.py             |  25 +++
 src/wuttafarm/web/forms/widgets.py            |  72 ++++++
 src/wuttafarm/web/menus.py                    |  15 ++
 .../web/templates/deform/seasonrefs.pt        |  13 ++
 .../web/templates/wuttafarm-components.mako   | 197 +++++++++++++++++
 src/wuttafarm/web/views/common.py             |   8 +
 src/wuttafarm/web/views/farmos/plants.py      |  90 ++++++--
 src/wuttafarm/web/views/plants.py             | 204 ++++++++++++++++-
 15 files changed, 1029 insertions(+), 27 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/c5183b781d34_add_plant_seasons.py
 create mode 100644 src/wuttafarm/web/templates/deform/seasonrefs.pt

diff --git a/src/wuttafarm/db/alembic/versions/c5183b781d34_add_plant_seasons.py b/src/wuttafarm/db/alembic/versions/c5183b781d34_add_plant_seasons.py
new file mode 100644
index 0000000..406ad64
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/c5183b781d34_add_plant_seasons.py
@@ -0,0 +1,205 @@
+"""add plant seasons
+
+Revision ID: c5183b781d34
+Revises: 5f474125a80e
+Create Date: 2026-03-06 20:18:40.160531
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "c5183b781d34"
+down_revision: Union[str, None] = "5f474125a80e"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # season
+    op.create_table(
+        "season",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("name", sa.String(length=100), nullable=False),
+        sa.Column("description", sa.String(length=255), nullable=True),
+        sa.Column("farmos_uuid", wuttjamaican.db.util.UUID(), nullable=True),
+        sa.Column("drupal_id", sa.Integer(), nullable=True),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_season")),
+        sa.UniqueConstraint("drupal_id", name=op.f("uq_season_drupal_id")),
+        sa.UniqueConstraint("farmos_uuid", name=op.f("uq_season_farmos_uuid")),
+        sa.UniqueConstraint("name", name=op.f("uq_season_name")),
+    )
+    op.create_table(
+        "season_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column("name", sa.String(length=100), autoincrement=False, nullable=True),
+        sa.Column(
+            "description", sa.String(length=255), autoincrement=False, nullable=True
+        ),
+        sa.Column(
+            "farmos_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column("drupal_id", sa.Integer(), autoincrement=False, nullable=True),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_season_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_season_version_end_transaction_id"),
+        "season_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_season_version_operation_type"),
+        "season_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_season_version_pk_transaction_id",
+        "season_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_season_version_pk_validity",
+        "season_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_season_version_transaction_id"),
+        "season_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+    # asset_plant_season
+    op.create_table(
+        "asset_plant_season",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("plant_asset_uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("season_uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["plant_asset_uuid"],
+            ["asset_plant.uuid"],
+            name=op.f("fk_asset_plant_season_plant_asset_uuid_asset_plant"),
+        ),
+        sa.ForeignKeyConstraint(
+            ["season_uuid"],
+            ["season.uuid"],
+            name=op.f("fk_asset_plant_season_season_uuid_season"),
+        ),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_asset_plant_season")),
+    )
+    op.create_table(
+        "asset_plant_season_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "plant_asset_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "season_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_asset_plant_season_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_asset_plant_season_version_end_transaction_id"),
+        "asset_plant_season_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_plant_season_version_operation_type"),
+        "asset_plant_season_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_plant_season_version_pk_transaction_id",
+        "asset_plant_season_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_plant_season_version_pk_validity",
+        "asset_plant_season_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_plant_season_version_transaction_id"),
+        "asset_plant_season_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # asset_plant_season
+    op.drop_index(
+        op.f("ix_asset_plant_season_version_transaction_id"),
+        table_name="asset_plant_season_version",
+    )
+    op.drop_index(
+        "ix_asset_plant_season_version_pk_validity",
+        table_name="asset_plant_season_version",
+    )
+    op.drop_index(
+        "ix_asset_plant_season_version_pk_transaction_id",
+        table_name="asset_plant_season_version",
+    )
+    op.drop_index(
+        op.f("ix_asset_plant_season_version_operation_type"),
+        table_name="asset_plant_season_version",
+    )
+    op.drop_index(
+        op.f("ix_asset_plant_season_version_end_transaction_id"),
+        table_name="asset_plant_season_version",
+    )
+    op.drop_table("asset_plant_season_version")
+    op.drop_table("asset_plant_season")
+
+    # season
+    op.drop_index(op.f("ix_season_version_transaction_id"), table_name="season_version")
+    op.drop_index("ix_season_version_pk_validity", table_name="season_version")
+    op.drop_index("ix_season_version_pk_transaction_id", table_name="season_version")
+    op.drop_index(op.f("ix_season_version_operation_type"), table_name="season_version")
+    op.drop_index(
+        op.f("ix_season_version_end_transaction_id"), table_name="season_version"
+    )
+    op.drop_table("season_version")
+    op.drop_table("season")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index 15514fb..929e64b 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -37,7 +37,13 @@ from .asset_land import LandType, LandAsset
 from .asset_structure import StructureType, StructureAsset
 from .asset_animal import AnimalType, AnimalAsset
 from .asset_group import GroupAsset
-from .asset_plant import PlantType, PlantAsset, PlantAssetPlantType
+from .asset_plant import (
+    PlantType,
+    Season,
+    PlantAsset,
+    PlantAssetPlantType,
+    PlantAssetSeason,
+)
 from .log import LogType, Log, LogAsset, LogGroup, LogLocation, LogQuantity, LogOwner
 from .log_activity import ActivityLog
 from .log_harvest import HarvestLog
diff --git a/src/wuttafarm/db/model/asset_plant.py b/src/wuttafarm/db/model/asset_plant.py
index 62f7e9b..fa1be03 100644
--- a/src/wuttafarm/db/model/asset_plant.py
+++ b/src/wuttafarm/db/model/asset_plant.py
@@ -91,6 +91,65 @@ class PlantType(model.Base):
         return self.name or ""
 
 
+class Season(model.Base):
+    """
+    Represents a "season" (taxonomy term) from farmOS
+    """
+
+    __tablename__ = "season"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Season",
+        "model_title_plural": "Seasons",
+    }
+
+    uuid = model.uuid_column()
+
+    name = sa.Column(
+        sa.String(length=100),
+        nullable=False,
+        unique=True,
+        doc="""
+        Name of the season.
+        """,
+    )
+
+    description = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Optional description for the season.
+        """,
+    )
+
+    farmos_uuid = sa.Column(
+        model.UUID(),
+        nullable=True,
+        unique=True,
+        doc="""
+        UUID for the season within farmOS.
+        """,
+    )
+
+    drupal_id = sa.Column(
+        sa.Integer(),
+        nullable=True,
+        unique=True,
+        doc="""
+        Drupal internal ID for the season.
+        """,
+    )
+
+    _plant_assets = orm.relationship(
+        "PlantAssetSeason",
+        cascade_backrefs=False,
+        back_populates="season",
+    )
+
+    def __str__(self):
+        return self.name or ""
+
+
 class PlantAsset(AssetMixin, model.Base):
     """
     Represents a plant asset from farmOS
@@ -117,6 +176,19 @@ class PlantAsset(AssetMixin, model.Base):
         creator=lambda pt: PlantAssetPlantType(plant_type=pt),
     )
 
+    _seasons = orm.relationship(
+        "PlantAssetSeason",
+        cascade="all, delete-orphan",
+        cascade_backrefs=False,
+        back_populates="plant_asset",
+    )
+
+    seasons = association_proxy(
+        "_seasons",
+        "season",
+        creator=lambda s: PlantAssetSeason(season=s),
+    )
+
 
 add_asset_proxies(PlantAsset)
 
@@ -146,3 +218,30 @@ class PlantAssetPlantType(model.Base):
         """,
         back_populates="_plant_assets",
     )
+
+
+class PlantAssetSeason(model.Base):
+    """
+    Associates one or more seasons with a plant asset.
+    """
+
+    __tablename__ = "asset_plant_season"
+    __versioned__ = {}
+
+    uuid = model.uuid_column()
+
+    plant_asset_uuid = model.uuid_fk_column("asset_plant.uuid", nullable=False)
+    plant_asset = orm.relationship(
+        PlantAsset,
+        foreign_keys=plant_asset_uuid,
+        back_populates="_seasons",
+    )
+
+    season_uuid = model.uuid_fk_column("season.uuid", nullable=False)
+    season = orm.relationship(
+        Season,
+        doc="""
+        Reference to the season.
+        """,
+        back_populates="_plant_assets",
+    )
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index ac4dc86..ff1022d 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -368,6 +368,12 @@ class PlantTypeImporter(ToFarmOSTaxonomy):
     farmos_taxonomy_type = "plant_type"
 
 
+class SeasonImporter(ToFarmOSTaxonomy):
+
+    model_title = "Season"
+    farmos_taxonomy_type = "season"
+
+
 class PlantAssetImporter(ToFarmOSAsset):
 
     model_title = "PlantAsset"
@@ -377,6 +383,7 @@ class PlantAssetImporter(ToFarmOSAsset):
         "uuid",
         "asset_name",
         "plant_type_uuids",
+        "season_uuids",
         "notes",
         "archived",
     ]
@@ -388,6 +395,9 @@ class PlantAssetImporter(ToFarmOSAsset):
                 "plant_type_uuids": [
                     UUID(p["id"]) for p in plant["relationships"]["plant_type"]["data"]
                 ],
+                "season_uuids": [
+                    UUID(p["id"]) for p in plant["relationships"]["season"]["data"]
+                ],
             }
         )
         return data
@@ -413,6 +423,15 @@ class PlantAssetImporter(ToFarmOSAsset):
                         "type": "taxonomy_term--plant_type",
                     }
                 )
+        if "season_uuids" in self.fields:
+            rels["season"] = {"data": []}
+            for uuid in source_data["season_uuids"]:
+                rels["season"]["data"].append(
+                    {
+                        "id": str(uuid),
+                        "type": "taxonomy_term--season",
+                    }
+                )
 
         payload["attributes"].update(attrs)
         if rels:
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index f4f4948..b492fac 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -102,6 +102,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
         importers["PlantType"] = PlantTypeImporter
+        importers["Season"] = SeasonImporter
         importers["PlantAsset"] = PlantAssetImporter
         importers["Unit"] = UnitImporter
         importers["StandardQuantity"] = StandardQuantityImporter
@@ -316,6 +317,28 @@ class PlantTypeImporter(FromWuttaFarm, farmos_importing.model.PlantTypeImporter)
         }
 
 
+class SeasonImporter(FromWuttaFarm, farmos_importing.model.SeasonImporter):
+    """
+    WuttaFarm → farmOS API exporter for Seasons
+    """
+
+    source_model_class = model.Season
+
+    supported_fields = [
+        "uuid",
+        "name",
+    ]
+
+    drupal_internal_id_field = "drupal_internal__tid"
+
+    def normalize_source_object(self, season):
+        return {
+            "uuid": season.farmos_uuid or self.app.make_true_uuid(),
+            "name": season.name,
+            "_src_object": season,
+        }
+
+
 class PlantAssetImporter(FromWuttaFarmAsset, farmos_importing.model.PlantAssetImporter):
     """
     WuttaFarm → farmOS API exporter for Plant Assets
@@ -328,6 +351,7 @@ class PlantAssetImporter(FromWuttaFarmAsset, farmos_importing.model.PlantAssetIm
         fields.extend(
             [
                 "plant_type_uuids",
+                "season_uuids",
             ]
         )
         return fields
@@ -336,9 +360,8 @@ class PlantAssetImporter(FromWuttaFarmAsset, farmos_importing.model.PlantAssetIm
         data = super().normalize_source_object(plant)
         data.update(
             {
-                "plant_type_uuids": [
-                    t.plant_type.farmos_uuid for t in plant._plant_types
-                ],
+                "plant_type_uuids": [pt.farmos_uuid for pt in plant.plant_types],
+                "season_uuids": [s.farmos_uuid for s in plant.seasons],
             }
         )
         return data
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index ea1fd4b..c0671a7 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -110,6 +110,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
         importers["PlantType"] = PlantTypeImporter
+        importers["Season"] = SeasonImporter
         importers["PlantAsset"] = PlantAssetImporter
         importers["Measure"] = MeasureImporter
         importers["Unit"] = UnitImporter
@@ -577,6 +578,34 @@ class PlantTypeImporter(FromFarmOS, ToWutta):
         }
 
 
+class SeasonImporter(FromFarmOS, ToWutta):
+    """
+    farmOS API → WuttaFarm importer for Seasons
+    """
+
+    model_class = model.Season
+
+    supported_fields = [
+        "farmos_uuid",
+        "drupal_id",
+        "name",
+        "description",
+    ]
+
+    def get_source_objects(self):
+        """ """
+        return list(self.farmos_client.resource.iterate("taxonomy_term", "season"))
+
+    def normalize_source_object(self, season):
+        """ """
+        return {
+            "farmos_uuid": UUID(season["id"]),
+            "drupal_id": season["attributes"]["drupal_internal__tid"],
+            "name": season["attributes"]["name"],
+            "description": season["attributes"]["description"],
+        }
+
+
 class PlantAssetImporter(AssetImporterBase):
     """
     farmOS API → WuttaFarm importer for Plant Assets
@@ -589,6 +618,7 @@ class PlantAssetImporter(AssetImporterBase):
         fields.extend(
             [
                 "plant_types",
+                "seasons",
             ]
         )
         return fields
@@ -602,11 +632,17 @@ class PlantAssetImporter(AssetImporterBase):
             if plant_type.farmos_uuid:
                 self.plant_types_by_farmos_uuid[plant_type.farmos_uuid] = plant_type
 
+        self.seasons_by_farmos_uuid = {}
+        for season in self.target_session.query(model.Season):
+            if season.farmos_uuid:
+                self.seasons_by_farmos_uuid[season.farmos_uuid] = season
+
     def normalize_source_object(self, plant):
         """ """
         data = super().normalize_source_object(plant)
 
         plant_types = []
+        seasons = []
         if relationships := plant.get("relationships"):
 
             if plant_type := relationships.get("plant_type"):
@@ -619,9 +655,18 @@ class PlantAssetImporter(AssetImporterBase):
                     else:
                         log.warning("plant type not found: %s", plant_type["id"])
 
+            if season := relationships.get("season"):
+                seasons = []
+                for season in season["data"]:
+                    if wf_season := self.seasons_by_farmos_uuid.get(UUID(season["id"])):
+                        seasons.append(wf_season.uuid)
+                    else:
+                        log.warning("season not found: %s", season["id"])
+
         data.update(
             {
                 "plant_types": set(plant_types),
+                "seasons": set(seasons),
             }
         )
         return data
@@ -632,6 +677,9 @@ class PlantAssetImporter(AssetImporterBase):
         if "plant_types" in self.fields:
             data["plant_types"] = set([pt.uuid for pt in plant.plant_types])
 
+        if "seasons" in self.fields:
+            data["seasons"] = set([s.uuid for s in plant.seasons])
+
         return data
 
     def update_target_object(self, plant, source_data, target_data=None):
@@ -664,6 +712,25 @@ class PlantAssetImporter(AssetImporterBase):
                             )
                             self.target_session.delete(plant_type)
 
+        if "seasons" in self.fields:
+            if not target_data or target_data["seasons"] != source_data["seasons"]:
+
+                for uuid in source_data["seasons"]:
+                    if not target_data or uuid not in target_data["seasons"]:
+                        self.target_session.flush()
+                        plant._seasons.append(model.PlantAssetSeason(season_uuid=uuid))
+
+                if target_data:
+                    for uuid in target_data["seasons"]:
+                        if uuid not in source_data["seasons"]:
+                            season = (
+                                self.target_session.query(model.PlantAssetSeason)
+                                .filter(model.PlantAssetSeason.plant_asset == plant)
+                                .filter(model.PlantAssetSeason.season_uuid == uuid)
+                                .one()
+                            )
+                            self.target_session.delete(season)
+
         return plant
 
 
diff --git a/src/wuttafarm/normal.py b/src/wuttafarm/normal.py
index 2e38f49..38edbab 100644
--- a/src/wuttafarm/normal.py
+++ b/src/wuttafarm/normal.py
@@ -125,6 +125,11 @@ class Normalizer(GenericHandler):
                             }
                         )
 
+        # if self.farmos_4x:
+        #     archived = asset["attributes"]["archived"]
+        # else:
+        #     archived = asset["attributes"]["status"] == "archived"
+
         return {
             "uuid": asset["id"],
             "drupal_id": asset["attributes"]["drupal_internal__id"],
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index bad5670..2bcb4c8 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -288,6 +288,31 @@ class PlantTypeRefs(WuttaSet):
         return PlantTypeRefsWidget(self.request, **kwargs)
 
 
+class SeasonRefs(WuttaSet):
+    """
+    Schema type for Plant Types field (on a Plant Asset).
+    """
+
+    def serialize(self, node, appstruct):
+        if not appstruct:
+            return []
+
+        return [season.uuid.hex for season in appstruct]
+
+    def widget_maker(self, **kwargs):
+        from wuttafarm.web.forms.widgets import SeasonRefsWidget
+
+        model = self.app.model
+        session = Session()
+
+        if "values" not in kwargs:
+            seasons = session.query(model.Season).order_by(model.Season.name).all()
+            values = [(s.uuid.hex, str(s)) for s in seasons]
+            kwargs["values"] = values
+
+        return SeasonRefsWidget(self.request, **kwargs)
+
+
 class StructureType(colander.SchemaType):
 
     def __init__(self, request, *args, **kwargs):
diff --git a/src/wuttafarm/web/forms/widgets.py b/src/wuttafarm/web/forms/widgets.py
index d74a436..6cf1cfc 100644
--- a/src/wuttafarm/web/forms/widgets.py
+++ b/src/wuttafarm/web/forms/widgets.py
@@ -332,6 +332,78 @@ class PlantTypeRefsWidget(Widget):
         return set(pstruct.split(","))
 
 
+class SeasonRefsWidget(Widget):
+    """
+    Widget for Seasons field (on a Plant Asset).
+    """
+
+    template = "seasonrefs"
+    values = ()
+
+    def __init__(self, request, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    def serialize(self, field, cstruct, **kw):
+        """ """
+        model = self.app.model
+        session = Session()
+
+        if cstruct in (colander.null, None):
+            cstruct = ()
+
+        if readonly := kw.get("readonly", self.readonly):
+            items = []
+
+            seasons = (
+                session.query(model.Season)
+                .filter(model.Season.uuid.in_(cstruct))
+                .order_by(model.Season.name)
+                .all()
+            )
+
+            for season in seasons:
+                items.append(
+                    HTML.tag(
+                        "li",
+                        c=tags.link_to(
+                            str(season),
+                            self.request.route_url("seasons.view", uuid=season.uuid),
+                        ),
+                    )
+                )
+
+            return HTML.tag("ul", c=items)
+
+        values = kw.get("values", self.values)
+        if not isinstance(values, sequence_types):
+            raise TypeError("Values must be a sequence type (list, tuple, or range).")
+
+        kw["values"] = _normalize_choices(values)
+        tmpl_values = self.get_template_values(field, cstruct, kw)
+        return field.renderer(self.template, **tmpl_values)
+
+    def get_template_values(self, field, cstruct, kw):
+        """ """
+        values = super().get_template_values(field, cstruct, kw)
+
+        values["js_values"] = json.dumps(values["values"])
+
+        if self.request.has_perm("seasons.create"):
+            values["can_create"] = True
+
+        return values
+
+    def deserialize(self, field, pstruct):
+        """ """
+        if not pstruct:
+            return set()
+
+        return set(pstruct.split(","))
+
+
 class StructureWidget(Widget):
     """
     Widget to display a "structure" field.
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index fe7719e..3b75b4e 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -128,6 +128,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "plant_types",
                     "perm": "plant_types.list",
                 },
+                {
+                    "title": "Seasons",
+                    "route": "seasons",
+                    "perm": "seasons.list",
+                },
                 {
                     "title": "Structure Types",
                     "route": "structure_types",
@@ -281,6 +286,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_plant_types",
                     "perm": "farmos_plant_types.list",
                 },
+                {
+                    "title": "Seasons",
+                    "route": "farmos_seasons",
+                    "perm": "farmos_seasons.list",
+                },
                 {
                     "title": "Structure Types",
                     "route": "farmos_structure_types",
@@ -369,6 +379,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_plant_types",
                     "perm": "farmos_plant_types.list",
                 },
+                {
+                    "title": "Seasons",
+                    "route": "farmos_seasons",
+                    "perm": "farmos_seasons.list",
+                },
                 {
                     "title": "Structure Types",
                     "route": "farmos_structure_types",
diff --git a/src/wuttafarm/web/templates/deform/seasonrefs.pt b/src/wuttafarm/web/templates/deform/seasonrefs.pt
new file mode 100644
index 0000000..955241a
--- /dev/null
+++ b/src/wuttafarm/web/templates/deform/seasonrefs.pt
@@ -0,0 +1,13 @@
+<div tal:define="
+     name name|field.name;
+     oid oid|field.oid;
+     vmodel vmodel|'modelData.'+oid;
+     can_create can_create|False;"
+     tal:omit-tag="">
+
+  <seasons-picker tal:attributes="name name;
+                                  v-model vmodel;
+                                  :seasons js_values;
+                                  :can-create str(can_create).lower();" />
+
+</div>
diff --git a/src/wuttafarm/web/templates/wuttafarm-components.mako b/src/wuttafarm/web/templates/wuttafarm-components.mako
index 1a07690..c537489 100644
--- a/src/wuttafarm/web/templates/wuttafarm-components.mako
+++ b/src/wuttafarm/web/templates/wuttafarm-components.mako
@@ -3,6 +3,7 @@
   ${self.make_assets_picker_component()}
   ${self.make_animal_type_picker_component()}
   ${self.make_plant_types_picker_component()}
+  ${self.make_seasons_picker_component()}
 </%def>
 
 <%def name="make_assets_picker_component()">
@@ -433,3 +434,199 @@
     <% request.register_component('plant-types-picker', 'PlantTypesPicker') %>
   </script>
 </%def>
+
+<%def name="make_seasons_picker_component()">
+  <script type="text/x-template" id="seasons-picker-template">
+    <div>
+      <input type="hidden" :name="name" :value="value" />
+
+      <div style="display: flex; gap: 0.5rem; align-items: center;">
+
+        <span>Add:</span>
+
+        <b-autocomplete v-model="addName"
+                        ref="addName"
+                        :data="addNameData"
+                        field="name"
+                        open-on-focus
+                        keep-first
+                        @select="addNameSelected"
+                        clear-on-select
+                        style="flex-grow: 1;">
+          <template #empty>No results found</template>
+        </b-autocomplete>
+
+        <b-button type="is-primary"
+                  icon-pack="fas"
+                  icon-left="plus"
+                  @click="createInit()">
+          New
+        </b-button>
+
+      </div>
+
+      <${b}-table :data="seasonData">
+
+        <${b}-table-column field="name" v-slot="props">
+          <span>{{ props.row.name }}</span>
+        </${b}-table-column>
+
+        <${b}-table-column v-slot="props">
+            <a href="#"
+               class="has-text-danger"
+               @click.prevent="removeSeason(props.row)">
+              <i class="fas fa-trash" /> &nbsp; Remove
+            </a>
+        </${b}-table-column>
+
+      </${b}-table>
+
+      <${b}-modal v-if="canCreate"
+                  has-modal-card
+                  % if request.use_oruga:
+                  v-model:active="createShowDialog"
+                  % else:
+                  :active.sync="createShowDialog"
+                  % endif
+                  >
+        <div class="modal-card">
+
+          <header class="modal-card-head">
+            <p class="modal-card-title">New Season</p>
+          </header>
+
+          <section class="modal-card-body">
+            <b-field label="Name" horizontal>
+              <b-input v-model="createName"
+                       ref="createName"
+                       expanded
+                       @keydown.native="createNameKeydown" />
+            </b-field>
+          </section>
+
+          <footer class="modal-card-foot">
+            <b-button type="is-primary"
+                      @click="createSave()"
+                      :disabled="createSaving || !createName"
+                      icon-pack="fas"
+                      icon-left="save">
+              {{ createSaving ? "Working, please wait..." : "Save" }}
+            </b-button>
+            <b-button @click="createShowDialog = false">
+              Cancel
+            </b-button>
+          </footer>
+        </div>
+      </${b}-modal>
+    </div>
+  </script>
+  <script>
+    const SeasonsPicker = {
+        template: '#seasons-picker-template',
+        mixins: [WuttaRequestMixin],
+        props: {
+            name: String,
+            value: Array,
+            seasons: Array,
+            canCreate: Boolean,
+        },
+        data() {
+            return {
+                internalSeasons: this.seasons.map((pt) => {
+                    return {uuid: pt[0], name: pt[1]}
+                }),
+
+                addName: '',
+
+                createShowDialog: false,
+                createName: null,
+                createSaving: false,
+            }
+        },
+        computed: {
+            seasonData() {
+                const data = []
+
+                if (this.value) {
+                    for (let ptype of this.internalSeasons) {
+                        if (this.value.includes(ptype.uuid)) {
+                            data.push(ptype)
+                        }
+                    }
+                }
+
+                return data
+            },
+            addNameData() {
+                if (!this.addName) {
+                    return this.internalSeasons
+                }
+
+                return this.internalSeasons.filter((ptype) => {
+                    return ptype.name.toLowerCase().indexOf(this.addName.toLowerCase()) >= 0
+                })
+            },
+        },
+        methods: {
+
+            addNameSelected(option) {
+                const value = Array.from(this.value || [])
+
+                if (!value.includes(option.uuid)) {
+                    value.push(option.uuid)
+                    this.$emit('input', value)
+                }
+
+                this.addName = null
+            },
+
+            createInit() {
+                this.createName = this.addName
+                this.createShowDialog = true
+                this.$nextTick(() => {
+                    this.$refs.createName.focus()
+                })
+            },
+
+            createNameKeydown(event) {
+                // nb. must prevent main form submit on ENTER
+                // (since ultimately this lives within an outer form)
+                // but also we can submit the modal pseudo-form
+                if (event.which == 13) {
+                    event.preventDefault()
+                    this.createSave()
+                }
+            },
+
+            createSave() {
+                this.createSaving = true
+                ## TODO
+                % if not app.is_farmos_wrapper():
+                const url = "${url('seasons.ajax_create')}"
+                % endif
+                const params = {name: this.createName}
+                this.wuttaPOST(url, params, response => {
+                    this.internalSeasons.push(response.data)
+                    const value = Array.from(this.value || [])
+                    value.push(response.data.uuid)
+                    this.$emit('input', value)
+                    this.addName = null
+                    this.createSaving = false
+                    this.createShowDialog = false
+                }, response => {
+                    this.createSaving = false
+                })
+            },
+
+            removeSeason(ptype) {
+                let value = Array.from(this.value)
+                const i = value.indexOf(ptype.uuid)
+                value.splice(i, 1)
+                this.$emit('input', value)
+            },
+        },
+    }
+    Vue.component('seasons-picker', SeasonsPicker)
+    <% request.register_component('seasons-picker', 'SeasonsPicker') %>
+  </script>
+</%def>
diff --git a/src/wuttafarm/web/views/common.py b/src/wuttafarm/web/views/common.py
index 674d76e..445f810 100644
--- a/src/wuttafarm/web/views/common.py
+++ b/src/wuttafarm/web/views/common.py
@@ -95,6 +95,8 @@ class CommonView(base.CommonView):
                 "farmos_quantities_standard.view",
                 "farmos_quantity_types.list",
                 "farmos_quantity_types.view",
+                "farmos_seasons.list",
+                "farmos_seasons.view",
                 "farmos_structure_assets.list",
                 "farmos_structure_assets.view",
                 "farmos_structure_types.list",
@@ -132,6 +134,12 @@ class CommonView(base.CommonView):
                 "logs_observation.view",
                 "logs_observation.versions",
                 "quick.eggs",
+                "plant_types.list",
+                "plant_types.view",
+                "plant_types.versions",
+                "seasons.list",
+                "seasons.view",
+                "seasons.versions",
                 "structure_types.list",
                 "structure_types.view",
                 "structure_types.versions",
diff --git a/src/wuttafarm/web/views/farmos/plants.py b/src/wuttafarm/web/views/farmos/plants.py
index 57bf2d4..40768c4 100644
--- a/src/wuttafarm/web/views/farmos/plants.py
+++ b/src/wuttafarm/web/views/farmos/plants.py
@@ -32,7 +32,12 @@ from wuttaweb.forms.widgets import WuttaDateTimeWidget
 
 from wuttafarm.web.views.farmos.master import TaxonomyMasterView
 from wuttafarm.web.views.farmos import FarmOSMasterView
-from wuttafarm.web.forms.schema import UsersType, StructureType, FarmOSPlantTypes
+from wuttafarm.web.forms.schema import (
+    UsersType,
+    StructureType,
+    FarmOSPlantTypes,
+    FarmOSRefs,
+)
 from wuttafarm.web.forms.widgets import ImageWidget
 
 
@@ -75,6 +80,43 @@ class PlantTypeView(TaxonomyMasterView):
         return buttons
 
 
+class SeasonView(TaxonomyMasterView):
+    """
+    Master view for Seasons in farmOS.
+    """
+
+    model_name = "farmos_season"
+    model_title = "farmOS Season"
+    model_title_plural = "farmOS Seasons"
+
+    route_prefix = "farmos_seasons"
+    url_prefix = "/farmOS/seasons"
+
+    farmos_taxonomy_type = "season"
+    farmos_refurl_path = "/admin/structure/taxonomy/manage/season/overview"
+
+    def get_xref_buttons(self, season):
+        buttons = super().get_xref_buttons(season)
+        model = self.app.model
+        session = self.Session()
+
+        if wf_season := (
+            session.query(model.Season)
+            .filter(model.Season.farmos_uuid == season["uuid"])
+            .first()
+        ):
+            buttons.append(
+                self.make_button(
+                    f"View {self.app.get_title()} record",
+                    primary=True,
+                    url=self.request.route_url("seasons.view", uuid=wf_season.uuid),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+
 class PlantAssetView(FarmOSMasterView):
     """
     Master view for farmOS Plant Assets
@@ -89,6 +131,10 @@ class PlantAssetView(FarmOSMasterView):
 
     farmos_refurl_path = "/assets/plant"
 
+    labels = {
+        "seasons": "Season",
+    }
+
     grid_columns = [
         "name",
         "archived",
@@ -99,6 +145,7 @@ class PlantAssetView(FarmOSMasterView):
     form_fields = [
         "name",
         "plant_types",
+        "seasons",
         "archived",
         "owners",
         "location",
@@ -151,6 +198,21 @@ class PlantAssetView(FarmOSMasterView):
                             }
                         )
 
+            # add seasons
+            if seasons := relationships.get("season"):
+                if seasons["data"]:
+                    data["seasons"] = []
+                    for season in seasons["data"]:
+                        season = self.farmos_client.resource.get_id(
+                            "taxonomy_term", "season", season["id"]
+                        )
+                        data["seasons"].append(
+                            {
+                                "uuid": season["data"]["id"],
+                                "name": season["data"]["attributes"]["name"],
+                            }
+                        )
+
             # add location
             if location := relationships.get("location"):
                 if location["data"]:
@@ -199,22 +261,14 @@ class PlantAssetView(FarmOSMasterView):
         return plant["name"]
 
     def normalize_plant(self, plant):
-
-        if notes := plant["attributes"]["notes"]:
-            notes = notes["value"]
-
-        if self.farmos_4x:
-            archived = plant["attributes"]["archived"]
-        else:
-            archived = plant["attributes"]["status"] == "archived"
-
+        normal = self.normal.normalize_farmos_asset(plant)
         return {
-            "uuid": plant["id"],
-            "drupal_id": plant["attributes"]["drupal_internal__id"],
-            "name": plant["attributes"]["name"],
+            "uuid": normal["uuid"],
+            "drupal_id": normal["drupal_id"],
+            "name": normal["asset_name"],
             "location": colander.null,  # TODO
-            "archived": archived,
-            "notes": notes or colander.null,
+            "archived": normal["archived"],
+            "notes": normal["notes"] or colander.null,
         }
 
     def configure_form(self, form):
@@ -225,6 +279,9 @@ class PlantAssetView(FarmOSMasterView):
         # plant_types
         f.set_node("plant_types", FarmOSPlantTypes(self.request))
 
+        # seasons
+        f.set_node("seasons", FarmOSRefs(self.request, "farmos_seasons"))
+
         # location
         f.set_node("location", StructureType(self.request))
 
@@ -279,6 +336,9 @@ def defaults(config, **kwargs):
     PlantTypeView = kwargs.get("PlantTypeView", base["PlantTypeView"])
     PlantTypeView.defaults(config)
 
+    SeasonView = kwargs.get("SeasonView", base["SeasonView"])
+    SeasonView.defaults(config)
+
     PlantAssetView = kwargs.get("PlantAssetView", base["PlantAssetView"])
     PlantAssetView.defaults(config)
 
diff --git a/src/wuttafarm/web/views/plants.py b/src/wuttafarm/web/views/plants.py
index 2d4bdce..16bd3c0 100644
--- a/src/wuttafarm/web/views/plants.py
+++ b/src/wuttafarm/web/views/plants.py
@@ -28,9 +28,9 @@ from webhelpers2.html import tags
 from wuttaweb.forms.schema import WuttaDictEnum
 from wuttaweb.util import get_form_data
 
-from wuttafarm.db.model import PlantType, PlantAsset
+from wuttafarm.db.model import PlantType, Season, PlantAsset
 from wuttafarm.web.views.assets import AssetTypeMasterView, AssetMasterView
-from wuttafarm.web.forms.schema import PlantTypeRefs
+from wuttafarm.web.forms.schema import PlantTypeRefs, SeasonRefs
 from wuttafarm.web.forms.widgets import ImageWidget
 from wuttafarm.web.util import get_farmos_client_for_user
 
@@ -195,6 +195,166 @@ class PlantTypeView(AssetTypeMasterView):
         )
 
 
+class SeasonView(AssetTypeMasterView):
+    """
+    Master view for Seasons
+    """
+
+    model_class = Season
+    route_prefix = "seasons"
+    url_prefix = "/seasons"
+
+    farmos_entity_type = "taxonomy_term"
+    farmos_bundle = "season"
+    farmos_refurl_path = "/admin/structure/taxonomy/manage/season/overview"
+
+    grid_columns = [
+        "name",
+        "description",
+    ]
+
+    sort_defaults = "name"
+
+    filter_defaults = {
+        "name": {"active": True, "verb": "contains"},
+    }
+
+    form_fields = [
+        "name",
+        "description",
+        "drupal_id",
+        "farmos_uuid",
+    ]
+
+    has_rows = True
+    row_model_class = PlantAsset
+    rows_viewable = True
+
+    row_grid_columns = [
+        "asset_name",
+        "archived",
+    ]
+
+    rows_sort_defaults = "asset_name"
+
+    def configure_grid(self, grid):
+        g = grid
+        super().configure_grid(g)
+
+        # name
+        g.set_link("name")
+
+    def get_farmos_url(self, season):
+        return self.app.get_farmos_url(f"/taxonomy/term/{season.drupal_id}")
+
+    def get_xref_buttons(self, season):
+        buttons = super().get_xref_buttons(season)
+
+        if season.farmos_uuid:
+            buttons.append(
+                self.make_button(
+                    "View farmOS record",
+                    primary=True,
+                    url=self.request.route_url(
+                        "farmos_seasons.view", uuid=season.farmos_uuid
+                    ),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+    def delete(self):
+        season = self.get_instance()
+
+        if season._plant_assets:
+            self.request.session.flash(
+                "Cannot delete season which is still referenced by plant assets.",
+                "warning",
+            )
+            url = self.get_action_url("view", season)
+            return self.redirect(self.request.get_referrer(default=url))
+
+        return super().delete()
+
+    def get_row_grid_data(self, season):
+        model = self.app.model
+        session = self.Session()
+        return (
+            session.query(model.PlantAsset)
+            .join(model.Asset)
+            .outerjoin(model.PlantAssetSeason)
+            .filter(model.PlantAssetSeason.season == season)
+        )
+
+    def configure_row_grid(self, grid):
+        g = grid
+        super().configure_row_grid(g)
+        model = self.app.model
+
+        # asset_name
+        g.set_link("asset_name")
+        g.set_sorter("asset_name", model.Asset.asset_name)
+        g.set_filter("asset_name", model.Asset.asset_name)
+
+        # archived
+        g.set_renderer("archived", "boolean")
+        g.set_sorter("archived", model.Asset.archived)
+        g.set_filter("archived", model.Asset.archived)
+
+    def get_row_action_url_view(self, plant, i):
+        return self.request.route_url("plant_assets.view", uuid=plant.uuid)
+
+    def ajax_create(self):
+        """
+        AJAX view to create a new season.
+        """
+        model = self.app.model
+        session = self.Session()
+        data = get_form_data(self.request)
+
+        name = data.get("name")
+        if not name:
+            return {"error": "Name is required"}
+
+        season = model.Season(name=name)
+        session.add(season)
+        session.flush()
+
+        if self.app.is_farmos_mirror():
+            client = get_farmos_client_for_user(self.request)
+            self.app.auto_sync_to_farmos(season, client=client)
+
+        return {
+            "uuid": season.uuid.hex,
+            "name": season.name,
+            "farmos_uuid": season.farmos_uuid.hex,
+            "drupal_id": season.drupal_id,
+        }
+
+    @classmethod
+    def defaults(cls, config):
+        """ """
+        cls._defaults(config)
+        cls._season_defaults(config)
+
+    @classmethod
+    def _season_defaults(cls, config):
+        route_prefix = cls.get_route_prefix()
+        permission_prefix = cls.get_permission_prefix()
+        url_prefix = cls.get_url_prefix()
+
+        # ajax_create
+        config.add_route(f"{route_prefix}.ajax_create", f"{url_prefix}/ajax/new")
+        config.add_view(
+            cls,
+            attr="ajax_create",
+            route_name=f"{route_prefix}.ajax_create",
+            permission=f"{permission_prefix}.create",
+            renderer="json",
+        )
+
+
 class PlantAssetView(AssetMasterView):
     """
     Master view for Plant Assets
@@ -209,6 +369,7 @@ class PlantAssetView(AssetMasterView):
 
     labels = {
         "plant_types": "Crop/Variety",
+        "seasons": "Season",
     }
 
     grid_columns = [
@@ -254,17 +415,26 @@ class PlantAssetView(AssetMasterView):
             f.set_default("plant_types", [pt.uuid for pt in plant.plant_types])
 
         # season
-        if not (self.creating or self.editing):  # TODO
-            f.fields.insert_after("plant_types", "season")
+        f.fields.insert_after("plant_types", "seasons")
+        f.set_node("seasons", SeasonRefs(self.request))
+        f.set_required("seasons", False)
+        if not self.creating:
+            # nb. must explcitly declare value for non-standard field
+            f.set_default("seasons", plant.seasons)
 
     def objectify(self, form):
-        model = self.app.model
-        session = self.Session()
         plant = super().objectify(form)
         data = form.validated
 
+        self.set_plant_types(plant, data["plant_types"])
+        self.set_seasons(plant, data["seasons"])
+
+        return plant
+
+    def set_plant_types(self, plant, desired):
+        model = self.app.model
+        session = self.Session()
         current = [pt.uuid for pt in plant.plant_types]
-        desired = data["plant_types"]
 
         for uuid in desired:
             if uuid not in current:
@@ -278,7 +448,22 @@ class PlantAssetView(AssetMasterView):
                 assert plant_type
                 plant.plant_types.remove(plant_type)
 
-        return plant
+    def set_seasons(self, plant, desired):
+        model = self.app.model
+        session = self.Session()
+        current = [s.uuid for s in plant.seasons]
+
+        for uuid in desired:
+            if uuid not in current:
+                season = session.get(model.Season, uuid)
+                assert season
+                plant.seasons.append(season)
+
+        for uuid in current:
+            if uuid not in desired:
+                season = session.get(model.Season, uuid)
+                assert season
+                plant.seasons.remove(season)
 
 
 def defaults(config, **kwargs):
@@ -287,6 +472,9 @@ def defaults(config, **kwargs):
     PlantTypeView = kwargs.get("PlantTypeView", base["PlantTypeView"])
     PlantTypeView.defaults(config)
 
+    SeasonView = kwargs.get("SeasonView", base["SeasonView"])
+    SeasonView.defaults(config)
+
     PlantAssetView = kwargs.get("PlantAssetView", base["PlantAssetView"])
     PlantAssetView.defaults(config)
 

From 6d80937e0c31aad382cabf620e4369f672494784 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Fri, 6 Mar 2026 21:59:38 -0600
Subject: [PATCH 06/20] feat: expose Assets field when editing a Log record

---
 src/wuttafarm/web/views/logs.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/wuttafarm/web/views/logs.py b/src/wuttafarm/web/views/logs.py
index 9c983b7..0a893c2 100644
--- a/src/wuttafarm/web/views/logs.py
+++ b/src/wuttafarm/web/views/logs.py
@@ -256,10 +256,9 @@ class LogMasterView(WuttaFarmMasterView):
             f.set_default("timestamp", self.app.make_utc())
 
         # assets
-        if self.creating or self.editing:
-            f.remove("assets")  # TODO: need to support this
-        else:
-            f.set_node("assets", AssetRefs(self.request))
+        f.set_node("assets", AssetRefs(self.request))
+        f.set_required("assets", False)
+        if not self.creating:
             # nb. must explicity declare value for non-standard field
             f.set_default("assets", log.assets)
 
@@ -324,13 +323,33 @@ class LogMasterView(WuttaFarmMasterView):
 
     def objectify(self, form):
         log = super().objectify(form)
+        data = form.validated
 
         if self.creating:
             model_class = self.get_model_class()
             log.log_type = self.get_farmos_log_type()
 
+        self.set_assets(log, data["assets"] or [])
+
         return log
 
+    def set_assets(self, log, desired):
+        model = self.app.model
+        session = self.Session()
+        current = [a.uuid for a in log.assets]
+
+        for uuid in desired:
+            if uuid not in current:
+                asset = session.get(model.Asset, uuid)
+                assert asset
+                log.assets.append(asset)
+
+        for uuid in current:
+            if uuid not in desired:
+                asset = session.get(model.Asset, uuid)
+                assert asset
+                log.assets.remove(asset)
+
     def get_farmos_url(self, log):
         return self.app.get_farmos_url(f"/log/{log.drupal_id}")
 

From 797c045f678b4502ac2150f525673fef0ef749f0 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sat, 7 Mar 2026 10:27:45 -0600
Subject: [PATCH 07/20] feat: add edit/sync support for `Log.locations`

also set `Log.owners` to current user, when creating new log
---
 src/wuttafarm/farmos/importing/model.py     | 14 +++++++++
 src/wuttafarm/farmos/importing/wuttafarm.py |  2 ++
 src/wuttafarm/web/forms/schema.py           |  5 +++-
 src/wuttafarm/web/forms/widgets.py          |  2 +-
 src/wuttafarm/web/views/logs.py             | 32 +++++++++++++++++----
 5 files changed, 47 insertions(+), 8 deletions(-)

diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index ff1022d..0593d22 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -631,6 +631,7 @@ class ToFarmOSLog(ToFarmOS):
         "notes",
         "quick",
         "assets",
+        "locations",
         "quantities",
     ]
 
@@ -693,6 +694,9 @@ class ToFarmOSLog(ToFarmOS):
             "notes": normal["notes"],
             "quick": normal["quick"],
             "assets": [(a["asset_type"], UUID(a["uuid"])) for a in normal["assets"]],
+            "locations": [
+                (l["asset_type"], UUID(l["uuid"])) for l in normal["locations"]
+            ],
             "quantities": [UUID(uuid) for uuid in normal["quantity_uuids"]],
         }
 
@@ -725,6 +729,16 @@ class ToFarmOSLog(ToFarmOS):
                     }
                 )
             rels["asset"] = {"data": assets}
+        if "locations" in self.fields:
+            locations = []
+            for asset_type, uuid in source_data["locations"]:
+                locations.append(
+                    {
+                        "type": f"asset--{asset_type}",
+                        "id": str(uuid),
+                    }
+                )
+            rels["location"] = {"data": locations}
         if "quantities" in self.fields:
             quantities = []
             for uuid in source_data["quantities"]:
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index b492fac..74b2b7e 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -458,6 +458,7 @@ class FromWuttaFarmLog(FromWuttaFarm):
         "notes",
         "quick",
         "assets",
+        "locations",
         "quantities",
     ]
 
@@ -472,6 +473,7 @@ class FromWuttaFarmLog(FromWuttaFarm):
             "notes": log.notes,
             "quick": self.config.parse_list(log.quick) if log.quick else [],
             "assets": [(a.asset_type, a.farmos_uuid) for a in log.assets],
+            "locations": [(l.asset_type, l.farmos_uuid) for l in log.locations],
             "quantities": [qty.farmos_uuid for qty in log.quantities],
             "_src_object": log,
         }
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index 2bcb4c8..ac5279b 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -402,9 +402,10 @@ class AssetRefs(WuttaSet):
     Schema type for Assets field (on a Log record)
     """
 
-    def __init__(self, request, for_asset=None, **kwargs):
+    def __init__(self, request, for_asset=None, is_location=None, **kwargs):
         super().__init__(request, **kwargs)
         self.for_asset = for_asset
+        self.is_location = is_location
 
     def serialize(self, node, appstruct):
         if not appstruct:
@@ -420,6 +421,8 @@ class AssetRefs(WuttaSet):
 
         if "values" not in kwargs:
             query = session.query(model.Asset)
+            if self.is_location is not None:
+                query = query.filter(model.Asset.is_location == self.is_location)
             if self.for_asset:
                 query = query.filter(model.Asset.uuid != self.for_asset.uuid)
             query = query.order_by(model.Asset.asset_name)
diff --git a/src/wuttafarm/web/forms/widgets.py b/src/wuttafarm/web/forms/widgets.py
index 6cf1cfc..545ea78 100644
--- a/src/wuttafarm/web/forms/widgets.py
+++ b/src/wuttafarm/web/forms/widgets.py
@@ -521,7 +521,7 @@ class AssetRefsWidget(Widget):
     def deserialize(self, field, pstruct):
         """ """
         if not pstruct:
-            return colander.null
+            return set()
 
         return set(pstruct.split(","))
 
diff --git a/src/wuttafarm/web/views/logs.py b/src/wuttafarm/web/views/logs.py
index 0a893c2..ce08097 100644
--- a/src/wuttafarm/web/views/logs.py
+++ b/src/wuttafarm/web/views/logs.py
@@ -271,10 +271,8 @@ class LogMasterView(WuttaFarmMasterView):
             f.set_default("groups", log.groups)
 
         # locations
-        if self.creating or self.editing:
-            f.remove("locations")  # TODO: need to support this
-        else:
-            f.set_node("locations", AssetRefs(self.request))
+        f.set_node("locations", AssetRefs(self.request, is_location=True))
+        if not self.creating:
             # nb. must explicity declare value for non-standard field
             f.set_default("locations", log.locations)
 
@@ -326,10 +324,15 @@ class LogMasterView(WuttaFarmMasterView):
         data = form.validated
 
         if self.creating:
-            model_class = self.get_model_class()
+
+            # log_type
             log.log_type = self.get_farmos_log_type()
 
-        self.set_assets(log, data["assets"] or [])
+            # owner
+            log.owners = [self.request.user]
+
+        self.set_assets(log, data["assets"])
+        self.set_locations(log, data["locations"])
 
         return log
 
@@ -350,6 +353,23 @@ class LogMasterView(WuttaFarmMasterView):
                 assert asset
                 log.assets.remove(asset)
 
+    def set_locations(self, log, desired):
+        model = self.app.model
+        session = self.Session()
+        current = [l.uuid for l in log.locations]
+
+        for uuid in desired:
+            if uuid not in current:
+                location = session.get(model.Asset, uuid)
+                assert location
+                log.locations.append(location)
+
+        for uuid in current:
+            if uuid not in desired:
+                location = session.get(model.Asset, uuid)
+                assert location
+                log.locations.remove(location)
+
     def get_farmos_url(self, log):
         return self.app.get_farmos_url(f"/log/{log.drupal_id}")
 

From 1d303a818cd0f8409fbfb6e2dd456deb8b1a8e6d Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sat, 7 Mar 2026 10:40:42 -0600
Subject: [PATCH 08/20] feat: add edit/sync support for `Log.groups`

---
 src/wuttafarm/farmos/importing/model.py     | 12 +++++++++++
 src/wuttafarm/farmos/importing/wuttafarm.py |  2 ++
 src/wuttafarm/web/forms/schema.py           |  9 ++++++--
 src/wuttafarm/web/views/logs.py             | 24 +++++++++++++++++----
 4 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 0593d22..9994f55 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -632,6 +632,7 @@ class ToFarmOSLog(ToFarmOS):
         "quick",
         "assets",
         "locations",
+        "groups",
         "quantities",
     ]
 
@@ -697,6 +698,7 @@ class ToFarmOSLog(ToFarmOS):
             "locations": [
                 (l["asset_type"], UUID(l["uuid"])) for l in normal["locations"]
             ],
+            "groups": [(g["asset_type"], UUID(g["uuid"])) for g in normal["groups"]],
             "quantities": [UUID(uuid) for uuid in normal["quantity_uuids"]],
         }
 
@@ -739,6 +741,16 @@ class ToFarmOSLog(ToFarmOS):
                     }
                 )
             rels["location"] = {"data": locations}
+        if "groups" in self.fields:
+            groups = []
+            for asset_type, uuid in source_data["groups"]:
+                groups.append(
+                    {
+                        "type": f"asset--{asset_type}",
+                        "id": str(uuid),
+                    }
+                )
+            rels["group"] = {"data": groups}
         if "quantities" in self.fields:
             quantities = []
             for uuid in source_data["quantities"]:
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 74b2b7e..8b682a3 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -459,6 +459,7 @@ class FromWuttaFarmLog(FromWuttaFarm):
         "quick",
         "assets",
         "locations",
+        "groups",
         "quantities",
     ]
 
@@ -474,6 +475,7 @@ class FromWuttaFarmLog(FromWuttaFarm):
             "quick": self.config.parse_list(log.quick) if log.quick else [],
             "assets": [(a.asset_type, a.farmos_uuid) for a in log.assets],
             "locations": [(l.asset_type, l.farmos_uuid) for l in log.locations],
+            "groups": [(g.asset_type, g.farmos_uuid) for g in log.groups],
             "quantities": [qty.farmos_uuid for qty in log.quantities],
             "_src_object": log,
         }
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index ac5279b..2d56cd4 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -402,10 +402,13 @@ class AssetRefs(WuttaSet):
     Schema type for Assets field (on a Log record)
     """
 
-    def __init__(self, request, for_asset=None, is_location=None, **kwargs):
+    def __init__(
+        self, request, for_asset=None, is_group=None, is_location=None, **kwargs
+    ):
         super().__init__(request, **kwargs)
-        self.for_asset = for_asset
+        self.is_group = is_group
         self.is_location = is_location
+        self.for_asset = for_asset
 
     def serialize(self, node, appstruct):
         if not appstruct:
@@ -421,6 +424,8 @@ class AssetRefs(WuttaSet):
 
         if "values" not in kwargs:
             query = session.query(model.Asset)
+            if self.is_group is not None:
+                query = query.join(model.GroupAsset)
             if self.is_location is not None:
                 query = query.filter(model.Asset.is_location == self.is_location)
             if self.for_asset:
diff --git a/src/wuttafarm/web/views/logs.py b/src/wuttafarm/web/views/logs.py
index ce08097..9f53f50 100644
--- a/src/wuttafarm/web/views/logs.py
+++ b/src/wuttafarm/web/views/logs.py
@@ -263,10 +263,8 @@ class LogMasterView(WuttaFarmMasterView):
             f.set_default("assets", log.assets)
 
         # groups
-        if self.creating or self.editing:
-            f.remove("groups")  # TODO: need to support this
-        else:
-            f.set_node("groups", AssetRefs(self.request))
+        f.set_node("groups", AssetRefs(self.request, is_group=True))
+        if not self.creating:
             # nb. must explicity declare value for non-standard field
             f.set_default("groups", log.groups)
 
@@ -333,6 +331,7 @@ class LogMasterView(WuttaFarmMasterView):
 
         self.set_assets(log, data["assets"])
         self.set_locations(log, data["locations"])
+        self.set_groups(log, data["groups"])
 
         return log
 
@@ -370,6 +369,23 @@ class LogMasterView(WuttaFarmMasterView):
                 assert location
                 log.locations.remove(location)
 
+    def set_groups(self, log, desired):
+        model = self.app.model
+        session = self.Session()
+        current = [g.uuid for g in log.groups]
+
+        for uuid in desired:
+            if uuid not in current:
+                group = session.get(model.Asset, uuid)
+                assert group
+                log.groups.append(group)
+
+        for uuid in current:
+            if uuid not in desired:
+                group = session.get(model.Asset, uuid)
+                assert group
+                log.groups.remove(group)
+
     def get_farmos_url(self, log):
         return self.app.get_farmos_url(f"/log/{log.drupal_id}")
 

From a43f98c304397706ccccb4eb4251c8a6fda6b7e7 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sun, 8 Mar 2026 12:27:05 -0500
Subject: [PATCH 09/20] feat: add edit/sync support for Log Quantities

er, just Standard Quantities so far..and just supported enough to move
the ball forward, it still needs lots more polish
---
 src/wuttafarm/app.py                          |  26 ++
 src/wuttafarm/db/model/quantities.py          |   6 +-
 src/wuttafarm/web/forms/schema.py             |  33 +-
 src/wuttafarm/web/forms/widgets.py            |  85 ++++-
 .../web/templates/deform/quantityrefs.pt      |  13 +
 .../web/templates/wuttafarm-components.mako   | 352 ++++++++++++++++++
 src/wuttafarm/web/views/logs.py               |  61 ++-
 src/wuttafarm/web/views/master.py             |   5 +-
 8 files changed, 555 insertions(+), 26 deletions(-)
 create mode 100644 src/wuttafarm/web/templates/deform/quantityrefs.pt

diff --git a/src/wuttafarm/app.py b/src/wuttafarm/app.py
index cb9aed3..6bbca34 100644
--- a/src/wuttafarm/app.py
+++ b/src/wuttafarm/app.py
@@ -151,6 +151,32 @@ class WuttaFarmAppHandler(base.AppHandler):
         factory = self.load_object(spec)
         return factory(self.config, farmos_client)
 
+    def get_quantity_types(self, session=None):
+        """
+        Returns a list of all known quantity types.
+        """
+        model = self.model
+        with self.short_session(session=session) as sess:
+            return (
+                sess.query(model.QuantityType).order_by(model.QuantityType.name).all()
+            )
+
+    def get_measures(self, session=None):
+        """
+        Returns a list of all known measures.
+        """
+        model = self.model
+        with self.short_session(session=session) as sess:
+            return sess.query(model.Measure).order_by(model.Measure.name).all()
+
+    def get_units(self, session=None):
+        """
+        Returns a list of all known units.
+        """
+        model = self.model
+        with self.short_session(session=session) as sess:
+            return sess.query(model.Unit).order_by(model.Unit.name).all()
+
     def auto_sync_to_farmos(self, obj, model_name=None, client=None, require=True):
         """
         Export the given object to farmOS, using configured handler.
diff --git a/src/wuttafarm/db/model/quantities.py b/src/wuttafarm/db/model/quantities.py
index 4bed6a0..bcc2183 100644
--- a/src/wuttafarm/db/model/quantities.py
+++ b/src/wuttafarm/db/model/quantities.py
@@ -181,9 +181,13 @@ class Quantity(model.Base):
         creator=make_log_quantity,
     )
 
+    def get_value_decimal(self):
+        # TODO: should actually return a decimal here?
+        return self.value_numerator / self.value_denominator
+
     def render_as_text(self, config=None):
         measure = str(self.measure or self.measure_id or "")
-        value = self.value_numerator / self.value_denominator
+        value = self.get_value_decimal()
         if config:
             app = config.get_app()
             value = app.render_quantity(value)
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index 2d56cd4..f9dc33a 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -437,21 +437,46 @@ class AssetRefs(WuttaSet):
         return AssetRefsWidget(self.request, **kwargs)
 
 
-class LogQuantityRefs(WuttaSet):
+class QuantityRefs(colander.List):
     """
     Schema type for Quantities field (on a Log record)
     """
 
+    def __init__(self, request):
+        super().__init__()
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
     def serialize(self, node, appstruct):
         if not appstruct:
             return colander.null
 
-        return {qty.uuid for qty in appstruct}
+        quantities = []
+        for qty in appstruct:
+            quantities.append(
+                {
+                    "uuid": qty.uuid.hex,
+                    "quantity_type": {
+                        "id": qty.quantity_type_id,
+                        "name": qty.quantity_type.name,
+                    },
+                    "measure": qty.measure_id,
+                    "value": qty.get_value_decimal(),
+                    "units": {
+                        "uuid": qty.units.uuid.hex,
+                        "name": qty.units.name,
+                    },
+                    "as_text": qty.render_as_text(self.config),
+                }
+            )
+
+        return quantities
 
     def widget_maker(self, **kwargs):
-        from wuttafarm.web.forms.widgets import LogQuantityRefsWidget
+        from wuttafarm.web.forms.widgets import QuantityRefsWidget
 
-        return LogQuantityRefsWidget(self.request, **kwargs)
+        return QuantityRefsWidget(self.request, **kwargs)
 
 
 class OwnerRefs(WuttaSet):
diff --git a/src/wuttafarm/web/forms/widgets.py b/src/wuttafarm/web/forms/widgets.py
index 545ea78..f1cf067 100644
--- a/src/wuttafarm/web/forms/widgets.py
+++ b/src/wuttafarm/web/forms/widgets.py
@@ -526,11 +526,19 @@ class AssetRefsWidget(Widget):
         return set(pstruct.split(","))
 
 
-class LogQuantityRefsWidget(WuttaCheckboxChoiceWidget):
+class QuantityRefsWidget(Widget):
     """
     Widget for Quantities field (on a Log record)
     """
 
+    template = "quantityrefs"
+
+    def __init__(self, request, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
     def serialize(self, field, cstruct, **kw):
         """ """
         model = self.app.model
@@ -538,24 +546,71 @@ class LogQuantityRefsWidget(WuttaCheckboxChoiceWidget):
 
         readonly = kw.get("readonly", self.readonly)
         if readonly:
+            if not cstruct:
+                return ""
+
             quantities = []
-            for uuid in cstruct or []:
-                qty = session.get(model.Quantity, uuid)
-                quantities.append(
-                    HTML.tag(
-                        "li",
-                        c=tags.link_to(
-                            qty.render_as_text(self.config),
-                            # TODO
-                            self.request.route_url(
-                                "quantities_standard.view", uuid=qty.uuid
-                            ),
-                        ),
-                    )
+
+            for qty in cstruct:
+                # TODO: support more quantity types
+                url = self.request.route_url(
+                    "quantities_standard.view", uuid=qty["uuid"]
                 )
+                quantities.append(HTML.tag("li", c=tags.link_to(qty["as_text"], url)))
+
             return HTML.tag("ul", c=quantities)
 
-        return super().serialize(field, cstruct, **kw)
+        tmpl_values = self.get_template_values(field, cstruct, kw)
+        return field.renderer(self.template, **tmpl_values)
+
+    def get_template_values(self, field, cstruct, kw):
+        model = self.app.model
+        session = Session()
+        values = super().get_template_values(field, cstruct, kw)
+
+        qtypes = []
+        for qtype in self.app.get_quantity_types(session):
+            # TODO: add support for other quantity types
+            if qtype.drupal_id == "standard":
+                qtypes.append(
+                    {
+                        "uuid": qtype.uuid.hex,
+                        "drupal_id": qtype.drupal_id,
+                        "name": qtype.name,
+                    }
+                )
+        values["quantity_types"] = qtypes
+
+        measures = []
+        for measure in self.app.get_measures(session):
+            measures.append(
+                {
+                    "uuid": measure.uuid.hex,
+                    "drupal_id": measure.drupal_id,
+                    "name": measure.name,
+                }
+            )
+        values["measures"] = measures
+
+        units = []
+        for unit in self.app.get_units(session):
+            units.append(
+                {
+                    "uuid": unit.uuid.hex,
+                    "drupal_id": unit.drupal_id,
+                    "name": unit.name,
+                }
+            )
+        values["units"] = units
+
+        return values
+
+    def deserialize(self, field, pstruct):
+        """ """
+        if not pstruct:
+            return set()
+
+        return json.loads(pstruct)
 
 
 class OwnerRefsWidget(WuttaCheckboxChoiceWidget):
diff --git a/src/wuttafarm/web/templates/deform/quantityrefs.pt b/src/wuttafarm/web/templates/deform/quantityrefs.pt
new file mode 100644
index 0000000..5c98b84
--- /dev/null
+++ b/src/wuttafarm/web/templates/deform/quantityrefs.pt
@@ -0,0 +1,13 @@
+<div tal:define="
+     name name|field.name;
+     oid oid|field.oid;
+     vmodel vmodel|'modelData.'+oid;"
+     tal:omit-tag="">
+
+  <quantities-editor tal:attributes="name name;
+                                     v-model vmodel;
+                                     :quantity-types quantity_types;
+                                     :measures measures;
+                                     :units units;" />
+
+</div>
diff --git a/src/wuttafarm/web/templates/wuttafarm-components.mako b/src/wuttafarm/web/templates/wuttafarm-components.mako
index c537489..d735274 100644
--- a/src/wuttafarm/web/templates/wuttafarm-components.mako
+++ b/src/wuttafarm/web/templates/wuttafarm-components.mako
@@ -2,6 +2,8 @@
 <%def name="make_wuttafarm_components()">
   ${self.make_assets_picker_component()}
   ${self.make_animal_type_picker_component()}
+  ${self.make_quantity_editor_component()}
+  ${self.make_quantities_editor_component()}
   ${self.make_plant_types_picker_component()}
   ${self.make_seasons_picker_component()}
 </%def>
@@ -239,6 +241,356 @@
   </script>
 </%def>
 
+<%def name="make_quantity_editor_component()">
+  <script type="text/x-template" id="quantity-editor-template">
+    <div>
+
+      <b-field label="Measure" horizontal
+               ## TODO: why is this needed?
+               style="margin-bottom: 1rem;">
+        <b-select v-model="value.measure"
+                  ref="measure">
+          <option v-for="m in measures"
+                  :value="m.drupal_id">
+            {{ m.name }}
+          </option>
+      </b-field>
+
+      <b-field label="Value" horizontal
+               ## TODO: why is this needed?
+               style="margin-bottom: 1rem;">
+        <b-input v-model="value.value"
+                 ref="value"
+                 @keydown.native="inputKeydown" />
+      </b-field>
+
+      <b-field label="Units" horizontal
+               style="margin-bottom: 1rem;">
+
+        <b-button v-if="value.units.uuid"
+                  @click="changeUnit()">
+          {{ value.units.name }} &nbsp; &nbsp; (click to change)
+        </b-button>
+
+        <b-autocomplete v-show="!value.units.uuid"
+                        v-model="unitsName"
+                        ref="unitsName"
+                        :data="unitsNameData"
+                        field="name"
+                        open-on-focus
+                        keep-first
+                        @select="unitsNameSelected"
+                        clear-on-select>
+          <template #empty>No results found</template>
+        </b-autocomplete>
+
+      </b-field>
+
+      <div class="buttons" style="margin-left: 8rem;">
+        <b-button type="is-primary"
+                  ref="save"
+                  @click="save"
+                  :disabled="saveDisabled">
+          {{ creating ? "Create" : "Update" }} Quantity
+        </b-button>
+        <b-button @click="$emit('cancel')">
+          Cancel
+        </b-button>
+      </div>
+
+    </div>
+  </script>
+  <script>
+    const QuantityEditor = {
+        template: '#quantity-editor-template',
+        props: {
+            name: String,
+            value: Object,
+            measures: Array,
+            units: Array,
+            creating: {
+                type: Boolean,
+                default: false,
+            }
+        },
+        data() {
+
+
+            return {
+                measure: this.value.measure,
+                valueAmount: this.value.value,
+                unit: this.value.units,
+                unitsName: '',
+            }
+        },
+        computed: {
+
+            saveDisabled() {
+                if (!this.value.measure) {
+                    return true
+                }
+                if (!this.value.value) {
+                    return true
+                }
+                if (!this.value.units.uuid) {
+                    return true
+                }
+                return false
+            },
+
+            unitsNameData() {
+                if (!this.unitsName) {
+                    return this.units
+                }
+                return this.units.filter((unit) => {
+                    return unit.name.toLowerCase().indexOf(this.unitsName.toLowerCase()) >= 0
+                })
+            },
+        },
+        methods: {
+
+            focusMeasure() {
+                this.$refs.measure.focus()
+            },
+
+            focusValue() {
+                this.$refs.value.focus()
+            },
+
+            changeUnit() {
+                this.value.units = {}
+                this.$emit('input', this.value)
+                this.$nextTick(() => {
+                    this.$refs.unitsName.focus()
+                })
+            },
+
+            unitsNameSelected(option) {
+                if (option) {
+                    this.value.units = option
+                    this.$emit('input', this.value)
+                    this.unitsName = null
+                    if (this.value.measure && this.value.value) {
+                        this.$nextTick(() => {
+                            this.$refs.save.$el.focus()
+                        })
+                    }
+                }
+            },
+
+            inputKeydown(event) {
+                // nb. must prevent main form submit on ENTER
+                // (since ultimately this lives within an outer form)
+                // but also we can submit the modal pseudo-form
+                if (event.which == 13) {
+                    event.preventDefault()
+                    this.save()
+                }
+            },
+
+            save() {
+                this.$emit('save', this.value)
+            },
+        },
+    }
+    Vue.component('quantity-editor', QuantityEditor)
+    <% request.register_component('quantity-editor', 'QuantityEditor') %>
+  </script>
+</%def>
+
+<%def name="make_quantities_editor_component()">
+  <script type="text/x-template" id="quantities-editor-template">
+    <div>
+      <input type="hidden" :name="name" :value="value ? JSON.stringify(value) : ''" />
+
+      <${b}-table ref="table"
+                  :data="value || []"
+                  detailed
+                  detail-key="uuid"
+                  icon-pack="fas"
+                  :show-detail-icon="false">
+
+        <${b}-table-column field="as_text"
+                           v-slot="props"
+                           label="Quantity">
+          <span>{{ props.row.as_text }}</span>
+        </${b}-table-column>
+
+        <${b}-table-column field="quantity_type"
+                           v-slot="props"
+                           label="Quantity Type">
+          <span>{{ props.row.quantity_type.name }}</span>
+        </${b}-table-column>
+
+        <${b}-table-column v-slot="props">
+          <div v-show="!editing[props.row.uuid]">
+            <a href="#"
+               @click.prevent="editInit(props.row)">
+              <i class="fas fa-edit" /> Edit
+            </a>
+            &nbsp;
+            <a href="#"
+               class="has-text-danger"
+               @click.prevent="removeQuantity(props.row)">
+              <i class="fas fa-trash" /> Remove
+            </a>
+          </div>
+        </${b}-table-column>
+
+        <template #detail="props">
+          <quantity-editor v-model="props.row"
+                           :measures="measures"
+                           :units="units"
+                           @save="editSave"
+                           @cancel="editCancel(props.row)" />
+        </template>
+
+      </${b}-table>
+
+      <b-field grouped
+               v-show="!creating">
+
+        <b-select v-model="quantityType">
+          <option v-for="qtype of quantityTypes"
+                  :value="qtype.drupal_id">
+            {{ qtype.name }}
+          </option>
+        </b-select>
+
+        <b-button type="is-primary"
+                  icon-pack="fas"
+                  icon-left="plus"
+                  @click="createInit()">
+          Add New Quantity
+        </b-button>
+
+      </b-field>
+
+      <quantity-editor v-show="creating"
+                       v-model="newQuantity"
+                       ref="newQuantity"
+                       creating
+                       @save="createSave"
+                       @cancel="createCancel"
+                       :measures="measures"
+                       :units="units" />
+
+    </div>
+  </script>
+  <script>
+    const QuantitiesEditor = {
+        template: '#quantities-editor-template',
+        props: {
+            name: String,
+            value: Array,
+            quantityTypes: Array,
+            defaultQuantityType: {
+                type: String,
+                default: 'standard',
+            },
+            measures: Array,
+            units: Array,
+        },
+        data() {
+
+            const editing = {}
+            if (this.value) {
+                for (qty of this.value) {
+                    editing[qty.uuid] = false
+                }
+            }
+
+            const measureMap = {}
+            for (let m of this.measures) {
+                measureMap[m.drupal_id] = m.name
+            }
+
+            return {
+                measureMap,
+                quantityType: this.defaultQuantityType,
+                editShowDialog: false,
+                editNew: true,
+                editQuantity: null,
+                editMeasure: null,
+                editValue: null,
+                editUnits: null,
+                editing: editing,
+                creating: false,
+                newQuantity: {
+                    measure: null,
+                    value: null,
+                    units: {},
+                },
+                newCounter: 1,
+            }
+        },
+        methods: {
+
+            createSave(qty) {
+                qty = Object.fromEntries(Object.entries(qty))
+
+                qty.uuid = 'new_' + this.newCounter++
+                qty.as_text = "( " + this.measureMap[qty.measure] + " ) " + qty.value + " " + qty.units.name
+
+                const value = Array.from(this.value || [])
+                value.push(qty)
+                this.$emit('input', value)
+
+                this.creating = false
+            },
+
+            createCancel() {
+                this.creating = false
+            },
+
+            createInit() {
+
+                this.newQuantity.quantity_type = {
+                    drupal_id: this.quantityType,
+                    ## TODO: add support for other quantity types
+                    name: "Standard",
+                }
+
+                this.newQuantity.measure = null
+                this.newQuantity.value = null
+                this.newQuantity.units = {}
+
+                this.creating = true
+                this.$nextTick(() => {
+                    this.$refs.newQuantity.focusMeasure()
+                })
+            },
+
+            editInit(qty) {
+                this.$refs.table.openDetailRow(qty)
+                this.editing[qty.uuid] = true
+            },
+
+            editSave(row) {
+                row.as_text = "( " + this.measureMap[row.measure] + " ) " + row.value + " " + row.units.name
+                this.$emit('input', this.value)
+                this.editing[row.uuid] = false
+                this.$refs.table.closeDetailRow(row)
+            },
+
+            editCancel(qty) {
+                this.$refs.table.closeDetailRow(qty)
+                this.editing[qty.uuid] = false
+            },
+
+            removeQuantity(qty) {
+                let value = Array.from(this.value)
+                const i = value.indexOf(qty)
+                value.splice(i, 1)
+                this.$emit('input', value)
+            },
+        },
+    }
+    Vue.component('quantities-editor', QuantitiesEditor)
+    <% request.register_component('quantities-editor', 'QuantitiesEditor') %>
+  </script>
+</%def>
+
 <%def name="make_plant_types_picker_component()">
   <script type="text/x-template" id="plant-types-picker-template">
     <div>
diff --git a/src/wuttafarm/web/views/logs.py b/src/wuttafarm/web/views/logs.py
index 9f53f50..acf8f0d 100644
--- a/src/wuttafarm/web/views/logs.py
+++ b/src/wuttafarm/web/views/logs.py
@@ -34,7 +34,7 @@ from wuttaweb.forms.widgets import WuttaDateTimeWidget
 
 from wuttafarm.web.views import WuttaFarmMasterView
 from wuttafarm.db.model import LogType, Log
-from wuttafarm.web.forms.schema import AssetRefs, LogQuantityRefs, OwnerRefs
+from wuttafarm.web.forms.schema import AssetRefs, QuantityRefs, OwnerRefs
 from wuttafarm.util import get_log_type_enum
 
 
@@ -287,10 +287,8 @@ class LogMasterView(WuttaFarmMasterView):
             f.set_readonly("log_type")
 
         # quantities
-        if self.creating or self.editing:
-            f.remove("quantities")  # TODO: need to support this
-        else:
-            f.set_node("quantities", LogQuantityRefs(self.request))
+        f.set_node("quantities", QuantityRefs(self.request))
+        if not self.creating:
             # nb. must explicity declare value for non-standard field
             f.set_default("quantities", log.quantities)
 
@@ -332,6 +330,7 @@ class LogMasterView(WuttaFarmMasterView):
         self.set_assets(log, data["assets"])
         self.set_locations(log, data["locations"])
         self.set_groups(log, data["groups"])
+        self.set_quantities(log, data["quantities"])
 
         return log
 
@@ -386,6 +385,58 @@ class LogMasterView(WuttaFarmMasterView):
                 assert group
                 log.groups.remove(group)
 
+    def set_quantities(self, log, desired):
+        model = self.app.model
+        session = self.Session()
+
+        current = {qty.uuid.hex: qty for qty in log.quantities}
+        for new_qty in desired:
+            units = session.get(model.Unit, new_qty["units"]["uuid"])
+            assert units
+            if new_qty["uuid"].startswith("new_"):
+                assert new_qty["quantity_type"]["drupal_id"] == "standard"
+                factory = model.StandardQuantity
+                qty = factory(
+                    quantity_type_id=new_qty["quantity_type"]["drupal_id"],
+                    measure_id=new_qty["measure"],
+                    value_numerator=int(new_qty["value"]),
+                    value_denominator=1,
+                    units=units,
+                )
+                # nb. must ensure "typed" quantity record persists!
+                session.add(qty)
+                # but must add "generic" quantity record to log
+                log.quantities.append(qty.quantity)
+            else:
+                old_qty = current[new_qty["uuid"]]
+                old_qty.measure_id = new_qty["measure"]
+                old_qty.value_numerator = int(new_qty["value"])
+                old_qty.value_denominator = 1
+                old_qty.units = units
+
+        desired = [qty["uuid"] for qty in desired]
+        for old_qty in list(log.quantities):
+            # nb. "old_qty" may be newly-created, w/ no uuid yet
+            # (this logic may break if session gets flushed early!)
+            if old_qty.uuid and old_qty.uuid.hex not in desired:
+                log.quantities.remove(old_qty)
+
+    def auto_sync_to_farmos(self, client, log):
+        model = self.app.model
+        session = self.Session()
+
+        # nb. ensure quantities have uuid keys
+        session.flush()
+
+        for qty in log.quantities:
+            # TODO: support more quantity types
+            if qty.quantity_type_id == "standard":
+                qty = session.get(model.StandardQuantity, qty.uuid)
+                assert qty
+                self.app.auto_sync_to_farmos(qty, client=client)
+
+        self.app.auto_sync_to_farmos(log, client=client)
+
     def get_farmos_url(self, log):
         return self.app.get_farmos_url(f"/log/{log.drupal_id}")
 
diff --git a/src/wuttafarm/web/views/master.py b/src/wuttafarm/web/views/master.py
index 747cdc5..5d37d55 100644
--- a/src/wuttafarm/web/views/master.py
+++ b/src/wuttafarm/web/views/master.py
@@ -113,7 +113,10 @@ class WuttaFarmMasterView(MasterView):
         # maybe also sync change to farmOS
         if self.app.is_farmos_mirror():
             client = get_farmos_client_for_user(self.request)
-            self.app.auto_sync_to_farmos(obj, client=client, require=False)
+            self.auto_sync_to_farmos(client, obj)
+
+    def auto_sync_to_farmos(self, client, obj):
+        self.app.auto_sync_to_farmos(obj, client=client, require=False)
 
     def get_farmos_entity_type(self):
         if self.farmos_entity_type:

From a355e9e1b75261d1a082d6d9c9823b0d323282e2 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sun, 8 Mar 2026 13:24:56 -0500
Subject: [PATCH 10/20] fix: add ordinal for sorting Measures

---
 src/wuttafarm/app.py                          |  2 +-
 .../82a497e30a97_add_measure_ordinal.py       | 37 +++++++++++++++++++
 src/wuttafarm/db/model/unit.py                |  8 ++++
 src/wuttafarm/importing/farmos.py             |  4 ++
 src/wuttafarm/web/views/units.py              |  4 +-
 5 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/82a497e30a97_add_measure_ordinal.py

diff --git a/src/wuttafarm/app.py b/src/wuttafarm/app.py
index 6bbca34..e83bce0 100644
--- a/src/wuttafarm/app.py
+++ b/src/wuttafarm/app.py
@@ -167,7 +167,7 @@ class WuttaFarmAppHandler(base.AppHandler):
         """
         model = self.model
         with self.short_session(session=session) as sess:
-            return sess.query(model.Measure).order_by(model.Measure.name).all()
+            return sess.query(model.Measure).order_by(model.Measure.ordinal).all()
 
     def get_units(self, session=None):
         """
diff --git a/src/wuttafarm/db/alembic/versions/82a497e30a97_add_measure_ordinal.py b/src/wuttafarm/db/alembic/versions/82a497e30a97_add_measure_ordinal.py
new file mode 100644
index 0000000..2cd8057
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/82a497e30a97_add_measure_ordinal.py
@@ -0,0 +1,37 @@
+"""add Measure.ordinal
+
+Revision ID: 82a497e30a97
+Revises: c5183b781d34
+Create Date: 2026-03-08 13:15:36.917747
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "82a497e30a97"
+down_revision: Union[str, None] = "c5183b781d34"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # measure
+    op.add_column("measure", sa.Column("ordinal", sa.Integer(), nullable=True))
+    op.add_column(
+        "measure_version",
+        sa.Column("ordinal", sa.Integer(), autoincrement=False, nullable=True),
+    )
+
+
+def downgrade() -> None:
+
+    # measure
+    op.drop_column("measure_version", "ordinal")
+    op.drop_column("measure", "ordinal")
diff --git a/src/wuttafarm/db/model/unit.py b/src/wuttafarm/db/model/unit.py
index e9c6e70..a376e2c 100644
--- a/src/wuttafarm/db/model/unit.py
+++ b/src/wuttafarm/db/model/unit.py
@@ -42,6 +42,14 @@ class Measure(model.Base):
 
     uuid = model.uuid_column()
 
+    ordinal = sa.Column(
+        sa.Integer(),
+        nullable=True,
+        doc="""
+        Ordinal (sequence number) for the measure.
+        """,
+    )
+
     name = sa.Column(
         sa.String(length=100),
         nullable=False,
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index c0671a7..1e07e77 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -873,6 +873,7 @@ class MeasureImporter(FromFarmOS, ToWutta):
 
     supported_fields = [
         "drupal_id",
+        "ordinal",
         "name",
     ]
 
@@ -883,12 +884,15 @@ class MeasureImporter(FromFarmOS, ToWutta):
         )
         response.raise_for_status()
         data = response.json()
+        self.ordinal = 0
         return data["definitions"]["attributes"]["properties"]["measure"]["oneOf"]
 
     def normalize_source_object(self, measure):
         """ """
+        self.ordinal += 1
         return {
             "drupal_id": measure["const"],
+            "ordinal": self.ordinal,
             "name": measure["title"],
         }
 
diff --git a/src/wuttafarm/web/views/units.py b/src/wuttafarm/web/views/units.py
index fe8dafe..13cff36 100644
--- a/src/wuttafarm/web/views/units.py
+++ b/src/wuttafarm/web/views/units.py
@@ -37,17 +37,19 @@ class MeasureView(WuttaFarmMasterView):
     url_prefix = "/measures"
 
     grid_columns = [
+        "ordinal",
         "name",
         "drupal_id",
     ]
 
-    sort_defaults = "name"
+    sort_defaults = "ordinal"
 
     filter_defaults = {
         "name": {"active": True, "verb": "contains"},
     }
 
     form_fields = [
+        "ordinal",
         "name",
         "drupal_id",
     ]

From b2a718493790ca4805f335d49ca0dd4ce5a8b289 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sun, 8 Mar 2026 15:05:24 -0500
Subject: [PATCH 11/20] feat: add edit/sync support for Material Types

---
 .../versions/1c89f3fbb521_add_materialtype.py | 116 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   1 +
 src/wuttafarm/db/model/material_type.py       |  80 ++++++++++++
 src/wuttafarm/farmos/importing/model.py       |  24 +++-
 src/wuttafarm/farmos/importing/wuttafarm.py   |  45 +++++--
 src/wuttafarm/importing/farmos.py             |  42 +++++--
 src/wuttafarm/web/menus.py                    |  15 +++
 src/wuttafarm/web/views/__init__.py           |   3 +-
 src/wuttafarm/web/views/farmos/__init__.py    |   1 +
 src/wuttafarm/web/views/farmos/materials.py   |  76 ++++++++++++
 src/wuttafarm/web/views/master.py             | 109 ++++++++++++++++
 src/wuttafarm/web/views/material_types.py     |  52 ++++++++
 12 files changed, 537 insertions(+), 27 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/1c89f3fbb521_add_materialtype.py
 create mode 100644 src/wuttafarm/db/model/material_type.py
 create mode 100644 src/wuttafarm/web/views/farmos/materials.py
 create mode 100644 src/wuttafarm/web/views/material_types.py

diff --git a/src/wuttafarm/db/alembic/versions/1c89f3fbb521_add_materialtype.py b/src/wuttafarm/db/alembic/versions/1c89f3fbb521_add_materialtype.py
new file mode 100644
index 0000000..0d4c0f5
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/1c89f3fbb521_add_materialtype.py
@@ -0,0 +1,116 @@
+"""add MaterialType
+
+Revision ID: 1c89f3fbb521
+Revises: 82a497e30a97
+Create Date: 2026-03-08 14:38:04.538621
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "1c89f3fbb521"
+down_revision: Union[str, None] = "82a497e30a97"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # material_type
+    op.create_table(
+        "material_type",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("name", sa.String(length=100), nullable=False),
+        sa.Column("description", sa.String(length=255), nullable=True),
+        sa.Column("farmos_uuid", wuttjamaican.db.util.UUID(), nullable=True),
+        sa.Column("drupal_id", sa.Integer(), nullable=True),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_material_type")),
+        sa.UniqueConstraint("drupal_id", name=op.f("uq_material_type_drupal_id")),
+        sa.UniqueConstraint("farmos_uuid", name=op.f("uq_material_type_farmos_uuid")),
+    )
+    op.create_table(
+        "material_type_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column("name", sa.String(length=100), autoincrement=False, nullable=True),
+        sa.Column(
+            "description", sa.String(length=255), autoincrement=False, nullable=True
+        ),
+        sa.Column(
+            "farmos_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column("drupal_id", sa.Integer(), autoincrement=False, nullable=True),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_material_type_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_material_type_version_end_transaction_id"),
+        "material_type_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_material_type_version_operation_type"),
+        "material_type_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_material_type_version_pk_transaction_id",
+        "material_type_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_material_type_version_pk_validity",
+        "material_type_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_material_type_version_transaction_id"),
+        "material_type_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # material_type
+    op.drop_index(
+        op.f("ix_material_type_version_transaction_id"),
+        table_name="material_type_version",
+    )
+    op.drop_index(
+        "ix_material_type_version_pk_validity", table_name="material_type_version"
+    )
+    op.drop_index(
+        "ix_material_type_version_pk_transaction_id", table_name="material_type_version"
+    )
+    op.drop_index(
+        op.f("ix_material_type_version_operation_type"),
+        table_name="material_type_version",
+    )
+    op.drop_index(
+        op.f("ix_material_type_version_end_transaction_id"),
+        table_name="material_type_version",
+    )
+    op.drop_table("material_type_version")
+    op.drop_table("material_type")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index 929e64b..ba80389 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -31,6 +31,7 @@ from .users import WuttaFarmUser
 
 # wuttafarm proper models
 from .unit import Unit, Measure
+from .material_type import MaterialType
 from .quantities import QuantityType, Quantity, StandardQuantity
 from .asset import AssetType, Asset, AssetParent
 from .asset_land import LandType, LandAsset
diff --git a/src/wuttafarm/db/model/material_type.py b/src/wuttafarm/db/model/material_type.py
new file mode 100644
index 0000000..e21f38c
--- /dev/null
+++ b/src/wuttafarm/db/model/material_type.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Model definition for Material Types
+"""
+
+import sqlalchemy as sa
+
+from wuttjamaican.db import model
+
+
+class MaterialType(model.Base):
+    """
+    Represents a "material type" (taxonomy term) from farmOS
+    """
+
+    __tablename__ = "material_type"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Material Type",
+        "model_title_plural": "Material Types",
+    }
+
+    uuid = model.uuid_column()
+
+    name = sa.Column(
+        sa.String(length=100),
+        nullable=False,
+        doc="""
+        Name of the material type.
+        """,
+    )
+
+    description = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Optional description for the material type.
+        """,
+    )
+
+    farmos_uuid = sa.Column(
+        model.UUID(),
+        nullable=True,
+        unique=True,
+        doc="""
+        UUID for the material type within farmOS.
+        """,
+    )
+
+    drupal_id = sa.Column(
+        sa.Integer(),
+        nullable=True,
+        unique=True,
+        doc="""
+        Drupal internal ID for the material type.
+        """,
+    )
+
+    def __str__(self):
+        return self.name or ""
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 9994f55..980c329 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -71,6 +71,7 @@ class ToFarmOSTaxonomy(ToFarmOS):
     supported_fields = [
         "uuid",
         "name",
+        "description",
     ]
 
     def get_target_objects(self, **kwargs):
@@ -102,17 +103,24 @@ class ToFarmOSTaxonomy(ToFarmOS):
         return result["data"]
 
     def normalize_target_object(self, obj):
+        if description := obj["attributes"]["description"]:
+            description = description["value"]
         return {
             "uuid": UUID(obj["id"]),
             "name": obj["attributes"]["name"],
+            "description": description,
         }
 
     def get_term_payload(self, source_data):
-        return {
-            "attributes": {
-                "name": source_data["name"],
-            }
-        }
+
+        attrs = {}
+        if "name" in self.fields:
+            attrs["name"] = source_data["name"]
+        if "description" in self.fields:
+            attrs["description"] = {"value": source_data["description"]}
+
+        payload = {"attributes": attrs}
+        return payload
 
     def create_target_object(self, key, source_data):
         if source_data.get("__ignoreme__"):
@@ -311,6 +319,12 @@ class AnimalTypeImporter(ToFarmOSTaxonomy):
     farmos_taxonomy_type = "animal_type"
 
 
+class MaterialTypeImporter(ToFarmOSTaxonomy):
+
+    model_title = "MaterialType"
+    farmos_taxonomy_type = "material_type"
+
+
 class GroupAssetImporter(ToFarmOSAsset):
 
     model_title = "GroupAsset"
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 8b682a3..549d3b0 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -105,6 +105,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers["Season"] = SeasonImporter
         importers["PlantAsset"] = PlantAssetImporter
         importers["Unit"] = UnitImporter
+        importers["MaterialType"] = MaterialTypeImporter
         importers["StandardQuantity"] = StandardQuantityImporter
         importers["ActivityLog"] = ActivityLogImporter
         importers["HarvestLog"] = HarvestLogImporter
@@ -199,26 +200,46 @@ class AnimalAssetImporter(
         return data
 
 
-class AnimalTypeImporter(FromWuttaFarm, farmos_importing.model.AnimalTypeImporter):
+class FromWuttaFarmTaxonomy(FromWuttaFarm):
+    """
+    Base class for taxonomy term exporters
+    """
+
+    supported_fields = [
+        "uuid",
+        "name",
+        "description",
+    ]
+
+    drupal_internal_id_field = "drupal_internal__tid"
+
+    def normalize_source_object(self, term):
+        return {
+            "uuid": term.farmos_uuid or self.app.make_true_uuid(),
+            "name": term.name,
+            "description": term.description,
+            "_src_object": term,
+        }
+
+
+class AnimalTypeImporter(
+    FromWuttaFarmTaxonomy, farmos_importing.model.AnimalTypeImporter
+):
     """
     WuttaFarm → farmOS API exporter for Animal Types
     """
 
     source_model_class = model.AnimalType
 
-    supported_fields = [
-        "uuid",
-        "name",
-    ]
 
-    drupal_internal_id_field = "drupal_internal__tid"
+class MaterialTypeImporter(
+    FromWuttaFarmTaxonomy, farmos_importing.model.MaterialTypeImporter
+):
+    """
+    WuttaFarm → farmOS API exporter for Material Types
+    """
 
-    def normalize_source_object(self, animal_type):
-        return {
-            "uuid": animal_type.farmos_uuid or self.app.make_true_uuid(),
-            "name": animal_type.name,
-            "_src_object": animal_type,
-        }
+    source_model_class = model.MaterialType
 
 
 class UnitImporter(FromWuttaFarm, farmos_importing.model.UnitImporter):
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index 1e07e77..58eff68 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -114,6 +114,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["PlantAsset"] = PlantAssetImporter
         importers["Measure"] = MeasureImporter
         importers["Unit"] = UnitImporter
+        importers["MaterialType"] = MaterialTypeImporter
         importers["QuantityType"] = QuantityTypeImporter
         importers["StandardQuantity"] = StandardQuantityImporter
         importers["LogType"] = LogTypeImporter
@@ -397,12 +398,12 @@ class AnimalAssetImporter(AssetImporterBase):
         return data
 
 
-class AnimalTypeImporter(FromFarmOS, ToWutta):
+class TaxonomyImporterBase(FromFarmOS, ToWutta):
     """
-    farmOS API → WuttaFarm importer for Animal Types
+    farmOS API → WuttaFarm importer for taxonomy terms
     """
 
-    model_class = model.AnimalType
+    taxonomy_type = None
 
     supported_fields = [
         "farmos_uuid",
@@ -413,18 +414,41 @@ class AnimalTypeImporter(FromFarmOS, ToWutta):
 
     def get_source_objects(self):
         """ """
-        return list(self.farmos_client.resource.iterate("taxonomy_term", "animal_type"))
+        return list(
+            self.farmos_client.resource.iterate("taxonomy_term", self.taxonomy_type)
+        )
 
-    def normalize_source_object(self, animal_type):
+    def normalize_source_object(self, term):
         """ """
+        if description := term["attributes"]["description"]:
+            description = description["value"]
+
         return {
-            "farmos_uuid": UUID(animal_type["id"]),
-            "drupal_id": animal_type["attributes"]["drupal_internal__tid"],
-            "name": animal_type["attributes"]["name"],
-            "description": animal_type["attributes"]["description"],
+            "farmos_uuid": UUID(term["id"]),
+            "drupal_id": term["attributes"]["drupal_internal__tid"],
+            "name": term["attributes"]["name"],
+            "description": description,
         }
 
 
+class AnimalTypeImporter(TaxonomyImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Animal Types
+    """
+
+    model_class = model.AnimalType
+    taxonomy_type = "animal_type"
+
+
+class MaterialTypeImporter(TaxonomyImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Material Types
+    """
+
+    model_class = model.MaterialType
+    taxonomy_type = "material_type"
+
+
 class AssetTypeImporter(FromFarmOS, ToWutta):
     """
     farmOS API → WuttaFarm importer for Asset Types
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index 3b75b4e..9252e5b 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -193,6 +193,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "log_types",
                     "perm": "log_types.list",
                 },
+                {
+                    "title": "Material Types",
+                    "route": "material_types",
+                    "perm": "material_types.list",
+                },
                 {
                     "title": "Measures",
                     "route": "measures",
@@ -307,6 +312,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_log_types",
                     "perm": "farmos_log_types.list",
                 },
+                {
+                    "title": "Material Types",
+                    "route": "farmos_material_types",
+                    "perm": "farmos_material_types.list",
+                },
                 {
                     "title": "Quantity Types",
                     "route": "farmos_quantity_types",
@@ -431,6 +441,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_log_types",
                     "perm": "farmos_log_types.list",
                 },
+                {
+                    "title": "Material Types",
+                    "route": "farmos_material_types",
+                    "perm": "farmos_material_types.list",
+                },
                 {
                     "title": "Quantity Types",
                     "route": "farmos_quantity_types",
diff --git a/src/wuttafarm/web/views/__init__.py b/src/wuttafarm/web/views/__init__.py
index 0d58a72..d189e42 100644
--- a/src/wuttafarm/web/views/__init__.py
+++ b/src/wuttafarm/web/views/__init__.py
@@ -25,7 +25,7 @@ WuttaFarm Views
 
 from wuttaweb.views import essential
 
-from .master import WuttaFarmMasterView
+from .master import WuttaFarmMasterView, TaxonomyMasterView
 
 
 def includeme(config):
@@ -48,6 +48,7 @@ def includeme(config):
     # native table views
     if mode != enum.FARMOS_INTEGRATION_MODE_WRAPPER:
         config.include("wuttafarm.web.views.units")
+        config.include("wuttafarm.web.views.material_types")
         config.include("wuttafarm.web.views.quantities")
         config.include("wuttafarm.web.views.asset_types")
         config.include("wuttafarm.web.views.assets")
diff --git a/src/wuttafarm/web/views/farmos/__init__.py b/src/wuttafarm/web/views/farmos/__init__.py
index e59ac1f..9cb57d5 100644
--- a/src/wuttafarm/web/views/farmos/__init__.py
+++ b/src/wuttafarm/web/views/farmos/__init__.py
@@ -28,6 +28,7 @@ from .master import FarmOSMasterView
 
 def includeme(config):
     config.include("wuttafarm.web.views.farmos.users")
+    config.include("wuttafarm.web.views.farmos.materials")
     config.include("wuttafarm.web.views.farmos.quantities")
     config.include("wuttafarm.web.views.farmos.asset_types")
     config.include("wuttafarm.web.views.farmos.units")
diff --git a/src/wuttafarm/web/views/farmos/materials.py b/src/wuttafarm/web/views/farmos/materials.py
new file mode 100644
index 0000000..e56557d
--- /dev/null
+++ b/src/wuttafarm/web/views/farmos/materials.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+View for farmOS materials
+"""
+
+from wuttafarm.web.views.farmos.master import TaxonomyMasterView
+
+
+class MaterialTypeView(TaxonomyMasterView):
+    """
+    Master view for Material Types in farmOS.
+    """
+
+    model_name = "farmos_material_type"
+    model_title = "farmOS Material Type"
+    model_title_plural = "farmOS Material Types"
+
+    route_prefix = "farmos_material_types"
+    url_prefix = "/farmOS/material-types"
+
+    farmos_taxonomy_type = "material_type"
+    farmos_refurl_path = "/admin/structure/taxonomy/manage/material_type/overview"
+
+    def get_xref_buttons(self, material_type):
+        buttons = super().get_xref_buttons(material_type)
+        model = self.app.model
+        session = self.Session()
+
+        if wf_material_type := (
+            session.query(model.MaterialType)
+            .filter(model.MaterialType.farmos_uuid == material_type["uuid"])
+            .first()
+        ):
+            buttons.append(
+                self.make_button(
+                    f"View {self.app.get_title()} record",
+                    primary=True,
+                    url=self.request.route_url(
+                        "material_types.view", uuid=wf_material_type.uuid
+                    ),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    MaterialTypeView = kwargs.get("MaterialTypeView", base["MaterialTypeView"])
+    MaterialTypeView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)
diff --git a/src/wuttafarm/web/views/master.py b/src/wuttafarm/web/views/master.py
index 5d37d55..53bbac2 100644
--- a/src/wuttafarm/web/views/master.py
+++ b/src/wuttafarm/web/views/master.py
@@ -148,3 +148,112 @@ class WuttaFarmMasterView(MasterView):
             bundle = self.get_farmos_bundle()
             client = get_farmos_client_for_user(self.request)
             client.resource.delete(entity_type, bundle, farmos_uuid)
+
+
+class TaxonomyMasterView(WuttaFarmMasterView):
+    """
+    Base class for master views serving taxonomy terms.
+    """
+
+    farmos_entity_type = "taxonomy_term"
+
+    grid_columns = [
+        "name",
+        "description",
+    ]
+
+    sort_defaults = "name"
+
+    filter_defaults = {
+        "name": {"active": True, "verb": "contains"},
+    }
+
+    form_fields = [
+        "name",
+        "description",
+        "drupal_id",
+        "farmos_uuid",
+    ]
+
+    def configure_grid(self, grid):
+        g = grid
+        super().configure_grid(g)
+
+        # name
+        g.set_link("name")
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+
+        # description
+        f.set_widget("description", "notes")
+
+    def get_farmos_url(self, obj):
+        return self.app.get_farmos_url(f"/taxonomy/term/{obj.drupal_id}")
+
+    def get_xref_buttons(self, term):
+        buttons = super().get_xref_buttons(term)
+
+        if term.farmos_uuid:
+            buttons.append(
+                self.make_button(
+                    "View farmOS record",
+                    primary=True,
+                    url=self.request.route_url(
+                        f"{self.farmos_route_prefix}.view", uuid=term.farmos_uuid
+                    ),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+    def ajax_create(self):
+        """
+        AJAX view to create a new taxonomy term.
+        """
+        model = self.app.model
+        session = self.Session()
+        data = get_form_data(self.request)
+
+        name = data.get("name")
+        if not name:
+            return {"error": "Name is required"}
+
+        term = self.model_class(name=name)
+        session.add(term)
+        session.flush()
+
+        if self.app.is_farmos_mirror():
+            client = get_farmos_client_for_user(self.request)
+            self.app.auto_sync_to_farmos(term, client=client)
+
+        return {
+            "uuid": term.uuid.hex,
+            "name": term.name,
+            "farmos_uuid": term.farmos_uuid.hex,
+            "drupal_id": term.drupal_id,
+        }
+
+    @classmethod
+    def defaults(cls, config):
+        """ """
+        cls._defaults(config)
+        cls._taxonomy_defaults(config)
+
+    @classmethod
+    def _taxonomy_defaults(cls, config):
+        route_prefix = cls.get_route_prefix()
+        permission_prefix = cls.get_permission_prefix()
+        url_prefix = cls.get_url_prefix()
+
+        # ajax_create
+        config.add_route(f"{route_prefix}.ajax_create", f"{url_prefix}/ajax/new")
+        config.add_view(
+            cls,
+            attr="ajax_create",
+            route_name=f"{route_prefix}.ajax_create",
+            permission=f"{permission_prefix}.create",
+            renderer="json",
+        )
diff --git a/src/wuttafarm/web/views/material_types.py b/src/wuttafarm/web/views/material_types.py
new file mode 100644
index 0000000..d2118a7
--- /dev/null
+++ b/src/wuttafarm/web/views/material_types.py
@@ -0,0 +1,52 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Master view for Material Types
+"""
+
+from wuttafarm.web.views import TaxonomyMasterView
+from wuttafarm.db.model import MaterialType
+
+
+class MaterialTypeView(TaxonomyMasterView):
+    """
+    Master view for Material Types
+    """
+
+    model_class = MaterialType
+    route_prefix = "material_types"
+    url_prefix = "/material-types"
+
+    farmos_route_prefix = "farmos_material_types"
+    farmos_bundle = "material_type"
+    farmos_refurl_path = "/admin/structure/taxonomy/manage/material_type/overview"
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    MaterialTypeView = kwargs.get("MaterialTypeView", base["MaterialTypeView"])
+    MaterialTypeView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)

From 1d5499686f95ca133f659454aab1ddbe37c53065 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sun, 8 Mar 2026 15:50:36 -0500
Subject: [PATCH 12/20] fix: cleanup grid views for All, Standard Quantities

---
 src/wuttafarm/web/views/farmos/quantities.py |   2 +
 src/wuttafarm/web/views/quantities.py        | 104 +++++++++++++++++--
 2 files changed, 98 insertions(+), 8 deletions(-)

diff --git a/src/wuttafarm/web/views/farmos/quantities.py b/src/wuttafarm/web/views/farmos/quantities.py
index a388559..97ec9f0 100644
--- a/src/wuttafarm/web/views/farmos/quantities.py
+++ b/src/wuttafarm/web/views/farmos/quantities.py
@@ -171,6 +171,7 @@ class QuantityMasterView(FarmOSMasterView):
 
         # as_text
         g.set_renderer("as_text", self.render_as_text_for_grid)
+        g.set_link("as_text")
 
         # measure
         g.set_renderer("measure", self.render_measure_for_grid)
@@ -303,6 +304,7 @@ class StandardQuantityView(QuantityMasterView):
     url_prefix = "/farmOS/quantities/standard"
 
     farmos_quantity_type = "standard"
+    farmos_refurl_path = "/log-quantities/standard"
 
     def get_xref_buttons(self, standard_quantity):
         model = self.app.model
diff --git a/src/wuttafarm/web/views/quantities.py b/src/wuttafarm/web/views/quantities.py
index d4112cf..9ff8912 100644
--- a/src/wuttafarm/web/views/quantities.py
+++ b/src/wuttafarm/web/views/quantities.py
@@ -25,11 +25,14 @@ Master view for Quantities
 
 from collections import OrderedDict
 
+from webhelpers2.html import tags
+
 from wuttaweb.db import Session
 
 from wuttafarm.web.views import WuttaFarmMasterView
 from wuttafarm.db.model import QuantityType, Quantity, StandardQuantity
 from wuttafarm.web.forms.schema import UnitRef, LogRef
+from wuttafarm.util import get_log_type_enum
 
 
 def get_quantity_type_enum(config):
@@ -100,17 +103,28 @@ class QuantityMasterView(WuttaFarmMasterView):
     Base class for Quantity master views
     """
 
+    farmos_entity_type = "quantity"
+
+    labels = {
+        "log_id": "Log ID",
+    }
+
     grid_columns = [
         "drupal_id",
-        "as_text",
-        "quantity_type",
+        "log_id",
+        "log_status",
+        "log_timestamp",
+        "log_type",
+        "log_name",
+        "log_assets",
         "measure",
         "value",
         "units",
         "label",
+        "quantity_type",
     ]
 
-    sort_defaults = ("drupal_id", "desc")
+    sort_defaults = ("log_timestamp", "desc")
 
     form_fields = [
         "quantity_type",
@@ -129,10 +143,15 @@ class QuantityMasterView(WuttaFarmMasterView):
         model = self.app.model
         model_class = self.get_model_class()
         session = session or self.Session()
+
         query = session.query(model_class)
         if model_class is not model.Quantity:
             query = query.join(model.Quantity)
+
         query = query.join(model.Measure).join(model.Unit)
+
+        query = query.outerjoin(model.LogQuantity).outerjoin(model.Log)
+
         return query
 
     def configure_grid(self, grid):
@@ -140,14 +159,39 @@ class QuantityMasterView(WuttaFarmMasterView):
         super().configure_grid(g)
         model = self.app.model
         model_class = self.get_model_class()
+        session = self.Session()
 
         # drupal_id
         g.set_label("drupal_id", "ID", column_only=True)
         g.set_sorter("drupal_id", model.Quantity.drupal_id)
 
-        # as_text
-        g.set_renderer("as_text", self.render_as_text_for_grid)
-        g.set_link("as_text")
+        # log_id
+        g.set_renderer("log_id", self.render_log_id_for_grid)
+        g.set_sorter("log_id", model.Log.drupal_id)
+
+        # log_status
+        g.set_renderer("log_status", self.render_log_status_for_grid)
+        g.set_sorter("log_status", model.Log.status)
+
+        # log_timestamp
+        g.set_renderer("log_timestamp", self.render_log_timestamp_for_grid)
+        g.set_sorter("log_timestamp", model.Log.timestamp)
+
+        # log_type
+        self.log_type_enum = get_log_type_enum(self.config, session)
+        g.set_renderer("log_type", self.render_log_type_for_grid)
+        g.set_sorter("log_type", model.Log.log_type)
+
+        # log_name
+        g.set_renderer("log_name", self.render_log_name_for_grid)
+        g.set_sorter("log_name", model.Log.message)
+        if not self.farmos_style_grid_links:
+            g.set_link("log_name")
+
+        # log_assets
+        g.set_renderer("log_assets", self.render_log_assets_for_grid)
+        if not self.farmos_style_grid_links:
+            g.set_link("log_assets")
 
         # quantity_type
         if model_class is not model.Quantity:
@@ -177,8 +221,47 @@ class QuantityMasterView(WuttaFarmMasterView):
 
             g.add_action("view", icon="eye", url=quantity_url)
 
-    def render_as_text_for_grid(self, quantity, field, value):
-        return quantity.render_as_text(self.config)
+    def render_log_id_for_grid(self, quantity, field, value):
+        if log := quantity.log:
+            return log.drupal_id
+        return None
+
+    def render_log_status_for_grid(self, quantity, field, value):
+        enum = self.app.enum
+        if log := quantity.log:
+            return enum.LOG_STATUS.get(log.status, log.status)
+        return None
+
+    def render_log_timestamp_for_grid(self, quantity, field, value):
+        if log := quantity.log:
+            return self.app.render_date(log.timestamp)
+        return None
+
+    def render_log_type_for_grid(self, quantity, field, value):
+        if log := quantity.log:
+            return self.log_type_enum.get(log.log_type, log.log_type)
+        return None
+
+    def render_log_name_for_grid(self, quantity, field, value):
+        if log := quantity.log:
+            if self.farmos_style_grid_links:
+                url = self.request.route_url(f"logs_{log.log_type}.view", uuid=log.uuid)
+                return tags.link_to(log.message, url)
+            return log.message
+        return None
+
+    def render_log_assets_for_grid(self, quantity, field, value):
+        if log := quantity.log:
+            if self.farmos_style_grid_links:
+                links = []
+                for asset in log.assets:
+                    url = self.request.route_url(
+                        f"{asset.asset_type}_assets.view", uuid=asset.uuid
+                    )
+                    links.append(tags.link_to(str(asset), url))
+                return ", ".join(links)
+            return [str(a) for a in log.assets]
+        return None
 
     def render_value_for_grid(self, quantity, field, value):
         value = quantity.value_numerator / quantity.value_denominator
@@ -271,6 +354,8 @@ class AllQuantityView(QuantityMasterView):
     deletable = False
     model_is_versioned = False
 
+    farmos_refurl_path = "/log-quantities"
+
 
 class StandardQuantityView(QuantityMasterView):
     """
@@ -281,6 +366,9 @@ class StandardQuantityView(QuantityMasterView):
     route_prefix = "quantities_standard"
     url_prefix = "/quantities/standard"
 
+    farmos_bundle = "standard"
+    farmos_refurl_path = "/log-quantities/standard"
+
 
 def defaults(config, **kwargs):
     base = globals()

From 6bc5f06f7aba1d574e56547b2b06596114c64c31 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Sun, 8 Mar 2026 16:01:12 -0500
Subject: [PATCH 13/20] fix: improve behavior when deleting a Standard Quantity

---
 src/wuttafarm/db/model/quantities.py         |  7 ++++++-
 src/wuttafarm/web/views/farmos/quantities.py | 13 ++++++++++---
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/wuttafarm/db/model/quantities.py b/src/wuttafarm/db/model/quantities.py
index bcc2183..4030450 100644
--- a/src/wuttafarm/db/model/quantities.py
+++ b/src/wuttafarm/db/model/quantities.py
@@ -204,7 +204,12 @@ class QuantityMixin:
 
     @declared_attr
     def quantity(cls):
-        return orm.relationship(Quantity)
+        return orm.relationship(
+            Quantity,
+            single_parent=True,
+            cascade="all, delete-orphan",
+            cascade_backrefs=False,
+        )
 
     def render_as_text(self, config=None):
         return self.quantity.render_as_text(config)
diff --git a/src/wuttafarm/web/views/farmos/quantities.py b/src/wuttafarm/web/views/farmos/quantities.py
index 97ec9f0..0cb318b 100644
--- a/src/wuttafarm/web/views/farmos/quantities.py
+++ b/src/wuttafarm/web/views/farmos/quantities.py
@@ -26,6 +26,7 @@ View for farmOS Quantity Types
 import datetime
 
 import colander
+import requests
 
 from wuttaweb.forms.schema import WuttaDateTime
 from wuttaweb.forms.widgets import WuttaDateTimeWidget
@@ -204,9 +205,15 @@ class QuantityMasterView(FarmOSMasterView):
         return qty["value"]["decimal"]
 
     def get_instance(self):
-        quantity = self.farmos_client.resource.get_id(
-            "quantity", self.farmos_quantity_type, self.request.matchdict["uuid"]
-        )
+        # TODO: this pattern should be repeated for other views
+        try:
+            quantity = self.farmos_client.resource.get_id(
+                "quantity", self.farmos_quantity_type, self.request.matchdict["uuid"]
+            )
+        except requests.HTTPError as exc:
+            if exc.response.status_code == 404:
+                raise self.notfound()
+
         self.raw_json = quantity
 
         data = self.normalize_quantity(quantity["data"])

From dfc8dc0de3e1d7913b41c8927caba85998683cb3 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Mon, 9 Mar 2026 14:36:53 -0500
Subject: [PATCH 14/20] feat: add edit/sync support for Material Types +
 Material Quantities

---
 src/wuttafarm/app.py                          |  42 ++++
 .../9c53513f8862_add_materialquantity.py      | 211 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   8 +-
 src/wuttafarm/db/model/material_type.py       |  20 ++
 src/wuttafarm/db/model/quantities.py          |  64 ++++++
 src/wuttafarm/farmos/importing/model.py       |  43 ++++
 src/wuttafarm/farmos/importing/wuttafarm.py   |  19 ++
 src/wuttafarm/importing/farmos.py             |  74 ++++++
 src/wuttafarm/normal.py                       |  44 ++--
 src/wuttafarm/web/forms/schema.py             |  82 +++++--
 src/wuttafarm/web/forms/widgets.py            |  99 ++++++--
 src/wuttafarm/web/menus.py                    |  15 ++
 .../web/templates/deform/materialtyperefs.pt  |  13 ++
 .../web/templates/deform/quantityrefs.pt      |   1 +
 .../web/templates/wuttafarm-components.mako   | 168 +++++++++++++-
 src/wuttafarm/web/util.py                     |   8 +-
 src/wuttafarm/web/views/farmos/logs.py        |  17 +-
 src/wuttafarm/web/views/farmos/quantities.py  | 112 +++++++++-
 src/wuttafarm/web/views/logs.py               |  39 +++-
 src/wuttafarm/web/views/quantities.py         |  82 ++++++-
 20 files changed, 1075 insertions(+), 86 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/9c53513f8862_add_materialquantity.py
 create mode 100644 src/wuttafarm/web/templates/deform/materialtyperefs.pt

diff --git a/src/wuttafarm/app.py b/src/wuttafarm/app.py
index e83bce0..decd44f 100644
--- a/src/wuttafarm/app.py
+++ b/src/wuttafarm/app.py
@@ -177,6 +177,48 @@ class WuttaFarmAppHandler(base.AppHandler):
         with self.short_session(session=session) as sess:
             return sess.query(model.Unit).order_by(model.Unit.name).all()
 
+    def get_material_types(self, session=None):
+        """
+        Returns a list of all known material types.
+        """
+        model = self.model
+        with self.short_session(session=session) as sess:
+            return (
+                sess.query(model.MaterialType).order_by(model.MaterialType.name).all()
+            )
+
+    def get_quantity_models(self):
+        model = self.model
+        return {
+            "standard": model.StandardQuantity,
+            "material": model.MaterialQuantity,
+        }
+
+    def get_true_quantity(self, quantity, require=True):
+        model = self.model
+        if not isinstance(quantity, model.Quantity):
+            if require and not quantity:
+                raise ValueError(f"quantity is not valid: {quantity}")
+            return quantity
+
+        session = self.get_session(quantity)
+        models = self.get_quantity_models()
+        if require and quantity.quantity_type_id not in models:
+            raise ValueError(
+                f"quantity has invalid quantity_type_id: {quantity.quantity_type_id}"
+            )
+
+        true_quantity = session.get(models[quantity.quantity_type_id], quantity.uuid)
+        if require and not true_quantity:
+            raise ValueError(f"quantity has no true/typed quantity record: {quantity}")
+
+        return true_quantity
+
+    def make_true_quantity(self, quantity_type_id, **kwargs):
+        models = self.get_quantity_models()
+        kwargs["quantity_type_id"] = quantity_type_id
+        return models[quantity_type_id](**kwargs)
+
     def auto_sync_to_farmos(self, obj, model_name=None, client=None, require=True):
         """
         Export the given object to farmOS, using configured handler.
diff --git a/src/wuttafarm/db/alembic/versions/9c53513f8862_add_materialquantity.py b/src/wuttafarm/db/alembic/versions/9c53513f8862_add_materialquantity.py
new file mode 100644
index 0000000..6f28989
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/9c53513f8862_add_materialquantity.py
@@ -0,0 +1,211 @@
+"""add MaterialQuantity
+
+Revision ID: 9c53513f8862
+Revises: 1c89f3fbb521
+Create Date: 2026-03-08 18:14:05.587678
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "9c53513f8862"
+down_revision: Union[str, None] = "1c89f3fbb521"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # quantity_material
+    op.create_table(
+        "quantity_material",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["uuid"], ["quantity.uuid"], name=op.f("fk_quantity_material_uuid_quantity")
+        ),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_quantity_material")),
+    )
+    op.create_table(
+        "quantity_material_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_quantity_material_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_quantity_material_version_end_transaction_id"),
+        "quantity_material_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_quantity_material_version_operation_type"),
+        "quantity_material_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_quantity_material_version_pk_transaction_id",
+        "quantity_material_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_quantity_material_version_pk_validity",
+        "quantity_material_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_quantity_material_version_transaction_id"),
+        "quantity_material_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+    # quantity_material_material_type
+    op.create_table(
+        "quantity_material_material_type",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("quantity_uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("material_type_uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["material_type_uuid"],
+            ["material_type.uuid"],
+            name=op.f(
+                "fk_quantity_material_material_type_material_type_uuid_material_type"
+            ),
+        ),
+        sa.ForeignKeyConstraint(
+            ["quantity_uuid"],
+            ["quantity_material.uuid"],
+            name=op.f(
+                "fk_quantity_material_material_type_quantity_uuid_quantity_material"
+            ),
+        ),
+        sa.PrimaryKeyConstraint(
+            "uuid", name=op.f("pk_quantity_material_material_type")
+        ),
+    )
+    op.create_table(
+        "quantity_material_material_type_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "quantity_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "material_type_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid",
+            "transaction_id",
+            name=op.f("pk_quantity_material_material_type_version"),
+        ),
+    )
+    op.create_index(
+        op.f("ix_quantity_material_material_type_version_end_transaction_id"),
+        "quantity_material_material_type_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_quantity_material_material_type_version_operation_type"),
+        "quantity_material_material_type_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_quantity_material_material_type_version_pk_transaction_id",
+        "quantity_material_material_type_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_quantity_material_material_type_version_pk_validity",
+        "quantity_material_material_type_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_quantity_material_material_type_version_transaction_id"),
+        "quantity_material_material_type_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # quantity_material_material_type
+    op.drop_index(
+        op.f("ix_quantity_material_material_type_version_transaction_id"),
+        table_name="quantity_material_material_type_version",
+    )
+    op.drop_index(
+        "ix_quantity_material_material_type_version_pk_validity",
+        table_name="quantity_material_material_type_version",
+    )
+    op.drop_index(
+        "ix_quantity_material_material_type_version_pk_transaction_id",
+        table_name="quantity_material_material_type_version",
+    )
+    op.drop_index(
+        op.f("ix_quantity_material_material_type_version_operation_type"),
+        table_name="quantity_material_material_type_version",
+    )
+    op.drop_index(
+        op.f("ix_quantity_material_material_type_version_end_transaction_id"),
+        table_name="quantity_material_material_type_version",
+    )
+    op.drop_table("quantity_material_material_type_version")
+    op.drop_table("quantity_material_material_type")
+
+    # quantity_material
+    op.drop_index(
+        op.f("ix_quantity_material_version_transaction_id"),
+        table_name="quantity_material_version",
+    )
+    op.drop_index(
+        "ix_quantity_material_version_pk_validity",
+        table_name="quantity_material_version",
+    )
+    op.drop_index(
+        "ix_quantity_material_version_pk_transaction_id",
+        table_name="quantity_material_version",
+    )
+    op.drop_index(
+        op.f("ix_quantity_material_version_operation_type"),
+        table_name="quantity_material_version",
+    )
+    op.drop_index(
+        op.f("ix_quantity_material_version_end_transaction_id"),
+        table_name="quantity_material_version",
+    )
+    op.drop_table("quantity_material_version")
+    op.drop_table("quantity_material")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index ba80389..35130da 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -32,7 +32,13 @@ from .users import WuttaFarmUser
 # wuttafarm proper models
 from .unit import Unit, Measure
 from .material_type import MaterialType
-from .quantities import QuantityType, Quantity, StandardQuantity
+from .quantities import (
+    QuantityType,
+    Quantity,
+    StandardQuantity,
+    MaterialQuantity,
+    MaterialQuantityMaterialType,
+)
 from .asset import AssetType, Asset, AssetParent
 from .asset_land import LandType, LandAsset
 from .asset_structure import StructureType, StructureAsset
diff --git a/src/wuttafarm/db/model/material_type.py b/src/wuttafarm/db/model/material_type.py
index e21f38c..a124451 100644
--- a/src/wuttafarm/db/model/material_type.py
+++ b/src/wuttafarm/db/model/material_type.py
@@ -24,6 +24,8 @@ Model definition for Material Types
 """
 
 import sqlalchemy as sa
+from sqlalchemy import orm
+from sqlalchemy.ext.associationproxy import association_proxy
 
 from wuttjamaican.db import model
 
@@ -76,5 +78,23 @@ class MaterialType(model.Base):
         """,
     )
 
+    _quantities = orm.relationship(
+        "MaterialQuantityMaterialType",
+        cascade="all, delete-orphan",
+        cascade_backrefs=False,
+        back_populates="material_type",
+    )
+
+    def _make_material_quantity(qty):
+        from wuttafarm.db.model import MaterialQuantityMaterialType
+
+        return MaterialQuantityMaterialType(quantity=qty)
+
+    quantities = association_proxy(
+        "_quantities",
+        "quantity",
+        creator=_make_material_quantity,
+    )
+
     def __str__(self):
         return self.name or ""
diff --git a/src/wuttafarm/db/model/quantities.py b/src/wuttafarm/db/model/quantities.py
index 4030450..4fa92af 100644
--- a/src/wuttafarm/db/model/quantities.py
+++ b/src/wuttafarm/db/model/quantities.py
@@ -211,6 +211,9 @@ class QuantityMixin:
             cascade_backrefs=False,
         )
 
+    def get_value_decimal(self):
+        return self.quantity.get_value_decimal()
+
     def render_as_text(self, config=None):
         return self.quantity.render_as_text(config)
 
@@ -249,3 +252,64 @@ class StandardQuantity(QuantityMixin, model.Base):
 
 
 add_quantity_proxies(StandardQuantity)
+
+
+class MaterialQuantity(QuantityMixin, model.Base):
+    """
+    Represents a Material Quantity from farmOS
+    """
+
+    __tablename__ = "quantity_material"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Material Quantity",
+        "model_title_plural": "Material Quantities",
+        "farmos_quantity_type": "material",
+    }
+
+    _material_types = orm.relationship(
+        "MaterialQuantityMaterialType",
+        cascade="all, delete-orphan",
+        cascade_backrefs=False,
+        back_populates="quantity",
+    )
+
+    material_types = association_proxy(
+        "_material_types",
+        "material_type",
+        creator=lambda mtype: MaterialQuantityMaterialType(material_type=mtype),
+    )
+
+    def render_as_text(self, config=None):
+        text = super().render_as_text(config)
+        mtypes = ", ".join([str(mt) for mt in self.material_types])
+        return f"{mtypes} {text}"
+
+
+add_quantity_proxies(MaterialQuantity)
+
+
+class MaterialQuantityMaterialType(model.Base):
+    """
+    Represents a "material quantity's material type relationship" from
+    farmOS.
+    """
+
+    __tablename__ = "quantity_material_material_type"
+    __versioned__ = {}
+
+    uuid = model.uuid_column()
+
+    quantity_uuid = model.uuid_fk_column("quantity_material.uuid", nullable=False)
+    quantity = orm.relationship(
+        MaterialQuantity,
+        foreign_keys=quantity_uuid,
+        back_populates="_material_types",
+    )
+
+    material_type_uuid = model.uuid_fk_column("material_type.uuid", nullable=False)
+    material_type = orm.relationship(
+        "MaterialType",
+        foreign_keys=material_type_uuid,
+        back_populates="_quantities",
+    )
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 980c329..4905a5e 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -617,6 +617,49 @@ class ToFarmOSQuantity(ToFarmOS):
         return payload
 
 
+class MaterialQuantityImporter(ToFarmOSQuantity):
+
+    model_title = "MaterialQuantity"
+    farmos_quantity_type = "material"
+
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "material_types",
+            ]
+        )
+        return fields
+
+    def normalize_target_object(self, quantity):
+        data = super().normalize_target_object(quantity)
+
+        if "material_types" in self.fields:
+            data["material_types"] = [
+                UUID(mtype["id"])
+                for mtype in quantity["relationships"]["material_type"]["data"]
+            ]
+
+        return data
+
+    def get_quantity_payload(self, source_data):
+        payload = super().get_quantity_payload(source_data)
+
+        rels = {}
+        if "material_types" in self.fields:
+            rels["material_type"] = {"data": []}
+            for uuid in source_data["material_types"]:
+                rels["material_type"]["data"].append(
+                    {
+                        "id": str(uuid),
+                        "type": "taxonomy_term--material_type",
+                    }
+                )
+
+        payload.setdefault("relationships", {}).update(rels)
+        return payload
+
+
 class StandardQuantityImporter(ToFarmOSQuantity):
 
     model_title = "StandardQuantity"
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 549d3b0..7bb9538 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -106,6 +106,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers["PlantAsset"] = PlantAssetImporter
         importers["Unit"] = UnitImporter
         importers["MaterialType"] = MaterialTypeImporter
+        importers["MaterialQuantity"] = MaterialQuantityImporter
         importers["StandardQuantity"] = StandardQuantityImporter
         importers["ActivityLog"] = ActivityLogImporter
         importers["HarvestLog"] = HarvestLogImporter
@@ -449,6 +450,24 @@ class FromWuttaFarmQuantity(FromWuttaFarm):
         }
 
 
+class MaterialQuantityImporter(
+    FromWuttaFarmQuantity, farmos_importing.model.MaterialQuantityImporter
+):
+    """
+    WuttaFarm → farmOS API exporter for Material Quantities
+    """
+
+    source_model_class = model.MaterialQuantity
+
+    def normalize_source_object(self, quantity):
+        data = super().normalize_source_object(quantity)
+
+        if "material_types" in self.fields:
+            data["material_types"] = [mt.farmos_uuid for mt in quantity.material_types]
+
+        return data
+
+
 class StandardQuantityImporter(
     FromWuttaFarmQuantity, farmos_importing.model.StandardQuantityImporter
 ):
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index 58eff68..695d373 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -117,6 +117,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["MaterialType"] = MaterialTypeImporter
         importers["QuantityType"] = QuantityTypeImporter
         importers["StandardQuantity"] = StandardQuantityImporter
+        importers["MaterialQuantity"] = MaterialQuantityImporter
         importers["LogType"] = LogTypeImporter
         importers["ActivityLog"] = ActivityLogImporter
         importers["HarvestLog"] = HarvestLogImporter
@@ -1419,3 +1420,76 @@ class StandardQuantityImporter(QuantityImporterBase):
         "units_uuid",
         "label",
     ]
+
+
+class MaterialQuantityImporter(QuantityImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Material Quantities
+    """
+
+    model_class = model.MaterialQuantity
+
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "material_types",
+            ]
+        )
+        return fields
+
+    def normalize_source_object(self, quantity):
+        """ """
+        data = super().normalize_source_object(quantity)
+
+        if "material_types" in self.fields:
+            data["material_types"] = [
+                UUID(mtype["id"])
+                for mtype in quantity["relationships"]["material_type"]["data"]
+            ]
+
+        return data
+
+    def normalize_target_object(self, quantity):
+        data = super().normalize_target_object(quantity)
+
+        if "material_types" in self.fields:
+            data["material_types"] = [
+                mtype.farmos_uuid for mtype in quantity.material_types
+            ]
+
+        return data
+
+    def update_target_object(self, quantity, source_data, target_data=None):
+        model = self.app.model
+        quantity = super().update_target_object(quantity, source_data, target_data)
+
+        if "material_types" in self.fields:
+            if (
+                not target_data
+                or target_data["material_types"] != source_data["material_types"]
+            ):
+
+                for farmos_uuid in source_data["material_types"]:
+                    if (
+                        not target_data
+                        or farmos_uuid not in target_data["material_types"]
+                    ):
+                        mtype = (
+                            self.target_session.query(model.MaterialType)
+                            .filter(model.MaterialType.farmos_uuid == farmos_uuid)
+                            .one()
+                        )
+                        quantity.material_types.append(mtype)
+
+                if target_data:
+                    for farmos_uuid in target_data["material_types"]:
+                        if farmos_uuid not in source_data["material_types"]:
+                            mtype = (
+                                self.target_session.query(model.MaterialType)
+                                .filter(model.MaterialType.farmos_uuid == farmos_uuid)
+                                .one()
+                            )
+                            quantity.material_types.remove(mtype)
+
+        return quantity
diff --git a/src/wuttafarm/normal.py b/src/wuttafarm/normal.py
index 38edbab..d03a3ec 100644
--- a/src/wuttafarm/normal.py
+++ b/src/wuttafarm/normal.py
@@ -260,27 +260,29 @@ class Normalizer(GenericHandler):
 
                         measure_id = attrs["measure"]
 
-                        quantity_objects.append(
-                            {
-                                "uuid": quantity["id"],
-                                "drupal_id": attrs["drupal_internal__id"],
-                                "quantity_type_uuid": rels["quantity_type"]["data"][
-                                    "id"
-                                ],
-                                "quantity_type_id": rels["quantity_type"]["data"][
-                                    "meta"
-                                ]["drupal_internal__target_id"],
-                                "measure_id": measure_id,
-                                "measure_name": self.get_farmos_measure_name(
-                                    measure_id
-                                ),
-                                "value_numerator": value["numerator"],
-                                "value_decimal": value["decimal"],
-                                "value_denominator": value["denominator"],
-                                "unit_uuid": unit_uuid,
-                                "unit_name": unit["attributes"]["name"],
-                            }
-                        )
+                        quantity_object = {
+                            "uuid": quantity["id"],
+                            "drupal_id": attrs["drupal_internal__id"],
+                            "quantity_type_uuid": rels["quantity_type"]["data"]["id"],
+                            "quantity_type_id": rels["quantity_type"]["data"]["meta"][
+                                "drupal_internal__target_id"
+                            ],
+                            "measure_id": measure_id,
+                            "measure_name": self.get_farmos_measure_name(measure_id),
+                            "value_numerator": value["numerator"],
+                            "value_decimal": value["decimal"],
+                            "value_denominator": value["denominator"],
+                            "unit_uuid": unit_uuid,
+                            "unit_name": unit["attributes"]["name"],
+                        }
+                        if quantity_object["quantity_type_id"] == "material":
+                            quantity_object["material_types"] = [
+                                {"uuid": mtype["id"]}
+                                for mtype in quantity["relationships"]["material_type"][
+                                    "data"
+                                ]
+                            ]
+                        quantity_objects.append(quantity_object)
 
             if owners := relationships.get("owner"):
                 for user in owners["data"]:
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index f9dc33a..9543c51 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -164,10 +164,9 @@ class FarmOSRefs(WuttaSet):
         self.route_prefix = route_prefix
 
     def serialize(self, node, appstruct):
-        if appstruct is colander.null:
+        if not appstruct:
             return colander.null
-
-        return json.dumps(appstruct)
+        return appstruct
 
     def widget_maker(self, **kwargs):
         from wuttafarm.web.forms.widgets import FarmOSRefsWidget
@@ -288,6 +287,37 @@ class PlantTypeRefs(WuttaSet):
         return PlantTypeRefsWidget(self.request, **kwargs)
 
 
+class MaterialTypeRefs(colander.List):
+    """
+    Schema type for Material Types field (on a Material Asset).
+    """
+
+    def __init__(self, request):
+        super().__init__()
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    def serialize(self, node, appstruct):
+        if not appstruct:
+            return colander.null
+
+        mtypes = []
+        for mtype in appstruct:
+            mtypes.append(
+                {
+                    "uuid": mtype.uuid.hex,
+                    "name": mtype.name,
+                }
+            )
+        return mtypes
+
+    def widget_maker(self, **kwargs):
+        from wuttafarm.web.forms.widgets import MaterialTypeRefsWidget
+
+        return MaterialTypeRefsWidget(self.request, **kwargs)
+
+
 class SeasonRefs(WuttaSet):
     """
     Schema type for Plant Types field (on a Plant Asset).
@@ -454,22 +484,36 @@ class QuantityRefs(colander.List):
 
         quantities = []
         for qty in appstruct:
-            quantities.append(
-                {
-                    "uuid": qty.uuid.hex,
-                    "quantity_type": {
-                        "id": qty.quantity_type_id,
-                        "name": qty.quantity_type.name,
-                    },
-                    "measure": qty.measure_id,
-                    "value": qty.get_value_decimal(),
-                    "units": {
-                        "uuid": qty.units.uuid.hex,
-                        "name": qty.units.name,
-                    },
-                    "as_text": qty.render_as_text(self.config),
-                }
-            )
+
+            quantity = {
+                "uuid": qty.uuid.hex,
+                "quantity_type": {
+                    "drupal_id": qty.quantity_type_id,
+                    "name": qty.quantity_type.name,
+                },
+                "measure": qty.measure_id,
+                "value": qty.get_value_decimal(),
+                "units": {
+                    "uuid": qty.units.uuid.hex,
+                    "name": qty.units.name,
+                },
+                "as_text": qty.render_as_text(self.config),
+                # nb. always include this regardless of quantity type,
+                # for sake of easier frontend logic
+                "material_types": [],
+            }
+
+            if qty.quantity_type_id == "material":
+                quantity["material_types"] = []
+                for mtype in qty.material_types:
+                    quantity["material_types"].append(
+                        {
+                            "uuid": mtype.uuid.hex,
+                            "name": mtype.name,
+                        }
+                    )
+
+            quantities.append(quantity)
 
         return quantities
 
diff --git a/src/wuttafarm/web/forms/widgets.py b/src/wuttafarm/web/forms/widgets.py
index f1cf067..355adcc 100644
--- a/src/wuttafarm/web/forms/widgets.py
+++ b/src/wuttafarm/web/forms/widgets.py
@@ -124,7 +124,7 @@ class FarmOSRefsWidget(Widget):
                 return HTML.tag("span")
 
             links = []
-            for obj in json.loads(cstruct):
+            for obj in cstruct:
                 url = self.request.route_url(
                     f"{self.route_prefix}.view", uuid=obj["uuid"]
                 )
@@ -332,6 +332,72 @@ class PlantTypeRefsWidget(Widget):
         return set(pstruct.split(","))
 
 
+class MaterialTypeRefsWidget(Widget):
+    """
+    Widget for Material Types field (on a Material Asset).
+    """
+
+    template = "materialtyperefs"
+    values = ()
+
+    def __init__(self, request, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    def serialize(self, field, cstruct, **kw):
+        """ """
+        model = self.app.model
+        session = Session()
+
+        if not cstruct:
+            cstruct = []
+
+        if readonly := kw.get("readonly", self.readonly):
+            items = []
+            for mtype in cstruct:
+                items.append(
+                    HTML.tag(
+                        "li",
+                        c=tags.link_to(
+                            mtype["name"],
+                            self.request.route_url(
+                                "material_types.view", uuid=mtype["uuid"]
+                            ),
+                        ),
+                    )
+                )
+            return HTML.tag("ul", c=items)
+
+        tmpl_values = self.get_template_values(field, cstruct, kw)
+        return field.renderer(self.template, **tmpl_values)
+
+    def get_template_values(self, field, cstruct, kw):
+        """ """
+        values = super().get_template_values(field, cstruct, kw)
+        session = Session()
+
+        material_types = []
+        for mtype in self.app.get_material_types(session):
+            material_types.append(
+                {
+                    "uuid": mtype.uuid.hex,
+                    "name": mtype.name,
+                }
+            )
+        values["material_types"] = json.dumps(material_types)
+
+        return values
+
+    def deserialize(self, field, pstruct):
+        """ """
+        if not pstruct:
+            return []
+
+        return json.loads(pstruct)
+
+
 class SeasonRefsWidget(Widget):
     """
     Widget for Seasons field (on a Plant Asset).
@@ -550,11 +616,10 @@ class QuantityRefsWidget(Widget):
                 return ""
 
             quantities = []
-
             for qty in cstruct:
-                # TODO: support more quantity types
                 url = self.request.route_url(
-                    "quantities_standard.view", uuid=qty["uuid"]
+                    f"quantities_{qty['quantity_type']['drupal_id']}.view",
+                    uuid=qty["uuid"],
                 )
                 quantities.append(HTML.tag("li", c=tags.link_to(qty["as_text"], url)))
 
@@ -570,17 +635,25 @@ class QuantityRefsWidget(Widget):
 
         qtypes = []
         for qtype in self.app.get_quantity_types(session):
-            # TODO: add support for other quantity types
-            if qtype.drupal_id == "standard":
-                qtypes.append(
-                    {
-                        "uuid": qtype.uuid.hex,
-                        "drupal_id": qtype.drupal_id,
-                        "name": qtype.name,
-                    }
-                )
+            qtypes.append(
+                {
+                    "uuid": qtype.uuid.hex,
+                    "drupal_id": qtype.drupal_id,
+                    "name": qtype.name,
+                }
+            )
         values["quantity_types"] = qtypes
 
+        material_types = []
+        for mtype in self.app.get_material_types(session):
+            material_types.append(
+                {
+                    "uuid": mtype.uuid.hex,
+                    "name": mtype.name,
+                }
+            )
+        values["material_types"] = material_types
+
         measures = []
         for measure in self.app.get_measures(session):
             measures.append(
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index 9252e5b..249c210 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -182,6 +182,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "quantities",
                     "perm": "quantities.list",
                 },
+                {
+                    "title": "Material Quantities",
+                    "route": "quantities_material",
+                    "perm": "quantities_material.list",
+                },
                 {
                     "title": "Standard Quantities",
                     "route": "quantities_standard",
@@ -322,6 +327,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_quantity_types",
                     "perm": "farmos_quantity_types.list",
                 },
+                {
+                    "title": "Material Quantities",
+                    "route": "farmos_quantities_material",
+                    "perm": "farmos_quantities_material.list",
+                },
                 {
                     "title": "Standard Quantities",
                     "route": "farmos_quantities_standard",
@@ -451,6 +461,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_quantity_types",
                     "perm": "farmos_quantity_types.list",
                 },
+                {
+                    "title": "Material Quantities",
+                    "route": "farmos_quantities_material",
+                    "perm": "farmos_quantities_material.list",
+                },
                 {
                     "title": "Standard Quantities",
                     "route": "farmos_quantities_standard",
diff --git a/src/wuttafarm/web/templates/deform/materialtyperefs.pt b/src/wuttafarm/web/templates/deform/materialtyperefs.pt
new file mode 100644
index 0000000..44ac6e8
--- /dev/null
+++ b/src/wuttafarm/web/templates/deform/materialtyperefs.pt
@@ -0,0 +1,13 @@
+<div tal:define="
+     name name|field.name;
+     oid oid|field.oid;
+     vmodel vmodel|'modelData.'+oid;
+     can_create can_create|False;"
+     tal:omit-tag="">
+
+  <material-types-picker tal:attributes="name name;
+                                         v-model vmodel;
+                                         :material-types material_types;
+                                         :can-create str(can_create).lower();" />
+
+</div>
diff --git a/src/wuttafarm/web/templates/deform/quantityrefs.pt b/src/wuttafarm/web/templates/deform/quantityrefs.pt
index 5c98b84..cc65f77 100644
--- a/src/wuttafarm/web/templates/deform/quantityrefs.pt
+++ b/src/wuttafarm/web/templates/deform/quantityrefs.pt
@@ -7,6 +7,7 @@
   <quantities-editor tal:attributes="name name;
                                      v-model vmodel;
                                      :quantity-types quantity_types;
+                                     :material-types material_types;
                                      :measures measures;
                                      :units units;" />
 
diff --git a/src/wuttafarm/web/templates/wuttafarm-components.mako b/src/wuttafarm/web/templates/wuttafarm-components.mako
index d735274..d8f94b3 100644
--- a/src/wuttafarm/web/templates/wuttafarm-components.mako
+++ b/src/wuttafarm/web/templates/wuttafarm-components.mako
@@ -2,6 +2,7 @@
 <%def name="make_wuttafarm_components()">
   ${self.make_assets_picker_component()}
   ${self.make_animal_type_picker_component()}
+  ${self.make_material_types_picker_component()}
   ${self.make_quantity_editor_component()}
   ${self.make_quantities_editor_component()}
   ${self.make_plant_types_picker_component()}
@@ -241,10 +242,134 @@
   </script>
 </%def>
 
+<%def name="make_material_types_picker_component()">
+  <script type="text/x-template" id="material-types-picker-template">
+    <div>
+      <input type="hidden" :name="name" :value="JSON.stringify(value)" />
+
+      <div style="display: flex; gap: 0.5rem; align-items: center;">
+
+        <span>Add:</span>
+
+        <b-autocomplete v-model="addName"
+                        ref="addName"
+                        :data="addNameData"
+                        field="name"
+                        open-on-focus
+                        keep-first
+                        @select="addNameSelected"
+                        clear-on-select
+                        style="flex-grow: 1;">
+          <template #empty>No results found</template>
+        </b-autocomplete>
+
+      </div>
+
+      <${b}-table :data="materialTypeData">
+
+        <${b}-table-column field="name" v-slot="props">
+          <span>{{ props.row.name }}</span>
+        </${b}-table-column>
+
+        <${b}-table-column v-slot="props">
+            <a href="#"
+               class="has-text-danger"
+               @click.prevent="removeMaterialType(props.row)">
+              <i class="fas fa-trash" /> &nbsp; Remove
+            </a>
+        </${b}-table-column>
+
+      </${b}-table>
+    </div>
+  </script>
+  <script>
+    const MaterialTypesPicker = {
+        template: '#material-types-picker-template',
+        props: {
+            name: String,
+            value: Array,
+            materialTypes: Array,
+        },
+        data() {
+            return {
+                addName: '',
+            }
+        },
+        computed: {
+            materialTypeData() {
+                const data = []
+
+                if (this.value) {
+
+                    const mtypes = new Map(this.materialTypes.map((mtype) => {
+                        return [mtype.uuid, mtype.name]
+                    }))
+
+                    for (const mtype of this.value) {
+                        if (mtypes.has(mtype.uuid)) {
+                            data.push(mtype)
+                        }
+                    }
+                }
+
+                return data
+            },
+            addNameData() {
+                if (!this.addName) {
+                    return this.materialTypes
+                }
+
+                return this.materialTypes.filter((mtype) => {
+                    return mtype.name.toLowerCase().indexOf(this.addName.toLowerCase()) >= 0
+                })
+            },
+        },
+        methods: {
+
+            focus() {
+                this.$refs.addName.focus()
+            },
+
+            addNameSelected(option) {
+                if (!option) {
+                    return
+                }
+
+                const value = Array.from(this.value || [])
+
+                if (!value.includes(option)) {
+                    value.push(option)
+                    this.$emit('input', value)
+                }
+
+                this.addName = null
+            },
+
+            removeMaterialType(ptype) {
+                const value = Array.from(this.value)
+                const i = value.indexOf(ptype)
+                value.splice(i, 1)
+                this.$emit('input', value)
+            },
+        },
+    }
+    Vue.component('material-types-picker', MaterialTypesPicker)
+    <% request.register_component('material-types-picker', 'MaterialTypesPicker') %>
+  </script>
+</%def>
+
 <%def name="make_quantity_editor_component()">
   <script type="text/x-template" id="quantity-editor-template">
     <div>
 
+      <b-field v-if="quantityType == 'material'"
+               label="Material Types"
+               horizontal>
+        <material-types-picker v-model="value.material_types"
+                               ref="materials"
+                               :material-types="materialTypes" />
+      </b-field>
+
       <b-field label="Measure" horizontal
                ## TODO: why is this needed?
                style="margin-bottom: 1rem;">
@@ -306,6 +431,8 @@
         props: {
             name: String,
             value: Object,
+            quantityType: String,
+            materialTypes: Array,
             measures: Array,
             units: Array,
             creating: {
@@ -314,8 +441,6 @@
             }
         },
         data() {
-
-
             return {
                 measure: this.value.measure,
                 valueAmount: this.value.value,
@@ -349,8 +474,12 @@
         },
         methods: {
 
-            focusMeasure() {
-                this.$refs.measure.focus()
+            focusForCreate() {
+                if (this.value.quantity_type.drupal_id == 'material') {
+                    this.$refs.materials.focus()
+                } else {
+                    this.$refs.measure.focus()
+                }
             },
 
             focusValue() {
@@ -439,6 +568,8 @@
 
         <template #detail="props">
           <quantity-editor v-model="props.row"
+                           :quantity-type="props.row.quantity_type.drupal_id"
+                           :material-types="materialTypes"
                            :measures="measures"
                            :units="units"
                            @save="editSave"
@@ -468,6 +599,8 @@
 
       <quantity-editor v-show="creating"
                        v-model="newQuantity"
+                       :quantity-type="quantityType"
+                       :material-types="materialTypes"
                        ref="newQuantity"
                        creating
                        @save="createSave"
@@ -484,6 +617,7 @@
             name: String,
             value: Array,
             quantityTypes: Array,
+            materialTypes: Array,
             defaultQuantityType: {
                 type: String,
                 default: 'standard',
@@ -530,7 +664,7 @@
                 qty = Object.fromEntries(Object.entries(qty))
 
                 qty.uuid = 'new_' + this.newCounter++
-                qty.as_text = "( " + this.measureMap[qty.measure] + " ) " + qty.value + " " + qty.units.name
+                qty.as_text = this.getQuantityText(qty)
 
                 const value = Array.from(this.value || [])
                 value.push(qty)
@@ -557,7 +691,7 @@
 
                 this.creating = true
                 this.$nextTick(() => {
-                    this.$refs.newQuantity.focusMeasure()
+                    this.$refs.newQuantity.focusForCreate()
                 })
             },
 
@@ -566,11 +700,25 @@
                 this.editing[qty.uuid] = true
             },
 
-            editSave(row) {
-                row.as_text = "( " + this.measureMap[row.measure] + " ) " + row.value + " " + row.units.name
+            getQuantityText(qty) {
+                let text = "( " + this.measureMap[qty.measure] + " ) "
+                    + qty.value + " " + qty.units.name
+
+                if (qty.quantity_type.drupal_id == 'material') {
+                    const materials = qty.material_types.map((mtype) => {
+                        return mtype.name
+                    }).join(', ')
+                    text = materials + " " + text
+                }
+
+                return text
+            },
+
+            editSave(qty) {
+                qty.as_text = this.getQuantityText(qty)
                 this.$emit('input', this.value)
-                this.editing[row.uuid] = false
-                this.$refs.table.closeDetailRow(row)
+                this.editing[qty.uuid] = false
+                this.$refs.table.closeDetailRow(qty)
             },
 
             editCancel(qty) {
diff --git a/src/wuttafarm/web/util.py b/src/wuttafarm/web/util.py
index 977550a..35a6f02 100644
--- a/src/wuttafarm/web/util.py
+++ b/src/wuttafarm/web/util.py
@@ -78,4 +78,10 @@ def render_quantity_object(quantity):
     measure = quantity["measure_name"]
     value = quantity["value_decimal"]
     unit = quantity["unit_name"]
-    return f"( {measure} ) {value} {unit}"
+    text = f"( {measure} ) {value} {unit}"
+
+    if quantity["quantity_type_id"] == "material":
+        materials = ", ".join([mtype["name"] for mtype in quantity["material_types"]])
+        return f"{materials} {text}"
+
+    return text
diff --git a/src/wuttafarm/web/views/farmos/logs.py b/src/wuttafarm/web/views/farmos/logs.py
index cb7a87b..74fb941 100644
--- a/src/wuttafarm/web/views/farmos/logs.py
+++ b/src/wuttafarm/web/views/farmos/logs.py
@@ -45,7 +45,7 @@ from wuttafarm.web.forms.schema import (
     LogQuick,
     Notes,
 )
-from wuttafarm.web.util import render_quantity_objects
+from wuttafarm.web.util import render_quantity_objects, render_quantity_object
 
 
 class LogMasterView(FarmOSMasterView):
@@ -199,7 +199,20 @@ class LogMasterView(FarmOSMasterView):
         )
         self.raw_json = result
         included = {obj["id"]: obj for obj in result.get("included", [])}
-        return self.normalize_log(result["data"], included)
+        instance = self.normalize_log(result["data"], included)
+
+        for qty in instance["quantities"]:
+
+            if qty["quantity_type_id"] == "material":
+                for mtype in qty["material_types"]:
+                    result = self.farmos_client.resource.get_id(
+                        "taxonomy_term", "material_type", mtype["uuid"]
+                    )
+                    mtype["name"] = result["data"]["attributes"]["name"]
+
+            qty["as_text"] = render_quantity_object(qty)
+
+        return instance
 
     def get_instance_title(self, log):
         return log["name"]
diff --git a/src/wuttafarm/web/views/farmos/quantities.py b/src/wuttafarm/web/views/farmos/quantities.py
index 0cb318b..1c3830f 100644
--- a/src/wuttafarm/web/views/farmos/quantities.py
+++ b/src/wuttafarm/web/views/farmos/quantities.py
@@ -32,7 +32,7 @@ from wuttaweb.forms.schema import WuttaDateTime
 from wuttaweb.forms.widgets import WuttaDateTimeWidget
 
 from wuttafarm.web.views.farmos import FarmOSMasterView
-from wuttafarm.web.forms.schema import FarmOSUnitRef
+from wuttafarm.web.forms.schema import FarmOSUnitRef, FarmOSRefs
 from wuttafarm.web.grids import ResourceData
 
 
@@ -143,6 +143,7 @@ class QuantityMasterView(FarmOSMasterView):
     sort_defaults = ("drupal_id", "desc")
 
     form_fields = [
+        "quantity_type_name",
         "measure",
         "value",
         "units",
@@ -207,18 +208,23 @@ class QuantityMasterView(FarmOSMasterView):
     def get_instance(self):
         # TODO: this pattern should be repeated for other views
         try:
-            quantity = self.farmos_client.resource.get_id(
-                "quantity", self.farmos_quantity_type, self.request.matchdict["uuid"]
+            result = self.farmos_client.resource.get_id(
+                "quantity",
+                self.farmos_quantity_type,
+                self.request.matchdict["uuid"],
+                params={"include": self.get_farmos_api_includes()},
             )
         except requests.HTTPError as exc:
             if exc.response.status_code == 404:
                 raise self.notfound()
 
-        self.raw_json = quantity
+        self.raw_json = result
 
-        data = self.normalize_quantity(quantity["data"])
+        included = {obj["id"]: obj for obj in result.get("included", [])}
+        assert included
+        data = self.normalize_quantity(result["data"], included)
 
-        if relationships := quantity["data"].get("relationships"):
+        if relationships := result["data"].get("relationships"):
 
             # add units
             if units := relationships.get("units"):
@@ -286,6 +292,11 @@ class QuantityMasterView(FarmOSMasterView):
         f = form
         super().configure_form(f)
 
+        # quantity_type_name
+        f.set_label("quantity_type_name", "Quantity Type")
+        f.set_readonly("quantity_type_name")
+        f.set_default("quantity_type_name", self.farmos_quantity_type.capitalize())
+
         # created
         f.set_node("created", WuttaDateTime(self.request))
         f.set_widget("created", WuttaDateTimeWidget(self.request))
@@ -338,6 +349,90 @@ class StandardQuantityView(QuantityMasterView):
         return buttons
 
 
+class MaterialQuantityView(QuantityMasterView):
+    """
+    View for farmOS Material Quantities
+    """
+
+    model_name = "farmos_material_quantity"
+    model_title = "farmOS Material Quantity"
+    model_title_plural = "farmOS Material Quantities"
+
+    route_prefix = "farmos_quantities_material"
+    url_prefix = "/farmOS/quantities/material"
+
+    farmos_quantity_type = "material"
+    farmos_refurl_path = "/log-quantities/material"
+
+    def get_farmos_api_includes(self):
+        includes = super().get_farmos_api_includes()
+        includes.update({"material_type"})
+        return includes
+
+    def normalize_quantity(self, quantity, included={}):
+        normal = super().normalize_quantity(quantity, included)
+
+        material_type_objects = []
+        material_type_uuids = []
+        if relationships := quantity["relationships"]:
+
+            if material_types := relationships["material_type"]["data"]:
+                for mtype in material_types:
+                    uuid = mtype["id"]
+                    material_type_uuids.append(uuid)
+                    material_type = {
+                        "uuid": uuid,
+                        "type": mtype["type"],
+                    }
+                    if mtype := included.get(uuid):
+                        material_type.update(
+                            {
+                                "name": mtype["attributes"]["name"],
+                            }
+                        )
+                    material_type_objects.append(material_type)
+
+        normal.update(
+            {
+                "material_types": material_type_objects,
+                "material_type_uuids": material_type_uuids,
+            }
+        )
+        return normal
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+
+        # material_types
+        f.fields.insert_before("measure", "material_types")
+        f.set_node("material_types", FarmOSRefs(self.request, "farmos_material_types"))
+
+    def get_xref_buttons(self, material_quantity):
+        model = self.app.model
+        session = self.Session()
+        buttons = []
+
+        if wf_material_quantity := (
+            session.query(model.MaterialQuantity)
+            .join(model.Quantity)
+            .filter(model.Quantity.farmos_uuid == material_quantity["uuid"])
+            .first()
+        ):
+            buttons.append(
+                self.make_button(
+                    f"View {self.app.get_title()} record",
+                    primary=True,
+                    url=self.request.route_url(
+                        "quantities_material.view", uuid=wf_material_quantity.uuid
+                    ),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+
 def defaults(config, **kwargs):
     base = globals()
 
@@ -349,6 +444,11 @@ def defaults(config, **kwargs):
     )
     StandardQuantityView.defaults(config)
 
+    MaterialQuantityView = kwargs.get(
+        "MaterialQuantityView", base["MaterialQuantityView"]
+    )
+    MaterialQuantityView.defaults(config)
+
 
 def includeme(config):
     defaults(config)
diff --git a/src/wuttafarm/web/views/logs.py b/src/wuttafarm/web/views/logs.py
index acf8f0d..3d91ba1 100644
--- a/src/wuttafarm/web/views/logs.py
+++ b/src/wuttafarm/web/views/logs.py
@@ -290,7 +290,9 @@ class LogMasterView(WuttaFarmMasterView):
         f.set_node("quantities", QuantityRefs(self.request))
         if not self.creating:
             # nb. must explicity declare value for non-standard field
-            f.set_default("quantities", log.quantities)
+            f.set_default(
+                "quantities", [self.app.get_true_quantity(q) for q in log.quantities]
+            )
 
         # notes
         f.set_widget("notes", "notes")
@@ -389,15 +391,15 @@ class LogMasterView(WuttaFarmMasterView):
         model = self.app.model
         session = self.Session()
 
-        current = {qty.uuid.hex: qty for qty in log.quantities}
+        current = {
+            qty.uuid.hex: self.app.get_true_quantity(qty) for qty in log.quantities
+        }
         for new_qty in desired:
             units = session.get(model.Unit, new_qty["units"]["uuid"])
             assert units
             if new_qty["uuid"].startswith("new_"):
-                assert new_qty["quantity_type"]["drupal_id"] == "standard"
-                factory = model.StandardQuantity
-                qty = factory(
-                    quantity_type_id=new_qty["quantity_type"]["drupal_id"],
+                qty = self.app.make_true_quantity(
+                    new_qty["quantity_type"]["drupal_id"],
                     measure_id=new_qty["measure"],
                     value_numerator=int(new_qty["value"]),
                     value_denominator=1,
@@ -413,6 +415,8 @@ class LogMasterView(WuttaFarmMasterView):
                 old_qty.value_numerator = int(new_qty["value"])
                 old_qty.value_denominator = 1
                 old_qty.units = units
+                if old_qty.quantity_type_id == "material":
+                    self.set_material_types(old_qty, new_qty["material_types"])
 
         desired = [qty["uuid"] for qty in desired]
         for old_qty in list(log.quantities):
@@ -421,6 +425,22 @@ class LogMasterView(WuttaFarmMasterView):
             if old_qty.uuid and old_qty.uuid.hex not in desired:
                 log.quantities.remove(old_qty)
 
+    def set_material_types(self, quantity, desired):
+        model = self.app.model
+        session = self.Session()
+        current = {mtype.uuid: mtype for mtype in quantity.material_types}
+
+        for new_mtype in desired:
+            mtype = session.get(model.MaterialType, new_mtype["uuid"])
+            assert mtype
+            if mtype.uuid not in current:
+                quantity.material_types.append(mtype)
+
+        desired = [mtype["uuid"] for mtype in desired]
+        for old_mtype in current.values():
+            if old_mtype.uuid.hex not in desired:
+                quantity.material_types.remove(old_mtype)
+
     def auto_sync_to_farmos(self, client, log):
         model = self.app.model
         session = self.Session()
@@ -429,11 +449,8 @@ class LogMasterView(WuttaFarmMasterView):
         session.flush()
 
         for qty in log.quantities:
-            # TODO: support more quantity types
-            if qty.quantity_type_id == "standard":
-                qty = session.get(model.StandardQuantity, qty.uuid)
-                assert qty
-                self.app.auto_sync_to_farmos(qty, client=client)
+            qty = self.app.get_true_quantity(qty)
+            self.app.auto_sync_to_farmos(qty, client=client)
 
         self.app.auto_sync_to_farmos(log, client=client)
 
diff --git a/src/wuttafarm/web/views/quantities.py b/src/wuttafarm/web/views/quantities.py
index 9ff8912..9a91941 100644
--- a/src/wuttafarm/web/views/quantities.py
+++ b/src/wuttafarm/web/views/quantities.py
@@ -30,8 +30,13 @@ from webhelpers2.html import tags
 from wuttaweb.db import Session
 
 from wuttafarm.web.views import WuttaFarmMasterView
-from wuttafarm.db.model import QuantityType, Quantity, StandardQuantity
-from wuttafarm.web.forms.schema import UnitRef, LogRef
+from wuttafarm.db.model import (
+    QuantityType,
+    Quantity,
+    StandardQuantity,
+    MaterialQuantity,
+)
+from wuttafarm.web.forms.schema import UnitRef, LogRef, MaterialTypeRefs
 from wuttafarm.util import get_log_type_enum
 
 
@@ -370,6 +375,74 @@ class StandardQuantityView(QuantityMasterView):
     farmos_refurl_path = "/log-quantities/standard"
 
 
+class MaterialQuantityView(QuantityMasterView):
+    """
+    Master view for Material Quantities
+    """
+
+    model_class = MaterialQuantity
+    route_prefix = "quantities_material"
+    url_prefix = "/quantities/material"
+
+    farmos_bundle = "material"
+    farmos_refurl_path = "/log-quantities/material"
+
+    def configure_grid(self, grid):
+        g = grid
+        super().configure_grid(g)
+
+        # material_types
+        g.columns.append("material_types")
+        g.set_label("material_types", "Material Type", column_only=True)
+        g.set_renderer("material_types", self.render_material_types_for_grid)
+
+    def render_material_types_for_grid(self, quantity, field, value):
+        if self.farmos_style_grid_links:
+            links = []
+            for mtype in quantity.material_types:
+                url = self.request.route_url("material_types.view", uuid=mtype.uuid)
+                links.append(tags.link_to(str(mtype), url))
+            return ", ".join(links)
+
+        return ", ".join([str(mtype) for mtype in quantity.material_types])
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+        quantity = form.model_instance
+
+        # material_types
+        f.fields.insert_after("quantity_type", "material_types")
+        f.set_node("material_types", MaterialTypeRefs(self.request))
+        if not self.creating:
+            f.set_default("material_types", quantity.material_types)
+
+    def objectify(self, form):
+        quantity = super().objectify(form)
+        data = form.validated
+
+        self.set_material_types(quantity, data["material_types"])
+
+        return quantity
+
+    def set_material_types(self, quantity, desired):
+        model = self.app.model
+        session = self.Session()
+
+        current = {mt.uuid.hex: mt for mt in quantity.material_types}
+
+        for mtype in desired:
+            if mtype["uuid"] not in current:
+                mtype = session.get(model.MaterialType, mtype["uuid"])
+                assert mtype
+                quantity.material_types.append(mtype)
+
+        desired = [mtype["uuid"] for mtype in desired]
+        for uuid, mtype in current.items():
+            if uuid not in desired:
+                quantity.material_types.remove(mtype)
+
+
 def defaults(config, **kwargs):
     base = globals()
 
@@ -384,6 +457,11 @@ def defaults(config, **kwargs):
     )
     StandardQuantityView.defaults(config)
 
+    MaterialQuantityView = kwargs.get(
+        "MaterialQuantityView", base["MaterialQuantityView"]
+    )
+    MaterialQuantityView.defaults(config)
+
 
 def includeme(config):
     defaults(config)

From d9211c17135ff56a76be00c3520c953e1c0a7133 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Mon, 9 Mar 2026 15:36:51 -0500
Subject: [PATCH 15/20] feat: add schema, edit/sync support for Water Assets

---
 .../versions/de1197d24485_add_waterasset.py   | 100 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   1 +
 src/wuttafarm/db/model/asset_water.py         |  45 ++++++++
 src/wuttafarm/farmos/importing/model.py       |  15 +++
 src/wuttafarm/farmos/importing/wuttafarm.py   |   9 ++
 src/wuttafarm/importing/farmos.py             |   9 ++
 src/wuttafarm/web/menus.py                    |  15 +++
 src/wuttafarm/web/views/__init__.py           |   1 +
 src/wuttafarm/web/views/farmos/__init__.py    |   1 +
 src/wuttafarm/web/views/farmos/assets.py      |  44 +++++++-
 src/wuttafarm/web/views/farmos/quantities.py  |   1 +
 src/wuttafarm/web/views/farmos/water.py       |  81 ++++++++++++++
 src/wuttafarm/web/views/water.py              |  59 +++++++++++
 13 files changed, 376 insertions(+), 5 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/de1197d24485_add_waterasset.py
 create mode 100644 src/wuttafarm/db/model/asset_water.py
 create mode 100644 src/wuttafarm/web/views/farmos/water.py
 create mode 100644 src/wuttafarm/web/views/water.py

diff --git a/src/wuttafarm/db/alembic/versions/de1197d24485_add_waterasset.py b/src/wuttafarm/db/alembic/versions/de1197d24485_add_waterasset.py
new file mode 100644
index 0000000..e123fc3
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/de1197d24485_add_waterasset.py
@@ -0,0 +1,100 @@
+"""add WaterAsset
+
+Revision ID: de1197d24485
+Revises: 9c53513f8862
+Create Date: 2026-03-09 14:59:12.032318
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "de1197d24485"
+down_revision: Union[str, None] = "9c53513f8862"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # asset_water
+    op.create_table(
+        "asset_water",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["uuid"], ["asset.uuid"], name=op.f("fk_asset_water_uuid_asset")
+        ),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_asset_water")),
+    )
+    op.create_table(
+        "asset_water_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_asset_water_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_asset_water_version_end_transaction_id"),
+        "asset_water_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_water_version_operation_type"),
+        "asset_water_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_water_version_pk_transaction_id",
+        "asset_water_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_water_version_pk_validity",
+        "asset_water_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_water_version_transaction_id"),
+        "asset_water_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # asset_water
+    op.drop_index(
+        op.f("ix_asset_water_version_transaction_id"), table_name="asset_water_version"
+    )
+    op.drop_index(
+        "ix_asset_water_version_pk_validity", table_name="asset_water_version"
+    )
+    op.drop_index(
+        "ix_asset_water_version_pk_transaction_id", table_name="asset_water_version"
+    )
+    op.drop_index(
+        op.f("ix_asset_water_version_operation_type"), table_name="asset_water_version"
+    )
+    op.drop_index(
+        op.f("ix_asset_water_version_end_transaction_id"),
+        table_name="asset_water_version",
+    )
+    op.drop_table("asset_water_version")
+    op.drop_table("asset_water")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index 35130da..e2b96c4 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -51,6 +51,7 @@ from .asset_plant import (
     PlantAssetPlantType,
     PlantAssetSeason,
 )
+from .asset_water import WaterAsset
 from .log import LogType, Log, LogAsset, LogGroup, LogLocation, LogQuantity, LogOwner
 from .log_activity import ActivityLog
 from .log_harvest import HarvestLog
diff --git a/src/wuttafarm/db/model/asset_water.py b/src/wuttafarm/db/model/asset_water.py
new file mode 100644
index 0000000..046c899
--- /dev/null
+++ b/src/wuttafarm/db/model/asset_water.py
@@ -0,0 +1,45 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Model definition for Water Assets
+"""
+
+from wuttjamaican.db import model
+
+from wuttafarm.db.model.asset import AssetMixin, add_asset_proxies
+
+
+class WaterAsset(AssetMixin, model.Base):
+    """
+    Represents a water asset from farmOS
+    """
+
+    __tablename__ = "asset_water"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Water Asset",
+        "model_title_plural": "Water Assets",
+        "farmos_asset_type": "water",
+    }
+
+
+add_asset_proxies(WaterAsset)
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 4905a5e..5e6f01b 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -491,6 +491,21 @@ class StructureAssetImporter(ToFarmOSAsset):
         return payload
 
 
+class WaterAssetImporter(ToFarmOSAsset):
+
+    model_title = "WaterAsset"
+    farmos_asset_type = "water"
+
+    supported_fields = [
+        "uuid",
+        "asset_name",
+        "is_location",
+        "is_fixed",
+        "notes",
+        "archived",
+    ]
+
+
 ##############################
 # quantity importers
 ##############################
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 7bb9538..7f99b51 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -98,6 +98,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers = super().define_importers()
         importers["LandAsset"] = LandAssetImporter
         importers["StructureAsset"] = StructureAssetImporter
+        importers["WaterAsset"] = WaterAssetImporter
         importers["AnimalType"] = AnimalTypeImporter
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
@@ -417,6 +418,14 @@ class StructureAssetImporter(
         return data
 
 
+class WaterAssetImporter(FromWuttaFarmAsset, farmos_importing.model.WaterAssetImporter):
+    """
+    WuttaFarm → farmOS API exporter for Water Assets
+    """
+
+    source_model_class = model.WaterAsset
+
+
 ##############################
 # quantity importers
 ##############################
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index 695d373..a16393d 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -106,6 +106,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["LandAsset"] = LandAssetImporter
         importers["StructureType"] = StructureTypeImporter
         importers["StructureAsset"] = StructureAssetImporter
+        importers["WaterAsset"] = WaterAssetImporter
         importers["AnimalType"] = AnimalTypeImporter
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
@@ -830,6 +831,14 @@ class StructureTypeImporter(FromFarmOS, ToWutta):
         }
 
 
+class WaterAssetImporter(AssetImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Water Assets
+    """
+
+    model_class = model.WaterAsset
+
+
 class UserImporter(FromFarmOS, ToWutta):
     """
     farmOS API → WuttaFarm importer for Users
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index 249c210..e518361 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -112,6 +112,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "structure_assets",
                     "perm": "structure_assets.list",
                 },
+                {
+                    "title": "Water",
+                    "route": "water_assets",
+                    "perm": "water_assets.list",
+                },
                 {"type": "sep"},
                 {
                     "title": "Animal Types",
@@ -259,6 +264,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_structure_assets",
                     "perm": "farmos_structure_assets.list",
                 },
+                {
+                    "title": "Water Assets",
+                    "route": "farmos_water_assets",
+                    "perm": "farmos_water_assets.list",
+                },
                 {"type": "sep"},
                 {
                     "title": "Activity Logs",
@@ -383,6 +393,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_structure_assets",
                     "perm": "farmos_structure_assets.list",
                 },
+                {
+                    "title": "Water",
+                    "route": "farmos_water_assets",
+                    "perm": "farmos_water_assets.list",
+                },
                 {"type": "sep"},
                 {
                     "title": "Animal Types",
diff --git a/src/wuttafarm/web/views/__init__.py b/src/wuttafarm/web/views/__init__.py
index d189e42..94f8772 100644
--- a/src/wuttafarm/web/views/__init__.py
+++ b/src/wuttafarm/web/views/__init__.py
@@ -57,6 +57,7 @@ def includeme(config):
         config.include("wuttafarm.web.views.animals")
         config.include("wuttafarm.web.views.groups")
         config.include("wuttafarm.web.views.plants")
+        config.include("wuttafarm.web.views.water")
         config.include("wuttafarm.web.views.logs")
         config.include("wuttafarm.web.views.logs_activity")
         config.include("wuttafarm.web.views.logs_harvest")
diff --git a/src/wuttafarm/web/views/farmos/__init__.py b/src/wuttafarm/web/views/farmos/__init__.py
index 9cb57d5..2de8ff9 100644
--- a/src/wuttafarm/web/views/farmos/__init__.py
+++ b/src/wuttafarm/web/views/farmos/__init__.py
@@ -40,6 +40,7 @@ def includeme(config):
     config.include("wuttafarm.web.views.farmos.animals")
     config.include("wuttafarm.web.views.farmos.groups")
     config.include("wuttafarm.web.views.farmos.plants")
+    config.include("wuttafarm.web.views.farmos.water")
     config.include("wuttafarm.web.views.farmos.log_types")
     config.include("wuttafarm.web.views.farmos.logs_activity")
     config.include("wuttafarm.web.views.farmos.logs_harvest")
diff --git a/src/wuttafarm/web/views/farmos/assets.py b/src/wuttafarm/web/views/farmos/assets.py
index 11f744b..863b947 100644
--- a/src/wuttafarm/web/views/farmos/assets.py
+++ b/src/wuttafarm/web/views/farmos/assets.py
@@ -24,6 +24,7 @@ Base class for Asset master views
 """
 
 import colander
+import requests
 from webhelpers2.html import tags
 
 from wuttafarm.web.views.farmos import FarmOSMasterView
@@ -75,6 +76,22 @@ class AssetMasterView(FarmOSMasterView):
         "archived": {"active": True, "verb": "is_false"},
     }
 
+    form_fields = [
+        "name",
+        "notes",
+        "asset_type_name",
+        "is_location",
+        "is_fixed",
+        "owners",
+        "locations",
+        "groups",
+        "archived",
+        "thumbnail_url",
+        "image_url",
+        "thumbnail",
+        "image",
+    ]
+
     def get_grid_data(self, **kwargs):
         return ResourceData(
             self.config,
@@ -142,11 +159,16 @@ class AssetMasterView(FarmOSMasterView):
         return {"asset_type", "location", "owner", "image"}
 
     def get_instance(self):
-        result = self.farmos_client.asset.get_id(
-            self.farmos_asset_type,
-            self.request.matchdict["uuid"],
-            params={"include": ",".join(self.get_farmos_api_includes())},
-        )
+        try:
+            result = self.farmos_client.asset.get_id(
+                self.farmos_asset_type,
+                self.request.matchdict["uuid"],
+                params={"include": ",".join(self.get_farmos_api_includes())},
+            )
+        except requests.HTTPError as exc:
+            if exc.response.status_code == 404:
+                raise self.notfound()
+            raise
         self.raw_json = result
         included = {obj["id"]: obj for obj in result.get("included", [])}
         return self.normalize_asset(result["data"], included)
@@ -217,6 +239,8 @@ class AssetMasterView(FarmOSMasterView):
             "name": asset["attributes"]["name"],
             "asset_type": asset_type_object,
             "asset_type_name": asset_type_name,
+            "is_location": asset["attributes"]["is_location"],
+            "is_fixed": asset["attributes"]["is_fixed"],
             "notes": notes or colander.null,
             "owners": owner_objects,
             "owner_names": owner_names,
@@ -253,6 +277,16 @@ class AssetMasterView(FarmOSMasterView):
         f.set_widget("notes", "notes")
         f.set_required("notes", False)
 
+        # is_location
+        f.set_node("is_location", colander.Boolean())
+
+        # is_fixed
+        f.set_node("is_fixed", colander.Boolean())
+
+        # groups
+        if self.creating or self.editing:
+            f.remove("groups")  # TODO: add support for this?
+
         # archived
         f.set_node("archived", colander.Boolean())
 
diff --git a/src/wuttafarm/web/views/farmos/quantities.py b/src/wuttafarm/web/views/farmos/quantities.py
index 1c3830f..bd2e519 100644
--- a/src/wuttafarm/web/views/farmos/quantities.py
+++ b/src/wuttafarm/web/views/farmos/quantities.py
@@ -217,6 +217,7 @@ class QuantityMasterView(FarmOSMasterView):
         except requests.HTTPError as exc:
             if exc.response.status_code == 404:
                 raise self.notfound()
+            raise
 
         self.raw_json = result
 
diff --git a/src/wuttafarm/web/views/farmos/water.py b/src/wuttafarm/web/views/farmos/water.py
new file mode 100644
index 0000000..129f22e
--- /dev/null
+++ b/src/wuttafarm/web/views/farmos/water.py
@@ -0,0 +1,81 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Master view for Water Assets in farmOS
+"""
+
+from wuttafarm.web.views.farmos.assets import AssetMasterView
+
+
+class WaterAssetView(AssetMasterView):
+    """
+    Master view for farmOS Water Assets
+    """
+
+    model_name = "farmos_water_assets"
+    model_title = "farmOS Water Asset"
+    model_title_plural = "farmOS Water Assets"
+
+    route_prefix = "farmos_water_assets"
+    url_prefix = "/farmOS/assets/water"
+
+    farmos_asset_type = "water"
+    farmos_refurl_path = "/assets/water"
+
+    grid_columns = [
+        "thumbnail",
+        "drupal_id",
+        "name",
+        "archived",
+    ]
+
+    def get_xref_buttons(self, water):
+        model = self.app.model
+        session = self.Session()
+        buttons = super().get_xref_buttons(water)
+
+        if wf_water := (
+            session.query(model.Asset)
+            .filter(model.Asset.farmos_uuid == water["uuid"])
+            .first()
+        ):
+            buttons.append(
+                self.make_button(
+                    f"View {self.app.get_title()} record",
+                    primary=True,
+                    url=self.request.route_url("water_assets.view", uuid=wf_water.uuid),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    WaterAssetView = kwargs.get("WaterAssetView", base["WaterAssetView"])
+    WaterAssetView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)
diff --git a/src/wuttafarm/web/views/water.py b/src/wuttafarm/web/views/water.py
new file mode 100644
index 0000000..c0d551e
--- /dev/null
+++ b/src/wuttafarm/web/views/water.py
@@ -0,0 +1,59 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Master view for Water Assets
+"""
+
+from wuttafarm.db.model import WaterAsset
+from wuttafarm.web.views.assets import AssetMasterView
+
+
+class WaterAssetView(AssetMasterView):
+    """
+    Master view for Plant Assets
+    """
+
+    model_class = WaterAsset
+    route_prefix = "water_assets"
+    url_prefix = "/assets/water"
+
+    farmos_bundle = "water"
+    farmos_refurl_path = "/assets/water"
+
+    grid_columns = [
+        "thumbnail",
+        "drupal_id",
+        "asset_name",
+        "parents",
+        "archived",
+    ]
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    WaterAssetView = kwargs.get("WaterAssetView", base["WaterAssetView"])
+    WaterAssetView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)

From 03f6da8ab7d821047eb3c88f9f28afb8a5df8f69 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Mon, 9 Mar 2026 15:58:41 -0500
Subject: [PATCH 16/20] feat: add schema, edit/sync support for Equipment Types

---
 .../e5b27eac471c_add_equipmenttype.py         | 118 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   1 +
 src/wuttafarm/db/model/asset_equipment.py     |  41 ++++++
 src/wuttafarm/db/model/taxonomy.py            |  74 +++++++++++
 src/wuttafarm/farmos/importing/model.py       |   6 +
 src/wuttafarm/farmos/importing/wuttafarm.py   |  11 ++
 src/wuttafarm/importing/farmos.py             |  10 ++
 src/wuttafarm/web/menus.py                    |  15 +++
 src/wuttafarm/web/views/__init__.py           |   1 +
 src/wuttafarm/web/views/equipment.py          |  53 ++++++++
 src/wuttafarm/web/views/farmos/__init__.py    |   1 +
 src/wuttafarm/web/views/farmos/equipment.py   |  76 +++++++++++
 12 files changed, 407 insertions(+)
 create mode 100644 src/wuttafarm/db/alembic/versions/e5b27eac471c_add_equipmenttype.py
 create mode 100644 src/wuttafarm/db/model/asset_equipment.py
 create mode 100644 src/wuttafarm/db/model/taxonomy.py
 create mode 100644 src/wuttafarm/web/views/equipment.py
 create mode 100644 src/wuttafarm/web/views/farmos/equipment.py

diff --git a/src/wuttafarm/db/alembic/versions/e5b27eac471c_add_equipmenttype.py b/src/wuttafarm/db/alembic/versions/e5b27eac471c_add_equipmenttype.py
new file mode 100644
index 0000000..a436725
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/e5b27eac471c_add_equipmenttype.py
@@ -0,0 +1,118 @@
+"""add EquipmentType
+
+Revision ID: e5b27eac471c
+Revises: de1197d24485
+Create Date: 2026-03-09 15:45:35.047694
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "e5b27eac471c"
+down_revision: Union[str, None] = "de1197d24485"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # equipment_type
+    op.create_table(
+        "equipment_type",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("name", sa.String(length=100), nullable=False),
+        sa.Column("description", sa.String(length=255), nullable=True),
+        sa.Column("drupal_id", sa.Integer(), nullable=True),
+        sa.Column("farmos_uuid", wuttjamaican.db.util.UUID(), nullable=True),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_equipment_type")),
+        sa.UniqueConstraint("drupal_id", name=op.f("uq_equipment_type_drupal_id")),
+        sa.UniqueConstraint("farmos_uuid", name=op.f("uq_equipment_type_farmos_uuid")),
+        sa.UniqueConstraint("name", name=op.f("uq_equipment_type_name")),
+    )
+    op.create_table(
+        "equipment_type_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column("name", sa.String(length=100), autoincrement=False, nullable=True),
+        sa.Column(
+            "description", sa.String(length=255), autoincrement=False, nullable=True
+        ),
+        sa.Column("drupal_id", sa.Integer(), autoincrement=False, nullable=True),
+        sa.Column(
+            "farmos_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_equipment_type_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_equipment_type_version_end_transaction_id"),
+        "equipment_type_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_equipment_type_version_operation_type"),
+        "equipment_type_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_equipment_type_version_pk_transaction_id",
+        "equipment_type_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_equipment_type_version_pk_validity",
+        "equipment_type_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_equipment_type_version_transaction_id"),
+        "equipment_type_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # equipment_type
+    op.drop_index(
+        op.f("ix_equipment_type_version_transaction_id"),
+        table_name="equipment_type_version",
+    )
+    op.drop_index(
+        "ix_equipment_type_version_pk_validity", table_name="equipment_type_version"
+    )
+    op.drop_index(
+        "ix_equipment_type_version_pk_transaction_id",
+        table_name="equipment_type_version",
+    )
+    op.drop_index(
+        op.f("ix_equipment_type_version_operation_type"),
+        table_name="equipment_type_version",
+    )
+    op.drop_index(
+        op.f("ix_equipment_type_version_end_transaction_id"),
+        table_name="equipment_type_version",
+    )
+    op.drop_table("equipment_type_version")
+    op.drop_table("equipment_type")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index e2b96c4..7475543 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -42,6 +42,7 @@ from .quantities import (
 from .asset import AssetType, Asset, AssetParent
 from .asset_land import LandType, LandAsset
 from .asset_structure import StructureType, StructureAsset
+from .asset_equipment import EquipmentType
 from .asset_animal import AnimalType, AnimalAsset
 from .asset_group import GroupAsset
 from .asset_plant import (
diff --git a/src/wuttafarm/db/model/asset_equipment.py b/src/wuttafarm/db/model/asset_equipment.py
new file mode 100644
index 0000000..6a589f1
--- /dev/null
+++ b/src/wuttafarm/db/model/asset_equipment.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Model definition for Equipment
+"""
+
+from wuttjamaican.db import model
+
+from wuttafarm.db.model.taxonomy import TaxonomyMixin
+
+
+class EquipmentType(TaxonomyMixin, model.Base):
+    """
+    Represents a "equipment type" (taxonomy term) from farmOS
+    """
+
+    __tablename__ = "equipment_type"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Equipment Type",
+        "model_title_plural": "Equipment Types",
+    }
diff --git a/src/wuttafarm/db/model/taxonomy.py b/src/wuttafarm/db/model/taxonomy.py
new file mode 100644
index 0000000..3d84197
--- /dev/null
+++ b/src/wuttafarm/db/model/taxonomy.py
@@ -0,0 +1,74 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Base logic for taxonomy term models
+"""
+
+import sqlalchemy as sa
+
+from wuttjamaican.db import model
+
+
+class TaxonomyMixin:
+    """
+    Mixin for taxonomy term models
+    """
+
+    uuid = model.uuid_column()
+
+    name = sa.Column(
+        sa.String(length=100),
+        nullable=False,
+        unique=True,
+        doc="""
+        Name for the taxonomy term.
+        """,
+    )
+
+    description = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Optional description for the taxonomy term.
+        """,
+    )
+
+    drupal_id = sa.Column(
+        sa.Integer(),
+        nullable=True,
+        unique=True,
+        doc="""
+        Drupal internal ID for the taxonomy term.
+        """,
+    )
+
+    farmos_uuid = sa.Column(
+        model.UUID(),
+        nullable=True,
+        unique=True,
+        doc="""
+        UUID for the taxonomy term within farmOS.
+        """,
+    )
+
+    def __str__(self):
+        return self.name or ""
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 5e6f01b..26e040c 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -319,6 +319,12 @@ class AnimalTypeImporter(ToFarmOSTaxonomy):
     farmos_taxonomy_type = "animal_type"
 
 
+class EquipmentTypeImporter(ToFarmOSTaxonomy):
+
+    model_title = "EquipmentType"
+    farmos_taxonomy_type = "equipment_type"
+
+
 class MaterialTypeImporter(ToFarmOSTaxonomy):
 
     model_title = "MaterialType"
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index 7f99b51..f6e7a39 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -99,6 +99,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers["LandAsset"] = LandAssetImporter
         importers["StructureAsset"] = StructureAssetImporter
         importers["WaterAsset"] = WaterAssetImporter
+        importers["EquipmentType"] = EquipmentTypeImporter
         importers["AnimalType"] = AnimalTypeImporter
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
@@ -224,6 +225,16 @@ class FromWuttaFarmTaxonomy(FromWuttaFarm):
         }
 
 
+class EquipmentTypeImporter(
+    FromWuttaFarmTaxonomy, farmos_importing.model.EquipmentTypeImporter
+):
+    """
+    WuttaFarm → farmOS API exporter for Equipment Types
+    """
+
+    source_model_class = model.EquipmentType
+
+
 class AnimalTypeImporter(
     FromWuttaFarmTaxonomy, farmos_importing.model.AnimalTypeImporter
 ):
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index a16393d..dda4974 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -107,6 +107,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["StructureType"] = StructureTypeImporter
         importers["StructureAsset"] = StructureAssetImporter
         importers["WaterAsset"] = WaterAssetImporter
+        importers["EquipmentType"] = EquipmentTypeImporter
         importers["AnimalType"] = AnimalTypeImporter
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
@@ -451,6 +452,15 @@ class MaterialTypeImporter(TaxonomyImporterBase):
     taxonomy_type = "material_type"
 
 
+class EquipmentTypeImporter(TaxonomyImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Equipment Types
+    """
+
+    model_class = model.EquipmentType
+    taxonomy_type = "equipment_type"
+
+
 class AssetTypeImporter(FromFarmOS, ToWutta):
     """
     farmOS API → WuttaFarm importer for Asset Types
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index e518361..ed7a11a 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -123,6 +123,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "animal_types",
                     "perm": "animal_types.list",
                 },
+                {
+                    "title": "Equipment Types",
+                    "route": "equipment_types",
+                    "perm": "equipment_types.list",
+                },
                 {
                     "title": "Land Types",
                     "route": "land_types",
@@ -296,6 +301,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_animal_types",
                     "perm": "farmos_animal_types.list",
                 },
+                {
+                    "title": "Equipment Types",
+                    "route": "farmos_equipment_types",
+                    "perm": "farmos_equipment_types.list",
+                },
                 {
                     "title": "Land Types",
                     "route": "farmos_land_types",
@@ -404,6 +414,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_animal_types",
                     "perm": "farmos_animal_types.list",
                 },
+                {
+                    "title": "Equipment Types",
+                    "route": "farmos_equipment_types",
+                    "perm": "farmos_equipment_types.list",
+                },
                 {
                     "title": "Land Types",
                     "route": "farmos_land_types",
diff --git a/src/wuttafarm/web/views/__init__.py b/src/wuttafarm/web/views/__init__.py
index 94f8772..8e57f34 100644
--- a/src/wuttafarm/web/views/__init__.py
+++ b/src/wuttafarm/web/views/__init__.py
@@ -54,6 +54,7 @@ def includeme(config):
         config.include("wuttafarm.web.views.assets")
         config.include("wuttafarm.web.views.land")
         config.include("wuttafarm.web.views.structures")
+        config.include("wuttafarm.web.views.equipment")
         config.include("wuttafarm.web.views.animals")
         config.include("wuttafarm.web.views.groups")
         config.include("wuttafarm.web.views.plants")
diff --git a/src/wuttafarm/web/views/equipment.py b/src/wuttafarm/web/views/equipment.py
new file mode 100644
index 0000000..5e080ef
--- /dev/null
+++ b/src/wuttafarm/web/views/equipment.py
@@ -0,0 +1,53 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Master view for Plants
+"""
+
+from wuttafarm.db.model import EquipmentType
+from wuttafarm.web.views import TaxonomyMasterView
+
+
+class EquipmentTypeView(TaxonomyMasterView):
+    """
+    Master view for Equipment Types
+    """
+
+    model_class = EquipmentType
+    route_prefix = "equipment_types"
+    url_prefix = "/equipment-types"
+
+    farmos_route_prefix = "farmos_equipment_types"
+    farmos_entity_type = "taxonomy_term"
+    farmos_bundle = "equipment_type"
+    farmos_refurl_path = "/admin/structure/taxonomy/manage/equipment_type/overview"
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    EquipmentTypeView = kwargs.get("EquipmentTypeView", base["EquipmentTypeView"])
+    EquipmentTypeView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)
diff --git a/src/wuttafarm/web/views/farmos/__init__.py b/src/wuttafarm/web/views/farmos/__init__.py
index 2de8ff9..c92a04c 100644
--- a/src/wuttafarm/web/views/farmos/__init__.py
+++ b/src/wuttafarm/web/views/farmos/__init__.py
@@ -36,6 +36,7 @@ def includeme(config):
     config.include("wuttafarm.web.views.farmos.land_assets")
     config.include("wuttafarm.web.views.farmos.structure_types")
     config.include("wuttafarm.web.views.farmos.structures")
+    config.include("wuttafarm.web.views.farmos.equipment")
     config.include("wuttafarm.web.views.farmos.animal_types")
     config.include("wuttafarm.web.views.farmos.animals")
     config.include("wuttafarm.web.views.farmos.groups")
diff --git a/src/wuttafarm/web/views/farmos/equipment.py b/src/wuttafarm/web/views/farmos/equipment.py
new file mode 100644
index 0000000..67987c3
--- /dev/null
+++ b/src/wuttafarm/web/views/farmos/equipment.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Master view for farmOS Equipment
+"""
+
+from wuttafarm.web.views.farmos.master import TaxonomyMasterView
+
+
+class EquipmentTypeView(TaxonomyMasterView):
+    """
+    Master view for Equipment Types in farmOS.
+    """
+
+    model_name = "farmos_equipment_type"
+    model_title = "farmOS Equipment Type"
+    model_title_plural = "farmOS Equipment Types"
+
+    route_prefix = "farmos_equipment_types"
+    url_prefix = "/farmOS/equipment-types"
+
+    farmos_taxonomy_type = "equipment_type"
+    farmos_refurl_path = "/admin/structure/taxonomy/manage/equipment_type/overview"
+
+    def get_xref_buttons(self, equipment_type):
+        buttons = super().get_xref_buttons(equipment_type)
+        model = self.app.model
+        session = self.Session()
+
+        if wf_equipment_type := (
+            session.query(model.EquipmentType)
+            .filter(model.EquipmentType.farmos_uuid == equipment_type["uuid"])
+            .first()
+        ):
+            buttons.append(
+                self.make_button(
+                    f"View {self.app.get_title()} record",
+                    primary=True,
+                    url=self.request.route_url(
+                        "equipment_types.view", uuid=wf_equipment_type.uuid
+                    ),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    EquipmentTypeView = kwargs.get("EquipmentTypeView", base["EquipmentTypeView"])
+    EquipmentTypeView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)

From 42c73375ace006bea691a78f70ac671c17921ef9 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Mon, 9 Mar 2026 20:32:53 -0500
Subject: [PATCH 17/20] feat: add schema, edit/sync support for Equipment
 Assets

---
 .../e9b8664e1f39_add_equipmentasset.py        | 218 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   2 +-
 src/wuttafarm/db/model/asset_equipment.py     |  94 +++++++-
 src/wuttafarm/farmos/importing/model.py       |  62 +++++
 src/wuttafarm/farmos/importing/wuttafarm.py   |  39 ++++
 src/wuttafarm/importing/farmos.py             | 106 +++++++++
 src/wuttafarm/web/forms/schema.py             |  60 ++++-
 src/wuttafarm/web/forms/widgets.py            | 115 +++++++++
 src/wuttafarm/web/menus.py                    |  15 ++
 .../web/templates/deform/equipmenttyperefs.pt |  13 ++
 .../web/templates/wuttafarm-components.mako   | 212 +++++++++++++++++
 src/wuttafarm/web/views/assets.py             |   2 +-
 src/wuttafarm/web/views/equipment.py          |  71 +++++-
 src/wuttafarm/web/views/farmos/animals.py     |  42 +---
 src/wuttafarm/web/views/farmos/assets.py      |  43 +++-
 src/wuttafarm/web/views/farmos/equipment.py   | 135 +++++++++++
 src/wuttafarm/web/views/master.py             |   1 +
 17 files changed, 1182 insertions(+), 48 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/e9b8664e1f39_add_equipmentasset.py
 create mode 100644 src/wuttafarm/web/templates/deform/equipmenttyperefs.pt

diff --git a/src/wuttafarm/db/alembic/versions/e9b8664e1f39_add_equipmentasset.py b/src/wuttafarm/db/alembic/versions/e9b8664e1f39_add_equipmentasset.py
new file mode 100644
index 0000000..2a8ed15
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/e9b8664e1f39_add_equipmentasset.py
@@ -0,0 +1,218 @@
+"""add EquipmentAsset
+
+Revision ID: e9b8664e1f39
+Revises: e5b27eac471c
+Create Date: 2026-03-09 18:05:54.917562
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "e9b8664e1f39"
+down_revision: Union[str, None] = "e5b27eac471c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # asset_equipment
+    op.create_table(
+        "asset_equipment",
+        sa.Column("manufacturer", sa.String(length=255), nullable=True),
+        sa.Column("model", sa.String(length=255), nullable=True),
+        sa.Column("serial_number", sa.String(length=255), nullable=True),
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["uuid"], ["asset.uuid"], name=op.f("fk_asset_equipment_uuid_asset")
+        ),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_asset_equipment")),
+    )
+    op.create_table(
+        "asset_equipment_version",
+        sa.Column(
+            "manufacturer", sa.String(length=255), autoincrement=False, nullable=True
+        ),
+        sa.Column("model", sa.String(length=255), autoincrement=False, nullable=True),
+        sa.Column(
+            "serial_number", sa.String(length=255), autoincrement=False, nullable=True
+        ),
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_asset_equipment_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_asset_equipment_version_end_transaction_id"),
+        "asset_equipment_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_equipment_version_operation_type"),
+        "asset_equipment_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_equipment_version_pk_transaction_id",
+        "asset_equipment_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_equipment_version_pk_validity",
+        "asset_equipment_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_equipment_version_transaction_id"),
+        "asset_equipment_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+    # asset_equipment_equipment_type
+    op.create_table(
+        "asset_equipment_equipment_type",
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("equipment_asset_uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.Column("equipment_type_uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["equipment_asset_uuid"],
+            ["asset_equipment.uuid"],
+            name=op.f(
+                "fk_asset_equipment_equipment_type_equipment_asset_uuid_asset_equipment"
+            ),
+        ),
+        sa.ForeignKeyConstraint(
+            ["equipment_type_uuid"],
+            ["equipment_type.uuid"],
+            name=op.f(
+                "fk_asset_equipment_equipment_type_equipment_type_uuid_equipment_type"
+            ),
+        ),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_asset_equipment_equipment_type")),
+    )
+    op.create_table(
+        "asset_equipment_equipment_type_version",
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "equipment_asset_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "equipment_type_uuid",
+            wuttjamaican.db.util.UUID(),
+            autoincrement=False,
+            nullable=True,
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid",
+            "transaction_id",
+            name=op.f("pk_asset_equipment_equipment_type_version"),
+        ),
+    )
+    op.create_index(
+        op.f("ix_asset_equipment_equipment_type_version_end_transaction_id"),
+        "asset_equipment_equipment_type_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_equipment_equipment_type_version_operation_type"),
+        "asset_equipment_equipment_type_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_equipment_equipment_type_version_pk_transaction_id",
+        "asset_equipment_equipment_type_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_asset_equipment_equipment_type_version_pk_validity",
+        "asset_equipment_equipment_type_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_asset_equipment_equipment_type_version_transaction_id"),
+        "asset_equipment_equipment_type_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # asset_equipment_equipment_type
+    op.drop_index(
+        op.f("ix_asset_equipment_equipment_type_version_transaction_id"),
+        table_name="asset_equipment_equipment_type_version",
+    )
+    op.drop_index(
+        "ix_asset_equipment_equipment_type_version_pk_validity",
+        table_name="asset_equipment_equipment_type_version",
+    )
+    op.drop_index(
+        "ix_asset_equipment_equipment_type_version_pk_transaction_id",
+        table_name="asset_equipment_equipment_type_version",
+    )
+    op.drop_index(
+        op.f("ix_asset_equipment_equipment_type_version_operation_type"),
+        table_name="asset_equipment_equipment_type_version",
+    )
+    op.drop_index(
+        op.f("ix_asset_equipment_equipment_type_version_end_transaction_id"),
+        table_name="asset_equipment_equipment_type_version",
+    )
+    op.drop_table("asset_equipment_equipment_type_version")
+    op.drop_table("asset_equipment_equipment_type")
+
+    # asset_equipment
+    op.drop_index(
+        op.f("ix_asset_equipment_version_transaction_id"),
+        table_name="asset_equipment_version",
+    )
+    op.drop_index(
+        "ix_asset_equipment_version_pk_validity", table_name="asset_equipment_version"
+    )
+    op.drop_index(
+        "ix_asset_equipment_version_pk_transaction_id",
+        table_name="asset_equipment_version",
+    )
+    op.drop_index(
+        op.f("ix_asset_equipment_version_operation_type"),
+        table_name="asset_equipment_version",
+    )
+    op.drop_index(
+        op.f("ix_asset_equipment_version_end_transaction_id"),
+        table_name="asset_equipment_version",
+    )
+    op.drop_table("asset_equipment_version")
+    op.drop_table("asset_equipment")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index 7475543..df4115a 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -42,7 +42,7 @@ from .quantities import (
 from .asset import AssetType, Asset, AssetParent
 from .asset_land import LandType, LandAsset
 from .asset_structure import StructureType, StructureAsset
-from .asset_equipment import EquipmentType
+from .asset_equipment import EquipmentType, EquipmentAsset, EquipmentAssetEquipmentType
 from .asset_animal import AnimalType, AnimalAsset
 from .asset_group import GroupAsset
 from .asset_plant import (
diff --git a/src/wuttafarm/db/model/asset_equipment.py b/src/wuttafarm/db/model/asset_equipment.py
index 6a589f1..51af9ee 100644
--- a/src/wuttafarm/db/model/asset_equipment.py
+++ b/src/wuttafarm/db/model/asset_equipment.py
@@ -23,14 +23,19 @@
 Model definition for Equipment
 """
 
+import sqlalchemy as sa
+from sqlalchemy import orm
+from sqlalchemy.ext.associationproxy import association_proxy
+
 from wuttjamaican.db import model
 
 from wuttafarm.db.model.taxonomy import TaxonomyMixin
+from wuttafarm.db.model.asset import AssetMixin, add_asset_proxies
 
 
 class EquipmentType(TaxonomyMixin, model.Base):
     """
-    Represents a "equipment type" (taxonomy term) from farmOS
+    Represents an "equipment type" (taxonomy term) from farmOS
     """
 
     __tablename__ = "equipment_type"
@@ -39,3 +44,90 @@ class EquipmentType(TaxonomyMixin, model.Base):
         "model_title": "Equipment Type",
         "model_title_plural": "Equipment Types",
     }
+
+    _equipment_assets = orm.relationship(
+        "EquipmentAssetEquipmentType",
+        cascade_backrefs=False,
+        back_populates="equipment_type",
+    )
+
+
+class EquipmentAsset(AssetMixin, model.Base):
+    """
+    Represents an equipment asset from farmOS
+    """
+
+    __tablename__ = "asset_equipment"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Equipment Asset",
+        "model_title_plural": "Equipment Assets",
+        "farmos_asset_type": "equipment",
+    }
+
+    manufacturer = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Name of the manufacturer, if applicable.
+        """,
+    )
+
+    model = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Model name for the equipment, if applicable.
+        """,
+    )
+
+    serial_number = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Serial number for the equipment, if applicable.
+        """,
+    )
+
+    _equipment_types = orm.relationship(
+        "EquipmentAssetEquipmentType",
+        cascade="all, delete-orphan",
+        cascade_backrefs=False,
+        back_populates="equipment_asset",
+    )
+
+    equipment_types = association_proxy(
+        "_equipment_types",
+        "equipment_type",
+        creator=lambda pt: EquipmentAssetEquipmentType(equipment_type=pt),
+    )
+
+
+add_asset_proxies(EquipmentAsset)
+
+
+class EquipmentAssetEquipmentType(model.Base):
+    """
+    Associates one or more equipment types with an equipment asset.
+    """
+
+    __tablename__ = "asset_equipment_equipment_type"
+    __versioned__ = {}
+
+    uuid = model.uuid_column()
+
+    equipment_asset_uuid = model.uuid_fk_column("asset_equipment.uuid", nullable=False)
+    equipment_asset = orm.relationship(
+        EquipmentAsset,
+        foreign_keys=equipment_asset_uuid,
+        back_populates="_equipment_types",
+    )
+
+    equipment_type_uuid = model.uuid_fk_column("equipment_type.uuid", nullable=False)
+    equipment_type = orm.relationship(
+        EquipmentType,
+        doc="""
+        Reference to the equipment type.
+        """,
+        back_populates="_equipment_assets",
+    )
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index 26e040c..bb1b41c 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -325,6 +325,68 @@ class EquipmentTypeImporter(ToFarmOSTaxonomy):
     farmos_taxonomy_type = "equipment_type"
 
 
+class EquipmentAssetImporter(ToFarmOSAsset):
+
+    model_title = "EquipmentAsset"
+    farmos_asset_type = "equipment"
+
+    supported_fields = [
+        "uuid",
+        "asset_name",
+        "manufacturer",
+        "model",
+        "serial_number",
+        "equipment_type_uuids",
+        "is_location",
+        "is_fixed",
+        "notes",
+        "archived",
+    ]
+
+    def normalize_target_object(self, equipment):
+        data = super().normalize_target_object(equipment)
+        data.update(
+            {
+                "manufacturer": equipment["attributes"]["manufacturer"],
+                "model": equipment["attributes"]["model"],
+                "serial_number": equipment["attributes"]["serial_number"],
+                "equipment_type_uuids": [
+                    UUID(etype["id"])
+                    for etype in equipment["relationships"]["equipment_type"]["data"]
+                ],
+            }
+        )
+        return data
+
+    def get_asset_payload(self, source_data):
+        payload = super().get_asset_payload(source_data)
+
+        attrs = {}
+        if "manufacturer" in self.fields:
+            attrs["manufacturer"] = source_data["manufacturer"]
+        if "model" in self.fields:
+            attrs["model"] = source_data["model"]
+        if "serial_number" in self.fields:
+            attrs["serial_number"] = source_data["serial_number"]
+
+        rels = {}
+        if "equipment_type_uuids" in self.fields:
+            rels["equipment_type"] = {"data": []}
+            for uuid in source_data["equipment_type_uuids"]:
+                rels["equipment_type"]["data"].append(
+                    {
+                        "id": str(uuid),
+                        "type": "taxonomy_term--equipment_type",
+                    }
+                )
+
+        payload["attributes"].update(attrs)
+        if rels:
+            payload.setdefault("relationships", {}).update(rels)
+
+        return payload
+
+
 class MaterialTypeImporter(ToFarmOSTaxonomy):
 
     model_title = "MaterialType"
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index f6e7a39..bd42e86 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -100,6 +100,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers["StructureAsset"] = StructureAssetImporter
         importers["WaterAsset"] = WaterAssetImporter
         importers["EquipmentType"] = EquipmentTypeImporter
+        importers["EquipmentAsset"] = EquipmentAssetImporter
         importers["AnimalType"] = AnimalTypeImporter
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
@@ -235,6 +236,44 @@ class EquipmentTypeImporter(
     source_model_class = model.EquipmentType
 
 
+class EquipmentAssetImporter(
+    FromWuttaFarmAsset, farmos_importing.model.EquipmentAssetImporter
+):
+    """
+    WuttaFarm → farmOS API exporter for Equipment Assets
+    """
+
+    source_model_class = model.EquipmentAsset
+
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+
+        print(fields)
+        fields.extend(
+            [
+                "manufacturer",
+                "model",
+                "serial_number",
+                "equipment_type_uuids",
+            ]
+        )
+        return fields
+
+    def normalize_source_object(self, equipment):
+        data = super().normalize_source_object(equipment)
+        data.update(
+            {
+                "manufacturer": equipment.manufacturer,
+                "model": equipment.model,
+                "serial_number": equipment.serial_number,
+                "equipment_type_uuids": [
+                    etype.farmos_uuid for etype in equipment.equipment_types
+                ],
+            }
+        )
+        return data
+
+
 class AnimalTypeImporter(
     FromWuttaFarmTaxonomy, farmos_importing.model.AnimalTypeImporter
 ):
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index dda4974..93e8d30 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -108,6 +108,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["StructureAsset"] = StructureAssetImporter
         importers["WaterAsset"] = WaterAssetImporter
         importers["EquipmentType"] = EquipmentTypeImporter
+        importers["EquipmentAsset"] = EquipmentAssetImporter
         importers["AnimalType"] = AnimalTypeImporter
         importers["AnimalAsset"] = AnimalAssetImporter
         importers["GroupAsset"] = GroupAssetImporter
@@ -489,6 +490,111 @@ class AssetTypeImporter(FromFarmOS, ToWutta):
         }
 
 
+class EquipmentAssetImporter(AssetImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Equipment Assets
+    """
+
+    model_class = model.EquipmentAsset
+
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "equipment_types",
+            ]
+        )
+        return fields
+
+    def setup(self):
+        super().setup()
+        model = self.app.model
+
+        self.equipment_types_by_farmos_uuid = {}
+        for equipment_type in self.target_session.query(model.EquipmentType):
+            if equipment_type.farmos_uuid:
+                self.equipment_types_by_farmos_uuid[equipment_type.farmos_uuid] = (
+                    equipment_type
+                )
+
+    def normalize_source_object(self, equipment):
+        """ """
+        data = super().normalize_source_object(equipment)
+
+        equipment_types = []
+        if relationships := equipment.get("relationships"):
+
+            if equipment_type := relationships.get("equipment_type"):
+                equipment_types = []
+                for equipment_type in equipment_type["data"]:
+                    if wf_equipment_type := self.equipment_types_by_farmos_uuid.get(
+                        UUID(equipment_type["id"])
+                    ):
+                        equipment_types.append(wf_equipment_type.uuid)
+                    else:
+                        log.warning(
+                            "equipment type not found: %s", equipment_type["id"]
+                        )
+
+        data.update(
+            {
+                "manufacturer": equipment["attributes"]["manufacturer"],
+                "model": equipment["attributes"]["model"],
+                "serial_number": equipment["attributes"]["serial_number"],
+                "equipment_types": set(equipment_types),
+            }
+        )
+        return data
+
+    def normalize_target_object(self, equipment):
+        data = super().normalize_target_object(equipment)
+
+        if "equipment_types" in self.fields:
+            data["equipment_types"] = set(
+                [etype.uuid for etype in equipment.equipment_types]
+            )
+
+        return data
+
+    def update_target_object(self, equipment, source_data, target_data=None):
+        model = self.app.model
+        equipment = super().update_target_object(equipment, source_data, target_data)
+
+        if "equipment_types" in self.fields:
+            if (
+                not target_data
+                or target_data["equipment_types"] != source_data["equipment_types"]
+            ):
+
+                for uuid in source_data["equipment_types"]:
+                    if not target_data or uuid not in target_data["equipment_types"]:
+                        self.target_session.flush()
+                        equipment._equipment_types.append(
+                            model.EquipmentAssetEquipmentType(equipment_type_uuid=uuid)
+                        )
+
+                if target_data:
+                    for uuid in target_data["equipment_types"]:
+                        if uuid not in source_data["equipment_types"]:
+                            equipment_type = (
+                                self.target_session.query(
+                                    model.EquipmentAssetEquipmentType
+                                )
+                                .filter(
+                                    model.EquipmentAssetEquipmentType.equipment_asset
+                                    == equipment
+                                )
+                                .filter(
+                                    model.EquipmentAssetEquipmentType.equipment_type_uuid
+                                    == uuid
+                                )
+                                .one()
+                            )
+                            self.target_session.delete(equipment_type)
+
+        return equipment
+
+
 class GroupAssetImporter(AssetImporterBase):
     """
     farmOS API → WuttaFarm importer for Group Assets
diff --git a/src/wuttafarm/web/forms/schema.py b/src/wuttafarm/web/forms/schema.py
index 9543c51..e24f0cf 100644
--- a/src/wuttafarm/web/forms/schema.py
+++ b/src/wuttafarm/web/forms/schema.py
@@ -28,7 +28,7 @@ import json
 import colander
 
 from wuttaweb.db import Session
-from wuttaweb.forms.schema import ObjectRef, WuttaSet
+from wuttaweb.forms.schema import ObjectRef, WuttaSet, WuttaList
 from wuttaweb.forms.widgets import NotesWidget
 
 
@@ -216,6 +216,35 @@ class FarmOSQuantityRefs(WuttaSet):
         return FarmOSQuantityRefsWidget(**kwargs)
 
 
+class FarmOSTaxonomyTerms(colander.SchemaType):
+    """
+    Schema type which can represent multiple taxonomy terms.
+    """
+
+    route_prefix = None
+
+    def __init__(self, request, route_prefix=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        if route_prefix:
+            self.route_prefix = route_prefix
+
+    def serialize(self, node, appstruct):
+        if not appstruct:
+            return colander.null
+        return appstruct
+
+    def widget_maker(self, **kwargs):
+        from wuttafarm.web.forms.widgets import FarmOSTaxonomyTermsWidget
+
+        return FarmOSTaxonomyTermsWidget(self.request, self.route_prefix, **kwargs)
+
+
+class FarmOSEquipmentTypeRefs(FarmOSTaxonomyTerms):
+
+    route_prefix = "farmos_equipment_types"
+
+
 class FarmOSPlantTypes(colander.SchemaType):
 
     def __init__(self, request, *args, **kwargs):
@@ -260,6 +289,35 @@ class LandTypeRef(ObjectRef):
         return self.request.route_url("land_types.view", uuid=land_type.uuid)
 
 
+class TaxonomyTermRefs(WuttaList):
+    """
+    Generic schema type for a field which can reference multiple
+    taxonomy terms.
+    """
+
+    def serialize(self, node, appstruct):
+        if not appstruct:
+            return colander.null
+
+        terms = []
+        for term in appstruct:
+            terms.append(
+                {
+                    "uuid": str(term.uuid),
+                    "name": term.name,
+                }
+            )
+        return terms
+
+
+class EquipmentTypeRefs(TaxonomyTermRefs):
+
+    def widget_maker(self, **kwargs):
+        from wuttafarm.web.forms.widgets import EquipmentTypeRefsWidget
+
+        return EquipmentTypeRefsWidget(self.request, **kwargs)
+
+
 class PlantTypeRefs(WuttaSet):
     """
     Schema type for Plant Types field (on a Plant Asset).
diff --git a/src/wuttafarm/web/forms/widgets.py b/src/wuttafarm/web/forms/widgets.py
index 355adcc..db79eae 100644
--- a/src/wuttafarm/web/forms/widgets.py
+++ b/src/wuttafarm/web/forms/widgets.py
@@ -33,6 +33,7 @@ from wuttaweb.forms.widgets import WuttaCheckboxChoiceWidget, ObjectRefWidget
 from wuttaweb.db import Session
 
 from wuttafarm.web.util import render_quantity_objects
+from wuttafarm.db.model import EquipmentType
 
 
 class ImageWidget(Widget):
@@ -228,6 +229,38 @@ class FarmOSUnitRefWidget(Widget):
         return super().serialize(field, cstruct, **kw)
 
 
+class FarmOSTaxonomyTermsWidget(Widget):
+    """
+    Widget to display a field which can reference multiple taxonomy
+    terms.
+    """
+
+    def __init__(self, request, route_prefix, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.route_prefix = route_prefix
+
+    def serialize(self, field, cstruct, **kw):
+        """ """
+        readonly = kw.get("readonly", self.readonly)
+        if readonly:
+            if cstruct in (colander.null, None):
+                return HTML.tag("span")
+
+            links = []
+            for term in cstruct:
+                link = tags.link_to(
+                    term["name"],
+                    self.request.route_url(
+                        f"{self.route_prefix}.view", uuid=term["uuid"]
+                    ),
+                )
+                links.append(HTML.tag("li", c=link))
+            return HTML.tag("ul", c=links)
+
+        return super().serialize(field, cstruct, **kw)
+
+
 class FarmOSPlantTypesWidget(Widget):
     """
     Widget to display a farmOS "plant types" field.
@@ -258,6 +291,88 @@ class FarmOSPlantTypesWidget(Widget):
         return super().serialize(field, cstruct, **kw)
 
 
+class TaxonomyTermRefsWidget(Widget):
+    """
+    Generic (incomplete) widget for fields which can reference
+    multiple taxonomy terms.
+
+    This widget can handle typical read-only scenarios but the
+    editable mode is not implemented.
+    """
+
+    route_prefix = None
+
+    def __init__(self, request, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    @classmethod
+    def get_route_prefix(cls):
+        return cls.route_prefix
+
+    @classmethod
+    def get_permission_prefix(cls):
+        return cls.route_prefix
+
+    def serialize(self, field, cstruct, **kw):
+        """ """
+        if not cstruct:
+            cstruct = []
+
+        if readonly := kw.get("readonly", self.readonly):
+            items = []
+            route_prefix = self.get_route_prefix()
+            for term in cstruct:
+                url = self.request.route_url(f"{route_prefix}.view", uuid=term["uuid"])
+                link = tags.link_to(term["name"], url)
+                items.append(HTML.tag("li", c=link))
+            return HTML.tag("ul", c=items)
+
+        tmpl_values = self.get_template_values(field, cstruct, kw)
+        return field.renderer(self.template, **tmpl_values)
+
+    def get_template_values(self, field, cstruct, kw):
+        values = super().get_template_values(field, cstruct, kw)
+        model = self.app.model
+        session = Session()
+
+        terms = []
+        query = session.query(self.model_class).order_by(self.model_class.name)
+        for term in query:
+            terms.append(
+                {
+                    "uuid": str(term.uuid),
+                    "name": term.name,
+                }
+            )
+        values["terms"] = terms
+
+        permission_prefix = self.get_permission_prefix()
+        if self.request.has_perm(f"{permission_prefix}.create"):
+            values["can_create"] = True
+
+        return values
+
+    def deserialize(self, field, pstruct):
+        """ """
+        if not pstruct:
+            return colander.null
+
+        return json.loads(pstruct)
+
+
+class EquipmentTypeRefsWidget(TaxonomyTermRefsWidget):
+    """
+    Widget for Equipment Types field.
+    """
+
+    model_class = EquipmentType
+    route_prefix = "equipment_types"
+    template = "equipmenttyperefs"
+
+
 class PlantTypeRefsWidget(Widget):
     """
     Widget for Plant Types field (on a Plant Asset).
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index ed7a11a..a44e5a9 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -92,6 +92,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "animal_assets",
                     "perm": "animal_assets.list",
                 },
+                {
+                    "title": "Equipment",
+                    "route": "equipment_assets",
+                    "perm": "equipment_assets.list",
+                },
                 {
                     "title": "Group",
                     "route": "group_assets",
@@ -249,6 +254,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_animal_assets",
                     "perm": "farmos_animal_assets.list",
                 },
+                {
+                    "title": "Equipment Assets",
+                    "route": "farmos_equipment_assets",
+                    "perm": "farmos_equipment_assets.list",
+                },
                 {
                     "title": "Group Assets",
                     "route": "farmos_group_assets",
@@ -383,6 +393,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_animal_assets",
                     "perm": "farmos_animal_assets.list",
                 },
+                {
+                    "title": "Equipment",
+                    "route": "farmos_equipment_assets",
+                    "perm": "farmos_equipment_assets.list",
+                },
                 {
                     "title": "Group",
                     "route": "farmos_group_assets",
diff --git a/src/wuttafarm/web/templates/deform/equipmenttyperefs.pt b/src/wuttafarm/web/templates/deform/equipmenttyperefs.pt
new file mode 100644
index 0000000..4d48fd7
--- /dev/null
+++ b/src/wuttafarm/web/templates/deform/equipmenttyperefs.pt
@@ -0,0 +1,13 @@
+<div tal:define="
+     name name|field.name;
+     oid oid|field.oid;
+     vmodel vmodel|'modelData.'+oid;
+     can_create can_create|False;"
+     tal:omit-tag="">
+
+  <equipment-types-picker tal:attributes="name name;
+                                          v-model vmodel;
+                                          :equipment-types terms;
+                                          :can-create str(can_create).lower();" />
+
+</div>
diff --git a/src/wuttafarm/web/templates/wuttafarm-components.mako b/src/wuttafarm/web/templates/wuttafarm-components.mako
index d8f94b3..890568f 100644
--- a/src/wuttafarm/web/templates/wuttafarm-components.mako
+++ b/src/wuttafarm/web/templates/wuttafarm-components.mako
@@ -1,5 +1,7 @@
 
 <%def name="make_wuttafarm_components()">
+  ${self.make_taxonomy_terms_picker_component()}
+  ${self.make_equipment_types_picker_component()}
   ${self.make_assets_picker_component()}
   ${self.make_animal_type_picker_component()}
   ${self.make_material_types_picker_component()}
@@ -9,6 +11,216 @@
   ${self.make_seasons_picker_component()}
 </%def>
 
+<%def name="make_taxonomy_terms_picker_component()">
+  <script type="text/x-template" id="taxonomy-terms-picker-template">
+    <div>
+      <input type="hidden" :name="name" :value="JSON.stringify(value)" />
+
+      <div style="display: flex; gap: 0.5rem; align-items: center;">
+
+        <span>Add:</span>
+
+        <b-autocomplete v-model="addName"
+                        ref="addName"
+                        :data="addNameData"
+                        field="name"
+                        open-on-focus
+                        keep-first
+                        @select="addNameSelected"
+                        clear-on-select
+                        style="flex-grow: 1;">
+          <template #empty>No results found</template>
+        </b-autocomplete>
+
+        <b-button type="is-primary"
+                  icon-pack="fas"
+                  icon-left="plus"
+                  @click="createInit()">
+          New
+        </b-button>
+
+      </div>
+
+      <${b}-table :data="value">
+
+        <${b}-table-column field="name" v-slot="props">
+          <span>{{ props.row.name }}</span>
+        </${b}-table-column>
+
+        <${b}-table-column v-slot="props">
+            <a href="#"
+               class="has-text-danger"
+               @click.prevent="removeTerm(props.row)">
+              <i class="fas fa-trash" /> &nbsp; Remove
+            </a>
+        </${b}-table-column>
+
+      </${b}-table>
+
+      <${b}-modal v-if="canCreate"
+                  has-modal-card
+                  % if request.use_oruga:
+                  v-model:active="createShowDialog"
+                  % else:
+                  :active.sync="createShowDialog"
+                  % endif
+                  >
+        <div class="modal-card">
+
+          <header class="modal-card-head">
+            <p class="modal-card-title">New {{ termTitle }} </p>
+          </header>
+
+          <section class="modal-card-body">
+            <b-field label="Name" horizontal>
+              <b-input v-model="createName"
+                       ref="createName"
+                       expanded
+                       @keydown.native="createNameKeydown" />
+            </b-field>
+          </section>
+
+          <footer class="modal-card-foot">
+            <b-button type="is-primary"
+                      @click="createSave()"
+                      :disabled="createSaving || !createName"
+                      icon-pack="fas"
+                      icon-left="save">
+              {{ createSaving ? "Working, please wait..." : "Save" }}
+            </b-button>
+            <b-button @click="createShowDialog = false">
+              Cancel
+            </b-button>
+          </footer>
+        </div>
+      </${b}-modal>
+    </div>
+  </script>
+  <script>
+    const TaxonomyTermsPicker = {
+        template: '#taxonomy-terms-picker-template',
+        mixins: [WuttaRequestMixin],
+        props: {
+            name: String,
+            value: Array,
+            termTitle: String,
+            terms: Array,
+            canCreate: Boolean,
+            createUrl: String,
+        },
+        data() {
+            return {
+                addName: '',
+                createShowDialog: false,
+                createName: null,
+                createSaving: false,
+            }
+        },
+        computed: {
+
+            addNameData() {
+                if (!this.addName) {
+                    return this.terms
+                }
+
+                return this.terms.filter((term) => {
+                    return term.name.toLowerCase().indexOf(this.addName.toLowerCase()) >= 0
+                })
+            },
+        },
+        methods: {
+
+            addNameSelected(option) {
+                if (!option) {
+                    return
+                }
+
+                const uuids = this.value.map((term) => {
+                    return term.uuid
+                })
+
+                if (!uuids.includes(option.uuid)) {
+                    this.value.push(option)
+                    this.$emit('input', this.value)
+                }
+
+                this.addName = null
+            },
+
+            createInit() {
+                this.createName = this.addName
+                this.createShowDialog = true
+                this.$nextTick(() => {
+                    this.$refs.createName.focus()
+                })
+            },
+
+            createNameKeydown(event) {
+                // nb. must prevent main form submit on ENTER
+                // (since ultimately this lives within an outer form)
+                // but also we can submit the modal pseudo-form
+                if (event.which == 13) {
+                    event.preventDefault()
+                    this.createSave()
+                }
+            },
+
+            createSave() {
+                this.createSaving = true
+                const params = {name: this.createName}
+                this.wuttaPOST(this.createUrl, params, response => {
+                    this.value.push(response.data)
+                    this.$emit('input', this.value)
+                    this.addName = null
+                    this.createSaving = false
+                    this.createShowDialog = false
+                }, response => {
+                    this.createSaving = false
+                })
+            },
+
+            removeTerm(term) {
+                const value = Array.from(this.value)
+                const i = value.indexOf(term)
+                value.splice(i, 1)
+                this.$emit('input', value)
+            },
+        },
+    }
+    Vue.component('taxonomy-terms-picker', TaxonomyTermsPicker)
+    <% request.register_component('taxonomy-terms-picker', 'TaxonomyTermsPicker') %>
+  </script>
+</%def>
+
+<%def name="make_equipment_types_picker_component()">
+  <script type="text/x-template" id="equipment-types-picker-template">
+    <taxonomy-terms-picker v-model="proxyValue"
+                           :name="name"
+                           term-title="Equipment Type"
+                           :terms="equipmentTypes"
+                           :can-create="canCreate"
+                           create-url="${url('equipment_types.ajax_create')}" />
+  </script>
+  <script>
+    const EquipmentTypesPicker = {
+        template: '#equipment-types-picker-template',
+        props: {
+            name: String,
+            value: Array,
+            equipmentTypes: Array,
+            canCreate: Boolean,
+        },
+        data() {
+            return {
+                proxyValue: this.value || [],
+            }
+        },
+    }
+    Vue.component('equipment-types-picker', EquipmentTypesPicker)
+    <% request.register_component('equipment-types-picker', 'EquipmentTypesPicker') %>
+  </script>
+</%def>
+
 <%def name="make_assets_picker_component()">
   <script type="text/x-template" id="assets-picker-template">
     <div>
diff --git a/src/wuttafarm/web/views/assets.py b/src/wuttafarm/web/views/assets.py
index 5cc70e5..64f4dbc 100644
--- a/src/wuttafarm/web/views/assets.py
+++ b/src/wuttafarm/web/views/assets.py
@@ -83,9 +83,9 @@ class AssetMasterView(WuttaFarmMasterView):
         "notes",
         "asset_type",
         "owners",
-        "locations",
         "is_location",
         "is_fixed",
+        "locations",
         "groups",
         "archived",
         "drupal_id",
diff --git a/src/wuttafarm/web/views/equipment.py b/src/wuttafarm/web/views/equipment.py
index 5e080ef..8076556 100644
--- a/src/wuttafarm/web/views/equipment.py
+++ b/src/wuttafarm/web/views/equipment.py
@@ -23,8 +23,10 @@
 Master view for Plants
 """
 
-from wuttafarm.db.model import EquipmentType
+from wuttafarm.db.model import EquipmentType, EquipmentAsset
 from wuttafarm.web.views import TaxonomyMasterView
+from wuttafarm.web.views.assets import AssetMasterView
+from wuttafarm.web.forms.schema import EquipmentTypeRefs
 
 
 class EquipmentTypeView(TaxonomyMasterView):
@@ -42,12 +44,79 @@ class EquipmentTypeView(TaxonomyMasterView):
     farmos_refurl_path = "/admin/structure/taxonomy/manage/equipment_type/overview"
 
 
+class EquipmentAssetView(AssetMasterView):
+    """
+    Master view for Equipment Assets
+    """
+
+    model_class = EquipmentAsset
+    route_prefix = "equipment_assets"
+    url_prefix = "/assets/equipment"
+
+    farmos_bundle = "equipment"
+    farmos_refurl_path = "/assets/equipment"
+
+    labels = {
+        "equipment_types": "Equipment Type",
+    }
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+        equipment = f.model_instance
+
+        # equipment_types
+        f.fields.insert_after("asset_name", "equipment_types")
+        f.set_node("equipment_types", EquipmentTypeRefs(self.request))
+        if not self.creating:
+            # nb. must explcitly declare value for non-standard field
+            f.set_default("equipment_types", equipment.equipment_types)
+
+        # manufacturer
+        f.fields.insert_after("equipment_types", "manufacturer")
+
+        # model
+        f.fields.insert_after("manufacturer", "model")
+
+        # serial_number
+        f.fields.insert_after("model", "serial_number")
+
+    def objectify(self, form):
+        equipment = super().objectify(form)
+        data = form.validated
+
+        self.set_equipment_types(equipment, data["equipment_types"])
+
+        return equipment
+
+    def set_equipment_types(self, equipment, desired):
+        model = self.app.model
+        session = self.Session()
+        current = [str(etype.uuid) for etype in equipment.equipment_types]
+
+        for etype in desired:
+            if etype["uuid"] not in current:
+                equipment_type = session.get(model.EquipmentType, etype["uuid"])
+                assert equipment_type
+                equipment.equipment_types.append(equipment_type)
+
+        desired = [etype["uuid"] for etype in desired]
+        for uuid in current:
+            if uuid not in desired:
+                equipment_type = session.get(model.EquipmentType, uuid)
+                assert equipment_type
+                equipment.equipment_types.remove(equipment_type)
+
+
 def defaults(config, **kwargs):
     base = globals()
 
     EquipmentTypeView = kwargs.get("EquipmentTypeView", base["EquipmentTypeView"])
     EquipmentTypeView.defaults(config)
 
+    EquipmentAssetView = kwargs.get("EquipmentAssetView", base["EquipmentAssetView"])
+    EquipmentAssetView.defaults(config)
+
 
 def includeme(config):
     defaults(config)
diff --git a/src/wuttafarm/web/views/farmos/animals.py b/src/wuttafarm/web/views/farmos/animals.py
index c99cc5a..6a6bc92 100644
--- a/src/wuttafarm/web/views/farmos/animals.py
+++ b/src/wuttafarm/web/views/farmos/animals.py
@@ -39,7 +39,7 @@ from wuttafarm.web.grids import (
     NullableBooleanFilter,
     DateTimeFilter,
 )
-from wuttafarm.web.forms.schema import FarmOSRef, FarmOSAssetRefs
+from wuttafarm.web.forms.schema import FarmOSRef
 
 
 class AnimalView(AssetMasterView):
@@ -99,8 +99,7 @@ class AnimalView(AssetMasterView):
 
     def get_farmos_api_includes(self):
         includes = super().get_farmos_api_includes()
-        includes.add("animal_type")
-        includes.add("group")
+        includes.update(["animal_type"])
         return includes
 
     def configure_grid(self, grid):
@@ -131,10 +130,6 @@ class AnimalView(AssetMasterView):
         g.set_sorter("sex", SimpleSorter("sex"))
         g.set_filter("sex", StringFilter)
 
-        # groups
-        g.set_label("groups", "Group Membership")
-        g.set_renderer("groups", self.render_groups_for_grid)
-
         # is_sterile
         g.set_renderer("is_sterile", "boolean")
         g.set_sorter("is_sterile", SimpleSorter("is_sterile"))
@@ -145,18 +140,6 @@ class AnimalView(AssetMasterView):
         url = self.request.route_url("farmos_animal_types.view", uuid=uuid)
         return tags.link_to(value, url)
 
-    def render_groups_for_grid(self, animal, field, value):
-        groups = []
-        for group in animal["groups"]:
-            if self.farmos_style_grid_links:
-                url = self.request.route_url(
-                    "farmos_group_assets.view", uuid=group["uuid"]
-                )
-                groups.append(tags.link_to(group["name"], url))
-            else:
-                groups.append(group["name"])
-        return ", ".join(groups)
-
     def get_instance(self):
 
         data = super().get_instance()
@@ -192,8 +175,6 @@ class AnimalView(AssetMasterView):
             sterile = animal["attributes"]["is_castrated"]
 
         animal_type_object = None
-        group_objects = []
-        group_names = []
         if relationships := animal.get("relationships"):
 
             if animal_type := relationships.get("animal_type"):
@@ -203,24 +184,11 @@ class AnimalView(AssetMasterView):
                         "name": animal_type["attributes"]["name"],
                     }
 
-            if groups := relationships.get("group"):
-                for group in groups["data"]:
-                    if group := included.get(group["id"]):
-                        group = {
-                            "uuid": group["id"],
-                            "name": group["attributes"]["name"],
-                            "asset_type": "group",
-                        }
-                        group_objects.append(group)
-                        group_names.append(group["name"])
-
         normal.update(
             {
                 "animal_type": animal_type_object,
                 "animal_type_uuid": animal_type_object["uuid"],
                 "animal_type_name": animal_type_object["name"],
-                "groups": group_objects,
-                "group_names": group_names,
                 "birthdate": birthdate,
                 "sex": animal["attributes"]["sex"] or colander.null,
                 "is_sterile": sterile,
@@ -271,12 +239,6 @@ class AnimalView(AssetMasterView):
         # is_sterile
         f.set_node("is_sterile", colander.Boolean())
 
-        # groups
-        if self.creating or self.editing:
-            f.remove("groups")  # TODO
-        else:
-            f.set_node("groups", FarmOSAssetRefs(self.request))
-
     def get_api_payload(self, animal):
         payload = super().get_api_payload(animal)
 
diff --git a/src/wuttafarm/web/views/farmos/assets.py b/src/wuttafarm/web/views/farmos/assets.py
index 863b947..24dd145 100644
--- a/src/wuttafarm/web/views/farmos/assets.py
+++ b/src/wuttafarm/web/views/farmos/assets.py
@@ -28,7 +28,7 @@ import requests
 from webhelpers2.html import tags
 
 from wuttafarm.web.views.farmos import FarmOSMasterView
-from wuttafarm.web.forms.schema import FarmOSRefs, FarmOSLocationRefs
+from wuttafarm.web.forms.schema import FarmOSRefs, FarmOSAssetRefs, FarmOSLocationRefs
 from wuttafarm.web.forms.widgets import ImageWidget
 from wuttafarm.web.grids import (
     ResourceData,
@@ -80,12 +80,13 @@ class AssetMasterView(FarmOSMasterView):
         "name",
         "notes",
         "asset_type_name",
+        "owners",
         "is_location",
         "is_fixed",
-        "owners",
         "locations",
         "groups",
         "archived",
+        "drupal_id",
         "thumbnail_url",
         "image_url",
         "thumbnail",
@@ -127,6 +128,10 @@ class AssetMasterView(FarmOSMasterView):
         # locations
         g.set_renderer("locations", self.render_locations_for_grid)
 
+        # groups
+        g.set_label("groups", "Group Membership")
+        g.set_renderer("groups", self.render_assets_for_grid)
+
         # archived
         g.set_renderer("archived", "boolean")
         g.set_sorter("archived", SimpleSorter("archived"))
@@ -137,6 +142,20 @@ class AssetMasterView(FarmOSMasterView):
             return tags.image(url, f"thumbnail for {self.get_model_title()}")
         return None
 
+    def render_assets_for_grid(self, log, field, value):
+        if not value:
+            return ""
+
+        assets = []
+        for asset in value:
+            if self.farmos_style_grid_links:
+                route = f"farmos_{asset['asset_type']}_assets.view"
+                url = self.request.route_url(route, uuid=asset["uuid"])
+                assets.append(tags.link_to(asset["name"], url))
+            else:
+                assets.append(asset["name"])
+        return ", ".join(assets)
+
     def render_locations_for_grid(self, asset, field, value):
         locations = []
         for location in value:
@@ -156,7 +175,7 @@ class AssetMasterView(FarmOSMasterView):
         return None
 
     def get_farmos_api_includes(self):
-        return {"asset_type", "location", "owner", "image"}
+        return {"asset_type", "location", "group", "owner", "image"}
 
     def get_instance(self):
         try:
@@ -192,6 +211,7 @@ class AssetMasterView(FarmOSMasterView):
         owner_names = []
         location_objects = []
         location_names = []
+        group_objects = []
         thumbnail_url = None
         image_url = None
         if relationships := asset.get("relationships"):
@@ -225,6 +245,16 @@ class AssetMasterView(FarmOSMasterView):
                         location_objects.append(location)
                         location_names.append(location["name"])
 
+            if groups := relationships.get("group"):
+                for group in groups["data"]:
+                    if group := included.get(group["id"]):
+                        group = {
+                            "uuid": group["id"],
+                            "name": group["attributes"]["name"],
+                            "asset_type": "group",
+                        }
+                        group_objects.append(group)
+
             if images := relationships.get("image"):
                 for image in images["data"]:
                     if image := included.get(image["id"]):
@@ -246,6 +276,7 @@ class AssetMasterView(FarmOSMasterView):
             "owner_names": owner_names,
             "locations": location_objects,
             "location_names": location_names,
+            "groups": group_objects,
             "archived": archived,
             "thumbnail_url": thumbnail_url or colander.null,
             "image_url": image_url or colander.null,
@@ -267,6 +298,12 @@ class AssetMasterView(FarmOSMasterView):
             f.set_label("locations", "Current Location")
             f.set_node("locations", FarmOSLocationRefs(self.request))
 
+        # groups
+        if self.creating or self.editing:
+            f.remove("groups")  # TODO
+        else:
+            f.set_node("groups", FarmOSAssetRefs(self.request))
+
         # owners
         if self.creating or self.editing:
             f.remove("owners")  # TODO
diff --git a/src/wuttafarm/web/views/farmos/equipment.py b/src/wuttafarm/web/views/farmos/equipment.py
index 67987c3..6855747 100644
--- a/src/wuttafarm/web/views/farmos/equipment.py
+++ b/src/wuttafarm/web/views/farmos/equipment.py
@@ -23,7 +23,11 @@
 Master view for farmOS Equipment
 """
 
+from webhelpers2.html import tags
+
 from wuttafarm.web.views.farmos.master import TaxonomyMasterView
+from wuttafarm.web.views.farmos.assets import AssetMasterView
+from wuttafarm.web.forms.schema import FarmOSEquipmentTypeRefs
 
 
 class EquipmentTypeView(TaxonomyMasterView):
@@ -65,12 +69,143 @@ class EquipmentTypeView(TaxonomyMasterView):
         return buttons
 
 
+class EquipmentAssetView(AssetMasterView):
+    """
+    Master view for farmOS Equipment Assets
+    """
+
+    model_name = "farmos_equipment_assets"
+    model_title = "farmOS Equipment Asset"
+    model_title_plural = "farmOS Equipment Assets"
+
+    route_prefix = "farmos_equipment_assets"
+    url_prefix = "/farmOS/assets/equipment"
+
+    farmos_asset_type = "equipment"
+    farmos_refurl_path = "/assets/equipment"
+
+    labels = {
+        "equipment_types": "Equipment Type",
+    }
+
+    grid_columns = [
+        "thumbnail",
+        "drupal_id",
+        "name",
+        "equipment_types",
+        "manufacturer",
+        "model",
+        "serial_number",
+        "groups",
+        "owners",
+        "archived",
+    ]
+
+    def get_farmos_api_includes(self):
+        includes = super().get_farmos_api_includes()
+        includes.update(["equipment_type"])
+        return includes
+
+    def configure_grid(self, grid):
+        g = grid
+        super().configure_grid(g)
+
+        # equipment_types
+        g.set_renderer("equipment_types", self.render_equipment_types_for_grid)
+
+    def render_equipment_types_for_grid(self, equipment, field, value):
+        if self.farmos_style_grid_links:
+            links = []
+            for etype in value:
+                url = self.request.route_url(
+                    f"farmos_equipment_types.view", uuid=etype["uuid"]
+                )
+                links.append(tags.link_to(etype["name"], url))
+            return ", ".join(links)
+
+        return ", ".join([etype["name"] for etype in value])
+
+    def normalize_asset(self, equipment, included):
+        data = super().normalize_asset(equipment, included)
+
+        equipment_type_objects = []
+        rels = equipment["relationships"]
+        for etype in rels["equipment_type"]["data"]:
+            uuid = etype["id"]
+            equipment_type = {
+                "uuid": uuid,
+                "type": etype["type"],
+            }
+            if etype := included.get(uuid):
+                equipment_type.update(
+                    {
+                        "name": etype["attributes"]["name"],
+                    }
+                )
+            equipment_type_objects.append(equipment_type)
+
+        data.update(
+            {
+                "manufacturer": equipment["attributes"]["manufacturer"],
+                "model": equipment["attributes"]["model"],
+                "serial_number": equipment["attributes"]["serial_number"],
+                "equipment_types": equipment_type_objects,
+            }
+        )
+
+        return data
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+
+        # equipment_types
+        f.fields.insert_after("name", "equipment_types")
+        f.set_node("equipment_types", FarmOSEquipmentTypeRefs(self.request))
+
+        # manufacturer
+        f.fields.insert_after("equipment_types", "manufacturer")
+
+        # model
+        f.fields.insert_after("manufacturer", "model")
+
+        # serial_number
+        f.fields.insert_after("model", "serial_number")
+
+    def get_xref_buttons(self, equipment):
+        model = self.app.model
+        session = self.Session()
+
+        buttons = super().get_xref_buttons(equipment)
+
+        if wf_equipment := (
+            session.query(model.Asset)
+            .filter(model.Asset.farmos_uuid == equipment["uuid"])
+            .first()
+        ):
+            buttons.append(
+                self.make_button(
+                    f"View {self.app.get_title()} record",
+                    primary=True,
+                    url=self.request.route_url(
+                        "equipment_assets.view", uuid=wf_equipment.uuid
+                    ),
+                    icon_left="eye",
+                )
+            )
+
+        return buttons
+
+
 def defaults(config, **kwargs):
     base = globals()
 
     EquipmentTypeView = kwargs.get("EquipmentTypeView", base["EquipmentTypeView"])
     EquipmentTypeView.defaults(config)
 
+    EquipmentAssetView = kwargs.get("EquipmentAssetView", base["EquipmentAssetView"])
+    EquipmentAssetView.defaults(config)
+
 
 def includeme(config):
     defaults(config)
diff --git a/src/wuttafarm/web/views/master.py b/src/wuttafarm/web/views/master.py
index 53bbac2..d9fe986 100644
--- a/src/wuttafarm/web/views/master.py
+++ b/src/wuttafarm/web/views/master.py
@@ -26,6 +26,7 @@ Base class for WuttaFarm master views
 from webhelpers2.html import tags
 
 from wuttaweb.views import MasterView
+from wuttaweb.util import get_form_data
 
 from wuttafarm.web.util import use_farmos_style_grid_links, get_farmos_client_for_user
 

From f48cf559636b6e3578fdb6baa236a3986e8f9532 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Tue, 10 Mar 2026 10:25:38 -0500
Subject: [PATCH 18/20] feat: add schema, edit/sync support for Seeding Logs

---
 .../versions/dca5b48a5562_add_seedinglog.py   | 108 ++++++++++++++++++
 src/wuttafarm/db/model/__init__.py            |   1 +
 src/wuttafarm/db/model/log_seeding.py         |  71 ++++++++++++
 src/wuttafarm/farmos/importing/model.py       |  45 ++++++++
 src/wuttafarm/farmos/importing/wuttafarm.py   |  20 ++++
 src/wuttafarm/importing/farmos.py             |  38 ++++++
 src/wuttafarm/normal.py                       |   9 +-
 src/wuttafarm/web/menus.py                    |  15 +++
 src/wuttafarm/web/views/__init__.py           |   1 +
 src/wuttafarm/web/views/farmos/__init__.py    |   1 +
 .../web/views/farmos/logs_seeding.py          | 105 +++++++++++++++++
 src/wuttafarm/web/views/logs_seeding.py       |  80 +++++++++++++
 12 files changed, 492 insertions(+), 2 deletions(-)
 create mode 100644 src/wuttafarm/db/alembic/versions/dca5b48a5562_add_seedinglog.py
 create mode 100644 src/wuttafarm/db/model/log_seeding.py
 create mode 100644 src/wuttafarm/web/views/farmos/logs_seeding.py
 create mode 100644 src/wuttafarm/web/views/logs_seeding.py

diff --git a/src/wuttafarm/db/alembic/versions/dca5b48a5562_add_seedinglog.py b/src/wuttafarm/db/alembic/versions/dca5b48a5562_add_seedinglog.py
new file mode 100644
index 0000000..6a374b4
--- /dev/null
+++ b/src/wuttafarm/db/alembic/versions/dca5b48a5562_add_seedinglog.py
@@ -0,0 +1,108 @@
+"""add SeedingLog
+
+Revision ID: dca5b48a5562
+Revises: e9b8664e1f39
+Create Date: 2026-03-10 09:52:13.999777
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import wuttjamaican.db.util
+
+
+# revision identifiers, used by Alembic.
+revision: str = "dca5b48a5562"
+down_revision: Union[str, None] = "e9b8664e1f39"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+
+    # log_seeding
+    op.create_table(
+        "log_seeding",
+        sa.Column("source", sa.String(length=255), nullable=True),
+        sa.Column("purchase_date", sa.DateTime(), nullable=True),
+        sa.Column("lot_number", sa.String(length=255), nullable=True),
+        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["uuid"], ["log.uuid"], name=op.f("fk_log_seeding_uuid_log")
+        ),
+        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_log_seeding")),
+    )
+    op.create_table(
+        "log_seeding_version",
+        sa.Column("source", sa.String(length=255), autoincrement=False, nullable=True),
+        sa.Column("purchase_date", sa.DateTime(), autoincrement=False, nullable=True),
+        sa.Column(
+            "lot_number", sa.String(length=255), autoincrement=False, nullable=True
+        ),
+        sa.Column(
+            "uuid", wuttjamaican.db.util.UUID(), autoincrement=False, nullable=False
+        ),
+        sa.Column(
+            "transaction_id", sa.BigInteger(), autoincrement=False, nullable=False
+        ),
+        sa.Column("end_transaction_id", sa.BigInteger(), nullable=True),
+        sa.Column("operation_type", sa.SmallInteger(), nullable=False),
+        sa.PrimaryKeyConstraint(
+            "uuid", "transaction_id", name=op.f("pk_log_seeding_version")
+        ),
+    )
+    op.create_index(
+        op.f("ix_log_seeding_version_end_transaction_id"),
+        "log_seeding_version",
+        ["end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_log_seeding_version_operation_type"),
+        "log_seeding_version",
+        ["operation_type"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_log_seeding_version_pk_transaction_id",
+        "log_seeding_version",
+        ["uuid", sa.literal_column("transaction_id DESC")],
+        unique=False,
+    )
+    op.create_index(
+        "ix_log_seeding_version_pk_validity",
+        "log_seeding_version",
+        ["uuid", "transaction_id", "end_transaction_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_log_seeding_version_transaction_id"),
+        "log_seeding_version",
+        ["transaction_id"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+
+    # log_seeding
+    op.drop_index(
+        op.f("ix_log_seeding_version_transaction_id"), table_name="log_seeding_version"
+    )
+    op.drop_index(
+        "ix_log_seeding_version_pk_validity", table_name="log_seeding_version"
+    )
+    op.drop_index(
+        "ix_log_seeding_version_pk_transaction_id", table_name="log_seeding_version"
+    )
+    op.drop_index(
+        op.f("ix_log_seeding_version_operation_type"), table_name="log_seeding_version"
+    )
+    op.drop_index(
+        op.f("ix_log_seeding_version_end_transaction_id"),
+        table_name="log_seeding_version",
+    )
+    op.drop_table("log_seeding_version")
+    op.drop_table("log_seeding")
diff --git a/src/wuttafarm/db/model/__init__.py b/src/wuttafarm/db/model/__init__.py
index df4115a..d90272b 100644
--- a/src/wuttafarm/db/model/__init__.py
+++ b/src/wuttafarm/db/model/__init__.py
@@ -58,3 +58,4 @@ from .log_activity import ActivityLog
 from .log_harvest import HarvestLog
 from .log_medical import MedicalLog
 from .log_observation import ObservationLog
+from .log_seeding import SeedingLog
diff --git a/src/wuttafarm/db/model/log_seeding.py b/src/wuttafarm/db/model/log_seeding.py
new file mode 100644
index 0000000..7f68923
--- /dev/null
+++ b/src/wuttafarm/db/model/log_seeding.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Model definition for Seeding Logs
+"""
+
+import sqlalchemy as sa
+
+from wuttjamaican.db import model
+
+from wuttafarm.db.model.log import LogMixin, add_log_proxies
+
+
+class SeedingLog(LogMixin, model.Base):
+    """
+    Represents a Seeding Log from farmOS
+    """
+
+    __tablename__ = "log_seeding"
+    __versioned__ = {}
+    __wutta_hint__ = {
+        "model_title": "Seeding Log",
+        "model_title_plural": "Seeding Logs",
+        "farmos_log_type": "seeding",
+    }
+
+    source = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Where the seed was obtained, if applicable.
+        """,
+    )
+
+    purchase_date = sa.Column(
+        sa.DateTime(),
+        nullable=True,
+        doc="""
+        When the seed was purchased, if applicable.
+        """,
+    )
+
+    lot_number = sa.Column(
+        sa.String(length=255),
+        nullable=True,
+        doc="""
+        Lot number for the seed, if applicable.
+        """,
+    )
+
+
+add_log_proxies(SeedingLog)
diff --git a/src/wuttafarm/farmos/importing/model.py b/src/wuttafarm/farmos/importing/model.py
index bb1b41c..011a170 100644
--- a/src/wuttafarm/farmos/importing/model.py
+++ b/src/wuttafarm/farmos/importing/model.py
@@ -955,3 +955,48 @@ class ObservationLogImporter(ToFarmOSLog):
 
     model_title = "ObservationLog"
     farmos_log_type = "observation"
+
+
+class SeedingLogImporter(ToFarmOSLog):
+
+    model_title = "SeedingLog"
+    farmos_log_type = "seeding"
+
+    def get_supported_fields(self):
+        fields = list(super().get_supported_fields())
+        fields.extend(
+            [
+                "source",
+                "purchase_date",
+                "lot_number",
+            ]
+        )
+        return fields
+
+    def normalize_target_object(self, log):
+        data = super().normalize_target_object(log)
+        data.update(
+            {
+                "source": log["attributes"]["source"],
+                "purchase_date": self.normalize_datetime(
+                    log["attributes"]["purchase_date"]
+                ),
+                "lot_number": log["attributes"]["lot_number"],
+            }
+        )
+        return data
+
+    def get_log_payload(self, source_data):
+        payload = super().get_log_payload(source_data)
+
+        attrs = {}
+        if "source" in self.fields:
+            attrs["source"] = source_data["source"]
+        if "purchase_date" in self.fields:
+            attrs["purchase_date"] = self.format_datetime(source_data["purchase_date"])
+        if "lot_number" in self.fields:
+            attrs["lot_number"] = source_data["lot_number"]
+
+        if attrs:
+            payload["attributes"].update(attrs)
+        return payload
diff --git a/src/wuttafarm/farmos/importing/wuttafarm.py b/src/wuttafarm/farmos/importing/wuttafarm.py
index bd42e86..746f761 100644
--- a/src/wuttafarm/farmos/importing/wuttafarm.py
+++ b/src/wuttafarm/farmos/importing/wuttafarm.py
@@ -115,6 +115,7 @@ class FromWuttaFarmToFarmOS(FromWuttaFarmHandler, ToFarmOSHandler):
         importers["HarvestLog"] = HarvestLogImporter
         importers["MedicalLog"] = MedicalLogImporter
         importers["ObservationLog"] = ObservationLogImporter
+        importers["SeedingLog"] = SeedingLogImporter
         return importers
 
 
@@ -630,3 +631,22 @@ class ObservationLogImporter(
     """
 
     source_model_class = model.ObservationLog
+
+
+class SeedingLogImporter(FromWuttaFarmLog, farmos_importing.model.SeedingLogImporter):
+    """
+    WuttaFarm → farmOS API exporter for Seeding Logs
+    """
+
+    source_model_class = model.SeedingLog
+
+    def normalize_source_object(self, log):
+        data = super().normalize_source_object(log)
+        data.update(
+            {
+                "source": log.source,
+                "purchase_date": log.purchase_date,
+                "lot_number": log.lot_number,
+            }
+        )
+        return data
diff --git a/src/wuttafarm/importing/farmos.py b/src/wuttafarm/importing/farmos.py
index 93e8d30..c739bad 100644
--- a/src/wuttafarm/importing/farmos.py
+++ b/src/wuttafarm/importing/farmos.py
@@ -126,6 +126,7 @@ class FromFarmOSToWuttaFarm(FromFarmOSHandler, ToWuttaFarmHandler):
         importers["HarvestLog"] = HarvestLogImporter
         importers["MedicalLog"] = MedicalLogImporter
         importers["ObservationLog"] = ObservationLogImporter
+        importers["SeedingLog"] = SeedingLogImporter
         return importers
 
 
@@ -155,6 +156,8 @@ class FromFarmOS(Importer):
 
         :returns: Equivalent naive UTC ``datetime``
         """
+        if not dt:
+            return None
         dt = datetime.datetime.fromisoformat(dt)
         return self.app.make_utc(dt)
 
@@ -1417,6 +1420,41 @@ class ObservationLogImporter(LogImporterBase):
     model_class = model.ObservationLog
 
 
+class SeedingLogImporter(LogImporterBase):
+    """
+    farmOS API → WuttaFarm importer for Seeding Logs
+    """
+
+    model_class = model.SeedingLog
+
+    def get_simple_fields(self):
+        """ """
+        fields = list(super().get_simple_fields())
+        # nb. must explicitly declare proxy fields
+        fields.extend(
+            [
+                "source",
+                "purchase_date",
+                "lot_number",
+            ]
+        )
+        return fields
+
+    def normalize_source_object(self, log):
+        """ """
+        data = super().normalize_source_object(log)
+        data.update(
+            {
+                "source": log["attributes"]["source"],
+                "purchase_date": self.normalize_datetime(
+                    log["attributes"]["purchase_date"]
+                ),
+                "lot_number": log["attributes"]["lot_number"],
+            }
+        )
+        return data
+
+
 class QuantityImporterBase(FromFarmOS, ToWutta):
     """
     Base class for farmOS API → WuttaFarm quantity importers
diff --git a/src/wuttafarm/normal.py b/src/wuttafarm/normal.py
index d03a3ec..c47fcc3 100644
--- a/src/wuttafarm/normal.py
+++ b/src/wuttafarm/normal.py
@@ -84,6 +84,12 @@ class Normalizer(GenericHandler):
         self._farmos_units = units
         return self._farmos_units
 
+    def normalize_datetime(self, value):
+        if not value:
+            return None
+        value = datetime.datetime.fromisoformat(value)
+        return self.app.localtime(value)
+
     def normalize_farmos_asset(self, asset, included={}):
         """ """
 
@@ -149,8 +155,7 @@ class Normalizer(GenericHandler):
     def normalize_farmos_log(self, log, included={}):
 
         if timestamp := log["attributes"]["timestamp"]:
-            timestamp = datetime.datetime.fromisoformat(timestamp)
-            timestamp = self.app.localtime(timestamp)
+            timestamp = self.normalize_datetime(timestamp)
 
         if notes := log["attributes"]["notes"]:
             notes = notes["value"]
diff --git a/src/wuttafarm/web/menus.py b/src/wuttafarm/web/menus.py
index a44e5a9..2756738 100644
--- a/src/wuttafarm/web/menus.py
+++ b/src/wuttafarm/web/menus.py
@@ -191,6 +191,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "logs_observation",
                     "perm": "logs_observation.list",
                 },
+                {
+                    "title": "Seeding",
+                    "route": "logs_seeding",
+                    "perm": "logs_seeding.list",
+                },
                 {"type": "sep"},
                 {
                     "title": "All Quantities",
@@ -305,6 +310,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_logs_observation",
                     "perm": "farmos_logs_observation.list",
                 },
+                {
+                    "title": "Seeding Logs",
+                    "route": "farmos_logs_seeding",
+                    "perm": "farmos_logs_seeding.list",
+                },
                 {"type": "sep"},
                 {
                     "title": "Animal Types",
@@ -490,6 +500,11 @@ class WuttaFarmMenuHandler(base.MenuHandler):
                     "route": "farmos_logs_observation",
                     "perm": "farmos_logs_observation.list",
                 },
+                {
+                    "title": "Seeding",
+                    "route": "farmos_logs_seeding",
+                    "perm": "farmos_logs_seeding.list",
+                },
                 {"type": "sep"},
                 {
                     "title": "Log Types",
diff --git a/src/wuttafarm/web/views/__init__.py b/src/wuttafarm/web/views/__init__.py
index 8e57f34..e66f479 100644
--- a/src/wuttafarm/web/views/__init__.py
+++ b/src/wuttafarm/web/views/__init__.py
@@ -64,6 +64,7 @@ def includeme(config):
         config.include("wuttafarm.web.views.logs_harvest")
         config.include("wuttafarm.web.views.logs_medical")
         config.include("wuttafarm.web.views.logs_observation")
+        config.include("wuttafarm.web.views.logs_seeding")
 
     # quick form views
     # (nb. these work with all integration modes)
diff --git a/src/wuttafarm/web/views/farmos/__init__.py b/src/wuttafarm/web/views/farmos/__init__.py
index c92a04c..708b553 100644
--- a/src/wuttafarm/web/views/farmos/__init__.py
+++ b/src/wuttafarm/web/views/farmos/__init__.py
@@ -47,3 +47,4 @@ def includeme(config):
     config.include("wuttafarm.web.views.farmos.logs_harvest")
     config.include("wuttafarm.web.views.farmos.logs_medical")
     config.include("wuttafarm.web.views.farmos.logs_observation")
+    config.include("wuttafarm.web.views.farmos.logs_seeding")
diff --git a/src/wuttafarm/web/views/farmos/logs_seeding.py b/src/wuttafarm/web/views/farmos/logs_seeding.py
new file mode 100644
index 0000000..ed967cc
--- /dev/null
+++ b/src/wuttafarm/web/views/farmos/logs_seeding.py
@@ -0,0 +1,105 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+View for farmOS Seeding Logs
+"""
+
+from wuttaweb.forms.schema import WuttaDateTime
+from wuttaweb.forms.widgets import WuttaDateTimeWidget
+
+from wuttafarm.web.views.farmos.logs import LogMasterView
+from wuttafarm.web.grids import SimpleSorter, StringFilter
+
+
+class SeedingLogView(LogMasterView):
+    """
+    View for farmOS seeding logs
+    """
+
+    model_name = "farmos_seeding_log"
+    model_title = "farmOS Seeding Log"
+    model_title_plural = "farmOS Seeding Logs"
+
+    route_prefix = "farmos_logs_seeding"
+    url_prefix = "/farmOS/logs/seeding"
+
+    farmos_log_type = "seeding"
+    farmos_refurl_path = "/logs/seeding"
+
+    grid_columns = [
+        "status",
+        "drupal_id",
+        "timestamp",
+        "name",
+        "assets",
+        "locations",
+        "purchase_date",
+        "source",
+        "is_group_assignment",
+        "owners",
+    ]
+
+    def normalize_log(self, log, included):
+        data = super().normalize_log(log, included)
+        data.update(
+            {
+                "source": log["attributes"]["source"],
+                "purchase_date": self.normal.normalize_datetime(
+                    log["attributes"]["purchase_date"]
+                ),
+                "lot_number": log["attributes"]["lot_number"],
+            }
+        )
+        return data
+
+    def configure_grid(self, grid):
+        g = grid
+        super().configure_grid(g)
+
+        # purchase_date
+        g.set_renderer("purchase_date", "date")
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+
+        # source
+        f.fields.insert_after("timestamp", "source")
+
+        # purchase_date
+        f.fields.insert_after("source", "purchase_date")
+        f.set_node("purchase_date", WuttaDateTime())
+        f.set_widget("purchase_date", WuttaDateTimeWidget(self.request))
+
+        # lot_number
+        f.fields.insert_after("purchase_date", "lot_number")
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    SeedingLogView = kwargs.get("SeedingLogView", base["SeedingLogView"])
+    SeedingLogView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)
diff --git a/src/wuttafarm/web/views/logs_seeding.py b/src/wuttafarm/web/views/logs_seeding.py
new file mode 100644
index 0000000..8946aff
--- /dev/null
+++ b/src/wuttafarm/web/views/logs_seeding.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  WuttaFarm --Web app to integrate with and extend farmOS
+#  Copyright © 2026 Lance Edgar
+#
+#  This file is part of WuttaFarm.
+#
+#  WuttaFarm is free software: you can redistribute it and/or modify it under
+#  the terms of the GNU General Public License as published by the Free Software
+#  Foundation, either version 3 of the License, or (at your option) any later
+#  version.
+#
+#  WuttaFarm is distributed in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  WuttaFarm.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Master view for Seeding Logs
+"""
+
+from wuttaweb.forms.widgets import WuttaDateTimeWidget
+
+from wuttafarm.web.views.logs import LogMasterView
+from wuttafarm.db.model import SeedingLog
+
+
+class SeedingLogView(LogMasterView):
+    """
+    Master view for Seeding Logs
+    """
+
+    model_class = SeedingLog
+    route_prefix = "logs_seeding"
+    url_prefix = "/logs/seeding"
+
+    farmos_bundle = "seeding"
+    farmos_refurl_path = "/logs/seeding"
+
+    grid_columns = [
+        "status",
+        "drupal_id",
+        "timestamp",
+        "message",
+        "assets",
+        "locations",
+        "purchase_date",
+        "source",
+        "is_group_assignment",
+        "owners",
+    ]
+
+    def configure_form(self, form):
+        f = form
+        super().configure_form(f)
+
+        # source
+        f.fields.insert_after("timestamp", "source")
+
+        # purchase_date
+        f.fields.insert_after("source", "purchase_date")
+        f.set_widget("purchase_date", WuttaDateTimeWidget(self.request))
+
+        # lot_number
+        f.fields.insert_after("purchase_date", "lot_number")
+
+
+def defaults(config, **kwargs):
+    base = globals()
+
+    SeedingLogView = kwargs.get("SeedingLogView", base["SeedingLogView"])
+    SeedingLogView.defaults(config)
+
+
+def includeme(config):
+    defaults(config)

From 3bacb884dc719b4d957e1e04e248317b6ed829a2 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Tue, 10 Mar 2026 10:52:35 -0500
Subject: [PATCH 19/20] fix: avoid error when material type is unknown

not sure if this is a unique situation in my dev environment or
what..but i keep encountering this in dev, so might as well add it.
better safe than sorry
---
 src/wuttafarm/web/util.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/wuttafarm/web/util.py b/src/wuttafarm/web/util.py
index 35a6f02..ec88525 100644
--- a/src/wuttafarm/web/util.py
+++ b/src/wuttafarm/web/util.py
@@ -81,7 +81,9 @@ def render_quantity_object(quantity):
     text = f"( {measure} ) {value} {unit}"
 
     if quantity["quantity_type_id"] == "material":
-        materials = ", ".join([mtype["name"] for mtype in quantity["material_types"]])
+        materials = ", ".join(
+            [mtype.get("name", "???") for mtype in quantity["material_types"]]
+        )
         return f"{materials} {text}"
 
     return text

From 8baf140c70a8bdaa80546f09da0f6bfffb38dd65 Mon Sep 17 00:00:00 2001
From: Lance Edgar <lance@wuttaproject.org>
Date: Tue, 10 Mar 2026 10:59:27 -0500
Subject: [PATCH 20/20] =?UTF-8?q?bump:=20version=200.8.0=20=E2=86=92=200.9?=
 =?UTF-8?q?.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md   | 27 +++++++++++++++++++++++++++
 pyproject.toml |  4 ++--
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f1eedfc..794220d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,33 @@ All notable changes to WuttaFarm will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## v0.9.0 (2026-03-10)
+
+### Feat
+
+- add schema, edit/sync support for Seeding Logs
+- add schema, edit/sync support for Equipment Assets
+- add schema, edit/sync support for Equipment Types
+- add schema, edit/sync support for Water Assets
+- add edit/sync support for Material Types + Material Quantities
+- add edit/sync support for Material Types
+- add edit/sync support for Log Quantities
+- add edit/sync support for `Log.groups`
+- add edit/sync support for `Log.locations`
+- expose Assets field when editing a Log record
+- add edit/sync support for Plant Seasons
+- add edit/sync support for asset parents
+
+### Fix
+
+- avoid error when material type is unknown
+- improve behavior when deleting a Standard Quantity
+- cleanup grid views for All, Standard Quantities
+- add ordinal for sorting Measures
+- expose `is_location` and `is_fixed` for editing on Animal Asset
+- allow "N/A" option for animal sex
+- fix Assets column for All Logs subgrid when viewing asset
+
 ## v0.8.0 (2026-03-04)
 
 ### Feat
diff --git a/pyproject.toml b/pyproject.toml
index 1bb1dda..51737ce 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "WuttaFarm"
-version = "0.8.0"
+version = "0.9.0"
 description = "Web app to integrate with and extend farmOS"
 readme = "README.md"
 authors = [
@@ -34,7 +34,7 @@ dependencies = [
     "pyramid_exclog",
     "uvicorn[standard]",
     "WuttaSync",
-    "WuttaWeb[continuum]>=0.29.0",
+    "WuttaWeb[continuum]>=0.29.2",
 ]