public async Task HandleScheduleItemCompletedEvent(Domain.Schedules.Events.ScheduleItemCompletedEvent e)
{
var item = await _repository.FindByUUID <ScheduleItem>(e.ItemUuid)
.Include(x => x.Schedule)
.Include(x => x.Html)
.FirstOrDefaultAsync();
if (item == null)
{
return;
}
var subscriber = await _uCenter.GetUser(x => x.UserId, item.UserId);
if (subscriber == null)
{
return;
}
await _feedSvc.PublishAsync(new FeedInputModel
{
ContentId = item.Id.ToString(),
FeedTitle = item.GenerateDescription(),
FeedContent = item.Schedule.Title,
Link = $"{AppConst.DomainAddress}/schedules/u/{subscriber.Alias}/{item.ScheduleId}/detail/{item.Id}",
UserId = item.UserId,
AppId = AppConst.AppGuid,
FeedType = FeedType.ScheduleItemDone,
IsPrivate = item.Schedule.IsPrivate
});
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
public async Task HandleScheduleItemUpdatedEvent(Domain.Schedules.Events.ScheduleItemUpdatedEvent e)
{
var item = await _repository.FindByUUID <ScheduleItem>(e.ItemUuid).Include(x => x.Html).FirstOrDefaultAsync();
if (item == null)
{
return;
}
// Update feeds
var model = new FeedUpdateModel
{
ContentId = item.Id.ToString(),
FeedTitle = item.GenerateDescription(),
FeedType = FeedType.ScheduleItemNew
};
await _feedSvc.UpdateAsync(model);
if (item.Completed)
{
model.FeedType = FeedType.ScheduleItemDone;
await _feedSvc.UpdateAsync(model);
}
var will = _scheduleSvc.ShouldClearCache(item.DateAdded) || _scheduleSvc.ShouldClearCache(item.DateEnd);
if (will)
{
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
}
public async Task HandleScheduleDeletedEvent(ScheduleDeletedEvent e)
{
var schedule = await _repository.FindByUUID <Schedule>(e.ScheduleUuid).IgnoreQueryFilters().FirstOrDefaultAsync();
if (schedule == null)
{
return;
}
var model = new FeedDeletedInput
{
ContentId = schedule.Id.ToString(),
FeedType = FeedType.ScheduleNew,
AppId = AppConst.AppGuid,
UserId = schedule.UserId
};
await _feedSvc.DeleteAsync(model);
if (schedule.Stage == Domain.Schedules.Stage.Completed)
{
model.FeedType = FeedType.ScheduleCompleted;
await _feedSvc.DeleteAsync(model);
}
if (_scheduleSvc.ShouldClearCache(schedule.DateUpdated))
{
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
}
public async Task HandleScheduleItemDeletedEvent(Domain.Schedules.Events.ScheduleItemDeletedEvent e)
{
var item = await _repository.FindByUUID <ScheduleItem>(e.ItemUuid)
.IgnoreQueryFilters()
.Include(x => x.Schedule)
.FirstOrDefaultAsync();
if (item == null)
{
return;
}
var model = new FeedDeletedInput
{
ContentId = item.Id.ToString(),
AppId = AppConst.AppGuid,
UserId = item.Schedule.UserId,
FeedType = FeedType.ScheduleItemNew
};
await _feedSvc.DeleteAsync(model);
if (item.Completed)
{
model.FeedType = FeedType.ScheduleItemDone;
await _feedSvc.DeleteAsync(model);
}
if (_scheduleSvc.ShouldClearCache(item.DateAdded) || _scheduleSvc.ShouldClearCache(item.DateEnd))
{
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
}
public async Task HandleScheduleCompletedEvent(ScheduleCompletedEvent e)
{
var schedule = await _repository.FindByUUID <Schedule>(e.ScheduleUuid).FirstOrDefaultAsync();
if (schedule == null)
{
return;
}
var user = await _uCenter.GetUser(x => x.UserId, schedule.UserId);
if (user == null)
{
return;
}
await _feedSvc.PublishAsync(new FeedInputModel
{
AppId = AppConst.AppGuid,
FeedType = FeedType.ScheduleCompleted,
ContentId = schedule.Id.ToString(),
UserId = schedule.UserId,
FeedTitle = schedule.Title,
IsPrivate = schedule.IsPrivate,
Link = $"{AppConst.DomainAddress}/schedules/u/{user.Alias}/{schedule.Id}"
});
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
public async Task HandleScheduleCreatedEvent(ScheduleCreatedEvent e)
{
var schedule = await _repository.FindByUUID <Schedule>(e.ScheduleUuid).FirstOrDefaultAsync();
if (schedule == null)
{
return;
}
if (schedule.ParentId > 0)
{
return; // Not publish feed if it's a subscribed schedule
}
var user = await _uCenter.GetUser(x => x.UserId, schedule.UserId);
if (user == null)
{
return;
}
await _feedSvc.PublishAsync(new FeedInputModel
{
ContentId = schedule.Id.ToString(),
FeedTitle = schedule.Title,
FeedContent = schedule.Description,
UserId = schedule.UserId,
Link = $"{AppConst.DomainAddress}/schedules/u/{user.Alias}/{schedule.Id}",
IsPrivate = schedule.IsPrivate,
AppId = AppConst.AppGuid,
FeedType = FeedType.ScheduleNew
});
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
public async Task HandleScheduleUpdatedEvent(ScheduleUpdatedEvent e)
{
var schedule = await _repository.FindByUUID <Schedule>(e.ScheduleUuid).FirstOrDefaultAsync();
if (schedule == null)
{
return;
}
var model = new FeedUpdateModel
{
ContentId = schedule.Id.ToString(),
FeedTitle = schedule.Title,
FeedContent = schedule.Description,
FeedType = FeedType.ScheduleNew
};
await _feedSvc.UpdateAsync(model);
if (schedule.Stage == Stage.Completed)
{
model.FeedType = FeedType.ScheduleCompleted;
await _feedSvc.UpdateAsync(model);
}
if (_scheduleSvc.ShouldClearCache(schedule.DateAdded) || _scheduleSvc.ShouldClearCache(schedule.DateEnd))
{
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
}
public async Task HandleScheduleItemUndoEvent(ScheduleItemUndoEvent e)
{
await _feedSvc.DeleteAsync(new FeedDeletedInput
{
AppId = AppConst.AppGuid,
FeedType = FeedType.ScheduleItemDone,
ContentId = e.ItemId.ToString(),
UserId = e.UserId
});
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
public async Task HandleScheduleCancelledEvent(ScheduleCancelledEvent e)
{
var schedule = await _repository.FindByUUID <Schedule>(e.ScheduleUuid).FirstOrDefaultAsync();
if (schedule == null)
{
return;
}
await _feedSvc.DeleteAsync(new FeedDeletedInput
{
AppId = AppConst.AppGuid,
FeedType = FeedType.ScheduleCompleted,
UserId = schedule.UserId,
ContentId = schedule.Id.ToString()
});
if (_scheduleSvc.ShouldClearCache(schedule.DateUpdated))
{
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
}
public async Task HandleScheduleItemCreatedEvent(Cnblogs.Academy.Domain.Schedules.Events.ScheduleItemCreatedEvent e)
{
var item = await _repository.FindByUUID <ScheduleItem>(e.ItemUuid)
.Include(x => x.Schedule)
.Include(x => x.Html)
.FirstOrDefaultAsync();
if (item == null)
{
return;
}
if (item.ParentId > 0)
{
return; //child item 不需要发布动态
}
var alias = await _uCenter.GetUser(x => x.UserId, item.UserId, x => x.Alias);
if (string.IsNullOrEmpty(alias))
{
return;
}
await _feedSvc.PublishAsync(new FeedInputModel
{
ContentId = item.Id.ToString(),
FeedTitle = item.GenerateDescription(),
Link = $"{AppConst.DomainAddress}/schedules/u/{alias}/{item.ScheduleId}/item/{item.Id}",
UserId = item.UserId,
IsPrivate = item.Schedule.IsPrivate,
AppId = AppConst.AppGuid,
FeedType = FeedType.ScheduleItemNew,
});
await _cache.RemoveAsync(CacheKeyStore.HomeFeeds());
}
/// <summary>
/// Initializes a new instance of the <see cref="MemoryCachedResultsetCache"/> class.
/// </summary>
/// <param name="name">The name to use to look up configuration information. This is passed to the MemoryCache constructor</param>
/// <param name="config">A collection of name/value pairs of configuration information to use for configuring the cache. This is passed
/// to the MemoryCache constructor</param>
/// <remarks>See for details on the parameters of this constructor the MemoryCache constructor documentation:
/// http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache.memorycache.aspx
/// </remarks>
public MemoryCachedResultsetCache(string name, NameValueCollection config)
{
_memoryCache = new MemoryCache(name, config);
_keyStore = new CacheKeyStore();
}
/// <summary>
/// Initializes a new instance of the <see cref="MemoryCachedResultsetCache"/> class.
/// </summary>
/// <remarks>This ctor will use the Default memory cache object, which needs configuration through the config file</remarks>
public MemoryCachedResultsetCache()
{
_memoryCache = MemoryCache.Default;
_keyStore = new CacheKeyStore();
}
public async Task <IEnumerable <ScheduleFollowingDto> > GetScheduleFollowings(long id)
{
return(await _cache.GetValueOrCreateAsync(CacheKeyStore.ScheduleFollowings(id),
3600 * 24,
() => GetCacheScheduleFollowings(id)));
}
public async Task HandleUnsubscribeEvent(UnsubscribeEvent e)
{
await _cache.RemoveAsync(CacheKeyStore.ScheduleFollowings(e.ParentId));
}
public async Task HandleNewSubscriberEvent(NewSubscriberEvent e)
{
var id = await _repository.FindByUUID <Schedule>(e.ParentScheduleUuid).Select(x => x.Id).FirstOrDefaultAsync();
await _cache.RemoveAsync(CacheKeyStore.ScheduleFollowings(id));
}
/// <summary>
/// Initializes a new instance of the <see cref="MemoryCachedResultsetCache"/> class.
/// </summary>
/// <param name="name">The name to use to look up configuration information. This is passed to the MemoryCache constructor</param>
/// <param name="config">A collection of name/value pairs of configuration information to use for configuring the cache. This is passed
/// to the MemoryCache constructor</param>
/// <remarks>See for details on the parameters of this constructor the MemoryCache constructor documentation:
/// http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache.memorycache.aspx
/// </remarks>
public MemoryCachedResultsetCache(string name, NameValueCollection config)
{
_memoryCache = new MemoryCache(name, config);
_keyStore = new CacheKeyStore();
}
public async Task <PagedResult <FeedDto> > GetConcernFeeds(int page, int size, Guid userId, Guid?groupId = null)
{
return(await _cache.GetValueOrCreateAsync <PagedResult <FeedDto> >(CacheKeyStore.IndexFeeds(page, userId, groupId), 5 * 60,
() => _feedsApi.GetConcernFeeds(AppConst.AppId, page, size, userId, groupId)));
}
public async Task <IEnumerable <FeedDto> > GetAcademyFeedsAsync(int page, int size)
{
return(await _cache.GetValueOrCreateAsync <IEnumerable <FeedDto> >(CacheKeyStore.HomeFeeds(page), 5 * 60,
() => _feedsApi.GetFeedsByAppId(AppConst.AppId, page, size)));
}
