├── tests
    └── pdbMate.Core.Tests
    │   ├── settings
    │       ├── sabnzbd.template.json
    │       ├── pdbapi.template.json
    │       └── nzbget.template.json
    │   ├── SabnzbdServiceTests.cs
    │   ├── pdbMate.Core.Tests.csproj
    │   ├── PdbApiServiceTests.cs
    │   └── NzbGetServiceTests.cs
├── src
    ├── pdbMate
    │   ├── SetupLogic
    │   │   ├── ISetup.cs
    │   │   ├── AppSettingsResult.cs
    │   │   └── Setup.cs
    │   ├── Properties
    │   │   └── launchSettings.json
    │   ├── Commands
    │   │   ├── SetupCommand.cs
    │   │   ├── RenameCommand.cs
    │   │   ├── ChangeNamesCommand.cs
    │   │   ├── DownloadCommand.cs
    │   │   ├── AutopilotCommand.cs
    │   │   └── BackfillingCommand.cs
    │   ├── appsettings.Template.json
    │   ├── pdbMate.csproj
    │   └── Program.cs
    └── pdbMate.Core
    │   ├── Data
    │       ├── DownloadClient.cs
    │       ├── Site.cs
    │       ├── Nzbget
    │       │   ├── NzbgetResult.cs
    │       │   ├── NzbgetResultAddDownload.cs
    │       │   ├── NzbgetRequestAddDownload.cs
    │       │   ├── NzbgetQueue.cs
    │       │   └── NzbgetHistory.cs
    │       ├── KnownVideoQualityResult.cs
    │       ├── Actor.cs
    │       ├── Sabnzbd
    │       │   ├── SabnzbdSlotAction.cs
    │       │   ├── SabnzbdAddUrlResult.cs
    │       │   ├── SabnzbdAddDownloadResult.cs
    │       │   ├── SabnzbdResult.cs
    │       │   ├── SabnzbdHistory.cs
    │       │   ├── SabnzbdQueueSlot.cs
    │       │   ├── SabnzbdSlot.cs
    │       │   └── SabnzbdQueue.cs
    │       ├── VideoQuality.cs
    │       ├── VideoclipMetaResult.cs
    │       ├── RenamerResult.cs
    │       ├── Video.cs
    │       ├── UsenetIndexer.cs
    │       ├── SourceFile.cs
    │       └── UsenetRelease.cs
    │   ├── Interfaces
    │       ├── IRenameWorkflow.cs
    │       ├── IChangeNamingTemplateService.cs
    │       ├── IVideoQualityProdiver.cs
    │       ├── IUsenetDownloadService.cs
    │       ├── IDuplicateFinder.cs
    │       ├── IVideoMatching.cs
    │       ├── ISabnzbdService.cs
    │       ├── INzbgetService.cs
    │       ├── IFileOperatingService.cs
    │       ├── IPdbApiService.cs
    │       └── IRenameService.cs
    │   ├── SabnzbdServiceOptions.cs
    │   ├── PdbApiServiceOptions.cs
    │   ├── NzbgetServiceOptions.cs
    │   ├── RenameServiceOptions.cs
    │   ├── UsenetDownloadServiceOptions.cs
    │   ├── StringNormalizer.cs
    │   ├── NzbgetServiceCollectionExtensions.cs
    │   ├── PdbApiServiceCollectionExtensions.cs
    │   ├── SabnzbdServiceCollectionExtensions.cs
    │   ├── pdbMate.Core.csproj
    │   ├── UsenetDownloadServiceCollectionExtensions.cs
    │   ├── RenameServiceCollectionExtensions.cs
    │   ├── DuplicateFinder.cs
    │   ├── RenameWorkflow.cs
    │   ├── VideoQualityProdiver.cs
    │   ├── StringExtractor.cs
    │   ├── SabnzbdService.cs
    │   ├── ChangeNamingTemplateService.cs
    │   ├── FileOperatingService.cs
    │   ├── VideoMatching.cs
    │   ├── NzbgetService.cs
    │   ├── PdbApiService.cs
    │   ├── RenameService.cs
    │   └── UsenetDownloadService.cs
├── pdbMate.sln
├── README.md
├── .gitignore
└── LICENSE


/tests/pdbMate.Core.Tests/settings/sabnzbd.template.json:
--------------------------------------------------------------------------------
1 | {
2 |   "Url": "http://127.0.0.1:8080/sabnzbd/api",
3 |   "ApiKey": ""
4 | }


--------------------------------------------------------------------------------
/tests/pdbMate.Core.Tests/settings/pdbapi.template.json:
--------------------------------------------------------------------------------
1 | {
2 |   "BaseUrl": "https://api-test.porndb.me/",
3 |   "Apikey": "--MY-OWN-APIKEY--"
4 | }


--------------------------------------------------------------------------------
/src/pdbMate/SetupLogic/ISetup.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.SetupLogic
2 | {
3 |     public interface ISetup
4 |     {
5 |         bool RunSetup();
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/DownloadClient.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Data
2 | {
3 |     public enum DownloadClient
4 |     {
5 |         Sabnzbd,
6 |         Nzbget
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/tests/pdbMate.Core.Tests/settings/nzbget.template.json:
--------------------------------------------------------------------------------
1 | {
2 |   "Hostname": "127.0.0.1",
3 |   "Port": 6789,
4 |   "Username": "",
5 |   "Password": "",
6 |   "UseHttps": false
7 | }


--------------------------------------------------------------------------------
/src/pdbMate/Properties/launchSettings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "profiles": {
3 |     "pdbMate": {
4 |       "commandName": "Project",
5 |       "commandLineArgs": "download"
6 |     }
7 |   }
8 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IRenameWorkflow.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Interfaces
2 | {
3 |     public interface IRenameWorkflow
4 |     {
5 |         bool Rename(bool dryRun);
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Site.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Data
2 | {
3 |     public class Site
4 |     {
5 |         public int Id { get; set; }
6 |         public string Sitename { get; set; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IChangeNamingTemplateService.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Interfaces
2 | {
3 |     public interface IChangeNamingTemplateService
4 |     {
5 |         void RenameToNewTemplate(bool dryRun);
6 |     }
7 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/SabnzbdServiceOptions.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core
2 | {
3 |     public class SabnzbdServiceOptions
4 |     {
5 |         public string Url { get; set; }
6 |         public string ApiKey { get; set; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Nzbget/NzbgetResult.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Data.Nzbget
2 | {
3 |     public class NzbgetResult<T>
4 |     {
5 |         public string Version { get; set; }
6 |         public T Result { get; set; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/KnownVideoQualityResult.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Data
2 | {
3 |     public class KnownVideoQualityResult
4 |     {
5 |         public int VideoId { get; set; }
6 |         public int VideoQualityId { get; set; }
7 |     }
8 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Nzbget/NzbgetResultAddDownload.cs:
--------------------------------------------------------------------------------
1 | namespace pdbMate.Core.Data.Nzbget
2 | {
3 |     public class NzbgetResultAddDownload
4 |     {
5 |         public string Version { get; set; }
6 |         public int Result { get; set; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Actor.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data
 2 | {
 3 |     public class Actor
 4 |     {
 5 |         public int Id { get; set; }
 6 |         public string Actorname { get; set; }
 7 |         public int Gender { get; set; }
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdSlotAction.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 | namespace pdbMate.Core.Data.Sabnzbd
3 | {
4 |     public class SabnzbdSlotAction
5 |     {
6 |         public string Name { get; set; }
7 |         public List<string> Actions { get; set; }
8 |     }
9 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/PdbApiServiceOptions.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace pdbMate.Core
 4 | {
 5 |     public class PdbApiServiceOptions
 6 |     {
 7 |         public string BaseUrl { get; set; }
 8 |         public string Apikey { get; set; }
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IVideoQualityProdiver.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Data;
 2 | 
 3 | namespace pdbMate.Core.Interfaces
 4 | {
 5 |     public interface IVideoQualityProdiver
 6 |     {
 7 |         VideoQuality GetById(int id);
 8 |         VideoQuality GetByName(string name);
 9 |     }
10 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdAddUrlResult.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace pdbMate.Core.Data.Sabnzbd
 4 | {
 5 |     public class SabnzbdAddUrlResult
 6 |     {
 7 |         public bool Status { get; set; }
 8 |         public List<string> Nzo_ids { get; set; }
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IUsenetDownloadService.cs:
--------------------------------------------------------------------------------
1 | using pdbMate.Core.Data;
2 | 
3 | namespace pdbMate.Core.Interfaces
4 | {
5 |     public interface IUsenetDownloadService
6 |     {
7 |         void Execute(bool dryRun, DownloadClient? client, int? backFillingActors, int? backFillingSites, int daysBack);
8 |     }
9 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IDuplicateFinder.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using pdbMate.Core.Data;
 3 | 
 4 | namespace pdbMate.Core.Interfaces
 5 | {
 6 |     public interface IDuplicateFinder
 7 |     {
 8 |         List<RenamerResult> Process(List<RenamerResult> renameResults, bool includeQuality);
 9 |     }
10 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/VideoQuality.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data
 2 | {
 3 |     public class VideoQuality
 4 |     {
 5 |         public int Id { get; set; }
 6 |         public string Name { get; set; }
 7 |         public string SimplifiedName { get; set; }
 8 |         public int BetterQualityOrdinal { get; set; }
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/VideoclipMetaResult.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data
 2 | {
 3 |     public class VideoclipMetaResult
 4 |     {
 5 |         public SourceFile Source { get; set; }
 6 |         public Video Video { get; set; }
 7 |         public int VideoQualityId { get; set; }
 8 |         public string FileExtension { get; set; }
 9 |     }
10 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdAddDownloadResult.cs:
--------------------------------------------------------------------------------
 1 | using System.Text.Json.Serialization;
 2 | 
 3 | namespace pdbMate.Core.Data.Sabnzbd
 4 | {
 5 |     public class SabnzbdAddDownloadResult
 6 |     {
 7 |         [JsonPropertyName("status")]
 8 |         public bool Status { get; set; }
 9 |         public string Error { get; set; }
10 |     }
11 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/NzbgetServiceOptions.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core
 2 | {
 3 |     public class NzbgetServiceOptions
 4 |     {
 5 |         public string Hostname { get; set; }
 6 |         public int Port { get; set; }
 7 |         public string Username { get; set; }
 8 |         public string Password { get; set; }
 9 |         public bool UseHttps { get; set; }
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdResult.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data.Sabnzbd
 2 | {
 3 |     public class SabnzbdResult
 4 |     {
 5 |         public string Status { get; set; }
 6 |         public string Error { get; set; }
 7 |         public string Version { get; set; }
 8 |         public SabnzbdHistory History { get; set; }
 9 |         public SabnzbdQueue Queue { get; set; }
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IVideoMatching.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using pdbMate.Core.Data;
 3 | 
 4 | namespace pdbMate.Core.Interfaces
 5 | {
 6 |     public interface IVideoMatching
 7 |     {
 8 |         Video GetVideoByName(string name);
 9 |         Video GetVideoByDate(List<Video> videos, string name);
10 |         Video GetVideoByEpisode(List<Video> videos, string name);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/RenameServiceOptions.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace pdbMate.Core
 4 | {
 5 |     public class RenameServiceOptions
 6 |     {
 7 |         public string FilenameTemplate { get; set; }
 8 |         public string FolderTemplate { get; set; }
 9 |         public List<string> SourceFolders { get; set; }
10 |         public string TargetFolder { get; set; }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/RenamerResult.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data
 2 | {
 3 |     public class RenamerResult
 4 |     {
 5 |         public SourceFile Source { get; set; }
 6 |         public string Filename { get; set; }
 7 |         public string Foldername { get; set; }
 8 |         public string FileExtension { get; set; }
 9 |         public int VideoQualityId { get; set; }
10 |         public Video Video { get; set; }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Video.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace pdbMate.Core.Data
 5 | {
 6 |     public class Video
 7 |     {
 8 |         public int Id { get; set; }
 9 |         public Site Site { get; set; }
10 |         public string Title { get; set; }
11 |         public string FullTitle { get; set; }
12 |         public DateTime Releasedate { get; set; }
13 |         public List<Actor> Actors { get; set; }
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/UsenetIndexer.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data
 2 | {
 3 |     public class UsenetIndexer
 4 |     {
 5 |         public int Id { get; set; }
 6 |         public string Name { get; set; }
 7 |         public string Script { get; set; }
 8 |         public string Templateurl { get; set; }
 9 |         public string Downloadurl { get; set; }
10 |         public string Regexguid { get; set; }
11 |         public string Apikey { get; set; }
12 |         public string Apiuserid { get; set; }
13 |     }
14 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Nzbget/NzbgetRequestAddDownload.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Text.Json.Serialization;
 3 | 
 4 | namespace pdbMate.Core.Data.Nzbget
 5 | {
 6 |     public class NzbgetRequestAddDownload
 7 |     {
 8 |         [JsonPropertyName("method")]
 9 |         public string Method { get; set; }
10 | 
11 |         [JsonPropertyName("id")]
12 |         public int Id { get; set; }
13 | 
14 |         [JsonPropertyName("params")]
15 |         public object[] Params { get; set; }
16 |     }
17 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/SourceFile.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data
 2 | {
 3 |     public class SourceFile
 4 |     {
 5 |         public string Path { get; set; }
 6 |         public string FileExtension { get; set; }
 7 |         public string Filename { get; set; }
 8 |         public string Foldername { get; set; }
 9 |         public int Filesize { get; set; }
10 |         public bool IsDuplicate { get; set; }
11 |         public bool IsToSmall { get; set; }
12 |         public bool IsNoVideoExtension { get; set; }
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/ISabnzbdService.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.Extensions.Options;
 2 | using pdbMate.Core.Data.Sabnzbd;
 3 | 
 4 | namespace pdbMate.Core.Interfaces
 5 | {
 6 |     public interface ISabnzbdService
 7 |     {
 8 |         void setOptions(IOptions<SabnzbdServiceOptions> optionsToSet);
 9 |         bool CheckConnection();
10 |         string GetVersion();
11 |         bool AddDownload(string url);
12 |         SabnzbdQueue GetQueue(int start, int limit);
13 |         SabnzbdHistory GetHistory(int start, int limit);
14 |     }
15 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/UsenetDownloadServiceOptions.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Data;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace pdbMate.Core
 5 | {
 6 |     public class UsenetDownloadServiceOptions
 7 |     {
 8 |         public List<string> AllowedQualities { get; set; }
 9 |         public bool KeepOnlyHighestQuality { get; set; }
10 |         public bool DownloadFavoriteActors { get; set; }
11 |         public bool DownloadFavoriteSites { get; set; }
12 |         public DownloadClient ActiveClient  { get; set; }
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/INzbgetService.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using Microsoft.Extensions.Options;
 3 | using pdbMate.Core.Data.Nzbget;
 4 | 
 5 | namespace pdbMate.Core.Interfaces
 6 | {
 7 |     public interface INzbgetService
 8 |     {
 9 |         void setOptions(IOptions<NzbgetServiceOptions> optionsToSet);
10 |         void CheckConnection();
11 |         int GetVersion();
12 |         List<NzbgetQueue> GetQueue();
13 |         List<NzbgetHistory> GetHistory();
14 |         bool AddDownload(string url);
15 |     }
16 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IFileOperatingService.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using pdbMate.Core.Data;
 3 | 
 4 | namespace pdbMate.Core.Interfaces
 5 | {
 6 |     public interface IFileOperatingService
 7 |     {
 8 |         void RemoveUnwantedFiles(List<SourceFile> files, bool dryRun);
 9 |         void MoveFilesBasedOnRenameResults(List<RenamerResult> renamerResults, string targetFolder, bool dryRun);
10 |         void DeleteDirectories(List<string> directories, bool dryRun);
11 | 
12 |         void WriteJsonFromObject<T>(T objectClass, string filename);
13 |     }
14 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/StringNormalizer.cs:
--------------------------------------------------------------------------------
 1 | using System.Text.RegularExpressions;
 2 | 
 3 | namespace pdbMate.Core
 4 | {
 5 |     public static class StringNormalizer
 6 |     {
 7 |         public static string Normalize(string s)
 8 |         {
 9 |             s = Regex.Replace(s, @"[^a-zA-Z]+", " ");
10 |             s = s.ToLowerInvariant();
11 |             s = s.Replace("     ", " ");
12 |             s = s.Replace("    ", " ");
13 |             s = s.Replace("   ", " ");
14 |             s = s.Replace("  ", " ");
15 |             s = s.Replace("  ", " ");
16 |             s = s.Trim();
17 | 
18 |             return s;
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/UsenetRelease.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace pdbMate.Core.Data
 4 | {
 5 |     public class UsenetRelease
 6 |     {
 7 |         public int Id { get; set; }
 8 |         public int Indexer { get; set; }
 9 |         public int Video { get; set; }
10 |         public int Site { get; set; }
11 |         public string Guid { get; set; }
12 |         public string Title { get; set; }
13 |         public int Filesize { get; set; }
14 |         public int Actor1 { get; set; }
15 |         public int Actor2 { get; set; }
16 |         public DateTime Created { get; set; }
17 |         public VideoQuality VideoQuality { get; set; }
18 |     }
19 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IPdbApiService.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using Microsoft.Extensions.Options;
 3 | using pdbMate.Core.Data;
 4 | 
 5 | namespace pdbMate.Core.Interfaces
 6 | {
 7 |     public interface IPdbApiService
 8 |     {
 9 |         void setOptions(IOptions<PdbApiServiceOptions> optionsToSet);
10 |         List<VideoQuality> GetAllVideoQuality();
11 |         List<Site> GetSites();
12 |         List<Video> GetVideosBySite(Site site);
13 |         List<Actor> GetFavoriteActors();
14 |         List<Site> GetFavoriteSites();
15 |         List<UsenetRelease> GetReleases(int page, int take, int? actor, int? site, string search);
16 |         List<UsenetIndexer> GetMyIndexer();
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/pdbMate/Commands/SetupCommand.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.SetupLogic;
 2 | using pdbme.pdbInfrastructure.Logging.Commands;
 3 | using Spectre.Console.Cli;
 4 | using System;
 5 | 
 6 | namespace pdbMate.Commands
 7 | {
 8 |     public class SetupCommand : Command<SetupCommand.Settings>
 9 |     {
10 |         private readonly ISetup setup;
11 | 
12 |         public SetupCommand(ISetup setup)
13 |         {
14 |             this.setup = setup ?? throw new ArgumentNullException(nameof(setup));
15 |         }
16 | 
17 |         public class Settings : LogCommandSettings
18 |         {
19 |         }
20 | 
21 |         public override int Execute(CommandContext context, Settings settings)
22 |         {
23 |             setup.RunSetup();
24 |             return 0;
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/NzbgetServiceCollectionExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.Extensions.Configuration;
 3 | using Microsoft.Extensions.DependencyInjection;
 4 | using pdbMate.Core.Interfaces;
 5 | 
 6 | namespace pdbMate.Core
 7 | {
 8 |     public static class NzbgetServiceCollectionExtensions
 9 |     {
10 |         public static IServiceCollection AddNzbgetService(this IServiceCollection services, IConfiguration config)
11 |         {
12 |             if (services == null) throw new ArgumentNullException(nameof(services));
13 |             if (config == null) throw new ArgumentNullException(nameof(config));
14 | 
15 |             services.AddScoped<INzbgetService, NzbgetService>();
16 |             services.Configure<NzbgetServiceOptions>(config);
17 | 
18 |             return services;
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/PdbApiServiceCollectionExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.Extensions.Configuration;
 3 | using Microsoft.Extensions.DependencyInjection;
 4 | using pdbMate.Core.Interfaces;
 5 | 
 6 | namespace pdbMate.Core
 7 | {
 8 |     public static class PdbApiServiceCollectionExtensions
 9 |     {
10 |         public static IServiceCollection AddPdbApiService(this IServiceCollection services, IConfiguration config)
11 |         {
12 |             if (services == null) throw new ArgumentNullException(nameof(services));
13 |             if (config == null) throw new ArgumentNullException(nameof(config));
14 | 
15 |             services.AddScoped<IPdbApiService, PdbApiService>();
16 |             services.Configure<PdbApiServiceOptions>(config);
17 | 
18 |             return services;
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/SabnzbdServiceCollectionExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.Extensions.Configuration;
 3 | using Microsoft.Extensions.DependencyInjection;
 4 | using pdbMate.Core.Interfaces;
 5 | 
 6 | namespace pdbMate.Core
 7 | {
 8 |     public static class SabnzbdServiceCollectionExtensions
 9 |     {
10 |         public static IServiceCollection AddSabnzbdService(this IServiceCollection services, IConfiguration config)
11 |         {
12 |             if (services == null) throw new ArgumentNullException(nameof(services));
13 |             if (config == null) throw new ArgumentNullException(nameof(config));
14 | 
15 |             services.AddScoped<ISabnzbdService, SabnzbdService>();
16 |             services.Configure<SabnzbdServiceOptions>(config);
17 | 
18 |             return services;
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/pdbMate.Core.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net6.0</TargetFramework>
 5 |     <DebugType>portable</DebugType>
 6 | 	<AssemblyVersion>0.2.0</AssemblyVersion>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="6.0.0" />
11 |     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="6.0.0" />
12 |     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
13 |     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="6.0.0" />
14 |     <PackageReference Include="RestSharp" Version="107.3.0" />
15 |     <PackageReference Include="RestSharp.Serializers.SystemTextJson" Version="106.15.0" />
16 |   </ItemGroup>
17 | 
18 | </Project>
19 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Interfaces/IRenameService.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using pdbMate.Core.Data;
 3 | 
 4 | namespace pdbMate.Core.Interfaces
 5 | {
 6 |     public interface IRenameService
 7 |     {
 8 |         List<SourceFile> GetFilesToProcess();
 9 |         List<RenamerResult> ProcessBatch(List<SourceFile> sourceFiles);
10 |         List<RenamerResult> ProcessFiles(List<SourceFile> sourceFiles);
11 |         List<string> GetEmptyDirectories();
12 |         List<KnownVideoQualityResult> GetKnownVideoQualityResults();
13 | 
14 |         List<RenamerResult> CheckForDuplicates(List<RenamerResult> renamerResults,
15 |             List<KnownVideoQualityResult> knownVideoQualityResults);
16 | 
17 |         List<RenamerResult> CheckForDuplicatesInResults(List<RenamerResult> renamerResults);
18 |         string GetTargetPath();
19 |         string ReplaceTemplatePlaceholders(string template, RenamerResult v);
20 |     }
21 | }


--------------------------------------------------------------------------------
/src/pdbMate/appsettings.Template.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Rename": {
 3 |     "FilenameTemplate": "{Video.ReleasedateShort} - {Video.Title} - {VideoQuality.SimplifiedName} - {PdbId}{FileExtension}",
 4 |     "FolderTemplate": "{Video.Site.Sitename}",
 5 |     "SourceFolders": [
 6 |       ""
 7 |     ],
 8 |     "TargetFolder": ""
 9 |   },
10 |   "PdbApi": {
11 |     "BaseUrl": "https://api.porndb.me/",
12 |     "ApiKey": "--MY-OWN-APIKEY--"
13 |   },
14 |   "Nzbget": {
15 |     "Hostname": "127.0.0.1",
16 |     "Port": 6789,
17 |     "Username": "",
18 |     "Password": "",
19 |     "UseHttps": false
20 |   },
21 |   "Sabnzbd": {
22 |     "Url": "http://127.0.0.1:8080/sabnzbd/api",
23 |     "ApiKey": ""
24 |   },
25 |   "UsenetDownload": {
26 |     "AllowedQualities": [ "1080p", "2160p" ],
27 |     "KeepOnlyHighestQuality": true,
28 |     "DownloadFavoriteActors": true,
29 |     "DownloadFavoriteSites": true,
30 |     "ActiveClient": 0
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/UsenetDownloadServiceCollectionExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.Extensions.Configuration;
 3 | using Microsoft.Extensions.DependencyInjection;
 4 | using pdbMate.Core.Interfaces;
 5 | 
 6 | namespace pdbMate.Core
 7 | {
 8 |     public static class UsenetDownloadServiceCollectionExtensions
 9 |     {
10 |         public static IServiceCollection AddUsenetDownloadService(this IServiceCollection services, IConfiguration config)
11 |         {
12 |             if (services == null) throw new ArgumentNullException(nameof(services));
13 |             if (config == null) throw new ArgumentNullException(nameof(config));
14 | 
15 |             services.AddScoped<IUsenetDownloadService, UsenetDownloadService>();
16 |             services.AddScoped<IVideoMatching, VideoMatching>();
17 |             services.Configure<UsenetDownloadServiceOptions>(config);
18 | 
19 |             return services;
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdHistory.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Text.Json.Serialization;
 3 | 
 4 | namespace pdbMate.Core.Data.Sabnzbd
 5 | {
 6 |     public class SabnzbdHistory
 7 |     {
 8 |         [JsonPropertyName("total_size")]
 9 |         public string TotalSize { get; set; }
10 | 
11 |         [JsonPropertyName("month_size")]
12 |         public string MonthSize { get; set; }
13 | 
14 |         [JsonPropertyName("week_size")]
15 |         public string WeekSize { get; set; }
16 | 
17 |         [JsonPropertyName("day_size")]
18 |         public string DaySize { get; set; }
19 | 
20 |         [JsonPropertyName("noofslots")]
21 |         public int NumberOfSlots { get; set; }
22 | 
23 |         [JsonPropertyName("last_history_update")]
24 |         public int LastHistoryUpdate { get; set; }
25 | 
26 |         public string Version { get; set; }
27 | 
28 |         public List<SabnzbdSlot> Slots { get; set; }
29 |     }
30 | }


--------------------------------------------------------------------------------
/src/pdbMate/Commands/RenameCommand.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Interfaces;
 2 | using pdbme.pdbInfrastructure.Logging.Commands;
 3 | using Spectre.Console.Cli;
 4 | using System.ComponentModel;
 5 | 
 6 | namespace pdbMate.Commands
 7 | {
 8 |     public class RenameCommand : Command<RenameCommand.Settings>
 9 |     {
10 |         private readonly IRenameWorkflow renameWorkflow;
11 | 
12 |         public RenameCommand(IRenameWorkflow renameWorkflow)
13 |         {
14 |             this.renameWorkflow = renameWorkflow;
15 |         }
16 | 
17 |         public class Settings : LogCommandSettings
18 |         {
19 |             [CommandOption("-d|--dryrun")]
20 |             [DefaultValue(false)]
21 |             public bool DryRun { get; init; }
22 |         }
23 | 
24 |         public override int Execute(CommandContext context, Settings settings)
25 |         {
26 |             renameWorkflow.Rename(settings.DryRun);
27 |             return 0;
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/pdbMate/Commands/ChangeNamesCommand.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Interfaces;
 2 | using pdbme.pdbInfrastructure.Logging.Commands;
 3 | using Spectre.Console.Cli;
 4 | using System.ComponentModel;
 5 | 
 6 | namespace pdbMate.Commands
 7 | {
 8 |     public class ChangeNamesCommand : Command<ChangeNamesCommand.Settings>
 9 |     {
10 |         private readonly IChangeNamingTemplateService changeNamingTemplateService;
11 | 
12 |         public ChangeNamesCommand(IChangeNamingTemplateService changeNamingTemplateService)
13 |         {
14 |             this.changeNamingTemplateService = changeNamingTemplateService;
15 |         }
16 | 
17 |         public class Settings : LogCommandSettings
18 |         {
19 |             [CommandOption("-d|--dryrun")]
20 |             [DefaultValue(false)]
21 |             public bool DryRun { get; init; }
22 |         }
23 | 
24 |         public override int Execute(CommandContext context, Settings settings)
25 |         {
26 |             changeNamingTemplateService.RenameToNewTemplate(settings.DryRun);
27 |             return 0;
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/RenameServiceCollectionExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Microsoft.Extensions.Configuration;
 3 | using Microsoft.Extensions.DependencyInjection;
 4 | using pdbMate.Core.Interfaces;
 5 | 
 6 | namespace pdbMate.Core
 7 | {
 8 |     public static class RenameServiceCollectionExtensions
 9 |     {
10 |         public static IServiceCollection AddRenameService(this IServiceCollection services, IConfiguration config)
11 |         {
12 |             if (services == null) throw new ArgumentNullException(nameof(services));
13 |             if (config == null) throw new ArgumentNullException(nameof(config));
14 | 
15 |             services.AddScoped<IFileOperatingService, FileOperatingService>();
16 |             services.AddScoped<IRenameService, RenameService>();
17 |             services.AddScoped<IVideoQualityProdiver, VideoQualityProdiver>();
18 |             services.AddScoped<IDuplicateFinder, DuplicateFinder>();
19 |             services.Configure<RenameServiceOptions>(config);
20 |             services.AddScoped<IChangeNamingTemplateService, ChangeNamingTemplateService>();
21 |             services.AddScoped<IRenameWorkflow, RenameWorkflow>();
22 | 
23 |             return services;
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/pdbMate/Commands/DownloadCommand.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Data;
 2 | using pdbMate.Core.Interfaces;
 3 | using pdbme.pdbInfrastructure.Logging.Commands;
 4 | using Spectre.Console.Cli;
 5 | using System;
 6 | using System.ComponentModel;
 7 | 
 8 | namespace pdbMate.Commands
 9 | {
10 |     public class DownloadCommand : Command<DownloadCommand.Settings>
11 |     {
12 |         private readonly IUsenetDownloadService usenetDownloadService;
13 | 
14 |         public DownloadCommand(IUsenetDownloadService usenetDownloadService)
15 |         {
16 |             this.usenetDownloadService = usenetDownloadService ?? throw new ArgumentNullException(nameof(usenetDownloadService));
17 |         }
18 | 
19 |         public class Settings : LogCommandSettings
20 |         {
21 |             [CommandOption("-d|--dryrun")]
22 |             [DefaultValue(false)]
23 |             public bool DryRun { get; init; }
24 | 
25 |             [CommandOption("-c|--client")]
26 |             public DownloadClient? Client { get; init; }
27 |         }
28 | 
29 |         public override int Execute(CommandContext context, Settings settings)
30 |         {
31 |             usenetDownloadService.Execute(settings.DryRun, settings.Client, null, null, 0);
32 |             return 0;
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Nzbget/NzbgetQueue.cs:
--------------------------------------------------------------------------------
 1 | namespace pdbMate.Core.Data.Nzbget
 2 | {
 3 |     public class NzbgetQueue
 4 |     {
 5 |         public int FirstId { get; set; }
 6 |         public int LastId { get; set; }
 7 |         public string Status { get; set; }
 8 |         public int NzbId { get; set; }
 9 |         public string NzbName { get; set; }
10 |         public string NzbNicename { get; set; }
11 |         public string Kind { get; set; }
12 |         public string Url { get; set; }
13 |         public string NzbFilename { get; set; }
14 |         public string DestDir { get; set; }
15 |         public string FinalDir { get; set; }
16 |         public string Category { get; set; }
17 |         public string UrlStatus { get; set; }
18 |         public int FileSizeMb { get; set; }
19 |         public int FileCount { get; set; }
20 |         public bool Deleted { get; set; }
21 |         public int TotalArticles { get; set; }
22 |         public int SuccessArticles { get; set; }
23 |         public int FailedArticles { get; set; }
24 |         public int Health { get; set; }
25 |         public int CriticalHealth { get; set; }
26 |         public string DupeKey { get; set; }
27 |         public int DupeScore { get; set; }
28 |         public string DupeMode { get; set; }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/pdbMate/pdbMate.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>Exe</OutputType>
 5 |     <TargetFramework>net6.0</TargetFramework>
 6 |     <DebugType>portable</DebugType>
 7 |     <AssemblyVersion>0.3.1</AssemblyVersion>
 8 |   </PropertyGroup>
 9 | 
10 |   <ItemGroup>
11 |     <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.1" />
12 |     <PackageReference Include="pdbme.pdbInfrastructure" Version="1.0.3" />
13 |     <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
14 |     <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
15 |     <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
16 |     <PackageReference Include="Spectre.Console" Version="0.43.0" />
17 |   </ItemGroup>
18 | 
19 |   <ItemGroup>
20 |     <ProjectReference Include="..\pdbMate.Core\pdbMate.Core.csproj" />
21 |   </ItemGroup>
22 | 
23 |   <ItemGroup>
24 |     <None Update="appsettings.Template.json">
25 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
26 |     </None>
27 |     <None Update="appsettings.json">
28 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
29 |     </None>
30 |   </ItemGroup>
31 | 
32 |   <ProjectExtensions><VisualStudio><UserProperties /></VisualStudio></ProjectExtensions>
33 | 
34 | </Project>
35 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdQueueSlot.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Text.Json.Serialization;
 3 | 
 4 | namespace pdbMate.Core.Data.Sabnzbd
 5 | {
 6 |     public class SabnzbdQueueSlot
 7 |     {
 8 |         public int Index { get; set; }
 9 | 
10 |         [JsonPropertyName("nzo_id")] 
11 |         public string NzoId { get; set; }
12 |         public string UnpackOpts { get; set; }
13 |         public string Priority { get; set; }
14 |         public string Script { get; set; }
15 |         public string Filename { get; set; }
16 |         public List<string> Labels { get; set; }
17 |         public string Password { get; set; }
18 |         public string Cat { get; set; }
19 |         public string Mbleft { get; set; }
20 |         public string Mb { get; set; }
21 |         public string Size { get; set; }
22 |         public string SizeLeft { get; set; }
23 |         public string Percentage { get; set; }
24 |         public string MbMissing { get; set; }
25 |         public string Status { get; set; }
26 |         public string Timeleft { get; set; }
27 |         public string Eta { get; set; }
28 |         [JsonPropertyName("avg_age")] 
29 |         public string AverageAge { get; set; }
30 | 
31 |         [JsonPropertyName("has_rating")] 
32 |         public bool HasRating { get; set; }
33 |     }
34 | }


--------------------------------------------------------------------------------
/src/pdbMate/Commands/AutopilotCommand.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Data;
 2 | using pdbMate.Core.Interfaces;
 3 | using pdbme.pdbInfrastructure.Logging.Commands;
 4 | using Spectre.Console.Cli;
 5 | using System.ComponentModel;
 6 | 
 7 | namespace pdbMate.Commands
 8 | {
 9 |     public class AutopilotCommand : Command<AutopilotCommand.Settings>
10 |     {
11 |         private readonly IRenameWorkflow renameWorkflow;
12 |         private readonly IUsenetDownloadService usenetDownloadService;
13 | 
14 |         public AutopilotCommand(IRenameWorkflow renameWorkflow, IUsenetDownloadService usenetDownloadService)
15 |         {
16 |             this.renameWorkflow = renameWorkflow;
17 |             this.usenetDownloadService = usenetDownloadService;
18 |         }
19 | 
20 |         public class Settings : LogCommandSettings
21 |         {
22 |             [CommandOption("-d|--dryrun")]
23 |             [DefaultValue(false)]
24 |             public bool DryRun { get; set; }
25 | 
26 |             [CommandOption("-c|--client")]
27 |             public DownloadClient? Client { get; init; }
28 |         }
29 | 
30 |         public override int Execute(CommandContext context, Settings settings)
31 |         {
32 |             renameWorkflow.Rename(settings.DryRun);
33 |             usenetDownloadService.Execute(settings.DryRun, settings.Client, null, null, 0);
34 |             return 0;
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/pdbMate.Core.Tests/SabnzbdServiceTests.cs:
--------------------------------------------------------------------------------
 1 | using System.IO;
 2 | using System.Text.Json;
 3 | using Microsoft.Extensions.Logging;
 4 | using NUnit.Framework;
 5 | using FluentAssertions;
 6 | using Microsoft.Extensions.Options;
 7 | using pdbMate.Core.Interfaces;
 8 | 
 9 | namespace pdbMate.Core.Tests
10 | {
11 |     // To run these tests start a docker vm with sabnzbd
12 |     //
13 |     public class SabnzbdServiceTests
14 |     {
15 |         private ILogger<ISabnzbdService> sabnzbdServiceLogger;
16 |         private IOptions<SabnzbdServiceOptions> nzbgetOptions;
17 | 
18 |         [SetUp]
19 |         public void Setup()
20 |         {
21 |             using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
22 |             sabnzbdServiceLogger = loggerFactory.CreateLogger<ISabnzbdService>();
23 | 
24 |             var jsonString = File.ReadAllText(Path.Combine("settings", "sabnzbd.json"));
25 |             nzbgetOptions = Options.Create(JsonSerializer.Deserialize<SabnzbdServiceOptions>(jsonString));
26 |         }
27 | 
28 |         [Test]
29 |         public void GetVersion()
30 |         {
31 |             ISabnzbdService service = new SabnzbdService(sabnzbdServiceLogger, nzbgetOptions);
32 | 
33 |             service.CheckConnection();
34 |             service.GetVersion().Should().NotBeNullOrEmpty();
35 | 
36 |             service.GetQueue(0, 100).Should().NotBeNull();
37 |             service.GetHistory(0, 100).Should().NotBeNull();
38 |         }
39 |     }
40 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Nzbget/NzbgetHistory.cs:
--------------------------------------------------------------------------------
 1 | using System.Text.Json.Serialization;
 2 | 
 3 | namespace pdbMate.Core.Data.Nzbget
 4 | {
 5 |     public class NzbgetHistory
 6 |     {
 7 |         public int Id { get; set; }
 8 |         public string Name { get; set; }
 9 |         public int RemainingFileCount { get; set; }
10 |         public bool RetryData { get; set; }
11 |         public string Status { get; set; }
12 |         public int Nzbid { get; set; }
13 |         public string NzbName { get; set; }
14 |         public string NzbNicename { get; set; }
15 |         public string Kind { get; set; }
16 |         public string Url { get; set; }
17 |         public string NzbFilename { get; set; }
18 |         public string DestDir { get; set; }
19 |         public string FinalDir { get; set; }
20 |         public string Category { get; set; }
21 |         public string MarkStatus { get; set; }
22 |         public string UrlStatus { get; set; }
23 |         public int FileSizeMb { get; set; }
24 |         public int FileCount { get; set; }
25 |         public bool Deleted { get; set; }
26 |         public int TotalArticles { get; set; }
27 |         public int SuccessArticles { get; set; }
28 |         public int FailedArticles { get; set; }
29 |         public int Health { get; set; }
30 |         public int CriticalHealth { get; set; }
31 |         public string DupeKey { get; set; }
32 |         public int DupeScore { get; set; }
33 |         public string DupeMode { get; set; }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdSlot.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Text.Json.Serialization;
 3 | 
 4 | namespace pdbMate.Core.Data.Sabnzbd
 5 | {
 6 |     public class SabnzbdSlot
 7 |     {
 8 |         public int Id { get; set; }
 9 |         public int Completed { get; set; }
10 |         public string Name { get; set; }
11 | 
12 |         [JsonPropertyName("nzb_name")]
13 |         public string NzbName { get; set; }
14 | 
15 |         public string Category { get; set; }
16 | 
17 |         [JsonPropertyName("pp")]
18 |         public string PostProcessing { get; set; }
19 |         public string Script { get; set; }
20 |         public string Report { get; set; }
21 |         public string Url { get; set; }
22 |         public string Status { get; set; }
23 | 
24 |         [JsonPropertyName("nzo_id")]
25 |         public string NzoId { get; set; }
26 |         public string Storage { get; set; }
27 |         public string Path { get; set; }
28 | 
29 |         [JsonPropertyName("script_log")]
30 |         public string ScriptLog { get; set; }
31 | 
32 |         [JsonPropertyName("script_line")]
33 |         public string ScriptLine { get; set; }
34 | 
35 |         [JsonPropertyName("download_time")]
36 |         public int DownloadTime { get; set; }
37 | 
38 |         [JsonPropertyName("postproc_time")]
39 |         public int PostProcessTime { get; set; }
40 | 
41 |         [JsonPropertyName("stage_log")]
42 |         public List<SabnzbdSlotAction> StageLog { get; set; }
43 |     }
44 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/DuplicateFinder.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using Microsoft.Extensions.Logging;
 3 | using pdbMate.Core.Data;
 4 | using pdbMate.Core.Interfaces;
 5 | 
 6 | namespace pdbMate.Core
 7 | {
 8 |     public class DuplicateFinder : IDuplicateFinder
 9 |     {
10 |         private readonly ILogger<IDuplicateFinder> logger;
11 | 
12 |         public DuplicateFinder(ILogger<IDuplicateFinder> logger)
13 |         {
14 |             this.logger = logger;
15 |         }
16 | 
17 |         public List<RenamerResult> Process(List<RenamerResult> renameResults, bool includeQuality)
18 |         {
19 |             List<string> alreadyExistingKeys = new List<string>();
20 |             foreach (var renameResult in renameResults)
21 |             {
22 |                 if (renameResult.Video == null)
23 |                 {
24 |                     continue;
25 |                 }
26 | 
27 |                 string key = renameResult.Video.Id.ToString();
28 |                 if (includeQuality)
29 |                 {
30 |                     key = renameResult.Video.Id + "-" + renameResult.VideoQualityId;
31 |                 }
32 | 
33 |                 if (alreadyExistingKeys.Contains(key))
34 |                 {
35 |                     renameResult.Source.IsDuplicate = true;
36 |                 }
37 |                 else
38 |                 {
39 |                     alreadyExistingKeys.Add(key);
40 |                 }
41 |             }
42 | 
43 |             return renameResults;
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/RenameWorkflow.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Interfaces;
 2 | using System;
 3 | 
 4 | namespace pdbMate.Core
 5 | {
 6 |     public class RenameWorkflow : IRenameWorkflow
 7 |     {
 8 |         private readonly IRenameService renameService;
 9 |         private readonly IFileOperatingService fileOperatingService;
10 | 
11 |         public RenameWorkflow(IRenameService renameService, IFileOperatingService fileOperatingService)
12 |         {
13 |             this.renameService = renameService;
14 |             this.fileOperatingService = fileOperatingService;
15 |         }
16 | 
17 |         public bool Rename(bool dryRun)
18 |         {
19 |             var files = renameService.GetFilesToProcess();
20 | 
21 |             fileOperatingService.RemoveUnwantedFiles(files, dryRun);
22 | 
23 |             var renamerResults = renameService.ProcessBatch(files);
24 |             var knownVideoResults = renameService.GetKnownVideoQualityResults();
25 | 
26 |             renamerResults = renameService.CheckForDuplicatesInResults(renamerResults);
27 |             renamerResults = renameService.CheckForDuplicates(renamerResults, knownVideoResults);
28 | 
29 |             fileOperatingService.WriteJsonFromObject(renamerResults, $"rename_{DateTime.Now:yyMMdd_hh_mm}.json");
30 |             fileOperatingService.MoveFilesBasedOnRenameResults(renamerResults, renameService.GetTargetPath(), dryRun);
31 |             fileOperatingService.DeleteDirectories(renameService.GetEmptyDirectories(), dryRun);
32 | 
33 |             return true;
34 |         }
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/pdbMate/Commands/BackfillingCommand.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Data;
 2 | using pdbMate.Core.Interfaces;
 3 | using pdbme.pdbInfrastructure.Logging.Commands;
 4 | using Spectre.Console.Cli;
 5 | using System;
 6 | using System.ComponentModel;
 7 | 
 8 | namespace pdbMate.Commands
 9 | {
10 |     public class BackfillingCommand : Command<BackfillingCommand.Settings>
11 |     {
12 |         private readonly IUsenetDownloadService usenetDownloadService;
13 | 
14 |         public BackfillingCommand(IUsenetDownloadService usenetDownloadService)
15 |         {
16 |             this.usenetDownloadService = usenetDownloadService ?? throw new ArgumentNullException(nameof(usenetDownloadService));
17 |         }
18 | 
19 |         public class Settings : LogCommandSettings
20 |         {
21 |             [CommandOption("-d|--dryrun")]
22 |             [DefaultValue(false)]
23 |             public bool DryRun { get; init; }
24 | 
25 |             [CommandOption("-c|--client")]
26 |             public DownloadClient? Client { get; init; }
27 | 
28 |             [CommandOption("--actor")]
29 |             public int? Actor { get; init; }
30 | 
31 |             [CommandOption("--site")]
32 |             public int? Site { get; init; }
33 | 
34 |             [CommandOption("--daysback")]
35 |             [DefaultValue(30)]
36 |             public int DaysBack { get; init; }
37 |         }
38 | 
39 |         public override int Execute(CommandContext context, Settings settings)
40 |         {
41 |             usenetDownloadService.Execute(settings.DryRun, settings.Client, settings.Actor, settings.Site, settings.DaysBack);
42 |             return 0;
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/VideoQualityProdiver.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | using Microsoft.Extensions.Logging;
 4 | using pdbMate.Core.Data;
 5 | using pdbMate.Core.Interfaces;
 6 | 
 7 | namespace pdbMate.Core
 8 | {
 9 |     public class VideoQualityProdiver : IVideoQualityProdiver
10 |     {
11 |         private readonly ILogger<IVideoQualityProdiver> logger;
12 |         private readonly IPdbApiService pdbApi;
13 |         private readonly Dictionary<int, VideoQuality> interalCache;
14 |         public VideoQualityProdiver(ILogger<IVideoQualityProdiver> logger, IPdbApiService pdbApi)
15 |         {
16 |             this.logger = logger;
17 |             this.pdbApi = pdbApi;
18 | 
19 |             interalCache = new Dictionary<int, VideoQuality>();
20 |         }
21 | 
22 |         public VideoQuality GetById(int id)
23 |         {
24 |             interalCache.TryGetValue(id, out VideoQuality result);
25 |             if (result == null)
26 |             {
27 |                 FillCache();
28 |                 interalCache.TryGetValue(id, out result);
29 |             }
30 | 
31 |             return result;
32 |         }
33 | 
34 |         public VideoQuality GetByName(string name)
35 |         {
36 |             if (!interalCache.Any())
37 |             {
38 |                 FillCache();
39 |             }
40 | 
41 |             if (!interalCache.Any()) return null;
42 |             foreach (var (_, value) in interalCache)
43 |             {
44 |                 if (value.Name.Equals(name))
45 |                 {
46 |                     return value;
47 |                 }
48 |             }
49 | 
50 |             return null;
51 |         }
52 | 
53 |         private void FillCache()
54 |         {
55 |             var videoQualities = pdbApi.GetAllVideoQuality();
56 |             foreach (var videoQuality in videoQualities)
57 |             {
58 |                 interalCache.TryAdd(videoQuality.Id, videoQuality);
59 |             }
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/pdbMate.Core.Tests/pdbMate.Core.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net6.0</TargetFramework>
 5 | 
 6 |     <IsPackable>false</IsPackable>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <PackageReference Include="FluentAssertions" Version="6.5.1" />
11 |     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
12 |     <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
13 |     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
14 |     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
15 |     <PackageReference Include="Moq" Version="4.16.1" />
16 |     <PackageReference Include="NUnit" Version="3.13.2" />
17 |     <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
18 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
19 |   </ItemGroup>
20 | 
21 |   <ItemGroup>
22 |     <ProjectReference Include="..\..\src\pdbMate.Core\pdbMate.Core.csproj" />
23 |   </ItemGroup>
24 | 
25 |   <ItemGroup>
26 |     <None Update="settings\sabnzbd.template.json">
27 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
28 |     </None>
29 |     <None Update="settings\sabnzbd.json">
30 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
31 |     </None>
32 |     <None Update="settings\nzbget.json">
33 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
34 |     </None>
35 |     <None Update="settings\nzbget.template.json">
36 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
37 |     </None>
38 |     <None Update="settings\pdbapi.json">
39 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
40 |     </None>
41 |     <None Update="settings\pdbapi.template.json">
42 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
43 |     </None>
44 |     <None Update="settings\pdbapi.json">
45 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
46 |     </None>
47 |   </ItemGroup>
48 | 
49 |   <ItemGroup>
50 |     <Folder Include="samples\" />
51 |   </ItemGroup>
52 | 
53 | </Project>
54 | 


--------------------------------------------------------------------------------
/src/pdbMate/SetupLogic/AppSettingsResult.cs:
--------------------------------------------------------------------------------
 1 | using pdbMate.Core.Data;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace pdbMate.ApplicationSetupLogic
 5 | {
 6 |     public class AppSettingsResult
 7 |     {
 8 |         public AppSettingsRename Rename { get; set; } = new AppSettingsRename();
 9 |         public AppSettingsPdbApi PdbApi { get; set; } = new AppSettingsPdbApi();
10 |         public AppSettingsNzbget Nzbget { get; set; } = new AppSettingsNzbget();
11 |         public AppSettingsSabnzbd Sabnzbd { get; set; } = new AppSettingsSabnzbd();
12 |         public AppSettingsUsenetDownload UsenetDownload { get; set; } = new AppSettingsUsenetDownload();
13 |     }
14 | 
15 |     public class AppSettingsRename
16 |     {
17 |         public string FilenameTemplate { get; set; } = "{Video.ReleasedateShort} - {Video.Title} - {VideoQuality.SimplifiedName} - {PdbId}{FileExtension}";
18 |         public string FolderTemplate { get; set; } = "{Video.Site.Sitename}";
19 |         public List<string> SourceFolders { get; set; } = new List<string>();
20 |         public string TargetFolder { get; set; }
21 |     }
22 | 
23 |     public class AppSettingsPdbApi
24 |     {
25 |         public string BaseUrl { get; set; } = "https://api.porndb.me/";
26 |         public string ApiKey { get; set; }
27 |     }
28 | 
29 |     public class AppSettingsNzbget
30 |     {
31 |         public string Hostname { get; set; } = "127.0.0.1";
32 |         public int Port { get; set; } = 6789;
33 |         public string Username { get; set; } = "";
34 |         public string Password { get; set; } = "";
35 |         public bool UseHttps { get; set; } = false;
36 |     }
37 | 
38 |     public class AppSettingsSabnzbd
39 |     {
40 |         public string Url { get; set; } = "http://127.0.0.1:8080/sabnzbd/api";
41 |         public string ApiKey { get; set; } = "";
42 |     }
43 | 
44 |     public class AppSettingsUsenetDownload
45 |     {
46 |         public List<string> AllowedQualities { get; set; } = new List<string>() { "1080p", "2160p"};
47 |         public bool KeepOnlyHighestQuality { get; set; } = true;
48 |         public bool DownloadFavoriteActors { get; set; } = true;
49 |         public bool DownloadFavoriteSites { get; set; } = true;
50 |         public DownloadClient ActiveClient { get; set; } = DownloadClient.Sabnzbd;
51 |     }
52 | }


--------------------------------------------------------------------------------
/pdbMate.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.32112.339
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "pdbMate", "src\pdbMate\pdbMate.csproj", "{1F218E0B-563D-4502-97FB-869D4427DE7E}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "pdbMate.Core", "src\pdbMate.Core\pdbMate.Core.csproj", "{A8539E9E-8391-4C1A-9418-B56E41DF93D4}"
 9 | EndProject
10 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "pdbMate.Core.Tests", "tests\pdbMate.Core.Tests\pdbMate.Core.Tests.csproj", "{AFFB29F6-04C9-4555-B9CC-2CFB69584C31}"
11 | EndProject
12 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{53E44897-2505-4E67-8770-1DEE9611D83C}"
13 | 	ProjectSection(SolutionItems) = preProject
14 | 		.gitignore = .gitignore
15 | 		README.md = README.md
16 | 	EndProjectSection
17 | EndProject
18 | Global
19 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
20 | 		Debug|Any CPU = Debug|Any CPU
21 | 		Release|Any CPU = Release|Any CPU
22 | 	EndGlobalSection
23 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
24 | 		{1F218E0B-563D-4502-97FB-869D4427DE7E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
25 | 		{1F218E0B-563D-4502-97FB-869D4427DE7E}.Debug|Any CPU.Build.0 = Debug|Any CPU
26 | 		{1F218E0B-563D-4502-97FB-869D4427DE7E}.Release|Any CPU.ActiveCfg = Release|Any CPU
27 | 		{1F218E0B-563D-4502-97FB-869D4427DE7E}.Release|Any CPU.Build.0 = Release|Any CPU
28 | 		{A8539E9E-8391-4C1A-9418-B56E41DF93D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
29 | 		{A8539E9E-8391-4C1A-9418-B56E41DF93D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
30 | 		{A8539E9E-8391-4C1A-9418-B56E41DF93D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
31 | 		{A8539E9E-8391-4C1A-9418-B56E41DF93D4}.Release|Any CPU.Build.0 = Release|Any CPU
32 | 		{AFFB29F6-04C9-4555-B9CC-2CFB69584C31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
33 | 		{AFFB29F6-04C9-4555-B9CC-2CFB69584C31}.Debug|Any CPU.Build.0 = Debug|Any CPU
34 | 		{AFFB29F6-04C9-4555-B9CC-2CFB69584C31}.Release|Any CPU.ActiveCfg = Release|Any CPU
35 | 		{AFFB29F6-04C9-4555-B9CC-2CFB69584C31}.Release|Any CPU.Build.0 = Release|Any CPU
36 | 	EndGlobalSection
37 | 	GlobalSection(SolutionProperties) = preSolution
38 | 		HideSolutionNode = FALSE
39 | 	EndGlobalSection
40 | 	GlobalSection(ExtensibilityGlobals) = postSolution
41 | 		SolutionGuid = {6608D00E-8C9B-4296-9CBE-E51AF2CE4D2A}
42 | 	EndGlobalSection
43 | EndGlobal
44 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/Data/Sabnzbd/SabnzbdQueue.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Text.Json.Serialization;
 3 | 
 4 | namespace pdbMate.Core.Data.Sabnzbd
 5 | {
 6 |     public class SabnzbdQueue
 7 |     {
 8 |         public bool Paused { get; set; }
 9 | 
10 |         [JsonPropertyName("pause_int")]
11 |         public string PausedInt { get; set; }
12 | 
13 |         [JsonPropertyName("paused_all")]
14 |         public bool PausedAll { get; set; }
15 | 
16 |         public string Diskspace1 { get; set; }
17 |         public string Diskspace2 { get; set; }
18 | 
19 |         [JsonPropertyName("diskspace1_norm")]
20 |         public string Diskspace1Normalized { get; set; }
21 |         [JsonPropertyName("diskspace2_norm")]
22 |         public string Diskspace2Normalized { get; set; }
23 |         public string Diskspacetotal1 { get; set; }
24 |         public string Diskspacetotal2 { get; set; }
25 |         public string Loadavg { get; set; }
26 |         public string Speedlimit { get; set; }
27 |         [JsonPropertyName("speedlimit_abs")]
28 |         public string SpeedlimitAbsolute { get; set; }
29 |         [JsonPropertyName("have_warnings")]
30 |         public string HaveWarnings { get; set; }
31 |         public string Finishaction { get; set; }
32 |         public string Quota { get; set; }
33 |         [JsonPropertyName("have_quota")]
34 |         public bool HaveQuota { get; set; }
35 |         [JsonPropertyName("left_quota")]
36 |         public string LeftQuota { get; set; }
37 |         [JsonPropertyName("cache_art")]
38 |         public string CacheArt { get; set; }
39 |         [JsonPropertyName("cache_size")]
40 |         public string CacheSize { get; set; }
41 |         [JsonPropertyName("cache_max")]
42 |         public string CacheMax { get; set; }
43 |         [JsonPropertyName("kbpersec")]
44 |         public string Kbpersec { get; set; }
45 |         public string Speed { get; set; }
46 |         public string Mbleft { get; set; }
47 |         public string Mb { get; set; }
48 |         public string Sizeleft { get; set; }
49 |         public string Size { get; set; }
50 | 
51 |         [JsonPropertyName("noofslots_total")]
52 |         public int NumberOfSlotsTotal { get; set; }
53 |         public string Status { get; set; }
54 |         public string Timeleft { get; set; }
55 |         public string Eta { get; set; }
56 |         [JsonPropertyName("refresh_rate")]
57 |         public string RefreshRate { get; set; }
58 |         public List<string> Categories { get; set; }
59 | 
60 |         [JsonPropertyName("rating_enable")]
61 |         public bool RatingEnable { get; set; }
62 |         public int Start { get; set; }
63 |         public int Limit { get; set; }
64 | 
65 |         public int Finish { get; set; }
66 | 
67 | 
68 |         public string Version { get; set; }
69 | 
70 |         public List<SabnzbdQueueSlot> Slots { get; set; }
71 |     }
72 | }


--------------------------------------------------------------------------------
/tests/pdbMate.Core.Tests/PdbApiServiceTests.cs:
--------------------------------------------------------------------------------
 1 | using System.IO;
 2 | using System.Linq;
 3 | using System.Text.Json;
 4 | using Microsoft.Extensions.Logging;
 5 | using NUnit.Framework;
 6 | using FluentAssertions;
 7 | using Microsoft.Extensions.Options;
 8 | using pdbMate.Core.Interfaces;
 9 | 
10 | namespace pdbMate.Core.Tests
11 | {
12 |     public class PdbApiServiceTests
13 |     {
14 |         private ILogger<IPdbApiService> pdbApiServiceLogger;
15 |         private IOptions<PdbApiServiceOptions> pdbApiOptions;
16 | 
17 |         private const string Sitename = "5KP" + "orn";
18 | 
19 |         [SetUp]
20 |         public void Setup()
21 |         {
22 |             using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
23 |             pdbApiServiceLogger = loggerFactory.CreateLogger<IPdbApiService>();
24 | 
25 |             var jsonString = File.ReadAllText(Path.Combine("settings", "pdbapi.json"));
26 |             PdbApiServiceOptions optionsPdbApi = JsonSerializer.Deserialize<PdbApiServiceOptions>(jsonString);
27 | 
28 |             pdbApiOptions = Options.Create(optionsPdbApi);
29 |         }
30 | 
31 |         [Test]
32 |         public void GetSites()
33 |         {
34 |             IPdbApiService pdbApiService = new PdbApiService(pdbApiServiceLogger, pdbApiOptions);
35 |             var resultList = pdbApiService.GetSites();
36 |             resultList.Should().NotBeNull();
37 |             resultList.Count.Should().BeGreaterThan(0);
38 |             resultList.First(x => x.Sitename.Equals(Sitename)).Id.Should().Be(606, "Site should be found in results searched by sitename.");
39 |             resultList.First(x => x.Id == 606).Sitename.Should().Be("5KPorn", "Site should be found in results searched by id.");
40 |         }
41 | 
42 |         [Test]
43 |         public void GetVideos()
44 |         {
45 |             IPdbApiService pdbApiService = new PdbApiService(pdbApiServiceLogger, pdbApiOptions);
46 |             var sites = pdbApiService.GetSites();
47 |             sites.Should().NotBeNull();
48 |             var site = sites.First(x => x.Sitename.Equals(Sitename));
49 | 
50 |             var videos = pdbApiService.GetVideosBySite(site);
51 |             videos.Should().NotBeNull();
52 |             videos.Count.Should().BeGreaterThan(0);
53 |             var videoMishaMaver = videos.FirstOrDefault(x => x.Title.Contains("Misha Maver"));
54 |             videoMishaMaver.Should().NotBeNull();
55 |             videoMishaMaver?.Site.Should().NotBeNull();
56 |             videoMishaMaver?.Site.Id.Should().Be(site.Id);
57 |             videoMishaMaver?.Id.Should().BeGreaterThan(0);
58 |             videoMishaMaver?.Title.Should().Be("Misha Maver");
59 |             videoMishaMaver?.Actors.Should().NotBeNull();
60 |             videoMishaMaver?.Actors.Should().HaveCountGreaterThan(0);
61 |             videoMishaMaver?.Actors?.First().Actorname.Should().Be("Misha Maver");
62 |         }
63 |     }
64 | }


--------------------------------------------------------------------------------
/tests/pdbMate.Core.Tests/NzbGetServiceTests.cs:
--------------------------------------------------------------------------------
 1 | using System.IO;
 2 | using System.Text.Json;
 3 | using Microsoft.Extensions.Logging;
 4 | using NUnit.Framework;
 5 | using FluentAssertions;
 6 | using Microsoft.Extensions.Options;
 7 | using pdbMate.Core.Interfaces;
 8 | 
 9 | namespace pdbMate.Core.Tests
10 | {
11 |     // To run these tests start a docker vm with nzbget
12 |     //
13 |     // e.g.
14 |     // docker run --name=nzbget -p 6789:6789 linuxserver/nzbget:latest
15 |     public class NzbGetServiceTests
16 |     {
17 |         private ILogger<INzbgetService> nzbgetServiceLogger;
18 |         private IOptions<NzbgetServiceOptions> nzbgetOptions;
19 | 
20 |         private const string Sitename = "5KP" + "orn";
21 | 
22 |         [SetUp]
23 |         public void Setup()
24 |         {
25 |             using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
26 |             nzbgetServiceLogger = loggerFactory.CreateLogger<INzbgetService>();
27 | 
28 |             var jsonString = File.ReadAllText(Path.Combine("settings", "nzbget.json"));
29 |             nzbgetOptions = Options.Create(JsonSerializer.Deserialize<NzbgetServiceOptions>(jsonString));
30 |         }
31 | 
32 |         [Test]
33 |         public void GetVersion()
34 |         {
35 |             INzbgetService service = new NzbgetService(nzbgetServiceLogger, nzbgetOptions);
36 | 
37 |             service.CheckConnection();
38 |             service.GetVersion().Should().BeGreaterThanOrEqualTo(1);
39 | 
40 |             service.GetQueue().Should().NotBeNull();
41 |             service.GetHistory().Should().NotBeNull();
42 |             //service.AddDownload();
43 |             /*
44 |             var resultList = pdbApiService.GetSites();
45 |             resultList.Should().NotBeNull();
46 |             resultList.Count.Should().BeGreaterThan(0);
47 |             resultList.First(x => x.Sitename.Equals(Sitename)).Id.Should().Be(606, "Site should be found in results searched by sitename.");
48 |             resultList.First(x => x.Id == 606).Sitename.Should().Be("5KPorn", "Site should be found in results searched by id.");
49 |             */
50 |         }
51 |         /*
52 |         [Test]
53 |         public void GetVideos()
54 |         {
55 |             IPdbApiService pdbApiService = new PdbApiService(pdbApiServiceLogger, pdbApiOptions);
56 |             var sites = pdbApiService.GetSites();
57 |             sites.Should().NotBeNull();
58 |             var site = sites.First(x => x.Sitename.Equals(Sitename));
59 | 
60 |             var videos = pdbApiService.GetVideosBySite(site);
61 |             videos.Should().NotBeNull();
62 |             videos.Count.Should().BeGreaterThan(0);
63 |             var videoMishaMaver = videos.FirstOrDefault(x => x.Title.Contains("Misha Maver"));
64 |             videoMishaMaver.Should().NotBeNull();
65 |             videoMishaMaver?.Site.Should().NotBeNull();
66 |             videoMishaMaver?.Site.Id.Should().Be(site.Id);
67 |             videoMishaMaver?.Id.Should().BeGreaterThan(0);
68 |             videoMishaMaver?.Title.Should().Be("Misha Maver");
69 |             videoMishaMaver?.Actors.Should().NotBeNull();
70 |             videoMishaMaver?.Actors.Should().HaveCountGreaterThan(0);
71 |             videoMishaMaver?.Actors?.First().Actorname.Should().Be("Misha Maver");
72 |         }
73 |         */
74 |     }
75 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/StringExtractor.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Globalization;
  3 | using System.Net.NetworkInformation;
  4 | using System.Text.RegularExpressions;
  5 | 
  6 | namespace pdbMate.Core
  7 | {
  8 |     public static class StringExtractor 
  9 |     {
 10 |         public static DateTime? ExtractDate(string title)
 11 |         {
 12 |             var match = Regex.Match(title, @"^([a-z0-9-_]+)\.([0-9]{2})\.([0-9]{2})\.([0-9]{2})",
 13 |                 RegexOptions.IgnoreCase);
 14 | 
 15 |             if (match.Success)
 16 |             {
 17 |                 var dateString = $"{match.Groups[2].Value}-{match.Groups[3].Value}-{match.Groups[4].Value}";
 18 | 
 19 |                 if (DateTime.TryParseExact(dateString, "yy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dt))
 20 |                 {
 21 |                     return dt;
 22 |                 }
 23 | 
 24 |                 if (DateTime.TryParseExact(dateString, "dd-MM-yy", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dt2))
 25 |                 {
 26 |                     return dt2;
 27 |                 }
 28 |             }
 29 |             else
 30 |             {
 31 |                 var matchFourDigit = Regex.Match(title, @"^([a-z0-9-_]+)\.([0-9]{4})\.([0-9]{2})\.([0-9]{2})",
 32 |                     RegexOptions.IgnoreCase);
 33 | 
 34 |                 if (matchFourDigit.Success)
 35 |                 {
 36 |                     var dateString = $"{matchFourDigit.Groups[2].Value}-{matchFourDigit.Groups[3].Value}-{matchFourDigit.Groups[4].Value}";
 37 | 
 38 |                     if (DateTime.TryParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dt2))
 39 |                     {
 40 |                         return dt2;
 41 |                     }
 42 |                 }
 43 |             }
 44 | 
 45 |             return null;
 46 |         }
 47 | 
 48 |         public static string ReplaceSpacesByDots(string s)
 49 |         {
 50 |             s = s.Replace(" ", ".");
 51 |             return s;
 52 |         }
 53 | 
 54 |         public static string ExtractTeam(string title)
 55 |         {
 56 |             title = title.Replace("-Pornfuscated", "");
 57 | 
 58 |             Match matchTeamname = Regex.Match(title, @"(2160p|1080p|720p|480)\.(MP4|WMV|MKV)-([a-z0-9]+)$", RegexOptions.IgnoreCase);
 59 |             if (matchTeamname.Success)
 60 |             {
 61 |                 return matchTeamname.Groups[3].Value;
 62 |             }
 63 | 
 64 |             return "";
 65 |         }
 66 | 
 67 |         public static string ExtractPrefixBeforeQualityAndReleasegroup(string title)
 68 |         {
 69 |             Match matchTeamname = Regex.Match(title, @"(.*)\.XXX\.(2160p|1080p|720p|480)\.(MP4|WMV|MKV)-([a-z0-9]+)", RegexOptions.IgnoreCase);
 70 |             if (matchTeamname.Success)
 71 |             {
 72 |                 return matchTeamname.Groups[1].Value;
 73 |             }
 74 | 
 75 |             return "";
 76 |         }
 77 | 
 78 | 
 79 |         public static string ExtractEpisode(string title)
 80 |         {
 81 |             string episode = "";
 82 |             title = ReplaceSpacesByDots(title);
 83 |             Match match = Regex.Match(title, @"\.E([0-9]{2,4})\.", RegexOptions.IgnoreCase);
 84 |             if (match.Success)
 85 |             {
 86 |                 episode = match.Groups[1].Value;
 87 |             }
 88 | 
 89 |             return episode;
 90 |         }
 91 | 
 92 |         public static string ExtractQuality(string s)
 93 |         {
 94 |             s = s.Replace(" ", ".");
 95 |             s = s.Replace("_", ".");
 96 |             s = s.Replace(",", ".");
 97 |             s = s.Replace("-", ".");
 98 | 
 99 |             Match matchTeamname = Regex.Match(s, @"\.(2160p|1080p|720p|480p)\.", RegexOptions.IgnoreCase);
100 |             if (matchTeamname.Success)
101 |             {
102 |                 return matchTeamname.Groups[1].Value;
103 |             }
104 | 
105 |             return "";
106 |         }
107 | 
108 |         public static string GetSeparator(string name)
109 |         {
110 |             var countPoint = name.Split('.').Length - 1;
111 |             var countWhitespace = name.Split(' ').Length - 1;
112 |             var countMinus = name.Split('-').Length - 1;
113 | 
114 |             if (countMinus > countWhitespace && countMinus > countPoint)
115 |             {
116 |                 return "-";
117 |             }
118 | 
119 |             if (countPoint > countWhitespace && countPoint > countMinus)
120 |             {
121 |                 return ".";
122 |             }
123 | 
124 |             return " ";
125 |         }
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/SabnzbdService.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Net;
  3 | using System.Text.Json;
  4 | using Microsoft.Extensions.Logging;
  5 | using Microsoft.Extensions.Options;
  6 | using pdbMate.Core.Data.Sabnzbd;
  7 | using pdbMate.Core.Interfaces;
  8 | using RestSharp;
  9 | using RestSharp.Serializers.Json;
 10 | 
 11 | namespace pdbMate.Core
 12 | {
 13 |     public class SabnzbdService : ISabnzbdService
 14 |     {
 15 |         private readonly ILogger<ISabnzbdService> logger;
 16 |         private SabnzbdServiceOptions options;
 17 |         private RestClient client;
 18 | 
 19 |         public SabnzbdService(ILogger<ISabnzbdService> logger, IOptions<SabnzbdServiceOptions> options)
 20 |         {
 21 |             this.logger = logger;
 22 | 
 23 |             setOptions(options);
 24 |         }
 25 | 
 26 |         public void setOptions(IOptions<SabnzbdServiceOptions> optionsToSet)
 27 |         {
 28 |             options = optionsToSet.Value;
 29 | 
 30 |             if (string.IsNullOrEmpty(options.Url))
 31 |             {
 32 |                 return;
 33 |             }
 34 | 
 35 |             client = new RestClient(options.Url);
 36 |             client.UseSystemTextJson(new JsonSerializerOptions()
 37 |             {
 38 |                 PropertyNameCaseInsensitive = true,
 39 |                 WriteIndented = true
 40 |             });
 41 |         }
 42 | 
 43 |         public bool CheckConnection()
 44 |         {
 45 |             var version = GetVersion();
 46 |             logger.LogInformation($"Connection to {options.Url} was {(string.IsNullOrEmpty(version) ? "not successful" : "successful")} - Version: {version}");
 47 |             return !string.IsNullOrEmpty(version);
 48 |         }
 49 | 
 50 |         public string GetVersion()
 51 |         {
 52 |             var request = new RestRequest("/", Method.Get);
 53 |             request.AddQueryParameter("mode", "version");
 54 |             request.AddQueryParameter("output", "json");
 55 | 
 56 |             var response = client.ExecuteGetAsync<SabnzbdResult>(request).GetAwaiter().GetResult();
 57 |             if (response.IsSuccessful)
 58 |             {
 59 |                 var versionData = response.Data;
 60 | 
 61 |                 return versionData == null ? "" : versionData.Version;
 62 |             }
 63 | 
 64 |             var errormessage = "sabnzbd returned " + response.StatusCode.ToString() + " HTTP-Status-Code. " + response.ErrorMessage;
 65 |             if (response.StatusCode == HttpStatusCode.Unauthorized)
 66 |             {
 67 |                 errormessage += " Hint: sabnzbd probably needs username and password for authentication.";
 68 |             }
 69 | 
 70 |             throw new ApplicationException(errormessage);
 71 |         }
 72 | 
 73 |         public bool AddDownload(string url)
 74 |         {
 75 |             var request = new RestRequest("/", Method.Get);
 76 |             request.AddQueryParameter("mode", "addurl");
 77 |             request.AddQueryParameter("output", "json");
 78 |             request.AddQueryParameter("apikey", options.ApiKey);
 79 |             request.AddQueryParameter("name", url);
 80 | 
 81 |             var response = client.GetAsync<SabnzbdAddUrlResult>(request).GetAwaiter().GetResult();
 82 |             return response.Status;
 83 |         }
 84 | 
 85 |         public SabnzbdQueue GetQueue(int start, int limit)
 86 |         {
 87 |             var request = new RestRequest("/", Method.Get);
 88 |             request.AddQueryParameter("mode", "queue");
 89 |             request.AddQueryParameter("output", "json");
 90 |             request.AddQueryParameter("apikey", options.ApiKey);
 91 |             request.AddQueryParameter("start", start.ToString());
 92 |             request.AddQueryParameter("limit", limit.ToString());
 93 | 
 94 |             var response = client.GetAsync<SabnzbdResult>(request).GetAwaiter().GetResult();
 95 |             var data = response;
 96 | 
 97 |             return data?.Queue;
 98 |         }
 99 | 
100 |         public SabnzbdHistory GetHistory(int start, int limit)
101 |         {
102 |             var request = new RestRequest("/", Method.Get);
103 |             request.AddQueryParameter("mode", "history");
104 |             request.AddQueryParameter("output", "json");
105 |             request.AddQueryParameter("apikey", options.ApiKey);
106 |             request.AddQueryParameter("start", start.ToString());
107 |             request.AddQueryParameter("limit", limit.ToString());
108 | 
109 |             var response = client.GetAsync<SabnzbdResult>(request).GetAwaiter().GetResult();
110 |             var data = response;
111 | 
112 |             return data?.History;
113 |         }
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/ChangeNamingTemplateService.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Linq;
  5 | using System.Text.RegularExpressions;
  6 | using Microsoft.Extensions.Logging;
  7 | using Microsoft.Extensions.Options;
  8 | using pdbMate.Core.Data;
  9 | using pdbMate.Core.Interfaces;
 10 | 
 11 | namespace pdbMate.Core
 12 | {
 13 |     public class ChangeNamingTemplateService : IChangeNamingTemplateService
 14 |     {
 15 |         private readonly ILogger<ChangeNamingTemplateService> logger;
 16 |         private readonly IPdbApiService pdbApi;
 17 |         private readonly IRenameService renameService;
 18 |         private readonly IVideoQualityProdiver videoQualityProdiver;
 19 |         private readonly RenameServiceOptions renameServiceOptions;
 20 | 
 21 |         public ChangeNamingTemplateService(ILogger<ChangeNamingTemplateService> logger, IPdbApiService pdbApi, IRenameService renameService, IVideoQualityProdiver videoQualityProdiver, IOptions<RenameServiceOptions> renameServiceOptions)
 22 |         {
 23 |             this.logger = logger;
 24 |             this.pdbApi = pdbApi;
 25 |             this.renameService = renameService;
 26 |             this.videoQualityProdiver = videoQualityProdiver;
 27 |             this.renameServiceOptions = renameServiceOptions.Value;
 28 |         }
 29 | 
 30 |         public void RenameToNewTemplate(bool dryRun)
 31 |         {
 32 |             var sites = pdbApi.GetSites();
 33 | 
 34 |             string targetFolder = renameServiceOptions.TargetFolder;
 35 |             var folders = Directory.EnumerateDirectories(targetFolder, "*", SearchOption.TopDirectoryOnly).ToList();
 36 |             foreach (string folder in folders)
 37 |             {
 38 |                 var di = new DirectoryInfo(folder);
 39 |                 var site = sites.SingleOrDefault(x => x.Sitename == di.Name);
 40 |                 if(site == null)
 41 |                 {
 42 |                     logger.LogInformation($"Site for folder {di.Name} not found.");
 43 |                     continue;
 44 |                 }
 45 | 
 46 |                 var videos = pdbApi.GetVideosBySite(site);
 47 |                 ProcessBySite(site, videos, folder, dryRun);
 48 |             }
 49 |         }
 50 | 
 51 |         private void ProcessBySite(Site site, List<Video> videos, string searchFolder, bool dryRun)
 52 |         {
 53 |             if (!Directory.Exists(searchFolder))
 54 |             {
 55 |                 logger.LogError($"Directory {searchFolder} does not exist.");
 56 |                 return;
 57 |             }
 58 | 
 59 |             var files = Directory.EnumerateFiles(searchFolder, "*.*", SearchOption.TopDirectoryOnly).ToList();
 60 |             foreach (var file in files)
 61 |             {
 62 |                 Match match = Regex.Match(file, @"P([0-9]{7})", RegexOptions.IgnoreCase);
 63 | 
 64 |                 if (!match.Success)
 65 |                 {
 66 |                     continue;
 67 |                 }
 68 | 
 69 |                 int videoQualityId = 0;
 70 |                 bool parsed = int.TryParse(match.Groups[1].Value, out var pdbId);
 71 |                 if (!parsed)
 72 |                 {
 73 |                     continue;
 74 |                 }
 75 | 
 76 |                 FileInfo fi = new FileInfo(file);
 77 |                 videoQualityId = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(fi.Name))?.Id ?? 0;
 78 | 
 79 |                 var video = videos.SingleOrDefault(x => x.Id == pdbId);
 80 |                 if(video == null)
 81 |                 {
 82 |                     logger.LogInformation($"Video info for id {pdbId} not found (in videos for site {site.Sitename}).");
 83 |                     continue;
 84 |                 }
 85 | 
 86 |                 string newFilename = renameService.ReplaceTemplatePlaceholders(renameServiceOptions.FilenameTemplate, new RenamerResult()
 87 |                 {
 88 |                     Video = video,
 89 |                     VideoQualityId = videoQualityId,
 90 |                     FileExtension = fi.Extension,
 91 |                     Filename = fi.Name,
 92 |                     Foldername = searchFolder,
 93 |                     Source = new SourceFile()
 94 |                     {
 95 |                         Filename = fi.Name,
 96 |                         FileExtension = fi.Extension
 97 |                     }
 98 |                 });
 99 | 
100 |                 logger.LogInformation($"Rename {fi.Name} to {newFilename}");
101 |                 if (!dryRun)
102 |                 {
103 |                     File.Move(Path.Combine(searchFolder, fi.Name), Path.Combine(searchFolder, newFilename));
104 |                 }
105 |             }
106 |         }
107 |     }
108 | }


--------------------------------------------------------------------------------
/src/pdbMate.Core/FileOperatingService.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Text.Json;
  5 | using Microsoft.Extensions.Logging;
  6 | using pdbMate.Core.Data;
  7 | using pdbMate.Core.Interfaces;
  8 | 
  9 | namespace pdbMate.Core
 10 | {
 11 |     public class FileOperatingService : IFileOperatingService
 12 |     {
 13 |         private readonly ILogger<IFileOperatingService> logger;
 14 | 
 15 | 
 16 |         public FileOperatingService(ILogger<IFileOperatingService> logger)
 17 |         {
 18 |             this.logger = logger;
 19 |         }
 20 | 
 21 |         public void RemoveUnwantedFiles(List<SourceFile> files, bool dryRun)
 22 |         {
 23 |             logger.LogInformation("==============");
 24 |             logger.LogInformation(" Remove files ");
 25 |             logger.LogInformation("==============");
 26 |             foreach (var file in files)
 27 |             {
 28 |                 if (file.IsNoVideoExtension || file.IsToSmall || file.IsDuplicate)
 29 |                 {
 30 |                     if (!dryRun && File.Exists(file.Path))
 31 |                     {
 32 |                         File.Delete(file.Path);
 33 |                     }
 34 |                     logger.LogInformation("Deleting " + file.Path);
 35 |                 }
 36 |             }
 37 |         }
 38 | 
 39 |         public void MoveFilesBasedOnRenameResults(List<RenamerResult> renamerResults, string targetFolder, bool dryRun)
 40 |         {
 41 |             logger.LogInformation("==============");
 42 |             logger.LogInformation(" Move files to");
 43 |             logger.LogInformation("==============");
 44 | 
 45 |             foreach (var renamerResult in renamerResults)
 46 |             {
 47 |                 if (renamerResult.Source.IsDuplicate)
 48 |                 {
 49 |                     if (!dryRun && File.Exists(renamerResult.Source.Path))
 50 |                     {
 51 |                         File.Delete(renamerResult.Source.Path);
 52 |                     }
 53 |                     logger.LogInformation("Deleting duplicate file " + renamerResult.Source.Path);
 54 |                     continue;
 55 |                 }
 56 | 
 57 |                 if (renamerResult.Source.IsNoVideoExtension || renamerResult.Source.IsToSmall)
 58 |                 {
 59 |                     if (!dryRun && File.Exists(renamerResult.Source.Path))
 60 |                     {
 61 |                         File.Delete(renamerResult.Source.Path);
 62 |                     }
 63 |                     logger.LogInformation("Deleting non-video or small file " + renamerResult.Source.Path);
 64 |                     continue;
 65 |                 }
 66 | 
 67 |                 if (renamerResult.Video == null)
 68 |                 {
 69 |                     logger.LogWarning($"No video found for source filename: {renamerResult.Source.Filename}");
 70 |                     continue;
 71 |                 }
 72 | 
 73 |                 string sourceFile = renamerResult.Source.Path;
 74 | 
 75 |                 string targetFolderWithSubfolder = string.IsNullOrEmpty(renamerResult.Foldername)
 76 |                     ? ""
 77 |                     : Path.Combine(targetFolder, renamerResult.Foldername);
 78 |                 string targetFile = (string.IsNullOrEmpty(renamerResult.Foldername)) ?
 79 |                     Path.Combine(targetFolder, renamerResult.Filename) :
 80 |                     Path.Combine(targetFolder, renamerResult.Foldername, renamerResult.Filename);
 81 | 
 82 |                 if (!dryRun)
 83 |                 {
 84 |                     if (!File.Exists(sourceFile))
 85 |                     {
 86 |                         logger.LogError($"Source file {sourceFile} cound not be found.");
 87 |                         continue;
 88 |                     }
 89 | 
 90 |                     if (File.Exists(targetFile))
 91 |                     {
 92 |                         logger.LogError($"Target file {targetFile} already exists.");
 93 |                         continue;
 94 |                     }
 95 | 
 96 |                     try
 97 |                     {
 98 |                         if (!string.IsNullOrEmpty(targetFolderWithSubfolder) && !Directory.Exists(targetFolderWithSubfolder))
 99 |                         {
100 |                             Directory.CreateDirectory(targetFolderWithSubfolder);
101 |                         }
102 | 
103 |                         File.Move(sourceFile, targetFile);
104 |                     }
105 |                     catch (Exception ex)
106 |                     {
107 |                         logger.LogError($"Moving {sourceFile} to {targetFile} failed with Exception: {ex.Message}.");
108 |                         break;
109 |                     }
110 | 
111 |                 }
112 |                 logger.LogInformation(targetFile);
113 |             }
114 |         }
115 | 
116 |         public void DeleteDirectories(List<string> directories, bool dryRun)
117 |         {
118 |             if (dryRun) return;
119 |             foreach (var directoryPath in directories)
120 |             {
121 |                 Directory.Delete(directoryPath);
122 |             }
123 |         }
124 | 
125 |         public void WriteJsonFromObject<T>(T objectClass, string filename)
126 |         {
127 |             var jsonString = JsonSerializer.Serialize<T>(objectClass);
128 |             File.WriteAllText(filename, jsonString);
129 |         }
130 |     }
131 | }
132 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/VideoMatching.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using Microsoft.Extensions.Logging;
  5 | using pdbMate.Core.Data;
  6 | using pdbMate.Core.Interfaces;
  7 | 
  8 | namespace pdbMate.Core
  9 | {
 10 |     public class VideoMatching : IVideoMatching
 11 |     {
 12 |         private readonly ILogger<VideoMatching> logger;
 13 |         private readonly IPdbApiService pdbApi;
 14 |         private readonly Dictionary<string, Video> interalCache;
 15 |         public VideoMatching(ILogger<VideoMatching> logger, IPdbApiService pdbApi)
 16 |         {
 17 |             this.logger = logger;
 18 |             this.pdbApi = pdbApi;
 19 | 
 20 |             interalCache = new Dictionary<string, Video>();
 21 |         }
 22 | 
 23 |         public Video GetVideoByName(string name)
 24 |         {
 25 |             if (interalCache.ContainsKey(name))
 26 |             {
 27 |                 return interalCache[name];
 28 |             }
 29 | 
 30 |             var site = FindSiteByFirstWord(StringExtractor.GetSeparator(name), name);
 31 |             if (site == null)
 32 |             {
 33 |                 return null;
 34 |             }
 35 | 
 36 |             var videos = pdbApi.GetVideosBySite(site);
 37 | 
 38 |             var byDate = GetVideoByDate(videos, name);
 39 |             if (byDate != null)
 40 |             {
 41 |                 interalCache.Add(name, byDate);
 42 |                 return byDate;
 43 |             }
 44 | 
 45 |             var byEpisode = GetVideoByEpisode(videos, name);
 46 |             if (byEpisode != null)
 47 |             {
 48 |                 interalCache.Add(name, byEpisode);
 49 |                 return byEpisode;
 50 |             }
 51 | 
 52 |             var byNormalization = GetVideoByNormalization(videos, name);
 53 |             interalCache.Add(name, byNormalization);
 54 |             return byNormalization;
 55 |         }
 56 | 
 57 |         public Video GetVideoByDate(List<Video> videos, string name)
 58 |         {
 59 |             var dateExtracted = StringExtractor.ExtractDate(name);
 60 |             if (dateExtracted != null)
 61 |             {
 62 |                 int foundVideosByDateCount = videos.Count(x => x.Releasedate == dateExtracted);
 63 |                 if (foundVideosByDateCount == 1)
 64 |                 {
 65 |                     return videos.Single(x => x.Releasedate == dateExtracted);
 66 |                 }
 67 | 
 68 |                 var videosFound = videos.Where(x => x.Releasedate == dateExtracted).ToList();
 69 |                 var videoFoundResult = GetVideoByNormalization(videosFound, name);
 70 |                 if (videoFoundResult != null)
 71 |                 {
 72 |                     return videoFoundResult;
 73 |                 }
 74 |             }
 75 | 
 76 |             return null;
 77 |         }
 78 | 
 79 |         public Video GetVideoByEpisode(List<Video> videos, string name)
 80 |         {
 81 |             var episodeExtracted = StringExtractor.ExtractEpisode(name);
 82 |             if (episodeExtracted != null)
 83 |             {
 84 |                 int foundVideosByEpisodeCount = videos.Count(x => x.FullTitle.Contains(" " + episodeExtracted));
 85 |                 if (foundVideosByEpisodeCount == 1)
 86 |                 {
 87 |                     return videos.Single(x => x.FullTitle.Contains(" " + episodeExtracted));
 88 |                 }
 89 | 
 90 |                 var videosFound = videos.Where(x => x.FullTitle.Contains(" " + episodeExtracted)).ToList();
 91 |                 var videoFoundResult = GetVideoByNormalization(videosFound, name);
 92 |                 if (videoFoundResult != null)
 93 |                 {
 94 |                     return videoFoundResult;
 95 |                 }
 96 |             }
 97 | 
 98 |             return null;
 99 |         }
100 | 
101 |         private Video GetVideoByNormalization(List<Video> videos, string name)
102 |         {
103 |             var prefixString = StringExtractor.ExtractPrefixBeforeQualityAndReleasegroup(name);
104 |             if (!string.IsNullOrEmpty(prefixString))
105 |             {
106 |                 var n = StringNormalizer.Normalize(prefixString);
107 |                 var foundByNormalizationVideos = new List<Video>();
108 |                 foreach (var videoFound in videos)
109 |                 {
110 |                     var nFound = StringNormalizer.Normalize(videoFound.FullTitle);
111 | 
112 |                     if (n.Equals(nFound))
113 |                     {
114 |                         foundByNormalizationVideos.Add(videoFound);
115 |                     }
116 |                 }
117 | 
118 |                 if (foundByNormalizationVideos.Count == 1)
119 |                 {
120 |                     return foundByNormalizationVideos[0];
121 |                 }
122 |             }
123 | 
124 |             return null;
125 |         }
126 | 
127 |         private Site FindSiteByFirstWord(string separator, string name)
128 |         {
129 |             var sites = pdbApi.GetSites();
130 |             var firstWordBySeparator = !name.Contains(separator) ? "" : name.Substring(0, name.IndexOf(separator, StringComparison.Ordinal));
131 |             if (!string.IsNullOrWhiteSpace(firstWordBySeparator) && firstWordBySeparator.Length >= 3)
132 |             {
133 |                 var siteFound = sites.FirstOrDefault(x => string.Equals(x.Sitename, firstWordBySeparator, StringComparison.CurrentCultureIgnoreCase));
134 |                 if (siteFound != null)
135 |                 {
136 |                     return siteFound;
137 |                 }
138 |             }
139 | 
140 |             return null;
141 |         }
142 |     }
143 | }
144 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/NzbgetService.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Globalization;
  4 | using System.Net;
  5 | using System.Text.Json;
  6 | using Microsoft.Extensions.Logging;
  7 | using Microsoft.Extensions.Options;
  8 | using pdbMate.Core.Data.Nzbget;
  9 | using pdbMate.Core.Interfaces;
 10 | using RestSharp;
 11 | using RestSharp.Authenticators;
 12 | using RestSharp.Serializers.Json;
 13 | 
 14 | namespace pdbMate.Core
 15 | {
 16 |     public class NzbgetService : INzbgetService
 17 |     {
 18 |         private readonly ILogger<INzbgetService> logger;
 19 |         private NzbgetServiceOptions options;
 20 |         private RestClient client;
 21 | 
 22 |         public NzbgetService(ILogger<INzbgetService> logger, IOptions<NzbgetServiceOptions> options)
 23 |         {
 24 |             this.logger = logger;
 25 | 
 26 |             setOptions(options);
 27 |         }
 28 | 
 29 |         public void setOptions(IOptions<NzbgetServiceOptions> optionsToSet)
 30 |         {
 31 |             options = optionsToSet.Value;
 32 | 
 33 |             var authString = "";
 34 |             if (!string.IsNullOrEmpty(this.options.Username) && !string.IsNullOrEmpty(this.options.Password))
 35 |             {
 36 |                 authString = this.options.Username + ":" + this.options.Password + "@";
 37 |             }
 38 | 
 39 |             if (string.IsNullOrEmpty(this.options.Hostname))
 40 |             {
 41 |                 return;
 42 |             }
 43 | 
 44 |             var baseUrl = (this.options.UseHttps ? "https://" : "http://") + authString + this.options.Hostname + ":" +
 45 |                           this.options.Port;
 46 | 
 47 |             client = new RestClient(baseUrl);
 48 |             client.UseSystemTextJson(new JsonSerializerOptions()
 49 |             {
 50 |                 PropertyNameCaseInsensitive = true,
 51 |                 WriteIndented = true
 52 |             });
 53 | 
 54 |             if (!string.IsNullOrEmpty(this.options.Username) || !string.IsNullOrEmpty(this.options.Password))
 55 |             {
 56 |                 client.Authenticator = new HttpBasicAuthenticator(this.options.Username, this.options.Password);
 57 |             }
 58 |         }
 59 | 
 60 |         public void CheckConnection()
 61 |         {
 62 |             ValidateSettings();
 63 |             GetVersion();
 64 |         }
 65 | 
 66 |         public int GetVersion()
 67 |         {
 68 |             var request = new RestRequest("jsonrpc/version", Method.Get);
 69 | 
 70 |             var response = client.ExecuteGetAsync<NzbgetResult<string>>(request).GetAwaiter().GetResult();
 71 |             if (response.IsSuccessful)
 72 |             {
 73 |                 string versionData = response.Data.Version;
 74 | 
 75 |                 if (versionData == null)
 76 |                 {
 77 |                     throw new ApplicationException("No version returned.");
 78 |                 }
 79 | 
 80 |                 return (double.TryParse(versionData, NumberStyles.Any, CultureInfo.InvariantCulture, out var versionNumber) ? (int)Math.Round(versionNumber) : 0);
 81 |             }
 82 | 
 83 |             var errormessage = "nzbget returned " + response.StatusCode.ToString() + " HTTP-Status-Code. " + response.ErrorMessage;
 84 |             if (response.StatusCode == HttpStatusCode.Unauthorized)
 85 |             {
 86 |                 errormessage += " Hint: nzbget probably needs username and password for authentication.";
 87 |             }
 88 | 
 89 |             throw new ApplicationException(errormessage);
 90 |         }
 91 | 
 92 |         public List<NzbgetQueue> GetQueue()
 93 |         {
 94 |             var request = new RestRequest("jsonrpc/listgroups", Method.Get);
 95 | 
 96 |             var response = client.GetAsync<NzbgetResult<List<NzbgetQueue>>>(request).GetAwaiter().GetResult();
 97 |             return response.Result;
 98 |         }
 99 | 
100 |         public List<NzbgetHistory> GetHistory()
101 |         {
102 |             var request = new RestRequest("jsonrpc/history", Method.Get);
103 | 
104 |             var response = client.GetAsync<NzbgetResult<List<NzbgetHistory>>>(request).GetAwaiter().GetResult();
105 |             var data = response;
106 | 
107 |             return data?.Result;
108 |         }
109 | 
110 |         public bool AddDownload(string url)
111 |         {
112 |             var paramsArray = new object[] {
113 |                 "",
114 |                 url,
115 |                 "",
116 |                 0,
117 |                 false,
118 |                 false,
119 |                 "",
120 |                 0,
121 |                 "FORCE"
122 |             };
123 |             var request = new RestRequest("jsonrpc/append", Method.Post);
124 |             request.AddJsonBody(new NzbgetRequestAddDownload()
125 |             {
126 |                 Method = "append",
127 |                 Id = 0,
128 |                 Params = paramsArray
129 |             });
130 | 
131 |             var response = client.PostAsync<NzbgetResultAddDownload>(request).GetAwaiter().GetResult();
132 |             if (response.Result > 0)
133 |             {
134 |                 return true;
135 |             }
136 | 
137 |             return false;
138 |         }
139 | 
140 |         private void ValidateSettings()
141 |         {
142 |             if (string.IsNullOrWhiteSpace(options.Hostname))
143 |             {
144 |                 throw new ArgumentException("Hostname for nzbget is empty.");
145 |             }
146 | 
147 |             if (options.Hostname.StartsWith("http"))
148 |             {
149 |                 throw new ArgumentException($"Given hostname {options.Hostname} should not contain http oder https. Valid example: myapp.mydomain.com or 176.56.59.1");
150 |             }
151 | 
152 |             if (options.Port == 0)
153 |             {
154 |                 throw new ArgumentException($"Please provide a valid port for nzbget.");
155 |             }
156 |         }
157 |     }
158 | }
159 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # pdbMate
  2 | 
  3 | pdbMate supports you organizing your media library by automatic renaming and organizing by media sites.
  4 | 
  5 | pdbMate is a tool with a Command Line Interface (CLI) that performs different tasks to help you handle files downloaded from usenet. 
  6 | 
  7 | The tool is specialized for adult content and uses an API to gather information about sites, actors, video titles and release names.
  8 | 
  9 | We try to avoid any adult related terms in any code and documentation about pdbMate.
 10 | 
 11 | Why did we come up with pdbMate: There are no media manager that can sort adult content. pdbMate tries to fill this gap.
 12 | 
 13 | ## Breaking changes
 14 | pdbMate has been updated to dotnet6
 15 | 
 16 | # Install
 17 | 
 18 | Download the latest release from releases for your operating system:
 19 | 
 20 | https://github.com/pdbme/pdbMate/releases
 21 | 
 22 | Install .NET framework 6.0 Runtime
 23 | 
 24 | https://dotnet.microsoft.com/en-us/download/dotnet/6.0/runtime
 25 | 
 26 | If build from source: Rename the appsettings.Template.json to appsettings.json
 27 | 
 28 | Configure appsettings.json to your needs:
 29 | 
 30 |     define sourcefolders (folders that are recursively searched for videos to rename)
 31 |     define on targetfolder (your files will be moved to this folder)
 32 |     get an api key and fill out PdbApi -> ApiKey
 33 | 
 34 | # CommandLine Usage
 35 | 
 36 | You can call the CLI with different functions, for example:
 37 | 
 38 | rename files but do not actually change anything (just see what would happen):
 39 | 
 40 | `pdbMate rename --dryrun`
 41 | 
 42 | rename files with no turning back:
 43 | 
 44 | `pdbMate rename`
 45 | 
 46 | add new downloads to sabnzbd
 47 | 
 48 | `pdbMate download`
 49 | 
 50 | add new downloads to nzbget
 51 | 
 52 | `pdbMate download --client nzbget`
 53 | 
 54 | rename and download with sabnzbd
 55 | 
 56 | `pdbMate autopilot`
 57 | 
 58 | rename and download with nzbget
 59 | 
 60 | `pdbMate autopilot --client nzbget`
 61 | 
 62 | The dryrun parameter means no files will be renamed. So you can check the results before renaming and moving your files.
 63 | The client parameter sets the usenet download client that should be used (sabnzbd or nzbget). Default value for this parameter is sabnzbd.
 64 | 
 65 | # Rename
 66 | 
 67 | Typical use-case: You are downloading adult content from usenet and want to sort your downloads by sites (one folder per adult website) and you want to sort out duplicate files. 
 68 | When downloading from usenet you typically have one release per folder. This is not optimal when using media managers like Plex. You want some kind of sorting in a reasonable folder structure.
 69 | 
 70 | Renaming and moving files makes sense when you want to watch videos on your local PC and even when adding content to your media managers. There are no media manager that can sort adult content.
 71 | 
 72 | What does the rename function do (Step-By-Step)?
 73 | 
 74 | - Gather a list of all files in the source folders you specified in your appsettings.json.
 75 | - Ignore folders and files that are not ready for renaming (unpack folders from sabnzbd)
 76 | - Querying the pdb API for sites and videos (results are cached during the execution).
 77 | - Sort out files that are to small or have the wrong file extension (mkv and mp4 only).
 78 | - Determine a matching video id from pdb API and getting the video quality (from folder or filename).
 79 | - Determine duplicate filenames
 80 | - Moving and renaming files depending on your settings from FilenameTemplate and FolderTemplate in appsettings.json.
 81 | - Deleting duplicates and unused files (small files etc.)
 82 | 
 83 | # Download
 84 | 
 85 | The download option enables you to automatically add nzb files to sabnzbd or nzbget for all newly released videos based on your favorite sites and actors (specified in porndb.me).
 86 | 
 87 | What does the download function do (Step-By-Step)?
 88 | 
 89 |  - pdbMate asks the porndb.me API with your API key what favorite sites and actors you have on record. 
 90 |  - It checks the directories you specified in the appsettings.json and builds a list of videos you already have on disk.
 91 |  - Then it asks the porndb.me API about new releases from your indexers (only those you have an api key on record with on porndb.me). 
 92 |  - Then it adds nzb files to either sabnzbd or nzbget for releases that you do not have on disk yet.
 93 | 
 94 | The major advantage with pdbMate download function in comparison to rss feeds is you do not get duplicates at all and you can specify prefered video qualities (video resolution).
 95 | 
 96 | Once you configured pdbMate correctly on your downloading machine, you can manage your favorite sites and stars on porndb.me and the rest is done automatically by pdbMate and your usenet downloader.
 97 | 
 98 | Configured correctly you now have an automated download functionality setup for porn from usenet. As far as we know this has never been accompished before. Custom rss feeds where the best option you had until now.
 99 | 
100 | # Configuring pdbMate
101 | 
102 | In the same directory as pbbMate there is a appsettings.Template.json - please rename this file to appsettings.json.
103 | 
104 | Once renamed, you have to change some settings:
105 | 
106 | ## porndb.me API
107 | Most importantly you have to replace --MY-OWN-APIKEY-- with your personal api key at porndb.me.
108 | 
109 | ## renaming config
110 | You should specify one or more SourceFolders. Then you should specify the target folder where the renamed files will be moved to.
111 | FilenameTemplate and FolderTemplte do not need to be changed, you can edit they to your personal preference if you like.
112 | 
113 | Examples for FilenameTemplate:
114 | 
115 | ```
116 | {Video.Site.Sitename} - {Video.Title} - {VideoQuality.SimplifiedName}.{PdbId}{FileExtension}
117 | {Video.ReleasedateShort} - {Video.Title} - {VideoQuality.SimplifiedName}.{PdbId}{FileExtension}
118 | {OriginalFilename}.{VideoQuality.SimplifiedName}.{PdbId}{FileExtension}
119 | ```
120 | 
121 | Available placeholders:
122 | ```
123 | {Video.Site.Sitename}
124 | {Video.Site.Id}
125 | {Video.Id}
126 | {Video.Title}
127 | {Video.Releasedate}
128 | {Video.ReleasedateShort}
129 | {VideoQuality.SimplifiedName}
130 | {VideoQuality.Name}
131 | {FileExtension}
132 | {PdbId}
133 | {OriginalFilename}
134 | ```
135 | 
136 | ## configure download client
137 | You can set connection details to your favorite usenet download client. Both clients can be configured but you determine with your command line call arguments (e.g. --client nzbget) which client is used. The default client is sabnzbd.
138 | 
139 | ## configure download settings
140 | In UsenetDownload you can change:
141 | - AllowedQualities: You decided which video quality the release must have to be downloaded.
142 | - KeepOnlyHighestQuality: during renaming and only the highest quality of a release is kept, everything else is considered a duplicate and will be removed
143 | - DownloadFavoriteActors: In autopilot mode all new releases from your favorite actors will be added to your download client
144 | - DownloadFavoriteSites: In autopilot mode all new releases from your favorite sites will be added to your download client
145 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Mono auto generated files
 17 | mono_crash.*
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | [Ww][Ii][Nn]32/
 27 | [Aa][Rr][Mm]/
 28 | [Aa][Rr][Mm]64/
 29 | bld/
 30 | [Bb]in/
 31 | [Oo]bj/
 32 | [Ll]og/
 33 | [Ll]ogs/
 34 | 
 35 | # Visual Studio 2015/2017 cache/options directory
 36 | .vs/
 37 | # Uncomment if you have tasks that create the project's static files in wwwroot
 38 | #wwwroot/
 39 | 
 40 | # Visual Studio 2017 auto generated files
 41 | Generated\ Files/
 42 | 
 43 | # MSTest test Results
 44 | [Tt]est[Rr]esult*/
 45 | [Bb]uild[Ll]og.*
 46 | 
 47 | # NUnit
 48 | *.VisualState.xml
 49 | TestResult.xml
 50 | nunit-*.xml
 51 | 
 52 | # Build Results of an ATL Project
 53 | [Dd]ebugPS/
 54 | [Rr]eleasePS/
 55 | dlldata.c
 56 | 
 57 | # Benchmark Results
 58 | BenchmarkDotNet.Artifacts/
 59 | 
 60 | # .NET Core
 61 | project.lock.json
 62 | project.fragment.lock.json
 63 | artifacts/
 64 | 
 65 | # ASP.NET Scaffolding
 66 | ScaffoldingReadMe.txt
 67 | 
 68 | # StyleCop
 69 | StyleCopReport.xml
 70 | 
 71 | # Files built by Visual Studio
 72 | *_i.c
 73 | *_p.c
 74 | *_h.h
 75 | *.ilk
 76 | *.meta
 77 | *.obj
 78 | *.iobj
 79 | *.pch
 80 | *.pdb
 81 | *.ipdb
 82 | *.pgc
 83 | *.pgd
 84 | *.rsp
 85 | *.sbr
 86 | *.tlb
 87 | *.tli
 88 | *.tlh
 89 | *.tmp
 90 | *.tmp_proj
 91 | *_wpftmp.csproj
 92 | *.log
 93 | *.vspscc
 94 | *.vssscc
 95 | .builds
 96 | *.pidb
 97 | *.svclog
 98 | *.scc
 99 | 
100 | # Chutzpah Test files
101 | _Chutzpah*
102 | 
103 | # Visual C++ cache files
104 | ipch/
105 | *.aps
106 | *.ncb
107 | *.opendb
108 | *.opensdf
109 | *.sdf
110 | *.cachefile
111 | *.VC.db
112 | *.VC.VC.opendb
113 | 
114 | # Visual Studio profiler
115 | *.psess
116 | *.vsp
117 | *.vspx
118 | *.sap
119 | 
120 | # Visual Studio Trace Files
121 | *.e2e
122 | 
123 | # TFS 2012 Local Workspace
124 | $tf/
125 | 
126 | # Guidance Automation Toolkit
127 | *.gpState
128 | 
129 | # ReSharper is a .NET coding add-in
130 | _ReSharper*/
131 | *.[Rr]e[Ss]harper
132 | *.DotSettings.user
133 | 
134 | # TeamCity is a build add-in
135 | _TeamCity*
136 | 
137 | # DotCover is a Code Coverage Tool
138 | *.dotCover
139 | 
140 | # AxoCover is a Code Coverage Tool
141 | .axoCover/*
142 | !.axoCover/settings.json
143 | 
144 | # Coverlet is a free, cross platform Code Coverage Tool
145 | coverage*.json
146 | coverage*.xml
147 | coverage*.info
148 | 
149 | # Visual Studio code coverage results
150 | *.coverage
151 | *.coveragexml
152 | 
153 | # NCrunch
154 | _NCrunch_*
155 | .*crunch*.local.xml
156 | nCrunchTemp_*
157 | 
158 | # MightyMoose
159 | *.mm.*
160 | AutoTest.Net/
161 | 
162 | # Web workbench (sass)
163 | .sass-cache/
164 | 
165 | # Installshield output folder
166 | [Ee]xpress/
167 | 
168 | # DocProject is a documentation generator add-in
169 | DocProject/buildhelp/
170 | DocProject/Help/*.HxT
171 | DocProject/Help/*.HxC
172 | DocProject/Help/*.hhc
173 | DocProject/Help/*.hhk
174 | DocProject/Help/*.hhp
175 | DocProject/Help/Html2
176 | DocProject/Help/html
177 | 
178 | # Click-Once directory
179 | publish/
180 | 
181 | # Publish Web Output
182 | *.[Pp]ublish.xml
183 | *.azurePubxml
184 | # Note: Comment the next line if you want to checkin your web deploy settings,
185 | # but database connection strings (with potential passwords) will be unencrypted
186 | *.pubxml
187 | *.publishproj
188 | 
189 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
190 | # checkin your Azure Web App publish settings, but sensitive information contained
191 | # in these scripts will be unencrypted
192 | PublishScripts/
193 | 
194 | # NuGet Packages
195 | *.nupkg
196 | # NuGet Symbol Packages
197 | *.snupkg
198 | # The packages folder can be ignored because of Package Restore
199 | **/[Pp]ackages/*
200 | # except build/, which is used as an MSBuild target.
201 | !**/[Pp]ackages/build/
202 | # Uncomment if necessary however generally it will be regenerated when needed
203 | #!**/[Pp]ackages/repositories.config
204 | # NuGet v3's project.json files produces more ignorable files
205 | *.nuget.props
206 | *.nuget.targets
207 | 
208 | # Microsoft Azure Build Output
209 | csx/
210 | *.build.csdef
211 | 
212 | # Microsoft Azure Emulator
213 | ecf/
214 | rcf/
215 | 
216 | # Windows Store app package directories and files
217 | AppPackages/
218 | BundleArtifacts/
219 | Package.StoreAssociation.xml
220 | _pkginfo.txt
221 | *.appx
222 | *.appxbundle
223 | *.appxupload
224 | 
225 | # Visual Studio cache files
226 | # files ending in .cache can be ignored
227 | *.[Cc]ache
228 | # but keep track of directories ending in .cache
229 | !?*.[Cc]ache/
230 | 
231 | # Others
232 | ClientBin/
233 | ~$*
234 | *~
235 | *.dbmdl
236 | *.dbproj.schemaview
237 | *.jfm
238 | *.pfx
239 | *.publishsettings
240 | orleans.codegen.cs
241 | 
242 | # Including strong name files can present a security risk
243 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
244 | #*.snk
245 | 
246 | # Since there are multiple workflows, uncomment next line to ignore bower_components
247 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
248 | #bower_components/
249 | 
250 | # RIA/Silverlight projects
251 | Generated_Code/
252 | 
253 | # Backup & report files from converting an old project file
254 | # to a newer Visual Studio version. Backup files are not needed,
255 | # because we have git ;-)
256 | _UpgradeReport_Files/
257 | Backup*/
258 | UpgradeLog*.XML
259 | UpgradeLog*.htm
260 | ServiceFabricBackup/
261 | *.rptproj.bak
262 | 
263 | # SQL Server files
264 | *.mdf
265 | *.ldf
266 | *.ndf
267 | 
268 | # Business Intelligence projects
269 | *.rdl.data
270 | *.bim.layout
271 | *.bim_*.settings
272 | *.rptproj.rsuser
273 | *- [Bb]ackup.rdl
274 | *- [Bb]ackup ([0-9]).rdl
275 | *- [Bb]ackup ([0-9][0-9]).rdl
276 | 
277 | # Microsoft Fakes
278 | FakesAssemblies/
279 | 
280 | # GhostDoc plugin setting file
281 | *.GhostDoc.xml
282 | 
283 | # Node.js Tools for Visual Studio
284 | .ntvs_analysis.dat
285 | node_modules/
286 | 
287 | # Visual Studio 6 build log
288 | *.plg
289 | 
290 | # Visual Studio 6 workspace options file
291 | *.opt
292 | 
293 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
294 | *.vbw
295 | 
296 | # Visual Studio LightSwitch build output
297 | **/*.HTMLClient/GeneratedArtifacts
298 | **/*.DesktopClient/GeneratedArtifacts
299 | **/*.DesktopClient/ModelManifest.xml
300 | **/*.Server/GeneratedArtifacts
301 | **/*.Server/ModelManifest.xml
302 | _Pvt_Extensions
303 | 
304 | # Paket dependency manager
305 | .paket/paket.exe
306 | paket-files/
307 | 
308 | # FAKE - F# Make
309 | .fake/
310 | 
311 | # CodeRush personal settings
312 | .cr/personal
313 | 
314 | # Python Tools for Visual Studio (PTVS)
315 | __pycache__/
316 | *.pyc
317 | 
318 | # Cake - Uncomment if you are using it
319 | # tools/**
320 | # !tools/packages.config
321 | 
322 | # Tabs Studio
323 | *.tss
324 | 
325 | # Telerik's JustMock configuration file
326 | *.jmconfig
327 | 
328 | # BizTalk build output
329 | *.btp.cs
330 | *.btm.cs
331 | *.odx.cs
332 | *.xsd.cs
333 | 
334 | # OpenCover UI analysis results
335 | OpenCover/
336 | 
337 | # Azure Stream Analytics local run output
338 | ASALocalRun/
339 | 
340 | # MSBuild Binary and Structured Log
341 | *.binlog
342 | 
343 | # NVidia Nsight GPU debugger configuration file
344 | *.nvuser
345 | 
346 | # MFractors (Xamarin productivity tool) working folder
347 | .mfractor/
348 | 
349 | # Local History for Visual Studio
350 | .localhistory/
351 | 
352 | # BeatPulse healthcheck temp database
353 | healthchecksdb
354 | 
355 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
356 | MigrationBackup/
357 | 
358 | # Ionide (cross platform F# VS Code tools) working folder
359 | .ionide/
360 | 
361 | # Fody - auto-generated XML schema
362 | FodyWeavers.xsd
363 | 
364 | # Test json files
365 | /tests/pdbMate.Core.Tests/settings/pdbapi.json
366 | /tests/pdbMate.Core.Tests/settings/nzbget.json
367 | /tests/pdbMate.Core.Tests/settings/sabnzbd.json
368 | 
369 | # Local appsettings
370 | /src/pdbMate/appsettings.json
371 | 
372 | # Personal readme file for notes
373 | /src/pdbMate/README.Personal.md


--------------------------------------------------------------------------------
/src/pdbMate.Core/PdbApiService.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using Microsoft.Extensions.Logging;
  5 | using Microsoft.Extensions.Options;
  6 | using pdbMate.Core.Data;
  7 | using pdbMate.Core.Interfaces;
  8 | using RestSharp;
  9 | 
 10 | namespace pdbMate.Core
 11 | {
 12 |     public class PdbApiService : IPdbApiService
 13 |     {
 14 |         private readonly ILogger<IPdbApiService> logger;
 15 |         
 16 |         private RestClient client;
 17 |         private PdbApiServiceOptions options;
 18 |         private List<Site> cachedSites;
 19 |         private List<UsenetIndexer> cachedIndexers;
 20 |         private readonly Dictionary<int,List<Video>> cachedVideos;
 21 | 
 22 |         public PdbApiService(ILogger<IPdbApiService> logger, IOptions<PdbApiServiceOptions> options)
 23 |         {
 24 |             this.logger = logger;
 25 |             setOptions(options);
 26 | 
 27 |             cachedVideos = new Dictionary<int, List<Video>>();
 28 |         }
 29 | 
 30 |         public void setOptions(IOptions<PdbApiServiceOptions> optionsToSet)
 31 |         {
 32 |             options = optionsToSet.Value;
 33 | 
 34 |             if (options != null && !string.IsNullOrEmpty(options.BaseUrl))
 35 |             {
 36 |                 client = new RestClient(options.BaseUrl);
 37 |                 client.AddDefaultHeader("X-PORNDB-APIKEY", options.Apikey);
 38 |             }
 39 |         }
 40 | 
 41 |         public List<VideoQuality> GetAllVideoQuality()
 42 |         {
 43 |             List<VideoQuality> videoQuality = new List<VideoQuality> {
 44 |                 new VideoQuality() {
 45 |                     Id = 0, Name = "Unknown", SimplifiedName = "Unknown", BetterQualityOrdinal = 0
 46 |                 },
 47 |                 new VideoQuality()
 48 |                 {
 49 |                     Id = 1, Name = "720p", SimplifiedName = "720p", BetterQualityOrdinal = 2
 50 |                 },
 51 |                 new VideoQuality()
 52 |                 {
 53 |                     Id = 2, Name = "1080p", SimplifiedName = "1080p", BetterQualityOrdinal = 3
 54 |                 },
 55 |                 new VideoQuality()
 56 |                 {
 57 |                     Id = 3, Name = "2160p", SimplifiedName = "2160p", BetterQualityOrdinal = 4
 58 |                 },
 59 |                 new VideoQuality()
 60 |                 {
 61 |                     Id = 4, Name = "480p", SimplifiedName = "480p", BetterQualityOrdinal = 1
 62 |                 }
 63 |             };
 64 | 
 65 |             return videoQuality;
 66 |         }
 67 | 
 68 |         public List<Site> GetSites()
 69 |         {
 70 |             if (cachedSites != null) return cachedSites;
 71 | 
 72 |             var request = new RestRequest("api/pornsites", Method.Get)
 73 |                 .AddQueryParameter("limit", "100000");
 74 | 
 75 |             var response = client.GetAsync<List<Site>>(request).GetAwaiter().GetResult();
 76 |             cachedSites = response;
 77 | 
 78 |             return cachedSites;
 79 |         }
 80 | 
 81 |         public List<Video> GetVideosBySite(Site site)
 82 |         {
 83 |             if (cachedVideos.ContainsKey(site.Id))
 84 |             {
 85 |                 return cachedVideos[site.Id];
 86 |             }
 87 | 
 88 |             var request = new RestRequest("api/pornvideos", Method.Get)
 89 |                 .AddQueryParameter("limit", "100000")
 90 |                 .AddQueryParameter("pornsite", site.Id.ToString());
 91 | 
 92 |             var response = client.GetAsync<List<PdbApiPornvideo>>(request).GetAwaiter().GetResult();
 93 |             var videosReturned = response;
 94 | 
 95 |             var requestActors = new RestRequest("api/actors", Method.Get)
 96 |                 .AddQueryParameter("limit", "100000")
 97 |                 .AddQueryParameter("pornsite", site.Id.ToString());
 98 | 
 99 |             var responseActors = client.GetAsync<List<Actor>>(requestActors).GetAwaiter().GetResult();
100 |             var actorsReturned = responseActors;
101 | 
102 |             List<Video> videos = new List<Video>();
103 |             foreach (PdbApiPornvideo videoReturned in videosReturned)
104 |             {
105 |                 var actors = new List<Actor>();
106 |                 if (videoReturned.Pornstar1 > 0)
107 |                 {
108 |                     var actorFound = actorsReturned.FirstOrDefault(x => x.Id == videoReturned.Pornstar1);
109 |                     if (actorFound != null)
110 |                     {
111 |                         actors.Add(new Actor()
112 |                         {
113 |                             Id = actorFound.Id,
114 |                             Actorname = actorFound.Actorname,
115 |                             Gender = actorFound.Gender
116 |                         });
117 |                     }
118 |                 }
119 | 
120 |                 if (videoReturned.Pornstar2 > 0)
121 |                 {
122 |                     var actorFound = actorsReturned.FirstOrDefault(x => x.Id == videoReturned.Pornstar2);
123 |                     if (actorFound != null)
124 |                     {
125 |                         actors.Add(new Actor()
126 |                         {
127 |                             Id = actorFound.Id,
128 |                             Actorname = actorFound.Actorname,
129 |                             Gender = actorFound.Gender
130 |                         });
131 |                     }
132 |                 }
133 | 
134 |                 var video = new Video()
135 |                 {
136 |                     Id = videoReturned.Id,
137 |                     Site = new Site()
138 |                     {
139 |                         Id = site.Id,
140 |                         Sitename = site.Sitename
141 |                     },
142 |                     Actors = actors,
143 |                     Releasedate = videoReturned.ReleaseDate,
144 |                     Title = videoReturned.VideoTitle,
145 |                     FullTitle = videoReturned.FullTitle
146 |                 };
147 |                 videos.Add(video);
148 |             }
149 | 
150 |             cachedVideos.Add(site.Id, videos);
151 |             return videos;
152 |         }
153 | 
154 |         public List<Actor> GetFavoriteActors()
155 |         {
156 |             var request = new RestRequest("api/myactors", Method.Get);
157 | 
158 |             var response= client.GetAsync<List<Actor>>(request).GetAwaiter().GetResult();
159 |             return response;
160 |         }
161 | 
162 |         public List<Site> GetFavoriteSites()
163 |         {
164 |             var request = new RestRequest("api/mysites", Method.Get);
165 | 
166 |             var response = client.GetAsync<List<Site>>(request).GetAwaiter().GetResult();
167 |             return response;
168 |         }
169 |         
170 |         public List<UsenetRelease> GetReleases(int page, int take, int? actor, int? site, string search)
171 |         {
172 |             var request = new RestRequest("api/usenet/releases", Method.Get)
173 |                 .AddQueryParameter("page", page.ToString())
174 |                 .AddQueryParameter("take", take.ToString());
175 | 
176 |             if (actor != null && actor != 0)
177 |             {
178 |                 request.AddQueryParameter("actor", actor.Value.ToString());
179 |             }
180 | 
181 |             if (!string.IsNullOrEmpty(search))
182 |             {
183 |                 request.AddQueryParameter("search", search);
184 |             }
185 | 
186 |             if (site != null && site != 0)
187 |             {
188 |                 request.AddQueryParameter("site", site.Value.ToString());
189 |             }
190 | 
191 |             var response = client.GetAsync<List<UsenetRelease>>(request).GetAwaiter().GetResult();
192 |             return response;
193 |         }
194 | 
195 |         public List<UsenetIndexer> GetMyIndexer()
196 |         {
197 |             if (cachedIndexers != null)
198 |             {
199 |                 return cachedIndexers;
200 |             }
201 | 
202 |             var request = new RestRequest("api/myindexer", Method.Get);
203 |             var response = client.GetAsync<List<UsenetIndexer>>(request).GetAwaiter().GetResult();
204 |             cachedIndexers = response;
205 |             return cachedIndexers;
206 |         }
207 |     }
208 | 
209 |     internal class PdbApiPornvideo
210 |     {
211 |         public int Id { get; set; }
212 |         public int Pornsite { get; set; }
213 |         public string VideoTitle { get; set; }
214 |         public string FullTitle { get; set; } // for Fulltext search
215 |         public string FullReleaseTitle { get; set; } // for Fulltext search
216 |         public DateTime Created { get; set; }
217 |         public DateTime ReleaseDate { get; set; }
218 |         public int Pornstar1 { get; set; }
219 |         public int Pornstar2 { get; set; }
220 |         public int SceneRelease { get; set; }
221 |         public string PreviewImageUrl { get; set; }
222 |         public string PreviewVideoUrl { get; set; }
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------
/src/pdbMate/Program.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using Microsoft.Extensions.Configuration;
  5 | using Microsoft.Extensions.DependencyInjection;
  6 | using pdbMate.Commands;
  7 | using pdbMate.Core;
  8 | using pdbMate.SetupLogic;
  9 | using pdbme.pdbInfrastructure.DependencyInjection.Services;
 10 | using pdbme.pdbInfrastructure.Logging.Services;
 11 | using Serilog;
 12 | using Serilog.Events;
 13 | using Serilog.Sinks.SystemConsole.Themes;
 14 | using Spectre.Console;
 15 | using Spectre.Console.Cli;
 16 | 
 17 | namespace pdbMate
 18 | {
 19 |     public class Program
 20 |     {
 21 |         private static IConfigurationRoot _configuration;
 22 | 
 23 |         private static int Main(string[] args)
 24 |         {
 25 |             AnsiConsole.Write(
 26 |                 new FigletText("pdbMate")
 27 |                     .LeftAligned()
 28 |                     .Color(Color.Purple));
 29 | 
 30 |             bool appSettingsFound = File.Exists("appsettings.json");
 31 |             if (!appSettingsFound)
 32 |             {
 33 |                 Console.Error.WriteLine("No appsettings.json found! Starting interactive setup...");
 34 |                 args = new string[] { "setup" };
 35 |             }
 36 | 
 37 |             if (args.Length == 0)
 38 |             {
 39 |                 args = GetArgsByInteractiveMode();
 40 |             }
 41 | 
 42 |             return RunWithArguments(args);
 43 |         }
 44 | 
 45 |         private static int RunWithArguments(string[] args)
 46 |         {
 47 |             var serviceCollections = ConfigureApp();
 48 |             var registrar = new TypeRegistrar(serviceCollections);
 49 | 
 50 |             var app = new CommandApp(registrar);
 51 |             app.Configure(config =>
 52 |             {
 53 |                 config.PropagateExceptions();
 54 | 
 55 |                 config.SetInterceptor(new LogInterceptor());
 56 | 
 57 |                 config.SetExceptionHandler(ex =>
 58 |                 {
 59 |                     Log.Logger.Error(ex.Message + " Stacktrace: " + ex.StackTrace);
 60 |                     return -1;
 61 |                 });
 62 | 
 63 |                 config.AddCommand<RenameCommand>("rename")
 64 |                     .WithDescription("Rename and sort video files in subfolders by sitename.")
 65 |                     .WithExample(new[] { "rename", "--dryrun" });
 66 |                 config.AddCommand<SetupCommand>("setup")
 67 |                     .WithDescription("Interactive setup to configure pdbMate.")
 68 |                     .WithExample(new[] { "setup" });
 69 |                 config.AddCommand<DownloadCommand>("download")
 70 |                     .WithDescription("Rename and sort video files in subfolders by sitename.")
 71 |                     .WithExample(new[] { "download", "--dryrun" })
 72 |                     .WithExample(new[] { "download", "--dryrun", "--client", "nzbget" });
 73 |                 config.AddCommand<ChangeNamesCommand>("changenames")
 74 |                     .WithDescription("Apply different naming template to an existing folder (a folder with sorted videos - only videos with a pdbid in their filename will be renamed).")
 75 |                     .WithExample(new[] { "changenames", "--dryrun" });
 76 |                 config.AddCommand<BackfillingCommand>("backfilling")
 77 |                     .WithDescription("Backfilling by favorite sites and actors (0 means all favorite actors or sites - otherwise the id of one site or actor).")
 78 |                     .WithExample(new[] { "backfilling", "--actor", "0" })
 79 |                     .WithExample(new[] { "backfilling", "--actor", "0", "--site", "0" })
 80 |                     .WithExample(new[] { "backfilling", "--site", "6" });
 81 |             });
 82 | 
 83 |             return app.Run(args);
 84 |         }
 85 | 
 86 |         private static ServiceCollection ConfigureApp()
 87 |         {
 88 |             _configuration = new ConfigurationBuilder()
 89 |                 .SetBasePath(Directory.GetCurrentDirectory())
 90 |                 .AddJsonFile("appsettings.json", true, false)
 91 |                 .Build();
 92 | 
 93 |             var services = new ServiceCollection();
 94 |             services.AddOptions();
 95 | 
 96 |             services.AddLogging(opt =>
 97 |             {
 98 |                 var loggerConfig = new LoggerConfiguration()
 99 |                     .MinimumLevel.Information()
100 |                     .MinimumLevel.ControlledBy(LogInterceptor.LogLevel)
101 |                     .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
102 |                     .WriteTo.Console(theme: AnsiConsoleTheme.Code, outputTemplate: "[{Level:u3}] {Message:lj}{NewLine}{Exception}")
103 |                     .WriteTo.File("log.txt", rollingInterval: RollingInterval.Day, retainedFileCountLimit: 7, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}")
104 |                     .CreateLogger();
105 | 
106 |                 opt.AddSerilog(loggerConfig);
107 |             });
108 | 
109 |             services.AddPdbApiService(_configuration.GetSection("PdbApi"));
110 |             services.AddRenameService(_configuration.GetSection("Rename"));
111 |             services.AddNzbgetService(_configuration.GetSection("Nzbget"));
112 |             services.AddSabnzbdService(_configuration.GetSection("Sabnzbd"));
113 |             services.AddUsenetDownloadService(_configuration.GetSection("UsenetDownload"));
114 | 
115 |             services.AddScoped<ISetup, Setup>();
116 |             return services;
117 |         }
118 | 
119 |         private static string[] GetArgsByInteractiveMode()
120 |         {
121 |             var argList = new List<string>();
122 | 
123 |             var action = AnsiConsole.Prompt(
124 |                 new SelectionPrompt<string>()
125 |                     .Title("Which [green]action[/] do you want to execute?")
126 |                     .AddChoices(new[] {
127 |                         "rename", "download", "autopilot", "setup", "backfilling"
128 |                     }));
129 | 
130 |             argList.Add(action);
131 | 
132 |             var isVerbose = AnsiConsole.Confirm("Run action in debug logging mode?");
133 |             if (isVerbose)
134 |             {
135 |                 argList.Add("--loglevel");
136 |                 argList.Add("d");
137 |             }
138 | 
139 |             if (action == "rename" || action == "download" || action == "autopilot" || action == "backfilling")
140 |             {
141 |                 var isDryRun = AnsiConsole.Confirm("Execute action as dryrun (does not modify anything on disk)?");
142 |                 if (isDryRun)
143 |                 {
144 |                     argList.Add("--dryrun");
145 |                 }
146 |             }
147 | 
148 |             if (action == "backfilling")
149 |             {
150 |                 var doBackfillingForActors = AnsiConsole.Confirm("Do backfilling for all your favorite actors?");
151 |                 if (doBackfillingForActors)
152 |                 {
153 |                     argList.Add("--actor");
154 |                     argList.Add("0");
155 |                 }
156 | 
157 |                 var doBackfillingForSites = AnsiConsole.Confirm("Do backfilling for all your favorite sites?");
158 |                 if (doBackfillingForSites)
159 |                 {
160 |                     argList.Add("--site");
161 |                     argList.Add("0");
162 |                 }
163 | 
164 |                 var daysBack = AnsiConsole.Prompt(
165 |                     new TextPrompt<int>($"Enter the maximum [green]number of days[/] you want to go back and backfill:")
166 |                         .PromptStyle("green")
167 |                         .ValidationErrorMessage("[red]That's not a valid number of days[/]")
168 |                         .Validate(id =>
169 |                         {
170 |                             if (id == 0)
171 |                             {
172 |                                 return ValidationResult.Error($"[red]Number of days should be more than 0[/]");
173 |                             }
174 | 
175 |                             if (id > 1800)
176 |                             {
177 |                                 return ValidationResult.Error($"[red]Number of days should be less than 1800[/]");
178 |                             }
179 | 
180 |                             return ValidationResult.Success();
181 |                         }));
182 |                 argList.Add("--daysback");
183 |                 argList.Add(daysBack.ToString());
184 | 
185 |                 if (!doBackfillingForActors && !doBackfillingForSites)
186 |                 {
187 |                     var siteId = AnsiConsole.Prompt(
188 |                     new TextPrompt<int>($"Enter [green]site id[/] you want to backfill (enter 0 to skip and continue with an actor id):")
189 |                         .PromptStyle("green")
190 |                         .ValidationErrorMessage("[red]That's not a valid site id[/]")
191 |                         .Validate(id =>
192 |                         {
193 |                             if (id < 0)
194 |                             {
195 |                                 return ValidationResult.Error($"[red]Id {id} is not known[/]");
196 |                             }
197 | 
198 |                             return ValidationResult.Success();
199 |                         }));
200 |                     if(siteId > 0)
201 |                     {
202 |                         argList.Add("--site");
203 |                         argList.Add(siteId.ToString());
204 |                     }
205 |                     else
206 |                     {
207 |                         var actorId = AnsiConsole.Prompt(
208 |                             new TextPrompt<int>($"Enter [green]actor id[/] you want to backfill:")
209 |                                 .PromptStyle("green")
210 |                                 .ValidationErrorMessage("[red]That's not a valid actor id[/]")
211 |                                 .Validate(id =>
212 |                                 {
213 |                                     if (id == 0)
214 |                                     {
215 |                                         return ValidationResult.Error($"[red]Id {id} is not known[/]");
216 |                                     }
217 | 
218 |                                     return ValidationResult.Success();
219 |                                 }));
220 |                         argList.Add("--actor");
221 |                         argList.Add(actorId.ToString());
222 |                     }
223 |                 }
224 |             }
225 | 
226 |             return argList.ToArray();
227 |         }
228 |     }
229 | }
230 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/src/pdbMate/SetupLogic/Setup.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.Extensions.Options;
  2 | using pdbMate.ApplicationSetupLogic;
  3 | using pdbMate.Core;
  4 | using pdbMate.Core.Data;
  5 | using pdbMate.Core.Interfaces;
  6 | using Spectre.Console;
  7 | using System;
  8 | using System.IO;
  9 | using System.Text.Json;
 10 | 
 11 | namespace pdbMate.SetupLogic
 12 | {
 13 |     public class Setup : ISetup
 14 |     {
 15 |         private AppSettingsResult appSettings;
 16 |         private readonly IPdbApiService pdbApiService;
 17 |         private readonly ISabnzbdService sabnzbdService;
 18 |         private readonly INzbgetService nzbgetService;
 19 | 
 20 |         public Setup(IPdbApiService pdbApiService, ISabnzbdService sabnzbdService, INzbgetService nzbgetService)
 21 |         {
 22 |             this.pdbApiService = pdbApiService;
 23 |             this.sabnzbdService = sabnzbdService;
 24 |             this.nzbgetService = nzbgetService;
 25 |         }
 26 | 
 27 |         public bool RunSetup()
 28 |         {
 29 |             appSettings = new AppSettingsResult();
 30 | 
 31 |             ReadApiKey();
 32 |             bool useForDownload = ReadActiveServices();
 33 |             if (useForDownload)
 34 |             {
 35 |                 ReadDownloadClient();
 36 |             }
 37 |             ReadRenaming();
 38 | 
 39 |             return SaveToDisk();
 40 |         }
 41 | 
 42 |         private void ReadRenaming()
 43 |         {
 44 |             var useForRenaming = AnsiConsole.Confirm("Do you want to use pdbMate to rename your downloads (sort them into folders based on sitename and rename files into a humanfriendly format - very useful for media players like plex)?");
 45 |             if (!useForRenaming)
 46 |             {
 47 |                 return;
 48 |             }
 49 | 
 50 |             var useStandardFormat = AnsiConsole.Confirm("Use default format for folder and filename renaming (Folder: {Video.Site.Sitename} File: {Video.ReleasedateShort} - {Video.Title} - {VideoQuality.SimplifiedName} - {PdbId}{FileExtension})?");
 51 |             if (!useStandardFormat)
 52 |             {
 53 |                 appSettings.Rename.FilenameTemplate = AnsiConsole.Prompt(
 54 |                 new TextPrompt<string>($"Enter your desired [green]filename template[/] for renaming:")
 55 |                     .PromptStyle("green")
 56 |                     .ValidationErrorMessage("[red]That's not a valid filename template[/]")
 57 |                     .Validate(filenameTemplate =>
 58 |                     {
 59 |                         if (!filenameTemplate.Contains("{FileExtension}"))
 60 |                         {
 61 |                             return ValidationResult.Error("[red]Please include at least the {FileExtension}[/]");
 62 |                         }
 63 | 
 64 |                         return ValidationResult.Success();
 65 |                     }));
 66 |                 appSettings.Rename.FolderTemplate = AnsiConsole.Prompt(
 67 |                     new TextPrompt<string>($"Enter your desired [green]folder template[/] for renaming:")
 68 |                         .PromptStyle("green"));
 69 |             }
 70 | 
 71 |             bool doYouWantToAddAnother = false;
 72 |             do
 73 |             {
 74 |                 var sourceFolder = AnsiConsole.Prompt(
 75 |                 new TextPrompt<string>($"Add [green]folderpath[/] as source for renaming:")
 76 |                     .PromptStyle("green")
 77 |                     .ValidationErrorMessage("[red]That's not a valid folderpath[/]")
 78 |                     .Validate(folderpath =>
 79 |                     {
 80 |                         if (!Directory.Exists(folderpath))
 81 |                         {
 82 |                             return ValidationResult.Error("[red]This directory does not exist[/]");
 83 |                         }
 84 | 
 85 |                         return ValidationResult.Success();
 86 |                     }));
 87 | 
 88 |                 appSettings.Rename.SourceFolders.Add(sourceFolder);
 89 |                 doYouWantToAddAnother = AnsiConsole.Confirm("Do you want to add another source folder for renaming?");
 90 |             }
 91 |             while (doYouWantToAddAnother);
 92 | 
 93 |             appSettings.Rename.TargetFolder = AnsiConsole.Prompt(
 94 |             new TextPrompt<string>($"In which [green]target path[/] should renamed files be moved (every site will become its own subfolder if the default folder template setting wasn't changed):")
 95 |                 .PromptStyle("green")
 96 |                 .ValidationErrorMessage("[red]That's not a valid target path[/]")
 97 |                 .Validate(targetFolder =>
 98 |                 {
 99 |                     if (!Directory.Exists(targetFolder))
100 |                     {
101 |                         return ValidationResult.Error("[red]This directory does not exist[/]");
102 |                     }
103 | 
104 |                     return ValidationResult.Success();
105 |                 }));
106 |         }
107 |         private void ReadApiKey()
108 |         {
109 |             var apikey = AnsiConsole.Prompt(
110 |                 new TextPrompt<string>($"Enter your [green]apikey[/] for {appSettings.PdbApi.BaseUrl}:")
111 |                     .PromptStyle("green")
112 |                     .ValidationErrorMessage("[red]That's not a valid apikey[/]")
113 |                     .Validate(apikey =>
114 |                     {
115 |                         if (apikey.Length != 32)
116 |                         {
117 |                             return ValidationResult.Error("[red]The apikey must be 32 characters long[/]");
118 |                         }
119 | 
120 |                         if (!IsApiKeyValid(apikey))
121 |                         {
122 |                             return ValidationResult.Error($"[red]Failed to connect to {appSettings.PdbApi.BaseUrl} with your apikey[/]");
123 |                         }
124 | 
125 |                         return ValidationResult.Success();
126 |                     }));
127 | 
128 |             appSettings.PdbApi.ApiKey = apikey;
129 |             pdbApiService.setOptions(Options.Create(new PdbApiServiceOptions()
130 |             {
131 |                 BaseUrl = appSettings.PdbApi.BaseUrl,
132 |                 Apikey = appSettings.PdbApi.ApiKey
133 |             }));
134 | 
135 |             AnsiConsole.MarkupLine("[green]Successfully[/] connected with your apikey");
136 |         }
137 | 
138 |         private bool IsApiKeyValid(string apiKey)
139 |         {
140 |             try
141 |             {
142 |                 pdbApiService.setOptions(Options.Create(new PdbApiServiceOptions()
143 |                 {
144 |                     BaseUrl = appSettings.PdbApi.BaseUrl,
145 |                     Apikey = apiKey
146 |                 }));
147 |                 var r = pdbApiService.GetMyIndexer();
148 |                 return true;
149 |             }
150 |             catch
151 |             {
152 |                 return false;
153 |             }
154 |         }
155 | 
156 |         private bool ReadActiveServices()
157 |         {
158 |             var useForDownload = AnsiConsole.Confirm("Do you want to use pdbMate to add downloads to your usenet client?");
159 |             if (useForDownload)
160 |             {
161 |                 var allowedQualities = AnsiConsole.Prompt(
162 |                     new MultiSelectionPrompt<string>()
163 |                         .Title("What [green]video quality[/] do you want to download?")
164 |                         .InstructionsText(
165 |                             "[grey](Press [blue]<space>[/] to toggle a quality, " +
166 |                             "[green]<enter>[/] to accept)[/]")
167 |                         .AddChoices(new[] {
168 |                             "1080p", "2160p"
169 |                         }));
170 | 
171 |                 var keepOnlyHighestQuality = AnsiConsole.Confirm("When downloading from usenet, only keep the highest quality of the same release?");
172 |                 var downloadFavoriteActors = AnsiConsole.Confirm("Add downloads based on your favorite actors?");
173 |                 var downloadFavoriteSites = AnsiConsole.Confirm("Add downloads based on your favorite sites?");
174 | 
175 |                 if (!downloadFavoriteActors && !downloadFavoriteSites)
176 |                 {
177 |                     AnsiConsole.MarkupLine($"[red]You do not want to add downloads based on your [bold]favorite actors OR sites[/] - pdbMate would not add any downloads - let's start from the beginning.[/]");
178 |                     ReadActiveServices();
179 |                 }
180 | 
181 |                 appSettings.UsenetDownload.AllowedQualities = allowedQualities;
182 |                 appSettings.UsenetDownload.KeepOnlyHighestQuality = keepOnlyHighestQuality;
183 |                 appSettings.UsenetDownload.DownloadFavoriteSites = downloadFavoriteSites;
184 |                 appSettings.UsenetDownload.DownloadFavoriteActors = downloadFavoriteActors;
185 |             }
186 | 
187 |             return useForDownload;
188 |         }
189 | 
190 |         private void ReadDownloadClient()
191 |         {
192 |             var client = AnsiConsole.Prompt(
193 |                 new SelectionPrompt<string>()
194 |                     .Title("Which [green]download client[/] do you want to use?")
195 |                     .AddChoices(new[] {
196 |                         "sabnzbd", "nzbget"
197 |                     }));
198 | 
199 |             if (client == "sabnzbd")
200 |             {
201 |                 ReadSabnzbd();
202 |                 appSettings.UsenetDownload.ActiveClient = DownloadClient.Sabnzbd;
203 |                 return;
204 |             }
205 | 
206 |             ReadNzbget();
207 |             appSettings.UsenetDownload.ActiveClient = DownloadClient.Nzbget;
208 |         }
209 | 
210 |         private void ReadSabnzbd()
211 |         {
212 |             var hostname = AnsiConsole.Prompt(
213 |                 new TextPrompt<string>($"Enter [green]hostname[/] for sabnzbd (e.g. localhost):")
214 |                     .PromptStyle("green")
215 |                     .ValidationErrorMessage("[red]That's not a valid hostname[/]")
216 |                     .Validate(hostname =>
217 |                     {
218 |                         if (hostname.Contains(':'))
219 |                         {
220 |                             return ValidationResult.Error("[red]Do not provide http or the port in the hostname[/]");
221 |                         }
222 | 
223 |                         return ValidationResult.Success();
224 |                     }));
225 | 
226 |             var useSsl = AnsiConsole.Confirm("Using SSL to connect?");
227 |             hostname = $"http{(useSsl ? "s" : "")}://" + hostname;
228 | 
229 |             var port = AnsiConsole.Prompt(
230 |                 new TextPrompt<int>($"Enter [green]port[/] for sabnzbd (e.g. 8080):")
231 |                     .PromptStyle("green")
232 |                     .ValidationErrorMessage("[red]That's not a valid port[/]")
233 |                     .Validate(port =>
234 |                     {
235 |                         if (port == 0)
236 |                         {
237 |                             return ValidationResult.Error("[red]Port 0 is not a valid port[/]");
238 |                         }
239 | 
240 |                         return ValidationResult.Success();
241 |                     }));
242 | 
243 |             hostname = hostname + ":" + port + "/sabnzbd/api";
244 | 
245 |             var apikey = AnsiConsole.Prompt(
246 |                 new TextPrompt<string>($"Enter [green]apikey[/] for sabnzbd:")
247 |                     .PromptStyle("green")
248 |                     .ValidationErrorMessage("[red]That's not a valid apikey[/]")
249 |                     .Validate(apikey =>
250 |                     {
251 |                         if (apikey.Length != 32)
252 |                         {
253 |                             return ValidationResult.Error("[red]The apikey must be 32 characters long[/]");
254 |                         }
255 | 
256 |                         return ValidationResult.Success();
257 |                     }));
258 | 
259 |             if (!IsConnectionSabnzbdSuccessful(hostname, apikey))
260 |             {
261 |                 AnsiConsole.MarkupLine($"[red]Cound not connect to sabnzbd on url: {hostname} - let's start from the beginning.[/]");
262 |                 ReadDownloadClient();
263 |             }
264 | 
265 |             appSettings.Sabnzbd.Url = hostname;
266 |             appSettings.Sabnzbd.ApiKey = apikey;
267 |         }
268 | 
269 |         private void ReadNzbget()
270 |         {
271 |             var hostname = AnsiConsole.Prompt(
272 |             new TextPrompt<string>($"Enter [green]hostname[/] for nzbget (e.g. localhost):")
273 |                 .PromptStyle("green")
274 |                 .ValidationErrorMessage("[red]That's not a valid hostname[/]")
275 |                 .Validate(hostname =>
276 |                 {
277 |                     if (hostname.Contains(':'))
278 |                     {
279 |                         return ValidationResult.Error("[red]Do not provide http or the port in the hostname[/]");
280 |                     }
281 | 
282 |                     return ValidationResult.Success();
283 |                 }));
284 | 
285 |             var useSsl = AnsiConsole.Confirm("Using SSL to connect?");
286 | 
287 |             var port = AnsiConsole.Prompt(
288 |             new TextPrompt<int>($"Enter [green]port[/] for sabnzbd (e.g. 8080):")
289 |                 .PromptStyle("green")
290 |                 .ValidationErrorMessage("[red]That's not a valid port[/]")
291 |                 .Validate(port =>
292 |                 {
293 |                     if (port == 0)
294 |                     {
295 |                         return ValidationResult.Error("[red]Port 0 is not a valid port[/]");
296 |                     }
297 | 
298 |                     return ValidationResult.Success();
299 |                 }));
300 | 
301 |             var useAuth = AnsiConsole.Confirm("Do you need to specify username and password for accessing nzbget?");
302 | 
303 |             var username = "";
304 |             var password = "";
305 |             if (useAuth)
306 |             {
307 |                 username = AnsiConsole.Prompt(new TextPrompt<string>($"Enter [green]username[/] for nzbget:")
308 |                     .PromptStyle("green").AllowEmpty());
309 | 
310 |                 password = AnsiConsole.Prompt(new TextPrompt<string>($"Enter [green]password[/] for nzbget:")
311 |                     .PromptStyle("green").AllowEmpty());
312 |             }
313 | 
314 |             if (!IsConnectionNzbgetSuccessful(hostname, port, username, password, useSsl))
315 |             {
316 |                 AnsiConsole.MarkupLine($"[red]Cound not connect to nzbget on url: {hostname} - let's start from the beginning.[/]");
317 |                 ReadDownloadClient();
318 |             }
319 | 
320 |             appSettings.Nzbget.Username = username;
321 |             appSettings.Nzbget.Password = password;
322 |             appSettings.Nzbget.Hostname = hostname;
323 |             appSettings.Nzbget.Port = port;
324 |             appSettings.Nzbget.UseHttps = useSsl;
325 |         }
326 | 
327 |         private bool IsConnectionNzbgetSuccessful(string hostname, int port, string username, string password, bool useSsl)
328 |         {
329 |             nzbgetService.setOptions(Options.Create(new NzbgetServiceOptions()
330 |             {
331 |                 Hostname = hostname,
332 |                 Port = port,
333 |                 Username = username,
334 |                 Password = password,
335 |                 UseHttps = useSsl
336 |             }));
337 | 
338 |             try
339 |             {
340 |                 return nzbgetService.GetVersion() > 0;
341 |             }
342 |             catch
343 |             {
344 |                 return false;
345 |             }
346 |         }
347 | 
348 |         private bool IsConnectionSabnzbdSuccessful(string hostname, string apikey)
349 |         {
350 |             sabnzbdService.setOptions(Options.Create(new SabnzbdServiceOptions()
351 |             {
352 |                 Url = hostname,
353 |                 ApiKey = apikey
354 |             }));
355 | 
356 |             try
357 |             {
358 |                 return !string.IsNullOrEmpty(sabnzbdService.GetVersion());
359 |             }
360 |             catch
361 |             {
362 |                 return false;
363 |             }
364 |         }
365 | 
366 |         private bool SaveToDisk()
367 |         {
368 |             string s = JsonSerializer.Serialize(appSettings, new JsonSerializerOptions()
369 |             {
370 |                 WriteIndented = true
371 |             });
372 | 
373 |             File.WriteAllText("appsettings.json", s);
374 | 
375 |             if (File.Exists("appsettings.json"))
376 |             {
377 |                 Console.WriteLine("Successfully written your settings to appsettings.json. Next start of pdbMate will run in autopilot mode with sabnzbd client.");
378 |             }
379 | 
380 |             return true;
381 |         }
382 |     }
383 | }
384 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/RenameService.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.Extensions.Logging;
  2 | using Microsoft.Extensions.Options;
  3 | using pdbMate.Core.Data;
  4 | using pdbMate.Core.Interfaces;
  5 | using System;
  6 | using System.Collections.Generic;
  7 | using System.IO;
  8 | using System.Linq;
  9 | using System.Text.RegularExpressions;
 10 | 
 11 | namespace pdbMate.Core
 12 | {
 13 |     public class RenameService : IRenameService
 14 |     {
 15 |         private readonly ILogger<IRenameService> logger;
 16 |         private readonly IPdbApiService pdbApi;
 17 |         private readonly IVideoQualityProdiver videoQualityProdiver;
 18 |         private readonly RenameServiceOptions renameServiceOptions;
 19 | 
 20 |         public RenameService(ILogger<IRenameService> logger, IPdbApiService pdbApi, IVideoQualityProdiver videoQualityProdiver, IOptions<RenameServiceOptions> renameServiceOptions)
 21 |         {
 22 |             this.logger = logger;
 23 |             this.pdbApi = pdbApi;
 24 |             this.videoQualityProdiver = videoQualityProdiver;
 25 |             this.renameServiceOptions = renameServiceOptions.Value;
 26 |         }
 27 | 
 28 |         public string GetTargetPath()
 29 |         {
 30 |             return renameServiceOptions.TargetFolder;
 31 |         }
 32 | 
 33 |         public List<SourceFile> GetFilesToProcess()
 34 |         {
 35 |             logger.LogInformation("Search for files in folders specified in appsettings.json:");
 36 |             List<string> files = new List<string>();
 37 |             foreach (var sourceFolder in renameServiceOptions.SourceFolders)
 38 |             {
 39 |                 
 40 |                 if (Directory.Exists(sourceFolder))
 41 |                 {
 42 |                     logger.LogInformation(sourceFolder);
 43 |                     files.AddRange(Directory.EnumerateFiles(sourceFolder, "*.*", SearchOption.AllDirectories).ToList());
 44 |                 }
 45 |                 else
 46 |                 {
 47 |                     logger.LogWarning("Folder does not exists: " + sourceFolder);
 48 |                 }
 49 |             }
 50 | 
 51 |             files = files.Where(file => !file.Contains("_UNPACK_")).ToList();
 52 | 
 53 |             return GetFileAttributes(files);
 54 |         }
 55 | 
 56 |         public List<string> GetEmptyDirectories()
 57 |         {
 58 |             logger.LogInformation("Search for empty directories in source folders specified in appsettings.json:");
 59 |             List<string> emptyDirectories = new List<string>();
 60 |             foreach (var sourceFolder in renameServiceOptions.SourceFolders)
 61 |             {
 62 |                 var folders = Directory.GetDirectories(sourceFolder);
 63 |                 foreach (var folder in folders)
 64 |                 {
 65 |                     if (Directory.Exists(folder) && !Directory.EnumerateFileSystemEntries(folder).Any())
 66 |                     {
 67 |                         emptyDirectories.Add(folder);
 68 |                     }
 69 |                 }
 70 | 
 71 |             }
 72 | 
 73 |             return emptyDirectories;
 74 |         }
 75 | 
 76 |         private List<SourceFile> GetFileAttributes(List<string> sourceFiles)
 77 |         {
 78 |             List<SourceFile> result = new List<SourceFile>();
 79 |             List<string> allowedExtension = new List<string>(){ ".mp4", ".mkv" };
 80 |             int minimumFilesizeInMegabyte = 150;
 81 | 
 82 |             foreach (var sourceFile in sourceFiles)
 83 |             {
 84 |                 if (!File.Exists(sourceFile))
 85 |                 {
 86 |                     continue;
 87 |                 }
 88 | 
 89 |                 var fi = new FileInfo(sourceFile);
 90 | 
 91 |                 var resultFile = new SourceFile()
 92 |                 {
 93 |                     Path = sourceFile,
 94 |                     Filename = Path.GetFileNameWithoutExtension(sourceFile),
 95 |                     Foldername = fi.Directory?.Name ?? "",
 96 |                     FileExtension = Path.GetExtension(sourceFile).ToLower(),
 97 |                     IsNoVideoExtension = false,
 98 |                     IsDuplicate = false,
 99 |                     IsToSmall = false
100 |                 };
101 | 
102 |                 if (!allowedExtension.Contains(resultFile.FileExtension))
103 |                 {
104 |                     resultFile.IsNoVideoExtension = true;
105 |                 }
106 | 
107 |                 if (fi.Length < (minimumFilesizeInMegabyte * 1000 * 1000))
108 |                 {
109 |                     resultFile.IsToSmall = true;
110 |                 }
111 | 
112 |                 result.Add(resultFile);
113 |             }
114 | 
115 |             return result;
116 |         }
117 | 
118 |         public List<RenamerResult> ProcessBatch(List<SourceFile> sourceFiles)
119 |         {
120 |             List<RenamerResult> resultList = ProcessFiles(sourceFiles);
121 |             foreach (var r in resultList)
122 |             {
123 |                 r.FileExtension = r.Source.FileExtension;
124 |                 if (r.Video != null)
125 |                 {
126 |                     r.Filename = ReplaceTemplatePlaceholders(renameServiceOptions.FilenameTemplate, r);
127 |                     r.Foldername = ReplaceTemplatePlaceholders(renameServiceOptions.FolderTemplate, r);
128 |                 }
129 |             }
130 | 
131 |             return resultList;
132 |         }
133 | 
134 |         public List<RenamerResult> ProcessFiles(List<SourceFile> sourceFiles)
135 |         {
136 |             List<RenamerResult> resultList = new List<RenamerResult>();
137 |             foreach (var sourceFile in sourceFiles)
138 |             {
139 |                 var v = new RenamerResult()
140 |                 {
141 |                     Source = sourceFile,
142 |                     Video = null,
143 |                     VideoQualityId = 0
144 |                 };
145 | 
146 |                 if (!sourceFile.IsNoVideoExtension && !sourceFile.IsToSmall)
147 |                 {
148 |                     var titleAndSite = GetRelevantTitleAndSite(sourceFile.Filename, sourceFile.Foldername);
149 |                     if (titleAndSite != null)
150 |                     {
151 |                         var title = titleAndSite.Item1;
152 |                         var site = titleAndSite.Item2;
153 | 
154 |                         logger.LogDebug($"Next GetVideoByFilename for {title} - Site: {site.Sitename}");
155 |                         Video video = GetVideoByFilename(title, site);
156 |                         logger.LogDebug($"Result GetVideoByFilename: {video?.Title ?? ""}");
157 |                         if (video != null)
158 |                         {
159 |                             v.Video = video;
160 |                             v.VideoQualityId = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(title))?.Id ?? 0;
161 |                         }
162 |                     }
163 |                 }
164 | 
165 |                 resultList.Add(v);
166 |             }
167 | 
168 |             return resultList;
169 |         }
170 | 
171 |         public List<KnownVideoQualityResult> GetKnownVideoQualityResults()
172 |         {
173 |             List<KnownVideoQualityResult> result = new List<KnownVideoQualityResult>();
174 |             string targetFolder = renameServiceOptions.TargetFolder;
175 |             if (!Directory.Exists(targetFolder))
176 |             {
177 |                 logger.LogError($"Target directory {targetFolder} does not exist.");
178 |                 return new List<KnownVideoQualityResult>();
179 |             }
180 | 
181 |             var files = Directory.EnumerateFiles(targetFolder, "*.*", SearchOption.AllDirectories).ToList();
182 |             foreach (var file in files)
183 |             {
184 |                 Match match = Regex.Match(file, @"P([0-9]{7})", RegexOptions.IgnoreCase);
185 | 
186 |                 if (match.Success)
187 |                 {
188 |                     string pdbIdString = match.Groups[1].Value;
189 |                     bool parsed = int.TryParse(pdbIdString, out var pdbId);
190 |                     if (parsed)
191 |                     {
192 |                         FileInfo fi = new FileInfo(file);
193 |                         result.Add(new KnownVideoQualityResult()
194 |                         {
195 |                             VideoId = pdbId,
196 |                             VideoQualityId = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(fi.Name))?.Id ?? 0
197 |                         });
198 |                     }
199 |                 }
200 |             }
201 | 
202 |             return result;
203 |         }
204 | 
205 |         public List<RenamerResult> CheckForDuplicates(List<RenamerResult> renamerResults, List<KnownVideoQualityResult> knownVideoQualityResults)
206 |         {
207 |             foreach (var renamerResult in renamerResults)
208 |             {
209 |                 if (renamerResult.Video != null && knownVideoQualityResults.Any(x => x.VideoId == renamerResult.Video.Id && x.VideoQualityId == renamerResult.VideoQualityId))
210 |                 {
211 |                     renamerResult.Source.IsDuplicate = true;
212 |                 }
213 |             }
214 | 
215 |             return renamerResults;
216 |         }
217 | 
218 |         public List<RenamerResult> CheckForDuplicatesInResults(List<RenamerResult> renamerResults)
219 |         {
220 |             List<KnownVideoQualityResult> knownVideoQualityResultsInResult = new List<KnownVideoQualityResult>();
221 |             foreach (var renamerResult in renamerResults)
222 |             {
223 |                 if (renamerResult.Video != null && knownVideoQualityResultsInResult.Any(x => x.VideoId == renamerResult.Video.Id && x.VideoQualityId == renamerResult.VideoQualityId))
224 |                 {
225 |                     renamerResult.Source.IsDuplicate = true;
226 |                 }
227 |                 else
228 |                 {
229 |                     if (renamerResult.Video != null)
230 |                     {
231 |                         knownVideoQualityResultsInResult.Add(new KnownVideoQualityResult() { VideoId = renamerResult.Video.Id, VideoQualityId = renamerResult.VideoQualityId });
232 |                     }
233 |                 }
234 |             }
235 | 
236 |             return renamerResults;
237 |         }
238 | 
239 |         private Tuple<string, Site> GetRelevantTitleAndSite(string filenameWithoutExtension, string directoryName)
240 |         {
241 |             var site = GetSiteByFirstword(filenameWithoutExtension, directoryName);
242 |             if (site == null)
243 |             {
244 |                 return null;
245 |             }
246 | 
247 |             bool firstWordInFolder = directoryName.ToLower().Contains(site.Sitename.ToLower());
248 |             string title = filenameWithoutExtension;
249 |             if (firstWordInFolder)
250 |             {
251 |                 title = directoryName;
252 |             }
253 | 
254 |             return new Tuple<string, Site>(title, site);
255 |         }
256 | 
257 |         private Video GetVideoByFilename(string title, Site site)
258 |         {
259 |             DateTime? releaseDate = StringExtractor.ExtractDate(title);
260 |             string episode = StringExtractor.ExtractEpisode(title);
261 | 
262 |             List<Video> videos = GetVideosBySiteWithCached(site);
263 | 
264 |             if (releaseDate != null)
265 |             {
266 |                 var foundMatchingVideos = videos.Where(x => x.Releasedate == releaseDate.Value).ToList();
267 |                 logger.LogDebug("Found videos (by ReleaseDate): " + foundMatchingVideos.Count + " Date: " + releaseDate.Value.ToString("yyyyMMdd"));
268 |                 if (!foundMatchingVideos.Any() || foundMatchingVideos.Count >= 6) return null;
269 |                 foreach (var foundMatchingVideo in foundMatchingVideos)
270 |                 {
271 |                     logger.LogDebug("Video: " + foundMatchingVideo.Title + " matching: " + title + " ?");
272 | 
273 |                     if (foundMatchingVideo.Title.Contains(" "))
274 |                     {
275 |                         string firstWord = foundMatchingVideo.Title.Substring(0,
276 |                             foundMatchingVideo.Title.IndexOf(" ", StringComparison.InvariantCulture));
277 |                         if (title.Contains(firstWord))
278 |                         {
279 |                             return foundMatchingVideo;
280 |                         }
281 |                     }
282 | 
283 |                     string foundTitle = foundMatchingVideo.Title.Replace(" ", ".").ToLower();
284 |                     string titleSimplified = title.ToLower().Replace(" ", ".");
285 | 
286 |                     if (titleSimplified.Contains(foundTitle))
287 |                     {
288 |                         return foundMatchingVideo;
289 |                     }
290 |                 }
291 | 
292 |                 return null;
293 |             }
294 | 
295 |             if (!string.IsNullOrEmpty(episode))
296 |             {
297 |                 var foundMatchingVideos = videos.Where(x => x.FullTitle.Contains("E" + episode)).ToList();
298 |                 logger.LogDebug("Found videos (by Episode): " + foundMatchingVideos.Count + " Episode: E" + episode);
299 |                 if (foundMatchingVideos.Any() && foundMatchingVideos.Count < 6)
300 |                 {
301 |                     foreach (var foundMatchingVideo in foundMatchingVideos)
302 |                     {
303 |                         var firstwordLength = foundMatchingVideo.Title.IndexOf(" ", StringComparison.InvariantCulture);
304 |                         if (firstwordLength > 0)
305 |                         {
306 |                             var firstWord = foundMatchingVideo.Title.Substring(0, firstwordLength);
307 |                             if (title.Contains(firstWord))
308 |                             {
309 |                                 return foundMatchingVideo;
310 |                             }
311 |                         }
312 |                     }
313 |                 }
314 |             }
315 | 
316 |             return null;
317 |         }
318 | 
319 |         private Site GetSiteByFirstword(string filenameWithoutExtension, string directoryName)
320 |         {
321 |             List<Site> sites = GetSites();
322 | 
323 |             List<string> separatorArray = new List<string> { ".", " ", "-"};
324 | 
325 |             Site foundSite = null;
326 |             foreach (var separator in separatorArray)
327 |             {
328 |                 var site = GetSiteByFilenameWithFirstWordSeparator(sites, separator, directoryName);
329 |                 if (site != null)
330 |                 {
331 |                     foundSite = site;
332 |                     break;
333 |                 }
334 |             }
335 | 
336 |             if (foundSite == null)
337 |             {
338 |                 foreach (var separator in separatorArray)
339 |                 {
340 |                     var site = GetSiteByFilenameWithFirstWordSeparator(sites, separator, filenameWithoutExtension);
341 |                     if (site != null)
342 |                     {
343 |                         foundSite = site;
344 |                         break;
345 |                     }
346 |                 }
347 |             }
348 | 
349 |             return foundSite;
350 |         }
351 | 
352 |         private Site GetSiteByFilenameWithFirstWordSeparator(List<Site> sites, string separator, string filenameWithoutExtension)
353 |         {
354 |             if (filenameWithoutExtension.Contains(separator))
355 |             {
356 |                 var firstWordBySeparator = filenameWithoutExtension.Substring(0, filenameWithoutExtension.IndexOf(separator, StringComparison.Ordinal));
357 |                 if (!string.IsNullOrWhiteSpace(firstWordBySeparator) && firstWordBySeparator.Length >= 3)
358 |                 {
359 |                     var siteFound = sites.FirstOrDefault(x => string.Equals(x.Sitename, firstWordBySeparator, StringComparison.CurrentCultureIgnoreCase));
360 |                     if (siteFound != null)
361 |                     {
362 |                         return siteFound;
363 |                     }
364 |                 }
365 |             }
366 | 
367 |             return null;
368 |         }
369 | 
370 |         private List<Site> GetSites()
371 |         {
372 |             return pdbApi.GetSites();
373 |         }
374 | 
375 |         private readonly Dictionary<int, List<Video>> cachedVideosBySite = new Dictionary<int, List<Video>>();
376 |         private List<Video> GetVideosBySiteWithCached(Site site)
377 |         {
378 |             if (cachedVideosBySite.ContainsKey(site.Id))
379 |             {
380 |                 return cachedVideosBySite[site.Id];
381 |             }
382 | 
383 |             List<Video> videos = pdbApi.GetVideosBySite(site);
384 |             cachedVideosBySite.Add(site.Id, videos);
385 |             return videos;
386 |         }
387 | 
388 |         public string ReplaceTemplatePlaceholders(string template, RenamerResult v)
389 |         {
390 |             string r = template;
391 |             r = r.Replace("{Video.Site.Sitename}", v.Video.Site.Sitename);
392 |             r = r.Replace("{Video.Site.Id}", v.Video.Site.Id.ToString());
393 |             r = r.Replace("{Video.Id}", v.Video.Id.ToString());
394 |             r = r.Replace("{Video.Title}", v.Video.Title);
395 |             r = r.Replace("{Video.Releasedate}", v.Video.Releasedate.ToString("yyyy-MM-dd"));
396 |             r = r.Replace("{Video.ReleasedateShort}", v.Video.Releasedate.ToString("yy-MM-dd"));
397 |             r = r.Replace("{VideoQuality.SimplifiedName}", videoQualityProdiver.GetById(v.VideoQualityId).SimplifiedName);
398 |             r = r.Replace("{VideoQuality.Name}", videoQualityProdiver.GetById(v.VideoQualityId).Name);
399 |             r = r.Replace("{FileExtension}", v.FileExtension);
400 |             r = r.Replace("{PdbId}", $"P{v.Video.Id:D7}");
401 |             r = r.Replace("{OriginalFilename}", v.Source.Filename);
402 | 
403 |             return r;
404 |         }
405 |     }
406 | }
407 | 


--------------------------------------------------------------------------------
/src/pdbMate.Core/UsenetDownloadService.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using Microsoft.Extensions.Logging;
  5 | using Microsoft.Extensions.Options;
  6 | using pdbMate.Core.Data;
  7 | using pdbMate.Core.Interfaces;
  8 | 
  9 | namespace pdbMate.Core
 10 | {
 11 |     public class UsenetDownloadService : IUsenetDownloadService
 12 |     {
 13 |         private readonly ILogger<IUsenetDownloadService> logger;
 14 |         private readonly UsenetDownloadServiceOptions options;
 15 |         private readonly IRenameService renameService;
 16 |         private readonly IPdbApiService pdbApiService;
 17 |         private readonly IVideoQualityProdiver videoQualityProdiver;
 18 |         private readonly ISabnzbdService sabnzbdService;
 19 |         private readonly INzbgetService nzbgetService;
 20 |         private readonly IVideoMatching videoMatching;
 21 | 
 22 |         public UsenetDownloadService(ILogger<IUsenetDownloadService> logger, IOptions<UsenetDownloadServiceOptions> options, 
 23 |             IRenameService renameService, IPdbApiService pdbApiService, IVideoQualityProdiver videoQualityProdiver,
 24 |             ISabnzbdService sabnzbdService, INzbgetService nzbgetService, IVideoMatching videoMatching)
 25 |         {
 26 |             this.logger = logger;
 27 |             this.options = options.Value;
 28 |             this.renameService = renameService;
 29 |             this.pdbApiService = pdbApiService;
 30 |             this.videoQualityProdiver = videoQualityProdiver;
 31 |             this.sabnzbdService = sabnzbdService;
 32 |             this.nzbgetService = nzbgetService;
 33 |             this.videoMatching = videoMatching;
 34 |         }
 35 | 
 36 |         public void Execute(bool dryRun, DownloadClient? overrideActiveClient, int? backFillingActors, int? backFillingSites, int daysBack)
 37 |         {
 38 |             var client = options.ActiveClient;
 39 |             if (overrideActiveClient != null)
 40 |             {
 41 |                 client = overrideActiveClient.GetValueOrDefault(DownloadClient.Sabnzbd);
 42 |             }
 43 | 
 44 |             PreFlightCheck(client);
 45 | 
 46 |             var resultList = new List<UsenetRelease>();
 47 |             var knownVideosOnDisk = renameService.GetKnownVideoQualityResults();
 48 | 
 49 |             if (backFillingActors != null || backFillingSites != null)
 50 |             {
 51 |                 if(backFillingActors != null)
 52 |                 {
 53 |                     var usenetReleases = GetBackfillingActors(backFillingActors.GetValueOrDefault(0), knownVideosOnDisk, daysBack);
 54 |                     if (usenetReleases != null)
 55 |                     {
 56 |                         logger.LogInformation($"A total of {usenetReleases.Count}  actor-related releases were found.");
 57 |                         resultList.AddRange(usenetReleases);
 58 |                     }
 59 |                 }
 60 | 
 61 |                 if (backFillingSites != null)
 62 |                 {
 63 |                     var usenetReleases = GetBackfillingSites(backFillingSites.GetValueOrDefault(0), knownVideosOnDisk, daysBack);
 64 |                     if (usenetReleases != null)
 65 |                     {
 66 |                         logger.LogInformation($"A total of {usenetReleases.Count}  site-related releases were found.");
 67 |                         resultList.AddRange(usenetReleases);
 68 |                     }
 69 |                 }
 70 |             }
 71 |             else
 72 |             {
 73 |                 var usenetReleases = GetLatestReleases();
 74 |                 if(usenetReleases != null)
 75 |                 {
 76 |                     resultList.AddRange(usenetReleases);
 77 |                 }
 78 |             }
 79 | 
 80 |             if (resultList == null || resultList.Count == 0)
 81 |             {
 82 |                 logger.LogError($"{resultList?.Count ?? -1} releases found. Exiting.");
 83 |                 return;
 84 |             }
 85 | 
 86 |             logger.LogInformation($"A total of {resultList.Count} releases were found.");
 87 | 
 88 |             if (options.KeepOnlyHighestQuality)
 89 |             {
 90 |                 resultList = KeepOnlyHighestQuality(resultList);
 91 |                 // TODO: remove releases that are knownVideosOnDisk with higher quality:
 92 | 
 93 |                 logger.LogInformation($"{resultList.Count} releases after Filter: keep only highest quality release.");
 94 |             }
 95 | 
 96 |             var excludeReleases = GetReleasesToExcludeFromDownloadClient(resultList, client);
 97 | 
 98 |             var excludeReleasesIds = excludeReleases.Select(x => x.Id);
 99 |             resultList.RemoveAll(x => excludeReleasesIds.Contains(x.Id));
100 |             logger.LogInformation($"{resultList.Count} releases after Filter: Exclude active downloads Downloads - exlcuded {excludeReleases.Count}.");
101 | 
102 |             resultList = RemoveDuplicates(resultList);
103 |             logger.LogInformation($"{resultList.Count} releases after Filter: remove duplicates.");
104 | 
105 |             logger.LogInformation($"-- List releases to add");
106 |             
107 | 
108 |             if (client.Equals(DownloadClient.Nzbget))
109 |             {
110 |                 foreach (var result in resultList)
111 |                 {
112 |                     logger.LogInformation($"Add {result.Title} to download list (Id: {result.Id}, Indexer: {result.Indexer}, PID: {result.Video}).");
113 |                     if (!dryRun)
114 |                     {
115 |                         var donwloadLink = GetDownloadLink(result);
116 |                         logger.LogInformation($"Add to nzbget: {donwloadLink}");
117 |                         nzbgetService.AddDownload(donwloadLink);
118 |                     }
119 |                 }
120 |             } 
121 |             else if (client.Equals(DownloadClient.Sabnzbd))
122 |             {
123 |                 foreach (var result in resultList)
124 |                 {
125 |                     logger.LogInformation($"Add {result.Title} to download list (Id: {result.Id}, Indexer: {result.Indexer}).");
126 |                     if (!dryRun)
127 |                     {
128 |                         var donwloadLink = GetDownloadLink(result);
129 |                         logger.LogInformation($"Add to sabnzbd: {donwloadLink}");
130 |                         sabnzbdService.AddDownload(donwloadLink);
131 |                     }
132 |                 }
133 |             }
134 |             else
135 |             {
136 |                 throw new NotImplementedException();
137 |             }
138 |             logger.LogInformation($"-----------------------");
139 |         }
140 | 
141 |         private List<UsenetRelease> GetLatestReleases()
142 |         {
143 |             var knownVideosOnDisk = renameService.GetKnownVideoQualityResults();
144 |             var favoriteSites = options.DownloadFavoriteSites ? pdbApiService.GetFavoriteSites() : null;
145 |             var favoriteActors = options.DownloadFavoriteActors ? pdbApiService.GetFavoriteActors() : null;
146 |             var releases = pdbApiService.GetReleases(1, 1000, 0, 0, "");
147 |             var myIndexers = pdbApiService.GetMyIndexer();
148 | 
149 |             if (releases == null || !releases.Any())
150 |             {
151 |                 logger.LogError("No releases found");
152 |                 return null;
153 |             }
154 | 
155 |             var resultList = new List<UsenetRelease>();
156 |             foreach (var release in releases)
157 |             {
158 |                 release.VideoQuality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(release.Title));
159 |                 bool matchActor = favoriteActors != null && options.DownloadFavoriteActors && favoriteActors.Any(x => x.Id == release.Actor1 || x.Id == release.Actor2);
160 |                 bool matchSite = favoriteSites != null && options.DownloadFavoriteSites && favoriteSites.Any(x => x.Id == release.Site);
161 | 
162 |                 if (myIndexers.Any(x => x.Id == release.Indexer) && (matchActor || matchSite) && !IsDuplicate(release, knownVideosOnDisk, resultList))
163 |                 {
164 |                     logger.LogDebug($"Add {release.Title} to resultlist.");
165 |                     resultList.Add(release);
166 |                 }
167 |             }
168 |             logger.LogInformation($"{resultList.Count} releases found.");
169 | 
170 |             return resultList;
171 |         }
172 | 
173 |         private List<UsenetRelease> GetBackfillingSites(int backFillingSites, List<KnownVideoQualityResult> knownVideosOnDisk, int daysBack)
174 |         {
175 |             var dateDaysBack = DateTime.Now.AddDays(-1 * daysBack);
176 |             var favoriteSites = new List<Site>();
177 | 
178 |             if (backFillingSites == 0)
179 |             {
180 |                 favoriteSites.AddRange(pdbApiService.GetFavoriteSites());
181 |             }
182 |             else
183 |             {
184 |                 favoriteSites.Add(new Site() { Id = backFillingSites });
185 |             }
186 | 
187 |             var resultList = new List<UsenetRelease>();
188 |             var myIndexers = pdbApiService.GetMyIndexer();
189 |             var myIndexersInts = myIndexers.Select(x => x.Id).ToList();
190 | 
191 |             foreach (var site in favoriteSites)
192 |             {
193 |                 var releases = pdbApiService.GetReleases(1, 5000, 0, site.Id, "");
194 | 
195 |                 if (releases == null || !releases.Any())
196 |                 {
197 |                     logger.LogError("No releases found");
198 |                     return null;
199 |                 }
200 | 
201 |                 var foundReleasess = releases.Where(x => x.Site == site.Id && myIndexersInts.Contains(x.Indexer) && x.Created >= dateDaysBack);
202 |                 foreach (var release in foundReleasess)
203 |                 {
204 |                     release.VideoQuality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(release.Title));
205 | 
206 |                     if (!IsDuplicate(release, knownVideosOnDisk, resultList))
207 |                     {
208 |                         logger.LogInformation($"Add {release.Title} to resultlist.");
209 |                         resultList.Add(release);
210 |                     }
211 |                 }
212 |                 logger.LogInformation($"{resultList.Count} releases added for site id: {site.Id}.");
213 |             }
214 | 
215 |             return resultList;
216 |         }
217 | 
218 |         private List<UsenetRelease> GetBackfillingActors(int backFillingActors, List<KnownVideoQualityResult> knownVideosOnDisk, int daysBack)
219 |         {
220 |             var dateDaysBack = DateTime.Now.AddDays(-1 * daysBack);
221 |             var favoriteActors = new List<Actor>();
222 | 
223 |             if(backFillingActors == 0)
224 |             {
225 |                 favoriteActors.AddRange(pdbApiService.GetFavoriteActors());
226 |             }
227 |             else
228 |             {
229 |                 favoriteActors.Add(new Actor() { Id = backFillingActors });
230 |             }
231 | 
232 |             var resultList = new List<UsenetRelease>();
233 |             var myIndexers = pdbApiService.GetMyIndexer();
234 |             var myIndexersInts = myIndexers.Select(x => x.Id).ToList();
235 | 
236 |             foreach (var actor in favoriteActors)
237 |             {
238 |                 var releases = pdbApiService.GetReleases(1, 5000, actor.Id, 0, "");
239 | 
240 |                 if (releases == null || !releases.Any())
241 |                 {
242 |                     logger.LogError("No releases found");
243 |                     continue;
244 |                 }
245 | 
246 |                 var foundReleasess = releases.Where(x => (x.Actor1 == actor.Id || x.Actor2 == actor.Id) && myIndexersInts.Contains(x.Indexer) && x.Created >= dateDaysBack);
247 |                 foreach (var release in foundReleasess)
248 |                 {
249 |                     release.VideoQuality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(release.Title));
250 | 
251 |                     if (!IsDuplicate(release, knownVideosOnDisk, resultList))
252 |                     {
253 |                         logger.LogDebug($"Add {release.Title} to resultlist.");
254 |                         resultList.Add(release);
255 |                     }
256 |                 }
257 |                 logger.LogInformation($"{resultList.Count} releases added for actor id: {actor.Id}.");
258 |             }
259 | 
260 |             return resultList;
261 |         }
262 | 
263 |         private void PreFlightCheck(DownloadClient client)
264 |         {
265 |             switch (client)
266 |             {
267 |                 case DownloadClient.Nzbget:
268 |                     nzbgetService.CheckConnection();
269 |                     break;
270 |                 case DownloadClient.Sabnzbd:
271 |                     sabnzbdService.CheckConnection();
272 |                     break;
273 |                 default:
274 |                     throw new ApplicationException($"Please specify a valid download client - given: {client} - expected: sabnzbd or nzbget");
275 |             }
276 |         }
277 | 
278 |         private string GetDownloadLink(UsenetRelease release)
279 |         {
280 |             string url = "";
281 |             var indexerId = release.Indexer;
282 |             var indexer = pdbApiService.GetMyIndexer().SingleOrDefault(x => x.Id == indexerId);
283 |             if (indexer != null)
284 |             {
285 |                 url = indexer.Downloadurl.Replace("[USERID]", indexer.Apiuserid).Replace("[GUID]", release.Guid)
286 |                     .Replace("[APIKEY]", indexer.Apikey);
287 |             }
288 | 
289 |             return url;
290 |         }
291 | 
292 |         private List<UsenetRelease> RemoveDuplicates(List<UsenetRelease> releases)
293 |         {
294 |             var groupByVideoId = releases.GroupBy(x => x.Video);
295 |             //Using Query Syntax
296 |             //IEnumerable<IGrouping<string, Student>> GroupByQS = (from std in Student.GetStudents()
297 |             //                                                     group std by std.Barnch);
298 |             //It will iterate through each groups
299 |             List<UsenetRelease> filteredList = new List<UsenetRelease>();
300 |             foreach (var videoIdGroup in groupByVideoId)
301 |             {
302 |                 var videoId = videoIdGroup.Key;
303 |                 var videoWithBestQuality = videoIdGroup.OrderByDescending(x => x.VideoQuality.BetterQualityOrdinal).FirstOrDefault();
304 |                 if(videoWithBestQuality != null)
305 |                 {
306 |                     filteredList.Add(videoWithBestQuality);
307 |                 }
308 |             }
309 | 
310 |             return filteredList;
311 |             /*
312 |             var result = new List<UsenetRelease>();
313 |             var known = new List<KnownVideoQualityResult>();
314 |             foreach (var r in releases)
315 |             {
316 |                 if (known.Any(x => x.VideoId == r.Video && x.VideoQualityId == r.VideoQuality.Id))
317 |                 {
318 |                     continue;
319 |                 }
320 | 
321 |                 known.Add(new KnownVideoQualityResult()
322 |                 {
323 |                     VideoId = r.Video,
324 |                     VideoQualityId = r.VideoQuality.Id
325 |                 });
326 |                 result.Add(r);
327 |             }
328 |             
329 |             return result;*/
330 |         }
331 | 
332 |         private List<UsenetRelease> GetReleasesToExcludeFromDownloadClient(List<UsenetRelease> resultList, DownloadClient client)
333 |         {
334 |             var excludeReleases = new List<UsenetRelease>();
335 |             if (client.Equals(DownloadClient.Nzbget))
336 |             {
337 |                 var usenetReleases = GetReleasesToExcludeFromNzbget(resultList);
338 |                 if (usenetReleases != null)
339 |                 {
340 |                     excludeReleases.AddRange(usenetReleases);
341 |                 }
342 |             }
343 |             if (client.Equals(DownloadClient.Sabnzbd))
344 |             {
345 |                 var usenetReleases = GetReleasesToExcludeFromSabnzbd(resultList);
346 |                 if(usenetReleases != null)
347 |                 {
348 |                     excludeReleases.AddRange(usenetReleases);
349 |                 }
350 |             }
351 |             return excludeReleases;
352 |         }
353 | 
354 |         private List<UsenetRelease> GetReleasesToExcludeFromSabnzbd(List<UsenetRelease> releases)
355 |         {
356 |             // All releases found in queue must be excluded from releases list
357 |             List<UsenetRelease> excludeReleases = new List<UsenetRelease>();
358 | 
359 |             var slots = sabnzbdService.GetQueue(0, 1000).Slots;
360 |             foreach (var slot in slots)
361 |             {
362 |                 var videoFound = videoMatching.GetVideoByName(slot.Filename);
363 |                 if (videoFound != null)
364 |                 {
365 |                     var quality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(slot.Filename));
366 | 
367 |                     var releasesFound = releases
368 |                         .Where(x => x.Video == videoFound.Id && x.VideoQuality.Id == quality.Id).ToList();
369 |                     if (releasesFound != null && releasesFound.Any())
370 |                     {
371 |                         excludeReleases.AddRange(releasesFound);
372 |                     }
373 |                 }
374 |             }
375 | 
376 |             var slotsHistory = sabnzbdService.GetHistory(0, 1000).Slots;
377 |             foreach (var slot in slotsHistory)
378 |             {
379 |                 var videoFound = videoMatching.GetVideoByName(slot.Name);
380 |                 if (videoFound != null)
381 |                 {
382 |                     var quality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(slot.Name));
383 | 
384 |                     var releasesFound = releases
385 |                         .Where(x => x.Video == videoFound.Id && x.VideoQuality.Id == quality.Id).ToList();
386 |                     if (releasesFound != null && releasesFound.Any())
387 |                     {
388 |                         excludeReleases.AddRange(releasesFound);
389 |                     }
390 |                 }
391 |             }
392 | 
393 |             return excludeReleases;
394 |         }
395 | 
396 |         private List<UsenetRelease> GetReleasesToExcludeFromNzbget(List<UsenetRelease> releases)
397 |         {
398 |             // All releases found in queue must be excluded from releases list
399 |             List<UsenetRelease> excludeReleases = new List<UsenetRelease>();
400 | 
401 |             var queueEntries = nzbgetService.GetQueue();
402 |             if (queueEntries == null || queueEntries.Count == 0)
403 |             {
404 |                 return excludeReleases;
405 |             }
406 | 
407 |             foreach (var queueEntry in queueEntries)
408 |             {
409 |                 var videoFound = videoMatching.GetVideoByName(queueEntry.NzbName);
410 |                 if (videoFound != null)
411 |                 {
412 |                     var quality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(queueEntry.NzbName));
413 |                     if (quality == null)
414 |                     {
415 |                         logger.LogError("Quality not found for queue entry {nzbname}.", queueEntry.NzbName);
416 |                         continue;
417 |                     }
418 | 
419 |                     var releasesFound = releases
420 |                         .Where(x => x.Video == videoFound.Id && x.VideoQuality.Id == quality.Id).ToList();
421 |                     if (releasesFound != null && releasesFound.Any())
422 |                     {
423 |                         excludeReleases.AddRange(releasesFound);
424 |                     }
425 |                 }
426 |             }
427 | 
428 |             var historyEntries = nzbgetService.GetHistory();
429 |             if (historyEntries == null || historyEntries.Count == 0)
430 |             {
431 |                 return excludeReleases;
432 |             }
433 | 
434 |             foreach (var historyEntry in historyEntries)
435 |             {
436 |                 var videoFound = videoMatching.GetVideoByName(historyEntry.NzbName);
437 |                 if (videoFound != null)
438 |                 {
439 |                     var quality = videoQualityProdiver.GetByName(StringExtractor.ExtractQuality(historyEntry.NzbName));
440 |                     if(quality == null)
441 |                     {
442 |                         logger.LogError("Quality not found for history entry {nzbname}.", historyEntry.NzbName);
443 |                         continue;
444 |                     }
445 | 
446 |                     var releasesFound = releases
447 |                         .Where(x => x.Video == videoFound.Id && x.VideoQuality.Id == quality.Id).ToList();
448 |                     if (releasesFound != null && releasesFound.Any())
449 |                     {
450 |                         excludeReleases.AddRange(releasesFound);
451 |                     }
452 |                 }
453 |             }
454 | 
455 |             return excludeReleases;
456 |         }
457 | 
458 |         private bool IsQualityAllowed(UsenetRelease release)
459 |         {
460 |             if (release.VideoQuality == null)
461 |             {
462 |                 return false; // releases without quality information will be ignored
463 |             }
464 | 
465 |             if (!options.AllowedQualities.Contains(release.VideoQuality.SimplifiedName))
466 |             {
467 |                 return false; // quality not allowed
468 |             }
469 | 
470 |             return true;
471 |         }
472 | 
473 |         private bool IsDuplicate(UsenetRelease release, List<KnownVideoQualityResult> knownVideosOnDisk, List<UsenetRelease> releasesAlreadyInList)
474 |         {
475 |             if (!IsQualityAllowed(release))
476 |             {
477 |                 return true; // handle as duplicate if quality is not allowed.
478 |             }
479 | 
480 |             if (knownVideosOnDisk.Any(x => x.VideoId == release.Video && x.VideoQualityId == release.VideoQuality.Id))
481 |             {
482 |                 return true; // release in exactly the quality is on disk
483 |             }
484 | 
485 |             if(releasesAlreadyInList.Any(x => x.Video == release.Video && x.VideoQuality.Id == release.VideoQuality.Id))
486 |             {
487 |                 return true;
488 |             }
489 | 
490 |             if (options.KeepOnlyHighestQuality)
491 |             {
492 |                 var betterQualities = GetBetterQualitiesThan(release.VideoQuality.Id);
493 |                 if (betterQualities != null && betterQualities.Any() && 
494 |                     knownVideosOnDisk.Any(x => x.VideoId == release.Video && betterQualities.Contains(x.VideoQualityId)) &&
495 |                     releasesAlreadyInList.Any(x => x.Video == release.Video && betterQualities.Contains(x.VideoQuality.Id))
496 |                     )
497 |                 {
498 |                     return true; // release in a higher quality is on disk or in list
499 |                 }
500 |             }
501 | 
502 |             return false;
503 |         }
504 | 
505 |         private List<int> GetBetterQualitiesThan(int videoQualityId)
506 |         {
507 |             var videoQualities = pdbApiService.GetAllVideoQuality();
508 |             var betterThanThis = videoQualities.Single(x => x.Id == videoQualityId);
509 |             var betterQualities =
510 |                 videoQualities.Where(x => x.BetterQualityOrdinal > betterThanThis.BetterQualityOrdinal);
511 |             return betterQualities.Select(x => x.Id).ToList();
512 | 
513 |         }
514 | 
515 |         private List<UsenetRelease> KeepOnlyHighestQuality(List<UsenetRelease> releases)
516 |         {
517 |             var highestQualities = GetHighestQualities(releases);
518 | 
519 |             List<UsenetRelease> filteredReleases = new List<UsenetRelease>();
520 |             foreach (var release in releases)
521 |             {
522 |                 var releaseFoundInMultiQualityRelease = highestQualities.SingleOrDefault(x => x.VideoId == release.Id);
523 |                 if (releaseFoundInMultiQualityRelease != null)
524 |                 {
525 |                     if (release.VideoQuality.Id == releaseFoundInMultiQualityRelease.VideoQualityId)
526 |                     {
527 |                         filteredReleases.Add(release); // multiple releases found, but this is the highest quality
528 |                     }
529 |                 }
530 |                 else
531 |                 {
532 |                     filteredReleases.Add(release); // only one release available
533 |                 }
534 |             }
535 | 
536 |             return filteredReleases;
537 |         }
538 | 
539 |         private List<KnownVideoQualityResult> GetHighestQualities(List<UsenetRelease> releases)
540 |         {
541 |             List<KnownVideoQualityResult> bestQualities = new List<KnownVideoQualityResult>();
542 |             var releasesWithMultipleQualities = releases.GroupBy(x => x.Video).Where(grp => grp.Count() > 1);
543 |             foreach (var group in releasesWithMultipleQualities)
544 |             {
545 |                 var bestQualityRelease = group.OrderBy(x => x.VideoQuality.BetterQualityOrdinal).FirstOrDefault();
546 |                 if (bestQualityRelease != null)
547 |                 {
548 |                     bestQualities.Add(new KnownVideoQualityResult()
549 |                     {
550 |                         VideoId = bestQualityRelease.Video,
551 |                         VideoQualityId = bestQualityRelease.VideoQuality.Id
552 |                     });
553 |                 }
554 |             }
555 | 
556 |             return bestQualities;
557 |         }
558 |     }
559 | }
560 | 


--------------------------------------------------------------------------------