617 lines
23 KiB
C#
617 lines
23 KiB
C#
using HtmlAgilityPack;
|
||
using Shared.Engine.RxEnumerate;
|
||
using Shared.Models.Base;
|
||
using Shared.Models.Online.Kodik;
|
||
using Shared.Models.Online.Settings;
|
||
using Shared.Models.Templates;
|
||
using System.Collections.Concurrent;
|
||
using System.Text;
|
||
using System.Text.RegularExpressions;
|
||
using System.Web;
|
||
|
||
namespace Shared.Engine.Online
|
||
{
|
||
public struct KodikInvoke
|
||
{
|
||
#region KodikInvoke
|
||
static readonly ConcurrentDictionary<string, string> psingles = new ();
|
||
static readonly IHybridCache hybridCache = IHybridCache.Get(null);
|
||
readonly IEnumerable<Result> fallbackDatabase;
|
||
|
||
string host;
|
||
string apihost, token, videopath;
|
||
bool usehls, cdn_is_working;
|
||
HttpHydra httpHydra;
|
||
Func<string, string> onstreamfile;
|
||
Action requesterror;
|
||
|
||
public KodikInvoke(string host, KodikSettings init, string videopath, IEnumerable<Result> fallbackDatabase, HttpHydra httpHydra, Func<string, string> onstreamfile, Action requesterror = null)
|
||
{
|
||
this.host = host != null ? $"{host}/" : null;
|
||
this.apihost = init.apihost;
|
||
this.token = init.token;
|
||
this.videopath = videopath;
|
||
this.fallbackDatabase = fallbackDatabase;
|
||
this.httpHydra = httpHydra;
|
||
this.onstreamfile = onstreamfile;
|
||
this.usehls = init.hls;
|
||
this.cdn_is_working = init.cdn_is_working;
|
||
this.requesterror = requesterror;
|
||
}
|
||
#endregion
|
||
|
||
#region Embed
|
||
async public Task<List<Result>> Embed(string imdb_id, long kinopoisk_id, int s)
|
||
{
|
||
if (string.IsNullOrEmpty(imdb_id) && kinopoisk_id == 0)
|
||
return null;
|
||
|
||
List<Result> results = null;
|
||
|
||
if (!string.IsNullOrWhiteSpace(token))
|
||
{
|
||
string url = $"{apihost}/search?token={token}&limit=100&with_episodes=true";
|
||
if (kinopoisk_id > 0)
|
||
url += $"&kinopoisk_id={kinopoisk_id}";
|
||
|
||
if (!string.IsNullOrWhiteSpace(imdb_id))
|
||
url += $"&imdb_id={imdb_id}";
|
||
|
||
if (s > 0)
|
||
url += $"&season={s}";
|
||
|
||
var root = await httpHydra.Get<RootObject>(url, safety: true);
|
||
if (root?.results != null)
|
||
results = root.results;
|
||
else
|
||
requesterror?.Invoke();
|
||
}
|
||
|
||
if (results == null)
|
||
results = FallbackByIds(imdb_id, kinopoisk_id, s);
|
||
|
||
return results;
|
||
}
|
||
|
||
|
||
public async Task<EmbedModel> Embed(string title, string original_title, int clarification)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(title) && string.IsNullOrEmpty(original_title))
|
||
return null;
|
||
|
||
List<Result> results = null;
|
||
|
||
if (!string.IsNullOrWhiteSpace(token))
|
||
{
|
||
string url = $"{apihost}/search?token={token}&limit=100&title={HttpUtility.UrlEncode(original_title ?? title)}&with_episodes=true&with_material_data=true";
|
||
|
||
var root = await httpHydra.Get<RootObject>(url, safety: true);
|
||
if (root?.results != null)
|
||
results = root.results;
|
||
else
|
||
requesterror?.Invoke();
|
||
}
|
||
|
||
if (results == null)
|
||
results = FallbackByTitle(title, original_title);
|
||
|
||
if (results == null)
|
||
return null;
|
||
|
||
var hash = new HashSet<string>(20);
|
||
var stpl = new SimilarTpl(results.Count);
|
||
string enc_title = HttpUtility.UrlEncode(title);
|
||
string enc_original_title = HttpUtility.UrlEncode(original_title);
|
||
|
||
foreach (var similar in results)
|
||
{
|
||
string pick = similar.title?.ToLowerAndTrim();
|
||
if (string.IsNullOrEmpty(pick))
|
||
continue;
|
||
|
||
if (hash.Contains(pick))
|
||
continue;
|
||
|
||
hash.Add(pick);
|
||
|
||
string name = !string.IsNullOrEmpty(similar.title) && !string.IsNullOrEmpty(similar.title_orig) ? $"{similar.title} / {similar.title_orig}" : (similar.title ?? similar.title_orig);
|
||
|
||
string details = similar.translation.title;
|
||
if (similar.last_season > 0)
|
||
details += $"{SimilarTpl.OnlineSplit} {similar.last_season}й сезон";
|
||
|
||
var matd = similar.material_data;
|
||
string img = PosterApi.Size(matd.anime_poster_url ?? matd.drama_poster_url ?? matd.poster_url);
|
||
stpl.Append(name, similar.year?.ToString(), details, host + $"lite/kodik?title={enc_title}&original_title={enc_original_title}&clarification={clarification}&pick={HttpUtility.UrlEncode(pick)}", img);
|
||
}
|
||
|
||
return new EmbedModel()
|
||
{
|
||
stpl = stpl,
|
||
result = results
|
||
};
|
||
}
|
||
catch { return null; }
|
||
}
|
||
|
||
public List<Result> Embed(List<Result> results, string pick)
|
||
{
|
||
var content = new List<Result>(results.Count);
|
||
|
||
foreach (var i in results)
|
||
{
|
||
if (i.title == null || i.title.ToLowerAndTrim() != pick)
|
||
continue;
|
||
|
||
content.Add(i);
|
||
}
|
||
|
||
return content;
|
||
}
|
||
#endregion
|
||
|
||
#region VideoParse
|
||
async public Task<List<StreamModel>> VideoParse(string linkhost, string link)
|
||
{
|
||
List<StreamModel> streams = null;
|
||
|
||
string player_single = null;
|
||
string domain = null, d_sign = null, pd = null, pd_sign = null, ref_domain = null, ref_sign = null, type = null, hash = null, id = null;
|
||
|
||
await httpHydra.GetSpan($"https:{link}", iframe =>
|
||
{
|
||
player_single = Rx.Match(iframe, "src=\"/(assets/js/app\\.player_[^\"]+\\.js)\"");
|
||
|
||
var advertDebug = Rx.Split("advertDebug", iframe);
|
||
if (advertDebug.Count > 1)
|
||
{
|
||
var preview = Rx.Split("preview-icons", advertDebug[1].Span);
|
||
if (preview.Count > 0)
|
||
{
|
||
string _frame = Regex.Replace(preview[0].ToString(), "[\n\r\t ]+", "");
|
||
domain = Regex.Match(_frame, "domain=\"([^\"]+)\"").Groups[1].Value;
|
||
d_sign = Regex.Match(_frame, "d_sign=\"([^\"]+)\"").Groups[1].Value;
|
||
pd = Regex.Match(_frame, "pd=\"([^\"]+)\"").Groups[1].Value;
|
||
pd_sign = Regex.Match(_frame, "pd_sign=\"([^\"]+)\"").Groups[1].Value;
|
||
ref_domain = Regex.Match(_frame, "ref=\"([^\"]+)\"").Groups[1].Value;
|
||
ref_sign = Regex.Match(_frame, "ref_sign=\"([^\"]+)\"").Groups[1].Value;
|
||
type = Regex.Match(_frame, "videoInfo.type='([^']+)'").Groups[1].Value;
|
||
hash = Regex.Match(_frame, "videoInfo.hash='([^']+)'").Groups[1].Value;
|
||
id = Regex.Match(_frame, "videoInfo.id='([^']+)'").Groups[1].Value;
|
||
}
|
||
}
|
||
});
|
||
|
||
if (string.IsNullOrEmpty(domain) || string.IsNullOrEmpty(player_single))
|
||
{
|
||
requesterror?.Invoke();
|
||
return null;
|
||
}
|
||
|
||
string uri = null;
|
||
if (!psingles.TryGetValue(player_single, out uri))
|
||
{
|
||
await httpHydra.GetSpan($"{linkhost}/{player_single}", playerjs =>
|
||
{
|
||
uri = DecodeUrlBase64(Rx.Match(playerjs, "type:\"POST\",url:atob\\(\"([^\"]+)\"\\)"));
|
||
if (!string.IsNullOrEmpty(uri))
|
||
psingles.TryAdd(player_single, uri);
|
||
});
|
||
}
|
||
|
||
if (string.IsNullOrEmpty(uri))
|
||
{
|
||
requesterror?.Invoke();
|
||
return null;
|
||
}
|
||
|
||
bool _usehls = usehls;
|
||
|
||
await httpHydra.PostSpan($"{linkhost + uri}", $"d={domain}&d_sign={d_sign}&pd={pd}&pd_sign={pd_sign}&ref={ref_domain}&ref_sign={ref_sign}&bad_user=false&cdn_is_working={cdn_is_working.ToString().ToLower()}&type={type}&hash={hash}&id={id}&info=%7B%7D", json =>
|
||
{
|
||
var rx = Rx.Matches("\"([0-9]+)p?\":\\[\\{\"src\":\"([^\"]+)", json);
|
||
if (rx.Count == 0)
|
||
return;
|
||
|
||
streams = new List<StreamModel>(rx.Count);
|
||
|
||
foreach (var row in rx.Rows())
|
||
{
|
||
var g = row.Groups();
|
||
|
||
if (!string.IsNullOrWhiteSpace(g[2].Value))
|
||
{
|
||
string m3u = g[2].Value;
|
||
if (!m3u.Contains("manifest.m3u8"))
|
||
{
|
||
int zCharCode = Convert.ToInt32('Z');
|
||
|
||
string src = Regex.Replace(g[2].Value, "[a-zA-Z]", e =>
|
||
{
|
||
int eCharCode = Convert.ToInt32(e.Value[0]);
|
||
return ((eCharCode <= zCharCode ? 90 : 122) >= (eCharCode = eCharCode + 18) ? (char)eCharCode : (char)(eCharCode - 26)).ToString();
|
||
});
|
||
|
||
m3u = DecodeUrlBase64(src);
|
||
}
|
||
|
||
if (m3u.StartsWith("//"))
|
||
m3u = $"https:{m3u}";
|
||
|
||
if (!_usehls && m3u.Contains(".m3u"))
|
||
m3u = m3u.Replace(":hls:manifest.m3u8", "");
|
||
|
||
streams.Add(new StreamModel() { q = $"{g[1].Value}p", url = m3u });
|
||
}
|
||
}
|
||
});
|
||
|
||
if (streams == null || streams.Count == 0)
|
||
{
|
||
requesterror?.Invoke();
|
||
return null;
|
||
}
|
||
|
||
streams.Reverse();
|
||
|
||
return streams;
|
||
}
|
||
|
||
public string VideoParse(List<StreamModel> streams, string title, string original_title, int episode, bool play, VastConf vast = null)
|
||
{
|
||
if (streams == null || streams.Count == 0)
|
||
return string.Empty;
|
||
|
||
if (play)
|
||
return onstreamfile(streams[0].url);
|
||
|
||
string name = title ?? original_title ?? "auto";
|
||
if (episode > 0)
|
||
name += $" ({episode} серия)";
|
||
|
||
var streamquality = new StreamQualityTpl();
|
||
foreach (var l in streams)
|
||
streamquality.Append(onstreamfile(l.url), l.q);
|
||
|
||
return VideoTpl.ToJson("play", onstreamfile(streams[0].url), name, streamquality: streamquality, vast: vast);
|
||
}
|
||
#endregion
|
||
|
||
#region Tpl
|
||
public async Task<ITplResult> Tpl(List<Result> results, string args, string imdb_id, long kinopoisk_id, string title, string original_title, int clarification, string pick, string kid, int s, bool showstream, bool rjson)
|
||
{
|
||
string enc_title = HttpUtility.UrlEncode(title);
|
||
string enc_original_title = HttpUtility.UrlEncode(original_title);
|
||
|
||
if (results[0].type is "foreign-movie" or "soviet-cartoon" or "foreign-cartoon" or "russian-cartoon" or "anime" or "russian-movie")
|
||
{
|
||
#region Фильм
|
||
var mtpl = new MovieTpl(title, original_title, results.Count);
|
||
|
||
foreach (var data in results)
|
||
{
|
||
string url = host + $"lite/kodik/video?title={enc_title}&original_title={enc_original_title}&link={HttpUtility.UrlEncode(data.link)}";
|
||
|
||
string streamlink = null;
|
||
if (showstream)
|
||
{
|
||
streamlink = usehls ? $"{url.Replace("/video", $"/{videopath}.m3u8")}&play=true" : $"{url.Replace("/video", $"/{videopath}")}&play=true";
|
||
|
||
if (!string.IsNullOrEmpty(args))
|
||
streamlink += $"&{args.Remove(0, 1)}";
|
||
}
|
||
|
||
mtpl.Append(data.translation.title, url, "call", streamlink);
|
||
}
|
||
|
||
return mtpl;
|
||
#endregion
|
||
}
|
||
else
|
||
{
|
||
#region Сериал
|
||
string enc_pick = HttpUtility.UrlEncode(pick);
|
||
|
||
if (s == -1)
|
||
{
|
||
var tpl = new SeasonTpl(results.Count);
|
||
var hash = new HashSet<int>();
|
||
|
||
foreach (var item in results.AsEnumerable().Reverse())
|
||
{
|
||
int season = item.last_season;
|
||
string link = host + $"lite/kodik?rjson={rjson}&imdb_id={imdb_id}&kinopoisk_id={kinopoisk_id}&title={enc_title}&original_title={enc_original_title}&clarification={clarification}&pick={enc_pick}&s={season}";
|
||
|
||
if (hash.Contains(season))
|
||
continue;
|
||
|
||
hash.Add(season);
|
||
tpl.Append($"{season} сезон", link, season);
|
||
}
|
||
|
||
return tpl;
|
||
}
|
||
else
|
||
{
|
||
#region Перевод
|
||
var vtpl = new VoiceTpl();
|
||
HashSet<string> hash = new HashSet<string>();
|
||
|
||
foreach (var item in results)
|
||
{
|
||
string id = item.id;
|
||
if (string.IsNullOrEmpty(id))
|
||
continue;
|
||
|
||
string name = item.translation.title ?? "оригинал";
|
||
if (hash.Contains(name))
|
||
continue;
|
||
|
||
if (item.last_season != s)
|
||
{
|
||
if (item.seasons == null || !item.seasons.ContainsKey(s.ToString()))
|
||
continue;
|
||
}
|
||
|
||
hash.Add(name);
|
||
|
||
if (string.IsNullOrEmpty(kid))
|
||
kid = id;
|
||
|
||
string link = host + $"lite/kodik?rjson={rjson}&imdb_id={imdb_id}&kinopoisk_id={kinopoisk_id}&title={enc_title}&original_title={enc_original_title}&clarification={clarification}&pick={enc_pick}&s={s}&kid={id}";
|
||
|
||
vtpl.Append(name, kid == id, link);
|
||
}
|
||
#endregion
|
||
|
||
var selected = results.FirstOrDefault(i => i.id == kid);
|
||
if (string.IsNullOrEmpty(selected.id))
|
||
selected = results[0];
|
||
|
||
var series = await ResolveEpisodesAsync(selected, s);
|
||
if (series == null || series.Count == 0)
|
||
return default;
|
||
|
||
var etpl = new EpisodeTpl(vtpl, series.Count);
|
||
|
||
string sArhc = s.ToString();
|
||
|
||
foreach (var episode in series)
|
||
{
|
||
string url = host + $"lite/kodik/video?title={enc_title}&original_title={enc_original_title}&link={HttpUtility.UrlEncode(episode.Value)}&episode={episode.Key}";
|
||
|
||
string streamlink = null;
|
||
if (showstream)
|
||
{
|
||
streamlink = usehls ? $"{url.Replace("/video", $"/{videopath}.m3u8")}&play=true" : $"{url.Replace("/video", $"/{videopath}")}&play=true";
|
||
|
||
if (!string.IsNullOrEmpty(args))
|
||
streamlink += $"&{args.Remove(0, 1)}";
|
||
}
|
||
|
||
etpl.Append($"{episode.Key} серия", title ?? original_title, sArhc, episode.Key, url, "call", streamlink: streamlink);
|
||
}
|
||
|
||
return etpl;
|
||
}
|
||
#endregion
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region DecodeUrlBase64
|
||
static string DecodeUrlBase64(string s)
|
||
{
|
||
if (s == null)
|
||
return s;
|
||
|
||
return Encoding.UTF8.GetString(Convert.FromBase64String(s.Replace('-', '+').Replace('_', '/').PadRight(4 * ((s.Length + 3) / 4), '=')));
|
||
}
|
||
#endregion
|
||
|
||
|
||
#region [Codex AI] - db.json
|
||
List<Result> FallbackByIds(string imdb_id, long kinopoisk_id, int season)
|
||
{
|
||
var data = fallbackDatabase;
|
||
if (data == null)
|
||
return null;
|
||
|
||
bool requireImdb = !string.IsNullOrEmpty(imdb_id);
|
||
bool requireKinopoisk = kinopoisk_id > 0;
|
||
|
||
var matches = data.Where(item =>
|
||
{
|
||
bool imdbMatch = !requireImdb || string.Equals(item.imdb_id, imdb_id, StringComparison.OrdinalIgnoreCase);
|
||
bool kinopoiskMatch = !requireKinopoisk || item.kinopoisk_id == kinopoisk_id.ToString();
|
||
return imdbMatch && kinopoiskMatch;
|
||
}).ToList();
|
||
|
||
if (matches.Count == 0)
|
||
return null;
|
||
|
||
return matches.Count == 0 ? null : matches;
|
||
}
|
||
|
||
List<Result> FallbackByTitle(string title, string originalTitle)
|
||
{
|
||
var data = fallbackDatabase;
|
||
if (data == null)
|
||
return null;
|
||
|
||
bool hasTitle = !string.IsNullOrWhiteSpace(title);
|
||
bool hasOriginal = !string.IsNullOrWhiteSpace(originalTitle);
|
||
|
||
var strictMatches = new List<Result>();
|
||
List<Result> fallbackMatches = (hasTitle || hasOriginal) ? new List<Result>() : null;
|
||
|
||
foreach (var item in data)
|
||
{
|
||
bool titleMatch = !hasTitle || TitleMatches(item.title, title) || TitleMatches(item.title_orig, title);
|
||
bool originalMatch = !hasOriginal || TitleMatches(item.title, originalTitle) || TitleMatches(item.title_orig, originalTitle);
|
||
|
||
if (titleMatch && originalMatch)
|
||
{
|
||
strictMatches.Add(item);
|
||
continue;
|
||
}
|
||
|
||
if (fallbackMatches == null)
|
||
continue;
|
||
|
||
if (TitleMatches(item.title, title) ||
|
||
TitleMatches(item.title_orig, title) ||
|
||
TitleMatches(item.title, originalTitle) ||
|
||
TitleMatches(item.title_orig, originalTitle))
|
||
{
|
||
fallbackMatches.Add(item);
|
||
}
|
||
}
|
||
|
||
var matches = strictMatches.Count > 0 ? strictMatches : fallbackMatches;
|
||
|
||
return matches == null || matches.Count == 0 ? null : matches;
|
||
}
|
||
|
||
static bool TitleMatches(string source, string target)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(source) || string.IsNullOrWhiteSpace(target))
|
||
return false;
|
||
|
||
string normalizedSource = StringConvert.SearchName(source);
|
||
string normalizedTarget = StringConvert.SearchName(target);
|
||
|
||
if (string.IsNullOrWhiteSpace(normalizedSource) || string.IsNullOrWhiteSpace(normalizedTarget))
|
||
return false;
|
||
|
||
return normalizedSource.Contains(normalizedTarget);
|
||
}
|
||
|
||
async Task<Dictionary<string, string>> ResolveEpisodesAsync(Result selected, int season)
|
||
{
|
||
if (season <= 0)
|
||
return null;
|
||
|
||
string seasonKey = season.ToString();
|
||
|
||
if (selected.seasons != null &&
|
||
selected.seasons.TryGetValue(seasonKey, out var seasonInfo) &&
|
||
seasonInfo.episodes != null &&
|
||
seasonInfo.episodes.Count > 0)
|
||
{
|
||
return seasonInfo.episodes;
|
||
}
|
||
|
||
var seasonsFromHtml = await LoadSeasonsFromHtml(selected);
|
||
if (seasonsFromHtml != null &&
|
||
seasonsFromHtml.TryGetValue(seasonKey, out seasonInfo) &&
|
||
seasonInfo.episodes != null &&
|
||
seasonInfo.episodes.Count > 0)
|
||
{
|
||
return seasonInfo.episodes;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
async Task<Dictionary<string, Season>> LoadSeasonsFromHtml(Result selected)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(selected.id) || string.IsNullOrWhiteSpace(selected.link) || httpHydra == null)
|
||
return null;
|
||
|
||
string cacheKey = $"kodik:series:{selected.id}";
|
||
if (hybridCache.TryGetValue(cacheKey, out Dictionary<string, Season> cached))
|
||
return cached;
|
||
|
||
try
|
||
{
|
||
string html = await httpHydra.Get($"https:{selected.link}");
|
||
if (string.IsNullOrWhiteSpace(html))
|
||
{
|
||
requesterror?.Invoke();
|
||
return null;
|
||
}
|
||
|
||
var doc = new HtmlDocument();
|
||
doc.LoadHtml(html);
|
||
|
||
var optionsRoot = doc.DocumentNode.SelectSingleNode("//div[contains(@class,'series-options')]");
|
||
if (optionsRoot == null)
|
||
return null;
|
||
|
||
var seasons = new Dictionary<string, Season>();
|
||
|
||
var seasonNodes = optionsRoot.SelectNodes(".//div[contains(@class,'season-')]");
|
||
if (seasonNodes == null)
|
||
return null;
|
||
|
||
foreach (var seasonNode in seasonNodes)
|
||
{
|
||
string classes = seasonNode.GetAttributeValue("class", string.Empty);
|
||
var match = Regex.Match(classes, "season-([0-9]+)");
|
||
if (!match.Success)
|
||
continue;
|
||
|
||
string seasonKey = match.Groups[1].Value;
|
||
if (string.IsNullOrEmpty(seasonKey))
|
||
continue;
|
||
|
||
var options = seasonNode.SelectNodes(".//option");
|
||
if (options == null || options.Count == 0)
|
||
continue;
|
||
|
||
var episodes = new Dictionary<string, string>();
|
||
|
||
foreach (var option in options)
|
||
{
|
||
string episodeNumber = option.GetAttributeValue("value", null) ?? option.InnerText;
|
||
episodeNumber = episodeNumber?.Trim();
|
||
if (string.IsNullOrEmpty(episodeNumber))
|
||
continue;
|
||
|
||
string episodeLink = BuildEpisodeLink(option);
|
||
if (string.IsNullOrEmpty(episodeLink))
|
||
continue;
|
||
|
||
if (!episodes.ContainsKey(episodeNumber))
|
||
episodes[episodeNumber] = episodeLink;
|
||
}
|
||
|
||
if (episodes.Count > 0)
|
||
{
|
||
seasons[seasonKey] = new Season
|
||
{
|
||
link = selected.link,
|
||
episodes = episodes
|
||
};
|
||
}
|
||
}
|
||
|
||
if (seasons.Count == 0)
|
||
return null;
|
||
|
||
hybridCache.Set(cacheKey, seasons, TimeSpan.FromMinutes(20));
|
||
return seasons;
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
static string BuildEpisodeLink(HtmlNode option)
|
||
{
|
||
string dataId = option.GetAttributeValue("data-id", null);
|
||
string dataHash = option.GetAttributeValue("data-hash", null);
|
||
|
||
if (string.IsNullOrWhiteSpace(dataId) || string.IsNullOrWhiteSpace(dataHash))
|
||
return null;
|
||
|
||
return $"//kodik.info/seria/{dataId}/{dataHash}/720p";
|
||
}
|
||
#endregion
|
||
}
|
||
}
|