internal async Task <RootObject> FetchMainResult(string id, int seasonNumber, int episodeNumber, string language, CancellationToken cancellationToken)
{
var url = string.Format(GetTvInfo3, id, seasonNumber.ToString(CultureInfo.InvariantCulture), episodeNumber, MovieDbProvider.ApiKey);
if (!string.IsNullOrEmpty(language))
{
url += string.Format("&language={0}", language);
}
var includeImageLanguageParam = MovieDbProvider.GetImageLanguagesParam(language);
// Get images in english and with no language
url += "&include_image_language=" + includeImageLanguageParam;
cancellationToken.ThrowIfCancellationRequested();
using (var json = await MovieDbProvider.Current.GetMovieDbResponse(new HttpRequestOptions
{
Url = url,
CancellationToken = cancellationToken,
AcceptHeader = MovieDbProvider.AcceptHeader
}).ConfigureAwait(false))
{
return(_jsonSerializer.DeserializeFromStream <RootObject>(json));
}
}
/// <summary>
/// Retrieves the user data.
/// </summary>
/// <param name="userId">The user id.</param>
/// <param name="key">The key.</param>
/// <returns>Task{UserItemData}.</returns>
private UserItemData RetrieveUserData(Guid userId, string key)
{
using (var cmd = _connection.CreateCommand())
{
cmd.CommandText = "select data from userdata where key = @key and userId=@userId";
var idParam = cmd.Parameters.Add("@key", DbType.String);
idParam.Value = key;
var userIdParam = cmd.Parameters.Add("@userId", DbType.Guid);
userIdParam.Value = userId;
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult | CommandBehavior.SingleRow))
{
if (reader.Read())
{
using (var stream = reader.GetMemoryStream(0))
{
return(_jsonSerializer.DeserializeFromStream <UserItemData>(stream));
}
}
}
return(new UserItemData());
}
}
public DateTimeOffset GetUpdateTime(Stream stream, IJsonSerializer json, ILogger <LiveTvService> logger)
{
var root = json.DeserializeFromStream <RootObject>(stream);
UtilsHelper.DebugInformation(logger, string.Format("[NextPVR] LastUpdate Response: {0}", json.SerializeToString(root)));
return(DateTimeOffset.FromUnixTimeSeconds(root.last_update));
}
public static async Task<MBRegistrationRecord> GetRegistrationStatus(IHttpClient httpClient, IJsonSerializer jsonSerializer, string feature, string mb2Equivalent = null)
{
var mac = GetMacAddress();
var data = new Dictionary<string, string> {{"feature", feature}, {"key",SupporterKey}, {"mac",mac}, {"mb2equiv",mb2Equivalent}, {"legacykey", LegacyKey} };
var reg = new RegRecord();
try
{
using (var json = await httpClient.Post(MBValidateUrl, data, CancellationToken.None).ConfigureAwait(false))
{
reg = jsonSerializer.DeserializeFromStream<RegRecord>(json);
}
if (reg.registered)
{
LicenseFile.AddRegCheck(feature);
}
}
catch (Exception)
{
//if we have trouble obtaining from web - allow it if we've validated in the past 30 days
reg.registered = LicenseFile.LastChecked(feature) > DateTime.UtcNow.AddDays(-30);
}
return new MBRegistrationRecord {IsRegistered = reg.registered, ExpirationDate = reg.expDate, RegChecked = true};
}
public IEnumerable <ChannelInfo> GetChannels(Stream stream, IJsonSerializer json, ILogger <LiveTvService> logger)
{
var root = json.DeserializeFromStream <RootObject>(stream);
if (root == null)
{
logger.LogError("Failed to download channel information.");
throw new Exception("Failed to download channel information.");
}
if (root.channels != null)
{
UtilsHelper.DebugInformation(logger, string.Format("[NextPVR] ChannelResponse: {0}", json.SerializeToString(root)));
return(root.channels.Select(i => new ChannelInfo
{
Name = i.channelName,
Number = i.channelNumberFormated,
Id = i.channelId.ToString(_usCulture),
ImageUrl = string.Format("{0}/service?method=channel.icon&channel_id={1}", _baseUrl, i.channelId),
ChannelType = ChannelHelper.GetChannelType(i.channelType),
HasImage = i.channelIcon
}));
}
return(new List <ChannelInfo>());
}
/// <summary>
/// Retrieve all users from the database
/// </summary>
/// <returns>IEnumerable{User}.</returns>
public IEnumerable <User> RetrieveAllUsers()
{
var list = new List <User>();
using (var connection = CreateConnection(true).Result)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "select guid,data from users";
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult))
{
while (reader.Read())
{
var id = reader.GetGuid(0);
using (var stream = reader.GetMemoryStream(1))
{
var user = _jsonSerializer.DeserializeFromStream <User>(stream);
user.Id = id;
list.Add(user);
}
}
}
}
}
return(list);
}
private async Task <ChannelItemResult> GetStreams(string mainCategory, InternalChannelItemQuery query, CancellationToken cancellationToken)
{
var page = new HtmlDocument();
var items = new List <ChannelItemInfo>();
using (var json = await _httpClient.Get(String.Format("http://www.ustream.tv/ajax-alwayscache/new/explore/{0}/all.json?subCategory={1}&type=live&location=anywhere&page={2}", mainCategory, query.FolderId, 1), CancellationToken.None).ConfigureAwait(false))
{
var reg = _jsonSerializer.DeserializeFromStream <RootObject>(json);
page.LoadHtml(reg.pageContent);
foreach (var node in page.DocumentNode.SelectNodes("//div[contains(@class, \"media-item\")]"))
{
var url = node.SelectSingleNode(".//img/parent::a").Attributes["href"].Value;
var title = node.SelectSingleNode(".//h4/a/text()").InnerText;
var thumb = node.SelectSingleNode(".//img").Attributes["src"].Value;
items.Add(new ChannelItemInfo
{
Name = title,
ImageUrl = thumb,
Id = "stream_" + url,
Type = ChannelItemType.Media,
ContentType = ChannelMediaContentType.Clip,
IsInfiniteStream = true,
MediaType = ChannelMediaType.Video,
});
}
}
return(new ChannelItemResult
{
Items = items.ToList()
});
}
public object Get(ReviewRequest request)
{
var parms = "?id=" + request.Id;
if (request.MaxRating > 0)
{
parms += "&max=" + request.MaxRating;
}
if (request.MinRating > 0)
{
parms += "&min=" + request.MinRating;
}
if (request.MinRating > 0)
{
parms += "&limit=" + request.Limit;
}
if (request.ForceTitle)
{
parms += "&title=true";
}
var result = _httpClient.Get(Constants.MbAdminUrl + "/service/packageReview/retrieve" + parms, CancellationToken.None).Result;
var reviews = _serializer.DeserializeFromStream <List <PackageReviewInfo> >(result);
return(ToOptimizedResult(reviews));
}
public static async Task<MBRegistrationRecord> GetRegistrationStatus(IHttpClient httpClient, IJsonSerializer jsonSerializer, string feature, string mb2Equivalent = null, string version = null)
{
//check the reg file first to alleviate strain on the MB admin server - must actually check in every 30 days tho
var reg = new RegRecord {registered = LicenseFile.LastChecked(feature) > DateTime.UtcNow.AddDays(-30)};
if (!reg.registered)
{
var mac = _networkManager.GetMacAddress();
var data = new Dictionary<string, string> { { "feature", feature }, { "key", SupporterKey }, { "mac", mac }, { "mb2equiv", mb2Equivalent }, { "legacykey", LegacyKey }, { "ver", version }, { "platform", Environment.OSVersion.VersionString } };
try
{
using (var json = await httpClient.Post(MBValidateUrl, data, CancellationToken.None).ConfigureAwait(false))
{
reg = jsonSerializer.DeserializeFromStream<RegRecord>(json);
}
if (reg.registered)
{
LicenseFile.AddRegCheck(feature);
}
else
{
LicenseFile.RemoveRegCheck(feature);
}
}
catch (Exception e)
{
_logger.ErrorException("Error checking registration status of {0}", e, feature);
}
}
return new MBRegistrationRecord {IsRegistered = reg.registered, ExpirationDate = reg.expDate, RegChecked = true};
}
/// <summary>
/// Gets the display preferences.
/// </summary>
/// <param name="displayPreferencesId">The display preferences id.</param>
/// <param name="userId">The user id.</param>
/// <param name="client">The client.</param>
/// <returns>Task{DisplayPreferences}.</returns>
/// <exception cref="System.ArgumentNullException">item</exception>
public DisplayPreferences GetDisplayPreferences(string displayPreferencesId, Guid userId, string client)
{
if (string.IsNullOrWhiteSpace(displayPreferencesId))
{
throw new ArgumentNullException("displayPreferencesId");
}
var guidId = displayPreferencesId.GetMD5();
var cmd = _connection.CreateCommand();
cmd.CommandText = "select data from userdisplaypreferences where id = @id and userId=@userId and client=@client";
cmd.Parameters.Add(cmd, "@id", DbType.Guid).Value = guidId;
cmd.Parameters.Add(cmd, "@userId", DbType.Guid).Value = userId;
cmd.Parameters.Add(cmd, "@client", DbType.String).Value = client;
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult | CommandBehavior.SingleRow))
{
if (reader.Read())
{
using (var stream = reader.GetMemoryStream(0))
{
return(_jsonSerializer.DeserializeFromStream <DisplayPreferences>(stream));
}
}
}
return(new DisplayPreferences
{
Id = guidId.ToString("N")
});
}
private BaseItem GetItem(IDataReader reader)
{
var typeString = reader.GetString(0);
var type = _typeMapper.GetType(typeString);
if (type == null)
{
_logger.Debug("Unknown type {0}", typeString);
return(null);
}
using (var stream = reader.GetMemoryStream(1))
{
try
{
return(_jsonSerializer.DeserializeFromStream(stream, type) as BaseItem);
}
catch (SerializationException ex)
{
_logger.ErrorException("Error deserializing item", ex);
return(null);
}
}
}
private async void AddDevice(string url)
{
await _semaphore.WaitAsync().ConfigureAwait(false);
try
{
var options = GetConfiguration();
if (options.TunerHosts.Any(i =>
string.Equals(i.Type, HdHomerunHost.DeviceType, StringComparison.OrdinalIgnoreCase) &&
UriEquals(i.Url, url)))
{
return;
}
// Strip off the port
url = new Uri(url).GetComponents(UriComponents.AbsoluteUri & ~UriComponents.Port, UriFormat.UriEscaped).TrimEnd('/');
// Test it by pulling down the lineup
using (var stream = await _httpClient.Get(new HttpRequestOptions
{
Url = string.Format("{0}/discover.json", url),
CancellationToken = CancellationToken.None,
BufferContent = false
}))
{
var response = _json.DeserializeFromStream <HdHomerunHost.DiscoverResponse>(stream);
var existing = GetConfiguration().TunerHosts
.FirstOrDefault(i => string.Equals(i.Type, HdHomerunHost.DeviceType, StringComparison.OrdinalIgnoreCase) && string.Equals(i.DeviceId, response.DeviceID, StringComparison.OrdinalIgnoreCase));
if (existing == null)
{
await _liveTvManager.SaveTunerHost(new TunerHostInfo
{
Type = HdHomerunHost.DeviceType,
Url = url,
DataVersion = 1,
DeviceId = response.DeviceID
}).ConfigureAwait(false);
}
else
{
if (!string.Equals(existing.Url, url, StringComparison.OrdinalIgnoreCase))
{
existing.Url = url;
await _liveTvManager.SaveTunerHost(existing).ConfigureAwait(false);
}
}
}
}
catch (Exception ex)
{
_logger.ErrorException("Error saving device", ex);
}
finally
{
_semaphore.Release();
}
}
public IEnumerable <ChannelInfo> GetChannels(Stream stream, IJsonSerializer json, ILogger logger)
{
logger.Info("[VDR] Start GetChannels");
var root = json.DeserializeFromStream <RootObject>(stream);
logger.Info("[VDR] got Root Object");
// logger.Info(string.Format("[VDR] Display Root Object: {0}", json.SerializeToString(root)));
// List<ChannelInfo> channels = new List<ChannelInfo>();
if (root != null && root.Channels != null)
{
logger.Info("[VDR] Parse Channel Response");
UtilsHelper.DebugInformation(logger, string.Format("[VDR] ChannelResponse: {0}", json.SerializeToString(root)));
return(root.Channels.Select(i => new ChannelInfo
{
Name = i.name,
ChannelType = i.is_radio ? ChannelType.Radio : ChannelType.TV,
Number = i.number.ToString(_usCulture),
Id = i.channel_id,
ImageUrl = i.image ? string.Format("{0}/channels/image/{1}", _baseUrl, i.channel_id) : null,
HasImage = i.image
}));
}
else
{
logger.Info("[VDR] Parse Channel Response failed");
logger.Info(string.Format("[VDR] ChannelResponse: {0}", json.SerializeToString(root)));
}
return(new List <ChannelInfo>());
}
public IEnumerable<ChannelInfo> GetChannels(Stream stream, IJsonSerializer json,ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
if (root.channelsJSONObject.rtn != null && root.channelsJSONObject.rtn.Error)
{
logger.Error(root.channelsJSONObject.rtn.Message ?? "Failed to download channel information.");
throw new ApplicationException(root.channelsJSONObject.rtn.Message ?? "Failed to download channel information.");
}
if (root.channelsJSONObject != null && root.channelsJSONObject.Channels != null)
{
UtilsHelper.DebugInformation(logger,string.Format("[NextPvr] ChannelResponse: {0}", json.SerializeToString(root)));
return root.channelsJSONObject.Channels.Select(i => new ChannelInfo
{
Name = i.channel.channelName,
Number = i.channel.channelFormattedNumber.ToString(_usCulture),
Id = i.channel.channelOID.ToString(_usCulture),
ImageUrl = string.IsNullOrEmpty(i.channel.channelIcon) ? null : (_baseUrl + "/" + i.channel.channelIcon),
HasImage = !string.IsNullOrEmpty(i.channel.channelIcon)
});
}
return new List<ChannelInfo>();
}
public async Task <object> Get(ReviewRequest request)
{
var parms = "?id=" + request.Id;
if (request.MaxRating > 0)
{
parms += "&max=" + request.MaxRating;
}
if (request.MinRating > 0)
{
parms += "&min=" + request.MinRating;
}
if (request.MinRating > 0)
{
parms += "&limit=" + request.Limit;
}
if (request.ForceTitle)
{
parms += "&title=true";
}
using (var result = await _httpClient.Get(MbAdminUrl + "/service/packageReview/retrieve" + parms, CancellationToken.None)
.ConfigureAwait(false))
{
var reviews = _serializer.DeserializeFromStream <List <PackageReviewInfo> >(result);
return(ToOptimizedResult(reviews));
}
}
/// <summary>
/// Retrieve all users from the database
/// </summary>
/// <returns>IEnumerable{User}.</returns>
public IEnumerable <User> RetrieveAllUsers()
{
var list = new List <User>();
using (WriteLock.Read())
{
using (var connection = CreateConnection(true))
{
foreach (var row in connection.Query("select guid,data from users"))
{
var id = row[0].ReadGuidFromBlob();
using (var stream = _memoryStreamProvider.CreateNew(row[1].ToBlob()))
{
stream.Position = 0;
var user = _jsonSerializer.DeserializeFromStream <User>(stream);
user.Id = id;
list.Add(user);
}
}
}
}
return(list);
}
/// <summary>
/// Called when [receive].
/// </summary>
/// <param name="bytes">The bytes.</param>
private void OnReceiveInternal(byte[] bytes)
{
LastActivityDate = DateTime.UtcNow;
if (OnReceive == null)
{
return;
}
try
{
WebSocketMessageInfo info;
using (var memoryStream = new MemoryStream(bytes))
{
var stub = (WebSocketMessage <object>)_jsonSerializer.DeserializeFromStream(memoryStream, typeof(WebSocketMessage <object>));
info = new WebSocketMessageInfo
{
MessageType = stub.MessageType,
Data = stub.Data == null ? null : stub.Data.ToString()
};
}
info.Connection = this;
OnReceive(info);
}
catch (Exception ex)
{
_logger.ErrorException("Error processing web socket message", ex);
}
}
private async Task EnsureData(CancellationToken cancellationToken)
{
if (_items == null)
{
_logger.Debug("Getting {0} from {1}", string.Join(MediaSync.PathSeparatorString, GetRemotePath().ToArray()), _provider.Name);
var fileResult = await _provider.GetFiles(new FileQuery
{
FullPath = GetRemotePath().ToArray()
}, _target, cancellationToken).ConfigureAwait(false);
if (fileResult.Items.Length > 0)
{
using (var stream = await _provider.GetFile(fileResult.Items[0].Id, _target, new Progress<double>(), cancellationToken))
{
_items = _json.DeserializeFromStream<List<LocalItem>>(stream);
}
}
else
{
_items = new List<LocalItem>();
}
}
}
public static CaptureCardList ParseCaptureCardList(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream <RootCaptureObject>(stream);
UtilsHelper.DebugInformation(logger, string.Format("[MythTV] ParseCaptureCardList Response: {0}", json.SerializeToString(root)));
return(root.CaptureCardList);
}
protected override async Task <IEnumerable <ChannelInfo> > GetChannelsInternal(TunerHostInfo info, CancellationToken cancellationToken)
{
var options = new HttpRequestOptions
{
Url = string.Format("{0}/lineup.json", GetApiUrl(info, false)),
CancellationToken = cancellationToken
};
using (var stream = await _httpClient.Get(options))
{
var root = _jsonSerializer.DeserializeFromStream <List <Channels> >(stream);
if (root != null)
{
var result = root.Select(i => new ChannelInfo
{
Name = i.GuideName,
Number = i.GuideNumber.ToString(CultureInfo.InvariantCulture),
Id = ChannelIdPrefix + i.GuideNumber.ToString(CultureInfo.InvariantCulture),
IsFavorite = i.Favorite
});
if (info.ImportFavoritesOnly)
{
result = result.Where(i => (i.IsFavorite ?? true)).ToList();
}
return(result);
}
return(new List <ChannelInfo>());
}
}
public async Task <IEnumerable <ChannelInfo> > GetChannels(CancellationToken cancellationToken)
{
ChannelList = new List <ChannelInfo>();
var options = new HttpRequestOptions
{
Url = string.Format("{0}/lineup.json", getWebUrl()),
CancellationToken = cancellationToken
};
using (var stream = await _httpClient.Get(options))
{
var root = _jsonSerializer.DeserializeFromStream <List <Channels> >(stream);
_logger.Info("Found " + root.Count() + "channels on host: " + Url);
_logger.Info("Only Favorites?" + OnlyFavorites);
if (Convert.ToBoolean(_onlyFavorites))
{
root.RemoveAll(x => x.Favorite == false);
}
//root.RemoveAll(i => i.DRM);
if (root != null)
{
ChannelList = root.Select(i => new ChannelInfo
{
Name = i.GuideName,
Number = i.GuideNumber.ToString(CultureInfo.InvariantCulture),
Id = i.GuideNumber.ToString(CultureInfo.InvariantCulture),
}).ToList();
}
else
{
ChannelList = new List <ChannelInfo>();
}
return(ChannelList);
}
}
public static async Task <MBRegistrationRecord> GetRegistrationStatus(IHttpClient httpClient, IJsonSerializer jsonSerializer, string feature, string mb2Equivalent = null)
{
var mac = _networkManager.GetMacAddress();
var data = new Dictionary <string, string> {
{ "feature", feature }, { "key", SupporterKey }, { "mac", mac }, { "mb2equiv", mb2Equivalent }, { "legacykey", LegacyKey }
};
var reg = new RegRecord();
try
{
using (var json = await httpClient.Post(MBValidateUrl, data, CancellationToken.None).ConfigureAwait(false))
{
reg = jsonSerializer.DeserializeFromStream <RegRecord>(json);
}
if (reg.registered)
{
LicenseFile.AddRegCheck(feature);
}
}
catch (Exception)
{
//if we have trouble obtaining from web - allow it if we've validated in the past 30 days
reg.registered = LicenseFile.LastChecked(feature) > DateTime.UtcNow.AddDays(-30);
}
return(new MBRegistrationRecord {
IsRegistered = reg.registered, ExpirationDate = reg.expDate, RegChecked = true
});
}
public IEnumerable <ChannelInfo> GetChannels(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream <RootObject>(stream);
if (root.channelsJSONObject.rtn != null && root.channelsJSONObject.rtn.Error)
{
logger.Error(root.channelsJSONObject.rtn.Message ?? "Failed to download channel information.");
throw new ApplicationException(root.channelsJSONObject.rtn.Message ?? "Failed to download channel information.");
}
if (root.channelsJSONObject != null && root.channelsJSONObject.Channels != null)
{
UtilsHelper.DebugInformation(logger, string.Format("[NextPvr] ChannelResponse: {0}", json.SerializeToString(root)));
return(root.channelsJSONObject.Channels.Select(i => new ChannelInfo
{
Name = i.channel.channelName,
Number = i.channel.channelFormattedNumber.ToString(_usCulture),
Id = i.channel.channelOID.ToString(_usCulture),
ImageUrl = string.IsNullOrEmpty(i.channel.channelIcon) ? null : (_baseUrl + "/" + i.channel.channelIcon),
HasImage = !string.IsNullOrEmpty(i.channel.channelIcon)
}));
}
return(new List <ChannelInfo>());
}
private RecRule GetOneRecRule(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream <RecRuleRoot>(stream);
logger.Debug(string.Format("[MythTV] GetOneRecRule Response: {0}",
json.SerializeToString(root)));
return(root.RecRule);
}
protected async Task <T> ExecuteRequest <T>(string url, CancellationToken cancellationToken)
{
var httpRequest = await PrepareHttpRequestOptions(url, cancellationToken);
var result = await _httpClient.Get(httpRequest);
return(_jsonSerializer.DeserializeFromStream <T>(result));
}
public IEnumerable <SeriesTimerInfo> GetSeriesTimers(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream <RecRuleListRoot>(stream);
return(root.RecRuleList.RecRules
.Where(rule => rule.Type.Equals("Record All"))
.Select(i => RecRuleToSeriesTimerInfo(i)));
}
/// <summary>
/// Gets all available packages.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="packageType">Type of the package.</param>
/// <param name="applicationVersion">The application version.</param>
/// <returns>Task{List{PackageInfo}}.</returns>
public async Task <IEnumerable <PackageInfo> > GetAvailablePackages(CancellationToken cancellationToken,
PackageType?packageType = null,
Version applicationVersion = null)
{
var data = new Dictionary <string, string> {
{ "key", _securityManager.SupporterKey }, { "mac", _networkManager.GetMacAddress() }
};
using (var json = await _httpClient.Post(Constants.Constants.MbAdminUrl + "service/package/retrieveall", data, cancellationToken).ConfigureAwait(false))
{
cancellationToken.ThrowIfCancellationRequested();
var packages = _jsonSerializer.DeserializeFromStream <List <PackageInfo> >(json).ToList();
return(FilterPackages(packages, packageType, applicationVersion));
}
}
private DisplayPreferences Get(IReadOnlyList <IResultSetValue> row)
{
using (var stream = new MemoryStream(row[0].ToBlob()))
{
stream.Position = 0;
return(_jsonSerializer.DeserializeFromStream <DisplayPreferences>(stream));
}
}
public List <string> GetRecGroupList(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream <RootRecGroupList>(stream);
var ans = root.StringList;
ans.Add("Deleted");
return(ans);
}
private async Task <UpdateInfoData> Do(GetUpdateInfo request)
{
var r = new UpdateInfoData()
{
LoadedVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
PendingLoadVersion = GetPendingLoadVersion(),
};
try
{
var resp = await client.GetAsync("https://api.github.com/repos/JavScraper/Emby.Plugins.JavScraper/releases/latest");
if (resp.StatusCode == System.Net.HttpStatusCode.OK)
{
var data = jsonSerializer.DeserializeFromStream <Rootobject>(await resp.Content.ReadAsStreamAsync());
r.UpdateMessage = data.body;
foreach (var v in data.assets.Where(o => o.name.IndexOf("JavScraper", StringComparison.OrdinalIgnoreCase) >= 0 && o.name.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)))
{
var m = regexVersion.Match(v.name);
if (m.Success)
{
r.LatestVersion = m.ToString();
r.LatestUrl = v.browser_download_url;
break;
}
}
}
else
{
r.ErrorMessage = "获取新版下失败。";
return(r);
}
}
catch (Exception ex)
{
r.ErrorMessage = ex.Message;
return(r);
}
//r.PendingLoadVersion = "1.0.0";
if (request.update == true && r.HasNewVersion)
{
try
{
var ms = await client.GetStreamAsync(r.LatestUrl);
zipClient.ExtractAllFromZip(ms, appPaths.PluginsPath, true);
r.PendingLoadVersion = GetPendingLoadVersion();
}
catch (Exception ex)
{
r.ErrorMessage = $"更新失败：{ex.Message}";
}
}
return(r);
}
protected async Task <TResponse> Post <TRequest, TResponse>(TRequest request) where TRequest : BaseAuthedRequest where TResponse : BaseResponse
{
var data = request.ToDictionary();
//Append the signature
Helpers.AppendSignature(ref data);
var options = new HttpRequestOptions
{
Url = BuildPostUrl(request.Secure),
ResourcePool = Plugin.LastfmResourcePool,
RequestContentType = "application/json",
CancellationToken = CancellationToken.None,
TimeoutMs = 120000,
LogErrorResponseBody = false,
LogRequest = true,
BufferContent = false,
EnableHttpCompression = false,
EnableKeepAlive = false
};
options.SetPostData(data);
using (var httpResponseInfo = await _httpClient.Post(options))
{
try
{
var result = _jsonSerializer.DeserializeFromStream <TResponse>(httpResponseInfo.Content);
//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);
}
}
private async Task <ChannelItemResult> GetShowList(InternalChannelItemQuery query, CancellationToken cancellationToken)
{
var items = new List <ChannelItemInfo>();
using (var site = await _httpClient.Get(new HttpRequestOptions()
{
Url = String.Format("http://www.cbs.com/carousels/showsByCategory/{0}/offset/0/limit/99/", query.FolderId),
CancellationToken = CancellationToken.None
}).ConfigureAwait(false))
{
var showList = _jsonSerializer.DeserializeFromStream <ShowList>(site);
foreach (var c in showList.result.data)
{
if ((c.filepath_ipad == "") || (c.filepath_show_logo == ""))
{
continue;
}
if ((c.title == "Live On Letterman") || (c.title == "The CBS Dream Team...It's Epic"))
{
continue;
}
var url = c.link;
if (!url.Contains("/video"))
{
url = url + "video";
}
var thumb = c.filepath_ipad;
items.Add(new ChannelItemInfo
{
Name = c.title,
ImageUrl = thumb,
Id = "category!_" + url,
Type = ChannelItemType.Folder
});
}
}
return(new ChannelItemResult
{
Items = items.ToList()
});
}
public void Post(UpdateNamedConfiguration request)
{
var key = GetPathValue(2);
var configurationType = _configurationManager.GetConfigurationType(key);
var configuration = _jsonSerializer.DeserializeFromStream(request.RequestStream, configurationType);
_configurationManager.SaveConfiguration(key, configuration);
}
public IEnumerable<ProgramInfo> GetPrograms(Stream stream, IJsonSerializer json, string channelId, ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
logger.Debug("[NextPvr] GetPrograms Response: {0}",json.SerializeToString(root));
var listings = root.Guide.Listings;
return listings.Where(i => string.Equals(i.Channel.channelOID.ToString(_usCulture), channelId, StringComparison.OrdinalIgnoreCase))
.SelectMany(i => i.EPGEvents.Select(e => GetProgram(i.Channel, e.epgEventJSONObject.epgEvent)));
}
public bool? RecordingError(Stream stream, IJsonSerializer json,ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
if (root.epgEventJSONObject != null && root.epgEventJSONObject.rtn != null)
{
UtilsHelper.DebugInformation(logger,string.Format("[NextPvr] RecordingError Response: {0}", json.SerializeToString(root)));
return root.epgEventJSONObject.rtn.Error;
}
return null;
}
public bool LoggedIn(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
if (root.SIDValidation != null)
{
logger.Debug("[NextPvr] connection validation: {0}", json.SerializeToString(root));
return root.SIDValidation.validated;
}
logger.Error("[NextPvr] Failed to validate your connection with NextPvr.");
throw new ApplicationException("Failed to validate your connection with NextPvr.");
}
public VLCObj GetVLCResponse(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
if (root.JSONVlcObject.VLC_Obj != null && root.JSONVlcObject.VLC_Obj.isVlcAvailable == true)
{
UtilsHelper.DebugInformation(logger,string.Format("[NextPvr] VLC Response: {0}", json.SerializeToString(root)));
return root.JSONVlcObject.VLC_Obj;
}
logger.Error("[NextPvr] Failed to load the VLC from NEWA");
throw new ApplicationException("Failed to load the VLC from NEWA.");
}
public ClientKeys GetClientKeys(Stream stream, IJsonSerializer json,ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
if (root.clientKeys != null && root.clientKeys.sid != null && root.clientKeys.salt != null)
{
logger.Debug("[NextPvr] ClientKeys: {0}", json.SerializeToString(root));
return root.clientKeys;
}
logger.Error("[NextPvr] Failed to load the ClientKeys from NextPvr.");
throw new ApplicationException("Failed to load the ClientKeys from NextPvr.");
}
public IEnumerable<SeriesTimerInfo> GetSeriesTimers(Stream stream, IJsonSerializer json,ILogger logger)
{
if (stream == null)
{
logger.Error("[NextPvr] GetSeriesTimers stream == null");
throw new ArgumentNullException("stream");
}
var root = json.DeserializeFromStream<RootObject>(stream);
UtilsHelper.DebugInformation(logger,string.Format("[NextPvr] GetSeriesTimers Response: {0}", json.SerializeToString(root)));
return root.ManageResults
.EPGEvents
.Select(i => i.epgEventJSONObject)
// Seeing epgEventJSONObject coming back null for some responses
.Where(i => i != null)
// Seeing recurring parents coming back with these reponses, for some reason
.Where(i => i.recurr != null)
.Select(GetSeriesTimerInfo);
}
public TunerResponse(Stream stream, IJsonSerializer json)
{
_root = json.DeserializeFromStream<RootObject>(stream);
}
public VersionCheckResponse(Stream stream, IJsonSerializer json)
{
_root = json.DeserializeFromStream<RootObject>(stream);
}
public ScheduleSettings GetScheduleSettings(Stream stream, IJsonSerializer json)
{
return json.DeserializeFromStream<ScheduleSettings>(stream);
}
public static CaptureCardList ParseCaptureCardList(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream<RootCaptureObject>(stream);
UtilsHelper.DebugInformation(logger, string.Format("[MythTV] ParseCaptureCardList Response: {0}", json.SerializeToString(root)));
return root.CaptureCardList;
}
/// <summary>
/// Gets all user data.
/// </summary>
/// <param name="oldDatabase">The old database.</param>
/// <param name="jsonSerializer">The json serializer.</param>
/// <returns>IEnumerable{UserItemData}.</returns>
private static IEnumerable<UserItemData> GetAllUserData(IDbConnection oldDatabase, IJsonSerializer jsonSerializer)
{
using (var cmd = oldDatabase.CreateCommand())
{
cmd.CommandText = "select userId,key,data from userdata";
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult))
{
while (reader.Read())
{
var userId = reader.GetGuid(0);
var key = reader.GetString(1);
using (var stream = reader.GetMemoryStream(2))
{
var userData = jsonSerializer.DeserializeFromStream<UserItemData>(stream);
userData.UserId = userId;
userData.Key = key;
yield return userData;
}
}
}
}
}
private static RecRuleListRoot ParseRecRules(Stream stream, IJsonSerializer json)
{
return json.DeserializeFromStream<RecRuleListRoot>(stream);
}
internal static Program ParseRecorded(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream<RootProgramObject>(stream);
return root.Program;
}
public Rtn GetVLCReturn(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream<RootObject>(stream);
UtilsHelper.DebugInformation(logger,string.Format("[NextPvr] VLC Return: {0}", json.SerializeToString(root)));
return root.JSONVlcObject.rtn;
}
public static RecordId ParseRecordId(Stream stream, IJsonSerializer json)
{
return json.DeserializeFromStream<RecordId>(stream);
}
public static ProgramList ParseProgramList(Stream stream, IJsonSerializer json, ILogger logger)
{
var root = json.DeserializeFromStream<RootProgramListObject>(stream);
return root.ProgramList;
}
