Scheduler, events, cache and commands

use renox::prelude::*;
use renox::chrono::Weekday;
use std::time::Duration;

/// A task: refresh the stock from a supplier. (Empty here.)
async fn sync_stock(_state: AppState) -> Result { Ok(()) }
/// A task: build a report. (Empty here.)
async fn report(_state: AppState) -> Result { Ok(()) }

/// The app, with one task for each kind of timetable.
fn app() -> App {
    App::new().schedule(|s| {
        // A task can also be written in place, as a closure.
        s.every_minute("heartbeat", |_state| async move { Ok(()) });
        s.every_minutes(5, "sync-stock", sync_stock) // :00, :05, :10 … on the clock
            .weekdays()
            .between("08:00", "17:00");
        s.every(Duration::from_secs(30 * 60), "refresh-rates", report);
        s.hourly("hourly-report", report);
        // Every night at 02:00, delete carts nobody touched for 30 days.
        s.daily_at("02:00", "cleanup", |state| async move {
            renox::db::sql("DELETE FROM carts WHERE updated_at < ?")
                .bind(renox::db::now() - renox::chrono::TimeDelta::days(30))
                .execute(&state.db)
                .await?;
            Ok(())
        });
        s.weekly_on(Weekday::Mon, "07:00", "weekly-report", report);
        s.monthly_on(1, "00:05", "invoices", report); // day 29–31 skips shorter months
        s.cron("30 9 * * 1-5", "standup", report) // minute hour day month weekday
            .timezone("Europe/Amsterdam");
    })
}

use renox::prelude::*;

/// The backup task. (Empty here.)
async fn backup(_state: AppState) -> Result { Ok(()) }

/// Runs when the backup fails: queue a mail to the address in ALERT_EMAIL.
async fn alert(err: Error, state: AppState) {
    let to = state.config.var("ALERT_EMAIL").unwrap_or_else(|| "[email protected]".into());
    let mail = renox::mail::Mail::new(to, "The backup failed", format!("{err:?}"));
    // Even the alert can fail; then the best we can do is print the error.
    if let Err(err) = state.queue_mail(mail).await {
        eprintln!("could not queue the alert: {err:?}");
    }
}

/// The app, with the backup at 03:00, three pings and the alert.
fn app() -> App {
    App::new().schedule(|s| {
        s.daily_at("03:00", "backup", backup)
            .ping_before("https://hc-ping.com/your-uuid/start")
            .ping_on_success("https://hc-ping.com/your-uuid")
            .ping_on_failure("https://hc-ping.com/your-uuid/fail")
            .on_failure(alert);
    })
}

use renox::prelude::*;
use renox::report::{ErrorReport, ReportKind};

/// The app, with a reporter that hears about every failed scheduled task.
fn app() -> App {
    App::new().report(|report: ErrorReport, _state: AppState| async move {
        // Reports also come from other places; only look at scheduled tasks here.
        if report.kind == ReportKind::ScheduledTask {
            eprintln!("task {:?} failed: {}", report.source, report.message);
        }
    })
}

use renox::prelude::*;
use std::time::Duration;

/// One day, as a `Duration`.
const DAY: Duration = Duration::from_secs(24 * 60 * 60);

/// Deletes old rows from every table that grows, then prints how many.
async fn housekeeping(state: AppState) -> Result {
    let db = &state.db;
    let cache = state.cache.prune().await?; // expired rows (CACHE_STORE=database)
    let sessions = Session::prune_expired(db).await?; // SESSION_DRIVER=database
    let tokens = renox::auth::prune_expired_tokens(db, DAY).await?; // expired over a day ago
    let read = renox::auth::prune_read_notifications(db, 30 * DAY).await?; // read over 30 days ago
    let audit = renox::audit::prune(db, 365 * DAY).await?; // the Audit module's log
    let failed = state.queue.prune_failed(7 * DAY).await?; // failed_jobs
    let batches = state.queue.prune_batches(DAY).await?; // finished job_batches
    println!("pruned {cache} cache, {sessions} sessions, {tokens} tokens, {read} notifications, \
              {audit} audit entries, {failed} failed jobs, {batches} batches");
    Ok(())
}

/// The app, with the Auth and Audit modules, and housekeeping every day at 04:00.
fn app() -> App {
    App::new()
        .module(Auth::new())
        .module(renox::audit::Audit)
        .schedule(|s| {
            s.daily_at("04:00", "housekeeping", housekeeping);
        })
}

use renox::prelude::*;
use renox::testing::TestApp;

/// An app with one task, which counts its runs in the cache.
fn app() -> App {
    App::new().schedule(|s| {
        s.daily_at("02:00", "count", |state| async move {
            state.cache.increment("runs", 1).await?;
            Ok(())
        });
    })
}

/// Runs the task once, and checks that the count is 1.
async fn the_task_counts() -> Result {
    let app = TestApp::new(app()).await;
    app.kernel().run_scheduled("count").await?;
    assert_eq!(app.state().cache.get::<i64>("runs").await?, Some(1));
    Ok(())
}

use renox::prelude::*;
use serde::{Deserialize, Serialize};

/// The event: an order was placed. It carries the order's id.
#[derive(Clone, Debug)]
struct OrderPlaced {
    order_id: i64,
}

impl Event for OrderPlaced {} // Clone + Send + Sync + 'static

/// A queue job that sends the receipt.
#[derive(Serialize, Deserialize)]
struct SendReceipt { order_id: i64 }

impl Job for SendReceipt {
    const NAME: &'static str = "send-receipt";
    async fn handle(self, _ctx: JobContext) -> Result { Ok(()) }
}

/// The stock module: it listens for orders and lowers the stock.
struct Stock;

impl Module for Stock {
    fn name(&self) -> &'static str { "stock" }

    /// Called at boot: this is where a module adds its listeners.
    fn register(&self, app: &mut Registry) {
        app.listen(|event: OrderPlaced, state| async move {
            renox::db::sql("UPDATE products SET stock = stock - 1 WHERE id IN \
                            (SELECT product_id FROM order_items WHERE order_id = ?)")
                .bind(event.order_id)
                .execute(&state.db)
                .await?;
            Ok(())
        });
    }
}

/// The app: a listener of its own (queue the receipt), plus the stock module's.
fn app() -> App {
    App::new()
        .job::<SendReceipt>()
        .listen(|event: OrderPlaced, state| async move {
            state.dispatch(SendReceipt { order_id: event.order_id }).await?; // slow work: queue it
            Ok(())
        })
        .module(Stock)
}

/// A handler that places an order: it emits the event, then goes to the orders page.
async fn place(State(state): State<AppState>) -> Result<Redirect> {
    state.emit(OrderPlaced { order_id: 1 }).await?;
    Ok(Redirect::to("/orders"))
}

use renox::prelude::*;
use renox::testing::TestApp;

/// A small event for the test.
#[derive(Clone, Debug)]
struct OrderPlaced { order_id: i64 }
impl Event for OrderPlaced {}

/// Checks that emitting the event is recorded, with the right order id.
async fn placing_an_order_emits_the_event() -> Result {
    let app = TestApp::new(App::new()).await;
    app.fake_events();
    app.state().emit(OrderPlaced { order_id: 7 }).await?; // usually: app.post("/orders", …)
    app.assert_emitted::<OrderPlaced>(|e| e.order_id == 7);
    assert_eq!(app.emitted::<OrderPlaced>().len(), 1);
    Ok(())
}

use renox::prelude::*;
use std::time::Duration;

/// Shows each cache method once.
async fn demo(state: AppState) -> Result {
    let cache = &state.cache;
    // remember: read "products.count"; if it's missing or too old, count again and keep it.
    let count: i64 = cache
        .remember("products.count", Duration::from_secs(60), || async {
            renox::db::sql("SELECT COUNT(*) FROM products").scalar(&state.db).await.map_err(Into::into)
        })
        .await?; // computed once a minute; errors are not cached

    cache.put("banner", &"Sale today", Some(Duration::from_secs(3600))).await?; // None: no expiry
    let banner: Option<String> = cache.get("banner").await?;
    let present = cache.has("banner").await?;
    let first = cache.add("welcome-sent:7", &true, None).await?; // false if already there
    let code: Option<String> = cache.pull("otp:7").await?; // read and remove
    let views = cache.increment("views:home", 1).await?; // atomic; 1 the first time
    cache.decrement("stock:42", 1).await?;
    cache.forget("banner").await?;
    cache.flush().await?; // everything the app cached; keeps the framework's `renox:` rows
    let _ = (count, banner, present, first, code, views);
    Ok(())
}

use renox::prelude::*;
use std::time::Duration;

/// Builds the sales report, unless someone else already is.
async fn sales_report(state: AppState) -> Result {
    // Held for 5 minutes at most, so a crashed holder doesn't block others forever.
    let lock = state.cache.lock("sales-report", Duration::from_secs(300));
    let Some(guard) = lock.try_acquire().await? else {
        return Ok(()); // someone else is on it
    };
    // … build and send the report …
    guard.release().await?; // or let it drop (released in the background)
    Ok(())
}

/// Works on one order, waiting a little if someone else is working on it.
async fn work_on_order(state: AppState, order_id: i64) -> Result {
    let lock = state.cache.lock(&format!("order:{order_id}"), Duration::from_secs(30));
    let guard = lock.block(Duration::from_secs(5)).await?; // waits up to 5 s, then 423 Locked
    // … one process at a time …
    drop(guard);
    Ok(())
}

use renox::prelude::*;
use renox::command::Args;

/// The command `admin:create --email E --password P`: makes an admin user.
async fn create_admin(args: Args, state: AppState) -> Result {
    // Both flags are needed; if one is missing, say how to use the command.
    let (Some(email), Some(password)) = (args.value("--email"), args.value("--password")) else {
        return Err(Error::BadRequest("usage: admin:create --email E --password P".into()));
    };
    User::register(&state.db, "Admin", email, password).await?;
    println!("Created {email}.");
    Ok(())
}

/// The app, with the command registered under its name and a one-line description.
fn app() -> App {
    App::new()
        .module(Auth::new())
        .command("admin:create", "Create an admin user (--email, --password)", create_admin)
}

use renox::prelude::*;
use renox::clap;
use renox::command::AppCommand;

/// Delete entries older than --days (default 30).
#[derive(clap::Parser)]
#[command(name = "entries:prune")]
struct PruneEntries {
    /// Keep entries younger than this many days.
    #[arg(long, default_value_t = 30)]
    days: i64,
    /// Don't ask first.
    #[arg(long)]
    force: bool,
}

impl AppCommand for PruneEntries {
    /// What the command does. `self` holds the options, already read and checked.
    async fn run(self, state: AppState) -> Result {
        // Ask first, unless --force was given.
        let question = format!("Delete entries older than {} days?", self.days);
        if !self.force && !renox::prompt::confirm(&question, true).await? {
            return Ok(());
        }
        let cutoff = renox::db::now() - renox::chrono::TimeDelta::days(self.days);
        let deleted = renox::db::sql("DELETE FROM entries WHERE created_at < ?")
            .bind(cutoff)
            .execute(&state.db)
            .await?;
        println!("Deleted {deleted} entries.");
        Ok(())
    }
}

/// The app, with the typed command.
fn app() -> App {
    App::new().typed_command::<PruneEntries>()
}

use renox::prelude::*;
use renox::prompt;

/// Makes a user, asking for anything that wasn't given as a flag.
async fn create_user(args: renox::command::Args, state: AppState) -> Result {
    // Use --email if it was typed; otherwise ask for it.
    let email = match args.value("--email") {
        Some(email) => email.to_owned(),
        None => prompt::ask("Email").await?, // asks until something is typed
    };
    let name = prompt::ask_or("Name", "Admin").await?; // empty answer: the default
    let password = prompt::secret("Password").await?; // not echoed
    let role = prompt::choice("Role", &["admin", "staff"], Some("staff")).await?; // text or number
    if prompt::confirm(&format!("Create {email} as {role}?"), true).await? {
        User::register(&state.db, &name, &email, &password).await?;
    }
    Ok(())
}

use renox::prelude::*;
use renox::testing::TestApp;

/// Answers "no", checks nothing was deleted, then answers "yes".
async fn the_command_asks_first(app: TestApp) -> Result {
    renox::prompt::answering(["no"], app.kernel().call("entries:prune", ["--days", "7"])).await?;
    app.assert_database_count("entries", 2).await; // nothing deleted
    renox::prompt::answering(["yes"], app.kernel().call("entries:prune", ["--days", "7"])).await?;
    Ok(())
}

/// Runs a built-in command the way the real program does.
async fn the_binary_runs_a_built_in() -> Result {
    App::new().run_args(["migrate:status"]).await // any command, output on stdout
}