public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args)
.ConfigureApi((context, options) =>
{
ApiKeyToken apiKeyToken = new ApiKeyToken(context.Configuration["<token>"], timeout: TimeSpan.FromSeconds(1));
options.AddTokens(apiKeyToken);
BearerToken bearerToken = new BearerToken(context.Configuration["<token>"], timeout: TimeSpan.FromSeconds(1));
options.AddTokens(bearerToken);
BasicToken basicToken = new BasicToken(context.Configuration["<username>"], context.Configuration["<password>"], timeout: TimeSpan.FromSeconds(1));
options.AddTokens(basicToken);
HttpSigningConfiguration config = new HttpSigningConfiguration("<keyId>", "<keyFilePath>", null, new List <string>(), HashAlgorithmName.SHA256, "<signingAlgorithm>", 0);
HttpSignatureToken httpSignatureToken = new HttpSignatureToken(config, timeout: TimeSpan.FromSeconds(1));
options.AddTokens(httpSignatureToken);
OAuthToken oauthToken = new OAuthToken(context.Configuration["<token>"], timeout: TimeSpan.FromSeconds(1));
options.AddTokens(oauthToken);
});
static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
Console.WriteLine($"usage: ApiKeyGenerator.exe {{client id}} {{tag}} {{tag}} {{tag}} {{tag}}");
return;
}
TokenHelper.AddKeyFile("APIKEY", @"E:\BlogWork\MeetUp.ApiTokenDemo\APIKEY-PRIVATE.xml");
ApiKeyToken apikey = TokenHelper.CreateToken <ApiKeyToken>();
apikey.ExpireDate = DateTime.Now.AddYears(1);
apikey.ClientID = args[0];
apikey.Tags = args.Skip(1).ToArray();
Console.WriteLine("API KEY Generated:");
Console.WriteLine(TokenHelper.EncodeToken("APIKEY", apikey));
}
//public void Post([FromBody]string value)
public IHttpActionResult Post()
{
string apikey = this.Request.Headers.GetValues("X-APIKEY").First();
ApiKeyToken apikeyToken = TokenHelper.DecodeToken <ApiKeyToken>("APIKEY", apikey);
SessionToken sessionToken = TokenHelper.CreateToken <SessionToken>();
sessionToken.ClientID = apikeyToken.ClientID;
sessionToken.UserHostAddress = System.Web.HttpContext.Current.Request.UserHostAddress;
sessionToken.CreateDate = DateTime.Now;
sessionToken.ExpireDate = DateTime.Now.AddHours(1.0);
sessionToken.EnableAdminFunction = false;
sessionToken.EnableMemberFunction = !apikeyToken.Tags.Contains("BAD");
sessionToken.EnableVIPFunction = apikeyToken.Tags.Contains("VIP");
return(new TokenTextResult("SESSION", sessionToken));
//return TokenHelper.EncodeToken("SESSION", sessionToken);
//return this.Ok<string>(TokenHelper.EncodeToken("SESSION", sessionToken));
//return this.Content<string>(HttpStatusCode.OK, TokenHelper.EncodeToken("SESSION", sessionToken));
}
public async Task <ApiResponse <Dictionary <string, int>?> > GetInventoryWithHttpInfoAsync(System.Threading.CancellationToken?cancellationToken = null)
{
try
{
using (HttpRequestMessage request = new HttpRequestMessage())
{
UriBuilder uriBuilder = new UriBuilder();
uriBuilder.Host = HttpClient.BaseAddress !.Host;
uriBuilder.Scheme = ClientUtils.SCHEME;
uriBuilder.Path = ClientUtils.CONTEXT_PATH + "/store/inventory";
List <TokenBase> tokens = new List <TokenBase>();
ApiKeyToken apiKey = (ApiKeyToken)await ApiKeyProvider.GetAsync(cancellationToken).ConfigureAwait(false);
tokens.Add(apiKey);
apiKey.UseInHeader(request, "api_key");
request.RequestUri = uriBuilder.Uri;
string[] accepts = new string[] {
"application/json"
};
string?accept = ClientUtils.SelectHeaderAccept(accepts);
if (accept != null)
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(accept));
}
request.Method = HttpMethod.Get;
using (HttpResponseMessage responseMessage = await HttpClient.SendAsync(request, cancellationToken.GetValueOrDefault()).ConfigureAwait(false))
{
DateTime requestedAt = DateTime.UtcNow;
string responseContent = await responseMessage.Content.ReadAsStringAsync(cancellationToken.GetValueOrDefault()).ConfigureAwait(false);
if (ApiResponded != null)
{
try
{
ApiResponded.Invoke(this, new ApiResponseEventArgs(requestedAt, DateTime.UtcNow, responseMessage.StatusCode, "/store/inventory"));
}
catch (Exception e)
{
Logger.LogError(e, "An error occured while invoking ApiResponded.");
}
}
ApiResponse <Dictionary <string, int>?> apiResponse = new ApiResponse <Dictionary <string, int>?>(responseMessage, responseContent);
if (apiResponse.IsSuccessStatusCode)
{
apiResponse.Content = Newtonsoft.Json.JsonConvert.DeserializeObject <Dictionary <string, int> >(apiResponse.RawContent, ClientUtils.JsonSerializerSettings);
}
else if (apiResponse.StatusCode == (HttpStatusCode)429)
{
foreach (TokenBase token in tokens)
{
token.BeginRateLimit();
}
}
return(apiResponse);
}
}
}
catch (Exception e)
{
Logger.LogError(e, "An error occured while sending the request to the server.");
throw;
}
}
public async Task <ApiResponse <ModelClient?> > TestClassnameWithHttpInfoAsync(ModelClient modelClient, System.Threading.CancellationToken?cancellationToken = null)
{
try
{
#pragma warning disable CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
if (modelClient == null)
{
throw new ArgumentNullException(nameof(modelClient));
}
#pragma warning disable CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
using (HttpRequestMessage request = new HttpRequestMessage())
{
UriBuilder uriBuilder = new UriBuilder();
uriBuilder.Host = HttpClient.BaseAddress !.Host;
uriBuilder.Scheme = ClientUtils.SCHEME;
uriBuilder.Path = ClientUtils.CONTEXT_PATH + "/fake_classname_test";
System.Collections.Specialized.NameValueCollection parseQueryString = System.Web.HttpUtility.ParseQueryString(string.Empty);
if ((modelClient as object) is System.IO.Stream stream)
{
request.Content = new StreamContent(stream);
}
else
{
// request.Content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(modelClient, ClientUtils.JsonSerializerSettings));
request.Content = new StringContent(System.Text.Json.JsonSerializer.Serialize(modelClient, ClientUtils.JsonSerializerOptions));
}
List <TokenBase> tokens = new List <TokenBase>();
ApiKeyToken apiKey = (ApiKeyToken)await ApiKeyProvider.GetAsync(cancellationToken).ConfigureAwait(false);
tokens.Add(apiKey);
apiKey.UseInQuery(request, uriBuilder, parseQueryString, "api_key_query");
uriBuilder.Query = parseQueryString.ToString();
request.RequestUri = uriBuilder.Uri;
string[] contentTypes = new string[] {
"application/json"
};
string?contentType = ClientUtils.SelectHeaderContentType(contentTypes);
if (contentType != null)
{
request.Content.Headers.Add("ContentType", contentType);
}
string[] accepts = new string[] {
"application/json"
};
string?accept = ClientUtils.SelectHeaderAccept(accepts);
if (accept != null)
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(accept));
}
request.Method = HttpMethod.Patch;
using (HttpResponseMessage responseMessage = await HttpClient.SendAsync(request, cancellationToken.GetValueOrDefault()).ConfigureAwait(false))
{
DateTime requestedAt = DateTime.UtcNow;
string responseContent = await responseMessage.Content.ReadAsStringAsync(cancellationToken.GetValueOrDefault()).ConfigureAwait(false);
if (ApiResponded != null)
{
try
{
ApiResponded.Invoke(this, new ApiResponseEventArgs(requestedAt, DateTime.UtcNow, responseMessage.StatusCode, "/fake_classname_test"));
}
catch (Exception e)
{
Logger.LogError(e, "An error occured while invoking ApiResponded.");
}
}
ApiResponse <ModelClient?> apiResponse = new ApiResponse <ModelClient?>(responseMessage, responseContent);
if (apiResponse.IsSuccessStatusCode)
{
apiResponse.Content = System.Text.Json.JsonSerializer.Deserialize <ModelClient>(apiResponse.RawContent, ClientUtils.JsonSerializerOptions);
}
else if (apiResponse.StatusCode == (HttpStatusCode)429)
{
foreach (TokenBase token in tokens)
{
token.BeginRateLimit();
}
}
return(apiResponse);
}
}
}
catch (Exception e)
{
Logger.LogError(e, "An error occured while sending the request to the server.");
throw;
}
}
