edgee-components-runtime 1.2.27

Edgee components runtime (using wasmtime)
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
136
137
138
139
140
141
142

use crate::data_collection::convert::{convert_products, convert_properties};
use crate::data_collection::payload;
use crate::data_collection::versions::v1_0_0::data_collection::exports::edgee::components::data_collection as DC;

impl From<payload::Event> for DC::Event {
    fn from(value: payload::Event) -> Self {
        let data = match value.data {
            payload::Data::Page(page) => DC::Data::Page(page.into()),
            payload::Data::User(user) => DC::Data::User(user.into()),
            payload::Data::Track(track) => DC::Data::Track(track.into()),
        };
        let consent = match value.consent {
            Some(payload::Consent::Pending) => Some(DC::Consent::Pending),
            Some(payload::Consent::Granted) => Some(DC::Consent::Granted),
            Some(payload::Consent::Denied) => Some(DC::Consent::Denied),
            None => None,
        };
        Self {
            uuid: value.uuid,
            timestamp: value.timestamp.timestamp(),
            timestamp_millis: value.timestamp.timestamp_millis(),
            timestamp_micros: value.timestamp.timestamp_micros(),
            event_type: value.event_type.into(),
            data,
            context: value.context.into(),
            consent,
        }
    }
}

impl From<payload::EventType> for DC::EventType {
    fn from(value: payload::EventType) -> Self {
        match value {
            payload::EventType::Page => Self::Page,
            payload::EventType::User => Self::User,
            payload::EventType::Track => Self::Track,
        }
    }
}

impl From<payload::Page> for DC::PageData {
    fn from(value: payload::Page) -> Self {
        Self {
            name: value.name,
            category: value.category,
            keywords: value.keywords,
            title: value.title,
            url: value.url,
            path: value.path,
            search: value.search,
            referrer: value.referrer,
            properties: convert_properties(value.properties.clone()),
        }
    }
}

impl From<payload::User> for DC::UserData {
    fn from(value: payload::User) -> Self {
        Self {
            user_id: value.user_id,
            anonymous_id: value.anonymous_id,
            edgee_id: value.edgee_id,
            properties: convert_properties(value.properties.clone()),
        }
    }
}

impl From<payload::Track> for DC::TrackData {
    fn from(value: payload::Track) -> Self {
        Self {
            name: value.name,
            properties: convert_properties(value.properties.clone()),
            products: convert_products(value.properties.clone()),
        }
    }
}

impl From<payload::Context> for DC::Context {
    fn from(value: payload::Context) -> Self {
        Self {
            page: value.page.into(),
            user: value.user.into(),
            client: value.client.into(),
            campaign: value.campaign.into(),
            session: value.session.into(),
        }
    }
}

impl From<payload::Campaign> for DC::Campaign {
    fn from(value: payload::Campaign) -> Self {
        Self {
            name: value.name,
            source: value.source,
            medium: value.medium,
            term: value.term,
            content: value.content,
            creative_format: value.creative_format,
            marketing_tactic: value.marketing_tactic,
        }
    }
}

impl From<payload::Client> for DC::Client {
    fn from(value: payload::Client) -> Self {
        Self {
            ip: value.ip,
            locale: value.locale,
            timezone: value.timezone,
            user_agent: value.user_agent,
            user_agent_architecture: value.user_agent_architecture,
            user_agent_bitness: value.user_agent_bitness,
            user_agent_full_version_list: value.user_agent_full_version_list,
            user_agent_version_list: value.user_agent_version_list,
            user_agent_mobile: value.user_agent_mobile,
            user_agent_model: value.user_agent_model,
            os_name: value.os_name,
            os_version: value.os_version,
            screen_width: value.screen_width,
            screen_height: value.screen_height,
            screen_density: value.screen_density,
            continent: value.continent,
            country_code: value.country_code,
            country_name: value.country_name,
            region: value.region,
            city: value.city,
        }
    }
}

impl From<payload::Session> for DC::Session {
    fn from(value: payload::Session) -> Self {
        Self {
            session_id: value.session_id,
            previous_session_id: value.previous_session_id,
            session_count: value.session_count,
            session_start: value.session_start,
            first_seen: value.first_seen.timestamp(),
            last_seen: value.last_seen.timestamp(),
        }
    }
}