private async Task <CollectionResult> FetchMainResult(string id, string language, CancellationToken cancellationToken)
{
var url = string.Format(GetCollectionInfo3, id, TmdbUtils.ApiKey);
if (!string.IsNullOrEmpty(language))
{
url += string.Format("&language={0}", TmdbMovieProvider.NormalizeLanguage(language));
// Get images in english and with no language
url += "&include_image_language=" + TmdbMovieProvider.GetImageLanguagesParam(language);
}
cancellationToken.ThrowIfCancellationRequested();
CollectionResult mainResult;
using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
{
Url = url,
CancellationToken = cancellationToken,
AcceptHeader = TmdbUtils.AcceptHeader
}).ConfigureAwait(false))
{
using (var json = response.Content)
{
mainResult = await _json.DeserializeFromStreamAsync <CollectionResult>(json).ConfigureAwait(false);
}
}
cancellationToken.ThrowIfCancellationRequested();
if (mainResult != null && string.IsNullOrEmpty(mainResult.Name))
{
if (!string.IsNullOrEmpty(language) && !string.Equals(language, "en", StringComparison.OrdinalIgnoreCase))
{
url = string.Format(GetCollectionInfo3, id, TmdbUtils.ApiKey) + "&language=en";
if (!string.IsNullOrEmpty(language))
{
// Get images in english and with no language
url += "&include_image_language=" + TmdbMovieProvider.GetImageLanguagesParam(language);
}
using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
{
Url = url,
CancellationToken = cancellationToken,
AcceptHeader = TmdbUtils.AcceptHeader
}).ConfigureAwait(false))
{
using (var json = response.Content)
{
mainResult = await _json.DeserializeFromStreamAsync <CollectionResult>(json).ConfigureAwait(false);
}
}
}
}
return(mainResult);
}
public async Task <MetadataResult <MusicArtist> > GetMetadata(ArtistInfo info, CancellationToken cancellationToken)
{
var result = new MetadataResult <MusicArtist>
{
Item = new MusicArtist()
};
var httpRequestOptions = new HttpRequestOptions
{
CancellationToken = cancellationToken,
};
httpRequestOptions.Url = $"{searchUrl}\"{HttpUtility.UrlEncode(info.Name)}\"";
using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false))
{
var openLibrarySearch = await _json.DeserializeFromStreamAsync <OpenLibrarySearch>(resp.Content).ConfigureAwait(false);
var author = openLibrarySearch.docs.FirstOrDefault();
if (author != null)
{
result.HasMetadata = true;
result.Item.Name = author.name;
}
}
return(result);
}
public async Task <MetadataResult <MusicAlbum> > GetMetadata(AlbumInfo info, CancellationToken cancellationToken)
{
var result = new MetadataResult <MusicAlbum>
{
Item = new MusicAlbum()
};
var httpRequestOptions = new HttpRequestOptions
{
CancellationToken = cancellationToken,
};
if (info.ProviderIds.TryGetValue("isbn", out string isbn))
{
httpRequestOptions.Url = $"{baseUrl}ISBN:{isbn}";
using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false))
{
var openLibrarySearch = await _json.DeserializeFromStreamAsync <Dictionary <string, OpenLibraryResp> >(resp.Content).ConfigureAwait(false);
if (openLibrarySearch.TryGetValue($"ISBN:{isbn}", out OpenLibraryResp book))
{
result.HasMetadata = true;
result.Item.Album = book.title;
result.Item.AlbumArtists = book.authors.Select(i => i.name).ToArray();
result.Item.Artists = book.authors.Select(i => i.name).ToArray();
foreach (var dewey in book.classifications.dewey_decimal_class)
{
result.Item.AddGenre(dewey);
}
}
}
}
else
{
httpRequestOptions.Url = $"{searchUrl}\"{HttpUtility.UrlEncode(info.Name)}\"";
using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false))
{
var openLibrarySearch = await _json.DeserializeFromStreamAsync <OpenLibrarySearch>(resp.Content).ConfigureAwait(false);
var book = openLibrarySearch.docs.FirstOrDefault();
if (book != null)
{
result.HasMetadata = true;
result.Item.Album = book.title;
result.Item.AlbumArtists = book.author_name;
result.Item.Artists = book.author_name;
result.Item.ProductionYear = book.first_publish_year;
if (book.isbn != null)
{
result.Item.ProviderIds.Add("isbn", book.isbn.FirstOrDefault());
}
}
}
}
return(result);
}
/// <summary>
/// Register an app store sale with our back-end. It will validate the transaction with the store
/// and then register the proper feature and then fill in the supporter key on success.
/// </summary>
/// <param name="parameters">Json parameters to send to admin server</param>
public async Task RegisterAppStoreSale(string parameters)
{
var options = new HttpRequestOptions()
{
Url = AppstoreRegUrl,
CancellationToken = CancellationToken.None,
BufferContent = false
};
options.RequestHeaders.Add("X-Emby-Token", _appHost.SystemId);
options.RequestContent = parameters;
options.RequestContentType = "application/json";
try
{
using (var response = await _httpClient.Post(options).ConfigureAwait(false))
{
var reg = await _jsonSerializer.DeserializeFromStreamAsync <RegRecord>(response.Content).ConfigureAwait(false);
if (reg == null)
{
var msg = "Result from appstore registration was null.";
_logger.Error(msg);
throw new ArgumentException(msg);
}
if (!String.IsNullOrEmpty(reg.key))
{
await UpdateSupporterKey(reg.key).ConfigureAwait(false);
}
}
}
catch (ArgumentException)
{
SaveAppStoreInfo(parameters);
throw;
}
catch (HttpException e)
{
_logger.ErrorException("Error registering appstore purchase {0}", e, parameters ?? "NO PARMS SENT");
if (e.StatusCode.HasValue && e.StatusCode.Value == HttpStatusCode.PaymentRequired)
{
throw new PaymentRequiredException();
}
throw new Exception("Error registering store sale");
}
catch (Exception e)
{
_logger.ErrorException("Error registering appstore purchase {0}", e, parameters ?? "NO PARMS SENT");
SaveAppStoreInfo(parameters);
//TODO - could create a re-try routine on start-up if this file is there. For now we can handle manually.
throw new Exception("Error registering store sale");
}
}
private async Task <CollectionResult> FetchMainResult(string id, string language, CancellationToken cancellationToken)
{
var url = string.Format(CultureInfo.InvariantCulture, GetCollectionInfo3, id, TmdbUtils.ApiKey);
if (!string.IsNullOrEmpty(language))
{
url += string.Format(CultureInfo.InvariantCulture, "&language={0}", TmdbMovieProvider.NormalizeLanguage(language));
// Get images in english and with no language
url += "&include_image_language=" + TmdbMovieProvider.GetImageLanguagesParam(language);
}
cancellationToken.ThrowIfCancellationRequested();
using var requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in TmdbUtils.AcceptHeaders)
{
requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(header));
}
using var mainResponse = await TmdbMovieProvider.Current.GetMovieDbResponse(requestMessage, cancellationToken).ConfigureAwait(false);
await using var stream = await mainResponse.Content.ReadAsStreamAsync().ConfigureAwait(false);
var mainResult = await _json.DeserializeFromStreamAsync <CollectionResult>(stream).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
if (mainResult != null && string.IsNullOrEmpty(mainResult.Name))
{
if (!string.IsNullOrEmpty(language) && !string.Equals(language, "en", StringComparison.OrdinalIgnoreCase))
{
url = string.Format(CultureInfo.InvariantCulture, GetCollectionInfo3, id, TmdbUtils.ApiKey) + "&language=en";
if (!string.IsNullOrEmpty(language))
{
// Get images in english and with no language
url += "&include_image_language=" + TmdbMovieProvider.GetImageLanguagesParam(language);
}
using var langRequestMessage = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in TmdbUtils.AcceptHeaders)
{
langRequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(header));
}
await using var langStream = await mainResponse.Content.ReadAsStreamAsync().ConfigureAwait(false);
mainResult = await _json.DeserializeFromStreamAsync <CollectionResult>(langStream).ConfigureAwait(false);
}
}
return(mainResult);
}
/// <summary>
/// Gets one movie or tv item by doubanID.
/// </summary>
/// <param name="doubanID">The subject ID in Douban.</param>
/// <param name="type">Subject type.</param>
/// <param name="cancellationToken">Used to cancel the request.</param>
/// <returns>The subject of one item.</returns>
public async Task <Response.Subject> GetSubject(string doubanID, MediaType type, CancellationToken cancellationToken)
{
_logger.LogInformation($"Start to GetSubject by Id: {doubanID}");
string path = $"/api/v2/{type:G}/{doubanID}";
Dictionary <string, string> queryParams = new Dictionary <string, string>();
var contentStream = await GetResponse(path, queryParams, cancellationToken);
Response.Subject subject = await _jsonSerializer.DeserializeFromStreamAsync <Response.Subject>(contentStream);
_logger.LogTrace($"Finish doing GetSubject by Id: {doubanID}");
return(subject);
}
private async Task <List <RemoteSearchResult> > GetSearchResultsGeneric(string name, string type, int?year, string language, string baseImageUrl, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("name");
}
var url3 = string.Format(_searchURL, WebUtility.UrlEncode(name), TmdbUtils.ApiKey, language, type);
using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
{
Url = url3,
CancellationToken = cancellationToken,
AcceptHeader = TmdbUtils.AcceptHeader
}).ConfigureAwait(false))
{
using (var json = response.Content)
{
var searchResults = await _json.DeserializeFromStreamAsync <TmdbSearchResult <MovieResult> >(json).ConfigureAwait(false);
var results = searchResults.Results ?? new List <MovieResult>();
return(results
.Select(i =>
{
var remoteResult = new RemoteSearchResult
{
SearchProviderName = TmdbMovieProvider.Current.Name,
Name = i.Title ?? i.Name ?? i.Original_Title,
ImageUrl = string.IsNullOrWhiteSpace(i.Poster_Path) ? null : baseImageUrl + i.Poster_Path
};
if (!string.IsNullOrWhiteSpace(i.Release_Date))
{
// These dates are always in this exact format
if (DateTime.TryParseExact(i.Release_Date, "yyyy-MM-dd", _usCulture, DateTimeStyles.None, out var r))
{
remoteResult.PremiereDate = r.ToUniversalTime();
remoteResult.ProductionYear = remoteResult.PremiereDate.Value.Year;
}
}
remoteResult.SetProviderId(MetadataProviders.Tmdb, i.Id.ToString(_usCulture));
return remoteResult;
})
.ToList());
}
}
}
public async Task <MetadataResult <Book> > GetMetadata(BookInfo info, CancellationToken cancellationToken)
{
var result = new MetadataResult <Book>
{
Item = new Book()
};
var httpRequestOptions = new HttpRequestOptions
{
CancellationToken = cancellationToken,
};
if (info.ProviderIds.TryGetValue("isbn", out string isbn))
{
httpRequestOptions.Url = $"{baseUrl}ISBN:{isbn}";
using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false))
{
var openLibrarySearch = await _json.DeserializeFromStreamAsync <Dictionary <string, OpenLibraryResp> >(resp.Content).ConfigureAwait(false);
if (openLibrarySearch.TryGetValue($"ISBN:{isbn}", out OpenLibraryResp book))
{
result.HasMetadata = true;
result.Item.Name = book.title;
}
}
}
else
{
httpRequestOptions.Url = $"{searchUrl}\"{HttpUtility.UrlEncode(info.Name)}\"";
using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false))
{
var openLibrarySearch = await _json.DeserializeFromStreamAsync <OpenLibrarySearch>(resp.Content).ConfigureAwait(false);
var book = openLibrarySearch.docs.FirstOrDefault();
if (book != null)
{
result.HasMetadata = true;
result.Item.Name = book.title;
result.Item.ProductionYear = book.first_publish_year;
if (book.isbn != null)
{
result.Item.ProviderIds.Add("isbn", book.isbn.FirstOrDefault());
}
}
}
}
return(result);
}
public async Task <List <Game> > GetGamesAsync(DateTime inputDate)
{
var request = new HttpRequestOptions();
if (_gameType.Equals("nhl", StringComparison.OrdinalIgnoreCase))
{
request.Url = NhlLink;
}
else if (_gameType.Equals("mlb", StringComparison.OrdinalIgnoreCase))
{
request.Url = MlbLink;
}
else
{
throw new ArgumentOutOfRangeException(nameof(_gameType), "Unknown Game Type");
}
request.Url = string.Format(request.Url, inputDate.ToString("yyyy-MM-dd"));
_logger.Debug($"[LazyMan][GetGamesAsync] Getting games from {request.Url}");
var responseStream = await _httpClient.Get(request).ConfigureAwait(false);
var containerObject = await _jsonSerializer.DeserializeFromStreamAsync(responseStream,
typeof(StatsApiContainer)).ConfigureAwait(false);
var container = (StatsApiContainer)containerObject;
return(ContainerToGame(container));
}
internal async Task <Response.Subject> GetSubject(string sid,
CancellationToken cancellationToken)
{
_logger.LogInformation("Trying to get douban subject by sid: {0}", sid);
cancellationToken.ThrowIfCancellationRequested();
if (string.IsNullOrWhiteSpace(sid))
{
throw new ArgumentException("sid is empty when getting subject");
}
String apikey = _config.ApiKey;
var url = String.Format("http://api.douban.com/v2/movie/subject/{0}?apikey={1}",
sid,
apikey);
var options = new HttpRequestOptions
{
Url = url,
CancellationToken = cancellationToken,
BufferContent = true,
EnableDefaultUserAgent = true,
};
var response = await _httpClient.GetResponse(options).ConfigureAwait(false);
var data = await _jsonSerializer.DeserializeFromStreamAsync <Response.Subject>(response.Content);
return(data);
}
internal async Task <SeasonResult> FetchMainResult(string id, int seasonNumber, string language, CancellationToken cancellationToken)
{
var url = string.Format(GetTvInfo3, id, seasonNumber.ToString(CultureInfo.InvariantCulture), TmdbUtils.ApiKey);
if (!string.IsNullOrEmpty(language))
{
url += string.Format("&language={0}", TmdbMovieProvider.NormalizeLanguage(language));
}
var includeImageLanguageParam = TmdbMovieProvider.GetImageLanguagesParam(language);
// Get images in english and with no language
url += "&include_image_language=" + includeImageLanguageParam;
cancellationToken.ThrowIfCancellationRequested();
using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
{
Url = url,
CancellationToken = cancellationToken,
AcceptHeader = TmdbUtils.AcceptHeader
}).ConfigureAwait(false))
{
using (var json = response.Content)
{
return(await _jsonSerializer.DeserializeFromStreamAsync <SeasonResult>(json).ConfigureAwait(false));
}
}
}
private async Task <T> FetchDataAsync <T>(string body, CancellationToken cancellationToken) where T : class
{
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
var options = new HttpRequestOptions
{
RequestContent = body.AsMemory(),
Url = "https://graphql.anilist.co/",
RequestContentType = "application/json",
TimeoutMs = 30000,
CancellationToken = cancellationToken
};
var result = await _httpClient.Post(options).ConfigureAwait(false);
if (result == null || result.Content == null)
{
return(null);
}
return(await _serializer.DeserializeFromStreamAsync <T>(result.Content).ConfigureAwait(false));
}
internal async Task <SeasonResult> FetchMainResult(string id, int seasonNumber, string language, CancellationToken cancellationToken)
{
var url = string.Format(
CultureInfo.InvariantCulture,
GetTvInfo3,
id,
seasonNumber.ToString(CultureInfo.InvariantCulture),
TmdbUtils.ApiKey);
if (!string.IsNullOrEmpty(language))
{
url += string.Format(CultureInfo.InvariantCulture, "&language={0}", TmdbMovieProvider.NormalizeLanguage(language));
}
var includeImageLanguageParam = TmdbMovieProvider.GetImageLanguagesParam(language);
// Get images in english and with no language
url += "&include_image_language=" + includeImageLanguageParam;
cancellationToken.ThrowIfCancellationRequested();
using var requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in TmdbUtils.AcceptHeaders)
{
requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(header));
}
using var response = await TmdbMovieProvider.Current.GetMovieDbResponse(requestMessage, cancellationToken).ConfigureAwait(false);
await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(await _jsonSerializer.DeserializeFromStreamAsync <SeasonResult>(stream).ConfigureAwait(false));
}
public async Task <IEnumerable <RemoteSearchResult> > GetSearchResults(PersonLookupInfo searchInfo, CancellationToken cancellationToken)
{
var tmdbId = searchInfo.GetProviderId(MetadataProvider.Tmdb);
var tmdbSettings = await TmdbMovieProvider.Current.GetTmdbSettings(cancellationToken).ConfigureAwait(false);
var tmdbImageUrl = tmdbSettings.images.GetImageUrl("original");
if (!string.IsNullOrEmpty(tmdbId))
{
await EnsurePersonInfo(tmdbId, cancellationToken).ConfigureAwait(false);
var dataFilePath = GetPersonDataFilePath(_configurationManager.ApplicationPaths, tmdbId);
var info = _jsonSerializer.DeserializeFromFile <PersonResult>(dataFilePath);
var images = (info.Images ?? new PersonImages()).Profiles ?? new List <Profile>();
var result = new RemoteSearchResult
{
Name = info.Name,
SearchProviderName = Name,
ImageUrl = images.Count == 0 ? null : (tmdbImageUrl + images[0].File_Path)
};
result.SetProviderId(MetadataProvider.Tmdb, info.Id.ToString(_usCulture));
result.SetProviderId(MetadataProvider.Imdb, info.Imdb_Id);
return(new[] { result });
}
if (searchInfo.IsAutomated)
{
// Don't hammer moviedb searching by name
return(new List <RemoteSearchResult>());
}
var url = string.Format(
CultureInfo.InvariantCulture,
TmdbUtils.BaseTmdbApiUrl + @"3/search/person?api_key={1}&query={0}",
WebUtility.UrlEncode(searchInfo.Name),
TmdbUtils.ApiKey);
using var requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in TmdbUtils.AcceptHeaders)
{
requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(header));
}
var response = await TmdbMovieProvider.Current.GetMovieDbResponse(requestMessage, cancellationToken).ConfigureAwait(false);
await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
var result2 = await _jsonSerializer.DeserializeFromStreamAsync <TmdbSearchResult <PersonSearchResult> >(stream).ConfigureAwait(false)
?? new TmdbSearchResult <PersonSearchResult>();
return(result2.Results.Select(i => GetSearchResult(i, tmdbImageUrl)));
}
public async Task Post(UpdateNamedConfiguration request)
{
var key = GetPathValue(2);
var configurationType = _configurationManager.GetConfigurationType(key);
var configuration = await _jsonSerializer.DeserializeFromStreamAsync(request.RequestStream, configurationType).ConfigureAwait(false);
_configurationManager.SaveConfiguration(key, configuration);
}
public async Task <IEnumerable <RemoteSearchResult> > GetSearchResults(PersonLookupInfo searchInfo, CancellationToken cancellationToken)
{
var tmdbId = searchInfo.GetProviderId(MetadataProviders.Tmdb);
var tmdbSettings = await MovieDbProvider.Current.GetTmdbSettings(cancellationToken).ConfigureAwait(false);
var tmdbImageUrl = tmdbSettings.images.GetImageUrl("original");
if (!string.IsNullOrEmpty(tmdbId))
{
await EnsurePersonInfo(tmdbId, cancellationToken).ConfigureAwait(false);
var dataFilePath = GetPersonDataFilePath(_configurationManager.ApplicationPaths, tmdbId);
var info = _jsonSerializer.DeserializeFromFile <PersonResult>(dataFilePath);
var images = (info.images ?? new Images()).profiles ?? new List <Profile>();
var result = new RemoteSearchResult
{
Name = info.name,
SearchProviderName = Name,
ImageUrl = images.Count == 0 ? null : (tmdbImageUrl + images[0].file_path)
};
result.SetProviderId(MetadataProviders.Tmdb, info.id.ToString(_usCulture));
result.SetProviderId(MetadataProviders.Imdb, info.imdb_id);
return(new[] { result });
}
if (searchInfo.IsAutomated)
{
// Don't hammer moviedb searching by name
return(new List <RemoteSearchResult>());
}
var url = string.Format(MovieDbProvider.BaseMovieDbUrl + @"3/search/person?api_key={1}&query={0}", WebUtility.UrlEncode(searchInfo.Name), MovieDbProvider.ApiKey);
using (var response = await MovieDbProvider.Current.GetMovieDbResponse(new HttpRequestOptions
{
Url = url,
CancellationToken = cancellationToken,
AcceptHeader = MovieDbProvider.AcceptHeader
}).ConfigureAwait(false))
{
using (var json = response.Content)
{
var result = await _jsonSerializer.DeserializeFromStreamAsync <PersonSearchResults>(json).ConfigureAwait(false) ??
new PersonSearchResults();
return(result.Results.Select(i => GetSearchResult(i, tmdbImageUrl)));
}
}
}
public Task <object> DeserializeJson(Type type, Stream stream)
{
//using (var reader = new StreamReader(stream))
//{
// var json = reader.ReadToEnd();
// Logger.Info(json);
// return _jsonSerializer.DeserializeFromString(json, type);
//}
return(_jsonSerializer.DeserializeFromStreamAsync(stream, type));
}
public async Task RefreshUserAuth(TraktUser traktUser, CancellationToken cancellationToken)
{
var data = new TraktUserTokenRequest
{
client_id = TraktUris.Id,
client_secret = TraktUris.Secret,
redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
};
if (!string.IsNullOrWhiteSpace(traktUser.PIN))
{
data.code = traktUser.PIN;
data.grant_type = "authorization_code";
}
else if (!string.IsNullOrWhiteSpace(traktUser.RefreshToken))
{
data.refresh_token = traktUser.RefreshToken;
data.grant_type = "refresh_token";
}
else
{
_logger.Error("Tried to reauthenticate with Trakt, but neither PIN nor refreshToken was available");
}
_logger.Info($"{data.code} - {data.grant_type}");
TraktUserToken userToken;
using (var response = await PostToTrakt(TraktUris.Token, data, null, cancellationToken).ConfigureAwait(false))
{
_logger.Info($"{response}");
userToken = await _jsonSerializer.DeserializeFromStreamAsync <TraktUserToken>(response).ConfigureAwait(false);
}
if (userToken != null)
{
traktUser.AccessToken = userToken.access_token;
traktUser.RefreshToken = userToken.refresh_token;
traktUser.PIN = null;
traktUser.AccessTokenExpiration = DateTimeOffset.Now.AddMonths(2);
Plugin.Instance.PluginConfiguration.Pin = null;
Plugin.Instance.SaveConfiguration();
}
}
protected async Task <T> PostRequest <T>(string url, string accessToken, IDictionary <string, string> data, CancellationToken cancellationToken)
{
var requestUrl = this.PrepareRequestUrl(url);
using (var requestMessage = new HttpRequestMessage(HttpMethod.Post, requestUrl))
{
if (!string.IsNullOrEmpty(accessToken))
{
requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
}
requestMessage.Headers.Add("User-Agent", UserAgent);
requestMessage.Content = new FormUrlEncodedContent(data);
var result = await _httpClient.SendAsync(requestMessage, cancellationToken).ConfigureAwait(false);
var responseStream = await result.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(await _jsonSerializer.DeserializeFromStreamAsync <T>(responseStream).ConfigureAwait(false));
}
}
/// <summary>
/// Send a POST request to the LastFM Api
/// </summary>
/// <typeparam name="TRequest">The type of the request</typeparam>
/// <typeparam name="TResponse">The type of the response</typeparam>
/// <param name="request">The request</param>
/// <returns>A response with type TResponse</returns>
public async Task <TResponse> Post <TRequest, TResponse>(TRequest request) where TRequest : BaseRequest where TResponse : BaseResponse
{
var data = request.ToDictionary();
//Append the signature
Helpers.AppendSignature(ref data);
var options = new HttpRequestOptions
{
Url = BuildPostUrl(request.Secure),
CancellationToken = CancellationToken.None,
EnableHttpCompression = false,
};
options.SetPostData(EscapeDictionary(data));
using (var response = await _httpClient.Post(options))
{
using (var stream = response.Content)
{
try
{
var result = await _jsonSerializer.DeserializeFromStreamAsync <TResponse>(stream).ConfigureAwait(false);
//Lets Log the error here to ensure all errors are logged
if (result.IsError())
{
Plugin.Logger.Error(result.Message);
}
return(result);
}
catch (Exception e)
{
Plugin.Logger.Debug(e.Message);
}
}
return(null);
}
}
/// <summary>
/// Gets all available packages.
/// </summary>
/// <returns>Task{List{PackageInfo}}.</returns>
public async Task <List <PackageInfo> > GetAvailablePackages(CancellationToken cancellationToken,
bool withRegistration = true,
string packageType = null,
Version applicationVersion = null)
{
if (withRegistration)
{
var data = new Dictionary <string, string>
{
{ "key", _securityManager.SupporterKey },
{ "mac", _applicationHost.SystemId },
{ "systemid", _applicationHost.SystemId }
};
var options = new HttpRequestOptions
{
Url = "https://www.mb3admin.com/admin/service/package/retrieveall?includeAllRuntimes=true",
CancellationToken = cancellationToken
};
options.SetPostData(data);
using (var response = await _httpClient.SendAsync(options, "POST").ConfigureAwait(false))
{
using (var json = response.Content)
{
cancellationToken.ThrowIfCancellationRequested();
var packages = await _jsonSerializer.DeserializeFromStreamAsync <PackageInfo[]>(json).ConfigureAwait(false);
return(FilterPackages(packages, packageType, applicationVersion));
}
}
}
else
{
var packages = await GetAvailablePackagesWithoutRegistrationInfo(cancellationToken).ConfigureAwait(false);
return(FilterPackages(packages, packageType, applicationVersion));
}
}
/// <summary>
/// Gets the TMDB settings.
/// </summary>
/// <returns>Task{TmdbSettingsResult}.</returns>
internal async Task <TmdbSettingsResult> GetTmdbSettings(CancellationToken cancellationToken)
{
if (_tmdbSettings != null)
{
return(_tmdbSettings);
}
using var requestMessage = new HttpRequestMessage(HttpMethod.Get, string.Format(CultureInfo.InvariantCulture, TmdbConfigUrl, TmdbUtils.ApiKey));
foreach (var header in TmdbUtils.AcceptHeaders)
{
requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(header));
}
using var response = await GetMovieDbResponse(requestMessage).ConfigureAwait(false);
await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
_tmdbSettings = await _jsonSerializer.DeserializeFromStreamAsync <TmdbSettingsResult>(stream).ConfigureAwait(false);
return(_tmdbSettings);
}
private async Task <SmartPlaylistDto> LoadPlaylistAsync(string filePath)
{
using (var reader = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 4096,
FileOptions.Asynchronous))
{
var res = await _jsonSerializer.DeserializeFromStreamAsync <SmartPlaylistDto>(reader)
.ConfigureAwait(false);
reader.Close();
return(res);
}
}
/// <summary>
/// Gets the TMDB settings.
/// </summary>
/// <returns>Task{TmdbSettingsResult}.</returns>
internal async Task <TmdbSettingsResult> GetTmdbSettings(CancellationToken cancellationToken)
{
if (_tmdbSettings != null)
{
return(_tmdbSettings);
}
using (var response = await GetMovieDbResponse(new HttpRequestOptions
{
Url = string.Format(TmdbConfigUrl, ApiKey),
CancellationToken = cancellationToken,
AcceptHeader = AcceptHeader
}).ConfigureAwait(false))
{
using (var json = response.Content)
{
_tmdbSettings = await _jsonSerializer.DeserializeFromStreamAsync <TmdbSettingsResult>(json).ConfigureAwait(false);
return(_tmdbSettings);
}
}
}
protected async Task <Metadata> GetMetadata(string vid, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(vid))
{
Logger.LogError($"[AVDC] invalid vid: \"{vid}\"");
return(new Metadata());
}
var url = $"{Config.Server}{ApiPath.Metadata}{vid}";
try
{
var contentStream = await GetStream(url, cancellationToken);
return(await _jsonSerializer.DeserializeFromStreamAsync <Metadata>(contentStream));
}
catch (Exception e)
{
Logger.LogError($"[AVDC] GetMetadata for {vid} failed: {e.Message}");
return(new Metadata());
}
}
/// <summary>
/// Posts the specified request.
/// </summary>
/// <param name="request">The request.</param>
public async Task Post(UpdatePluginConfiguration request)
{
// We need to parse this manually because we told service stack not to with IRequiresRequestStream
// https://code.google.com/p/servicestack/source/browse/trunk/Common/ServiceStack.Text/ServiceStack.Text/Controller/PathInfo.cs
var id = Guid.Parse(GetPathValue(1));
if (!(_appHost.Plugins.First(p => p.Id == id) is IHasPluginConfiguration plugin))
{
throw new FileNotFoundException();
}
var configuration = (await _jsonSerializer.DeserializeFromStreamAsync(request.RequestStream, plugin.ConfigurationType).ConfigureAwait(false)) as BasePluginConfiguration;
plugin.UpdateConfiguration(configuration);
}
/// <summary>
/// Gets one movie or tv item by doubanID.
/// </summary>
/// <param name="doubanID">The subject ID in Douban.</param>
/// <param name="type">Subject type.</param>
/// <param name="cancellationToken">Used to cancel the request.</param>
/// <returns>The subject of one item.</returns>
public async Task <Response.Subject> GetSubject(string doubanID, MediaType type, CancellationToken cancellationToken)
{
_logger.LogInformation($"Start to GetSubject by Id: {doubanID}");
string path = $"/api/v2/{type:G}/{doubanID}";
// Try to use cache firstly.
if (_cache.TryGet <Response.Subject>(path, out Response.Subject subject))
{
_logger.LogInformation($"Get subject {doubanID} from cache");
return(subject);
}
Dictionary <string, string> queryParams = new Dictionary <string, string>();
var contentStream = await GetResponse(path, queryParams, cancellationToken);
subject = await _jsonSerializer.DeserializeFromStreamAsync <Response.Subject>(contentStream);
// Add it into cache
_cache.Add(path, subject);
_logger.LogTrace($"Finish doing GetSubject by Id: {doubanID}");
return(subject);
}
/// <summary>
/// Gets all available packages.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{List{PackageInfo}}.</returns>
public async Task <List <PackageInfo> > GetAvailablePackagesWithoutRegistrationInfo(CancellationToken cancellationToken)
{
using (var response = await _httpClient.SendAsync(new HttpRequestOptions
{
Url = "https://repo.jellyfin.org/releases/plugin/manifest.json",
CancellationToken = cancellationToken,
Progress = new SimpleProgress <double>(),
CacheLength = GetCacheLength()
}, "GET").ConfigureAwait(false))
{
using (var stream = response.Content)
{
return(FilterPackages(await _jsonSerializer.DeserializeFromStreamAsync <PackageInfo[]>(stream).ConfigureAwait(false)));
}
}
}
/// <summary>
/// Gets all available packages.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{List{PackageInfo}}.</returns>
public async Task <List <PackageInfo> > GetAvailablePackagesWithoutRegistrationInfo(CancellationToken cancellationToken)
{
using (var response = await _httpClient.SendAsync(new HttpRequestOptions
{
Url = "https://www.mb3admin.local/admin/service/EmbyPackages.json",
CancellationToken = cancellationToken,
Progress = new SimpleProgress <double>(),
CacheLength = GetCacheLength(),
CacheMode = CacheMode.Unconditional
}, "GET").ConfigureAwait(false))
{
using (var stream = response.Content)
{
return(FilterPackages(await _jsonSerializer.DeserializeFromStreamAsync <PackageInfo[]>(stream).ConfigureAwait(false)));
}
}
}
public async Task <PinRedeemResult> RedeemPasswordResetPin(string pin)
{
var userManager = _appHost.Resolve <IUserManager>();
var usersReset = new List <string>();
foreach (var resetFile in Directory.EnumerateFiles(_passwordResetFileBaseDir, $"{BaseResetFileName}*"))
{
SerializablePasswordReset spr;
await using (var str = File.OpenRead(resetFile))
{
spr = await _jsonSerializer.DeserializeFromStreamAsync <SerializablePasswordReset>(str).ConfigureAwait(false);
}
if (spr.ExpirationDate < DateTime.UtcNow)
{
File.Delete(resetFile);
}
else if (string.Equals(
spr.Pin.Replace("-", string.Empty, StringComparison.Ordinal),
pin.Replace("-", string.Empty, StringComparison.Ordinal),
StringComparison.InvariantCultureIgnoreCase))
{
var resetUser = userManager.GetUserByName(spr.UserName)
?? throw new ResourceNotFoundException($"User with a username of {spr.UserName} not found");
await userManager.ChangePassword(resetUser, pin).ConfigureAwait(false);
usersReset.Add(resetUser.Username);
File.Delete(resetFile);
}
}
if (usersReset.Count < 1)
{
throw new ResourceNotFoundException($"No Users found with a password reset request matching pin {pin}");
}
return(new PinRedeemResult
{
Success = true,
UsersReset = usersReset.ToArray()
});
}
