1
0
mirror of https://github.com/Sonarr/Sonarr.git synced 2024-10-31 16:02:29 +01:00
Sonarr/NzbDrone.Core/Providers/XbmcProvider.cs

474 lines
18 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
2011-03-06 22:36:09 +01:00
using System.IO;
using System.Linq;
2011-03-06 22:36:09 +01:00
using System.Xml.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NLog;
2012-02-11 01:48:20 +01:00
using NzbDrone.Common;
2013-02-24 07:48:52 +01:00
using NzbDrone.Core.Configuration;
using NzbDrone.Core.Tv;
using NzbDrone.Core.Model.Xbmc;
using NzbDrone.Core.Providers.Xbmc;
namespace NzbDrone.Core.Providers
{
2011-04-08 17:15:51 +02:00
public class XbmcProvider
{
2011-04-10 04:44:01 +02:00
private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
2013-02-24 07:48:52 +01:00
private readonly IConfigService _configService;
2013-04-11 01:41:45 +02:00
private readonly IHttpProvider _httpProvider;
private readonly EventClientProvider _eventClientProvider;
2013-04-11 01:41:45 +02:00
public XbmcProvider(IConfigService configService, IHttpProvider httpProvider, EventClientProvider eventClientProvider)
{
2013-02-24 07:48:52 +01:00
_configService = configService;
_httpProvider = httpProvider;
_eventClientProvider = eventClientProvider;
}
public XbmcProvider()
{
}
2011-04-08 17:15:51 +02:00
public virtual void Notify(string header, string message)
{
//Always use EventServer, until Json has real support for it
2013-02-24 07:48:52 +01:00
foreach (var host in _configService.XbmcHosts.Split(','))
{
Logger.Trace("Sending Notifcation to XBMC Host: {0}", host);
_eventClientProvider.SendNotification(header, message, IconType.Jpeg, "NzbDrone.jpg", GetHostWithoutPort(host));
}
}
public virtual void Update(Series series)
{
//Use Json for Eden/Nightly or depricated HTTP for 10.x (Dharma) to get the proper path
//Perform update with EventServer (Json currently doesn't support updating a specific path only - July 2011)
2013-02-24 07:48:52 +01:00
var username = _configService.XbmcUsername;
var password = _configService.XbmcPassword;
2013-02-24 07:48:52 +01:00
foreach (var host in _configService.XbmcHosts.Split(','))
{
Logger.Trace("Determining version of XBMC Host: {0}", host);
var version = GetJsonVersion(host, username, password);
//If Dharma
2012-12-13 22:52:54 +01:00
if (version == new XbmcVersion(2))
{
//Check for active player only when we should skip updates when playing
2013-02-24 07:48:52 +01:00
if (!_configService.XbmcUpdateWhenPlaying)
{
Logger.Trace("Determining if there are any active players on XBMC host: {0}", host);
var activePlayers = GetActivePlayersDharma(host, username, password);
//If video is currently playing, then skip update
2013-04-03 04:20:05 +02:00
if (activePlayers["video"])
{
Logger.Debug("Video is currently playing, skipping library update");
continue;
}
}
UpdateWithHttp(series, host, username, password);
}
//If Eden or newer (attempting to make it future compatible)
2012-12-13 22:52:54 +01:00
else if (version == new XbmcVersion(3) || version == new XbmcVersion(4))
{
//Check for active player only when we should skip updates when playing
2013-02-24 07:48:52 +01:00
if (!_configService.XbmcUpdateWhenPlaying)
{
Logger.Trace("Determining if there are any active players on XBMC host: {0}", host);
var activePlayers = GetActivePlayersEden(host, username, password);
//If video is currently playing, then skip update
2013-04-03 04:20:05 +02:00
if (activePlayers.Any(a => a.Type.Equals("video")))
{
Logger.Debug("Video is currently playing, skipping library update");
continue;
}
}
2012-12-14 06:18:15 +01:00
UpdateWithJsonExecBuiltIn(series, host, username, password);
}
2012-12-13 22:52:54 +01:00
else if (version >= new XbmcVersion(5))
{
//Check for active player only when we should skip updates when playing
2013-02-24 07:48:52 +01:00
if (!_configService.XbmcUpdateWhenPlaying)
2012-12-13 22:52:54 +01:00
{
Logger.Trace("Determining if there are any active players on XBMC host: {0}", host);
var activePlayers = GetActivePlayersEden(host, username, password);
//If video is currently playing, then skip update
if (activePlayers.Any(a => a.Type.Equals("video")))
{
Logger.Debug("Video is currently playing, skipping library update");
continue;
}
}
2012-12-14 06:18:15 +01:00
UpdateWithJsonVideoLibraryScan(series, host, username, password);
2012-12-13 22:52:54 +01:00
}
//Log Version zero if check failed
else
Logger.Trace("Unknown version: [{0}], skipping.", version);
}
}
2012-12-14 06:18:15 +01:00
public virtual bool UpdateWithJsonExecBuiltIn(Series series, string host, string username, string password)
{
try
2011-03-06 22:36:09 +01:00
{
//Use Json!
var xbmcShows = GetTvShowsJson(host, username, password);
TvShow path = null;
//Log if response is null, otherwise try to find XBMC's path for series
if (xbmcShows == null)
Logger.Trace("Failed to get TV Shows from XBMC");
else
path = xbmcShows.FirstOrDefault(s => s.ImdbNumber == series.Id || s.Label == series.Title);
//var hostOnly = GetHostWithoutPort(host);
if (path != null)
{
Logger.Trace("Updating series [{0}] (Path: {1}) on XBMC host: {2}", series.Title, path.File, host);
var command = String.Format("ExecBuiltIn(UpdateLibrary(video,{0}))", path.File);
SendCommand(host, command, username, password);
}
else
{
Logger.Trace("Series [{0}] doesn't exist on XBMC host: {1}, Updating Entire Library", series.Title, host);
SendCommand(host, "ExecBuiltIn(UpdateLibrary(video))", username, password);
}
2011-03-06 22:36:09 +01:00
}
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
return false;
}
return true;
}
2012-12-14 06:18:15 +01:00
public virtual bool UpdateWithJsonVideoLibraryScan(Series series, string host, string username, string password)
{
try
{
//Use Json!
var xbmcShows = GetTvShowsJson(host, username, password);
TvShow path = null;
//Log if response is null, otherwise try to find XBMC's path for series
if (xbmcShows == null)
Logger.Trace("Failed to get TV Shows from XBMC");
else
path = xbmcShows.FirstOrDefault(s => s.ImdbNumber == series.Id || s.Label == series.Title);
2012-12-14 06:18:15 +01:00
var postJson = new JObject();
postJson.Add(new JProperty("jsonrpc", "2.0"));
postJson.Add(new JProperty("method", "VideoLibrary.Scan"));
postJson.Add(new JProperty("id", 55));
if (path != null)
{
Logger.Trace("Updating series [{0}] (Path: {1}) on XBMC host: {2}", series.Title, path.File, host);
postJson.Add(new JProperty("params", new JObject(new JObject(new JProperty("directory", path.File)))));
}
else
Logger.Trace("Series [{0}] doesn't exist on XBMC host: {1}, Updating Entire Library", series.Title, host);
var response = _httpProvider.PostCommand(host, username, password, postJson.ToString());
if (CheckForJsonError(response))
return false;
Logger.Trace(" from response");
var result = JsonConvert.DeserializeObject<XbmcJsonResult<String>>(response);
2013-04-03 04:20:05 +02:00
if (!result.Result.Equals("OK", StringComparison.InvariantCultureIgnoreCase))
2012-12-14 06:18:15 +01:00
return false;
}
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
return false;
}
return true;
}
public virtual bool UpdateWithHttp(Series series, string host, string username, string password)
{
try
2011-03-06 22:36:09 +01:00
{
Logger.Trace("Sending Update DB Request to XBMC Host: {0}", host);
var xbmcSeriesPath = GetXbmcSeriesPath(host, series.Id, username, password);
2011-03-06 22:36:09 +01:00
//If the path is found update it, else update the whole library
if (!String.IsNullOrEmpty(xbmcSeriesPath))
{
Logger.Trace("Updating series [{0}] on XBMC host: {1}", series.Title, host);
var command = String.Format("ExecBuiltIn(UpdateLibrary(video,{0}))", xbmcSeriesPath);
SendCommand(host, command, username, password);
}
else
2011-03-06 22:36:09 +01:00
{
//Update the entire library
Logger.Trace("Series [{0}] doesn't exist on XBMC host: {1}, Updating Entire Library", series.Title, host);
SendCommand(host, "ExecBuiltIn(UpdateLibrary(video))", username, password);
2011-03-06 22:36:09 +01:00
}
}
2011-03-06 22:36:09 +01:00
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
return false;
2011-03-06 22:36:09 +01:00
}
2013-04-03 04:20:05 +02:00
return true;
}
2011-04-08 17:15:51 +02:00
public virtual void Clean()
{
//Use EventServer, once Dharma is extinct use Json?
2013-02-24 07:48:52 +01:00
foreach (var host in _configService.XbmcHosts.Split(','))
2011-03-06 22:36:09 +01:00
{
Logger.Trace("Sending DB Clean Request to XBMC Host: {0}", host);
var command = "ExecBuiltIn(CleanLibrary(video))";
_eventClientProvider.SendAction(GetHostWithoutPort(host), ActionType.ExecBuiltin, command);
2011-03-06 22:36:09 +01:00
}
}
public virtual string SendCommand(string host, string command, string username, string password)
{
var url = String.Format("http://{0}/xbmcCmds/xbmcHttp?command={1}", host, command);
if (!String.IsNullOrEmpty(username))
{
return _httpProvider.DownloadString(url, username, password);
}
2011-04-10 04:44:01 +02:00
return _httpProvider.DownloadString(url);
}
2011-03-06 22:36:09 +01:00
public virtual string GetXbmcSeriesPath(string host, int seriesId, string username, string password)
2011-03-06 22:36:09 +01:00
{
2011-04-10 04:44:01 +02:00
var query =
String.Format(
"select path.strPath from path, tvshow, tvshowlinkpath where tvshow.c12 = {0} and tvshowlinkpath.idShow = tvshow.idShow and tvshowlinkpath.idPath = path.idPath",
seriesId);
2011-03-06 22:36:09 +01:00
var command = String.Format("QueryVideoDatabase({0})", query);
const string setResponseCommand =
2011-04-10 04:44:01 +02:00
"SetResponseFormat(webheader;false;webfooter;false;header;<xml>;footer;</xml>;opentag;<tag>;closetag;</tag>;closefinaltag;false)";
const string resetResponseCommand = "SetResponseFormat()";
2011-03-06 22:36:09 +01:00
SendCommand(host, setResponseCommand, username, password);
var response = SendCommand(host, command, username, password);
SendCommand(host, resetResponseCommand, username, password);
2011-03-06 22:36:09 +01:00
if (String.IsNullOrEmpty(response))
return String.Empty;
var xDoc = XDocument.Load(new StringReader(response.Replace("&", "&amp;")));
2011-03-06 22:36:09 +01:00
var xml = (from x in xDoc.Descendants("xml") select x).FirstOrDefault();
if (xml == null)
return String.Empty;
var field = xml.Descendants("field").FirstOrDefault();
if (field == null)
return String.Empty;
return field.Value;
}
2012-12-13 22:52:54 +01:00
public virtual XbmcVersion GetJsonVersion(string host, string username, string password)
{
//2 = Dharma
2012-12-13 22:52:54 +01:00
//3 & 4 = Eden
//5 & 6 = Frodo
try
{
var postJson = new JObject();
postJson.Add(new JProperty("jsonrpc", "2.0"));
postJson.Add(new JProperty("method", "JSONRPC.Version"));
postJson.Add(new JProperty("id", 10));
var response = _httpProvider.PostCommand(host, username, password, postJson.ToString());
if (CheckForJsonError(response))
2012-12-13 22:52:54 +01:00
return new XbmcVersion();
Logger.Trace("Getting version from response");
2012-12-13 22:52:54 +01:00
var result = JsonConvert.DeserializeObject<XbmcJsonResult<JObject>>(response);
var versionObject = result.Result.Property("version");
if (versionObject.Value.Type == JTokenType.Integer)
return new XbmcVersion((int)versionObject.Value);
2013-04-03 04:20:05 +02:00
if (versionObject.Value.Type == JTokenType.Object)
2012-12-13 22:52:54 +01:00
return JsonConvert.DeserializeObject<XbmcVersion>(versionObject.Value.ToString());
throw new InvalidCastException("Unknown Version structure!: " + versionObject);
}
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
}
2012-12-13 22:52:54 +01:00
return new XbmcVersion();
}
public virtual Dictionary<string, bool> GetActivePlayersDharma(string host, string username, string password)
{
try
{
var postJson = new JObject();
postJson.Add(new JProperty("jsonrpc", "2.0"));
postJson.Add(new JProperty("method", "Player.GetActivePlayers"));
postJson.Add(new JProperty("id", 10));
var response = _httpProvider.PostCommand(host, username, password, postJson.ToString());
if (CheckForJsonError(response))
return null;
var result = JsonConvert.DeserializeObject<ActivePlayersDharmaResult>(response);
return result.Result;
}
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
}
return null;
}
public virtual List<ActivePlayer> GetActivePlayersEden(string host, string username, string password)
{
try
{
var postJson = new JObject();
postJson.Add(new JProperty("jsonrpc", "2.0"));
postJson.Add(new JProperty("method", "Player.GetActivePlayers"));
postJson.Add(new JProperty("id", 10));
var response = _httpProvider.PostCommand(host, username, password, postJson.ToString());
if (CheckForJsonError(response))
return null;
var result = JsonConvert.DeserializeObject<ActivePlayersEdenResult>(response);
return result.Result;
}
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
}
return null;
}
public virtual List<TvShow> GetTvShowsJson(string host, string username, string password)
{
try
{
var postJson = new JObject();
postJson.Add(new JProperty("jsonrpc", "2.0"));
postJson.Add(new JProperty("method", "VideoLibrary.GetTvShows"));
postJson.Add(new JProperty("params", new JObject { new JProperty("properties", new string[] { "file", "imdbnumber" }) }));
postJson.Add(new JProperty("id", 10));
var response = _httpProvider.PostCommand(host, username, password, postJson.ToString());
if (CheckForJsonError(response))
return null;
var result = JsonConvert.DeserializeObject<TvShowResponse>(response);
var shows = result.Result.TvShows;
return shows;
}
catch (Exception ex)
{
Logger.DebugException(ex.Message, ex);
}
return null;
}
public virtual bool CheckForJsonError(string response)
{
Logger.Trace("Looking for error in response: {0}", response);
if (response.StartsWith("{\"error\""))
{
2013-04-03 04:20:05 +02:00
var error = JsonConvert.DeserializeObject<ErrorResult>(response);
var code = error.Error["code"];
var message = error.Error["message"];
Logger.Debug("XBMC Json Error. Code = {0}, Message: {1}", code, message);
return true;
}
2011-09-27 19:41:36 +02:00
if (String.IsNullOrWhiteSpace(response))
{
Logger.Debug("Invalid response from XBMC, the response is not valid JSON");
return true;
}
return false;
}
public virtual void TestNotification(string hosts)
{
foreach (var host in hosts.Split(','))
{
Logger.Trace("Sending Test Notifcation to XBMC Host: {0}", host);
_eventClientProvider.SendNotification("Test Notification", "Success! Notifications are setup correctly", IconType.Jpeg, "NzbDrone.jpg", GetHostWithoutPort(host));
}
}
public virtual void TestJsonApi(string hosts, string username, string password)
{
foreach (var host in hosts.Split(','))
{
Logger.Trace("Sending Test Notifcation to XBMC Host: {0}", host);
var version = GetJsonVersion(host, username, password);
2012-12-13 22:52:54 +01:00
if (version == new XbmcVersion())
throw new Exception("Failed to get JSON version in test");
}
}
private string GetHostWithoutPort(string address)
{
return address.Split(':')[0];
}
}
2011-04-10 04:44:01 +02:00
}