mob_push 0.2.1

notify pusher using Mob Push
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

use std::collections::BTreeMap;

use serde::ser::SerializeStruct;
use serde_json::Value;
use typed_builder::TypedBuilder;
use url::Url;

use crate::push_notify::NotifySerialize;

#[derive(Debug)]
pub enum PushForward {
    HomePage,
    Link(Url),
    Scheme(Scheme),
    Internet(Url),
}

impl PushForward {
    pub fn new_to_home_page() -> Self {
        Self::HomePage
    }

    pub fn new_to_link(url: Url) -> Self {
        Self::Link(url)
    }

    pub fn new_to_scheme(scheme: Scheme) -> Self {
        Self::Scheme(scheme)
    }

    pub fn new_to_internet(url: Url) -> Self {
        Self::Internet(url)
    }
}

impl NotifySerialize for PushForward {
    fn serialize_field(&self) -> usize {
        match self {
            PushForward::HomePage => 1,
            PushForward::Link(_) => 2,
            PushForward::Scheme(Scheme { uri, value, .. }) => {
                2 + if uri.is_none() { 1 } else { 0 } + if value.is_none() { 1 } else { 0 }
            }
            PushForward::Internet(_) => 2,
        }
    }

    fn serialize<S: serde::Serializer>(
        &self,
        struct_serialize: &mut <S as serde::Serializer>::SerializeStruct,
    ) -> Result<(), <S as serde::Serializer>::Error> {
        struct_serialize.serialize_field(
            "nextType",
            &match self {
                PushForward::HomePage => 0,
                PushForward::Link(_) => 1,
                PushForward::Scheme(_) => 2,
                PushForward::Internet(_) => 3,
            },
        )?;

        match self {
            PushForward::HomePage => (),
            PushForward::Link(url) => struct_serialize.serialize_field("url", url)?,
            PushForward::Scheme(Scheme { scheme, uri, value }) => {
                struct_serialize.serialize_field("scheme", scheme)?;
                if let Some(url) = uri {
                    struct_serialize.serialize_field("url", url)?;
                }

                if let Some(map) = value {
                    struct_serialize
                        .serialize_field("schemeDataList", &map.iter().collect::<Vec<_>>())?;
                }
            }
            PushForward::Internet(url) => struct_serialize.serialize_field("intentUrl", url)?,
        };

        Ok(())
    }
}

#[derive(Debug, TypedBuilder)]
pub struct Scheme {
    scheme: Url,
    uri: Option<Url>,
    value: Option<BTreeMap<String, Value>>,
}