pub mod error;
use std::fmt::Display;
use std::env;
use std::fmt;
use std::iter::Iterator;
use serde::{Deserialize};
use keytree::serialize::{
KeyTreeString,
IntoKeyTree,
};
use crate::error::Error;
use crate::error::*;
pub struct Fred;
impl Fred {
pub fn category(category_id: usize) -> Result<Categories, Error> {
let response = response(
"category",
vec!(
format!("category_id={}", category_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn category_children(category_id: usize) -> Result<Categories, Error> {
let response = response(
"category/children",
vec!(
format!("category_id={}", category_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn category_related(category_id: usize) -> Result<Categories, Error> {
let response = response(
"category/related",
vec!(
format!("category_id={}", category_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn category_series(category_id: usize) -> Result<CategorySeries, Error> {
let response = response(
"category/series",
vec!(
format!("category_id={}", category_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn category_tags(category_id: usize) -> Result<CategoryTags, Error> {
let response = response(
"category/tags",
vec!(
format!("category_id={}", category_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn category_related_tags(category_id: usize, tag_names: &str) -> Result<CategoryRelatedTags, Error> {
let response = response(
"category/related_tags",
vec!(
format!("category_id={}", category_id),
format!("tag_names={}", tag_names),
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn releases() -> Result<Releases, Error> {
let response = response(
"releases",
Vec::new(),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn releases_dates() -> Result<ReleaseDates, Error> {
let response = response(
"releases/dates",
Vec::new(),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release(release_id: usize) -> Result<Release, Error> {
let response = response(
"release",
vec!(
format!("release_id={}", release_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release_dates(release_id: usize) -> Result<ReleaseDates, Error> {
let response = response(
"release/dates",
vec!(
format!("release_id={}", release_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release_series(release_id: usize) -> Result<ReleaseSeries, Error> {
let response = response(
"release/series",
vec!(
format!("release_id={}", release_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release_sources(release_id: usize) -> Result<ReleaseSources, Error> {
let response = response(
"release/sources",
vec!(
format!("release_id={}", release_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release_tags(release_id: usize) -> Result<ReleaseTags, Error> {
let response = response(
"release/tags",
vec!(
format!("release_id={}", release_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release_related_tags(release_id: usize, tag_names: &str) -> Result<ReleaseRelatedTags, Error> {
let response = response(
"release/related_tags",
vec!(
format!("release_id={}", release_id),
format!("tag_names={}", tag_names),
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn release_tables(release_id: usize) -> Result<ReleaseTables, Error> {
let response = response(
"release/tables",
vec!(
format!("release_id={}", release_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series(series_id: &str) -> Result<Series, Error> {
let response = response(
"series",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_json(series_id: &str) -> Result<String, Error> {
let response = response(
"series",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_categories(series_id: &str) -> Result<Categories, Error> {
let response = response(
"series/categories",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_observations(series_id: &str) -> Result<SeriesObservations, Error> {
let response = response(
"series/observations",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_observations_json(series_id: &str) -> Result<String, Error> {
let response = response(
"series/observations",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_release(series_id: &str) -> Result<SeriesRelease, Error>{
let response = response(
"series/release",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_search(search_text: &str) -> Result<SeriesSearch, Error> {
let response = response(
"series/search",
vec!(
format!("search_text={}", search_text)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_search_tags(series_search_text: &str) -> Result<SeriesSearchTags, Error> {
let response = response(
"series/search/tags",
vec!(
format!("series_search_text={}", series_search_text)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_search_related_tags(series_search_text: &str, tag_names: &str) -> Result<SeriesSearchRelatedTags, Error> {
let response = response(
"series/search/related_tags",
vec!(
format!("series_search_text={}", series_search_text),
format!("tag_names={}", tag_names),
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_tags(series_id: &str) -> Result<SeriesTags, Error> {
let response = response(
"series/tags",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_updates() -> Result<SeriesUpdates, Error> {
let response = response(
"series/updates",
Vec::new(),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn series_vintagedates(series_id: &str) -> Result<SeriesVintageDates, Error> {
let response = response(
"series/vintagedates",
vec!(
format!("series_id={}", series_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn sources() -> Result<Sources, Error> {
let response = response(
"sources",
Vec::new(),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn source(source_id: usize) -> Result<ReleaseSources, Error> {
let response = response(
"source",
vec!(
format!("source_id={}", source_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn source_releases(source_id: usize) -> Result<SourceReleases, Error> {
let response = response(
"source/releases",
vec!(
format!("source_id={}", source_id)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn tags() -> Result<Tags, Error> {
let response = response(
"tags",
Vec::new(),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn related_tags(tag_names: &str) -> Result<Tags, Error> {
let response = response(
"related_tags",
vec!(
format!("tag_names={}", tag_names)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
pub fn tags_series(tag_names: &str) -> Result<TagsSeries, Error> {
let response = response(
"tags/series",
vec!(
format!("tag_names={}", tag_names)
),
)?;
serde_json::from_str(&response).map_err(|err| json(err))
}
}
pub fn json<T: Display>(err: T) -> Error {
failed_to_parse_json(&err.to_string())
}
fn response(url: &str, keyvals: Vec<String>) -> Result<String, Error> {
let request = request_str(url, keyvals);
let blocking_response = match reqwest::blocking::get(&request) {
Ok(response) => response,
Err(err) => {
return Err(failed_http_request(&err.to_string()))
},
};
let response = match blocking_response.text_with_charset("utf-8") {
Ok(response) => {
response
},
Err(err) => {
return Err(failed_http_request(&err.to_string()))
},
};
let first_line = response.lines().next().unwrap();
if first_line.contains("error_code") {
return Err(failed_http_request(&response))
}
Ok(response)
}
fn request_str(url: &str, keyvals: Vec<String>) -> String {
let mut s = format!(
"https://api.stlouisfed.org/fred/{}?",
url,
);
for kv in keyvals {
s.push_str(&kv);
s.push('&');
};
s.push_str(&format!(
"api_key={}&file_type=json",
env::var("FRED_API_KEY").unwrap(),
));
s
}
#[derive(Debug, Deserialize)]
pub struct Categories {
pub categories: Vec<Category>,
}
impl fmt::Display for Categories {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut s = String::new();
for category in &self.categories {
s.push_str(&category.to_string());
};
write!(f, "{}", s)
}
}
#[derive(Debug, Deserialize)]
pub struct Category {
pub id: usize,
pub name: String,
pub parent_id: usize,
pub notes: Option<String>,
}
impl fmt::Display for Category {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f,
"id: {}\nname: {}\nparent_id: {}\nnotes: {:?}\n",
self.id,
self.name,
self.parent_id,
self.notes,
)
}
}
#[derive(Debug, Deserialize)]
pub struct CategoryChildren {
pub categories: Vec<Category>,
}
#[derive(Debug, Deserialize)]
pub struct CategoryRelated {
categories: Vec<Category>,
}
pub struct SeriesItemsIter<'a> {
data: &'a SeriesItems,
count: usize,
}
impl<'a> Iterator for SeriesItemsIter<'a> {
type Item = &'a SeriesItem;
fn next(&mut self) -> Option<Self::Item> {
if self.count == self.data.0.len() {
None
} else {
self.count += 1;
Some(&self.data.0[self.count - 1])
}
}
}
#[derive(Debug, Deserialize)]
pub struct SeriesItems(Vec<SeriesItem>);
impl SeriesItems {
pub fn iter<'a>(&'a self) -> SeriesItemsIter {
SeriesItemsIter {
data: &self,
count: 0,
}
}
pub fn exclude_phrases(&self, phrases: Vec<&str>) -> SeriesItems {
let mut v = Vec::new();
for series in self.iter() {
if !phrases.iter().any(|title| series.title.contains(title)) {
v.push(series.clone());
}
}
SeriesItems(v)
}
pub fn has_phrase(&self, phrase: &str) -> SeriesItems {
let mut v = Vec::new();
for series in self.iter() {
if series.title.contains(phrase) {
v.push(series.clone());
}
}
SeriesItems(v)
}
pub fn equals_one_of(&self, titles: Vec<&str>) -> SeriesItems {
let mut v = Vec::new();
for series in self.iter() {
if titles.iter().any(|title| *title == series.title) {
v.push(series.clone());
}
}
SeriesItems(v)
}
pub fn only_include(&self, phrases: Vec<&str>) -> SeriesItems {
let mut v = Vec::new();
for series in &self.0 {
if phrases.iter().any(|title| series.title.contains(title)) {
v.push(series.clone());
}
}
SeriesItems(v)
}
pub fn inner(&self) -> Vec<SeriesItem> {
(*self.0).to_vec()
}
}
impl IntoKeyTree for SeriesItems {
fn keytree(&self) -> KeyTreeString {
let mut s = KeyTreeString::new();
s.push_key(0, "series_items");
for series_item in self.iter() {
let sis = series_item.keytree();
s.push_keytree(1, sis);
}
s
}
}
impl fmt::Display for SeriesItems {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut s = KeyTreeString::new();
for (i, series) in self.0.iter().enumerate() {
s.push_value(0, "series", &i.to_string());
s.push_keytree(1, series.keytree());
};
write!(f, "{}", s)
}
}
#[derive(Debug, Deserialize)]
pub struct CategorySeries {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub seriess: SeriesItems,
}
impl fmt::Display for CategorySeries {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut s = String::new();
for (i, series) in self.seriess.0.iter().enumerate() {
s.push_str(&i.to_string());
s.push('\n');
s.push_str(&series.to_string());
s.push('\n');
};
write!(f, "{}", s)
}
}
#[derive(Debug, Deserialize)]
pub struct CategoryTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<Tag>,
}
#[derive(Debug, Deserialize)]
pub struct Tag {
pub name: String,
pub group_id: String,
pub notes: Option<String>,
pub created: String,
pub popularity: isize,
pub series_count: isize,
}
impl fmt::Display for Tag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f,
"name: {}\nnotes: {:?}\nseries_count: {}",
self.name,
self.notes,
self.series_count
)
}
}
#[derive(Debug, Deserialize)]
pub struct CategoryRelatedTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<Tag>,
}
#[derive(Debug, Deserialize)]
pub struct Releases {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub releases: Vec<ReleaseItem>,
}
#[derive(Debug, Deserialize)]
pub struct Release {
pub realtime_start: String,
pub realtime_end: String,
pub releases: Vec<ReleaseItem>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseItem {
pub id: isize,
pub realtime_start: String,
pub realtime_end: String,
pub name: String,
pub press_release: bool,
pub link: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct ReleasesDates {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub release_dates: Vec<ReleaseDate>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseDates {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub release_dates: Vec<ReleaseDateItem>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseDateItem {
pub release_id: isize,
pub date: String,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseDate {
pub release_id: isize,
pub release_name: String,
pub date: String,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseSeries {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub seriess: SeriesItems,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseSources {
pub realtime_start: String,
pub realtime_end: String,
pub sources: Vec<SourceItem>,
}
#[derive(Debug, Deserialize)]
pub struct SourceItem {
pub id: isize,
pub realtime_start: String,
pub realtime_end: String,
pub name: String,
pub link: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<TagItem>,
}
#[derive(Debug, Deserialize)]
pub struct TagItem {
pub name: String,
pub group_id: String,
pub notes: Option<String>,
pub created: String,
pub popularity: isize,
pub series_count: isize,
}
impl fmt::Display for TagItem {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f,
"name: {}\ngroup_id: {}\nnotes: {:?}\n",
self.name,
self.group_id,
self.notes,
)
}
}
#[derive(Debug, Deserialize)]
pub struct ReleaseRelatedTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<TagItem>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseTables {
pub name: String,
pub element_id: isize,
pub release_id: String,
pub elements: Vec<ReleaseKeyVal>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseKeyVal {
pub key: isize,
pub value: ReleaseElement,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseElement {
pub element_id: isize,
pub release_id: String,
pub series_id: String,
pub parent_id: String,
pub line: String,
#[serde(rename = "type")]
pub ty: String,
pub name: String,
pub level: String,
pub children: Vec<ReleaseElement>,
}
#[derive(Debug, Deserialize)]
pub struct Series {
pub realtime_start: String,
pub realtime_end: String,
pub seriess: SeriesItems,
}
impl IntoKeyTree for Series {
fn keytree(&self) -> KeyTreeString {
let mut s = KeyTreeString::new();
s.push_key(0, "series");
s.push_value(1, "realtime_start", &self.realtime_start);
s.push_value(1, "realtime_end", &self.realtime_end);
s.push_keytree(1, self.seriess.keytree());
s
}
}
impl fmt::Display for Series {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = self.keytree();
writeln!(f, "{}", s)
}
}
#[derive(Clone, Debug, Deserialize)]
pub struct SeriesItem {
pub id: String,
pub realtime_start: String,
pub realtime_end: String,
pub title: String,
pub observation_start: String,
pub observation_end: String,
pub frequency: String,
pub units: String,
pub units_short: String,
pub seasonal_adjustment: String,
pub seasonal_adjustment_short: String,
pub last_updated: String,
pub popularity: isize, pub group_popularity: Option<isize>, pub notes: Option<String>,
}
impl SeriesItem {
pub fn keytree(&self) -> KeyTreeString {
let mut s = KeyTreeString::new();
s.push_key(0, "series_item");
s.push_value(1, "id", &self.id);
s.push_value(1, "realtime_start", &self.realtime_start);
s.push_value(1, "realtime_end", &self.realtime_end);
s.push_value(1, "title", &self.title);
s.push_value(1, "observation_start", &self.observation_start);
s.push_value(1, "observation_end", &self.observation_end);
s.push_value(1, "frequency", &self.frequency);
s.push_value(1, "units", &self.units);
s.push_value(1, "units_short", &self.units_short);
s.push_value(1, "seasonal_adjustment", &self.seasonal_adjustment);
s.push_value(1, "last_updated", &self.last_updated);
s.push_value(1, "notes", "(see JSON data for notes)");
s
}
pub fn tags(&self) -> String {
Fred::series_tags(&self.id).unwrap().one_line()
}
}
impl fmt::Display for SeriesItem {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = self.keytree();
writeln!(f, "{}", s)
}
}
#[derive(Debug, Deserialize)]
pub struct SeriesCategories {
pub categories: Vec<CategoryItem>,
}
#[derive(Debug, Deserialize)]
pub struct CategoryItem {
pub id: String,
pub name: String,
pub parent_id: isize,
}
#[derive(Debug, Deserialize)]
pub struct Observations(Vec<Observation>);
impl Observations {
pub fn iter<'a>(&'a self) -> ObservationsIter {
ObservationsIter {
data: &self,
count: 0,
}
}
}
impl fmt::Display for Observations {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut s = String::new();
for obs in self.iter() {
s.push_str(&obs.to_string());
s.push('\n');
}
s.pop();
write!(f, "{}", s)
}
}
pub struct ObservationsIter<'a> {
data: &'a Observations,
count: usize,
}
impl<'a> Iterator for ObservationsIter<'a> {
type Item = &'a Observation;
fn next(&mut self) -> Option<Self::Item> {
if self.count == self.data.0.len() {
None
} else {
self.count += 1;
Some(&self.data.0[self.count - 1])
}
}
}
#[derive(Debug, Deserialize)]
pub struct SeriesObservations {
pub realtime_start: String,
pub realtime_end: String,
pub observation_start: String,
pub observation_end: String,
pub units: String,
pub output_type: isize,
pub file_type: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub observations: Observations,
}
#[derive(Debug, Deserialize)]
pub struct Observation {
pub realtime_start: String,
pub realtime_end: String,
pub date: String,
pub value: String,
}
impl fmt::Display for Observation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}, {}", self.date, self.value)
}
}
#[derive(Debug, Deserialize)]
pub struct SeriesRelease {
pub realtime_start: String,
pub realtime_end: String,
pub releases: Vec<ReleaseItem>,
}
#[derive(Debug, Deserialize)]
pub struct SeriesSearch {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub seriess: SeriesItems,
}
#[derive(Debug, Deserialize)]
pub struct SeriesSearchTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<TagItem>,
}
#[derive(Debug, Deserialize)]
pub struct SeriesSearchRelatedTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<TagItem>,
}
#[derive(Debug, Deserialize)]
pub struct SeriesTags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<TagItem>,
}
impl SeriesTags {
pub fn one_line(&self) -> String {
let mut s = String::new();
for tag in self.tags.iter() {
s.push_str(&tag.name);
s.push_str(", ");
};
s
}
}
impl fmt::Display for SeriesTags {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut s = String::new();
for (i, tags) in self.tags.iter().enumerate() {
s.push_str(&i.to_string());
s.push('\n');
s.push_str(&tags.to_string());
s.push('\n');
};
write!(f, "{}", s)
}
}
#[derive(Debug, Deserialize)]
pub struct SeriesUpdates {
pub realtime_start: String,
pub realtime_end: String,
pub filter_variable: String,
pub filter_value: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub seriess: SeriesItems,
}
#[derive(Debug, Deserialize)]
pub struct SeriesVintageDates {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub vintage_dates: Vec<String>,
}
#[derive(Debug, Deserialize)]
pub struct Sources {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub sources: Vec<SourceItem>,
}
#[derive(Debug, Deserialize)]
pub struct SourceReleases {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub releases: Vec<ReleaseItem>,
}
#[derive(Debug, Deserialize)]
pub struct Tags {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub tags: Vec<Tag>,
}
impl fmt::Display for Tags {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut tags = String::new();
for (i, tag) in self.tags.iter().enumerate() {
tags.push_str(&i.to_string());
tags.push('\n');
tags.push_str(&tag.to_string());
tags.push('\n');
tags.push('\n');
};
write!(f, "{}", tags)
}
}
#[derive(Debug, Deserialize)]
pub struct TagsSeries {
pub realtime_start: String,
pub realtime_end: String,
pub order_by: String,
pub sort_order: String,
pub count: isize,
pub offset: isize,
pub limit: isize,
pub seriess: SeriesItems,
}
impl TagsSeries {
pub fn series_titles(&self) -> String {
let mut s = String::new();
for series in &self.seriess.0 {
s.push_str(&series.title);
s.push('\n');
}
s
}
pub fn series(self) -> SeriesItems {
self.seriess
}
}
impl fmt::Display for TagsSeries {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut series = String::new();
for (i, s) in self.seriess.0.iter().enumerate() {
series.push_str(&format!("{}\n", i));
series.push_str(&s.to_string());
series.push('\n');
};
write!(f, "{}", series)
}
}