private async Task <List <RelationDto> > GetAllRelations()
{
var cahceValue = await _cache.GetAsync(EasyCachingConsts.MenuRelationCacheKey, async() =>
{
var allRelations = await _relationRepository.GetAll().ToListAsync();
return(_mapper.Map <List <RelationDto> >(allRelations));
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
return(cahceValue.Value);
}
private async Task <List <DeptDto> > GetAll()
{
var tempcache = await _cache.GetAsync <List <DeptDto> >(EasyCachingConsts.DetpListCacheKey);
var cahceValue = await _cache.GetAsync(EasyCachingConsts.DetpListCacheKey, async() =>
{
var allDepts = await _deptRepository.GetAll().ToListAsync();
return(_mapper.Map <List <DeptDto> >(allDepts));
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
return(cahceValue.Value);
}
public async Task <string> GetAsync(int type = 1)
{
if (type == 1)
{
await _provider.RemoveAsync("demo");
return("removed");
}
else if (type == 2)
{
await _provider.SetAsync("demo", "123", TimeSpan.FromMinutes(1));
return("seted");
}
else if (type == 3)
{
var res = await _provider.GetAsync("demo", async() => await Task.FromResult("456"), TimeSpan.FromMinutes(1));
return($"cached value : {res}");
}
else
{
return("error");
}
}
public async Task <string> GetAsync(string str)
{
var method = str.ToLower();
switch (method)
{
case "get":
var res = await _provider.GetAsync("demo", async() => await Task.FromResult("3-456"), TimeSpan.FromHours(1));
return($"cached value : {res}");
case "set":
await _provider.SetAsync("demo", "3-123", TimeSpan.FromHours(1));
return("seted");
case "remove":
await _provider.RemoveAsync("demo");
return("removed");
default:
return("default");
}
}
public async Task <bool> ExistPermissions(RolePermissionsCheckInputDto inputDto)
{
bool result = false;
var cahceValue = await _cache.GetAsync(EasyCachingConsts.MenuCodesCacheKey, async() =>
{
var allMenus = await _relationRepository.GetAll()
.Where(x => x.Menu.Status == true)
.Select(x => new RoleMenuCodesDto {
RoleId = x.RoleId, Code = x.Menu.Code
})
.ToArrayAsync();
return(allMenus.Distinct().ToArray());
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
var codes = cahceValue?.Value.Where(x => inputDto.RoleIds.Contains(x.RoleId)).Select(x => x.Code.ToUpper());
if (codes.Any())
{
var ownerMenusTotal = codes.Intersect(inputDto.Permissions.Select(x => x.ToUpper()))
.Count();
if (ownerMenusTotal > 0)
{
result = true;
}
}
return(await Task.FromResult(result));
}
public async Task <int> Delete(long Id)
{
var depts1 = (await _locaCahce.GetAsync <List <DeptNodeDto> >(EasyCachingConsts.DetpListCacheKey)).Value;
var depts2 = (await _redisCache.GetAsync <List <DeptNodeDto> >(EasyCachingConsts.DetpListCacheKey)).Value;
var depts3 = (await _cache.GetAsync <List <DeptNodeDto> >(EasyCachingConsts.DetpListCacheKey)).Value;
int result = await _systemManagerService.DeleteDept(Id);
return(await Task.FromResult(result));
}
private async Task <List <CfgDto> > GetAllFromCache()
{
var cahceValue = await _cache.GetAsync(EasyCachingConsts.CfgListCacheKey, async() =>
{
var allCfgs = await _cfgRepository.GetAll().ToListAsync();
return(_mapper.Map <List <CfgDto> >(allCfgs));
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
return(cahceValue.Value);
}
public async Task <List <DeptDto> > GetAllFromCacheAsync()
{
var cahceValue = await _cache.GetAsync(EasyCachingConsts.DetpListCacheKey, async() =>
{
var allDepts = await _deptRepository.GetAll(writeDb: true).OrderBy(x => x.Ordinal).ToListAsync();
return(_mapper.Map <List <DeptDto> >(allDepts));
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
return(cahceValue.Value);
}
private async Task <List <DictDto> > GetAllFromCache()
{
var cahceValue = await _cache.GetAsync(EasyCachingConsts.DictListCacheKey, async() =>
{
var allDicts = await _dictRepository.GetAll(writeDb: true).ToListAsync();
return(_mapper.Map <List <DictDto> >(allDicts));
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
return(cahceValue.Value);
}
public async Task <byte[]?> GetAsync(string key, CancellationToken token = default)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var result = await _hybridCachingProvider.GetAsync <byte[]>(key).ConfigureAwait(false);
return((!result.HasValue || result.IsNull) ? null : result.Value);
}
public async Task <IEnumerable <string> > GetPermissions(RolePermissionsCheckInputDto inputDto)
{
var cahceValue = await _cache.GetAsync(EasyCachingConsts.MenuCodesCacheKey, async() =>
{
var allMenus = await _relationRepository.GetAll()
.Where(x => x.Menu.Status == true)
.Select(x => new RoleMenuCodesDto {
RoleId = x.RoleId, Code = x.Menu.Code
})
.ToArrayAsync();
return(allMenus.Distinct().ToArray());
}, TimeSpan.FromSeconds(EasyCachingConsts.OneYear));
var codes = cahceValue.Value?.Where(x => inputDto.RoleIds.Contains(x.RoleId)).Select(x => x.Code.ToUpper());
if (codes != null && codes.Any())
{
return(codes.Intersect(inputDto.Permissions.Select(x => x.ToUpper())));
}
return(null);
}
/// <summary>
/// Proceeds the able.
/// </summary>
/// <param name="invocation">Invocation.</param>
private void ProceedAble(IInvocation invocation)
{
var serviceMethod = invocation.Method ?? invocation.MethodInvocationTarget;
if (GetMethodAttributes(serviceMethod).FirstOrDefault(x => typeof(EasyCachingAbleAttribute).IsAssignableFrom(x.GetType())) is EasyCachingAbleAttribute attribute)
{
var returnType = serviceMethod.IsReturnTask()
? serviceMethod.ReturnType.GetGenericArguments().First()
: serviceMethod.ReturnType;
var cacheKey = string.IsNullOrEmpty(attribute.CacheKey)
? _keyGenerator.GetCacheKey(serviceMethod, invocation.Arguments, attribute.CacheKeyPrefix)
: attribute.CacheKey;
object cacheValue = null;
var isAvailable = true;
try
{
if (attribute.IsHybridProvider)
{
cacheValue = _hybridCachingProvider.GetAsync(cacheKey, returnType).GetAwaiter().GetResult();
}
else
{
var _cacheProvider = _cacheProviderFactory.GetCachingProvider(attribute.CacheProviderName ?? _options.Value.CacheProviderName);
cacheValue = _cacheProvider.GetAsync(cacheKey, returnType).GetAwaiter().GetResult();
}
}
catch (Exception ex)
{
if (!attribute.IsHighAvailability)
{
throw;
}
else
{
isAvailable = false;
_logger?.LogError(new EventId(), ex, $"Cache provider get error.");
}
}
if (cacheValue != null)
{
if (serviceMethod.IsReturnTask())
{
invocation.ReturnValue =
TypeofTaskResultMethod.GetOrAdd(returnType, t => typeof(Task).GetMethods().First(p => p.Name == "FromResult" && p.ContainsGenericParameters).MakeGenericMethod(returnType)).Invoke(null, new object[] { cacheValue });
}
else
{
invocation.ReturnValue = cacheValue;
}
}
else
{
// Invoke the method if we don't have a cache hit
invocation.Proceed();
if (!string.IsNullOrWhiteSpace(cacheKey) && invocation.ReturnValue != null && isAvailable)
{
// get the result
var returnValue = serviceMethod.IsReturnTask()
? invocation.UnwrapAsyncReturnValue().Result
: invocation.ReturnValue;
// should we do something when method return null?
// 1. cached a null value for a short time
// 2. do nothing
if (returnValue != null)
{
if (attribute.IsHybridProvider)
{
_hybridCachingProvider.Set(cacheKey, returnValue, TimeSpan.FromSeconds(attribute.Expiration));
}
else
{
var _cacheProvider = _cacheProviderFactory.GetCachingProvider(attribute.CacheProviderName ?? _options.Value.CacheProviderName);
_cacheProvider.Set(cacheKey, returnValue, TimeSpan.FromSeconds(attribute.Expiration));
}
}
}
}
}
else
{
// Invoke the method if we don't have EasyCachingAbleAttribute
invocation.Proceed();
}
}
public async Task <string> GetCachedResponseAsync(string cacheKey)
{
var cachedResponse = await _hybridCachingProvider.GetAsync <string>(cacheKey);
return(string.IsNullOrWhiteSpace(cachedResponse.Value) ? null : cachedResponse.Value);
}