(Perl) Quickbooks OAuth1 Authorization (3-legged)

Demonstrates 3-legged OAuth1 authorization for Quickbooks.

Chilkat Perl Downloads Perl Module for Windows, MacOS, Linux, Alpine Linux, Solaris

use chilkat();

$consumerKey = "QUICKBOOKS_CONSUMER_KEY";
$consumerSecret = "QUICKBOOKS_CONSUMER_SECRET";

$requestTokenUrl = "https://oauth.intuit.com/oauth/v1/get_request_token";
$authorizeUrl = "https://appcenter.intuit.com/Connect/Begin";
$accessTokenUrl = "https://oauth.intuit.com/oauth/v1/get_access_token";

# The port number is picked at random. It's some unused port that won't likely conflict with anything else..
$callbackUrl = "http://localhost:3017/";
$callbackLocalPort = 3017;

# The 1st step in 3-legged OAuth1.0a is to send a POST to the request token URL to obtain an OAuth Request Token
$http = chilkat::CkHttp->new();

$http->put_OAuth1(1);
$http->put_OAuthConsumerKey($consumerKey);
$http->put_OAuthConsumerSecret($consumerSecret);
$http->put_OAuthCallback($callbackUrl);

$req = chilkat::CkHttpRequest->new();
# resp is a HttpResponse
$resp = $http->PostUrlEncoded($requestTokenUrl,$req);
if ($http->get_LastMethodSuccess() != 1) {
    print $http->lastErrorText() . "\r\n";
    exit;
}

if ($resp->get_StatusCode() >= 400) {
    print "Error response status code = " . $resp->get_StatusCode() . "\r\n";
    print $resp->bodyStr() . "\r\n";
    exit;
}

# If successful, the resp.BodyStr contains this:  
# oauth_token=-Wa_KwAAAAAAxfEPAAABV8Qar4Q&oauth_token_secret=OfHY4tZBX2HK4f7yIw76WYdvnl99MVGB&oauth_callback_confirmed=true
print $resp->bodyStr() . "\r\n";

$hashTab1 = chilkat::CkHashtable->new();
$hashTab1->AddQueryParams($resp->bodyStr());

$requestToken = $hashTab1->lookupStr("oauth_token");
$requestTokenSecret = $hashTab1->lookupStr("oauth_token_secret");
$http->put_OAuthTokenSecret($requestTokenSecret);

print "oauth_token = " . $requestToken . "\r\n";
print "oauth_token_secret = " . $requestTokenSecret . "\r\n";

# ---------------------------------------------------------------------------
# The next step is to form a URL to send to the AuthorizeUrl
# This is an HTTP GET that we load into a popup browser.
$sbUrlForBrowser = chilkat::CkStringBuilder->new();
$sbUrlForBrowser->Append($authorizeUrl);
$sbUrlForBrowser->Append("?oauth_token=");
$sbUrlForBrowser->Append($requestToken);
$urlForBrowser = $sbUrlForBrowser->getAsString();

# When the urlForBrowser is loaded into a browser, the response from Quickbooks will redirect back to localhost:3017
# We'll need to start a socket that is listening on port 3017 for the callback from the browser.
$listenSock = chilkat::CkSocket->new();

$backLog = 5;
$success = $listenSock->BindAndListen($callbackLocalPort,$backLog);
if ($success != 1) {
    print $listenSock->lastErrorText() . "\r\n";
    exit;
}

# Wait for the browser's connection in a background thread.
# (We'll send load the URL into the browser following this..)
# Wait a max of 60 seconds before giving up.
$maxWaitMs = 60000;
# task is a Task
$task = $listenSock->AcceptNextConnectionAsync($maxWaitMs);
$task->Run();

#  At this point, your application should load the URL in a browser.
#  For example,
#  in C#:  System.Diagnostics.Process.Start(urlForBrowser);
#  in Java: Desktop.getDesktop().browse(new URI(urlForBrowser));
#  in VBScript: Set wsh=WScript.CreateObject("WScript.Shell")
#               wsh.Run urlForBrowser
# in Xojo: ShowURL(url)  (see http://docs.xojo.com/index.php/ShowURL)
# in Dataflex: Runprogram Background "c:\Program Files\Internet Explorer\iexplore.exe" sUrl        
#  The Quickbooks account owner would interactively accept or deny the authorization request.

#  Add the code to load the url in a web browser here...
#  Add the code to load the url in a web browser here...
#  Add the code to load the url in a web browser here...
# System.Diagnostics.Process.Start(urlForBrowser);

# Wait for the listenSock's task to complete.
$success = $task->Wait($maxWaitMs);
if (!$success or ($task->get_StatusInt() != 7) or ($task->get_TaskSuccess() != 1)) {
    if (!$success) {
        # The task.LastErrorText applies to the Wait method call.
        print $task->lastErrorText() . "\r\n";
    }
    else {
        # The ResultErrorText applies to the underlying task method call (i.e. the AcceptNextConnection)
        print $task->status() . "\r\n";
        print $task->resultErrorText() . "\r\n";
    }

    exit;
}

# If we get to this point, the connection from the browser arrived and was accepted.

# We no longer need the listen socket...
# Close it so that it's no longer listening on port 3017.
$listenSock->Close(10);

# The first thing to do is to get the connected socket.
$sock = chilkat::CkSocket->new();
$sock->LoadTaskResult($task);

# Read the start line of the request..
$startLine = $sock->receiveUntilMatch("\r\n");
if ($sock->get_LastMethodSuccess() != 1) {
    print $sock->lastErrorText() . "\r\n";
    exit;
}

# Read the request header.
$requestHeader = $sock->receiveUntilMatch("\r\n\r\n");
if ($sock->get_LastMethodSuccess() != 1) {
    print $sock->lastErrorText() . "\r\n";
    exit;
}

# The browser SHOULD be sending us a GET request, and therefore there is no body to the request.
# Once the request header is received, we have all of it.
# We can now send our HTTP response.
$sbResponseHtml = chilkat::CkStringBuilder->new();
$sbResponseHtml->Append("<html><body><p>Chilkat thanks you!</b></body</html>");

$sbResponse = chilkat::CkStringBuilder->new();
$sbResponse->Append("HTTP/1.1 200 OK\r\n");
$sbResponse->Append("Content-Length: ");
$sbResponse->AppendInt($sbResponseHtml->get_Length());
$sbResponse->Append("\r\n");
$sbResponse->Append("Content-Type: text/html\r\n");
$sbResponse->Append("\r\n");
$sbResponse->AppendSb($sbResponseHtml);

$sock->SendString($sbResponse->getAsString());
$sock->Close(50);

# The information we need is in the startLine.
# For example, the startLine will look like this:
#  GET /?oauth_token=abcdRQAAZZAAxfBBAAABVabcd_k&oauth_verifier=9rdOq5abcdCe6cn8M3jabcdj3Eabcd HTTP/1.1
$sbStartLine = chilkat::CkStringBuilder->new();
$sbStartLine->Append($startLine);
$numReplacements = $sbStartLine->Replace("GET /?","");
$numReplacements = $sbStartLine->Replace(" HTTP/1.1","");
$sbStartLine->Trim();

# oauth_token=qyprdP04IrTDIXtP1HRZz0geQdjXHVlGDxXPexlXZsjZNRcY&oauth_verifier=arx5pj5&realmId=193514465596199&dataSource=QBO
print "startline: " . $sbStartLine->getAsString() . "\r\n";

$hashTab1->Clear();
$hashTab1->AddQueryParams($sbStartLine->getAsString());

$requestToken = $hashTab1->lookupStr("oauth_token");
$authVerifier = $hashTab1->lookupStr("oauth_verifier");

# ------------------------------------------------------------------------------
# Finally , we must exchange the OAuth Request Token for an OAuth Access Token.

$http->put_OAuthToken($requestToken);
$http->put_OAuthVerifier($authVerifier);
# resp is a HttpResponse
$resp = $http->PostUrlEncoded($accessTokenUrl,$req);
if ($http->get_LastMethodSuccess() != 1) {
    print $http->lastErrorText() . "\r\n";
    exit;
}

# Make sure a successful response was received.
if ($resp->get_StatusCode() != 200) {
    print $resp->statusLine() . "\r\n";
    print $resp->header() . "\r\n";
    print $resp->bodyStr() . "\r\n";
    exit;
}

# If successful, the resp.BodyStr contains something like this:
# oauth_token=12347455-ffffrrlaBdCjbdGfyjZabcdb5APNtuTPNabcdEpp&oauth_token_secret=RxxxxJ8mTzUhwES4xxxxuJyFWDN8ZfHmrabcddh88LmWE
print $resp->bodyStr() . "\r\n";

$hashTab2 = chilkat::CkHashtable->new();
$hashTab2->AddQueryParams($resp->bodyStr());

$accessToken = $hashTab2->lookupStr("oauth_token");
$accessTokenSecret = $hashTab2->lookupStr("oauth_token_secret");

# The access token + secret is what should be saved and used for
# subsequent REST API calls.
print "Access Token = " . $accessToken . "\r\n";
print "Access Token Secret = " . $accessTokenSecret . "\r\n";

# Save this access token for future calls.
$json = chilkat::CkJsonObject->new();
$json->AppendString("oauth_token",$accessToken);
$json->AppendString("oauth_token_secret",$accessTokenSecret);

# Also save the realmId and dataSource from hashTab1.
$realmId = $hashTab1->lookupStr("realmId");
print "realmId = " . $realmId . "\r\n";
$dataSource = $hashTab1->lookupStr("dataSource");
print "dataSource = " . $dataSource . "\r\n";

$json->AppendString("realmId",$realmId);
$json->AppendString("dataSource",$dataSource);

$fac = chilkat::CkFileAccess->new();
$fac->WriteEntireTextFile("qa_data/tokens/quickbooks.json",$json->emit(),"utf-8",0);

print "Success." . "\r\n";