domo 0.3.2

The Domo Rust SDK wrapping our APIs. Also includes a CLI application.
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

use domo::public::page::Collection;
use domo::public::page::Page;
use domo::public::Client;

use structopt::StructOpt;

use super::util;

/// Wraps the page api
#[derive(StructOpt, Debug)]
pub enum PageCommand {
    #[structopt(name = "list")]
    List {
        #[structopt(short = "l", long = "limit")]
        limit: Option<u32>,
        #[structopt(short = "o", long = "offset")]
        offset: Option<u32>,
    },
    #[structopt(name = "create")]
    Create {},

    #[structopt(name = "retrieve")]
    Retrieve { id: u64 },

    #[structopt(name = "update")]
    Update { id: u64 },

    #[structopt(name = "delete")]
    Delete { id: u64 },

    #[structopt(name = "list-collections")]
    ListCollections { id: u64 },

    #[structopt(name = "create-collection")]
    CreateCollection { id: u64 },

    #[structopt(name = "update-collection")]
    UpdateCollection { id: u64, collection_id: u64 },

    #[structopt(name = "delete-collection")]
    DeleteCollection { id: u64, collection_id: u64 },
}

pub async fn execute(dc: Client, editor: &str, template: Option<String>, command: PageCommand) {
    match command {
        PageCommand::List { limit, offset } => {
            let r = dc.get_pages(limit, offset).await.unwrap();
            util::vec_obj_template_output(r, template);
        }
        PageCommand::Create {} => {
            let r = Page::template();
            let r = util::edit_obj(editor, r, "").unwrap();
            let r = dc.post_page(r).await.unwrap();
            util::obj_template_output(r, template);
        }
        PageCommand::Retrieve { id } => {
            let r = dc.get_page(id).await.unwrap();
            util::obj_template_output(r, template);
        }
        PageCommand::Update { id } => {
            let r = dc.get_page(id).await.unwrap();
            let r = util::edit_obj(editor, r, "").unwrap();
            let r = dc.put_page(id, r).await.unwrap();
            util::obj_template_output(r, template);
        }
        PageCommand::Delete { id } => {
            dc.delete_page(id).await.unwrap();
        }
        PageCommand::ListCollections { id } => {
            let r = dc.get_page_collections(id).await.unwrap();
            util::vec_obj_template_output(r, template);
        }
        PageCommand::CreateCollection { id } => {
            let r = Collection::template();
            let r = util::edit_obj(editor, r, "").unwrap();
            let r = dc.post_page_collection(id, r).await.unwrap();
            util::obj_template_output(r, template);
        }
        PageCommand::UpdateCollection { id, collection_id } => {
            let r = dc.get_page_collections(id).await.unwrap();
            let r: Collection = {
                let mut ret: Option<Collection> = None;
                for c in r {
                    if let Some(id) = c.id {
                        if id == collection_id {
                            ret = Some(c);
                        }
                    }
                }
                if let Some(c) = ret {
                    c
                } else {
                    panic!("Invalid Collection Id");
                }
            };
            let r = util::edit_obj(editor, r, "").unwrap();
            dc.put_page_collection(id, collection_id, r).await.unwrap();
        }
        PageCommand::DeleteCollection { id, collection_id } => {
            dc.delete_page_collection(id, collection_id).await.unwrap();
        }
    }
}