wekan-cli 0.1.0

Agent-first, human-friendly command-line client for Wekan
Documentation 
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

pub mod api;
pub mod auth;
pub(crate) mod authenticated;
pub mod boards;
pub mod cards;
pub(crate) mod client_error;
pub mod comments;
pub(crate) mod credential_ops;
pub mod lists;
pub mod profile;
pub mod swimlanes;
pub mod users;

use clap::Subcommand;

use crate::{
    client::WekanClientFactory,
    command_result::CommandSuccess,
    config::profiles::ProfileStore,
    credentials::{CredentialStore, SecretInputProvider},
    error::AppError,
    input::ConfirmationProvider,
};

#[derive(Debug, Subcommand)]
pub enum RootCommand {
    /// Send a low-level request to the selected Wekan server.
    Api(api::ApiArgs),

    /// Authenticate with a Wekan server.
    Auth(auth::AuthArgs),

    /// Manage named local Wekan server profiles.
    Profile(profile::ProfileArgs),

    /// Inspect and administer Wekan users.
    User(users::UserArgs),

    /// Inspect and manage Wekan boards.
    Board(boards::BoardArgs),

    /// Inspect and manage lists on Wekan boards.
    List(lists::ListArgs),

    /// Inspect and manage cards in Wekan board lists.
    Card(Box<cards::CardArgs>),

    /// Inspect and manage comments on Wekan cards.
    Comment(comments::CommentArgs),

    /// Inspect and manage swimlanes on Wekan boards.
    Swimlane(swimlanes::SwimlaneArgs),
}

impl RootCommand {
    pub const fn supports_raw_output(&self) -> bool {
        matches!(self, Self::Api(_))
    }
}

pub(crate) enum PreparedCommand<'command, 'store> {
    Api {
        args: api::ApiArgs,
        client_factory: &'command WekanClientFactory,
    },
    Auth {
        command: auth::PreparedAuthCommand<'command, 'store>,
    },
    Profile {
        args: profile::ProfileArgs,
    },
    User {
        args: users::UserArgs,
        client_factory: &'command WekanClientFactory,
    },
    Board {
        args: boards::BoardArgs,
        client_factory: &'command WekanClientFactory,
    },
    List {
        args: lists::ListArgs,
        client_factory: &'command WekanClientFactory,
    },
    Card {
        args: Box<cards::CardArgs>,
        client_factory: &'command WekanClientFactory,
    },
    Comment {
        args: comments::CommentArgs,
        client_factory: &'command WekanClientFactory,
    },
    Swimlane {
        args: swimlanes::SwimlaneArgs,
        client_factory: &'command WekanClientFactory,
    },
}

pub(crate) async fn dispatch(
    command: PreparedCommand<'_, '_>,
    credential_store: &dyn CredentialStore,
    secret_input: &dyn SecretInputProvider,
    profile_store: &dyn ProfileStore,
    confirmation: &dyn ConfirmationProvider,
) -> Result<CommandSuccess, AppError> {
    match command {
        PreparedCommand::Api {
            args,
            client_factory,
        } => api::dispatch(args.command, client_factory, credential_store, confirmation).await,
        PreparedCommand::Auth { command } => {
            auth::dispatch(command, credential_store, secret_input, confirmation).await
        }
        PreparedCommand::Profile { args } => {
            profile::dispatch(args.command, profile_store, credential_store, confirmation)
        }
        PreparedCommand::User {
            args,
            client_factory,
        } => {
            users::dispatch(
                args.command,
                client_factory,
                credential_store,
                secret_input,
                confirmation,
            )
            .await
        }
        PreparedCommand::Board {
            args,
            client_factory,
        } => boards::dispatch(args.command, client_factory, credential_store, confirmation).await,
        PreparedCommand::List {
            args,
            client_factory,
        } => lists::dispatch(args.command, client_factory, credential_store, confirmation).await,
        PreparedCommand::Card {
            args,
            client_factory,
        } => cards::dispatch(args.command, client_factory, credential_store, confirmation).await,
        PreparedCommand::Comment {
            args,
            client_factory,
        } => comments::dispatch(args.command, client_factory, credential_store, confirmation).await,
        PreparedCommand::Swimlane {
            args,
            client_factory,
        } => {
            swimlanes::dispatch(args.command, client_factory, credential_store, confirmation).await
        }
    }
}