384 lines
14 KiB
C#
384 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Google.Apis.YouTube.v3;
|
|
using Google.Apis.Services;
|
|
using System.Text.RegularExpressions;
|
|
using Google.Apis.Urlshortener.v1;
|
|
using Google.Apis.Urlshortener.v1.Data;
|
|
using NLog;
|
|
using Google.Apis.Customsearch.v1;
|
|
using System.Net.Http;
|
|
using System.Net;
|
|
using Newtonsoft.Json.Linq;
|
|
using NadekoBot.Extensions;
|
|
|
|
namespace NadekoBot.Services.Impl
|
|
{
|
|
public class GoogleApiService : IGoogleApiService
|
|
{
|
|
const string search_engine_id = "018084019232060951019:hs5piey28-e";
|
|
|
|
private YouTubeService yt;
|
|
private UrlshortenerService sh;
|
|
private CustomsearchService cs;
|
|
|
|
private Logger _log { get; }
|
|
|
|
public GoogleApiService(IBotCredentials creds)
|
|
{
|
|
_creds = creds;
|
|
|
|
var bcs = new BaseClientService.Initializer
|
|
{
|
|
ApplicationName = "Nadeko Bot",
|
|
ApiKey = _creds.GoogleApiKey,
|
|
};
|
|
|
|
_log = LogManager.GetCurrentClassLogger();
|
|
|
|
yt = new YouTubeService(bcs);
|
|
sh = new UrlshortenerService(bcs);
|
|
cs = new CustomsearchService(bcs);
|
|
}
|
|
private static readonly Regex plRegex = new Regex("(?:youtu\\.be\\/|list=)(?<id>[\\da-zA-Z\\-_]*)", RegexOptions.Compiled);
|
|
public async Task<IEnumerable<string>> GetPlaylistIdsByKeywordsAsync(string keywords, int count = 1)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(keywords))
|
|
throw new ArgumentNullException(nameof(keywords));
|
|
|
|
if (count <= 0)
|
|
throw new ArgumentOutOfRangeException(nameof(count));
|
|
|
|
var match = plRegex.Match(keywords);
|
|
if (match.Length > 1)
|
|
{
|
|
return new[] { match.Groups["id"].Value.ToString() };
|
|
}
|
|
var query = yt.Search.List("snippet");
|
|
query.MaxResults = count;
|
|
query.Type = "playlist";
|
|
query.Q = keywords;
|
|
|
|
return (await query.ExecuteAsync()).Items.Select(i => i.Id.PlaylistId);
|
|
}
|
|
|
|
//private readonly Regex YtVideoIdRegex = new Regex(@"(?:youtube\.com\/\S*(?:(?:\/e(?:mbed))?\/|watch\?(?:\S*?&?v\=))|youtu\.be\/)(?<id>[a-zA-Z0-9_-]{6,11})", RegexOptions.Compiled);
|
|
private readonly IBotCredentials _creds;
|
|
|
|
public async Task<IEnumerable<string>> GetRelatedVideosAsync(string id, int count = 1)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(id))
|
|
throw new ArgumentNullException(nameof(id));
|
|
|
|
if (count <= 0)
|
|
throw new ArgumentOutOfRangeException(nameof(count));
|
|
var query = yt.Search.List("snippet");
|
|
query.MaxResults = count;
|
|
query.RelatedToVideoId = id;
|
|
query.Type = "video";
|
|
return (await query.ExecuteAsync()).Items.Select(i => "http://www.youtube.com/watch?v=" + i.Id.VideoId);
|
|
}
|
|
|
|
public async Task<IEnumerable<string>> GetVideoLinksByKeywordAsync(string keywords, int count = 1)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(keywords))
|
|
throw new ArgumentNullException(nameof(keywords));
|
|
|
|
if (count <= 0)
|
|
throw new ArgumentOutOfRangeException(nameof(count));
|
|
|
|
var query = yt.Search.List("snippet");
|
|
query.MaxResults = count;
|
|
query.Q = keywords;
|
|
query.Type = "video";
|
|
return (await query.ExecuteAsync()).Items.Select(i => "http://www.youtube.com/watch?v=" + i.Id.VideoId);
|
|
}
|
|
|
|
public async Task<IEnumerable<(string Name, string Id, string Url)>> GetVideoInfosByKeywordAsync(string keywords, int count = 1)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(keywords))
|
|
throw new ArgumentNullException(nameof(keywords));
|
|
|
|
if (count <= 0)
|
|
throw new ArgumentOutOfRangeException(nameof(count));
|
|
|
|
var query = yt.Search.List("snippet");
|
|
query.MaxResults = count;
|
|
query.Q = keywords;
|
|
query.Type = "video";
|
|
return (await query.ExecuteAsync()).Items.Select(i => (i.Snippet.Title.TrimTo(50), i.Id.VideoId, "http://www.youtube.com/watch?v=" + i.Id.VideoId));
|
|
}
|
|
|
|
public async Task<string> ShortenUrl(string url)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(url))
|
|
throw new ArgumentNullException(nameof(url));
|
|
|
|
if (string.IsNullOrWhiteSpace(_creds.GoogleApiKey))
|
|
return url;
|
|
|
|
try
|
|
{
|
|
var response = await sh.Url.Insert(new Url { LongUrl = url }).ExecuteAsync();
|
|
return response.Id;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_log.Warn(ex);
|
|
return url;
|
|
}
|
|
}
|
|
|
|
public async Task<IEnumerable<string>> GetPlaylistTracksAsync(string playlistId, int count = 50)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(playlistId))
|
|
throw new ArgumentNullException(nameof(playlistId));
|
|
|
|
if (count <= 0)
|
|
throw new ArgumentOutOfRangeException(nameof(count));
|
|
|
|
string nextPageToken = null;
|
|
|
|
List<string> toReturn = new List<string>(count);
|
|
|
|
do
|
|
{
|
|
var toGet = count > 50 ? 50 : count;
|
|
count -= toGet;
|
|
|
|
var query = yt.PlaylistItems.List("contentDetails");
|
|
query.MaxResults = toGet;
|
|
query.PlaylistId = playlistId;
|
|
query.PageToken = nextPageToken;
|
|
|
|
var data = await query.ExecuteAsync();
|
|
|
|
toReturn.AddRange(data.Items.Select(i => i.ContentDetails.VideoId));
|
|
nextPageToken = data.NextPageToken;
|
|
}
|
|
while (count > 0 && !string.IsNullOrWhiteSpace(nextPageToken));
|
|
|
|
return toReturn;
|
|
}
|
|
|
|
public async Task<IReadOnlyDictionary<string, TimeSpan>> GetVideoDurationsAsync(IEnumerable<string> videoIds)
|
|
{
|
|
await Task.Yield();
|
|
var videoIdsList = videoIds as List<string> ?? videoIds.ToList();
|
|
|
|
Dictionary<string, TimeSpan> toReturn = new Dictionary<string, TimeSpan>();
|
|
|
|
if (!videoIdsList.Any())
|
|
return toReturn;
|
|
var toGet = 0;
|
|
var remaining = videoIdsList.Count;
|
|
|
|
do
|
|
{
|
|
toGet = remaining > 50 ? 50 : remaining;
|
|
remaining -= toGet;
|
|
|
|
var q = yt.Videos.List("contentDetails");
|
|
q.Id = string.Join(",", videoIdsList.Take(toGet));
|
|
videoIdsList = videoIdsList.Skip(toGet).ToList();
|
|
var items = (await q.ExecuteAsync().ConfigureAwait(false)).Items;
|
|
foreach (var i in items)
|
|
{
|
|
toReturn.Add(i.Id, System.Xml.XmlConvert.ToTimeSpan(i.ContentDetails.Duration));
|
|
}
|
|
}
|
|
while (remaining > 0);
|
|
|
|
return toReturn;
|
|
}
|
|
|
|
public async Task<ImageResult> GetImageAsync(string query, int start = 1)
|
|
{
|
|
await Task.Yield();
|
|
if (string.IsNullOrWhiteSpace(query))
|
|
throw new ArgumentNullException(nameof(query));
|
|
|
|
var req = cs.Cse.List(query);
|
|
req.Cx = search_engine_id;
|
|
req.Num = 1;
|
|
req.Fields = "items(image(contextLink,thumbnailLink),link)";
|
|
req.SearchType = CseResource.ListRequest.SearchTypeEnum.Image;
|
|
req.Start = start;
|
|
|
|
var search = await req.ExecuteAsync().ConfigureAwait(false);
|
|
|
|
return new ImageResult(search.Items[0].Image, search.Items[0].Link);
|
|
}
|
|
|
|
public IEnumerable<string> Languages => _languageDictionary.Keys.OrderBy(x => x);
|
|
private readonly Dictionary<string, string> _languageDictionary = new Dictionary<string, string>() {
|
|
{ "afrikaans", "af"},
|
|
{ "albanian", "sq"},
|
|
{ "arabic", "ar"},
|
|
{ "armenian", "hy"},
|
|
{ "azerbaijani", "az"},
|
|
{ "basque", "eu"},
|
|
{ "belarusian", "be"},
|
|
{ "bengali", "bn"},
|
|
{ "bulgarian", "bg"},
|
|
{ "catalan", "ca"},
|
|
{ "chinese-traditional", "zh-TW"},
|
|
{ "chinese-simplified", "zh-CN"},
|
|
{ "chinese", "zh-CN"},
|
|
{ "croatian", "hr"},
|
|
{ "czech", "cs"},
|
|
{ "danish", "da"},
|
|
{ "dutch", "nl"},
|
|
{ "english", "en"},
|
|
{ "esperanto", "eo"},
|
|
{ "estonian", "et"},
|
|
{ "filipino", "tl"},
|
|
{ "finnish", "fi"},
|
|
{ "french", "fr"},
|
|
{ "galician", "gl"},
|
|
{ "german", "de"},
|
|
{ "georgian", "ka"},
|
|
{ "greek", "el"},
|
|
{ "haitian Creole", "ht"},
|
|
{ "hebrew", "iw"},
|
|
{ "hindi", "hi"},
|
|
{ "hungarian", "hu"},
|
|
{ "icelandic", "is"},
|
|
{ "indonesian", "id"},
|
|
{ "irish", "ga"},
|
|
{ "italian", "it"},
|
|
{ "japanese", "ja"},
|
|
{ "korean", "ko"},
|
|
{ "lao", "lo"},
|
|
{ "latin", "la"},
|
|
{ "latvian", "lv"},
|
|
{ "lithuanian", "lt"},
|
|
{ "macedonian", "mk"},
|
|
{ "malay", "ms"},
|
|
{ "maltese", "mt"},
|
|
{ "norwegian", "no"},
|
|
{ "persian", "fa"},
|
|
{ "polish", "pl"},
|
|
{ "portuguese", "pt"},
|
|
{ "romanian", "ro"},
|
|
{ "russian", "ru"},
|
|
{ "serbian", "sr"},
|
|
{ "slovak", "sk"},
|
|
{ "slovenian", "sl"},
|
|
{ "spanish", "es"},
|
|
{ "swahili", "sw"},
|
|
{ "swedish", "sv"},
|
|
{ "tamil", "ta"},
|
|
{ "telugu", "te"},
|
|
{ "thai", "th"},
|
|
{ "turkish", "tr"},
|
|
{ "ukrainian", "uk"},
|
|
{ "urdu", "ur"},
|
|
{ "vietnamese", "vi"},
|
|
{ "welsh", "cy"},
|
|
{ "yiddish", "yi"},
|
|
|
|
{ "af", "af"},
|
|
{ "sq", "sq"},
|
|
{ "ar", "ar"},
|
|
{ "hy", "hy"},
|
|
{ "az", "az"},
|
|
{ "eu", "eu"},
|
|
{ "be", "be"},
|
|
{ "bn", "bn"},
|
|
{ "bg", "bg"},
|
|
{ "ca", "ca"},
|
|
{ "zh-tw", "zh-TW"},
|
|
{ "zh-cn", "zh-CN"},
|
|
{ "hr", "hr"},
|
|
{ "cs", "cs"},
|
|
{ "da", "da"},
|
|
{ "nl", "nl"},
|
|
{ "en", "en"},
|
|
{ "eo", "eo"},
|
|
{ "et", "et"},
|
|
{ "tl", "tl"},
|
|
{ "fi", "fi"},
|
|
{ "fr", "fr"},
|
|
{ "gl", "gl"},
|
|
{ "de", "de"},
|
|
{ "ka", "ka"},
|
|
{ "el", "el"},
|
|
{ "ht", "ht"},
|
|
{ "iw", "iw"},
|
|
{ "hi", "hi"},
|
|
{ "hu", "hu"},
|
|
{ "is", "is"},
|
|
{ "id", "id"},
|
|
{ "ga", "ga"},
|
|
{ "it", "it"},
|
|
{ "ja", "ja"},
|
|
{ "ko", "ko"},
|
|
{ "lo", "lo"},
|
|
{ "la", "la"},
|
|
{ "lv", "lv"},
|
|
{ "lt", "lt"},
|
|
{ "mk", "mk"},
|
|
{ "ms", "ms"},
|
|
{ "mt", "mt"},
|
|
{ "no", "no"},
|
|
{ "fa", "fa"},
|
|
{ "pl", "pl"},
|
|
{ "pt", "pt"},
|
|
{ "ro", "ro"},
|
|
{ "ru", "ru"},
|
|
{ "sr", "sr"},
|
|
{ "sk", "sk"},
|
|
{ "sl", "sl"},
|
|
{ "es", "es"},
|
|
{ "sw", "sw"},
|
|
{ "sv", "sv"},
|
|
{ "ta", "ta"},
|
|
{ "te", "te"},
|
|
{ "th", "th"},
|
|
{ "tr", "tr"},
|
|
{ "uk", "uk"},
|
|
{ "ur", "ur"},
|
|
{ "vi", "vi"},
|
|
{ "cy", "cy"},
|
|
{ "yi", "yi"},
|
|
};
|
|
|
|
public async Task<string> Translate(string sourceText, string sourceLanguage, string targetLanguage)
|
|
{
|
|
await Task.Yield();
|
|
string text;
|
|
|
|
if (!_languageDictionary.ContainsKey(sourceLanguage) ||
|
|
!_languageDictionary.ContainsKey(targetLanguage))
|
|
throw new ArgumentException();
|
|
|
|
|
|
var url = string.Format("https://translate.googleapis.com/translate_a/single?client=gtx&sl={0}&tl={1}&dt=t&q={2}",
|
|
ConvertToLanguageCode(sourceLanguage),
|
|
ConvertToLanguageCode(targetLanguage),
|
|
WebUtility.UrlEncode(sourceText));
|
|
using (var http = new HttpClient())
|
|
{
|
|
http.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36");
|
|
text = await http.GetStringAsync(url).ConfigureAwait(false);
|
|
}
|
|
|
|
return (string.Concat(JArray.Parse(text)[0].Select(x => x[0])));
|
|
}
|
|
|
|
private string ConvertToLanguageCode(string language)
|
|
{
|
|
_languageDictionary.TryGetValue(language, out var mode);
|
|
return mode;
|
|
}
|
|
}
|
|
} |