public async Task CanCreate_should_not_throw_exception_if_added_to_root()
{
var command = new CreateAssetFolder {
AppId = appId, FolderName = "My Folder"
};
await GuardAssetFolder.CanCreate(command, assetQuery);
}
public async Task CanCreate_should_throw_exception_when_folder_name_not_defined()
{
var command = new CreateAssetFolder();
A.CallTo(() => assetQuery.FindAssetFolderAsync(command.ParentId))
.Returns(new List <IAssetFolderEntity>());
await ValidationAssert.ThrowsAsync(() => GuardAssetFolder.CanCreate(command, assetQuery),
new ValidationError("Folder name is required.", "FolderName"));
}
public async Task CanCreate_should_throw_exception_if_folder_not_found()
{
var command = new CreateAssetFolder {
AppId = appId, FolderName = "My Folder", ParentId = DomainId.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, command.ParentId, A <CancellationToken> ._))
.Returns(new List <IAssetFolderEntity>());
await ValidationAssert.ThrowsAsync(() => GuardAssetFolder.CanCreate(command, assetQuery),
new ValidationError("Asset folder does not exist.", "ParentId"));
}
public async Task CanCreate_should_not_throw_exception_if_folder_found()
{
var command = new CreateAssetFolder {
AppId = appId, FolderName = "My Folder", ParentId = DomainId.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(appId.Id, command.ParentId, A <CancellationToken> ._))
.Returns(new List <IAssetFolderEntity> {
AssetFolder()
});
await GuardAssetFolder.CanCreate(command, assetQuery);
}
private async Task CreateCore(CreateAssetFolder create, CreateAssetFolder c)
{
var operation = await AssetFolderOperation.CreateAsync(serviceProvider, c, () => Snapshot);
operation.MustHaveName(c.FolderName);
if (!c.OptimizeValidation)
{
await operation.MustMoveToValidFolder(c.ParentId);
}
Create(create);
}
public async Task CanCreate_should_not_throw_exception_when_folder_found()
{
var command = new CreateAssetFolder {
FolderName = "My Folder", ParentId = Guid.NewGuid()
};
A.CallTo(() => assetQuery.FindAssetFolderAsync(command.ParentId))
.Returns(new List <IAssetFolderEntity> {
CreateFolder()
});
await GuardAssetFolder.CanCreate(command, assetQuery);
}
public static Task CanCreate(CreateAssetFolder command, IAssetQueryService assetQuery)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(async e =>
{
if (string.IsNullOrWhiteSpace(command.FolderName))
{
e(Not.Defined(nameof(command.FolderName)), nameof(command.FolderName));
}
await CheckPathAsync(command.AppId.Id, command.ParentId, assetQuery, DomainId.Empty, e);
}));
}
public static Task CanCreate(CreateAssetFolder command, IAssetQueryService assetQuery)
{
Guard.NotNull(command);
return(Validate.It(() => "Cannot upload asset.", async e =>
{
if (string.IsNullOrWhiteSpace(command.FolderName))
{
e(Not.Defined("Folder name"), nameof(command.FolderName));
}
await CheckPathAsync(command.ParentId, assetQuery, Guid.Empty, e);
}));
}
public async Task Create_should_create_events_and_set_intitial_state()
{
var command = new CreateAssetFolder {
FolderName = "New Name"
};
var result = await PublishAsync(command);
result.ShouldBeEquivalent(sut.Snapshot);
Assert.Equal(command.FolderName, sut.Snapshot.FolderName);
LastEvents
.ShouldHaveSameEvents(
CreateAssetFolderEvent(new AssetFolderCreated {
FolderName = command.FolderName
})
);
}
public void Create(CreateAssetFolder command)
{
RaiseEvent(SimpleMapper.Map(command, new AssetFolderCreated()));
}
private void Create(CreateAssetFolder command)
{
Raise(command, new AssetFolderCreated());
}
public async Task <DomainId> ResolveOrCreateAsync(Context context, ICommandBus commandBus, string path)
{
Guard.NotNull(commandBus, nameof(commandBus));
Guard.NotNull(path, nameof(path));
path = path.Trim(TrimChars);
var elements = path.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries);
if (elements.Length == 0)
{
return(DomainId.Empty);
}
var currentId = DomainId.Empty;
var i = elements.Length;
for (; i > 0; i--)
{
var subPath = string.Join('/', elements.Take(i));
if (localCache.TryGetValue(GetCacheKey(subPath), out var cached) && cached is DomainId id)
{
currentId = id;
break;
}
}
var creating = false;
for (; i < elements.Length; i++)
{
var name = elements[i];
var isResolved = false;
if (!creating)
{
var children = await assetQuery.QueryAssetFoldersAsync(context, currentId);
foreach (var child in children)
{
var childPath = string.Join('/', elements.Take(i).Union(Enumerable.Repeat(child.FolderName, 1)));
localCache.Add(GetCacheKey(childPath), child.Id);
}
foreach (var child in children)
{
if (child.FolderName == name)
{
currentId = child.Id;
isResolved = true;
break;
}
}
}
if (!isResolved)
{
var command = new CreateAssetFolder {
ParentId = currentId, FolderName = name
};
await commandBus.PublishAsync(command);
currentId = command.AssetFolderId;
creating = true;
}
var newPath = string.Join('/', elements.Take(i).Union(Enumerable.Repeat(name, 1)));
localCache.Add(GetCacheKey(newPath), currentId);
}
return(currentId);
}
