args-cli 0.1.1

Command-line interface for args
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

use anyhow::Result;

use args_api::endpoint::user::{
    get_current_user::{GetCurrentUserRequest, GetCurrentUserResponse},
    get_user::{GetUserRequest, GetUserResponse},
    has_user::HasUserApiRequest,
    list_user_memberships::{ListUserMembershipsRequest, ListUserMembershipsResponse},
    list_user_repositories::{ListUserRepositoriesRequest, ListUserRepositoriesResponse},
    list_user_reviews::{ListUserReviewsRequest, ListUserReviewsResponse},
    update_current_user::{UpdateCurrentUserRequest, UpdateCurrentUserResponse},
};

use crate::client::ArgsClient;

#[allow(dead_code)]
impl ArgsClient {
    pub async fn get_current_user(
        &self,
        request: GetCurrentUserRequest,
    ) -> Result<GetCurrentUserResponse> {
        self.get("user".to_string(), request).await
    }

    pub async fn get_user(
        &self,
        user_name: &str,
        request: GetUserRequest,
    ) -> Result<GetUserResponse> {
        self.get(format!("user/{}", user_name), request).await
    }

    pub async fn has_user(&self, user_name: &str, request: HasUserApiRequest) -> Result<()> {
        self.head(format!("user/{}", user_name), request).await
    }

    pub async fn list_user_repositories(
        &self,
        user_name: &str,
        request: ListUserRepositoriesRequest,
    ) -> Result<ListUserRepositoriesResponse> {
        self.get(format!("user/{}/repositories", user_name), request)
            .await
    }

    pub async fn list_user_memberships(
        &self,
        user_name: &str,
        request: ListUserMembershipsRequest,
    ) -> Result<ListUserMembershipsResponse> {
        self.get(format!("user/{}/memberships", user_name), request)
            .await
    }

    pub async fn list_user_reviews(
        &self,
        user_name: &str,
        request: ListUserReviewsRequest,
    ) -> Result<ListUserReviewsResponse> {
        self.get(format!("user/{}/reviews", user_name), request)
            .await
    }

    pub async fn update_current_user(
        &self,
        request: UpdateCurrentUserRequest,
    ) -> Result<UpdateCurrentUserResponse> {
        self.patch("user".to_string(), request).await
    }
}