protected async Task <ResourceResponse <Document> > CreateDocumentAsync(TEntity item)
{
if (item is IValidateable)
{
var result = Validator.Validate(item as IValidateable);
if (!result.Successful)
{
throw new ValidationException("Invalid Data.", result.Errors);
}
}
item.DatabaseName = _dbName;
item.EntityType = typeof(TEntity).Name;
var response = await Client.CreateDocumentAsync(await GetCollectionDocumentsLinkAsync(), item);
if (response.StatusCode != System.Net.HttpStatusCode.Created)
{
_logger.AddCustomEvent(LogLevel.Error, $"DocuementDbRepo<{_dbName}>_CreateDocumentAsync", "Error return code: " + response.StatusCode,
new KeyValuePair <string, string>("EntityType", typeof(TEntity).Name),
new KeyValuePair <string, string>("Id", item.Id)
);
throw new Exception("Could not insert entity");
}
if (_cacheProvider != null)
{
await _cacheProvider.AddAsync(GetCacheKey(item.Id), JsonConvert.SerializeObject(item));
}
return(response);
}
public async Task <LabelSet> AddLabelAsync(Label label, EntityHeader org, EntityHeader user)
{
var labelSet = await GetLabelSetAsync(org, user);
if (!labelSet.Labels.Any(lbs => lbs.Text.ToLower() == label.Text.ToLower()))
{
await _cacheProvider.RemoveAsync(CacheKey(org));
labelSet.Labels.Add(label);
await UpsertDocumentAsync(labelSet);
}
await _cacheProvider.AddAsync(CacheKey(org), JsonConvert.SerializeObject(labelSet));
return(labelSet);
}
public async Task HandleAsync(T command, CancellationToken cancellationToken)
{
var key = _keyGenerator.GenerateKeyForCache(command);
if (string.IsNullOrEmpty(key))
{
await _decoratee.HandleAsync(command, cancellationToken);
}
else
{
var exist = await cacheProvider.ExistAsync(key);
if (exist)
{
var result = await cacheProvider.GetAsync <TResult>(key);
if (result != null)
{
command.Result = result;
}
}
else
{
await _decoratee.HandleAsync(command, cancellationToken);
await cacheProvider.AddAsync(key, command.Result);
}
}
}
public async Task HandleAsync(T command, CancellationToken cancellationToken)
{
var currentCommandPermission = command.Permission;
var currentUserPermissions = new List <CommandPermission>();
var cacheKey = "User" + _currentUser.UserId;
var existInCache = await _cacheProvider.ExistAsync(cacheKey);
if (existInCache)
{
currentUserPermissions = await _cacheProvider.GetAsync <List <CommandPermission> >(cacheKey);
}
else
{
var userRole = _userRoleRepository.Where(x => x.UserId == _currentUser.UserId).Select(x => x.RoleId).ToList();
currentUserPermissions = await _rolePermissionRepository.Where(x => userRole.Contains(x.RoleId)).Select(x => x.PermissionId).ToListAsync();
await _cacheProvider.AddAsync(cacheKey, currentUserPermissions);
}
var hasAccess = currentUserPermissions.Where(x => x == command.Permission).Any();
if (hasAccess)
{
await _decoratee.HandleAsync(command, cancellationToken);
}
else
{
throw new ExceptionResult(StatusEnum.Forbidden);
}
}
public async Task <string> GetCaptcha(string uuid)
{
var captchaCode = IdentifyCodeGenerator.Create(CaptchaLength, IdentifyCodeType.MixNumberLetter);
await _cacheProvider.AddAsync(string.Format(HeroConstants.CacheKey.Captcha, uuid), captchaCode);
return(captchaCode);
}
public static async Task <IEnumerable <T> > TryGetEnumerableFromCacheAsync <T>(this ICacheProvider cacheProvider,
string key, Func <Task <IEnumerable <T> > > retrievalFunc)
{
if (await cacheProvider.ContainsKeyAsync(key))
{
return(await cacheProvider.GetAsync <T[]>(key));
}
var data = await retrievalFunc();
_ = cacheProvider.AddAsync(key, data.ToArray());
return(data);
}
public async Task <T> BreakerRequestCircuitBreaker <T>(ServerCallContext context, Func <Task <T> > func)
{
var command = GetServiceEntryHystrixCommand(context.Method);
if (command == null)
{
return(await func.Invoke());
}
ICacheProvider cache = null;
if (!string.IsNullOrEmpty(command?.Cache.ToString()))
{
cache = ServiceLocator.GetService <ICacheProvider>(command?.Cache.ToString());
}
try
{
var response = ExecuteTimeout(context, func);
if (Convert.ToBoolean(command?.EnableServiceDegradation) && cache != null)
{
await cache.AddAsync(context.Method, response, TimeSpan.FromSeconds(command.ServiceDegradationTimeSpan));
}
return(response);
}
catch (Exception e)
{
if (Convert.ToBoolean(command?.EnableServiceDegradation) && cache != null)
{
var result = await cache.GetAsync <T>(context.Method);
return(result ?? Activator.CreateInstance <T>());
}
if (!_dictionary.TryGetValue($"{context.Method}_break", out var value))
{
_dictionary.TryAdd($"{context.Method}_break", 1);
}
if (value >= command?.BreakerRequestCircuitBreaker)
{
throw new RpcException(new Status(StatusCode.FailedPrecondition, e.Message));
}
_dictionary.TryUpdate($"{context.Method}_break", value + 1, value);
return(await BreakerRequestCircuitBreaker(context, func));
}
}
