public CollectionResourceExecutor(string collectionHref, IInternalDataStore dataStore, Expression expression)
{
this.collectionHref = collectionHref;
this.asyncDataStore = dataStore as IInternalAsyncDataStore;
this.syncDataStore = dataStore as IInternalSyncDataStore;
this.expression = expression;
}
/// <summary>
/// Adds an Account Store to this resource based on the result of a query.
/// </summary>
/// <typeparam name="T">The Account Store type.</typeparam>
/// <typeparam name="TMapping">The Account Store Mapping type.</typeparam>
/// <param name="container">The Account Store container.</param>
/// <param name="internalDataStore">The internal data store.</param>
/// <param name="query">A query that selects a single Account Store.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The new <see cref="IAccountStoreMapping"/>.</returns>
public static async Task <TMapping> AddAccountStoreAsync <T, TMapping>(
IAccountStoreContainer <TMapping> container,
IInternalAsyncDataStore internalDataStore,
Func <IAsyncQueryable <T>, IAsyncQueryable <T> > query,
CancellationToken cancellationToken)
where TMapping : class, IAccountStoreMapping <TMapping>
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
IAccountStore foundAccountStore = null;
if (typeof(T) == typeof(IDirectory))
{
var directoryQuery = query as Func <IAsyncQueryable <IDirectory>, IAsyncQueryable <IDirectory> >;
foundAccountStore = await GetSingleTenantDirectoryAsync(container, directoryQuery, cancellationToken).ConfigureAwait(false);
}
else if (typeof(T) == typeof(IGroup))
{
var groupQuery = query as Func <IAsyncQueryable <IGroup>, IAsyncQueryable <IGroup> >;
foundAccountStore = await GetSingleTenantGroupAsync(container, groupQuery, cancellationToken).ConfigureAwait(false);
}
if (foundAccountStore != null)
{
return((TMapping) await AddAccountStoreAsync(container, internalDataStore, foundAccountStore, cancellationToken).ConfigureAwait(false));
}
// No account store can be added
return(null);
}
public static Task<IAccount> CreateAccountAsync(IInternalAsyncDataStore dataStore, string accountsHref, IAccount account, Action<AccountCreationOptionsBuilder> creationOptionsAction, CancellationToken cancellationToken)
{
var builder = new AccountCreationOptionsBuilder();
creationOptionsAction(builder);
var options = builder.Build();
return dataStore.CreateAsync(accountsHref, account, options, cancellationToken);
}
public ResourceData(IInternalDataStore dataStore)
{
this.internalDataStore = dataStore;
this.internalDataStoreAsync = dataStore as IInternalAsyncDataStore;
this.internalDataStoreSync = dataStore as IInternalSyncDataStore;
this.Update();
}
public ResourceData(IInternalDataStore dataStore)
{
this.internalDataStore = dataStore;
this.internalDataStoreAsync = dataStore as IInternalAsyncDataStore;
this.internalDataStoreSync = dataStore as IInternalSyncDataStore;
this.Update();
}
public static Task<IGroup> CreateGroupAsync(IInternalAsyncDataStore internalDataStore, string groupsHref, IGroup group, Action<GroupCreationOptionsBuilder> creationOptionsAction, CancellationToken cancellationToken)
{
var builder = new GroupCreationOptionsBuilder();
creationOptionsAction(builder);
var options = builder.Build();
return internalDataStore.CreateAsync(groupsHref, group, options, cancellationToken);
}
public static Task <IGroup> CreateGroupAsync(IInternalAsyncDataStore internalDataStore, string groupsHref, string name, string description, CancellationToken cancellationToken)
{
var group = internalDataStore.Instantiate <IGroup>()
.SetName(name)
.SetDescription(description)
.SetStatus(GroupStatus.Enabled);
return(internalDataStore.CreateAsync(groupsHref, group, cancellationToken));
}
public static Task <IGroup> CreateGroupAsync(IInternalAsyncDataStore internalDataStore, string groupsHref, IGroup group, Action <GroupCreationOptionsBuilder> creationOptionsAction, CancellationToken cancellationToken)
{
var builder = new GroupCreationOptionsBuilder();
creationOptionsAction(builder);
var options = builder.Build();
return(internalDataStore.CreateAsync(groupsHref, group, options, cancellationToken));
}
public static Task<IGroup> CreateGroupAsync(IInternalAsyncDataStore internalDataStore, string groupsHref, string name, string description, CancellationToken cancellationToken)
{
var group = internalDataStore.Instantiate<IGroup>()
.SetName(name)
.SetDescription(description)
.SetStatus(GroupStatus.Enabled);
return internalDataStore.CreateAsync(groupsHref, group, cancellationToken);
}
public static Task <IAccount> CreateAccountAsync(IInternalAsyncDataStore dataStore, string accountsHref, IAccount account, Action <AccountCreationOptionsBuilder> creationOptionsAction, CancellationToken cancellationToken)
{
var builder = new AccountCreationOptionsBuilder();
creationOptionsAction(builder);
var options = builder.Build();
return(dataStore.CreateAsync(accountsHref, account, options, cancellationToken));
}
public BasicAuthenticator(IInternalDataStore dataStore)
{
this.dataStore = dataStore;
this.dataStoreAsync = dataStore as IInternalAsyncDataStore;
this.dataStoreSync = dataStore as IInternalSyncDataStore;
if (this.dataStore == null ||
this.dataStoreSync == null)
{
throw new ArgumentNullException("Internal data store could not be initialized.");
}
}
/// <summary>
/// Creates a new Account Store Mapping.
/// </summary>
/// <typeparam name="TMapping">The Account Store Mapping type.</typeparam>
/// <param name="container">The Account Store container.</param>
/// <param name="internalDataStore">The internal data store.</param>
/// <param name="mapping">The new mapping to create.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The new <see cref="IAccountStoreMapping"/>.</returns>
public static async Task <TMapping> CreateAccountStoreMappingAsync <TMapping>(
IAccountStoreContainer <TMapping> container,
IInternalAsyncDataStore internalDataStore,
IAccountStoreMapping <TMapping> mapping,
CancellationToken cancellationToken)
where TMapping : class, IAccountStoreMapping <TMapping>
{
SetContainer(mapping, container);
var href = ResolveEndpointHref(container);
return((TMapping)(await internalDataStore.CreateAsync(href, mapping, cancellationToken).ConfigureAwait(false)));
}
public BasicAuthenticator(IInternalDataStore dataStore)
{
this.dataStore = dataStore;
this.dataStoreAsync = dataStore as IInternalAsyncDataStore;
this.dataStoreSync = dataStore as IInternalSyncDataStore;
if (this.dataStore == null ||
this.dataStoreSync == null)
{
throw new ArgumentNullException("Internal data store could not be initialized.");
}
}
public CollectionResourceExecutor(IAsyncExecutor <TResult> executor, Expression newExpression)
{
this.expression = newExpression;
var cre = executor as CollectionResourceExecutor <TResult>;
if (cre != null)
{
this.collectionHref = cre.collectionHref;
this.asyncDataStore = cre.asyncDataStore;
this.syncDataStore = cre.syncDataStore;
}
}
/// <summary>
/// Adds an Account Store to this resource.
/// </summary>
/// <typeparam name="TMapping">The Account Store Mapping type.</typeparam>
/// <param name="container">The Account Store container.</param>
/// <param name="internalDataStore">The internal data store.</param>
/// <param name="accountStore">The Account Store to add.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The new <see cref="IAccountStoreMapping"/>.</returns>
public static async Task <TMapping> AddAccountStoreAsync <TMapping>(
IAccountStoreContainer <TMapping> container,
IInternalAsyncDataStore internalDataStore,
IAccountStore accountStore,
CancellationToken cancellationToken)
where TMapping : class, IAccountStoreMapping <TMapping>
{
var accountStoreMapping = internalDataStore
.Instantiate <IAccountStoreMapping <TMapping> >()
.SetAccountStore(accountStore)
.SetListIndex(int.MaxValue);
SetContainer(accountStoreMapping, container);
return((TMapping)(await CreateAccountStoreMappingAsync(container, internalDataStore, accountStoreMapping, cancellationToken).ConfigureAwait(false)));
}
/// <summary>
/// Gets the default Account or Group Store at the given <c>href</c>, if it exists.
/// </summary>
/// <param name="storeMappingHref">The AccountStoreMapping <c>href</c>.</param>
/// <param name="internalDataStore">The <see cref="IInternalAsyncDataStore"/>.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The <see cref="IAccountStore">Account Store</see>, or <see langword="null"/>.</returns>
public static async Task <IAccountStore> GetDefaultStoreAsync(
string storeMappingHref,
IInternalAsyncDataStore internalDataStore,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(storeMappingHref))
{
return(null);
}
var accountStoreMapping = await internalDataStore
.GetResourceAsync <IAccountStoreMapping>(storeMappingHref, cancellationToken)
.ConfigureAwait(false);
return(accountStoreMapping == null
? null
: await accountStoreMapping.GetAccountStoreAsync().ConfigureAwait(false));
}
public DefaultClient(
IClientApiKey apiKey,
string baseUrl,
AuthenticationScheme authenticationScheme,
int connectionTimeout,
IWebProxy proxy,
IHttpClient httpClient,
IJsonSerializer serializer,
ICacheProvider cacheProvider,
IUserAgentBuilder userAgentBuilder,
ILogger logger,
TimeSpan identityMapExpiration)
{
if (apiKey == null || !apiKey.IsValid())
{
throw new ArgumentException("API Key is not valid.");
}
if (string.IsNullOrEmpty(baseUrl))
{
throw new ArgumentNullException("Base URL cannot be empty.");
}
if (connectionTimeout < 0)
{
throw new ArgumentException("Timeout cannot be negative.");
}
this.logger = logger;
this.apiKey = apiKey;
this.baseUrl = baseUrl;
this.connectionTimeout = connectionTimeout;
this.proxy = proxy;
this.cacheProvider = cacheProvider;
this.authenticationScheme = authenticationScheme;
this.serializer = serializer;
this.httpClient = httpClient;
var requestExecutor = new DefaultRequestExecutor(httpClient, apiKey, authenticationScheme, this.logger);
this.dataStore = new DefaultDataStore(this as IClient, requestExecutor, baseUrl, this.serializer, this.logger, userAgentBuilder, cacheProvider, identityMapExpiration);
this.dataStoreAsync = this.dataStore as IInternalAsyncDataStore;
this.dataStoreSync = this.dataStore as IInternalSyncDataStore;
}
public static Task<IGroupMembership> CreateAsync(IAccount account, IGroup group, IInternalAsyncDataStore dataStore, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(account.Href))
{
throw new ApplicationException("You must persist the account first before assigning it to a group.");
}
if (string.IsNullOrEmpty(group.Href))
{
throw new ApplicationException("You must persist the group first because assigning it to a group.");
}
var groupMembership = (DefaultGroupMembership)dataStore.Instantiate<IGroupMembership>();
groupMembership.SetGroup(group);
groupMembership.SetAccount(account);
var href = "/groupMemberships";
return dataStore.CreateAsync<IGroupMembership>(href, groupMembership, cancellationToken);
}
public static Task<IAccount> CreateAccountAsync(IInternalAsyncDataStore dataStore, string accountsHref, IAccount account, CancellationToken cancellationToken)
=> dataStore.CreateAsync(accountsHref, account, cancellationToken);
public static Task <IAccount> CreateAccountAsync(IInternalAsyncDataStore dataStore, string accountsHref, string givenName, string surname, string email, string password, object customData, CancellationToken cancellationToken)
{
var account = CreateAccountWith(dataStore, givenName, surname, email, password, customData);
return(CreateAccountAsync(dataStore, accountsHref, account, cancellationToken: cancellationToken));
}
public Directory_options()
{
this.dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Directory).Object) as IInternalAsyncDataStore;
}
public DefaultClient(
IClientApiKey apiKey,
string baseUrl,
AuthenticationScheme authenticationScheme,
int connectionTimeout,
IWebProxy proxy,
IHttpClient httpClient,
IJsonSerializer serializer,
ICacheProvider cacheProvider,
IUserAgentBuilder userAgentBuilder,
ILogger logger,
TimeSpan identityMapExpiration)
{
if (apiKey == null || !apiKey.IsValid())
{
throw new ArgumentException("API Key is not valid.");
}
if (string.IsNullOrEmpty(baseUrl))
{
throw new ArgumentNullException("Base URL cannot be empty.");
}
if (connectionTimeout < 0)
{
throw new ArgumentException("Timeout cannot be negative.");
}
this.logger = logger;
this.apiKey = apiKey;
this.baseUrl = baseUrl;
this.connectionTimeout = connectionTimeout;
this.proxy = proxy;
this.cacheProvider = cacheProvider;
this.authenticationScheme = authenticationScheme;
this.serializer = serializer;
this.httpClient = httpClient;
var requestExecutor = new DefaultRequestExecutor(httpClient, apiKey, authenticationScheme, this.logger);
this.dataStore = new DefaultDataStore(this as IClient, requestExecutor, baseUrl, this.serializer, this.logger, userAgentBuilder, cacheProvider, identityMapExpiration);
this.dataStoreAsync = this.dataStore as IInternalAsyncDataStore;
this.dataStoreSync = this.dataStore as IInternalSyncDataStore;
}
public DefaultAsynchronousFilterChain(IInternalAsyncDataStore dataStore)
: this(dataStore, Enumerable.Empty<IAsynchronousFilter>())
{
}
public ProviderAccountResolver(IInternalDataStore dataStore)
{
this.dataStoreAsync = dataStore as IInternalAsyncDataStore;
this.dataStoreSync = dataStore as IInternalSyncDataStore;
}
public ProviderAccountResolver(IInternalDataStore dataStore)
{
this.dataStoreAsync = dataStore as IInternalAsyncDataStore;
this.dataStoreSync = dataStore as IInternalSyncDataStore;
}
internal DefaultAsynchronousFilterChain(IInternalAsyncDataStore dataStore, IEnumerable<IAsynchronousFilter> filters)
{
this.dataStore = dataStore;
this.filters = new List<IAsynchronousFilter>(filters);
}
public static Task <IGroup> CreateGroupAsync(IInternalAsyncDataStore internalDataStore, string groupsHref, IGroup group, IGroupCreationOptions creationOptions, CancellationToken cancellationToken) => internalDataStore.CreateAsync(groupsHref, group, creationOptions, cancellationToken);
/// <summary>
/// Adds an Account Store to this resource by <c>href</c> or name.
/// </summary>
/// <typeparam name="TMapping">The Account Store Mapping type.</typeparam>
/// <param name="container">The Account Store container.</param>
/// <param name="internalDataStore">The internal data store.</param>
/// <param name="hrefOrName">The name or <c>href</c> of the Account Store to add.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The new <see cref="IAccountStoreMapping"/>.</returns>
public static async Task <TMapping> AddAccountStoreAsync <TMapping>(
IAccountStoreContainer <TMapping> container,
IInternalAsyncDataStore internalDataStore,
string hrefOrName,
CancellationToken cancellationToken)
where TMapping : class, IAccountStoreMapping <TMapping>
{
if (string.IsNullOrEmpty(hrefOrName))
{
throw new ArgumentNullException(nameof(hrefOrName));
}
IAccountStore accountStore = null;
var splitHrefOrName = hrefOrName.Split('/');
bool looksLikeHref = splitHrefOrName.Length > 4;
if (looksLikeHref)
{
bool?isDirectoryType = null;
if (splitHrefOrName.Length == container.Href.Split('/').Length)
{
if (splitHrefOrName[4].Equals("directories", StringComparison.InvariantCultureIgnoreCase))
{
isDirectoryType = true;
}
else if (splitHrefOrName[4].Equals("groups", StringComparison.InvariantCultureIgnoreCase))
{
isDirectoryType = false;
}
}
if (isDirectoryType != null)
{
try
{
if (isDirectoryType == true)
{
accountStore = await internalDataStore.GetResourceAsync <IDirectory>(hrefOrName, cancellationToken).ConfigureAwait(false);
}
else if (isDirectoryType == false)
{
accountStore = await internalDataStore.GetResourceAsync <IGroup>(hrefOrName, cancellationToken).ConfigureAwait(false);
}
}
catch (ResourceException)
{
// It looked like an href, but no resource was found.
// We'll try looking it up by name.
}
}
}
if (accountStore == null)
{
// Try to find both a Directory and a Group with the given name
var directory = await GetSingleTenantDirectoryAsync(container, x => x.Where(d => d.Name == hrefOrName), cancellationToken).ConfigureAwait(false);
var group = await GetSingleTenantGroupAsync(container, x => x.Where(g => g.Name == hrefOrName), cancellationToken).ConfigureAwait(false);
if (directory != null && group != null)
{
throw new ArgumentException(
"There is both a Directory and a Group matching the provided name in the current tenant. " +
"Please provide the href of the intended Resource instead of its name in order to unambiguously identify it.");
}
accountStore = directory != null
? directory as IAccountStore
: group as IAccountStore;
}
if (accountStore != null)
{
return((TMapping) await AddAccountStoreAsync(container, internalDataStore, accountStore, cancellationToken).ConfigureAwait(false));
}
// Could not find any resource matching the hrefOrName value
return(null);
}
public Application_options()
{
this.dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Application).Object) as IInternalAsyncDataStore;
}
public Directory_options()
{
this.dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Directory).Object) as IInternalAsyncDataStore;
}
public static Task <IAccount> CreateAccountAsync(IInternalAsyncDataStore dataStore, string accountsHref, IAccount account, CancellationToken cancellationToken) => dataStore.CreateAsync(accountsHref, account, cancellationToken);
public DefaultAsynchronousFilterChain(IInternalAsyncDataStore dataStore)
: this(dataStore, Enumerable.Empty <IAsynchronousFilter>())
{
}
public Application_options()
{
this.dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Application).Object) as IInternalAsyncDataStore;
}
public static Task<IGroup> CreateGroupAsync(IInternalAsyncDataStore internalDataStore, string groupsHref, IGroup group, IGroupCreationOptions creationOptions, CancellationToken cancellationToken)
=> internalDataStore.CreateAsync(groupsHref, group, creationOptions, cancellationToken);
internal DefaultAsynchronousFilterChain(IInternalAsyncDataStore dataStore, IEnumerable <IAsynchronousFilter> filters)
{
this.dataStore = dataStore;
this.filters = new List <IAsynchronousFilter>(filters);
}
public static Task <IGroupMembership> CreateAsync(IAccount account, IGroup group, IInternalAsyncDataStore dataStore, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(account.Href))
{
throw new ApplicationException("You must persist the account first before assigning it to a group.");
}
if (string.IsNullOrEmpty(group.Href))
{
throw new ApplicationException("You must persist the group first because assigning it to a group.");
}
var groupMembership = (DefaultGroupMembership)dataStore.Instantiate <IGroupMembership>();
groupMembership.SetGroup(group);
groupMembership.SetAccount(account);
var href = "/groupMemberships";
return(dataStore.CreateAsync <IGroupMembership>(href, groupMembership, cancellationToken));
}
public static Task<IAccount> CreateAccountAsync(IInternalAsyncDataStore dataStore, string accountsHref, string givenName, string surname, string email, string password, object customData, CancellationToken cancellationToken)
{
var account = CreateAccountWith(dataStore, givenName, surname, email, password, customData);
return CreateAccountAsync(dataStore, accountsHref, account, cancellationToken: cancellationToken);
}
