internal string GetSeriesPath(XbmcSettings settings, Series series)
{
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",
series.TvdbId);
var command = string.Format("QueryVideoDatabase({0})", query);
const string setResponseCommand =
"SetResponseFormat(webheader;false;webfooter;false;header;<xml>;footer;</xml>;opentag;<tag>;closetag;</tag>;closefinaltag;false)";
const string resetResponseCommand = "SetResponseFormat()";
SendCommand(settings, setResponseCommand);
var response = SendCommand(settings, command);
SendCommand(settings, resetResponseCommand);
if (string.IsNullOrEmpty(response))
return string.Empty;
var xDoc = XDocument.Load(new StringReader(response.Replace("&", "&")));
var xml = xDoc.Descendants("xml").Select(x => x).FirstOrDefault();
if (xml == null)
return null;
var field = xml.Descendants("field").FirstOrDefault();
if (field == null)
return null;
return field.Value;
}
private void UpdateLibrary(XbmcSettings settings, Series series)
{
try
{
var seriesPath = GetSeriesPath(settings, series);
if (seriesPath != null)
{
_logger.Debug("Updating series {0} (Path: {1}) on XBMC host: {2}", series, seriesPath, settings.Address);
}
else
{
_logger.Debug("Series {0} doesn't exist on XBMC host: {1}, Updating Entire Library", series,
settings.Address);
}
var response = _proxy.UpdateLibrary(settings, seriesPath);
if (!response.Equals("OK", StringComparison.InvariantCultureIgnoreCase))
{
_logger.Debug("Failed to update library for: {0}", settings.Address);
}
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
}
public void Notify(XbmcSettings settings, string title, string message)
{
var notification = string.Format("Notification({0},{1},{2},{3})", title, message, settings.DisplayTime * 1000, "https://raw.github.com/Sonarr/Sonarr/develop/Logo/64.png");
var command = BuildExecBuiltInCommand(notification);
SendCommand(settings, command);
}
public void Clean(XbmcSettings settings)
{
const string cleanVideoLibrary = "CleanLibrary(video)";
var command = BuildExecBuiltInCommand(cleanVideoLibrary);
SendCommand(settings, command);
}
public XbmcVersion GetJsonVersion(XbmcSettings settings)
{
try
{
var postJson = new JObject();
postJson.Add(new JProperty("jsonrpc", "2.0"));
postJson.Add(new JProperty("method", "JSONRPC.Version"));
postJson.Add(new JProperty("id", 1));
var response = _httpProvider.PostCommand(settings.Address, settings.Username, settings.Password, postJson.ToString());
_logger.Debug("Getting version from response: " + response);
var result = Json.Deserialize<XbmcJsonResult<JObject>>(response);
var versionObject = result.Result.Property("version");
if (versionObject.Value.Type == JTokenType.Integer)
return new XbmcVersion((int)versionObject.Value);
if (versionObject.Value.Type == JTokenType.Object)
return Json.Deserialize<XbmcVersion>(versionObject.Value.ToString());
throw new InvalidCastException("Unknown Version structure!: " + versionObject);
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
return new XbmcVersion();
}
public ValidationFailure Test(XbmcSettings settings, string message)
{
_xbmcVersionCache.Clear();
try
{
_logger.Debug("Determining version of Host: {0}", settings.Address);
var version = GetJsonVersion(settings);
_logger.Debug("Version is: {0}", version);
if (version == new XbmcVersion(0))
{
throw new InvalidXbmcVersionException("Version received from XBMC is invalid, please correct your settings.");
}
Notify(settings, "Test Notification", message);
}
catch (Exception ex)
{
_logger.Error(ex, "Unable to send test message: " + ex.Message);
return new ValidationFailure("Host", "Unable to send test message");
}
return null;
}
public List<ActivePlayer> GetActivePlayers(XbmcSettings settings)
{
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(settings.Address, settings.Username, settings.Password, postJson.ToString());
if (CheckForError(response))
return new List<ActivePlayer>();
var result = Json.Deserialize<ActivePlayersEdenResult>(response);
return result.Result;
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
return new List<ActivePlayer>();
}
public List<ActivePlayer> GetActivePlayers(XbmcSettings settings)
{
var request = new RestRequest();
var response = ProcessRequest(request, settings, "Player.GetActivePlayers");
return Json.Deserialize<ActivePlayersEdenResult>(response).Result;
}
public List<TvShow> GetSeries(XbmcSettings settings)
{
var request = new RestRequest();
var parameters = new Dictionary<string, object>();
parameters.Add("properties", new[] { "file", "imdbnumber" });
var response = ProcessRequest(request, settings, "VideoLibrary.GetTvShows", parameters);
return Json.Deserialize<TvShowResponse>(response).Result.TvShows;
}
public void Notify(XbmcSettings settings, string title, string message)
{
var request = new RestRequest();
var parameters = new Dictionary<string, object>();
parameters.Add("title", title);
parameters.Add("message", message);
parameters.Add("image", "https://raw.github.com/Sonarr/Sonarr/develop/Logo/64.png");
parameters.Add("displaytime", settings.DisplayTime * 1000);
ProcessRequest(request, settings, "GUI.ShowNotification", parameters);
}
public void Notify(XbmcSettings settings, string title, string message)
{
var parameters = new JObject(
new JProperty("title", title),
new JProperty("message", message),
new JProperty("image", "https://raw.github.com/NzbDrone/NzbDrone/master/Logo/64.png"),
new JProperty("displaytime", settings.DisplayTime * 1000));
var postJson = BuildJsonRequest("GUI.ShowNotification", parameters);
_httpProvider.PostCommand(settings.Address, settings.Username, settings.Password, postJson.ToString());
}
public void Setup()
{
_settings = new XbmcSettings
{
Host = "localhost",
Port = 8080,
Username = "******",
Password = "******",
AlwaysUpdate = false,
CleanLibrary = false,
UpdateLibrary = true
};
}
private IApiProvider GetApiProvider(XbmcSettings settings)
{
var version = GetJsonVersion(settings);
var apiProvider = _apiProviders.SingleOrDefault(a => a.CanHandle(version));
if (apiProvider == null)
{
var message = string.Format("Invalid API Version: {0} for {1}", version, settings.Address);
throw new InvalidXbmcVersionException(message);
}
return apiProvider;
}
public void Setup()
{
_settings = Builder <XbmcSettings> .CreateNew()
.Build();
_xbmcSeries = Builder <TvShow> .CreateListOfSize(3)
.Build()
.ToList();
Mocker.GetMock <IXbmcJsonApiProxy>()
.Setup(s => s.GetSeries(_settings))
.Returns(_xbmcSeries);
}
public void Setup()
{
_settings = new XbmcSettings
{
Host = "localhost",
Port = 8080,
Username = "******",
Password = "******",
AlwaysUpdate = false,
CleanLibrary = false,
UpdateLibrary = true
};
_expectedUrl = string.Format("http://{0}/xbmcCmds/xbmcHttp?command={1}", _settings.Address, "getcurrentlyplaying");
}
private void Notify(XbmcSettings settings, string header, string message)
{
try
{
if (Settings.Notify)
{
_xbmcService.Notify(Settings, header, message);
}
}
catch (SocketException ex)
{
var logMessage = $"Unable to connect to PHT Host: {Settings.Host}:{Settings.Port}";
_logger.Debug(ex, logMessage);
}
}
private void Notify(XbmcSettings settings, string header, string message)
{
try
{
if (Settings.Notify)
{
_xbmcService.Notify(Settings, header, message);
}
}
catch (SocketException ex)
{
var logMessage = string.Format("Unable to connect to PHT Host: {0}:{1}", Settings.Host, Settings.Port);
_logger.DebugException(logMessage, ex);
}
}
public string UpdateLibrary(XbmcSettings settings, string path)
{
var request = new RestRequest();
var parameters = new Dictionary<string, object>();
parameters.Add("directory", path);
if (path.IsNullOrWhiteSpace())
{
parameters = null;
}
var response = ProcessRequest(request, settings, "VideoLibrary.Scan", parameters);
return Json.Deserialize<XbmcJsonResult<string>>(response).Result;
}
public void Update(XbmcSettings settings, Series series)
{
if (!settings.AlwaysUpdate)
{
_logger.Debug("Determining if there are any active players on XBMC host: {0}", settings.Address);
var activePlayers = GetActivePlayers(settings);
if (activePlayers.Any(a => a.Type.Equals("video")))
{
_logger.Debug("Video is currently playing, skipping library update");
return;
}
}
UpdateLibrary(settings, series);
}
public void Setup()
{
_settings = Builder <XbmcSettings> .CreateNew()
.Build();
_xbmcSeries = Builder <TvShow> .CreateListOfSize(3)
.All()
.With(s => s.ImdbNumber = "0")
.TheFirst(1)
.With(s => s.ImdbNumber = TVDB_ID.ToString())
.Build()
.ToList();
Mocker.GetMock <IXbmcJsonApiProxy>()
.Setup(s => s.GetSeries(_settings))
.Returns(_xbmcSeries);
}
public void Setup()
{
_settings = Builder <XbmcSettings> .CreateNew()
.Build();
_xbmcMovies = Builder <XbmcMovie> .CreateListOfSize(3)
.All()
.With(s => s.ImdbNumber = "tt00000")
.TheFirst(1)
.With(s => s.ImdbNumber = IMDB_ID)
.Build()
.ToList();
Mocker.GetMock <IXbmcJsonApiProxy>()
.Setup(s => s.GetMovies(_settings))
.Returns(_xbmcMovies);
}
public void Setup()
{
_settings = new XbmcSettings
{
Host = "localhost",
Port = 8080,
Username = "******",
Password = "******",
AlwaysUpdate = false,
CleanLibrary = false,
UpdateLibrary = true
};
Mocker.GetMock <IHttpProvider>()
.Setup(s => s.PostCommand(_settings.Address, _settings.Username, _settings.Password,
It.Is <string>(e => e.Replace(" ", "").Replace("\r\n", "").Replace("\t", "").Contains(_expectedJson.Replace(" ", "")))))
.Returns(_tvshowsResponse);
}
public void Setup()
{
_settings = new XbmcSettings
{
Host = "localhost",
Port = 8080,
Username = "******",
Password = "******",
AlwaysUpdate = false,
CleanLibrary = false,
UpdateLibrary = true
};
_fakeSeries = Builder <Series> .CreateNew()
.With(s => s.TvdbId = 79488)
.With(s => s.Title = "30 Rock")
.Build();
}
public void Setup()
{
_settings = new XbmcSettings
{
Host = "localhost",
Port = 8080,
Username = "******",
Password = "******",
AlwaysUpdate = false,
CleanLibrary = false,
UpdateLibrary = true
};
_fakeArtist = Builder <Artist> .CreateNew()
.With(s => s.ForeignArtistId = "9f4e41c3-2648-428e-b8c7-dc10465b49ac")
.With(s => s.Name = "Shawn Desman")
.Build();
}
internal List<ActivePlayer> GetActivePlayers(XbmcSettings settings)
{
try
{
var result = new List<ActivePlayer>();
var response = SendCommand(settings, "getcurrentlyplaying");
if (response.Contains("<li>Filename:[Nothing Playing]")) return new List<ActivePlayer>();
if (response.Contains("<li>Type:Video")) result.Add(new ActivePlayer(1, "video"));
return result;
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
return new List<ActivePlayer>();
}
public void Setup()
{
_settings = Builder <XbmcSettings> .CreateNew()
.Build();
_xbmcArtist = Builder <KodiArtist> .CreateListOfSize(3)
.All()
.With(s => s.MusicbrainzArtistId = new List <string> {
"0"
})
.TheFirst(1)
.With(s => s.MusicbrainzArtistId = new List <string> {
MB_ID.ToString()
})
.Build()
.ToList();
Mocker.GetMock <IXbmcJsonApiProxy>()
.Setup(s => s.GetArtist(_settings))
.Returns(_xbmcArtist);
}
public String GetSeriesPath(XbmcSettings settings, Series series)
{
var allSeries = _proxy.GetSeries(settings);
if (!allSeries.Any())
{
_logger.Debug("No TV shows returned from XBMC");
return null;
}
var matchingSeries = allSeries.FirstOrDefault(s =>
{
var tvdbId = 0;
Int32.TryParse(s.ImdbNumber, out tvdbId);
return tvdbId == series.TvdbId || s.Label == series.Title;
});
if (matchingSeries != null) return matchingSeries.File;
return null;
}
private XbmcVersion GetJsonVersion(XbmcSettings settings)
{
return _xbmcVersionCache.Get(settings.Address, () =>
{
var response = _proxy.GetJsonVersion(settings);
_logger.Debug("Getting version from response: " + response);
var result = Json.Deserialize<XbmcJsonResult<JObject>>(response);
var versionObject = result.Result.Property("version");
if (versionObject.Value.Type == JTokenType.Integer)
{
return new XbmcVersion((int)versionObject.Value);
}
if (versionObject.Value.Type == JTokenType.Object)
{
return Json.Deserialize<XbmcVersion>(versionObject.Value.ToString());
}
throw new InvalidCastException("Unknown Version structure!: " + versionObject);
}, TimeSpan.FromHours(12));
}
public List<ActivePlayer> GetActivePlayers(XbmcSettings settings)
{
return _proxy.GetActivePlayers(settings);
}
private IRestClient BuildClient(XbmcSettings settings)
{
var url = string.Format(@"http://{0}/jsonrpc", settings.Address);
var client = RestClientFactory.BuildClient(url);
if (!settings.Username.IsNullOrWhiteSpace())
{
client.Authenticator = new HttpBasicAuthenticator(settings.Username, settings.Password);
}
return client;
}
public string GetJsonVersion(XbmcSettings settings)
{
var request = new RestRequest();
return ProcessRequest(request, settings, "JSONRPC.Version");
}
public void CleanLibrary(XbmcSettings settings)
{
var request = new RestRequest();
ProcessRequest(request, settings, "VideoLibrary.Clean");
}
private string ProcessRequest(IRestRequest request, XbmcSettings settings, string method, Dictionary<string, object> parameters = null)
{
var client = BuildClient(settings);
request.Method = Method.POST;
request.RequestFormat = DataFormat.Json;
request.JsonSerializer = new JsonNetSerializer();
request.AddBody(new { jsonrpc = "2.0", method = method, id = 10, @params = parameters });
var response = client.ExecuteAndValidate(request);
_logger.Trace("Response: {0}", response.Content);
CheckForError(response);
return response.Content;
}
private string SendCommand(XbmcSettings settings, string command)
{
var url = string.Format("http://{0}/xbmcCmds/xbmcHttp?command={1}", settings.Address, command);
if (!string.IsNullOrEmpty(settings.Username))
{
return _httpProvider.DownloadString(url, settings.Username, settings.Password);
}
return _httpProvider.DownloadString(url);
}
private void UpdateLibrary(XbmcSettings settings, Series series)
{
try
{
_logger.Debug("Sending Update DB Request to XBMC Host: {0}", settings.Address);
var xbmcSeriesPath = GetSeriesPath(settings, series);
//If the path is found update it, else update the whole library
if (!string.IsNullOrEmpty(xbmcSeriesPath))
{
_logger.Debug("Updating series [{0}] on XBMC host: {1}", series, settings.Address);
var command = BuildExecBuiltInCommand(string.Format("UpdateLibrary(video,{0})", xbmcSeriesPath));
SendCommand(settings, command);
}
else
{
//Update the entire library
_logger.Debug("Series [{0}] doesn't exist on XBMC host: {1}, Updating Entire Library", series, settings.Address);
var command = BuildExecBuiltInCommand("UpdateLibrary(video)");
SendCommand(settings, command);
}
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
}
public void Setup()
{
_settings = Builder <XbmcSettings> .CreateNew()
.Build();
}
public void Clean(XbmcSettings settings)
{
_proxy.CleanLibrary(settings);
}
public string GetSeriesPath(XbmcSettings settings, Series series)
{
var allSeries = GetSeries(settings);
if (!allSeries.Any())
{
_logger.Debug("No TV shows returned from XBMC");
return null;
}
var matchingSeries = allSeries.FirstOrDefault(s => s.ImdbNumber == series.TvdbId || s.Label == series.Title);
if (matchingSeries != null) return matchingSeries.File;
return null;
}
public void Notify(XbmcSettings settings, string title, string message)
{
_proxy.Notify(settings, title, message);
}
public void Clean(XbmcSettings settings)
{
var postJson = BuildJsonRequest("VideoLibrary.Clean");
_httpProvider.PostCommand(settings.Address, settings.Username, settings.Password, postJson.ToString());
}
private void UpdateLibrary(XbmcSettings settings, Series series)
{
try
{
var seriesPath = GetSeriesPath(settings, series);
JObject postJson;
if (seriesPath != null)
{
_logger.Debug("Updating series {0} (Path: {1}) on XBMC host: {2}", series, seriesPath, settings.Address);
var parameters = new JObject(new JObject(new JProperty("directory", seriesPath)));
postJson = BuildJsonRequest("VideoLibrary.Scan", parameters);
}
else
{
_logger.Debug("Series {0} doesn't exist on XBMC host: {1}, Updating Entire Library", series,
settings.Address);
postJson = BuildJsonRequest("VideoLibrary.Scan");
}
var response = _httpProvider.PostCommand(settings.Address, settings.Username, settings.Password, postJson.ToString());
if (CheckForError(response)) return;
_logger.Debug(" from response");
var result = Json.Deserialize<XbmcJsonResult<String>>(response);
if (!result.Result.Equals("OK", StringComparison.InvariantCultureIgnoreCase))
{
_logger.Debug("Failed to update library for: {0}", settings.Address);
}
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
}
private List<TvShow> GetSeries(XbmcSettings settings)
{
try
{
var properties = new JObject { new JProperty("properties", new[] { "file", "imdbnumber" }) };
var postJson = BuildJsonRequest("VideoLibrary.GetTvShows", properties);
var response = _httpProvider.PostCommand(settings.Address, settings.Username, settings.Password, postJson.ToString());
if (CheckForError(response))
return new List<TvShow>();
var result = Json.Deserialize<TvShowResponse>(response);
var shows = result.Result.TvShows;
return shows;
}
catch (Exception ex)
{
_logger.DebugException(ex.Message, ex);
}
return new List<TvShow>();
}
