vika 0.1.2

#[derive(Debug, Serialize, Deserialize)]
pub struct Field {
    pub id: String,
    pub name: String,
    pub r#type: FieldType,
    pub desc: Option<String>,
    pub property: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct FieldsRespSchema {
    pub fields: Vec<Field>,
}

pub struct FieldsManager {
    pub space_id: String,
    pub datasheet_id: String,
    pub view_id: Option<String>,
    pub config: Config,
}

impl FieldsManager {
    pub async fn query_all(&self) -> anyhow::Result<Vec<Field>, anyhow::Error> {
        let url = format!(
            "{}/datasheets/{}/fields{}",
            self.config.get_url(),
            self.datasheet_id,
            match self.view_id.clone() {
                Some(view_id) => format!("?viewId={}", view_id),
                None => format!(""),
            }
        );
        let client = reqwest::Client::new();
        let resp = client
            .get(&url)
            .headers(self.config.clone().into())
            .send()
            .await?
            .json::<ResponseSchema<FieldsRespSchema>>()
            .await?;
        match resp.code {
            200 => anyhow::Ok(resp.data.unwrap().fields),
            _ => Err(anyhow::Error::msg(format!(
                "code: {}, success: {}, message: {}, request_url: {}",
                resp.code, resp.success, resp.message, url
            ))),
        }
    }
}

pub struct FieldManager {
    pub space_id: String,
    pub datasheet_id: String,
    pub view_id: String,
    pub field_id: String,
    pub config: Config,
}

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use crate::common::{config::Config, http::ResponseSchema};

#[derive(Debug, Serialize, Deserialize)]
pub enum FieldType {
    SingleText,
    Text,
    SingleSelect,
    MultiSelect,
    Number,
    Currency,
    Percent,
    Datetime,
    Attachment,
    Member,
    Checkbox,
    Rating,
    URL,
    Phone,
    Email,
    WorkDoc,
    OneWayLink,
    TwoWayLink,
    MagicLookUp,
    Formula,
    AutoNumber,
    Button,
    DateTime,
}

impl std::fmt::Display for FieldType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{:?}",
            match self {
                FieldType::SingleText => "SingleText",
                FieldType::Text => "Text",
                FieldType::SingleSelect => "SingleSelect",
                FieldType::MultiSelect => "MultiSelect",
                FieldType::Number => "Number",
                FieldType::Currency => "Currency",
                FieldType::Percent => "Percent",
                FieldType::Datetime => "Datetime",
                FieldType::Attachment => "Attachment",
                FieldType::Member => "Member",
                FieldType::Checkbox => "Checkbox",
                FieldType::Rating => "Rating",
                FieldType::URL => "URL",
                FieldType::Phone => "Phone",
                FieldType::Email => "Email",
                FieldType::WorkDoc => "WorkDoc",
                FieldType::OneWayLink => "OneWayLink",
                FieldType::TwoWayLink => "TwoWayLink",
                FieldType::MagicLookUp => "MagicLookUp",
                FieldType::Formula => "Formula",
                FieldType::AutoNumber => "AutoNumber",
                FieldType::Button => "Button",
                FieldType::DateTime => "DateTime",
            }
        )
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Attachment {
    id: String,
    name: String,
    size: usize,
    mime_type: String,
    token: String,
    width: usize,
    height: usize,
    url: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Member {
    id: String,
    r#type: i32,
    name: String,
    avatar: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Url {
    title: String,
    text: String,
    fafavicon: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum Formula {
    Formula(String),
    Number(f64),
    Bool(bool),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkDoc {
    document_id: String,
    title: String,
}