kanidm/src/lib/modify.rs

use proto_v1::Modify as ProtoModify;
use proto_v1::ModifyList as ProtoModifyList;

use error::SchemaError;
use schema::{SchemaAttribute, SchemaReadTransaction};

// Should this be std?
use std::slice;

#[derive(Serialize, Deserialize, Debug)]
pub struct ModifyValid;
#[derive(Serialize, Deserialize, Debug)]
pub struct ModifyInvalid;

#[derive(Serialize, Deserialize, Debug)]
pub enum Modify {
    // This value *should* exist.
    Present(String, String),
    // This value *should not* exist.
    Removed(String, String),
    // This attr *should not* exist.
    Purged(String),
}

impl Modify {
    pub fn from(m: &ProtoModify) -> Self {
        match m {
            ProtoModify::Present(a, v) => Modify::Present(a.clone(), v.clone()),
            ProtoModify::Removed(a, v) => Modify::Removed(a.clone(), v.clone()),
            ProtoModify::Purged(a) => Modify::Purged(a.clone()),
        }
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ModifyList<VALID> {
    valid: VALID,
    // The order of this list matters. Each change must be done in order.
    mods: Vec<Modify>,
}

// TODO: ModifyList should be like filter and have valid/invalid to schema.
// Or do we not care because the entry will be invalid at the end?

impl<'a> IntoIterator for &'a ModifyList<ModifyValid> {
    type Item = &'a Modify;
    type IntoIter = slice::Iter<'a, Modify>;

    fn into_iter(self) -> Self::IntoIter {
        self.mods.iter()
    }
}


impl ModifyList<ModifyInvalid> {
    pub fn new() -> Self {
        ModifyList {
            valid: ModifyInvalid,
            mods: Vec::new()
        }
    }

    pub fn new_list(mods: Vec<Modify>) -> Self {
        ModifyList {
            valid: ModifyInvalid,
            mods: mods
        }
    }

    pub fn push_mod(&mut self, modify: Modify) {
        self.mods.push(modify)
    }

    pub fn from(ml: &ProtoModifyList) -> Self {
        // For each ProtoModify, do a from.
        ModifyList {
            valid: ModifyInvalid,
            mods: ml.mods.iter().map(|pm| Modify::from(pm)).collect(),
        }
    }

    pub fn validate(&self,
        schema: &SchemaReadTransaction,
        ) -> Result<ModifyList<ModifyValid>, SchemaError> {
        // Check that all attributes exist in the schema

        // Normalise them

        // Validate them

        // Return new ModifyList!

        unimplemented!()
    }
}

impl ModifyList<ModifyValid> {
    #[cfg(test)]
    pub unsafe fn new_valid_list(mods: Vec<Modify>) -> Self {
        ModifyList {
            valid: ModifyValid,
            mods: mods
        }
    }
}

impl<VALID> ModifyList<VALID> {
    pub fn len(&self) -> usize {
        self.mods.len()
    }
}