rust-wechat-core 0.1.3

use md5::Digest;
use std::fs;
use base64ct::Encoding;
use hmac::{Hmac, Mac};
use md5::Md5;
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Unexpected;
use sha2::Sha256;
use crate::WechatError::CommonError;

pub type HmacSha256 = Hmac<Sha256>;

pub fn hmac_sha256(key: &[u8], data: &str) -> crate::Result<Vec<u8>> {
    let mut mac = HmacSha256::new_from_slice(key)
        .map_err(|err| CommonError(format!("{}", err)))?;
    mac.update(data.as_bytes());

    Ok(mac.finalize().into_bytes().to_vec())
}

pub fn base64(path: &str) -> crate::Result<String> {
    let bytes = fs::read(path)?;
    let data = base64ct::Base64::encode_string(&bytes);
    Ok(data)
}

pub fn md5(data: &str) -> crate::Result<String> {
    let mut hasher = Md5::new();
    hasher.update(data.as_bytes());
    let result = hasher.finalize();
    Ok(String::from_utf8_lossy(&result).into_owned())
}

pub fn bool_from_u8<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match u8::deserialize(deserializer)? {
        0 => Ok(false),
        _ => Ok(true),
    }
}

pub fn option_bool_from_u8<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
where
    D: Deserializer<'de>,
{
    match u8::deserialize(deserializer)? {
        0 => Ok(Some(false)),
        1 => Ok(Some(true)),
        _ => Ok(None),
    }
}
pub fn bool_from_str<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "0" => Ok(false),
        "1" => Ok(true),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"0 or 1",
        )),
    }
}
pub fn bool_to_u8<S>(value: &bool, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, {
    serializer.serialize_u8(if *value { 1u8 } else { 0u8 })
}
pub fn option_bool_to_u8<S>(value: &Option<bool>, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, {
    serializer.serialize_u8(
        if let Some(v) = value.as_ref() {
            if *v { 1u8 } else { 0u8 }
        } else {
            0u8
        }
    )
}
pub fn bool_to_str<S>(value: &bool, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, {
    serializer.serialize_str(if *value { "1" } else { "0" })
}