Fix the Resource Class creation error
Had to clean up some of the horizon.workflows code we were carrying around. Signed-off-by: Tomas Sedovic <tomas@sedovic.cz>
This commit is contained in:
Tomas Sedovic
parent
1839264f2a
commit
1b8705bedf
@ -36,412 +36,14 @@ from horizon import base
|
||||
from horizon import exceptions
|
||||
from horizon.templatetags.horizon import has_permissions
|
||||
from horizon.utils import html
|
||||
import horizon.workflows
|
||||
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class WorkflowContext(dict):
|
||||
def __init__(self, workflow, *args, **kwargs):
|
||||
super(WorkflowContext, self).__init__(*args, **kwargs)
|
||||
self._workflow = workflow
|
||||
|
||||
def __setitem__(self, key, val):
|
||||
super(WorkflowContext, self).__setitem__(key, val)
|
||||
return self._workflow._trigger_handlers(key)
|
||||
|
||||
def __delitem__(self, key):
|
||||
return self.__setitem__(key, None)
|
||||
|
||||
def set(self, key, val):
|
||||
return self.__setitem__(key, val)
|
||||
|
||||
def unset(self, key):
|
||||
return self.__delitem__(key)
|
||||
|
||||
|
||||
class ActionMetaclass(forms.forms.DeclarativeFieldsMetaclass):
|
||||
def __new__(mcs, name, bases, attrs):
|
||||
# Pop Meta for later processing
|
||||
opts = attrs.pop("Meta", None)
|
||||
# Create our new class
|
||||
cls = super(ActionMetaclass, mcs).__new__(mcs, name, bases, attrs)
|
||||
# Process options from Meta
|
||||
cls.name = getattr(opts, "name", name)
|
||||
cls.slug = getattr(opts, "slug", slugify(name))
|
||||
cls.permissions = getattr(opts, "permissions", ())
|
||||
cls.progress_message = getattr(opts,
|
||||
"progress_message",
|
||||
_("Processing..."))
|
||||
cls.help_text = getattr(opts, "help_text", "")
|
||||
cls.help_text_template = getattr(opts, "help_text_template", None)
|
||||
return cls
|
||||
|
||||
|
||||
class Action(forms.Form):
|
||||
"""
|
||||
An ``Action`` represents an atomic logical interaction you can have with
|
||||
the system. This is easier to understand with a conceptual example: in the
|
||||
context of a "launch instance" workflow, actions would include "naming
|
||||
the instance", "selecting an image", and ultimately "launching the
|
||||
instance".
|
||||
|
||||
Because ``Actions`` are always interactive, they always provide form
|
||||
controls, and thus inherit from Django's ``Form`` class. However, they
|
||||
have some additional intelligence added to them:
|
||||
|
||||
* ``Actions`` are aware of the permissions required to complete them.
|
||||
|
||||
* ``Actions`` have a meta-level concept of "help text" which is meant to be
|
||||
displayed in such a way as to give context to the action regardless of
|
||||
where the action is presented in a site or workflow.
|
||||
|
||||
* ``Actions`` understand how to handle their inputs and produce outputs,
|
||||
much like :class:`~horizon.forms.SelfHandlingForm` does now.
|
||||
|
||||
``Action`` classes may define the following attributes in a ``Meta``
|
||||
class within them:
|
||||
|
||||
.. attribute:: name
|
||||
|
||||
The verbose name for this action. Defaults to the name of the class.
|
||||
|
||||
.. attribute:: slug
|
||||
|
||||
A semi-unique slug for this action. Defaults to the "slugified" name
|
||||
of the class.
|
||||
|
||||
.. attribute:: permissions
|
||||
|
||||
A list of permission names which this action requires in order to be
|
||||
completed. Defaults to an empty list (``[]``).
|
||||
|
||||
.. attribute:: help_text
|
||||
|
||||
A string of simple help text to be displayed alongside the Action's
|
||||
fields.
|
||||
|
||||
.. attribute:: help_text_template
|
||||
|
||||
A path to a template which contains more complex help text to be
|
||||
displayed alongside the Action's fields. In conjunction with
|
||||
:meth:`~horizon.workflows.Action.get_help_text` method you can
|
||||
customize your help text template to display practically anything.
|
||||
"""
|
||||
|
||||
__metaclass__ = ActionMetaclass
|
||||
|
||||
def __init__(self, request, context, *args, **kwargs):
|
||||
if request.method == "POST":
|
||||
super(Action, self).__init__(request.POST, initial=context)
|
||||
else:
|
||||
super(Action, self).__init__(initial=context)
|
||||
|
||||
if not hasattr(self, "handle"):
|
||||
raise AttributeError("The action %s must define a handle method."
|
||||
% self.__class__.__name__)
|
||||
self.request = request
|
||||
self._populate_choices(request, context)
|
||||
|
||||
def __unicode__(self):
|
||||
return force_unicode(self.name)
|
||||
|
||||
def __repr__(self):
|
||||
return "<%s: %s>" % (self.__class__.__name__, self.slug)
|
||||
|
||||
def _populate_choices(self, request, context):
|
||||
for field_name, bound_field in self.fields.items():
|
||||
meth = getattr(self, "populate_%s_choices" % field_name, None)
|
||||
if meth is not None and callable(meth):
|
||||
bound_field.choices = meth(request, context)
|
||||
|
||||
def get_help_text(self, extra_context=None):
|
||||
""" Returns the help text for this step. """
|
||||
text = ""
|
||||
extra_context = extra_context or {}
|
||||
if self.help_text_template:
|
||||
tmpl = template.loader.get_template(self.help_text_template)
|
||||
context = template.RequestContext(self.request, extra_context)
|
||||
text += tmpl.render(context)
|
||||
else:
|
||||
text += linebreaks(force_unicode(self.help_text))
|
||||
return safe(text)
|
||||
|
||||
def add_error(self, message):
|
||||
"""
|
||||
Adds an error to the Action's Step based on API issues.
|
||||
"""
|
||||
self._get_errors()[NON_FIELD_ERRORS] = self.error_class([message])
|
||||
|
||||
def handle(self, request, context):
|
||||
"""
|
||||
Handles any requisite processing for this action. The method should
|
||||
return either ``None`` or a dictionary of data to be passed to
|
||||
:meth:`~horizon.workflows.Step.contribute`.
|
||||
|
||||
Returns ``None`` by default, effectively making it a no-op.
|
||||
"""
|
||||
return None
|
||||
|
||||
|
||||
class Step(object):
|
||||
"""
|
||||
A step is a wrapper around an action which defines it's context in a
|
||||
workflow. It knows about details such as:
|
||||
|
||||
* The workflow's context data (data passed from step to step).
|
||||
|
||||
* The data which must be present in the context to begin this step (the
|
||||
step's dependencies).
|
||||
|
||||
* The keys which will be added to the context data upon completion of the
|
||||
step.
|
||||
|
||||
* The connections between this step's fields and changes in the context
|
||||
data (e.g. if that piece of data changes, what needs to be updated in
|
||||
this step).
|
||||
|
||||
A ``Step`` class has the following attributes:
|
||||
|
||||
.. attribute:: action
|
||||
|
||||
The :class:`~horizon.workflows.Action` class which this step wraps.
|
||||
|
||||
.. attribute:: depends_on
|
||||
|
||||
A list of context data keys which this step requires in order to
|
||||
begin interaction.
|
||||
|
||||
.. attribute:: contributes
|
||||
|
||||
A list of keys which this step will contribute to the workflow's
|
||||
context data. Optional keys should still be listed, even if their
|
||||
values may be set to ``None``.
|
||||
|
||||
.. attribute:: connections
|
||||
|
||||
A dictionary which maps context data key names to lists of callbacks.
|
||||
The callbacks may be functions, dotted python paths to functions
|
||||
which may be imported, or dotted strings beginning with ``"self"``
|
||||
to indicate methods on the current ``Step`` instance.
|
||||
|
||||
.. attribute:: before
|
||||
|
||||
Another ``Step`` class. This optional attribute is used to provide
|
||||
control over workflow ordering when steps are dynamically added to
|
||||
workflows. The workflow mechanism will attempt to place the current
|
||||
step before the step specified in the attribute.
|
||||
|
||||
.. attribute:: after
|
||||
|
||||
Another ``Step`` class. This attribute has the same purpose as
|
||||
:meth:`~horizon.workflows.Step.before` except that it will instead
|
||||
attempt to place the current step after the given step.
|
||||
|
||||
.. attribute:: help_text
|
||||
|
||||
A string of simple help text which will be prepended to the ``Action``
|
||||
class' help text if desired.
|
||||
|
||||
.. attribute:: template_name
|
||||
|
||||
A path to a template which will be used to render this step. In
|
||||
general the default common template should be used. Default:
|
||||
``"horizon/common/_workflow_step.html"``.
|
||||
|
||||
.. attribute:: has_errors
|
||||
|
||||
A boolean value which indicates whether or not this step has any
|
||||
errors on the action within it or in the scope of the workflow. This
|
||||
attribute will only accurately reflect this status after validation
|
||||
has occurred.
|
||||
|
||||
.. attribute:: slug
|
||||
|
||||
Inherited from the ``Action`` class.
|
||||
|
||||
.. attribute:: name
|
||||
|
||||
Inherited from the ``Action`` class.
|
||||
|
||||
.. attribute:: permissions
|
||||
|
||||
Inherited from the ``Action`` class.
|
||||
"""
|
||||
action_class = None
|
||||
depends_on = ()
|
||||
contributes = ()
|
||||
connections = None
|
||||
before = None
|
||||
after = None
|
||||
help_text = ""
|
||||
template_name = "horizon/common/_workflow_step.html"
|
||||
|
||||
def __repr__(self):
|
||||
return "<%s: %s>" % (self.__class__.__name__, self.slug)
|
||||
|
||||
def __unicode__(self):
|
||||
return force_unicode(self.name)
|
||||
|
||||
def __init__(self, workflow):
|
||||
super(Step, self).__init__()
|
||||
self.workflow = workflow
|
||||
|
||||
cls = self.__class__.__name__
|
||||
if not (self.action_class and issubclass(self.action_class, Action)):
|
||||
raise AttributeError("You must specify an action for %s." % cls)
|
||||
|
||||
self.slug = self.action_class.slug
|
||||
self.name = self.action_class.name
|
||||
self.permissions = self.action_class.permissions
|
||||
self.has_errors = False
|
||||
self._handlers = {}
|
||||
|
||||
if self.connections is None:
|
||||
# We want a dict, but don't want to declare a mutable type on the
|
||||
# class directly.
|
||||
self.connections = {}
|
||||
|
||||
# Gather our connection handlers and make sure they exist.
|
||||
for key, handlers in self.connections.items():
|
||||
self._handlers[key] = []
|
||||
# TODO(gabriel): This is a poor substitute for broader handling
|
||||
if not isinstance(handlers, (list, tuple)):
|
||||
raise TypeError("The connection handlers for %s must be a "
|
||||
"list or tuple." % cls)
|
||||
for possible_handler in handlers:
|
||||
if callable(possible_handler):
|
||||
# If it's callable we know the function exists and is valid
|
||||
self._handlers[key].append(possible_handler)
|
||||
continue
|
||||
elif not isinstance(possible_handler, basestring):
|
||||
return TypeError("Connection handlers must be either "
|
||||
"callables or strings.")
|
||||
bits = possible_handler.split(".")
|
||||
if bits[0] == "self":
|
||||
root = self
|
||||
for bit in bits[1:]:
|
||||
try:
|
||||
root = getattr(root, bit)
|
||||
except AttributeError:
|
||||
raise AttributeError("The connection handler %s "
|
||||
"could not be found on %s."
|
||||
% (possible_handler, cls))
|
||||
handler = root
|
||||
elif len(bits) == 1:
|
||||
# Import by name from local module not supported
|
||||
raise ValueError("Importing a local function as a string "
|
||||
"is not supported for the connection "
|
||||
"handler %s on %s."
|
||||
% (possible_handler, cls))
|
||||
else:
|
||||
# Try a general import
|
||||
module_name = ".".join(bits[:-1])
|
||||
try:
|
||||
mod = import_module(module_name)
|
||||
handler = getattr(mod, bits[-1])
|
||||
except ImportError:
|
||||
raise ImportError("Could not import %s from the "
|
||||
"module %s as a connection "
|
||||
"handler on %s."
|
||||
% (bits[-1], module_name, cls))
|
||||
except AttributeError:
|
||||
raise AttributeError("Could not import %s from the "
|
||||
"module %s as a connection "
|
||||
"handler on %s."
|
||||
% (bits[-1], module_name, cls))
|
||||
self._handlers[key].append(handler)
|
||||
|
||||
@property
|
||||
def action(self):
|
||||
if not getattr(self, "_action", None):
|
||||
try:
|
||||
# Hook in the action context customization.
|
||||
workflow_context = dict(self.workflow.context)
|
||||
context = self.prepare_action_context(self.workflow.request,
|
||||
workflow_context)
|
||||
self._action = self.action_class(self.workflow.request,
|
||||
context)
|
||||
except:
|
||||
LOG.exception("Problem instantiating action class.")
|
||||
raise
|
||||
return self._action
|
||||
|
||||
def prepare_action_context(self, request, context):
|
||||
"""
|
||||
Allows for customization of how the workflow context is passed to the
|
||||
action; this is the reverse of what "contribute" does to make the
|
||||
action outputs sane for the workflow. Changes to the context are not
|
||||
saved globally here. They are localized to the action.
|
||||
|
||||
Simply returns the unaltered context by default.
|
||||
"""
|
||||
return context
|
||||
|
||||
def get_id(self):
|
||||
""" Returns the ID for this step. Suitable for use in HTML markup. """
|
||||
return "%s__%s" % (self.workflow.slug, self.slug)
|
||||
|
||||
def _verify_contributions(self, context):
|
||||
for key in self.contributes:
|
||||
# Make sure we don't skip steps based on weird behavior of
|
||||
# POST query dicts.
|
||||
field = self.action.fields.get(key, None)
|
||||
if field and field.required and not context.get(key):
|
||||
context.pop(key, None)
|
||||
failed_to_contribute = set(self.contributes)
|
||||
failed_to_contribute -= set(context.keys())
|
||||
if failed_to_contribute:
|
||||
raise exceptions.WorkflowError("The following expected data was "
|
||||
"not added to the workflow context "
|
||||
"by the step %s: %s."
|
||||
% (self.__class__,
|
||||
failed_to_contribute))
|
||||
return True
|
||||
|
||||
def contribute(self, data, context):
|
||||
"""
|
||||
Adds the data listed in ``contributes`` to the workflow's shared
|
||||
context. By default, the context is simply updated with all the data
|
||||
returned by the action.
|
||||
|
||||
Note that even if the value of one of the ``contributes`` keys is
|
||||
not present (e.g. optional) the key should still be added to the
|
||||
context with a value of ``None``.
|
||||
"""
|
||||
if data:
|
||||
for key in self.contributes:
|
||||
context[key] = data.get(key, None)
|
||||
return context
|
||||
|
||||
def render(self):
|
||||
""" Renders the step. """
|
||||
step_template = template.loader.get_template(self.template_name)
|
||||
extra_context = {"form": self.action,
|
||||
"step": self}
|
||||
|
||||
# FIXME: TableStep:
|
||||
if issubclass(self.__class__, TableStep):
|
||||
extra_context.update(self.get_context_data(self.workflow.request))
|
||||
|
||||
context = template.RequestContext(self.workflow.request, extra_context)
|
||||
return step_template.render(context)
|
||||
|
||||
def get_help_text(self):
|
||||
""" Returns the help text for this step. """
|
||||
text = linebreaks(force_unicode(self.help_text))
|
||||
text += self.action.get_help_text()
|
||||
return safe(text)
|
||||
|
||||
def add_error(self, message):
|
||||
"""
|
||||
Adds an error to the Step based on API issues.
|
||||
"""
|
||||
self.action.add_error(message)
|
||||
|
||||
|
||||
# FIXME: TableStep
|
||||
class TableStep(Step):
|
||||
class TableStep(horizon.workflows.Step):
|
||||
"""
|
||||
A :class:`~horizon.workflows.Step` class which knows how to deal with
|
||||
:class:`~horizon.tables.DataTable` classes rendered inside of it.
|
||||
@ -475,6 +77,19 @@ class TableStep(Step):
|
||||
self._tables = SortedDict(table_instances)
|
||||
self._table_data_loaded = False
|
||||
|
||||
def render(self):
|
||||
""" Renders the step. """
|
||||
step_template = template.loader.get_template(self.template_name)
|
||||
extra_context = {"form": self.action,
|
||||
"step": self}
|
||||
|
||||
# FIXME: TableStep:
|
||||
if issubclass(self.__class__, TableStep):
|
||||
extra_context.update(self.get_context_data(self.workflow.request))
|
||||
|
||||
context = template.RequestContext(self.workflow.request, extra_context)
|
||||
return step_template.render(context)
|
||||
|
||||
def load_table_data(self):
|
||||
"""
|
||||
Calls the ``get_{{ table_name }}_data`` methods for each table class
|
||||
@ -517,418 +132,3 @@ class TableStep(Step):
|
||||
|
||||
def has_more_data(self, table):
|
||||
return False
|
||||
|
||||
|
||||
class WorkflowMetaclass(type):
|
||||
def __new__(mcs, name, bases, attrs):
|
||||
super(WorkflowMetaclass, mcs).__new__(mcs, name, bases, attrs)
|
||||
attrs["_cls_registry"] = set([])
|
||||
return type.__new__(mcs, name, bases, attrs)
|
||||
|
||||
|
||||
class UpdateMembersStep(Step):
|
||||
"""A step that allows a user to add/remove members from a group.
|
||||
|
||||
.. attribute:: show_roles
|
||||
|
||||
Set to False to disable the display of the roles dropdown.
|
||||
|
||||
.. attribute:: available_list_title
|
||||
|
||||
The title used for the available list column.
|
||||
|
||||
.. attribute:: members_list_title
|
||||
|
||||
The title used for the members list column.
|
||||
|
||||
.. attribute:: no_available_text
|
||||
|
||||
The placeholder text used when the available list is empty.
|
||||
|
||||
.. attribute:: no_members_text
|
||||
|
||||
The placeholder text used when the members list is empty.
|
||||
|
||||
"""
|
||||
template_name = "horizon/common/_workflow_step_update_members.html"
|
||||
show_roles = True
|
||||
available_list_title = _("All available")
|
||||
members_list_title = _("Members")
|
||||
no_available_text = _("None available.")
|
||||
no_members_text = _("No members.")
|
||||
|
||||
|
||||
class Workflow(html.HTMLElement):
|
||||
"""
|
||||
A Workflow is a collection of Steps. It's interface is very
|
||||
straightforward, but it is responsible for handling some very
|
||||
important tasks such as:
|
||||
|
||||
* Handling the injection, removal, and ordering of arbitrary steps.
|
||||
|
||||
* Determining if the workflow can be completed by a given user at runtime
|
||||
based on all available information.
|
||||
|
||||
* Dispatching connections between steps to ensure that when context data
|
||||
changes all the applicable callback functions are executed.
|
||||
|
||||
* Verifying/validating the overall data integrity and subsequently
|
||||
triggering the final method to complete the workflow.
|
||||
|
||||
The ``Workflow`` class has the following attributes:
|
||||
|
||||
.. attribute:: name
|
||||
|
||||
The verbose name for this workflow which will be displayed to the user.
|
||||
Defaults to the class name.
|
||||
|
||||
.. attribute:: slug
|
||||
|
||||
The unique slug for this workflow. Required.
|
||||
|
||||
.. attribute:: steps
|
||||
|
||||
Read-only access to the final ordered set of step instances for
|
||||
this workflow.
|
||||
|
||||
.. attribute:: default_steps
|
||||
|
||||
A list of :class:`~horizon.workflows.Step` classes which serve as the
|
||||
starting point for this workflow's ordered steps. Defaults to an empty
|
||||
list (``[]``).
|
||||
|
||||
.. attribute:: finalize_button_name
|
||||
|
||||
The name which will appear on the submit button for the workflow's
|
||||
form. Defaults to ``"Save"``.
|
||||
|
||||
.. attribute:: success_message
|
||||
|
||||
A string which will be displayed to the user upon successful completion
|
||||
of the workflow. Defaults to
|
||||
``"{{ workflow.name }} completed successfully."``
|
||||
|
||||
.. attribute:: failure_message
|
||||
|
||||
A string which will be displayed to the user upon failure to complete
|
||||
the workflow. Defaults to ``"{{ workflow.name }} did not complete."``
|
||||
|
||||
.. attribute:: depends_on
|
||||
|
||||
A roll-up list of all the ``depends_on`` values compiled from the
|
||||
workflow's steps.
|
||||
|
||||
.. attribute:: contributions
|
||||
|
||||
A roll-up list of all the ``contributes`` values compiled from the
|
||||
workflow's steps.
|
||||
|
||||
.. attribute:: template_name
|
||||
|
||||
Path to the template which should be used to render this workflow.
|
||||
In general the default common template should be used. Default:
|
||||
``"horizon/common/_workflow.html"``.
|
||||
|
||||
.. attribute:: entry_point
|
||||
|
||||
The slug of the step which should initially be active when the
|
||||
workflow is rendered. This can be passed in upon initialization of
|
||||
the workflow, or set anytime after initialization but before calling
|
||||
either ``get_entry_point`` or ``render``.
|
||||
|
||||
.. attribute:: redirect_param_name
|
||||
|
||||
The name of a parameter used for tracking the URL to redirect to upon
|
||||
completion of the workflow. Defaults to ``"next"``.
|
||||
|
||||
.. attribute:: object
|
||||
|
||||
The object (if any) which this workflow relates to. In the case of
|
||||
a workflow which creates a new resource the object would be the created
|
||||
resource after the relevant creation steps have been undertaken. In
|
||||
the case of a workflow which updates a resource it would be the
|
||||
resource being updated after it has been retrieved.
|
||||
|
||||
"""
|
||||
__metaclass__ = WorkflowMetaclass
|
||||
slug = None
|
||||
default_steps = ()
|
||||
template_name = "horizon/common/_workflow.html"
|
||||
finalize_button_name = _("Save")
|
||||
success_message = _("%s completed successfully.")
|
||||
failure_message = _("%s did not complete.")
|
||||
redirect_param_name = "next"
|
||||
multipart = False
|
||||
_registerable_class = Step
|
||||
|
||||
def __unicode__(self):
|
||||
return self.name
|
||||
|
||||
def __repr__(self):
|
||||
return "<%s: %s>" % (self.__class__.__name__, self.slug)
|
||||
|
||||
def __init__(self, request=None, context_seed=None, entry_point=None,
|
||||
*args, **kwargs):
|
||||
super(Workflow, self).__init__(*args, **kwargs)
|
||||
if self.slug is None:
|
||||
raise AttributeError("The workflow %s must have a slug."
|
||||
% self.__class__.__name__)
|
||||
self.name = getattr(self, "name", self.__class__.__name__)
|
||||
self.request = request
|
||||
self.depends_on = set([])
|
||||
self.contributions = set([])
|
||||
self.entry_point = entry_point
|
||||
self.object = None
|
||||
|
||||
# Put together our steps in order. Note that we pre-register
|
||||
# non-default steps so that we can identify them and subsequently
|
||||
# insert them in order correctly.
|
||||
self._registry = dict([(step_class, step_class(self)) for step_class
|
||||
in self.__class__._cls_registry
|
||||
if step_class not in self.default_steps])
|
||||
self._gather_steps()
|
||||
|
||||
# Determine all the context data we need to end up with.
|
||||
for step in self.steps:
|
||||
self.depends_on = self.depends_on | set(step.depends_on)
|
||||
self.contributions = self.contributions | set(step.contributes)
|
||||
|
||||
# Initialize our context. For ease we can preseed it with a
|
||||
# regular dictionary. This should happen after steps have been
|
||||
# registered and ordered.
|
||||
self.context = WorkflowContext(self)
|
||||
context_seed = context_seed or {}
|
||||
clean_seed = dict([(key, val)
|
||||
for key, val in context_seed.items()
|
||||
if key in self.contributions | self.depends_on])
|
||||
self.context_seed = clean_seed
|
||||
self.context.update(clean_seed)
|
||||
|
||||
if request and request.method == "POST":
|
||||
for step in self.steps:
|
||||
valid = step.action.is_valid()
|
||||
# Be sure to use the CLEANED data if the workflow is valid.
|
||||
if valid:
|
||||
data = step.action.cleaned_data
|
||||
else:
|
||||
data = request.POST
|
||||
self.context = step.contribute(data, self.context)
|
||||
|
||||
@property
|
||||
def steps(self):
|
||||
if getattr(self, "_ordered_steps", None) is None:
|
||||
self._gather_steps()
|
||||
return self._ordered_steps
|
||||
|
||||
def get_step(self, slug):
|
||||
""" Returns the instantiated step matching the given slug. """
|
||||
for step in self.steps:
|
||||
if step.slug == slug:
|
||||
return step
|
||||
|
||||
def _gather_steps(self):
|
||||
ordered_step_classes = self._order_steps()
|
||||
for default_step in self.default_steps:
|
||||
self.register(default_step)
|
||||
self._registry[default_step] = default_step(self)
|
||||
self._ordered_steps = [self._registry[step_class]
|
||||
for step_class in ordered_step_classes
|
||||
if has_permissions(self.request.user,
|
||||
self._registry[step_class])]
|
||||
|
||||
def _order_steps(self):
|
||||
steps = list(copy.copy(self.default_steps))
|
||||
additional = self._registry.keys()
|
||||
for step in additional:
|
||||
try:
|
||||
min_pos = steps.index(step.after)
|
||||
except ValueError:
|
||||
min_pos = 0
|
||||
try:
|
||||
max_pos = steps.index(step.before)
|
||||
except ValueError:
|
||||
max_pos = len(steps)
|
||||
if min_pos > max_pos:
|
||||
raise exceptions.WorkflowError("The step %(new)s can't be "
|
||||
"placed between the steps "
|
||||
"%(after)s and %(before)s; the "
|
||||
"step %(before)s comes before "
|
||||
"%(after)s."
|
||||
% {"new": additional,
|
||||
"after": step.after,
|
||||
"before": step.before})
|
||||
steps.insert(max_pos, step)
|
||||
return steps
|
||||
|
||||
def get_entry_point(self):
|
||||
"""
|
||||
Returns the slug of the step which the workflow should begin on.
|
||||
|
||||
This method takes into account both already-available data and errors
|
||||
within the steps.
|
||||
"""
|
||||
# If we have a valid specified entry point, use it.
|
||||
if self.entry_point:
|
||||
if self.get_step(self.entry_point):
|
||||
return self.entry_point
|
||||
# Otherwise fall back to calculating the appropriate entry point.
|
||||
for step in self.steps:
|
||||
if step.has_errors:
|
||||
return step.slug
|
||||
try:
|
||||
step._verify_contributions(self.context)
|
||||
except exceptions.WorkflowError:
|
||||
return step.slug
|
||||
# If nothing else, just return the first step.
|
||||
return self.steps[0].slug
|
||||
|
||||
def _trigger_handlers(self, key):
|
||||
responses = []
|
||||
handlers = [(step.slug, f) for step in self.steps
|
||||
for f in step._handlers.get(key, [])]
|
||||
for slug, handler in handlers:
|
||||
responses.append((slug, handler(self.request, self.context)))
|
||||
return responses
|
||||
|
||||
@classmethod
|
||||
def register(cls, step_class):
|
||||
""" Registers a :class:`~horizon.workflows.Step` with the workflow. """
|
||||
if not inspect.isclass(step_class):
|
||||
raise ValueError('Only classes may be registered.')
|
||||
elif not issubclass(step_class, cls._registerable_class):
|
||||
raise ValueError('Only %s classes or subclasses may be registered.'
|
||||
% cls._registerable_class.__name__)
|
||||
if step_class in cls._cls_registry:
|
||||
return False
|
||||
else:
|
||||
cls._cls_registry.add(step_class)
|
||||
return True
|
||||
|
||||
@classmethod
|
||||
def unregister(cls, step_class):
|
||||
"""
|
||||
Unregisters a :class:`~horizon.workflows.Step` from the workflow.
|
||||
"""
|
||||
try:
|
||||
cls._cls_registry.remove(step_class)
|
||||
except KeyError:
|
||||
raise base.NotRegistered('%s is not registered' % cls)
|
||||
return cls._unregister(step_class)
|
||||
|
||||
def validate(self, context):
|
||||
"""
|
||||
Hook for custom context data validation. Should return a boolean
|
||||
value or raise :class:`~horizon.exceptions.WorkflowValidationError`.
|
||||
"""
|
||||
return True
|
||||
|
||||
def is_valid(self):
|
||||
"""
|
||||
Verified that all required data is present in the context and
|
||||
calls the ``validate`` method to allow for finer-grained checks
|
||||
on the context data.
|
||||
"""
|
||||
missing = self.depends_on - set(self.context.keys())
|
||||
if missing:
|
||||
raise exceptions.WorkflowValidationError(
|
||||
"Unable to complete the workflow. The values %s are "
|
||||
"required but not present." % ", ".join(missing))
|
||||
|
||||
# Validate each step. Cycle through all of them to catch all errors
|
||||
# in one pass before returning.
|
||||
steps_valid = True
|
||||
for step in self.steps:
|
||||
if not step.action.is_valid():
|
||||
steps_valid = False
|
||||
step.has_errors = True
|
||||
if not steps_valid:
|
||||
return steps_valid
|
||||
return self.validate(self.context)
|
||||
|
||||
def finalize(self):
|
||||
"""
|
||||
Finalizes a workflow by running through all the actions in order
|
||||
and calling their ``handle`` methods. Returns ``True`` on full success,
|
||||
or ``False`` for a partial success, e.g. there were non-critical
|
||||
errors. (If it failed completely the function wouldn't return.)
|
||||
"""
|
||||
partial = False
|
||||
for step in self.steps:
|
||||
try:
|
||||
data = step.action.handle(self.request, self.context)
|
||||
if data is True or data is None:
|
||||
continue
|
||||
elif data is False:
|
||||
partial = True
|
||||
else:
|
||||
self.context = step.contribute(data or {}, self.context)
|
||||
except:
|
||||
partial = True
|
||||
exceptions.handle(self.request)
|
||||
if not self.handle(self.request, self.context):
|
||||
partial = True
|
||||
return not partial
|
||||
|
||||
def handle(self, request, context):
|
||||
"""
|
||||
Handles any final processing for this workflow. Should return a boolean
|
||||
value indicating success.
|
||||
"""
|
||||
return True
|
||||
|
||||
def get_success_url(self):
|
||||
"""
|
||||
Returns a URL to redirect the user to upon completion. By default it
|
||||
will attempt to parse a ``success_url`` attribute on the workflow,
|
||||
which can take the form of a reversible URL pattern name, or a
|
||||
standard HTTP URL.
|
||||
"""
|
||||
try:
|
||||
return urlresolvers.reverse(self.success_url)
|
||||
except urlresolvers.NoReverseMatch:
|
||||
return self.success_url
|
||||
|
||||
def format_status_message(self, message):
|
||||
"""
|
||||
Hook to allow customization of the message returned to the user
|
||||
upon successful or unsuccessful completion of the workflow.
|
||||
|
||||
By default it simply inserts the workflow's name into the message
|
||||
string.
|
||||
"""
|
||||
if "%s" in message:
|
||||
return message % self.name
|
||||
else:
|
||||
return message
|
||||
|
||||
def render(self):
|
||||
""" Renders the workflow. """
|
||||
workflow_template = template.loader.get_template(self.template_name)
|
||||
extra_context = {"workflow": self}
|
||||
if self.request.is_ajax():
|
||||
extra_context['modal'] = True
|
||||
context = template.RequestContext(self.request, extra_context)
|
||||
return workflow_template.render(context)
|
||||
|
||||
def get_absolute_url(self):
|
||||
""" Returns the canonical URL for this workflow.
|
||||
|
||||
This is used for the POST action attribute on the form element
|
||||
wrapping the workflow.
|
||||
|
||||
For convenience it defaults to the value of
|
||||
``request.get_full_path()`` with any query string stripped off,
|
||||
e.g. the path at which the workflow was requested.
|
||||
"""
|
||||
return self.request.get_full_path().partition('?')[0]
|
||||
|
||||
def add_error_to_step(self, message, slug):
|
||||
"""
|
||||
Adds an error to the workflow's Step with the
|
||||
specifed slug based on API issues. This is useful
|
||||
when you wish for API errors to appear as errors on
|
||||
the form rather than using the messages framework.
|
||||
"""
|
||||
step = self.get_step(slug)
|
||||
if step:
|
||||
step.add_error(message)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user