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());
            }
        }
Example #2
0
        public async Task <IActionResult> UpdateFeedAsync(long id, long feedId, [FromBody] FeedUpdateModel model)
        {
            var collection = await _collectionRepository.GetCollectionAsync(id);

            if (collection == null)
            {
                return(NotFound("Invalid Collection Id"));
            }

            var feed = await _feedRepository.GetFeedAsync(feedId);

            if (feed == null)
            {
                return(NotFound("Invalid Feed Id"));
            }

            if (!ModelState.IsValid)
            {
                return(new ValidateObjectResult(ModelState));
            }

            feed.UpdateTitle(model.Title);

            await _feedRepository.UpdateFeedAsync();

            return(NoContent());
        }
        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());
            }
        }
Example #4
0
 public IActionResult Put(FeedUpdateModel model)
 {
     _logger.LogInformation(JsonConvert.SerializeObject(model));
     return(NoContent());
 }
 public async Task UpdateAsync(FeedUpdateModel model)
 {
     await _api.Update(model);
 }