private static async Task PerformRequest()
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
return;
}
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "OrdersAPI"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5001/orders");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine("Ok!");
}
}
static async Task Main(string[] args)
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "Client1",
ClientSecret = "secret1",
Scope = "api2"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("Hello World!");
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5005/api/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
//Console.WriteLine(JArray.Parse(content));
}
}
private static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
DiscoveryResponse disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
TokenResponse tokenResponse = await GetCredentialToken(client, disco);
if (tokenResponse == null)
{
return;
}
await GetPasswordResourceToken(client, disco);
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
HttpResponseMessage response = await apiClient.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
/// <summary>
/// 根据用户名+密码获取token
/// </summary>
/// <returns></returns>
private static async Task <string> GetAccessToken()
{
var client = new HttpClient();
// 获取导航文件
DiscoveryDocumentResponse disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return("");
}
// 客户端凭证模式获取token
var request = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "resourceOwnerPwd.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
//Scope = "MyApiResourceScope1",//欲进入的资源域，不指定则为ids中为该客户端配置的允许访问的所有资源域；指定的话，则获取到的token只能用来进入指定的资源域
};
TokenResponse tokenResponse = await client.RequestPasswordTokenAsync(request);
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return("");
}
Console.WriteLine("token:");
Console.WriteLine(tokenResponse.Json);
return(tokenResponse.AccessToken);
}
static async Task Main(string[] args)
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:44350");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "AF8754D8-796C-456F-91DF-1B0D21EB085E",
ClientSecret = "testtest",
Scope = "Tenogy.Api:Access2"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
// call api
client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
await CallApi(client, "access");
await CallApi(client, "scopes/scope");
await CallApi(client, "scopes/scope1");
await CallApi(client, "scopes/scope2");
}
static async Task Main(string[] args)
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:44330");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "platformApiClient",
ClientSecret = "SuperSecretPassword",
Scope = "quasar.read:*/*"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
var factory = new ConnectionFactory {
Password = tokenResponse.AccessToken
};
// "guest"/"guest" by default, limited to localhost connections
var conn = factory.CreateConnection();
Console.WriteLine(tokenResponse.Json);
Console.Read();
}
static void Main(string[] args)
{
var client = new HttpClient();
var disco = client.GetDiscoveryDocumentAsync("https://localhost:5000").Result;
if (!disco.IsError)
{
var token = client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest()
{
Address = disco.TokenEndpoint,
ClientId = "apiClient",
ClientSecret = "secret",
Scope = "api1"
}).Result;
if (!token.IsError)
{
Console.WriteLine(token.Json);
client = new HttpClient();
client.SetBearerToken(token.AccessToken);
var response = client.GetAsync("https://localhost:5001/api/identity").Result;
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(JArray.Parse(content));
}
}
}
Console.ReadLine();
}
static async Task Main(string[] args)
{
var protocolClient = new HttpClient();
var disco = await protocolClient.GetDiscoveryDocumentAsync("https://demo.identityserver.io");
if (disco.IsError)
{
throw new Exception(disco.Error);
}
var tokenResponse = await protocolClient.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret"
});
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
Console.WriteLine(await apiClient.GetStringAsync("http://localhost:3308/test"));
}
static async Task <TokenResponse> RequestTokenAsync()
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(Constants.Authority);
if (disco.IsError)
{
throw new Exception(disco.Error);
}
var response = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "54aafa4c-c720-447c-a60a-0e5ccd14782d",
ClientSecret = "wQJb1xk26WEKlVAT8js4IOI36CLXKAKj0o1Urfnx"
});
if (response.IsError)
{
throw new Exception(response.Error);
}
return(response);
}
private static async Task <string> GetAccessToken()
{
var httpClient = new HttpClient();
var openIdConnectEndPoint = await httpClient.GetDiscoveryDocumentAsync("https://localhost:5000");
var accessToken = await httpClient.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = openIdConnectEndPoint.TokenEndpoint,
ClientId = "oauthClient",
ClientSecret = "SuperSecretPassword",
Scope = "api1.read",
});
if (accessToken.IsError)
{
Console.WriteLine(accessToken.Error);
return(accessToken.Error);
}
Console.WriteLine(accessToken.Json);
return(accessToken.AccessToken);
}
private static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(IdpUri); // IDP
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "######",
ClientSecret = "#####",
Scope = "######"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
var token = tokenResponse.AccessToken;
var apiClient = new HttpClient();
apiClient.SetBearerToken(token);
// GET Location lockers
var response = await apiClient.GetAsync($"{ApiUri}/api/e-commerce/location/locker"); // API
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
var lockers = JsonConvert.DeserializeObject <IEnumerable <ECommerceLocationLockersModel> >(content);
var locker = lockers.FirstOrDefault();
Console.WriteLine(locker?.LockerNumber);
var order = await LoadLocker(locker?.QrCode, "SAMPle Order No", "Sample User Id", token);
if (order == null)
{
return;
}
Console.WriteLine(order.OtpCode, order.OrderId);
var confirm = await Confirm(order.OrderId, token);
if (confirm == null)
{
return;
}
Console.WriteLine(confirm.ConfirmLink, confirm.DeliveryNumber, confirm.LockerNumber, token);
}
}
private static async Task MainAsync()
{
// discover Identity Server 4's endpoints via its discovery document
var client = new HttpClient(); // Note: Both DiscoveryClient and TokenClient were deprecated
DiscoveryDocumentResponse disco = await client.GetDiscoveryDocumentAsync(IdendityServer4Address);
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return; // without "discovery document" we can not go on
}
// obtain the access token, for this client
TokenResponse tokenResponse = await client.RequestClientCredentialsTokenAsync(
new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "WebAPI"
}
);
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return; // without "access token" we can not go on
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// Ready to consume the WebAPI
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var customerInfo = new StringContent( // construct the payload for adding new customer
JsonConvert.SerializeObject(
new
{
Id = 12,
FirstName = "Kenny",
LastName = "Doe"
}),
Encoding.UTF8,
"application/json");
// post to the WebAPI to add new customer
HttpResponseMessage createCustomerResponse = await apiClient.PostAsync(WebApiEndPoint, customerInfo);
if (!createCustomerResponse.IsSuccessStatusCode)
{
Console.WriteLine(createCustomerResponse.StatusCode);
}
else
{
Console.WriteLine("Added new Custeromer");
}
// from the WebAI, get a list of the customers
HttpResponseMessage getCustomerReponse = await apiClient.GetAsync(WebApiEndPoint);
if (!getCustomerReponse.IsSuccessStatusCode)
{
Console.WriteLine(getCustomerReponse.StatusCode);
}
else
{
string content = await getCustomerReponse.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.ReadLine();
}
private static async Task Main()
{
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
//System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12 | System.Net.SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
//clientHandler.cert
//var cert = new X509Certificate2("fred.pfx", "apples");
HttpClientHandler handler = new HttpClientHandler();
X509Certificate2 certificate = new X509Certificate2("certificate.pfx", "secret");
handler.ClientCertificates.Add(certificate);
if (certificate == null)
{
Console.WriteLine("certificado ta nulo");
}
handler.ClientCertificates.Add(certificate);
//HttpClient client = new HttpClient(handler);
// discover endpoints from metadata
var client = new HttpClient(clientHandler);
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "43253244523456",
ClientSecret = "secret6",
Scope = "Enfermeiro"
});
//tokenResponse.AccessToken.c
Console.WriteLine(tokenResponse.ToString());
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient(clientHandler);
apiClient.SetBearerToken(tokenResponse.AccessToken);
//apiClient.
var response = await apiClient.GetAsync("https://localhost:6001/Funcionario/Consultas13145232242");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine("Deu certo????");
Console.WriteLine(content);
Console.WriteLine(JsonConvert.DeserializeObject(content));
}
}
static void Main(string[] args)
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = client.GetDiscoveryDocumentAsync("http://localhost:5000").Result;
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
}).Result;
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
// request token
tokenResponse = client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
}).Result;
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
// call api
client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = client.GetAsync("http://localhost:5001/identity").Result;
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(JArray.Parse(content));
}
}
static async System.Threading.Tasks.Task Main(string[] args)
{
var errorState = true;
var disco = new DiscoveryDocumentResponse();
// discover endpoints from metadata
var client = new HttpClient();
while (errorState)
{
disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
Console.ReadKey();
}
else
{
errorState = false;
Console.WriteLine("Done");
}
}
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine("Token Response Done");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
try
{
var response = await apiClient.GetAsync("https://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine(tokenResponse.Json);
}
catch (Exception ex)
{
}
}
static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(new DiscoveryDocumentRequest
{
Address = "https://identity.website.com:5001",
Policy = { RequireHttps = false }
});
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
string baseUrl = "https://api.website.com:5003";
// call authorized identity
var response = await apiClient.GetAsync(baseUrl + "/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
// call authorized controller
response = await apiClient.GetAsync(baseUrl + "/cake");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
// call unauthorized controller
response = await apiClient.GetAsync(baseUrl + "/weatherforecast");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
private static async Task Main(string[] args)
{
Console.WriteLine("Diligent Entities API App - Copyright 2020");
Console.WriteLine("\n");
// test input arguments were supplied
if (args.Length != 2 || args[0] != "--RefreshToken")
{
Console.WriteLine("Please pass a refresh token.");
Console.WriteLine("\n");
return;
}
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://ids-dev11.blueprintserver.com/ngdev-60");
if (disco.IsError)
{
Console.WriteLine("Discovery error : " + disco.Error);
Console.WriteLine("\n");
return;
}
// exchange refresh token
var refreshToken = args[1];
Console.WriteLine("Refresh Token entered: " + refreshToken);
Console.WriteLine("\n");
var tokenResponse = await client.RequestRefreshTokenAsync(new RefreshTokenRequest
{
Address = "https://ids-dev11.blueprintserver.com/ngdev-60/connect/token",
ClientId = "public.api",
ClientSecret = "87d19a99040284d433e9becd800670d1ec8bbd5dfcec9df724cfd901dfc602b9",
RefreshToken = refreshToken
});;
if (tokenResponse.IsError)
{
Console.WriteLine("Token error: " + tokenResponse.Error);
Console.WriteLine("\n");
return;
}
// BTL Console.WriteLine(tokenResponse.Json);
Console.WriteLine("Access Token exchanged: " + tokenResponse.AccessToken);
Console.WriteLine("\n");
Console.WriteLine("New Refresh Token: " + tokenResponse.RefreshToken);
Console.WriteLine("\n");
// call api
var apiClient = new HttpClient();
try
{
apiClient.DefaultRequestHeaders.Add("Tenant-Id", "ngdev-60");
apiClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + tokenResponse.AccessToken);
var options = new JsonWriterOptions
{
Indented = true
};
// format payload
using (var stream = new MemoryStream())
{
using (var writer = new Utf8JsonWriter(stream, options))
{
writer.WriteStartObject();
writer.WriteStartArray("sortCriteria");
writer.WriteEndArray();
writer.WriteStartArray("groupCriteria");
writer.WriteEndArray();
writer.WriteStartArray("searchCriteria");
writer.WriteEndArray();
writer.WriteStartArray("columns");
writer.WriteEndArray();
writer.WriteStartObject("parameters");
writer.WriteEndObject();
writer.WriteNumber("filterCombinator", 0);
writer.WriteNumber("pageSize", 10);
writer.WriteNumber("pageNumber", 0);
writer.WriteEndObject();
}
string json = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine("Payload: " + json);
Console.WriteLine("\n");
var content = new StringContent(json, Encoding.UTF8, "application/json");
var httpResponseMessage = await apiClient.PostAsync(
"https://dil-as-test.azure-api.net/entities/nextgen/companies/search",
content);
string resp = await httpResponseMessage.Content.ReadAsStringAsync();
Console.WriteLine("Summary: Companies refreshed");
Console.WriteLine("\n");
Console.WriteLine("Response: " + resp);
Console.WriteLine("\n");
}
}
catch (Exception ex)
{
Console.WriteLine("Caught exception : " + ex);
Console.WriteLine("\n");
}
}
static async Task Main()
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
//var apiTokenResponse = await client.RequestClientCredentialsTokenAsync(
// new ClientCredentialsTokenRequest
// {
// Address = disco.TokenEndpoint,
// ClientId = "client",
// ClientSecret = "511536EF-F270-4058-80CA-1C89C192F69A",
// Scope = "scope1"
// });
//if (apiTokenResponse.IsError)
//{
// Console.WriteLine(apiTokenResponse.Error);
// return;
//}
//var apiClient = new HttpClient();
//apiClient.SetBearerToken(apiTokenResponse.AccessToken);
//var response = await apiClient.GetAsync("https://localhost:6001/identity");
//if (!response.IsSuccessStatusCode)
//{
// Console.WriteLine(response.StatusCode);
//}
//else
//{
// var content = await response.Content.ReadAsStringAsync();
// Console.WriteLine(JArray.Parse(content));
//}
var passwordTokenResponse = await client.RequestPasswordTokenAsync(
new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "password",
ClientSecret = "511536EF-F270-4058-80CA-1C89C192F69A",
Scope = "scope1 openid profile",
UserName = "******",
Password = "******"
});
if (passwordTokenResponse.IsError)
{
Console.WriteLine(passwordTokenResponse.IsError);
return;
}
var passwordClient = new HttpClient();
passwordClient.SetBearerToken(passwordTokenResponse.AccessToken);
var response = await passwordClient.GetAsync(disco.UserInfoEndpoint);
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
Console.ReadKey();
}
static async Task Start()
{
try
{
using (var client = new HttpClient())
{
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
var tokenResource = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "clientid",
ClientSecret = "secret",
Scope = "myApi"
});
if (tokenResource.IsError)
{
Console.WriteLine(tokenResource.Error);
return;
}
Console.WriteLine(tokenResource.Json);
await Send(tokenResource.AccessToken);
async Task Send(string token)
{
using (var client2 = new HttpClient())
{
client2.SetBearerToken(token);
var response = await client2.GetAsync($"http://localhost:5001/api/values/{DateTime.Now.ToString("yyyyMMddHHmmss")}");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
return;
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine($"result:{content}");
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine($"There was an exception: {ex.ToString()}");
}
}
public static async Task Main(string[] args)
{
Console.WriteLine("Hello Console!");
// DISCO - Discovery Endpoint
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(new DiscoveryDocumentRequest
{
Address = "http://host.docker.internal:5000",
Policy = { RequireHttps = false }
});
if (disco.IsError)
{
Console.WriteLine(disco.Error);
Console.ReadKey(true);
return;
}
// Richiesta dell'AccessToken passando i parametri richiesti, usando il client M2M
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "m2m-client",
ClientSecret = "thisissosecret",
Scope = "user.basic",
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
Console.ReadKey(true);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// Richiesta dell'API usando l'AccessToken come Authorization nell'header
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
// microservice 1
var response = await apiClient.GetAsync("http://localhost:15100/numbers/random");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
Console.WriteLine("\n\n");
// microservice 2
response = await apiClient.GetAsync("http://localhost:15200/strings/hello");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
Console.WriteLine("\n\n");
// microservice 2 - claims
response = await apiClient.GetAsync("http://localhost:15200/claims");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
Console.ReadKey(true);
}
static async Task Run()
{
await Task.Delay(10000);
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token resource owner flow
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "Chat"
});
// request token client credential flow
//var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
//{
// Address = disco.TokenEndpoint,
// ClientId = "netClient",
// ClientSecret = "secret",
// Scope = "Chat"
//});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("https://localhost:5002/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
var c = new HubConnectionBuilder()
.WithUrl("https://localhost:5002/chat", config => {
config.AccessTokenProvider = () => Task.FromResult(tokenResponse.AccessToken);
})
.Build();
c.Closed += C_Closed;
c.On <string>("Echo", m => Console.WriteLine(m));
await c.StartAsync();
try
{
await c.SendAsync("Echo", "Hallo Echo");
var e = await c.InvokeAsync <string>("Echo2", "Hallo Echo2");
Console.WriteLine(e);
}
catch (Exception e)
{
throw;
}
await Task.Delay(5000);
await c.StopAsync();
}
static private async Task <DiscoveryDocumentResponse> GetDiscoveryDoc(HttpClient client)
{
return(await client.GetDiscoveryDocumentAsync("https://localhost:5001"));
}
static async Task Main(string[] args)
{
string baseAddress = "https://localhost:6001";
Console.WriteLine("App Start");
DiscoveryDocumentResponse disco;
// discover endpoints from metadata
{
var client = new HttpClient();
disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
}
// client.AccessTokenType = AccessTokenType.Reference;
// request token
{
var client = new HttpClient();
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
//setRequestHeader("Authorization", "Bearer " + user.access_token);
var accessToken = tokenResponse.Json["access_token"].ToString();
// WeatherForecast
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
var weatherGet = await client.GetStringAsync(baseAddress + "/WeatherForecast");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, baseAddress + "/identity");
request.Headers.Add("Authorization", new List <string>()
{
"Bearer " + accessToken
});
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var resp = await client.SendAsync(request);
var identityGet = await client.GetStringAsync(baseAddress + "/identity");
Console.WriteLine($"GET: {identityGet}");
}
{
var client = new HttpClient();
var tokenResponse2 = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
Password = "******",
UserName = "******",
Scope = "api1",
ClientId = "ro.client",
ClientSecret = "secret"
});
if (tokenResponse2.IsError)
{
Console.WriteLine(tokenResponse2.Error);
return;
}
Console.WriteLine(tokenResponse2.Json);
Console.WriteLine("\n\n");
}
{
var client = new HttpClient();
var tokenResponse3 = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client11",
ClientSecret = "secret11",
Scope = "api1"
});
if (tokenResponse3.IsError)
{
Console.WriteLine(tokenResponse3.Error);
return;
}
Console.WriteLine(tokenResponse3.Json);
}
{
var client4 = new HttpClient();
//reference token
var tokenResponse4 = await client4.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
Password = "******",
UserName = "******",
Scope = "api1",
ClientId = "ro.client2",
ClientSecret = "secret"
});
if (tokenResponse4.IsError)
{
Console.WriteLine(tokenResponse4.Error);
return;
}
Console.WriteLine(tokenResponse4.Json);
Console.WriteLine("\n\n");
var accessToken4 = tokenResponse4.Json["access_token"].ToString();
// WeatherForecast
// client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
var weatherGet4 = await client4.GetStringAsync(baseAddress + "/WeatherForecast");
HttpRequestMessage request4 = new HttpRequestMessage(HttpMethod.Get, baseAddress + "/identity");
request4.Headers.Add("Authorization", new List <string>()
{
"Bearer " + accessToken4
});
request4.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken4);
var resp4 = await client4.SendAsync(request4);
client4.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken4);
var identityGet4 = await client4.GetStringAsync(baseAddress + "/identity");
Console.WriteLine($"GET: {identityGet4}");
}
}
private static async Task RunDemo()
{
var client = new HttpClient();
// discover endpoints from metadata
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:8001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest()
{
Address = disco.TokenEndpoint,
ClientId = "client1",
ClientSecret = "123qwe",
//Scope = "api1,AuthServerApi",
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("访问Api1");
// call api
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:8003/api/values");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
Console.WriteLine("访问Api2");
response = await client.GetAsync("http://localhost:8004/api/values");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
}
static async Task Main(string[] args)
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// user password
var tokenPasswordTokenAsync = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "intro",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenPasswordTokenAsync.IsError)
{
Console.WriteLine(tokenPasswordTokenAsync.Error);
return;
}
Console.WriteLine(tokenPasswordTokenAsync.Json);
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
// call api
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5001/weatherforecast");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
private static async Task MainAsync()
{
var client = new HttpClient();
string token = "";
var uri = new Uri("http://localhost:5000/loginapi");
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(new LoginApiDto
{
Username = "******",
Password = "******"
}));
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var resp = await client.PostAsync(uri, httpContent);
if (resp.IsSuccessStatusCode)
{
token = await resp.Content.ReadAsStringAsync();
}
Console.WriteLine(token);
var apiClient2 = new HttpClient();
var apiResponse2 = await apiClient2.GetAsync("http://localhost:5000/protected");
if (!apiResponse2.IsSuccessStatusCode)
{
Console.WriteLine(apiResponse2.StatusCode);
}
else
{
var content = await apiResponse2.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
apiClient2 = new HttpClient();
apiClient2.SetBearerToken(token);
apiResponse2 = await apiClient2.GetAsync("http://localhost:5000/protected");
if (!apiResponse2.IsSuccessStatusCode)
{
Console.WriteLine(apiResponse2.StatusCode);
}
else
{
var content = await apiResponse2.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
// discover endpoints from the metadata by calling Auth server hosted on 5000 port
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request the token from the Auth server
var response = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (response.IsError)
{
Console.WriteLine(response.Error);
return;
}
Console.WriteLine(response.Json);
Console.WriteLine(response.RefreshToken);
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(response.AccessToken);
var apiResponse = await apiClient.GetAsync("http://localhost:5000/protected");
if (!apiResponse.IsSuccessStatusCode)
{
Console.WriteLine(apiResponse.StatusCode);
}
else
{
var content = await apiResponse.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.Write($"\n\nShould get unauthorized error:\n");
// call api
apiClient = new HttpClient();
apiResponse = await apiClient.GetAsync("http://localhost:5000/api/identity");
if (!apiResponse.IsSuccessStatusCode)
{
Console.WriteLine(apiResponse.StatusCode);
}
else
{
var content = await apiResponse.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
// -----------------------------------------------------------------
// Resource owner auth
Console.WriteLine("------------------------------");
Console.WriteLine("password auth");
Console.WriteLine("------------------------------");
// request token
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
}
private static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token with ClientCredentials
//var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
//{
// Address = disco.TokenEndpoint,
// ClientId = "client",
// ClientSecret = "secret",
// Scope = "api1"
//});
// request token with resource owner credentials
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.ReadLine();
}
public static async Task MainAsync(string[] args)
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine("------------Token Error---------------------");
Console.WriteLine(disco.Error);
return;
}
// request token
//var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
//{
// Address = disco.TokenEndpoint,
// ClientId = "client",
// ClientSecret = "secret",
// Scope = "api1"
//});
// request token
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine("------------Token Response---------------------");
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:5001/api/items");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine("------------Items api error---------------------");
var error = await response.Content.ReadAsStringAsync();
Console.WriteLine(response.StatusCode);
Console.WriteLine(error);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine("------------Items api response----------------------");
Console.WriteLine(JObject.Parse(content));
}
var stringContent = new StringContent("", UnicodeEncoding.UTF8, "application/json");
var responseBuy = await apiClient.PostAsync("http://localhost:5001/api/items/5/buy", stringContent);
if (!responseBuy.IsSuccessStatusCode)
{
var error = await responseBuy.Content.ReadAsStringAsync();
Console.WriteLine("------------Buy api error---------------------");
Console.WriteLine(responseBuy.StatusCode);
Console.WriteLine(error);
}
else
{
var content = await responseBuy.Content.ReadAsStringAsync();
Console.WriteLine("------------Buy api response---------------------");
Console.WriteLine(JObject.Parse(content));
}
}
private static async Task Main()
{
try
{
// discover endpoints from metadata
var client = new HttpClient();
//var ids4Url = "http://101.200.182.225:53362";
//// discover endpoints from metadata
//var discoveryClient = new DiscoveryClient(ids4Url) { Policy = { RequireHttps = false } };
//var disco = await discoveryClient.GetAsync();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:53362");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
//request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "business-app",
ClientSecret = "1q2w3e*",
Scope = "InternalGateway BaseService"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
//// call api
//var apiClient = new HttpClient();
//apiClient.SetBearerToken(tokenResponse.AccessToken);
//var response = await apiClient.GetAsync("http://localhost:51186/api/app/cs-machine-shift-report");
//if (!response.IsSuccessStatusCode)
//{
// Console.WriteLine(response.StatusCode);
//}
//else
//{
// //var content = await response.Content.ReadAsStringAsync();
// ////Console.WriteLine(content);
// //string baseAddr = "http://localhost:51186";
// //string path = "http://localhost:51186/BusinessService"; //"Bearer " + tokenResponse.AccessToken;
// //string auth = "Bearer " + tokenResponse.AccessToken;
// //HttpFactory httpFactory = new HttpFactory();
// //AbsHttpHelper helper = httpFactory.CreateHttpHelper("post", baseAddr, auth, path, true, null);
// //string rs = helper.GetResult();
// //Console.WriteLine(rs);
//}
using (var httpClient = new HttpClient())
{
httpClient.SetBearerToken(tokenResponse.AccessToken);
var response1 = await httpClient.GetAsync("http://localhost:51186/api/business/lt-machine-shift-report");
//var response1 = await httpClient.GetAsync("http://localhost:51186/api/business/lt-machine-shift-report");
if (response1.IsSuccessStatusCode)
{
System.Console.WriteLine(await response1.Content.ReadAsStringAsync());
}
else
{
Console.WriteLine(response1.StatusCode);
}
}
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
static async Task Main(string[] args)
{
var client = new HttpClient();
var discoveryResponse = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (discoveryResponse.IsError)
{
Console.WriteLine(discoveryResponse.Error);
return;
}
await ROpasswordAndClientCredentialsExample(client, discoveryResponse);
var resourceOwnerPasswordResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
ClientId = "ResourceOwnerPassword",
ClientSecret = "secret",
GrantType = "password",
UserName = "******",
Password = "******",
Scope = "profile"
});
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
var validatedToken = Validate(tokenResponse.AccessToken);
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:6001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
