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())