zulip-api 0.0.8

use serde::{Deserialize, Serialize};

use crate::message::channel_permission::*;
use crate::{field_access, impl_default, impl_display, StreamPostPolicy, TopicsPolicy};

/// Represents one of the channels that is visible to the user, and the user has never been subscribed to.
///
/// Important for clients containing UI where one can browse channels to subscribe to.
///
/// **Changes**: Before Zulip 10.0 (feature level 362), archived channels did not appear in this list, even if the `archived_channels` `client capability` was declared by the client.  Prior to Zulip 10.0 (feature level 349), if a user was in `can_administer_channel_group` of a channel that they never subscribed to, but not an organization administrator, the channel in question would not be part of this array.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NeverSubscribed {
    #[serde(skip_serializing_if = "Option::is_none")]
    stream_id: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    is_archived: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    date_created: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    creator_id: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    invite_only: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    rendered_description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    is_web_public: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    stream_post_policy: Option<StreamPostPolicy>,
    #[serde(skip_serializing_if = "Option::is_none")]
    message_retention_days: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    history_public_to_subscribers: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    topics_policy: Option<TopicsPolicy>,
    #[serde(skip_serializing_if = "Option::is_none")]
    first_message_id: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    folder_id: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    is_recently_active: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    is_announcement_only: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_add_subscribers_group: Option<CanAddSubscribersGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_remove_subscribers_group: Option<CanRemoveSubscribersGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_administer_channel_group: Option<CanAdministerChannelGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_delete_any_message_group: Option<CanDeleteAnyMessageGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_delete_own_message_group: Option<CanDeleteOwnMessageGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_move_messages_out_of_channel_group: Option<CanMoveMessagesOutOfChannelGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_move_messages_within_channel_group: Option<CanMoveMessagesWithinChannelGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_send_message_group: Option<CanSendMessageGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_subscribe_group: Option<CanSubscribeGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    can_resolve_topics_group: Option<CanResolveTopicsGroup>,
    #[serde(skip_serializing_if = "Option::is_none")]
    subscriber_count: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    stream_weekly_traffic: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    subscribers: Option<Vec<u64>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    partial_subscribers: Option<Vec<u64>>,
}

impl NeverSubscribed {
    /// Creates a new [NeverSubscribed].
    pub const fn new() -> Self {
        Self {
            stream_id: None,
            name: None,
            is_archived: None,
            description: None,
            date_created: None,
            creator_id: None,
            invite_only: None,
            rendered_description: None,
            is_web_public: None,
            stream_post_policy: None,
            message_retention_days: None,
            history_public_to_subscribers: None,
            topics_policy: None,
            first_message_id: None,
            folder_id: None,
            is_recently_active: None,
            is_announcement_only: None,
            can_add_subscribers_group: None,
            can_remove_subscribers_group: None,
            can_administer_channel_group: None,
            can_delete_any_message_group: None,
            can_delete_own_message_group: None,
            can_move_messages_out_of_channel_group: None,
            can_move_messages_within_channel_group: None,
            can_send_message_group: None,
            can_subscribe_group: None,
            can_resolve_topics_group: None,
            subscriber_count: None,
            stream_weekly_traffic: None,
            subscribers: None,
            partial_subscribers: None,
        }
    }
}

field_access! {
    NeverSubscribed {
        stream_id: option { u64 },
        is_archived: option { bool },
        date_created: option { u64 },
        creator_id: option { u64 },
        invite_only: option { bool },
        is_web_public: option { bool },
        stream_post_policy: option { StreamPostPolicy },
        message_retention_days: option { u64 },
        history_public_to_subscribers: option { bool },
        topics_policy: option { TopicsPolicy },
        first_message_id: option { u64 },
        folder_id: option { u64 },
        is_recently_active: option { bool },
        is_announcement_only: option { bool },
        subscriber_count: option { u64 },
        /// The average number of messages sent to the channel per week, as estimated based on recent weeks, rounded to the nearest integer.
        ///
        /// If `null`, the channel was recently created and there is insufficient data to estimate the average traffic.
        stream_weekly_traffic: option { u64 },
    }
}

field_access! {
    NeverSubscribed {
        name: option_cow_deref { str, String },
        description: option_cow_deref { str, String },
        rendered_description: option_cow_deref { str, String },
    }
}

field_access! {
    NeverSubscribed {
        can_add_subscribers_group: option_cow_ref { CanAddSubscribersGroup },
        can_remove_subscribers_group: option_cow_ref { CanRemoveSubscribersGroup },
        can_administer_channel_group: option_cow_ref { CanAdministerChannelGroup },
        can_delete_any_message_group: option_cow_ref { CanDeleteAnyMessageGroup },
        can_delete_own_message_group: option_cow_ref { CanDeleteOwnMessageGroup },
        can_move_messages_out_of_channel_group: option_cow_ref { CanMoveMessagesOutOfChannelGroup },
        can_move_messages_within_channel_group: option_cow_ref { CanMoveMessagesWithinChannelGroup },
        can_send_message_group: option_cow_ref { CanSendMessageGroup },
        can_subscribe_group: option_cow_ref { CanSubscribeGroup },
        can_resolve_topics_group: option_cow_ref { CanResolveTopicsGroup },
    }
}

field_access! {
    NeverSubscribed {
        /// A list of user IDs of users who are subscribed to the channel.
        ///
        /// Included only if `include_subscribers` is `true`.
        ///
        /// If a user is not allowed to know the subscribers for a channel, we will send an empty array.
        ///
        /// API authors should use other data to determine whether users like guest users are forbidden to know the subscribers.
        subscribers: option_cow_deref { [u64], Vec<u64> },
        /// If [`include_subscribers=\"partial\"`](https://zulip.com/api/get-subscriptions#parameter-include_subscribers) was requested,
        /// the server may, at its discretion, send a `partial_subscribers` list rather than a `subscribers` list for channels with a large number of subscribers.
        ///
        /// The `partial_subscribers` list contains an arbitrary subset of the channel's subscribers that is guaranteed to include all bot user
        /// subscribers as well as all users who have been active in the last 14 days, but otherwise can be chosen arbitrarily by the server.
        ///
        /// If a user is not allowed to know the subscribers for a channel, we will send an empty array.
        /// API authors should use other data to determine whether users like guest users are forbidden to know the subscribers.
        ///
        /// **Changes**: New in Zulip 11.0 (feature level 412).
        partial_subscribers: option_cow_deref { [u64], Vec<u64> },
    }
}

impl_default!(NeverSubscribed);
impl_display!(NeverSubscribed);

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_never_subscribed() {
        let stream_id = 1;
        let name = "test name";
        let is_archived = true;
        let description = "test description";
        let date_created = 2;
        let creator_id = 3;
        let invite_only = false;
        let rendered_description = "<p>description</p>";
        let is_web_public = true;
        let stream_post_policy = StreamPostPolicy::new();
        let message_retention_days = 4;
        let history_public_to_subscribers = false;
        let topics_policy = TopicsPolicy::new();
        let first_message_id = 5;
        let folder_id = 6;
        let is_recently_active = true;
        let is_announcement_only = false;
        let can_add_subscribers_group = CanAddSubscribersGroup::new();
        let can_remove_subscribers_group = CanRemoveSubscribersGroup::new();
        let can_administer_channel_group = CanAdministerChannelGroup::new();
        let can_delete_any_message_group = CanDeleteAnyMessageGroup::new();
        let can_delete_own_message_group = CanDeleteOwnMessageGroup::new();
        let can_move_messages_out_of_channel_group = CanMoveMessagesOutOfChannelGroup::new();
        let can_move_messages_within_channel_group = CanMoveMessagesWithinChannelGroup::new();
        let can_send_message_group = CanSendMessageGroup::new();
        let can_subscribe_group = CanSubscribeGroup::new();
        let can_resolve_topics_group = CanResolveTopicsGroup::new();
        let subscriber_count = 7;
        let stream_weekly_traffic = 8;
        let subscribers = [9u64];
        let partial_subscribers = [10u64];

        let never = NeverSubscribed::new()
            .with_stream_id(stream_id)
            .with_name(name)
            .with_is_archived(is_archived)
            .with_description(description)
            .with_date_created(date_created)
            .with_creator_id(creator_id)
            .with_invite_only(invite_only)
            .with_rendered_description(rendered_description)
            .with_is_web_public(is_web_public)
            .with_stream_post_policy(stream_post_policy)
            .with_message_retention_days(message_retention_days)
            .with_history_public_to_subscribers(history_public_to_subscribers)
            .with_topics_policy(topics_policy)
            .with_first_message_id(first_message_id)
            .with_folder_id(folder_id)
            .with_is_recently_active(is_recently_active)
            .with_is_announcement_only(is_announcement_only)
            .with_can_add_subscribers_group(&can_add_subscribers_group)
            .with_can_remove_subscribers_group(&can_remove_subscribers_group)
            .with_can_administer_channel_group(&can_administer_channel_group)
            .with_can_delete_any_message_group(&can_delete_any_message_group)
            .with_can_delete_own_message_group(&can_delete_own_message_group)
            .with_can_move_messages_out_of_channel_group(&can_move_messages_out_of_channel_group)
            .with_can_move_messages_within_channel_group(&can_move_messages_within_channel_group)
            .with_can_send_message_group(&can_send_message_group)
            .with_can_subscribe_group(&can_subscribe_group)
            .with_can_resolve_topics_group(&can_resolve_topics_group)
            .with_subscriber_count(subscriber_count)
            .with_stream_weekly_traffic(stream_weekly_traffic)
            .with_subscribers(subscribers.as_ref())
            .with_partial_subscribers(partial_subscribers.as_ref());
        let never_json = never.to_string();

        assert_eq!(serde_json::to_string(&never).unwrap(), never_json);
        assert_eq!(
            serde_json::from_str::<NeverSubscribed>(&never_json).unwrap(),
            never
        );

        assert_eq!(never.stream_id(), Some(stream_id));
        assert_eq!(never.name(), Some(name));
        assert_eq!(never.is_archived(), Some(is_archived));
        assert_eq!(never.description(), Some(description));
        assert_eq!(never.date_created(), Some(date_created));
        assert_eq!(never.creator_id(), Some(creator_id));
        assert_eq!(never.invite_only(), Some(invite_only));
        assert_eq!(never.rendered_description(), Some(rendered_description));
        assert_eq!(never.is_web_public(), Some(is_web_public));
        assert_eq!(never.stream_post_policy(), Some(stream_post_policy));
        assert_eq!(never.message_retention_days(), Some(message_retention_days));
        assert_eq!(
            never.history_public_to_subscribers(),
            Some(history_public_to_subscribers)
        );
        assert_eq!(never.topics_policy(), Some(topics_policy));
        assert_eq!(never.first_message_id(), Some(first_message_id));
        assert_eq!(never.folder_id(), Some(folder_id));
        assert_eq!(never.is_recently_active(), Some(is_recently_active));
        assert_eq!(never.is_announcement_only(), Some(is_announcement_only));
        assert_eq!(
            never.can_add_subscribers_group(),
            Some(&can_add_subscribers_group)
        );
        assert_eq!(
            never.can_remove_subscribers_group(),
            Some(&can_remove_subscribers_group)
        );
        assert_eq!(
            never.can_administer_channel_group(),
            Some(&can_administer_channel_group)
        );
        assert_eq!(
            never.can_delete_any_message_group(),
            Some(&can_delete_any_message_group)
        );
        assert_eq!(
            never.can_delete_own_message_group(),
            Some(&can_delete_own_message_group)
        );
        assert_eq!(
            never.can_move_messages_out_of_channel_group(),
            Some(&can_move_messages_out_of_channel_group)
        );
        assert_eq!(
            never.can_move_messages_within_channel_group(),
            Some(&can_move_messages_within_channel_group)
        );
        assert_eq!(
            never.can_send_message_group(),
            Some(&can_send_message_group)
        );
        assert_eq!(never.can_subscribe_group(), Some(&can_subscribe_group));
        assert_eq!(
            never.can_resolve_topics_group(),
            Some(&can_resolve_topics_group)
        );
        assert_eq!(never.subscriber_count(), Some(subscriber_count));
        assert_eq!(never.stream_weekly_traffic(), Some(stream_weekly_traffic));
        assert_eq!(never.subscribers(), Some(subscribers.as_ref()));
        assert_eq!(
            never.partial_subscribers(),
            Some(partial_subscribers.as_ref())
        );
    }
}