List <List <T> > ConvertMultiSearchResultToList(MultiSearchResult multiSearchResult)
{
var result = new List <List <T> >();
var paths = multiSearchResult.TokenizedResults;
foreach (var path in paths)
{
var tokens = new List <T>();
foreach (var node in path)
{
var wordId = node.WordId;
if (node.Type == ViterbiNode.NodeType.Known && wordId == -1)
{
// Do not include BOS/EOS
continue;
}
var token = TokenFactory.CreateToken(
wordId,
node.Surface,
node.Type,
node.StartIndex,
DictionaryMap[node.Type]
);
tokens.Add(token);
}
result.Add(tokens);
}
return(result);
}
private IAToken CreateToken(int startPos, int endPos)
{
IAToken token = TokenFactory.CreateToken(_text.Substring(startPos, endPos - startPos));
SetAddSpaceFlag(token, endPos);
return(token);
}
/// <summary>
/// Creates a new login token for authenticating a specific user for a specific application.
/// </summary>
/// <param name="username">The login name of the user requesting authentication.</param>
/// <param name="applicationID">The unique identifier of the application requesting authentication.</param>
/// <returns>A new login token if the specified user has access to the specified application; otherwise, null.</returns>
public Token CreateToken(string username, byte applicationID)
{
using (CPSecurityEntities context = new CPSecurityEntities())
{
var app = context.SecuritySsoApplications.FirstOrDefault(a => a.ApplicationId == applicationID);
if (app != null && HasUserRights(username, (CPUserRights)app.UserRights))
{
SecuritySsoToken token = new SecuritySsoToken()
{
UserName = username,
SecuritySsoApplication = app
};
try
{
context.SecuritySsoTokens.AddObject(token);
context.SaveChanges();
return(TokenFactory.CreateToken(token));
}
catch
{
}
}
}
return(null);
}
private IAToken GetQuotedIdentifier(ref int textPos, char endQuote)
{
int startPos = textPos;
textPos++;
while (textPos < _text.Length)
{
if (_text[textPos] == endQuote)
{
break;
}
textPos++;
}
if (textPos == _text.Length)
{
throw new ATokenizerException(string.Format("Missing terminating quote for quoted identifier starting at position {0}", startPos));
}
textPos++;
IAToken token = TokenFactory.CreateToken(_text.Substring(startPos, textPos - startPos));
SetAddSpaceFlag(token, textPos);
return(token);
}
private void button5_Click(object sender, EventArgs e)
{
IToken lToken = TokenFactory.CreateToken(WebSocketMessage.NS_SYSTEM_PLUGIN, "string");
lToken.SetString("data", "Hello");
mClient.SendToken(lToken, StringResponse);
}
public async Task WhenNoCorsHeadersAreAlreadySetOnTheResponse_SetsThemFromRequestSpecificHeaders()
{
var client = PipelineFactory.CreateHttpClient(_options, x =>
{
x.Use(async(context, next) =>
{
context.Request.Headers.Add("Origin", new[] { "Origin Value" });
context.Request.Headers.Add("Access-Control-Request-Method", new[] { "ACRM Value" });
context.Request.Headers.Add("Access-Control-Request-Headers", new[] { "ACRH Value" });
await next()
.ConfigureAwait(true);
});
});
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken(scope: new string[] { TokenFactory.Api1Scope }));
client.SetBearerToken(token);
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
var responseHeaders = result.Headers;
responseHeaders.GetValues("Access-Control-Allow-Origin").Should().BeEquivalentTo("Origin Value");
responseHeaders.GetValues("Access-Control-Expose-Headers").Should().BeEquivalentTo("WWW-Authenticate");
responseHeaders.GetValues("Access-Control-Allow-Method").Should().BeEquivalentTo("ACRM Value");
responseHeaders.GetValues("Access-Control-Allow-Headers").Should().BeEquivalentTo("ACRH Value");
}
private void button6_Click(object sender, EventArgs e)
{
IToken lToken = TokenFactory.CreateToken(WebSocketMessage.NS_SYSTEM_PLUGIN, "int");
lToken.SetInt("data", 5);
mClient.SendToken(lToken, IntegerResponse);
}
private void button7_Click(object sender, EventArgs e)
{
IToken lToken = TokenFactory.CreateToken(WebSocketMessage.NS_SYSTEM_PLUGIN, "double");
lToken.SetDouble("data", 1.3);
mClient.SendToken(lToken, DoubleResponse);
}
private void button8_Click(object sender, EventArgs e)
{
IToken lToken = TokenFactory.CreateToken(WebSocketMessage.NS_SYSTEM_PLUGIN, "bool");
lToken.SetBool("data", true);
mClient.SendToken(lToken, BooleanResponse);
}
public async Task WhenCorsHeadersAreAlreadySetOnTheResponse_LeavesThemAsIs()
{
var client = PipelineFactory.CreateHttpClient(_options, x =>
{
x.Use(async(context, next) =>
{
var hdr = context.Response.Headers;
//hdr.Remove("Access-Control-Allow-Origin");
//hdr.Remove("Access-Control-Allow-Method");
//hdr.Remove("Access-Control-Allow-Headers");
hdr.Add("Access-Control-Allow-Origin", new[] { "ACAO Value" });
hdr.Add("Access-Control-Allow-Method", new[] { "ACAM Value" });
hdr.Add("Access-Control-Allow-Headers", new[] { "ACAH Value" });
await next();
});
});
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken(scope: new string[] { TokenFactory.Api1Scope }));
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
var responseHeaders = result.Headers;
responseHeaders.GetValues("Access-Control-Allow-Origin").Should().BeEquivalentTo("ACAO Value");
responseHeaders.GetValues("Access-Control-Allow-Method").Should().BeEquivalentTo("ACAM Value");
responseHeaders.GetValues("Access-Control-Allow-Headers").Should().BeEquivalentTo("ACAH Value");
}
/// <summary>
/// Tokenize input sentence.
/// </summary>
/// <param name="offset">offset of sentence in original input text</param>
/// <param name="text">sentence to tokenize</param>
/// <returns>list of Token</returns>
List <T> CreateTokenList(int offset, string text)
{
var result = new List <T>();
var lattice = ViterbiBuilder.Build(text);
var bestPath = ViterbiSearcher.Search(lattice);
foreach (var node in bestPath)
{
var wordId = node.WordId;
if (node.Type == ViterbiNode.NodeType.Known && wordId == -1)
{
// Do not include BOS/EOS
continue;
}
var token = TokenFactory.CreateToken(
wordId,
node.Surface,
node.Type,
offset + node.StartIndex,
DictionaryMap[node.Type]
);
result.Add(token);
}
return(result);
}
private void Echo_Click(object sender, RoutedEventArgs e)
{
StatusList.Items.Add("sending echo token..");
var token = TokenFactory.CreateToken(WebSocketTokenClient.NS_SYSTEM_PLUGIN, "echo");
token.SetString("data", EchoMessage.Text);
_webSocketTokenClient.SendTokenText(token);
}
public void CreateHandshakeTokenAsyncTest()
{
string encodedToken = _token.GetEncodedToken();
_restoredSyn = _tokenFactory.CreateToken(encodedToken);
Assert.AreEqual(encodedToken, _restoredSyn.GetEncodedToken());
Assert.AreEqual(_token.PublicKey, _restoredSyn.PublicKey);
Assert.AreEqual(_token.Signature, _restoredSyn.Signature);
}
private void button10_Click(object sender, EventArgs e)
{
IToken lToken = TokenFactory.CreateToken(WebSocketMessage.NS_SYSTEM_PLUGIN, "dictionary");
Dictionary <string, object> lDic = new Dictionary <string, object>();
lDic.Add("data", 6);
lToken.SetDictionary("data", lDic);
mClient.SendToken(lToken, DictResponse);
}
public async Task Token_Sent_With_Unexpected_Audience_And_Audience_Validation_Is_On()
{
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken(audience: "UNEXPECTED_AUDIENCE"));
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public async Task Token_Sent_No_Scope_No_ScopeRequirements()
{
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
private void button9_Click(object sender, EventArgs e)
{
IToken lToken = TokenFactory.CreateToken(WebSocketMessage.NS_SYSTEM_PLUGIN, "list");
List <object> lList = new List <object>();
for (int i = 0; i < 5; i++)
{
lList.Add(i + 1);
}
lToken.SetList("data", lList);
mClient.SendToken(lToken, ListResponse);
}
public async Task Token_Sent_No_Scope_Api1_Api2_ScopeRequirements()
{
_options.RequiredScopes = new[] { TokenFactory.Api1Scope, TokenFactory.Api2Scope };
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task JWT_Sent_No_Scope_No_ScopeRequirements()
{
_options.BackchannelHttpHandler = new DiscoveryEndpointHandler();
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task Token_Sent_Api1_Scope_Api1_ScopeRequirements()
{
_options.RequiredScopes = new[] { TokenFactory.Api1Scope };
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(
TokenFactory.CreateToken(scope: new[] { TokenFactory.Api1Scope }));
client.SetBearerToken(token);
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task JWT_Sent_No_Scope_Api1_ScopeRequirements()
{
_options.BackchannelHttpHandler = new DiscoveryEndpointHandler();
_options.RequiredScopes = new[] { TokenFactory.Api1Scope };
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test")
.ConfigureAwait(false);
result.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public override void ExecuteOperation()
{
if (!ExecuteDomainExistsQuery())
{
CreateDomainCommand().ExecuteNonQuery();
}
Guid newNodeId = Guid.Empty;
CreateNodeCommand(out newNodeId).ExecuteNonQuery();
TransactionToken token = TokenFactory.CreateToken();
token.DelayedExecutionMapObjectId = newNodeId;
ResultTokens.Add(token);
}
public HttpClient CreateAuthenticatedClient(string token = null, string scheme = "Test")
{
if (string.IsNullOrEmpty(token))
{
token = TokenFactory.CreateToken("Test User", Array.Empty <string>());
}
var client = WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
services.AddAuthentication(scheme)
.AddScheme <AuthenticationSchemeOptions, TestAuthenticationHandler>(
scheme, options => { });
});
}).CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(scheme, token);
return(client);
}
public override IEnumerable <Token> Parse(string ETLString, TokenFactory tokenFactory)
{
var strs = SplitString(ETLString);
List <Token> retTokens = new List <Token>(strs.Count());
Regex _matcher;
ExpressionType _type;
foreach (string str in strs)
{
try
{
_type = tokenIdentifiers.First(ti =>
{
_matcher = new Regex(ti.Item1, RegexOptions.IgnoreCase);
return(_matcher.IsMatch(str));
}).Item2;
}
catch (InvalidOperationException ex)
{
throw new InvalidExpressionException($"Unrecognized Token {str}", ex);
}
if (_type.IsOperand())
{
retTokens.Add(tokenFactory.CreateValueToken(_type, Convert.ChangeType(str, ValueExpTypeToValueType[_type])));
}
else if (_type.IsOperator())
{
retTokens.Add(tokenFactory.CreateToken(_type));
}
else if (_type.IsSpecial())
{
retTokens.Add(tokenFactory.CreateSpecialToken(_type));
}
else
{
throw new ArgumentException($"Unrecoginzed Type: {_type.ToString()}");
}
}
return(retTokens);
}
private IAToken GetStringToken(ref int textPos)
{
int startPos = textPos;
textPos++;
while (textPos < _text.Length)
{
if (_text[textPos] == QuoteChar)
{
if (textPos + 1 < _text.Length && _text[textPos + 1] == QuoteChar)
{
textPos += 2;
}
else
{
break;
}
}
else
{
textPos++;
}
}
if (textPos == _text.Length)
{
throw new ATokenizerException(string.Format("Missing terminating quote for string starting at position {0}", startPos));
}
textPos++;
IAToken token = TokenFactory.CreateToken(_text.Substring(startPos, textPos - startPos));
if (ExpandEmptyStrings && token.Text == "''")
{
token.Text = "' '";
}
SetAddSpaceFlag(token, textPos);
return(token);
}
public async Task Token_From_QueryString()
{
var provider = new OAuthBearerAuthenticationProvider
{
OnRequestToken = c =>
{
var qs = c.OwinContext.Request.Query;
c.Token = qs.Get("access_token");
return(Task.FromResult(0));
}
};
_options.TokenProvider = provider;
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
var result = await client.GetAsync("http://test?access_token=" + token);
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task WhenDelayLoadMetadataIsTrue_MetadataRetrievalIsRetriedAfterFailure()
{
_options.BackchannelHttpHandler = new FailureDiscoveryEndpointHandler();
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
Func <Task> action = async() => await client.GetAsync("http://test");
action.
ShouldThrow <InvalidOperationException>().
And.
Message.Should().Contain("IDX10803"); // IDX10803: Unable to create to obtain configuration from: https://discodoc
_options.BackchannelHttpHandler = new DiscoveryEndpointHandler();
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task Valid_Token_With_ValidatingIdentity_Deny_Access()
{
var provider = new OAuthBearerAuthenticationProvider
{
OnValidateIdentity = c =>
{
c.Rejected();
return(Task.FromResult(0));
}
};
_options.TokenProvider = provider;
var client = PipelineFactory.CreateHttpClient(_options);
var token = TokenFactory.CreateTokenString(TokenFactory.CreateToken());
client.SetBearerToken(token);
var result = await client.GetAsync("http://test");
result.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public AddNodeTransactionOperation(SqlConnection connection, TransactionTokenFactory factory)
: base(connection, factory)
{
NewNodeToken = TokenFactory.CreateToken();
ResultTokens.Add(NewNodeToken);
}
public AddRelationshipTransactionOperation(SqlConnection connection, TransactionTokenFactory factory)
: base(connection, factory)
{
ResultTokens.Add(TokenFactory.CreateToken());
}
