public void SetUserPhoto(int tenant, Guid id, byte[] photo)
{
Service.SetUserPhoto(tenant, id, photo);
CacheUserPhotoItem.Publish(new UserPhotoCacheItem {
Key = UserServiceCache.GetUserPhotoCacheKey(tenant, id)
}, CacheNotifyAction.Remove);
}
public ConfigureCachedUserService(
IOptionsSnapshot <EFUserService> service,
UserServiceCache userServiceCache,
CoreBaseSettings coreBaseSettings)
{
Service = service;
UserServiceCache = userServiceCache;
CoreBaseSettings = coreBaseSettings;
}
public byte[] GetUserPhoto(int tenant, Guid id)
{
var photo = Cache.Get <byte[]>(UserServiceCache.GetUserPhotoCacheKey(tenant, id));
if (photo == null)
{
photo = Service.GetUserPhoto(tenant, id);
Cache.Insert(UserServiceCache.GetUserPhotoCacheKey(tenant, id), photo, PhotoExpiration);
}
return(photo);
}
private IDictionary <Guid, Group> GetGroups(int tenant)
{
GetChangesFromDb();
var key = UserServiceCache.GetGroupCacheKey(tenant);
var groups = Cache.Get <IDictionary <Guid, Group> >(key);
if (groups == null)
{
groups = Service.GetGroups(tenant, default);
Cache.Insert(key, groups, CacheExpiration);
}
return(groups);
}
private IDictionary <Guid, UserInfo> GetUsers(int tenant)
{
GetChangesFromDb();
var key = UserServiceCache.GetUserCacheKey(tenant);
var users = Cache.Get <IDictionary <Guid, UserInfo> >(key);
if (users == null)
{
users = Service.GetUsers(tenant, default);
Cache.Insert(key, users, CacheExpiration);
}
return(users);
}
public IDictionary <string, UserGroupRef> GetUserGroupRefs(int tenant, DateTime from)
{
GetChangesFromDb();
var key = UserServiceCache.GetRefCacheKey(tenant);
if (!(Cache.Get <UserGroupRefStore>(key) is IDictionary <string, UserGroupRef> refs))
{
refs = Service.GetUserGroupRefs(tenant, default);
Cache.Insert(key, new UserGroupRefStore(refs), CacheExpiration);
}
lock (refs)
{
return(from == default ? refs : refs.Values.Where(r => r.LastModified >= from).ToDictionary(r => r.CreateKey()));
}
}
public CachedUserService(
EFUserService service,
CoreBaseSettings coreBaseSettings,
UserServiceCache userServiceCache
) : this()
{
Service = service ?? throw new ArgumentNullException("service");
CoreBaseSettings = coreBaseSettings;
UserServiceCache = userServiceCache;
Cache = userServiceCache.Cache;
CacheUserInfoItem = userServiceCache.CacheUserInfoItem;
CacheUserPhotoItem = userServiceCache.CacheUserPhotoItem;
CacheGroupCacheItem = userServiceCache.CacheGroupCacheItem;
CacheUserGroupRefItem = userServiceCache.CacheUserGroupRefItem;
TrustInterval = userServiceCache.TrustInterval;
}
public CachedUserService(
DbUserService service,
CoreBaseSettings coreBaseSettings,
UserServiceCache userServiceCache
)
{
this.service = service ?? throw new ArgumentNullException("service");
CoreBaseSettings = coreBaseSettings;
UserServiceCache = userServiceCache;
cache = userServiceCache.Cache;
CacheUserInfoItem = userServiceCache.CacheUserInfoItem;
CacheUserPhotoItem = userServiceCache.CacheUserPhotoItem;
CacheGroupCacheItem = userServiceCache.CacheGroupCacheItem;
CacheUserGroupRefItem = userServiceCache.CacheUserGroupRefItem;
trustInterval = userServiceCache.TrustInterval;
CacheExpiration = TimeSpan.FromMinutes(20);
DbExpiration = TimeSpan.FromMinutes(1);
PhotoExpiration = TimeSpan.FromMinutes(10);
}
/// <summary>
/// For Personal only
/// </summary>
/// <param name="tenant"></param>
/// <param name="id"></param>
/// <returns></returns>
private UserInfo GetUserForPersonal(int tenant, Guid id)
{
if (!CoreBaseSettings.Personal)
{
return(GetUser(tenant, id));
}
var key = UserServiceCache.GetUserCacheKeyForPersonal(tenant, id);
var user = Cache.Get <UserInfo>(key);
if (user == null)
{
user = Service.GetUser(tenant, id);
if (user != null)
{
Cache.Insert(key, user, CacheExpiration);
}
}
return(user);
}
public void InvalidateCache()
{
UserServiceCache.InvalidateCache();
}
private void GetChangesFromDb()
{
if (!TrustInterval.Expired)
{
return;
}
if (Interlocked.CompareExchange(ref getchanges, 1, 0) == 0)
{
try
{
if (!TrustInterval.Expired)
{
return;
}
var starttime = TrustInterval.StartTime;
if (starttime != default)
{
var correction = TimeSpan.FromTicks(DbExpiration.Ticks * 3);
starttime = TrustInterval.StartTime.Subtract(correction);
}
TrustInterval.Start(DbExpiration);
//get and merge changes in cached tenants
foreach (var tenantGroup in Service.GetUsers(Tenant.DEFAULT_TENANT, starttime).Values.GroupBy(u => u.Tenant))
{
var users = Cache.Get <IDictionary <Guid, UserInfo> >(UserServiceCache.GetUserCacheKey(tenantGroup.Key));
if (users != null)
{
lock (users)
{
foreach (var u in tenantGroup)
{
users[u.ID] = u;
}
}
}
}
foreach (var tenantGroup in Service.GetGroups(Tenant.DEFAULT_TENANT, starttime).Values.GroupBy(g => g.Tenant))
{
var groups = Cache.Get <IDictionary <Guid, Group> >(UserServiceCache.GetGroupCacheKey(tenantGroup.Key));
if (groups != null)
{
lock (groups)
{
foreach (var g in tenantGroup)
{
groups[g.Id] = g;
}
}
}
}
foreach (var tenantGroup in Service.GetUserGroupRefs(Tenant.DEFAULT_TENANT, starttime).Values.GroupBy(r => r.Tenant))
{
var refs = Cache.Get <UserGroupRefStore>(UserServiceCache.GetRefCacheKey(tenantGroup.Key));
if (refs != null)
{
lock (refs)
{
foreach (var r in tenantGroup)
{
refs[r.CreateKey()] = r;
}
}
}
}
}
finally
{
Volatile.Write(ref getchanges, 0);
}
}
}
