0
# Core Framework
1

2
Foundation classes and application management providing the central coordination for Flask-AppBuilder applications. These components handle application initialization, view registration, security setup, menu management, and the complete application lifecycle.
3

4
## Capabilities
5

6
### AppBuilder Class
7

8
The central framework class that coordinates all Flask-AppBuilder components, manages the application lifecycle, and provides the primary interface for registering views, APIs, and other application components.
9

10
```python { .api }
11
from flask_appbuilder import AppBuilder
12

13
class AppBuilder:
14
    def __init__(self, app=None, session=None, menu=None, indexview=None, 
15
                 base_template="appbuilder/baselayout.html", static_folder="static/appbuilder", 
16
                 static_url_path="/appbuilder", security_manager_class=None, update_perms=True):
17
        """
18
        Initialize AppBuilder instance.
19
        
20
        Parameters:
21
        - app: Flask application instance
22
        - session: SQLAlchemy session
23
        - menu: Menu instance for navigation
24
        - indexview: Default index view class
25
        - base_template: Base template path
26
        - static_folder: Static files folder
27
        - static_url_path: URL path for static files
28
        - security_manager_class: Custom security manager class
29
        - update_perms: Auto-update permissions flag
30
        """
31
    
32
    def init_app(self, app, session):
33
        """
34
        Initialize Flask application with AppBuilder (application factory pattern).
35
        
36
        Parameters:
37
        - app: Flask application instance  
38
        - session: SQLAlchemy session
39
        """
40
    
41
    def add_view(self, baseview, name, href="", icon="", label="", category="", 
42
                 category_icon="", category_label="", menu_cond=None):
43
        """
44
        Add view to application with menu entry.
45
        
46
        Parameters:
47
        - baseview: View class to register
48
        - name: Menu item name
49
        - href: URL href (auto-generated if empty)
50
        - icon: Font Awesome icon class
51
        - label: Display label (defaults to name)
52
        - category: Menu category
53
        - category_icon: Category icon class  
54
        - category_label: Category display label
55
        - menu_cond: Callable for conditional menu display
56
        """
57
    
58
    def add_view_no_menu(self, baseview, endpoint=None, static_folder=None):
59
        """
60
        Add view without menu entry.
61
        
62
        Parameters:
63
        - baseview: View class to register
64
        - endpoint: Custom endpoint name
65
        - static_folder: Static files folder
66
        """
67
    
68
    def add_api(self, baseview):
69
        """
70
        Add API view to application.
71
        
72
        Parameters:
73
        - baseview: API view class to register
74
        """
75
    
76
    def add_link(self, name, href, icon="", label="", category="", 
77
                 category_icon="", category_label="", baseview=None, cond=None):
78
        """
79
        Add menu link without associated view.
80
        
81
        Parameters:
82
        - name: Link name
83
        - href: Link URL
84
        - icon: Font Awesome icon class
85
        - label: Display label
86
        - category: Menu category
87
        - category_icon: Category icon class
88
        - category_label: Category display label  
89
        - baseview: Associated view for permissions
90
        - cond: Callable for conditional display
91
        """
92
    
93
    def add_separator(self, category="", cond=None):
94
        """
95
        Add menu separator.
96
        
97
        Parameters:
98
        - category: Menu category
99
        - cond: Callable for conditional display
100
        """
101
    
102
    def security_cleanup(self):
103
        """Clean up unused permissions from database."""
104
    
105
    def security_converge(self, dry=True):
106
        """
107
        Migrate permissions to new names.
108
        
109
        Parameters:
110
        - dry: Dry run flag (no actual changes)
111
        
112
        Returns:
113
        Dict with migration information
114
        """
115
    
116
    def add_permissions(self, update_perms=True):
117
        """
118
        Add permissions for all registered views.
119
        
120
        Parameters:
121
        - update_perms: Update existing permissions flag
122
        """
123
    
124
    def register_blueprint(self, baseview, endpoint=None, static_folder=None):
125
        """
126
        Register view blueprint with Flask application.
127
        
128
        Parameters:
129
        - baseview: View instance
130
        - endpoint: Blueprint endpoint  
131
        - static_folder: Static files folder
132
        
133
        Returns:
134
        Blueprint instance
135
        """
136

137
# Properties
138
app = None  # Current Flask application
139
sm = None   # Security Manager instance
140
bm = None   # Babel Manager instance
141
openapi_manager = None  # OpenAPI Manager instance
142
menuapi_manager = None  # Menu API Manager instance
143
menu = None             # Menu instance
144
baseviews = []          # List of registered views
145
addon_managers = {}     # Dict of addon managers
146

147
# Dynamic properties
148
get_app = property(...)      # Current Flask app
149
get_session = property(...)  # Current SQLAlchemy session
150
app_name = property(...)     # Application name from config
151
app_theme = property(...)    # Application theme
152
app_icon = property(...)     # Application icon  
153
languages = property(...)    # Supported languages dict
154
version = property(...)      # Flask-AppBuilder version
155
```
156

157
### BaseView Class
158

159
Foundation class for all views providing routing, templating, security integration, and basic view functionality that other view classes extend.
160

161
```python { .api }
162
from flask_appbuilder.baseviews import BaseView, expose
163

164
class BaseView:
165
    def __init__(self):
166
        """Initialize base view with permissions and properties."""
167
    
168
    def create_blueprint(self, appbuilder, endpoint=None, static_folder=None):
169
        """
170
        Create Flask blueprint for this view.
171
        
172
        Parameters:
173
        - appbuilder: AppBuilder instance
174
        - endpoint: Custom endpoint name
175
        - static_folder: Static files folder
176
        
177
        Returns:
178
        Flask Blueprint instance
179
        """
180
    
181
    def render_template(self, template, **kwargs):
182
        """
183
        Render Jinja2 template with context.
184
        
185
        Parameters:
186
        - template: Template path
187
        - **kwargs: Template context variables
188
        
189
        Returns:
190
        Rendered template string
191
        """
192
    
193
    def update_redirect(self):
194
        """Update navigation history for redirect functionality."""
195
    
196
    def get_redirect(self):
197
        """
198
        Get previous URL from navigation history.
199
        
200
        Returns:
201
        Previous URL string or None
202
        """
203
    
204
    def get_method_permission(self, method_name):
205
        """
206
        Get permission name for view method.
207
        
208
        Parameters:
209
        - method_name: Method name
210
        
211
        Returns:
212
        Permission name string
213
        """
214

215
# Class properties  
216
route_base = ""             # Base URL route
217
template_folder = "templates"  # Template folder location
218
static_folder = None        # Static files folder
219
base_permissions = []       # List of allowed permissions
220
class_permission_name = ""  # Override class permission name  
221
method_permission_name = {} # Override method permission names
222
exclude_route_methods = set()  # Methods to exclude from routing
223
include_route_methods = set()  # Methods to include in routing (whitelist)
224
default_view = ""          # Default view method name
225
extra_args = {}            # Extra template arguments
226
limits = []                # Rate limiting configuration
227
```
228

229
### View Decorators
230

231
Decorators for exposing view methods as routes and controlling access to view functionality.
232

233
```python { .api }
234
from flask_appbuilder.baseviews import expose
235
from flask_appbuilder.security.decorators import has_access, permission_name
236

237
@expose(url="/", methods=["GET"])
238
def expose(url="/", methods=("GET",)):
239
    """
240
    Expose view method as Flask route.
241
    
242
    Parameters:
243
    - url: URL pattern for route
244
    - methods: HTTP methods list
245
    
246
    Usage:
247
    @expose('/custom-endpoint/')
248
    @has_access
249
    def my_view(self):
250
        return self.render_template('my_template.html')
251
    """
252

253
@has_access  
254
def has_access(f):
255
    """
256
    Enable granular security permissions for view methods.
257
    Redirects to login page on access denied.
258
    
259
    Usage:
260
    @expose('/admin-only/')  
261
    @has_access
262
    def admin_method(self):
263
        return "Admin only content"
264
    """
265

266
@permission_name("custom_permission")
267
def permission_name(name):
268
    """
269
    Override permission name for a view method.
270
    
271
    Parameters:
272
    - name: Custom permission name
273
    
274
    Usage:
275
    @expose('/special/')
276
    @has_access
277
    @permission_name("can_access_special")
278
    def special_method(self):
279
        return "Special access required"
280
    """
281
```
282

283
### BaseFormView Class
284

285
Foundation for form-based views providing form processing, validation, and rendering capabilities.
286

287
```python { .api }
288
from flask_appbuilder.baseviews import BaseFormView
289

290
class BaseFormView(BaseView):
291
    def form_get(self, form):
292
        """
293
        Override for custom form GET processing.
294
        
295
        Parameters:
296
        - form: WTForms form instance
297
        """
298
    
299
    def form_post(self, form):
300
        """
301
        Override for custom form POST processing.
302
        
303
        Parameters:  
304
        - form: WTForms form instance with submitted data
305
        
306
        Returns:
307
        Response or None to use default processing
308
        """
309

310
# Form properties
311
form_template = "appbuilder/general/model/edit.html"  # Form template path
312
edit_widget = None      # Form widget class
313
form_title = ""         # Form title
314
form_columns = []       # Form columns to include  
315
form = None            # WTForms form instance
316
form_fieldsets = []    # Form field groupings
317
```
318

319
### BaseModelView Class
320

321
Foundation for model-based views providing data model integration, searching, filtering, and basic model operations.
322

323
```python { .api }
324
from flask_appbuilder.baseviews import BaseModelView
325
from flask_appbuilder.models.sqla.interface import SQLAInterface
326

327
class BaseModelView(BaseView):
328
    def _init_properties(self):
329
        """Initialize view properties from datamodel."""
330
    
331
    def _init_forms(self):
332
        """Initialize search and other forms."""
333
    
334
    def _init_titles(self):
335
        """Initialize view titles."""
336
    
337
    def _get_search_widget(self, form, exclude_cols=[], widgets={}):
338
        """
339
        Get search widget for the view.
340
        
341
        Parameters:
342
        - form: Search form instance
343
        - exclude_cols: Columns to exclude from search
344
        - widgets: Custom widget overrides
345
        
346
        Returns:
347
        SearchWidget instance  
348
        """
349

350
# Model properties
351
datamodel = None               # SQLAlchemy interface instance
352
title = ""                     # View title
353
search_columns = []            # Searchable columns
354
search_exclude_columns = []    # Columns to exclude from search  
355
search_form_extra_fields = {}  # Extra search form fields
356
search_form_query_rel_fields = {}  # Related field queries for search
357
label_columns = {}             # Column label overrides
358
search_form = None            # Search form instance
359
base_filters = []             # Base query filters
360
base_order = []               # Default ordering  
361
search_widget = None          # Search widget class
362

363
# Usage example
364
class MyModelView(BaseModelView):
365
    datamodel = SQLAInterface(MyModel)
366
    search_columns = ['name', 'email']
367
    label_columns = {'name': 'Full Name'}
368
    base_filters = [['active', FilterEqual, True]]
369
```