} // prevent instances public static void saveToDB(List <string> entries) { StringBuilder logoB = new StringBuilder(); foreach (string entry in entries) { logoB.Append(entry).Append(entriesSplit); } if (logoB.Length > entriesSplit.Length) { logoB.Remove(logoB.Length - entriesSplit.Length, entriesSplit.Length); } DBOption.SetOptions(optionName, logoB.ToString()); entriesInMemory = false; }
void DoFileScan(List <String> scannedFolders, ref List <PathPair> previousScan) { MPTVSeriesLog.Write("File Watcher: Performing File Scan on Import Paths for changes", MPTVSeriesLog.LogLevel.Normal); // Check if Fullscreen Video is active as this can cause stuttering/dropped frames if (!DBOption.GetOptions(DBOption.cImportScanWhileFullscreenVideo) && Helper.IsFullscreenVideo) { MPTVSeriesLog.Write("File Watcher: Fullscreen Video has been detected, aborting file scan"); return; } List <PathPair> newScan = Filelister.GetFiles(scannedFolders); List <PathPair> addedFiles = new List <PathPair>(); addedFiles.AddRange(newScan); foreach (PathPair pair in previousScan) { addedFiles.RemoveAll(item => item.m_sFull_FileName == pair.m_sFull_FileName); } List <PathPair> removedFiles = new List <PathPair>(); removedFiles.AddRange(previousScan); foreach (PathPair pair in newScan) { removedFiles.RemoveAll(item => item.m_sFull_FileName == pair.m_sFull_FileName); } lock (m_modifiedFilesList) { foreach (PathPair pair in addedFiles) { m_modifiedFilesList.Add(new WatcherItem(pair, WatcherItemType.Added)); } foreach (PathPair pair in removedFiles) { m_modifiedFilesList.Add(new WatcherItem(pair, WatcherItemType.Deleted)); } } previousScan = newScan; MPTVSeriesLog.Write("File Watcher: Finished File Scan on Import Paths", MPTVSeriesLog.LogLevel.Normal); }
public static string stdGetSQL(SQLCondition condition, bool selectFull, bool includeStdCond) { string orderBy = !condition.customOrderStringIsSet ? " order by " + Q(cIndex) : condition.orderString; if (includeStdCond) { condition.AddCustom(stdConditions.ConditionsSQLString); if (!Settings.isConfig) { SQLCondition fullSubCond = new SQLCondition(); //fullSubCond.AddCustom(DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID), DBSeason.Q(DBSeason.cSeriesID), SQLConditionType.Equal); //fullSubCond.AddCustom(DBOnlineEpisode.Q(DBOnlineEpisode.cSeasonIndex), DBSeason.Q(DBSeason.cIndex), SQLConditionType.Equal); //condition.AddCustom(" season.seasonindex in ( " + DBEpisode.stdGetSQL(fullSubCond, false, true, DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID)) + " )"); string join = null; if (DBOption.GetOptions(DBOption.cOnlyShowLocalFiles)) { fullSubCond = DBEpisode.stdConditions; condition.AddCustom(fullSubCond.ConditionsSQLString.Replace("where", "and")); join = " left join local_episodes on season.seriesid = local_episodes.seriesid " + " and season.seasonindex = local_episodes.seasonindex left join online_episodes on local_episodes.compositeid = online_episodes.compositeid "; } else { join = " left join online_episodes on season.seriesid = online_episodes.seriesid " + " and season.seasonindex = online_episodes.seasonindex"; } return("select " + new SQLWhat(new DBSeason()) + join + condition + " group by season.id " + orderBy + condition.limitString); } } if (selectFull) { return("select " + new SQLWhat(new DBSeason()) + condition + orderBy + condition.limitString); } else { return("select " + DBSeason.cID + " from " + DBSeason.cTableName + " " + condition + orderBy + condition.limitString); } }
private void onStopExternal(Process proc, bool waitForExit) { if (!listenToExternalPlayerEvents) { return; } MPTVSeriesLog.Write("Playback Stopped in External Player:" + m_currentEpisode.ToString()); // Exit fullscreen Video so we can see main facade again if (GUIGraphicsContext.IsFullScreenVideo) { GUIGraphicsContext.IsFullScreenVideo = false; } // Mark Episode as watched regardless and prompt for rating bool markAsWatched = (DBOption.GetOptions(DBOption.cWatchedAfter) > 0 && m_currentEpisode[DBOnlineEpisode.cWatched] == 0); PlaybackOperationEnded(markAsWatched); }
public static void InitLogLevel() { using (var xmlreader = new MediaPortal.Profile.MPSettings()) { int logLevel = xmlreader.GetValueAsInt("general", "loglevel", 2); if (DBOption.GetOptions(DBOption.cSQLLoggingEnabled)) { selectedLogLevel = MPTVSeriesLog.LogLevel.DebugSQL; } else if (logLevel == 3) { selectedLogLevel = MPTVSeriesLog.LogLevel.Debug; } else { selectedLogLevel = MPTVSeriesLog.LogLevel.Normal; } } }
/// <summary> /// Read Logo Rules and Import into Database /// </summary> /// <param name="doc"></param> private static void GetLogoRules(XmlDocument doc) { XmlNode node = null; node = doc.DocumentElement.SelectSingleNode("/settings/logos"); if (node != null && node.Attributes.GetNamedItem("import").Value.ToLower() == "true") { MPTVSeriesLog.Write("Loading Skin Logo Rules", MPTVSeriesLog.LogLevel.Normal); DBOption.SetOptions("logoConfig", ""); List <string> logos = new List <string>(); foreach (string rule in node.InnerText.Split('\n')) { logos.Add(rule.Trim()); } localLogos.saveToDB(logos); ImportLogos = true; } }
private void OnSavePlayList() { currentSelectedItem = m_Facade.SelectedListItemIndex; string playlistFileName = string.Empty; if (GetKeyboard(ref playlistFileName)) { string playListPath = string.Empty; playListPath = DBOption.GetOptions(DBOption.cPlaylistPath); playListPath = MediaPortal.Util.Utils.RemoveTrailingSlash(playListPath); // check if Playlist folder exists, create it if not if (!Directory.Exists(playListPath)) { try { Directory.CreateDirectory(playListPath); } catch (Exception e) { MPTVSeriesLog.Write("Error: Unable to create Playlist path: " + e.Message); return; } } string fullPlayListPath = Path.GetFileNameWithoutExtension(playlistFileName); fullPlayListPath += ".tvsplaylist"; if (playListPath.Length != 0) { fullPlayListPath = playListPath + @"\" + fullPlayListPath; } PlayList playlist = new PlayList(); for (int i = 0; i < m_Facade.Count; ++i) { GUIListItem listItem = m_Facade[i]; PlayListItem playListItem = new PlayListItem(); playListItem.Episode = listItem.TVTag as DBEpisode; playlist.Add(playListItem); } PlayListIO saver = new PlayListIO(); saver.Save(playlist, fullPlayListPath); } }
void workerWatcher_DoWork(object sender, DoWorkEventArgs e) { System.Threading.Thread.CurrentThread.Priority = ThreadPriority.Lowest; // delay the start of file monitoring for a small period // this doesnt really need a config setting but can be manually overridden in DB option // purpose of the delay is to allow network devices to get ready after fresh boot from windows // and resume from standby...benifits UNC shares as Mapped drives are picked up from Device Manager events. // also DoFileScan can be expensive, so we dont want to do this on startup while other plugins/background tasks // are running as well. Thread.Sleep((int)DBOption.GetOptions(DBOption.cDelayImportPathMonitoringValue) * 1000); MPTVSeriesLog.Write("File Watcher: Starting File System Watcher Background Task", MPTVSeriesLog.LogLevel.Normal); setUpWatches(); // do the initial scan m_PreviousScan = Filelister.GetFiles(m_ScannedFolders); m_PreviousScanRemovable = Filelister.GetFiles(GetDeviceManagerWatchedFolders()); DateTime timeLastScan = DateTime.Now; // then start the watcher loop while (!worker.CancellationPending) { TimeSpan tsUpdate = DateTime.Now - timeLastScan; if ((int)tsUpdate.TotalMinutes >= m_nScanLapse) { timeLastScan = DateTime.Now; DoFileScan(); } signalModifiedFiles(); if (refreshWatchers) { setUpWatches(); } Thread.Sleep(1000); } }
public static String GetEpisodeImage(DBEpisode episode) { bool HideEpisodeImage = true; if (!localLogos.appendEpImage && (episode[DBOnlineEpisode.cWatched] || !DBOption.GetOptions(DBOption.cHideUnwatchedThumbnail))) { HideEpisodeImage = false; } // show episode image if (!HideEpisodeImage && !String.IsNullOrEmpty(episode.Image) && System.IO.File.Exists(episode.Image)) { return(episode.Image); } else { // show a fanart thumb instead Fanart fanart = Fanart.getFanart(episode[DBOnlineEpisode.cSeriesID]); return(fanart.FanartThumbFilename); } }
/// <summary> /// Read Graphics Quality Settings and Import into Database /// </summary> /// <param name="doc"></param> private static void GetGraphicsQuality(XmlDocument doc) { XmlNode node = null; XmlNode innerNode = null; node = doc.DocumentElement.SelectSingleNode("/settings/graphicsquality"); if (node != null && node.Attributes.GetNamedItem("import").Value.ToLower() == "true") { MPTVSeriesLog.Write("Loading Skin Thumbnail Graphics Quality", MPTVSeriesLog.LogLevel.Normal); innerNode = node.SelectSingleNode("seriesbanners"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeriesBanners, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("seriesposters"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeriesPosters, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("seriescoverflow"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeriesPosters, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("seasonbanners"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeasonBanners, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("episodethumbs"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualityEpisodeImages, innerNode.InnerText.Trim()); } ImportGraphics = true; } }
void OnPlaybackChanged(g_Player.MediaType type, int timeMovieStopped, string filename) { if (PlayBackOpWasOfConcern(g_Player.IsVideo? g_Player.MediaType.Video : g_Player.MediaType.Unknown, g_Player.CurrentFile)) { if (PlayPropertyUpdater.IsBusy) { PlayPropertyUpdater.CancelAsync(); } LogPlayBackOp("changed", g_Player.CurrentFile); try { #region Set Resume Point or Watched double watchedAfter = DBOption.GetOptions(DBOption.cWatchedAfter); if (!m_previousEpisode[DBOnlineEpisode.cWatched] && (timeMovieStopped / playlistPlayer.g_Player.Duration) > watchedAfter / 100) { m_previousEpisode[DBEpisode.cStopTime] = 0; m_previousEpisode.Commit(); MPTVSeriesLog.Write("This episode counts as watched"); MarkEpisodeAsWatched(m_previousEpisode); SetGUIProperties(true); } else { m_previousEpisode[DBEpisode.cStopTime] = timeMovieStopped; m_previousEpisode.Commit(); SetGUIProperties(true); } #endregion m_previousEpisode = null; } catch (Exception e) { MPTVSeriesLog.Write("TVSeriesPlugin.VideoHandler.OnPlaybackChanged()\r\n" + e.ToString()); } } }
static DBExpression() { // make sure the table is created - create a dummy object DBExpression dummy = new DBExpression(); DBExpression[] expressions = DBExpression.GetAll(); if (expressions == null || expressions.Length == 0) { // no expressions in the db, add defaults AddDefaults(); } else { // upgrade, add any new expressions int nCurrentDBVersion = cDBVersion; int nUpgradeDBVersion = DBOption.GetOptions(DBOption.cDBExpressionsVersion); while (nUpgradeDBVersion != nCurrentDBVersion) { DBExpression expression = new DBExpression(); switch (nUpgradeDBVersion) { case 4: expression[DBExpression.cEnabled] = "1"; expression[DBExpression.cIndex] = expressions.Length; expression[DBExpression.cType] = DBExpression.cType_Regexp; expression[DBExpression.cExpression] = @"(^.*?\\?(?<series>[^\\$]+?)[ .-]+(?<firstaired>\d{2,4}[.-]\d{2}[.-]\d{2,4})[ .-]*(?<title>(?![^\\]*?(?<!the)[ .(-]sample[ .)-]).*?)\.(?<ext>[^.]*)$)"; expression.Commit(); break; } nUpgradeDBVersion++; } DBOption.SetOptions(DBOption.cDBExpressionsVersion, nCurrentDBVersion); } }
public static String GetSeasonBanner(DBSeason season, bool createIfNotExist, bool isCoverflow) { Size size = isCoverflow ? reqSeasonPosterCFSize : reqSeasonPosterSize; String sFileName = season.Banner; String sTextureName = null; if (sFileName.Length > 0 && System.IO.File.Exists(sFileName)) { if (DBOption.GetOptions(DBOption.cAltImgLoading)) { sTextureName = sFileName; // bypass memoryimagebuilder } else { sTextureName = buildMemoryImageFromFile(sFileName, size); } } if (createIfNotExist && string.IsNullOrEmpty(sTextureName)) { // no image, use text, create our own string text = (season[DBSeason.cIndex] == 0) ? Translation.specials : Translation.Season + season[DBSeason.cIndex]; string ident = season[DBSeason.cSeriesID] + "S" + season[DBSeason.cIndex]; sTextureName = buildMemoryImage(drawSimpleBanner(size, text), ident, size, true); } // nothing left we can do, so return empty if still nothing if (string.IsNullOrEmpty(sTextureName)) { return(string.Empty); } s_SeasonsImageList.Add(sTextureName); return(sTextureName); }
void OnPlayBackStopped(g_Player.MediaType type, int timeMovieStopped, string filename) { if (PlayBackOpIsOfConcern(type, filename)) { if (PlayPropertyUpdater.IsBusy) { PlayPropertyUpdater.CancelAsync(); } LogPlayBackOp("stopped", filename); try { #region Set Resume Point or Watched double watchedAfter = DBOption.GetOptions(DBOption.cWatchedAfter); if ((timeMovieStopped / playlistPlayer.g_Player.Duration) > watchedAfter / 100) { m_currentEpisode[DBEpisode.cStopTime] = 0; m_currentEpisode.Commit(); PlaybackOperationEnded(true); } else { m_currentEpisode[DBEpisode.cStopTime] = timeMovieStopped; m_currentEpisode.Commit(); PlaybackOperationEnded(false); } #endregion m_currentEpisode = null; m_previousEpisode = null; } catch (Exception e) { MPTVSeriesLog.Write("TVSeriesPlugin.VideoHandler.OnPlayBackStopped()\r\n" + e.ToString()); } } }
public List <string> getGroupItems(int stepIndex, string[] currentStepSelection) // in nested groups, eg. Networks-Genres-.. we also need selections { SQLCondition conditions = null; MPTVSeriesLog.Write("View: GetGroupItems: Begin", MPTVSeriesLog.LogLevel.Debug); if (stepIndex >= m_steps.Count) { return(null); // wrong index specified!! } addHierarchyConditions(ref stepIndex, ref currentStepSelection, ref conditions); logicalViewStep step = m_steps[stepIndex]; List <string> items = new List <string>(); // to ensure we respect on the fly filter settings if (DBOption.GetOptions(DBOption.cOnlyShowLocalFiles) && (typeof(DBOnlineEpisode) != step.groupedBy.table.GetType() && typeof(DBEpisode) != step.groupedBy.table.GetType())) { // not generic SQLCondition fullSubCond = new SQLCondition(); fullSubCond.AddCustom(DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID), DBOnlineSeries.Q(DBOnlineSeries.cID), SQLConditionType.Equal); conditions.AddCustom(" exists( " + DBEpisode.stdGetSQL(fullSubCond, false) + " )"); } else if (DBOption.GetOptions(DBOption.cOnlyShowLocalFiles)) { // has to be grouped by something episode conditions.Add(new DBEpisode(), DBEpisode.cFilename, "", SQLConditionType.NotEqual); } string fieldName = step.groupedBy.rawFieldname; string tableName = step.groupedBy.table.m_tableName; string tableField = step.groupedBy.tableField; string userEditField = tableField + DBTable.cUserEditPostFix; string sql = string.Empty; // check if the useredit column exists if (DBTable.ColumnExists(tableName, fieldName + DBTable.cUserEditPostFix)) { sql = "select distinct(" + "case when (" + userEditField + " is null or " + userEditField + " = " + "'" + "'" + ") " + "then " + tableField + " else " + userEditField + " " + "end) as gnr, " + "count(*) from " + tableName + conditions + " group by gnr" + step.conds.orderString; } else { sql = "select distinct " + tableField + " , count(*) " + " from " + tableName + conditions + " group by " + tableField + step.conds.orderString; } SQLite.NET.SQLiteResultSet results = DBTVSeries.Execute(sql); MPTVSeriesLog.Write("View: GetGroupItems: SQL complete", MPTVSeriesLog.LogLevel.Debug); if (results.Rows.Count > 0) { for (int index = 0; index < results.Rows.Count; index++) { string tmpItem = results.Rows[index].fields[0]; // assume we now have a list of all distinct ones if (step.groupedBy.attempSplit) { // we want to try to split by "|" eg. for actors/genres string[] split = DBOnlineEpisode.splitField(tmpItem); foreach (string item in split) { if (item.Trim().Length == 0) { // display "Unknown" if field is empty" items.Add(Translation.Unknown); } else { items.Add(item.Trim()); } } } else { if (tmpItem.Trim().Length == 0) { items.Add(Translation.Unknown); } else { items.Add(tmpItem.Trim()); } } } if (step.groupedBy.attempSplit) { // have to check for dups (because we split eg. Drama|Action so "Action" might be in twice items = Helper.RemoveDuplicates(items); } // now we have to sort them again (Unknown/splitting above) items.Sort(); if (step.groupedBy.attempSplit) { // and limit in memory here (again because those splits are hard to deal with) if (step.limitItems > 0) { Helper.LimitList(ref items, step.limitItems); } } } MPTVSeriesLog.Write("View: GetGroupItems: Complete", MPTVSeriesLog.LogLevel.Debug); return(items); }
public override DBValue this[String fieldName] { get { switch (fieldName) { // if the user chooses a different language for the import, we don't have this as the prettyname case DBOnlineSeries.cOriginalName: string origLanguage = "en"; // English (original) DBValue currentTitle = base[DBOnlineSeries.cPrettyName]; if (DBOption.GetOptions(DBOption.cOnlineLanguage) == "en" && !DBOption.GetOptions(DBOption.cOverrideLanguage)) { return(base[DBOnlineSeries.cPrettyName]); } else { if (base[DBOnlineSeries.cOriginalName].ToString().Length > 0) { return(base[DBOnlineSeries.cOriginalName]); } else { // we need to get it MPTVSeriesLog.Write("Retrieving Original Series Name for '{0}'", currentTitle); UpdateSeries origParser = new UpdateSeries(base[DBOnlineSeries.cID], origLanguage, true); if (origParser != null && origParser.Results.Count == 1) { DBValue origTitle = origParser.Results[0][DBOnlineSeries.cPrettyName]; // there may not be an english title, so localized title is the original name origTitle = string.IsNullOrEmpty(origTitle) ? base[DBOnlineSeries.cPrettyName] : origTitle; // save for next time base[DBOnlineSeries.cOriginalName] = origTitle; Commit(); MPTVSeriesLog.Write("Original Series Name retrieved: '{0}'", origTitle); return(origTitle); } else { // something wrong MPTVSeriesLog.Write("Original Series Name could not be retrieved"); return(base[DBOnlineSeries.cPrettyName]); } } } case cSummary: DBValue summary = base[cSummary]; if (string.IsNullOrEmpty(summary)) { summary = Translation.SummaryNotAvailable; } return(summary); default: return(base[fieldName]); } } set { base[fieldName] = value; } }
static DBSeason() { DBSeason dummy = new DBSeason(); //////////////////////////////////////////////////////////////////////////////// #region Pretty Names displayed in Configuration Details Tab s_FieldToDisplayNameMap.Add(cID, "Composite Season ID"); s_FieldToDisplayNameMap.Add(cSeriesID, "Series ID"); s_FieldToDisplayNameMap.Add(cIndex, "Season Index"); s_FieldToDisplayNameMap.Add(cEpisodeCount, "Episodes"); s_FieldToDisplayNameMap.Add(cEpisodesUnWatched, "Episodes UnWatched"); s_FieldToDisplayNameMap.Add(cMyRating, "My Rating"); #endregion //////////////////////////////////////////////////////////////////////////////// int nCurrentDBVersion = cDBVersion; int nUpgradeDBVersion = DBOption.GetOptions(DBOption.cDBSeasonVersion); while (nUpgradeDBVersion != nCurrentDBVersion) { SQLCondition condEmpty = new SQLCondition(); List <DBSeason> AllSeasons = Get(condEmpty, true); // take care of the upgrade in the table switch (nUpgradeDBVersion) { case 1: // upgrade to version 2; clear the season table (series table format changed) try { String sqlQuery = "DROP TABLE season"; DBTVSeries.Execute(sqlQuery); nUpgradeDBVersion++; } catch { } break; case 2: DBSeason.GlobalSet(DBSeason.cHidden, 0, new SQLCondition()); DBSeries.GlobalSet(DBOnlineSeries.cGetEpisodesTimeStamp, 0, new SQLCondition()); nUpgradeDBVersion++; break; case 3: // create the unwatcheditem value by parsin the episodes foreach (DBSeason season in AllSeasons) { DBEpisode episode = DBEpisode.GetFirstUnwatched(season[DBSeason.cSeriesID], season[DBSeason.cIndex]); if (episode != null) { season[DBSeason.cUnwatchedItems] = true; } else { season[DBSeason.cUnwatchedItems] = false; } season.Commit(); } nUpgradeDBVersion++; break; case 4: // Set number of watched/unwatched episodes foreach (DBSeason season in AllSeasons) { int epsTotal = 0; int epsUnWatched = 0; DBEpisode.GetSeasonEpisodeCounts(season, out epsTotal, out epsUnWatched); season[DBSeason.cEpisodeCount] = epsTotal; season[DBSeason.cEpisodesUnWatched] = epsUnWatched; season.Commit(); } nUpgradeDBVersion++; break; default: nUpgradeDBVersion = nCurrentDBVersion; break; } } DBOption.SetOptions(DBOption.cDBSeasonVersion, nCurrentDBVersion); }
static FieldGetter() { formatingRule fr = null; // hide the episodesummary if option is set fr = new formatingRule(delegate(string value, string field, DBTable item) { DBEpisode e = item as DBEpisode; if (null == e) { return(false); } return(field == "<Episode.Summary>" && DBOption.GetOptions(DBOption.cHideUnwatchedSummary) && !e[DBOnlineEpisode.cWatched]); }, delegate(string value, string field, DBTable item) { return(Translation._Hidden_to_prevent_spoilers_); }); formatingRules.Add(fr); // replace seasonindex and episodeindex for different episode sortby // skins using these properties will display correct indexes based on sort order fr = new formatingRule(delegate(string value, string field, DBTable item) { DBEpisode e = item as DBEpisode; if (null == e) { return(false); } if (field.Contains("<Episode.SeasonIndex>") || field.Contains("<Episode.EpisodeIndex>")) { DBSeries s = Helper.getCorrespondingSeries(e[DBOnlineEpisode.cSeriesID]); if (null != s && s[DBOnlineSeries.cEpisodeSortOrder] == "DVD") { return(true); } } return(false); }, delegate(string value, string field, DBTable item) { string replacement = string.Empty; replacement = field.Replace("<Episode.SeasonIndex>", "<Episode.Combined_season>"); replacement = replacement.Replace("<Episode.EpisodeIndex>", "<Episode.Combined_episodenumber>"); return(resolveDynString(replacement, item)); }); formatingRules.Add(fr); fr = new formatingRule("\\n", Environment.NewLine); formatingRules.Add(fr); fr = new formatingRule("''", "'"); formatingRules.Add(fr); fr = new formatingRule("\\\"", "\""); formatingRules.Add(fr); fr = new formatingRule("\\'", "'"); formatingRules.Add(fr); fr = new formatingRule(Translation.Season + @"\:{0,1}\s{0,2}0", Translation.specials, true); formatingRules.Add(fr); fr = new formatingRule(@"Season\:{0,1}\s{0,2}0", Translation.specials, true); formatingRules.Add(fr); fr = new formatingRule(@"Season\:{0,1}\s{0,2}", Translation.Season + " ", true); formatingRules.Add(fr); fr = new formatingRule(@"(?<!\d)0x\d{1,3}", Translation.special + " ", true); formatingRules.Add(fr); // enable user to show 0/1 as Boolean (will show up as Yes/No) fr = new formatingRule("asBool(0)", Translation.No); formatingRules.Add(fr); fr = new formatingRule("asBool(1)", Translation.Yes); formatingRules.Add(fr); // want to ensure these show as is nonFormattingFields.Add("<Episode.EpisodeFilename>"); //_dateFormat = DBOption.GetOptions(DBOption.cDateFormatString); _dateFormat = System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern; _formatDates = !String.IsNullOrEmpty(_dateFormat) && DBOption.GetOptions(DBOption.cUseRegionalDateFormatString); }
public List <DBFanart> FanartsToDownload(int SeriesID) { // Only get a list of fanart that is available for download String sqlQuery = "select * from " + cTableName; sqlQuery += " where " + cSeriesID + " = " + SeriesID.ToString(); // Get Preferred Resolution int res = DBOption.GetOptions(DBOption.cAutoDownloadFanartResolution); bool getSeriesNameFanart = DBOption.GetOptions(DBOption.cAutoDownloadFanartSeriesNames); if (res == (int)FanartResolution.HD) { sqlQuery += " and " + cResolution + " = " + "\"1280x720\""; } if (res == (int)FanartResolution.FULLHD) { sqlQuery += " and " + cResolution + " = " + "\"1920x1080\""; } if (!getSeriesNameFanart) { sqlQuery += " and " + cSeriesName + " != " + "\"true\""; } SQLiteResultSet results = DBTVSeries.Execute(sqlQuery); if (results.Rows.Count > 0) { int iFanartCount = 0; List <DBFanart> AvailableFanarts = new List <DBFanart>(results.Rows.Count); for (int index = 0; index < results.Rows.Count; index++) { if (results.GetField(index, (int)results.ColumnIndices[cLocalPath]).Length > 0) { iFanartCount++; } else { // Add 'Available to Download' fanart to list AvailableFanarts.Add(new DBFanart()); AvailableFanarts[AvailableFanarts.Count - 1].Read(ref results, index); } } // sort by highest rated AvailableFanarts.Sort(); // Only return the fanarts that we want to download int AutoDownloadCount = DBOption.GetOptions(DBOption.cAutoDownloadFanartCount); for (int i = 0; i < AvailableFanarts.Count; i++) { // Dont get more than the user wants if (iFanartCount >= AutoDownloadCount) { break; } _FanartsToDownload.Add(AvailableFanarts[i]); iFanartCount++; } } return(_FanartsToDownload); }
void PlaybackOperationEnded(bool countAsWatched) { // notify listeners if (!countAsWatched && EpisodeStopped != null) { EpisodeStopped(m_currentEpisode); } if (countAsWatched || m_currentEpisode[DBOnlineEpisode.cWatched]) { MPTVSeriesLog.Write("This episode counts as watched"); if (countAsWatched) { MarkEpisodeAsWatched(m_currentEpisode); // notify listeners if (EpisodeWatched != null) { EpisodeWatched(m_currentEpisode); } } // if the ep wasn't rated before, and the option to ask is set, bring up the ratings menu if ((String.IsNullOrEmpty(m_currentEpisode[DBOnlineEpisode.cMyRating]) || m_currentEpisode[DBOnlineEpisode.cMyRating] == 0) && DBOption.GetOptions(DBOption.cAskToRate)) { MPTVSeriesLog.Write("Episode not rated yet"); if (RateRequestOccured != null) { RateRequestOccured.Invoke(m_currentEpisode); } } else { MPTVSeriesLog.Write("Episode has already been rated or option not set"); } } SetGUIProperties(true); // clear GUI Properties #region Invoke After Playback string invoke = (string)DBOption.GetOptions(DBOption.cInvokeExtAfterPlayback); if (countAsWatched && !string.IsNullOrEmpty(invoke)) { string invokeArgs = (string)DBOption.GetOptions(DBOption.cInvokeExtAfterPlaybackArgs); try { // replace any placeholders in the arguments for the script if any have been supplied. if (!string.IsNullOrEmpty(invokeArgs)) { invokeArgs = FieldGetter.resolveDynString(invokeArgs, m_currentEpisode, true); } invoke = FieldGetter.resolveDynString(invoke, m_currentEpisode, true); // use ProcessStartInfo instead of Process.Start(string) as latter produces a "cannot find file" // error if you pass in command line arguments. // also allows us to run the script hidden, preventing, for example, a command prompt popping up. ProcessStartInfo psi = new ProcessStartInfo(invoke, invokeArgs); psi.WindowStyle = ProcessWindowStyle.Hidden; Process proc = System.Diagnostics.Process.Start(psi); MPTVSeriesLog.Write(string.Format("Sucessfully Invoked AfterFilePlay Command: '{0}' '{1}'", invoke, invokeArgs)); // if not present in database this evaluates to false. If present and not a valid bool then // it evaluates to true bool waitForExit = (bool)DBOption.GetOptions(DBOption.cInvokeExtAfterPlaybackWaitForExit); // if true this thread will wait for the external user script to complete before continuing. if (waitForExit) { proc.WaitForExit(); } } catch (Exception e) { MPTVSeriesLog.Write(string.Format("Unable to Invoke ExtAfterPlayback Command: '{0}' '{1}'", invoke, invokeArgs)); MPTVSeriesLog.Write(e.Message); } } #endregion }
public void DownloadBanners(string onlineLanguage) { int maxConsecutiveDownloadErrors; var consecutiveDownloadErrors = 0; if (!int.TryParse(DBOption.GetOptions(DBOption.cMaxConsecutiveDownloadErrors).ToString(), out maxConsecutiveDownloadErrors)) { maxConsecutiveDownloadErrors = 3; } // now that we have all the paths, download all the files foreach (SeriesBannersMap map in SeriesBannersMap) { #region Series Wide Banners var seriesWideBanners = new List <WideBannerSeries>(map.SeriesWideBanners); var seriesWideBannersToKeep = new List <WideBannerSeries>(); // if localized and english banners exist then only get them // if none exist, then get what's left over if (seriesWideBanners.Exists(b => b.Language == onlineLanguage || b.Language == "en" || b.Language == string.Empty)) { seriesWideBanners.RemoveAll(b => b.Language != onlineLanguage && b.Language != "en" && b.Language != string.Empty); } foreach (var seriesWideBanner in seriesWideBanners) { if (consecutiveDownloadErrors >= maxConsecutiveDownloadErrors) { MPTVSeriesLog.Write("Too many consecutive download errors. Aborting."); return; } // mark the filename with the language seriesWideBanner.FileName = Helper.cleanLocalPath(seriesWideBanner.SeriesName) + @"\-lang" + seriesWideBanner.Language + "-" + seriesWideBanner.OnlinePath; string file = OnlineAPI.DownloadBanner(seriesWideBanner.OnlinePath, Settings.Path.banners, seriesWideBanner.FileName); if (BannerDownloadDone != null) { BannerDownloadDone(file); seriesWideBannersToKeep.Add(seriesWideBanner); consecutiveDownloadErrors = 0; } else { consecutiveDownloadErrors++; } } map.SeriesWideBanners = seriesWideBannersToKeep; #endregion #region Series Posters var seriesPosters = new List <PosterSeries>(map.SeriesPosters); var seriesPostersToKeep = new List <PosterSeries>(); // if localized and english banners exist then only get them // if none exist, then get what's left over if (seriesPosters.Exists(p => p.Language == onlineLanguage || p.Language == "en" || p.Language == string.Empty)) { seriesPosters.RemoveAll(p => p.Language != onlineLanguage && p.Language != "en" && p.Language != string.Empty); } foreach (var seriesPoster in seriesPosters) { if (consecutiveDownloadErrors >= maxConsecutiveDownloadErrors) { MPTVSeriesLog.Write("Too many consecutive download errors. Aborting."); return; } // mark the filename with the language seriesPoster.FileName = Helper.cleanLocalPath(seriesPoster.SeriesName) + @"\-lang" + seriesPoster.Language + "-" + seriesPoster.OnlinePath; string file = OnlineAPI.DownloadBanner(seriesPoster.OnlinePath, Settings.Path.banners, seriesPoster.FileName); if (BannerDownloadDone != null) { BannerDownloadDone(file); seriesPostersToKeep.Add(seriesPoster); consecutiveDownloadErrors = 0; } else { consecutiveDownloadErrors++; } } map.SeriesPosters = seriesPostersToKeep; #endregion #region Season Posters List <DBSeason> localSeasons = DBSeason.Get(new SQLCondition(new DBSeason(), DBSeason.cSeriesID, map.SeriesID, SQLConditionType.Equal), false); var seasonPosters = new List <PosterSeason>(map.SeasonPosters); var seasonPostersToKeep = new List <PosterSeason>(); // if localized and english banners exist then only get them // if none exist, then get what's left over if (seasonPosters.Exists(p => p.Language == onlineLanguage || p.Language == "en" || p.Language == string.Empty)) { seasonPosters.RemoveAll(p => p.Language != onlineLanguage && p.Language != "en" && p.Language != string.Empty); } foreach (var seasonPoster in seasonPosters) { if (consecutiveDownloadErrors >= maxConsecutiveDownloadErrors) { MPTVSeriesLog.Write("Too many consecutive download errors. Aborting."); return; } // only download season banners if we have online season in database if (!localSeasons.Any(s => s[DBSeason.cIndex] == seasonPoster.SeasonIndex)) { continue; } seasonPoster.FileName = Helper.cleanLocalPath(seasonPoster.SeriesName) + @"\-lang" + seasonPoster.Language + "-" + seasonPoster.OnlinePath; string file = OnlineAPI.DownloadBanner(seasonPoster.OnlinePath, Settings.Path.banners, seasonPoster.FileName); if (BannerDownloadDone != null) { BannerDownloadDone(file); seasonPostersToKeep.Add(seasonPoster); consecutiveDownloadErrors = 0; } else { consecutiveDownloadErrors++; } } map.SeasonPosters = seasonPostersToKeep; #endregion } }
static DBSeries() { // make sure the table is created on first run (and columns are added before we call SET) DBSeries dummy = new DBSeries(); s_nLastLocalID = DBOption.GetOptions(DBOption.cDBSeriesLastLocalID); s_FieldToDisplayNameMap.Add(cParsedName, "Parsed Name"); int nCurrentDBVersion = cDBVersion; int nUpgradeDBVersion = DBOption.GetOptions(DBOption.cDBSeriesVersion); while (nUpgradeDBVersion != nCurrentDBVersion) { SQLCondition condEmpty = new SQLCondition(); List <DBSeries> AllSeries = Get(condEmpty); // take care of the upgrade in the table switch (nUpgradeDBVersion) { case 1: case 2: // upgrade to version 3; clear the series table (we use 2 other tables now) try { String sqlQuery = "DROP TABLE series"; DBTVSeries.Execute(sqlQuery); nUpgradeDBVersion++; } catch { } break; case 3: // set all new perseries timestamps to 0 DBOnlineSeries.GlobalSet(new DBOnlineSeries(), DBOnlineSeries.cGetEpisodesTimeStamp, 0, new SQLCondition()); DBOnlineSeries.GlobalSet(new DBOnlineSeries(), DBOnlineSeries.cUpdateBannersTimeStamp, 0, new SQLCondition()); nUpgradeDBVersion++; break; case 4: DBSeries.GlobalSet(new DBSeries(), DBSeries.cHidden, 0, new SQLCondition()); nUpgradeDBVersion++; break; case 5: // copy all local parsed name into the online series if seriesID = 0 SQLCondition conditions = new SQLCondition(); conditions.Add(new DBOnlineSeries(), DBOnlineSeries.cID, 0, SQLConditionType.LessThan); // just getting the series should be enough List <DBSeries> seriesList = DBSeries.Get(conditions); nUpgradeDBVersion++; break; case 6: // set all watched flag timestamp to 0 (will be created) DBOnlineSeries.GlobalSet(new DBOnlineSeries(), DBOnlineSeries.cWatchedFileTimeStamp, 0, new SQLCondition()); nUpgradeDBVersion++; break; case 7: // all series no tagged for auto download at first DBOnlineSeries.GlobalSet(new DBOnlineSeries(), DBOnlineSeries.cTaggedToDownload, 0, new SQLCondition()); nUpgradeDBVersion++; break; case 8: // create the unwatcheditem value by parsin the episodes foreach (DBSeries series in AllSeries) { DBEpisode episode = DBEpisode.GetFirstUnwatched(series[DBSeries.cID]); if (episode != null) { series[DBOnlineSeries.cUnwatchedItems] = true; } else { series[DBOnlineSeries.cUnwatchedItems] = false; } series.Commit(); } nUpgradeDBVersion++; break; case 9: // Set number of watched/unwatched episodes foreach (DBSeries series in AllSeries) { int epsTotal = 0; int epsUnWatched = 0; DBEpisode.GetSeriesEpisodeCounts(series[DBSeries.cID], out epsTotal, out epsUnWatched); series[DBOnlineSeries.cEpisodeCount] = epsTotal; series[DBOnlineSeries.cEpisodesUnWatched] = epsUnWatched; series.Commit(); } nUpgradeDBVersion++; break; case 10: // Update Sort Name Column foreach (DBSeries series in AllSeries) { series[DBOnlineSeries.cSortName] = Helper.GetSortByName(series[DBOnlineSeries.cPrettyName]); series.Commit(); } nUpgradeDBVersion++; break; case 11: // Migrate isFavourite to new Tagged View conditions = new SQLCondition(); conditions.Add(new DBOnlineSeries(), DBOnlineSeries.cIsFavourite, "1", SQLConditionType.Equal); seriesList = DBSeries.Get(conditions); MPTVSeriesLog.Write("Migrating Favourite Series"); foreach (DBSeries series in seriesList) { // Tagged view are seperated with the pipe "|" character string tagName = "|" + DBView.cTranslateTokenFavourite + "|"; series[DBOnlineSeries.cViewTags] = Helper.GetSeriesViewTags(series, true, tagName); series.Commit(); } // Migrate isOnlineFavourite to new TaggedView conditions = new SQLCondition(); conditions.Add(new DBOnlineSeries(), DBOnlineSeries.cIsOnlineFavourite, "1", SQLConditionType.Equal); seriesList = DBSeries.Get(conditions); MPTVSeriesLog.Write("Migrating Online Favourite Series"); foreach (DBSeries series in seriesList) { // Tagged view are seperated with the pipe "|" character string tagName = "|" + DBView.cTranslateTokenOnlineFavourite + "|"; series[DBOnlineSeries.cViewTags] = Helper.GetSeriesViewTags(series, true, tagName); series.Commit(); } nUpgradeDBVersion++; break; case 12: // we now have parsed_series names as titlecased // to avoid users having to re-identify series for new episodes, and to avoid duplicate entries, we upgrade existing series names foreach (var series in AllSeries) { string oldName = series[DBSeries.cParsedName]; string newName = oldName.ToTitleCase(); MPTVSeriesLog.Write(string.Format("Upgrading Parsed Series Name: {0} to {1}", oldName, newName)); series[DBSeries.cParsedName] = newName; series.Commit(); } nUpgradeDBVersion++; break; case 13: // original name not working in previous release DBOnlineSeries.GlobalSet(new DBOnlineSeries(), DBOnlineSeries.cOriginalName, (DBValue)string.Empty, new SQLCondition()); nUpgradeDBVersion++; break; case 14: // original name not working in previous release DBOnlineSeries.GlobalSet(new DBOnlineSeries(), DBOnlineSeries.cTraktIgnore, 0, new SQLCondition()); nUpgradeDBVersion++; break; default: // new DB, nothing special to do nUpgradeDBVersion = nCurrentDBVersion; break; } } DBOption.SetOptions(DBOption.cDBSeriesVersion, nCurrentDBVersion); }
public bool ResumeOrPlay(DBEpisode episode) { try { MPTVSeriesLog.Write("Attempting to play: ", episode[DBEpisode.cFilename].ToString(), MPTVSeriesLog.LogLevel.Debug); // don't have this file ! if (episode[DBEpisode.cFilename].ToString().Length == 0) { return(false); } // check that we are not playing an episode out of episode if unwatched // ignore specials as they can be pretty out of wack! #region PlayBack Order // check sort order so our check is accurate var series = Helper.getCorrespondingSeries(episode[DBOnlineEpisode.cSeriesID]); bool dvdSortOrder = series[DBOnlineSeries.cEpisodeSortOrder] == "DVD"; string seasonField = dvdSortOrder ? DBOnlineEpisode.cCombinedSeason : DBOnlineEpisode.cSeasonIndex; string episodeField = dvdSortOrder ? DBOnlineEpisode.cCombinedEpisodeNumber : DBOnlineEpisode.cEpisodeIndex; if (DBOption.GetOptions(DBOption.cCheckPlayOutOfOrder) && !episode[DBOnlineEpisode.cWatched] && episode[seasonField] > 0 && episode[episodeField] > 1) { // first get the next unwatched episode from previously played // we are only interested in current season (could be multi-user watching multiple seasons) // API for GetNextUnwatched is not desirable as that works from Date Watched, we only care about watched here var conditions = new SQLCondition(); conditions.Add(new DBOnlineEpisode(), DBOnlineEpisode.cSeriesID, episode[DBOnlineSeries.cSeriesID], SQLConditionType.Equal); conditions.Add(new DBOnlineEpisode(), seasonField, episode[seasonField], SQLConditionType.Equal); conditions.Add(new DBOnlineEpisode(), episodeField, episode[episodeField], SQLConditionType.LessThan); conditions.Add(new DBOnlineEpisode(), episodeField, 0, SQLConditionType.GreaterThan); var episodes = DBEpisode.Get(conditions, false); if (episodes != null && episodes.Count > 0) { // set logical playback order based on sort order episodes.Sort(); // if the previous found episode is not watched then we are playing out of order // if we have a gap in episode collection then assume it has not been watched (this check is needed when user does not download all episode info) if (!episodes.Last()[DBOnlineEpisode.cWatched] || (episode[episodeField] - episodes.Last()[episodeField]) > 1) { GUIDialogYesNo dlgYesNo = (GUIDialogYesNo)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_YES_NO); dlgYesNo.SetHeading(Translation.Warning); dlgYesNo.SetLine(1, Translation.PlaybackOutOfOrderLine1); dlgYesNo.SetLine(2, string.Format("{0} - {1}x{2}", series.ToString(), episode[seasonField], episode[episodeField] - 1)); dlgYesNo.SetLine(3, Translation.PlaybackOutOfOrderLine2); dlgYesNo.DoModal(GUIWindowManager.ActiveWindow); if (!dlgYesNo.IsConfirmed) { return(false); } } } } #endregion m_previousEpisode = m_currentEpisode; m_currentEpisode = episode; int timeMovieStopped = m_currentEpisode[DBEpisode.cStopTime]; // Check if file is an Image e.g. ISO string filename = m_currentEpisode[DBEpisode.cFilename]; m_bIsImageFile = Helper.IsImageFile(filename); #region Invoke Before Playback // see if we have an invokeOption set up string invoke = (string)DBOption.GetOptions(DBOption.cInvokeExtBeforePlayback); if (!string.IsNullOrEmpty(invoke)) { string invokeArgs = (string)DBOption.GetOptions(DBOption.cInvokeExtBeforePlaybackArgs); try { // replace any placeholders in the arguments for the script if any have been supplied. if (!string.IsNullOrEmpty(invokeArgs)) { invokeArgs = FieldGetter.resolveDynString(invokeArgs, m_currentEpisode, true); } invoke = FieldGetter.resolveDynString(invoke, m_currentEpisode, true); // use ProcessStartInfo instead of Process.Start(string) as latter produces a "cannot find file" // error if you pass in command line arguments. // also allows us to run the script hidden, preventing, for example, a command prompt popping up. ProcessStartInfo psi = new ProcessStartInfo(invoke, invokeArgs); psi.WindowStyle = ProcessWindowStyle.Hidden; Process proc = System.Diagnostics.Process.Start(psi); MPTVSeriesLog.Write(string.Format("Sucessfully Invoked BeforeFilePlay Command: '{0}' '{1}'", invoke, invokeArgs)); // if not present in database this evaluates to false. If present and not a valid bool then // it evaluates to true bool waitForExit = (bool)DBOption.GetOptions(DBOption.cInvokeExtBeforePlaybackWaitForExit); // if true this thread will wait for the external user script to complete before continuing. if (waitForExit) { proc.WaitForExit(); } } catch (Exception e) { MPTVSeriesLog.Write(string.Format("Unable to Invoke BeforeFilePlay Command: '{0}' '{1}'", invoke, invokeArgs)); MPTVSeriesLog.Write(e.Message); } } #endregion #region Removable Media Handling if (!File.Exists(m_currentEpisode[DBEpisode.cFilename])) { string episodeVolumeLabel = m_currentEpisode[DBEpisode.cVolumeLabel].ToString(); if (string.IsNullOrEmpty(episodeVolumeLabel)) { episodeVolumeLabel = LocalParse.getImportPath(m_currentEpisode[DBEpisode.cFilename]); } // ask the user to input cd/dvd, usb disk or confirm network drive is connected GUIDialogOK dlgOK = (GUIDialogOK)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_OK); if (null == dlgOK) { return(false); } dlgOK.SetHeading(Translation.insertDisk); dlgOK.SetLine(1, Translation.InsertDiskMessage1); dlgOK.SetLine(2, Translation.InsertDiskMessage2); dlgOK.SetLine(3, Translation.InsertDiskMessage3); dlgOK.SetLine(4, string.Format(Translation.InsertDiskMessage4, episodeVolumeLabel)); dlgOK.DoModal(GUIWindowManager.ActiveWindow); if (!File.Exists(m_currentEpisode[DBEpisode.cFilename])) { return(false); // still not found, return to list } } #endregion #region Ask user to Resume // skip this if we are using an External Player bool bExternalPlayer = m_bIsImageFile ? m_bIsExternalDVDPlayer : m_bIsExternalPlayer; if (timeMovieStopped > 0 && !bExternalPlayer) { MPTVSeriesLog.Write("Asking user to resume episode from: " + Utils.SecondsToHMSString(timeMovieStopped)); GUIDialogYesNo dlgYesNo = (GUIDialogYesNo)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_YES_NO); if (null != dlgYesNo) { dlgYesNo.SetHeading(Translation.ResumeEpisode); dlgYesNo.SetLine(1, m_currentEpisode.onlineEpisode.CompleteTitle); dlgYesNo.SetLine(2, GUILocalizeStrings.Get(936) + " " + Utils.SecondsToHMSString(timeMovieStopped)); dlgYesNo.SetDefaultToYes(true); dlgYesNo.DoModal(GUIWindowManager.ActiveWindow); // reset resume data in DB if (!dlgYesNo.IsConfirmed) { timeMovieStopped = 0; m_currentEpisode[DBEpisode.cStopTime] = timeMovieStopped; m_currentEpisode.Commit(); MPTVSeriesLog.Write("User selected to start episode from beginning", MPTVSeriesLog.LogLevel.Debug); } else { MPTVSeriesLog.Write("User selected to resume episode", MPTVSeriesLog.LogLevel.Debug); // dont scrobble first of double episode if resuming past halfway double duration = m_currentEpisode[DBEpisode.cLocalPlaytime]; } } } #endregion Play(timeMovieStopped); return(true); } catch (Exception e) { MPTVSeriesLog.Write("TVSeriesPlugin.VideoHandler.ResumeOrPlay()\r\n" + e.ToString()); return(false); } }
static DBOption() { CreateTable(); #region Set Default Options if (GetOptions(cConfigLogCollapsed) == null) { SetOptions(cConfigLogCollapsed, false); } if (GetOptions(cDBSeriesLastLocalID) == null) { SetOptions(cDBSeriesLastLocalID, -1); } if (GetOptions(cShowHiddenItems) == null) { SetOptions(cShowHiddenItems, false); } if (GetOptions(cOnlineParseEnabled) == null) { SetOptions(cOnlineParseEnabled, true); } if (GetOptions(cFullSeriesRetrieval) == null) { SetOptions(cFullSeriesRetrieval, false); } if (GetOptions(cGetEpisodeSnapshots) == null) { SetOptions(cGetEpisodeSnapshots, true); } if (GetOptions(cAutoChooseSeries) == null) { SetOptions(cAutoChooseSeries, true); } if (GetOptions(cAutoChooseOrder) == null) { SetOptions(cAutoChooseOrder, true); } if (GetOptions(cOnlyShowLocalFiles) == null) { SetOptions(cOnlyShowLocalFiles, true); } if (GetOptions(cHideUnwatchedSummary) == null) { SetOptions(cHideUnwatchedSummary, false); } if (GetOptions(cHideUnwatchedThumbnail) == null) { SetOptions(cHideUnwatchedThumbnail, false); } if (GetOptions(cImportFolderWatch) == null) { SetOptions(cImportFolderWatch, true); } if (GetOptions(cImportScanRemoteShare) == null) { SetOptions(cImportScanRemoteShare, true); } if (GetOptions(cImportScanRemoteShareLapse) == null) { SetOptions(cImportScanRemoteShareLapse, 5); } if (GetOptions(cImportAutoUpdateOnlineData) == null) { SetOptions(cImportAutoUpdateOnlineData, true); } if (GetOptions(cImportAutoUpdateOnlineDataLapse) == null) { SetOptions(cImportAutoUpdateOnlineDataLapse, 12); } if (GetOptions(cImportOnlineUpdateScanLastTime) == null) { SetOptions(cImportOnlineUpdateScanLastTime, 0); } if (GetOptions(cImportDontClearMissingLocalFiles) == null) { SetOptions(cImportDontClearMissingLocalFiles, 0); } if (GetOptions(cCheckArtwork) == null) { SetOptions(cCheckArtwork, 0); } if (GetOptions(cPluginName) == null) { SetOptions(cPluginName, "My TV Series"); } if (GetOptions(cViewAutoHeight) == null) { SetOptions(cViewAutoHeight, true); } if (GetOptions(cViewSeriesListFormat) == null) { SetOptions(cViewSeriesListFormat, "ListPosters"); } if (GetOptions(cViewSeasonListFormat) == null) { SetOptions(cViewSeasonListFormat, 0); } if (GetOptions(cViewSeriesColOne) == null) { SetOptions(cViewSeriesColOne, ""); } if (GetOptions(cViewSeriesColTwo) == null) { SetOptions(cViewSeriesColTwo, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cPrettyName + ">"); } if (GetOptions(cViewSeriesColThree) == null) { SetOptions(cViewSeriesColThree, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cAirsDay + ">"); } if (GetOptions(cViewSeriesTitle) == null) { SetOptions(cViewSeriesTitle, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cPrettyName + ">"); } if (GetOptions(cViewSeriesSecondTitle) == null) { SetOptions(cViewSeriesSecondTitle, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cGenre + ">"); } if (GetOptions(cViewSeriesMain) == null) { SetOptions(cViewSeriesMain, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cSummary + ">"); } if (GetOptions(cUseSortName) == null) { SetOptions(cUseSortName, 0); // default sort is by pretty name } if (GetOptions(cViewSeasonColOne) == null) { SetOptions(cViewSeasonColOne, ""); } if (GetOptions(cViewSeasonColTwo) == null) { SetOptions(cViewSeasonColTwo, "Season <" + DBSeason.cOutName + "." + DBSeason.cIndex + ">"); } if (GetOptions(cViewSeasonColThree) == null) { SetOptions(cViewSeasonColThree, ""); } if (GetOptions(cViewSeasonTitle) == null) { SetOptions(cViewSeasonTitle, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cPrettyName + "> Season <" + DBSeason.cOutName + "." + DBSeason.cIndex + ">"); } if (GetOptions(cViewSeasonSecondTitle) == null) { SetOptions(cViewSeasonSecondTitle, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cGenre + ">"); } if (GetOptions(cViewSeasonMain) == null) { SetOptions(cViewSeasonMain, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cSummary + ">"); } if (GetOptions(cViewEpisodeColOne) == null) { SetOptions(cViewEpisodeColOne, ""); } if (GetOptions(cViewEpisodeColTwo) == null) { SetOptions(cViewEpisodeColTwo, "<" + DBEpisode.cOutName + "." + DBEpisode.cEpisodeIndex + ">: <" + DBEpisode.cOutName + "." + DBEpisode.cEpisodeName + ">"); } if (GetOptions(cViewEpisodeColThree) == null) { SetOptions(cViewEpisodeColThree, "<" + DBEpisode.cOutName + "." + DBOnlineEpisode.cFirstAired + ">"); } if (GetOptions(cViewEpisodeTitle) == null) { SetOptions(cViewEpisodeTitle, "<" + DBEpisode.cOutName + "." + DBEpisode.cSeasonIndex + ">x<" + DBEpisode.cOutName + "." + DBEpisode.cEpisodeIndex + ">: <" + DBEpisode.cOutName + "." + DBEpisode.cEpisodeName + ">"); } if (GetOptions(cViewEpisodeSecondTitle) == null) { SetOptions(cViewEpisodeSecondTitle, "<" + DBSeries.cOutName + "." + DBOnlineSeries.cGenre + ">"); } if (GetOptions(cViewEpisodeMain) == null) { SetOptions(cViewEpisodeMain, "<" + DBEpisode.cOutName + "." + DBOnlineEpisode.cEpisodeSummary + ">"); } if (GetOptions(cRandomBanner) == null) { SetOptions(cRandomBanner, 0); } if (GetOptions(cWatchedAfter) == null) { SetOptions(cWatchedAfter, 95); } // this is the default main mirrors if (GetOptions(DBOption.cMainMirror) == null || GetOptions(DBOption.cMainMirror) == "http://thetvdb.com/interfaces") { DBOption.SetOptions(DBOption.cMainMirror, cMainMirrorHardCoded); } if (GetOptions(cNewAPIUpgradeDone) == null) { SetOptions(cNewAPIUpgradeDone, 0); } int oldLangOptionSet; if (GetOptions(cOnlineLanguage) == null || int.TryParse(GetOptions(cOnlineLanguage), out oldLangOptionSet)) { SetOptions(cOnlineLanguage, "en"); // old api used index for onlinelang, new one two letters } if (GetOptions(cAppendFirstLogoToList) == null) { SetOptions(cAppendFirstLogoToList, 0); //default no (most skins don't seem to use this) } if (GetOptions(cGraphicalGroupView) == null) { SetOptions(cGraphicalGroupView, 0); //default yes (should work on all skins) } if (GetOptions(cQualitySeriesBanners) == null) { SetOptions(cQualitySeriesBanners, 75); } if (GetOptions(cQualitySeriesPosters) == null) { SetOptions(cQualitySeriesPosters, 50); } if (GetOptions(cQualitySeriesCoverflow) == null) { SetOptions(cQualitySeriesCoverflow, 50); } if (GetOptions(cQualitySeasonBanners) == null) { SetOptions(cQualitySeasonBanners, 75); } if (GetOptions(cQualitySeasonCoverflow) == null) { SetOptions(cQualitySeasonCoverflow, 90); } if (GetOptions(cQualityEpisodeImages) == null) { SetOptions(cQualityEpisodeImages, 100); } if (GetOptions(cFanartRandom) == null) { SetOptions(cFanartRandom, true); } if (GetOptions(cOnlineFavourites) == null) { SetOptions(cOnlineFavourites, false); } if (GetOptions(cPlaylistPath) == null) { string playListFolder = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + @"\My Playlists"; SetOptions(cPlaylistPath, playListFolder); } if (GetOptions(cRepeatPlaylist) == null) { SetOptions(cRepeatPlaylist, false); } if (GetOptions(cPlaylistAutoPlay) == null) { SetOptions(cPlaylistAutoPlay, true); } if (GetOptions(cPlaylistAutoShuffle) == null) { SetOptions(cPlaylistAutoShuffle, false); } if (GetOptions(cImportScanOnStartup) == null) { SetOptions(cImportScanOnStartup, true); } if (GetOptions(cAutoDownloadMissingArtwork) == null) { SetOptions(cAutoDownloadMissingArtwork, true); } if (GetOptions(cAutoUpdateEpisodeRatings) == null) { SetOptions(cAutoUpdateEpisodeRatings, false); } if (GetOptions(cAutoUpdateAllFanart) == null) { SetOptions(cAutoUpdateAllFanart, false); } if (GetOptions(cAutoDownloadFanart) == null) { SetOptions(cAutoDownloadFanart, true); } if (GetOptions(cAutoDownloadFanartCount) == null) { SetOptions(cAutoDownloadFanartCount, 3); } if (GetOptions(cAutoDownloadFanartResolution) == null) { SetOptions(cAutoDownloadFanartResolution, 0); //0=Both,1=1280x720,2=1920x1080 } if (GetOptions(cFanartThumbnailResolutionFilter) == null) { SetOptions(cFanartThumbnailResolutionFilter, 0); } if (GetOptions(cFanartCurrentView) == null) { SetOptions(cFanartCurrentView, 2); // Large Icons } if (GetOptions(cUseRegionalDateFormatString) == null) { SetOptions(cUseRegionalDateFormatString, 0); } if (GetOptions(cDefaultRating) == null) { SetOptions(cDefaultRating, 7); // Scale 1 - 10 } if (GetOptions(cRatingDisplayStars) == null) { SetOptions(cRatingDisplayStars, 10); // 5 or 10 Stars } if (GetOptions(cSortSpecials) == null) { SetOptions(cSortSpecials, 0); } if (GetOptions(cBackdropLoadingDelay) == null) { SetOptions(cBackdropLoadingDelay, 250); //milliseconds } if (GetOptions(cArtworkLoadingDelay) == null) { SetOptions(cArtworkLoadingDelay, 250); //milliseconds } if (GetOptions(cRandomFanartInterval) == null) { SetOptions(cRandomFanartInterval, 30000); //milliseconds } if (GetOptions(cAutoDownloadFanartSeriesNames) == null) { SetOptions(cAutoDownloadFanartSeriesNames, 0); } if (GetOptions(cParentalControlPinCode) == null) { SetOptions(cParentalControlPinCode, string.Empty); } if (GetOptions(cMarkRatedEpisodeAsWatched) == null) { SetOptions(cMarkRatedEpisodeAsWatched, 0); } if (GetOptions(cSubstituteMissingArtwork) == null) { SetOptions(cSubstituteMissingArtwork, 1); } if (GetOptions(cAskToRate) == null) { SetOptions(cAskToRate, 0); } if (GetOptions(cSkipSeasonViewOnSingleSeason) == null) { SetOptions(cSkipSeasonViewOnSingleSeason, 1); } if (GetOptions(cImportScanWhileFullscreenVideo) == null) { SetOptions(cImportScanWhileFullscreenVideo, 0); } if (GetOptions(cInvokeExtBeforePlayback) == null) { SetOptions(cInvokeExtBeforePlayback, string.Empty); } if (GetOptions(cInvokeExtBeforePlaybackArgs) == null) { SetOptions(cInvokeExtBeforePlaybackArgs, "\"<Episode.EpisodeFilename>\""); } if (GetOptions(cInvokeExtBeforePlaybackWaitForExit) == null) { SetOptions(cInvokeExtBeforePlaybackWaitForExit, 0); } if (GetOptions(cInvokeExtAfterPlayback) == null) { SetOptions(cInvokeExtAfterPlayback, string.Empty); } if (GetOptions(cInvokeExtAfterPlaybackArgs) == null) { SetOptions(cInvokeExtAfterPlaybackArgs, "\"<Episode.EpisodeFilename>\""); } if (GetOptions(cInvokeExtAfterPlaybackWaitForExit) == null) { SetOptions(cInvokeExtAfterPlaybackWaitForExit, 0); } if (GetOptions(cCountEmptyAndFutureAiredEps) == null) { SetOptions(cCountEmptyAndFutureAiredEps, 1); } if (GetOptions(cOnPlaySeriesOrSeasonAction) == null) { SetOptions(cOnPlaySeriesOrSeasonAction, 2); // set first unwatched as default } if (GetOptions(cNewEpisodeThumbType) == null) { SetOptions(cNewEpisodeThumbType, (int)NewEpisodeIndicatorType.recentlyadded); // Recently Added Episodes } if (GetOptions(cNewEpisodeRecentDays) == null) { SetOptions(cNewEpisodeRecentDays, 7); } if (GetOptions(cSubCentralEnabled) == null) { SetOptions(cSubCentralEnabled, true); } if (GetOptions(cSubCentralEnabledForEpisodes) == null) { SetOptions(cSubCentralEnabledForEpisodes, true); } if (GetOptions(cSubCentralSubtitleDownloadOnPlay) == null) { SetOptions(cSubCentralSubtitleDownloadOnPlay, false); } if (GetOptions(cPlaylistUnwatchedOnly) == null) { SetOptions(cPlaylistUnwatchedOnly, false); } if (GetOptions(cDisableMediaInfo) == null) { SetOptions(cDisableMediaInfo, false); } if (GetOptions(cMediaInfoParseSpeed) == null) { SetOptions(cMediaInfoParseSpeed, "0.1"); // Default is 0.5 (scan 50% of file) but we dont need that for TVSeries. } if (GetOptions(cImportDelay) == null) { SetOptions(cImportDelay, 30); } if (GetOptions(cDelayImportPathMonitoringValue) == null) { SetOptions(cDelayImportPathMonitoringValue, 20); } if (GetOptions(cSetHiddenSeriesAsScanIgnore) == null) { SetOptions(cSetHiddenSeriesAsScanIgnore, true); } if (GetOptions(cGetBlankBanners) == null) { SetOptions(cGetBlankBanners, false); } if (GetOptions(cGetTextBanners) == null) { SetOptions(cGetTextBanners, false); } if (GetOptions(cArtworkLimitSeriesWideBanners) == null) { SetOptions(cArtworkLimitSeriesWideBanners, 3); } if (GetOptions(cArtworkLimitSeriesPosters) == null) { SetOptions(cArtworkLimitSeriesPosters, 3); } if (GetOptions(cArtworkLimitSeasonPosters) == null) { SetOptions(cArtworkLimitSeasonPosters, 2); // 20 seasons = 40 posters } if (GetOptions(cMaxConsecutiveDownloadErrors) == null) { SetOptions(cMaxConsecutiveDownloadErrors, 3); } if (GetOptions(cSortSpecialSeasonLast) == null) { SetOptions(cSortSpecialSeasonLast, true); } if (GetOptions(cActorLayout) == null) { SetOptions(cActorLayout, 0); } if (GetOptions(cArtworkChooserLayout) == null) { SetOptions(cArtworkChooserLayout, 0); } if (GetOptions(cAutoGenerateEpisodeTitles) == null) { SetOptions(cAutoGenerateEpisodeTitles, true); } if (GetOptions(cParentalControlDisableAfter) == null) { SetOptions(cParentalControlDisableAfter, new DateTime(2018, 02, 25, 21, 0, 0).ToShortTimeString()); } if (GetOptions(cParentalControlDisableBefore) == null) { SetOptions(cParentalControlDisableBefore, new DateTime(2018, 02, 26, 3, 0, 0).ToShortTimeString()); } if (GetOptions(cParentalControlResetInterval) == null) { SetOptions(cParentalControlResetInterval, 60); } if (GetOptions(cShowDeleteMenu) == null) { SetOptions(cShowDeleteMenu, true); } if (GetOptions(cSQLLoggingEnabled) == null) { SetOptions(cSQLLoggingEnabled, false); } if (GetOptions(cCheckPlayOutOfOrder) == null) { SetOptions(cCheckPlayOutOfOrder, true); } if (GetOptions(cFilterUnwatched) == null) { SetOptions(cFilterUnwatched, false); } if (GetOptions(cAutoDownloadActors) == null) { SetOptions(cAutoDownloadActors, false); } if (GetOptions(cCleanOnlineEpisodes) == null) { SetOptions(cCleanOnlineEpisodes, true); } if (GetOptions(cCleanOnlineEpisodeZero) == null) { SetOptions(cCleanOnlineEpisodeZero, false); } if (GetOptions(cOverrideLanguage) == null) { SetOptions(cOverrideLanguage, false); } if (GetOptions(cCountSpecialEpisodesAsWatched) == null) { SetOptions(cCountSpecialEpisodesAsWatched, false); } if (GetOptions(cTraktCommunityRatings) == null) { SetOptions(cTraktCommunityRatings, true); } if (GetOptions(cParsedNameFromFolder) == null) { SetOptions(cParsedNameFromFolder, false); } if (GetOptions(cDisableMediaInfoInConfigImports) == null) { SetOptions(cDisableMediaInfoInConfigImports, false); } if (GetOptions(cCheckShowOnlyEpisodesRequiringManualSelection) == null) { SetOptions(cCheckShowOnlyEpisodesRequiringManualSelection, false); } #endregion }
public static Dictionary <string, List <EpisodeCounter> > GetEpisodesForCount() { var episodesForCount = new Dictionary <string, List <EpisodeCounter> >(); string selectFields = "online_episodes.SeriesID, online_episodes.EpisodeIndex, online_episodes.SeasonIndex, online_episodes.Combined_season, online_episodes.Watched"; string query = string.Empty; string whereClause = string.Empty; var wheres = new List <string>(); if (!DBOption.GetOptions(DBOption.cShowHiddenItems)) { wheres.Add("online_episodes.Hidden = 0"); } if (DBOption.GetOptions(DBOption.cOnlyShowLocalFiles)) { wheres.Add("local_episodes.EpisodeFilename != ''"); } if (!DBOption.GetOptions(DBOption.cCountEmptyAndFutureAiredEps)) { wheres.Add(string.Format("online_episodes.FirstAired <= '{0}' AND online_episodes.FirstAired != ''", DateTime.Now.ToString("yyyy-MM-dd"))); } if (wheres.Count > 0) { whereClause = string.Format("WHERE {0}", string.Join(" AND ", wheres.ToArray())); } if (DBOption.GetOptions(DBOption.cOnlyShowLocalFiles)) { // if we are only counting episodes that have a file ie. local reference // then we need to join the local and online episode tables // further more we also need to union two select statements with // one returning only the first of a single/double episode and the other // returning the second of any double episodes query = string.Format(@" SELECT {0} FROM online_episodes LEFT JOIN local_episodes ON local_episodes.CompositeID = online_episodes.CompositeID {1} UNION SELECT {0} FROM online_episodes LEFT JOIN local_episodes ON local_episodes.CompositeID2 = online_episodes.CompositeID {1} ", selectFields, whereClause); } else { query = string.Format(@" SELECT {0} FROM online_episodes {1} ", selectFields, whereClause); } SQLiteResultSet results = DBTVSeries.Execute(query); foreach (var row in results.Rows) { var seriesId = row.fields[0]; var episodeAirIdx = row.fields[1]; var seasonAirIdx = row.fields[2]; var seasonDvdIdx = row.fields[3]; var watched = row.fields[4]; if (episodesForCount.ContainsKey(seriesId)) { episodesForCount[seriesId].Add(new EpisodeCounter { EpisodeIdx = episodeAirIdx, SeasonAirIdx = seasonAirIdx, SeasonDvdIdx = seasonDvdIdx, EpisodeWatched = watched }); } else { var episodeList = new List <EpisodeCounter>(); episodeList.Add(new EpisodeCounter { EpisodeIdx = episodeAirIdx, SeasonAirIdx = seasonAirIdx, SeasonDvdIdx = seasonDvdIdx, EpisodeWatched = watched }); episodesForCount.Add(seriesId, episodeList); } } return(episodesForCount); }
public static void UpdateEpisodeCounts(DBSeries series, Dictionary <string, List <EpisodeCounter> > episodes) { if (series == null) { return; } string seriesId = series[DBSeries.cID]; int seriesEpsTotal = 0; int seriesEpsUnWatched = 0; bool airedOrder = series.IsAiredOrder; // dont worry about filtering season list, we already have a filtered episode list // query without std conditions for faster response. var conditions = new SQLCondition(new DBSeason(), DBSeason.cSeriesID, seriesId, SQLConditionType.Equal); var seasons = DBSeason.Get(conditions, false); // update season counts List <EpisodeCounter> eps = new List <EpisodeCounter>(); if (episodes.TryGetValue(seriesId, out eps)) { foreach (var season in seasons) { var seasonEps = eps.Where(e => airedOrder ? e.SeasonAirIdx == season[DBSeason.cIndex] : e.SeasonDvdIdx == season[DBSeason.cIndex]).ToList(); // dont commit seasons if are not viewing them // episodes for count is already filtered so can return 0 results if (seasonEps.Count == 0) { continue; } int count = seasonEps.Count(); int unWatchedCount = seasonEps.Where(e => e.EpisodeWatched != "1").Count(); season[DBSeason.cEpisodeCount] = count; season[DBSeason.cEpisodesUnWatched] = unWatchedCount; season[DBSeason.cUnwatchedItems] = unWatchedCount > 0; season.Commit(); seriesEpsTotal += count; // Count the Special (Season 0 (zero)) episodes as watched! if ((season[DBSeason.cIndex] != 0) || (season[DBSeason.cIndex] == 0 && !DBOption.GetOptions(DBOption.cCountSpecialEpisodesAsWatched))) { seriesEpsUnWatched += unWatchedCount; } } // update series counts series[DBOnlineSeries.cEpisodeCount] = seriesEpsTotal; series[DBOnlineSeries.cEpisodesUnWatched] = seriesEpsUnWatched; series[DBOnlineSeries.cUnwatchedItems] = seriesEpsUnWatched > 0; series.Commit(); } }
public void addHierarchyConditions(ref int stepIndex, ref string[] currentStepSelection, ref SQLCondition conditions) { logicalViewStep step = m_steps[stepIndex]; conditions = step.conds.Copy(); // important, don't change the steps themselves // we need to add one additional condition to reflect the selection one hierarchy up if (currentStepSelection != null && currentStepSelection.Length > 0 && stepIndex > 0) { switch (m_steps[stepIndex - 1].Type) { case logicalViewStep.type.group: bool requiresSplit = false; // use sql 'like' for split fields // selected group label string selectedItem = currentStepSelection[0]; // we expect to get the selected group's label // unknown really is "" so get all with null values here if (selectedItem == Translation.Unknown) { selectedItem = string.Empty; } else if (m_steps[stepIndex - 1].groupedBy.attempSplit) { requiresSplit = true; } string fieldName = m_steps[stepIndex - 1].groupedBy.rawFieldname; string tableName = m_steps[stepIndex - 1].groupedBy.table.m_tableName; string tableField = tableName + "." + fieldName; string userEditField = tableField + DBTable.cUserEditPostFix; string value = requiresSplit ? "like " + "'%" + selectedItem + "%'" : "= " + "'" + selectedItem + "'"; string sql = string.Empty; // check if the useredit column exists if (DBTable.ColumnExists(tableName, fieldName + DBTable.cUserEditPostFix)) { sql = "(case when (" + userEditField + " is null or " + userEditField + " = " + "'" + "'" + ") " + "then " + tableField + " else " + userEditField + " " + "end) " + value; } else { sql = tableField + " " + value; } conditions.AddCustom(sql); break; case logicalViewStep.type.series: // we expect to get the seriesID as stepSel conditions.Add(new DBSeason(), DBSeason.cSeriesID, currentStepSelection[0], SQLConditionType.Equal); if (DBOption.GetOptions(DBOption.cSortSpecialSeasonLast)) { conditions.InsertOrderItem(DBSeason.cTableName + "." + DBSeason.cIndex + " = 0", SQLCondition.orderType.Ascending); } break; case logicalViewStep.type.season: // we expect to get the seriesID/seasonIndex as stepSel // we want to query episodes using the CombinedSeason if Sort Order is "DVD" // CombinedSeason gives us the DVD Season and if empty will give us the Aired Season DBSeries series = Helper.getCorrespondingSeries(int.Parse(currentStepSelection[0])); bool SortByDVD = series[DBOnlineSeries.cEpisodeSortOrder] == "DVD"; string seasonIndex = SortByDVD ? DBOnlineEpisode.cCombinedSeason : DBOnlineEpisode.cSeasonIndex; conditions.Add(new DBOnlineEpisode(), DBOnlineEpisode.cSeriesID, currentStepSelection[0], SQLConditionType.Equal); conditions.beginGroup(); conditions.Add(new DBOnlineEpisode(), seasonIndex, currentStepSelection[1], SQLConditionType.Equal); if (DBOption.GetOptions(DBOption.cSortSpecials) && !SortByDVD) { conditions.nextIsOr = true; conditions.Add(new DBOnlineEpisode(), DBOnlineEpisode.cAirsBeforeSeason, currentStepSelection[1], SQLConditionType.Equal); conditions.Add(new DBOnlineEpisode(), DBOnlineEpisode.cAirsAfterSeason, currentStepSelection[1], SQLConditionType.Equal); conditions.nextIsOr = false; } conditions.endGroup(); break; } } }
public static void UpdateEpisodeCounts(DBSeries series) { if (series == null) { return; } int seriesEpsTotal = 0; int seriesEpsUnWatched = 0; int epsTotal = 0; int epsUnWatched = 0; // Update for each season in series and add each to total series count SQLCondition condition = new SQLCondition(); if (!DBOption.GetOptions(DBOption.cShowHiddenItems)) { //don't include hidden seasons unless the ShowHiddenItems option is set condition.Add(new DBSeason(), DBSeason.cHidden, 0, SQLConditionType.Equal); } List <DBSeason> Seasons = DBSeason.Get(series[DBSeries.cID], condition); foreach (DBSeason season in Seasons) { epsTotal = 0; epsUnWatched = 0; DBEpisode.GetSeasonEpisodeCounts(series, season, out epsTotal, out epsUnWatched); season[DBSeason.cEpisodeCount] = epsTotal; season[DBSeason.cEpisodesUnWatched] = epsUnWatched; season[DBSeason.cUnwatchedItems] = epsUnWatched > 0; season.Commit(); seriesEpsTotal += epsTotal; // Count the Special (Season 0 (zero)) episodes as watched! if ((season[DBSeason.cIndex] != 0) || (season[DBSeason.cIndex] == 0 && !DBOption.GetOptions(DBOption.cCountSpecialEpisodesAsWatched))) { seriesEpsUnWatched += epsUnWatched; } MPTVSeriesLog.Write(string.Format("Series \"{0} Season {1}\" has {2}/{3} unwatched episodes", series.ToString(), season[DBSeason.cIndex], epsUnWatched, epsTotal), MPTVSeriesLog.LogLevel.Debug); } MPTVSeriesLog.Write(string.Format("Series \"{0}\" has {1}/{2} unwatched episodes", series.ToString(), seriesEpsUnWatched, seriesEpsTotal), MPTVSeriesLog.LogLevel.Debug); series[DBOnlineSeries.cEpisodeCount] = seriesEpsTotal; series[DBOnlineSeries.cEpisodesUnWatched] = seriesEpsUnWatched; series[DBOnlineSeries.cUnwatchedItems] = seriesEpsUnWatched > 0; series.Commit(); }
public static logicalViewStep parseFromDB(string viewStep, bool hasSeriesBeforeIt) { logicalViewStep thisView = new logicalViewStep(); thisView.hasSeriesBeforeIt = hasSeriesBeforeIt; string[] viewSteps = System.Text.RegularExpressions.Regex.Split(viewStep, s_intSeperator); thisView.setType(viewSteps[0]); thisView.addConditionsFromString(viewSteps[1]); if (viewSteps[2].Length > 0) { string[] orderFields = System.Text.RegularExpressions.Regex.Split(viewSteps[2], ";"); thisView.inLineSpecials = orderFields[0] == "<Episode.EpisodeIndex>"; thisView.inLineSpecialsAsc = orderFields[0] != "desc"; for (int i = 0; i < orderFields.Length; i += 2) { if (thisView.Type != type.group) { DBTable table = null; string tableField = string.Empty; getTableFieldname(orderFields[i], out table, out tableField); tableField = getQTableNameFromUnknownType(table, tableField); // example of how the user can order by a different table // needs to be enabled once definable views are ready /* * if (thisView.Type == type.season && table.GetType() != typeof(DBSeason)) * { * Type lType = table.GetType(); * if (lType == typeof(DBOnlineSeries)) * tableField = "( select " + tableField + " from " + DBOnlineSeries.cTableName + " where " + DBOnlineSeries.Q(DBOnlineSeries.cID) + " = " + DBSeason.Q(DBSeason.cSeriesID) + ")"; + }*/ //if (thisView.Type == type.episode && ( table.GetType() == typeof(DBEpisode) || table.GetType() == typeof(DBOnlineEpisode))) //{ // // for perf reason a subquery is build, otherwise custom orders and the nessesary join really slow down sqllite! // SQLCondition subQueryConditions = thisView.conds.Copy(); // have to have all conds too // subQueryConditions.AddOrderItem(tableField, (orderFields[i + 1] == "asc" ? SQLCondition.orderType.Ascending : SQLCondition.orderType.Descending)); // if (viewSteps[3].Length > 0) // set the limit too // { // try // { // subQueryConditions.SetLimit(System.Convert.ToInt32(viewSteps[3])); // } // catch (Exception) // { // } // } // thisView.conds.AddSubQuery("compositeid", table, subQueryConditions, table.m_tableName + "." + DBEpisode.cCompositeID, SQLConditionType.In); //} thisView.conds.AddOrderItem(tableField, (orderFields[i + 1] == "asc" ? SQLCondition.orderType.Ascending : SQLCondition.orderType.Descending)); } } } if (thisView.Type == type.group && thisView.groupedBy != null) // for groups always by their values (ignore user setting!) { if (thisView.groupedBy.table.GetType() == typeof(DBSeries)) { if (!DBOption.GetOptions(DBOption.cShowHiddenItems)) { thisView.conds.Add(new DBSeries(), DBSeries.cHidden, 1, SQLConditionType.NotEqual); } } else if (thisView.groupedBy.table.GetType() == typeof(DBOnlineSeries)) { if (!DBOption.GetOptions(DBOption.cShowHiddenItems)) { thisView.conds.AddCustom(" not exists ( select * from " + DBSeries.cTableName + " where id = " + DBOnlineSeries.Q(DBOnlineSeries.cID) + " and " + DBSeries.Q(DBSeries.cHidden) + " = 1)"); } } else if (thisView.groupedBy.table.GetType() == typeof(DBSeason)) { if (!DBOption.GetOptions(DBOption.cShowHiddenItems)) { thisView.conds.Add(new DBSeason(), DBSeason.cHidden, 1, SQLConditionType.NotEqual); } } thisView.conds.AddOrderItem(thisView.groupedBy.tableField, SQLCondition.orderType.Descending); // tablefield includes tablename itself! } try { if (viewSteps[3].Length > 0) { thisView.limitItems = System.Convert.ToInt32(viewSteps[3]); thisView.conds.SetLimit(thisView.limitItems); } } catch (Exception) { MPTVSeriesLog.Write("Cannot interpret limit in logicalview, limit was: " + viewSteps[3]); } return(thisView); }
private void doWork(string seriesID) { XmlNode banners = OnlineAPI.getBannerList(Int32.Parse(seriesID)); if (banners == null) { return; } if (Helper.getCorrespondingSeries(Int32.Parse(seriesID)) == null) { return; } string SeriesName = Helper.getCorrespondingSeries(Int32.Parse(seriesID)).ToString(); List <WideBannerSeries> widebannerSeriesList = new List <WideBannerSeries>(); List <PosterSeries> posterSeriesList = new List <PosterSeries>(); List <PosterSeason> posterSeasonList = new List <PosterSeason>(); SeriesBannersMap map = new SeriesBannersMap(); map.SeriesID = seriesID; #region Series WideBanners foreach (XmlNode banner in banners.SelectNodes("/Banners/Banner[BannerType='series']")) { WideBannerSeries seriesWideBanners = new WideBannerSeries(); seriesWideBanners.Language = banner.SelectSingleNode("Language").InnerText; seriesWideBanners.OnlinePath = banner.SelectSingleNode("BannerPath").InnerText; seriesWideBanners.SeriesName = SeriesName; try { seriesWideBanners.Style = (ArtworkStyles)Enum.Parse(typeof(ArtworkStyles), banner.SelectSingleNode("BannerType2").InnerText, true); } catch { // maybe a new style introduced seriesWideBanners.Style = ArtworkStyles.unknown; } if (!string.IsNullOrEmpty(banner.SelectSingleNode("Rating").InnerText)) { double rating = double.Parse(banner.SelectSingleNode("Rating").InnerText, NumberStyles.Any, NumberFormatInfo.InvariantInfo); seriesWideBanners.Rating = Math.Round(rating, 1, MidpointRounding.AwayFromZero); } if (!string.IsNullOrEmpty(banner.SelectSingleNode("RatingCount").InnerText)) { seriesWideBanners.RatingCount = int.Parse(banner.SelectSingleNode("RatingCount").InnerText); } seriesWideBanners.SeriesID = seriesID; widebannerSeriesList.Add(seriesWideBanners); } // sort by highest rated widebannerSeriesList.Sort(); // remove banners of no interest if (!DBOption.GetOptions(DBOption.cGetTextBanners)) { widebannerSeriesList.RemoveAll(b => b.Style == ArtworkStyles.text); } if (!DBOption.GetOptions(DBOption.cGetBlankBanners)) { widebannerSeriesList.RemoveAll(b => b.Style == ArtworkStyles.blank); } // Respect User Limits, exception: if higher rated image or localised image is uploaded online int limit = DBOption.GetOptions(DBOption.cArtworkLimitSeriesWideBanners); if (limit < widebannerSeriesList.Count) { widebannerSeriesList.RemoveRange(limit, widebannerSeriesList.Count - limit); } map.SeriesWideBanners = widebannerSeriesList; #endregion #region Series Posters foreach (XmlNode banner in banners.SelectNodes("/Banners/Banner[BannerType='poster']")) { PosterSeries seriesPoster = new PosterSeries(); seriesPoster.Language = banner.SelectSingleNode("Language").InnerText; seriesPoster.OnlinePath = banner.SelectSingleNode("BannerPath").InnerText; seriesPoster.SeriesName = SeriesName; if (!string.IsNullOrEmpty(banner.SelectSingleNode("Rating").InnerText)) { double rating = double.Parse(banner.SelectSingleNode("Rating").InnerText, NumberStyles.Any, NumberFormatInfo.InvariantInfo); seriesPoster.Rating = Math.Round(rating, 1, MidpointRounding.AwayFromZero); } if (!string.IsNullOrEmpty(banner.SelectSingleNode("RatingCount").InnerText)) { seriesPoster.RatingCount = int.Parse(banner.SelectSingleNode("RatingCount").InnerText); } seriesPoster.SeriesID = seriesID; posterSeriesList.Add(seriesPoster); } posterSeasonList.Sort(); limit = DBOption.GetOptions(DBOption.cArtworkLimitSeriesPosters); if (limit < posterSeriesList.Count) { posterSeriesList.RemoveRange(limit, posterSeriesList.Count - limit); } map.SeriesPosters = posterSeriesList; #endregion #region Season Posters List <string> seasons = new List <string>(); foreach (XmlNode banner in banners.SelectNodes("/Banners/Banner[BannerType='season']")) { PosterSeason seasonPoster = new PosterSeason(); seasonPoster.Language = banner.SelectSingleNode("Language").InnerText; seasonPoster.OnlinePath = banner.SelectSingleNode("BannerPath").InnerText; seasonPoster.SeasonIndex = banner.SelectSingleNode("Season").InnerText; seasonPoster.SeriesName = SeriesName; try { seasonPoster.Style = (ArtworkStyles)Enum.Parse(typeof(ArtworkStyles), banner.SelectSingleNode("BannerType2").InnerText, true); } catch { // maybe a new style introduced seasonPoster.Style = ArtworkStyles.unknown; } if (!string.IsNullOrEmpty(banner.SelectSingleNode("Rating").InnerText)) { double rating = double.Parse(banner.SelectSingleNode("Rating").InnerText, NumberStyles.Any, NumberFormatInfo.InvariantInfo); seasonPoster.Rating = Math.Round(rating, 1, MidpointRounding.AwayFromZero); } if (!string.IsNullOrEmpty(banner.SelectSingleNode("RatingCount").InnerText)) { seasonPoster.RatingCount = int.Parse(banner.SelectSingleNode("RatingCount").InnerText); } if (!seasons.Contains(seasonPoster.SeasonIndex)) { seasons.Add(seasonPoster.SeasonIndex); } seasonPoster.SeriesID = seriesID; posterSeasonList.Add(seasonPoster); } posterSeasonList.Sort(); // we dont support season widebanners posterSeasonList.RemoveAll(p => p.Style == ArtworkStyles.seasonwide); limit = DBOption.GetOptions(DBOption.cArtworkLimitSeasonPosters); List <PosterSeason> posterSeasonListTemp = new List <PosterSeason>(posterSeasonList); foreach (string season in seasons) { int count = 0; foreach (PosterSeason pSeason in posterSeasonListTemp) { if (season == pSeason.SeasonIndex) { count++; if (limit < count) { posterSeasonList.Remove(pSeason); } } } } map.SeasonPosters = posterSeasonList; #endregion // series already in? if (SeriesBannersMap.Contains(map)) { SeriesBannersMap seriesMap = SeriesBannersMap[SeriesBannersMap.IndexOf(map)]; seriesMap.SeasonPosters.AddRange(map.SeasonPosters); seriesMap.SeriesWideBanners.AddRange(map.SeriesWideBanners); seriesMap.SeriesPosters.AddRange(map.SeriesPosters); } else { SeriesBannersMap.Add(map); } }