CLI Commands¶

import flet as ft
import flet_easy as fs
from pathlib import Path

from app.config import Config
from app.controllers import register_routes

# Initialize FletEasy app
app = fs.FletEasy(
    route_prefix=Config.ROUTE_PREFIX,
    route_init=Config.ROUTE_INIT,
    route_login=Config.ROUTE_LOGIN,
    secret_key=fs.SecretKey(Config.SECRET_KEY),
    auto_logout=Config.AUTO_LOGOUT,
    path_views=Path("app/views"),
    logger=Config.DEBUG
)

# Register all routes
register_routes(app)

# Configure global view
@app.view
def main_view(data: fs.Datasy):
    return fs.Viewsy(
        appbar=ft.AppBar(
            title=ft.Text(Config.APP_NAME),
            bgcolor=ft.Colors.BLUE,
            actions=[
                ft.IconButton(
                    ft.Icons.HOME,
                    on_click=data.go(data.route_init)
                )
            ]
        ),
        bgcolor=ft.Colors.GREY_50,
        padding=ft.padding.all(20)
    )

# Authentication handler
@app.login
def check_auth(data: fs.Datasy):
    token = data.page.client_storage.get("auth_token")
    return token is not None

if __name__ == "__main__":
    app.run(
        view=ft.AppView.WEB_BROWSER,
        port=Config.PORT,
        host=Config.HOST
    )

import os
from pathlib import Path

class Config:
    """Application configuration"""

    # App Settings
    APP_NAME = "Task Manager"
    DEBUG = os.getenv("DEBUG", "False").lower() == "true"

    # Server Settings
    HOST = os.getenv("HOST", "localhost")
    PORT = int(os.getenv("PORT", 8000))

    # Route Settings
    ROUTE_PREFIX = os.getenv("ROUTE_PREFIX", "")
    ROUTE_INIT = os.getenv("ROUTE_INIT", "/")
    ROUTE_LOGIN = os.getenv("ROUTE_LOGIN", "/login")

    # Security
    SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
    AUTO_LOGOUT = os.getenv("AUTO_LOGOUT", "True").lower() == "true"

    # Database (if using)
    DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///app.db")

    # Paths
    BASE_DIR = Path(__file__).parent.parent.parent
    STATIC_DIR = BASE_DIR / "app" / "static"

import flet as ft
import flet_easy as fs

def register_home_routes(app: fs.FletEasy):
    """Register home-related routes"""

    @app.page("/", title="Home")
    def home_page(data: fs.Datasy):
        return ft.View(
            "/",
            controls=[
                ft.Text("Welcome to Task Manager!", size=30),
                ft.Text("Manage your tasks efficiently", size=16),
                ft.ElevatedButton(
                    "Get Started",
                    on_click=data.go("/dashboard")
                ),
                ft.ElevatedButton(
                    "Login",
                    on_click=data.go("/login")
                )
            ],
            appbar=data.view.appbar,
            vertical_alignment=ft.MainAxisAlignment.CENTER,
            horizontal_alignment=ft.CrossAxisAlignment.CENTER
        )

    @app.page("/about", title="About")
    def about_page(data: fs.Datasy):
        return ft.View(
            "/about",
            controls=[
                ft.Text("About Task Manager", size=24),
                ft.Text(
                    "A simple and efficient task management application "
                    "built with Flet-Easy framework.",
                    size=14
                ),
                ft.ElevatedButton(
                    "← Back to Home",
                    on_click=data.go("/")
                )
            ],
            appbar=data.view.appbar
        )

from .home import register_home_routes
from .auth import register_auth_routes

def register_routes(app):
    """Register all application routes"""
    register_home_routes(app)
    register_auth_routes(app)

from dataclasses import dataclass
from typing import Optional
from datetime import datetime

@dataclass
class User:
    """User data model"""
    id: Optional[int] = None
    username: str = ""
    email: str = ""
    password_hash: str = ""
    created_at: Optional[datetime] = None
    is_active: bool = True

    def to_dict(self) -> dict:
        """Convert user to dictionary"""
        return {
            "id": self.id,
            "username": self.username,
            "email": self.email,
            "created_at": self.created_at.isoformat() if self.created_at else None,
            "is_active": self.is_active
        }

    @classmethod
    def from_dict(cls, data: dict) -> "User":
        """Create user from dictionary"""
        return cls(
            id=data.get("id"),
            username=data.get("username", ""),
            email=data.get("email", ""),
            password_hash=data.get("password_hash", ""),
            created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else None,
            is_active=data.get("is_active", True)
        )

import flet_easy as fs

class AuthMiddleware(fs.MiddlewareRequest):
    """Authentication middleware"""

    def before_request(self):
        """Check authentication before request"""
        # Skip auth check for public routes
        public_routes = ["/", "/login", "/register", "/about"]

        if self.data.route in public_routes:
            return None

        # Check if user is authenticated
        auth_token = self.data.page.client_storage.get("auth_token")
        if not auth_token:
            return fs.Redirect("/login")

        # Validate token (implement your validation logic)
        if not self._validate_token(auth_token):
            self.data.logout("auth_token")
            return fs.Redirect("/login")

        return None

    def after_request(self):
        """Log request after processing"""
        user_id = self.data.page.client_storage.get("user_id", "anonymous")
        print(f"User {user_id} accessed {self.data.route}")

    def _validate_token(self, token: str) -> bool:
        """Validate authentication token"""
        # Implement your token validation logic here
        # This is a placeholder implementation
        try:
            # Example: decode JWT token
            # decoded = fs.decode(token, secret_key)
            # return decoded is not None
            return len(token) > 10  # Placeholder validation
        except Exception:
            return False