redclock 2026.4.26

time-tracking CLI for Redmine
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

// SPDX-FileCopyrightText: The redclock Authors
// SPDX-License-Identifier: 0BSD

use crate::cli::logs;
use crate::models::cli::ServerCommands;
use crate::models::configuration::{Configuration, ServerRegistration};

pub fn dispatch(command: &ServerCommands, configuration: Configuration) -> anyhow::Result<()> {
    match command {
        ServerCommands::Add(args) => add(
            configuration,
            &args.url,
            args.name.as_ref(),
            args.token.token.as_ref(),
            args.token.command.as_ref(),
            args.default,
        ),
        ServerCommands::Remove(args) => {
            remove(configuration, args.server_selection.server.as_ref())
        }
        ServerCommands::List(_) => {
            list(&configuration);
            Ok(())
        }
        ServerCommands::SetDefault(args) => set_default(configuration, &args.name),
    }
}

fn add(
    mut configuration: Configuration,
    server_url: &str,
    server_name: Option<&String>,
    token: Option<&String>,
    command: Option<&String>,
    default: bool,
) -> anyhow::Result<()> {
    let name = server_name.cloned().unwrap_or_else(|| {
        server_url
            .replace("https://", "")
            .replace("http://", "")
            .trim_end_matches('/')
            .to_lowercase()
    });

    if configuration.find_server(&name).is_some() {
        anyhow::bail!("Server name already exists. Please use a different name.");
    }

    let registration = ServerRegistration {
        name: name.clone(),
        url: server_url.to_owned(),
        api_key: token.cloned(),
        api_key_command: command.cloned(),
    };

    configuration.add_server(registration)?;
    logs::server_add_success(&name);
    if default {
        set_default(configuration, &name)?;
    }
    Ok(())
}

fn remove(mut configuration: Configuration, server_name: Option<&String>) -> anyhow::Result<()> {
    let name = configuration
        .select_server(server_name)
        .map(|server| server.name.clone())
        .ok_or_else(|| {
            anyhow::anyhow!(
                "No server found in configuration. Run 'redclock server add ...' first to add one"
            )
        })?;

    configuration.remove_server(&name)?;
    logs::server_remove_success(&name);
    Ok(())
}

fn list(configuration: &Configuration) {
    for server in &configuration.servers {
        let text = configuration
            .default_server
            .clone()
            .filter(|default| default == &server.name)
            .map_or_else(
                || format!("{}: {}", server.name, server.url),
                |default| format!("{}: {} (default)", default, server.url),
            );

        println!("{text}");
    }
}

fn set_default(mut configuration: Configuration, server_name: &str) -> anyhow::Result<()> {
    configuration.set_default_server(server_name)?;
    logs::server_set_default(server_name);
    Ok(())
}