path: root/rust/fatcat-cli/src/commands.rs

use anyhow::{anyhow, Context, Result};
use chrono_humanize::HumanTime;
use fatcat_openapi::models;
#[allow(unused_imports)]
use log::{self, debug, info};
use std::io::{Write, BufRead};
use tabwriter::TabWriter;
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};

use crate::api::FatcatApiClient;
//use crate::download::download_file;
use crate::entities::{ApiEntityModel, ApiModelIdent, ApiModelSer, Mutation, read_entity_file};
use crate::specifier::Specifier;

// Want to show:
// - whether api_token found
// - configured api_host we are connecting to
// - whether we can connect to remote host (eg, get most recent changelog)
// - whether our auth is valid
// - current active editgroup
#[derive(Debug, PartialEq, Clone, serde::Serialize)]
pub struct ClientStatus {
    pub has_api_token: bool,
    pub api_host: String,
    pub last_changelog: Option<i64>,
    pub account: Option<models::Editor>,
}

impl ClientStatus {
    pub fn generate(api_client: &mut FatcatApiClient) -> Result<Self> {
        let last_changelog = match api_client
            .rt
            .block_on(api_client.api.get_changelog(Some(1)))
        {
            Ok(fatcat_openapi::GetChangelogResponse::Success(entry_vec)) => {
                Some(entry_vec[0].index)
            }
            Ok(_) | Err(_) => None,
        };
        let has_api_token = api_client.api_token.is_some();
        let account: Option<models::Editor> = if has_api_token && last_changelog.is_some() {
            match api_client
                .rt
                .block_on(api_client.api.auth_check(None))
                .context("check auth token")?
            {
                fatcat_openapi::AuthCheckResponse::Success(_) => Ok(()),
                fatcat_openapi::AuthCheckResponse::Forbidden(err) => {
                    Err(anyhow!("Forbidden ({}): {}", err.error, err.message))
                }
                fatcat_openapi::AuthCheckResponse::NotAuthorized { body: err, .. } => {
                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
                }
                resp => return Err(anyhow!("{:?}", resp)).context("auth check failed"),
            }
            .context("check auth token")?;
            match api_client
                .rt
                .block_on(
                    api_client
                        .api
                        .get_editor(api_client.editor_id.as_ref().unwrap().to_string()),
                )
                .context("fetching editor account info")?
            {
                fatcat_openapi::GetEditorResponse::Found(editor) => Some(editor),
                fatcat_openapi::GetEditorResponse::NotFound(err) => {
                    return Err(anyhow!("Not Found: {}", err.message))
                }
                resp => return Err(anyhow!("{:?}", resp)).context("editor fetch failed"),
            }
        } else {
            None
        };
        Ok(ClientStatus {
            api_host: api_client.api_host.clone(),
            has_api_token,
            last_changelog,
            account,
        })
    }

    pub fn pretty_print(self) -> Result<()> {
        let mut color_stdout = StandardStream::stdout(if atty::is(atty::Stream::Stdout) {
            ColorChoice::Auto
        } else {
            ColorChoice::Never
        });
        let color_normal = ColorSpec::new();
        let mut color_bold = ColorSpec::new();
        color_bold.set_bold(true);
        let mut color_happy = ColorSpec::new();
        color_happy.set_fg(Some(Color::Green)).set_bold(true);
        let mut color_sad = ColorSpec::new();
        color_sad.set_fg(Some(Color::Red)).set_bold(true);

        color_stdout.set_color(&color_normal)?;
        write!(&mut color_stdout, "{:>16}: ", "API host")?;
        color_stdout.set_color(&color_bold)?;
        write!(&mut color_stdout, "{}", self.api_host)?;
        match self.last_changelog {
            Some(index) => {
                color_stdout.set_color(&color_happy)?;
                writeln!(&mut color_stdout, " [successfully connected]")?;
                color_stdout.set_color(&color_normal)?;
                write!(&mut color_stdout, "{:>16}: ", "Last changelog")?;
                color_stdout.set_color(&color_bold)?;
                writeln!(&mut color_stdout, "{}", index)?;
            }
            None => {
                color_stdout.set_color(&color_sad)?;
                writeln!(&mut color_stdout, " [Failed to connect]")?;
            }
        };
        color_stdout.set_color(&color_normal)?;
        write!(&mut color_stdout, "{:>16}: ", "API auth token")?;
        if self.has_api_token {
            color_stdout.set_color(&color_happy)?;
            writeln!(&mut color_stdout, "[configured]")?;
        } else {
            color_stdout.set_color(&color_sad)?;
            writeln!(&mut color_stdout, "[not configured]")?;
        };
        if let Some(editor) = self.account {
            color_stdout.set_color(&color_normal)?;
            write!(&mut color_stdout, "{:>16}: ", "Account")?;
            color_stdout.set_color(&color_bold)?;
            write!(&mut color_stdout, "{}", editor.username)?;
            if editor.is_bot == Some(true) {
                color_stdout
                    .set_color(ColorSpec::new().set_fg(Some(Color::Blue)).set_bold(true))?;
                write!(&mut color_stdout, " [bot]")?;
            }
            if editor.is_admin == Some(true) {
                color_stdout
                    .set_color(ColorSpec::new().set_fg(Some(Color::Magenta)).set_bold(true))?;
                write!(&mut color_stdout, " [admin]")?;
            }
            match editor.is_active {
                Some(true) => {
                    color_stdout.set_color(&color_happy)?;
                    writeln!(&mut color_stdout, " [active]")?;
                }
                Some(false) | None => {
                    color_stdout.set_color(&color_sad)?;
                    writeln!(&mut color_stdout, " [disabled]")?;
                }
            };
            color_stdout.set_color(&color_normal)?;
            writeln!(
                &mut color_stdout,
                "{:>16}  editor_{}",
                "",
                editor.editor_id.unwrap()
            )?;
        };
        color_stdout.set_color(&color_normal)?;
        Ok(())
    }
}

pub fn print_editgroups(eg_list: Vec<models::Editgroup>, json: bool) -> Result<()> {
    if json {
        for eg in eg_list {
            writeln!(&mut std::io::stdout(), "{}", eg.to_json_string()?)?;
        }
    } else {
        let mut tw = TabWriter::new(std::io::stdout());
        writeln!(
            tw,
            "editgroup_id\tchangelog_index\tcreated\tsubmitted\tdescription"
        )?;
        for eg in eg_list {
            writeln!(
                tw,
                "{}\t{}\t{}\t{}\t{}",
                eg.editgroup_id.unwrap(),
                eg.changelog_index
                    .map_or("-".to_string(), |v| v.to_string()),
                eg.created
                    .map_or("-".to_string(), |v| HumanTime::from(v).to_string()),
                eg.submitted
                    .map_or("-".to_string(), |v| HumanTime::from(v).to_string()),
                eg.description.unwrap_or_else(|| "-".to_string())
            )?;
        }
        tw.flush()?;
    }
    Ok(())
}

pub fn print_changelog_entries(entry_list: Vec<models::ChangelogEntry>, json: bool) -> Result<()> {
    if json {
        for entry in entry_list {
            writeln!(&mut std::io::stdout(), "{}", entry.to_json_string()?)?;
        }
    } else {
        let mut tw = TabWriter::new(std::io::stdout());
        writeln!(tw, "index\ttimestamp\teditor\teditgroup_description")?;
        for entry in entry_list {
            writeln!(
                tw,
                "{}\t{}\t{}\t{}",
                entry.index,
                HumanTime::from(entry.timestamp).to_string(),
                entry
                    .editgroup
                    .as_ref()
                    .unwrap()
                    .editor
                    .as_ref()
                    .map_or("-".to_string(), |v| v.username.to_string()),
                entry
                    .editgroup
                    .as_ref()
                    .unwrap()
                    .description
                    .as_ref()
                    .map_or("-".to_string(), |v| v.to_string()),
            )?;
        }
        tw.flush()?;
    }
    Ok(())
}

pub fn print_entity_histories(
    history_list: Vec<models::EntityHistoryEntry>,
    json: bool,
) -> Result<()> {
    if json {
        for history in history_list {
            writeln!(&mut std::io::stdout(), "{}", history.to_json_string()?)?;
        }
    } else {
        let mut tw = TabWriter::new(std::io::stdout());
        writeln!(
            tw,
            "changelog_index\ttype\ttimestamp\teditor\teditgroup_description"
        )?;
        for history in history_list {
            let state = match (
                history.edit.revision,
                history.edit.prev_revision,
                history.edit.redirect_ident,
            ) {
                (Some(_), None, None) => "create",
                (Some(_), Some(_), None) => "update",
                (None, _, None) => "delete",
                (None, _, Some(_)) => "redirect",
                _ => "-",
            };
            writeln!(
                tw,
                "{}\t{}\t{}\t{}\t{}",
                history.changelog_entry.index,
                state,
                HumanTime::from(history.changelog_entry.timestamp).to_string(),
                history
                    .editgroup
                    .editor
                    .map_or("-".to_string(), |v| v.username.to_string()),
                history
                    .editgroup
                    .description
                    .unwrap_or_else(|| "-".to_string())
            )?;
        }
        tw.flush()?;
    }
    Ok(())
}

pub fn edit_entity_locally(api_client: &mut FatcatApiClient,  specifier: Specifier, editgroup_id: String, json: bool, editing_command: String) -> Result<models::EntityEdit> {
    // TODO: fetch editgroup, check if this entity is already being updated in it. If so,
    // need to fetch that revision, do the edit, parse that synatx is good, then delete the
    // existing edit and update with the new one.
    let original_entity = specifier.get_from_api(api_client, None, None)?;
    let exact_specifier = original_entity.specifier();
    let tmp_file = tempfile::Builder::new()
        .suffix(if json { ".json" } else { ".toml" })
        .tempfile()?;
    if json {
        writeln!(&tmp_file, "{}", original_entity.to_json_string()?)?
    } else {
        writeln!(&tmp_file, "{}", original_entity.to_toml_string()?)?
    }
    let mut editor_cmd = std::process::Command::new(&editing_command)
        .arg(tmp_file.path())
        .spawn()
        .expect("failed to execute process");
    let cmd_status = editor_cmd.wait()?;
    if !cmd_status.success() {
        return Err(anyhow!(
            "editor ({}) exited with non-success status code ({}), bailing on edit",
            editing_command,
            cmd_status
                .code()
                .map(|v| v.to_string())
                .unwrap_or_else(|| "N/A".to_string())
        ));
    };
    let json_str = read_entity_file(Some(tmp_file.path().to_path_buf()))?;
    // for whatever reason api_client's TCP connection is broken after spawning, so try a
    // dummy call, expected to fail, but connection should re-establish after this
    specifier
        .get_from_api(api_client, None, None)
        .context("re-fetch")
        .ok();
    let ee = api_client
        .update_entity_from_json(exact_specifier, &json_str, editgroup_id)
        .context("updating after edit")?;
    Ok(ee)
}