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/Lidarr/Lidarr/develop/Logo/64.png");
parameters.Add("displaytime", settings.DisplayTime * 1000);
ProcessRequest(request, settings, "GUI.ShowNotification", parameters);
}
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 ValidationFailure Test(XbmcSettings settings, string message)
{
try
{
Notify(settings, "Test Notification", message);
}
catch (Exception ex)
{
_logger.Error(ex, "Unable to send test message");
return(new ValidationFailure("Host", "Unable to send test message"));
}
return(null);
}
public string UpdateLibrary(XbmcSettings settings, string path)
{
string response;
if (path == null)
{
response = ProcessRequest(settings, "VideoLibrary.Scan");
}
else
{
response = ProcessRequest(settings, "VideoLibrary.Scan", path);
}
return(Json.Deserialize <XbmcJsonResult <string> >(response).Result);
}
private IRestClient BuildClient(XbmcSettings settings)
{
var url = string.Format(@"http://{0}/jsonrpc", settings.Address);
_logger.Debug("Url: " + url);
var client = RestClientFactory.BuildClient(url);
if (!settings.Username.IsNullOrWhiteSpace())
{
client.Authenticator = new HttpBasicAuthenticator(settings.Username, settings.Password);
}
return(client);
}
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, Artist artist)
{
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("audio")))
{
_logger.Debug("Audio is currently playing, skipping library update");
return;
}
}
UpdateLibrary(settings, artist);
}
public void UpdateMovie(XbmcSettings settings, Movie movie)
{
if (!settings.AlwaysUpdate)
{
_logger.Debug("Determining if there are any active players on XBMC host: {0}", settings.Address);
var activePlayers = _proxy.GetActivePlayers(settings);
if (activePlayers.Any(a => a.Type.Equals("video")))
{
_logger.Debug("Video is currently playing, skipping library update");
return;
}
}
UpdateMovieLibrary(settings, movie);
}
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 void UpdateMovieLibrary(XbmcSettings settings, Movie movie)
{
try
{
var response = _proxy.UpdateLibrary(settings, null);
if (!response.Equals("OK", StringComparison.InvariantCultureIgnoreCase))
{
_logger.Debug("Failed to update library for: {0}", settings.Address);
}
}
catch (Exception ex)
{
_logger.Debug(ex, ex.Message);
}
}
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);
}
}
public void Clean(XbmcSettings settings)
{
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 cleaning");
return;
}
}
const string cleanVideoLibrary = "CleanLibrary(video)";
var command = BuildExecBuiltInCommand(cleanVideoLibrary);
SendCommand(settings, command);
}
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 => s.ImdbNumber == series.TvdbId || s.Label == series.Title);
if (matchingSeries != null)
{
return(matchingSeries.File);
}
return(null);
}
public string GetArtistPath(XbmcSettings settings, Artist artist)
{
var allArtists = _proxy.GetArtist(settings);
if (!allArtists.Any())
{
_logger.Debug("No Artists returned from XBMC");
return(null);
}
var matchingArtist = allArtists.FirstOrDefault(s =>
{
var musicBrainzId = s.MusicbrainzArtistId.FirstOrDefault();
return(musicBrainzId == artist.Metadata.Value.ForeignArtistId || s.Label == artist.Name);
});
return(matchingArtist?.File);
}
public string GetMoviePath(XbmcSettings settings, Movie movie)
{
var allMovies = _proxy.GetMovies(settings);
if (!allMovies.Any())
{
_logger.Debug("No Movies returned from XBMC");
return(null);
}
var matchingMovies = allMovies.FirstOrDefault(s =>
{
return(s.ImdbNumber == movie.ImdbId || s.Label == movie.Title);
});
if (matchingMovies != null)
{
return(matchingMovies.File);
}
return(null);
}
private string ProcessRequest(XbmcSettings settings, string method, params object[] parameters)
{
var url = HttpRequestBuilder.BuildBaseUrl(settings.UseSsl, settings.Host, settings.Port, "jsonrpc");
var requestBuilder = new JsonRpcRequestBuilder(url, method, parameters);
requestBuilder.LogResponseContent = true;
var request = requestBuilder.Build();
if (!settings.Username.IsNullOrWhiteSpace())
{
request.Credentials = new BasicNetworkCredential(settings.Username, settings.Password);
}
var response = _httpClient.Execute(request);
_logger.Trace("Response: {0}", response.Content);
CheckForError(response);
return(response.Content);
}
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);
}
internal string GetArtistPath(XbmcSettings settings, Artist artist)
{
var query =
string.Format(
"select path.strPath from path, artist, artistlinkpath where artist.c12 = {0} and artistlinkpath.idArtist = artist.idArtist and artistlinkpath.idPath = path.idPath",
artist.Metadata.Value.ForeignArtistId);
var command = string.Format("QueryMusicDatabase({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 string ProcessRequest(XbmcSettings settings, string method, params object[] parameters)
{
var url = string.Format(@"http://{0}/jsonrpc", settings.Address);
var requestBuilder = new JsonRpcRequestBuilder(url, method, parameters);
requestBuilder.LogResponseContent = true;
var request = requestBuilder.Build();
if (!settings.Username.IsNullOrWhiteSpace())
{
request.AddBasicAuthentication(settings.Username, settings.Password);
}
var response = _httpClient.Execute(request);
_logger.Trace("Response: {0}", response.Content);
CheckForError(response);
return(response.Content);
}
public void Execute(TestXbmcCommand message)
{
var settings = new XbmcSettings
{
Host = message.Host,
Port = message.Port,
Username = message.Username,
Password = message.Password,
DisplayTime = message.DisplayTime
};
Logger.Debug("Determining version of XBMC Host: {0}", settings.Address);
var version = GetJsonVersion(settings);
Logger.Debug("Version is: {0}", version);
if (version == new XbmcVersion(0))
{
throw new InvalidXbmcVersionException("Verion received from XBMC is invalid, please correct your settings.");
}
Notify(settings, "Test Notification", "Success! XBMC has been successfully configured!");
}
private XbmcVersion GetJsonVersion(XbmcSettings settings)
{
return(_xbmcVersionCache.Get(settings.Address, () =>
{
var response = _proxy.GetJsonVersion(settings);
_logger.Debug("Getting version from response: {0}", 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 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", 10));
var response = _httpProvider.PostCommand(settings.Address, settings.Username, settings.Password, postJson.ToString());
Logger.Debug("Getting version from 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 List <ActivePlayer> GetActivePlayers(XbmcSettings settings)
{
return(_proxy.GetActivePlayers(settings));
}
public void Clean(XbmcSettings settings)
{
_proxy.CleanLibrary(settings);
}
public void Notify(XbmcSettings settings, string title, string message)
{
_proxy.Notify(settings, title, message);
}
public void CleanLibrary(XbmcSettings settings)
{
var request = new RestRequest();
ProcessRequest(request, settings, "VideoLibrary.Clean");
}
public string GetJsonVersion(XbmcSettings settings)
{
var request = new RestRequest();
return(ProcessRequest(request, settings, "JSONRPC.Version"));
}
public void Clean(XbmcSettings settings)
{
var provider = GetApiProvider(settings);
provider.Clean(settings);
}
public void UpdateMovie(XbmcSettings settings, Movie movie)
{
var provider = GetApiProvider(settings);
provider.UpdateMovie(settings, movie);
}
public void Notify(XbmcSettings settings, string title, string message)
{
var provider = GetApiProvider(settings);
provider.Notify(settings, title, message);
}
