protected override async Task ActAsync()
{
var request = A.Fake <HttpRequest>();
var headerDictionary = new HeaderDictionary {
{ "Authorization", "Basic Y2xpZW50SWQ6Y2xpZW50U2VjcmV0" }
};
A.CallTo(() => request.Headers).Returns(headerDictionary);
var httpContext = A.Fake <HttpContext>();
A.CallTo(() => httpContext.Request).Returns(request);
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
_controller.ControllerContext = controllerContext;
_actionResult = await _controller.PostAsync(
new TokenRequest
{
Grant_type = "client_credentials",
Scope = _requestedScope
});
_tokenError = ((ObjectResult)_actionResult).Value as TokenError;
}
public void HexStringTruncated3()
{
Tokenizer t = new Tokenizer(StringToStream("<00["));
TokenError e = t.GetToken() as TokenError;
Assert.NotNull(e);
Assert.True(e.Position == 0);
}
public void KeywordNullIncorrect()
{
Tokenizer t = new Tokenizer(StringToStream("Null"));
TokenError e = t.GetToken() as TokenError;
Assert.NotNull(e);
Assert.True(e.Position == 0);
}
/// <summary>
/// Combines two consecutive error tokens
/// </summary>
/// <param name="token">Previous error token</param>
/// <param name="whiteSpacesSkipped">How many white spaces where skipped.</param>
public void CombineErrorTokens(TokenError token, int whiteSpacesSkipped)
{
var whiteSpaces = "";
for ( var i = 0; i < whiteSpacesSkipped; i++ )
{
whiteSpaces += " ";
}
Lexeme += whiteSpaces + token.Lexeme;
}
public void DictionaryCloseFail4()
{
Tokenizer t = new Tokenizer(StringToStream("> >"));
TokenError n = t.GetToken() as TokenError;
Assert.NotNull(n);
Assert.True(n.Position == 0);
Assert.True(t.GetToken() is TokenError);
}
public void DictionaryOpenFail()
{
Tokenizer t = new Tokenizer(StringToStream("<"));
TokenError n = t.GetToken() as TokenError;
Assert.NotNull(n);
Assert.True(n.Position == 0);
Assert.True(t.GetToken() is TokenEmpty);
}
protected override async Task ActAsync()
{
_controller.ControllerContext =
ControllerHelper.CreateControllerContext(new HeaderDictionary {
{ "Authorization", "Basic Tm9Db2xvbkhlcmU=" }
});
_actionResult = await _controller.PostAsync(
new TokenRequest { Grant_type = "client_credentials" });
_tokenError = ((ObjectResult)_actionResult).Value as TokenError;
}
protected override async Task ActAsync()
{
_controller.ControllerContext = ControllerHelper.CreateControllerContext(
new HeaderDictionary
{
{ "Authorization", $"Basic {ControllerHelper.CreateEncodedAuthentication(clientSecret: null)}" }
});
_actionResult = await _controller.PostAsync(
new TokenRequest { Grant_type = "client_credentials" });
_tokenError = ((ObjectResult)_actionResult).Value as TokenError;
}
public async Task GenerateToken()
{
var response = await ClarifaiHttpClient.GetToken(ClientId, ClientSecret);
if (response is TokenError)
{
TokenError er = (TokenError)response;
_accessToken = "";
throw new Exception(er.Status_Msg);
}
else
{
Token token = (Token)response;
_accessToken = token.Access_Token;
}
}
public async Task <IActionResult> AuthenticateForm(CancellationToken cancellationToken, TokenRequest tokenRequest)
{
try
{
var userAgent = Request.UserAgent();
var command = new AuthenticateCommand(userAgent, tokenRequest);
var result = await _mediator.Send(command, cancellationToken).ConfigureAwait(false);
return(Ok(result));
}
catch (AuthenticationException authenticationException)
{
var error = new TokenError
{
Error = authenticationException.ErrorType,
ErrorDescription = authenticationException.Message
};
return(BadRequest(error));
}
}
public void Reconocer(Context context)
{
try
{
int caracter = (int)this.cadena[indice];
Token t = new TokenError(lexema);
Estatico.t.Text += t.mostrarToken();
lexema = "";
Estado_0 e0 = new Estado_0(indice + 1, cadena, lexema);
e0.Reconocer(context);
}
catch (Exception e)
{
Token t = new TokenError(lexema);
Estatico.t.Text += t.mostrarToken();
}
}
public static async Task <object> GetToken(string clientId, string clientSecret)
{
ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(ValidateServerCertificate);
//
// MESSAGE CONTENT
string postData = "client_id=" + clientId + "&client_secret=" + clientSecret + "&grant_type=client_credentials";
//string postData = "client_id=Wads5t98mMepkTuQFLbQvdYBPH0xIBz_7KqdhMIp&client_secret=Igqe-qov2dbcS8EQDHoI8DxRR0PiEN3y3Tj4Vu2m&grant_type=client_credentials";
byte[] byteArray = Encoding.UTF8.GetBytes(postData);
//
// CREATE REQUEST
HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(_apiEndPoint + _tokenPath);
Request.Method = "POST";
Request.KeepAlive = false;
Request.ContentType = "application/x-www-form-urlencoded";
Request.Headers.Add("cache-control", "no-cache");
Stream dataStream = await Request.GetRequestStreamAsync();
await dataStream.WriteAsync(byteArray, 0, byteArray.Length);
dataStream.Close();
//
// SEND MESSAGE
try
{
WebResponse Response = await Request.GetResponseAsync();
StreamReader Reader = new StreamReader(Response.GetResponseStream());
string responseLine = await Reader.ReadToEndAsync();
Reader.Close();
HttpStatusCode ResponseCode = ((HttpWebResponse)Response).StatusCode;
if (!ResponseCode.Equals(HttpStatusCode.OK))
{
TokenError error = Newtonsoft.Json.JsonConvert.DeserializeObject <TokenError>(responseLine);
return(error);
}
Token token = Newtonsoft.Json.JsonConvert.DeserializeObject <Token>(responseLine);
return(token);
}
catch (WebException e)
{
using (WebResponse response = e.Response)
{
HttpWebResponse httpResponse = (HttpWebResponse)response;
using (Stream data = response.GetResponseStream())
using (var reader = new StreamReader(data))
{
string text = reader.ReadToEnd();
TokenError error = Newtonsoft.Json.JsonConvert.DeserializeObject <TokenError>(text);
return(error);
}
}
}
return(new TokenError
{
Status_Code = "Undefined Error",
Status_Msg = "Undefined Error"
});
}
public AuthenticationError(HttpRequest httpRequest, TokenError errorResponse)
{
_httpRequest = httpRequest;
_errorResponse = errorResponse;
}
