mirror of https://github.com/Jackett/Jackett
180 lines
6.0 KiB
C#
180 lines
6.0 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Jackett.Common.Indexers;
|
|
using Jackett.Common.Models;
|
|
using Jackett.Common.Services.Interfaces;
|
|
using Jackett.Common.Utils;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Mvc.Filters;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using NLog;
|
|
|
|
namespace Jackett.Server.Controllers
|
|
{
|
|
public interface IIndexerController
|
|
{
|
|
IIndexerManagerService IndexerService { get; }
|
|
IIndexer CurrentIndexer { get; set; }
|
|
}
|
|
|
|
public class RequiresIndexer : IActionFilter
|
|
{
|
|
public void OnActionExecuting(ActionExecutingContext context)
|
|
{
|
|
var controller = context.Controller;
|
|
if (!(controller is IIndexerController))
|
|
return;
|
|
|
|
var indexerController = controller as IIndexerController;
|
|
|
|
var parameters = context.RouteData.Values;
|
|
|
|
if (!parameters.ContainsKey("indexerId"))
|
|
{
|
|
indexerController.CurrentIndexer = null;
|
|
return;
|
|
}
|
|
|
|
var indexerId = parameters["indexerId"] as string;
|
|
if (string.IsNullOrWhiteSpace(indexerId))
|
|
return;
|
|
|
|
var indexerService = indexerController.IndexerService;
|
|
var indexer = indexerService.GetIndexer(indexerId);
|
|
indexerController.CurrentIndexer = indexer;
|
|
}
|
|
|
|
public void OnActionExecuted(ActionExecutedContext context)
|
|
{
|
|
// do something after the action executes
|
|
}
|
|
}
|
|
|
|
[Route("api/v2.0/indexers")]
|
|
[ResponseCache(Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public class IndexerApiController : Controller, IIndexerController
|
|
{
|
|
public IIndexerManagerService IndexerService { get; private set; }
|
|
public IIndexer CurrentIndexer { get; set; }
|
|
private readonly Logger logger;
|
|
private readonly IServerService serverService;
|
|
private readonly ICacheService cacheService;
|
|
|
|
public IndexerApiController(IIndexerManagerService indexerManagerService, IServerService ss, ICacheService c, Logger logger)
|
|
{
|
|
IndexerService = indexerManagerService;
|
|
serverService = ss;
|
|
cacheService = c;
|
|
this.logger = logger;
|
|
}
|
|
|
|
[HttpGet]
|
|
[TypeFilter(typeof(RequiresIndexer))]
|
|
[Route("{indexerId?}/Config")]
|
|
public async Task<IActionResult> Config()
|
|
{
|
|
var config = await CurrentIndexer.GetConfigurationForSetup();
|
|
return Ok(config.ToJson(null));
|
|
}
|
|
|
|
[HttpPost]
|
|
[Route("{indexerId?}/Config")]
|
|
[TypeFilter(typeof(RequiresIndexer))]
|
|
public async Task<IActionResult> UpdateConfig([FromBody] Common.Models.DTO.ConfigItem[] config)
|
|
{
|
|
// invalidate cache for this indexer
|
|
cacheService.CleanIndexerCache(CurrentIndexer);
|
|
|
|
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);
|
|
}
|
|
|
|
return new NoContentResult();
|
|
}
|
|
catch
|
|
{
|
|
var baseIndexer = CurrentIndexer as BaseIndexer;
|
|
if (null != baseIndexer)
|
|
baseIndexer.ResetBaseConfig();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[HttpGet]
|
|
[Route("")]
|
|
public IEnumerable<Common.Models.DTO.Indexer> Indexers([FromQuery(Name = "configured")] bool configured)
|
|
{
|
|
var dto = IndexerService.GetAllIndexers().Select(i => new Common.Models.DTO.Indexer(i));
|
|
dto = configured ? dto.Where(i => i.configured) : dto;
|
|
return dto;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Route("{indexerid}/[action]")]
|
|
[TypeFilter(typeof(RequiresIndexer))]
|
|
public async Task<IActionResult> Test()
|
|
{
|
|
JToken jsonReply = new JObject();
|
|
try
|
|
{
|
|
await IndexerService.TestIndexer(CurrentIndexer.Id);
|
|
CurrentIndexer.LastError = null;
|
|
return NoContent();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var msg = ex.Message;
|
|
if (ex.InnerException != null)
|
|
msg += ": " + ex.InnerException.Message;
|
|
|
|
if (CurrentIndexer != null)
|
|
CurrentIndexer.LastError = msg;
|
|
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[HttpDelete]
|
|
[TypeFilter(typeof(RequiresIndexer))]
|
|
[Route("{indexerid}")]
|
|
public void Delete() => IndexerService.DeleteIndexer(CurrentIndexer.Id);
|
|
|
|
// TODO
|
|
// This should go to ServerConfigurationController
|
|
[Route("Cache")]
|
|
[HttpGet]
|
|
public List<TrackerCacheResult> Cache()
|
|
{
|
|
var results = cacheService.GetCachedResults();
|
|
ConfigureCacheResults(results);
|
|
return results;
|
|
}
|
|
|
|
private void ConfigureCacheResults(IEnumerable<TrackerCacheResult> results)
|
|
{
|
|
var serverUrl = serverService.GetServerUrl(Request);
|
|
foreach (var result in results)
|
|
{
|
|
var link = result.Link;
|
|
var file = StringUtil.MakeValidFileName(result.Title, '_', false);
|
|
result.Link = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "dl", file);
|
|
if (result.Link != null && result.Link.Scheme != "magnet" && !string.IsNullOrWhiteSpace(serverService.GetBlackholeDirectory()))
|
|
result.BlackholeLink = serverService.ConvertToProxyLink(link, serverUrl, result.TrackerId, "bh", file);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|