Add app api

Cargo.toml

@@ -31,6 +31,7 @@ int-enum = "0.5"
 itertools = "0.10"
 json = "0.12"
 lazy_static = "1.4"
+md5 = "0.7"
 modular-bitfield = "0.11"
 multipart = { features = ["server"], git = 'https://github.com/lifegpc/multipart', optional = true, default-features = false }
 openssl = { version = "0.10", optional = true }

Language/pixiv_downloader.pot

@@ -906,7 +906,7 @@ msgid "Failed to flush file:"
 msgstr ""
 
 #: src/settings_list.rs:24
-msgid "Pixiv's refresh tokens. Used to login."
+msgid "Pixiv's refresh token. Used to login."
 msgstr ""
 
 #: src/settings_list.rs:30

Language/pixiv_downloader.zh_CN.po

@@ -915,8 +915,8 @@ msgid "Failed to flush file:"
 msgstr "无法刷新文件缓冲区："
 
 #: src/settings_list.rs:24
-msgid "Pixiv's refresh tokens. Used to login."
-msgstr "Pixiv 的 refresh tokens。用于登录。"
+msgid "Pixiv's refresh token. Used to login."
+msgstr "Pixiv 的 refresh token。用于登录。"
 
 #: src/settings_list.rs:30
 msgid "Remove the part which after these parttens."

proc_macros/proc_macros.rs

@@ -944,3 +944,44 @@ pub fn http_error(item: TokenStream) -> TokenStream {
     );
     stream.into()
 }
+
+struct PrintError {
+    pub msg: Expr,
+    pub expr: Expr,
+    pub re: Option<Expr>,
+}
+
+impl Parse for PrintError {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let msg = input.parse()?;
+        input.parse::<token::Comma>()?;
+        let expr = input.parse()?;
+        let mut re = None;
+        match input.parse::<token::Comma>() {
+            Ok(_) => {
+                re.replace(input.parse()?);
+            }
+            Err(_) => {}
+        }
+        Ok(Self { msg, expr, re })
+    }
+}
+
+#[proc_macro]
+pub fn print_error(item: TokenStream) -> TokenStream {
+    let PrintError { msg, expr, re } = parse_macro_input!(item as PrintError);
+    let re = match re {
+        Some(re) => quote!(#re),
+        None => quote!(None),
+    };
+    let stream = quote!(
+        match (#expr) {
+            Ok(re) => re,
+            Err(e) => {
+                println!("{}{}", #msg, e);
+                return #re;
+            }
+        }
+    );
+    stream.into()
+}

src/download.rs

@@ -8,6 +8,8 @@ use crate::data::fanbox::FanboxData;
 use crate::data::json::JSONDataFile;
 #[cfg(feature = "ugoira")]
 use crate::data::video::get_video_metadata;
+#[cfg(feature = "db")]
+use crate::db::open_and_init_database;
 use crate::downloader::Downloader;
 use crate::downloader::DownloaderHelper;
 use crate::downloader::DownloaderResult;
@@ -23,6 +25,7 @@ use crate::fanbox::post::FanboxPost;
 use crate::fanbox_api::FanboxClient;
 use crate::gettext;
 use crate::opthelper::get_helper;
+use crate::pixiv_app::PixivAppClient;
 use crate::pixiv_link::FanboxPostID;
 use crate::pixiv_link::PixivID;
 use crate::pixiv_web::PixivWebClient;
@@ -34,6 +37,7 @@ use crate::utils::get_file_name_from_url;
 use crate::Main;
 use indicatif::MultiProgress;
 use json::JsonValue;
+use proc_macros::print_error;
 use reqwest::IntoUrl;
 use std::fs::{create_dir_all, File};
 use std::io::Write;
@@ -45,25 +49,23 @@ impl Main {
     pub async fn download(&mut self) -> i32 {
         let pw = Arc::new(PixivWebClient::new());
         let fc = Arc::new(FanboxClient::new());
+        #[cfg(feature = "db")]
+        let db = Arc::new(print_error!(
+            gettext("Failed to open database:"),
+            open_and_init_database(get_helper().db()).await,
+            0
+        ));
+        #[cfg(not(feature = "db"))]
+        let ac = Arc::new(PixivAppClient::new());
+        #[cfg(feature = "db")]
+        let ac = PixivAppClient::with_db(Some(db));
         let tasks = TaskManager::new_post();
         let download_multiple_posts = get_helper().download_multiple_posts();
         for id in self.cmd.as_ref().unwrap().ids.iter() {
             match id {
                 PixivID::Artwork(id) => {
-                    if !pw.is_inited() {
-                        if !pw.init() {
-                            println!("{}", gettext("Failed to initialize pixiv web api client."));
-                            return 1;
-                        }
-                        if !pw.check_login().await {
-                            return 1;
-                        }
-                        if !pw.logined() {
-                            println!("{}", gettext("Warning: Web api client not logged in, some future may not work."));
-                        }
-                    }
                     tasks
-                        .add_task(download_artwork(Arc::clone(&pw), id.clone()))
+                        .add_task(download_artwork(ac.clone(), Arc::clone(&pw), id.clone()))
                         .await;
                     if !download_multiple_posts {
                         tasks.join().await;
@@ -249,9 +251,52 @@ pub async fn download_artwork_link<L: IntoUrl + Clone>(
 }
 
 pub async fn download_artwork(
+    ac: PixivAppClient,
     pw: Arc<PixivWebClient>,
     id: u64,
 ) -> Result<(), PixivDownloaderError> {
+    let helper = get_helper();
+    let app_ok = helper.refresh_token().is_some();
+    if app_ok && helper.use_app_api() {
+        if let Err(e) = download_artwork_app(ac, pw.clone(), id).await {
+            println!("{}{}", gettext("Warning: Failed to download artwork with app api, trying to download with web api: "), e);
+            download_artwork_web(pw.clone(), id).await?;
+        }
+    } else if app_ok {
+        if let Err(_) = download_artwork_web(pw.clone(), id).await {
+            download_artwork_app(ac, pw.clone(), id).await?;
+        }
+    } else {
+        download_artwork_web(pw, id).await?;
+    }
+    Ok(())
+}
+
+pub async fn download_artwork_app(
+    ac: PixivAppClient,
+    pw: Arc<PixivWebClient>,
+    id: u64,
+) -> Result<(), PixivDownloaderError> {
+    let data = ac.get_illust_details(id).await?;
+    Ok(())
+}
+
+pub async fn download_artwork_web(
+    pw: Arc<PixivWebClient>,
+    id: u64,
+) -> Result<(), PixivDownloaderError> {
+    if !pw.is_login_checked() {
+        if !pw.check_login().await {
+            println!("{}", gettext("Failed to check login status."));
+        } else {
+            if !pw.logined() {
+                println!(
+                    "{}",
+                    gettext("Warning: Web api client not logged in, some future may not work.")
+                );
+            }
+        }
+    }
     let mut re = None;
     let pages;
     let mut ajax_ver = true;

src/downloader/downloader.rs

@@ -63,7 +63,6 @@ pub trait SetLen {
     fn set_len(&mut self, size: u64) -> Result<(), DownloaderError>;
 }
 
-#[derive(Debug)]
 /// A file downloader
 pub struct DownloaderInternal<
     T: Write + Seek + Send + Sync + ClearFile + GetTargetFileName + SetLen,

src/error.rs

@@ -23,7 +23,6 @@ pub enum PixivDownloaderError {
     FromUtf8Error(std::string::FromUtf8Error),
     #[cfg(feature = "server")]
     ToStrError(http::header::ToStrError),
-    #[cfg(all(feature = "server", feature = "db_sqlite", test))]
     JSONError(json::Error),
     #[cfg(feature = "openssl")]
     OpenSSLError(openssl::error::ErrorStack),

src/main.rs

@@ -38,6 +38,7 @@ mod opt;
 mod opthelper;
 mod opts;
 mod parser;
+mod pixiv_app;
 mod pixiv_link;
 mod pixiv_web;
 mod push;

src/opthelper.rs

@@ -294,6 +294,16 @@ impl OptHelper {
         65536
     }
 
+    pub fn refresh_token(&self) -> Option<String> {
+        if self.opt.get_ref().refresh_token.is_some() {
+            self.opt.get_ref().refresh_token.clone()
+        } else if self.settings.get_ref().have_str("refresh-token") {
+            self.settings.get_ref().get_str("refresh-token")
+        } else {
+            None
+        }
+    }
+
     pub fn update(&self, opt: CommandOpts, settings: SettingStore) {
         if settings.have("author-name-filters") {
             self._author_name_filters.replace_with2(
@@ -323,6 +333,17 @@ impl OptHelper {
         self.settings.replace_with2(settings);
     }
 
+    /// Whether to use Pixiv APP API first.
+    pub fn use_app_api(&self) -> bool {
+        if self.opt.get_ref().use_app_api.is_some() {
+            return self.opt.get_ref().use_app_api.unwrap();
+        }
+        if self.settings.get_ref().have("use-app-api") {
+            return self.settings.get_ref().get_bool("use-app-api").unwrap();
+        }
+        false
+    }
+
     pub fn overwrite(&self) -> Option<bool> {
         self.opt.get_ref().overwrite
     }

src/opts.rs

@@ -120,6 +120,10 @@ pub struct CommandOpts {
     #[cfg(feature = "ugoira")]
     pub ugoira_max_fps: Option<f32>,
     pub fanbox_page_number: Option<bool>,
+    /// Pixiv's refresh token. Used to login.
+    pub refresh_token: Option<String>,
+    /// Whether to use Pixiv APP API first.
+    pub use_app_api: Option<bool>,
 }
 
 impl CommandOpts {
@@ -163,6 +167,8 @@ impl CommandOpts {
             #[cfg(feature = "ugoira")]
             ugoira_max_fps: None,
             fanbox_page_number: None,
+            refresh_token: None,
+            use_app_api: None,
         }
     }
 
@@ -591,6 +597,26 @@ pub fn parse_cmd() -> Option<CommandOpts> {
         HasArg::Maybe,
         getopts::Occur::Optional,
     );
+    opts.optopt(
+        "",
+        "refresh-token",
+        gettext("Pixiv's refresh token. Used to login."),
+        "TOKEN",
+    );
+    opts.opt(
+        "",
+        "use-app-api",
+        format!(
+            "{} ({} {})",
+            gettext("Whether to use Pixiv APP API first."),
+            gettext("Default:"),
+            "yes"
+        )
+        .as_str(),
+        "yes/no",
+        HasArg::Maybe,
+        getopts::Occur::Optional,
+    );
     let result = match opts.parse(&argv[1..]) {
         Ok(m) => m,
         Err(err) => {
@@ -952,6 +978,20 @@ pub fn parse_cmd() -> Option<CommandOpts> {
             return None;
         }
     }
+    re.as_mut().unwrap().refresh_token = result.opt_str("refresh-token");
+    match parse_optional_opt(&result, "use-app-api", true, parse_bool) {
+        Ok(b) => re.as_mut().unwrap().use_app_api = b,
+        Err(e) => {
+            println!(
+                "{} {}",
+                gettext("Failed to parse <opt>:")
+                    .replace("<opt>", "use-app-api")
+                    .as_str(),
+                e
+            );
+            return None;
+        }
+    }
     re
 }