Skip to main content

xnode_manager_sdk/file/
handlers.rs

1use crate::{
2    file::{
3        GetPermissions, Permission, SetPermissions,
4        models::{
5            CreateDirectory, Directory, File, ReadDirectory, ReadFile, RemoveDirectory, RemoveFile,
6            WriteFile,
7        },
8    },
9    utils::{
10        Empty, SessionGetInput, SessionGetOutput, SessionPostInput, SessionPostOutput, session_get,
11        session_post,
12    },
13};
14
15pub fn scope() -> String {
16    "/file".to_string()
17}
18
19#[derive(Debug, Clone, PartialEq)]
20pub struct ReadFilePath {
21    pub scope: String,
22}
23pub type ReadFileInput<'a> = SessionGetInput<'a, ReadFilePath, ReadFile>;
24pub type ReadFileOutput = File;
25pub async fn read_file(input: ReadFileInput<'_>) -> SessionGetOutput<ReadFileOutput> {
26    session_get(input, scope(), |path| {
27        format!("/{scope}/read_file", scope = path.scope)
28    })
29    .await
30}
31
32#[derive(Debug, Clone, PartialEq)]
33pub struct WriteFilePath {
34    pub scope: String,
35}
36pub type WriteFileInput<'a> = SessionPostInput<'a, WriteFilePath, WriteFile>;
37pub type WriteFileOutput = Empty;
38pub async fn write_file(input: WriteFileInput<'_>) -> SessionPostOutput<WriteFileOutput> {
39    session_post(input, scope(), |path| {
40        format!("/{scope}/write_file", scope = path.scope)
41    })
42    .await
43}
44
45#[derive(Debug, Clone, PartialEq)]
46pub struct RemoveFilePath {
47    pub scope: String,
48}
49pub type RemoveFileInput<'a> = SessionPostInput<'a, RemoveFilePath, RemoveFile>;
50pub type RemoveFileOutput = Empty;
51pub async fn remove_file(input: RemoveFileInput<'_>) -> SessionPostOutput<RemoveFileOutput> {
52    session_post(input, scope(), |path| {
53        format!("/{scope}/remove_file", scope = path.scope)
54    })
55    .await
56}
57
58#[derive(Debug, Clone, PartialEq)]
59pub struct ReadDirectoryPath {
60    pub scope: String,
61}
62pub type ReadDirectoryInput<'a> = SessionGetInput<'a, ReadDirectoryPath, ReadDirectory>;
63pub type ReadDirectoryOutput = Directory;
64pub async fn read_directory(
65    input: ReadDirectoryInput<'_>,
66) -> SessionGetOutput<ReadDirectoryOutput> {
67    session_get(input, scope(), |path| {
68        format!("/{scope}/read_directory", scope = path.scope)
69    })
70    .await
71}
72
73#[derive(Debug, Clone, PartialEq)]
74pub struct CreateDirectoryPath {
75    pub scope: String,
76}
77pub type CreateDirectoryInput<'a> = SessionPostInput<'a, CreateDirectoryPath, CreateDirectory>;
78pub type CreateDirectoryOutput = Empty;
79pub async fn create_directory(
80    input: CreateDirectoryInput<'_>,
81) -> SessionPostOutput<CreateDirectoryOutput> {
82    session_post(input, scope(), |path| {
83        format!("/{scope}/create_directory", scope = path.scope)
84    })
85    .await
86}
87
88#[derive(Debug, Clone, PartialEq)]
89pub struct RemoveDirectoryPath {
90    pub scope: String,
91}
92pub type RemoveDirectoryInput<'a> = SessionPostInput<'a, RemoveDirectoryPath, RemoveDirectory>;
93pub type RemoveDirectoryOutput = Empty;
94pub async fn remove_directory(
95    input: RemoveDirectoryInput<'_>,
96) -> SessionPostOutput<RemoveDirectoryOutput> {
97    session_post(input, scope(), |path| {
98        format!("/{scope}/remove_directory", scope = path.scope)
99    })
100    .await
101}
102
103#[derive(Debug, Clone, PartialEq)]
104pub struct GetPermissionsPath {
105    pub scope: String,
106}
107pub type GetPermissionsInput<'a> = SessionGetInput<'a, GetPermissionsPath, GetPermissions>;
108pub type GetPermissionsOutput = Vec<Permission>;
109pub async fn get_permissions(
110    input: GetPermissionsInput<'_>,
111) -> SessionGetOutput<GetPermissionsOutput> {
112    session_get(input, scope(), |path| {
113        format!("/{scope}/get_permissions", scope = path.scope)
114    })
115    .await
116}
117
118#[derive(Debug, Clone, PartialEq)]
119pub struct SetPermissionsPath {
120    pub scope: String,
121}
122pub type SetPermissionsInput<'a> = SessionPostInput<'a, SetPermissionsPath, SetPermissions>;
123pub type SetPermissionsOutput = Empty;
124pub async fn set_permissions(
125    input: SetPermissionsInput<'_>,
126) -> SessionPostOutput<SetPermissionsOutput> {
127    session_post(input, scope(), |path| {
128        format!("/{scope}/set_permissions", scope = path.scope)
129    })
130    .await
131}