/// <inheritdoc/>
public Task SetPolicyAsync(ScalingGroupId groupId, PolicyId policyId, PolicyConfiguration configuration, CancellationToken cancellationToken)
{
if (groupId == null)
{
throw new ArgumentNullException("groupId");
}
if (policyId == null)
{
throw new ArgumentNullException("policyId");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
UriTemplate template = new UriTemplate("/groups/{groupId}/policies/{policyId}");
var parameters = new Dictionary <string, string> {
{ "groupId", groupId.Value }, { "policyId", policyId.Value }
};
Func <Task <Tuple <IdentityToken, Uri> >, Task <HttpWebRequest> > prepareRequest =
PrepareRequestAsyncFunc(HttpMethod.PUT, template, parameters, configuration);
Func <Task <HttpWebRequest>, Task <string> > requestResource =
GetResponseAsyncFunc(cancellationToken);
return(AuthenticateServiceAsync(cancellationToken)
.Then(prepareRequest)
.Then(requestResource));
}
public PrimeController(
IMapper mapper,
IMediator mediator,
ILinksService linksService,
ILoggingManager loggingManager,
PolicyConfiguration policyConfiguration)
{
_mapper = mapper;
_mediator = mediator;
_linksService = linksService;
_loggingManager = loggingManager;
_policyConfiguration = policyConfiguration;
_circuitBreakerPolicy = Policy
.Handle <TaskCanceledException>()
.CircuitBreakerAsync(policyConfiguration.CircuitBreakerAllowedExceptions, TimeSpan.FromMinutes(_policyConfiguration.CircuitBreakerShutdownDurationInMinutes),
(ex, t) =>
{
_loggingManager.LogFatal("Circuit broken!");
},
() =>
{
_loggingManager.LogInformation("Circuit Reset!");
});
}
public static PolicyConfiguration FromPolicyStorage(PolicyStorage policyStorage)
{
PolicyConfiguration policyConfiguration = new PolicyConfiguration(policyStorage.OrganizationalUnitRoot.ObjectGuid, policyStorage.Id.ObjectGuid);
UnifiedPolicyStorageFactory.CopyPropertiesFromStorage <PolicyConfiguration>(policyConfiguration, new TenantSettingFacade <PolicyStorage>(policyStorage));
return(policyConfiguration);
}
public async Task <PolicyConfiguration> AddBuildPolicy(string projectName, string repositoryName, string pipelineName)
{
PolicyConfiguration config = new PolicyConfiguration
{
IsBlocking = true,
IsEnabled = true
};
List <PolicyType> types = await Policy.GetPolicyTypesAsync(projectName);
config.Type = types.First(pt => pt.DisplayName == "Build");
GitRepository repo = await Git.GetRepositoryAsync(projectName, repositoryName);
BuildPolicySettings settings = new BuildPolicySettings("build policy");
BuildDefinition definition = await GetPipeline(projectName, pipelineName);
settings.BuildDefinitionId = definition.Id;
settings.FilenamePatterns.Add("/*");
settings.FilenamePatterns.Add("!**/*.md");
settings.Scope.Add(new BuildPolicySettings.ScopeEntry()
{
RefName = "refs/heads/master",
MatchKind = "Exact",
RepositoryID = repo.Id.ToString()
});
config.Settings = (JObject)JToken.FromObject(settings);
return(await Policy.CreatePolicyConfigurationAsync(config, projectName));
}
public async Task <PolicyConfiguration> AddRequiredReviewersPolicy(string projectName, string repositoryName, List <Guid> reviewers)
{
PolicyConfiguration config = new PolicyConfiguration
{
IsBlocking = true,
IsEnabled = true
};
List <PolicyType> types = await Policy.GetPolicyTypesAsync(projectName);
config.Type = types.First(pt => pt.DisplayName == "Required reviewers");
GitRepository repo = await Git.GetRepositoryAsync(projectName, repositoryName);
RequiredReviewersPolicySettings settings = new RequiredReviewersPolicySettings();
settings.RequiredReviewerIds.AddRange(reviewers);
settings.Scope.Add(new RequiredReviewersPolicySettings.ScopeEntry()
{
RefName = "refs/heads/master",
MatchKind = "Exact",
RepositoryID = repo.Id.ToString()
});
config.Settings = (JObject)JToken.FromObject(settings);
return(await Policy.CreatePolicyConfigurationAsync(config, projectName));
}
public void Invoke(int projectId, Policy policy, PolicyConfiguration policyConfiguration)
{
var project = projectRepository.GetById(projectId);
if (project == null)
{
throw new ArgumentNullException($"Cannot find project with id: {projectId}.");
}
var projectPolicy = project.ProjectPolicies.FirstOrDefault(m => m.Policy == policy);
if (projectPolicy != null)
{
project.ProjectPolicies.Remove(projectPolicy);
project.ProjectPolicies.Add(new ProjectPolicies
{
Policy = policy,
SerializedProjectPolicySetting = jsonConvertService.Serialize(policyConfiguration)
});
}
else
{
project.ProjectPolicies.Add(new ProjectPolicies
{
Policy = policy,
SerializedProjectPolicySetting = jsonConvertService.Serialize(policyConfiguration)
});
}
projectRepository.Edit(project);
eventBus.Publish(new PolicySaved(projectId, policy));
}
/// <summary>
/// Updates a policy in Azure DevOps.
/// </summary>
/// <param name="policyClient">Policy client</param>
/// <param name="types">Types</param>
/// <param name="projectId">Team project id</param>
/// <param name="repository">Git repository</param>
/// <param name="currentPolicy">Branch policy</param>
/// <param name="policy">Policy</param>
/// <param name="serverPolicy">Azure DevOps policy</param>
/// <returns>Task</returns>
protected abstract Task UpdatePolicy(
PolicyHttpClient policyClient,
IEnumerable <PolicyType> types,
Guid projectId,
GitRepository repository,
BranchPolicies currentPolicy,
Policy policy,
PolicyConfiguration serverPolicy);
public void RequestRefresh(string policyId)
{
PolicyConfiguration policyConfiguration = null;
if (_policyConfigurations.TryGetValue(policyId, out policyConfiguration))
{
RequestRefresh(policyConfiguration);
}
}
/// <summary>
/// Returns the repository id from the settings.
/// </summary>
/// <param name="configuration">Policy configuration</param>
/// <param name="policy">Policy</param>
/// <returns>bool</returns>
public static bool DoesSubTypeMatch(this PolicyConfiguration configuration, Policy policy)
{
if (!policy.HasSubType)
{
return(true);
}
return(configuration.Settings.Value <string>(policy.SubTypePropertyName) == policy.SubTypePropertyValue);
}
public static PolicyStorage ToPolicyStorage(PolicyConfiguration policy)
{
PolicyStorage policyStorage = new PolicyStorage();
policyStorage[ADObjectSchema.OrganizationalUnitRoot] = new ADObjectId(policy.TenantId);
policyStorage.Name = policy.Name;
policyStorage.SetId((ADObjectId)DalHelper.ConvertFromStoreObject(policy.ObjectId, typeof(ADObjectId)));
UnifiedPolicyStorageFactory.CopyPropertiesToStorage <PolicyConfiguration>(new TenantSettingFacade <PolicyStorage>(policyStorage), policy);
return(policyStorage);
}
/// <summary>
/// Returns the repository id from the settings.
/// </summary>
/// <param name="configuration">Policy configuration</param>
/// <returns>repository id</returns>
public static MatchKind?GetMatchKind(this PolicyConfiguration configuration)
{
var value = GetValueFromScopeElement(configuration, "matchKind");
if (string.IsNullOrEmpty(value))
{
return(null);
}
return(Enum.Parse <MatchKind>(value, true));
}
public async Task <OpenIdConnectConfiguration> GetConfigurationByPolicyAsync(CancellationToken cancel, string policyId)
{
PolicyConfiguration policyConfiguration = null;
if (!_policyConfigurations.TryGetValue(policyId, out policyConfiguration))
{
return(null);
}
return(await GetConfigurationByPolicyAsync(policyConfiguration, cancel));
}
#pragma warning restore 1998
/// <summary>
/// Logs the change.
/// </summary>
/// <param name="policyClient">Policy client</param>
/// <param name="types">Types</param>
/// <param name="projectId">Team project id</param>
/// <param name="repository">Git repository</param>
/// <param name="currentPolicy">Branch policy</param>
/// <param name="policy">Policy</param>
/// <param name="serverPolicy">Server policy</param>
/// <returns>Task</returns>
#pragma warning disable 1998
protected override async Task UpdatePolicy(
PolicyHttpClient policyClient,
IEnumerable <PolicyType> types,
Guid projectId,
GitRepository repository,
BranchPolicies currentPolicy,
Policy policy,
PolicyConfiguration serverPolicy)
{
this.Logger.Info($"Policy found, would be updated in Azure DevOps. (Repository: {repository.Name}, Branch: {currentPolicy.Branch}, Type: {policy.TypeString})");
this.Logger.Debug($"Settings is: {policy.PrepareSettingsWithScopeAndSubType(repository.Id, policy)}");
}
private void RequestRefresh(PolicyConfiguration policyConfiguration)
{
if (policyConfiguration == null)
{
throw new ArgumentNullException(nameof(policyConfiguration));
}
DateTimeOffset now = DateTimeOffset.UtcNow;
if (now >= policyConfiguration.LastRefresh.UtcDateTime.Add(RefreshInterval))
{
policyConfiguration.SyncAfter = now;
}
}
private static void BuildPolicy(IExceptionPolicyBuilder builder, PolicyConfiguration config, IDictionary <string, IExceptionFilter> filters)
{
foreach (var it in config.PreHandlers)
{
var handlerConfig = GetHandlerConfiguration(it.HandlerType);
var filterableConfig = it as FilterableHandlerConfiguration;
if (null == filterableConfig)
{
builder.Pre(handlerBuilder => handlerConfig.Use(handlerBuilder, _ => true, it.Arguments.ToDictionary(item => item.Name, item => item.Value)));
}
else
{
builder.Pre(handlerBuilder => handlerConfig.Use(handlerBuilder, context => filters[filterableConfig.Filter].Match(context), it.Arguments.ToDictionary(item => item.Name, item => item.Value)));
}
}
foreach (var it in config.PostHandlers)
{
var handlerConfig = GetHandlerConfiguration(it.HandlerType);
var filterableConfig = it as FilterableHandlerConfiguration;
if (null == filterableConfig)
{
builder.Post(handlerBuilder => handlerConfig.Use(handlerBuilder, _ => true, it.Arguments.ToDictionary(item => item.Name, item => item.Value)));
}
else
{
builder.Post(handlerBuilder => handlerConfig.Use(handlerBuilder, context => filters[filterableConfig.Filter].Match(context), it.Arguments.ToDictionary(item => item.Name, item => item.Value)));
}
}
foreach (var entry in config.PolicyEntries)
{
builder.For(entry.ExceptionType, entry.PostHandlingAction, handlerBuilder => {
foreach (var it in entry.Handlers)
{
var handlerConfig = GetHandlerConfiguration(it.HandlerType);
var filterableConfig = it as FilterableHandlerConfiguration;
if (null == filterableConfig)
{
handlerConfig.Use(handlerBuilder, _ => true, it.Arguments.ToDictionary(item => item.Name, item => item.Value));
}
else
{
handlerConfig.Use(handlerBuilder, context => filters[filterableConfig.Filter].Match(context), it.Arguments.ToDictionary(item => item.Name, item => item.Value));
}
}
});
}
}
/// <summary>
/// Updates a policy in Azure DevOps.
/// </summary>
/// <param name="policyClient">Policy client</param>
/// <param name="types">Types</param>
/// <param name="projectId">Team project id</param>
/// <param name="repository">Git repository</param>
/// <param name="currentPolicy">Branch policy</param>
/// <param name="policy">Policy</param>
/// <param name="serverPolicy">Azure DevOps policy</param>
/// <returns>Task</returns>
protected override async Task UpdatePolicy(
PolicyHttpClient policyClient,
IEnumerable <PolicyType> types,
Guid projectId,
GitRepository repository,
BranchPolicies currentPolicy,
Policy policy,
PolicyConfiguration serverPolicy)
{
var policyConfiguration = this.GetPolicyConfiguration(types, repository, policy);
var update = await policyClient.UpdatePolicyConfigurationAsync(policyConfiguration, projectId, serverPolicy.Id).ConfigureAwait(false);
this.Logger.Debug(this.Serializer.Serialize(update));
this.Logger.Info($"Policy updated. (Repository: {repository.Name}, Branch: {currentPolicy.Branch}, Type: {policy.TypeString})");
}
/// <inheritdoc/>
public Task <Policy> CreatePolicyAsync(ScalingGroupId groupId, PolicyConfiguration configuration, CancellationToken cancellationToken)
{
if (groupId == null)
{
throw new ArgumentNullException("groupId");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
UriTemplate template = new UriTemplate("/groups/{groupId}/policies");
var parameters = new Dictionary <string, string> {
{ "groupId", groupId.Value }
};
Func <Task <Tuple <IdentityToken, Uri> >, Task <HttpWebRequest> > prepareRequest =
PrepareRequestAsyncFunc(HttpMethod.POST, template, parameters, new[] { configuration });
Func <Task <HttpWebRequest>, Task <JObject> > requestResource =
GetResponseAsyncFunc <JObject>(cancellationToken);
Func <Task <JObject>, Policy> resultSelector =
task =>
{
JObject result = task.Result;
if (result == null)
{
return(null);
}
JToken valueToken = result["policies"];
if (valueToken == null)
{
return(null);
}
Policy[] policies = valueToken.ToObject <Policy[]>();
return(policies[0]);
};
return(AuthenticateServiceAsync(cancellationToken)
.Then(prepareRequest)
.Then(requestResource)
.Select(resultSelector));
}
public void GivenPolicyConfigurationExistsForClaimGroupWithBehaviourAs(string ReconciliationAllocationGroupName, string claimTypeName, Table tblClaimGroupSettings)
{
TableRow row = tblClaimGroupSettings.Rows[0];
_policyConfiguration = new PolicyConfiguration()
{
ClaimGroupSettings = new List <ReconciliationAllocationGroupClaimTypeBehaviour>()
{
new ReconciliationAllocationGroupClaimTypeBehaviour()
{
ReconciliationAllocationGroupName = ReconciliationAllocationGroupName,
ClaimTypeName = claimTypeName,
OverDeliveryDeminimis = Convert.ToDecimal(row["OverDeliveryDeminimis"]),
UnderDeliveryDeminimis = Convert.ToDecimal(row["UnderDeliveryDeminimis"]),
ReconcileIfOverDelivery = GetBooleanValue(row["ReconcileOverDelivery"]),
ReconcileIfUnderDelivery = GetBooleanValue(row["ReconcileUnderDelivery"])
}
}
};
}
public void GivenDeliverableGroupExistsAsFollows(string deliverableGroupName, Table tblDeliverableGroupSettings)
{
TableRow row =
tblDeliverableGroupSettings.Rows[0];
if (_policyConfiguration == null)
{
_policyConfiguration = new PolicyConfiguration();
}
if (_policyConfiguration.DeliverableGroupSettings == null)
{
_policyConfiguration.DeliverableGroupSettings = new List <DeliverableGroupBehaviour>();
}
DeliverableGroupBehaviour groupBehaviour = new DeliverableGroupBehaviour
{
DeliverableGroupName = deliverableGroupName,
IsClaimToProfileCappingNeeded = GetBooleanValue(row["IsClaimToProfileCappingNeeded"])
};
_policyConfiguration.DeliverableGroupSettings.Add(groupBehaviour);
}
public PolicyConfigurationProvider()
{
this.policyConfig = ConfigurationManager.GetSection("throttlePolicy") as PolicyConfiguration;
}
/// <summary>
/// Returns the repository id from the settings.
/// </summary>
/// <param name="configuration">Policy configuration</param>
/// <returns>repository id</returns>
public static string GetBranch(this PolicyConfiguration configuration)
{
return(GetValueFromScopeElement(configuration, "refName")?.Replace("refs/heads/", string.Empty));
}
/// <summary> /// Deletes a policy in Azure DevOps. /// </summary> /// <param name="policyClient">Policy client</param> /// <param name="projectId">Team project id</param> /// <param name="policy">Policy</param> protected abstract void DeletePolicy(PolicyHttpClient policyClient, Guid projectId, PolicyConfiguration policy);
/// <summary>
/// Replace the configuration for a scaling policy.
/// </summary>
/// <remarks>
/// This method can be used to replace the behavior associated with webhooks which
/// have already in use by applications.
/// </remarks>
/// <param name="service">The Auto Scale service instance.</param>
/// <param name="groupId">The ID of the scaling group. This is obtained from <see cref="ScalingGroup.Id">ScalingGroup.Id</see>.</param>
/// <param name="policyId">The ID of the scaling policy. This is obtained from <see cref="Policy.Id">Policy.Id</see>.</param>
/// <param name="configuration">A <see cref="PolicyConfiguration"/> object describing the new scaling policy configuration.</param>
/// <exception cref="ArgumentNullException">If <paramref name="service"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException">
/// If <paramref name="groupId"/> is <see langword="null"/>.
/// <para>-or-</para>
/// <para>If <paramref name="policyId"/> is <see langword="null"/>.</para>
/// <para>-or-</para>
/// <para>If <paramref name="configuration"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="WebException">If the REST request does not return successfully.</exception>
/// <seealso href="http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/PUT_putPolicy_v1.0__tenantId__groups__groupId__policies__policyId__autoscale-policies.html">Replace policy (Rackspace Auto Scale Developer Guide - API v1.0)</seealso>
public static void SetPolicy(this IAutoScaleService service, ScalingGroupId groupId, PolicyId policyId, PolicyConfiguration configuration)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
try
{
service.SetPolicyAsync(groupId, policyId, configuration, CancellationToken.None).Wait();
}
catch (AggregateException ex)
{
ReadOnlyCollection <Exception> innerExceptions = ex.Flatten().InnerExceptions;
if (innerExceptions.Count == 1)
{
throw innerExceptions[0];
}
throw;
}
}
private async Task <OpenIdConnectConfiguration> GetConfigurationByPolicyAsync(PolicyConfiguration policyConfiguration, CancellationToken cancel)
{
DateTimeOffset now = DateTimeOffset.UtcNow;
DateTimeOffset sync = policyConfiguration.SyncAfter;
OpenIdConnectConfiguration config = policyConfiguration.Configuration;
if (config != null && sync > now)
{
return(config);
}
await _refreshLock.WaitAsync(cancel);
try
{
Exception retrieveEx = null;
if (sync <= now)
{
try
{
config = await OpenIdConnectConfigurationRetriever.GetAsync(policyConfiguration.MetadataAddress, cancel);
policyConfiguration.Configuration = config;
Contract.Assert(policyConfiguration.Configuration != null);
policyConfiguration.LastRefresh = now;
policyConfiguration.SyncAfter = now.UtcDateTime.Add(_automaticRefreshInterval);
}
catch (Exception ex)
{
retrieveEx = ex;
policyConfiguration.SyncAfter = now.UtcDateTime.Add(_automaticRefreshInterval < _refreshInterval ? _automaticRefreshInterval : _refreshInterval);
}
}
if (config == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, ErrorMessages.IDX10803, policyConfiguration.MetadataAddress ?? "null"), retrieveEx);
}
return(config);
}
finally
{
_refreshLock.Release();
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy(name: AllowAllPolicy,
builder =>
{
builder.AllowAnyOrigin();
builder.AllowAnyMethod();
builder.AllowAnyHeader();
});
});
services.AddResponseCaching();
services.AddControllers();
services.AddMediatR(typeof(Startup));
services.AddScoped <ICalculationRepository, CalculationRepository>();
services.AddScoped <IPrimeLinkRepository, PrimeLinkRepository>();
services.AddScoped <ILoggingManager, LoggingManager>();
services.AddSingleton <IBackgroundTaskQueue, BackgroundTaskQueue>();
services.AddHostedService <QueuedHostedService>();
var connectionStrings = new ConnectionStrings();
Configuration.Bind("ConnectionStrings", connectionStrings);
var policyConfigurations = new PolicyConfiguration();
Configuration.Bind("PolicyConfiguration", policyConfigurations);
services.AddSingleton(connectionStrings);
services.AddSingleton(policyConfigurations);
var connectionString = string.Format(Configuration["ConnectionStrings:DatabaseConnection"]);
services.AddEntityFrameworkNpgsql()
.AddDbContext <PrimeDbContext>(options => options
.UseNpgsql(connectionString, options =>
{
options.MigrationsAssembly(typeof(PrimeDbContext).Assembly.FullName);
}));
services.AddAutoMapper(configuration =>
{
configuration.AddProfile(new CalculationProfile());
configuration.AddProfile(new PrimeLinkProfile());
});
services.AddHealthChecks()
.AddCheck <ScienceHealthCheck>("Science service host connection")
.AddCheck <DatabaseHealthChecks>("Database service host connection");
services.AddLinks(configure =>
{
configure.AddPolicy <LinkDto>("GetCalculationStatePolicy", policy =>
{
policy
.RequireSelfLink()
.RequireRoutedLink("location", nameof(PrimeController.GetCalculationState), x => new { number = x.Id });
});
configure.AddPolicy <LinkDto>("GetPrimeLinkStatePolicy", policy =>
{
policy
.RequireSelfLink()
.RequireRoutedLink("location", nameof(PrimeController.GetPrimeLink), x => new { number = x.Id });
});
});
services.AddOpenApiDocument(settings =>
{
settings.Title = "Prime API";
settings.DocumentName = "v1";
settings.Version = "v1";
});
}
/// <summary>
/// Configure Json HttpClient.
/// </summary>
/// <param name="services"></param>
/// <param name="serviceConfiguration"></param>
/// <param name="policyConfiguration"></param>
/// <typeparam name="TClient"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <returns>Configured IHttpClientBuilder</returns>
public static IHttpClientBuilder ConfigureJsonHttpClient <TClient, TImplementation>(this IServiceCollection services, HttpServiceConfiguration serviceConfiguration, PolicyConfiguration policyConfiguration = default)
where TClient : class
where TImplementation : class, TClient
{
if (serviceConfiguration is null)
{
throw new ArgumentNullException(nameof(serviceConfiguration));
}
if (policyConfiguration is null)
{
throw new ArgumentNullException(nameof(policyConfiguration));
}
return(services.AddHttpClient <TClient, TImplementation>(client => ConfigureBaseJsonHttpClient(client, serviceConfiguration))
.SetupHandlersAndPolicies(policyConfiguration));
}
private static IHttpClientBuilder SetupHandlersAndPolicies(this IHttpClientBuilder clientBuilder, PolicyConfiguration policyConfiguration)
{
clientBuilder
//.ConfigurePrimaryHttpMessageHandler(x => new HttpClientHandler(x.GetRequiredService<ISOAPMessageLogger>()))
.SetHandlerLifetime(policyConfiguration.HttpClientRenewalInterval)
.AddPolicyHandler(
RetryPolicyHandler.WaitAndRetry(policyConfiguration.HttpRetry)
)
.AddPolicyHandler(
CircuitBreakerPolicyHandler.Break(policyConfiguration.HttpCircuitBreaker)
);
return(clientBuilder);
}
/// <summary>
/// Returns the branch from the settings.
/// </summary>
/// <param name="configuration">Policy configuration</param>
/// <returns>branch</returns>
public static string GetRepositoryId(this PolicyConfiguration configuration)
{
return(GetValueFromScopeElement(configuration, "repositoryId"));
}
/// <summary>
/// Deletes a policy in Azure DevOps.
/// </summary>
/// <param name="policyClient">Policy client</param>
/// <param name="projectId">Team project id</param>
/// <param name="policy">Policy</param>
protected override async void DeletePolicy(PolicyHttpClient policyClient, Guid projectId, PolicyConfiguration policy)
{
await policyClient.DeletePolicyConfigurationAsync(projectId, policy.Id).ConfigureAwait(false);
this.Logger.Info($"Policy removed. (Repository: {policy.GetRepositoryId()}, Branch: {policy.GetBranch()}, Type: {policy.Type.DisplayName})");
}
private static string GetValueFromScopeElement(PolicyConfiguration configuration, string property)
{
return(configuration.Settings["scope"].First.Value <string>(property));
}
