public async Task Multiple_And_Simple_State_Check_Should_Be_Prevent_Multiple_Checks()
{
var myStateEntities = new SimpleStateCheckerTestBase.MyStateEntity[]
{
new SimpleStateCheckerTestBase.MyStateEntity()
{
CreationTime = DateTime.Parse("2022-01-01", CultureInfo.InvariantCulture)
},
new SimpleStateCheckerTestBase.MyStateEntity()
{
CreationTime = DateTime.Parse("2020-01-01", CultureInfo.InvariantCulture),
}
};
myStateEntities[0].AddSimpleStateChecker(new MySimpleBatchStateChecker());
myStateEntities[1].AddSimpleStateChecker(new MySimpleStateChecker());
var result = await SimpleStateCheckerManager.IsEnabledAsync(myStateEntities);
result.Count.ShouldBe(2);
result[myStateEntities[0]].ShouldBeTrue();
result[myStateEntities[1]].ShouldBeFalse();
myStateEntities[0].CheckCount.ShouldBe(0);
myStateEntities[0].GlobalCheckCount.ShouldBe(0);
myStateEntities[0].MultipleCheckCount.ShouldBe(1);
myStateEntities[0].MultipleGlobalCheckCount.ShouldBe(0);
myStateEntities[1].CheckCount.ShouldBe(1);
myStateEntities[1].GlobalCheckCount.ShouldBe(0);
myStateEntities[1].MultipleCheckCount.ShouldBe(0);
myStateEntities[1].MultipleGlobalCheckCount.ShouldBe(0);
}
public async Task Multiple_State_Check_Should_Be_Works()
{
var checker = new MySimpleBatchStateChecker();
var myStateEntities = new MyStateEntity[]
{
new MyStateEntity()
{
CreationTime = DateTime.Parse("2021-01-01", CultureInfo.InvariantCulture),
LastModificationTime = DateTime.Parse("2021-01-01", CultureInfo.InvariantCulture)
},
new MyStateEntity()
{
CreationTime = DateTime.Parse("2021-01-01", CultureInfo.InvariantCulture),
LastModificationTime = DateTime.Parse("2021-01-01", CultureInfo.InvariantCulture)
}
};
foreach (var myStateEntity in myStateEntities)
{
myStateEntity.AddSimpleStateChecker(checker);
}
(await SimpleStateCheckerManager.IsEnabledAsync(myStateEntities)).ShouldAllBe(x => x.Value);
foreach (var myStateEntity in myStateEntities)
{
myStateEntity.CreationTime = DateTime.Parse("2001-01-01", CultureInfo.InvariantCulture);
}
(await SimpleStateCheckerManager.IsEnabledAsync(myStateEntities)).ShouldAllBe(x => !x.Value);
}
public async Task Multiple_Global_State_Check_Should_Be_Works()
{
var myStateEntity = new MyStateEntity()
{
CreationTime = DateTime.Parse("2021-01-01", CultureInfo.InvariantCulture)
};
(await SimpleStateCheckerManager.IsEnabledAsync(myStateEntity)).ShouldBeFalse();
myStateEntity.LastModificationTime = DateTime.Parse("2001-01-01", CultureInfo.InvariantCulture);
(await SimpleStateCheckerManager.IsEnabledAsync(myStateEntity)).ShouldBeTrue();
}
protected virtual async Task <MultiplePermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition[] permissions, string providerName, string providerKey)
{
var permissionNames = permissions.Select(x => x.Name).ToArray();
var multiplePermissionWithGrantedProviders = new MultiplePermissionWithGrantedProviders(permissionNames);
var neededCheckPermissions = new List <PermissionDefinition>();
foreach (var permission in permissions
.Where(x => x.IsEnabled)
.Where(x => x.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
.Where(x => !x.Providers.Any() || x.Providers.Contains(providerName)))
{
if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
{
neededCheckPermissions.Add(permission);
}
}
if (!neededCheckPermissions.Any())
{
return(multiplePermissionWithGrantedProviders);
}
foreach (var provider in ManagementProviders)
{
permissionNames = neededCheckPermissions.Select(x => x.Name).ToArray();
var multiplePermissionValueProviderGrantInfo = await provider.CheckAsync(permissionNames, providerName, providerKey);
foreach (var providerResultDict in multiplePermissionValueProviderGrantInfo.Result)
{
if (providerResultDict.Value.IsGranted)
{
var permissionWithGrantedProvider = multiplePermissionWithGrantedProviders.Result
.First(x => x.Name == providerResultDict.Key);
permissionWithGrantedProvider.IsGranted = true;
permissionWithGrantedProvider.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResultDict.Value.ProviderKey));
}
}
}
return(multiplePermissionWithGrantedProviders);
}
public virtual async Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted)
{
var permission = PermissionDefinitionManager.Get(permissionName);
if (!permission.IsEnabled || !await SimpleStateCheckerManager.IsEnabledAsync(permission))
{
//TODO: BusinessException
throw new ApplicationException($"The permission named '{permission.Name}' is disabled!");
}
if (permission.Providers.Any() && !permission.Providers.Contains(providerName))
{
//TODO: BusinessException
throw new ApplicationException($"The permission named '{permission.Name}' has not compatible with the provider named '{providerName}'");
}
if (!permission.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
{
//TODO: BusinessException
throw new ApplicationException($"The permission named '{permission.Name}' has multitenancy side '{permission.MultiTenancySide}' which is not compatible with the current multitenancy side '{CurrentTenant.GetMultiTenancySide()}'");
}
var currentGrantInfo = await GetInternalAsync(permission, providerName, providerKey);
if (currentGrantInfo.IsGranted == isGranted)
{
return;
}
var provider = ManagementProviders.FirstOrDefault(m => m.Name == providerName);
if (provider == null)
{
//TODO: BusinessException
throw new AbpException("Unknown permission management provider: " + providerName);
}
await provider.SetAsync(permissionName, providerKey, isGranted);
}
protected virtual async Task <PermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition permission, string providerName, string providerKey)
{
var result = new PermissionWithGrantedProviders(permission.Name, false);
if (!permission.IsEnabled)
{
return(result);
}
if (!await SimpleStateCheckerManager.IsEnabledAsync(permission))
{
return(result);
}
if (!permission.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
{
return(result);
}
if (permission.Providers.Any() && !permission.Providers.Contains(providerName))
{
return(result);
}
foreach (var provider in ManagementProviders)
{
var providerResult = await provider.CheckAsync(permission.Name, providerName, providerKey);
if (providerResult.IsGranted)
{
result.IsGranted = true;
result.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResult.ProviderKey));
}
}
return(result);
}
