public static void Update(this ShowSql showBdd, ITraktUserHiddenItem item)
{
showBdd.Blacklisted = true;
if (item.Type == TraktHiddenItemType.Show)
{
showBdd.Name = item.Show.Title;
showBdd.Year = item.Show.Year;
}
else if (item.Type == TraktHiddenItemType.Movie)
{
showBdd.Name = item.Movie.Title;
showBdd.Year = item.Movie.Year;
}
var show = item.Show;
if (show.Ids.Tmdb.HasValue)
{
showBdd.Providers[ProviderSql.Tmdb] = show.Ids.Tmdb.ToString();
}
if (!string.IsNullOrEmpty(show.Ids.Imdb))
{
showBdd.Providers[ProviderSql.Imdb] = show.Ids.Imdb;
}
}
/// <summary>
/// Create an NHibernate configuration class.
/// </summary>
/// <param name="options">Configuration options.</param>
/// <returns>The configuration.</returns>
public NHibernate.Cfg.Configuration CreateNHibernateConfiguration(ConfigurationFlags options)
{
var configuration = new NHibernate.Cfg.Configuration();
if ((options & ConfigurationFlags.Settings) == ConfigurationFlags.Settings)
{
configuration.SetProperty("hibernate.connection.connection_string", ConnectionConnectionString);
configuration.SetProperty("hibernate.connection.provider", ConnectionProvider);
configuration.SetProperty("hibernate.connection.driver_class", ConnectionDriverClass);
configuration.SetProperty("hibernate.show_sql",
ShowSql.ToString(CultureInfo.InvariantCulture).ToUpper(
CultureInfo.InvariantCulture));
configuration.SetProperty("hibernate.dialect", Dialect);
}
if ((options & ConfigurationFlags.Mappings) == ConfigurationFlags.Mappings)
{
foreach (Assembly assembly in MappingAssemblies)
{
configuration.AddAssembly(assembly);
}
}
if ((options & ConfigurationFlags.Interceptor) == ConfigurationFlags.Interceptor)
{
configuration.SetInterceptor(Interceptor);
}
return(configuration);
}
public IDictionary <string, string> GetProperties()
{
if (Provider.IsEmpty())
{
throw new ApplicationException("DatabaseSettings unavailable. Make sure your application configuration file has appSetting entries for the necessary DatabaseSettings properties.");
}
var properties = new Dictionary <string, string>
{
{ "connection.provider", Provider },
{ "connection.driver_class", Driver },
{ "dialect", Dialect },
{ "use_outer_join", UseOuterJoin.ToString().ToLowerInvariant() },
{ "connection.connection_string", ConnectionString },
{ "show_sql", ShowSql.ToString().ToLowerInvariant() },
{ "proxyfactory.factory_class", ProxyFactory }
};
if (IsCacheEnabled())
{
properties.Add("cache.provider_class", CacheProvider);
properties.Add("cache.use_second_level_cache", "true");
properties.Add("cache.use_query_cache", "true");
}
if (GenerateStatistics)
{
properties.Add("generate_statistics", "true");
}
return(properties);
}
public static IPersistenceConfigurer GetDatabaseConfig(ShowSql showSql)
{
return(showSql switch
{
ShowSql.No => PostgreSQLConfiguration.Standard.ConnectionString(ConfigurationHelper.ConnectionString),
ShowSql.UnformattedSql => PostgreSQLConfiguration.Standard.ConnectionString(ConfigurationHelper.ConnectionString).ShowSql(),
ShowSql.FormattedSql => PostgreSQLConfiguration.Standard.ConnectionString(ConfigurationHelper.ConnectionString).ShowSql().FormatSql(),
_ => throw new Exception($"Database configuration not found on {nameof(DatabaseConfigurer)}.{nameof(GetDatabaseConfig)}."),
});
public static void Update(this ShowSql showBdd, TMDbConfig config, TvShow item)
{
showBdd.PosterUrl = config.Images.SecureBaseUrl + "w500" + item.PosterPath;
if (item.ExternalIds != null)
{
showBdd.Providers[ProviderSql.Imdb] = item.ExternalIds.ImdbId;
}
}
public bool RefreshMissingEpisodes(IDatabase database)
{
List <ShowSql> result = new List <ShowSql>();
var show = new ShowSql(true)
{
Id = 99718,
Name = "Westworld",
Providers = new Dictionary <ProviderSql, string> {
{ ProviderSql.Imdb, "tt0475784" }, { ProviderSql.Tmdb, "63247" }
},
};
var season = new SeasonSql()
{
SeasonNumber = 2,
};
season.Episodes = new List <EpisodeSql>
{
new EpisodeSql()
{
EpisodeNumber = 3, Status = EpisodeStatusSql.Missing
},
new EpisodeSql()
{
EpisodeNumber = 4, Status = EpisodeStatusSql.Missing
},
new EpisodeSql()
{
EpisodeNumber = 5, Status = EpisodeStatusSql.Collected
}
};
show.Seasons = new List <SeasonSql> {
season
};
result.Add(show);
result.Add(new ShowSql(true)
{
Id = 123,
Name = "z fake",
});
result.Add(new ShowSql(true)
{
Id = 456,
Name = "9 fake",
});
database.AddOrUpdateShows(result);
return(true);
}
public static void Update(this ShowSql showBdd, TraktShow item)
{
showBdd.Name = item.SerieName;
showBdd.Year = item.Year;
if (item.Tmdb.HasValue)
{
showBdd.Providers[ProviderSql.Tmdb] = item.Tmdb.ToString();
}
if (!string.IsNullOrEmpty(item.Imdb))
{
showBdd.Providers[ProviderSql.Imdb] = item.Imdb;
}
}
/// <summary>
/// Converts this instance to key value pairs specifically for passing
/// to NHibernate configuration.
/// </summary>
public IDictionary <string, string> GetAsNHiberateProperties()
{
var properties = new Dictionary <string, string>
{
{ "connection.provider", Provider },
{ "connection.driver_class", DriverClass },
{ "dialect", Dialect },
{ "use_outer_join", UseOuterJoin.ToString() },
{ "connection.connection_string", ConnectionString },
{ "show_sql", ShowSql.ToString() },
{ "proxyfactory.factory_class", ProxyFactory }
};
return(properties);
}
private ShowSql GetShow(IDatabase database, uint id)
{
ShowSql localShow = null;
lock (ShowLock())
{
localShow = database.GetShow(id);
if (localShow == null)
{
localShow = new ShowSql(true)
{
Id = id,
};
}
}
return(localShow);
}
private SeasonSql GetSeason(ShowSql show, int seasonNumber)
{
SeasonSql localSeason = null;
lock (ShowLock())
{
localSeason = show.Seasons.SingleOrDefault(s => s.SeasonNumber == seasonNumber);
if (localSeason == null)
{
localSeason = new SeasonSql(show)
{
SeasonNumber = seasonNumber,
};
show.Seasons.Add(localSeason);
}
}
return(localSeason);
}
private async Task <List <ShowSql> > RefreshSeasonHiddenItem(IDatabase database, List <ShowSql> shows)
{
Dictionary <uint, ShowSql> res = shows.ToDictionary(s => s.Id);
TraktPagedResponse <ITraktUserHiddenItem> hiddenSeason = await Client.Users.GetHiddenItemsAsync(TraktHiddenItemsSection.ProgressCollected, TraktHiddenItemType.Season).ConfigureAwait(false);
TraktPagedResponse <ITraktUserHiddenItem> hiddenSeasonRes = hiddenSeason;
foreach (ITraktUserHiddenItem traktUserHiddenItem in hiddenSeasonRes)
{
ShowSql localShow = res.ContainsKey(traktUserHiddenItem.Show.Ids.Trakt) ? res[traktUserHiddenItem.Show.Ids.Trakt] : GetShow(database, traktUserHiddenItem.Show.Ids.Trakt);
SeasonSql localSeason = GetSeason(localShow, traktUserHiddenItem.Season.Number.Value);
localSeason.Update(traktUserHiddenItem);
res[localShow.Id] = localShow;
}
return(res.Values.ToList());
}
private async Task <List <ShowSql> > RefreshShowHiddenItem(IDatabase database)
{
List <ShowSql> res = new List <ShowSql>();
TraktPagedResponse <ITraktUserHiddenItem> hiddenShow = await Client.Users
.GetHiddenItemsAsync(TraktHiddenItemsSection.ProgressCollected, TraktHiddenItemType.Show)
.ConfigureAwait(false);
TraktPagedResponse <ITraktUserHiddenItem> hiddenShowRes = hiddenShow;
foreach (ITraktUserHiddenItem traktUserHiddenItem in hiddenShowRes)
{
ShowSql localShow = GetShow(database, traktUserHiddenItem.Show.Ids.Trakt);
localShow.Update(traktUserHiddenItem);
res.Add(localShow);
}
return(res);
}
public static Shared.Remote.Show Convert(this ShowSql sho)
{
Shared.Remote.Show show = new Shared.Remote.Show
{
Id = sho.Id,
Blacklisted = sho.Blacklisted,
SerieName = sho.Name,
Year = sho.Year,
//Providers = sho.Providers.ToDictionary(
// pair => (Provider)Enum.Parse(typeof(Provider), Enum.GetName(typeof(ProviderSql), pair.Key)),
// pair => pair.Value),
PosterUrl = sho.PosterUrl,
};
foreach (var seasonSqLite in sho.Seasons)
{
show.Seasons.Add(seasonSqLite.Convert());
}
return(show);
}
public static void Initialize(ShowSql showSql)
{
_fluentConfiguration = Fluently.Configure()
.Database(DatabaseConfigurer.GetDatabaseConfig(showSql))
.Mappings(m =>
{
m.FluentMappings
.AddFromAssembly(Assembly.Load(ConfigurationHelper.EntitiesMapsNamespace))
.Conventions.Add(new TableNamingConvention())
.Conventions.Add(new ColumnNamingConvention())
.Conventions.Add(new PrimaryKeyNamingConvention())
.Conventions.Add(new ForeignKeyNamingConvention())
.Conventions.Add(new ReferenceConvention());
})
.ExposeConfiguration(x =>
{
x.SetInterceptor(new SqlStatementInterceptor());
});
_currentSession = _fluentConfiguration.BuildSessionFactory();
}
private async Task RefreshShow(TMDbClient client, ShowSql showSql)
{
if (!showSql.Blacklisted && showSql.Providers.ContainsKey(ProviderSql.Tmdb) && !string.IsNullOrEmpty(showSql.Providers[ProviderSql.Tmdb]) && int.TryParse(showSql.Providers[ProviderSql.Tmdb], out var showId))
{
bool first = true;
// Refresh episodes
foreach (var seasonSql in showSql.Seasons.Where(s => !s.Blacklisted))
{
foreach (var episodeSql in seasonSql.Episodes)
{
if (string.IsNullOrEmpty(episodeSql.PosterUrl) && episodeSql.Status == EpisodeStatusSql.Missing)
{
if (first)
{
first = false;
}
else
{
await Task.Delay(1000);
}
await RefreshEpisode(client, episodeSql, showId);
}
}
}
// Missing show infos
if (string.IsNullOrEmpty(showSql.PosterUrl))
{
TvShow tvShow = await client.GetTvShowAsync(showId, TvShowMethods.ExternalIds, "fr-FR").ConfigureAwait(false);
showSql.Update(client.Config, tvShow);
}
}
}
private async Task HandleProgress(TraktShow traktShow, ShowSql bddShow)
{
// Remove Season blacklist
traktShow.Seasons.RemoveAll(s => bddShow.Seasons.Any(b => b.SeasonNumber == s.Season && b.Blacklisted));
if (traktShow.Seasons.Any())
{
TraktResponse <TraktNet.Objects.Get.Shows.ITraktShowCollectionProgress> collectionProgress =
await Client.Shows.GetShowCollectionProgressAsync(traktShow.Id.ToString(), false, false, false).ConfigureAwait(false);
TraktResponse <TraktNet.Objects.Get.Shows.ITraktShowCollectionProgress> collectionProgressRes = collectionProgress;
foreach (ITraktSeasonCollectionProgress season in collectionProgressRes.Value.Seasons)
{
TraktSeason misSeason = traktShow.Seasons.SingleOrDefault(e => e.Season == season.Number);
if (misSeason == null)
{
misSeason = new TraktSeason {
Season = season.Number.Value
};
traktShow.Seasons.Add(misSeason);
}
foreach (ITraktEpisodeCollectionProgress episode in season.Episodes)
{
// Already existing in missing
if (misSeason.MissingEpisodes.All(m => m.Episode != episode.Number))
{
misSeason.MissingEpisodes.Add(new TraktEpisode {
Episode = episode.Number.Value, Collected = episode.Completed.HasValue && episode.Completed.Value
});
}
}
}
foreach (TraktSeason showSeason in traktShow.Seasons)
{
SeasonSql season = GetSeason(bddShow, showSeason.Season);
// BlackList Ended series if complete
if ((traktShow.Status == TraktShowStatus.Ended || traktShow.Status == TraktShowStatus.Canceled) && !showSeason.MissingEpisodes.Any())
{
season.Blacklisted = true;
}
if (!season.Blacklisted)
{
// Save missing episode
foreach (TraktEpisode missingEpisode in showSeason.MissingEpisodes)
{
EpisodeSql ep = GetEpisode(season, missingEpisode.Episode);
ep.Status = missingEpisode.Collected || missingEpisode.Watched ? EpisodeStatusSql.Collected : EpisodeStatusSql.Missing;
}
}
// Remove watched from missing
showSeason.MissingEpisodes.RemoveAll(m => m.Watched);
// Remove collected from missing
showSeason.MissingEpisodes.RemoveAll(m => m.Collected);
}
traktShow.Seasons.RemoveAll(s => !s.MissingEpisodes.Any());
}
}
public bool RefreshMissingEpisodes(IDatabase database)
{
SetupClient(database);
RefreshHiddenItem(database);
// Set all missing to unknown
database.ClearMissingEpisodes();
Task <TraktListResponse <ITraktCollectionShow> > collected = Client.Users.GetCollectionShowsAsync("me", new TraktExtendedInfo {
Full = true
});
Task <TraktListResponse <ITraktWatchedShow> > watched = Client.Users.GetWatchedShowsAsync("me", new TraktExtendedInfo {
Full = true
});
List <TraktShow> shows = new List <TraktShow>();
watched.Wait();
TraktListResponse <ITraktWatchedShow> watchedRes = watched.Result;
foreach (ITraktWatchedShow traktWatchedShow in watchedRes)
{
int watchedEpisodes = traktWatchedShow.WatchedSeasons.Where(s => s.Number != 0).Sum(season => season.Episodes.Count());
TraktShow show = new TraktShow
{
Id = traktWatchedShow.Ids.Trakt,
Year = traktWatchedShow.Year,
SerieName = traktWatchedShow.Title,
Watched = watchedEpisodes >= traktWatchedShow.AiredEpisodes,
Status = traktWatchedShow.Status,
Imdb = traktWatchedShow.Ids.Imdb,
Tmdb = traktWatchedShow.Ids.Tmdb,
};
foreach (ITraktWatchedShowSeason season in traktWatchedShow.WatchedSeasons)
{
TraktSeason traktSeason = new TraktSeason {
Season = season.Number.Value
};
foreach (ITraktWatchedShowEpisode episode in season.Episodes)
{
traktSeason.MissingEpisodes.Add(new TraktEpisode {
Episode = episode.Number.Value, Watched = true
});
}
show.Seasons.Add(traktSeason);
}
shows.Add(show);
}
collected.Wait();
TraktListResponse <ITraktCollectionShow> collectedRes = collected.Result;
foreach (ITraktCollectionShow traktCollectionShow in collectedRes)
{
TraktShow show = shows.SingleOrDefault(s => s.Id == traktCollectionShow.Ids.Trakt);
if (show == null)
{
show = new TraktShow
{
Id = traktCollectionShow.Ids.Trakt,
Year = traktCollectionShow.Year,
SerieName = traktCollectionShow.Title,
Status = traktCollectionShow.Status,
Imdb = traktCollectionShow.Ids.Imdb,
Tmdb = traktCollectionShow.Ids.Tmdb,
};
shows.Add(show);
}
foreach (ITraktCollectionShowSeason season in traktCollectionShow.CollectionSeasons)
{
TraktSeason misSeason = show.Seasons.SingleOrDefault(e => e.Season == season.Number);
if (misSeason == null)
{
misSeason = new TraktSeason {
Season = season.Number.Value
};
show.Seasons.Add(misSeason);
}
foreach (ITraktCollectionShowEpisode episode in season.Episodes)
{
TraktEpisode misEpisode = misSeason.MissingEpisodes.SingleOrDefault(e => e.Episode == episode.Number);
if (misEpisode != null)
{
misEpisode.Collected = true;
}
else
{
misSeason.MissingEpisodes.Add(new TraktEpisode {
Episode = episode.Number.Value, Collected = true
});
}
}
}
}
shows.RemoveAll(s => s.Watched);
// PrepareDB
List <ShowSql> bddShows = database.GetShows();
List <ShowSql> updateShows = new List <ShowSql>();
// Remove Show blacklist
shows.RemoveAll(s => bddShows.Any(b => b.Id == s.Id && b.Blacklisted));
List <Task> tasks = new List <Task>();
foreach (TraktShow traktShow in shows)
{
ShowSql localShow = GetShow(database, traktShow.Id);
localShow.Update(traktShow);
updateShows.Add(localShow);
tasks.Add(HandleProgress(traktShow, localShow));
}
Task.WaitAll(tasks.ToArray());
database.AddOrUpdateShows(updateShows);
database.ClearUnknownEpisodes();
shows.RemoveAll(s => !s.Seasons.Any());
return(true);
}
