class BaseView(with_metaclass(AdminViewMeta, BaseViewClass)): """ Base administrative view. Derive from this class to implement your administrative interface piece. For example:: from flask_admin import BaseView, expose class MyView(BaseView): @expose('/') def index(self): return 'Hello World!' Icons can be added to the menu by using `menu_icon_type` and `menu_icon_value`. For example:: admin.add_view(MyView(name='My View', menu_icon_type='glyph', menu_icon_value='glyphicon-home')) """ @property def _template_args(self): """ Extra template arguments. If you need to pass some extra parameters to the template, you can override particular view function, contribute arguments you want to pass to the template and call parent view. These arguments are local for this request and will be discarded in the next request. Any value passed through ``_template_args`` will override whatever parent view function passed to the template. For example:: class MyAdmin(ModelView): @expose('/') def index(self): self._template_args['name'] = 'foobar' self._template_args['code'] = '12345' super(MyAdmin, self).index() """ args = getattr(g, '_admin_template_args', None) if args is None: args = g._admin_template_args = dict() return args def __init__(self, name=None, category=None, endpoint=None, url=None, static_folder=None, static_url_path=None, menu_class_name=None, menu_icon_type=None, menu_icon_value=None): """ Constructor. :param name: Name of this view. If not provided, will default to the class name. :param category: View category. If not provided, this view will be shown as a top-level menu item. Otherwise, it will be in a submenu. :param endpoint: Base endpoint name for the view. For example, if there's a view method called "index" and endpoint is set to "myadmin", you can use `url_for('myadmin.index')` to get the URL to the view method. Defaults to the class name in lower case. :param url: Base URL. If provided, affects how URLs are generated. For example, if the url parameter is "test", the resulting URL will look like "/admin/test/". If not provided, will use endpoint as a base url. However, if URL starts with '/', absolute path is assumed and '/admin/' prefix won't be applied. :param static_url_path: Static URL Path. If provided, this specifies the path to the static url directory. :param menu_class_name: Optional class name for the menu item. :param menu_icon_type: Optional icon. Possible icon types: - `flask_admin.consts.ICON_TYPE_GLYPH` - Bootstrap glyph icon - `flask_admin.consts.ICON_TYPE_FONT_AWESOME` - Font Awesome icon - `flask_admin.consts.ICON_TYPE_IMAGE` - Image relative to Flask static directory - `flask_admin.consts.ICON_TYPE_IMAGE_URL` - Image with full URL :param menu_icon_value: Icon glyph name or URL, depending on `menu_icon_type` setting """ self.name = name self.category = category self.endpoint = self._get_endpoint(endpoint) self.url = url self.static_folder = static_folder self.static_url_path = static_url_path self.menu = None self.menu_class_name = menu_class_name self.menu_icon_type = menu_icon_type self.menu_icon_value = menu_icon_value # Initialized from create_blueprint self.admin = None self.blueprint = None # Default view if self._default_view is None: raise Exception( u'Attempted to instantiate admin view %s without default view' % self.__class__.__name__) def _get_endpoint(self, endpoint): """ Generate Flask endpoint name. By default converts class name to lower case if endpoint is not explicitly provided. """ if endpoint: return endpoint return self.__class__.__name__.lower() def _get_view_url(self, admin, url): """ Generate URL for the view. Override to change default behavior. """ if url is None: if admin.url != '/': url = '%s/%s' % (admin.url, self.endpoint) else: if self == admin.index_view: url = '/' else: url = '/%s' % self.endpoint else: if not url.startswith('/'): url = '%s/%s' % (admin.url, url) return url def create_blueprint(self, admin): """ Create Flask blueprint. """ # Store admin instance self.admin = admin # If the static_url_path is not provided, use the admin's if not self.static_url_path: self.static_url_path = admin.static_url_path # Generate URL self.url = self._get_view_url(admin, self.url) # If we're working from the root of the site, set prefix to None if self.url == '/': self.url = None # prevent admin static files from conflicting with flask static files if not self.static_url_path: self.static_folder = 'static' self.static_url_path = '/static/admin' # If name is not provided, use capitalized endpoint name if self.name is None: self.name = self._prettify_class_name(self.__class__.__name__) # Create blueprint and register rules self.blueprint = Blueprint(self.endpoint, __name__, url_prefix=self.url, subdomain=self.admin.subdomain, template_folder=op.join( 'templates', self.admin.template_mode), static_folder=self.static_folder, static_url_path=self.static_url_path) for url, name, methods in self._urls: self.blueprint.add_url_rule(url, name, getattr(self, name), methods=methods) return self.blueprint def render(self, template, **kwargs): """ Render template :param template: Template path to render :param kwargs: Template arguments """ # Store self as admin_view kwargs['admin_view'] = self kwargs['admin_base_template'] = self.admin.base_template # Provide i18n support even if flask-babel is not installed # or enabled. kwargs['_gettext'] = babel.gettext kwargs['_ngettext'] = babel.ngettext kwargs['h'] = h # Expose get_url helper kwargs['get_url'] = self.get_url # Expose config info kwargs['config'] = current_app.config # Contribute extra arguments kwargs.update(self._template_args) return render_template(template, **kwargs) def _prettify_class_name(self, name): """ Split words in PascalCase string into separate words. :param name: String to prettify """ return h.prettify_class_name(name) def is_visible(self): """ Override this method if you want dynamically hide or show administrative views from Flask-Admin menu structure By default, item is visible in menu. Please note that item should be both visible and accessible to be displayed in menu. """ return True def is_accessible(self): """ Override this method to add permission checks. Flask-Admin does not make any assumptions about the authentication system used in your application, so it is up to you to implement it. By default, it will allow access for everyone. """ return True def _handle_view(self, name, **kwargs): """ This method will be executed before calling any view method. It will execute the ``inaccessible_callback`` if the view is not accessible. :param name: View function name :param kwargs: View function arguments """ if not self.is_accessible(): return self.inaccessible_callback(name, **kwargs) def _run_view(self, fn, *args, **kwargs): """ This method will run actual view function. While it is similar to _handle_view, can be used to change arguments that are passed to the view. :param fn: View function :param kwargs: Arguments """ return fn(self, *args, **kwargs) def inaccessible_callback(self, name, **kwargs): """ Handle the response to inaccessible views. By default, it throw HTTP 403 error. Override this method to customize the behaviour. """ return abort(403) def get_url(self, endpoint, **kwargs): """ Generate URL for the endpoint. If you want to customize URL generation logic (persist some query string argument, for example), this is right place to do it. :param endpoint: Flask endpoint name :param kwargs: Arguments for `url_for` """ return url_for(endpoint, **kwargs) @property def _debug(self): if not self.admin or not self.admin.app: return False return self.admin.app.debug
class X(with_metaclass(View)): pass