cooplan-definition-schema-validator 0.2.2

Validate JSON values against a definition
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::category_chain::CategoryChain;
use crate::definition_type::DefinitionType;
use crate::error::{Error, ErrorKind};
use cooplan_definitions_lib::definition::Definition;
use serde::Deserialize;
use serde_json::{Map, Value};

/// Validated, definition scoped, JSON value.
#[derive(Debug, Deserialize)]
pub struct DefinitionValue {
    definition: String,
    definition_type: DefinitionType,
    category_chain: CategoryChain,
    value: Map<String, Value>,
}

impl DefinitionValue {
    pub fn try_new(
        definition: &Definition,
        category_chain: CategoryChain,
        value: Map<String, Value>,
    ) -> Result<DefinitionValue, Error> {
        let definition_type = if value.contains_key(DefinitionType::Product.attribute_id()) {
            DefinitionType::Product
        } else if value.contains_key(DefinitionType::Modifier.attribute_id()) {
            DefinitionType::Modifier
        } else if value.contains_key(DefinitionType::Service.attribute_id()) {
            DefinitionType::Service
        } else {
            return Err(Error::new(
                ErrorKind::InvalidValue,
                "definition type not found",
            ));
        };

        Ok(DefinitionValue {
            definition: definition.version(),
            category_chain,
            definition_type,
            value,
        })
    }

    pub fn definition(&self) -> &String {
        &self.definition
    }

    pub fn value(&self) -> &Map<String, Value> {
        &self.value
    }

    pub fn category_chain(&self) -> &CategoryChain {
        &self.category_chain
    }

    pub fn definition_type(&self) -> DefinitionType {
        self.definition_type
    }
}