Helper Functions and Utilities

def set_current_view(view):
    """
    Set current administrative view in request context.
    
    Args:
        view (BaseView): Admin view to set as current
    """

def get_current_view():
    """
    Get current administrative view from request context.
    
    Returns:
        BaseView: Current admin view or None
    """

def get_url(endpoint, **kwargs):
    """
    Generate URL for endpoint with admin context.
    Alternative to Flask url_for with admin-specific functionality.
    
    Args:
        endpoint (str): Endpoint name
        **kwargs: URL parameters
        
    Returns:
        str: Generated URL
    """

def is_required_form_field(field):
    """
    Check if form field has required validators.
    
    Args:
        field: WTForms field instance
        
    Returns:
        bool: True if field is required
    """

def is_form_submitted():
    """
    Check if current request contains form submission.
    
    Returns:
        bool: True if request method is POST or PUT
    """

def validate_form_on_submit(form):
    """
    Validate form if it has been submitted.
    
    Args:
        form: WTForms form instance
        
    Returns:
        bool: True if form is submitted and valid
    """

def get_form_data():
    """
    Get form data from current request.
    
    Returns:
        dict: Form data from request
    """

def is_field_error(errors):
    """
    Check if field has validation errors.
    
    Args:
        errors: Field errors list
        
    Returns:
        bool: True if field has errors
    """

def flash_errors(form, message):
    """
    Flash form validation errors to user.
    
    Args:
        form: Form instance with errors
        message (str): Base error message
    """

def resolve_ctx(context):
    """
    Resolve Jinja2 template context.
    
    Args:
        context: Jinja2 context object
        
    Returns:
        dict: Resolved context dictionary
    """

def get_render_ctx():
    """
    Get current view template context.
    
    Returns:
        dict: Template context variables
    """

def prettify_class_name(name):
    """
    Convert PascalCase class name to readable text.
    
    Args:
        name (str): Class name in PascalCase
        
    Returns:
        str: Human-readable name
    """

def is_safe_url(target):
    """
    Validate URL safety for redirects.
    
    Args:
        target (str): URL to validate
        
    Returns:
        bool: True if URL is safe for redirecting
    """

def get_redirect_target(param_name='url'):
    """
    Get safe redirect target from request parameters.
    
    Args:
        param_name (str): Parameter name containing redirect URL
        
    Returns:
        str: Safe redirect URL or None
    """

def import_module(name, required=True):
    """
    Dynamically import module by name.
    
    Args:
        name (str): Module name to import
        required (bool): Raise exception if import fails
        
    Returns:
        module: Imported module or None if not required
    """

def import_attribute(name):
    """
    Import attribute by string reference (e.g., 'module.Class').
    
    Args:
        name (str): Fully qualified attribute name
        
    Returns:
        object: Imported attribute
    """

def module_not_found(additional_depth=0):
    """
    Check if ImportError originated from missing module.
    
    Args:
        additional_depth (int): Additional stack frames to check
        
    Returns:
        bool: True if error is from missing module
    """

def rec_getattr(obj, attr, default=None):
    """
    Recursive getattr with dot notation support.
    
    Args:
        obj: Object to get attribute from
        attr (str): Attribute name with optional dot notation (e.g., 'user.profile.name')
        default: Default value if attribute not found
        
    Returns:
        object: Attribute value or default
    """

def get_dict_attr(obj, attr, default=None):
    """
    Get attribute without triggering __getattr__ magic method.
    
    Args:
        obj: Object to get attribute from
        attr (str): Attribute name
        default: Default value if attribute not found
        
    Returns:
        object: Attribute value or default
    """

def escape(value):
    """
    Escape special characters for safe URL encoding.
    
    Args:
        value (str): String to escape
        
    Returns:
        str: Escaped string
    """

def iterencode(iter):
    """
    Encode enumerable (list/tuple) as string for URL parameters.
    
    Args:
        iter: Iterable to encode
        
    Returns:
        str: Encoded string representation
    """

def iterdecode(value):
    """
    Decode string back to tuple/list from iterencode.
    
    Args:
        value (str): Encoded string
        
    Returns:
        tuple: Decoded values
    """

def gettext(string, **variables):
    """
    Get translated string with variable substitution.
    
    Args:
        string (str): String to translate
        **variables: Variables for string formatting
        
    Returns:
        str: Translated string
    """

def ngettext(singular, plural, num, **variables):
    """
    Get pluralized translation based on number.
    
    Args:
        singular (str): Singular form
        plural (str): Plural form  
        num (int): Number for pluralization
        **variables: Variables for string formatting
        
    Returns:
        str: Translated string (singular or plural)
    """

def lazy_gettext(string, **variables):
    """
    Lazy translation that resolves when string is used.
    
    Args:
        string (str): String to translate
        **variables: Variables for string formatting
        
    Returns:
        LazyString: Lazy translation object
    """

VALID_SCHEMES = ['http', 'https']    # Valid URL schemes for safety checking
CHAR_ESCAPE = '.'                    # Character used for escaping
CHAR_SEPARATOR = ','                 # Character used for separating values

from flask_admin.helpers import validate_form_on_submit, flash_errors
from flask import request, flash, redirect, url_for

class CustomModelView(ModelView):
    def create_view(self):
        form = self.create_form()
        
        if validate_form_on_submit(form):
            try:
                if self.create_model(form):
                    flash('Record created successfully!', 'success')
                    return redirect(url_for('.index_view'))
                else:
                    flash('Failed to create record.', 'error')
            except Exception as ex:
                flash(f'Error: {str(ex)}', 'error')
        else:
            # Flash form validation errors
            if request.method == 'POST':
                flash_errors(form, 'Please correct the errors below:')
        
        return self.render('admin/model/create.html', form=form)

from flask_admin.helpers import is_safe_url, get_redirect_target
from flask import request, redirect, url_for

class SecureView(BaseView):
    @expose('/')
    def index(self):
        # Get safe redirect target
        next_url = get_redirect_target('next')
        
        if next_url and is_safe_url(next_url):
            return redirect(next_url)
        
        return self.render('admin/secure_index.html')
    
    @expose('/login')
    def login(self):
        # Validate redirect URL from query parameter
        next_url = request.args.get('next')
        
        if next_url and not is_safe_url(next_url):
            # Block potentially malicious redirects
            flash('Invalid redirect URL detected.', 'warning')
            next_url = None
        
        return self.render('admin/login.html', next_url=next_url)

from flask_admin.tools import rec_getattr
from flask_admin.helpers import prettify_class_name

class DynamicModelView(ModelView):
    def __init__(self, model, *args, **kwargs):
        super().__init__(model, *args, **kwargs)
        
        # Auto-generate view name from model class
        if not kwargs.get('name'):
            self.name = prettify_class_name(model.__name__)
    
    def _format_nested_attribute(self, view, context, model, name):
        """Custom formatter supporting nested attributes."""
        # Use rec_getattr for nested attribute access like 'user.profile.name'
        value = rec_getattr(model, name, default='N/A')
        return str(value)
    
    def scaffold_list_columns(self):
        columns = super().scaffold_list_columns()
        
        # Add formatters for nested attributes
        nested_columns = [col for col in columns if '.' in col]
        for col in nested_columns:
            if col not in self.column_formatters:
                self.column_formatters[col] = self._format_nested_attribute
        
        return columns

from flask_admin.tools import import_attribute, import_module
from flask import current_app

class PluggableModelView(ModelView):
    def __init__(self, model, *args, **kwargs):
        super().__init__(model, *args, **kwargs)
        
        # Load custom formatters from configuration
        formatter_config = current_app.config.get('ADMIN_FORMATTERS', {})
        
        for field_name, formatter_path in formatter_config.items():
            try:
                formatter_func = import_attribute(formatter_path)
                self.column_formatters[field_name] = formatter_func
            except (ImportError, AttributeError) as ex:
                current_app.logger.warning(f'Failed to load formatter {formatter_path}: {ex}')
    
    def load_custom_filters(self):
        """Load custom filters from plugins."""
        filter_modules = current_app.config.get('ADMIN_FILTER_MODULES', [])
        
        custom_filters = []
        for module_name in filter_modules:
            try:
                module = import_module(module_name, required=False)
                if module and hasattr(module, 'get_filters'):
                    filters = module.get_filters(self.model)
                    custom_filters.extend(filters)
            except ImportError:
                current_app.logger.warning(f'Failed to load filter module: {module_name}')
        
        return custom_filters

from flask_admin.helpers import get_render_ctx, resolve_ctx
from flask import g

class EnhancedView(BaseView):
    def render(self, template, **kwargs):
        # Get current render context
        ctx = get_render_ctx()
        
        # Add custom context variables
        enhanced_ctx = {
            'current_user': getattr(g, 'user', None),
            'app_version': current_app.config.get('VERSION', 'Unknown'),
            'debug_mode': current_app.debug,
            'custom_menu_items': self.get_custom_menu_items()
        }
        
        # Merge contexts
        ctx.update(enhanced_ctx)
        ctx.update(kwargs)
        
        return super().render(template, **ctx)
    
    def get_custom_menu_items(self):
        """Generate custom menu items based on user permissions."""
        items = []
        
        if hasattr(g, 'user') and g.user:
            if g.user.can_access_reports:
                items.append({
                    'name': 'Reports',
                    'url': '/admin/reports/',
                    'icon': 'fa-chart-bar'
                })
        
        return items

from flask_admin.tools import iterencode, iterdecode
from flask import request, url_for

class FilterableView(ModelView):
    def apply_filters_from_url(self):
        """Apply filters from URL parameters."""
        # Decode filter parameters
        filter_param = request.args.get('filters')
        
        if filter_param:
            try:
                # Decode filter tuple from URL
                filter_ids = iterdecode(filter_param)
                
                # Apply filters
                for filter_id in filter_ids:
                    self.apply_filter(filter_id)
                    
            except (ValueError, TypeError):
                # Invalid filter parameter
                pass
    
    def generate_filtered_url(self, active_filters):
        """Generate URL with encoded filter parameters."""
        # Encode active filters for URL
        if active_filters:
            filter_param = iterencode(active_filters)
            return url_for('.index_view', filters=filter_param)
        
        return url_for('.index_view')