path: root/examples/network_stream.rs

/* Example Zot API command line utility, part of zotapi.
 * Copyright (C) 2018 Harald Eilertsen <haraldei@anduin.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

use zotapi;

use serde_json;
use std::iter::Iterator;

pub fn fetch(client: &zotapi::Client, raw: bool) {
    match client.network_stream() {
        Ok(payload) => {
            if raw {
                println!("{}", payload);
            }
            else {
                list(&payload);
            }
        },
        Err(e) => {
            println!("Error getting channel stream: {:?}", e);
        }
    }
}

fn list(payload: &str) {
    match serde_json::from_str(&payload) {
        Ok(serde_json::Value::Array(v)) => {
            for item in v.into_iter() {
                print_item(&item);
                println!("-----");
            }
        },
        Ok(_) => {
            println!("Wrong type returned, expected an array.")
        },
        Err(e) => {
            println!("Error: {}", e);
        }
    }
}

fn get_str(v: &serde_json::Value) -> &str {
    v.as_str().unwrap_or("")
}

fn get_verb(item: &serde_json::Value) -> &str {
    match get_str(&item["verb"]).split("/").last() {
        Some("post") => "posted",
        Some("like") => "liked",
        Some("share") => "shared",
        Some("dislike") => "disliked",
        _ => "unknown verb",
    }
}

fn get_object_type(item: &serde_json::Value) -> &str {
    get_str(&item["object_type"])
        .split("/")
        .last()
        .unwrap_or("unknown object")
}

fn get_tags(item: &serde_json::Value) -> String {
    match item["tags"] {
        serde_json::Value::Array(ref v) => {
            v.iter().map(|t| {
                let prefix = match get_str(&t["type"]) {
                    "hashtag" => "#",
                    "forum" => "!",
                    "mention" => "@",
                    _ => "",
                };
                format!("{}{}", prefix, get_str(&t["tag"]))
            }).collect::<Vec<_>>().join(", ")
        },
        serde_json::Value::Null => {
            String::new()
        },
        _ => {
            String::from("invalid tags, expected array...")
        }
    }
}

fn print_item(item: &serde_json::Value) {
    let author = &item["author"];
    print!("{} ", get_str(&item["created"]));
    print!("{} ", get_str(&author["name"]));
    println!("{} a {}", get_verb(&item), get_object_type(&item));
    println!("URL:   {}", get_str(&author["url"]));
    println!("Proto: {}", get_str(&author["network"]));
    println!("Title: {}", get_str(&item["title"]));
    println!("Tags : {}", get_tags(&item));
    println!("Message:\n{}", get_str(&item["body"]));
}