Zig

Isabel Connect Create Access Token given Valid Refresh Token

See more Ibanity Examples

Create (refresh) an access token given a valid refresh token. Zig

const std = @import("std");
const chilkat = @import("chilkat");

pub fn main(init: std.process.Init) !void {
    const alloc = init.arena.allocator();

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

    const http = try chilkat.Http.init();
    defer http.deinit();

    // Implements the following CURL command:

    // curl -X POST https://api.ibanity.com/isabel-connect/oauth2/token \
    // --cert certificate.pem:qwertyuiop1 \
    // --key private_key.pem  \
    // -H "Content-Type: application/x-www-form-urlencoded" \
    // -H "Accept: application/vnd.api+json" \
    // -H "Ibanity-Idempotency-Key: 94c5586e-e15e-4bae-a1fe-fdbefe1f11d3"  \
    // -d grant_type=refresh_token \
    // -d refresh_token=valid_refresh_token \
    // -d client_id=valid_client_id \
    // -d client_secret=valid_client_secret

    // Ibanity provides the certificate + private key in PFX format.  This example will use the .pfx instead of the pair of PEM files.
    // (It is also possible to implement using Chilkat with the PEM files, but PFX is easier.)
    const cert = try chilkat.Cert.init();
    defer cert.deinit();
    cert.loadPfxFile("qa_data/pfx/my_ibanity_certificate.pfx", "my_pfx_password") catch {
        std.debug.print("{s}\n", .{try cert.getLastErrorText(alloc)});
        return;
    };

    http.setSslClientCert(cert) catch {
        std.debug.print("{s}\n", .{try http.getLastErrorText(alloc)});
        return;
    };

    const req = try chilkat.HttpRequest.init();
    defer req.deinit();
    req.setHttpVerb("POST");
    req.setPath("/isabel-connect/oauth2/token");
    req.setContentType("application/x-www-form-urlencoded");
    req.addParam("grant_type", "refresh_token");

    // Load the previously obtained refresh token.
    const json_token = try chilkat.JsonObject.init();
    defer json_token.deinit();
    json_token.loadFile("qa_data/tokens/isabel_refresh_token.json") catch {
        std.debug.print("No existing access token.\n", .{});
        return;
    };

    req.addParam("refresh_token", try json_token.stringOf(alloc, "refresh_token"));

    // Note: For sandbox testing, we literally want to use the strings
    // "valid_client_id", and "valid_client_secret".
    // For the live app, you would replace these with actual values.
    req.addParam("client_id", "valid_client_id");
    req.addParam("client_secret", "valid_client_secret");

    req.addHeader("Accept", "application/vnd.api+json");

    const crypt = try chilkat.Crypt2.init();
    defer crypt.deinit();
    const idempotency_key = try crypt.generateUuid(alloc);
    std.debug.print("Ibanity-Idempotency-Key: {s}\n", .{idempotency_key});
    req.addHeader("Ibanity-Idempotency-Key", idempotency_key);

    const resp = try chilkat.HttpResponse.init();
    defer resp.deinit();
    http.httpReq("https://api.ibanity.com/isabel-connect/oauth2/token", req, resp) catch {
        std.debug.print("{s}\n", .{try http.getLastErrorText(alloc)});
        return;
    };

    const sb_response_body = try chilkat.StringBuilder.init();
    defer sb_response_body.deinit();
    resp.getBodySb(sb_response_body) catch {};
    const j_resp = try chilkat.JsonObject.init();
    defer j_resp.deinit();
    j_resp.loadSb(sb_response_body) catch {};
    j_resp.setEmitCompact(false);

    std.debug.print("Response Body:\n", .{});
    std.debug.print("{s}\n", .{try j_resp.emit(alloc)});

    const resp_status_code = resp.getStatusCode();
    std.debug.print("Response Status Code = {d}\n", .{resp_status_code});
    if (resp_status_code >= 400) {
        std.debug.print("Response Header:\n", .{});
        std.debug.print("{s}\n", .{try resp.getHeader(alloc)});
        std.debug.print("Failed.\n", .{});
        return;
    }

    // Sample JSON response:
    // (Sample code for parsing the JSON response is shown below)

    // Notice that we don't get a new refresh token.  The original refresh token is used each time we
    // want to refresh.  However, we get a new access token.  This access token is to be used in Isabel API calls
    // until we need to refresh again.
    // {
    //   "token_type": "Bearer",
    //   "scope": "cloudconnect",
    //   "expires_in": 1799,
    //   "access_token": "access_token_1603365408"
    // }

    // Sample code for parsing the JSON response...
    // Use the following online tool to generate parsing code from sample JSON:
    // Generate Parsing Code from JSON

    _ = try j_resp.stringOf(alloc, "token_type");
    _ = try j_resp.stringOf(alloc, "scope");
    _ = j_resp.intOf("expires_in");
    _ = try j_resp.stringOf(alloc, "access_token");

    // Save this to a file so we can load in other examples to include the access token in the HTTP request.
    try j_resp.writeFile("qa_data/tokens/isabel_access_token.json");
}