public static async Task <PostPermissions> FromCacheAsync(
IInternalUserLoader internalUserLoader,
CachePostPermissions cachePostPermissions,
CancellationToken cancellationToken)
{
Ensure.Argument.IsNotNull(internalUserLoader, nameof(internalUserLoader));
Ensure.Argument.IsNotNull(cachePostPermissions, nameof(cachePostPermissions));
// Load dependencies.
var userTasks = cachePostPermissions.UserIds?.Select(u => internalUserLoader.FetchAsync(u, cancellationToken)).ToList() ?? new List <Task <User> >();
var groupTasks = cachePostPermissions.Groups?.Select(g => PostReference.FromCacheAsync(internalUserLoader, g, cancellationToken)).ToList() ?? new List <Task <PostReference> >();
await Task.WhenAll(
Task.WhenAll(userTasks),
Task.WhenAll(groupTasks)
);
var users = userTasks.Select(t => t.Result).ToList();
Ensure.Dependency.IsNotNull(users, nameof(users));
// Create the resulting post permissions.
return(new PostPermissions
{
IsPublic = cachePostPermissions.IsPublic,
Users = users,
Groups = groupTasks.Select(t => t.Result).ToList()
});
}
public static async Task <PostReference> FromCacheAsync(
IInternalUserLoader internalUserLoader,
CachePostReference cachePostReference,
CancellationToken cancellationToken)
{
Ensure.Argument.IsNotNull(internalUserLoader, nameof(internalUserLoader));
Ensure.Argument.IsNotNull(cachePostReference, nameof(cachePostReference));
// Retrieve dependencies.
var user = await internalUserLoader.FetchAsync(cachePostReference.UserId, cancellationToken);
Ensure.Dependency.IsNotNull(user, nameof(user));
return(new PostReference
{
User = user,
OriginalEntity = cachePostReference.OriginalEntity,
PostId = cachePostReference.PostId,
VersionId = cachePostReference.VersionId,
Type = PostType.FromString(cachePostReference.Type),
Role = cachePostReference.Role,
IsPublic = cachePostReference.IsPublic
});
}
public UserLoader(
IInternalUserLoader internalUserLoader,
IExternalUserLoader externalUserLoader,
ITaskHelpers taskHelpers,
IUriHelpers uriHelpers)
{
Ensure.Argument.IsNotNull(internalUserLoader, nameof(internalUserLoader));
Ensure.Argument.IsNotNull(externalUserLoader, nameof(externalUserLoader));
Ensure.Argument.IsNotNull(taskHelpers, nameof(taskHelpers));
Ensure.Argument.IsNotNull(uriHelpers, nameof(uriHelpers));
this.internalUserLoader = internalUserLoader;
this.externalUserLoader = externalUserLoader;
this.taskHelpers = taskHelpers;
this.uriHelpers = uriHelpers;
}
private async Task <User> CreateExpectedUserAsync(IInternalUserLoader internalUserLoader)
{
// Create the resource.
var user = internalUserLoader.MakeNew(new CacheUser
{
Id = this.global.RandomId(),
VersionId = this.global.RandomId(),
Handle = "testhandle",
Email = "*****@*****.**",
Entity = "https://entity.quentez.com",
CreatedAt = DateTime.UtcNow
});
// Save it.
await user.SaveAsync();
return(user);
}
public InternalPostLoader(
ITables tables,
IPostLicenseLoader postLicenseLoader,
ITextHelpers textHelpers,
IResourceCacheService resourceCacheService,
IInternalUserLoader internalUserLoader,
IAttachmentLoader attachmentLoader)
{
Ensure.Argument.IsNotNull(tables, nameof(tables));
Ensure.Argument.IsNotNull(postLicenseLoader, nameof(postLicenseLoader));
Ensure.Argument.IsNotNull(textHelpers, nameof(textHelpers));
Ensure.Argument.IsNotNull(resourceCacheService, nameof(resourceCacheService));
Ensure.Argument.IsNotNull(internalUserLoader, nameof(internalUserLoader));
Ensure.Argument.IsNotNull(attachmentLoader, nameof(attachmentLoader));
this.textHelpers = textHelpers;
this.resourceCacheService = resourceCacheService;
this.internalUserLoader = internalUserLoader;
this.attachmentLoader = attachmentLoader;
this.postLicenseLoader = postLicenseLoader;
this.postTable = tables.TableForVersionedType <CachePost>();
}
public static async Task <Post> FromCacheAsync(
IResourceCacheService resourceCacheService,
IInternalUserLoader internalUserLoader,
IAttachmentLoader attachmentLoader,
IPostLicenseLoader postLicenseLoader,
CachePost cachePost,
CancellationToken cancellationToken)
{
Ensure.Argument.IsNotNull(internalUserLoader, nameof(internalUserLoader));
Ensure.Argument.IsNotNull(attachmentLoader, nameof(attachmentLoader));
Ensure.Argument.IsNotNull(postLicenseLoader, nameof(postLicenseLoader));
Ensure.Argument.IsNotNull(cachePost, nameof(cachePost));
// Resolve dependencies.
var userTask = internalUserLoader.FetchAsync(cachePost.UserId, cancellationToken);
var permissionsTask = PostPermissions.FromCacheAsync(internalUserLoader, cachePost.Permissions, cancellationToken);
var linksTasks = cachePost.Links?.Select(r => PostReference.FromCacheAsync(internalUserLoader, r, cancellationToken)).ToList() ?? new List <Task <PostReference> >();
var attachmentsTasks = cachePost.Attachments?.Select(a => PostAttachment.FromCacheAsync(attachmentLoader, a, cancellationToken)).ToList() ?? new List <Task <PostAttachment> >();
var licensesTasks = cachePost.Licenses?.Select(l => postLicenseLoader.LoadAsync(l, cancellationToken)).ToList() ?? new List <Task <PostLicense> >();
await Task.WhenAll(
userTask,
permissionsTask,
Task.WhenAll(linksTasks),
Task.WhenAll(attachmentsTasks),
Task.WhenAll(licensesTasks)
);
// Make sure all of our required dependencies are here.
var user = userTask.Result;
Ensure.Dependency.IsNotNull(user, nameof(user));
var licenses = licensesTasks.Select(t => t.Result).ToList();
Ensure.Dependency.IsNotNull(licenses, nameof(licenses));
return(new Post(resourceCacheService)
{
Id = cachePost.Id,
VersionId = cachePost.VersionId,
CreatedAt = cachePost.CreatedAt,
DeletedAt = cachePost.DeletedAt,
OriginalCreatedAt = cachePost.OriginalCreatedAt,
// User.
User = user,
OriginalEntity = cachePost.OriginalEntity,
// Version.
Type = PostType.FromString(cachePost.Type),
Permissions = permissionsTask.Result,
Links = linksTasks.Select(t => t.Result).ToList(),
Attachments = attachmentsTasks.Select(t => t.Result).ToList(),
Licenses = licenses,
// Dates.
PublishedAt = cachePost.PublishedAt,
OriginalPublishedAt = cachePost.OriginalPublishedAt
});
}
