oca_conductor 0.2.14

Lib for validating or tranforming data captured with OCA
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::data_set::DataSet;
use crate::errors::GenericError;
use serde::{Serialize, Serializer};
use serde_json::Value;
use std::collections::BTreeMap;

#[cfg(feature = "transformer")]
use crate::transformer::data_set_transformer::Operation;
#[cfg(feature = "transformer")]
use oca_rs::state::oca::OCA;
#[cfg(feature = "transformer")]
use serde_json::Map;

#[derive(Clone)]
pub struct JSONDataSet {
    pub raw: String,
}

impl Serialize for JSONDataSet {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.raw)
    }
}

impl DataSet for JSONDataSet {
    fn new(raw: String) -> Box<Self> {
        Box::new(Self { raw })
    }

    fn get_raw(&self) -> String {
        self.raw.clone()
    }

    fn load(
        &self,
        _attribute_types: BTreeMap<String, String>,
    ) -> Result<Vec<Value>, Vec<GenericError>> {
        match serde_json::from_str(&self.raw).unwrap_or(Value::Null) {
            Value::Array(data_set_array) => Ok(data_set_array),
            Value::Object(data_set_object) => Ok(vec![Value::Object(data_set_object)]),
            _ => Ok(vec![]),
        }
    }

    #[cfg(feature = "transformer")]
    fn transform_schema(
        &self,
        _mappings: BTreeMap<String, String>,
        _subset_attributes_op: Option<Vec<String>>,
    ) -> Result<Box<dyn DataSet + Sync + Send>, GenericError> {
        // TODO
        Ok(Self::new(self.raw.clone()))
    }

    #[cfg(feature = "transformer")]
    fn transform_data(
        &self,
        oca: &OCA,
        entry_code_mappings: BTreeMap<String, BTreeMap<String, String>>,
        unit_transformation_operations: BTreeMap<String, Vec<Operation>>,
    ) -> Result<Box<dyn DataSet + Sync + Send>, Vec<GenericError>> {
        // TODO
        let mut transformed_data_set = vec![];

        for record in self.load(oca.capture_base.attributes.clone())? {
            let record_map = record.as_object().unwrap();
            let mut transformed_data = Map::new();
            for (k, v) in record_map {
                let key = k.to_string();
                let mut value = v.clone();
                if let Some(mapped_entries) = entry_code_mappings.get(k) {
                    match value {
                        Value::Array(ref values_vec) => {
                            let mut mapped_values = vec![];
                            for v in values_vec {
                                match mapped_entries.get(v.as_str().unwrap()) {
                                    Some(mapped_entry) => {
                                        mapped_values.push(Value::String(mapped_entry.to_string()));
                                    }
                                    None => {
                                        mapped_values.push(v.clone());
                                    }
                                }
                            }
                            value = Value::Array(mapped_values);
                        }
                        Value::String(_) => {
                            if let Some(mapped_entry) = mapped_entries.get(value.as_str().unwrap())
                            {
                                value = Value::String(mapped_entry.to_string());
                            };
                        }
                        _ => (),
                    }
                }
                if let Some(operations) = unit_transformation_operations.get(k) {
                    if let Value::Number(num) = &value {
                        value = Value::Number(
                            serde_json::value::Number::from_f64(
                                self.calculate_value_units(num.as_f64().unwrap(), operations),
                            )
                            .unwrap(),
                        );
                    }
                }
                transformed_data.insert(key, value);
            }

            transformed_data_set.push(Value::Object(transformed_data));
        }

        Ok(Self::new(
            serde_json::to_string(&Value::Array(transformed_data_set)).unwrap(),
        ))
    }
}