public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
List <AnimeParadiseData> data = (List <AnimeParadiseData>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
if ((setData.DubExists && subData.isDub) || (setData.SubExists && !subData.isDub))
{
continue;
}
if (subData.season == ms.season &&
(ToLowerAndReplace(ms.name, false).StartsWith(ToLowerAndReplace(subData.name, false)) ||
ToLowerAndReplace(ms.engName, false).StartsWith(ToLowerAndReplace(subData.name, false)))) // THIS IS BECAUSE SEASON IS SEPERATED FROM NAME
{
try {
string d = DownloadString("https://animeparadise.cc/anime.php?s=" + subData.id, referer: subData.referer);
var doc = new HtmlAgilityPack.HtmlDocument();
doc.LoadHtml(d);
var nodes = doc.QuerySelectorAll("h1.title");
int lastEp = int.Parse(nodes[^ 1].InnerText);
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
List <AnimeVibeData> data = (List <AnimeVibeData>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
if (subData.title.Contains(ms.japName))
{
bool isDub = subData.isDub;
if (isDub && !setData.DubExists)
{
for (int i = 1; i <= subData.maxEp; i++)
{
setData.dubEpisodes.Add(subData.href + i);
}
}
else if (!setData.SubExists)
{
for (int i = 1; i <= subData.maxEp; i++)
{
setData.subEpisodes.Add(subData.href + i);
}
}
}
}
return(setData);
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
List <AnimeSimpleTitle> data = (List <AnimeSimpleTitle>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
if (ms.MalId == subData.malId)
{
var ep = GetAnimeSimpleEpisodes(subData.id);
if (ep.HasValue)
{
var _val = ep.Value;
for (int i = 0; i < _val.subbedEpisodes; i++)
{
setData.subEpisodes.Add(_val.urls[i]);
}
for (int i = 0; i < _val.dubbedEpisodes; i++)
{
setData.dubEpisodes.Add(_val.urls[i]);
}
}
}
}
return(setData);
}
public NonBloatSeasonData GetData(MALSeason data, out bool suc)
{
var list = data.nonBloatSeasonData.Where(t => t.name == Name).ToList();
suc = list.Count > 0;
return(suc ? list[0] : new NonBloatSeasonData());
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
List <DubbedSearchItem> data = (List <DubbedSearchItem>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
if (subData.isMovie)
{
continue;
}
// SEE https://bestdubbedanime.com/search/_
string name = subData.name.ToLower();
string baseName = ToDown(name);
if (baseName.StartsWith(ToDown(ms.name)) || baseName.StartsWith(ToDown(ActiveMovie.title.name)) || baseName.StartsWith(ToDown(ActiveMovie.title.ogName)))
{
int season = 1;
if (name.Contains("season 2") || name.Contains("2nd season") || name.Contains("second season") || (name.EndsWith(" 2") && !name.EndsWith("part 2")))
{
season = 2;
}
else if (name.Contains("season 3") || name.Contains("3rd season") || (name.EndsWith(" 3") && !name.EndsWith("part 3")))
{
season = 3;
}
if (ms.season != season)
{
continue;
}
int part = 1;
if (name.Contains("part 2") || name.Contains("part ii"))
{
part = 2;
}
if (ms.part != part)
{
continue;
}
var ep = provider.GetDubbedAnimeEpisode(subData.slug, 1);
if (!ep.HasValue)
{
continue;
}
for (int i = 0; i < ep.Value.totalEp; i++)
{
setData.dubEpisodes.Add(subData.slug);
}
break;
}
}
return(setData);
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
List <RealShiroItem> data = (List <RealShiroItem>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
if (Token == "")
{
error("NO SHIRO TOKEN! AT " + nameof(GetSeasonData));
return(setData);
}
string[] extraData = new string[2];
foreach (var subData in data)
{
if ((setData.DubExists && subData.isDub) || (setData.SubExists && !subData.isDub))
{
continue;
}
bool synoExist = false;
if (subData.synonyms != null && ms.synonyms != null && ms.synonyms.Count > 0 && subData.synonyms.Length > 0)
{
synoExist = ms.synonyms.Where(t => subData.synonyms.Contains(t)).ToArray().Length > 0;
}
if (ToDown(ms.engName) == ToDown(subData.name) || synoExist)
{
List <string> episodes = new List <string>();
string slug = subData.slug;
for (int i = 1; i <= subData.episodes; i++)
{
episodes.Add($"https://tapi.{shiroBase._siteUrl.Replace("https://", "")}/anime-episode/slug/{slug}-episode-{i}?token={Token}");
}
if (subData.isDub)
{
setData.dubEpisodes = episodes;
}
else
{
setData.subEpisodes = episodes;
}
extraData[subData.isDub ? 1 : 0] = slug;
}
}
setData.extraData = extraData;
return(setData);
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
List <string> data = (List <string>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
}
return(setData);
}
public override void GetHasDubSub(MALSeason data, out bool dub, out bool sub)
{
var _data = GetData(data, out bool suc);
if (suc)
{
dub = _data.DubExists;
sub = _data.SubExists;
}
else
{
dub = false;
sub = false;
}
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
YuSearchItems[] data = (YuSearchItems[])storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
if (baseProvider == null)
{
return(setData);
}
int index = 0;
foreach (var subData in data)
{
string toDownTitle = ToDown(subData.fields.title);
if (index < 2 || ToDown(ms.name) == toDownTitle || ToDown(ms.engName) == toDownTitle || ToDown(ms.japName) == toDownTitle) // CAN BE REMOVED, BUT MIGHT BE BLOCKED DUE TO MANY REQUESTS
{
var info = baseProvider.GetYuInfo(subData.pk, subData.fields.slug);
if (!GetThredActive(tempThread))
{
return(setData);
}
if (info.HasValue)
{
var infoVal = info.Value;
if (infoVal.malId == ms.MalId)
{
for (int i = 0; i < infoVal.subbedEps; i++)
{
setData.subEpisodes.Add($"https://yugenani.me/watch/{subData.pk}/{subData.fields.slug}/{(i + 1)}/");
}
for (int i = 0; i < infoVal.dubbedEps; i++)
{
setData.dubEpisodes.Add($"https://yugenani.me/watch/{subData.pk}/{subData.fields.slug}-dub/{(i + 1)}/");
}
return(setData);
}
}
}
index++;
}
return(setData);
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
AnimeFeverHelper.AnimeFeverSearchInfo data = (AnimeFeverHelper.AnimeFeverSearchInfo)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data.data)
{
if (subData.name == ms.engName || subData.alt_name == ms.engName)
{
try {
var mainInfo = helper.GetAnimeFeverEpisodeInfo(subData.id, subData.slug);
if (mainInfo == null)
{
continue;
}
var _mainInfo = mainInfo.Value;
var emtyList = new string[_mainInfo.data.Count].ToList();
var referers = new string[_mainInfo.data.Count];
int index = 0;
setData.dubEpisodes = emtyList;
setData.subEpisodes = emtyList;
foreach (var epInfo in _mainInfo.data)
{
var langs = epInfo.video_meta.audio_languages;
if (langs.Contains("eng"))
{
setData.dubEpisodes[index] = (epInfo.id.ToString());
}
if (langs.Contains("jap"))
{
setData.subEpisodes[index] = (epInfo.id.ToString());
}
referers[index] = $"https://www.animefever.tv/series/{subData.id}-{subData.slug}/episode/{epInfo.id}-episode-{index+1}-{epInfo.slug}";
print("ANIMEFEVER REFERER: " + referers[index]);
index++;
}
setData.extraData = referers;
}
catch (Exception) { }
}
}
return(setData);
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
if (storedData == null)
{
return(new NonBloatSeasonData());
}
List <NineAnimeDataSearch> data = (List <NineAnimeDataSearch>)storedData;
if (data.Count == 0)
{
return(new NonBloatSeasonData());
}
print("START:::: " + data.FString());
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
if (subData.names.Split(' ').Contains(ms.japName))
{
bool isDub = subData.isDub;
if (isDub && !setData.dubExists)
{
for (int i = 1; i <= subData.maxEp; i++)
{
setData.dubEpisodes.Add(subData.href);
}
}
else if (!setData.subExists)
{
for (int i = 1; i <= subData.maxEp; i++)
{
setData.subEpisodes.Add(subData.href);
}
}
}
}
return(setData);
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
GenoanimeSearchItem[] data = (GenoanimeSearchItem[])storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
string cName = ToDown(ms.engName);
string[] cSyno = ms.synonyms.Select(t => ToDown(t)).ToArray();
foreach (var subData in data)
{
bool isDub = subData.name.Contains(" (Dub)");
string name = subData.name.Replace(" (Dub)", "");
string dName = ToDown(name);
if (dName == cName || cSyno.Contains(dName))
{
if ((!setData.DubExists && isDub) || (!setData.SubExists && !isDub))
{
string d = DownloadString("https://genoanime.com" + subData.link[1..]);
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
ArrayAnimeSearchResult[] data = (ArrayAnimeSearchResult[])storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
bool isDub = subData.title.Contains(" (Dub)");
if ((!setData.SubExists && !isDub) || (!setData.DubExists && isDub))
{
string realTitle = subData.title.Replace(" (Dub)", "");
string realDownTitle = ToDown(realTitle);
bool synoExist = false;
if (ms.synonyms != null && ms.synonyms.Count > 0)
{
foreach (var syno in ms.synonyms)
{
if (ToDown(syno) == realDownTitle)
{
synoExist = true;
break;
}
}
}
if (ToDown(ms.engName) == realDownTitle || synoExist)
{
try {
string d = DownloadString("https://arrayanimeapi.vercel.app/api/details/" + subData.id, tempThread, referer: "https://www.arrayanime.com/");
if (d.IsClean())
{
ArrayAnimeItemResultRoot itemRoot = JsonConvert.DeserializeObject <ArrayAnimeItemResultRoot>(d);
if (itemRoot.results != null && itemRoot.results.Length > 0)
{
int totalEpisodes = int.Parse(itemRoot.results[0].totalepisode);
List <string> episodes = new List <string>(totalEpisodes);
for (int i = 0; i < totalEpisodes; i++)
{
episodes.Add($"https://t-arrayapi.vercel.app/api/watching/{subData.id}/{(i + 1)}");
}
if (isDub)
{
setData.dubEpisodes = episodes;
}
else
{
setData.subEpisodes = episodes;
}
}
}
}
catch (System.Exception _ex) {
error(_ex);
}
}
}
}
return(setData);
}
public virtual NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
throw new NotImplementedException();
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
try {
List <FourAnimeQuickSearchItem> data = (List <FourAnimeQuickSearchItem>)storedData;
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
foreach (var subData in data)
{
var _title = ToLowerAndReplace(subData.title);
if ((ms.Year == -1 || (subData.year == ms.Year.ToString())) && (
_title == ToLowerAndReplace(ms.engName) ||
_title == ToLowerAndReplace(ms.name) ||
ms.synonyms.Select(t => ToLowerAndReplace(t)).Contains(_title))) // CHECK
{
string url = subData.href;
string d = DownloadString(url, tempThread);
if (!d.IsClean())
{
continue;
}
bool isSub = d.Contains("/language/subbed"); // There is some dubbed anime
if ((isSub && !setData.SubExists) || (!isSub && !setData.DubExists)) // To prevent duplicates, first result if often right
{
try {
var doc = new HtmlAgilityPack.HtmlDocument();
doc.LoadHtml(d);
var episodes = doc.QuerySelectorAll("ul.episodes.range.active > li > a");
List <FourAnimeEpisode> localEpisodes = new List <FourAnimeEpisode>();
foreach (var f in episodes) // This is to really make sure no offset happends, if for some reason some episode is misson
{
int.TryParse(f.InnerText, out int ep);
if (ep > 0)
{
localEpisodes.Add(new FourAnimeEpisode()
{
episode = ep,
href = f.GetAttributeValue("href", "")
});
}
}
if (localEpisodes.Count == 0)
{
continue;
}
int maxEp = localEpisodes.OrderBy(t => - t.episode).First().episode;
var list = new string[maxEp].ToList();
foreach (var item in localEpisodes)
{
list[item.episode - 1] = item.href;
}
if (isSub)
{
setData.subEpisodes = list;
}
else
{
setData.dubEpisodes = list;
}
}
catch (Exception _ex) {
error(_ex);
}
}
}
}
return(setData);
}
catch (Exception _ex) {
error("Fatal Ex in 4Anime Getseason: " + _ex);
return(new NonBloatSeasonData());
}
}
public override NonBloatSeasonData GetSeasonData(MALSeason ms, TempThread tempThread, string year, object storedData)
{
NonBloatSeasonData setData = new NonBloatSeasonData()
{
dubEpisodes = new List <string>(), subEpisodes = new List <string>()
};
try {
string name = ms.name;
var list = (List <TheMovieTitle>)storedData;
string compare = ToDown(name, true, "");
var end = list.Where(t => (t.href.Contains("/anime-info/")) && ToDown(t.name, true, "") == compare).OrderBy(t => { FuzzyMatch(t.name, name, out int score); return(-score); }).ToArray();
bool subExists = false;
bool dubExists = false;
string subUrl = "";
string dubUrl = "";
for (int k = 0; k < end.Length; k++)
{
if (!subExists && !end[k].isDub)
{
subExists = true;
subUrl = end[k].href;
}
if (!dubExists && end[k].isDub)
{
dubExists = true;
dubUrl = end[k].href;
}
}
try {
int maxSubbedEp = subExists ? TheMovieHelper.GetMaxEp(DownloadString(subUrl), subUrl) : 0;
if (!GetThredActive(tempThread))
{
return(setData);
}
; // COPY UPDATE PROGRESS
int maxDubbedEp = dubExists ? TheMovieHelper.GetMaxEp(DownloadString(dubUrl), dubUrl) : 0;
if (!GetThredActive(tempThread))
{
return(setData);
}
; // COPY UPDATE PROGRESS
for (int i = 0; i < maxDubbedEp; i++)
{
setData.dubEpisodes.Add(dubUrl);
}
for (int i = 0; i < maxSubbedEp; i++)
{
setData.subEpisodes.Add(subUrl);
}
return(setData);
}
catch (Exception _ex) {
print("ANIME ERROROROROOR.::" + _ex);
return(setData);
}
}
catch (Exception) {
return(setData);
}
}
