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

lino/core/actions.py

@@ -1,464 +1,76 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2009-2024 Rumma & Ko Ltd
+# Copyright 2009-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
-"""This defines the :class:`Action` class and the :func:`action`
-decorator, and some of the standard actions.  See :ref:`dev.actions`.
+# See src/core/actions.rst
 
-"""
-
-from .utils import InstanceAction
+from django.conf import settings
+from django.utils.translation import gettext_lazy as _
+from django.utils.text import format_lazy
+from django.utils.encoding import force_str
+from django.utils.translation import gettext
+from lino.core import constants
+from lino.core import keyboard
 from .utils import traverse_ddh_fklist
-from .utils import Parametrizable
 from .utils import navinfo
-from .utils import resolve_model
 from .utils import obj2unicode
-from .permissions import Permittable
-from lino.utils.choosers import check_for_chooser
-from lino.modlib.users.utils import get_user_profile
-from lino.core import keyboard
-from lino.core import fields
-from lino.core import layouts
-from lino.core import constants
-from lino import logger
+# from .action import Action
 
-from django.utils.translation import gettext_lazy as _
-from django.utils.translation import gettext
-from django.utils.text import format_lazy
-from django.utils.encoding import force_str
-from django.conf import settings
-from django.db import models
 from django.core.exceptions import BadRequest
 
-from django.apps import apps
-
-
-def discover_choosers():
-    logger.debug("Discovering choosers for database fields...")
-    for model in apps.get_models():
-        for field in model._meta.fields:
-            check_for_chooser(model, field)
-
-
-def resolve_layout(cls, k, spec, layout_class, **options):
-    # k: just for naming the culprit in error messages
-    if isinstance(spec, str):
-        if "\n" in spec or not "." in spec:
-            return layout_class(spec, cls, **options)
-        else:
-            layout_class = settings.SITE.models.resolve(spec)
-            if layout_class is None:
-                raise Exception(
-                    "Unresolved {} {!r} for {}".format(k, spec, cls))
-            return layout_class(None, cls, **options)
-    elif isinstance(spec, layouts.Panel):
-        options.update(spec.options)
-        return layout_class(spec.desc, cls, **options)
-    else:
-        if not isinstance(spec, layout_class):
-            if not isinstance(cls, type):
-                # cls is an action instance
-                cls = cls.__class__
-            msg = (
-                "{}.{}.{} must be a string, " "a Panel or an instance of {} (not {!r})"
-            )
-            raise Exception(
-                msg.format(cls.__module__, cls.__name__,
-                           k, layout_class.__name__, spec)
-            )
-        if spec._datasource is None:
-            spec.set_datasource(cls)
-            return spec
-        elif not issubclass(cls, spec._datasource):
-            raise Exception(
-                "Cannot reuse %s instance (%s of %r) for %r"
-                % (spec.__class__, k, spec._datasource, cls)
-            )
-    return spec
-
-
-def install_layout(cls, k, layout_class, **options):
-    """
-    - `cls` is the actor (a class object)
-
-    - `k` is one of 'grid_layout', 'detail_layout', 'insert_layout',
-      'params_layout', 'card_layout'
-
-    - `layout_class`
-
-    """
-    # if str(cls) == 'courses.Pupils':
-    #     print("20160329 install_layout", k, layout_class)
-    dl = cls.__dict__.get(k, None)
-    if dl is None:  # and not cls._class_init_done:
-        dl = getattr(cls, k, None)
-    if dl is None:
-        return
-    setattr(cls, k, resolve_layout(cls, k, dl, layout_class, **options))
-
-
-def register_params(cls):
-    """`cls` is either an actor (a class object) or an action (an
-    instance).
-
-    """
-    if cls.parameters is not None:
-        for k, v in cls.parameters.items():
-            v.set_attributes_from_name(k)
-            v.table = cls
-            # v.model = cls  # 20181023 experimentally
-
-        if cls.params_layout is None:
-            cls.params_layout = cls._params_layout_class.join_str.join(
-                cls.parameters.keys()
-            )
-        install_layout(cls, "params_layout", cls._params_layout_class)
-
-    # e.g. accounting.ByJournal is just a mixin but provides a default value for its children
-    elif cls.params_layout is not None:
-        raise Exception("{} has a params_layout but no parameters".format(cls))
-
-    # if isinstance(cls, type) and cls.__name__.endswith("Users"):
-    # # if isinstance(cls, type) and cls.model is not None and cls.model.__name__ == "User":
-    #     # if str(cls.model) != "users.User":
-    #     #     raise Exception("{} {}".format(cls, cls.model))
-    #     print("20200825 {}.register_params {} {}".format(
-    #         cls, cls.parameters, cls.params_layout))
-
-
-def setup_params_choosers(self):
-    if self.parameters:
-        for k, fld in self.parameters.items():
-            if isinstance(fld, models.ForeignKey):
-                msg = "Invalid target %s in parameter {} of {}".format(k, self)
-                fld.remote_field.model = resolve_model(
-                    fld.remote_field.model, strict=msg
-                )
-                fields.set_default_verbose_name(fld)
-
-            check_for_chooser(self, fld)
-
-
-def make_params_layout_handle(self):
-    # `self` is either an Action instance or an Actor class object
-    return self.params_layout.get_layout_handle()
+from .utils import InstanceAction
+from .permissions import Permittable
+from lino.core import layouts
+from lino.core import fields
+from lino.core.utils import Parametrizable
+# from lino.core.fields import setup_params_choosers
+from lino.core.utils import register_params, make_params_layout_handle
 
 
 class Action(Parametrizable, Permittable):
-    """
-    Abstract base class for all actions.
-
-    The first argument is the optional `label`, other arguments should
-    be specified as keywords and can be any of the existing class
-    attributes.
-
-    """
-
-    # ~ __metaclass__ = ActionMetaClass
     _params_layout_class = layouts.ActionParamsLayout
-
     label = None
     button_text: str = None
-
     button_color = None
-    """
-    The color to be used on icon-less buttons for this action
-    (i.e. which have no :attr:`icon_name`).  See also
-    :attr:`lino.core.site.Site.use_silk_icons`.
-
-    Not yet implemented. This is currently being ignored.
-    """
-
     debug_permissions = False
     save_action_name = None
-
     disable_primary_key = True
-    """
-    Whether primary key fields should be disabled when using this
-    action. This is `True` for all actions except :class:`ShowInsert`.
-    """
-
     keep_user_values = False
-    """
-    Whether the parameter window should keep its values between
-    different calls. If this is True, Lino does not fill any default
-    values and leaves those from a previous call.
-
-    Deprecated because it (1) is not used on any production site, (2) has a
-    least two side effect: the fields *never* get a default value, even not on
-    first execution, and you cannot explicitly specify programmatic field
-    values. And (3) we actually wouldn't want to specify this per action but per
-    field.
-
-    """
     icon_name = None
-    """
-    The class name of an icon to be used for this action when
-    rendered as toolbar button.  Allowed icon names are defined in
-    :data:`lino.core.constants.ICON_NAMES`.
-
-    """
     ui5_icon_name = None
     react_icon_name = None
     hidden_elements = frozenset()
-
     combo_group = None
-    """
-    The name of another action to which to "attach" this action.
-    Both actions will then be rendered as a single combobutton.
-
-    """
     parameters = None
-    """
-    See :attr:`lino.core.utils.Parametrizable.parameters`.
-    """
 
     use_param_panel = False
-    """
-    Used internally. This is True for window actions whose window use
-    the parameter panel: grid and emptytable (but not showdetail)
-
-    """
     no_params_window = False
-    """
-    Set this to `True` if your action has :attr:`parameters` but you
-    do *not* want it to open a window where the user can edit these
-    parameters before calling the action.
-
-    Setting this attribute to `True` means that the calling code must
-    explicitly set all parameter values.  Usage example are the
-    :attr:`lino_xl.lib.polls.models.AnswersByResponse.answer_buttons`
-    and :attr:`lino_xl.lib-tickets.Ticket.quick_assign_to`
-    virtual fields.
-
-    """
     sort_index = 90
-    """
-    Determines the sort order in which the actions will be presented
-    to the user.
-
-    List actions are negative and come first.
-
-    Predefined `sort_index` values are:
-
-    ===== =================================
-    value action
-    ===== =================================
-    -1    :class:`as_pdf <lino_xl.lib.appypod.PrintTableAction>`
-    10    :class:`ShowInsert`
-    11    :attr:`duplicate <lino.mixins.duplicable.Duplicable.duplicate>`
-    20    :class:`detail <ShowDetail>`
-    30    :class:`delete <DeleteSelected>`
-    31    :class:`merge <lino.core.merge.MergeAction>`
-    50    :class:`Print <lino.mixins.printable.BasePrintAction>`
-    51    :class:`Clear Cache <lino.mixins.printable.ClearCacheAction>`
-    52    :attr:`lino.modlib.users.UserPlan.start_plan`
-    53    :attr:`lino.modlib.users.UserPlan.update_plan`
-    60    :class:`ShowSlaveTable`
-    90    default for all custom row actions
-    100   :class:`SubmitDetail`
-    200   default for all workflow actions (:class:`ChangeStateAction <lino.core.workflows.ChangeStateAction>`)
-    ===== =================================
-
-
-    """
     help_text = None
 
     auto_save = True
-    """
-    What to do when this action is being called while the user is on a
-    dirty record.
-
-    - `False` means: forget any changes in current record and run the
-      action.
-
-    - `True` means: save any changes in current record before running
-      the action.  `None` means: ask the user.
-
-    """
 
     extjs_main_panel = None
-    """
-    Used by :mod:`lino_xl.lib.extensible` and
-    :mod:`lino.modlib.awesome_uploader`.
-
-    Example::
-
-        class CalendarAction(dd.Action):
-            extjs_main_panel = "Lino.CalendarApp().get_main_panel()"
-            ...
-
-
-    """
-
     js_handler = None
-    """
-    This is usually `None`.  Otherwise it is the name of a Javascript
-    callable to be called without arguments. That callable must have
-    been defined in a :attr:`lino.core.plugin.Plugin.site_js_snippets`
-    of the plugin.
-
-    Also can be defined as a class method, that takes the actor as the only
-    argument and should return a JavaScript executable.
-    An example use case is defined in
-    :class:`lino.modlib.help.OpenHelpWindow` where the return string
-    follows the format::
-
-        return "let _ = window.open('URL')"
-
-    Callable Example::
-
-        def js_handler(self, actor):
-            ...
-            return JS_EXECUTABLE
-
-    """
-
     action_name = None
-    """
-    Internally used to store the name of this action within the
-    defining Actor's namespace.
-
-    """
-
     defining_actor = None
-    """
-    The :class:`lino.core.actors.Actor` who uses this action for the
-    first time.  This is set during :meth:`attach_to_actor`.  This is
-    used internally e.g. by :mod:`lino.modlib.extjs` when generating
-    JavaScript code for certain actions.
-    """
-
     hotkey = None
-    """
-    An instance of :class:`lino.core.keyboard.Hotkey`. Used as a keyboard
-    shortcut to trigger actions.
-    """
-
     default_format = "html"
-    """
-    Used internally.
-    """
-
     editable = True
-    """
-
-    Whether the parameter fields should be editable.
-    Setting this to False seems nonsense.
-    """
-
     readonly = True
-
     opens_a_window = False
-
     hide_top_toolbar = False  # 20210509
-    """
-    This is set to `True` for :class:`ShowInsert`.
-
-    As an applicationdeveloper you don't need this action attribute, but
-    see :attr:`lino.core.actors.Actor.hide_top_toolbar`.
-
-    """
     hide_navigator = False  # 20210509
-    """
-    Hide navigator actions on window opened by this action.
-
-    """
-
     never_collapse = False
-    """
-    When `True` the action will always be visible, regardless of whether
-    the toolbar collapsed or not.
-    """
-
     show_in_side_toolbar = False
-
     show_in_plain = False
-    """
-    Whether this action should be displayed as a button in the toolbar
-    of a plain html view.
-    """
-
     show_in_toolbar = True
-    """
-
-    Whether this action should be displayed in the toolbar.
-
-    In ExtJS this will also cause it to be in the context menu of a grid.
-
-    For example the :class:`CheckinVisitor
-    <lino_xl.lib.reception.CheckinVisitor>`,
-    :class:`ReceiveVisitor
-    <lino_xl.lib.reception.ReceiveVisitor>` and
-    :class:`CheckoutVisitor
-    <lino_xl.lib.reception.CheckoutVisitor>` actions have this
-    attribute explicitly set to `False` because otherwise they would be
-    visible in the toolbar.
-    """
-
     show_in_workflow = False
-    """
-    Whether this action should be displayed in the
-    :attr:`workflow_buttons <lino.core.model.Model.workflow_buttons>`
-    column.  If this is True, then Lino will automatically set
-    :attr:`custom_handler` to True.
-    """
-
     custom_handler = False
-    """
-    Whether this action is implemented as Javascript function call.
-    This is necessary if you want your action to be callable using an
-    "action link" (html button).
-    """
-
     select_rows = True
-    """
-    True if this action needs an object to act on.
-
-    Set this to `False` if this action is a list action, not a row
-    action.
-    """
     http_method = "GET"
-    """
-    HTTP method to use when this action is called using an AJAX call.
-
-    """
-
     preprocessor = "null"  # None
-    """
-    Name of a Javascript function to be invoked on the web client when
-    this action is called.
-    """
-
     window_type = None
-    """
-    On actions that opens_a_window this must be a unique one-letter
-    string expressing the window type.
-
-    See `constants.WINDOW_TYPES`.
-
-    Allowed values are:
-
-    - None : opens_a_window is False
-    - 't' : ShowTable
-    - 'd' : ShowDetail
-    - 'i' : ShowInsert
-
-    This can be used e.g. by a summary view to decide how to present the
-    summary data (usage example
-    :meth:`lino.modlib.uploads.AreaUploads.get_table_summary`).
-
-    """
-
     callable_from = "td"
-    """
-    A string that specifies from which :attr:`window_type` this action
-    is callable.  None means that it is only callable from code.
-
-    Default value is 'td' which means from both table and detail
-    (including ShowEmptyTable which is subclass of ShowDetail). But
-    not callable from ShowInsert.
-    """
-
     hide_virtual_fields = False
     required_states = None
     default_record_id = None
@@ -488,57 +100,40 @@ class Action(Parametrizable, Permittable):
 
         if self.callable_from is not None:
             for c in self.callable_from:
-                if not c in constants.WINDOW_TYPES:
+                if c not in constants.WINDOW_TYPES:
                     raise Exception(f"Invalid window_type spec {c} in {self}")
 
     def __get__(self, instance, owner):
-        """
-        When a model has an action "foo", then getting an attribute
-        "foo" of a model instance will return an :class:`InstanceAction`.
-        """
         if instance is None:
             return self
         return InstanceAction(self, None, instance, owner)
 
-    # def get_a_href_target(self):
-    #     return None
-
-    def get_django_form(self):
-        """returns a django form object based on the params of this action"""
-        from django import forms
-
-        mapping = {"PasswordField": "CharField"}
-
-        class LinoForm(forms.Form):
-            pass
-
-        for name, field in self.parameters.items():
-            setattr(
-                LinoForm,
-                name,
-                getattr(
-                    forms,
-                    mapping.get(field.__class__.__name__,
-                                field.__class__.__name__),
-                )(),
-            )
-        return LinoForm
+    # def get_django_form(self):
+    #     """returns a django form object based on the params of this action"""
+    #     from django import forms
+    #
+    #     mapping = {"PasswordField": "CharField"}
+    #
+    #     class LinoForm(forms.Form):
+    #         pass
+    #
+    #     for name, field in self.parameters.items():
+    #         setattr(
+    #             LinoForm,
+    #             name,
+    #             getattr(
+    #                 forms,
+    #                 mapping.get(field.__class__.__name__,
+    #                             field.__class__.__name__),
+    #             )(),
+    #         )
+    #     return LinoForm
 
     @classmethod
     def decorate(cls, *args, **kw):
-        """
-        Return a decorator that turns an instance method on a model or a
-        class method on an actor into an action of this class.
-
-        The decorated method will be installed as the actions's
-        :meth:`run_from_ui <Action.run_from_ui>` method.
-
-        All arguments are forwarded to :meth:`Action.__init__`.
-
-        """
 
         def decorator(fn):
-            assert not "required" in kw
+            assert "required" not in kw
             # print 20140422, fn.__name__
             kw.setdefault("custom_handler", True)
             a = cls(*args, **kw)
@@ -556,12 +151,6 @@ class Action(Parametrizable, Permittable):
         return actor.required_roles
 
     def is_callable_from(self, caller):
-        """
-        Return `True` if this action makes sense as a button from within
-        the specified `caller` (an action instance which must have a
-        :attr:`window_type`).  Do not override this method on your
-        subclass ; rather specify :attr:`callable_from`.
-        """
         assert caller.window_type is not None
         if self.callable_from is None:
             return False
@@ -569,10 +158,6 @@ class Action(Parametrizable, Permittable):
         # return isinstance(caller, self.callable_from)
 
     def is_window_action(self):
-        """Return `True` if this is a "window action" (i.e. which opens a GUI
-        window on the client before executing).
-
-        """
         return self.opens_a_window or (self.parameters and not self.no_params_window)
 
     def get_status(self, ar, **kw):
@@ -612,10 +197,6 @@ class Action(Parametrizable, Permittable):
         return options
 
     def get_label(self):
-        """
-        Return the `label` of this action, or the `action_name` if the
-        action has no explicit label.
-        """
         return self.label or self.action_name
 
     def get_button_label(self, actor):
@@ -662,18 +243,9 @@ class Action(Parametrizable, Permittable):
             assert self.action_name == name
         self.action_name = name
         self.defining_actor = wf
-        setup_params_choosers(self)
+        fields.setup_params_choosers(self)
 
     def attach_to_actor(self, owner, name):
-        """
-        Called once per actor and per action on startup before a
-        :class:`BoundAction` instance is created.  If this returns
-        False, then the action won't be attached to the given actor.
-
-        The owner is the actor which "defines" the action, i.e. uses
-        that instance for the first time.  Subclasses of the owner may
-        re-use the same instance without becoming the owner.
-        """
         # if not actor.editable and not self.readonly:
         #     return False
         if self.defining_actor is not None:
@@ -690,50 +262,25 @@ class Action(Parametrizable, Permittable):
             #     "tried to attach named action %s.%s as %s" %
             #     (actor, self.action_name, name))
         self.action_name = name
-        setup_params_choosers(self)
-        # setup_params_choosers(self.__class__)
+        fields.setup_params_choosers(self)
+        # fields.setup_params_choosers(self.__class__)
         return True
 
     def get_action_permission(self, ar, obj, state):
-        """Return (True or False) whether the given :class:`ActionRequest
-        <lino.core.requests.BaseRequest>` `ar` should get permission
-        to run on the given Model instance `obj` (which is in the
-        given `state`).
-
-        Derived Action classes may override this to add vetos.
-        E.g. the MoveUp action of a Sequenced is not available on the
-        first row of given `ar`.
-
-        This should be used only for light-weight tests. If this
-        requires a database lookup, consider disabling the action in
-        :meth:`disabled_fields
-        <lino.core.model.Model.disabled_fields>` where you can disable
-        multiple actions and fields at once.
-
-        """
         return True
 
     def get_view_permission(self, user_type):
-        """
-        Return True if this action is visible for users of given user_type.
+        return self.get_action_view_permission(self.defining_actor, user_type)
+        # raise Exception("20250323 replaced by get_action_view_permission()")
 
-        """
+    def get_action_view_permission(self, actor, user_type):
         return True
 
     def run_from_ui(self, ar, **kwargs):
-        """
-        Execute the action.  `ar` is a :class:`BaseRequest
-        <lino.core.requests.BaseRequest>` object.
-        """
         raise BadRequest("{} has no run_from_ui() method".format(
             self.__class__.__name__))
 
     def run_from_code(self, ar=None, *args, **kwargs):
-        """
-        Probably to be deprecated.
-        Execute the action.  The default calls :meth:`run_from_ui`.  You
-        may override this to define special behaviour
-        """
         self.run_from_ui(ar, *args, **kwargs)
 
     def run_from_session(self, ses, *args, **kw):  # 20130820
@@ -745,17 +292,6 @@ class Action(Parametrizable, Permittable):
         return ia.run_from_session(ses, **kw)
 
     def action_param_defaults(self, ar, obj, **kw):
-        """Same as :meth:`lino.core.actors.Actor.param_defaults`, except that
-        on an action it is a instance method.
-
-        Note that this method is not called for actions which are rendered
-        in a toolbar (:ticket:`1336`).
-
-        Usage examples:
-        :class:`lino.modlib.users.actions.SendWelcomeMail`
-
-        """
-
         for k, pf in self.parameters.items():
             # print 20151203, pf.name, repr(pf.rel.to)
             kw[k] = pf.get_default()
@@ -765,27 +301,15 @@ class Action(Parametrizable, Permittable):
         pass
 
     def get_layout_aliases(self):
-        """
+        return []
 
-        Yield a series of (ALIAS, repl) tuples that cause a name ALIAS in a
-        layout based on this action to be replaced by its replacement `repl`.
 
-        """
-        return []
+action = Action.decorate
 
 
 class TableAction(Action):
     pass
 
-    # def get_action_title(self, ar):
-    #     return ar.get_title()
-
-
-# class RedirectAction(Action):
-
-#     def get_target_url(self, elem):
-#         raise NotImplementedError
-
 
 class ShowTable(TableAction):
     use_param_panel = True
@@ -846,9 +370,6 @@ class ShowDetail(Action):
 
 
 class ShowEmptyTable(ShowDetail):
-    """
-    The default action for :class:`lino.utils.report.EmptyTable`.
-    """
 
     use_param_panel = True
     action_name = "show"
@@ -930,13 +451,15 @@ class ShowInsert(TableAction):
         if wl is not None:
             return wl.window_size
 
-    def get_view_permission(self, user_type):
+    def get_action_view_permission(self, actor, user_type):
         # the action is readonly because it doesn't write to the
         # current object, but since it does modify the database we
         # want to hide it for readonly users.
+        if not actor.allow_create:
+            return False
         if user_type and user_type.readonly:
             return False
-        return super().get_view_permission(user_type)
+        return super().get_action_view_permission(actor, user_type)
 
     def create_instance(self, ar):
         """
@@ -993,11 +516,6 @@ class ValidateForm(Action):
 
 
 class SaveGridCell(Action):
-    """
-    Called when user edited a cell of a non-phantom record in a grid.
-    Installed as `update_action` on every :class:`Actor`.
-
-    """
 
     sort_index = 10
     show_in_workflow = False
@@ -1019,13 +537,6 @@ class SaveGridCell(Action):
 
 
 class SubmitDetail(SaveGridCell):
-    """Save changes in the detail form.
-
-    This is rendered as the "Save" button of a :term:`detail window`.
-
-    Installed as `submit_detail` on every actor.
-
-    """
 
     sort_index = 100
     icon_name = "disk"
@@ -1051,9 +562,6 @@ class SubmitDetail(SaveGridCell):
 
 
 class CreateRow(Action):
-    """
-    Called when user edited a cell of a phantom record in a grid.
-    """
 
     sort_index = 10
     auto_save = False
@@ -1188,10 +696,6 @@ class ExplicitRefresh(Action):  # experimental 20170929
 
 
 class ShowSlaveTable(Action):
-    """
-    An action that opens a window showing another table (to be
-    specified when instantiating the action).
-    """
 
     TABLE2ACTION_ATTRS = (
         "icon_name",
@@ -1211,9 +715,10 @@ class ShowSlaveTable(Action):
             self._help_text = help_text
         super().__init__(**kw)
 
-    @classmethod
-    def get_actor_label(self):
-        return self.get_label() or self.slave_table.label
+    # Removed 20250521 because I don't see why it is needed
+    # @classmethod
+    # def get_actor_label(self):
+    #     return self.get_label() or self.slave_table.label
 
     def attach_to_actor(self, actor, name):
         if isinstance(self.slave_table, str):
@@ -1246,15 +751,6 @@ class ShowSlaveTable(Action):
 
 
 class WrappedAction(Action):
-    """
-
-    On instantiation it takes a :class:`BoundAction
-    <lino.core.boundaction.BoundAction>` as a positional argument and returns an
-    action instance that behaves as a wrapper around the given
-    *BoundAction.action* useful when binding to another :class:`Actor
-    <lino.core.actors.Actor>`.
-
-    """
 
     instance = None  # for Renderer.menu_item_button()
     show_in_toolbar = True
@@ -1308,7 +804,6 @@ class WrappedAction(Action):
 
 
 class MultipleRowAction(Action):
-    """Base class for actions that update something on every selected row."""
 
     custom_handler = True
 
@@ -1333,11 +828,6 @@ class MultipleRowAction(Action):
 
 
 class DeleteSelected(MultipleRowAction):
-    """Delete the selected row(s).
-
-    This action is automatically installed on every editable actor.
-
-    """
 
     action_name = "delete_selected"  # because...
     if True:  # settings.SITE.use_silk_icons:
@@ -1436,21 +926,9 @@ class DeleteSelected(MultipleRowAction):
         return 1
 
 
-action = Action.decorate
+# Some actions are described by a single action instance used by most actors:
 
-
-def get_view_permission(e):
-    if isinstance(e, Permittable) and not e.get_view_permission(get_user_profile()):
-        return False
-    # e.g. pcsw.ClientDetail has a tab "Other", visible only to system
-    # admins but the "Other" contains a GridElement RolesByPerson
-    # which is not per se reserved for system admins.  js of normal
-    # users should not try to call on_master_changed() on it
-    parent = e.parent
-    while parent is not None:
-        if isinstance(parent, Permittable) and not parent.get_view_permission(
-            get_user_profile()
-        ):
-            return False  # bug 3 (bcss_summary) blog/2012/0927
-        parent = parent.parent
-    return True
+SUBMIT_DETAIL = SubmitDetail()
+DELETE_ACTION = DeleteSelected()
+UPDATE_ACTION = SaveGridCell()
+VALIDATE_FORM = ValidateForm()