Struct SignatureNotificationRequest 

pub struct SignatureNotificationRequest {
    pub relying_party_uuid: String,
    pub relying_party_name: String,
    pub certificate_level: CertificateLevel,
    pub signature_protocol: SignatureProtocol,
    pub signature_protocol_parameters: SignatureProtocolParameters,
    pub nonce: Option<String>,
    pub interactions: String,
    pub request_properties: Option<RequestProperties>,
    pub capabilities: Option<Vec<String>>,
}

Signature Request

This struct represents a request for a signature session with the Smart ID service. It includes various parameters required for the signature process.

Properties

• relying_party_uuid - The UUID of the relying party, provided by Smart ID.
• relying_party_name - The name of the relying party, provided by Smart ID.
• certificate_level - The level of the certificate required for the signature.
• signature_protocol - The protocol used for the signature.
• signature_protocol_parameters - The parameters for the signature protocol.
• interactions - A base64 encoded JSON string of interactions allowed during the signature session. At least one interaction is required. Interactions are limited based on the flow type, look at the Interaction documentation for more information.
• nonce - An optional nonce for the request.
• request_properties - Optional properties for the request.
• capabilities - Used only when agreed with Smart-ID provider. When omitted, request capabilities are derived from the certificate_level parameter.

Example

use smart_id_rust_client::config::SmartIDConfig;
use smart_id_rust_client::models::api::signature_session::SignatureNotificationRequest;
use smart_id_rust_client::models::interaction::Interaction;
use smart_id_rust_client::models::signature::{HashingAlgorithm, SignatureAlgorithm};
use smart_id_rust_client::error::Result;///

use smart_id_rust_client::models::common::SessionConfig::SignatureNotification;

fn create_signature_request(cfg: &SmartIDConfig) -> Result<SignatureNotificationRequest> {
    let interactions = vec![Interaction::DisplayTextAndPIN {
        display_text_60: "Sign document".to_string(),
    }];
    SignatureNotificationRequest::new(
        cfg,
        interactions,
        "base64-encoded-digest".to_string(),
        SignatureAlgorithm::RsassaPss,
        HashingAlgorithm::sha_256,
    )
}

Fields

relying_party_uuid: String

relying_party_name: String

certificate_level: CertificateLevel

signature_protocol: SignatureProtocol

signature_protocol_parameters: SignatureProtocolParameters

nonce: Option<String>

interactions: String

request_properties: Option<RequestProperties>

capabilities: Option<Vec<String>>

Used only when agreed with Smart-ID provider. When omitted request capabilities are derived from certificateLevel parameter.

Implementations

impl SignatureNotificationRequest

pub fn new( cfg: &SmartIDConfig, interactions: Vec<Interaction>, digest: String, signature_algorithm: SignatureAlgorithm, hash_algorithm: HashingAlgorithm, ) -> Result<Self>

Creates a new SignatureRequest.

Arguments

• cfg - The configuration for the Smart-ID service.
• interactions - A vector of interactions allowed during the signature session. At least one interaction is required. Interactions are limited based on the flow type, look at the Interaction documentation for more information.
• digest - The digest to be signed. Base64 encoded.
• signature_algorithm - The algorithm used for the signature.

Errors

Returns an error if no interactions are defined or if any interaction has invalid text length.

Trait Implementations

impl Clone for SignatureNotificationRequest

fn clone(&self) -> SignatureNotificationRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SignatureNotificationRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SignatureNotificationRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SignatureNotificationRequest

fn eq(&self, other: &SignatureNotificationRequest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SignatureNotificationRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SignatureNotificationRequest