@@ -608,6 +613,7 @@
+
diff --git a/src/Jackett/Content/libs/api.js b/src/Jackett/Content/libs/api.js
new file mode 100644
index 000000000..681d5879a
--- /dev/null
+++ b/src/Jackett/Content/libs/api.js
@@ -0,0 +1,88 @@
+var api = {
+ version: "2.0",
+ root: "/api",
+
+ getApiPath: function(category, action) {
+ var path = this.root + "/v" + this.version + "/" + category;
+ if (action !== undefined)
+ path = path + "/" + action
+ return path;
+ },
+
+ getAllIndexers: function(callback) {
+ return $.get(this.getApiPath("indexers"), callback);
+ },
+
+ getServerConfig: function(callback) {
+ return $.get(this.getApiPath("server", "config"), callback);
+ },
+
+ getIndexerConfig: function(indexerId, callback) {
+ return $.get(this.getApiPath("indexers", indexerId + "/config"), callback);
+ },
+
+ updateIndexerConfig: function(indexerId, config, callback) {
+ return $.ajax({
+ url: this.getApiPath("indexers", indexerId + "/config"),
+ type: 'POST',
+ data: JSON.stringify(config),
+ dataType: 'json',
+ contentType: 'application/json',
+ cache: false,
+ success: callback
+ });
+ },
+
+ deleteIndexer: function(indexerId, callback) {
+ return $.ajax({
+ url: this.getApiPath("indexers", indexerId),
+ type: 'DELETE',
+ cache: false,
+ success: callback
+ });
+ },
+
+ testIndexer: function(indexerId, callback) {
+ return $.post(this.getApiPath("indexers", indexerId + "/test"), callback);
+ },
+
+ resultsForIndexer: function(indexerId, query, callback) {
+ return $.get(this.getApiPath("indexers", indexerId + "/results"), query, callback);
+ },
+
+ getServerCache: function(callback) {
+ return $.get(this.getApiPath("indexers", "cache"), callback);
+ },
+
+ getServerLogs: function(callback) {
+ return $.get(this.getApiPath("server", "logs"), callback);
+ },
+
+ updateServerConfig: function(serverConfig, callback) {
+ return $.ajax({
+ url: this.getApiPath("server", "config"),
+ type: 'POST',
+ data: JSON.stringify(serverConfig),
+ dataType: 'json',
+ contentType: 'application/json',
+ cache: false,
+ success: callback
+ });
+ },
+
+ updateServer: function(callback) {
+ return $.post(this.getApiPath("server", "update"), callback);
+ },
+
+ updateAdminPassword: function(password, callback) {
+ return $.ajax({
+ url: this.getApiPath("server", "adminpassword"),
+ type: 'POST',
+ data: JSON.stringify(password),
+ dataType: 'json',
+ contentType: 'application/json',
+ cache: false,
+ success: callback
+ });
+ }
+}
\ No newline at end of file
diff --git a/src/Jackett/Content/setup_indexer.html b/src/Jackett/Content/setup_indexer.html
deleted file mode 100644
index ce1e61a26..000000000
--- a/src/Jackett/Content/setup_indexer.html
+++ /dev/null
@@ -1,120 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/src/Jackett/Controllers/AdminController.cs b/src/Jackett/Controllers/AdminController.cs
deleted file mode 100644
index bfc594921..000000000
--- a/src/Jackett/Controllers/AdminController.cs
+++ /dev/null
@@ -1,610 +0,0 @@
-using Autofac;
-using AutoMapper;
-using Jackett.Indexers;
-using Jackett.Models;
-using Jackett.Services;
-using Jackett.Utils;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using NLog;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Net.Http.Headers;
-using System.Security.Claims;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Web;
-using System.Web.Http;
-using System.Web.Http.Results;
-using System.Web.Security;
-using System.Windows.Forms;
-
-namespace Jackett.Controllers
-{
- [RoutePrefix("admin")]
- [JackettAuthorized]
- [JackettAPINoCache]
- public class AdminController : ApiController
- {
- private IConfigurationService config;
- private IIndexerManagerService indexerService;
- private IServerService serverService;
- private ISecuityService securityService;
- private IProcessService processService;
- private ICacheService cacheService;
- private Logger logger;
- private ILogCacheService logCache;
- private IUpdateService updater;
-
- public AdminController(IConfigurationService config, IIndexerManagerService i, IServerService ss, ISecuityService s, IProcessService p, ICacheService c, Logger l, ILogCacheService lc, IUpdateService u)
- {
- this.config = config;
- indexerService = i;
- serverService = ss;
- securityService = s;
- processService = p;
- cacheService = c;
- logger = l;
- logCache = lc;
- updater = u;
- }
-
- private async Task
ReadPostDataJson()
- {
- var content = await Request.Content.ReadAsStringAsync();
- return JObject.Parse(content);
- }
-
-
- private HttpResponseMessage GetFile(string path)
- {
- var result = new HttpResponseMessage(HttpStatusCode.OK);
- var mappedPath = Path.Combine(config.GetContentFolder(), path);
- var stream = new FileStream(mappedPath, FileMode.Open, FileAccess.Read, FileShare.Read);
- result.Content = new StreamContent(stream);
- result.Content.Headers.ContentType = new MediaTypeHeaderValue(MimeMapping.GetMimeMapping(mappedPath));
-
- return result;
- }
-
- [HttpGet]
- [AllowAnonymous]
- public RedirectResult Logout()
- {
- var ctx = Request.GetOwinContext();
- var authManager = ctx.Authentication;
- authManager.SignOut("ApplicationCookie");
- return Redirect("Admin/Dashboard");
- }
-
- [HttpGet]
- [HttpPost]
- [AllowAnonymous]
- public async Task Dashboard()
- {
- if (Request.RequestUri.Query != null && Request.RequestUri.Query.Contains("logout"))
- {
- var file = GetFile("login.html");
- securityService.Logout(file);
- return file;
- }
-
-
- if (securityService.CheckAuthorised(Request))
- {
- return GetFile("index.html");
-
- }
- else
- {
- var formData = await Request.Content.ReadAsFormDataAsync();
-
- if (formData != null && securityService.HashPassword(formData["password"]) == serverService.Config.AdminPassword)
- {
- var file = GetFile("index.html");
- securityService.Login(file);
- return file;
- }
- else
- {
- return GetFile("login.html");
- }
- }
- }
-
- [Route("set_admin_password")]
- [HttpPost]
- public async Task SetAdminPassword()
- {
- var jsonReply = new JObject();
- try
- {
- var postData = await ReadPostDataJson();
- var password = (string)postData["password"];
- if (string.IsNullOrEmpty(password))
- {
- serverService.Config.AdminPassword = string.Empty;
- }
- else
- {
- serverService.Config.AdminPassword = securityService.HashPassword(password);
- }
-
- serverService.SaveConfig();
- jsonReply["result"] = "success";
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Exception in SetAdminPassword");
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- }
- return Json(jsonReply);
- }
-
- [Route("get_config_form")]
- [HttpPost]
- public async Task GetConfigForm()
- {
- var jsonReply = new JObject();
- try
- {
- var postData = await ReadPostDataJson();
- var indexer = indexerService.GetIndexer((string)postData["indexer"]);
- var config = await indexer.GetConfigurationForSetup();
- jsonReply["config"] = config.ToJson(null);
- jsonReply["caps"] = indexer.TorznabCaps.CapsToJson();
- jsonReply["name"] = indexer.DisplayName;
- jsonReply["alternativesitelinks"] = JToken.FromObject(indexer.AlternativeSiteLinks);
- jsonReply["result"] = "success";
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Exception in GetConfigForm");
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- }
- return Json(jsonReply);
- }
-
- [Route("configure_indexer")]
- [HttpPost]
- public async Task Configure()
- {
- var jsonReply = new JObject();
- IIndexer indexer = null;
- try
- {
- var postData = await ReadPostDataJson();
- string indexerString = (string)postData["indexer"];
- indexer = indexerService.GetIndexer((string)postData["indexer"]);
- jsonReply["name"] = indexer.DisplayName;
- var configurationResult = await indexer.ApplyConfiguration(postData["config"]);
- if (configurationResult == IndexerConfigurationStatus.RequiresTesting)
- {
- await indexerService.TestIndexer((string)postData["indexer"]);
- }
- else if (configurationResult == IndexerConfigurationStatus.Failed)
- {
- throw new Exception("Configuration Failed");
- }
- jsonReply["result"] = "success";
- }
- catch (Exception ex)
- {
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- var baseIndexer = indexer as BaseIndexer;
- if (null != baseIndexer)
- baseIndexer.ResetBaseConfig();
- if (ex is ExceptionWithConfigData)
- {
- jsonReply["config"] = ((ExceptionWithConfigData)ex).ConfigData.ToJson(null, false);
- }
- else
- {
- logger.Error(ex, "Exception in Configure");
- }
- }
- return Json(jsonReply);
- }
-
- [Route("get_indexers")]
- [HttpGet]
- public IHttpActionResult Indexers()
- {
- var jsonReply = new JObject();
- try
- {
- jsonReply["result"] = "success";
- JArray items = new JArray();
-
- foreach (var indexer in indexerService.GetAllIndexers())
- {
- var item = new JObject();
- item["id"] = indexer.ID;
- item["name"] = indexer.DisplayName;
- item["description"] = indexer.DisplayDescription;
- item["type"] = indexer.Type;
- item["configured"] = indexer.IsConfigured;
- item["site_link"] = indexer.SiteLink;
- item["language"] = indexer.Language;
- item["last_error"] = indexer.LastError;
- item["potatoenabled"] = indexer.TorznabCaps.Categories.Select(c => c.ID).Any(i => PotatoController.MOVIE_CATS.Contains(i));
-
- var caps = new JObject();
- foreach (var cap in indexer.TorznabCaps.Categories)
- caps[cap.ID.ToString()] = cap.Name;
- item["caps"] = caps;
- items.Add(item);
- }
- jsonReply["items"] = items;
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Exception in get_indexers");
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- }
- return Json(jsonReply);
- }
-
- [Route("test_indexer")]
- [HttpPost]
- public async Task Test()
- {
- JToken jsonReply = new JObject();
- IIndexer indexer = null;
- try
- {
- var postData = await ReadPostDataJson();
- string indexerString = (string)postData["indexer"];
- indexer = indexerService.GetIndexer(indexerString);
- await indexerService.TestIndexer(indexerString);
- jsonReply["name"] = indexer.DisplayName;
- jsonReply["result"] = "success";
- indexer.LastError = null;
- }
- catch (Exception ex)
- {
- var msg = ex.Message;
- if (ex.InnerException != null)
- msg += ": " + ex.InnerException.Message;
- logger.Error(ex, "Exception in test_indexer");
- jsonReply["result"] = "error";
- jsonReply["error"] = msg;
- if (indexer != null)
- indexer.LastError = msg;
- }
- return Json(jsonReply);
- }
-
- [Route("delete_indexer")]
- [HttpPost]
- public async Task Delete()
- {
- var jsonReply = new JObject();
- try
- {
- var postData = await ReadPostDataJson();
- string indexerString = (string)postData["indexer"];
- indexerService.DeleteIndexer(indexerString);
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Exception in delete_indexer");
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- }
- return Json(jsonReply);
- }
-
- [Route("trigger_update")]
- [HttpGet]
- public IHttpActionResult TriggerUpdates()
- {
- var jsonReply = new JObject();
- updater.CheckForUpdatesNow();
- return Json(jsonReply);
- }
-
- [Route("get_jackett_config")]
- [HttpGet]
- public IHttpActionResult GetConfig()
- {
- var jsonReply = new JObject();
- try
- {
- var cfg = new JObject();
- cfg["notices"] = JToken.FromObject(serverService.notices);
- cfg["port"] = serverService.Config.Port;
- cfg["external"] = serverService.Config.AllowExternal;
- cfg["api_key"] = serverService.Config.APIKey;
- cfg["blackholedir"] = serverService.Config.BlackholeDir;
- cfg["updatedisabled"] = serverService.Config.UpdateDisabled;
- cfg["prerelease"] = serverService.Config.UpdatePrerelease;
- cfg["password"] = string.IsNullOrEmpty(serverService.Config.AdminPassword) ? string.Empty : serverService.Config.AdminPassword.Substring(0, 10);
- cfg["logging"] = Startup.TracingEnabled;
- cfg["basepathoverride"] = serverService.Config.BasePathOverride;
- cfg["omdbkey"] = serverService.Config.OmdbApiKey;
-
- jsonReply["config"] = cfg;
- jsonReply["app_version"] = config.GetVersion();
- jsonReply["result"] = "success";
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Exception in get_jackett_config");
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- }
- return Json(jsonReply);
- }
-
- [Route("set_config")]
- [HttpPost]
- public async Task SetConfig()
- {
- var originalPort = Engine.Server.Config.Port;
- var originalAllowExternal = Engine.Server.Config.AllowExternal;
- var jsonReply = new JObject();
- try
- {
- var postData = await ReadPostDataJson();
- int port = (int)postData["port"];
- bool external = (bool)postData["external"];
- string saveDir = (string)postData["blackholedir"];
- bool updateDisabled = (bool)postData["updatedisabled"];
- bool preRelease = (bool)postData["prerelease"];
- bool logging = (bool)postData["logging"];
- string basePathOverride = (string)postData["basepathoverride"];
- string omdbApiKey = (string)postData["omdbkey"];
-
- Engine.Server.Config.UpdateDisabled = updateDisabled;
- Engine.Server.Config.UpdatePrerelease = preRelease;
- Engine.Server.Config.BasePathOverride = basePathOverride;
- Startup.BasePath = Engine.Server.BasePath();
- Engine.Server.SaveConfig();
-
- Engine.SetLogLevel(logging ? LogLevel.Debug : LogLevel.Info);
- Startup.TracingEnabled = logging;
-
- if (omdbApiKey != Engine.Server.Config.OmdbApiKey)
- {
- Engine.Server.Config.OmdbApiKey = omdbApiKey;
- Engine.Server.SaveConfig();
- // HACK
- indexerService.InitAggregateIndexer();
- }
-
- if (port != Engine.Server.Config.Port || external != Engine.Server.Config.AllowExternal)
- {
-
- if (ServerUtil.RestrictedPorts.Contains(port))
- {
- jsonReply["result"] = "error";
- jsonReply["error"] = "The port you have selected is restricted, try a different one.";
- return Json(jsonReply);
- }
-
- if (port < 1 || port > 65535)
- {
- jsonReply["result"] = "error";
- jsonReply["error"] = "The port you have selected is invalid, it must be below 65535.";
- return Json(jsonReply);
- }
-
- // Save port to the config so it can be picked up by the if needed when running as admin below.
- Engine.Server.Config.AllowExternal = external;
- Engine.Server.Config.Port = port;
- Engine.Server.SaveConfig();
-
- // On Windows change the url reservations
- if (System.Environment.OSVersion.Platform != PlatformID.Unix)
- {
- if (!ServerUtil.IsUserAdministrator())
- {
- try
- {
- processService.StartProcessAndLog(Application.ExecutablePath, "--ReserveUrls", true);
- }
- catch
- {
- Engine.Server.Config.Port = originalPort;
- Engine.Server.Config.AllowExternal = originalAllowExternal;
- Engine.Server.SaveConfig();
- jsonReply["result"] = "error";
- jsonReply["error"] = "Failed to acquire admin permissions to reserve the new port.";
- return Json(jsonReply);
- }
- }
- else
- {
- serverService.ReserveUrls(true);
- }
- }
-
- (new Thread(() =>
- {
- Thread.Sleep(500);
- serverService.Stop();
- Engine.BuildContainer();
- Engine.Server.Initalize();
- Engine.Server.Start();
- })).Start();
- }
-
- if (saveDir != Engine.Server.Config.BlackholeDir)
- {
- if (!string.IsNullOrEmpty(saveDir))
- {
- if (!Directory.Exists(saveDir))
- {
- throw new Exception("Blackhole directory does not exist");
- }
- }
-
- Engine.Server.Config.BlackholeDir = saveDir;
- Engine.Server.SaveConfig();
- }
-
- jsonReply["result"] = "success";
- jsonReply["port"] = port;
- jsonReply["external"] = external;
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Exception in set_port");
- jsonReply["result"] = "error";
- jsonReply["error"] = ex.Message;
- }
- return Json(jsonReply);
- }
-
- [Route("GetCache")]
- [HttpGet]
- public List GetCache()
- {
- var results = cacheService.GetCachedResults();
- ConfigureCacheResults(results);
- return results;
- }
-
-
- private void ConfigureCacheResults(List results)
- {
- var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
- foreach (var result in results)
- {
- var link = result.Link;
- var file = StringUtil.MakeValidFileName(result.Title, '_', false) + ".torrent";
- result.Link = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "dl", file);
- if (result.Link != null && result.Link.Scheme != "magnet" && !string.IsNullOrWhiteSpace(Engine.Server.Config.BlackholeDir))
- result.BlackholeLink = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "bh", file);
-
- }
- }
-
- [Route("GetLogs")]
- [HttpGet]
- public List GetLogs()
- {
- return logCache.Logs;
- }
-
- [Route("Search")]
- [HttpPost]
- public ManualSearchResult Search([FromBody]AdminSearch value)
- {
- var results = new List();
- var stringQuery = new TorznabQuery();
-
- var queryStr = value.Query;
- if (queryStr != null)
- {
- var seasonMatch = Regex.Match(queryStr, @"S(\d{2,4})");
- if (seasonMatch.Success)
- {
- stringQuery.Season = int.Parse(seasonMatch.Groups[1].Value);
- queryStr = queryStr.Remove(seasonMatch.Index, seasonMatch.Length);
- }
-
- var episodeMatch = Regex.Match(queryStr, @"E(\d{2,4}[A-Za-z]?)");
- if (episodeMatch.Success)
- {
- stringQuery.Episode = episodeMatch.Groups[1].Value;
- queryStr = queryStr.Remove(episodeMatch.Index, episodeMatch.Length);
- }
- queryStr = queryStr.Trim();
- }
-
-
- stringQuery.SearchTerm = queryStr;
- stringQuery.Categories = value.Category == 0 ? new int[0] : new int[1] { value.Category };
- stringQuery.ExpandCatsToSubCats();
-
- // try to build an IMDB Query
- var imdbID = ParseUtil.GetFullImdbID(stringQuery.SanitizedSearchTerm);
- TorznabQuery imdbQuery = null;
- if (imdbID != null)
- {
- imdbQuery = new TorznabQuery()
- {
- ImdbID = imdbID,
- Categories = stringQuery.Categories,
- Season = stringQuery.Season,
- Episode = stringQuery.Episode,
- };
- imdbQuery.ExpandCatsToSubCats();
- }
-
- var trackers = indexerService.GetAllIndexers().Where(t => t.IsConfigured).ToList();
- if (!string.IsNullOrWhiteSpace(value.Tracker))
- {
- trackers = trackers.Where(t => t.ID == value.Tracker).ToList();
- }
-
- if (value.Category != 0)
- {
- trackers = trackers.Where(t => t.TorznabCaps.Categories.Select(c => c.ID).Contains(value.Category)).ToList();
- }
-
- Parallel.ForEach(trackers.ToList(), new ParallelOptions { MaxDegreeOfParallelism = 1000 }, indexer =>
- {
- try
- {
- var query = stringQuery;
- // use imdb Query for trackers which support it
- if (imdbQuery != null && indexer.TorznabCaps.SupportsImdbSearch)
- query = imdbQuery;
-
- var searchResults = indexer.ResultsForQuery(query).Result;
- cacheService.CacheRssResults(indexer, searchResults);
-
- foreach (var result in searchResults)
- {
- var item = Mapper.Map(result);
- item.Tracker = indexer.DisplayName;
- item.TrackerId = indexer.ID;
- item.Peers = item.Peers - item.Seeders; // Use peers as leechers
- lock (results)
- {
- results.Add(item);
- }
- }
- }
- catch (Exception e)
- {
- logger.Error(e, "An error occured during manual search on " + indexer.DisplayName + ": " + e.Message);
- }
- });
-
- ConfigureCacheResults(results);
-
- if (trackers.Count > 1)
- {
- results = results.OrderByDescending(d => d.PublishDate).ToList();
- }
-
- var manualResult = new ManualSearchResult()
- {
- Results = results,
- Indexers = trackers.Select(t => t.DisplayName).ToList()
- };
-
-
- if (manualResult.Indexers.Count == 0)
- manualResult.Indexers = new List() { "None" };
-
- logger.Info(string.Format("Manual search for \"{0}\" on {1} with {2} results.", stringQuery.GetQueryString(), string.Join(", ", manualResult.Indexers), manualResult.Results.Count));
- return manualResult;
- }
- }
-}
-
diff --git a/src/Jackett/Controllers/IndexerApiController.cs b/src/Jackett/Controllers/IndexerApiController.cs
new file mode 100644
index 000000000..adf2d28cf
--- /dev/null
+++ b/src/Jackett/Controllers/IndexerApiController.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.Filters;
+using AutoMapper;
+using Jackett.Indexers;
+using Jackett.Models;
+using Jackett.Services;
+using Jackett.Utils;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NLog;
+
+namespace Jackett.Controllers.V20
+{
+ public interface IIndexerController
+ {
+ IIndexerManagerService IndexerService { get; }
+ IIndexer CurrentIndexer { get; set; }
+ }
+
+ public class RequiresIndexerAttribute : ActionFilterAttribute
+ {
+ public override void OnActionExecuting(HttpActionContext actionContext)
+ {
+ base.OnActionExecuting(actionContext);
+
+ var controller = actionContext.ControllerContext.Controller;
+ if (!(controller is IIndexerController))
+ return;
+
+ var indexerController = controller as IIndexerController;
+
+ var parameters = actionContext.RequestContext.RouteData.Values;
+
+ if (!parameters.ContainsKey("indexerId"))
+ {
+ indexerController.CurrentIndexer = null;
+ return;
+ }
+
+ var indexerId = parameters["indexerId"] as string;
+ if (indexerId.IsNullOrEmptyOrWhitespace())
+ return;
+
+ var indexerService = indexerController.IndexerService;
+ var indexer = indexerService.GetIndexer(indexerId);
+ indexerController.CurrentIndexer = indexer;
+ }
+ }
+
+ [RoutePrefix("api/v2.0/indexers")]
+ [JackettAuthorized]
+ [JackettAPINoCache]
+ public class IndexerApiController : ApiController, IIndexerController
+ {
+ public IIndexerManagerService IndexerService { get; private set; }
+ public IIndexer CurrentIndexer { get; set; }
+
+ public IndexerApiController(IIndexerManagerService indexerManagerService, IServerService ss, ICacheService c, Logger logger)
+ {
+ IndexerService = indexerManagerService;
+ serverService = ss;
+ cacheService = c;
+ this.logger = logger;
+ }
+
+ [HttpGet]
+ [RequiresIndexer]
+ public async Task Config()
+ {
+ var config = await CurrentIndexer.GetConfigurationForSetup();
+ return Ok(config.ToJson(null));
+ }
+
+ [HttpPost]
+ [ActionName("Config")]
+ [RequiresIndexer]
+ public async Task UpdateConfig([FromBody]Models.DTO.ConfigItem[] config)
+ {
+ try
+ {
+ // HACK
+ var jsonString = JsonConvert.SerializeObject(config);
+ var json = JToken.Parse(jsonString);
+
+ var configurationResult = await CurrentIndexer.ApplyConfiguration(json);
+
+ if (configurationResult == IndexerConfigurationStatus.RequiresTesting)
+ await IndexerService.TestIndexer(CurrentIndexer.ID);
+ }
+ catch
+ {
+ var baseIndexer = CurrentIndexer as BaseIndexer;
+ if (null != baseIndexer)
+ baseIndexer.ResetBaseConfig();
+ throw;
+ }
+ }
+
+ [HttpGet]
+ [Route("")]
+ public IEnumerable Indexers()
+ {
+ var dto = IndexerService.GetAllIndexers().Select(i => new Models.DTO.Indexer(i));
+ return dto;
+ }
+
+ [HttpPost]
+ [RequiresIndexer]
+ public async Task Test()
+ {
+ JToken jsonReply = new JObject();
+ try
+ {
+ await IndexerService.TestIndexer(CurrentIndexer.ID);
+ CurrentIndexer.LastError = null;
+ }
+ catch (Exception ex)
+ {
+ var msg = ex.Message;
+ if (ex.InnerException != null)
+ msg += ": " + ex.InnerException.Message;
+
+ if (CurrentIndexer != null)
+ CurrentIndexer.LastError = msg;
+
+ throw;
+ }
+ }
+
+ [HttpDelete]
+ [RequiresIndexer]
+ [Route("{indexerId}")]
+ public void Delete()
+ {
+ IndexerService.DeleteIndexer(CurrentIndexer.ID);
+ }
+
+ // TODO
+ // This should go to ServerConfigurationController
+ [Route("Cache")]
+ [HttpGet]
+ public List Cache()
+ {
+ var results = cacheService.GetCachedResults();
+ ConfigureCacheResults(results);
+ return results;
+ }
+
+ private void ConfigureCacheResults(IEnumerable results)
+ {
+ var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
+ foreach (var result in results)
+ {
+ var link = result.Link;
+ var file = StringUtil.MakeValidFileName(result.Title, '_', false) + ".torrent";
+ result.Link = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "dl", file);
+ if (result.Link != null && result.Link.Scheme != "magnet" && !string.IsNullOrWhiteSpace(Engine.Server.Config.BlackholeDir))
+ result.BlackholeLink = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "bh", file);
+
+ }
+ }
+
+ private Logger logger;
+ private IServerService serverService;
+ private ICacheService cacheService;
+ }
+}
diff --git a/src/Jackett/Controllers/PotatoController.cs b/src/Jackett/Controllers/PotatoController.cs
deleted file mode 100644
index 85f514122..000000000
--- a/src/Jackett/Controllers/PotatoController.cs
+++ /dev/null
@@ -1,166 +0,0 @@
-using AutoMapper;
-using Jackett.Models;
-using Jackett.Services;
-using Jackett.Utils;
-using Jackett.Utils.Clients;
-using Newtonsoft.Json.Linq;
-using NLog;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
-using System.Web;
-using System.Web.Http;
-using Jackett.Indexers;
-
-namespace Jackett.Controllers
-{
- [AllowAnonymous]
- [JackettAPINoCache]
- public class PotatoController : ApiController
- {
- private IIndexerManagerService indexerService;
- private Logger logger;
- private IServerService serverService;
- private ICacheService cacheService;
- private IWebClient webClient;
-
- public static int[] MOVIE_CATS
- {
- get
- {
- var torznabQuery = new TorznabQuery()
- {
- Categories = new int[1] { TorznabCatType.Movies.ID },
- };
-
- torznabQuery.ExpandCatsToSubCats();
- return torznabQuery.Categories;
- }
- }
-
- public PotatoController(IIndexerManagerService i, Logger l, IServerService s, ICacheService c, IWebClient w)
- {
- indexerService = i;
- logger = l;
- serverService = s;
- cacheService = c;
- webClient = w;
- }
-
- [HttpGet]
- public async Task Call(string indexerID, [FromUri]TorrentPotatoRequest request)
- {
- var indexer = indexerService.GetIndexer(indexerID);
-
- var allowBadApiDueToDebug = false;
-#if DEBUG
- allowBadApiDueToDebug = Debugger.IsAttached;
-#endif
-
- if (!allowBadApiDueToDebug && !string.Equals(request.passkey, serverService.Config.APIKey, StringComparison.InvariantCultureIgnoreCase))
- {
- logger.Warn(string.Format("A request from {0} was made with an incorrect API key.", Request.GetOwinContext().Request.RemoteIpAddress));
- return Request.CreateResponse(HttpStatusCode.Forbidden, "Incorrect API key");
- }
-
- if (!indexer.IsConfigured)
- {
- logger.Warn(string.Format("Rejected a request to {0} which is unconfigured.", indexer.DisplayName));
- return Request.CreateResponse(HttpStatusCode.Forbidden, "This indexer is not configured.");
- }
-
- if (!indexer.TorznabCaps.Categories.Select(c => c.ID).Any(i => MOVIE_CATS.Contains(i)))
- {
- logger.Warn(string.Format("Rejected a request to {0} which does not support searching for movies.", indexer.DisplayName));
- return Request.CreateResponse(HttpStatusCode.Forbidden, "This indexer does not support movies.");
- }
-
- var year = 0;
-
- var omdbApiKey = serverService.Config.OmdbApiKey;
- if (!request.imdbid.IsNullOrEmptyOrWhitespace() && !omdbApiKey.IsNullOrEmptyOrWhitespace())
- {
- // We are searching by IMDB id so look up the name
- var resolver = new OmdbResolver(webClient, omdbApiKey.ToNonNull());
- var movie = await resolver.MovieForId(request.imdbid.ToNonNull());
- request.search = movie.Title;
- year = ParseUtil.CoerceInt(movie.Year);
- }
-
- var torznabQuery = new TorznabQuery()
- {
- ApiKey = request.passkey,
- Categories = MOVIE_CATS,
- SearchTerm = request.search,
- ImdbID = request.imdbid,
- QueryType = "TorrentPotato"
- };
-
- IEnumerable releases = new List();
-
- if (indexer.CanHandleQuery(torznabQuery))
- releases = await indexer.ResultsForQuery(torznabQuery);
-
- // Cache non query results
- if (string.IsNullOrEmpty(torznabQuery.SanitizedSearchTerm))
- {
- cacheService.CacheRssResults(indexer, releases);
- }
-
- var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
- var potatoResponse = new TorrentPotatoResponse();
-
- if (!torznabQuery.SanitizedSearchTerm.IsNullOrEmptyOrWhitespace())
- releases = TorznabUtil.FilterResultsToTitle(releases, torznabQuery.SanitizedSearchTerm, year);
- if (!torznabQuery.ImdbID.IsNullOrEmptyOrWhitespace())
- releases = TorznabUtil.FilterResultsToImdb(releases, request.imdbid);
-
- foreach (var r in releases)
- {
- var release = Mapper.Map(r);
- release.Link = serverService.ConvertToProxyLink(release.Link, serverUrl, indexerID, "dl", release.Title + ".torrent");
-
- // Only accept torrent links, magnet is not supported
- // This seems to be no longer the case, allowing magnet URIs for now
- if (release.Link != null || release.MagnetUri != null)
- {
- potatoResponse.results.Add(new TorrentPotatoResponseItem()
- {
- release_name = release.Title + "[" + indexer.DisplayName + "]", // Suffix the indexer so we can see which tracker we are using in CPS as it just says torrentpotato >.>
- torrent_id = release.Guid.ToString(),
- details_url = release.Comments.ToString(),
- download_url = (release.Link != null ? release.Link.ToString() : release.MagnetUri.ToString()),
- imdb_id = release.Imdb.HasValue ? "tt" + release.Imdb : null,
- freeleech = (release.DownloadVolumeFactor == 0 ? true : false),
- type = "movie",
- size = (long)release.Size / (1024 * 1024), // This is in MB
- leechers = (int)release.Peers - (int)release.Seeders,
- seeders = (int)release.Seeders,
- publish_date = r.PublishDate == DateTime.MinValue ? null : release.PublishDate.ToUniversalTime().ToString("s")
- });
- }
- }
-
- // Log info
- if (string.IsNullOrWhiteSpace(torznabQuery.SanitizedSearchTerm))
- {
- logger.Info(string.Format("Found {0} torrentpotato releases from {1}", releases.Count(), indexer.DisplayName));
- }
- else
- {
- logger.Info(string.Format("Found {0} torrentpotato releases from {1} for: {2}", releases.Count(), indexer.DisplayName, torznabQuery.GetQueryString()));
- }
-
- // Force the return as Json
- return new HttpResponseMessage()
- {
- Content = new JsonContent(potatoResponse)
- };
- }
- }
-}
diff --git a/src/Jackett/Controllers/ResultsController.cs b/src/Jackett/Controllers/ResultsController.cs
new file mode 100644
index 000000000..bcc8b9512
--- /dev/null
+++ b/src/Jackett/Controllers/ResultsController.cs
@@ -0,0 +1,379 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.Filters;
+using System.Xml.Linq;
+using Jackett.Indexers;
+using Jackett.Models;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json;
+using NLog;
+
+namespace Jackett.Controllers.V20
+{
+ public class RequiresApiKeyAttribute : AuthorizationFilterAttribute
+ {
+ public override void OnAuthorization(HttpActionContext actionContext)
+ {
+ var validApiKey = Engine.Server.Config.APIKey;
+ var queryParams = actionContext.Request.GetQueryNameValuePairs().ToDictionary();
+ var queryApiKey = queryParams.ContainsKey("apikey") ? queryParams["apikey"] : null;
+ queryApiKey = queryParams.ContainsKey("passkey") ? queryParams["passkey"] : queryApiKey;
+
+#if DEBUG
+ if (Debugger.IsAttached)
+ return;
+#endif
+ if (queryApiKey != validApiKey)
+ actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Unauthorized);
+ }
+ }
+
+ public class RequiresConfiguredIndexerAttribute : ActionFilterAttribute
+ {
+ public override void OnActionExecuting(HttpActionContext actionContext)
+ {
+ var controller = actionContext.ControllerContext.Controller;
+ if (!(controller is IIndexerController))
+ return;
+
+ var indexerController = controller as IIndexerController;
+
+ var parameters = actionContext.RequestContext.RouteData.Values;
+
+ if (!parameters.ContainsKey("indexerId"))
+ {
+ indexerController.CurrentIndexer = null;
+ actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid parameter");
+ return;
+ }
+
+ var indexerId = parameters["indexerId"] as string;
+ if (indexerId.IsNullOrEmptyOrWhitespace())
+ {
+ indexerController.CurrentIndexer = null;
+ actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid parameter");
+ return;
+ }
+
+ var indexerService = indexerController.IndexerService;
+ var indexer = indexerService.GetIndexer(indexerId);
+
+ if (indexer == null)
+ {
+ indexerController.CurrentIndexer = null;
+ actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid parameter");
+ return;
+ }
+
+ if (!indexer.IsConfigured)
+ {
+ indexerController.CurrentIndexer = null;
+ actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Indexer is not configured");
+ return;
+ }
+
+ indexerController.CurrentIndexer = indexer;
+ }
+ }
+
+ public class RequiresValidQueryAttribute : RequiresConfiguredIndexerAttribute
+ {
+ public override void OnActionExecuting(HttpActionContext actionContext)
+ {
+ base.OnActionExecuting(actionContext);
+ if (actionContext.Response != null)
+ return;
+
+ var controller = actionContext.ControllerContext.Controller;
+ if (!(controller is IResultController))
+ return;
+
+ var resultController = controller as IResultController;
+
+ var query = actionContext.ActionArguments.First().Value;
+ var queryType = query.GetType();
+ var converter = queryType.GetMethod("ToTorznabQuery", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
+ if (converter == null)
+ actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "");
+ var converted = converter.Invoke(null, new object[] { query });
+ var torznabQuery = converted as TorznabQuery;
+ resultController.CurrentQuery = torznabQuery;
+
+ if (!resultController.CurrentIndexer.CanHandleQuery(resultController.CurrentQuery))
+ actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, $"{resultController.CurrentIndexer.ID} does not support the requested query.");
+ }
+ }
+
+ public class JsonResponseAttribute : ActionFilterAttribute
+ {
+ public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
+ {
+ base.OnActionExecuted(actionExecutedContext);
+
+ var content = actionExecutedContext.Response.Content as ObjectContent;
+ actionExecutedContext.Response.Content = new JsonContent(content.Value);
+ }
+ }
+
+ public interface IResultController : IIndexerController
+ {
+ TorznabQuery CurrentQuery { get; set; }
+ }
+
+ [JackettAuthorized]
+ [JackettAPINoCache]
+ [RoutePrefix("api/v2.0/indexers")]
+ [RequiresApiKey]
+ [RequiresValidQuery]
+ public class ResultsController : ApiController, IResultController
+ {
+ public IIndexerManagerService IndexerService { get; private set; }
+ public IIndexer CurrentIndexer { get; set; }
+ public TorznabQuery CurrentQuery { get; set; }
+
+ public ResultsController(IIndexerManagerService indexerManagerService, IServerService ss, ICacheService c, Logger logger)
+ {
+ IndexerService = indexerManagerService;
+ serverService = ss;
+ cacheService = c;
+ this.logger = logger;
+ }
+
+ [HttpGet]
+ public async Task Results([FromUri]Models.DTO.ApiSearch request)
+ {
+ var trackers = IndexerService.GetAllIndexers().Where(t => t.IsConfigured);
+ if (CurrentIndexer.ID != "all")
+ trackers = trackers.Where(t => t.ID == CurrentIndexer.ID).ToList();
+ trackers = trackers.Where(t => t.IsConfigured && t.CanHandleQuery(CurrentQuery));
+
+ var tasks = trackers.ToList().Select(t => t.ResultsForQuery(CurrentQuery)).ToList();
+ var aggregateTask = Task.WhenAll(tasks);
+
+ await aggregateTask;
+
+ var results = tasks.Where(t => t.Status == TaskStatus.RanToCompletion).Where(t => t.Result.Count() > 0).SelectMany(t =>
+ {
+ var searchResults = t.Result;
+ var indexer = searchResults.First().Origin;
+ cacheService.CacheRssResults(indexer, searchResults);
+
+ return searchResults.Select(result =>
+ {
+ var item = AutoMapper.Mapper.Map(result);
+ item.Tracker = indexer.DisplayName;
+ item.TrackerId = indexer.ID;
+ item.Peers = item.Peers - item.Seeders; // Use peers as leechers
+
+ return item;
+ });
+ }).OrderByDescending(d => d.PublishDate).ToList();
+
+ ConfigureCacheResults(results);
+
+ var manualResult = new Models.DTO.ManualSearchResult()
+ {
+ Results = results,
+ Indexers = trackers.Select(t => t.DisplayName).ToList()
+ };
+
+
+ if (manualResult.Indexers.Count() == 0)
+ manualResult.Indexers = new List() { "None" };
+
+ logger.Info(string.Format("Manual search for \"{0}\" on {1} with {2} results.", CurrentQuery.SanitizedSearchTerm, string.Join(", ", manualResult.Indexers), manualResult.Results.Count()));
+ return manualResult;
+ }
+
+ [HttpGet]
+ public async Task Torznab([FromUri]Models.DTO.TorznabRequest request)
+ {
+ if (string.Equals(CurrentQuery.QueryType, "caps", StringComparison.InvariantCultureIgnoreCase))
+ {
+ return ResponseMessage(new HttpResponseMessage()
+ {
+ Content = new StringContent(CurrentIndexer.TorznabCaps.ToXml(), Encoding.UTF8, "application/xml")
+ });
+ }
+
+ if (CurrentQuery.ImdbID != null)
+ {
+ if (CurrentQuery.QueryType != "movie")
+ {
+ logger.Warn($"A non movie request with an imdbid was made from {Request.GetOwinContext().Request.RemoteIpAddress}.");
+ return GetErrorXML(201, "Incorrect parameter: only movie-search supports the imdbid parameter");
+ }
+
+ if (!string.IsNullOrEmpty(CurrentQuery.SearchTerm))
+ {
+ logger.Warn($"A movie-search request from {Request.GetOwinContext().Request.RemoteIpAddress} was made contining q and imdbid.");
+ return GetErrorXML(201, "Incorrect parameter: please specify either imdbid or q");
+ }
+
+ CurrentQuery.ImdbID = ParseUtil.GetFullImdbID(CurrentQuery.ImdbID); // normalize ImdbID
+ if (CurrentQuery.ImdbID == null)
+ {
+ logger.Warn($"A movie-search request from {Request.GetOwinContext().Request.RemoteIpAddress} was made with an invalid imdbid.");
+ return GetErrorXML(201, "Incorrect parameter: invalid imdbid format");
+ }
+
+ if (!CurrentIndexer.TorznabCaps.SupportsImdbSearch)
+ {
+ logger.Warn($"A movie-search request with imdbid from {Request.GetOwinContext().Request.RemoteIpAddress} was made but the indexer {CurrentIndexer.DisplayName} doesn't support it.");
+ return GetErrorXML(203, "Function Not Available: imdbid is not supported by this indexer");
+ }
+ }
+
+ var releases = await CurrentIndexer.ResultsForQuery(CurrentQuery);
+
+ // Some trackers do not support multiple category filtering so filter the releases that match manually.
+ int? newItemCount = null;
+
+ // Cache non query results
+ if (string.IsNullOrEmpty(CurrentQuery.SanitizedSearchTerm))
+ {
+ newItemCount = cacheService.GetNewItemCount(CurrentIndexer, releases);
+ cacheService.CacheRssResults(CurrentIndexer, releases);
+ }
+
+ // Log info
+ var logBuilder = new StringBuilder();
+ if (newItemCount != null)
+ {
+ logBuilder.AppendFormat("Found {0} ({1} new) releases from {2}", releases.Count(), newItemCount, CurrentIndexer.DisplayName);
+ }
+ else
+ {
+ logBuilder.AppendFormat("Found {0} releases from {1}", releases.Count(), CurrentIndexer.DisplayName);
+ }
+
+ if (!string.IsNullOrWhiteSpace(CurrentQuery.SanitizedSearchTerm))
+ {
+ logBuilder.AppendFormat(" for: {0}", CurrentQuery.GetQueryString());
+ }
+
+ logger.Info(logBuilder.ToString());
+
+ var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
+ var resultPage = new ResultPage(new ChannelInfo
+ {
+ Title = CurrentIndexer.DisplayName,
+ Description = CurrentIndexer.DisplayDescription,
+ Link = new Uri(CurrentIndexer.SiteLink),
+ ImageUrl = new Uri(serverUrl + "logos/" + CurrentIndexer.ID + ".png"),
+ ImageTitle = CurrentIndexer.DisplayName,
+ ImageLink = new Uri(CurrentIndexer.SiteLink),
+ ImageDescription = CurrentIndexer.DisplayName
+ });
+
+ var proxiedReleases = releases.Select(r => AutoMapper.Mapper.Map(r)).Select(r =>
+ {
+ r.Link = serverService.ConvertToProxyLink(r.Link, serverUrl, r.Origin.ID, "dl", r.Title + ".torrent");
+ return r;
+ });
+
+ resultPage.Releases = proxiedReleases.ToList();
+
+ var xml = resultPage.ToXml(new Uri(serverUrl));
+ // Force the return as XML
+ return ResponseMessage(new HttpResponseMessage()
+ {
+ Content = new StringContent(xml, Encoding.UTF8, "application/rss+xml")
+ });
+ }
+
+ public IHttpActionResult GetErrorXML(int code, string description)
+ {
+ var xdoc = new XDocument(
+ new XDeclaration("1.0", "UTF-8", null),
+ new XElement("error",
+ new XAttribute("code", code.ToString()),
+ new XAttribute("description", description)
+ )
+ );
+
+ var xml = xdoc.Declaration.ToString() + Environment.NewLine + xdoc.ToString();
+
+ return ResponseMessage(new HttpResponseMessage()
+ {
+ Content = new StringContent(xml, Encoding.UTF8, "application/xml")
+ });
+ }
+
+ [HttpGet]
+ [JsonResponse]
+ public async Task Potato([FromUri]Models.DTO.TorrentPotatoRequest request)
+ {
+ var releases = await CurrentIndexer.ResultsForQuery(CurrentQuery);
+
+ // Cache non query results
+ if (string.IsNullOrEmpty(CurrentQuery.SanitizedSearchTerm))
+ cacheService.CacheRssResults(CurrentIndexer, releases);
+
+ // Log info
+ if (string.IsNullOrWhiteSpace(CurrentQuery.SanitizedSearchTerm))
+ logger.Info($"Found {releases.Count()} torrentpotato releases from {CurrentIndexer.DisplayName}");
+ else
+ logger.Info($"Found {releases.Count()} torrentpotato releases from {CurrentIndexer.DisplayName} for: {CurrentQuery.GetQueryString()}");
+
+ var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
+ var potatoReleases = releases.Where(r => r.Link != null || r.MagnetUri != null).Select(r =>
+ {
+ var release = AutoMapper.Mapper.Map(r);
+ release.Link = serverService.ConvertToProxyLink(release.Link, serverUrl, CurrentIndexer.ID, "dl", release.Title + ".torrent");
+ var item = new Models.DTO.TorrentPotatoResponseItem()
+ {
+ release_name = release.Title + "[" + CurrentIndexer.DisplayName + "]", // Suffix the indexer so we can see which tracker we are using in CPS as it just says torrentpotato >.>
+ torrent_id = release.Guid.ToString(),
+ details_url = release.Comments.ToString(),
+ download_url = (release.Link != null ? release.Link.ToString() : release.MagnetUri.ToString()),
+ imdb_id = release.Imdb.HasValue ? "tt" + release.Imdb : null,
+ freeleech = (release.DownloadVolumeFactor == 0 ? true : false),
+ type = "movie",
+ size = (long)release.Size / (1024 * 1024), // This is in MB
+ leechers = (int)release.Peers - (int)release.Seeders,
+ seeders = (int)release.Seeders,
+ publish_date = r.PublishDate == DateTime.MinValue ? null : release.PublishDate.ToUniversalTime().ToString("s")
+ };
+ return item;
+ });
+
+ var potatoResponse = new Models.DTO.TorrentPotatoResponse()
+ {
+ results = potatoReleases.ToList()
+ };
+
+ return potatoResponse;
+ }
+
+ private void ConfigureCacheResults(IEnumerable results)
+ {
+ var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
+ foreach (var result in results)
+ {
+ var link = result.Link;
+ var file = StringUtil.MakeValidFileName(result.Title, '_', false) + ".torrent";
+ result.Link = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "dl", file);
+ if (result.Link != null && result.Link.Scheme != "magnet" && !string.IsNullOrWhiteSpace(Engine.Server.Config.BlackholeDir))
+ result.BlackholeLink = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "bh", file);
+
+ }
+ }
+
+ private Logger logger;
+ private IServerService serverService;
+ private ICacheService cacheService;
+ }
+}
diff --git a/src/Jackett/Controllers/ServerConfigurationController.cs b/src/Jackett/Controllers/ServerConfigurationController.cs
new file mode 100644
index 000000000..f7517af68
--- /dev/null
+++ b/src/Jackett/Controllers/ServerConfigurationController.cs
@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Web.Http;
+using Jackett.Models;
+using Jackett.Services;
+using Jackett.Utils;
+using NLog;
+
+namespace Jackett.Controllers.V20
+{
+ [RoutePrefix("api/v2.0/server")]
+ [JackettAuthorized]
+ [JackettAPINoCache]
+ public class ServerConfigurationController : ApiController
+ {
+ public ServerConfigurationController(IConfigurationService c, IServerService s, IProcessService p, IIndexerManagerService i, ISecuityService ss, IUpdateService u, ILogCacheService lc, Logger l)
+ {
+ config = c;
+ serverService = s;
+ processService = p;
+ indexerService = i;
+ securityService = ss;
+ updater = u;
+ logCache = lc;
+ logger = l;
+ }
+
+ [HttpPost]
+ public void AdminPassword([FromBody]string password)
+ {
+ var oldPassword = serverService.Config.AdminPassword;
+ if (string.IsNullOrEmpty(password))
+ password = string.Empty;
+
+ if (oldPassword != password)
+ {
+ serverService.Config.AdminPassword = securityService.HashPassword(password);
+ serverService.SaveConfig();
+ }
+ }
+
+ [HttpPost]
+ public void Update()
+ {
+ updater.CheckForUpdatesNow();
+ }
+
+ [HttpGet]
+ public Models.DTO.ServerConfig Config()
+ {
+
+ var dto = new Models.DTO.ServerConfig(serverService.notices, serverService.Config, config.GetVersion());
+ return dto;
+ }
+
+ [ActionName("Config")]
+ [HttpPost]
+ public void UpdateConfig([FromBody]Models.DTO.ServerConfig config)
+ {
+ var originalPort = Engine.Server.Config.Port;
+ var originalAllowExternal = Engine.Server.Config.AllowExternal;
+ int port = config.port;
+ bool external = config.external;
+ string saveDir = config.blackholedir;
+ bool updateDisabled = config.updatedisabled;
+ bool preRelease = config.prerelease;
+ bool logging = config.logging;
+ string basePathOverride = config.basepathoverride;
+ string omdbApiKey = config.omdbkey;
+
+ Engine.Server.Config.UpdateDisabled = updateDisabled;
+ Engine.Server.Config.UpdatePrerelease = preRelease;
+ Engine.Server.Config.BasePathOverride = basePathOverride;
+ Startup.BasePath = Engine.Server.BasePath();
+ Engine.Server.SaveConfig();
+
+ Engine.SetLogLevel(logging ? LogLevel.Debug : LogLevel.Info);
+ Startup.TracingEnabled = logging;
+
+ if (omdbApiKey != Engine.Server.Config.OmdbApiKey)
+ {
+ Engine.Server.Config.OmdbApiKey = omdbApiKey;
+ Engine.Server.SaveConfig();
+ // HACK
+ indexerService.InitAggregateIndexer();
+ }
+
+ if (port != Engine.Server.Config.Port || external != Engine.Server.Config.AllowExternal)
+ {
+
+ if (ServerUtil.RestrictedPorts.Contains(port))
+ throw new Exception("The port you have selected is restricted, try a different one.");
+
+ if (port < 1 || port > 65535)
+ throw new Exception("The port you have selected is invalid, it must be below 65535.");
+
+ // Save port to the config so it can be picked up by the if needed when running as admin below.
+ Engine.Server.Config.AllowExternal = external;
+ Engine.Server.Config.Port = port;
+ Engine.Server.SaveConfig();
+
+ // On Windows change the url reservations
+ if (System.Environment.OSVersion.Platform != PlatformID.Unix)
+ {
+ if (!ServerUtil.IsUserAdministrator())
+ {
+ try
+ {
+ processService.StartProcessAndLog(System.Windows.Forms.Application.ExecutablePath, "--ReserveUrls", true);
+ }
+ catch
+ {
+ Engine.Server.Config.Port = originalPort;
+ Engine.Server.Config.AllowExternal = originalAllowExternal;
+ Engine.Server.SaveConfig();
+
+ throw new Exception("Failed to acquire admin permissions to reserve the new port.");
+ }
+ }
+ else
+ {
+ serverService.ReserveUrls(true);
+ }
+ }
+
+ (new Thread(() =>
+ {
+ Thread.Sleep(500);
+ serverService.Stop();
+ Engine.BuildContainer();
+ Engine.Server.Initalize();
+ Engine.Server.Start();
+ })).Start();
+ }
+
+ if (saveDir != Engine.Server.Config.BlackholeDir)
+ {
+ if (!string.IsNullOrEmpty(saveDir))
+ {
+ if (!Directory.Exists(saveDir))
+ {
+ throw new Exception("Blackhole directory does not exist");
+ }
+ }
+
+ Engine.Server.Config.BlackholeDir = saveDir;
+ Engine.Server.SaveConfig();
+ }
+ }
+
+ [HttpGet]
+ public List Logs()
+ {
+ return logCache.Logs;
+ }
+
+ private IConfigurationService config;
+ private IServerService serverService;
+ private IProcessService processService;
+ private IIndexerManagerService indexerService;
+ private ISecuityService securityService;
+ private IUpdateService updater;
+ private ILogCacheService logCache;
+ private Logger logger;
+ }
+}
diff --git a/src/Jackett/Controllers/TorznabController.cs b/src/Jackett/Controllers/TorznabController.cs
deleted file mode 100644
index a455d5afb..000000000
--- a/src/Jackett/Controllers/TorznabController.cs
+++ /dev/null
@@ -1,182 +0,0 @@
-using AutoMapper;
-using Jackett.Models;
-using Jackett.Services;
-using Jackett.Utils;
-using NLog;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
-using System.Web;
-using System.Web.Http;
-using System.Xml.Linq;
-using Jackett.Indexers;
-
-namespace Jackett.Controllers
-{
- [AllowAnonymous]
- [JackettAPINoCache]
- public class TorznabController : ApiController
- {
- private IIndexerManagerService indexerService;
- private Logger logger;
- private IServerService serverService;
- private ICacheService cacheService;
-
- public TorznabController(IIndexerManagerService i, Logger l, IServerService s, ICacheService c)
- {
- indexerService = i;
- logger = l;
- serverService = s;
- cacheService = c;
- }
-
- public HttpResponseMessage GetErrorXML(int code, string description)
- {
- var xdoc = new XDocument(
- new XDeclaration("1.0", "UTF-8", null),
- new XElement("error",
- new XAttribute("code", code.ToString()),
- new XAttribute("description", description)
- )
- );
-
- var xml = xdoc.Declaration.ToString() + Environment.NewLine + xdoc.ToString();
-
- return new HttpResponseMessage()
- {
- Content = new StringContent(xml, Encoding.UTF8, "application/xml")
- };
- }
-
- [HttpGet]
- public async Task Call(string indexerID)
- {
- var indexer = indexerService.GetIndexer(indexerID);
- var torznabQuery = TorznabQuery.FromHttpQuery(HttpUtility.ParseQueryString(Request.RequestUri.Query));
-
- if (string.Equals(torznabQuery.QueryType, "caps", StringComparison.InvariantCultureIgnoreCase))
- {
- return new HttpResponseMessage()
- {
- Content = new StringContent(indexer.TorznabCaps.ToXml(), Encoding.UTF8, "application/xml")
- };
- }
-
- torznabQuery.ExpandCatsToSubCats();
- var allowBadApiDueToDebug = false;
-#if DEBUG
- allowBadApiDueToDebug = Debugger.IsAttached;
-#endif
-
- if (!allowBadApiDueToDebug && !string.Equals(torznabQuery.ApiKey, serverService.Config.APIKey, StringComparison.InvariantCultureIgnoreCase))
- {
- logger.Warn(string.Format("A request from {0} was made with an incorrect API key.", Request.GetOwinContext().Request.RemoteIpAddress));
- return Request.CreateResponse(HttpStatusCode.Forbidden, "Incorrect API key");
- }
-
- if (!indexer.IsConfigured)
- {
- logger.Warn(string.Format("Rejected a request to {0} which is unconfigured.", indexer.DisplayName));
- return Request.CreateResponse(HttpStatusCode.Forbidden, "This indexer is not configured.");
- }
-
- if (torznabQuery.ImdbID != null)
- {
- if (torznabQuery.QueryType != "movie")
- {
- logger.Warn(string.Format("A non movie request with an imdbid was made from {0}.", Request.GetOwinContext().Request.RemoteIpAddress));
- return GetErrorXML(201, "Incorrect parameter: only movie-search supports the imdbid parameter");
- }
-
- if (!string.IsNullOrEmpty(torznabQuery.SearchTerm))
- {
- logger.Warn(string.Format("A movie-search request from {0} was made contining q and imdbid.", Request.GetOwinContext().Request.RemoteIpAddress));
- return GetErrorXML(201, "Incorrect parameter: please specify either imdbid or q");
- }
-
- torznabQuery.ImdbID = ParseUtil.GetFullImdbID(torznabQuery.ImdbID); // normalize ImdbID
- if (torznabQuery.ImdbID == null)
- {
- logger.Warn(string.Format("A movie-search request from {0} was made with an invalid imdbid.", Request.GetOwinContext().Request.RemoteIpAddress));
- return GetErrorXML(201, "Incorrect parameter: invalid imdbid format");
- }
-
- if (!indexer.TorznabCaps.SupportsImdbSearch)
- {
- logger.Warn(string.Format("A movie-search request with imdbid from {0} was made but the indexer {1} doesn't support it.", Request.GetOwinContext().Request.RemoteIpAddress, indexer.DisplayName));
- return GetErrorXML(203, "Function Not Available: imdbid is not supported by this indexer");
- }
- }
-
- var releases = await indexer.ResultsForQuery(torznabQuery);
-
- // Some trackers do not keep their clocks up to date and can be ~20 minutes out!
- foreach (var release in releases.Where(r => r.PublishDate > DateTime.Now))
- {
- release.PublishDate = DateTime.Now;
- }
-
- // Some trackers do not support multiple category filtering so filter the releases that match manually.
- int? newItemCount = null;
-
- // Cache non query results
- if (string.IsNullOrEmpty(torznabQuery.SanitizedSearchTerm))
- {
- newItemCount = cacheService.GetNewItemCount(indexer, releases);
- cacheService.CacheRssResults(indexer, releases);
- }
-
- // Log info
- var logBuilder = new StringBuilder();
- if (newItemCount != null)
- {
- logBuilder.AppendFormat(string.Format("Found {0} ({1} new) releases from {2}", releases.Count(), newItemCount, indexer.DisplayName));
- }
- else
- {
- logBuilder.AppendFormat(string.Format("Found {0} releases from {1}", releases.Count(), indexer.DisplayName));
- }
-
- if (!string.IsNullOrWhiteSpace(torznabQuery.SanitizedSearchTerm))
- {
- logBuilder.AppendFormat(" for: {0}", torznabQuery.GetQueryString());
- }
-
- logger.Info(logBuilder.ToString());
-
- var serverUrl = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
- var resultPage = new ResultPage(new ChannelInfo
- {
- Title = indexer.DisplayName,
- Description = indexer.DisplayDescription,
- Link = new Uri(indexer.SiteLink),
- ImageUrl = new Uri(serverUrl + "logos/" + indexer.ID + ".png"),
- ImageTitle = indexer.DisplayName,
- ImageLink = new Uri(indexer.SiteLink),
- ImageDescription = indexer.DisplayName
- });
-
-
- foreach (var result in releases)
- {
- var clone = Mapper.Map(result);
- clone.Link = serverService.ConvertToProxyLink(clone.Link, serverUrl, result.Origin.ID, "dl", result.Title + ".torrent");
- resultPage.Releases.Add(clone);
- }
-
- var xml = resultPage.ToXml(new Uri(serverUrl));
- // Force the return as XML
- return new HttpResponseMessage()
- {
- Content = new StringContent(xml, Encoding.UTF8, "application/rss+xml")
- };
- }
-
-
- }
-}
diff --git a/src/Jackett/Controllers/UIController.cs b/src/Jackett/Controllers/UIController.cs
new file mode 100644
index 000000000..7e0a21ce8
--- /dev/null
+++ b/src/Jackett/Controllers/UIController.cs
@@ -0,0 +1,89 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using System.Web;
+using System.Web.Http;
+using Jackett.Services;
+using Jackett.Utils;
+using NLog;
+
+namespace Jackett.Controllers
+{
+ [RoutePrefix("UI")]
+ [JackettAuthorized]
+ [JackettAPINoCache]
+ public class WebUIController : ApiController
+ {
+ public WebUIController(IConfigurationService config, IServerService ss, ISecuityService s, Logger l)
+ {
+ this.config = config;
+ serverService = ss;
+ securityService = s;
+ logger = l;
+ }
+
+ private HttpResponseMessage GetFile(string path)
+ {
+ var result = new HttpResponseMessage(HttpStatusCode.OK);
+ var mappedPath = Path.Combine(config.GetContentFolder(), path);
+ var stream = new FileStream(mappedPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+ result.Content = new StreamContent(stream);
+ result.Content.Headers.ContentType = new MediaTypeHeaderValue(MimeMapping.GetMimeMapping(mappedPath));
+
+ return result;
+ }
+
+ [HttpGet]
+ [AllowAnonymous]
+ public IHttpActionResult Logout()
+ {
+ var ctx = Request.GetOwinContext();
+ var authManager = ctx.Authentication;
+ authManager.SignOut("ApplicationCookie");
+ return Redirect("UI/Dashboard");
+ }
+
+ [HttpGet]
+ [HttpPost]
+ [AllowAnonymous]
+ public async Task Dashboard()
+ {
+ if (Request.RequestUri.Query != null && Request.RequestUri.Query.Contains("logout"))
+ {
+ var file = GetFile("login.html");
+ securityService.Logout(file);
+ return file;
+ }
+
+
+ if (securityService.CheckAuthorised(Request))
+ {
+ return GetFile("index.html");
+
+ }
+ else
+ {
+ var formData = await Request.Content.ReadAsFormDataAsync();
+
+ if (formData != null && securityService.HashPassword(formData["password"]) == serverService.Config.AdminPassword)
+ {
+ var file = GetFile("index.html");
+ securityService.Login(file);
+ return file;
+ }
+ else
+ {
+ return GetFile("login.html");
+ }
+ }
+ }
+
+ private IConfigurationService config;
+ private IServerService serverService;
+ private ISecuityService securityService;
+ private Logger logger;
+ }
+}
diff --git a/src/Jackett/Engine.cs b/src/Jackett/Engine.cs
index 2809aeda7..65d006bec 100644
--- a/src/Jackett/Engine.cs
+++ b/src/Jackett/Engine.cs
@@ -10,6 +10,8 @@ using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
+using System.Web.Http.Dependencies;
+using Autofac.Integration.WebApi;
namespace Jackett
{
@@ -37,9 +39,9 @@ namespace Jackett
}
- public static IContainer GetContainer()
+ public static IDependencyResolver DependencyResolver()
{
- return container;
+ return new AutofacWebApiDependencyResolver(container);
}
public static bool IsWindows
diff --git a/src/Jackett/Indexers/BaseIndexer.cs b/src/Jackett/Indexers/BaseIndexer.cs
index e9e70d201..a3a5dd81e 100644
--- a/src/Jackett/Indexers/BaseIndexer.cs
+++ b/src/Jackett/Indexers/BaseIndexer.cs
@@ -216,11 +216,17 @@ namespace Jackett.Indexers
public virtual async Task> ResultsForQuery(TorznabQuery query)
{
+ if (!CanHandleQuery(query))
+ return new ReleaseInfo[0];
var results = await PerformQuery(query);
results = FilterResults(query, results);
results = results.Select(r =>
{
r.Origin = this;
+
+ // Some trackers do not keep their clocks up to date and can be ~20 minutes out!
+ if (r.PublishDate > DateTime.Now)
+ r.PublishDate = DateTime.Now;
return r;
});
diff --git a/src/Jackett/Indexers/Meta/BaseMetaIndexer.cs b/src/Jackett/Indexers/Meta/BaseMetaIndexer.cs
index f1d63cf4b..33b5c621a 100644
--- a/src/Jackett/Indexers/Meta/BaseMetaIndexer.cs
+++ b/src/Jackett/Indexers/Meta/BaseMetaIndexer.cs
@@ -27,9 +27,9 @@ namespace Jackett.Indexers.Meta
return Task.FromResult(IndexerConfigurationStatus.Completed);
}
- public override async Task> ResultsForQuery(TorznabQuery query)
+ protected override IEnumerable FilterResults(TorznabQuery query, IEnumerable results)
{
- return await PerformQuery(query);
+ return results;
}
protected override async Task> PerformQuery(TorznabQuery query)
diff --git a/src/Jackett/Indexers/Meta/MetaIndexers.cs b/src/Jackett/Indexers/Meta/MetaIndexers.cs
index 9ab13631a..817f8b8c0 100644
--- a/src/Jackett/Indexers/Meta/MetaIndexers.cs
+++ b/src/Jackett/Indexers/Meta/MetaIndexers.cs
@@ -14,6 +14,13 @@ namespace Jackett.Indexers.Meta
{
class AggregateIndexer : BaseMetaIndexer
{
+ public override string ID
+ {
+ get
+ {
+ return "all";
+ }
+ }
public AggregateIndexer(IFallbackStrategyProvider fallbackStrategyProvider, IResultFilterProvider resultFilterProvider, IIndexerConfigurationService configService, IWebClient wc, Logger l, IProtectionService ps)
: base("AggregateSearch", "This feed includes all configured trackers", fallbackStrategyProvider, resultFilterProvider, configService, wc, l, new ConfigurationData(), ps, x => true)
{
diff --git a/src/Jackett/Jackett.csproj b/src/Jackett/Jackett.csproj
index 998564ac4..2e1e39cb3 100644
--- a/src/Jackett/Jackett.csproj
+++ b/src/Jackett/Jackett.csproj
@@ -174,8 +174,6 @@
-
-
@@ -265,7 +263,6 @@
-
@@ -283,7 +280,6 @@
-
@@ -296,9 +292,6 @@
-
-
-
@@ -332,7 +325,6 @@
-
@@ -365,12 +357,10 @@
-
+
-
-
@@ -384,6 +374,19 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -428,6 +431,9 @@
Designer
+
+ PreserveNewest
+
@@ -531,9 +537,6 @@
PreserveNewest
-
- PreserveNewest
-
TextTemplatingFileGenerator
TorznabCatType.generated.cs
@@ -570,6 +573,7 @@
+