Struct Impression 

pub struct Impression {
    pub device_info: DeviceInfo,
    pub display_location: String,
    pub promoted_tweet_info: Option<PromotedTweetInfo>,
    pub advertiser_info: AdvertiserInfo,
    pub matched_targeting_criteria: Option<Vec<TargetingCriteria>>,
    pub impression_time: DateTime<Utc>,
}

Example

use chrono::{DateTime, NaiveDateTime, Utc};

use twitter_archive::convert::date_year_month_day_hour_minute_second::FORMAT;

use twitter_archive::structs::ad::Impression;

let impression_time_string = "2023-06-05 17:00:52";
let impression_time_native_time = NaiveDateTime::parse_from_str(&impression_time_string, FORMAT).unwrap();
let impression_time_date_time = DateTime::<Utc>::from_naive_utc_and_offset(impression_time_native_time, Utc);

let json = format!(r#"{{
  "deviceInfo": {{
    "osType": "Desktop"
  }},
  "displayLocation": "TweetConversation",
  "promotedTweetInfo": {{
    "tweetId": "1111111111111111111",
    "tweetText": "Click bate",
    "urls": [],
    "mediaUrls": [
      "https://t.co/AHAAAAAAAA"
    ]
  }},
  "advertiserInfo": {{
    "advertiserName": "EXAMPLE",
    "screenName": "@EXAMPLE"
  }},
  "matchedTargetingCriteria": [
    {{
      "targetingType": "Follower look-alikes",
      "targetingValue": "@EXAMPLE"
    }}
  ],
  "impressionTime": "{impression_time_string}"
}}"#);

let data: Impression = serde_json::from_str(&json).unwrap();

// De-serialized properties
assert_eq!(data.device_info.os_type, "Desktop");

assert_eq!(data.display_location, "TweetConversation");

if let Some(promoted_tweet_info) = &data.promoted_tweet_info {
    assert_eq!(promoted_tweet_info.tweet_id, "1111111111111111111");
    assert_eq!(promoted_tweet_info.tweet_text, "Click bate");
    assert_eq!(promoted_tweet_info.urls.len(), 0);
    assert_eq!(promoted_tweet_info.media_urls.len(), 1);
    assert_eq!(promoted_tweet_info.media_urls[0], "https://t.co/AHAAAAAAAA");
}

if let Some(advertiser_name) = &data.advertiser_info.advertiser_name {
    assert_eq!(advertiser_name, "EXAMPLE");
}
if let Some(screen_name) = &data.advertiser_info.screen_name {
    assert_eq!(screen_name, "@EXAMPLE");
}

if let Some(matched_targeting_criteria) = &data.matched_targeting_criteria {
    assert_eq!(matched_targeting_criteria.len(), 1);
    assert_eq!(matched_targeting_criteria[0].targeting_type, "Follower look-alikes");
    if let Some(targeting_value) = &matched_targeting_criteria[0].targeting_value {
        assert_eq!(targeting_value, "@EXAMPLE");
    }
}

assert_eq!(data.impression_time, impression_time_date_time);

// Re-serialize is equivalent to original data without pretty printing
assert_eq!(serde_json::to_string_pretty(&data).unwrap(), json);

Fields

device_info: DeviceInfo

Example JSON data

{
  "deviceInfo": {
    "osType": "Desktop"
  }
}

display_location: String

Example JSON data

{ "displayLocation": "TweetConversation" }

promoted_tweet_info: Option<PromotedTweetInfo>

Example JSON data

{
  "promotedTweetInfo": {
    "tweetId": "1111111111111111111",
    "tweetText": "Click bate",
    "urls": [],
    "mediaUrls": [
      "https://t.co/AHAAAAAAAA"
    ]
  }
}

advertiser_info: AdvertiserInfo

Example JSON data

{
  "advertiserInfo": {
    "advertiserName": "EXAMPLE",
    "screenName": "@EXAMPLE"
  }
}

matched_targeting_criteria: Option<Vec<TargetingCriteria>>

Example JSON data

{
  "matchedTargetingCriteria": [
    {
      "targetingType": "Follower look-alikes",
      "targetingValue": "@EXAMPLE"
    }
  ]
}

impression_time: DateTime<Utc>

Example JSON data

{ "impressionTime": "2023-06-05 17:00:52" }

Trait Implementations

impl Clone for Impression

fn clone(&self) -> Impression

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Impression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Impression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Impression

fn fmt(&self, _derive_more_display_formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for Impression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.