def dispatch(self, request, *args, **kwargs):
module_str = "%s:%s" % (request.GET.get("module"),
request.GET.get("model"))
self.return_url = reverse("wshop_admin:%s.list" %
request.GET.get("return_url"))
match = resolve(self.return_url)
view_context = load("%s:%s" %
(match.func.__module__, match.func.__name__))
default_columns = view_context.default_columns
self.model = load(module_str)
self.settings = ViewSettings(self.model, default_columns, view_context)
return super(ListSettingsView, self).dispatch(request, *args, **kwargs)
def _build_settings_columns(self):
columns = []
all_models = [(None, self.model)]
defaults = [col.id for col in self.default_columns]
known_names = []
for identifier, m in self.view_context.related_objects:
all_models.append((identifier, load(m)))
for identifier, model in all_models:
if hasattr(model, "_parler_meta"):
self._add_translated_columns(columns, defaults, identifier,
known_names, model)
self._add_local_columns(all_models, columns, defaults, identifier,
known_names, model)
self._add_m2m_columns(all_models, columns, defaults, identifier,
known_names, model)
self._add_provided_columns(columns, identifier, known_names, model)
table_columns = set([col.id for col in columns])
for default_column in self.default_columns:
if default_column.id not in table_columns and default_column.id != "select":
columns.append(default_column)
return columns
def _load_phases(self):
phases = OrderedDict()
for phase_spec in self.phase_specs:
phase_class = load(phase_spec)
phases[phase_class.identifier] = self.instantiate_phase_class(
phase_class)
return list(phases.values())
def test_list_view(rf, class_spec, admin_user):
shop = get_default_shop()
view = load(class_spec).as_view()
request = apply_request_middleware(rf.get("/", {
"jq": json.dumps({"perPage": 100, "page": 1})
}), user=admin_user)
response = view(request)
assert 200 <= response.status_code < 300
def encode_enum(enum_val):
enum_cls = enum_val.__class__
spec = "%s:%s" % (enum_cls.__module__, enum_cls.__name__)
try:
if load(spec) != enum_cls:
raise ImproperlyConfigured("That's not the same class!")
except ImproperlyConfigured: # Also raised by `load`
return enum_val.value # Fall back to the bare value.
return [spec, enum_val.value]
def test_detail_view(rf, admin_user, model_and_class):
get_default_shop() # obvious prerequisite
model_func, class_spec = model_and_class
model = model_func()
view = load(class_spec).as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=model.pk)
if hasattr(response, "render"):
response.render()
assert 200 <= response.status_code < 300
def get_order_identifier(order):
if order.identifier:
raise ValueError(
"Order passed to get_order_identifier() already has an identifier")
order_identifier_method = settings.WSHOP_ORDER_IDENTIFIER_METHOD
if order_identifier_method == "id":
return force_text(order.id)
elif callable(order_identifier_method):
return order_identifier_method(order)
else:
getter = load(order_identifier_method, "Order identifier generator")
return getter(order)
def _load_provide_objects(category):
provide_specs = _get_provide_specs_from_apps(category)
loaded_provides = _loaded_provides[category]
if set(provide_specs) != set(
loaded_provides.keys()): # Changes occurred, reload provides
_uncache(category)
explanation = "Loading provides %s" % category
loaded_provides = OrderedDict()
for spec in provide_specs:
loaded_provides[spec] = load(spec, explanation)
_loaded_provides[category] = loaded_provides
return _loaded_provides.get(category, {})
def load_mass_actions(self):
# TODO: Make extendable through provides in near future
actions = []
for action in self.mass_actions:
obj = load(action)()
action_data = {}
extra_data = obj.get_action_info(self.request)
if extra_data and isinstance(extra_data, dict):
action_data.update(extra_data)
action_data.update({"key": obj.identifier, "value": obj.label})
actions.append(action_data)
return actions
def _load_module(self):
spec = self.default_module_spec
module_identifier = self.module_identifier
if module_identifier:
impls = self.get_module_implementation_map()
if module_identifier not in impls:
raise ModuleNotFound(
"Invalid module identifier %r in %s" %
(module_identifier, force_ascii(repr(self))))
spec = impls[module_identifier]
cls = load(spec,
context_explanation="Loading module for %s" %
force_ascii(repr(self)))
options = getattr(self, self.module_options_field, None) or {}
return cls(self, options)
def load(cls, identifier, theme=None):
"""
Get a plugin class based on the identifier from the `xtheme_plugin` provides registry.
:param identifier: Plugin class identifier
:type identifier: str
:return: A plugin class, or None
:rtype: class[Plugin]|None
"""
loaded_plugin = get_identifier_to_object_map("xtheme_plugin").get(
identifier)
if not loaded_plugin and theme is not None:
for plugin_spec in theme.plugins:
plugin = load(plugin_spec)
if plugin.identifier == identifier:
return plugin
return loaded_plugin
def load_setup_wizard_pane(shop, request, pane_id):
"""
Search, load and return a valid Wizard Pane by its identifier.
:type request: HttpRequest
:param pane_id: the pane identifier
:type pane_id: str
:return: the pane instance or None
:rtype: wshop.admin.views.wizard.WizardPane|None
"""
if not shop:
raise ValueError("Shop instance is mandatory")
for pane_spec in getattr(settings, "WSHOP_SETUP_WIZARD_PANE_SPEC", []):
pane_class = load(pane_spec)
pane_inst = pane_class(request=request, object=shop)
if pane_inst.identifier == pane_id and pane_inst.valid():
return pane_inst
def load_setup_wizard_panes(shop, request=None, visible_only=True):
"""
Load the setup Wizard panes.
The result will be a list of valid pane instances.
:type request: HttpRequest|None
:param visible_only: whether to return only visible panes
:type visible_only: bool
"""
if not shop:
raise ValueError("Shop instance is mandatory")
panes = []
for pane_spec in getattr(settings, "WSHOP_SETUP_WIZARD_PANE_SPEC", []):
pane_class = load(pane_spec)
pane_inst = pane_class(request=request, object=shop)
if pane_inst.valid() and (not visible_only or pane_inst.visible()):
panes.append(pane_inst)
return panes
def get_reference_number(order):
from wshop import configuration
from wshop.admin.modules.settings.consts import ORDER_REFERENCE_NUMBER_METHOD_FIELD
if order.reference_number:
raise ValueError(
"Order passed to get_reference_number() already has a reference number"
)
reference_number_method = configuration.get(
order.shop, ORDER_REFERENCE_NUMBER_METHOD_FIELD,
settings.WSHOP_REFERENCE_NUMBER_METHOD)
if reference_number_method == "unique":
return get_unique_reference_number_for_order(order)
elif reference_number_method == "running":
return get_running_reference_number(order)
elif reference_number_method == "shop_running":
return get_shop_running_reference_number(order)
elif callable(reference_number_method):
return reference_number_method(order)
else:
getter = load(reference_number_method, "Reference number generator")
return getter(order)
def get_theme_plugin_choices(self, empty_label=None):
"""
Get a sorted list of 2-tuples (identifier and name) of available theme specific Xtheme plugins.
Handy for `<select>` boxes.
:param empty_label: Label for the "empty" choice. If falsy, no empty choice is prepended
:type empty_label: str|None
:return: List of 2-tuples
:rtype: Iterable[tuple[str, str]]
"""
choices = []
if empty_label:
choices.append(("", empty_label))
for plugin_spec in self.plugins:
plugin = load(plugin_spec)
choices.append((
plugin.identifier,
getattr(plugin, "name", None) or plugin.identifier
))
choices.sort()
return choices
def decode_enum(val):
spec, value = val
cls = load(spec)
if issubclass(cls, Enum):
return cls(value)
return value # Fall back to the bare value. Not optimal, I know.
def _get_mass_action(self, action_identifier):
for mass_action in self.mass_actions:
loaded_action = load(mass_action)()
if loaded_action.identifier == action_identifier:
return loaded_action
return None
def register(module_class):
if isinstance(module_class, six.string_types):
module_class = load(module_class, "Admin Module")
_registry.append(module_class())
