allow passing cookie at startup

HookedBehemoth · HookedBehemoth · commit e5ef27229476 · 2025-05-02T15:14:32.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/build.rs b/build.rs
@@ -6,7 +6,7 @@ use std::process::Command;
 
 fn main() {
     let output = Command::new("git")
-        .args(&["rev-parse", "HEAD"])
+        .args(["rev-parse", "HEAD"])
         .output()
         .unwrap();
     let git_hash = String::from_utf8(output.stdout).unwrap();
diff --git a/src/api/article.rs b/src/api/article.rs
@@ -1,8 +1,11 @@
-use crate::api::{common::Article, error::ApiResult, fetch::fetch};
+use crate::{
+    api::{common::Article, error::ApiResult, fetch::fetch},
+    client::Client,
+};
 
 const API_URL: &str = "https://www.reuters.com/pf/api/v3/content/fetch/article-by-id-or-url-v1";
 
-pub fn fetch_article_by_url(client: &ureq::Agent, path: &str) -> ApiResult<Article> {
+pub fn fetch_article_by_url(client: &Client, path: &str) -> ApiResult<Article> {
     let query = format!(r#"{{"website_url":"{path}","website":"reuters"}}"#);
 
     fetch(client, API_URL, &query)
diff --git a/src/api/common.rs b/src/api/common.rs
@@ -10,9 +10,7 @@ pub struct Articles {
 
 #[derive(Deserialize)]
 pub struct Pagination {
-    pub size: Option<u32>,
     pub total_size: Option<u32>,
-    pub orderby: String,
 }
 
 #[derive(Deserialize)]
@@ -25,12 +23,6 @@ pub struct Article {
     pub published_time: String,
 }
 
-#[derive(Deserialize)]
-pub struct Section {
-    pub path: String,
-    pub name: String,
-}
-
 #[derive(Deserialize)]
 pub struct ApiResponse<T> {
     #[serde(rename = "statusCode")]
diff --git a/src/api/fetch.rs b/src/api/fetch.rs
@@ -1,10 +1,13 @@
-use crate::api::{
-    common::ApiResponse,
-    error::{ApiError, ApiResult},
+use crate::{
+    api::{
+        common::ApiResponse,
+        error::{ApiError, ApiResult},
+    },
+    client::Client,
 };
 use serde::Deserialize;
 
-pub(crate) fn fetch<T>(client: &ureq::Agent, url: &str, query: &str) -> ApiResult<T>
+pub(crate) fn fetch<T>(client: &Client, url: &str, query: &str) -> ApiResult<T>
 where
     T: for<'a> Deserialize<'a>,
 {
diff --git a/src/api/legacy_article.rs b/src/api/legacy_article.rs
@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-use crate::api::error::ApiError;
+use crate::{api::error::ApiError, client::Client};
 
 use super::error::ApiResult;
 
@@ -27,7 +27,6 @@ pub struct LegacyArticleArticle {
 
 #[derive(Deserialize)]
 pub struct LegacyArticleStream {
-    pub id: String,
     pub headline: String,
     pub description: String,
     pub date: LegacyArticleDate,
@@ -52,10 +51,7 @@ pub struct LegacyArticleBodyItem {
     pub content: String,
 }
 
-pub fn fetch_legacy_article(
-    client: &ureq::Agent,
-    path: &str,
-) -> Result<ureq::Response, ureq::Error> {
+pub fn fetch_legacy_article(client: &Client, path: &str) -> Result<ureq::Response, ureq::Error> {
     let link = format!("https://www.reuters.com{path}");
 
     client.get(&link).call()
diff --git a/src/api/markit.rs b/src/api/markit.rs
@@ -1,24 +1,14 @@
-use super::{
-    common::{Article, Pagination},
-    error::ApiResult,
-    fetch::fetch,
-};
+use crate::client::Client;
+
+use super::{common::Article, error::ApiResult, fetch::fetch};
 
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StockSearchResult {
-    pub pagination: Pagination,
-    pub market_info: MarketInfo,
     pub articles: Box<[Article]>,
 }
 
-#[derive(serde::Deserialize)]
-pub struct MarketInfo {
-    pub website: String,
-    pub about: String,
-}
-
-pub fn fetch_by_stock_symbol(client: &ureq::Agent, symbol: &str) -> ApiResult<StockSearchResult> {
+pub fn fetch_by_stock_symbol(client: &Client, symbol: &str) -> ApiResult<StockSearchResult> {
     const API_URL: &str =
         "https://www.reuters.com/pf/api/v3/content/fetch/articles-by-stock-symbol-v1";
 
diff --git a/src/api/search.rs b/src/api/search.rs
@@ -1,9 +1,11 @@
+use crate::client::Client;
+
 use super::{common::Articles, error::ApiResult, fetch::fetch};
 
 const API_URL: &str = "https://www.reuters.com/pf/api/v3/content/fetch/articles-by-search-v2";
 
 pub fn fetch_articles_by_search(
-    client: &ureq::Agent,
+    client: &Client,
     keyword: &str,
     offset: u32,
     size: u32,
diff --git a/src/api/section.rs b/src/api/section.rs
@@ -1,10 +1,12 @@
+use crate::client::Client;
+
 use super::{common::Articles, error::ApiResult, fetch::fetch};
 
 const API_URL: &str =
     "https://www.reuters.com/pf/api/v3/content/fetch/recent-stories-by-sections-v1";
 
 pub fn fetch_articles_by_section(
-    client: &ureq::Agent,
+    client: &Client,
     path: &str,
     offset: u32,
     size: u32,
diff --git a/src/api/topic.rs b/src/api/topic.rs
@@ -1,9 +1,11 @@
+use crate::client::Client;
+
 use super::{common::Articles, error::ApiResult, fetch::fetch};
 
 const API_URL: &str = "https://www.reuters.com/pf/api/v3/content/fetch/articles-by-topic-v1";
 
 pub fn fetch_articles_by_topic(
-    client: &ureq::Agent,
+    client: &Client,
     path: &str,
     offset: u32,
     size: u32,
diff --git a/src/client.rs b/src/client.rs
@@ -0,0 +1,20 @@
+use ureq::Request;
+
+pub struct Client {
+    agent: ureq::Agent,
+    headers: Vec<(String, String)>,
+}
+
+impl Client {
+    pub fn new(agent: ureq::Agent, headers: Vec<(String, String)>) -> Self {
+        Self { agent, headers }
+    }
+
+    pub fn get(&self, path: &str) -> Request {
+        let mut request = self.agent.get(path);
+        for (key, value) in &self.headers {
+            request = request.set(key, value)
+        }
+        request
+    }
+}
diff --git a/src/main.rs b/src/main.rs
@@ -1,8 +1,10 @@
 mod api;
+mod client;
 mod render;
 mod routes;
 
 use api::error::ApiError;
+use client::Client;
 use routes::{
     about::render_about,
     article::render_article,
@@ -97,6 +99,15 @@ fn main() {
         client_builder.build()
     };
 
+    let mut headers = vec![];
+
+    if let Ok(cookie) = pargs.value_from_str("--cookie") {
+        println!("Cookie: {cookie}");
+        headers.push(("Cookie".to_string(), cookie));
+    };
+
+    let client = Client::new(client, headers);
+
     println!("Listening on http://{}", list_address);
     rouille::start_server(list_address, move |request| {
         let path = request.url();
diff --git a/src/routes/article.rs b/src/routes/article.rs
@@ -1,11 +1,12 @@
 use crate::{
     api::{article::fetch_article_by_url, error::ApiResult},
+    client::Client,
     render::byline,
 };
 use chrono::{DateTime, Utc};
 use maud::{html, PreEscaped};
 
-pub fn render_article(client: &ureq::Agent, path: &str) -> ApiResult<String> {
+pub fn render_article(client: &Client, path: &str) -> ApiResult<String> {
     let article = fetch_article_by_url(client, path)?;
 
     let published_time = article
diff --git a/src/routes/internet_news.rs b/src/routes/internet_news.rs
@@ -6,11 +6,12 @@ use crate::{
         error::{ApiError, ApiResult},
         legacy_article::{fetch_legacy_article, parse_legacy_article},
     },
+    client::Client,
     render::legacy_article_byline::render_byline,
 };
 
 pub fn render_legacy_article(
-    client: &ureq::Agent,
+    client: &Client,
     path: &str,
 ) -> Result<ApiResult<String>, rouille::Response> {
     let response = match fetch_legacy_article(client, path) {
diff --git a/src/routes/markets.rs b/src/routes/markets.rs
@@ -1,6 +1,9 @@
-use crate::api::{error::ApiResult, markit::fetch_by_stock_symbol};
+use crate::{
+    api::{error::ApiResult, markit::fetch_by_stock_symbol},
+    client::Client,
+};
 
-pub fn render_market(client: &ureq::Agent, path: &str) -> ApiResult<String> {
+pub fn render_market(client: &Client, path: &str) -> ApiResult<String> {
     let company = if let Some(end) = path.find('/') {
         &path[..end]
     } else {
diff --git a/src/routes/search.rs b/src/routes/search.rs
@@ -2,6 +2,7 @@ use crate::api::{
     common::Articles, error::ApiResult, search::fetch_articles_by_search,
     section::fetch_articles_by_section, topic::fetch_articles_by_topic,
 };
+use crate::client::Client;
 use crate::document;
 use maud::html;
 
@@ -12,22 +13,17 @@ enum SearchType {
     Query,
 }
 
-pub fn render_topic(client: &ureq::Agent, path: &str, offset: u32, size: u32) -> ApiResult<String> {
+pub fn render_topic(client: &Client, path: &str, offset: u32, size: u32) -> ApiResult<String> {
     let article = fetch_articles_by_topic(client, path, offset, size)?;
     render_articles(article, path, offset, size, SearchType::Topic)
 }
 
-pub fn render_section(
-    client: &ureq::Agent,
-    path: &str,
-    offset: u32,
-    size: u32,
-) -> ApiResult<String> {
+pub fn render_section(client: &Client, path: &str, offset: u32, size: u32) -> ApiResult<String> {
     let article = fetch_articles_by_section(client, path, offset, size)?;
     render_articles(article, path, offset, size, SearchType::Section)
 }
 
-pub fn render_search(client: &ureq::Agent, request: &rouille::Request) -> ApiResult<String> {
+pub fn render_search(client: &Client, request: &rouille::Request) -> ApiResult<String> {
     match request.get_param("query") {
         Some(query) => {
             let offset = request
@@ -79,7 +75,7 @@ fn render_articles(
             articles
                 .topics
                 .as_ref()
-                .and_then(|t| t.get(0).map(|t| t.name.as_str()))
+                .and_then(|t| t.first().map(|t| t.name.as_str()))
                 .unwrap_or(""),
             format!("{path}?"),
         ),
