CHANGELOG.md

@@ -5,40 +5,6 @@ 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.11.2 (2026-03-21)
-
-### Fix
-
-- use separate thread to sync changes to farmOS
-- avoid error if asset has no geometry
-
-## v0.11.1 (2026-03-21)
-
-### Fix
-
-- improve behavior when deleting mirrored record from farmOS
-- use correct uuid when processing webhook to delete record
-
-## v0.11.0 (2026-03-15)
-
-### Feat
-
-- show basic map for "fixed" assets
-
-### Fix
-
-- include LogQuantity changes when viewing Log revision
-
-## v0.10.0 (2026-03-11)
-
-### Feat
-
-- add support for webhooks module in farmOS
-
-### Fix
-
-- remove print statement
-
 ## v0.9.0 (2026-03-10)
 
 ### Feat

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "WuttaFarm"
-version = "0.11.2"
+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.30.1",
+    "WuttaWeb[continuum]>=0.29.2",
 ]
 
 

src/wuttafarm/app.py

@@ -270,7 +270,6 @@ class WuttaFarmAppHandler(base.AppHandler):
            then nothing will happen / import is silently skipped when
            there is no such importer.
         """
-        model = self.app.model
         handler = self.app.get_import_handler("import.to_wuttafarm.from_farmos")
 
         if model_name not in handler.importers:
@@ -281,10 +280,6 @@ class WuttaFarmAppHandler(base.AppHandler):
         # nb. begin txn to establish the API client
         handler.begin_source_transaction(client)
         with self.short_session(commit=True) as session:
-
-            if user := session.query(model.User).filter_by(username="farmos").first():
-                session.info["continuum_user_id"] = user.uuid
-
             handler.target_session = session
             importer = handler.get_importer(model_name, caches_target=False)
             normal = importer.normalize_source_object(obj)

src/wuttafarm/cli/__init__.py

@@ -29,4 +29,3 @@ from .base import wuttafarm_typer
 from . import export_farmos
 from . import import_farmos
 from . import install
-from . import process_webhooks

src/wuttafarm/cli/process_webhooks.py

@@ -1,180 +0,0 @@
-# -*- 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/>.
-#
-################################################################################
-"""
-WuttaFarm CLI
-"""
-
-import logging
-import time
-
-import typer
-from oauthlib.oauth2 import BackendApplicationClient
-from requests_oauthlib import OAuth2Session
-
-from wuttafarm.cli import wuttafarm_typer
-
-
-log = logging.getLogger(__name__)
-
-
-class ChangeProcessor:
-
-    def __init__(self, config):
-        self.config = config
-        self.app = config.get_app()
-
-    def process_change(self, change):
-        if change.deleted:
-            self.delete_record(change)
-        else:
-            self.import_record(change)
-
-    def import_record(self, change):
-        token = self.get_farmos_oauth2_token()
-        client = self.app.get_farmos_client(token=token)
-
-        full_type = f"{change.entity_type}--{change.bundle}"
-        record = client.resource.get_id(
-            change.entity_type, change.bundle, change.farmos_uuid
-        )
-
-        importer_map = self.get_importer_map()
-        model_name = importer_map[full_type]
-
-        self.app.auto_sync_from_farmos(record["data"], model_name, client=client)
-
-    def delete_record(self, change):
-        model = self.app.model
-        handler = self.app.get_import_handler("import.to_wuttafarm.from_farmos")
-
-        importer_map = self.get_importer_map()
-        full_type = f"{change.entity_type}--{change.bundle}"
-        model_name = importer_map[full_type]
-
-        token = self.get_farmos_oauth2_token()
-        client = self.app.get_farmos_client(token=token)
-
-        # nb. begin txn to establish the API client
-        handler.begin_source_transaction(client)
-        with self.app.short_session(commit=True) as session:
-            handler.target_session = session
-            importer = handler.get_importer(model_name, caches_target=False)
-
-            # try to attribute change to 'farmos' user
-            if user := session.query(model.User).filter_by(username="farmos").first():
-                session.info["continuum_user_id"] = user.uuid
-
-            # only support importers with farmos_uuid as key
-            # (pretty sure that covers us..can revise if needed)
-            if importer.get_keys() != ["farmos_uuid"]:
-                log.warning(
-                    "unsupported keys for %s importer: %s",
-                    model_name,
-                    importer.get_keys(),
-                )
-                return
-
-            # delete corresponding record from our app
-            if obj := importer.get_target_object((change.farmos_uuid,)):
-                importer.delete_target_object(obj)
-
-    # TODO: this should live elsewhere
-    def get_farmos_oauth2_token(self):
-
-        client_id = self.config.get(
-            "farmos.oauth2.importing.client_id", default="wuttafarm"
-        )
-        client_secret = self.config.require("farmos.oauth2.importing.client_secret")
-        scope = self.config.get("farmos.oauth2.importing.scope", default="farm_manager")
-
-        client = BackendApplicationClient(client_id=client_id)
-        oauth = OAuth2Session(client=client)
-
-        return oauth.fetch_token(
-            token_url=self.app.get_farmos_url("/oauth/token"),
-            include_client_id=True,
-            client_secret=client_secret,
-            scope=scope,
-        )
-
-    # TODO: this should live elsewhere
-    def get_importer_map(self):
-        return {
-            "asset--animal": "AnimalAsset",
-            "asset--equipment": "EquipmentAsset",
-            "asset--group": "GroupAsset",
-            "asset--land": "LandAsset",
-            "asset--plant": "PlantAsset",
-            "asset--structure": "StructureAsset",
-            "asset--water": "WaterAsset",
-            "log--activity": "ActivityLog",
-            "log--harvest": "HarvestLog",
-            "log--medical": "MedicalLog",
-            "log--observation": "ObservationLog",
-            "log--seeding": "SeedingLog",
-            "quantity--material": "MaterialQuantity",
-            "quantity--standard": "StandardQuantity",
-            "taxonomy_term--animal_type": "AnimalType",
-            "taxonomy_term--equipment_type": "EquipmentType",
-            "taxonomy_term--plant_type": "PlantType",
-            "taxonomy_term--season": "Season",
-            "taxonomy_term--material_type": "MaterialType",
-            "taxonomy_term--unit": "Unit",
-        }
-
-
-@wuttafarm_typer.command()
-def process_webhooks(
-    ctx: typer.Context,
-):
-    """
-    Process incoming webhook requests from farmOS.
-    """
-    config = ctx.parent.wutta_config
-    app = config.get_app()
-    model = app.model
-    processor = ChangeProcessor(config)
-
-    while True:
-        with app.short_session(commit=True) as session:
-
-            query = session.query(model.WebhookChange).order_by(
-                model.WebhookChange.received
-            )
-
-            # nb. fetch (at most) 2 changes instead of just 1;
-            # this will control time delay behavior below
-            if changes := query[:2]:
-
-                # process first change
-                change = changes[0]
-                log.info("processing webhook change: %s", change)
-                processor.process_change(change)
-                session.delete(change)
-
-                # minimal time delay if 2nd change exists
-                if len(changes) == 2:
-                    time.sleep(0.1)
-                    continue
-
-        # nothing in queue, so wait 1 sec before checking again
-        time.sleep(1)

src/wuttafarm/db/alembic/versions/dd4d4142b96d_add_webhookchange.py

@@ -1,41 +0,0 @@
-"""add WebhookChange
-
-Revision ID: dd4d4142b96d
-Revises: dca5b48a5562
-Create Date: 2026-03-10 22:31:54.324952
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-import wuttjamaican.db.util
-
-
-# revision identifiers, used by Alembic.
-revision: str = "dd4d4142b96d"
-down_revision: Union[str, None] = "dca5b48a5562"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-
-    # webhook_change
-    op.create_table(
-        "webhook_change",
-        sa.Column("uuid", wuttjamaican.db.util.UUID(), nullable=False),
-        sa.Column("entity_type", sa.String(length=100), nullable=False),
-        sa.Column("bundle", sa.String(length=100), nullable=False),
-        sa.Column("farmos_uuid", wuttjamaican.db.util.UUID(), nullable=False),
-        sa.Column("deleted", sa.Boolean(), nullable=False),
-        sa.Column("received", sa.DateTime(), nullable=False),
-        sa.PrimaryKeyConstraint("uuid", name=op.f("pk_webhook_change")),
-    )
-
-
-def downgrade() -> None:
-
-    # webhook_change
-    op.drop_table("webhook_change")

src/wuttafarm/db/model/__init__.py

@@ -59,6 +59,3 @@ from .log_harvest import HarvestLog
 from .log_medical import MedicalLog
 from .log_observation import ObservationLog
 from .log_seeding import SeedingLog
-
-# misc.
-from .webhook import WebhookChange

src/wuttafarm/db/model/webhook.py

@@ -1,61 +0,0 @@
-# -*- 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 webhook changes
-"""
-
-import sqlalchemy as sa
-
-from wuttjamaican.db import model
-from wuttjamaican.util import make_utc
-
-
-class WebhookChange(model.Base):
-    """
-    Represents a "change" (create/update/delete) notification which
-    originated in farmOS and delivered via webhook.
-
-    This table serves as a "FIFO queue" for processing the changes.
-    """
-
-    __tablename__ = "webhook_change"
-
-    uuid = model.uuid_column()
-
-    entity_type = sa.Column(sa.String(length=100), nullable=False)
-    bundle = sa.Column(sa.String(length=100), nullable=False)
-    farmos_uuid = sa.Column(model.UUID(), nullable=False)
-
-    deleted = sa.Column(sa.Boolean(), nullable=False)
-
-    received = sa.Column(
-        sa.DateTime(),
-        nullable=False,
-        default=make_utc,
-        doc="""
-    Date and time when the change was obtained from the watcher thread.
-    """,
-    )
-
-    def __str__(self):
-        event_type = "delete" if self.deleted else "create/update"
-        return f"{event_type} {self.entity_type}--{self.bundle}: {self.farmos_uuid}"

src/wuttafarm/farmos/importing/wuttafarm.py

@@ -248,6 +248,8 @@ class EquipmentAssetImporter(
 
     def get_supported_fields(self):
         fields = list(super().get_supported_fields())
+
+        print(fields)
         fields.extend(
             [
                 "manufacturer",

src/wuttafarm/importing/farmos.py

@@ -339,8 +339,6 @@ class AnimalAssetImporter(AssetImporterBase):
 
     model_class = model.AnimalAsset
 
-    animal_types_by_farmos_uuid = None
-
     def get_supported_fields(self):
         fields = list(super().get_supported_fields())
         fields.extend(
@@ -363,17 +361,6 @@ class AnimalAssetImporter(AssetImporterBase):
             if animal_type.farmos_uuid:
                 self.animal_types_by_farmos_uuid[animal_type.farmos_uuid] = animal_type
 
-    def get_animal_type_by_farmos_uuid(self, uuid):
-        if self.animal_types_by_farmos_uuid is not None:
-            return self.animal_types_by_farmos_uuid.get(uuid)
-
-        model = self.app.model
-        return (
-            self.target_session.query(model.AnimalType)
-            .filter(model.AnimalType.farmos_uuid == uuid)
-            .first()
-        )
-
     def normalize_source_object(self, animal):
         """ """
         animal_type_uuid = None
@@ -381,7 +368,7 @@ class AnimalAssetImporter(AssetImporterBase):
 
             if animal_type := relationships.get("animal_type"):
                 if animal_type["data"]:
-                    if wf_animal_type := self.get_animal_type_by_farmos_uuid(
+                    if wf_animal_type := self.animal_types_by_farmos_uuid.get(
                         UUID(animal_type["data"]["id"])
                     ):
                         animal_type_uuid = wf_animal_type.uuid
@@ -513,8 +500,6 @@ class EquipmentAssetImporter(AssetImporterBase):
 
     model_class = model.EquipmentAsset
 
-    equipment_types_by_farmos_uuid = None
-
     def get_supported_fields(self):
         fields = list(super().get_supported_fields())
         fields.extend(
@@ -535,17 +520,6 @@ class EquipmentAssetImporter(AssetImporterBase):
                     equipment_type
                 )
 
-    def get_equipment_type_by_farmos_uuid(self, uuid):
-        if self.equipment_types_by_farmos_uuid is not None:
-            return self.equipment_types_by_farmos_uuid.get(uuid)
-
-        model = self.app.model
-        return (
-            self.target_session.query(model.EquipmentType)
-            .filter_by(farmos_uuid=uuid)
-            .first()
-        )
-
     def normalize_source_object(self, equipment):
         """ """
         data = super().normalize_source_object(equipment)
@@ -556,7 +530,7 @@ class EquipmentAssetImporter(AssetImporterBase):
             if equipment_type := relationships.get("equipment_type"):
                 equipment_types = []
                 for equipment_type in equipment_type["data"]:
-                    if wf_equipment_type := self.get_equipment_type_by_farmos_uuid(
+                    if wf_equipment_type := self.equipment_types_by_farmos_uuid.get(
                         UUID(equipment_type["id"])
                     ):
                         equipment_types.append(wf_equipment_type.uuid)
@@ -658,8 +632,6 @@ class LandAssetImporter(AssetImporterBase):
 
     model_class = model.LandAsset
 
-    land_types_by_id = None
-
     def get_supported_fields(self):
         fields = list(super().get_supported_fields())
         fields.extend(
@@ -678,21 +650,10 @@ class LandAssetImporter(AssetImporterBase):
         for land_type in self.target_session.query(model.LandType):
             self.land_types_by_id[land_type.drupal_id] = land_type
 
-    def get_land_type_by_id(self, drupal_id):
-        if self.land_types_by_id is not None:
-            return self.land_types_by_id.get(drupal_id)
-
-        model = self.app.model
-        return (
-            self.target_session.query(model.LandType)
-            .filter_by(drupal_id=drupal_id)
-            .first()
-        )
-
     def normalize_source_object(self, land):
         """ """
         land_type_id = land["attributes"]["land_type"]
-        land_type = self.get_land_type_by_id(land_type_id)
+        land_type = self.land_types_by_id.get(land_type_id)
         if not land_type:
             log.warning(
                 "invalid land_type '%s' for farmOS Land Asset: %s", land_type_id, land
@@ -797,9 +758,6 @@ class PlantAssetImporter(AssetImporterBase):
 
     model_class = model.PlantAsset
 
-    plant_types_by_farmos_uuid = None
-    seasons_by_farmos_uuid = None
-
     def get_supported_fields(self):
         fields = list(super().get_supported_fields())
         fields.extend(
@@ -824,26 +782,6 @@ class PlantAssetImporter(AssetImporterBase):
             if season.farmos_uuid:
                 self.seasons_by_farmos_uuid[season.farmos_uuid] = season
 
-    def get_plant_type_by_farmos_uuid(self, uuid):
-        if self.plant_types_by_farmos_uuid is not None:
-            return self.plant_types_by_farmos_uuid.get(uuid)
-
-        model = self.app.model
-        return (
-            self.target_session.query(model.PlantType)
-            .filter_by(farmos_uuid=uuid)
-            .first()
-        )
-
-    def get_season_by_farmos_uuid(self, uuid):
-        if self.seasons_by_farmos_uuid is not None:
-            return self.seasons_by_farmos_uuid.get(uuid)
-
-        model = self.app.model
-        return (
-            self.target_session.query(model.Season).filter_by(farmos_uuid=uuid).first()
-        )
-
     def normalize_source_object(self, plant):
         """ """
         data = super().normalize_source_object(plant)
@@ -855,7 +793,7 @@ class PlantAssetImporter(AssetImporterBase):
             if plant_type := relationships.get("plant_type"):
                 plant_types = []
                 for plant_type in plant_type["data"]:
-                    if wf_plant_type := self.get_plant_type_by_farmos_uuid(
+                    if wf_plant_type := self.plant_types_by_farmos_uuid.get(
                         UUID(plant_type["id"])
                     ):
                         plant_types.append(wf_plant_type.uuid)
@@ -865,7 +803,7 @@ class PlantAssetImporter(AssetImporterBase):
             if season := relationships.get("season"):
                 seasons = []
                 for season in season["data"]:
-                    if wf_season := self.get_season_by_farmos_uuid(UUID(season["id"])):
+                    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"])
@@ -948,8 +886,6 @@ class StructureAssetImporter(AssetImporterBase):
 
     model_class = model.StructureAsset
 
-    structure_types_by_id = None
-
     def get_supported_fields(self):
         fields = list(super().get_supported_fields())
         fields.extend(
@@ -967,21 +903,10 @@ class StructureAssetImporter(AssetImporterBase):
         for structure_type in self.target_session.query(model.StructureType):
             self.structure_types_by_id[structure_type.drupal_id] = structure_type
 
-    def get_structure_type_by_id(self, drupal_id):
-        if self.structure_types_by_id is not None:
-            return self.structure_types_by_id.get(drupal_id)
-
-        model = self.app.model
-        return (
-            self.target_session.query(model.StructureType)
-            .filter_by(drupal_id=drupal_id)
-            .first()
-        )
-
     def normalize_source_object(self, structure):
         """ """
         structure_type_id = structure["attributes"]["structure_type"]
-        structure_type = self.get_structure_type_by_id(structure_type_id)
+        structure_type = self.structure_types_by_id.get(structure_type_id)
         if not structure_type:
             log.warning(
                 "invalid structure_type '%s' for farmOS Structure Asset: %s",

src/wuttafarm/web/templates/appinfo/configure.mako

@@ -57,11 +57,6 @@
       </div>
     </b-field>
 
-    <b-field v-if="simpleSettings['${app.appname}.farmos_integration_mode'] == 'mirror'"
-             label="Webhook URI for farmOS">
-      <wutta-copyable-text text="${url('webhooks.farmos')}" />
-    </b-field>
-
     <b-checkbox name="${app.appname}.farmos_style_grid_links"
                 v-model="simpleSettings['${app.appname}.farmos_style_grid_links']"
                 native-value="true"

src/wuttafarm/web/templates/assets/master/view.mako

@@ -10,74 +10,5 @@
       </b-notification>
   % endif
 
-  <div style="display: flex; margin-right: 0.5rem;">
+  ${parent.page_content()}
-
-    ## main form
-    <div style="flex-grow: 1;">
-      ${parent.page_content()}
-    </div>
-
-    ## location map
-    % if map_polygon:
-        <div ref="map" style="flex-grow: 2; height: 500px;" />
-    % endif
-
-  </div>
-
-</%def>
-
-<%def name="modify_vue_vars()">
-  ${parent.modify_vue_vars()}
-  % if map_polygon:
-      <script>
-
-        ThisPageData.map = null
-
-        ThisPage.mounted = function() {
-
-            this.map = new maplibregl.Map({
-                container: this.$refs.map,
-                style: 'https://tiles.openfreemap.org/styles/liberty',
-                center: ${json.dumps(map_center)|n},
-                zoom: 16,
-            })
-
-            this.map.on('load', () => {
-
-                this.map.addSource('assetGeometry', {
-                    'type': 'geojson',
-                    'data': {
-                        'type': 'Feature',
-                        'geometry': {
-                            'type': 'Polygon',
-                            'coordinates': ${json.dumps(map_polygon)|n},
-                        }
-                    }
-                })
-
-                this.map.addLayer({
-                    'id': 'assetGeometry',
-                    'source': 'assetGeometry',
-                    'type': 'line',
-                    'paint': {
-                        'line-color': 'orange',
-                        'line-width': 2,
-                    },
-                })
-
-                this.map.fitBounds(${json.dumps(map_bounds)|n}, {
-                    linear: true,
-                })
-
-                this.map.addControl(new maplibregl.FullscreenControl())
-                this.map.addControl(new maplibregl.NavigationControl(), 'top-left')
-                this.map.addControl(new maplibregl.ScaleControl({
-                    maxWidth: 80,
-                    unit: 'imperial',
-                }))
-            })
-        }
-
-      </script>
-  % endif
 </%def>

src/wuttafarm/web/templates/base.mako

@@ -1,16 +1,6 @@
 <%inherit file="wuttaweb:templates/base.mako" />
 <%namespace file="/wuttafarm-components.mako" import="make_wuttafarm_components" />
 
-<%def name="head_tags()">
-  ${parent.head_tags()}
-
-  ## TODO: this likely does not belong in the base template, and should be
-  ## included per template where actually needed.  but this is easier for now.
-  <script src="https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.js"></script>
-  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.css" />
-
-</%def>
-
 <%def name="index_title_controls()">
   ${parent.index_title_controls()}
 

src/wuttafarm/web/views/__init__.py

@@ -73,7 +73,3 @@ def includeme(config):
     # views for farmOS
     if mode != enum.FARMOS_INTEGRATION_MODE_NONE:
         config.include("wuttafarm.web.views.farmos")
-
-    # webhook views (only for mirror mode)
-    if mode == enum.FARMOS_INTEGRATION_MODE_MIRROR:
-        config.include("wuttafarm.web.views.webhooks")

src/wuttafarm/web/views/assets.py

@@ -23,7 +23,6 @@
 Master view for Assets
 """
 
-import re
 from collections import OrderedDict
 
 from webhelpers2.html import tags
@@ -360,38 +359,6 @@ class AssetMasterView(WuttaFarmMasterView):
 
         return buttons
 
-    def get_template_context(self, context):
-        context = super().get_template_context(context)
-
-        if self.viewing:
-            asset = context["instance"]
-
-            # add location geometry if applicable
-            if asset.is_fixed and asset.farmos_uuid and not self.app.is_standalone():
-
-                # TODO: eventually sync GIS data, avoid this API call?
-                client = get_farmos_client_for_user(self.request)
-                result = client.asset.get_id(asset.asset_type, asset.farmos_uuid)
-                if geometry := result["data"]["attributes"]["intrinsic_geometry"]:
-
-                    context["map_center"] = [geometry["lon"], geometry["lat"]]
-
-                    context["map_bounds"] = [
-                        [geometry["left"], geometry["bottom"]],
-                        [geometry["right"], geometry["top"]],
-                    ]
-
-                    if match := re.match(
-                        r"^POLYGON \(\((?P<points>[^\)]+)\)\)$", geometry["value"]
-                    ):
-                        points = match.group("points").split(", ")
-                        points = [
-                            [float(pt) for pt in pair.split(" ")] for pair in points
-                        ]
-                        context["map_polygon"] = [points]
-
-        return context
-
     def get_version_joins(self):
         """
         We override this to declare the relationship between the

src/wuttafarm/web/views/logs.py

@@ -491,7 +491,6 @@ class LogMasterView(WuttaFarmMasterView):
         return super().get_version_joins() + [
             model.Log,
             (model.LogAsset, "log_uuid", "uuid"),
-            (model.LogQuantity, "log_uuid", "uuid"),
         ]
 
 

src/wuttafarm/web/views/master.py

@@ -23,10 +23,6 @@
 Base class for WuttaFarm master views
 """
 
-import threading
-import time
-
-import requests
 from webhelpers2.html import tags
 
 from wuttaweb.views import MasterView
@@ -111,36 +107,17 @@ class WuttaFarmMasterView(MasterView):
             f.set_readonly("drupal_id")
 
     def persist(self, obj, session=None):
-        session = session or self.Session()
 
         # save per usual
         super().persist(obj, session)
 
         # maybe also sync change to farmOS
         if self.app.is_farmos_mirror():
-            if self.creating:
-                session.flush()  # need the new uuid
             client = get_farmos_client_for_user(self.request)
-            thread = threading.Thread(
+            self.auto_sync_to_farmos(client, obj)
-                target=self.auto_sync_to_farmos, args=(client, obj.uuid)
-            )
-            thread.start()
 
-    def auto_sync_to_farmos(self, client, uuid):
+    def auto_sync_to_farmos(self, client, obj):
-        model = self.app.model
+        self.app.auto_sync_to_farmos(obj, client=client, require=False)
-        model_class = self.get_model_class()
-
-        with self.app.short_session(commit=True) as session:
-            if user := session.query(model.User).filter_by(username="farmos").first():
-                session.info["continuum_user_id"] = user.uuid
-
-            obj = None
-            while not obj:
-                obj = session.get(model_class, uuid)
-                if not obj:
-                    time.sleep(0.1)
-
-            self.app.auto_sync_to_farmos(obj, client=client, require=False)
 
     def get_farmos_entity_type(self):
         if self.farmos_entity_type:
@@ -168,24 +145,10 @@ class WuttaFarmMasterView(MasterView):
 
         # maybe delete from farmOS also
         if farmos_uuid:
+            entity_type = self.get_farmos_entity_type()
+            bundle = self.get_farmos_bundle()
             client = get_farmos_client_for_user(self.request)
-            # nb. must use separate thread to avoid some kind of race
-            # condition (?) - seems as though maybe a "boomerang"
-            # effect is happening; this seems to help anyway
-            thread = threading.Thread(
-                target=self.delete_from_farmos, args=(client, farmos_uuid)
-            )
-            thread.start()
-
-    def delete_from_farmos(self, client, farmos_uuid):
-        entity_type = self.get_farmos_entity_type()
-        bundle = self.get_farmos_bundle()
-        try:
             client.resource.delete(entity_type, bundle, farmos_uuid)
-        except requests.HTTPError as exc:
-            # ignore if record not found in farmOS
-            if exc.response.status_code != 404:
-                raise
 
 
 class TaxonomyMasterView(WuttaFarmMasterView):

src/wuttafarm/web/views/quick/eggs.py

@@ -24,8 +24,6 @@ Quick Form for "Eggs"
 """
 
 import json
-import threading
-import time
 
 import colander
 from deform.widget import SelectWidget
@@ -333,43 +331,13 @@ class EggsQuickForm(QuickFormView):
         session.flush()
 
         if self.app.is_farmos_mirror():
-            thread = threading.Thread(
+            if new_unit:
-                target=self.auto_sync_to_farmos,
+                self.app.auto_sync_to_farmos(unit, client=self.farmos_client)
-                args=(log.uuid, quantity.uuid, new_unit.uuid if new_unit else None),
+            self.app.auto_sync_to_farmos(quantity, client=self.farmos_client)
-            )
+            self.app.auto_sync_to_farmos(log, client=self.farmos_client)
-            thread.start()
 
         return log
 
-    def auto_sync_to_farmos(self, log_uuid, quantity_uuid, new_unit_uuid):
-        model = self.app.model
-
-        with self.app.short_session(commit=True) as session:
-            if user := session.query(model.User).filter_by(username="farmos").first():
-                session.info["continuum_user_id"] = user.uuid
-
-            if new_unit_uuid:
-                new_unit = None
-                while not new_unit:
-                    new_unit = session.get(model.Unit, new_unit_uuid)
-                    if not new_unit:
-                        time.sleep(0.1)
-                self.app.auto_sync_to_farmos(unit, client=self.farmos_client)
-
-            quantity = None
-            while not quantity:
-                quantity = session.get(model.StandardQuantity, quantity_uuid)
-                if not quantity:
-                    time.sleep(0.1)
-            self.app.auto_sync_to_farmos(quantity, client=self.farmos_client)
-
-            log = None
-            while not log:
-                log = session.get(model.HarvestLog, log_uuid)
-                if not log:
-                    time.sleep(0.1)
-            self.app.auto_sync_to_farmos(log, client=self.farmos_client)
-
     def redirect_after_save(self, log):
         model = self.app.model
 

src/wuttafarm/web/views/webhooks.py

@@ -1,96 +0,0 @@
-# -*- 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/>.
-#
-################################################################################
-"""
-Views for use as webhooks
-"""
-
-import logging
-from uuid import UUID
-
-from wuttaweb.views import View
-from wuttaweb.db import Session
-
-
-log = logging.getLogger(__name__)
-
-
-class WebhookView(View):
-    """
-    Webhook views
-    """
-
-    def farmos_webhook(self):
-        model = self.app.model
-        session = Session()
-
-        try:
-            data = self.request.json
-            log.debug("got webhook payload: %s", data)
-
-            _, entity_type, event_type = data["event"].split(":")
-
-            uuid = data["entity"]["uuid"][0]["value"]
-            if entity_type == "taxonomy_term":
-                bundle = data["entity"]["vid"][0]["target_id"]
-            else:
-                bundle = data["entity"]["type"][0]["target_id"]
-
-            change = model.WebhookChange(
-                entity_type=entity_type,
-                bundle=bundle,
-                farmos_uuid=UUID(uuid),
-                deleted=event_type == "delete",
-            )
-            session.add(change)
-
-        except:
-            log.exception("failed to process webhook request")
-
-        return {}
-
-    @classmethod
-    def defaults(cls, config):
-        cls._webhook_defaults(config)
-
-    @classmethod
-    def _webhook_defaults(cls, config):
-
-        # farmos webhook
-        config.add_route("webhooks.farmos", "/farmos/webhook", request_method="POST")
-        config.add_view(
-            cls,
-            attr="farmos_webhook",
-            route_name="webhooks.farmos",
-            require_csrf=False,
-            renderer="json",
-        )
-
-
-def defaults(config, **kwargs):
-    base = globals()
-
-    WebhookView = kwargs.get("WebhookView", base["WebhookView"])
-    WebhookView.defaults(config)
-
-
-def includeme(config):
-    defaults(config)