public static async Task <PostAttachment> FromCacheAsync(
IAttachmentLoader attachmentLoader,
CachePostAttachment cachePostAttachment,
CancellationToken cancellationToken)
{
Ensure.Argument.IsNotNull(attachmentLoader, nameof(attachmentLoader));
Ensure.Argument.IsNotNull(cachePostAttachment, nameof(cachePostAttachment));
// Load dependencies.
var attachment = await attachmentLoader.FetchAsync(cachePostAttachment.AttachmentId, cancellationToken);
Ensure.Dependency.IsNotNull(attachment, nameof(attachment));
// Create the new post attachment.
return(new PostAttachment
{
Attachment = attachment,
Category = cachePostAttachment.Category,
Name = cachePostAttachment.Name,
ContentType = cachePostAttachment.ContentType
});
}
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 SkeletonJsonReader(IAttachmentLoader attachmentLoader)
{
this.attachmentLoader = attachmentLoader;
}
public SkeletonJsonReader(TextureAtlas atlas)
{
attachmentLoader = new TextureAtlasAttachmentLoader(atlas);
}
/// <summary>
/// Initializes a new instance of the <see cref="SkeletonJson" /> class.
/// </summary>
/// <param name="atlas">The atlas.</param>
public SkeletonJson(Atlas atlas)
{
this.attachmentLoader = new AtlasAttachmentLoader(atlas);
this.Scale = 1;
}
/// <summary>
/// Initializes a new instance of the <see cref="SkeletonJson" /> class.
/// </summary>
/// <param name="attachmentLoader">The attachment loader.</param>
/// <exception cref="System.ArgumentNullException">attachmentLoader cannot be null.</exception>
public SkeletonJson(IAttachmentLoader attachmentLoader)
{
if (attachmentLoader == null)
{
throw new ArgumentNullException("attachmentLoader cannot be null.");
}
this.attachmentLoader = attachmentLoader;
this.Scale = 1;
}
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
});
}
