Example #1
0
        public async Task <bool> DeleteEpisodeWatched(EpisodeWatched episodeWatched)
        {
            using (var trans = _context.Database.BeginTransaction(_capPublisher, autoCommit: false))
            {
                try
                {
                    _context.EpisodeWatched.Remove(episodeWatched);
                    await _context.SaveChangesAsync();

                    var episodeWatchedDeletedEvent = _mapper.Map <EpisodeWatchedDeletedEvent>(episodeWatched);
                    await _capPublisher.SendEvent(EventInfo.EpisodeWatchedDeleted,
                                                  episodeWatchedDeletedEvent);

                    await trans.CommitAsync();

                    return(true);
                }
                catch (Exception e)
                {
                    await trans.RollbackAsync();

                    _logger.LogError(e, $"Unexpected error while deleting episode watched" +
                                     $" EpisodeId:{episodeWatched.EpisodeId} UserId:{episodeWatched.ViewerId}");
                    return(false);
                }
            }
        }
Example #2
0
        public async Task <bool> CreateEpisodeWatched(Episode episode, string viewerId)
        {
            using (var trans = _context.Database.BeginTransaction(_capPublisher, autoCommit: false))
            {
                try
                {
                    if (!await IsSeriesWatchedByViewer(episode.SeriesId, viewerId))
                    {
                        var seriesWatched = new SeriesWatched
                        {
                            SeriesId = episode.SeriesId,
                            ViewerId = viewerId
                        };
                        _context.SeriesWatched.Add(seriesWatched);
                        await _context.SaveChangesAsync();

                        var seriesWatchedEvent = _mapper.Map <SeriesWatchedEvent>(seriesWatched);
                        await _capPublisher.SendEvent(EventInfo.SeriesWatchedCreated, seriesWatchedEvent);
                    }

                    var episodeWatched = new EpisodeWatched
                    {
                        EpisodeId = episode.EpisodeId,
                        ViewerId  = viewerId
                    };
                    _context.EpisodeWatched.Add(episodeWatched);
                    var episodeWatchedEvent = _mapper.Map <EpisodeWatchedEvent>(episodeWatched);
                    await _context.SaveChangesAsync();

                    await _capPublisher.SendEvent(EventInfo.EpisodeWatchedCreated, episodeWatchedEvent);

                    await trans.CommitAsync();

                    return(true);
                }
                catch (Exception e)
                {
                    await trans.RollbackAsync();

                    _logger.LogError(e, $"Unexpected error while creating episode watched" +
                                     $" EpisodeId:{episode.EpisodeId} UserId:{viewerId}");
                    return(false);
                }
            }
        }
        private ITraktSyncHistoryPost GetWatchedShowsForSync(IList <MediaItem> localWatchedEpisodes, IEnumerable <EpisodeWatched> traktEpisodesWatched)
        {
            _mediaPortalServices.GetLogger().Info("Trakt: finding local shows to add to trakt watched history");
            TraktSyncHistoryPostBuilder      builder        = new TraktSyncHistoryPostBuilder();
            ILookup <string, EpisodeWatched> onlineEpisodes = traktEpisodesWatched.ToLookup(twe => CreateLookupKey(twe), twe => twe);

            foreach (var episode in localWatchedEpisodes)
            {
                string         tvdbKey      = CreateLookupKey(episode);
                EpisodeWatched traktEpisode = onlineEpisodes[tvdbKey].FirstOrDefault();

                if (traktEpisode == null)
                {
                    TraktShow show = new TraktShow
                    {
                        Title = MediaItemAspectsUtl.GetSeriesTitle(episode),
                        Ids   = new TraktShowIds
                        {
                            Tvdb = MediaItemAspectsUtl.GetTvdbId(episode),
                            Imdb = MediaItemAspectsUtl.GetSeriesImdbId(episode)
                        }
                    };

                    DateTime watchedAt = MediaItemAspectsUtl.GetLastPlayedDate(episode);

                    builder.AddShow(show, new PostHistorySeasons
                    {
                        {
                            MediaItemAspectsUtl.GetSeasonIndex(episode),
                            new PostHistoryEpisodes
                            {
                                { MediaItemAspectsUtl.GetEpisodeIndex(episode), watchedAt }
                            }
                        }
                    });
                }
            }
            return(builder.Build());
        }