taskman 0.1.1

Cli for the task management.
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

use clap::{Arg, command, Command};

use AppCommand::{CreateTaskCommand, DeleteTaskCommand, GetTasksCommand};

use crate::commands::{AppCommand, CreateTask, DeleteTask, GetTasks};

pub(crate) fn parse(_: Vec<String>) -> AppCommand {
    let matches = command!()
        .subcommand(Command::new("create")
            .about("Create resource")
            .args([
                Arg::new("resource")
                    .required(true)
                    .value_parser(["task"]),
            ]))
        .subcommand(Command::new("delete")
            .about("Delete resource")
            .arg(Arg::new("resource")
                .required(true)
                .value_parser(["task"])
            )
            .arg(Arg::new("id")
                .required(false)
            )
        )
        .subcommand(Command::new("get")
            .about("Get resource")
            .arg(
                Arg::new("resource")
                    .value_parser(["tasks"])
                    .required(true)
            )
        )
        .get_matches();


    if let Some(arg_m) = matches.subcommand_matches("create") {
        if let Some(arg_m) = arg_m.get_one::<String>("resource") {
            return match arg_m.as_str() {
                "task" => CreateTaskCommand(CreateTask),
                &_ => panic!("Not valid value = {}", arg_m.as_str())
            };
        }
    }

    if let Some(command) = matches.subcommand_matches("delete") {
        if let Some(resource) = command.get_one::<String>("resource") {
            match resource.as_str() {
                "task" => {
                    if let Some(id) = command.get_one::<String>("id") {
                        return DeleteTaskCommand(DeleteTask {
                            id: id.parse().expect("Resource id must be a number.")
                        });
                    }
                }
                &_ => panic!("Not valid value = {}", resource.as_str())
            };
        }
    }

    if let Some(command) = matches.subcommand_matches("get") {
        if let Some(resource) = command.get_one::<String>("resource") {
            return match resource.as_str() {
                "tasks" => {
                    GetTasksCommand(GetTasks::new(None, None))
                }
                &_ => panic!("Not valid value = {}", resource.as_str())
            };
        }
    }
    panic!("Parse error!")
}