libreddit/src/post.rs

170 lines
5.2 KiB
Rust
Raw Normal View History

2020-10-25 21:25:59 +01:00
// CRATES
2021-01-13 21:52:00 +01:00
use crate::utils::{cookie, error, format_num, format_url, media, param, parse_rich_flair, prefs, request, rewrite_url, val, Comment, Flags, Flair, Post, Preferences};
2021-01-07 06:27:24 +01:00
use actix_web::{HttpRequest, HttpResponse};
2020-12-15 01:35:04 +01:00
2020-12-20 04:54:46 +01:00
use async_recursion::async_recursion;
2020-10-25 21:25:59 +01:00
use askama::Template;
2021-01-06 05:01:21 +01:00
use time::OffsetDateTime;
2020-11-30 03:50:29 +01:00
2020-10-25 21:25:59 +01:00
// STRUCTS
#[derive(Template)]
#[template(path = "post.html", escape = "none")]
struct PostTemplate {
comments: Vec<Comment>,
post: Post,
2020-10-26 04:57:19 +01:00
sort: String,
2021-01-10 22:20:47 +01:00
prefs: Preferences,
2020-10-25 21:25:59 +01:00
}
2021-01-03 05:50:23 +01:00
pub async fn item(req: HttpRequest) -> HttpResponse {
2021-01-07 17:38:05 +01:00
// Build Reddit API path
2021-01-07 19:32:55 +01:00
let mut path: String = format!("{}.json?{}&raw_json=1", req.path(), req.query_string());
// Set sort to sort query parameter
let mut sort: String = param(&path, "sort");
// Grab default comment sort method from Cookies
2021-01-09 02:50:03 +01:00
let default_sort = cookie(&req, "comment_sort");
2021-01-07 19:32:55 +01:00
// If there's no sort query but there's a default sort, set sort to default_sort
if sort.is_empty() && !default_sort.is_empty() {
sort = default_sort;
path = format!("{}.json?{}&sort={}&raw_json=1", req.path(), req.query_string(), sort);
}
2021-01-01 00:54:13 +01:00
2020-12-22 06:40:06 +01:00
// Log the post ID being fetched in debug mode
#[cfg(debug_assertions)]
2021-01-03 07:46:02 +01:00
dbg!(req.match_info().get("id").unwrap_or(""));
2021-01-02 07:21:43 +01:00
2020-11-21 06:04:35 +01:00
// Send a request to the url, receive JSON in response
2021-01-02 00:28:13 +01:00
match request(&path).await {
2021-01-01 00:54:13 +01:00
// Otherwise, grab the JSON output from the request
2021-01-02 00:28:13 +01:00
Ok(res) => {
// Parse the JSON into Post and Comment structs
2021-01-07 06:27:24 +01:00
let post = parse_post(&res[0]).await;
let comments = parse_comments(&res[1]).await;
2021-01-02 00:28:13 +01:00
// Use the Post and Comment structs to generate a website to show users
2021-01-10 22:20:47 +01:00
let s = PostTemplate {
comments,
post,
sort,
prefs: prefs(req),
}
.render()
.unwrap();
2021-01-03 05:50:23 +01:00
HttpResponse::Ok().content_type("text/html").body(s)
2021-01-02 07:21:43 +01:00
}
2021-01-02 00:28:13 +01:00
// If the Reddit API returns an error, exit and send error page to user
Err(msg) => error(msg).await,
2020-10-25 21:25:59 +01:00
}
}
2020-10-26 01:52:57 +01:00
// POSTS
2021-01-07 06:27:24 +01:00
async fn parse_post(json: &serde_json::Value) -> Post {
2020-12-23 03:29:43 +01:00
// Retrieve post (as opposed to comments) from JSON
let post: &serde_json::Value = &json["data"]["children"][0];
2020-10-25 21:25:59 +01:00
2020-12-23 03:29:43 +01:00
// Grab UTC time as unix timestamp
2021-01-04 06:31:21 +01:00
let unix_time: i64 = post["data"]["created_utc"].as_f64().unwrap_or_default().round() as i64;
// Parse post score and upvote ratio
2021-01-04 06:31:21 +01:00
let score = post["data"]["score"].as_i64().unwrap_or_default();
let ratio: f64 = post["data"]["upvote_ratio"].as_f64().unwrap_or(1.0) * 100.0;
2020-10-25 21:25:59 +01:00
2020-12-23 03:29:43 +01:00
// Determine the type of media along with the media URL
2021-01-07 06:27:24 +01:00
let (post_type, media) = media(&post["data"]).await;
2020-12-23 03:29:43 +01:00
// Build a post using data parsed from Reddit post API
2021-01-07 06:27:24 +01:00
Post {
id: val(post, "id"),
title: val(post, "title"),
community: val(post, "subreddit"),
body: rewrite_url(&val(post, "selftext_html")),
author: val(post, "author"),
2021-01-13 21:52:00 +01:00
author_flair: Flair {
flair_parts: parse_rich_flair(
val(post, "author_flair_type"),
post["data"]["author_flair_richtext"].as_array(),
post["data"]["author_flair_text"].as_str(),
),
2021-01-12 22:43:03 +01:00
background_color: val(post, "author_flair_background_color"),
foreground_color: val(post, "author_flair_text_color"),
},
permalink: val(post, "permalink"),
2020-12-07 19:32:46 +01:00
score: format_num(score),
upvote_ratio: ratio as i64,
2021-01-07 06:27:24 +01:00
post_type,
2021-01-12 02:47:14 +01:00
thumbnail: format_url(val(post, "thumbnail").as_str()),
2021-01-13 21:52:00 +01:00
flair: Flair {
flair_parts: parse_rich_flair(
val(post, "link_flair_type"),
post["data"]["link_flair_richtext"].as_array(),
post["data"]["link_flair_text"].as_str(),
),
2021-01-12 22:43:03 +01:00
background_color: val(post, "link_flair_background_color"),
foreground_color: if val(post, "link_flair_text_color") == "dark" {
2020-11-17 05:36:36 +01:00
"black".to_string()
} else {
"white".to_string()
},
2021-01-12 22:43:03 +01:00
},
2020-12-30 04:01:02 +01:00
flags: Flags {
nsfw: post["data"]["over_18"].as_bool().unwrap_or(false),
stickied: post["data"]["stickied"].as_bool().unwrap_or(false),
2020-12-30 04:01:02 +01:00
},
2021-01-07 06:27:24 +01:00
media,
2021-01-11 23:08:12 +01:00
domain: val(post, "domain"),
2021-01-06 05:01:21 +01:00
time: OffsetDateTime::from_unix_timestamp(unix_time).format("%b %d %Y %H:%M UTC"),
2021-01-07 06:27:24 +01:00
}
2020-10-25 21:25:59 +01:00
}
// COMMENTS
2020-12-20 04:54:46 +01:00
#[async_recursion]
2021-01-07 06:27:24 +01:00
async fn parse_comments(json: &serde_json::Value) -> Vec<Comment> {
2020-12-20 04:54:46 +01:00
// Separate the comment JSON into a Vector of comments
2021-01-12 03:05:13 +01:00
let comment_data = match json["data"]["children"].as_array() {
Some(f) => f.to_owned(),
2021-01-13 04:52:02 +01:00
None => Vec::new(),
2021-01-12 03:05:13 +01:00
};
2020-10-25 21:25:59 +01:00
let mut comments: Vec<Comment> = Vec::new();
2020-10-26 04:57:19 +01:00
2020-12-20 04:54:46 +01:00
// For each comment, retrieve the values to build a Comment object
2020-12-23 03:29:43 +01:00
for comment in comment_data {
2020-10-25 21:25:59 +01:00
let unix_time: i64 = comment["data"]["created_utc"].as_f64().unwrap_or(0.0).round() as i64;
2020-12-20 04:54:46 +01:00
if unix_time == 0 {
continue;
}
2020-10-26 01:52:57 +01:00
let score = comment["data"]["score"].as_i64().unwrap_or(0);
2021-01-12 03:05:13 +01:00
let body = rewrite_url(&val(&comment, "body_html"));
2020-10-26 01:52:57 +01:00
2020-12-20 04:54:46 +01:00
let replies: Vec<Comment> = if comment["data"]["replies"].is_object() {
2021-01-07 06:27:24 +01:00
parse_comments(&comment["data"]["replies"]).await
2020-12-20 04:54:46 +01:00
} else {
Vec::new()
};
2020-10-26 03:05:09 +01:00
2020-10-25 21:25:59 +01:00
comments.push(Comment {
2021-01-12 03:05:13 +01:00
id: val(&comment, "id"),
2021-01-01 21:33:57 +01:00
body,
2021-01-12 03:05:13 +01:00
author: val(&comment, "author"),
2020-12-07 19:32:46 +01:00
score: format_num(score),
2021-01-06 05:01:21 +01:00
time: OffsetDateTime::from_unix_timestamp(unix_time).format("%b %d %Y %H:%M UTC"),
2021-01-01 21:33:57 +01:00
replies,
2021-01-13 21:52:00 +01:00
flair: Flair {
flair_parts: parse_rich_flair(
val(&comment, "author_flair_type"),
comment["data"]["author_flair_richtext"].as_array(),
comment["data"]["author_flair_text"].as_str(),
),
2021-01-12 22:43:03 +01:00
background_color: val(&comment, "author_flair_background_color"),
foreground_color: val(&comment, "author_flair_text_color"),
},
2020-10-25 21:25:59 +01:00
});
}
2021-01-07 06:27:24 +01:00
comments
2020-10-26 04:57:19 +01:00
}