path: root/src/vcard.rs

use std::ops::Deref;
use std::collections::BTreeMap;

use component::Component;
use component::parse_component;
use property::Property;

use std::result::Result as RResult;
use error::*;

#[derive(Debug)]
pub struct Vcard(Component);

/// The Vcard object.
///
/// This type simply holds data and offers functions to access this data. It does not compute
/// anything.
impl Vcard {

    /// Parse a string to a Vcard object
    ///
    /// Returns an error if the parsed text is not a Vcard (that means that an error is returned
    /// also if this is a valid icalendar!)
    ///
    pub fn build(s: &str) -> VObjectResult<Vcard> {
        parse_component(s)
            .and_then(|c| {
                Self::from_component(c).map_err(|_| VObjectErrorKind::NotAVCard)
            })
    }

    /// Helper for `VcardBuilder::new()`
    pub fn builder() -> VcardBuilder {
        VcardBuilder::new()
    }

    /// Wrap a Component into a Vcard object, or don't do it if the Component is not a Vcard.
    pub fn from_component(c: Component)-> RResult<Vcard, Component> {
        if c.name == "VCARD" {
            Ok(Vcard(c))
        } else {
            Err(c)
        }
    }

    make_getter_function_for_values!(adr            , "ADR"          , Adr);
    make_getter_function_for_optional!(anniversary  , "ANNIVERSARY"  , Anniversary);
    make_getter_function_for_optional!(bday         , "BDAY"         , BDay);
    make_getter_function_for_values!(categories     , "CATEGORIES"   , Category);
    make_getter_function_for_optional!(clientpidmap , "CLIENTPIDMAP" , ClientPidMap);
    make_getter_function_for_values!(email          , "EMAIL"        , Email);
    make_getter_function_for_values!(fullname       , "FN"           , FullName);
    make_getter_function_for_optional!(gender       , "GENDER"       , Gender);
    make_getter_function_for_values!(geo            , "GEO"          , Geo);
    make_getter_function_for_values!(impp           , "IMPP"         , IMPP);
    make_getter_function_for_values!(key            , "KEY"          , Key);
    make_getter_function_for_values!(lang           , "LANG"         , Lang);
    make_getter_function_for_values!(logo           , "LOGO"         , Logo);
    make_getter_function_for_values!(member         , "MEMBER"       , Member);
    make_getter_function_for_optional!(name         , "N"            , Name);
    make_getter_function_for_values!(nickname       , "NICKNAME"     , NickName);
    make_getter_function_for_values!(note           , "NOTE"         , Note);
    make_getter_function_for_values!(org            , "ORG"          , Organization);
    make_getter_function_for_values!(photo          , "PHOTO"        , Photo);
    make_getter_function_for_optional!(proid        , "PRIOD"        , Proid);
    make_getter_function_for_values!(related        , "RELATED"      , Related);
    make_getter_function_for_optional!(rev          , "REV"          , Rev);
    make_getter_function_for_values!(role           , "ROLE"         , Title);
    make_getter_function_for_values!(sound          , "SOUND"        , Sound);
    make_getter_function_for_values!(tel            , "TEL"          , Tel);
    make_getter_function_for_values!(title          , "TITLE"        , Title);
    make_getter_function_for_values!(tz             , "TZ"           , Tz);
    make_getter_function_for_optional!(uid          , "UID"          , Uid);
    make_getter_function_for_values!(url            , "URL"          , Url);
    make_getter_function_for_optional!(version      , "VERSION"      , Version);

    fn set_properties(&mut self, props: BTreeMap<String, Vec<Property>>) {
        self.0.props = props;
    }

}

impl Default for Vcard {
    fn default() -> Self {
        Vcard(Component::new(String::from("VCARD")))
    }
}

impl Deref for Vcard {
    type Target = Component;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// A builder for building a Vcard object.
pub struct VcardBuilder {
    properties: BTreeMap<String, Vec<Property>>
}

macro_rules! make_builder_fn {
    (
        fn $fnname:ident building $property_name:tt with_params,
        $mapfn:expr => $( $arg_name:ident : $arg_type:ty ),*
    ) => {
        pub fn $fnname(mut self, params: $crate::param::Parameters, $( $arg_name : $arg_type ),*) -> Self {
            let raw_value = vec![ $( $arg_name ),* ]
                .into_iter()
                .map($mapfn)
                .collect::<Vec<_>>()
                .join(";");

            let prop = Property {
                name: String::from($property_name),
                params: params,
                raw_value: raw_value,
                prop_group: None
            };

            self.properties.entry(String::from($property_name)).or_insert(vec![]).push(prop);
            self
        }
    };

    (
        fn $fnname:ident building $property_name:tt,
        $mapfn:expr => $( $arg_name:ident : $arg_type:ty ),*
    ) => {
        pub fn $fnname(mut self, $( $arg_name : $arg_type ),*) -> Self {
            let raw_value = vec![ $( $arg_name ),* ]
                .into_iter()
                .map($mapfn)
                .collect::<Vec<_>>()
                .join(";");


            let prop = Property {
                name: String::from($property_name),
                params: BTreeMap::new(),
                raw_value: raw_value,
                prop_group: None
            };
            self.properties.entry(String::from($property_name)).or_insert(vec![]).push(prop);
            self
        }
    }
}

impl VcardBuilder {
    pub fn new() -> Self {
        VcardBuilder {
            properties: BTreeMap::new(),
        }
    }

    pub fn build(self) -> VObjectResult<Vcard> {
        let mut v = Vcard::default();
        v.set_properties(self.properties);
        Ok(v)
    }

    make_builder_fn!(fn with_adr building "ADR" with_params,
                     |o| o.unwrap_or(String::from("")) =>
                     pobox    : Option<String>,
                     ext      : Option<String>,
                     street   : Option<String>,
                     locality : Option<String>,
                     region   : Option<String>,
                     code     : Option<String>,
                     country  : Option<String>);

    make_builder_fn!(fn with_anniversary  building "ANNIVERSARY"        , |o| o => value: String);
    make_builder_fn!(fn with_bday         building "BDAY" with_params   , |o| o => value: String);
    make_builder_fn!(fn with_categories   building "CATEGORIES"         , |o| o.join(";") => org: Vec<String>);
    make_builder_fn!(fn with_clientpidmap building "CLIENTPIDMAP"       , |o| o => raw: String);
    make_builder_fn!(fn with_email        building "EMAIL"              , |o| o => email: String);
    make_builder_fn!(fn with_fullname     building "FN"                 , |o| o => fullname: String);
    make_builder_fn!(fn with_gender       building "GENDER" with_params , |o| o => value: String);
    make_builder_fn!(fn with_geo          building "GEO"                , |o| o => uri: String);
    make_builder_fn!(fn with_impp         building "IMPP"               , |o| o => uri: String);
    make_builder_fn!(fn with_key          building "KEY"                , |o| o => uri: String);
    make_builder_fn!(fn with_lang         building "LANG"               , |o| o => lang: String);
    make_builder_fn!(fn with_logo         building "LOGO"               , |o| o => uri: String);
    make_builder_fn!(fn with_member       building "MEMBER"             , |o| o => uri: String);

    make_builder_fn!(fn with_name building "N" with_params,
                     |o|