lino 25.5.2__py3-none-any.whl → 25.5.3__py3-none-any.whl

lino/core/actors.py

@@ -16,7 +16,7 @@ from inspect import getmro
 from django.db import models
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _
-from django.utils.html import format_html, mark_safe, SafeString
+from django.utils.html import format_html, mark_safe
 
 from lino import logger
 from lino.utils import MissingRow
@@ -27,6 +27,9 @@ from lino.core import constants
 from lino.core.boundaction import BoundAction
 from lino.core.exceptions import ChangedAPI
 from lino.core.constants import _handle_attr_name
+from lino.core.utils import Parametrizable, install_layout, resolve_layout
+# from lino.core.fields import setup_params_choosers
+from lino.core.utils import make_params_layout_handle, register_params
 from lino.core.permissions import add_requirements, Permittable
 from lino.core.utils import resolve_model
 from lino.core.utils import error2str
@@ -43,14 +46,6 @@ ACTOR_SEP = "."
 DIVTPL = '<div class="htmlText">{}</div>'
 btn_sep = mark_safe(" ")
 
-# The well-known standard actions are described by (usually) always a same
-# action instance.
-
-SUBMIT_DETAIL = actions.SubmitDetail()
-DELETE_ACTION = actions.DeleteSelected()
-# INSERT_ACTION = actions.ShowInsert()
-UPDATE_ACTION = actions.SaveGridCell()
-VALIDATE_FORM = actions.ValidateForm()
 
 # actors are automatically discovered at startup.
 
@@ -102,6 +97,14 @@ def register_actor(a):
             return
     old = actors_dict.define(a.app_label, a.__name__, a)
     if old is not None:
+        # For example lino_voga.lib.courses.EnrolmentsByCourse replaces class of
+        # same name from lino_xl
+        # print(f"20250523 {repr(a)} replaces {repr(old)} ({old.abstract} {a.abstract})")
+        # if not issubclass(a, old):
+        #     raise Exception(f"20250523 {a} is not subclass of {old}")
+        # if not a.abstract:
+        #     old.abstract = True
+        #     a.abstract = False
         i = actors_list.index(old)
         actors_list[i] = a
         # actors_list.remove(old)
@@ -150,7 +153,7 @@ class ActorMetaClass(type):
         if declared_editable is not None:
             classDict.update(_editable=declared_editable)
 
-        if (pk := classDict.get("default_record_id", None)) is not None:
+        if classDict.get("default_record_id", None) is not None:
             classDict.update(hide_navigator=True)
             classDict.update(allow_create=False)
             classDict.update(allow_delete=False)
@@ -184,6 +187,8 @@ class ActorMetaClass(type):
 
         if actor_classes is not None:
             actor_classes.append(cls)
+        # else:
+        #     print(f"20250523 found {cls} but actor_classes is None")
         return cls
 
     def __str__(cls):
@@ -208,7 +213,7 @@ class ActorMetaClass(type):
 
 
 # class Actor(metaclass=ActorMetaClass, type('NewBase', (actions.Parametrizable, Permittable), {}))):
-class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
+class Actor(Parametrizable, Permittable, metaclass=ActorMetaClass):
     """
     The base class for all actors (:term:`data table`).  Subclassed by
     :class:`AbstractTable <lino.core.tables.AbstractTable>`, :class:`Table
@@ -255,7 +260,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         the user has permission to view the actor or not.
     """
 
-    _detail_action_class = actions.ShowDetail
+    _detail_action_class = None
 
     obvious_fields = set()
     """A set of names of fields that are considered :term:`obvious field`.  """
@@ -337,8 +342,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     Special cases: :class:`lino_xl.lib.cal.EntriesByGuest` shows the entries
     having a presence pointing to this guest.
 
-    Note that the :attr:`master_key` is automatically added to
-    :attr:`hidden_columns`.
+    The :attr:`master_key` is automatically added to :attr:`hidden_columns`.
 
 
     """
@@ -348,7 +352,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     parameters = None
     # See :attr:`lino.core.utils.Parametrizable.parameters`.
 
-    _params_layout_class = layouts.ParamsLayout
+    _params_layout_class = None
     _state_to_disabled_actions = None
 
     ignore_required_states = False
@@ -712,8 +716,8 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     @classmethod
     def make_params_layout_handle(cls):
         if cls.is_abstract():
-            raise Exception("{} is abstract".format(cls))
-        return actions.make_params_layout_handle(cls)
+            raise Exception(f"{repr(cls)} is abstract")
+        return make_params_layout_handle(cls)
 
     @classmethod
     def is_abstract(cls):
@@ -815,6 +819,8 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                 edm.add(constants.DISPLAY_MODE_LIST)
             if 'as_page' in model.__dict__:
                 edm.add(constants.DISPLAY_MODE_STORY)
+            if 'as_tile' in model.__dict__:
+                edm.add(constants.DISPLAY_MODE_TILES)
             # no need to automatically add summary because it's in default_display_modes of every table
             # if 'as_summary_item' in model.__dict__:
             #     edm.add(constants.DISPLAY_MODE_SUMMARY)
@@ -828,19 +834,19 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         # 20200430 this was previously part of class_init, but is now called in
         # a second loop. Because calview.EventsParams copies parameters from Events.
 
-        actions.install_layout(cls, "detail_layout", layouts.DetailLayout)
-        actions.install_layout(
+        install_layout(cls, "detail_layout", layouts.DetailLayout)
+        install_layout(
             cls,
             "insert_layout",
             layouts.InsertLayout,
             window_size=(cls.insert_layout_width, "auto"),
         )
-        actions.install_layout(cls, "card_layout", layouts.DetailLayout)
+        install_layout(cls, "card_layout", layouts.DetailLayout)
         # actions.install_layout(cls, "list_layout", layouts.DetailLayout)
 
         cls.extra_layouts = dict()
         for name, main in cls.get_extra_layouts():
-            layout_instance = actions.resolve_layout(
+            layout_instance = resolve_layout(
                 cls, "extra_layout", main, layouts.DetailLayout
             )
             cls.extra_layouts.update({name: layout_instance})
@@ -1079,7 +1085,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
             #     logger.info("20181230 %r detail_action is %r", cls, cls.detail_action)
             if cls.editable:
                 cls.submit_detail = cls._bind_action(
-                    "submit_detail", SUBMIT_DETAIL, True
+                    "submit_detail", actions.SUBMIT_DETAIL, True
                 )
 
         # avoid inheriting the following actions from parent:
@@ -1099,13 +1105,13 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                     )
             if cls.allow_delete:
                 cls.delete_action = cls._bind_action(
-                    "delete_action", DELETE_ACTION, True
+                    "delete_action", actions.DELETE_ACTION, True
                 )
             cls.update_action = cls._bind_action(
-                "update_action", UPDATE_ACTION, True)
+                "update_action", actions.UPDATE_ACTION, True)
             if cls.detail_layout:
                 cls.validate_form = cls._bind_action(
-                    "validate_form", VALIDATE_FORM, True
+                    "validate_form", actions.VALIDATE_FORM, True
                 )
 
         if is_string(cls.workflow_owner_field):
@@ -1505,14 +1511,14 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                     name = "main"
                 if name in kw:
                     raise Exception(
-                        "set_detail() got two definitions for %r." % name)
+                        "set_form_layout() got two definitions for %r." % name)
                 kw[name] = dtl
             else:
                 if not isinstance(dtl, lcl):
-                    msg = "{} is neither a string nor a layout".format(
-                        type(dtl))
+                    msg = f"{repr(dtl)} is neither a string nor a layout"
                     raise Exception(msg)
                 assert dtl._datasource is None
+
                 # added for 20120914c but it wasn't the problem
                 # if existing and not isinstance(existing, string_types):
                 if existing and not is_string(existing):
@@ -1536,8 +1542,19 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                     dtl._element_options.update(existing._element_options)
                 dtl._datasource = self
                 setattr(self, attname, dtl)
-        if kw:
-            getattr(self, attname).update(**kw)
+
+            # The following tests added for :ref:`book.changes.20250523`:
+            if (kernel := settings.SITE.kernel) is not None:
+                if (front_end := kernel.editing_front_end) is not None:
+                    hname = front_end.ui_handle_attr_name
+                    # we do not want any inherited handle
+                    h = existing.__dict__.get(hname, None)
+                    if h is not None:
+                        raise Exception(
+                            f"{existing} has already a layout handle {h.ui}")
+
+            if kw:
+                getattr(self, attname).update(**kw)
 
     @classmethod
     def add_detail_panel(self, *args, **kw):
@@ -1606,6 +1623,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
 
     @classmethod
     def after_site_setup(cls, site):
+        # print(f"20250523 after_site_setup {cls}")
         self = cls
         # ~ raise "20100616"
         # ~ assert not self._setup_done, "%s.setup() called again" % self
@@ -1627,11 +1645,14 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                 # settings.SITE.register_virtual_field(vf)
 
         if not self.is_abstract():
-            actions.register_params(self)
+            register_params(self)
+            if self.parameters is not None:
+                assert isinstance(self.params_layout, self._params_layout_class)
+                # print(f"20250523 params_layout ok for {repr(self)}")
             self._collect_actions()
 
         if not self.is_abstract():
-            actions.setup_params_choosers(self)
+            fields.setup_params_choosers(self)
 
         # ~ logger.info("20130906 Gonna Actor.do_setup() on %s", self)
         self.do_setup()
@@ -1952,6 +1973,19 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         # assert_safe(html_text)  # temporary 20240506
         return format_html(DIVTPL, html_text)
 
+    @classmethod
+    def get_table_as_tiles(cls, obj, ar):
+        sar = cls.create_request(parent=ar, master_instance=obj,
+                                 is_on_main_actor=False)
+        html = SAFE_EMPTY
+        for i, obj in enumerate(sar.data_iterator):
+            if i == cls.preview_limit:
+                break
+            s = obj.as_story_item(sar)
+            # assert_safe(s)  # temporary 20240506
+            html += s
+        return html
+
     @classmethod
     def get_table_story(cls, obj, ar):
         sar = cls.create_request(parent=ar, master_instance=obj,

lino/core/atomizer.py

@@ -0,0 +1,355 @@
+# Copyright 2009-2026 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+from django.db import models
+from django.conf import settings
+
+from lino import logger
+from lino.utils import curry
+from lino.utils import choosers
+from lino.core import store
+from lino.core import actors
+from lino.core import fields
+from lino.core.utils import resolve_model
+
+
+def make_remote_field(model, name):
+    parts = name.split("__")
+    if len(parts) == 1:
+        return
+    # It's going to be a RemoteField
+    # logger.warning("20151203 RemoteField %s in %s", name, cls)
+
+    cls = model
+    field_chain = []
+    editable = False
+    gettable = True
+    leaf_chooser = None
+    for n in parts:
+        if model is None:
+            return
+            # raise Exception(
+            #     "Invalid remote field {0} for {1}".format(name, cls))
+
+        if isinstance(model, str):
+            # Django 1.9 no longer resolves the
+            # rel.model of ForeignKeys on abstract
+            # models, so we do it here.
+            model = resolve_model(model)
+            # logger.warning("20151203 %s", model)
+
+        fld = model.get_data_elem(n)
+        if fld is None:
+            return
+            # raise Exception(
+            #     "Invalid RemoteField %s.%s (no field %s in %s)" %
+            #     (full_model_name(model), name, n, full_model_name(model)))
+
+        if isinstance(fld, fields.DummyField):
+            # a remote field containing at least one dummy field is itself a
+            # dummy field
+            return fld
+
+        # Why was this? it caused docs/specs/avanti/courses.rst to fail
+        # if isinstance(fld, models.ManyToOneRel):
+        #     gettable = False
+
+        # make sure that the atomizer gets created.
+        get_atomizer(model, fld, fld.name)
+
+        if isinstance(fld, fields.VirtualField):
+            fld.lino_resolve_type()
+        leaf_chooser = choosers.check_for_chooser(model, fld)
+
+        field_chain.append(fld)
+        if isinstance(
+            fld, (models.OneToOneRel, models.OneToOneField, models.ForeignKey)
+        ):
+            editable = True
+        if getattr(fld, "remote_field", None):
+            model = fld.remote_field.model
+        else:
+            model = None
+
+    # if not gettable:
+    #     # raise Exception("20231112")
+    #     return RemoteField(none_getter, name, fld)
+
+    if leaf_chooser is not None:
+        d = choosers.get_choosers_dict(cls)
+        d[name] = leaf_chooser
+
+    def getter(obj, ar=None):
+        try:
+            for fld in field_chain:
+                if obj is None:
+                    return None
+                obj = fld._lino_atomizer.full_value_from_object(obj, ar)
+            return obj
+        except Exception as e:
+            # raise
+            msg = "Error while computing {}: {} ({} in {})"
+            raise Exception(msg.format(name, e, fld, field_chain))
+            # ~ if False: # only for debugging
+            if True:  # see 20130802
+                logger.exception(e)
+                return str(e)
+            return None
+
+    if not editable:
+        rf = fields.RemoteField(getter, name, fld)
+        # choosers.check_for_chooser(model, rf)
+        return rf
+
+    def setter(obj, value):
+        # logger.info("20180712 %s setter() %s", name, value)
+        # all intermediate fields are OneToOneRel
+        target = obj
+        try:
+            for i, fld in enumerate(field_chain):
+                # print("20180712a %s" % fld)
+                if isinstance(fld, (models.OneToOneRel, models.ForeignKey)):
+                    reltarget = getattr(target, fld.name, None)
+                    if reltarget is None:
+                        rkw = {fld.field.name: target}
+                        # print(
+                        #     "20180712 create {}({})".format(
+                        #         fld.related_model, rkw))
+                        reltarget = fld.related_model(**rkw)
+                        reltarget.save_new_instance(
+                            fld.related_model.get_default_table().create_request()
+                        )
+
+                    setattr(target, fld.name, reltarget)
+
+                    if target == obj and target.id is None:
+                        # Model.save_new_instance will be called do not insert this record.
+                        target = reltarget
+                        continue
+                    target.full_clean()
+                    target.save()
+                    # print("20180712b {}.{} = {}".format(
+                    #     target, fld.name, reltarget))
+                    target = reltarget
+                else:
+                    setattr(target, fld.name, value)
+                    target.full_clean()
+                    target.save()
+                    # print(
+                    #     "20180712c setattr({},{},{}".format(
+                    #         target, fld.name, value))
+                    return True
+        except Exception as e:
+            if False:  # only for debugging
+                logger.exception(e)
+                return str(e)
+            raise e.__class__("Error while setting %s: %s" % (name, e))
+            return False
+
+    rf = fields.RemoteField(getter, name, fld, setter)
+    # choosers.check_for_chooser(model, rf)
+    return rf
+
+
+def create_atomizer(holder, fld, name):
+    """
+    The holder is where the (potential) choices come from. It can be
+    a model, an actor or an action. `fld` is a data element.
+    """
+    if name is None:
+        # print("20181023 create_atomizer() no name {}".format(fld))
+        return
+        # raise Exception("20181023 create_atomizer() {}".format(fld))
+    if isinstance(fld, fields.RemoteField):
+        """
+        Hack: we create a StoreField based on the remote field,
+        then modify some of its behaviour.
+        """
+        sf = create_atomizer(holder, fld.field, fld.name)
+
+        # print("20180712 create_atomizer {} from {}".format(sf, fld.field))
+
+        def value_from_object(unused, obj, ar=None):
+            return fld.func(obj, ar)
+
+        def full_value_from_object(unused, obj, ar=None):
+            return fld.func(obj, ar)
+
+        def set_value_in_object(sf, ar, instance, v):
+            # print("20180712 {}.set_value_in_object({}, {})".format(
+            #     sf, instance, v))
+            old_value = sf.value_from_object(instance, ar.request)
+            if old_value != v:
+                return fld.setter(instance, v)
+
+        sf.value_from_object = curry(value_from_object, sf)
+        sf.full_value_from_object = curry(full_value_from_object, sf)
+        sf.set_value_in_object = curry(set_value_in_object, sf)
+        return sf
+
+    meth = getattr(fld, "_return_type_for_method", None)
+    if meth is not None:
+        # uh, this is tricky...
+        # raise Exception(f"20250523 {fld} has a _return_type_for_method")
+        # print(f"20250523 {fld} has a _return_type_for_method")
+        return store.MethodStoreField(fld, name)
+
+    # sf_class = getattr(fld, 'lino_atomizer_class', None)
+    # if sf_class is not None:
+    #     return sf_class(fld, name)
+
+    if isinstance(fld, fields.DummyField):
+        return None
+    if isinstance(fld, fields.RequestField):
+        delegate = create_atomizer(holder, fld.return_type, fld.name)
+        return store.RequestStoreField(fld, delegate, name)
+    if isinstance(fld, type) and issubclass(fld, actors.Actor):
+        # raise Exception(f"20250523 {fld} is an actor!")
+        return
+    # if isinstance(fld, type) and issubclass(fld, actors.Actor):
+    #     raise Exception("20230219")
+    #     # 20210618 & 20230218
+    #     if settings.SITE.kernel.default_ui.support_async:
+    #         return SlaveTableStoreField(fld, name)
+    #     return DisplayStoreField(fld, name)
+
+    if isinstance(fld, fields.VirtualField):
+        delegate = create_atomizer(holder, fld.return_type, fld.name)
+        if delegate is None:
+            # e.g. VirtualField with DummyField as return_type
+            return None
+            # raise Exception("No atomizer for %s %s %s" % (
+            #     holder, fld.return_type, fld.name))
+        return store.VirtStoreField(fld, delegate, name)
+    if isinstance(fld, models.FileField):
+        return store.FileFieldStoreField(fld, name)
+    if isinstance(fld, models.ManyToManyField):
+        return store.StoreField(fld, name)
+    if isinstance(fld, fields.PasswordField):
+        return store.PasswordStoreField(fld, name)
+    if isinstance(fld, models.OneToOneField):
+        return store.OneToOneStoreField(fld, name)
+    if isinstance(fld, models.OneToOneRel):
+        return store.OneToOneRelStoreField(fld, name)
+
+    if settings.SITE.is_installed("contenttypes"):
+        from lino.core.gfks import GenericForeignKey, GenericRel
+        from lino.modlib.gfks.fields import GenericForeignKeyIdField
+
+        if isinstance(fld, GenericForeignKey):
+            return store.GenericForeignKeyField(fld, name)
+        if isinstance(fld, GenericRel):
+            return store.GenericRelField(fld, name)
+        if isinstance(fld, GenericForeignKeyIdField):
+            return store.ComboStoreField(fld, name)
+
+    if isinstance(fld, models.ForeignKey):
+        return store.ForeignKeyStoreField(fld, name)
+    if isinstance(fld, models.TimeField):
+        return store.TimeStoreField(fld, name)
+    if isinstance(fld, models.DateTimeField):
+        return store.DateTimeStoreField(fld, name)
+    if isinstance(fld, fields.IncompleteDateField):
+        return store.IncompleteDateStoreField(fld, name)
+    if isinstance(fld, models.DateField):
+        return store.DateStoreField(fld, name)
+    if isinstance(fld, models.BooleanField):
+        return store.BooleanStoreField(fld, name)
+    if isinstance(fld, models.DecimalField):
+        return store.DecimalStoreField(fld, name)
+    if isinstance(fld, models.AutoField):
+        return store.AutoStoreField(fld, name)
+        # kw.update(type='int')
+    if isinstance(fld, models.SmallIntegerField):
+        return store.IntegerStoreField(fld, name)
+    if isinstance(fld, fields.DisplayField):
+        return store.DisplayStoreField(fld, name)
+    if isinstance(fld, models.IntegerField):
+        return store.IntegerStoreField(fld, name)
+    if isinstance(fld, fields.PreviewTextField):
+        return store.PreviewTextStoreField(fld, name)
+    if isinstance(fld, models.ManyToOneRel):
+        # raise Exception("20190625 {} {} {}".format(holder, fld, name))
+        return
+    if (sft := store.FIELD_TYPES.get(fld.__class__, None)) is not None:
+        return sft(fld, name)
+    kw = {}
+    if choosers.uses_simple_values(holder, fld):
+        return store.StoreField(fld, name, **kw)
+    else:
+        return store.ComboStoreField(fld, name, **kw)
+
+
+def get_atomizer(holder, fld, name):
+    """
+    Return the :term:`atomizer` for this database field.
+
+    An atomizer is an instance of a subclass of :class:`StoreField`.
+
+    """
+    # if name is None:
+    #     raise Exception("20250523 name is None")
+    sf = getattr(fld, "_lino_atomizer", None)
+    if sf is None:
+        sf = create_atomizer(holder, fld, name)
+        if sf is None:
+            # print(f"20250523 {fld} on {holder} has no StoreField")
+            return
+        assert isinstance(sf, store.StoreField)
+        # if not isinstance(sf, StoreField):
+        #     raise Exception("{} is not a StoreField".format(sf))
+        if isinstance(fld, type):
+            raise Exception("20240913 trying to set class attribute")
+        setattr(fld, "_lino_atomizer", sf)
+    return sf
+
+
+def fields_list(model, field_names):
+    """
+    Return a set with the names of the specified fields, checking
+    whether each of them exists.
+
+    Arguments: `model` is any subclass of `django.db.models.Model`. It
+    may be a string with the full name of a model
+    (e.g. ``"myapp.MyModel"``).  `field_names` is a single string with
+    a space-separated list of field names.
+
+    If one of the names refers to a dummy field, this name will be ignored
+    silently.
+
+    For example if you have a model `MyModel` with two fields `foo` and
+    `bar`, then ``dd.fields_list(MyModel,"foo bar")`` will return
+    ``['foo','bar']`` and ``dd.fields_list(MyModel,"foo baz")`` will raise
+    an exception.
+
+    TODO: either rename this to `fields_set` or change it to return an
+    iterable on the fields.
+    """
+    lst = set()
+    names_list = field_names.split()
+
+    for name in names_list:
+        if name == "*":
+            explicit_names = set()
+            for name in names_list:
+                if name != "*":
+                    explicit_names.add(name)
+            for de in fields.wildcard_data_elems(model):
+                if not isinstance(de, DummyField):
+                    if de.name not in explicit_names:
+                        if fields.use_as_wildcard(de):
+                            lst.add(de.name)
+        else:
+            e = model.get_data_elem(name)
+            if e is None:
+                raise fields.FieldDoesNotExist(
+                    "No data element %r in %s" % (name, model))
+            if not hasattr(e, "name"):
+                raise fields.FieldDoesNotExist(
+                    "%s %r in %s has no name" % (e.__class__, name, model)
+                )
+            if isinstance(e, fields.DummyField):
+                pass
+            else:
+                lst.add(e.name)
+    return lst

lino/core/boundaction.py

@@ -86,8 +86,12 @@ class BoundAction(object):
         return self.action.get_window_layout(self.actor)
 
     def get_layout_handel(self):
-        layout = self.get_window_layout()
-        return layout.get_layout_handle() if layout is not None else None
+        if (layout := self.get_window_layout()) is not None:
+            try:
+                return layout.get_layout_handle()
+            except Exception as e:
+                raise Exception(
+                    f"20250523 get_layout_handle for {self} failed ({e})")
 
     def get_window_size(self):
         return self.action.get_window_size(self.actor)
@@ -163,7 +167,7 @@ class BoundAction(object):
         """
         u = ar.get_user()
 
-        if not self.action.get_view_permission(u.user_type):
+        if not self.action.get_action_view_permission(self.actor, u.user_type):
             return False
         if not self._allow(u, obj, state):
             return False
@@ -186,7 +190,7 @@ class BoundAction(object):
         #         return False
         # elif not self.action.defining_actor.get_view_permission(user_type):
         #     return False
-        if not self.action.get_view_permission(user_type):
+        if not self.action.get_action_view_permission(self.actor, user_type):
             return False
         return self.allow_view(user_type)
 

lino/core/constants.py

@@ -65,6 +65,7 @@ DISPLAY_MODE_LIST = "list"
 DISPLAY_MODE_CARDS = "cards"
 DISPLAY_MODE_GALLERY = "gallery"
 DISPLAY_MODE_STORY = "story"
+DISPLAY_MODE_TILES = "tiles"
 
 DISPLAY_MODES = {
     DISPLAY_MODE_GRID,
@@ -74,7 +75,8 @@ DISPLAY_MODES = {
     DISPLAY_MODE_LIST,
     DISPLAY_MODE_CARDS,
     DISPLAY_MODE_GALLERY,
-    DISPLAY_MODE_STORY}
+    DISPLAY_MODE_STORY,
+    DISPLAY_MODE_TILES}
 
 BASIC_DISPLAY_MODES = {
     DISPLAY_MODE_GRID,

lino/core/dbtables.py

@@ -14,7 +14,8 @@ from lino.core import actors
 from lino.core.model import Model
 from lino.core import actions
 from lino.core import fields
-from lino.utils.html import tostring, assert_safe
+from lino.core.atomizer import fields_list
+
 from lino import logger
 
 import datetime
@@ -382,13 +383,13 @@ class Table(AbstractTable):
         if self.model is not None:
             if isinstance(self.hidden_columns, str):
                 self.hidden_columns = frozenset(
-                    fields.fields_list(self.model, self.hidden_columns)
+                    fields_list(self.model, self.hidden_columns)
                 )
             self.hidden_columns |= self.model.hidden_columns
 
             if isinstance(self.active_fields, str):
                 self.active_fields = frozenset(
-                    fields.fields_list(self.model, self.active_fields)
+                    fields_list(self.model, self.active_fields)
                 )
             self.active_fields |= self.model.active_fields
             self.hidden_elements |= self.model.hidden_elements