product_os_utilities/

lib.rs

#![no_std]
extern crate no_std_compat as std;

use std::prelude::v1::*;

pub mod data;

use std::fmt::Formatter;

use crate::data::DataFormat;

#[cfg(any(feature = "networking", feature = "networking_std"))]
use product_os_net::{ IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs };

#[cfg(feature = "networking_std")]
use dns_lookup::lookup_host;

#[cfg(feature = "files")]
use product_os_security::RandomGeneratorTemplate;

#[cfg(feature = "content")]
use content_inspector::{ContentType, inspect};
#[cfg(feature = "content")]
use mime_sniffer::MimeTypeSniffer;


#[cfg(feature = "files")]
use std::sync::Arc;

#[cfg(feature = "files")]
use parking_lot::Mutex;


#[cfg(feature = "json")]
use regex::Regex;
#[cfg(feature = "json")]
use chrono::NaiveDateTime;

#[cfg(any(feature = "json", feature = "yaml", feature = "networking", feature = "networking_std"))]
use std::str::FromStr;

use serde::{ Serialize, Deserialize };


#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
pub enum ProductOSError {
    GenericError(String)
}

impl ProductOSError {
    pub fn to_string(&self) -> String {
        match self {
            ProductOSError::GenericError(e) => e.to_owned(),
            // _ => "Dunno".to_string()
        }
    }
}

impl std::fmt::Display for ProductOSError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            ProductOSError::GenericError(s) => write!(f, "{}", s)
        }
    }
}


pub struct ProductOSUtilities {}

impl ProductOSUtilities {
    #[cfg(feature = "files")]
    pub fn get_current_working_dir() -> String {
        let res = std::env::current_dir();
        match res {
            Ok(path) => path.into_os_string().into_string().unwrap(),
            Err(_) => panic!("Problem getting current working directory")
        }
    }

    #[cfg(feature = "files")]
    pub fn get_base_path(files_path: &str) -> String {
        let mut files_base_path = String::new();

        if !files_path.starts_with("/") {
            files_base_path.push_str(ProductOSUtilities::get_current_working_dir().as_str());
        }

        if !files_path.ends_with("/") {
            files_base_path.push_str("/");
        }

        files_base_path.push_str(files_path);

        tracing::info!("File list path used for file list get is: {:?}", files_base_path);

        files_base_path
    }

    #[cfg(feature = "files")]
    pub fn get_file_list(files_path: &str) -> Result<Vec<String>, ProductOSError> {
        let files_base_path = ProductOSUtilities::get_base_path(files_path);

        tracing::info!("File list path used for file list get is: {:?}", files_base_path);

        let entries = walkdir::WalkDir::new(files_base_path.as_str())
            .min_depth(1)
            .max_depth(5)
            .follow_links(true)
            .into_iter()
            .filter_entry(|e| ProductOSUtilities::is_not_hidden(e));
        //.filter_map(|v| v.ok());
        //.for_each(|entry| );

        let mut files_list = Vec::new();

        for entry in entries {
            match entry {
                Ok(entry) => {
                    let path = entry.path();
                    match path.to_str() {
                        None => {}
                        Some(s) => {
                            if entry.metadata().unwrap().is_file() {
                                // let filename = s.split('/').collect::<Vec<&str>>().last().unwrap().to_owned();

                                let mut files_path = files_path.to_owned();
                                files_path.push_str(s.to_string().replace(files_base_path.as_str(), "").as_str());

                                let mut files_data_path = String::from(files_base_path.as_str());
                                files_data_path.push_str(s.to_string().replace(files_base_path.as_str(), "").as_str());

                                files_list.push(files_data_path);
                            }
                        }
                    }
                }
                Err(e) => return Err(ProductOSError::GenericError(format!("Failed to read files folder entry: {:?}", e)))
            }
        }

        Ok(files_list)
    }

    #[cfg(feature = "files")]
    fn is_not_hidden(entry: &walkdir::DirEntry) -> bool {
        entry
            .file_name()
            .to_str()
            .map(|s| !s.starts_with("."))
            .unwrap_or(false)
    }

    #[cfg(feature = "files")]
    pub fn get_select_file(random_generator: Arc<Mutex<product_os_security::RandomGenerator>>, files_path: &str) -> Result<String, ProductOSError> {
        let mut generator = random_generator.lock();

        match ProductOSUtilities::get_file_list(files_path) {
            Ok(files_list) => {
                let random_value = generator.get_random_usize(0, files_list.len());
                let value: String = files_list.get(random_value).unwrap().to_string();
                Ok(value)
            }
            Err(e) => Err(e)
        }
    }

    #[cfg(feature = "logging_std")]
    pub fn define_logging(level: tracing::Level) -> tracing_subscriber::FmtSubscriber {
        // a builder for `FmtSubscriber`.
        tracing_subscriber::FmtSubscriber::builder()
            // filter spans/events with level TRACE or higher.
            .with_max_level(level)
            // build but do not install the subscriber.
            .finish()
    }

    #[cfg(feature = "logging_std")]
    pub fn set_global_logger(definition: tracing_subscriber::FmtSubscriber) {
        match tracing::subscriber::set_global_default(definition) {
            Ok(_) => {}
            Err(e) => { tracing::warn!("Error setting default subscriber: {}", e) }
        }
    }

    #[cfg(feature = "networking_advanced")]
    pub fn get_all_current_host_ip_addresses() -> Vec<core::net::IpAddr> {
        let mut ip_list = Vec::new();

        for iface in pnet::datalink::interfaces() {
            let ips = iface.ips;

            for ip in ips {
                tracing::info!("Idnentified current host IP address: {:?}", ip);
                ip_list.push(ip.network())
            }
        }

        ip_list
    }

    #[cfg(feature = "networking_std")]
    pub fn get_socket_address(host: &str, port: u16, default_all_interfaces: bool) -> SocketAddr {
        let socket_port = port;

        let default_address = match default_all_interfaces {
            true => SocketAddr::from((Ipv4Addr::new(0, 0, 0, 0), socket_port)),
            false => SocketAddr::from((Ipv4Addr::new(127, 0, 0, 1), socket_port))
        };

        match lookup_host(host) {
            Ok(addresses) => {
                for address in addresses {
                    let address_string = address.to_string();
                    match SocketAddr::from_str(address_string.as_str()) {
                        Ok(socket_addr) => return socket_addr,
                        Err(_) => {}
                    }
                }

                tracing::info!("Hostname did not resolve any meaningful address, using default address");
                default_address
            },
            Err(_) => {
                match Ipv4Addr::from_str(host) {
                    Ok(address) => {
                        SocketAddr::from((IpAddr::V4(address), socket_port))
                    },
                    Err(_) => {
                        match Ipv6Addr::from_str(host) {
                            Ok(address) => {
                                SocketAddr::from((IpAddr::V6(address), socket_port))
                            },
                            Err(_) => {
                                tracing::error!("Address defined does not meet any allowed formats, using default address");
                                default_address
                            }
                        }
                    }
                }
            }
        }
    }

    #[cfg(feature = "networking_std")]
    pub fn get_all_interfaces_socket_address(host: &str, port: u16) -> SocketAddr {
        let socket_port = port;

        let default_address = SocketAddr::from((Ipv4Addr::new(0, 0, 0, 0), socket_port));

        match Ipv4Addr::from_str(host) {
            Ok(address) => {
                SocketAddr::from((IpAddr::V4(address), socket_port))
            },
            Err(_) => {
                match Ipv6Addr::from_str(host) {
                    Ok(address) => {
                        SocketAddr::from((IpAddr::V6(address), socket_port))
                    },
                    Err(_) => {
                        tracing::error!("Address defined does not meet any allowed formats, using default address");
                        default_address
                    }
                }
            }
        }
    }

    #[cfg(feature = "networking_std")]
    pub fn get_local_socket_address(host: &str, port: u16) -> SocketAddr {
        let socket_port = port;

        let default_address = SocketAddr::from((Ipv4Addr::new(127, 0, 0, 1), socket_port));

        match Ipv4Addr::from_str(host) {
            Ok(address) => {
                SocketAddr::from((IpAddr::V4(address), socket_port))
            },
            Err(_) => {
                match Ipv6Addr::from_str(host) {
                    Ok(address) => {
                        SocketAddr::from((IpAddr::V6(address), socket_port))
                    },
                    Err(_) => {
                        tracing::error!("Address defined does not meet any allowed formats, using default address");
                        default_address
                    }
                }
            }
        }
    }

    // JSON

    #[cfg(feature = "json")]
    pub fn find_json_property(object: &serde_json::Value, property: &str, default_value: &serde_json::Value) -> serde_json::Value {
        let property_parts = property.split(".").collect::<Vec<&str>>();
        let property_parts_length = property_parts.len();

        ProductOSUtilities::find_json_property_internal(object, property_parts, default_value, 0, property_parts_length)
    }

    #[cfg(feature = "json")]
    fn find_json_property_internal(object: &serde_json::Value, property_parts: Vec<&str>, default_value: &serde_json::Value, depth: usize, property_parts_length: usize) -> serde_json::Value {
        match object {
            serde_json::Value::Array(array) => {
                match usize::from_str(property_parts.get(depth).unwrap()) {
                    Ok(prop) => {
                        match array.get(prop) {
                            None => default_value.to_owned(),
                            Some(value) => {
                                if depth == property_parts_length - 1 {
                                    value.to_owned()
                                }
                                else {
                                    ProductOSUtilities::find_json_property_internal(value, property_parts.to_owned(), default_value, depth + 1, property_parts_length)
                                }
                            }
                        }
                    }
                    Err(_) => default_value.to_owned()
                }
            }
            serde_json::Value::Object(o) => {
                #[cfg(feature = "logging")]
                tracing::info!("Name {:?} in object {:?} for remap", &property_parts.get(depth).unwrap().to_string(), o);
                match o.get_key_value(&property_parts.get(depth).unwrap().to_string()) {
                    None => default_value.to_owned(),
                    Some((_, value)) => {
                        if depth == property_parts_length - 1 {
                            value.to_owned()
                        }
                        else {
                            ProductOSUtilities::find_json_property_internal(value, property_parts.to_owned(), default_value, depth + 1, property_parts_length)
                        }
                    }
                }
            }
            _ => default_value.to_owned()
        }
    }

    #[cfg(feature = "json")]
    pub fn is_number_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Number(_) => true,
            serde_json::Value::String(s) => {
                let regex = Regex::new("^[-+]?[0-9]+([.][0-9]+)?$").unwrap();
                regex.is_match(s.as_str())
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_integer_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Number(n) => {
                if n.is_i64() || n.is_u64() { true }
                else { false }
            },
            serde_json::Value::String(s) => {
                let regex = Regex::new("^[-+]?[0-9]+$").unwrap();
                regex.is_match(s.as_str())
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_float_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Number(n) => {
                if n.is_f64() { true }
                else { false }
            },
            serde_json::Value::String(s) => {
                let regex = Regex::new("^[-+]?[0-9]+([.][0-9]+)$").unwrap();
                regex.is_match(s.as_str())
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_boolean_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Bool(_) => true,
            serde_json::Value::Number(n) => {
                if n.is_i64() {
                    match n.as_i64().unwrap() {
                        0 | 1 => true,
                        _ => false
                    }
                }
                else if n.is_u64() {
                    match n.as_u64().unwrap() {
                        0 | 1 => true,
                        _ => false
                    }
                }
                else { false }
            }
            serde_json::Value::String(s) => {
                let regex = Regex::new("^(?i)(none|some|null|true|false|0|1)$").unwrap();
                regex.is_match(s.as_str())
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_date_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(s) => {
                match NaiveDateTime::from_str(s.as_str()) {
                    Ok(_) => true,
                    Err(_) => false
                }
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_base64_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(s) => {
                let regex = Regex::new("^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$").unwrap();
                regex.is_match(s.as_str())
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_mime_type_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(s) => {
                let regex = Regex::new("\\w+/[-.\\w]+(?:\\+[-.\\w]+)?").unwrap();
                regex.is_match(s.as_str())
            }
            _ => false
        }
    }

    #[cfg(all(feature = "json", feature = "content"))]
    pub fn is_valid_mime_type_json(object: &serde_json::Value) -> Option<String> {
        match object {
            serde_json::Value::String(s) => {
                match s.as_str().sniff_mime_type() {
                    None => None,
                    Some(s) => Some(s.to_string())
                }
            }
            _ => None
        }
    }

    #[cfg(all(feature = "json", feature = "content"))]
    pub fn is_binary_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(s) => {
                match inspect(s.as_bytes()) {
                    ContentType::BINARY => true,
                    _ => false
                }
            }
            _ => false
        }
    }

    #[cfg(all(feature = "json", feature = "xml"))]
    pub fn is_xml_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(s) => {
                let parser = xml::reader::EventReader::from_str(s.as_str());

                let mut is_valid = false;
                for e in parser {
                    match e {
                        Ok(_) => { is_valid = true },
                        Err(_) => {}
                    }
                }

                is_valid
            }
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_array_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Array(_) => true,
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_string_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(_) => true,
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_option_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::String(_) => true,
            serde_json::Value::Number(_) => true,
            serde_json::Value::Bool(_) => true,
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_object_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Object(_) => true,
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn is_null_json(object: &serde_json::Value) -> bool {
        match object {
            serde_json::Value::Null => true,
            _ => false
        }
    }

    #[cfg(feature = "json")]
    pub fn data_type_json(object: &serde_json::Value) -> DataFormat {
        if ProductOSUtilities::is_number_json(object) {
            return DataFormat::Number
        }

        if ProductOSUtilities::is_boolean_json(object) {
            return DataFormat::Boolean
        }

        if ProductOSUtilities::is_date_json(object) {
            return DataFormat::Date
        }

        #[cfg(all(feature = "json", feature = "xml"))] {
            if ProductOSUtilities::is_xml_json(object) {
                return DataFormat::XML
            }
        }

        if ProductOSUtilities::is_object_json(object) {
            return DataFormat::JSON
        }

        if ProductOSUtilities::is_array_json(object) {
            return DataFormat::List
        }

        if ProductOSUtilities::is_base64_json(object) {
            return DataFormat::Base64
        }

        #[cfg(all(feature = "json", feature = "content"))] {
            if ProductOSUtilities::is_binary_json(object) {
                return DataFormat::Binary
            }
        }

        #[cfg(all(feature = "json", feature = "content"))] {
            match ProductOSUtilities::is_valid_mime_type_json(object) {
                None => {
                    if ProductOSUtilities::is_string_json(object) {
                        return DataFormat::Text
                    }
                    else if ProductOSUtilities::is_option_json(object) {
                        return DataFormat::Option(object.to_string())
                    }
                }
                Some(s) => {
                    return DataFormat::Mime(s)
                }
            }
        }

        DataFormat::Unknown
    }

    #[cfg(feature = "text")]
    pub fn text_indent(size: usize) -> String {
        const INDENT: &'static str = "    ";
        (0..size).map(|_| INDENT)
            .fold(String::with_capacity(size*INDENT.len()), |r, s| r + s)
    }

    #[cfg(feature = "yaml")]
    pub fn yaml_to_string(yaml: &serde_yaml::Value, is_document: bool) -> Result<String, ProductOSError> {
        let depth = 0;

        let mut yaml_string = String::new();

        if is_document {
            yaml_string.push_str("---\n");
        }

        match ProductOSUtilities::yaml_to_string_internal(yaml, depth) {
            Ok(yaml_str) => yaml_string.push_str(yaml_str.as_str()),
            Err(e) => return Err(e)
        }

        Ok(yaml_string)
    }

    #[cfg(feature = "yaml")]
    pub fn string_to_yaml(yaml_string: &str) -> Result<serde_yaml::Value, ProductOSError> {
        match serde_yaml::from_str(yaml_string) {
            Ok(v) => Ok(v),
            Err(e) => Err(ProductOSError::GenericError(e.to_string()))
        }
    }

    #[cfg(feature = "yaml")]
    fn yaml_to_string_internal(yaml: &serde_yaml::Value, mut depth: usize) -> Result<String, ProductOSError> {
        let mut yaml_string = String::new();

        match yaml {
            serde_yaml::Value::Null => {},
            serde_yaml::Value::Bool(b) => yaml_string.push_str(format!("{}", b).as_str()),
            serde_yaml::Value::Number(n) => {
                match n.as_u64() {
                    Some(u) => yaml_string.push_str(format!("{}", u).as_str()),
                    None => {
                        match n.as_f64() {
                            Some(f) => yaml_string.push_str(format!("{}", f).as_str()),
                            None => {
                                match n.as_i64() {
                                    Some(i) => yaml_string.push_str(format!("{}", i).as_str()),
                                    None => return Err(ProductOSError::GenericError(String::from("Could not convert YAML")))
                                }
                            }
                        }
                    }
                }
            }
            serde_yaml::Value::String(s) => yaml_string.push_str(format!("{}", s).as_str()),
            serde_yaml::Value::Sequence(a) => {
                for element in a {
                    match ProductOSUtilities::yaml_to_string_internal(element, depth) {
                        Ok(value) => {
                            yaml_string.push_str(format!("{}- ", ProductOSUtilities::text_indent(depth)).as_str());

                            depth = depth + 1;
                            yaml_string.push_str(format!("{}", value).as_str());
                            depth = depth - 1;
                        }
                        Err(e) => return Err(e)
                    };

                    yaml_string.push_str("\n");
                }
            }
            serde_yaml::Value::Mapping(m) => {
                for (key, value) in m {
                    match ProductOSUtilities::yaml_to_string_internal(key, depth) {
                        Ok(key) => {
                            yaml_string.push_str(format!("{}{}: ", ProductOSUtilities::text_indent(depth), key).as_str());
                        }
                        Err(e) => return Err(e)
                    };

                    depth = depth + 1;
                    match ProductOSUtilities::yaml_to_string_internal(value, depth) {
                        Ok(value) => {
                            yaml_string.push_str(format!("{}", value).as_str());
                        }
                        Err(e) => return Err(e)
                    };
                    depth = depth - 1;

                    yaml_string.push_str("\n");
                }
            }
            serde_yaml::Value::Tagged(t) => {
                let value = match ProductOSUtilities::yaml_to_string_internal(&t.value, depth + 1) {
                    Ok(v) => v,
                    Err(e) => return Err(e)
                };

                yaml_string.push_str(format!("{}: {}\n", t.tag.to_string(), value).as_str());
            }
        }

        Ok(yaml_string)

        /*
        match yaml.as_hash() {
            Some(hash) => {
                for (key, value) in hash {
                    match ProductOSUtilities::yaml_to_string_internal(key, depth) {
                        Ok(key) => {
                            yaml_string.push_str(format!("{}{}: ", ProductOSUtilities::text_indent(depth), key).as_str());
                        }
                        Err(e) => return Err(e)
                    };

                    depth = depth + 1;
                    match ProductOSUtilities::yaml_to_string_internal(value, depth) {
                        Ok(value) => {
                            yaml_string.push_str(format!("{}", value).as_str());
                        }
                        Err(e) => return Err(e)
                    };
                    depth = depth - 1;

                    yaml_string.push_str("\n");
                }

                Ok(yaml_string)
            }
            None => {
                match yaml.as_vec() {
                    Some(array) => {
                        for element in array {
                            match ProductOSUtilities::yaml_to_string_internal(element, depth) {
                                Ok(value) => {
                                    yaml_string.push_str(format!("{}- ", ProductOSUtilities::text_indent(depth)).as_str());

                                    depth = depth + 1;
                                    yaml_string.push_str(format!("{}", value).as_str());
                                    depth = depth - 1;
                                }
                                Err(e) => return Err(e)
                            };

                            yaml_string.push_str("\n");
                        }
                    }
                    None => {
                        match yaml.as_str() {
                            Some(s) => yaml_string.push_str(format!("{}", s).as_str()),
                            None => {
                                match yaml.as_bool() {
                                    Some(b) => yaml_string.push_str(format!("{}", b).as_str()),
                                    None => {
                                        match yaml.as_f64() {
                                            Some(f) => yaml_string.push_str(format!("{}", f).as_str()),
                                            None => {
                                                match yaml.as_i64() {
                                                    Some(i) => yaml_string.push_str(format!("{}", i).as_str()),
                                                    None => return Err(ProductOSError::GenericError(String::from("Could not convert YAML")))
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        yaml_string.push_str("\n");
                    }
                }

                Ok(yaml_string)
            }
        }
        */
    }


    #[cfg(all(feature = "json", feature = "yaml"))]
    pub fn yaml_to_json(yaml: &serde_yaml::Value) -> Result<serde_json::Value, ProductOSError> {
        ProductOSUtilities::yaml_value_to_json_value(yaml)
        /*
        match yaml.as_hash() {
            Some(hash) => {
                let mut map = serde_json::Map::new();

                for (key, value) in hash {
                    let key = match ProductOSUtilities::yaml_to_json(key) {
                        Ok(json_key) => {
                            match json_key {
                                serde_json::Value::String(s) => s,
                                _ => return Err(ProductOSError::GenericError(String::from("Invalid type for a JSON key converting from serde_yaml::Value to Json")))
                            }
                        }
                        Err(e) => return Err(e)
                    };

                    let value = match ProductOSUtilities::yaml_to_json(value) {
                        Ok(json_value) => json_value,
                        Err(e) => return Err(e)
                    };

                    map.insert(key, value);
                }

                Ok(serde_json::Value::Object(map))
            }
            None => {
                match yaml.as_vec() {
                    Some(array) => {
                        let mut vector = vec!();

                        for element in array {
                            match ProductOSUtilities::yaml_to_json(element) {
                                Ok(result) => vector.push(result),
                                Err(e) => return Err(e)
                            }
                        }

                        Ok(serde_json::Value::Array(vector))
                    }
                    None => {
                        match yaml.as_str() {
                            Some(s) => Ok(serde_json::Value::String(s.to_string())),
                            None => {
                                match yaml.as_bool() {
                                    Some(b) => Ok(serde_json::Value::Bool(b)),
                                    None => {
                                        match yaml.as_f64() {
                                            Some(f) => {
                                                match serde_json::Number::from_f64(f) {
                                                    Some(n) => Ok(serde_json::Value::Number(n)),
                                                    None => Err(ProductOSError::GenericError(String::from("Could not convert YAML")))
                                                }
                                            }
                                            None => {
                                                match yaml.as_i64() {
                                                    Some(i) => Ok(serde_json::Value::Number(serde_json::Number::from(i))),
                                                    None => Err(ProductOSError::GenericError(String::from("Could not convert YAML")))
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        */
    }

    #[cfg(all(feature = "json", feature = "yaml"))]
    pub fn json_to_yaml(value: &serde_json::Value, mut depth: usize) -> Result<serde_yaml::Value, ProductOSError> {
        let mut yaml_string = String::new();

        match value {
            serde_json::Value::Object(o) => {
                for (key, value) in o {
                    yaml_string.push_str(format!("{}{}: ", ProductOSUtilities::text_indent(depth), key).as_str());

                    match ProductOSUtilities::json_to_yaml(value, depth) {
                        Ok(yaml_value) => {
                            depth = depth + 1;
                            match ProductOSUtilities::yaml_to_string(&yaml_value, false) {
                                Ok(value_string) => yaml_string.push_str(format!("{}", value_string).as_str()),
                                Err(e) => return Err(e)
                            }
                            depth = depth - 1;
                        }
                        Err(e) => return Err(e)
                    };

                    yaml_string.push_str("\n");
                }
            }
            serde_json::Value::Array(array) => {
                for _ in array {
                    match ProductOSUtilities::json_to_yaml(value, depth) {
                        Ok(value) => {
                            yaml_string.push_str(format!("{}- ", ProductOSUtilities::text_indent(depth)).as_str());

                            depth = depth + 1;
                            match ProductOSUtilities::yaml_to_string(&value, false) {
                                Ok(value_string) => yaml_string.push_str(format!("{}", value_string).as_str()),
                                Err(e) => return Err(e)
                            }
                            depth = depth - 1;
                        }
                        Err(e) => return Err(e)
                    };

                    yaml_string.push_str("\n");
                }
            }
            serde_json::Value::String(s) => {
                yaml_string.push_str(format!("{}", s).as_str());
                yaml_string.push_str("\n");
            }
            serde_json::Value::Bool(b) => {
                yaml_string.push_str(format!("{}", b).as_str());
                yaml_string.push_str("\n");
            }
            serde_json::Value::Number(n) => {
                match n.as_f64() {
                    Some(f) => yaml_string.push_str(format!("{}", f).as_str()),
                    None => {
                        match n.as_i64() {
                            Some(i) => yaml_string.push_str(format!("{}", i).as_str()),
                            None => {
                                match n.as_u64() {
                                    Some(u) => yaml_string.push_str(format!("{}", u).as_str()),
                                    None => return Err(ProductOSError::GenericError(String::from("Could not convert number value")))
                                }
                            }
                        }
                    }
                }
                yaml_string.push_str("\n");
            }
            serde_json::Value::Null => {
                yaml_string.push_str("null");
                yaml_string.push_str("\n");
            }
        }

        ProductOSUtilities::string_to_yaml(yaml_string.as_str())
    }

    #[cfg(all(feature = "yaml", feature = "json"))]
    pub fn yaml_value_to_json_value(value: &serde_yaml::Value) -> Result<serde_json::Value, ProductOSError> {
        match value {
            serde_yaml::Value::Null => Ok(serde_json::Value::Null),
            serde_yaml::Value::Bool(b) => Ok(serde_json::Value::Bool(b.to_owned())),
            serde_yaml::Value::Number(n) => {
                match n.as_u64() {
                    None => match n.as_i64() {
                        None => match n.as_f64() {
                            None => return Err(ProductOSError::GenericError(String::from("Invalid value returned"))),
                            Some(f) => {
                                match serde_json::Number::from_f64(f.to_owned()) {
                                    None => return Err(ProductOSError::GenericError(String::from("Invalid float value returned"))),
                                    Some(f) => Ok(serde_json::Value::Number(f))
                                }
                            }
                        }
                        Some(i) => Ok(serde_json::Value::Number(serde_json::Number::from(i.to_owned())))
                    }
                    Some(u) => Ok(serde_json::Value::Number(serde_json::Number::from(u.to_owned())))
                }
            }
            serde_yaml::Value::String(s) => Ok(serde_json::Value::String(s.to_owned())),
            serde_yaml::Value::Sequence(a) => {
                let mut val_vec: Vec<serde_json::Value> = vec!();

                for e in a.as_slice() {
                    match ProductOSUtilities::yaml_value_to_json_value(e) {
                        Ok(v) => val_vec.push(v),
                        Err(e) => return Err(e)
                    }
                }

                Ok(serde_json::Value::Array(val_vec))
            }
            serde_yaml::Value::Mapping(m) => {
                let mut map = serde_json::Map::new();

                for (k, v) in m.iter() {
                    let key = match ProductOSUtilities::yaml_value_to_json_value(k) {
                        Ok(v) => match v {
                            serde_json::Value::String(k) => k,
                            _ => return Err(ProductOSError::GenericError(String::from("Invalid value returned")))
                        },
                        Err(e) => return Err(e)
                    };

                    let value = match ProductOSUtilities::yaml_value_to_json_value(v) {
                        Ok(v) => v,
                        Err(e) => return Err(e)
                    };

                    map.insert(key, value);
                }

                Ok(serde_json::Value::Object(map))
            }
            serde_yaml::Value::Tagged(t) => {
                let tag = t.tag.to_string();
                let value = match ProductOSUtilities::yaml_value_to_json_value(&t.value) {
                    Ok(v) => v,
                    Err(e) => return Err(e)
                };

                let mut map = serde_json::Map::new();
                map.insert(tag, value);

                Ok(serde_json::Value::Object(map))
            }
        }
    }

    #[cfg(all(feature = "yaml", feature = "json"))]
    pub fn json_value_to_yaml_value(value: &serde_json::Value) -> Result<serde_yaml::Value, ProductOSError> {
        match value {
            serde_json::Value::Null => Ok(serde_yaml::Value::Null),
            serde_json::Value::Bool(b) => Ok(serde_yaml::Value::Bool(b.to_owned())),
            serde_json::Value::Number(n) => {
                match n.as_u64() {
                    None => match n.as_i64() {
                        None => match n.as_f64() {
                            None => return Err(ProductOSError::GenericError(String::from("Invalid value returned"))),
                            Some(f) => Ok(serde_yaml::Value::Number(serde_yaml::Number::from(f.to_owned())))
                        }
                        Some(i) => Ok(serde_yaml::Value::Number(serde_yaml::Number::from(i.to_owned())))
                    }
                    Some(u) => Ok(serde_yaml::Value::Number(serde_yaml::Number::from(u.to_owned())))
                }
            }
            serde_json::Value::String(s) => Ok(serde_yaml::Value::String(s.to_owned())),
            serde_json::Value::Array(a) => {
                let mut val_vec: Vec<serde_yaml::Value> = vec!();

                for e in a.as_slice() {
                    match ProductOSUtilities::json_value_to_yaml_value(e) {
                        Ok(v) => val_vec.push(v),
                        Err(e) => return Err(e)
                    }
                }

                Ok(serde_yaml::Value::Sequence(val_vec))
            }
            serde_json::Value::Object(o) => {
                let mut map = serde_yaml::Mapping::new();

                for (k, v) in o.iter() {
                    let key = serde_yaml::Value::String(k.to_owned());

                    let value = match ProductOSUtilities::json_value_to_yaml_value(v) {
                        Ok(v) => v,
                        Err(e) => return Err(e)
                    };

                    map.insert(key, value);
                }

                Ok(serde_yaml::Value::Mapping(map))
            }
        }
    }

    #[cfg(feature = "yaml")]
    pub fn find_yaml_property(yaml: &serde_yaml::Value, property: &str, default_value: &serde_yaml::Value) -> serde_yaml::Value {
        let property_parts = property.split(".").collect::<Vec<&str>>();
        let property_parts_length = property_parts.len();

        ProductOSUtilities::find_yaml_property_internal(yaml, property_parts, default_value, 0, property_parts_length)
    }

    #[cfg(feature = "yaml")]
    fn find_yaml_property_internal(yaml: &serde_yaml::Value, property_parts: Vec<&str>, default_value: &serde_yaml::Value, depth: usize, property_parts_length: usize) -> serde_yaml::Value {
        match yaml {
            serde_yaml::Value::Sequence(array) => {
                match usize::from_str(property_parts.get(depth).unwrap()) {
                    Ok(prop) => {
                        match array.get(prop) {
                            None => default_value.to_owned(),
                            Some(value) => {
                                if depth == property_parts_length - 1 {
                                    value.to_owned()
                                }
                                else {
                                    ProductOSUtilities::find_yaml_property_internal(value, property_parts.to_owned(), default_value, depth + 1, property_parts_length)
                                }
                            }
                        }
                    }
                    Err(_) => default_value.to_owned()
                }
            }
            serde_yaml::Value::Mapping(map) => {
                match map.get(&serde_yaml::Value::String(property_parts.get(depth).unwrap().to_string())) {
                    None => default_value.to_owned(),
                    Some(value) => {
                        if depth == property_parts_length - 1 {
                            value.to_owned()
                        }
                        else {
                            ProductOSUtilities::find_yaml_property_internal(value, property_parts.to_owned(), default_value, depth + 1, property_parts_length)
                        }
                    }
                }
            }
            _ => default_value.to_owned()
        }

        /*
        match yaml.as_hash() {
            Some(hash) => {
                match hash.get(&serde_yaml::Value::String(property_parts.get(depth).unwrap().to_string())) {
                    None => default_value,
                    Some(value) => {
                        if depth == property_parts_length - 1 {
                            value.to_owned()
                        }
                        else {
                            ProductOSUtilities::find_yaml_property_internal(value, property_parts.to_owned(), default_value.to_owned(), depth + 1, property_parts_length)
                        }
                    }
                }
            }
            None => {
                match yaml.as_vec() {
                    Some(array) => {
                        match usize::from_str(property_parts.get(depth).unwrap()) {
                            Ok(prop) => {
                                match array.get(prop) {
                                    None => default_value,
                                    Some(value) => {
                                        if depth == property_parts_length - 1 {
                                            value.to_owned()
                                        }
                                        else {
                                            ProductOSUtilities::find_yaml_property_internal(value, property_parts.to_owned(), default_value.to_owned(), depth + 1, property_parts_length)
                                        }
                                    }
                                }
                            }
                            Err(_) => default_value
                        }
                    }
                    None => default_value
                }
            }
        }
        */
    }
}


/*
fn is_directory(entry: &walkdir::DirEntry) -> bool {
    entry
        .metadata()
        .unwrap()
        .is_dir()
}

fn is_file(entry: &walkdir::DirEntry) -> bool {
    entry
        .metadata()
        .unwrap()
        .is_file()
}
*/