Struct LicenseKey 

pub struct LicenseKey {

    pub ProductId: u64,
    pub Id: Option<u64>,
    pub Key: Option<String>,
    pub Created: u64,
    pub Expires: u64,
    pub Period: u64,
    pub F1: bool,
    pub F2: bool,
    pub F3: bool,
    pub F4: bool,
    pub F5: bool,
    pub F6: bool,
    pub F7: bool,
    pub F8: bool,
    pub Notes: Option<String>,
    pub Block: bool,
    pub GlobalId: Option<u64>,
    pub Customer: Option<Customer>,
    pub ActivatedMachines: Vec<ActivationData>,
    pub TrialActivation: bool,
    pub MaxNoOfMachines: Option<u64>,
    pub AllowedMachines: Vec<String>,
    pub DataObjects: Vec<DataObject>,
    pub SignDate: u64,
    /* private fields */
}

Represents a license key in cryptolens format.

Fields

ProductId: u64

Id: Option<u64>

Key: Option<String>

Created: u64

Expires: u64

Period: u64

F1: bool

F2: bool

F3: bool

F4: bool

F5: bool

F6: bool

F7: bool

F8: bool

Notes: Option<String>

Block: bool

GlobalId: Option<u64>

Customer: Option<Customer>

ActivatedMachines: Vec<ActivationData>

TrialActivation: bool

MaxNoOfMachines: Option<u64>

AllowedMachines: Vec<String>

DataObjects: Vec<DataObject>

SignDate: u64

Implementations

impl LicenseKey

pub fn from_response_str(s: &str) -> Result<LicenseKey>

Constructs a LicenseKey from a JSON string containing activation response data.

Arguments

• s - A string slice that holds the JSON data to parse.

Errors

Returns an error if parsing fails or if base64 decoding is unsuccessful.

pub fn has_valid_signature(&self, public_key: &str) -> Result<bool>

Verifies the validity of the digital signature associated with this license key.

Arguments

• public_key - A string slice containing the public key in XML format used to verify the signature.

Returns

Returns true if the signature is valid, otherwise returns false.

Errors

Returns an error if any cryptographic operations fail during verification.

Trait Implementations

impl Debug for LicenseKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LicenseKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LicenseKey

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.