In the previous posts, we went through each platform, looking at how we implement deep linking for each of the platforms. At the end of the deep link flow, we have arrived back within our portable Application object with a URL to process. This URL has a response code at the end that we have to parse out and send back to Forge to get our access and refresh tokens.
This is pretty easy, something like this works:
private string GetResponseCodeFromUrl(string redirectUrl)
{
string codeParameter = "?code=";
int pos = redirectUrl.IndexOf(codeParameter);
string code = redirectUrl.Substring(pos + codeParameter.Length);
return code;
}
After that we post a REST call to “https://developer.api.autodesk.com/authentication/v1/gettoken”. Inside of the content of the post call, we need to add a string with all of our app keys and codes, in a similar fashion to how we started off the whole authentication process in the first post of the series. The string content looks like this and should be all on one line.
var content = new StringContent($"client_id={ClientId}&client_secret={ClientSecret}&grant_type=authorization_code&code={ResponseCode}&redirect_uri={CallbackUrl}");
See the above link for an explanation of the ClientId, ClientSecret and redirect_uri. The ReponseCode is simply the code that we retrieved using the above GetResponseCodeFromUrl function above.
private AuthData AuthorizationData { get; set; }
public async Task<bool> GetAccessTokenAsync(string redirectUrl)
{
ResponseCode = GetResponseCodeFromUrl(redirectUrl);
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Clear();
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "https://developer.api.autodesk.com/authentication/v1/gettoken"))
{
request.Content = new StringContent($"client_id={ClientId}&client_secret={ClientSecret}&grant_type=authorization_code&code={ResponseCode}&redirect_uri={CallbackUrl}");
request.Content.Headers.ContentType =
new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using (HttpResponseMessage response = await client.SendAsync(request))
{
string data = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
AuthorizationData = Deserialize<AuthData>(data);
return true;
}
}
}
}
return false;
}
If all goes well, we end up getting a response with our authorization data. That structure looks like this:
public class AuthData
{
[JsonProperty("token_type")]
public string TokenType { get; set; }
[JsonProperty("expires_in")]
public int ExpiresInMinutes { get; set; }
[JsonProperty("refresh_token")]
public string RefreshToken { get; set; }
[JsonProperty("access_token")]
public string AccessToken { get; set; }
public DateTime DateGranted { get; set; }
public AuthData()
{
DateGranted = DateTime.Now;
}
}
I am using Json.NET as my deserializer and am using the attributes to redirect the parsed data into the properties that I want. I think pretty much everyone uses Json.NET, but if it is the first you have heard about it, it is definitely worth your time to look at. Important properties above are:
- AccessToken: use this for all of your Forge requests so that Forge knows you are authenticated.
- RefreshToken: the access token will expire. You use the refresh token to request a new one without forcing the user to re-authenticate.
- ExpiresIn: how many minutes before the access token expires.
- DateGranted: not returned by Forge, but sets when the token was granted so that we can compute when it expires.
And that is about it! In the next post, we will look at refreshing the access token.
random bits and bytes 