public void ConfigureServices()
{
var services = new ServiceCollection();
services.AddMemoryCache();
services.AddOptions();
services.Configure <SearchConfiguration>(options =>
{
Configuration.GetSection("search").Bind(options);
SearchConfiguration.Validate(options);
});
services.Configure <CosmosConfiguration>(options =>
{
Configuration.GetSection("documents").Bind(options);
CosmosConfiguration.Validate(options);
});
services.Configure <StorageConfiguration>((config) =>
{
Configuration.GetSection("storage").Bind(config);
StorageConfiguration.Validate(config);
});
services.Configure <BatchConfiguration>((config) =>
{
Configuration.GetSection("batch").Bind(config);
BatchConfiguration.Validate(config);
});
var armTemplatesMap = new ArmTemplatesMap();
services.AddSingleton(armTemplatesMap);
var staticAssetsMap = new StaticAssetsMap();
services.AddSingleton(staticAssetsMap);
services.AddSingleton <ApplicationJobs>();
services.AddSingleton <DatasetStorageService>();
services.AddSingleton <DatasetOwnersService>();
services.AddSingleton <DatasetEditStorageService>();
services.AddSingleton <UserDataStorageService>();
services.AddSingleton <SasTokenService>();
services.AddSingleton <ValidationService>();
services.AddSingleton <DatasetSearchService>();
services.AddSingleton <FileSearchService>();
ServiceProvider = services.BuildServiceProvider();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationInsightsTelemetry();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <IConfiguration>(Configuration);
services.AddOptions();
services.Configure <IdentityProviderConfiguration>(options =>
{
Configuration.GetSection("azuread").Bind(options);
IdentityProviderConfiguration.Validate(options);
});
services.Configure <SearchConfiguration>(options =>
{
Configuration.GetSection("search").Bind(options);
SearchConfiguration.Validate(options);
});
services.Configure <CosmosConfiguration>(options =>
{
Configuration.GetSection("documents").Bind(options);
CosmosConfiguration.Validate(options);
});
services.Configure <StorageConfiguration>((config) =>
{
Configuration.GetSection("storage").Bind(config);
StorageConfiguration.Validate(config);
});
services.Configure <BatchConfiguration>((config) =>
{
Configuration.GetSection("batch").Bind(config);
BatchConfiguration.Validate(config);
});
services.Configure <AppInsightsConfiguration>((config) =>
{
Configuration.GetSection("applicationinsights").Bind(config);
AppInsightsConfiguration.Validate(config);
});
var armTemplatesMap = new ArmTemplatesMap();
services.AddSingleton(armTemplatesMap);
var staticAssetsMap = new StaticAssetsMap();
services.AddSingleton(staticAssetsMap);
services.AddMemoryCache();
//services
// .AddAuthentication(options =>
// {
// options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
// options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
// })
// .AddJwtBearer(options =>
// {
// options.Audience = Configuration["azureADConfig:clientId"];
// options.Authority = Configuration["azureADConfig:authority"];
// options.Events = new JwtBearerEvents
// {
// OnMessageReceived = FetchAuthTokenFromCookie,
// OnTokenValidated = async context =>
// {
// var principal = context.Principal;
// var ODREmailList = Configuration["ODRAdminList"].Split(";");
// }
// };
// });
//services
// .AddAuthentication(options =>
// {
// options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
// })
// .AddJwtBearer(options =>
// {
// options.Audience = Configuration["azureADConfig:clientId"];
// options.Authority = Configuration["azureADConfig:authority"];
// options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
// {
// ValidAudience = Configuration["azureADConfig:clientId"],
// ValidIssuer = $"https://login.microsoftonline.com/" + Configuration["azureADConfig:tenantId"] + "/v2.0"
// };
// options.Events = new JwtBearerEvents
// {
// OnMessageReceived = FetchAuthTokenFromCookie,
// //OnTokenValidated = async context =>
// //{
// // var principal = context.Principal;
// // if (Configuration.GetChildren().Any(item => item.Key == "ODRAdminList") && principal.Claims.Any(c => c.Type == "preferred_username"))
// // {
// // var ODRAdminsList = Configuration["ODRAdminList"].Split(";").ToList();
// // var testSubject = principal.Claims.FirstOrDefault(c => c.Type == "preferred_username").Value;
// // if (ODRAdminsList.Contains(testSubject))
// // {
// // var claims = new List<Claim>
// // {
// // new Claim(ClaimTypes.Role, "ODRAdmin")
// // };
// // var appIdentity = new ClaimsIdentity(claims);
// // principal.AddIdentity(appIdentity);
// // }
// // }
// //}
// };
// });
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
var tenantName = Configuration["AzureAD:Tenant"].Split('.').First();
var policyName = Configuration["AzureAD:Policy"];
var audience = Configuration["AzureAD:Audience"];
options.MetadataAddress = $"https://{tenantName}.b2clogin.com/{tenantName}.onmicrosoft.com/{policyName}/v2.0/.well-known/openid-configuration";
options.Audience = audience;
options.Events = new JwtBearerEvents
{
OnMessageReceived = FetchAuthTokenFromCookie,
OnAuthenticationFailed = context =>
{
var ctx = context;
return(Task.FromResult(0));
},
};
});
services.AddMvc();
services
.AddAuthorization(options =>
{
options.AddPolicy(PolicyNames.MustBeInAdminGroup, policy =>
{
var authorizedAdminUsers = Configuration["AuthorizedAdminUsers"];
policy.Requirements.Add(new AzureActiveDirectoryGroupRequirement(authorizedAdminUsers));
});
});
services.AddSingleton <IAuthorizationHandler, AzureActiveDirectoryGroupHandler>();
//if (CurrentEnvironment.IsDevelopment())
//{
// services.AddSingleton<IAuthorizationHandler, DevelopmentOnlyNoAuthDirectoryGroupHandler>();
//}
//else
//{
// services.AddSingleton<IAuthorizationHandler, AzureActiveDirectoryGroupHandler>();
//}
services.AddScoped <DatasetSearchService>();
services.AddScoped <UserDataSearchService>();
services.AddScoped <DatasetStorageService>();
services.AddScoped <AppInsightsService>();
services.AddScoped <UserDataStorageService>();
services.AddScoped <LicenseStorageService>();
services.AddScoped <SasTokenService>();
services.AddScoped <ValidationService>();
services.AddScoped <ApplicationJobs>();
// In production, the Angular files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ui-app";
});
// Add Swagger generator
if (Configuration.GetValue <bool>("Application:EnableSwagger"))
{
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
{
Title = "MSR ODR Admin API",
Version = "v1"
});
});
}
}
/// <summary>
/// Create or update a batch configuration for an integration account.
/// </summary>
/// <param name='resourceGroupName'>
/// The resource group name.
/// </param>
/// <param name='integrationAccountName'>
/// The integration account name.
/// </param>
/// <param name='batchConfigurationName'>
/// The batch configuration name.
/// </param>
/// <param name='batchConfiguration'>
/// The batch configuration.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <BatchConfiguration> > CreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string integrationAccountName, string batchConfigurationName, BatchConfiguration batchConfiguration, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
if (resourceGroupName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
}
if (integrationAccountName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "integrationAccountName");
}
if (batchConfigurationName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "batchConfigurationName");
}
if (batchConfiguration == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "batchConfiguration");
}
if (batchConfiguration != null)
{
batchConfiguration.Validate();
}
if (Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("resourceGroupName", resourceGroupName);
tracingParameters.Add("integrationAccountName", integrationAccountName);
tracingParameters.Add("batchConfigurationName", batchConfigurationName);
tracingParameters.Add("batchConfiguration", batchConfiguration);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "CreateOrUpdate", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Logic/integrationAccounts/{integrationAccountName}/batchConfigurations/{batchConfigurationName}").ToString();
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
_url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
_url = _url.Replace("{integrationAccountName}", System.Uri.EscapeDataString(integrationAccountName));
_url = _url.Replace("{batchConfigurationName}", System.Uri.EscapeDataString(batchConfigurationName));
List <string> _queryParameters = new List <string>();
if (Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("PUT");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (batchConfiguration != null)
{
_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(batchConfiguration, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 201)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <BatchConfiguration>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <BatchConfiguration>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
// Deserialize Response
if ((int)_statusCode == 201)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <BatchConfiguration>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Adds the runtime services to the instance.
/// </summary>
/// <param name="services">The services.</param>
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <IConfiguration>(this.Configuration);
services.AddSingleton <ITelemetryInitializer, TelemetryUserAndSessionContext>();
services.AddApplicationInsightsTelemetry();
services.AddOptions();
services.Configure <IdentityProviderConfiguration>(options =>
{
Configuration.GetSection("azuread").Bind(options);
IdentityProviderConfiguration.Validate(options);
});
services.Configure <SearchConfiguration>(options =>
{
Configuration.GetSection("search").Bind(options);
SearchConfiguration.Validate(options);
});
services.Configure <CosmosConfiguration>(options =>
{
Configuration.GetSection("documents").Bind(options);
CosmosConfiguration.Validate(options);
});
services.Configure <StorageConfiguration>((config) =>
{
Configuration.GetSection("storage").Bind(config);
StorageConfiguration.Validate(config);
});
services.Configure <WebServerConfiguration>(options =>
{
Configuration.GetSection("webserver").Bind(options);
WebServerConfiguration.Validate(options);
});
services.Configure <BatchConfiguration>((config) =>
{
Configuration.GetSection("batch").Bind(config);
BatchConfiguration.Validate(config);
});
var armTemplatesMap = Configuration.GetSection("armTemplates").Get <ArmTemplatesMap>();
services.AddSingleton(armTemplatesMap);
var staticAssetsMap = Configuration.GetSection("staticAssets").Get <StaticAssetsMap>();
services.AddSingleton(staticAssetsMap);
services.AddMemoryCache();
services.AddCors(options =>
{
options.AddPolicy("DefaultPolicy",
builder => builder.AllowAnyOrigin()
.WithMethods("GET", "POST", "PUT", "DELETE")
.AllowAnyHeader()
.AllowCredentials());
});
services.AddResponseCompression(opt =>
{
opt.EnableForHttps = true;
});
services.AddMvc()
.AddMvcOptions(options =>
{
options.Filters.Add(new TelemetryExceptionFilter(new LoggerFactory()));
})
.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new StringEnumConverter
{
CamelCaseText = true
});
});
services.AddScoped <DatasetSearchService>();
services.AddScoped <FileSearchService>();
services.AddScoped <DatasetStorageService>();
services.AddScoped <DatasetOwnersService>();
services.AddScoped <DatasetEditStorageService>();
services.AddScoped <UserDataStorageService>();
services.AddScoped <FileStorageService>();
services.AddScoped <LicenseStorageService>();
services.AddScoped <ValidationService>();
services.AddScoped <SasTokenService>();
services.AddScoped <GenerateFilePreview>();
services.AddScoped <CurrentUserService>();
services.AddScoped <ApplicationJobs>();
if (this.UseSwagger)
{
services.UseSwagger(this.Configuration);
}
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
var tenantName = Configuration["AzureAD:Tenant"].Split('.').First();
var policyName = Configuration["AzureAD:Policy"];
var audience = Configuration["AzureAD:Audience"];
options.MetadataAddress = $"https://{tenantName}.b2clogin.com/{tenantName}.onmicrosoft.com/{policyName}/v2.0/.well-known/openid-configuration";
options.Audience = audience;
options.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
var ctx = context;
return(Task.FromResult(0));
},
};
});
}
public void PassesValidation()
{
var batchConfig = BuildBatchConfiguration();
BatchConfiguration.Validate(batchConfig);
}
