path: root/src/xchan.rs

// zotapi - Rust wrapper for Sot API as implemented by Hubzilla
// 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 <https://www.gnu.org/licenses/>.

use crate::{client::Client, error::Error};
use serde::Deserialize;

#[derive(Debug, Default, Deserialize)]
pub struct XChan {
    hash: String,
    guid: String,
    guid_sig: String,
    pubkey: String,
    photo_mimetype: String,
    photo_l: String,
    photo_m: String,
    photo_s: String,
    addr: String,
    url: String,
    connurl: String,
    follow: String,
    connpage: String,
    name: String,
    network: String,
    instance_url: String,
    flags: u32,
    photo_date: String,
    name_date: String,
    hidden: u32,
    orphan: u32,
    censored: u32,
    selfcensored: u32,
    system: u32,
    pubforum: u32,
    deleted: u32,
}

impl XChan {
    pub fn z<'a>() -> XChanRequest<'a> {
        XChanRequest::default()
    }
}

enum XChanRequestSelector<'a> {
    Address(&'a str),
    Hash(&'a str),
    GUID(&'a str),
}

#[derive(Default)]
pub struct XChanRequest<'a> {
    data: Option<XChanRequestSelector<'a>>,
}

impl<'a> XChanRequest<'a> {
    pub fn by_address(&mut self, addr: &'a str) -> &mut XChanRequest<'a> {
        self.data = Some(XChanRequestSelector::Address(addr));
        self
    }

    pub fn by_hash(&mut self, hash: &'a str) -> &mut XChanRequest<'a> {
        self.data = Some(XChanRequestSelector::Hash(hash));
        self
    }

    pub fn by_guid(&mut self, guid: &'a str) -> &mut XChanRequest<'a> {
        self.data = Some(XChanRequestSelector::GUID(guid));
        self
    }

    pub async fn fetch(&self, client: &Client) -> Result<XChan, Error> {
        let mut req = client.get("xchan");

        if let Some(sel) = &self.data {
            req = match sel {
                XChanRequestSelector::Address(s) => req.query(&[("address", s.to_string())]),
                XChanRequestSelector::Hash(s)    => req.query(&[("hash", s.to_string())]),
                XChanRequestSelector::GUID(s)    => req.query(&[("guid", s.to_string())]),
            };
        }

        Ok(serde_json::from_str(&dbg!(req.send().await?.text().await?))?)
    }
}