Lidarr/NzbDrone.Core/RootFolders/RootFolderService.cs

160 lines
5.6 KiB
C#
Raw Normal View History

2013-02-04 04:18:59 +00:00
using System.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using NLog;
2011-11-13 04:07:06 +00:00
using NzbDrone.Common;
using NzbDrone.Core.Configuration;
using NzbDrone.Core.Datastore;
using NzbDrone.Core.Tv;
2013-02-04 04:18:59 +00:00
namespace NzbDrone.Core.RootFolders
{
2013-02-04 04:18:59 +00:00
public interface IRootFolderService
{
2013-02-05 04:07:07 +00:00
List<RootFolder> All();
2013-05-13 04:24:04 +00:00
List<RootFolder> AllWithUnmappedFolders();
2013-02-05 04:07:07 +00:00
RootFolder Add(RootFolder rootDir);
2013-04-12 00:36:47 +00:00
void Remove(int id);
List<UnmappedFolder> GetUnmappedFolders(string path);
Dictionary<string, long> FreeSpaceOnDrives();
2013-04-12 00:36:47 +00:00
RootFolder Get(int id);
2013-02-04 04:18:59 +00:00
}
public class RootFolderService : IRootFolderService
{
private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
private readonly IBasicRepository<RootFolder> _rootFolderRepository;
2013-05-10 23:53:50 +00:00
private readonly IDiskProvider _diskProvider;
2013-02-19 06:56:02 +00:00
private readonly ISeriesRepository _seriesRepository;
private readonly IConfigService _configService;
public RootFolderService(IBasicRepository<RootFolder> rootFolderRepository,
IDiskProvider diskProvider,
ISeriesRepository seriesRepository,
IConfigService configService)
{
2013-02-04 04:18:59 +00:00
_rootFolderRepository = rootFolderRepository;
_diskProvider = diskProvider;
2013-02-19 06:56:02 +00:00
_seriesRepository = seriesRepository;
_configService = configService;
}
2013-02-05 04:07:07 +00:00
public virtual List<RootFolder> All()
{
2013-02-19 06:56:02 +00:00
var rootFolders = _rootFolderRepository.All().ToList();
2013-05-13 04:24:04 +00:00
return rootFolders;
}
public virtual List<RootFolder> AllWithUnmappedFolders()
{
var rootFolders = _rootFolderRepository.All().ToList();
rootFolders.ForEach(folder =>
2013-05-13 04:24:04 +00:00
{
if (_diskProvider.FolderExists(folder.Path))
{
2013-05-13 04:24:04 +00:00
folder.FreeSpace = _diskProvider.GetAvilableSpace(folder.Path);
folder.UnmappedFolders = GetUnmappedFolders(folder.Path);
}
});
return rootFolders;
}
public virtual RootFolder Add(RootFolder rootFolder)
{
2013-08-03 03:28:17 +00:00
var all = All();
if (String.IsNullOrWhiteSpace(rootFolder.Path) || !Path.IsPathRooted(rootFolder.Path))
throw new ArgumentException("Invalid path");
if (!_diskProvider.FolderExists(rootFolder.Path))
throw new DirectoryNotFoundException("Can't add root directory that doesn't exist.");
if (All().Exists(r => DiskProvider.PathEquals(r.Path, rootFolder.Path)))
throw new InvalidOperationException("Recent directory already exist.");
2013-08-03 03:28:17 +00:00
if (!String.IsNullOrWhiteSpace(_configService.DownloadedEpisodesFolder) &&
DiskProvider.PathEquals(_configService.DownloadedEpisodesFolder, rootFolder.Path))
throw new InvalidOperationException("Drone Factory folder cannot be used.");
2013-02-19 06:56:02 +00:00
_rootFolderRepository.Insert(rootFolder);
2013-02-04 04:18:59 +00:00
rootFolder.FreeSpace = _diskProvider.GetAvilableSpace(rootFolder.Path);
rootFolder.UnmappedFolders = GetUnmappedFolders(rootFolder.Path);
return rootFolder;
}
2011-04-10 02:44:01 +00:00
2013-04-12 00:36:47 +00:00
public virtual void Remove(int id)
{
2013-04-12 00:36:47 +00:00
_rootFolderRepository.Delete(id);
}
2011-04-10 02:44:01 +00:00
public virtual List<UnmappedFolder> GetUnmappedFolders(string path)
{
Logger.Debug("Generating list of unmapped folders");
if (String.IsNullOrEmpty(path))
throw new ArgumentException("Invalid path provided", "path");
var results = new List<UnmappedFolder>();
var series = _seriesRepository.All().ToList();
if (!_diskProvider.FolderExists(path))
{
Logger.Debug("Path supplied does not exist: {0}", path);
return results;
}
foreach (string seriesFolder in _diskProvider.GetDirectories(path))
{
if (!series.Any(s => s.Path == seriesFolder))
2011-07-27 22:59:48 +00:00
{
var di = new DirectoryInfo(seriesFolder.Normalize());
results.Add(new UnmappedFolder{ Name = di.Name, Path = di.FullName });
2011-07-27 22:59:48 +00:00
}
}
if (Path.GetPathRoot(path).Equals(path, StringComparison.InvariantCultureIgnoreCase))
{
var setToRemove = _diskProvider.SpecialFolders;
results.RemoveAll(x => setToRemove.Contains(new DirectoryInfo(x.Path.ToLowerInvariant()).Name));
}
Logger.Debug("{0} unmapped folders detected.", results.Count);
return results;
}
public virtual Dictionary<string, long> FreeSpaceOnDrives()
{
var freeSpace = new Dictionary<string, long>();
2013-02-04 04:18:59 +00:00
var rootDirs = All();
foreach (var rootDir in rootDirs)
{
var pathRoot = _diskProvider.GetPathRoot(rootDir.Path);
if (!freeSpace.ContainsKey(pathRoot))
{
try
{
freeSpace.Add(pathRoot, _diskProvider.GetAvilableSpace(rootDir.Path));
}
catch (Exception ex)
{
2013-03-06 20:30:53 +00:00
Logger.WarnException("Error getting disk space for: " + pathRoot, ex);
}
}
}
return freeSpace;
}
2013-04-12 00:36:47 +00:00
public RootFolder Get(int id)
{
return _rootFolderRepository.Get(id);
}
}
2011-04-10 02:44:01 +00:00
}