Struct KsefClient 

pub struct KsefClient { /* private fields */ }

Implementations

impl KsefClient

pub fn new(base_url: String, sleep_time: u64) -> Result<Self, ParseError>

Examples found in repository

examples/get_access_token.rs (line 4)

async fn main() {
    
    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();

    let company_info = ksef_client::CompanyInfo {
        ksef_token: "<ksef_token>".to_string(),
        nip: "<nip>".to_string(),
    };

    let access_tokens = match client.get_access_tokens(&company_info).await {
        Ok(access_tokens) => access_tokens,
        Err(e) => {
            eprintln!("Error getting access_tokens: {}", e);
            return;
        }
    };
    
    let access_token = access_tokens.access_token.token;

    println!("access_token {}", access_token);
}

examples/invoice_export.rs (line 6)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();
    let access_token = "<access_token>".to_string();

    let invoice_query_filters = ksef_client::invoice::InvoiceQueryFilters {
        subject_type: ksef_client::invoice::InvoiceSubjectType::Subject1,
        date_range: ksef_client::invoice::DateRange {
            from: Utc::now() - chrono::Duration::days(90),
            to: Some(Utc::now()),
            date_type: ksef_client::invoice::DateType::PermanentStorage,
            restrict_to_permanent_storage_hwm_date: Some(true),
        },
    };

    let get_invoice_export_result = match client.get_invoice_export(&invoice_query_filters, &access_token).await {
        Ok(get_invoice_export_result) => get_invoice_export_result,
        Err(e) => {
            eprintln!("Error: {}; {}", e.code, e.message);
            return;
        }
    };

    println!("{:#?}", get_invoice_export_result);
}

examples/query_invoice_metadata.rs (line 6)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();
    let access_token = "<access_token>".to_string();

    let invoice_query_filters = ksef_client::invoice::InvoiceQueryFilters {
        subject_type: ksef_client::invoice::InvoiceSubjectType::Subject1,
        date_range: ksef_client::invoice::DateRange {
            from: Utc::now() - chrono::Duration::days(90),
            to: Some(Utc::now()),
            date_type: ksef_client::invoice::DateType::Issue,
            restrict_to_permanent_storage_hwm_date: None,
        },
    };

    let query_invoice_metadata_result = match client.query_invoice_metadata(&invoice_query_filters, &access_token, 0, 10, ksef_client::invoice::SortOrder::Asc).await {
            Ok(query_invoice_metadata_result) => query_invoice_metadata_result,
            Err(e) => {
                eprintln!("Error: {}; {}", e.code, e.message);
                return;
            }
        };
        
    println!("{:#?}", query_invoice_metadata_result);    
}

examples/refresh_token.rs (line 6)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();

    let company_info = ksef_client::CompanyInfo {
        ksef_token: "<ksef_token>".to_string(),
        nip: "<nip>".to_string(),
    };

    let access_tokens = match client.get_access_tokens(&company_info).await {
        Ok(access_tokens) => access_tokens,
        Err(e) => {
            eprintln!("Error getting access_tokens: {}", e);
            return;
        }
    };

    // if access token has expired
    if access_tokens.access_token.valid_until < Utc::now() {
        // refresh token ->
        let access_token_info = match client
            .refresh_access_token(&access_tokens.refresh_token.token)
            .await
        {
            Ok(access_token_info) => access_token_info,
            Err(e) => {
                eprintln!("Error getting refresh token: {}", e);
                return;
            }
        };

        let access_token = access_token_info.token;

        println!("access_token {}", access_token);
    }
}

pub async fn get_access_tokens( &self, company_info: &CompanyInfo, ) -> Result<TokenPair, &str>

Examples found in repository

examples/get_access_token.rs (line 11)

async fn main() {
    
    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();

    let company_info = ksef_client::CompanyInfo {
        ksef_token: "<ksef_token>".to_string(),
        nip: "<nip>".to_string(),
    };

    let access_tokens = match client.get_access_tokens(&company_info).await {
        Ok(access_tokens) => access_tokens,
        Err(e) => {
            eprintln!("Error getting access_tokens: {}", e);
            return;
        }
    };
    
    let access_token = access_tokens.access_token.token;

    println!("access_token {}", access_token);
}

examples/refresh_token.rs (line 13)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();

    let company_info = ksef_client::CompanyInfo {
        ksef_token: "<ksef_token>".to_string(),
        nip: "<nip>".to_string(),
    };

    let access_tokens = match client.get_access_tokens(&company_info).await {
        Ok(access_tokens) => access_tokens,
        Err(e) => {
            eprintln!("Error getting access_tokens: {}", e);
            return;
        }
    };

    // if access token has expired
    if access_tokens.access_token.valid_until < Utc::now() {
        // refresh token ->
        let access_token_info = match client
            .refresh_access_token(&access_tokens.refresh_token.token)
            .await
        {
            Ok(access_token_info) => access_token_info,
            Err(e) => {
                eprintln!("Error getting refresh token: {}", e);
                return;
            }
        };

        let access_token = access_token_info.token;

        println!("access_token {}", access_token);
    }
}

pub async fn refresh_access_token( &self, refresh_token: &String, ) -> Result<TokenInfo, &str>

Examples found in repository

examples/refresh_token.rs (line 25)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();

    let company_info = ksef_client::CompanyInfo {
        ksef_token: "<ksef_token>".to_string(),
        nip: "<nip>".to_string(),
    };

    let access_tokens = match client.get_access_tokens(&company_info).await {
        Ok(access_tokens) => access_tokens,
        Err(e) => {
            eprintln!("Error getting access_tokens: {}", e);
            return;
        }
    };

    // if access token has expired
    if access_tokens.access_token.valid_until < Utc::now() {
        // refresh token ->
        let access_token_info = match client
            .refresh_access_token(&access_tokens.refresh_token.token)
            .await
        {
            Ok(access_token_info) => access_token_info,
            Err(e) => {
                eprintln!("Error getting refresh token: {}", e);
                return;
            }
        };

        let access_token = access_token_info.token;

        println!("access_token {}", access_token);
    }
}

pub async fn query_invoice_metadata( &self, request: &InvoiceQueryFilters, access_token: &String, page_offset: i32, page_size: i32, sort_order: SortOrder, ) -> Result<PagedInvoiceResponse, ErrorResponse>

Examples found in repository

examples/query_invoice_metadata.rs (line 19)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();
    let access_token = "<access_token>".to_string();

    let invoice_query_filters = ksef_client::invoice::InvoiceQueryFilters {
        subject_type: ksef_client::invoice::InvoiceSubjectType::Subject1,
        date_range: ksef_client::invoice::DateRange {
            from: Utc::now() - chrono::Duration::days(90),
            to: Some(Utc::now()),
            date_type: ksef_client::invoice::DateType::Issue,
            restrict_to_permanent_storage_hwm_date: None,
        },
    };

    let query_invoice_metadata_result = match client.query_invoice_metadata(&invoice_query_filters, &access_token, 0, 10, ksef_client::invoice::SortOrder::Asc).await {
            Ok(query_invoice_metadata_result) => query_invoice_metadata_result,
            Err(e) => {
                eprintln!("Error: {}; {}", e.code, e.message);
                return;
            }
        };
        
    println!("{:#?}", query_invoice_metadata_result);    
}

pub async fn get_invoice_export( &self, filters: &InvoiceQueryFilters, access_token: &String, ) -> Result<InvoiceExportResult, ErrorResponse>

Examples found in repository

examples/invoice_export.rs (line 19)

async fn main() {

    let client = ksef_client::KsefClient::new("https://api.ksef.mf.gov.pl".to_string(), 2000).unwrap();
    let access_token = "<access_token>".to_string();

    let invoice_query_filters = ksef_client::invoice::InvoiceQueryFilters {
        subject_type: ksef_client::invoice::InvoiceSubjectType::Subject1,
        date_range: ksef_client::invoice::DateRange {
            from: Utc::now() - chrono::Duration::days(90),
            to: Some(Utc::now()),
            date_type: ksef_client::invoice::DateType::PermanentStorage,
            restrict_to_permanent_storage_hwm_date: Some(true),
        },
    };

    let get_invoice_export_result = match client.get_invoice_export(&invoice_query_filters, &access_token).await {
        Ok(get_invoice_export_result) => get_invoice_export_result,
        Err(e) => {
            eprintln!("Error: {}; {}", e.code, e.message);
            return;
        }
    };

    println!("{:#?}", get_invoice_export_result);
}