Rust

Firebase GET - Reading Data

See more Firebase Examples

Demonstrates how to read parts of a Firebase JSON database. The data used in this example is at Chilkat Firebase Pigs Database, and is shown here:

Rust

// Demonstrates how to read parts of a Firebase JSON database.

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

// This example assumes a JWT authentication token, if required, has been previously obtained.
// See Get Firebase Access Token from JSON Service Account Private Key for sample code.

// Load the previously obtained Firebase access token into a string.
let fac = chilkat::FileAccess::new();
let Ok(access_token) = fac.read_entire_text_file("qa_data/tokens/firebaseToken.txt", "utf-8") else {
    println!("{}", fac.last_error_text());
    return;
};

let rest = chilkat::Rest::new();

// Make the initial connection (without sending a request yet).
// Once connected, any number of requests may be sent.  It is not necessary to explicitly
// call Connect before each request.  
if rest.connect("chilkat.firebaseio.com", 443, true, true).is_err() {
    println!("{}", rest.last_error_text());
    return;
}

// If authentication is required...
let auth_google = chilkat::AuthGoogle::new();
auth_google.set_access_token(&access_token);
let _ = rest.set_auth_google(&auth_google);

// Chilkat's sample data (pig-rescue data) is publicly readable at: https://chilkat.firebaseio.com/.json

// Let's get the animals with the shallow parameter so we can see how many pigs exist.
let Ok(json_response) = rest.full_request_no_body("GET", "/pig-rescue/animal.json?shallow=true") else {
    println!("{}", rest.last_error_text());
    return;
};

// The JSON returned should look like this:  
// {"-KI3bD-FU_Dake7sYOiP":true,"-KI3bD-FU_Dake7sYOiT":true,"-KI3bD-FU_Dake7sYOiS":true,"-KI3bD-FU_Dake7sYOiU":true,"-KI3bD-FU_Dake7sYOiV":true,"-KI3bD-FU_Dake7sYOiR":true,"-KI3bD-FU_Dake7sYOiQ":true}
println!("{}", json_response);

// Parse the response so we can iterate over each pig in the database..
let piggy_path = chilkat::StringBuilder::new();
let shallow = chilkat::JsonObject::new();
let piggy_data = chilkat::JsonObject::new();
let _ = shallow.load(&json_response);
let count = shallow.size();
let mut i = 0;
while i < count {

    // Get each individual pig's data.
    piggy_path.clear();
    let _ = piggy_path.append("/pig-rescue/animal/");
    let _ = piggy_path.append(&shallow.name_at(i).unwrap_or_default());
    let _ = piggy_path.append("/.json");

    let Ok(piggy_json) = rest.full_request_no_body("GET", &piggy_path.get_as_string().unwrap_or_default()) else {
        println!("{}", rest.last_error_text());
        return;
    };

    // Show this piggy's data...
    // An example of one pig's data is shown here:
    // {"birth":"February, 1998","from":"Middle Ave.","gender":"F","in-date":"January, 2000",
    //   "name":"Molly II","picture":{"caption":"Molly in the Pasture","description":"Black pig","file":"molly_th.jpg"},
    //   "species":"pot belly pig","type":"Cathy's Herd"}
    println!("---- {} ----", i);
    println!("{}", piggy_json);

    // Let's get the pig's name, and the caption of the picture.
    let _ = piggy_data.load(&piggy_json);
    println!("name: {}", piggy_data.string_of("name").unwrap_or_default());
    println!("caption: {}", piggy_data.string_of("picture.caption").unwrap_or_default());

    i = i + 1;
}

// Note: In many of the Chilkat examples, you may notice strange ways
// of doing something that should be simpler and shorter.  For example,
// building the piggyPath (above) could've been written differently,
// with some simple string concatenation.
// 
// The reason is that the Chilkat examples are written in a 
// proprietary "example code" scripting language,
// and then automatically generated to each of the different programming
// languages you see on example-code.com.  The code generation is
// limited in what it can do.  For example, string concatentation
// is not yet a feature of the "example code" scripting language (as of May 2016), 
// and therefore you won't see the use of a programming language's string
// concatentation operators in any example.  
//