cw-cyber/packages/hub-base/src/validating.rs

use cid::{Cid, Version};
use cosmwasm_std::Response;
use std::str::FromStr;

use crate::error::ContractError;

/// Basic rule /[a-z0-9-]/
pub fn validate_by_basic_rule(val: String, field_name: String) -> Result<Response, ContractError> {
    for byte in val.as_bytes().iter() {
        // - && 0-9 && a-z
        if (*byte != 45) && (*byte < 48 || *byte > 57) && (*byte < 97 || *byte > 122) {
            return Err(ContractError::IncorrectInputData {
                val: format!(
                    "Incorrect value for field field {}. Allowed expression /[a-z0-9-]/",
                    field_name
                ),
            });
        }
    }
    Ok(Response::default())
}

/// Basic rule /[A-Z0-9]/
pub fn validate_by_basic_uppercase_rule(
    val: String,
    field_name: String,
) -> Result<Response, ContractError> {
    for byte in val.as_bytes().iter() {
        // 0-9 && A-Z
        if (*byte < 48 || *byte > 57) && (*byte < 65 || *byte > 90) {
            return Err(ContractError::IncorrectInputData {
                val: format!(
                    "Incorrect value for field {}. Allowed expression /[A-Z0-9]/",
                    field_name
                ),
            });
        }
    }
    Ok(Response::default())
}

/// Basic rule /[a-z0-9-_]/
pub fn validate_chain_id(val: String, field_name: String) -> Result<Response, ContractError> {
    for byte in val.as_bytes().iter() {
        // - && _ && 0-9 && a-z
        if (*byte != 45)
            && (*byte != 95)
            && (*byte < 48 || *byte > 57)
            && (*byte < 97 || *byte > 122)
        {
            return Err(ContractError::IncorrectInputData {
                val: format!(
                    "Incorrect value for field field {}. Allowed expression /[a-z0-9-]/",
                    field_name
                ),
            });
        }
    }
    Ok(Response::default())
}

/// URL rule: allows = & {} : / . - _ 0-9 a-z A-Z
pub fn validate_url(val: String, field_name: String) -> Result<Response, ContractError> {
    for byte in val.as_bytes().iter() {
        // = & } { : / . - _ 0-9 a-z A-Z
        if (*byte != 61)
            && (*byte != 38)
            && (*byte != 125)
            && (*byte != 123)
            && (*byte != 58)
            && (*byte != 95)
            && (*byte != 45)
            && (*byte != 47)
            && (*byte != 46)
            && (*byte < 48 || *byte > 57)
            && (*byte < 97 || *byte > 122)
            && (*byte < 65 || *byte > 90)
        {
            return Err(ContractError::IncorrectInputData {
                val: format!("Incorrect value for field {}. Allowed only url", field_name),
            });
        }
    }
    Ok(Response::default())
}

/// Period rule /[0-9]/
pub fn validate_period(val: String, field_name: String) -> Result<Response, ContractError> {
    for byte in val.as_bytes().iter() {
        // 0-9
        if *byte < 48 || *byte > 57 {
            return Err(ContractError::IncorrectInputData {
                val: format!(
                    "Incorrect value for field field {}. Allowed expression /[0-9]/",
                    field_name
                ),
            });
        }
    }
    Ok(Response::default())
}

/// Datatype rule /[a-z0-9-]/ (same as basic but different error message)
pub fn validate_datatype(val: String) -> Result<Response, ContractError> {
    for byte in val.as_bytes().iter() {
        // - && 0-9 && a-z
        if (*byte != 45) && (*byte < 48 || *byte > 57) && (*byte < 97 || *byte > 122) {
            return Err(ContractError::IncorrectInputData {
                val: "Incorrect data-type. a-z0-9- allowed".to_string(),
            });
        }
    }
    Ok(Response::default())
}

/// Validate an IPFS CID (must be v0) with field name in error.
pub fn validate_ipfs_cid(particle: String, field_name: String) -> Result<Response, ContractError> {
    let try_particle = Cid::from_str(&particle);
    if let Ok(particle_value) = try_particle {
        if particle_value.version() != Version::V0 {
            return Err(ContractError::IncorrectInputData {
                val: format!(
                    "Incorrect value for field {}. Allowed only Ipfs hash",
                    field_name
                ),
            });
        }
    } else {
        return Err(ContractError::IncorrectInputData {
            val: format!(
                "Incorrect value for field {}. Allowed only Ipfs hash",
                field_name
            ),
        });
    }
    Ok(Response::default())
}

/// Validate an optional particle (IPFS CID v0). Returns Ok if None.
pub fn validate_particle(particle: &Option<String>) -> Result<Response, ContractError> {
    if let Some(ref p) = particle {
        validate_ipfs_cid(p.clone(), "particle".to_string())
    } else {
        Ok(Response::default())
    }
}