claudetools/projects/msp-tools/guru-rmm/server/src/db/commands.rs

//! Commands database operations

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
use uuid::Uuid;

/// Command record from database
#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
pub struct Command {
    pub id: Uuid,
    pub agent_id: Uuid,
    pub command_type: String,
    pub command_text: String,
    pub status: String,
    pub exit_code: Option<i32>,
    pub stdout: Option<String>,
    pub stderr: Option<String>,
    pub created_at: DateTime<Utc>,
    pub started_at: Option<DateTime<Utc>>,
    pub completed_at: Option<DateTime<Utc>>,
    pub created_by: Option<Uuid>,
}

/// Create a new command
#[derive(Debug, Clone, Deserialize)]
pub struct CreateCommand {
    pub agent_id: Uuid,
    pub command_type: String,
    pub command_text: String,
    pub created_by: Option<Uuid>,
}

/// Insert a new command
pub async fn create_command(pool: &PgPool, cmd: CreateCommand) -> Result<Command, sqlx::Error> {
    sqlx::query_as::<_, Command>(
        r#"
        INSERT INTO commands (agent_id, command_type, command_text, status, created_by)
        VALUES ($1, $2, $3, 'pending', $4)
        RETURNING *
        "#,
    )
    .bind(cmd.agent_id)
    .bind(&cmd.command_type)
    .bind(&cmd.command_text)
    .bind(cmd.created_by)
    .fetch_one(pool)
    .await
}

/// Get a command by ID
pub async fn get_command_by_id(pool: &PgPool, id: Uuid) -> Result<Option<Command>, sqlx::Error> {
    sqlx::query_as::<_, Command>("SELECT * FROM commands WHERE id = $1")
        .bind(id)
        .fetch_optional(pool)
        .await
}

/// Get pending commands for an agent
pub async fn get_pending_commands(
    pool: &PgPool,
    agent_id: Uuid,
) -> Result<Vec<Command>, sqlx::Error> {
    sqlx::query_as::<_, Command>(
        r#"
        SELECT * FROM commands
        WHERE agent_id = $1 AND status = 'pending'
        ORDER BY created_at ASC
        "#,
    )
    .bind(agent_id)
    .fetch_all(pool)
    .await
}

/// Get command history for an agent
pub async fn get_agent_commands(
    pool: &PgPool,
    agent_id: Uuid,
    limit: i64,
) -> Result<Vec<Command>, sqlx::Error> {
    sqlx::query_as::<_, Command>(
        r#"
        SELECT * FROM commands
        WHERE agent_id = $1
        ORDER BY created_at DESC
        LIMIT $2
        "#,
    )
    .bind(agent_id)
    .bind(limit)
    .fetch_all(pool)
    .await
}

/// Get all recent commands
pub async fn get_recent_commands(pool: &PgPool, limit: i64) -> Result<Vec<Command>, sqlx::Error> {
    sqlx::query_as::<_, Command>(
        r#"
        SELECT * FROM commands
        ORDER BY created_at DESC
        LIMIT $1
        "#,
    )
    .bind(limit)
    .fetch_all(pool)
    .await
}

/// Update command status to running
pub async fn mark_command_running(pool: &PgPool, id: Uuid) -> Result<(), sqlx::Error> {
    sqlx::query("UPDATE commands SET status = 'running', started_at = NOW() WHERE id = $1")
        .bind(id)
        .execute(pool)
        .await?;
    Ok(())
}

/// Update command result
#[derive(Debug, Clone, Deserialize)]
pub struct CommandResult {
    pub exit_code: i32,
    pub stdout: String,
    pub stderr: String,
}

pub async fn update_command_result(
    pool: &PgPool,
    id: Uuid,
    result: CommandResult,
) -> Result<(), sqlx::Error> {
    let status = if result.exit_code == 0 {
        "completed"
    } else {
        "failed"
    };

    sqlx::query(
        r#"
        UPDATE commands
        SET status = $1, exit_code = $2, stdout = $3, stderr = $4, completed_at = NOW()
        WHERE id = $5
        "#,
    )
    .bind(status)
    .bind(result.exit_code)
    .bind(&result.stdout)
    .bind(&result.stderr)
    .bind(id)
    .execute(pool)
    .await?;

    Ok(())
}

/// Delete a command
pub async fn delete_command(pool: &PgPool, id: Uuid) -> Result<bool, sqlx::Error> {
    let result = sqlx::query("DELETE FROM commands WHERE id = $1")
        .bind(id)
        .execute(pool)
        .await?;
    Ok(result.rows_affected() > 0)
}