Mercurial > minori

diff src/services/kitsu.cc @ 413:192da585a0a8 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*: fix formatting the clang-format file was broken andjust using LLVM defaults. now it's fixed and is more in line with what I actually prefer my code to look like -- esp. with regards to tabulators
author Paper <paper@tflc.us>
date Sat, 25 Jul 2026 14:54:32 -0400
parents 02a670a8e1c4
children
line wrap: on
line diff
--- a/src/services/kitsu.cc	Sat Jul 25 14:33:03 2026 -0400
+++ b/src/services/kitsu.cc	Sat Jul 25 14:54:32 2026 -0400
@@ -40,7 +40,7 @@
 	static const std::vector<std::string> headers = {{"Content-Type: application/json"}};
 
 	const std::string ret =
-	    Strings::ToUtf8String(HTTP::Request(std::string(OAUTH_PATH), headers, data.dump(), HTTP::Type::Post));
+		Strings::ToUtf8String(HTTP::Request(std::string(OAUTH_PATH), headers, data.dump(), HTTP::Type::Post));
 	if (ret.empty()) {
 		session.SetStatusBar(Strings::Translate("Kitsu: Request returned empty data!"));
 		return false;
@@ -51,19 +51,19 @@
 		result = nlohmann::json::parse(ret, nullptr, false);
 	} catch (const std::exception &ex) {
 		session.SetStatusBar(
-		    fmt::format(Strings::Translate("Kitsu: Failed to parse authorization data with error \"{}\""), ex.what()));
+			fmt::format(Strings::Translate("Kitsu: Failed to parse authorization data with error \"{}\""), ex.what()));
 		return false;
 	}
 
 	if (result.contains("/error"_json_pointer)) {
-		session.SetStatusBar(fmt::format(Strings::Translate("Kitsu: Failed with error \"{}\"!"),
-		                                 result["/error"_json_pointer].get<std::string>()));
+		session.SetStatusBar(fmt::format(
+			Strings::Translate("Kitsu: Failed with error \"{}\"!"), result["/error"_json_pointer].get<std::string>()));
 		return false;
 	}
 
-	const std::vector<nlohmann::json::json_pointer> required = {
-	    "/access_token"_json_pointer,  "/created_at"_json_pointer, "/expires_in"_json_pointer,
-	    "/refresh_token"_json_pointer, "/scope"_json_pointer,      "/token_type"_json_pointer};
+	const std::vector<nlohmann::json::json_pointer> required = {"/access_token"_json_pointer,
+		"/created_at"_json_pointer, "/expires_in"_json_pointer, "/refresh_token"_json_pointer, "/scope"_json_pointer,
+		"/token_type"_json_pointer};
 
 	for (const auto &ptr : required) {
 		if (!result.contains(ptr)) {
@@ -74,7 +74,7 @@
 
 	session.config.auth.kitsu.access_token = result["/access_token"_json_pointer].get<std::string>();
 	session.config.auth.kitsu.access_token_expiration = result["/created_at"_json_pointer].get<Time::Timestamp>() +
-	                                                    result["/expires_in"_json_pointer].get<Time::Timestamp>();
+														result["/expires_in"_json_pointer].get<Time::Timestamp>();
 	session.config.auth.kitsu.refresh_token = result["/refresh_token"_json_pointer].get<std::string>();
 
 	/* the next two are not that important */
@@ -85,8 +85,8 @@
 static bool RefreshAccessToken(void)
 {
 	const nlohmann::json request = {
-	    {"grant_type",    "refresh_token"                        },
-	    {"refresh_token", session.config.auth.kitsu.refresh_token},
+		{"grant_type",    "refresh_token"                        },
+		{"refresh_token", session.config.auth.kitsu.refresh_token},
 	};
 
 	if (!SendAuthRequest(request))
@@ -113,9 +113,18 @@
 static void AddAnimeFilters(std::map<std::string, std::string> &map)
 {
 	static const std::vector<std::string> fields = {
-	    "abbreviatedTitles", "averageRating",    "episodeCount", "episodeLength", "posterImage",
-	    "startDate",         "status",           "subtype",      "titles",        "categories",
-	    "synopsis",          "animeProductions",
+		"abbreviatedTitles",
+		"averageRating",
+		"episodeCount",
+		"episodeLength",
+		"posterImage",
+		"startDate",
+		"status",
+		"subtype",
+		"titles",
+		"categories",
+		"synopsis",
+		"animeProductions",
 	};
 	static const std::string imploded = Strings::Implode(fields, ",");
 
@@ -128,8 +137,16 @@
 static void AddLibraryEntryFilters(std::map<std::string, std::string> &map)
 {
 	static const std::vector<std::string> fields = {
-	    "anime",        "startedAt",      "finishedAt",  "notes",  "progress",
-	    "ratingTwenty", "reconsumeCount", "reconsuming", "status", "updatedAt",
+		"anime",
+		"startedAt",
+		"finishedAt",
+		"notes",
+		"progress",
+		"ratingTwenty",
+		"reconsumeCount",
+		"reconsuming",
+		"status",
+		"updatedAt",
 	};
 	static const std::string imploded = Strings::Implode(fields, ",");
 
@@ -139,16 +156,15 @@
 /* ----------------------------------------------------------------------------- */
 
 static std::optional<nlohmann::json> SendJSONAPIRequest(const std::string &path,
-                                                        const std::map<std::string, std::string> &params = {},
-                                                        const std::string &data = "", HTTP::Type type = HTTP::Type::Get)
+	const std::map<std::string, std::string> &params = {}, const std::string &data = "",
+	HTTP::Type type = HTTP::Type::Get)
 {
 	std::optional<std::string> token = AccountAccessToken();
 	if (!token)
 		return std::nullopt;
 
 	const std::vector<std::string> headers = {"Accept: application/vnd.api+json",
-	                                          "Authorization: Bearer " + token.value(),
-	                                          "Content-Type: application/vnd.api+json"};
+		"Authorization: Bearer " + token.value(), "Content-Type: application/vnd.api+json"};
 
 	const std::string url = HTTP::EncodeParamsList(std::string(BASE_API_PATH) + path, params);
 
@@ -161,7 +177,7 @@
 		json = nlohmann::json::parse(response);
 	} catch (const std::exception &ex) {
 		session.SetStatusBar(
-		    fmt::format(Strings::Translate("Kitsu: Failed to parse response with error \"{}\""), ex.what()));
+			fmt::format(Strings::Translate("Kitsu: Failed to parse response with error \"{}\""), ex.what()));
 		return std::nullopt;
 	}
 
@@ -183,9 +199,9 @@
 static void ParseTitleJson(Anime::Anime &anime, const nlohmann::json &json)
 {
 	static const std::map<std::string, Anime::TitleLanguage> lookup = {
-	    {"en",    Anime::TitleLanguage::English},
-	    {"en_jp", Anime::TitleLanguage::Romaji },
-	    {"ja_jp", Anime::TitleLanguage::Native }
+		{"en",    Anime::TitleLanguage::English},
+        {"en_jp", Anime::TitleLanguage::Romaji },
+		{"ja_jp", Anime::TitleLanguage::Native }
     };
 
 	for (const auto &[string, title] : lookup)
@@ -196,12 +212,12 @@
 static void ParseSubtype(Anime::Anime &anime, const std::string &str)
 {
 	static const std::map<std::string, Anime::SeriesFormat> lookup = {
-	    {"ONA",     Anime::SeriesFormat::Ona    },
+		{"ONA",     Anime::SeriesFormat::Ona    },
         {"OVA",     Anime::SeriesFormat::Ova    },
-	    {"TV",      Anime::SeriesFormat::Tv     },
-        {"movie",   Anime::SeriesFormat::Movie  },
-	    {"music",   Anime::SeriesFormat::Music  },
-        {"special", Anime::SeriesFormat::Special}
+        {"TV",      Anime::SeriesFormat::Tv     },
+		{"movie",   Anime::SeriesFormat::Movie  },
+        {"music",   Anime::SeriesFormat::Music  },
+		{"special", Anime::SeriesFormat::Special}
     };
 
 	if (lookup.find(str) == lookup.end())
@@ -213,11 +229,11 @@
 static void ParseListStatus(Anime::Anime &anime, const std::string &str)
 {
 	static const std::map<std::string, Anime::ListStatus> lookup = {
-	    {"completed", Anime::ListStatus::Completed},
-	    {"current",   Anime::ListStatus::Current  },
-	    {"dropped",   Anime::ListStatus::Dropped  },
-	    {"on_hold",   Anime::ListStatus::Paused   },
-	    {"planned",   Anime::ListStatus::Planning }
+		{"completed", Anime::ListStatus::Completed},
+        {"current",   Anime::ListStatus::Current  },
+		{"dropped",   Anime::ListStatus::Dropped  },
+        {"on_hold",   Anime::ListStatus::Paused   },
+		{"planned",   Anime::ListStatus::Planning }
     };
 
 	if (lookup.find(str) == lookup.end())
@@ -229,11 +245,11 @@
 static void ParseSeriesStatus(Anime::Anime &anime, const std::string &str)
 {
 	static const std::map<std::string, Anime::SeriesStatus> lookup = {
-	    {"current",    Anime::SeriesStatus::Releasing     },
-        {"finished",   Anime::SeriesStatus::Finished      },
-	    {"tba",        Anime::SeriesStatus::Hiatus        }, // is this right?
-	    {"unreleased", Anime::SeriesStatus::Cancelled     },
-        {"upcoming",   Anime::SeriesStatus::NotYetReleased},
+		{"current",    Anime::SeriesStatus::Releasing     },
+		{"finished",   Anime::SeriesStatus::Finished      },
+		{"tba",        Anime::SeriesStatus::Hiatus        }, // is this right?
+		{"unreleased", Anime::SeriesStatus::Cancelled     },
+		{"upcoming",   Anime::SeriesStatus::NotYetReleased},
 	};
 
 	if (lookup.find(str) == lookup.end())
@@ -273,7 +289,7 @@
 		ParseTitleJson(anime, attributes["/titles"_json_pointer]);
 
 	if (attributes.contains("/abbreviatedTitles"_json_pointer) &&
-	    attributes["/abbreviatedTitles"_json_pointer].is_array())
+		attributes["/abbreviatedTitles"_json_pointer].is_array())
 		for (const auto &title : attributes["/abbreviatedTitles"_json_pointer])
 			anime.AddTitleSynonym(title.get<std::string>());
 
@@ -283,10 +299,10 @@
 	if (attributes.contains("/startDate"_json_pointer) && attributes["/startDate"_json_pointer].is_string())
 		anime.SetStartedDate(attributes["/startDate"_json_pointer].get<std::string>());
 
-	anime.SetCompletedDate(attributes.contains("/endDate"_json_pointer) &&
-	                               attributes["/endDate"_json_pointer].is_string()
-	                           ? attributes["/endDate"_json_pointer].get<std::string>()
-	                           : anime.GetStartedDate());
+	anime.SetCompletedDate(
+		attributes.contains("/endDate"_json_pointer) && attributes["/endDate"_json_pointer].is_string()
+			? attributes["/endDate"_json_pointer].get<std::string>()
+			: anime.GetStartedDate());
 
 	if (attributes.contains("/subtype"_json_pointer) && attributes["/subtype"_json_pointer].is_string())
 		ParseSubtype(anime, attributes["/subtype"_json_pointer].get<std::string>());
@@ -295,7 +311,7 @@
 		ParseSeriesStatus(anime, attributes["/status"_json_pointer].get<std::string>());
 
 	if (attributes.contains("/posterImage/original"_json_pointer) &&
-	    attributes["/posterImage/original"_json_pointer].is_string())
+		attributes["/posterImage/original"_json_pointer].is_string())
 		anime.SetPosterUrl(attributes["/posterImage/original"_json_pointer].get<std::string>());
 
 	if (attributes.contains("/episodeCount"_json_pointer) && attributes["/episodeCount"_json_pointer].is_number())
@@ -310,15 +326,15 @@
 static int ParseLibraryJson(const nlohmann::json &json)
 {
 	static const std::vector<nlohmann::json::json_pointer> required = {
-	    "/id"_json_pointer,
-	    "/relationships/anime/data/id"_json_pointer,
-	    "/attributes"_json_pointer,
+		"/id"_json_pointer,
+		"/relationships/anime/data/id"_json_pointer,
+		"/attributes"_json_pointer,
 	};
 
 	for (const auto &ptr : required) {
 		if (!json.contains(ptr)) {
-			session.SetStatusBar(fmt::format(Strings::Translate("Kitsu: Failed to parse library object! (missing {})"),
-			                                 ptr.to_string()));
+			session.SetStatusBar(fmt::format(
+				Strings::Translate("Kitsu: Failed to parse library object! (missing {})"), ptr.to_string()));
 			return 0;
 		}
 	}
@@ -346,11 +362,11 @@
 
 	if (attributes.contains("/startedAt"_json_pointer) && attributes["/startedAt"_json_pointer].is_string())
 		anime.SetUserDateStarted(
-		    Date(Time::ParseISO8601Time(attributes["/startedAt"_json_pointer].get<std::string>())));
+			Date(Time::ParseISO8601Time(attributes["/startedAt"_json_pointer].get<std::string>())));
 
 	if (attributes.contains("/finishedAt"_json_pointer) && attributes["/finishedAt"_json_pointer].is_string())
 		anime.SetUserDateCompleted(
-		    Date(Time::ParseISO8601Time(attributes["/finishedAt"_json_pointer].get<std::string>())));
+			Date(Time::ParseISO8601Time(attributes["/finishedAt"_json_pointer].get<std::string>())));
 
 	if (attributes.contains("/notes"_json_pointer) && attributes["/notes"_json_pointer].is_string())
 		anime.SetUserNotes(attributes["/notes"_json_pointer].get<std::string>());
@@ -422,7 +438,7 @@
 	static const nlohmann::json::json_pointer required = "/type"_json_pointer;
 	if (!json.contains(required) && !json[required].is_string()) {
 		session.SetStatusBar(
-		    fmt::format(Strings::Translate("Kitsu: Failed to generic object! (missing {})"), required.to_string()));
+			fmt::format(Strings::Translate("Kitsu: Failed to generic object! (missing {})"), required.to_string()));
 		return 0;
 	}
 
@@ -456,11 +472,11 @@
 	bool have_next_page = true;
 
 	std::map<std::string, std::string> params = {
-	    {"filter[user_id]", auth.user_id                           },
-	    {"filter[kind]",    "anime"	                            },
-	    {"include",         "anime"	                            },
-	    {"page[offset]",    Strings::ToUtf8String(page)            },
-	    {"page[limit]",     Strings::ToUtf8String(LIBRARY_MAX_SIZE)}
+		{"filter[user_id]", auth.user_id                           },
+        {"filter[kind]",    "anime"                                },
+        {"include",         "anime"                                },
+		{"page[offset]",    Strings::ToUtf8String(page)            },
+        {"page[limit]",     Strings::ToUtf8String(LIBRARY_MAX_SIZE)}
     };
 	AddAnimeFilters(params);
 	AddLibraryEntryFilters(params);
@@ -502,12 +518,12 @@
 
 /* :) */
 static const std::map<std::string, std::string> anime_params = {
-    {"include", Strings::Implode(
-                    {
-                        "categories",
-                        "animeProductions",
-                        "animeProductions.producer",
-                    }, ",")}
+	{"include", Strings::Implode(
+					{
+						"categories",
+						"animeProductions",
+						"animeProductions.producer",
+					}, ",")}
 };
 
 bool RetrieveAnimeMetadata(int id)
@@ -531,7 +547,7 @@
 
 	if (!json.contains("/included"_json_pointer) || !json["/included"_json_pointer].is_array()) {
 		session.SetStatusBar(
-		    Strings::Translate("Kitsu: Server returned bad data when trying to retrieve anime metadata!"));
+			Strings::Translate("Kitsu: Server returned bad data when trying to retrieve anime metadata!"));
 		return false;
 	}
 
@@ -560,7 +576,7 @@
 
 	if (!json.contains("/data"_json_pointer) || !json["/data"_json_pointer].is_array()) {
 		session.SetStatusBar(
-		    Strings::Translate("Kitsu: Server returned bad data when trying to retrieve search results!"));
+			Strings::Translate("Kitsu: Server returned bad data when trying to retrieve search results!"));
 		return {};
 	}
 
@@ -580,10 +596,10 @@
 bool GetSeason(Anime::Season season)
 {
 	static const std::map<Anime::Season::Name, std::string> map = {
-	    {Anime::Season::Name::Winter, "winter"},
-	    {Anime::Season::Name::Spring, "spring"},
-	    {Anime::Season::Name::Summer, "summer"},
-	    {Anime::Season::Name::Autumn, "fall"  },
+		{Anime::Season::Name::Winter, "winter"},
+		{Anime::Season::Name::Spring, "spring"},
+		{Anime::Season::Name::Summer, "summer"},
+		{Anime::Season::Name::Autumn, "fall"  },
 	};
 
 	session.SetStatusBar(Strings::Translate("Kitsu: Retrieving season data..."));
@@ -602,7 +618,7 @@
 
 	if (!json.contains("/data"_json_pointer) || !json["/data"_json_pointer].is_array()) {
 		session.SetStatusBar(
-		    Strings::Translate("Kitsu: Server returned bad data when trying to retrieve search results!"));
+			Strings::Translate("Kitsu: Server returned bad data when trying to retrieve search results!"));
 		return false;
 	}
 
@@ -709,7 +725,7 @@
 bool AuthorizeUser(const std::string &email, const std::string &password)
 {
 	const nlohmann::json body = {
-	    {"grant_type", "password"               },
+		{"grant_type", "password"               },
         {"username",   email                    },
         {"password",   HTTP::UrlEncode(password)}
     };
@@ -718,7 +734,7 @@
 		return false;
 
 	static const std::map<std::string, std::string> params = {
-	    {"filter[self]", "true"}
+		{"filter[self]", "true"}
     };
 
 	std::optional<nlohmann::json> response = SendJSONAPIRequest("/users", params);