public RequestUrlAuthUrlParameters(IRequestAuthUrlParameters parameters) : base(parameters)
{
CallbackUrl = parameters?.CallbackUrl;
AuthAccessType = parameters?.AuthAccessType;
ForceLogin = parameters?.ForceLogin;
ScreenName = parameters?.ScreenName;
}
public void Validate(IRequestAuthUrlParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
}
public void Validate(IRequestAuthUrlParameters parameters)
{
_authClientRequiredParametersValidator.Validate(parameters);
if (parameters.CallbackUrl != null)
{
if (parameters.CallbackUrl != "oob" && !Uri.IsWellFormedUriString(parameters.CallbackUrl, UriKind.Absolute))
{
throw new ArgumentException("Invalid format, must be absolute uri or have a value of 'oob'", $"{nameof(parameters)}{nameof(parameters.CallbackUrl)}");
}
}
}
public string GetRequestAuthUrlQuery(IRequestAuthUrlParameters parameters)
{
var query = new StringBuilder(Resources.Auth_RequestToken);
if (parameters.AuthAccessType != null)
{
var paramValue = parameters.AuthAccessType == AuthAccessType.ReadWrite ? "write" : "read";
query.AddParameterToQuery("x_auth_access_type", paramValue);
}
query.AddFormattedParameterToQuery(parameters.FormattedCustomQueryParameters);
return(query.ToString());
}
public async Task <ITwitterResult <IAuthenticationRequest> > RequestAuthUrl(IRequestAuthUrlParameters parameters, ITwitterRequest request)
{
var authToken = new AuthenticationRequest(request.Query.TwitterCredentials);
var authProcessParams = new RequestAuthUrlInternalParameters(parameters, authToken);
if (string.IsNullOrEmpty(parameters.CallbackUrl))
{
authProcessParams.CallbackUrl = Resources.Auth_PinCodeUrl;
}
var requestTokenResponse = await _authQueryExecutor.RequestAuthUrl(authProcessParams, request).ConfigureAwait(false);
if (string.IsNullOrEmpty(requestTokenResponse.RawResult) || requestTokenResponse.RawResult == Resources.Auth_RequestToken)
{
throw new TwitterAuthException(requestTokenResponse, "Invalid authentication response");
}
var tokenInformation = _parseRequestUrlResponseRegex.Match(requestTokenResponse.RawResult);
if (!bool.TryParse(tokenInformation.Groups["oauth_callback_confirmed"].Value, out var callbackConfirmed) || !callbackConfirmed)
{
throw new TwitterAuthAbortedException(requestTokenResponse);
}
authToken.AuthorizationKey = tokenInformation.Groups["oauth_token"].Value;
authToken.AuthorizationSecret = tokenInformation.Groups["oauth_token_secret"].Value;
var authorizationUrl = new StringBuilder(Resources.Auth_AuthorizeBaseUrl);
authorizationUrl.AddParameterToQuery("oauth_token", authToken.AuthorizationKey);
authorizationUrl.AddParameterToQuery("force_login", parameters.ForceLogin);
authorizationUrl.AddParameterToQuery("screen_name", parameters.ScreenName);
authToken.AuthorizationURL = authorizationUrl.ToString();
return(new TwitterResult <IAuthenticationRequest>
{
Request = requestTokenResponse.Request,
Response = requestTokenResponse.Response,
DataTransferObject = authToken
});
}
public void Validate(IRequestAuthUrlParameters parameters)
{
_authClientParametersValidator.Validate(parameters);
}
public async Task <IAuthenticationRequest> RequestAuthenticationUrlAsync(IRequestAuthUrlParameters parameters)
{
var twitterResult = await _authRequester.RequestAuthUrlAsync(parameters).ConfigureAwait(false);
return(twitterResult?.Model);
}
public RequestAuthUrlInternalParameters(IRequestAuthUrlParameters parameters, IAuthenticationRequest authRequest) : base(parameters)
{
AuthRequest = authRequest;
}
public async Task <IAuthenticationRequest> RequestAuthenticationUrl(IRequestAuthUrlParameters parameters)
{
var twitterResult = await _authRequester.RequestAuthUrl(parameters).ConfigureAwait(false);
return(twitterResult?.DataTransferObject);
}
public Task <ITwitterResult <IAuthenticationRequest> > RequestAuthUrl(IRequestAuthUrlParameters parameters)
{
_validator.Validate(parameters);
return(ExecuteRequest(request => _authController.RequestAuthUrl(parameters, request)));
}
