nextcloud-client-api 0.1.0

implementation of the socket API for the NextCloud client
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
132
133
134
135

use core::fmt::{Display, Formatter, Result as FmtResult};

use thiserror::Error as ThisError;

#[derive(Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum ApiVerb {
    RetrieveFolderStatus,
    RetrieveFileStatus,
    Version,
    GetStrings,
    GetMenuItems,
    ShareMenuTitle,
    Activity,
    Encrypt,
    Share,
    Leaveshare,
    ManagePublicLinks,
    CopySecurefiledropLink,
    CopyPublicLink,
    CopyPrivateLink,
    EmailPrivateLink,
    OpenPrivateLink,
    MakeAvailableLocally,
    MakeOnlineOnly,
    ResolveConflict,
    DeleteItem,
    MoveItem,
    LockFile,
    UnlockFile,
    UpdateFolderView,
    RegisterPath,
    UnregisterPath,
    String,
    Status,
    MenuItem,
}

#[derive(Debug, ThisError)]
#[non_exhaustive]
pub enum Error {
    #[error("failed to parse verb: {0}")]
    ParsingFailed(String),
}

impl From<ApiVerb> for &str {
    #[inline]
    fn from(value: ApiVerb) -> Self {
        Self::from(&value)
    }
}

impl From<&ApiVerb> for &str {
    #[inline]
    fn from(value: &ApiVerb) -> Self {
        match *value {
            ApiVerb::RetrieveFolderStatus => "RETRIEVE_FOLDER_STATUS",
            ApiVerb::RetrieveFileStatus => "RETRIEVE_FILE_STATUS",
            ApiVerb::Version => "VERSION",
            ApiVerb::GetStrings => "GET_STRINGS",
            ApiVerb::GetMenuItems => "GET_MENU_ITEMS",
            ApiVerb::ShareMenuTitle => "SHARE_MENU_TITLE",
            ApiVerb::Activity => "ACTIVITY",
            ApiVerb::Encrypt => "ENCRYPT",
            ApiVerb::Share => "SHARE",
            ApiVerb::Leaveshare => "LEAVESHARE",
            ApiVerb::ManagePublicLinks => "MANAGE_PUBLIC_LINKS",
            ApiVerb::CopySecurefiledropLink => "COPY_SECUREFILEDROP_LINK",
            ApiVerb::CopyPublicLink => "COPY_PUBLIC_LINK",
            ApiVerb::CopyPrivateLink => "COPY_PRIVATE_LINK",
            ApiVerb::EmailPrivateLink => "EMAIL_PRIVATE_LINK",
            ApiVerb::OpenPrivateLink => "OPEN_PRIVATE_LINK",
            ApiVerb::MakeAvailableLocally => "MAKE_AVAILABLE_LOCALLY",
            ApiVerb::MakeOnlineOnly => "MAKE_ONLINE_ONLY",
            ApiVerb::ResolveConflict => "RESOLVE_CONFLICT",
            ApiVerb::DeleteItem => "DELETE_ITEM",
            ApiVerb::MoveItem => "MOVE_ITEM",
            ApiVerb::LockFile => "LOCK_FILE",
            ApiVerb::UnlockFile => "UNLOCK_FILE",
            ApiVerb::UpdateFolderView => "UPDATE_VIEW",
            ApiVerb::RegisterPath => "REGISTER_PATH",
            ApiVerb::UnregisterPath => "UNREGISTER_PATH",
            ApiVerb::String => "STRING",
            ApiVerb::Status => "STATUS",
            ApiVerb::MenuItem => "MENU_ITEM",
        }
    }
}

impl TryFrom<&str> for ApiVerb {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Ok(match value {
            "RETRIEVE_FOLDER_STATUS" => ApiVerb::RetrieveFolderStatus,
            "RETRIEVE_FILE_STATUS" => ApiVerb::RetrieveFileStatus,
            "VERSION" => ApiVerb::Version,
            "GET_STRINGS" => ApiVerb::GetStrings,
            "GET_MENU_ITEMS" => ApiVerb::GetMenuItems,
            "SHARE_MENU_TITLE" => ApiVerb::ShareMenuTitle,
            "ACTIVITY" => ApiVerb::Activity,
            "ENCRYPT" => ApiVerb::Encrypt,
            "SHARE" => ApiVerb::Share,
            "LEAVESHARE" => ApiVerb::Leaveshare,
            "MANAGE_PUBLIC_LINKS" => ApiVerb::ManagePublicLinks,
            "COPY_SECUREFILEDROP_LINK" => ApiVerb::CopySecurefiledropLink,
            "COPY_PUBLIC_LINK" => ApiVerb::CopyPublicLink,
            "COPY_PRIVATE_LINK" => ApiVerb::CopyPrivateLink,
            "EMAIL_PRIVATE_LINK" => ApiVerb::EmailPrivateLink,
            "OPEN_PRIVATE_LINK" => ApiVerb::OpenPrivateLink,
            "MAKE_AVAILABLE_LOCALLY" => ApiVerb::MakeAvailableLocally,
            "MAKE_ONLINE_ONLY" => ApiVerb::MakeOnlineOnly,
            "RESOLVE_CONFLICT" => ApiVerb::ResolveConflict,
            "DELETE_ITEM" => ApiVerb::DeleteItem,
            "MOVE_ITEM" => ApiVerb::MoveItem,
            "LOCK_FILE" => ApiVerb::LockFile,
            "UNLOCK_FILE" => ApiVerb::UnlockFile,
            "UPDATE_VIEW" => ApiVerb::UpdateFolderView,
            "REGISTER_PATH" => ApiVerb::RegisterPath,
            "UNREGISTER_PATH" => ApiVerb::UnregisterPath,
            "STRING" => ApiVerb::String,
            "STATUS" => ApiVerb::Status,
            "MENU_ITEM" => ApiVerb::MenuItem,
            _ => return Err(Error::ParsingFailed(format!("invalid verb: {value}"))),
        })
    }
}

impl Display for ApiVerb {
    #[expect(clippy::min_ident_chars, reason = "defined by trait")]
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        let verb: &str = self.into();
        write!(f, "{verb}")
    }
}