public DBSeries(String SeriesName)
: base(cTableName)
{
InitColumns();
if (!ReadPrimary(SeriesName))
{
InitValues();
}
if (this[cID] == 0)
{
m_onlineSeries = new DBOnlineSeries(s_nLastLocalID);
s_nLastLocalID--;
DBOption.SetOptions(DBOption.cDBSeriesLastLocalID, s_nLastLocalID);
this[cID] = m_onlineSeries[DBOnlineSeries.cID];
if (String.IsNullOrEmpty(m_onlineSeries[DBOnlineSeries.cPrettyName]))
{
m_onlineSeries[DBOnlineSeries.cPrettyName] = this[cParsedName];
m_onlineSeries[DBOnlineSeries.cSortName] = this[cParsedName];
m_onlineSeries.Commit();
}
}
else
{
m_onlineSeries = new DBOnlineSeries(this[cID]);
}
}
public GetSeries(String sSeriesName)
{
XmlNode node = Online_Parsing_Classes.OnlineAPI.GetSeries(sSeriesName);
nameToMatch = sSeriesName;
if (node != null)
{
foreach (XmlNode itemNode in node.ChildNodes)
{
DBOnlineSeries series = new DBOnlineSeries();
foreach (XmlNode propertyNode in itemNode.ChildNodes)
{
if (propertyNode.Name == "seriesid") // work around SeriesID inconsistancy
{
series[DBOnlineSeries.cID] = propertyNode.InnerText;
}
else if (DBOnlineSeries.s_OnlineToFieldMap.ContainsKey(propertyNode.Name))
series[DBOnlineSeries.s_OnlineToFieldMap[propertyNode.Name]] = propertyNode.InnerText;
else
{
// we don't know that field, add it to the series table
series.AddColumn(propertyNode.Name, new DBField(DBField.cTypeString));
series[propertyNode.Name] = propertyNode.InnerText;
}
}
listSeries.Add(series);
}
PerfectMatch = RankSearchResults(nameToMatch, listSeries, out listSeries);
}
}
public GetSeries(String sSeriesName)
{
XmlNode node = Online_Parsing_Classes.OnlineAPI.GetSeries(sSeriesName);
nameToMatch = sSeriesName;
if (node != null)
{
foreach (XmlNode itemNode in node.ChildNodes)
{
DBOnlineSeries series = new DBOnlineSeries();
foreach (XmlNode propertyNode in itemNode.ChildNodes)
{
if (propertyNode.Name == "seriesid") // work around SeriesID inconsistancy
{
series[DBOnlineSeries.cID] = propertyNode.InnerText;
}
else if (DBOnlineSeries.s_OnlineToFieldMap.ContainsKey(propertyNode.Name))
{
series[DBOnlineSeries.s_OnlineToFieldMap[propertyNode.Name]] = propertyNode.InnerText;
}
else
{
// we don't know that field, add it to the series table
series.AddColumn(propertyNode.Name, new DBField(DBField.cTypeString));
series[propertyNode.Name] = propertyNode.InnerText;
}
}
listSeries.Add(series);
}
PerfectMatch = RankSearchResults(nameToMatch, listSeries, out listSeries);
}
}
public static string stdGetSQL(SQLCondition conditions, bool selectFull, bool includeStdCond)
{
string field;
if (selectFull)
{
SQLWhat what = new SQLWhat(new DBOnlineSeries());
what.AddWhat(new DBSeries());
field = what;
}
else
{
field = DBOnlineSeries.Q(DBOnlineSeries.cID) + " from " + DBOnlineSeries.cTableName;
}
if (includeStdCond)
{
conditions.AddCustom(stdConditions.ConditionsSQLString);
}
string conds = conditions;
string orderBy = string.Empty;
if (selectFull)
{
bool bUseSortName = DBOption.GetOptions(DBOption.cUseSortName);
orderBy = conditions.customOrderStringIsSet
? conditions.orderString
: " order by " + (bUseSortName?"upper(" + DBOnlineSeries.Q(DBOnlineSeries.cSortName) + "),":"") + "upper(" + DBOnlineSeries.Q(DBOnlineSeries.cPrettyName) + ")";
}
return("select " + field + " left join " + cTableName + " on " + DBSeries.Q(cID) + "==" + DBOnlineSeries.Q(cID)
+ conds
+ orderBy
+ conditions.limitString);
}
public List <string> deleteSeries(TVSeriesPlugin.DeleteMenuItems type)
{
List <string> resultMsg = new List <string>();
// Always delete from Local episode table if deleting from disk or database
SQLCondition condition = new SQLCondition();
condition.Add(new DBSeason(), DBSeason.cSeriesID, this[DBSeries.cID], SQLConditionType.Equal);
/* TODO dunno if to include or exclude hidden items.
* if they are excluded then the if (resultMsg.Count is wrong and should do another select to get proper count
* 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(condition, false);
if (seasons != null)
{
foreach (DBSeason season in seasons)
{
resultMsg.AddRange(season.deleteSeason(type));
}
}
#region Facade Remote Color
// if we were successful at deleting all episodes of series from disk, set HasLocalFiles to false
// note: we only do this if the database entries still exist
if (resultMsg.Count == 0 && type == TVSeriesPlugin.DeleteMenuItems.disk)
{
this[DBOnlineSeries.cHasLocalFiles] = false;
this.Commit();
}
#endregion
#region Cleanup
// if there are no error messages and if we need to delete from db
// Delete from online tables and season/series tables
IsSeriesRemoved = false;
if (resultMsg.Count == 0 && type != TVSeriesPlugin.DeleteMenuItems.disk)
{
condition = new SQLCondition();
condition.Add(new DBSeries(), DBSeries.cID, this[DBSeries.cID], SQLConditionType.Equal);
DBSeries.Clear(condition);
condition = new SQLCondition();
condition.Add(new DBOnlineSeries(), DBOnlineSeries.cID, this[DBSeries.cID], SQLConditionType.Equal);
DBOnlineSeries.Clear(condition);
IsSeriesRemoved = true;
}
#endregion
return(resultMsg);
}
public DBSeries(bool bCreateEmptyOnline)
: base(cTableName)
{
InitColumns();
InitValues();
if (bCreateEmptyOnline)
{
m_onlineSeries = new DBOnlineSeries();
}
}
static List <string> getDynamicFileName(string dynfilename, Level level)
{
int dnyStart = 0;
List <string> result = new List <string>();
if (!dynfilename.Contains("<"))
{
// not dynamic
result.Add(Helper.getCleanAbsolutePath(dynfilename));
return(result);
}
#pragma warning disable 0642
else if ((dnyStart = dynfilename.IndexOf("<Episode.")) > -1)
{
;
}
else if ((dnyStart = dynfilename.IndexOf("<Series.")) > -1)
{
;
}
else if ((dnyStart = dynfilename.IndexOf("<Season.")) > -1)
{
;
}
#pragma warning restore 0642
else
{
// no '<' but none of the recognized? that is a wrong entry
return(result);
}
//MPTVSeriesLog.Write("dynamic Filename detected..trying to resolve");
string fieldToGet = string.Empty;
string value = string.Empty;
fieldToGet = dynfilename.Substring(dnyStart, dynfilename.IndexOf('>', dnyStart) - dnyStart + 1);
if (getFieldValues(fieldToGet, out value, level))
{
// for genres/actors we need to split dynamic filenames again
string[] vals = DBOnlineSeries.splitField(value);
for (int i = 0; i < vals.Length; i++)
{
// recursive so we support multiple dyn fields in filename
if (vals[i] != fieldToGet)
{
result.AddRange(getDynamicFileName(dynfilename.Replace(fieldToGet, vals[i].Trim()), level));
}
}
return(result);
}
else
{
return(new List <string>(new string[] { string.Empty })); // something went wrong
}
}
public GetSeries(String aSeriesName)
{
string lUserLanguage = DBOption.GetOptions(DBOption.cOnlineLanguage);
if (DBOption.GetOptions(DBOption.cOverrideSearchLanguageToEnglish))
{
lUserLanguage = "en";
}
// search for series basis the user's language
XmlNode lNode = Online_Parsing_Classes.OnlineAPI.GetSeries(aSeriesName, lUserLanguage);
if (lNode == null)
{
return;
}
// if we have no results from the user's language try English
if (lNode.ChildNodes.Count == 0 && lUserLanguage != "en")
{
lNode = Online_Parsing_Classes.OnlineAPI.GetSeries(aSeriesName, "en");
if (lNode == null)
{
return;
}
}
foreach (XmlNode itemNode in lNode.ChildNodes)
{
var lSeries = new DBOnlineSeries();
foreach (XmlNode propertyNode in itemNode.ChildNodes)
{
if (propertyNode.Name == "seriesid") // work around SeriesID inconsistancy
{
lSeries[DBOnlineSeries.cID] = propertyNode.InnerText;
}
else if (DBOnlineSeries.s_OnlineToFieldMap.ContainsKey(propertyNode.Name))
{
lSeries[DBOnlineSeries.s_OnlineToFieldMap[propertyNode.Name]] = propertyNode.InnerText;
}
else
{
// we don't know that field, add it to the series table
lSeries.AddColumn(propertyNode.Name, new DBField(DBField.cTypeString));
lSeries[propertyNode.Name] = propertyNode.InnerText;
}
}
mListSeries.Add(lSeries);
}
PerfectMatch = RankSearchResults(aSeriesName, mListSeries, out mListSeries);
}
// returns a list of all series with information stored in the database.
public static List <DBOnlineSeries> getAllSeries()
{
List <DBValue> seriesIDs = DBOnlineSeries.GetSingleField(DBOnlineSeries.cID, new SQLCondition(), new DBOnlineSeries());
List <DBOnlineSeries> rtn = new List <DBOnlineSeries>();
foreach (DBValue currSeriesID in seriesIDs)
{
rtn.Add(new DBOnlineSeries(currSeriesID));
}
return(rtn);
}
public static void UpdateUnWatched(DBEpisode episode)
{
DBOnlineSeries series = new DBOnlineSeries(episode[DBEpisode.cSeriesID]);
DBEpisode FirstUnwatchedEpisode = DBEpisode.GetFirstUnwatched(series[DBSeries.cID]);
if (FirstUnwatchedEpisode != null)
{
series[DBOnlineSeries.cUnwatchedItems] = true;
}
else
{
series[DBOnlineSeries.cUnwatchedItems] = false;
}
series.Commit();
}
public DBSeason(int nSeriesID, int nSeasonIndex)
: base(cTableName)
{
InitColumns();
String sSeasonID = nSeriesID + "_s" + nSeasonIndex;
if (!ReadPrimary(sSeasonID))
{
InitValues();
// set the parent series so that banners will be refreshed from scratched
DBOnlineSeries series = new DBOnlineSeries(nSeriesID);
series[DBOnlineSeries.cBannersDownloaded] = 0;
series.Commit();
}
this[cSeriesID] = nSeriesID;
this[cIndex] = nSeasonIndex;
}
public void ChangeSeriesID(int nSeriesID)
{
DBOnlineSeries newOnlineSeries = new DBOnlineSeries(nSeriesID);
if (m_onlineSeries[DBOnlineSeries.cHasLocalFilesTemp])
{
newOnlineSeries[DBOnlineSeries.cHasLocalFilesTemp] = 1;
}
if (m_onlineSeries[DBOnlineSeries.cHasLocalFiles])
{
newOnlineSeries[DBOnlineSeries.cHasLocalFiles] = 1;
}
newOnlineSeries[DBOnlineSeries.cEpisodeOrders] = m_onlineSeries[DBOnlineSeries.cEpisodeOrders];
newOnlineSeries[DBOnlineSeries.cChosenEpisodeOrder] = m_onlineSeries[DBOnlineSeries.cChosenEpisodeOrder];
m_onlineSeries = newOnlineSeries;
this[cID] = nSeriesID;
}
static DBOnlineSeries()
{
///////////////////////////////////////////////////
#region Pretty Names displayed in Configuration Details Tab
s_FieldToDisplayNameMap.Add(cID, "Online Series ID");
s_FieldToDisplayNameMap.Add(cPrettyName, "Title");
s_FieldToDisplayNameMap.Add(cStatus, "Show Status");
s_FieldToDisplayNameMap.Add(cGenre, "Genre");
s_FieldToDisplayNameMap.Add(cSummary, "Show Overview");
s_FieldToDisplayNameMap.Add(cAirsDay, "Aired Day");
s_FieldToDisplayNameMap.Add(cAirsTime, "Aired Time");
s_FieldToDisplayNameMap.Add(cSortName, "Sort By");
s_FieldToDisplayNameMap.Add(cLanguage, "Language (Override)");
s_FieldToDisplayNameMap.Add(cIMDBID, "IMDb ID");
s_FieldToDisplayNameMap.Add(cTraktID, "Trakt ID");
s_FieldToDisplayNameMap.Add(cEpisodeOrders, "Episode Orders");
s_FieldToDisplayNameMap.Add(cChosenEpisodeOrder, "Episode Order");
s_FieldToDisplayNameMap.Add(cContentRating, "Content Rating");
s_FieldToDisplayNameMap.Add(cMyRating, "My Rating");
s_FieldToDisplayNameMap.Add(cFirstAired, "First Aired");
s_FieldToDisplayNameMap.Add(cEpisodeCount, "Episodes");
s_FieldToDisplayNameMap.Add(cEpisodesUnWatched, "Episodes UnWatched");
s_FieldToDisplayNameMap.Add(cLastEpisodeAirDate, "Last Aired");
s_FieldToDisplayNameMap.Add(cLastUpdated, "Last Updated (UTC)");
s_FieldToDisplayNameMap.Add(cOriginalName, "English Name");
#endregion
///////////////////////////////////////////////////
//////////////////////////////////////////////////
#region Local DB field mapping to Online DB
s_OnlineToFieldMap.Add("id", cID);
s_OnlineToFieldMap.Add("SeriesName", cPrettyName);
s_OnlineToFieldMap.Add("Status", cStatus);
s_OnlineToFieldMap.Add("Genre", cGenre);
s_OnlineToFieldMap.Add("Overview", cSummary);
s_OnlineToFieldMap.Add("Airs_DayOfWeek", cAirsDay);
s_OnlineToFieldMap.Add("Airs_Time", cAirsTime);
s_OnlineToFieldMap.Add("SortName", cSortName);
#endregion
//////////////////////////////////////////////////
// make sure the table is created on first run
DBOnlineSeries dummy = new DBOnlineSeries();
}
static void getTableFieldname(string what, out DBTable table, out string fieldname)
{
string sTable = string.Empty;
fieldname = string.Empty;
table = null;
what = what.Replace("<", "").Replace(">", "").Trim();
sTable = what.Split('.')[0];
switch (sTable)
{
case "Series":
if (new DBOnlineSeries().FieldNames.Contains(what.Split('.')[1]))
{
table = new DBOnlineSeries();
fieldname = what.Split('.')[1];
}
else
{
table = new DBSeries();
fieldname = what.Split('.')[1];
}
break;
case "Season":
table = new DBSeason();
fieldname = what.Split('.')[1];
break;
case "Episode":
if (new DBOnlineEpisode().FieldNames.Contains(what.Split('.')[1]))
{
table = new DBOnlineEpisode();
fieldname = what.Split('.')[1];
}
else
{
table = new DBEpisode();
fieldname = what.Split('.')[1];
}
break;
}
}
public List <string> deleteSeason(TVSeriesPlugin.DeleteMenuItems type)
{
List <string> resultMsg = new List <string>();
// Always delete from Local episode table if deleting from disk or database
SQLCondition condition = new SQLCondition();
condition.Add(new DBEpisode(), DBEpisode.cSeriesID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
condition.Add(new DBEpisode(), DBEpisode.cSeasonIndex, this[DBSeason.cIndex], SQLConditionType.Equal);
/* TODO will include hidden episodes as hidden attribute is only in onlineepisodes. maybe we should include it in localepisodes also..
* if hidden episodes are excluded then the if (resultMsg.Count is wrong and should do another select to get proper count
* if (!DBOption.GetOptions(DBOption.cShowHiddenItems))
* {
* //don't include hidden seasons unless the ShowHiddenItems option is set
* condition.Add(new DBEpisode(), idden, 0, SQLConditionType.Equal);
* }
*/
List <DBEpisode> episodes = DBEpisode.Get(condition, false);
if (episodes != null)
{
bool hasLocalEpisodesToDelete = episodes.Exists(e => !string.IsNullOrEmpty(e[DBEpisode.cFilename]));
hasLocalEpisodesToDelete &= (type == TVSeriesPlugin.DeleteMenuItems.disk || type == TVSeriesPlugin.DeleteMenuItems.diskdatabase);
DBSeries series = Helper.getCorrespondingSeries(this[DBSeason.cSeriesID]);
string seriesName = series == null ? this[DBSeason.cSeriesID].ToString() : series.ToString();
// show progress dialog as this can be a long process esp for network drives
// will show new progress for each season if deleting from the series level
GUIDialogProgress progressDialog = null;
if (!Settings.isConfig)
{
progressDialog = (GUIDialogProgress)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_PROGRESS);
progressDialog.Reset();
progressDialog.DisplayProgressBar = true;
progressDialog.ShowWaitCursor = false;
progressDialog.DisableCancel(true);
progressDialog.SetHeading(Translation.Delete);
progressDialog.Percentage = 0;
progressDialog.SetLine(1, string.Format("{0} {1} {2}", seriesName, Translation.Season, this[DBSeason.cIndex]));
progressDialog.SetLine(2, string.Empty);
// only show progress dialog if we have local files in season
if (hasLocalEpisodesToDelete)
{
progressDialog.StartModal(GUIWindowManager.ActiveWindow);
}
}
int counter = 0;
foreach (DBEpisode episode in episodes)
{
string episodeName = string.Format("{0}x{1} - {2}", episode[DBOnlineEpisode.cSeasonIndex], episode[DBOnlineEpisode.cEpisodeIndex], episode[DBOnlineEpisode.cEpisodeName]);
if (!Settings.isConfig)
{
progressDialog.SetLine(2, episodeName);
}
if (!Settings.isConfig)
{
GUIWindowManager.Process();
}
resultMsg.AddRange(episode.deleteEpisode(type, true));
if (!Settings.isConfig)
{
progressDialog.Percentage = Convert.ToInt32(((double)++counter / (double)episodes.Count) * 100.0);
}
if (!Settings.isConfig)
{
GUIWindowManager.Process();
}
}
// close progress dialog
if (!Settings.isConfig)
{
progressDialog.Close();
}
// if we have removed all episodes in season without error, cleanup the online table
if (resultMsg.Count == 0 && type != TVSeriesPlugin.DeleteMenuItems.disk)
{
condition = new SQLCondition();
condition.Add(new DBOnlineEpisode(), DBOnlineEpisode.cSeriesID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
condition.Add(new DBOnlineEpisode(), DBOnlineEpisode.cSeasonIndex, this[DBSeason.cIndex], SQLConditionType.Equal);
DBOnlineEpisode.Clear(condition);
}
}
#region Facade Remote Color
// if we were successful at deleting all episodes of season from disk, set HasLocalFiles to false
// note: we only do this if the database entries still exist
if (resultMsg.Count == 0 && type == TVSeriesPlugin.DeleteMenuItems.disk)
{
this[cHasLocalFiles] = false;
this.Commit();
}
// if we were successful at deleting all episodes of season from disk,
// also check if any local episodes exist on disk for series and set HasLocalFiles to false
if (resultMsg.Count == 0 && type != TVSeriesPlugin.DeleteMenuItems.database)
{
// Check Series for Local Files
SQLCondition episodeConditions = new SQLCondition();
episodeConditions.Add(new DBEpisode(), DBEpisode.cSeriesID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
List <DBEpisode> localEpisodes = DBEpisode.Get(episodeConditions);
if (localEpisodes.Count == 0 && !DBSeries.IsSeriesRemoved)
{
DBSeries series = DBSeries.Get(this[DBSeason.cSeriesID]);
if (series != null)
{
series[DBOnlineSeries.cHasLocalFiles] = false;
series.Commit();
}
}
}
#endregion
#region Cleanup
// if there are no error messages and if we need to delete from db
if (resultMsg.Count == 0 && type != TVSeriesPlugin.DeleteMenuItems.disk)
{
condition = new SQLCondition();
condition.Add(new DBSeason(), DBSeason.cSeriesID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
condition.Add(new DBSeason(), DBSeason.cIndex, this[DBSeason.cIndex], SQLConditionType.Equal);
DBSeason.Clear(condition);
}
DBSeries.IsSeriesRemoved = false;
if (type != TVSeriesPlugin.DeleteMenuItems.disk)
{
// If local/online episode count is zero then delete the series and all seasons
condition = new SQLCondition();
condition.Add(new DBOnlineEpisode(), DBOnlineEpisode.cSeriesID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
episodes = DBEpisode.Get(condition, false);
if (episodes.Count == 0)
{
// Delete Seasons
condition = new SQLCondition();
condition.Add(new DBSeason(), DBSeason.cSeriesID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
DBSeason.Clear(condition);
// Delete Local Series
condition = new SQLCondition();
condition.Add(new DBSeries(), DBSeries.cID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
DBSeries.Clear(condition);
// Delete Online Series
condition = new SQLCondition();
condition.Add(new DBOnlineSeries(), DBOnlineSeries.cID, this[DBSeason.cSeriesID], SQLConditionType.Equal);
DBOnlineSeries.Clear(condition);
DBSeries.IsSeriesRemoved = true;
}
}
#endregion
return(resultMsg);
}
public UserInputResultSeriesActionPair(UserInputResults.SeriesAction RequestedAction, DBOnlineSeries series)
{
this.RequestedAction = RequestedAction;
this.ChosenSeries = series;
}
public static string resolveDynString(string what, DBTable item, bool splitFields, bool applyUserFormatting)
{
// apply userFormatting on the field's itself
if (applyUserFormatting)
{
performUserFormattingReplacement(ref what);
}
Level level = levelOfItem(item);
string value = what;
List <Level> whatLevels = getLevel(what);
_splitFields = splitFields;
// the item needs to be the type corresponding to the level (we require the item to match the indicated level)
if (level == Level.Episode) // we can do everything
{
if (whatLevels.Contains(Level.Episode))
{
DBOnlineEpisode o = item as DBOnlineEpisode;
if (o == null)
{
value = replaceEpisodeTags(item as DBEpisode, value);
}
else
{
value = replaceEpisodeTags(o, value);
}
}
if (whatLevels.Contains(Level.Season))
{
value = replaceSeasonTags(item[DBEpisode.cSeriesID], item[DBEpisode.cSeasonIndex], value);
}
if (whatLevels.Contains(Level.Series))
{
value = replaceSeriesTags(item[DBEpisode.cSeriesID], value);
}
}
else if (level == Level.Season && !whatLevels.Contains(Level.Episode)) // we can do season/series
{
if (whatLevels.Contains(Level.Season))
{
value = replaceSeasonTags(item as DBSeason, value);
}
if (whatLevels.Contains(Level.Series))
{
value = replaceSeriesTags(item[DBSeason.cSeriesID], value);
}
}
else if (level == Level.Series && !whatLevels.Contains(Level.Episode) && !whatLevels.Contains(Level.Season)) // we can only do series
{
DBOnlineSeries o = item as DBOnlineSeries;
if (o == null)
{
value = replaceSeriesTags(item as DBSeries, value);
}
else
{
value = replaceSeriesTags(item[DBSeries.cID], value);
}
}
if (nonFormattingFields.Contains(what))
{
return(value);
}
value = doFormatting(value, what, item);
value = MathParser.mathParser.TryParse(value);
value = MathParser.mathParser.TranslateExpression(value);
// apply userFormatting on the field's result
if (applyUserFormatting)
{
bool replacementOccured = performUserFormattingReplacement(ref value);
// because the replacement itself might be dynamic again, we resolve the result again
if (replacementOccured)
{
value = resolveDynString(value, item, splitFields, applyUserFormatting);
}
}
return(System.Web.HttpUtility.HtmlDecode(value));
}
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 UserInputResultSeriesActionPair(UserInputResults.SeriesAction RequestedAction, DBOnlineSeries series)
{
this.RequestedAction = RequestedAction;
this.ChosenSeries = series;
}
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 DBSeries(String SeriesName)
: base(cTableName)
{
InitColumns();
if (!ReadPrimary(SeriesName))
InitValues();
if (this[cID] == 0)
{
m_onlineSeries = new DBOnlineSeries(s_nLastLocalID);
s_nLastLocalID--;
DBOption.SetOptions(DBOption.cDBSeriesLastLocalID, s_nLastLocalID);
this[cID] = m_onlineSeries[DBOnlineSeries.cID];
if (String.IsNullOrEmpty(m_onlineSeries[DBOnlineSeries.cPrettyName]))
{
m_onlineSeries[DBOnlineSeries.cPrettyName] = this[cParsedName];
m_onlineSeries[DBOnlineSeries.cSortName] = this[cParsedName];
m_onlineSeries.Commit();
}
}
else
{
m_onlineSeries = new DBOnlineSeries(this[cID]);
}
}
public void ChangeSeriesID(int nSeriesID)
{
DBOnlineSeries newOnlineSeries = new DBOnlineSeries(nSeriesID);
if (m_onlineSeries[DBOnlineSeries.cHasLocalFilesTemp])
newOnlineSeries[DBOnlineSeries.cHasLocalFilesTemp] = 1;
if (m_onlineSeries[DBOnlineSeries.cHasLocalFiles])
newOnlineSeries[DBOnlineSeries.cHasLocalFiles] = 1;
newOnlineSeries[DBOnlineSeries.cEpisodeOrders] = m_onlineSeries[DBOnlineSeries.cEpisodeOrders];
newOnlineSeries[DBOnlineSeries.cChosenEpisodeOrder] = m_onlineSeries[DBOnlineSeries.cChosenEpisodeOrder];
m_onlineSeries = newOnlineSeries;
this[cID] = nSeriesID;
}
public static void UpdateUnWatched(DBEpisode episode)
{
DBOnlineSeries series = new DBOnlineSeries(episode[DBEpisode.cSeriesID]);
DBEpisode FirstUnwatchedEpisode = DBEpisode.GetFirstUnwatched(series[DBSeries.cID]);
if (FirstUnwatchedEpisode != null)
series[DBOnlineSeries.cUnwatchedItems] = true;
else
series[DBOnlineSeries.cUnwatchedItems] = false;
series.Commit();
}
static void getTableFieldname(string what, out DBTable table, out string fieldname)
{
string sTable = string.Empty;
fieldname = string.Empty;
table = null;
what = what.Replace("<", "").Replace(">", "").Trim();
sTable = what.Split('.')[0];
switch (sTable)
{
case "Series":
if(new DBOnlineSeries().FieldNames.Contains(what.Split('.')[1]))
{
table = new DBOnlineSeries();
fieldname = what.Split('.')[1];
}
else
{
table = new DBSeries();
fieldname = what.Split('.')[1];
}
break;
case "Season":
table = new DBSeason();
fieldname = what.Split('.')[1];
break;
case "Episode":
if (new DBOnlineEpisode().FieldNames.Contains(what.Split('.')[1]))
{
table = new DBOnlineEpisode();
fieldname = what.Split('.')[1];
}
else
{
table = new DBEpisode();
fieldname = what.Split('.')[1];
}
break;
}
}
static DBOnlineSeries()
{
///////////////////////////////////////////////////
#region Pretty Names displayed in Configuration Details Tab
s_FieldToDisplayNameMap.Add(cID, "Online Series ID");
s_FieldToDisplayNameMap.Add(cPrettyName, "Title");
s_FieldToDisplayNameMap.Add(cStatus, "Show Status");
s_FieldToDisplayNameMap.Add(cGenre, "Genre");
s_FieldToDisplayNameMap.Add(cSummary, "Show Overview");
s_FieldToDisplayNameMap.Add(cAirsDay, "Aired Day");
s_FieldToDisplayNameMap.Add(cAirsTime, "Aired Time");
s_FieldToDisplayNameMap.Add(cSortName, "Sort By");
s_FieldToDisplayNameMap.Add(cLanguage, "Language");
s_FieldToDisplayNameMap.Add(cIMDBID, "IMDB ID");
s_FieldToDisplayNameMap.Add(cEpisodeOrders, "Episode Orders");
s_FieldToDisplayNameMap.Add(cChosenEpisodeOrder, "Episode Order");
s_FieldToDisplayNameMap.Add(cContentRating, "Content Rating");
s_FieldToDisplayNameMap.Add(cMyRating, "My Rating");
s_FieldToDisplayNameMap.Add(cFirstAired, "First Aired");
s_FieldToDisplayNameMap.Add(cEpisodeCount, "Episodes");
s_FieldToDisplayNameMap.Add(cEpisodesUnWatched, "Episodes UnWatched");
#endregion
///////////////////////////////////////////////////
//////////////////////////////////////////////////
#region Local DB field mapping to Online DB
s_OnlineToFieldMap.Add("id", cID);
s_OnlineToFieldMap.Add("SeriesName", cPrettyName);
s_OnlineToFieldMap.Add("Status", cStatus);
s_OnlineToFieldMap.Add("Genre", cGenre);
s_OnlineToFieldMap.Add("Overview", cSummary);
s_OnlineToFieldMap.Add("Airs_DayOfWeek", cAirsDay);
s_OnlineToFieldMap.Add("Airs_Time", cAirsTime);
s_OnlineToFieldMap.Add("SortName", cSortName);
#endregion
//////////////////////////////////////////////////
// make sure the table is created on first run
DBOnlineSeries dummy = new DBOnlineSeries();
}
public DBSeries(bool bCreateEmptyOnline)
: base(cTableName)
{
InitColumns();
InitValues();
if (bCreateEmptyOnline)
m_onlineSeries = new DBOnlineSeries();
}
public void addSQLCondition(string what, string type, string condition)
{
if ((!what.Contains("<") || !what.Contains(".")) && !what.Contains("custom:"))
{
return;
}
SQLConditionType condtype;
switch (type)
{
case "=":
condtype = SQLConditionType.Equal;
break;
case ">":
condtype = SQLConditionType.GreaterThan;
break;
case ">=":
condtype = SQLConditionType.GreaterEqualThan;
break;
case "<":
condtype = SQLConditionType.LessThan;
break;
case "<=":
condtype = SQLConditionType.LessEqualThan;
break;
case "!=":
condtype = SQLConditionType.NotEqual;
break;
case "like":
condtype = SQLConditionType.Like;
break;
default:
condtype = SQLConditionType.Equal;
break;
}
DBTable table = null;
string tableField = string.Empty;
getTableFieldname(what, out table, out tableField);
Type lType = table.GetType();
SQLCondition fullSubCond = new SQLCondition();
if (logicalViewStep.type.series == Type && (lType != typeof(DBSeries) && lType != typeof(DBOnlineSeries)))
{
if (lType == typeof(DBSeason))
{
fullSubCond.AddCustom(DBSeason.Q(DBSeason.cSeriesID), DBOnlineSeries.Q(DBOnlineSeries.cID), SQLConditionType.Equal);
fullSubCond.AddCustom(DBSeason.Q(tableField), condition, condtype, true);
conds.AddCustom(" exists( " + DBSeason.stdGetSQL(fullSubCond, false) + " )");
}
else if (lType == typeof(DBOnlineEpisode))
{
fullSubCond.AddCustom(DBOnlineEpisode.Q(tableField), condition, condtype, true);
conds.AddCustom(" online_series.id in ( " + DBEpisode.stdGetSQL(fullSubCond, false, true, DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID)) + " )");
}
else if (lType == typeof(DBEpisode))
{
fullSubCond.AddCustom(DBEpisode.Q(tableField), condition, condtype, true);
conds.AddCustom(" online_series.id in ( " + DBEpisode.stdGetSQL(fullSubCond, false, true, DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID)) + " )");
}
}
else if (logicalViewStep.type.season == Type && lType != typeof(DBSeason))
{
if (lType == typeof(DBOnlineSeries) || lType == typeof(DBSeries))
{
fullSubCond.AddCustom(DBOnlineSeries.Q(DBOnlineSeries.cID), DBSeason.Q(DBSeason.cSeriesID), SQLConditionType.Equal);
fullSubCond.AddCustom(DBOnlineSeries.Q(tableField), condition, condtype, true);
conds.AddCustom(" exists( " + DBSeries.stdGetSQL(fullSubCond, false) + " )");
}
else if (lType == typeof(DBOnlineEpisode))
{
// we rely on the join in dbseason for this (much, much faster)
conds.AddCustom(DBOnlineEpisode.Q(tableField), condition, condtype, true);
}
else if (lType == typeof(DBEpisode))
{
fullSubCond.AddCustom(DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID), DBSeason.Q(DBSeason.cSeriesID), SQLConditionType.Equal);
fullSubCond.AddCustom(DBOnlineEpisode.Q(DBOnlineEpisode.cSeasonIndex), DBSeason.Q(DBSeason.cIndex), SQLConditionType.Equal);
fullSubCond.AddCustom(DBEpisode.Q(tableField), condition, condtype);
conds.AddCustom(" exists( " + DBEpisode.stdGetSQL(fullSubCond, false) + " )");
}
}
else if (logicalViewStep.type.episode == Type && (lType != typeof(DBEpisode) && lType != typeof(DBOnlineEpisode)))
{
if (lType == typeof(DBOnlineSeries) || lType == typeof(DBSeries))
{
fullSubCond.AddCustom(DBOnlineSeries.Q(DBOnlineSeries.cID), DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID), SQLConditionType.Equal);
fullSubCond.AddCustom(DBOnlineSeries.Q(tableField), condition, condtype, true);
conds.AddCustom(" exists( " + DBSeries.stdGetSQL(fullSubCond, false) + " )");
}
if (lType == typeof(DBSeason))
{
fullSubCond.AddCustom(DBSeason.Q(DBSeason.cSeriesID), DBOnlineEpisode.Q(DBOnlineEpisode.cSeriesID), SQLConditionType.Equal);
fullSubCond.AddCustom(DBSeason.Q(DBSeason.cIndex), DBOnlineEpisode.Q(DBOnlineEpisode.cSeasonIndex), SQLConditionType.Equal);
fullSubCond.AddCustom(DBSeason.Q(tableField), condition, condtype, true);
conds.AddCustom(" exists( " + DBSeason.stdGetSQL(fullSubCond, false) + " )");
}
}
else
{
// condition is on current table itself
conds.Add(table, tableField, condition.Trim(), condtype);
}
}
private IEnumerable <DBOnlineSeries> Work(String sSeriesID, String languageID, bool aOverride = false)
{
if (sSeriesID.Length > 0)
{
int result;
if (int.TryParse(sSeriesID, out result))
{
MPTVSeriesLog.Write(string.Format("Retrieving updated Metadata for series {0}", Helper.getCorrespondingSeries(result)), MPTVSeriesLog.LogLevel.Debug);
}
XmlNode node = null;
if (String.IsNullOrEmpty(languageID))
{
node = Online_Parsing_Classes.OnlineAPI.UpdateSeries(sSeriesID);
}
else
{
node = Online_Parsing_Classes.OnlineAPI.UpdateSeries(sSeriesID, languageID, aOverride);
}
if (node != null)
{
foreach (XmlNode itemNode in node.SelectNodes("/Data"))
{
bool hasDVDOrdering = false;
bool hasAbsoluteOrdering = false;
DBOnlineSeries series = new DBOnlineSeries();
foreach (XmlNode seriesNode in itemNode)
{
// first return item SHOULD ALWAYS be the series
if (seriesNode.Name.Equals("Series", StringComparison.InvariantCultureIgnoreCase))
{
foreach (XmlNode propertyNode in seriesNode.ChildNodes)
{
if (propertyNode.Name == "Language") // work around inconsistancy (language = Language)
{
series["language"] = propertyNode.InnerText;
}
else if (DBOnlineSeries.s_OnlineToFieldMap.ContainsKey(propertyNode.Name))
{
series[DBOnlineSeries.s_OnlineToFieldMap[propertyNode.Name]] = propertyNode.InnerText;
}
else
{
// we don't know that field, add it to the series table
series.AddColumn(propertyNode.Name, new DBField(DBField.cTypeString));
series[propertyNode.Name] = propertyNode.InnerText;
}
}
if (series != null)
{
mSeriesList.Add(series);
}
}
else if (!hasDVDOrdering || !hasAbsoluteOrdering || seriesNode.Name.Equals("Episode", StringComparison.InvariantCultureIgnoreCase))
{
foreach (XmlNode propertyNode in seriesNode.ChildNodes)
{
switch (propertyNode.Name)
{
case "DVD_episodenumber":
case "DVD_season":
if (!String.IsNullOrEmpty(propertyNode.InnerText))
{
hasDVDOrdering = true;
}
break;
case "absolute_number":
if (!String.IsNullOrEmpty(propertyNode.InnerText))
{
hasAbsoluteOrdering = true;
}
break;
}
}
}
}
if ((hasAbsoluteOrdering || hasDVDOrdering))
{
string ordering = series[DBOnlineSeries.cEpisodeOrders] == string.Empty ? "Aired|" : (string)series[DBOnlineSeries.cEpisodeOrders];
if (hasAbsoluteOrdering)
{
ordering += "Absolute|";
}
if (hasDVDOrdering)
{
ordering += "DVD";
}
series[DBOnlineSeries.cEpisodeOrders] = ordering;
}
if (series != null)
{
yield return(series);
}
}
}
}
}
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 IEnumerable<DBOnlineSeries> Work(String sSeriesID, String languageID)
{
if (sSeriesID.Length > 0)
{
int result;
if (int.TryParse(sSeriesID,out result))
MPTVSeriesLog.Write(string.Format("Retrieving updated Metadata for series {0}",Helper.getCorrespondingSeries(result)), MPTVSeriesLog.LogLevel.Debug);
XmlNode node = null;
if (String.IsNullOrEmpty(languageID))
{
node = Online_Parsing_Classes.OnlineAPI.UpdateSeries(sSeriesID);
}
else
{
node = Online_Parsing_Classes.OnlineAPI.UpdateSeries(sSeriesID, languageID);
}
if (node != null)
{
foreach (XmlNode itemNode in node.SelectNodes("/Data"))
{
bool hasDVDOrdering = false;
bool hasAbsoluteOrdering = false;
DBOnlineSeries series = new DBOnlineSeries();
foreach (XmlNode seriesNode in itemNode)
{
// first return item SHOULD ALWAYS be the series
if (seriesNode.Name.Equals("Series", StringComparison.InvariantCultureIgnoreCase))
{
foreach (XmlNode propertyNode in seriesNode.ChildNodes)
{
if (propertyNode.Name == "Language") // work around inconsistancy (language = Language)
{
series["language"] = propertyNode.InnerText;
}
else if (DBOnlineSeries.s_OnlineToFieldMap.ContainsKey(propertyNode.Name))
series[DBOnlineSeries.s_OnlineToFieldMap[propertyNode.Name]] = propertyNode.InnerText;
else
{
// we don't know that field, add it to the series table
series.AddColumn(propertyNode.Name, new DBField(DBField.cTypeString));
series[propertyNode.Name] = propertyNode.InnerText;
}
}
if (series != null) listSeries.Add(series);
}
else if(!hasDVDOrdering || !hasAbsoluteOrdering || seriesNode.Name.Equals("Episode", StringComparison.InvariantCultureIgnoreCase))
{
foreach (XmlNode propertyNode in seriesNode.ChildNodes)
{
switch (propertyNode.Name)
{
case "DVD_episodenumber":
case "DVD_season":
if(!String.IsNullOrEmpty(propertyNode.InnerText)) hasDVDOrdering = true;
break;
case "absolute_number":
if (!String.IsNullOrEmpty(propertyNode.InnerText)) hasAbsoluteOrdering = true;
break;
}
}
}
}
if ((hasAbsoluteOrdering || hasDVDOrdering))
{
string ordering = series[DBOnlineSeries.cEpisodeOrders] == string.Empty ? "Aired|" : (string)series[DBOnlineSeries.cEpisodeOrders];
if (hasAbsoluteOrdering) ordering += "Absolute|";
if (hasDVDOrdering) ordering += "DVD";
series[DBOnlineSeries.cEpisodeOrders] = ordering;
}
if(series != null) yield return series;
}
}
}
}