disma 0.16.4

Discord server management has never been easier!
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

use crate::{
    api::params::permission::PermissionsOverwriteParams,
    channel::{ChannelType, ExistingChannel},
};

use super::{ChannelParams, ChannelParamsChannelType, ChannelParamsPermissionsOverwritesStrategy};

impl From<&ExistingChannel> for ChannelParams {
    fn from(channel: &ExistingChannel) -> Self {
        let _type = channel.channel_type.clone().into();

        let category = channel
            .category
            .as_ref()
            .map(|category| category.name.clone());

        let permissions_overwrites = channel
            .overwrites
            .to_list()
            .iter()
            .map(PermissionsOverwriteParams::from)
            .collect::<Vec<PermissionsOverwriteParams>>();

        Self {
            name: channel.name.clone(),
            topic: channel.topic.clone(),
            _type,
            category,
            permissions_overwrites: ChannelParamsPermissionsOverwritesStrategy::Manual {
                items: permissions_overwrites,
            },
        }
    }
}

impl From<ChannelType> for ChannelParamsChannelType {
    fn from(value: ChannelType) -> Self {
        match value {
            ChannelType::TEXT => Self::TEXT,
            ChannelType::VOICE => Self::VOICE,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        api::params::{
            channel::{
                ChannelParams, ChannelParamsChannelType, ChannelParamsPermissionsOverwritesStrategy,
            },
            permission::PermissionsOverwriteParams,
        },
        category::ExistingCategory,
        channel::{ChannelType, ExistingChannel},
        permission::{
            Permission, PermissionsList, PermissionsOverwrite, PermissionsOverwritesList,
        },
        role::ExistingRole,
    };

    fn given_existing_category(name: &str) -> ExistingCategory {
        ExistingCategory {
            id: "some_id".to_string(),
            name: name.to_string(),
            overwrites: PermissionsOverwritesList::new(),
        }
    }

    fn given_existing_role(name: &str) -> ExistingRole {
        ExistingRole {
            id: "bob".to_string(),
            name: name.to_string(),
            permissions: PermissionsList::from(vec![Permission::VIEW_CHANNEL]),
            color: Some("123456".to_string()),
            is_mentionable: true,
            show_in_sidebar: false,
        }
    }

    fn given_matching_existing_and_params(
        name: &str,
        role: &ExistingRole,
        category: &ExistingCategory,
    ) -> (ExistingChannel, ChannelParams) {
        let existing = ExistingChannel {
            id: "something".to_string(),
            name: name.to_string(),
            category: Some(category.clone()),
            channel_type: ChannelType::VOICE,
            topic: Some("A nice winter".to_string()),
            overwrites: PermissionsOverwritesList::from(vec![PermissionsOverwrite {
                role: role.clone(),
                allow: PermissionsList::from(vec![Permission::ADMINISTRATOR]),
                deny: PermissionsList::from(vec![Permission::SEND_MESSAGES]),
            }]),
        };

        let params = ChannelParams {
            name: name.to_string(),
            category: Some(category.name.clone()),
            _type: ChannelParamsChannelType::VOICE,
            topic: Some("A nice winter".to_string()),
            permissions_overwrites: ChannelParamsPermissionsOverwritesStrategy::Manual {
                items: vec![PermissionsOverwriteParams {
                    role: role.name.clone(),
                    allow: vec![Permission::ADMINISTRATOR],
                    deny: vec![Permission::SEND_MESSAGES],
                }],
            },
        };

        (existing, params)
    }

    #[test]
    fn can_convert_existing_entity_to_params() {
        let name = "channel_1";
        let role = given_existing_role("role_1");
        let category = given_existing_category("category_1");
        let (existing, expected_params) =
            given_matching_existing_and_params(name, &role, &category);

        let params = ChannelParams::from(&existing);

        assert_eq!(params, expected_params);
    }
}