WuttaWeb 0.24.0__tar.gz → 0.25.1__tar.gz

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to wuttaweb 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.25.1 (2025-12-20)
+
+### Fix
+
+- add `WebDiff` class now that `Diff` lives in wuttjamaican
+- expose fallback key for email settings
+- expose transaction comment for version history
+- show display text for related objects, in version diff
+- discard non-declared field values for grid vue data
+- prevent error in DateTime schema type if no widget/request set
+
+## v0.25.0 (2025-12-17)
+
+### Feat
+
+- add "complete" (sic) timezone support
+
+### Fix
+
+- add local timezone awareness for datetime fields
+
 ## v0.24.0 (2025-12-15)
 
 ### Feat

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: WuttaWeb
-Version: 0.24.0
+Version: 0.25.1
 Summary: Web App for Wutta Framework
 Project-URL: Homepage, https://wuttaproject.org/
 Project-URL: Repository, https://forgejo.wuttaproject.org/wutta/wuttaweb
@@ -39,10 +39,10 @@ Requires-Dist: pyramid-tm
 Requires-Dist: pyramid>=2
 Requires-Dist: waitress
 Requires-Dist: webhelpers2
-Requires-Dist: wuttjamaican[db]>=0.25.0
+Requires-Dist: wuttjamaican[db]>=0.27.0
 Requires-Dist: zope-sqlalchemy>=1.5
 Provides-Extra: continuum
-Requires-Dist: wutta-continuum>=0.2.2; extra == 'continuum'
+Requires-Dist: wutta-continuum>=0.3.0; extra == 'continuum'
 Provides-Extra: docs
 Requires-Dist: furo; extra == 'docs'
 Requires-Dist: sphinx; extra == 'docs'

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "WuttaWeb"
-version = "0.24.0"
+version = "0.25.1"
 description = "Web App for Wutta Framework"
 readme = "README.md"
 authors = [{name = "Lance Edgar", email = "lance@wuttaproject.org"}]
@@ -44,13 +44,13 @@ dependencies = [
         "pyramid_tm",
         "waitress",
         "WebHelpers2",
-        "WuttJamaican[db]>=0.25.0",
+        "WuttJamaican[db]>=0.27.0",
         "zope.sqlalchemy>=1.5",
 ]
 
 
 [project.optional-dependencies]
-continuum = ["Wutta-Continuum>=0.2.2"]
+continuum = ["Wutta-Continuum>=0.3.0"]
 docs = ["Sphinx", "furo", "sphinxcontrib-programoutput"]
 tests = ["pylint", "pytest", "pytest-cov", "tox"]
 

wuttaweb-0.25.1/src/wuttaweb/diffs.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  wuttaweb -- Web App for Wutta Framework
+#  Copyright © 2024-2025 Lance Edgar
+#
+#  This file is part of Wutta Framework.
+#
+#  Wutta Framework 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.
+#
+#  Wutta Framework 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
+#  Wutta Framework.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Tools for displaying simple data diffs
+"""
+
+import sqlalchemy as sa
+
+from pyramid.renderers import render
+from webhelpers2.html import HTML
+
+from wuttjamaican.diffs import Diff
+
+
+class WebDiff(Diff):
+    """
+    Simple diff class for the web app.
+
+    This is based on the
+    :class:`~wuttjamaican:wuttjamaican.diffs.Diff` class; it just
+    tweaks :meth:`render_html()` to use the web template lookup
+    engine.
+    """
+
+    cell_padding = None
+
+    def render_html(self, template="/diff.mako", **kwargs):
+        """
+        Render the diff as HTML table.
+
+        :param template: Name of template to render, if you need to
+           override the default.
+
+        :param \\**kwargs: Remaining kwargs are passed as context to
+           the template renderer.
+
+        :returns: HTML literal string
+        """
+        context = kwargs
+        context["diff"] = self
+        html = render(template, context)
+        return HTML.literal(html)
+
+
+class VersionDiff(WebDiff):
+    """
+    Special diff class for use with version history views.  While
+    based on :class:`WebDiff`, this class uses a different signature
+    for the constructor.
+
+    :param config: The app :term:`config object`.
+
+    :param version: Reference to a Continuum version record object.
+
+    :param \\**kwargs: Remaining kwargs are passed as-is to the
+       :class:`WebDiff` constructor.
+    """
+
+    def __init__(self, config, version, **kwargs):
+        import sqlalchemy_continuum as continuum  # pylint: disable=import-outside-toplevel
+        from wutta_continuum.util import (  # pylint: disable=import-outside-toplevel
+            render_operation_type,
+        )
+
+        self.version = version
+        self.model_class = continuum.parent_class(type(self.version))
+        self.mapper = sa.inspect(self.model_class)
+        self.version_mapper = sa.inspect(type(self.version))
+        self.title = kwargs.pop("title", self.model_class.__name__)
+
+        self.operation_title = render_operation_type(self.version.operation_type)
+
+        if "nature" not in kwargs:
+            if (
+                version.previous
+                and version.operation_type == continuum.Operation.DELETE
+            ):
+                kwargs["nature"] = "delete"
+            elif version.previous:
+                kwargs["nature"] = "update"
+            else:
+                kwargs["nature"] = "create"
+
+        if "fields" not in kwargs:
+            kwargs["fields"] = self.get_default_fields()
+
+        old_data = {}
+        new_data = {}
+        for field in kwargs["fields"]:
+            if version.previous:
+                old_data[field] = getattr(version.previous, field)
+            new_data[field] = getattr(version, field)
+
+        super().__init__(config, old_data, new_data, **kwargs)
+
+    def get_default_fields(self):  # pylint: disable=missing-function-docstring
+        fields = sorted(self.version_mapper.columns.keys())
+
+        unwanted = [
+            "transaction_id",
+            "end_transaction_id",
+            "operation_type",
+        ]
+
+        return [field for field in fields if field not in unwanted]
+
+    def render_version_value(self, version, field, value):
+        """
+        Render the cell value HTML for a given version + field.
+
+        This method is used to render both sides of the diff (old +
+        new values).  It will just render the field value using a
+        monospace font by default.  However:
+
+        If the field is involved in a mapper relationship (i.e. it is
+        the "foreign key" to a related table), the logic here will
+        also (try to) traverse that show display text for the related
+        object (if found).
+
+        :param version: Reference to the Continuum version object.
+
+        :param field: Name of the field, as string.
+
+        :param value: Raw value for the field, as obtained from the
+           version object.
+
+        :returns: Rendered cell value as HTML literal
+        """
+        # first render normal span; this is our fallback but also may
+        # be embedded within a more complex result.
+        text = HTML.tag("span", c=[repr(value)], style="font-family: monospace;")
+
+        # loop thru all mapped relationship props
+        for prop in self.mapper.relationships:
+
+            # we only want singletons
+            if prop.uselist:
+                continue
+
+            # loop thru columns for prop
+            # nb. there should always be just one colum for a
+            # singleton prop, but technically a list is used, so no
+            # harm in looping i assume..
+            for col in prop.local_columns:
+
+                # we only want the matching column
+                if col.name != field:
+                    continue
+
+                # grab "related version" reference via prop key.  this
+                # would be like a UserVersion for instance.
+                if ref := getattr(version, prop.key):
+
+                    # grab "related object" reference.  this would be
+                    # like a User for instance.
+                    if ref := getattr(ref, "version_parent", None):
+
+                        # render text w/ related object as bold string
+                        style = (
+                            "margin-left: 2rem; font-style: italic; font-weight: bold;"
+                        )
+                        return HTML.tag(
+                            "span",
+                            c=[text, HTML.tag("span", c=[str(ref)], style=style)],
+                        )
+
+        return text
+
+    def render_old_value(self, field):
+        if self.nature == "create":
+            return ""
+        value = self.old_value(field)
+        return self.render_version_value(self.version.previous, field, value)
+
+    def render_new_value(self, field):
+        if self.nature == "delete":
+            return ""
+        value = self.new_value(field)
+        return self.render_version_value(self.version, field, value)

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/forms/schema.py

@@ -31,6 +31,7 @@ import colander
 import sqlalchemy as sa
 
 from wuttjamaican.conf import parse_list
+from wuttjamaican.util import localtime
 
 from wuttaweb.db import Session
 from wuttaweb.forms import widgets
@@ -38,20 +39,42 @@ from wuttaweb.forms import widgets
 
 class WuttaDateTime(colander.DateTime):
     """
-    Custom schema type for ``datetime`` fields.
+    Custom schema type for :class:`~python:datetime.datetime` fields.
 
     This should be used automatically for
-    :class:`sqlalchemy:sqlalchemy.types.DateTime` columns unless you
-    register another default.
+    :class:`~sqlalchemy:sqlalchemy.types.DateTime` ORM columns unless
+    you register another default.
 
     This schema type exists for sake of convenience, when working with
     the Buefy datepicker + timepicker widgets.
+
+    It also follows the datetime handling "rules" as outlined in
+    :doc:`wuttjamaican:narr/datetime`.  On the Python side, values
+    should be naive/UTC datetime objects.  On the HTTP side, values
+    will be ISO-format strings representing aware/local time.
     """
 
-    def deserialize(  # pylint: disable=inconsistent-return-statements,empty-docstring
+    def serialize(self, node, appstruct):
+        if not appstruct:
+            return colander.null
+
+        # nb. request should be present when it matters
+        if node.widget and node.widget.request:
+            request = node.widget.request
+            config = request.wutta_config
+            app = config.get_app()
+            appstruct = app.localtime(appstruct)
+        else:
+            # but if not, fallback to config-less logic
+            appstruct = localtime(appstruct)
+
+        if self.format:
+            return appstruct.strftime(self.format)
+        return appstruct.isoformat()
+
+    def deserialize(  # pylint: disable=inconsistent-return-statements
         self, node, cstruct
     ):
-        """ """
         if not cstruct:
             return colander.null
 
@@ -60,9 +83,17 @@ class WuttaDateTime(colander.DateTime):
             "%Y-%m-%dT%I:%M %p",
         ]
 
+        # nb. request is always assumed to be present here
+        request = node.widget.request
+        config = request.wutta_config
+        app = config.get_app()
+
         for fmt in formats:
             try:
-                return datetime.datetime.strptime(cstruct, fmt)
+                dt = datetime.datetime.strptime(cstruct, fmt)
+                if not dt.tzinfo:
+                    dt = app.localtime(dt, from_utc=False)
+                return app.make_utc(dt)
             except Exception:  # pylint: disable=broad-exception-caught
                 pass
 

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/forms/widgets.py

@@ -252,7 +252,9 @@ class WuttaDateTimeWidget(DateTimeInputWidget):
     def serialize(self, field, cstruct, **kw):  # pylint: disable=empty-docstring
         """ """
         readonly = kw.get("readonly", self.readonly)
-        if readonly and cstruct:
+        if readonly:
+            if not cstruct:
+                return ""
             dt = datetime.datetime.fromisoformat(cstruct)
             return self.app.render_datetime(dt)
 

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/grids/base.py

@@ -2390,6 +2390,9 @@ class Grid:  # pylint: disable=too-many-instance-attributes,too-many-public-meth
             # convert record to new dict
             record = self.object_to_dict(record)
 
+            # discard non-declared fields
+            record = {field: record[field] for field in record if field in self.columns}
+
             # make all values safe for json
             record = make_json_safe(record, warn=False)
 

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/templates/appinfo/configure.mako

@@ -48,6 +48,16 @@
       </b-checkbox>
     </b-field>
 
+    <b-field label="Time Zone"
+             :message="timezoneFieldMessage"
+             :type="timezoneFieldType">
+      <b-input name="${app.appname}.timezone.default"
+               v-model="simpleSettings['${app.appname}.timezone.default']"
+               ## TODO: ideally could use @change here but it does not work..?
+               ##@change="timezoneCheck()"
+               @input="timezoneCheck(); settingsNeedSaved = true" />
+    </b-field>
+
     <b-field label="Menu Handler">
       <input type="hidden"
              name="${app.appname}.web.menus.handler.spec"
@@ -270,6 +280,74 @@
 
     ThisPageData.menuHandlers = ${json.dumps(menu_handlers)|n}
 
+    ThisPageData.timezoneChecking = false
+    ThisPageData.timezoneInvalid = false
+    ThisPageData.timezoneError = false
+
+    ThisPage.computed.timezoneFieldMessage = function() {
+        if (this.timezoneChecking) {
+            return "Working, please wait..."
+        }
+        if (this.timezoneInvalid) {
+            return this.timezoneInvalid
+        }
+        if (this.timezoneError) {
+            return this.timezoneError
+        }
+        return "RESTART REQUIRED IF YOU CHANGE THIS.  The system (default) timezone is: ${default_timezone}"
+    }
+
+    ThisPage.computed.timezoneFieldType = function() {
+        if (this.timezoneChecking) {
+            return 'is-warning'
+        }
+        if (this.timezoneInvalid || this.timezoneError) {
+            return 'is-danger'
+        }
+    }
+
+    ThisPage.methods.timezoneCheck = function() {
+        if (this.timezoneChecking) {
+            return
+        }
+
+        this.timezoneError = false
+
+        if (!this.simpleSettings['${config.appname}.timezone.default']) {
+            this.timezoneInvalid = false
+
+        } else {
+            this.timezoneChecking = true
+            const url = '${url(f"{route_prefix}.check_timezone")}'
+            const params = {
+                tzname: this.simpleSettings['${config.appname}.timezone.default'],
+            }
+            this.wuttaGET(url, params, response => {
+                this.timezoneInvalid = response.data.invalid
+                this.timezoneChecking = false
+            }, response => {
+                this.timezoneError = response?.data?.error || "unknown error"
+                this.timezoneChecking = false
+            })
+        }
+    }
+
+    ThisPage.methods.timezoneValidate = function() {
+        if (this.timezoneChecking) {
+            return "Still checking time zone, please try again in a moment."
+        }
+
+        if (this.timezoneError) {
+            return "Error checking time zone!  Please reload page and try again."
+        }
+
+        if (this.timezoneInvalid) {
+            return "The time zone is invalid!"
+        }
+    }
+
+    ThisPageData.validators.push(ThisPage.methods.timezoneValidate)
+
     ThisPageData.weblibs = ${json.dumps(weblibs or [])|n}
 
     ThisPageData.editWebLibraryShowDialog = false

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/templates/appinfo/index.mako

@@ -19,6 +19,9 @@
         <b-field horizontal label="Node Title">
           <span>${app.get_node_title()}</span>
         </b-field>
+        <b-field horizontal label="Time Zone">
+          <span>${app.get_timezone_name()}</span>
+        </b-field>
         <b-field horizontal label="Production Mode">
           <span>${"Yes" if config.production() else "No"}</span>
         </b-field>

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/templates/master/view_version.mako

@@ -24,6 +24,10 @@
       <span>${transaction.id}</span>
     </b-field>
 
+    <b-field label="Comment" horizontal>
+      <span>${transaction.meta.get("comment", "")}</span>
+    </b-field>
+
   </div>
 
   <div style="padding: 2rem;">

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/views/email.py

@@ -63,6 +63,7 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
 
     form_fields = [
         "key",
+        "fallback_key",
         "description",
         "subject",
         "sender",
@@ -92,9 +93,11 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
     def normalize_setting(self, setting):  # pylint: disable=empty-docstring
         """ """
         key = setting.__name__
+        setting = setting(self.config)
         return {
             "key": key,
-            "description": setting.__doc__,
+            "fallback_key": setting.fallback_key or "",
+            "description": setting.get_description() or "",
             "subject": self.email_handler.get_auto_subject(
                 key, rendered=False, setting=setting
             ),
@@ -158,8 +161,12 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
         f = form
         super().configure_form(f)
 
+        # fallback_key
+        f.set_readonly("fallback_key")
+
         # description
         f.set_readonly("description")
+        f.set_widget("description", "notes")
 
         # replyto
         f.set_required("replyto", False)
@@ -247,11 +254,12 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
         if self.viewing:
             setting = context["instance"]
             context["setting"] = setting
+
             context["has_html_template"] = self.email_handler.get_auto_body_template(
-                setting["key"], "html"
+                setting["key"], "html", fallback_key=setting["fallback_key"]
             )
             context["has_txt_template"] = self.email_handler.get_auto_body_template(
-                setting["key"], "txt"
+                setting["key"], "txt", fallback_key=setting["fallback_key"]
             )
 
         return super().render_to_response(template, context)
@@ -269,11 +277,15 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
         mode = self.request.params.get("mode", "html")
 
         if mode == "txt":
-            body = self.email_handler.get_auto_txt_body(key, context)
+            body = self.email_handler.get_auto_txt_body(
+                key, context, fallback_key=setting.fallback_key
+            )
             self.request.response.content_type = "text/plain"
 
         else:  # html
-            body = self.email_handler.get_auto_html_body(key, context)
+            body = self.email_handler.get_auto_html_body(
+                key, context, fallback_key=setting.fallback_key
+            )
 
         self.request.response.text = body
         return self.request.response

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/views/master.py

@@ -1145,6 +1145,7 @@ class MasterView(View):  # pylint: disable=too-many-public-methods
             "issued_at",
             "user",
             "remote_addr",
+            "comment",
         ]
 
     def get_version_grid_data(self, instance):
@@ -1197,6 +1198,14 @@ class MasterView(View):  # pylint: disable=too-many-public-methods
         # remote_addr
         g.set_label("remote_addr", "IP Address")
 
+        # comment
+        g.set_renderer("comment", self.render_version_comment)
+
+    def render_version_comment(  # pylint: disable=missing-function-docstring,unused-argument
+        self, txn, key, value
+    ):
+        return txn.meta.get("comment", "")
+
     def view_version(self):  # pylint: disable=too-many-locals
         """
         View to show diff details for a particular object version.
@@ -1260,7 +1269,7 @@ class MasterView(View):  # pylint: disable=too-many-public-methods
             )
 
         version_diffs = [
-            VersionDiff(version)
+            VersionDiff(self.config, version)
             for version in self.get_relevant_versions(txn, instance)
         ]
 

{wuttaweb-0.24.0 → wuttaweb-0.25.1}/src/wuttaweb/views/settings.py

@@ -24,6 +24,7 @@
 Views for app settings
 """
 
+import datetime
 import json
 import os
 import sys
@@ -31,6 +32,7 @@ import subprocess
 from collections import OrderedDict
 
 from wuttjamaican.db.model import Setting
+from wuttjamaican.util import get_timezone_by_name
 from wuttaweb.views import MasterView
 from wuttaweb.util import get_libver, get_liburl
 
@@ -134,6 +136,7 @@ class AppInfoView(MasterView):  # pylint: disable=abstract-method
             {"name": f"{self.config.appname}.node_title"},
             {"name": f"{self.config.appname}.production", "type": bool},
             {"name": "wuttaweb.themes.expose_picker", "type": bool},
+            {"name": f"{self.config.appname}.timezone.default"},
             {"name": f"{self.config.appname}.web.menus.handler.spec"},
             # nb. this is deprecated; we define so it is auto-deleted
             # when we replace with newer setting
@@ -174,12 +177,31 @@ class AppInfoView(MasterView):  # pylint: disable=abstract-method
 
         return simple_settings
 
+    def configure_check_timezone(self):
+        """
+        AJAX view to validate a user-specified timezone name.
+
+        Route name for this is: ``appinfo.check_timezone``
+        """
+        tzname = self.request.GET.get("tzname")
+        if not tzname:
+            return {"invalid": "Must provide 'tzname' parameter."}
+        try:
+            get_timezone_by_name(tzname)
+            return {"invalid": False}
+        except Exception as err:  # pylint: disable=broad-exception-caught
+            return {"invalid": str(err)}
+
     def configure_get_context(  # pylint: disable=empty-docstring,arguments-differ
         self, **kwargs
     ):
         """ """
         context = super().configure_get_context(**kwargs)
 
+        # default system timezone
+        dt = datetime.datetime.now().astimezone()
+        context["default_timezone"] = dt.tzname()
+
         # add registered menu handlers
         web = self.app.get_web_handler()
         handlers = web.get_menu_handler_specs()
@@ -222,6 +244,32 @@ class AppInfoView(MasterView):  # pylint: disable=abstract-method
 
         return context
 
+    @classmethod
+    def defaults(cls, config):  # pylint: disable=empty-docstring
+        """ """
+        cls._defaults(config)
+        cls._appinfo_defaults(config)
+
+    @classmethod
+    def _appinfo_defaults(cls, config):
+        route_prefix = cls.get_route_prefix()
+        permission_prefix = cls.get_permission_prefix()
+        url_prefix = cls.get_url_prefix()
+
+        # check timezone
+        config.add_route(
+            f"{route_prefix}.check_timezone",
+            f"{url_prefix}/check-timezone",
+            request_method="GET",
+        )
+        config.add_view(
+            cls,
+            attr="configure_check_timezone",
+            route_name=f"{route_prefix}.check_timezone",
+            permission=f"{permission_prefix}.configure",
+            renderer="json",
+        )
+
 
 class SettingView(MasterView):  # pylint: disable=abstract-method
     """