public ResourceParameterBinding(
ScimServerConfiguration serverConfiguration,
HttpParameterDescriptor parameter)
: base(parameter)
{
_ServerConfiguration = serverConfiguration;
}
private void ConfigureHttpConfiguration(ScimServerConfiguration serverConfiguration)
{
var httpConfiguration = serverConfiguration.HttpConfiguration;
httpConfiguration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
httpConfiguration.MapHttpAttributeRoutes();
var settings = httpConfiguration.Formatters.JsonFormatter.SerializerSettings;
settings.ContractResolver = new ScimContractResolver(serverConfiguration)
{
IgnoreSerializableAttribute = true,
IgnoreSerializableInterface = true
};
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
settings.Converters.Add(new StringEnumConverter());
settings.Converters.Add(new ScimQueryOptionsConverter(serverConfiguration));
settings.Converters.Add(new ResourceJsonConverter(serverConfiguration, JsonSerializer.Create(settings)));
httpConfiguration.Filters.Add(new ScimAuthorizationAttribute(serverConfiguration));
httpConfiguration.ParameterBindingRules.Insert(
0,
descriptor =>
{
if (typeof(Resource).IsAssignableFrom(descriptor.ParameterType))
{
return(new ResourceParameterBinding(serverConfiguration, descriptor));
}
return(null);
});
httpConfiguration.ParameterBindingRules.Insert(
1,
descriptor =>
{
if (typeof(ScimQueryOptions).IsAssignableFrom(descriptor.ParameterType))
{
return(new ScimQueryOptionsParameterBinding(descriptor, serverConfiguration));
}
return(null);
});
// refer to https://tools.ietf.org/html/rfc7644#section-3.1
httpConfiguration.Formatters.JsonFormatter.SupportedMediaTypes.Add(new System.Net.Http.Headers.MediaTypeHeaderValue("application/scim+json"));
// See if user already provided an exception handler
if (!(httpConfiguration.Services.GetService(typeof(IExceptionHandler)) is OwinScimExceptionHandler))
{
httpConfiguration.Services.Replace(typeof(IExceptionHandler), new OwinScimExceptionHandler());
}
httpConfiguration.Services.Replace(typeof(IHttpControllerTypeResolver), new DefaultHttpControllerTypeResolver(IsControllerType));
httpConfiguration.Services.Replace(typeof(IHttpControllerSelector), new ScimHttpControllerSelector(httpConfiguration));
httpConfiguration.Filters.Add(new ModelBindingResponseAttribute());
}
public ScimResourceTypeDefinitionBuilder(
ScimServerConfiguration serverConfiguration,
string name,
string schema,
string endpoint,
Type validatorType,
SchemaBindingPredicate schemaBindingPredicate)
: base(serverConfiguration, schema)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException("name");
}
if (string.IsNullOrWhiteSpace(schema))
{
throw new ArgumentNullException("schema");
}
if (string.IsNullOrWhiteSpace(endpoint))
{
throw new ArgumentNullException("endpoint");
}
if (validatorType == null)
{
throw new ArgumentNullException("validatorType");
}
if (schemaBindingPredicate == null)
{
throw new ArgumentNullException("schemaBindingPredicate");
}
if (!schema.StartsWith(ScimConstants.Defaults.URNPrefix, StringComparison.OrdinalIgnoreCase))
{
throw new Exception("Resource types define a schema identifier which starts with \"" + ScimConstants.Defaults.URNPrefix + "\" as per RFC2141.");
}
_SchemaExtensions = new Dictionary <string, ScimResourceTypeExtension>();
if (!endpoint.StartsWith("/"))
{
endpoint = endpoint.Insert(0, "/");
}
_Endpoint = endpoint;
_ValidatorType = validatorType;
_SchemaBindingPredicate = schemaBindingPredicate;
SetName(name);
}
public ScimTypeDefinitionBuilder(ScimServerConfiguration serverConfiguration)
{
_ServerConfiguration = serverConfiguration;
_AttributeDefinitions = BuildDefaultTypeDefinitions();
var descriptionAttr = TypeDescriptor
.GetAttributes(typeof(T))
.Cast <Attribute>()
.SingleOrDefault(attr => attr is DescriptionAttribute) as DescriptionAttribute;
if (descriptionAttr != null)
{
SetDescription(descriptionAttr.Description.RemoveMultipleSpaces());
}
}
public void Configure(ApplicationConfigurationBase applicationConfiguration)
{
if (IsConfigured)
{
return;
}
var serverConfiguration = new ScimServerConfiguration();
applicationConfiguration.CompositionContainer.ComposeExportedValue(serverConfiguration);
// configure appBuilder middleware
AppBuilder.Use <ExceptionHandlerMiddleware>(); // global exception handler for returning SCIM-formatted messages
AppBuilder.Use((context, task) =>
{
AmbientRequestService.SetRequestInformation(context, serverConfiguration);
return(task.Invoke());
});
// discover and register all type definitions
var versionedSchemaTypes = new Dictionary <ScimVersion, IList <Type> >
{
{ ScimVersion.One, new List <Type>() },
{ ScimVersion.Two, new List <Type>() }
};
var typeDefinitions = applicationConfiguration.CompositionContainer.GetExportTypesThatImplement <IScimTypeDefinition>();
foreach (var typeDefinition in typeDefinitions)
{
Type distinctTypeDefinition;
var typeDefinitionTarget = GetTargetDefinitionType(typeDefinition); // the type of object being defined (e.g. User, Group, Name)
if (serverConfiguration.TypeDefinitionRegistry.TryGetValue(typeDefinitionTarget, out distinctTypeDefinition))
{
// already have a definition registered for the target type
// let's favor non-Owin.Scim definitions over built-in defaults
if (distinctTypeDefinition.Assembly.FullName.StartsWith(BuiltInAssemblyNamePrefix) &&
!typeDefinition.Assembly.FullName.StartsWith(BuiltInAssemblyNamePrefix))
{
serverConfiguration.TypeDefinitionRegistry[typeDefinitionTarget] = typeDefinition;
}
continue;
}
// register type definition
if (typeof(IScimSchemaTypeDefinition).IsAssignableFrom(typeDefinition))
{
var targetVersion = typeDefinitionTarget.Namespace.GetScimVersion() ?? serverConfiguration.DefaultScimVersion;
versionedSchemaTypes[targetVersion].Add(typeDefinitionTarget);
}
serverConfiguration.TypeDefinitionRegistry[typeDefinitionTarget] = typeDefinition;
}
serverConfiguration.SchemaTypeVersionCache = versionedSchemaTypes;
// instantiate an instance of each type definition and add it to configuration
// type definitions MAY instantiate new type definitions themselves during attribute definition composition
var enumerator = serverConfiguration.TypeDefinitionRegistry.Values.GetEnumerator();
while (enumerator.MoveNext())
{
// creating type definitions may be expensive due to reflection
// when a type definition is instantiated, it may implicitly instantiate/register other type
// definitions for complex attributes, therefore, no need to re-create the same definition more than once
if (serverConfiguration.ContainsTypeDefinition(enumerator.Current))
{
continue;
}
var typeDefinition = (IScimTypeDefinition)enumerator.Current.CreateInstance(serverConfiguration);
serverConfiguration.AddTypeDefiniton(typeDefinition);
}
// define a new HttpConfiguration
var httpConfiguration = serverConfiguration.HttpConfiguration = new HttpConfiguration();
// invoke custom configuration action if not null
if (_ConfigureScimServerAction != null)
{
_ConfigureScimServerAction.Invoke(serverConfiguration);
}
// register any optional middleware
if (serverConfiguration.RequireSsl)
{
AppBuilder.Use <RequireSslMiddleware>();
}
// create a DryIoC container with an optional fallback dependency resolver if one has been specified
if (serverConfiguration.DependencyResolver != null)
{
Container = new Container(
rules =>
rules.WithoutThrowIfDependencyHasShorterReuseLifespan()
.WithUnknownServiceResolvers(request =>
{
var shouldResolve = _TypeResolverCache.GetOrAdd(
request.ServiceType,
type =>
_CompositionConstraints.Any(
constraint =>
constraint(new FileInfo(type.Assembly.Location))));
if (!shouldResolve)
{
return(null);
}
return(new DelegateFactory(
resolver =>
serverConfiguration.DependencyResolver.Resolve(request.ServiceType)));
}),
new AsyncExecutionFlowScopeContext());
}
else
{
Container = new Container(
rules => rules.WithoutThrowIfDependencyHasShorterReuseLifespan(),
new AsyncExecutionFlowScopeContext());
}
// Configure http configuration for SCIM
ConfigureHttpConfiguration(serverConfiguration);
// Register our ScimServerConfiguration as a singleton
Container.RegisterInstance(serverConfiguration, Reuse.Singleton);
Container.WithWebApi(httpConfiguration);
AppBuilder.UseWebApi(httpConfiguration);
IsConfigured = true;
}
