impl ActiveModelBehavior for ActiveModel {
    fn before_save<C>(self, _db: &C, insert: bool) -> Result<Self, DbErr>
    where
        C: ConnectionTrait,
    {
        let mut this = self;
        if insert {
            // Set creation timestamp on insert
            this.created_at = Set(chrono::Utc::now());
        }
        // Always update the updated_at timestamp
        this.updated_at = Set(chrono::Utc::now());
        Ok(this)
    }
}

use sea_orm::entity::prelude::*;

#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum)]
#[sea_orm(rs_type = "String", db_type = "String(Some(20))")]
pub enum UserStatus {
    #[sea_orm(string_value = "active")]
    Active,
    #[sea_orm(string_value = "inactive")]
    Inactive,
    #[sea_orm(string_value = "locked")]
    Locked,
}

#[derive(Debug, Clone, PartialEq, DeriveEntityModel)]
#[sea_orm(table_name = "sys_user")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i64,
    pub status: UserStatus,  // Auto-mapped to/from VARCHAR
}

use sea_orm::{QueryOrder, PaginatorTrait};

// Ordered query
let users = entity::sys_user::Entity::find()
    .order_by_asc(entity::sys_user::Column::Username)
    .all(&db).await?;

// Paginated query
let paginator = entity::sys_user::Entity::find()
    .order_by_desc(entity::sys_user::Column::CreatedAt)
    .paginate(&db, 20);  // 20 items per page

let total_pages = paginator.num_pages().await?;
let total_items = paginator.num_items().await?;
let page = paginator.fetch_page(0).await?;  // Page 0 (first page)

// Delete by ID
entity::sys_user::Entity::delete_by_id(1001).exec(&db).await?;

// Delete with conditions
use sea_orm::{EntityTrait, QueryFilter, ColumnTrait};
entity::sys_user::Entity::delete_many()
    .filter(entity::sys_user::Column::Status.eq(0))
    .exec(&db).await?;

use sea_orm::{EntityTrait, RelationTrait};

// Load users with their department info
let users = entity::sys_user::Entity::find()
    .find_also_related(entity::sys_dept::Entity)
    .all(&db).await?;
// Vec<(sys_user::Model, Option<sys_dept::Model>)>

impl ActiveModelBehavior for ActiveModel {
    /// Called before saving (insert or update)
    fn before_save<C>(self, _db: &C, insert: bool) -> Result<Self, DbErr>
    where C: ConnectionTrait {
        let mut this = self;
        if insert {
            this.created_at = Set(chrono::Utc::now());
        }
        this.updated_at = Set(chrono::Utc::now());
        Ok(this)
    }

    /// Called after saving (insert or update)
    fn after_save<C>(model: Model, _db: &C, insert: bool) -> Result<Model, DbErr>
    where C: ConnectionTrait {
        tracing::info!("Model saved: {:?}", model.id);
        Ok(model)
    }

    /// Called before deleting
    fn before_delete<C>(self, _db: &C) -> Result<Self, DbErr>
    where C: ConnectionTrait {
        tracing::warn!("Deleting model");
        Ok(self)
    }
}

use sea_orm::{ActiveModelTrait, Set};

let user = entity::sys_user::ActiveModel {
    username: Set("alice".to_owned()),
    password_hash: Set(hash_password("secret")),
    status: Set(1),
    created_at: Set(chrono::Utc::now()),
    ..Default::default()
};
let result = user.insert(&db).await?;

#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {
    // Belongs To (many-to-one)
    #[sea_orm(
        belongs_to = "super::sys_dept::Entity",
        from = "Column::DeptId",
        to = "super::sys_dept::Column::Id"
    )]
    Dept,

    // Has Many (one-to-many)
    #[sea_orm(
        has_many = "super::sys_login_log::Entity",
        from = "Column::Id",
        to = "super::sys_login_log::Column::UserId"
    )]
    LoginLogs,
}