public void PopulateSeries(VM_AnimeSeries_User seriesContract)
{
if (seriesContract != null)
{
AnimeSeries = seriesContract;
}
}
public void Populate(VM_AnimeSeries_User contract)
{
//TODO we can get detailed in here
AniDBAnime = contract.AniDBAnime;
CrossRefAniDBTvDBV2 = contract.CrossRefAniDBTvDBV2;
TvDB_Series = contract.TvDB_Series;
CrossRefAniDBMovieDB = contract.CrossRefAniDBMovieDB;
CrossRefAniDBMAL = contract.CrossRefAniDBMAL;
AniDB_ID = contract.AniDB_ID;
AnimeGroupID = contract.AnimeGroupID;
AnimeSeriesID = contract.AnimeSeriesID;
DateTimeUpdated = contract.DateTimeUpdated;
DateTimeCreated = contract.DateTimeCreated;
DefaultAudioLanguage = contract.DefaultAudioLanguage;
DefaultSubtitleLanguage = contract.DefaultSubtitleLanguage;
SeriesNameOverride = contract.SeriesNameOverride;
DefaultFolder = contract.DefaultFolder;
LatestLocalEpisodeNumber = contract.LatestLocalEpisodeNumber;
PlayedCount = contract.PlayedCount;
StoppedCount = contract.StoppedCount;
UnwatchedEpisodeCount = contract.UnwatchedEpisodeCount;
WatchedCount = contract.WatchedCount;
WatchedDate = contract.WatchedDate;
EpisodeAddedDate = contract.EpisodeAddedDate;
WatchedEpisodeCount = contract.WatchedEpisodeCount;
MissingEpisodeCount = contract.MissingEpisodeCount;
MissingEpisodeCountGroups = contract.MissingEpisodeCountGroups;
Refresh();
}
public bool EvaluateGroupFilter(VM_AnimeSeries_User ser)
{
if (Series == null || !Series.ContainsKey(VM_ShokoServer.Instance.CurrentUser.JMMUserID))
{
return(false);
}
if (ser.AnimeSeriesID != 0)
{
return(Series[VM_ShokoServer.Instance.CurrentUser.JMMUserID].Contains(ser.AnimeSeriesID));
}
return(false);
}
public void RefreshAnime(bool forced)
{
if (VM_MainListHelper.Instance.AllSeriesDictionary.ContainsKey(AnimeSeriesID))
{
VM_AnimeSeries_User ser = VM_MainListHelper.Instance.AllSeriesDictionary[AnimeSeriesID];
aniDB_Anime = ser.AniDBAnime.AniDBAnime;
}
if (forced && aniDB_Anime != null)
{
VM_MainListHelper.Instance.UpdateAnime(aniDB_Anime.AnimeID);
}
if (forced && aniDB_Anime == null)
{
VM_MainListHelper.Instance.UpdateAnime(AnimeSeries.AniDBAnime.AniDBAnime.AnimeID);
if (AnimeSeries?.AniDBAnime.AniDBAnime != null)
{
aniDB_Anime = AnimeSeries.AniDBAnime.AniDBAnime;
}
}
}
public void Drop(IDropInfo dropInfo)
{
PlaylistItemType itemType = PlaylistItemType.AnimeSeries;
int objIDOld = -1;
VM_PlaylistItem pli = dropInfo.Data as VM_PlaylistItem;
if (pli == null)
{
return;
}
if (pli.ItemType == PlaylistItemType.Episode)
{
VM_AnimeEpisode_User ep = (VM_AnimeEpisode_User)pli.PlaylistItem;
itemType = PlaylistItemType.Episode;
objIDOld = ep.AnimeEpisodeID;
}
if (pli.ItemType == PlaylistItemType.AnimeSeries)
{
VM_AnimeSeries_User ep = (VM_AnimeSeries_User)pli.PlaylistItem;
itemType = PlaylistItemType.AnimeSeries;
objIDOld = ep.AnimeSeriesID;
}
int iType = (int)itemType;
// find where this item was previously
if (string.IsNullOrEmpty(PlaylistItems))
{
return;
}
string[] items = PlaylistItems.Split('|');
// create a new list without the moved item
string newItemList = "";
foreach (string pitem in items)
{
string[] parms = pitem.Split(';');
if (parms.Length != 2)
{
continue;
}
int objType;
int objID;
if (!int.TryParse(parms[0], out objType))
{
continue;
}
if (!int.TryParse(parms[1], out objID))
{
continue;
}
if (objType == iType && objID == objIDOld)
{
// skip the old item
}
else
{
if (newItemList.Length > 0)
{
newItemList += "|";
}
newItemList += $"{objType};{objID}";
}
}
// insert the moved item into it's new position
items = newItemList.Split('|');
PlaylistItems = "";
int curPos = 0;
if (string.IsNullOrEmpty(newItemList))
{
// means there was only one item in list to begin with
PlaylistItems += $"{iType};{objIDOld}";
}
else
{
foreach (string pitem in items)
{
string[] parms = pitem.Split(';');
if (parms.Length != 2)
{
continue;
}
int objType;
int objID;
int.TryParse(parms[0], out objType);
int.TryParse(parms[1], out objID);
if (curPos == dropInfo.InsertIndex)
{
// insert moved item
if (PlaylistItems.Length > 0)
{
PlaylistItems += "|";
}
PlaylistItems += $"{iType};{objIDOld}";
}
if (PlaylistItems.Length > 0)
{
PlaylistItems += "|";
}
PlaylistItems += $"{objType};{objID}";
curPos++;
}
}
// moved to the end of the list
if (dropInfo.InsertIndex > items.Length)
{
if (PlaylistItems.Length > 0)
{
PlaylistItems += "|";
}
PlaylistItems += $"{iType};{objIDOld}";
}
Save();
PopulatePlaylistObjects();
VM_PlaylistHelper.Instance.OnPlaylistModified(new PlaylistModifiedEventArgs(PlaylistID));
}
public List <VM_AnimeEpisode_User> GetAllEpisodes(bool onlyRandom)
{
List <VM_AnimeEpisode_User> allEps = new List <VM_AnimeEpisode_User>();
// find the next episode to play
if (DefaultPlayOrderEnum == PlaylistPlayOrder.Sequential && !onlyRandom)
{
foreach (VM_PlaylistItem pli in PlaylistObjects)
{
if (pli.ItemType == PlaylistItemType.Episode)
{
VM_AnimeEpisode_User epTemp = pli.PlaylistItem as VM_AnimeEpisode_User;
if (CanUseEpisode(this, epTemp))
{
allEps.Add(epTemp);
}
}
if (pli.ItemType == PlaylistItemType.AnimeSeries)
{
VM_AnimeSeries_User ser = (VM_AnimeSeries_User)pli.PlaylistItem;
VM_MainListHelper.Instance.UpdateAll();
ser.RefreshEpisodes();
List <VM_AnimeEpisode_User> eps = ser.AllEpisodes.OrderBy(a => a.EpisodeType).ThenBy(a => a.EpisodeNumber).ToList();
foreach (VM_AnimeEpisode_User epTemp in eps)
{
if (epTemp.EpisodeTypeEnum == EpisodeType.Episode || epTemp.EpisodeTypeEnum == EpisodeType.Special)
{
if (CanUseEpisode(this, epTemp))
{
allEps.Add(epTemp);
}
}
}
}
}
}
else // random
{
foreach (VM_PlaylistItem pli in PlaylistObjects)
{
if (pli.ItemType == PlaylistItemType.Episode)
{
VM_AnimeEpisode_User epTemp = pli.PlaylistItem as VM_AnimeEpisode_User;
if (CanUseEpisode(this, epTemp))
{
allEps.Add(epTemp);
}
}
if (pli.ItemType == PlaylistItemType.AnimeSeries)
{
VM_AnimeSeries_User ser = (VM_AnimeSeries_User)pli.PlaylistItem;
VM_MainListHelper.Instance.UpdateAll();
ser.RefreshEpisodes();
List <VM_AnimeEpisode_User> eps = ser.AllEpisodes;
foreach (VM_AnimeEpisode_User epTemp in eps)
{
if (epTemp.EpisodeTypeEnum == EpisodeType.Episode || epTemp.EpisodeTypeEnum == EpisodeType.Special)
{
if (CanUseEpisode(this, epTemp))
{
allEps.Add(epTemp);
}
}
}
}
}
allEps.Shuffle();
}
return(allEps);
}
public void SetNextEpisode(bool onlyRandom)
{
if (PlaylistObjects.Count == 0)
{
return;
}
// find the next episode to play
NextEpisode = null;
if (DefaultPlayOrderEnum == PlaylistPlayOrder.Sequential && !onlyRandom)
{
while (true)
{
foreach (VM_PlaylistItem pli in PlaylistObjects)
{
if (pli.ItemType == PlaylistItemType.Episode)
{
VM_AnimeEpisode_User epTemp = pli.PlaylistItem as VM_AnimeEpisode_User;
if (CanUseEpisode(this, epTemp))
{
NextEpisode = epTemp;
break;
}
}
if (pli.ItemType == PlaylistItemType.AnimeSeries)
{
VM_AnimeSeries_User ser = (VM_AnimeSeries_User)pli.PlaylistItem;
VM_MainListHelper.Instance.UpdateAll();
ser.RefreshEpisodes();
List <VM_AnimeEpisode_User> eps = ser.AllEpisodes.OrderBy(a => a.EpisodeType).ThenBy(a => a.EpisodeNumber).ToList();
bool foundEp = false;
foreach (VM_AnimeEpisode_User epTemp in eps)
{
if (epTemp.EpisodeTypeEnum == EpisodeType.Episode || epTemp.EpisodeTypeEnum == EpisodeType.Special)
{
if (CanUseEpisode(this, epTemp))
{
NextEpisode = epTemp;
foundEp = true;
break;
}
}
}
if (foundEp)
{
break;
}
}
}
break;
}
}
else // random
{
// get all the candidate episodes
List <VM_AnimeEpisode_User> canidateEps = new List <VM_AnimeEpisode_User>();
foreach (VM_PlaylistItem pli in PlaylistObjects)
{
if (pli.ItemType == PlaylistItemType.Episode)
{
VM_AnimeEpisode_User epTemp = pli.PlaylistItem as VM_AnimeEpisode_User;
if (CanUseEpisode(this, epTemp))
{
canidateEps.Add(epTemp);
}
}
if (pli.ItemType == PlaylistItemType.AnimeSeries)
{
VM_AnimeSeries_User ser = (VM_AnimeSeries_User)pli.PlaylistItem;
VM_MainListHelper.Instance.UpdateAll();
ser.RefreshEpisodes();
List <VM_AnimeEpisode_User> eps = ser.AllEpisodes;
foreach (VM_AnimeEpisode_User epTemp in eps)
{
if (epTemp.EpisodeTypeEnum == EpisodeType.Episode || epTemp.EpisodeTypeEnum == EpisodeType.Special)
{
if (CanUseEpisode(this, epTemp))
{
canidateEps.Add(epTemp);
}
}
}
}
}
// pick a random object from the play list
if (canidateEps.Count > 0)
{
NextEpisode = canidateEps[epRandom.Next(0, canidateEps.Count)];
}
}
if (NextEpisode != null)
{
NextEpisode.SetTvDBInfo();
NextEpisode.RefreshAnime();
AniDB_Anime = NextEpisode.AniDBAnime;
if (VM_MainListHelper.Instance.AllSeriesDictionary.ContainsKey(NextEpisode.AnimeSeriesID))
{
Series = VM_MainListHelper.Instance.AllSeriesDictionary[NextEpisode.AnimeSeriesID];
}
}
}
public bool EvaluateSeries(VM_AnimeSeries_User ser)
{
// make sure the user has not filtered this out
return(EvaluateTags(ser.AllTags));
}
