public UserGroupDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(g => g.Value)
.SetDescription(@"The identifier of the user's group.")
.SetMutability(Mutability.ReadOnly);
For(g => g.Ref)
.SetDescription(@"The URI of the corresponding 'Group' resource to which the user belongs.")
.SetReferenceTypes(ScimConstants.ResourceTypes.Group)
.SetMutability(Mutability.ReadOnly);
For(g => g.Type)
.SetDescription(@"A label indicating the attribute's function, e.g., 'direct' or 'indirect'.")
.SetCanonicalValues(ScimConstants.CanonicalValues.UserGroupTypes)
.SetMutability(Mutability.ReadOnly);
For(g => g.Display)
.SetDescription("A human-readable name, primarily used for display purposes.")
.SetMutability(Mutability.ReadOnly);
For(g => g.Primary)
.SetDescription(@"A boolean value indicating the 'primary' or preferred attribute value for this attribute.")
.SetMutability(Mutability.ReadOnly);
}
public GroupsController(
ScimServerConfiguration serverConfiguration,
IGroupService groupService)
: base(serverConfiguration)
{
_GroupService = groupService;
}
public ResourceParameterBinding(
ScimServerConfiguration serverConfiguration,
HttpParameterDescriptor parameter)
: base(parameter)
{
_ServerConfiguration = serverConfiguration;
}
public SchemasController(
ScimServerConfiguration serverConfiguration,
ISchemaService schemaService)
: base(serverConfiguration)
{
_SchemaService = schemaService;
}
public GroupsController(
ScimServerConfiguration serverConfiguration,
IGroupService groupService)
: base(serverConfiguration)
{
_GroupService = groupService;
}
public EnterpriseUserExtensionDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
SetName("Enterprise user");
SetDescription("Enterprise user resource extension.");
For(e => e.EmployeeNumber)
.SetDescription(
@"A string identifier, typically numeric or alphanumeric, assigned to a person,
typically based on order of hire or association with an organization.");
For(e => e.CostCenter)
.SetDescription(@"Identifies the name of a cost center.");
For(e => e.Organization)
.SetDescription(@"Identifies the name of an organization.");
For(e => e.Division)
.SetDescription(@"Identifies the name of a division.");
For(e => e.Department)
.SetDescription(@"Identifies the name of a department.");
For(e => e.Manager)
.SetDescription(@"The user's manager.");
}
public ServiceProviderConfigurationController(
ScimServerConfiguration serverConfiguration,
IServiceProviderConfigurationService serviceProviderConfigurationService)
: base(serverConfiguration)
{
_ServiceProviderConfigurationService = serviceProviderConfigurationService;
}
public ServiceProviderConfigurationController(
ScimServerConfiguration serverConfiguration,
IServiceProviderConfigurationService serviceProviderConfigurationService)
: base(serverConfiguration)
{
_ServiceProviderConfigurationService = serviceProviderConfigurationService;
}
/// <summary>
/// Parses the <paramref name="uri"/> as a reference to a local resource.
/// Returns null if the specified <paramref name="uri"/> is invalid.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="serverConfiguration">The server configuration.</param>
/// <returns>ScimResourceReference.</returns>
public static ScimResourceReference ToScimResourceReference(this Uri uri, ScimServerConfiguration serverConfiguration)
{
var scimPathBase = AmbientRequestService.BasePath;
var uriPaths = (string.IsNullOrWhiteSpace(scimPathBase)
? uri.AbsolutePath
: uri.AbsolutePath.Replace(scimPathBase, ""))
.TrimStart('/')
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (uriPaths.Length < 2)
{
return(null);
}
var resourceEndpoint = uriPaths[0];
var resourceId = uriPaths[1];
var resourceDefinition = serverConfiguration
.GetResourceTypeDefinitions(AmbientRequestService.ProtocolVersion)
.SingleOrDefault(rtd => rtd.Endpoint.IndexOf(resourceEndpoint, StringComparison.OrdinalIgnoreCase) >= 0);
if (resourceDefinition == null)
{
return(null); // invalid uri
}
return(new ScimResourceReference(resourceDefinition, resourceId));
}
public Registry(
[Import]IManageCryptography cryptograhyManager,
[Import]ScimServerConfiguration serverConfiguration)
{
_CryptograhyManager = cryptograhyManager;
_ServerConfiguration = serverConfiguration;
}
protected ResourceValidatorBase(
ScimServerConfiguration serverConfiguration,
ResourceExtensionValidators extensionValidators)
{
_ServerConfiguration = serverConfiguration;
_ExtensionValidators = extensionValidators;
CascadeMode = CascadeMode.StopOnFirstFailure;
// Virtual member call from ctor but derived types should not require
// construction to configure rulesets. This MAY be short-sighted, however,
// dependencies should not need to be used during construction; but referenced from
// lambdas defined during construction yet invoked during validation.
// -DGioulakis
RuleSet("default", ConfigureDefaultRuleSet);
RuleSet("create", ConfigureCreateRuleSet);
RuleSet("update", ConfigureUpdateRuleSet);
When(res => res.Extensions != null && res.Extensions.Any(),
() =>
{
RuleFor(res => res.Extensions)
.NestedRules(v =>
v.When(ext => ext.Value != null, () =>
{
v.RuleFor(ext => ext.Value)
.SetValidatorNonGeneric(ext => _ExtensionValidators[ext.Value.SchemaIdentifier]);
}));
});
}
public UsersController(
ScimServerConfiguration serverConfiguration,
IUserService userService)
: base(serverConfiguration)
{
_UserService = userService;
}
public ScimQueryOptionsParameterBinding(
HttpParameterDescriptor descriptor,
ScimServerConfiguration serverConfiguration)
: base(descriptor)
{
_ServerConfiguration = serverConfiguration;
}
public UsersController(
ScimServerConfiguration serverConfiguration,
IUserService userService)
: base(serverConfiguration)
{
_UserService = userService;
}
public ScimGroup1Definition(ScimServerConfiguration serverConfiguration)
: base(
serverConfiguration,
ScimConstants.ResourceTypes.Group,
ScimConstantsV1.Schemas.Group,
ScimConstantsV1.Endpoints.Groups,
typeof(ScimGroup1Validator),
(schemaIdentifiers, parameterType) => parameterType == typeof(ScimGroup1))
{
SetName("Group");
SetDescription("Group resource.");
For(u => u.Schemas)
.SetReturned(Returned.Always);
For(u => u.Id)
.SetMutability(Mutability.ReadOnly)
.SetReturned(Returned.Always)
.SetUniqueness(Uniqueness.Server)
.SetCaseExact(true);
For(u => u.DisplayName)
.SetDescription("A human-readable name for the group.")
.SetRequired(true);
For(u => u.Members)
.SetDescription("A list of members of the group.")
.AddCanonicalizationRule(member => member.Canonicalize(e => e.Type, StringExtensions.UppercaseFirstCharacter));
For(u => u.Meta)
.SetMutability(Mutability.ReadOnly)
.SetReturned(Returned.Always);
}
public AuthenticationSchemeDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(s => s.Type)
.SetDescription(@"The authentication scheme.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(s => s.Name)
.SetDescription(@"The common authentication scheme name, e.g., HTTP Basic.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(s => s.Description)
.SetDescription(@"A description of the authentication scheme.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(s => s.SpecUri)
.SetDescription(@"An HTTP-addressable URL pointing to the authentication scheme's specification.")
.SetMutability(Mutability.ReadOnly)
.SetReferenceTypes(ScimConstants.ReferenceTypes.External);
For(s => s.DocumentationUri)
.SetDescription(@"An HTTP-addressable URL pointing to the authentication scheme's usage documentation.")
.SetMutability(Mutability.ReadOnly)
.SetReferenceTypes(ScimConstants.ReferenceTypes.External);
}
public Registry(
[Import] IManageCryptography cryptograhyManager,
[Import] ScimServerConfiguration serverConfiguration)
{
_CryptograhyManager = cryptograhyManager;
_ServerConfiguration = serverConfiguration;
}
public ServiceLocatorResourceValidatorFactory(
IContainer container,
ScimServerConfiguration serverConfiguration)
{
_Container = container;
_ServerConfiguration = serverConfiguration;
}
public ScimQueryOptionsParameterBinding(
HttpParameterDescriptor descriptor,
ScimServerConfiguration serverConfiguration)
: base(descriptor)
{
_ServerConfiguration = serverConfiguration;
}
public ResourceMetadataDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(m => m.ResourceType)
.SetDescription(@"The name of the resource type of the resource.")
.SetMutability(Mutability.ReadOnly)
.SetCaseExact(true);
For(m => m.Created)
.SetDescription(@"The DateTime that the resource was added to the service provider.")
.SetMutability(Mutability.ReadOnly);
For(m => m.LastModified)
.SetDescription(@"The most recent DateTime that the details of this resource were updated at the service provider.")
.SetMutability(Mutability.ReadOnly);
For(m => m.Location)
.SetDescription(@"The URI of the resource being returned.")
.SetMutability(Mutability.ReadOnly);
For(m => m.Version)
.SetDescription(@"The version of the resource being returned.")
.SetMutability(Mutability.ReadOnly)
.SetCaseExact(true);
}
public SchemasController(
ScimServerConfiguration serverConfiguration,
ISchemaService schemaService)
: base(serverConfiguration)
{
_SchemaService = schemaService;
}
public CustomUserValidator(
ScimServerConfiguration serverConfiguration,
ResourceExtensionValidators extensionValidators,
IUserRepository userRepository,
IManagePasswords passwordManager)
: base(serverConfiguration, extensionValidators, userRepository, passwordManager)
{
}
private static ScimVersion GetScimVersion(IOwinRequest request, ScimServerConfiguration serverConfiguration)
{
var result = _VersionRegex.Match(request.Path.ToString());
if (result.Success)
return new ScimVersion(result.Groups[1].Value); // e.g. groups[] -> /v0/, v0
return serverConfiguration.DefaultScimVersion;
}
public CustomUserValidator(
ScimServerConfiguration serverConfiguration,
ResourceExtensionValidators extensionValidators,
IUserRepository userRepository,
IManagePasswords passwordManager)
: base(serverConfiguration, extensionValidators, userRepository, passwordManager)
{
}
public ScimFeatureDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(f => f.Supported)
.SetDescription(@"A boolean value specifying whether or not the operation is supported.")
.SetRequired(true)
.SetMutability(Mutability.ReadOnly);
}
public CustomUserDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(u => u.NickName)
.SetRequired(true)
.AddCanonicalizationRule(nickName => nickName.ToUpper());
SetValidator <CustomUserValidator>();
}
public X509CertificateDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(cert => cert.Value)
.SetDescription(@"The value of an X.509 certificate.");
For(cert => cert.Ref)
.AddCanonicalizationRule((uri, definition) => Canonicalization.EnforceScimUri(uri, definition, ServerConfiguration));
}
public CustomUserRepository(
ScimServerConfiguration scimServerConfiguration,
IMapper mapper,
KernelUserManager userManager)
{
_scimServerConfiguration = scimServerConfiguration;
_Mapper = mapper;
_UserManager = userManager;
}
public CustomUserDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(u => u.NickName)
.SetRequired(true)
.AddCanonicalizationRule(nickName => nickName.ToUpper());
SetValidator<CustomUserValidator>();
}
public CustomUserRepository(
ScimServerConfiguration scimServerConfiguration,
IMapper mapper,
KernelUserManager userManager)
{
_scimServerConfiguration = scimServerConfiguration;
_Mapper = mapper;
_UserManager = userManager;
}
public UserValidatorFactory(
ScimServerConfiguration serverConfiguration,
IUserRepository userRepository,
IManagePasswords passwordManager)
{
_ServerConfiguration = serverConfiguration;
_UserRepository = userRepository;
_PasswordManager = passwordManager;
}
public ScimUser2Validator(
ScimServerConfiguration serverConfiguration,
ResourceExtensionValidators extensionValidators,
IUserRepository userRepository,
IManagePasswords passwordManager)
: base(serverConfiguration, extensionValidators)
{
_UserRepository = userRepository;
_PasswordManager = passwordManager;
}
/// <summary>
/// Initializes a new instance of <see cref="ScimObjectAdapter{T}" />.
/// </summary>
/// <param name="serverConfiguration">The server configuration.</param>
/// <param name="contractResolver">The <see cref="IContractResolver" />.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public ScimObjectAdapter(ScimServerConfiguration serverConfiguration, IContractResolver contractResolver)
{
_ServerConfiguration = serverConfiguration;
if (contractResolver == null)
{
throw new ArgumentNullException("contractResolver");
}
ContractResolver = contractResolver;
}
public ScimGroup2Validator(
ScimServerConfiguration serverConfiguration,
ResourceExtensionValidators extensionValidators,
IUserRepository userRepository,
IGroupRepository groupRepository)
: base(serverConfiguration, extensionValidators)
{
_UserRepository = userRepository;
_GroupRepository = groupRepository;
}
private static ScimVersion GetScimVersion(IOwinRequest request, ScimServerConfiguration serverConfiguration)
{
var result = _VersionRegex.Match(request.Path.ToString());
if (result.Success)
{
return(new ScimVersion(result.Groups[1].Value)); // e.g. groups[] -> /v0/, v0
}
return(serverConfiguration.DefaultScimVersion);
}
public ServiceProviderConfiguration1Definition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration, ScimConstantsV1.Schemas.ServiceProviderConfig)
{
SetName("Service Provider Configuration");
SetDescription("Schema for representing the service provider's configuration");
For(u => u.Schemas)
.SetReturned(Returned.Always);
For(spc => spc.Id)
.SetReturned(Returned.Never);
For(spc => spc.ExternalId)
.SetReturned(Returned.Never);
For(spc => spc.DocumentationUri)
.SetDescription(@"An HTTP-addressable URL pointing to the service provider's human-consumable help documentation.")
.SetMutability(Mutability.ReadOnly)
.SetReferenceTypes(ScimConstants.ReferenceTypes.External);
For(spc => spc.Patch)
.SetDescription(@"A complex type that specifies PATCH configuration options.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(spc => spc.Bulk)
.SetDescription(@"A complex type that specifies bulk configuration options.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(spc => spc.Filter)
.SetDescription(@"A complex type that specifies FILTER options.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(spc => spc.ChangePassword)
.SetDescription(@"A complex type that specifies configuration options related to changing a password.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(spc => spc.Sort)
.SetDescription(@"A complex type that specifies Sort configuration options.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(spc => spc.ETag)
.SetDescription(@"A complex type that specifies ETag configuration options.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
For(spc => spc.AuthenticationSchemes)
.SetDescription(@"A multi-valued complex type that specifies supported authentication scheme properties.")
.SetMutability(Mutability.ReadOnly)
.SetRequired(true);
}
public GroupService(
ScimServerConfiguration serverConfiguration,
IResourceVersionProvider versionProvider,
IResourceValidatorFactory resourceValidatorFactory,
ICanonicalizationService canonicalizationService,
IGroupRepository groupRepository)
: base(serverConfiguration, versionProvider)
{
_GroupRepository = groupRepository;
_ResourceValidatorFactory = resourceValidatorFactory;
_CanonicalizationService = canonicalizationService;
}
public GroupService(
ScimServerConfiguration serverConfiguration,
IResourceVersionProvider versionProvider,
IResourceValidatorFactory resourceValidatorFactory,
ICanonicalizationService canonicalizationService,
IGroupRepository groupRepository)
: base(serverConfiguration, versionProvider)
{
_GroupRepository = groupRepository;
_ResourceValidatorFactory = resourceValidatorFactory;
_CanonicalizationService = canonicalizationService;
}
public TenantDefinition(ScimServerConfiguration serverConfiguration)
: base(
serverConfiguration,
"Tenant",
"urn:custom:schemas:Tenant",
"tenants",
typeof(TenantValidator),
(schemaIdentifiers, parameterType) => schemaIdentifiers.Contains("urn:custom:schemas:Tenant"))
{
For(tenant => tenant.Name)
.SetRequired(true)
.SetDescription("The name of the tenant.");
}
public ScimFeatureFilterDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(f => f.Supported)
.SetDescription(@"A boolean value specifying whether or not the operation is supported.")
.SetRequired(true)
.SetMutability(Mutability.ReadOnly);
For(f => f.MaxResults)
.SetDescription(@"An integer value specifying the maximum number of resources returned in a response.")
.SetRequired(true)
.SetMutability(Mutability.ReadOnly);
}
public ManagerDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(m => m.Value)
.SetDescription(@"The ""id"" of the SCIM resource representing the user's manager.");
For(m => m.Ref)
.SetDescription(@"The URI of the SCIM resource representing the user's manager.");
For(m => m.DisplayName)
.SetDescription(@"The displayName of the user's manager.")
.SetMutability(Mutability.ReadOnly);
}
internal static void SetRequestInformation(IOwinContext context, ScimServerConfiguration serverConfiguration)
{
var request = context.Request;
var host = request.Scheme + "://" + request.Host.Value;
var baseUri = new Uri(host + request.PathBase.Value);
context.Environment[ScimConstants.Hosting.BaseUri] = baseUri;
CallContext.LogicalSetData(ScimConstants.Hosting.BaseUri, baseUri);
CallContext.LogicalSetData(ScimConstants.Hosting.BasePath, request.PathBase.Value);
CallContext.LogicalSetData(ScimConstants.Hosting.Version, GetScimVersion(request, serverConfiguration));
CallContext.LogicalSetData(ScimConstants.Hosting.HttpMethod, new HttpMethod(context.Request.Method));
CallContext.LogicalSetData(ScimConstants.Hosting.QueryOptions, context.Request.Query.GetScimQueryOptions(serverConfiguration));
}
public SchemaExtensionDefinition(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
For(se => se.Required)
.SetDescription(@"A boolean value that specifies whether or not the schema extension is required for the resource type.")
.SetRequired(true);
For(se => se.Schema)
.SetDescription(
@"The URI of an extended schema, e.g., ""urn: edu:2.0:Staff"". This MUST be equal
to the ""id"" attribute of a ""Schema"" resource.")
.SetRequired(true);
}
public UserService(
ScimServerConfiguration serverConfiguration,
IResourceVersionProvider versionProvider,
ICanonicalizationService canonicalizationService,
IResourceValidatorFactory resourceValidatorFactory,
IUserRepository userRepository,
IManagePasswords passwordManager)
: base(serverConfiguration, versionProvider)
{
_CanonicalizationService = canonicalizationService;
_UserRepository = userRepository;
_PasswordManager = passwordManager;
_ResourceValidatorFactory = resourceValidatorFactory;
}
protected ServiceProviderConfigurationServiceBase(
ScimServerConfiguration serverConfiguration,
IResourceVersionProvider versionProvider)
: base(serverConfiguration, versionProvider)
{
_ServiceProviderConfigurationFactory = new Lazy<ServiceProviderConfiguration>(
() =>
{
var config = CreateServiceProviderConfiguration();
SetResourceVersion(config);
return config;
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceJsonConverter" /> class.
/// </summary>
/// <param name="serverConfiguration">The server configuration.</param>
/// <param name="serializer">The serializer to use.</param>
public ResourceJsonConverter(ScimServerConfiguration serverConfiguration, JsonSerializer serializer)
{
_ServerConfiguration = serverConfiguration;
_Serializer = serializer;
// Remove any instance of ResourceJsonConverter from this instances serializer.
// It shouldn't have any since this is instaniated before it gets added from the calling function,
// but just a precaution to prevent circular references which would cause a stackoverflow if json.net
// didn't catch it.
for (var index = 0; index < _Serializer.Converters.Count; index++)
{
var converter = _Serializer.Converters[index];
if (converter is ResourceJsonConverter)
_Serializer.Converters.RemoveAt(index);
}
}
/// <summary>
/// Parses the <paramref name="uri"/> as a reference to a local resource.
/// Returns null if the specified <paramref name="uri"/> is invalid.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="serverConfiguration">The server configuration.</param>
/// <returns>ScimResourceReference.</returns>
public static ScimResourceReference ToScimResourceReference(this Uri uri, ScimServerConfiguration serverConfiguration)
{
var scimPathBase = AmbientRequestService.BasePath;
var uriPaths = (string.IsNullOrWhiteSpace(scimPathBase)
? uri.AbsolutePath
: uri.AbsolutePath.Replace(scimPathBase, ""))
.TrimStart('/')
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (uriPaths.Length < 2)
return null;
var resourceEndpoint = uriPaths[0];
var resourceId = uriPaths[1];
var resourceDefinition = serverConfiguration
.GetResourceTypeDefinitions(AmbientRequestService.ProtocolVersion)
.SingleOrDefault(rtd => rtd.Endpoint.IndexOf(resourceEndpoint, StringComparison.OrdinalIgnoreCase) >= 0);
if (resourceDefinition == null)
return null; // invalid uri
return new ScimResourceReference(resourceDefinition, resourceId);
}
public InMemoryGroupRepository(ScimServerConfiguration scimServerConfiguration)
{
_Groups = new Dictionary<string, ScimGroup>();
_scimServerConfiguration = scimServerConfiguration;
}
public static ScimQueryOptions GetScimQueryOptions(this IReadableStringCollection collection, ScimServerConfiguration configuration)
{
var queryOptions = new ScimQueryOptions();
queryOptions.Attributes = collection.GetValues("attributes")
.ToMaybe()
.Bind(attributes => new HashSet<string>(attributes.Distinct(StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase).ToMaybe())
.FromMaybe(new HashSet<string>());
queryOptions.ExcludedAttributes = collection.GetValues("excludedAttributes")
.ToMaybe()
.Bind(attributes => new HashSet<string>(attributes.Distinct(StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase).ToMaybe())
.FromMaybe(new HashSet<string>());
queryOptions.Filter = collection.Get("filter")
.ToMaybe()
.Bind(filter =>
{
var scimFilter = new ScimFilter(configuration.ResourceExtensionSchemas.Keys, filter);
return PathFilterExpression.CreateFilterOnly(scimFilter.NormalizedFilterExpression).ToMaybe();
})
.FromMaybe(null);
queryOptions.SortBy = collection.Get("sortBy");
queryOptions.SortOrder = collection.Get("sortOrder")
.ToMaybe()
.Bind(
sortOrder =>
(sortOrder.Equals("descending", StringComparison.OrdinalIgnoreCase)
? SortOrder.Descending
: SortOrder.Ascending).ToMaybe())
.FromMaybe(SortOrder.Ascending); // default
queryOptions.StartIndex = collection.Get("startIndex")
.ToMaybe()
.Bind(index =>
{
// The 1-based index of the first query result. A value less than 1 SHALL be interpreted as 1.
int indexInt = 1;
try { indexInt = Convert.ToInt32(index); } catch {}
return (indexInt < 1 ? 1 : indexInt).ToMaybe();
})
.FromMaybe(1); // default
queryOptions.Count = collection.Get("count")
.ToMaybe()
.Bind(count =>
{
// Non-negative integer. Specifies the desired maximum number of query
// results per page, e.g., 10. A negative value SHALL be interpreted as
// "0". A value of "0" indicates that no resource indicates that no resource
// except for "totalResults".
int countInt = 0;
try { countInt = Convert.ToInt32(count); } catch { }
return (countInt < 0 ? 0 : countInt).ToMaybe();
})
.FromMaybe(configuration.GetFeature<ScimFeatureFilter>(ScimFeatureType.Filter).MaxResults); // default
return queryOptions;
}
public InMemoryUserRepository(ScimServerConfiguration scimServerConfiguration, IGroupRepository groupRepository)
{
_GroupRepository = groupRepository;
_Users = new ConcurrentDictionary<string, ScimUser>();
_scimServerConfiguration = scimServerConfiguration;
}
public ResourceTypesController(ScimServerConfiguration serverConfiguration, IResourceTypeService resourceTypeService)
: base(serverConfiguration)
{
_ResourceTypeService = resourceTypeService;
}
public ServiceProviderConfiguration2Service(
ScimServerConfiguration serverConfiguration,
IResourceVersionProvider versionProvider)
: base(serverConfiguration, versionProvider)
{
}
public ScimClientJsonMediaTypeFormatter(ScimServerConfiguration serverConfiguration)
{
SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/scim+json"));
SerializerSettings.Converters.Add(new ResourceJsonConverter(serverConfiguration, JsonSerializer.Create(SerializerSettings)));
}
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 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;
}
public TenantsController(ScimServerConfiguration serverConfiguration)
: base(serverConfiguration)
{
}
public ResourceTypeService(ScimServerConfiguration serverConfiguration, IResourceVersionProvider versionProvider)
: base(serverConfiguration, versionProvider)
{
_ResourceTypes = new Lazy<IReadOnlyDictionary<string, ResourceType>>(CreateResourceTypes);
}
public ScimAuthorizationAttribute(ScimServerConfiguration serverConfiguration)
{
_ServerConfiguration = serverConfiguration;
}
/// <summary>
/// Initializes a new instance of the <see cref="SchemaService" /> class.
/// </summary>
/// <param name="serverConfiguration">The configuration.</param>
/// <param name="versionProvider">The version provider.</param>
protected SchemaService(ScimServerConfiguration serverConfiguration, IResourceVersionProvider versionProvider)
: base(serverConfiguration, versionProvider)
{
_Schemas = new Lazy<IReadOnlyDictionary<string, ScimSchema>>(CreateSchemas);
}
public ScimPatchObjectAnalysis(
ScimServerConfiguration serverConfiguration,
object objectToSearch,
string filter,
IContractResolver contractResolver,
Operation operation)
{
_ServerConfiguration = serverConfiguration;
_ContractResolver = contractResolver;
_Operation = operation;
PatchMembers = new List<PatchMember>();
/*
ScimFilter.cs will handle normalizing the actual path string.
Examples:
"path":"members"
"path":"name.familyName"
"path":"addresses[type eq \"work\"]"
"path":"members[value eq \"2819c223-7f76-453a-919d-413861904646\"]"
"path":"members[value eq \"2819c223-7f76-453a-919d-413861904646\"].displayName"
Once normalized, associate each resource member with its filter (if present).
This is represented as a PathMember, which is essentially a tuple of <memberName, memberFilter?>
*/
var pathTree = new ScimFilter(_ServerConfiguration.ResourceExtensionSchemas.Keys, filter).Paths.ToList();
var lastPosition = 0;
var nodes = GetAffectedMembers(pathTree, ref lastPosition, new Node(objectToSearch, null));
if ((pathTree.Count - lastPosition) > 1)
{
IsValidPathForAdd = false;
IsValidPathForRemove = false;
return;
}
foreach (var node in nodes)
{
var attribute = node.Target as MultiValuedAttribute;
JsonProperty attemptedProperty;
if (attribute != null && PathIsMultiValuedEnumerable(pathTree[pathTree.Count - 1].Path, node, out attemptedProperty))
{
/* Check if we're at a MultiValuedAttribute.
If so, then we'll return a special PatchMember. This is because our actual target is
an element within an enumerable. (e.g. User->Emails[element])
So a PatchMember must have three pieces of information: (following the example above)
> Parent (User)
> PropertyPath (emails)
> Actual Target (email instance/element)
*/
UseDynamicLogic = false;
IsValidPathForAdd = true;
IsValidPathForRemove = true;
PatchMembers.Add(
new PatchMember(
pathTree[pathTree.Count - 1].Path,
new JsonPatchProperty(attemptedProperty, node.Parent),
node.Target));
}
else
{
UseDynamicLogic = false;
var jsonContract = (JsonObjectContract)contractResolver.ResolveContract(node.Target.GetType());
attemptedProperty = jsonContract.Properties.GetClosestMatchProperty(pathTree[pathTree.Count - 1].Path);
if (attemptedProperty == null)
{
IsValidPathForAdd = false;
IsValidPathForRemove = false;
}
else
{
IsValidPathForAdd = true;
IsValidPathForRemove = true;
PatchMembers.Add(
new PatchMember(
pathTree[pathTree.Count - 1].Path,
new JsonPatchProperty(attemptedProperty, node.Target)));
}
}
}
}
