xnode-manager-sdk 1.0.4

Rust Software Development Kit for interacting with Xnode Manager
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

use crate::{
    file::{
        GetPermissions, Permission, SetPermissions,
        models::{
            CreateDirectory, Directory, File, ReadDirectory, ReadFile, RemoveDirectory, RemoveFile,
            WriteFile,
        },
    },
    utils::{
        Empty, SessionGetInput, SessionGetOutput, SessionPostInput, SessionPostOutput, session_get,
        session_post,
    },
};

pub fn scope() -> String {
    "/file".to_string()
}

#[derive(Debug, Clone, PartialEq)]
pub struct ReadFilePath {
    pub scope: String,
}
pub type ReadFileInput<'a> = SessionGetInput<'a, ReadFilePath, ReadFile>;
pub type ReadFileOutput = File;
pub async fn read_file(input: ReadFileInput<'_>) -> SessionGetOutput<ReadFileOutput> {
    session_get(input, scope(), |path| {
        format!("/{scope}/read_file", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct WriteFilePath {
    pub scope: String,
}
pub type WriteFileInput<'a> = SessionPostInput<'a, WriteFilePath, WriteFile>;
pub type WriteFileOutput = Empty;
pub async fn write_file(input: WriteFileInput<'_>) -> SessionPostOutput<WriteFileOutput> {
    session_post(input, scope(), |path| {
        format!("/{scope}/write_file", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct RemoveFilePath {
    pub scope: String,
}
pub type RemoveFileInput<'a> = SessionPostInput<'a, RemoveFilePath, RemoveFile>;
pub type RemoveFileOutput = Empty;
pub async fn remove_file(input: RemoveFileInput<'_>) -> SessionPostOutput<RemoveFileOutput> {
    session_post(input, scope(), |path| {
        format!("/{scope}/remove_file", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct ReadDirectoryPath {
    pub scope: String,
}
pub type ReadDirectoryInput<'a> = SessionGetInput<'a, ReadDirectoryPath, ReadDirectory>;
pub type ReadDirectoryOutput = Directory;
pub async fn read_directory(
    input: ReadDirectoryInput<'_>,
) -> SessionGetOutput<ReadDirectoryOutput> {
    session_get(input, scope(), |path| {
        format!("/{scope}/read_directory", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct CreateDirectoryPath {
    pub scope: String,
}
pub type CreateDirectoryInput<'a> = SessionPostInput<'a, CreateDirectoryPath, CreateDirectory>;
pub type CreateDirectoryOutput = Empty;
pub async fn create_directory(
    input: CreateDirectoryInput<'_>,
) -> SessionPostOutput<CreateDirectoryOutput> {
    session_post(input, scope(), |path| {
        format!("/{scope}/create_directory", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct RemoveDirectoryPath {
    pub scope: String,
}
pub type RemoveDirectoryInput<'a> = SessionPostInput<'a, RemoveDirectoryPath, RemoveDirectory>;
pub type RemoveDirectoryOutput = Empty;
pub async fn remove_directory(
    input: RemoveDirectoryInput<'_>,
) -> SessionPostOutput<RemoveDirectoryOutput> {
    session_post(input, scope(), |path| {
        format!("/{scope}/remove_directory", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct GetPermissionsPath {
    pub scope: String,
}
pub type GetPermissionsInput<'a> = SessionGetInput<'a, GetPermissionsPath, GetPermissions>;
pub type GetPermissionsOutput = Vec<Permission>;
pub async fn get_permissions(
    input: GetPermissionsInput<'_>,
) -> SessionGetOutput<GetPermissionsOutput> {
    session_get(input, scope(), |path| {
        format!("/{scope}/get_permissions", scope = path.scope)
    })
    .await
}

#[derive(Debug, Clone, PartialEq)]
pub struct SetPermissionsPath {
    pub scope: String,
}
pub type SetPermissionsInput<'a> = SessionPostInput<'a, SetPermissionsPath, SetPermissions>;
pub type SetPermissionsOutput = Empty;
pub async fn set_permissions(
    input: SetPermissionsInput<'_>,
) -> SessionPostOutput<SetPermissionsOutput> {
    session_post(input, scope(), |path| {
        format!("/{scope}/set_permissions", scope = path.scope)
    })
    .await
}