public static void ImportDiscoveries()
{
XDocument xmlDoc = LoadXmlFile("discoveries");
var discoveries = xmlDoc.Root.Elements();
List <DiscoveryDto> discoveriesDto = new List <DiscoveryDto>();
foreach (XElement discovery in discoveries)
{
var discoveryDto = new DiscoveryDto()
{
DateMade = discovery.Attribute("DateMade")?.Value,
Telescope = discovery.Attribute("Telescope")?.Value,
Stars = discovery.Element("Stars")
.Elements()
.Select(e => e?.Value)
.ToList(),
Planets = discovery.Element("Planets")
.Elements()
.Select(e => e?.Value)
.ToList(),
Pioneers = discovery.Element("Pioneers")
.Elements()
.Select(e => e?.Value)
.ToList(),
Observers = discovery.Element("Observers")
.Elements()
.Select(e => e?.Value)
.ToList()
};
discoveriesDto.Add(discoveryDto);
}
DiscoveryStore.AddDiscoveries(discoveriesDto);
}
//public async Task Transfer(DiscoveryDto transferDto)
//{
// try
// {
// var uri = "https://localhost:44357/api/Banking";
// var transferContent = new StringContent(JsonConvert.SerializeObject(transferDto),
// System.Text.Encoding.UTF8, "application/json");
// var response = await _apiClient.PostAsync(uri, transferContent);
// response.EnsureSuccessStatusCode();
// }
// catch (Exception ex)
// {
// throw;
// }
//}
public async Task Discovery(DiscoveryDto transferDto)
{
try
{
var uri = "https://localhost:44357/api/Discovery";
for (int i = 0; i < transferDto.noOfAssetScanReq; i++)
{
var discoveryInfo = new DiscoveryInfo()
{
Id = Guid.NewGuid().ToString(), ScanType = "Asset"
};
var transferContent = new StringContent(JsonConvert.SerializeObject(discoveryInfo),
System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, transferContent);
response.EnsureSuccessStatusCode();
}
for (int i = 0; i < transferDto.noOfAccountScanReq; i++)
{
var discoveryInfo = new DiscoveryInfo()
{
Id = Guid.NewGuid().ToString(), ScanType = "Account"
};
var transferContent = new StringContent(JsonConvert.SerializeObject(discoveryInfo),
System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, transferContent);
response.EnsureSuccessStatusCode();
}
for (int i = 0; i < transferDto.noOfBothScanReq; i++)
{
var discoveryInfo = new DiscoveryInfo()
{
Id = Guid.NewGuid().ToString(), ScanType = "Both"
};
var transferContent = new StringContent(JsonConvert.SerializeObject(discoveryInfo),
System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, transferContent);
response.EnsureSuccessStatusCode();
}
}
catch (Exception ex)
{
throw;
}
}
//public async Task<IActionResult> Transfer(TransferViewModel model)
//{
// TransferDto transferDto = new TransferDto()
// {
// FromAccount = model.FromAccount,
// ToAccount = model.ToAccount,
// TransferAmount = model.TransferAmount
// };
// await _transferService.Transfer(transferDto);
// return View("Index");
//}
public async Task <IActionResult> Discovery(DiscoveryViewModel model)
{
DiscoveryDto transferDto = new DiscoveryDto()
{
noOfAccountScanReq = model.noOfAccountScanReq,
noOfAssetScanReq = model.noOfAssetScanReq,
noOfBothScanReq = model.noOfBothScanReq
};
await _transferService.Discovery(transferDto);
return(View("Index"));
}
private static ICollection <Planet> GetPlanets(DiscoveryDto discovery, PlanetHuntersContext context)
{
var planets = new HashSet <Planet>();
foreach (var planet in discovery.Planets)
{
var currPlanet = PlanetStore.GetPlanetByName(planet, context);
if (currPlanet != null)
{
planets.Add(currPlanet);
}
}
return(planets);
}
private static ICollection <Star> GetStars(DiscoveryDto discovery, PlanetHuntersContext context)
{
var stars = new HashSet <Star>();
foreach (var star in discovery.Stars)
{
var currStar = StarStore.GetStarByName(star, context);
if (currStar != null)
{
stars.Add(currStar);
}
}
return(stars);
}
public async Task <IHttpActionResult> GetConfiguration()
{
Logger.Info("Start discovery request");
if (!_options.Endpoints.EnableDiscoveryEndpoint)
{
Logger.Warn("Endpoint is disabled. Aborting");
return(NotFound());
}
var baseUrl = Request.GetIdentityServerBaseUrl();
var scopes = await _scopes.GetScopesAsync(publicOnly : true);
var claims = new List <string>();
foreach (var s in scopes)
{
claims.AddRange(from c in s.Claims
where s.Type == ScopeType.Identity
select c.Name);
}
var supportedGrantTypes = Constants.SupportedGrantTypes.AsEnumerable();
if (this._options.AuthenticationOptions.EnableLocalLogin == false)
{
supportedGrantTypes = supportedGrantTypes.Where(type => type != Constants.GrantTypes.Password);
}
var dto = new DiscoveryDto
{
issuer = _options.IssuerUri,
scopes_supported = scopes.Where(s => s.ShowInDiscoveryDocument).Select(s => s.Name).ToArray(),
claims_supported = claims.Distinct().ToArray(),
response_types_supported = Constants.SupportedResponseTypes.ToArray(),
response_modes_supported = Constants.SupportedResponseModes.ToArray(),
grant_types_supported = supportedGrantTypes.ToArray(),
subject_types_supported = new[] { "public" },
id_token_signing_alg_values_supported = new[] { Constants.SigningAlgorithms.RSA_SHA_256 },
token_endpoint_auth_methods_supported = new[] { Constants.TokenEndpointAuthenticationMethods.PostBody, Constants.TokenEndpointAuthenticationMethods.BasicAuthentication }
};
if (_options.Endpoints.EnableAuthorizeEndpoint)
{
dto.authorization_endpoint = baseUrl + Constants.RoutePaths.Oidc.Authorize;
}
if (_options.Endpoints.EnableTokenEndpoint)
{
dto.token_endpoint = baseUrl + Constants.RoutePaths.Oidc.Token;
}
if (_options.Endpoints.EnableUserInfoEndpoint)
{
dto.userinfo_endpoint = baseUrl + Constants.RoutePaths.Oidc.UserInfo;
}
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.end_session_endpoint = baseUrl + Constants.RoutePaths.Oidc.EndSession;
}
if (_options.Endpoints.EnableCheckSessionEndpoint)
{
dto.check_session_iframe = baseUrl + Constants.RoutePaths.Oidc.CheckSession;
}
if (_options.Endpoints.EnableTokenRevocationEndpoint)
{
dto.revocation_endpoint = baseUrl + Constants.RoutePaths.Oidc.Revocation;
}
if (_options.SigningCertificate != null)
{
dto.jwks_uri = baseUrl + Constants.RoutePaths.Oidc.DiscoveryWebKeys;
}
return(Json(dto, Settings));
}
public async Task <IHttpActionResult> GetConfiguration()
{
Logger.Info("Start discovery request");
var baseUrl = Request.GetIdentityServerBaseUrl();
var allScopes = await _scopes.GetScopesAsync(publicOnly : true);
var showScopes = new List <Scope>();
var dto = new DiscoveryDto
{
issuer = _context.GetIdentityServerIssuerUri(),
subject_types_supported = new[] { "public" },
id_token_signing_alg_values_supported = new[] { Constants.SigningAlgorithms.RSA_SHA_256 }
};
// scopes
if (_options.DiscoveryOptions.ShowIdentityScopes)
{
showScopes.AddRange(allScopes.Where(s => s.Type == ScopeType.Identity));
}
if (_options.DiscoveryOptions.ShowResourceScopes)
{
showScopes.AddRange(allScopes.Where(s => s.Type == ScopeType.Resource));
}
if (showScopes.Any())
{
dto.scopes_supported = showScopes.Where(s => s.ShowInDiscoveryDocument).Select(s => s.Name).ToArray();
}
// claims
if (_options.DiscoveryOptions.ShowClaims)
{
var claims = new List <string>();
foreach (var s in allScopes)
{
claims.AddRange(from c in s.Claims
where s.Type == ScopeType.Identity
select c.Name);
}
dto.claims_supported = claims.Distinct().ToArray();
}
// grant types
if (_options.DiscoveryOptions.ShowGrantTypes)
{
var standardGrantTypes = Constants.SupportedGrantTypes.AsEnumerable();
if (this._options.AuthenticationOptions.EnableLocalLogin == false)
{
standardGrantTypes = standardGrantTypes.Where(type => type != Constants.GrantTypes.Password);
}
var showGrantTypes = new List <string>(standardGrantTypes);
if (_options.DiscoveryOptions.ShowCustomGrantTypes)
{
showGrantTypes.AddRange(_customGrants.GetAvailableGrantTypes());
}
dto.grant_types_supported = showGrantTypes.ToArray();
}
// response types
if (_options.DiscoveryOptions.ShowResponseTypes)
{
dto.response_types_supported = Constants.SupportedResponseTypes.ToArray();
}
// response modes
if (_options.DiscoveryOptions.ShowResponseModes)
{
dto.response_modes_supported = Constants.SupportedResponseModes.ToArray();
}
// token endpoint authentication methods
if (_options.DiscoveryOptions.ShowTokenEndpointAuthenticationMethods)
{
dto.token_endpoint_auth_methods_supported = new[] { Constants.TokenEndpointAuthenticationMethods.PostBody, Constants.TokenEndpointAuthenticationMethods.BasicAuthentication };
}
// endpoints
if (_options.DiscoveryOptions.ShowEndpoints)
{
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.http_logout_supported = true;
}
if (_options.Endpoints.EnableAuthorizeEndpoint)
{
dto.authorization_endpoint = baseUrl + Constants.RoutePaths.Oidc.Authorize;
}
if (_options.Endpoints.EnableTokenEndpoint)
{
dto.token_endpoint = baseUrl + Constants.RoutePaths.Oidc.Token;
}
if (_options.Endpoints.EnableUserInfoEndpoint)
{
dto.userinfo_endpoint = baseUrl + Constants.RoutePaths.Oidc.UserInfo;
}
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.end_session_endpoint = baseUrl + Constants.RoutePaths.Oidc.EndSession;
}
if (_options.Endpoints.EnableCheckSessionEndpoint)
{
dto.check_session_iframe = baseUrl + Constants.RoutePaths.Oidc.CheckSession;
}
if (_options.Endpoints.EnableTokenRevocationEndpoint)
{
dto.revocation_endpoint = baseUrl + Constants.RoutePaths.Oidc.Revocation;
}
if (_options.Endpoints.EnableIntrospectionEndpoint)
{
dto.introspection_endpoint = baseUrl + Constants.RoutePaths.Oidc.Introspection;
}
}
if (_options.DiscoveryOptions.ShowKeySet)
{
if (_options.SigningCertificate != null)
{
dto.jwks_uri = baseUrl + Constants.RoutePaths.Oidc.DiscoveryWebKeys;
}
}
var jobject = JObject.FromObject(dto);
// custom entries
if (_options.DiscoveryOptions.CustomEntries != null && _options.DiscoveryOptions.CustomEntries.Any())
{
foreach (var item in _options.DiscoveryOptions.CustomEntries)
{
JToken token;
if (jobject.TryGetValue(item.Key, out token))
{
throw new Exception("Item does already exist - cannot add it via a custom entry: " + item.Key);
}
jobject.Add(new JProperty(item.Key, item.Value));
}
}
return(Content(HttpStatusCode.OK, jobject));
}
public async Task<IHttpActionResult> GetConfiguration()
{
Logger.Info("Start discovery request");
var baseUrl = Request.GetIdentityServerBaseUrl();
var allScopes = await _scopes.GetScopesAsync(publicOnly: true);
var showScopes = new List<Scope>();
var dto = new DiscoveryDto
{
issuer = _context.GetIdentityServerIssuerUri(),
subject_types_supported = new[] { "public" },
id_token_signing_alg_values_supported = new[] { Constants.SigningAlgorithms.RSA_SHA_256 },
code_challenge_methods_supported = new[] { Constants.CodeChallengeMethods.Plain, Constants.CodeChallengeMethods.SHA_256 }
};
// scopes
if (_options.DiscoveryOptions.ShowIdentityScopes)
{
showScopes.AddRange(allScopes.Where(s => s.Type == ScopeType.Identity));
}
if (_options.DiscoveryOptions.ShowResourceScopes)
{
showScopes.AddRange(allScopes.Where(s => s.Type == ScopeType.Resource));
}
if (showScopes.Any())
{
dto.scopes_supported = showScopes.Where(s => s.ShowInDiscoveryDocument).Select(s => s.Name).ToArray();
}
// claims
if (_options.DiscoveryOptions.ShowClaims)
{
var claims = new List<string>();
foreach (var s in allScopes)
{
claims.AddRange(from c in s.Claims
where s.Type == ScopeType.Identity
select c.Name);
}
dto.claims_supported = claims.Distinct().ToArray();
}
// grant types
if (_options.DiscoveryOptions.ShowGrantTypes)
{
var standardGrantTypes = Constants.SupportedGrantTypes.AsEnumerable();
if (this._options.AuthenticationOptions.EnableLocalLogin == false)
{
standardGrantTypes = standardGrantTypes.Where(type => type != Constants.GrantTypes.Password);
}
var showGrantTypes = new List<string>(standardGrantTypes);
if (_options.DiscoveryOptions.ShowCustomGrantTypes)
{
showGrantTypes.AddRange(_customGrants.GetAvailableGrantTypes());
}
dto.grant_types_supported = showGrantTypes.ToArray();
}
// response types
if (_options.DiscoveryOptions.ShowResponseTypes)
{
dto.response_types_supported = Constants.SupportedResponseTypes.ToArray();
}
// response modes
if (_options.DiscoveryOptions.ShowResponseModes)
{
dto.response_modes_supported = Constants.SupportedResponseModes.ToArray();
}
// token endpoint authentication methods
if (_options.DiscoveryOptions.ShowTokenEndpointAuthenticationMethods)
{
dto.token_endpoint_auth_methods_supported = new[] { Constants.TokenEndpointAuthenticationMethods.PostBody, Constants.TokenEndpointAuthenticationMethods.BasicAuthentication };
}
// endpoints
if (_options.DiscoveryOptions.ShowEndpoints)
{
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.frontchannel_logout_supported = true;
dto.frontchannel_logout_session_supported = true;
}
if (_options.Endpoints.EnableAuthorizeEndpoint)
{
dto.authorization_endpoint = baseUrl + Constants.RoutePaths.Oidc.Authorize;
}
if (_options.Endpoints.EnableTokenEndpoint)
{
dto.token_endpoint = baseUrl + Constants.RoutePaths.Oidc.Token;
}
if (_options.Endpoints.EnableUserInfoEndpoint)
{
dto.userinfo_endpoint = baseUrl + Constants.RoutePaths.Oidc.UserInfo;
}
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.end_session_endpoint = baseUrl + Constants.RoutePaths.Oidc.EndSession;
}
if (_options.Endpoints.EnableCheckSessionEndpoint)
{
dto.check_session_iframe = baseUrl + Constants.RoutePaths.Oidc.CheckSession;
}
if (_options.Endpoints.EnableTokenRevocationEndpoint)
{
dto.revocation_endpoint = baseUrl + Constants.RoutePaths.Oidc.Revocation;
}
if (_options.Endpoints.EnableIntrospectionEndpoint)
{
dto.introspection_endpoint = baseUrl + Constants.RoutePaths.Oidc.Introspection;
}
}
if (_options.DiscoveryOptions.ShowKeySet)
{
if (_options.SigningCertificate != null)
{
dto.jwks_uri = baseUrl + Constants.RoutePaths.Oidc.DiscoveryWebKeys;
}
}
var jobject = JObject.FromObject(dto, Serializer);
// custom entries
if (_options.DiscoveryOptions.CustomEntries != null && _options.DiscoveryOptions.CustomEntries.Any())
{
foreach (var item in _options.DiscoveryOptions.CustomEntries)
{
JToken token;
if (jobject.TryGetValue(item.Key, out token))
{
throw new Exception("Item does already exist - cannot add it via a custom entry: " + item.Key);
}
jobject.Add(new JProperty(item.Key, item.Value));
}
}
return Content(HttpStatusCode.OK, jobject);
}
public async Task<IHttpActionResult> GetConfiguration()
{
Logger.Info("Start discovery request");
if (!_options.Endpoints.EnableDiscoveryEndpoint)
{
Logger.Warn("Endpoint is disabled. Aborting");
return NotFound();
}
var baseUrl = Request.GetIdentityServerBaseUrl();
var scopes = await _scopes.GetScopesAsync(publicOnly: true);
var supportedGrantTypes = Constants.SupportedGrantTypes.AsEnumerable();
if (this._options.AuthenticationOptions.EnableLocalLogin == false)
{
supportedGrantTypes = supportedGrantTypes.Where(type => type != Constants.GrantTypes.Password);
}
var dto = new DiscoveryDto
{
issuer = _options.IssuerUri,
scopes_supported = scopes.Where(s => s.ShowInDiscoveryDocument).Select(s => s.Name).ToArray(),
response_types_supported = Constants.SupportedResponseTypes.ToArray(),
response_modes_supported = Constants.SupportedResponseModes.ToArray(),
grant_types_supported = supportedGrantTypes.ToArray(),
subject_types_supported = new[] { "public" },
id_token_signing_alg_values_supported = new[] { Constants.SigningAlgorithms.RSA_SHA_256 }
};
if (_options.Endpoints.EnableAuthorizeEndpoint)
{
dto.authorization_endpoint = baseUrl + Constants.RoutePaths.Oidc.Authorize;
}
if (_options.Endpoints.EnableTokenEndpoint)
{
dto.token_endpoint = baseUrl + Constants.RoutePaths.Oidc.Token;
}
if (_options.Endpoints.EnableUserInfoEndpoint)
{
dto.userinfo_endpoint = baseUrl + Constants.RoutePaths.Oidc.UserInfo;
}
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.end_session_endpoint = baseUrl + Constants.RoutePaths.Oidc.EndSession;
}
if (_options.Endpoints.EnableCheckSessionEndpoint)
{
dto.check_session_iframe = baseUrl + Constants.RoutePaths.Oidc.CheckSession;
}
if (_options.SigningCertificate != null)
{
dto.jwks_uri = baseUrl + Constants.RoutePaths.Oidc.DiscoveryWebKeys;
}
return Json(dto, Settings);
}
public async Task<IHttpActionResult> GetConfiguration()
{
Logger.Info("Start discovery request");
var baseUrl = Request.GetIdentityServerBaseUrl();
var scopes = await _scopes.GetScopesAsync(publicOnly: true);
var claims = new List<string>();
foreach (var s in scopes)
{
claims.AddRange(from c in s.Claims
where s.Type == ScopeType.Identity
select c.Name);
}
var supportedGrantTypes = Constants.SupportedGrantTypes.AsEnumerable();
if (this._options.AuthenticationOptions.EnableLocalLogin == false)
{
supportedGrantTypes = supportedGrantTypes.Where(type => type != Constants.GrantTypes.Password);
}
var dto = new DiscoveryDto
{
issuer = _options.IssuerUri,
scopes_supported = scopes.Where(s => s.ShowInDiscoveryDocument).Select(s => s.Name).ToArray(),
claims_supported = claims.Distinct().ToArray(),
response_types_supported = Constants.SupportedResponseTypes.ToArray(),
response_modes_supported = Constants.SupportedResponseModes.ToArray(),
grant_types_supported = supportedGrantTypes.ToArray(),
subject_types_supported = new[] { "public" },
id_token_signing_alg_values_supported = new[] { Constants.SigningAlgorithms.RSA_SHA_256 },
token_endpoint_auth_methods_supported = new[] { Constants.TokenEndpointAuthenticationMethods.PostBody, Constants.TokenEndpointAuthenticationMethods.BasicAuthentication }
};
if (_options.Endpoints.EnableAuthorizeEndpoint)
{
dto.authorization_endpoint = baseUrl + Constants.RoutePaths.Oidc.Authorize;
}
if (_options.Endpoints.EnableTokenEndpoint)
{
dto.token_endpoint = baseUrl + Constants.RoutePaths.Oidc.Token;
}
if (_options.Endpoints.EnableUserInfoEndpoint)
{
dto.userinfo_endpoint = baseUrl + Constants.RoutePaths.Oidc.UserInfo;
}
if (_options.Endpoints.EnableEndSessionEndpoint)
{
dto.end_session_endpoint = baseUrl + Constants.RoutePaths.Oidc.EndSession;
}
if (_options.Endpoints.EnableCheckSessionEndpoint)
{
dto.check_session_iframe = baseUrl + Constants.RoutePaths.Oidc.CheckSession;
}
if (_options.Endpoints.EnableTokenRevocationEndpoint)
{
dto.revocation_endpoint = baseUrl + Constants.RoutePaths.Oidc.Revocation;
}
if (_options.SigningCertificate != null)
{
dto.jwks_uri = baseUrl + Constants.RoutePaths.Oidc.DiscoveryWebKeys;
}
return Json(dto, Settings);
}
