WuttaWeb 0.20.5__tar.gz → 0.21.0__tar.gz

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/CHANGELOG.md

@@ -5,6 +5,28 @@ 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.21.0 (2025-02-01)
+
+### Feat
+
+- overhaul some User/Person form fields etc.
+
+### Fix
+
+- do not auto-create grid filters for uuid columns
+
+## v0.20.6 (2025-01-26)
+
+### Fix
+
+- add `setup_enhance_admin_user()` method for initial setup
+- add `render_percent()` method for Grid
+- allow override for Admin menu title
+- add `index_title_controls()` def block for base template
+- add `make_users_grid()` method for RoleView
+- fallback to empty string for uvicorn `root_path`
+- add `root_path` config setting for running webapp via uvicorn
+
 ## v0.20.5 (2025-01-23)
 
 ### Fix

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: WuttaWeb
-Version: 0.20.5
+Version: 0.21.0
 Summary: Web App for Wutta Framework
 Project-URL: Homepage, https://wuttaproject.org/
 Project-URL: Repository, https://forgejo.wuttaproject.org/wutta/wuttaweb
@@ -39,7 +39,7 @@ Requires-Dist: pyramid-tm
 Requires-Dist: pyramid>=2
 Requires-Dist: waitress
 Requires-Dist: webhelpers2
-Requires-Dist: wuttjamaican[db]>=0.20.2
+Requires-Dist: wuttjamaican[db]>=0.20.4
 Requires-Dist: zope-sqlalchemy>=1.5
 Provides-Extra: continuum
 Requires-Dist: wutta-continuum; extra == 'continuum'

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "WuttaWeb"
-version = "0.20.5"
+version = "0.21.0"
 description = "Web App for Wutta Framework"
 readme = "README.md"
 authors = [{name = "Lance Edgar", email = "lance@wuttaproject.org"}]
@@ -44,7 +44,7 @@ dependencies = [
         "pyramid_tm",
         "waitress",
         "WebHelpers2",
-        "WuttJamaican[db]>=0.20.2",
+        "WuttJamaican[db]>=0.20.4",
         "zope.sqlalchemy>=1.5",
 ]
 

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/cli/webapp.py

@@ -74,6 +74,7 @@ def webapp(
             'reload_dirs': config.get_list(f'{config.appname}.web.app.reload_dirs'),
             'factory': config.get_bool(f'{config.appname}.web.app.factory', default=False),
             'interface': config.get(f'{config.appname}.web.app.interface', default='auto'),
+            'root_path': config.get(f'{config.appname}.web.app.root_path', default=''),
         }
 
         # also must inject our config files to env, since there is no

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/forms/schema.py

@@ -572,28 +572,6 @@ class RoleRefs(WuttaSet):
         return widgets.RoleRefsWidget(self.request, **kwargs)
 
 
-class UserRefs(WuttaSet):
-    """
-    Form schema type for the Role
-    :attr:`~wuttjamaican:wuttjamaican.db.model.auth.Role.users`
-    association proxy field.
-
-    This is a subclass of :class:`WuttaSet`.  It uses a ``set`` of
-    :class:`~wuttjamaican:wuttjamaican.db.model.auth.User` ``uuid``
-    values for underlying data format.
-    """
-
-    def widget_maker(self, **kwargs):
-        """
-        Constructs a default widget for the field.
-
-        :returns: Instance of
-           :class:`~wuttaweb.forms.widgets.UserRefsWidget`.
-        """
-        kwargs.setdefault('session', Session())
-        return widgets.UserRefsWidget(self.request, **kwargs)
-
-
 class Permissions(WuttaSet):
     """
     Form schema type for the Role

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/forms/widgets.py

@@ -56,7 +56,6 @@ from webhelpers2.html import HTML
 from wuttjamaican.conf import parse_list
 
 from wuttaweb.db import Session
-from wuttaweb.grids import Grid
 
 
 class ObjectRefWidget(SelectWidget):
@@ -414,63 +413,6 @@ class RoleRefsWidget(WuttaCheckboxChoiceWidget):
         return super().serialize(field, cstruct, **kw)
 
 
-class UserRefsWidget(WuttaCheckboxChoiceWidget):
-    """
-    Widget for use with Role
-    :attr:`~wuttjamaican:wuttjamaican.db.model.auth.Role.users` field.
-    This is the default widget for the
-    :class:`~wuttaweb.forms.schema.UserRefs` type.
-
-    This is a subclass of :class:`WuttaCheckboxChoiceWidget`; however
-    it only supports readonly mode and does not use a template.
-    Rather, it generates and renders a
-    :class:`~wuttaweb.grids.base.Grid` showing the users list.
-    """
-
-    def serialize(self, field, cstruct, **kw):
-        """ """
-        readonly = kw.get('readonly', self.readonly)
-        if not readonly:
-            raise NotImplementedError("edit not allowed for this widget")
-
-        model = self.app.model
-        columns = ['username', 'active']
-
-        # generate data set for users
-        users = []
-        if cstruct:
-            for uuid in cstruct:
-                user = self.session.get(model.User, uuid)
-                if user:
-                    users.append(dict([(key, getattr(user, key))
-                                       for key in columns + ['uuid']]))
-
-        # do not render if no data
-        if not users:
-            return HTML.tag('span')
-
-        # grid
-        grid = Grid(self.request, key='roles.view.users',
-                    columns=columns, data=users)
-
-        # view action
-        if self.request.has_perm('users.view'):
-            url = lambda user, i: self.request.route_url('users.view', uuid=user['uuid'])
-            grid.add_action('view', icon='eye', url=url)
-            grid.set_link('person')
-            grid.set_link('username')
-
-        # edit action
-        if self.request.has_perm('users.edit'):
-            url = lambda user, i: self.request.route_url('users.edit', uuid=user['uuid'])
-            grid.add_action('edit', url=url)
-
-        # render as simple <b-table>
-        # nb. must indicate we are a part of this form
-        form = getattr(field.parent, 'wutta_form', None)
-        return grid.render_table_element(form)
-
-
 class PermissionsWidget(WuttaCheckboxChoiceWidget):
     """
     Widget for use with Role

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/grids/base.py

@@ -41,6 +41,7 @@ from webhelpers2.html import HTML
 from wuttaweb.db import Session
 from wuttaweb.util import FieldList, get_model_fields, make_json_safe
 from wuttjamaican.util import UNSPECIFIED
+from wuttjamaican.db.util import UUID
 from wuttaweb.grids.filters import default_sqlalchemy_filters, VerbNotSupported
 
 
@@ -612,6 +613,7 @@ class Grid:
         * ``'date'`` -> :meth:`render_date()`
         * ``'datetime'`` -> :meth:`render_datetime()`
         * ``'quantity'`` -> :meth:`render_quantity()`
+        * ``'percent'`` -> :meth:`render_percent()`
 
         Renderer overrides are tracked via :attr:`renderers`.
         """
@@ -622,6 +624,7 @@ class Grid:
             'date': self.render_date,
             'datetime': self.render_datetime,
             'quantity': self.render_quantity,
+            'percent': self.render_percent,
         }
 
         if renderer in builtins:
@@ -1134,14 +1137,15 @@ class Grid:
 
     def make_backend_filters(self, filters=None):
         """
-        Make backend filters for all columns in the grid.
+        Make "automatic" backend filters for the grid.
 
         This is called by the constructor, if :attr:`filterable` is
         true.
 
-        For each column in the grid, this checks the provided
-        ``filters`` and if the column is not yet in there, will call
-        :meth:`make_filter()` to add it.
+        For each "column" in the model class, this will call
+        :meth:`make_filter()` to add an automatic filter.  However it
+        first checks the provided ``filters`` and will not override
+        any of those.
 
         .. note::
 
@@ -1179,9 +1183,18 @@ class Grid:
 
             inspector = sa.inspect(self.model_class)
             for prop in inspector.column_attrs:
-                if prop.key not in filters:
-                    attr = getattr(self.model_class, prop.key)
-                    filters[prop.key] = self.make_filter(attr)
+
+                # do not overwrite existing filters
+                if prop.key in filters:
+                    continue
+
+                # do not create filter for UUID field
+                if (len(prop.columns) == 1
+                    and isinstance(prop.columns[0].type, UUID)):
+                    continue
+
+                attr = getattr(self.model_class, prop.key)
+                filters[prop.key] = self.make_filter(attr)
 
         return filters
 
@@ -1884,6 +1897,20 @@ class Grid:
         dt = getattr(obj, key)
         return self.app.render_datetime(dt)
 
+    def render_percent(self, obj, key, value, **kwargs):
+        """
+        Column renderer for percentage values.
+
+        This calls
+        :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_percent()`
+        for the return value.
+
+        This is not used automatically but you can use it explicitly::
+
+            grid.set_renderer('foo', 'percent')
+        """
+        return self.app.render_percent(value, **kwargs)
+
     def render_quantity(self, obj, key, value):
         """
         Column renderer for quantity values.

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/menus.py

@@ -143,6 +143,8 @@ class MenuHandler(GenericHandler):
         which will ultimately be one element of the final list of
         dicts as described in :class:`MenuHandler`.
 
+        :param title: Override the menu title; default is "Admin".
+
         :param include_people: You can pass this flag to indicate the
            admin menu should contain an entry for the "People" view.
         """
@@ -198,7 +200,7 @@ class MenuHandler(GenericHandler):
         ])
 
         return {
-            'title': "Admin",
+            'title': kwargs.get('title', "Admin"),
             'type': 'menu',
             'items': items,
         }

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/templates/base.mako

@@ -248,12 +248,7 @@
                     % else:
                         <h1 class="title">${index_title}</h1>
                     % endif
-                    % if master and master.creatable and not master.creating and master.has_perm('create'):
-                        <wutta-button once type="is-primary"
-                                      tag="a" href="${url(f'{route_prefix}.create')}"
-                                      icon-left="plus"
-                                      label="Create New" />
-                    % endif
+                    ${self.index_title_controls()}
                 % endif
               </div>
             </div>
@@ -349,6 +344,15 @@
       </footer>
 </%def>
 
+<%def name="index_title_controls()">
+  % if master and master.creatable and not master.creating and master.has_perm('create'):
+      <wutta-button once type="is-primary"
+                    tag="a" href="${url(f'{route_prefix}.create')}"
+                    icon-left="plus"
+                    label="Create New" />
+  % endif
+</%def>
+
 <%def name="render_vue_template_whole_page()">
   <script type="text/x-template" id="whole-page-template">
 

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/views/common.py

@@ -245,6 +245,8 @@ class CommonView(View):
                 session.add(person)
                 user.person = person
 
+            self.setup_enhance_admin_user(user)
+
             # send user to /login
             self.request.session.flash("Account created! Please login below.")
             return self.redirect(self.request.route_url('login'))
@@ -254,6 +256,17 @@ class CommonView(View):
             'form': form,
         }
 
+    def setup_enhance_admin_user(self, user):
+        """
+        Further "enhance" the initial admin user when it is first created.
+
+        This does nothing by default; subclass can override if needed.
+
+        :param user: New admin
+           :class:`~wuttjamaican:wuttjamaican.db.model.auth.User`
+           which was just created as part of initial setup.
+        """
+
     @classmethod
     def defaults(cls, config):
         cls._defaults(config)

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/views/people.py

@@ -28,7 +28,6 @@ import sqlalchemy as sa
 
 from wuttjamaican.db.model import Person
 from wuttaweb.views import MasterView
-from wuttaweb.forms.schema import UserRefs
 
 
 class PersonView(MasterView):
@@ -62,6 +61,14 @@ class PersonView(MasterView):
         'full_name': {'active': True},
     }
 
+    form_fields = [
+        'full_name',
+        'first_name',
+        'middle_name',
+        'last_name',
+        'users',
+    ]
+
     def configure_grid(self, g):
         """ """
         super().configure_grid(g)
@@ -80,20 +87,54 @@ class PersonView(MasterView):
         super().configure_form(f)
         person = f.model_instance
 
-        # TODO: master should handle these? (nullable column)
-        f.set_required('first_name', False)
-        f.set_required('middle_name', False)
-        f.set_required('last_name', False)
+        # full_name
+        if self.creating or self.editing:
+            f.remove('full_name')
 
         # users
-        # nb. colanderalchemy wants to do some magic for the true
-        # 'users' relationship, so we use a different field name
-        f.remove('users')
-        if not (self.creating or self.editing):
-            f.append('_users')
-            f.set_readonly('_users')
-            f.set_node('_users', UserRefs(self.request))
-            f.set_default('_users', [u.uuid for u in person.users])
+        if self.viewing:
+            f.set_grid('users', self.make_users_grid(person))
+
+    def make_users_grid(self, person):
+        """
+        Make and return the grid for the Users field.
+
+        This grid is shown for the Users field when viewing a Person.
+
+        :returns: Fully configured :class:`~wuttaweb.grids.base.Grid`
+           instance.
+        """
+        model = self.app.model
+        route_prefix = self.get_route_prefix()
+
+        grid = self.make_grid(key=f'{route_prefix}.view.users',
+                              model_class=model.User,
+                              data=person.users,
+                              columns=[
+                                  'username',
+                                  'active',
+                              ])
+
+        if self.request.has_perm('users.view'):
+            url = lambda user, i: self.request.route_url('users.view', uuid=user.uuid)
+            grid.add_action('view', icon='eye', url=url)
+            grid.set_link('username')
+
+        if self.request.has_perm('users.edit'):
+            url = lambda user, i: self.request.route_url('users.edit', uuid=user.uuid)
+            grid.add_action('edit', url=url)
+
+        return grid
+
+    def objectify(self, form):
+        """ """
+        person = super().objectify(form)
+
+        # full_name
+        person.full_name = self.app.make_full_name(person.first_name,
+                                                   person.last_name)
+
+        return person
 
     def autocomplete_query(self, term):
         """ """

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/views/roles.py

@@ -28,7 +28,7 @@ from wuttjamaican.db.model import Role, Permission
 from wuttaweb.views import MasterView
 from wuttaweb.db import Session
 from wuttaweb.forms import widgets
-from wuttaweb.forms.schema import UserRefs, Permissions, RoleRef
+from wuttaweb.forms.schema import Permissions, RoleRef
 
 
 class RoleView(MasterView):
@@ -123,9 +123,7 @@ class RoleView(MasterView):
         # users
         if not (self.creating or self.editing):
             f.append('users')
-            f.set_readonly('users')
-            f.set_node('users', UserRefs(self.request))
-            f.set_default('users', [u.uuid for u in role.users])
+            f.set_grid('users', self.make_users_grid(role))
 
         # permissions
         f.append('permissions')
@@ -134,6 +132,39 @@ class RoleView(MasterView):
         if not self.creating:
             f.set_default('permissions', list(role.permissions))
 
+    def make_users_grid(self, role):
+        """
+        Make and return the grid for the Users field.
+
+        This grid is shown for the Users field when viewing a Role.
+
+        :returns: Fully configured :class:`~wuttaweb.grids.base.Grid`
+           instance.
+        """
+        model = self.app.model
+        route_prefix = self.get_route_prefix()
+
+        grid = self.make_grid(key=f'{route_prefix}.view.users',
+                              model_class=model.User,
+                              data=role.users,
+                              columns=[
+                                  'username',
+                                  'person',
+                                  'active',
+                              ])
+
+        if self.request.has_perm('users.view'):
+            url = lambda user, i: self.request.route_url('users.view', uuid=user.uuid)
+            grid.add_action('view', icon='eye', url=url)
+            grid.set_link('person')
+            grid.set_link('username')
+
+        if self.request.has_perm('users.edit'):
+            url = lambda user, i: self.request.route_url('users.edit', uuid=user.uuid)
+            grid.add_action('edit', url=url)
+
+        return grid
+
     def unique_name(self, node, value):
         """ """
         model = self.app.model

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/src/wuttaweb/views/users.py

@@ -2,7 +2,7 @@
 ################################################################################
 #
 #  wuttaweb -- Web App for Wutta Framework
-#  Copyright © 2024 Lance Edgar
+#  Copyright © 2024-2025 Lance Edgar
 #
 #  This file is part of Wutta Framework.
 #
@@ -30,7 +30,6 @@ from wuttjamaican.db.model import User
 from wuttaweb.views import MasterView
 from wuttaweb.forms import widgets
 from wuttaweb.forms.schema import PersonRef, RoleRefs
-from wuttaweb.db import Session
 
 
 class UserView(MasterView):
@@ -61,6 +60,14 @@ class UserView(MasterView):
     }
     sort_defaults = 'username'
 
+    form_fields = [
+        'username',
+        'person',
+        'active',
+        'prevent_edit',
+        'roles',
+    ]
+
     def get_query(self, session=None):
         """ """
         query = super().get_query(session=session)
@@ -109,17 +116,24 @@ class UserView(MasterView):
         super().configure_form(f)
         user = f.model_instance
 
-        # never show these
-        f.remove('person_uuid',
-                 'role_refs')
-
-        # person
-        f.set_node('person', PersonRef(self.request, empty_option=True))
-        f.set_required('person', False)
-
         # username
         f.set_validator('username', self.unique_username)
 
+        # person
+        if self.creating or self.editing:
+            f.fields.insert_after('person', 'first_name')
+            f.set_required('first_name', False)
+            f.fields.insert_after('first_name', 'last_name')
+            f.set_required('last_name', False)
+            f.remove('person')
+            if self.editing:
+                person = user.person
+                if person:
+                    f.set_default('first_name', person.first_name)
+                    f.set_default('last_name', person.last_name)
+        else:
+            f.set_node('person', PersonRef(self.request))
+
         # password
         # nb. we must avoid 'password' as field name since
         # ColanderAlchemy wants to handle the raw/hashed value
@@ -140,7 +154,7 @@ class UserView(MasterView):
     def unique_username(self, node, value):
         """ """
         model = self.app.model
-        session = Session()
+        session = self.Session()
 
         query = session.query(model.User)\
                        .filter(model.User.username == value)
@@ -152,26 +166,48 @@ class UserView(MasterView):
         if query.count():
             node.raise_invalid("Username must be unique")
 
-    def objectify(self, form, session=None):
+    def objectify(self, form):
         """ """
+        model = self.app.model
+        auth = self.app.get_auth_handler()
         data = form.validated
 
         # normal logic first
         user = super().objectify(form)
 
+        # maybe update person name
+        if 'first_name' in form or 'last_name' in form:
+            first_name = data.get('first_name')
+            last_name = data.get('last_name')
+            if self.creating and (first_name or last_name):
+                user.person = auth.make_person(first_name=first_name, last_name=last_name)
+            elif self.editing:
+                if first_name or last_name:
+                    if user.person:
+                        person = user.person
+                        if 'first_name' in form:
+                            person.first_name = first_name
+                        if 'last_name' in form:
+                            person.last_name = last_name
+                        person.full_name = self.app.make_full_name(person.first_name,
+                                                                   person.last_name)
+                    else:
+                        user.person = auth.make_person(first_name=first_name, last_name=last_name)
+                elif user.person:
+                    user.person = None
+
         # maybe set user password
         if 'set_password' in form and data.get('set_password'):
-            auth = self.app.get_auth_handler()
             auth.set_user_password(user, data['set_password'])
 
         # update roles for user
         # TODO
         # if self.has_perm('edit_roles'):
-        self.update_roles(user, form, session=session)
+        self.update_roles(user, form)
 
         return user
 
-    def update_roles(self, user, form, session=None):
+    def update_roles(self, user, form):
         """ """
         # TODO
         # if not self.has_perm('edit_roles'):
@@ -181,7 +217,7 @@ class UserView(MasterView):
             return
 
         model = self.app.model
-        session = session or Session()
+        session = self.Session()
         auth = self.app.get_auth_handler()
 
         old_roles = set([role.uuid for role in user.roles])

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/tests/cli/test_webapp.py

@@ -88,7 +88,8 @@ app.spec = wuttaweb.app:make_wsgi_app
                                                 reload=False,
                                                 reload_dirs=None,
                                                 factory=False,
-                                                interface='auto')
+                                                interface='auto',
+                                                root_path='')
 
         # with reload
         uvicorn.run.reset_mock()
@@ -101,4 +102,5 @@ app.spec = wuttaweb.app:make_wsgi_app
                                                 reload=True,
                                                 reload_dirs=None,
                                                 factory=False,
-                                                interface='auto')
+                                                interface='auto',
+                                                root_path='')

{wuttaweb-0.20.5 → wuttaweb-0.21.0}/tests/forms/test_schema.py

@@ -377,20 +377,6 @@ class TestUserRef(WebTestCase):
             self.assertIn(f'/users/{user.uuid}', url)
 
 
-class TestUserRefs(DataTestCase):
-
-    def setUp(self):
-        self.setup_db()
-        self.request = testing.DummyRequest(wutta_config=self.config)
-
-    def test_widget_maker(self):
-        model = self.app.model
-        with patch.object(mod, 'Session', return_value=self.session):
-            typ = mod.UserRefs(self.request)
-            widget = typ.widget_maker()
-            self.assertIsInstance(widget, widgets.UserRefsWidget)
-
-
 class TestRoleRefs(DataTestCase):
 
     def setUp(self):