Genies (神灯)

use genies::context::CONTEXT;
use genies::k8s::k8s_health_check;
use salvo::prelude::*;

#[tokio::main]
async fn main() {
    // Initialize logging
    genies::config::log_config::init_log();
    
    // Initialize database connection
    CONTEXT.init_mysql().await;
    
    log::info!("Server starting at: http://{}", 
        CONTEXT.config.server_url.replace("0.0.0.0", "127.0.0.1"));
    
    // Build routes
    let router = Router::new()
        .push(k8s_health_check())  // K8s health check
        .push(Router::with_path("/api")
            .hoop(genies::context::auth::salvo_auth)  // JWT auth middleware
            .get(hello));
    
    // Start server
    let acceptor = TcpListener::new(&CONTEXT.config.server_url).bind().await;
    Server::new(acceptor).serve(router).await;
}

#[endpoint]
async fn hello() -> &'static str {
    "Hello, Genies!"
}

use genies_derive::Aggregate;
use serde::{Deserialize, Serialize};

#[derive(Aggregate, Debug, Serialize, Deserialize, Clone)]
#[aggregate_type("me.tdcarefor.order.domain.Order")]  // Optional: specify aggregate type name
#[id_field(id)]                                       // Required: specify ID field
#[initialize_with_defaults]                           // Optional: enable default value initialization
pub struct Order {
    pub id: String,
    pub customer_id: String,
    pub total_amount: f64,
    pub status: String,
}

impl AggregateType for Order {
    fn aggregate_type(&self) -> String { ... }
    fn atype() -> String { ... }
}

impl WithAggregateId for Order {
    type Id = String;
    fn aggregate_id(&self) -> &Self::Id { &self.id }
}

use genies_derive::DomainEvent;
use serde::{Deserialize, Serialize};

// Struct form
#[derive(DomainEvent, Debug, Serialize, Deserialize, Default, Clone)]
#[event_type_version("V1")]
#[event_source("me.tdcarefor.order.domain.Order")]
#[event_type("me.tdcarefor.order.event.OrderCreated")]
pub struct OrderCreatedEvent {
    pub order_id: String,
    pub customer_id: String,
    pub total_amount: f64,
}

// Enum form (multiple event types)
#[derive(DomainEvent, Debug, Serialize, Deserialize, Clone)]
#[event_type_version("V1")]
#[event_source("me.tdcarefor.order.domain.Order")]
pub enum OrderEvent {
    #[event_type("OrderCreated")]
    Created { order_id: String, customer_id: String },
    
    #[event_type("OrderShipped")]
    Shipped { order_id: String, tracking_number: String },
    
    #[event_type("OrderCancelled")]
    Cancelled { order_id: String, reason: String },
}

impl DomainEvent for OrderCreatedEvent {
    fn event_type_version(&self) -> String { "V1".to_string() }
    fn event_type(&self) -> String { "me.tdcarefor.order.event.OrderCreated".to_string() }
    fn event_source(&self) -> String { "me.tdcarefor.order.domain.Order".to_string() }
    fn json(&self) -> String { serde_json::to_string(self).unwrap() }
}

use genies::ddd::DomainEventPublisher::{publish, publishGenericDomainEvent};

// Publish an event associated with an aggregate root
async fn create_order(tx: &mut dyn Executor, order: &Order) -> Result<()> {
    let event = OrderCreatedEvent {
        order_id: order.id.clone(),
        customer_id: order.customer_id.clone(),
        total_amount: order.total_amount,
    };
    
    // Event will be associated with the Order aggregate root
    publish(tx, order, Box::new(event)).await;
    Ok(())
}

// Publish a generic domain event (not associated with any aggregate root)
async fn send_notification(tx: &mut dyn Executor) -> Result<()> {
    let event = NotificationEvent { message: "Hello".to_string() };
    publishGenericDomainEvent(tx, Box::new(event)).await;
    Ok(())
}

use genies_derive::topic;
use rbatis::executor::Executor;

#[topic(
    name = "me.tdcarefor.order.domain.Order",  // Topic name to subscribe to
    pubsub = "messagebus"                       // Dapr pubsub component name
)]
pub async fn on_order_created(
    tx: &mut dyn Executor,
    event: OrderCreatedEvent
) -> anyhow::Result<u64> {
    log::info!("Received order created event: {:?}", event);
    
    // Process the event...
    // Transactions are managed automatically: commit on success, rollback and retry on failure
    
    Ok(0)
}

use genies::{dapr_event_router, dapr_subscribe_handler};

// In main(), add Dapr event routes:
let router = Router::new()
    .push(business_routes())
    .push(dapr_event_router())       // Auto-collects all #[topic] handler routes
    .push(dapr_subscribe_handler()); // Dapr subscription discovery endpoint

use genies_derive::Config;
use serde::Deserialize;

#[derive(Config, Debug, Deserialize)]
pub struct MyAppConfig {
    #[config(default = "my-service")]
    pub server_name: String,
    
    #[config(default = "8080")]
    pub port: u32,
    
    #[config(default = "")]
    pub api_key: Option<String>,
    
    #[config(default = "")]
    pub allowed_origins: Vec<String>,
}

// Using the configuration
fn main() {
    let config = MyAppConfig::from_sources("./application.yml").unwrap();
    println!("Server: {}:{}", config.server_name, config.port);
}

impl MyAppConfig {
    pub fn from_file(path: &str) -> Result<Self, ConfigError>;
    pub fn from_sources(file_path: &str) -> Result<Self, ConfigError>;
    pub fn validate(&self) -> Result<(), ConfigError>;
    pub fn merge(&mut self, other: Self);
    pub fn load_env(&mut self) -> Result<(), ConfigError>;
}

use genies_derive::casbin;
use serde::{Serialize, Deserialize};
use salvo::oapi::ToSchema;

#[casbin]                           // Must be placed first
#[derive(Serialize, Deserialize, ToSchema)]
pub struct UserProfile {
    pub id: u64,
    pub name: String,
    pub email: String,
    pub phone: String,
    pub credit_card: String,
}

use genies_auth::casbin_auth;

// The casbin_auth middleware must be applied to routes that return #[casbin] VOs
let router = Router::with_path("users")
    .hoop(casbin_auth())       // Injects enforcer + subject into Depot
    .push(Router::with_path("{id}").get(get_user_profile));

use genies::context::CONTEXT;
use std::time::Duration;

async fn cache_example() -> Result<()> {
    let cache = &CONTEXT.cache_service;
    
    // String operations
    cache.set_string("key1", "value1").await?;
    let value = cache.get_string("key1").await?;
    cache.del_string("key1").await?;
    
    // With expiration
    cache.set_string_ex("session", "token123", Some(Duration::from_secs(3600))).await?;
    
    // JSON operations
    let user = User { id: 1, name: "test".to_string() };
    cache.set_json("user:1", &user).await?;
    let user: User = cache.get_json("user:1").await?;
    
    // Get TTL
    let ttl = cache.ttl("session").await?;
    
    Ok(())
}

#[async_trait]
pub trait ICacheService: Sync + Send {
    async fn set_string(&self, k: &str, v: &str) -> Result<String>;
    async fn get_string(&self, k: &str) -> Result<String>;
    async fn del_string(&self, k: &str) -> Result<String>;
    async fn set_string_ex(&self, k: &str, v: &str, ex: Option<Duration>) -> Result<String>;
    async fn ttl(&self, k: &str) -> Result<i64>;
}

use genies_derive::remote;
use once_cell::sync::Lazy;

// Define service base URL using config_gateway! macro
pub static UserService: Lazy<String> = genies::config_gateway!("/user-service");

#[remote]
#[get(url = UserService, path = "/api/users/{id}")]
pub async fn get_user_by_id(#[path] id: i64) -> feignhttp::Result<User> { impled!() }

// No need to manually pass the Authorization header
async fn example() {
    let user = get_user_by_id(123).await.unwrap();
}

use genies::k8s::k8s_health_check;
use salvo::Router;

let router = Router::new()
    .push(k8s_health_check());  // Automatically adds health check routes

// Provided endpoints:
// GET /actuator/health/liveness  - Liveness probe
// GET /actuator/health/readiness - Readiness probe

use genies::context::SERVICE_STATUS;
use std::ops::DerefMut;

fn set_not_ready() {
    let mut status = SERVICE_STATUS.lock().unwrap();
    let map = status.deref_mut();
    map.insert("readinessProbe".to_string(), false);
}

use std::sync::Arc;
use genies_auth::{EnforcerManager, LocalAuthConfig, combined_auth};

// In main():
let auth_config = Arc::new(LocalAuthConfig::new(&CONTEXT.config.jwt_secret));
let mgr = Arc::new(EnforcerManager::new().await.unwrap());

let router = Router::new()
    .hoop(affix_state::inject(auth_config.clone()))
    .hoop(affix_state::inject(mgr.clone()))
    .hoop(combined_auth)    // JWT + Casbin combined
    .push(business_routes());

pub trait DomainEvent: Send {
    fn event_type_version(&self) -> String;  // Event version
    fn event_type(&self) -> String;          // Event type identifier
    fn event_source(&self) -> String;        // Event source
    fn json(&self) -> String;                // Serialize to JSON
}

pub trait AggregateType {
    fn aggregate_type(&self) -> String;  // Get aggregate type name
    fn atype() -> String;                // Static method to get type name
}

pub trait WithAggregateId {
    type Id: Debug + Clone + PartialEq + Serialize + DeserializeOwned;
    fn aggregate_id(&self) -> &Self::Id;  // Get aggregate ID
}

#[async_trait]
pub trait ICacheService: Sync + Send {
    async fn set_string(&self, k: &str, v: &str) -> Result<String>;
    async fn get_string(&self, k: &str) -> Result<String>;
    async fn del_string(&self, k: &str) -> Result<String>;
    async fn set_string_ex(&self, k: &str, v: &str, ex: Option<Duration>) -> Result<String>;
    async fn ttl(&self, k: &str) -> Result<i64>;
}

pub struct RespVO<T> {
    pub code: Option<String>,   // "SUCCESS" or "FAIL"
    pub msg: Option<String>,    // Error message
    pub data: Option<T>,        // Response data
}

impl<T> RespVO<T> {
    pub fn from_result(arg: &Result<T>) -> Self;
    pub fn from(arg: &T) -> Self;
    pub fn from_error(code: &str, arg: &Error) -> Self;
    pub fn from_error_info(code: &str, info: &str) -> Self;
}

pub struct ResultDTO<T> {
    pub status: Option<i32>,    // 1=success, 0=failure
    pub message: Option<String>,
    pub data: Option<T>,
}

impl<T> ResultDTO<T> {
    pub fn success(message: &str, data: T) -> Self;
    pub fn error(message: &str) -> Self;
    pub fn success_empty(message: &str) -> ResultDTO<()>;
}

let rb = pool!();
User::select_by_id(rb, 1).await?;

let mut tx = tx_defer!();
User::insert(&mut tx, &user).await?;
tx.commit().await;  // Auto-rollback if not committed

let user_dto = copy!(&user_entity, UserDTO);

// DeviceUseEvent.rs - Define domain event
#[derive(DomainEvent, Debug, Serialize, Deserialize, Default, Clone)]
#[event_type_version("V2")]
#[event_source("me.tdcarefor.tdnis.device.domain.DeptDeviceEntity")]
#[event_type("me.tdcarefor.tdnis.device.event.DeviceUseEvent")]
pub struct DeviceUseEvent {
    pub id: Option<i64>,
    pub name: Option<String>,
    pub deviceNo: Option<String>,
}

// UseDeviceListeners.rs - Event consumer
#[topic(
    name = "me.tdcarefor.tdnis.device.domain.DeptDeviceEntity",
    pubsub = "messagebus"
)]
pub async fn onDeviceUseEvent(
    tx: &mut dyn Executor,
    event: DeviceUseEvent
) -> anyhow::Result<u64> {
    log::info!("Processing device use event: {:?}", event);
    Ok(0)
}