twilight_model/application/monetization/
sku_flags.rs

1use bitflags::bitflags;
2use serde::{
3    de::{Deserialize, Deserializer},
4    ser::{Serialize, Serializer},
5};
6
7bitflags! {
8    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9    pub struct SkuFlags: u64 {
10      /// SKU is available for purchase.
11      const AVAILABLE = 1 << 2;
12      /// A subscription purchased by a user and applied to a single server.
13      /// Everyone in that server gets your premium benefits.
14      const GUILD_SUBSCRIPTION = 1 << 7;
15      /// A subscription purchased by a user for themselves. They get access
16      /// to your premium benefits in every server.
17      const USER_SUBSCRIPTION = 1 << 8;
18    }
19}
20
21impl<'de> Deserialize<'de> for SkuFlags {
22    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
23        Ok(Self::from_bits_truncate(u64::deserialize(deserializer)?))
24    }
25}
26
27impl Serialize for SkuFlags {
28    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
29    where
30        S: Serializer,
31    {
32        serializer.serialize_u64(self.bits())
33    }
34}
35
36#[cfg(test)]
37mod tests {
38    use super::SkuFlags;
39    use serde::{Deserialize, Serialize};
40    use serde_test::Token;
41    use static_assertions::{assert_impl_all, const_assert_eq};
42    use std::{
43        fmt::{Binary, Debug, LowerHex, Octal, UpperHex},
44        hash::Hash,
45        ops::{
46            BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Sub, SubAssign,
47        },
48    };
49
50    assert_impl_all!(
51        SkuFlags: Binary,
52        BitAnd,
53        BitAndAssign,
54        BitOr,
55        BitOrAssign,
56        BitXor,
57        BitXorAssign,
58        Clone,
59        Copy,
60        Debug,
61        Deserialize<'static>,
62        Eq,
63        Extend<SkuFlags>,
64        FromIterator<SkuFlags>,
65        Hash,
66        LowerHex,
67        Not,
68        Octal,
69        PartialEq,
70        Send,
71        Serialize,
72        Sub,
73        SubAssign,
74        Sync,
75        UpperHex
76    );
77
78    const_assert_eq!(SkuFlags::AVAILABLE.bits(), 1 << 2);
79    const_assert_eq!(SkuFlags::GUILD_SUBSCRIPTION.bits(), 1 << 7);
80    const_assert_eq!(SkuFlags::USER_SUBSCRIPTION.bits(), 1 << 8);
81
82    #[test]
83    fn serde() {
84        serde_test::assert_tokens(
85            &SkuFlags::AVAILABLE,
86            &[Token::U64(SkuFlags::AVAILABLE.bits())],
87        );
88
89        serde_test::assert_tokens(
90            &SkuFlags::GUILD_SUBSCRIPTION,
91            &[Token::U64(SkuFlags::GUILD_SUBSCRIPTION.bits())],
92        );
93
94        serde_test::assert_tokens(
95            &SkuFlags::USER_SUBSCRIPTION,
96            &[Token::U64(SkuFlags::USER_SUBSCRIPTION.bits())],
97        );
98
99        serde_test::assert_de_tokens(&SkuFlags::empty(), &[Token::U64(1 << 63)]);
100    }
101}