wekan-cli 0.17.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

use clap::Args;

use crate::{
    client::{CreateCardRequest, WekanClientFactory},
    command_result::{CardCreateSuccess, CommandSuccess},
    commands::{
        authenticated::AuthenticatedContext, client_error::map_mutation_client_error_with_not_found,
    },
    credentials::CredentialStore,
    error::AppError,
    redaction::Redactor,
};

use super::{date_input, non_empty};

#[derive(Debug, Args)]
#[command(
    after_help = "Example:\n  wekan card create --board board-id --list list-id --title \"Plan next release\" --swimlane-id swimlane-id"
)]
#[command(next_help_heading = "Fields")]
pub struct CreateArgs {
    /// Wekan board ID.
    #[arg(long = "board", value_parser = non_empty, help_heading = "Target")]
    pub board_id: String,

    /// Wekan list ID.
    #[arg(long = "list", value_parser = non_empty, help_heading = "Target")]
    pub list_id: String,

    /// Card title; omit to use Wekan's empty default.
    #[arg(long, conflicts_with = "null_title")]
    pub title: Option<String>,

    /// Send an explicit null title.
    #[arg(long, conflicts_with = "title")]
    pub null_title: bool,

    /// Source card ID for linked-card creation. Wekan ignores other content fields.
    #[arg(long, value_parser = non_empty)]
    pub linked_id: Option<String>,

    /// Wekan swimlane ID.
    #[arg(long, value_parser = non_empty)]
    pub swimlane_id: String,

    /// Card description.
    #[arg(long, conflicts_with = "null_description")]
    pub description: Option<String>,

    /// Send an explicit null description.
    #[arg(long, conflicts_with = "description")]
    pub null_description: bool,

    /// Member ID; may be repeated.
    #[arg(long = "member", value_parser = non_empty)]
    pub members: Vec<String>,

    /// Assignee ID; may be repeated.
    #[arg(long = "assignee", value_parser = non_empty)]
    pub assignees: Vec<String>,

    /// Received date accepted by Wekan (timestamp, date-only, textual date or epoch milliseconds).
    #[arg(long, value_parser = date_input, allow_hyphen_values = true)]
    pub received_at: Option<crate::client::cards::CardDateInput>,

    /// Start date accepted by Wekan (timestamp, date-only, textual date or epoch milliseconds).
    #[arg(long, value_parser = date_input, allow_hyphen_values = true)]
    pub start_at: Option<crate::client::cards::CardDateInput>,

    /// Due date accepted by Wekan (timestamp, date-only, textual date or epoch milliseconds).
    #[arg(long, value_parser = date_input, allow_hyphen_values = true)]
    pub due_at: Option<crate::client::cards::CardDateInput>,

    /// End date accepted by Wekan (timestamp, date-only, textual date or epoch milliseconds).
    #[arg(long, value_parser = date_input, allow_hyphen_values = true)]
    pub end_at: Option<crate::client::cards::CardDateInput>,
}

pub(super) async fn execute(
    args: CreateArgs,
    client_factory: &WekanClientFactory,
    credential_store: &dyn CredentialStore,
) -> Result<CommandSuccess, AppError> {
    let request = CreateCardRequest {
        title: if args.null_title {
            Some(None)
        } else {
            args.title.map(Some)
        },
        linked_id: args.linked_id,
        swimlane_id: args.swimlane_id,
        description: if args.null_description {
            Some(None)
        } else {
            args.description.map(Some)
        },
        members: (!args.members.is_empty()).then_some(args.members),
        assignees: (!args.assignees.is_empty()).then_some(args.assignees),
        received_at: args.received_at,
        start_at: args.start_at,
        due_at: args.due_at,
        end_at: args.end_at,
    };
    let context = AuthenticatedContext::load(client_factory, credential_store)?;
    let redactor = Redactor::with_secret(context.record().token());
    let created = context
        .client()
        .create_card(
            &args.board_id,
            &args.list_id,
            &request,
            context.record().token(),
        )
        .await
        .map_err(|error| {
            map_mutation_client_error_with_not_found(
                error,
                &redactor,
                "card creation",
                "the linked source or requested card scope was not found",
            )
        })?;
    Ok(CommandSuccess::CardCreated(CardCreateSuccess {
        board_id: args.board_id,
        list_id: args.list_id,
        card_id: created.card_id,
    }))
}