private async Task StartAuthorization(MobileConnectStatus response)
{
_state = Guid.NewGuid().ToString("N");
_nonce = Guid.NewGuid().ToString("N");
var newResponse = _mobileConnect.StartAuthorization(_discoveryResponse,
response.DiscoveryResponse.ResponseData.subscriber_id, _state, _nonce, new MobileConnectRequestOptions());
await HandleResponse(newResponse);
}
private void ShowIdentity(MobileConnectStatus status)
{
loggedPanel.Visibility = Visibility.Collapsed;
identityPanel.Visibility = Visibility.Visible;
var json = new Newtonsoft.Json.Linq.JRaw(status.IdentityResponse.ResponseJson);
identity.Text = json.ToString(Newtonsoft.Json.Formatting.Indented);
}
public void ResponseConverterShouldHandleStartDiscoveryStatus()
{
var status = MobileConnectStatus.StartDiscovery();
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("discovery", actual.Action);
}
public void ResponseConverterShouldHandleTokenRevokedStatus()
{
var response = new RevokeTokenResponse(_responses["token-revoked"]);
var status = MobileConnectStatus.TokenRevoked(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("token_revoked", actual.Action);
}
public void ResponseConverterShouldHandleOperatorSelectionStatus()
{
var status = MobileConnectStatus.OperatorSelection(OPERATOR_SELECTION_URL);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("operator_selection", actual.Action);
Assert.AreEqual(OPERATOR_SELECTION_URL, actual.Url);
}
public void ResponseConverterShouldHandleCompleteStatus()
{
var response = new RequestTokenResponse(_responses["token"]);
var status = MobileConnectStatus.Complete(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("complete", actual.Action);
Assert.AreEqual(status.TokenResponse.ResponseData, actual.Token);
}
protected IHttpActionResult GetHttpMsgWithRedirect(string url, string errMsg = null)
{
if (string.IsNullOrEmpty(url))
{
return(CreateResponse(MobileConnectStatus.Error(ErrorCodes.InvalidArgument, errMsg, new Exception())));
}
var authResponse = Request.CreateResponse(HttpStatusCode.Redirect);
authResponse.Headers.Location = new Uri(url);
return(new ResponseMessageResult(authResponse));
}
public void ResponseConverterShouldHandleErrorStatus()
{
var error = "this is the error";
var description = "this is the description";
var status = MobileConnectStatus.Error(error, description, null);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("failure", actual.Status);
Assert.AreEqual("error", actual.Action);
Assert.AreEqual(error, actual.Error);
Assert.AreEqual(description, actual.Description);
}
private IHttpActionResult CreateResponse(MobileConnectStatus status)
{
var response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(status));
if (status.SetCookie != null)
{
foreach (var cookie in status.SetCookie)
{
response.Headers.Add("Set-Cookie", cookie);
}
}
return(new ResponseMessageResult(response));
}
private void Complete(MobileConnectStatus response)
{
_state = null;
_nonce = null;
_token = response.TokenResponse.ResponseData;
accessToken.Text = _token.AccessToken;
idToken.Text = _token.IdToken;
timeReceived.Text = _token.TimeReceived.ToString("u");
applicationName.Text = _discoveryResponse.ApplicationShortName ?? "";
validationResult.Text = response.TokenResponse.ValidationResult.ToString();
loginPanel.Visibility = Visibility.Collapsed;
loggedPanel.Visibility = Visibility.Visible;
}
public void ResponseConverterShouldHandleAuthenticationStatus()
{
var state = "qpwoeirurytalsksjdhdgf";
var nonce = "qpwowieuryrttalksjsggdfj";
var status = MobileConnectStatus.Authentication(AUTHORIZE_URL, state, nonce);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("authentication", actual.Action);
Assert.AreEqual(AUTHORIZE_URL, actual.Url);
Assert.AreEqual(state, actual.State);
Assert.AreEqual(nonce, actual.Nonce);
}
public void ResponseConverterShouldHandleStartAuthenticationStatus()
{
var session = "session";
var response = new DiscoveryResponse(_responses["authentication"]);
var status = MobileConnectStatus.StartAuthentication(response);
status.SDKSession = session;
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("start_authentication", actual.Action);
Assert.IsNotNull(actual.SdkSession);
Assert.IsNotNull(actual.SubscriberId);
}
private async Task StartAuthentication(MobileConnectStatus response)
{
_state = Utils.Security.GenerateSecureNonce();
_nonce = Utils.Security.GenerateSecureNonce();
_discoveryResponse = response.DiscoveryResponse;
_authOptions = new MobileConnectRequestOptions
{
Scope = GetScope(),
Context = "demo",
BindingMessage = "demo auth",
// Accept valid results and results indicating validation was skipped due to missing support on the provider
AcceptedValidationResults = TokenValidationResult.Valid | TokenValidationResult.IdTokenValidationSkipped,
};
var newResponse = _mobileConnect.StartAuthentication(_discoveryResponse,
response.DiscoveryResponse.ResponseData.subscriber_id, _state, _nonce, _authOptions);
await HandleResponse(newResponse);
}
private async Task HandleResponse(MobileConnectStatus response)
{
System.Diagnostics.Debug.WriteLine(response.ResponseType);
if (response.ResponseType == MobileConnectResponseType.OperatorSelection || response.ResponseType == MobileConnectResponseType.Authorization)
{
web.Navigate(new Uri(response.Url));
}
else if (response.ResponseType == MobileConnectResponseType.StartAuthorization)
{
await StartAuthorization(response);
}
else if (response.ResponseType == MobileConnectResponseType.Complete)
{
System.Diagnostics.Debug.WriteLine(response.TokenResponse.ResponseData.AccessToken);
Complete(response.TokenResponse.ResponseData.AccessToken);
}
else if (response.ResponseType == MobileConnectResponseType.Error)
{
HandleError(response);
}
}
private async Task HandleResponse(MobileConnectStatus response)
{
System.Diagnostics.Debug.WriteLine(response.ResponseType);
switch (response.ResponseType)
{
case MobileConnectResponseType.Error:
HandleError(response);
break;
case MobileConnectResponseType.OperatorSelection:
case MobileConnectResponseType.Authentication:
web.Navigate(new Uri(response.Url));
break;
case MobileConnectResponseType.StartDiscovery:
await StartDiscovery(null);
break;
case MobileConnectResponseType.StartAuthentication:
await StartAuthentication(response);
break;
case MobileConnectResponseType.Complete:
Complete(response);
break;
case MobileConnectResponseType.TokenRevoked:
validationResult.Text = "Token Revoked";
identityButton.IsEnabled = false;
userInfoButton.IsEnabled = false;
break;
case MobileConnectResponseType.UserInfo:
case MobileConnectResponseType.Identity:
ShowIdentity(response);
break;
}
}
protected IHttpActionResult CreateResponse(MobileConnectStatus status)
{
HttpResponseMessage response;
if (!string.IsNullOrEmpty(status.ErrorCode))
{
response = Request.CreateResponse(HttpStatusCode.Found, ResponseConverter.Convert(status));
}
else
{
response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(status));
}
if (status.SetCookie != null)
{
foreach (var cookie in status.SetCookie)
{
response.Headers.Add("Set-Cookie", cookie);
}
}
return(new ResponseMessageResult(response));
}
/// <summary>
/// Convert to lightweight serializable MobileConnectWebResponse
/// </summary>
/// <param name="status">Input status instance</param>
/// <returns>Serializable response instance</returns>
/// <example>
/// <code language="C#" title="WebApi Controller Example">
/// <![CDATA[
/// [HttpGet]
/// [Route("start_discovery")]
/// public async Task<object> StartDiscovery(string msisdn = "", string mcc = "", string mnc = "")
/// {
/// var response = await _mobileConnect.AttemptDiscovery(Request, msisdn, mcc, mnc, true, new MobileConnectRequestOptions());
/// return ResponseConverter.Convert(response);
/// }
/// ]]>
/// </code>
/// </example>
public static MobileConnectWebResponse Convert(MobileConnectStatus status)
{
var response = new MobileConnectWebResponse
{
Status = _statusDict[status.ResponseType],
Action = _actionDict[status.ResponseType],
Nonce = status.Nonce,
State = status.State,
Url = status.Url,
SdkSession = status.SDKSession,
SubscriberId = status.DiscoveryResponse?.ResponseData?.subscriber_id,
Token = status.TokenResponse?.ResponseData,
};
if (status.ResponseType == MobileConnectResponseType.Error)
{
response.Error = status.ErrorCode;
response.Description = status.ErrorMessage;
}
return(response);
}
protected IHttpActionResult CreateIdentityResponse(MobileConnectStatus authnStatus, MobileConnectStatus identityUserInfoStatustatus = null)
{
var authnResponse = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(authnStatus));
if (identityUserInfoStatustatus != null)
{
var response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(identityUserInfoStatustatus));
authnResponse.Content = new StringContent(СreateNewHttpResponseMessage(authnResponse, response));
if (identityUserInfoStatustatus.SetCookie != null)
{
foreach (var cookie in identityUserInfoStatustatus.SetCookie)
{
authnResponse.Headers.Add("Set-Cookie", cookie);
}
}
}
else
{
authnResponse.Content = new StringContent(СreateNewHttpResponseMessage(authnResponse));
}
return(new ResponseMessageResult(authnResponse));
}
/// <summary>
/// Convert to lightweight serializable MobileConnectWebResponse
/// </summary>
/// <param name="status">Input status instance</param>
/// <returns>Serializable response instance</returns>
/// <example>
/// <code language="C#" title="WebApi Controller Example">
/// <![CDATA[
/// [HttpGet]
/// [Route("start_discovery")]
/// public async Task<object> StartDiscovery(string msisdn = "", string mcc = "", string mnc = "")
/// {
/// var response = await _mobileConnect.AttemptDiscovery(Request, msisdn, mcc, mnc, true, new MobileConnectRequestOptions());
/// return ResponseConverter.Convert(response);
/// }
/// ]]>
/// </code>
/// </example>
public static MobileConnectWebResponse Convert(MobileConnectStatus status)
{
var response = new MobileConnectWebResponse
{
Status = status.ResponseType == MobileConnectResponseType.Error ? STATUS_FAILURE : STATUS_SUCCESS,
Action = _actionDict[status.ResponseType],
ApplicationShortName = status.DiscoveryResponse?.ApplicationShortName,
Nonce = status.Nonce,
State = status.State,
Url = status.Url,
SdkSession = status.SDKSession,
SubscriberId = status.DiscoveryResponse?.ResponseData?.subscriber_id,
Token = status.TokenResponse?.ResponseData,
Identity = status.IdentityResponse?.ResponseJson != null ? new Newtonsoft.Json.Linq.JRaw(status.IdentityResponse.ResponseJson) : null,
};
if (status.ResponseType == MobileConnectResponseType.Error)
{
response.Error = status.ErrorCode;
response.Description = status.ErrorMessage;
}
return(response);
}
private void HandleError(MobileConnectStatus response)
{
errorText.Text = response?.ErrorMessage;
progress.Visibility = Visibility.Collapsed;
submit.IsEnabled = true;
}
protected bool HandleErrorMsg(MobileConnectStatus status)
{
return(!string.IsNullOrEmpty(status.ErrorMessage));
}
public async Task <IHttpActionResult> DiscoveryCallback(
string state = null,
string error = null,
string error_description = null,
string description = null)
{
if (!string.IsNullOrEmpty(error))
{
return(CreateResponse(MobileConnectStatus.Error(error, error_description != null ? error_description : description, new Exception())));
}
var options = new MobileConnectRequestOptions
{
AcceptedValidationResults = Authentication.TokenValidationResult.Valid |
Authentication.TokenValidationResult.IdTokenValidationSkipped,
Context = ApiVersion.Equals(Utils.Constants.VERSION2_0) || ApiVersion.Equals(Utils.Constants.VERSION2_3) ? Utils.Constants.ContextBindingMsg : null,
BindingMessage = ApiVersion.Equals(Utils.Constants.VERSION2_0) || ApiVersion.Equals(Utils.Constants.VERSION2_3) ? Utils.Constants.ContextBindingMsg : null,
ClientName = OperatorParams.clientName,
AcrValues = OperatorParams.acrValues
};
Uri requestUri = Request.RequestUri;
SessionData sessionData = SessionCache.Get(state);
MobileConnectStatus status = await MobileConnect.HandleUrlRedirectAsync(Request, requestUri, sessionData.DiscoveryResponse,
state, sessionData.Nonce, options, ApiVersion);
var idTokenResponseModel =
JsonConvert.DeserializeObject <IdTokenResponse>(status.TokenResponse.DecodedIdTokenPayload);
MobileConnectStatus response = null;
if (idTokenResponseModel.nonce.Equals(sessionData.Nonce))
{
if (ApiVersion.Equals(Utils.Constants.VERSION1_1) &
!string.IsNullOrEmpty(sessionData.DiscoveryResponse.OperatorUrls.UserInfoUrl))
{
for (int scopeIndex = 0; scopeIndex < UserInfoScopes.Length; scopeIndex++)
{
if (OperatorParams.scope.Contains(UserInfoScopes[scopeIndex]))
{
response = await RequestUserInfo(sessionData.DiscoveryResponse,
status.TokenResponse.ResponseData.AccessToken);
return(CreateIdentityResponse(status, response));
}
}
}
if ((ApiVersion.Equals(Utils.Constants.VERSION2_0) || ApiVersion.Equals(Utils.Constants.VERSION2_3)) &
!string.IsNullOrEmpty(sessionData.DiscoveryResponse.OperatorUrls.PremiumInfoUrl))
{
for (int scopeIndex = 0; scopeIndex < IdentityScopes.Length; scopeIndex++)
{
if (OperatorParams.scope.Contains(IdentityScopes[scopeIndex]))
{
response = await RequestPremiumInfo(sessionData.DiscoveryResponse,
status.TokenResponse.ResponseData.AccessToken);
return(CreateIdentityResponse(status, response));
}
}
}
}
else
{
response = MobileConnectStatus.Error(
ErrorCodes.InvalidArgument, "nonce is incorrect", new Exception());
return(CreateResponse(response));
}
// return CreateResponse(status);
return(CreateIdentityResponse(status));
}
private async void SetSessionCache(MobileConnectStatus status, string msisdn, string mcc, string mnc, string sourceIp)
{
await SessionCache.Add(status.State,
new SessionData(DiscoveryCache.Get(StringUtils.FormatKey(msisdn, mcc, mnc, sourceIp)), status.Nonce));
}
private void HandleError(MobileConnectStatus response)
{
errorText.Text = response.ErrorMessage;
progress.Visibility = Visibility.Collapsed;
}
private async void SetSessionCache(MobileConnectStatus status, DiscoveryResponse discoveryResponse, string nonce)
{
await SessionCache.Add(status.State, new SessionData(discoveryResponse, nonce));
}
