public TrackController(ITrackService trackService, ILogger <TrackController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
TrackService = trackService;
}
public ImageSearchEngineBase(IRoadieSettings configuration, ILogger logger, string baseUrl,
string requestIp = null, string referrer = null)
{
_configuratio = configuration;
if (string.IsNullOrEmpty(referrer) || referrer.StartsWith("http://localhost"))
{
referrer = "http://github.com/sphildreth/Roadie";
}
_referrer = referrer;
if (string.IsNullOrEmpty(requestIp) || requestIp == "::1")
{
requestIp = "192.30.252.128";
}
_requestIp = requestIp;
_logger = logger;
_client = new RestClient(baseUrl)
{
UserAgent = WebHelper.UserAgent
};
ServicePointManager.ServerCertificateValidationCallback += delegate
{
return(true); // **** Always accept
};
}
public ReleaseController(IReleaseService releaseService, ILogger <ReleaseController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
ReleaseService = releaseService;
}
public static IRoadieDbContext Create(IRoadieSettings configuration)
{
switch (configuration.DbContextToUse)
{
case DbContexts.SQLite:
var sqlLiteOptionsBuilder = new DbContextOptionsBuilder <SQLiteRoadieDbContext>();
var databaseName = Path.Combine(configuration.FileDatabaseOptions.DatabaseFolder, $"{ configuration.FileDatabaseOptions.DatabaseName }.db");
sqlLiteOptionsBuilder.UseSqlite($"Filename={databaseName}");
return(new SQLiteRoadieDbContext(sqlLiteOptionsBuilder.Options));
case DbContexts.File:
var fileOptionsBuilder = new DbContextOptionsBuilder <MySQLRoadieDbContext>();
fileOptionsBuilder.UseFileContextDatabase(configuration.FileDatabaseOptions.DatabaseFormat.ToString().ToLower(),
databaseName: configuration.FileDatabaseOptions.DatabaseName,
location: configuration.FileDatabaseOptions.DatabaseFolder);
return(new FileRoadieDbContext(fileOptionsBuilder.Options));
case DbContexts.MySQL:
var mysqlOptionsBuilder = new DbContextOptionsBuilder <MySQLRoadieDbContext>();
mysqlOptionsBuilder.UseMySql(configuration.ConnectionString, mySqlOptions =>
{
mySqlOptions.EnableRetryOnFailure(
10,
TimeSpan.FromSeconds(30),
null);
});
return(new MySQLRoadieDbContext(mysqlOptionsBuilder.Options));
default:
throw new NotImplementedException("Unknown DbContext Type");
}
}
public BookmarkController(IBookmarkService bookmarkService, ILogger <BookmarkController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
BookmarkService = bookmarkService;
}
public EntityControllerBase(ICacheManager cacheManager, IRoadieSettings roadieSettings,
UserManager <User> userManager)
{
CacheManager = cacheManager;
RoadieSettings = roadieSettings;
UserManager = userManager;
}
public PlaylistController(IPlaylistService playlistService, ILogger <PlaylistController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
PlaylistService = playlistService;
}
public ImageController(IImageService imageService, ILogger <ImageController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
ImageService = imageService;
}
public AdminController(IAdminService adminService, ILogger <AdminController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
AdminService = adminService;
}
public BookmarkController(IBookmarkService bookmarkService, ILoggerFactory logger, ICacheManager cacheManager,
UserManager <ApplicationUser> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
this.Logger = logger.CreateLogger("RoadieApi.Controllers.BookmarkController");
this.BookmarkService = bookmarkService;
}
public static string CleanString(this string input, IRoadieSettings settings, string removeStringsRegex = null)
{
if (string.IsNullOrEmpty(input) || settings == null)
{
return(input);
}
var result = input;
foreach (var kvp in settings.Processing.ReplaceStrings.OrderBy(x => x.Order).ThenBy(x => x.Key))
{
result = result.Replace(kvp.Key, kvp.ReplaceWith, StringComparison.OrdinalIgnoreCase);
}
result = result.Trim().ToTitleCase(false);
var rs = removeStringsRegex ?? settings.Processing.RemoveStringsRegex;
if (!string.IsNullOrEmpty(rs))
{
result = Regex.Replace(result, rs, "", RegexOptions.IgnoreCase);
}
if (result.Length > 5)
{
var extensionStart = result.Substring(result.Length - 5, 2);
if (extensionStart == "_." || extensionStart == " .")
{
var inputSb = new StringBuilder(result);
inputSb.Remove(result.Length - 5, 2);
inputSb.Insert(result.Length - 5, ".");
result = inputSb.ToString();
}
}
// Strip out any more than single space and remove any blanks before and after
return(Regex.Replace(result, @"\s+", " ").Trim());
}
public PlayActivityController(IPlayActivityService playActivityService, ILoggerFactory logger, ICacheManager cacheManager,
UserManager <ApplicationUser> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
this.Logger = logger.CreateLogger("RoadieApi.Controllers.PlayActivityController");
this.PlayActivityService = playActivityService;
}
public ArtistController(IArtistService artistService, ILogger <ArtistController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
ArtistService = artistService;
}
public CommentController(ILoggerFactory logger, ICacheManager cacheManager, UserManager <ApplicationUser> userManager,
IRoadieSettings roadieSettings, ICommentService commentService)
: base(cacheManager, roadieSettings, userManager)
{
this.Logger = logger.CreateLogger("RoadieApi.Controllers.CommentController");
this.CommentService = commentService;
}
public AdminService(IRoadieSettings configuration,
IHttpEncoder httpEncoder,
IHttpContext httpContext,
data.IRoadieDbContext context,
ICacheManager cacheManager,
ILogger <ArtistService> logger,
IHubContext <ScanActivityHub> scanActivityHub
)
: base(configuration, httpEncoder, context, cacheManager, logger, httpContext)
{
this.ScanActivityHub = scanActivityHub;
this.EventMessageLogger = new EventMessageLogger();
this.EventMessageLogger.Messages += EventMessageLogger_Messages;
this.MusicBrainzProvider = new MusicBrainzProvider(configuration, cacheManager, MessageLogger);
this.LastFmHelper = new LastFmHelper(configuration, cacheManager, MessageLogger);
this.FileNameHelper = new FileNameHelper(configuration, cacheManager, MessageLogger);
this.ID3TagsHelper = new ID3TagsHelper(configuration, cacheManager, MessageLogger);
this.ArtistLookupEngine = new ArtistLookupEngine(configuration, httpEncoder, context, cacheManager, MessageLogger);
this.LabelLookupEngine = new LabelLookupEngine(configuration, httpEncoder, context, cacheManager, MessageLogger);
this.ReleaseLookupEngine = new ReleaseLookupEngine(configuration, httpEncoder, context, cacheManager, MessageLogger, this.ArtistLookupEngine, this.LabelLookupEngine);
this.ImageFactory = new ImageFactory(configuration, httpEncoder, context, cacheManager, MessageLogger, this.ArtistLookupEngine, this.ReleaseLookupEngine);
this.LabelFactory = new LabelFactory(configuration, httpEncoder, context, cacheManager, MessageLogger, this.ArtistLookupEngine, this.ReleaseLookupEngine);
this.AudioMetaDataHelper = new AudioMetaDataHelper(configuration, httpEncoder, context, this.MusicBrainzProvider, this.LastFmHelper, cacheManager,
MessageLogger, this.ArtistLookupEngine, this.ImageFactory, this.FileNameHelper, this.ID3TagsHelper);
this.ReleaseFactory = new ReleaseFactory(configuration, httpEncoder, context, cacheManager, MessageLogger, this.ArtistLookupEngine, this.LabelFactory, this.AudioMetaDataHelper, this.ReleaseLookupEngine);
this.ArtistFactory = new ArtistFactory(configuration, httpEncoder, context, cacheManager, MessageLogger, this.ArtistLookupEngine, this.ReleaseFactory, this.ImageFactory, this.ReleaseLookupEngine, this.AudioMetaDataHelper);
}
public ImageSearchEngineBase(IRoadieSettings configuration, ILogger logger, string baseUrl, string requestIp = null, string referrer = null)
{
this._configuratio = configuration;
if (string.IsNullOrEmpty(referrer) || referrer.StartsWith("http://localhost"))
{
referrer = "http://github.com/sphildreth/Roadie";
}
this._referrer = referrer;
if (string.IsNullOrEmpty(requestIp) || requestIp == "::1")
{
requestIp = "192.30.252.128";
}
this._requestIp = requestIp;
this._logger = logger;
this._client = new RestClient(baseUrl)
{
UserAgent = WebHelper.UserAgent
};
System.Net.ServicePointManager.ServerCertificateValidationCallback += delegate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate,
System.Security.Cryptography.X509Certificates.X509Chain chain,
System.Net.Security.SslPolicyErrors sslPolicyErrors)
{
return(true); // **** Always accept
};
}
public StatsController(IStatisticsService statisticsService, ILoggerFactory logger, ICacheManager cacheManager,
UserManager <ApplicationUser> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
this.Logger = logger.CreateLogger("RoadieApi.Controllers.StatsController");
this.StatisticsService = statisticsService;
}
public Audio(IRoadieSettings configuration, IHttpEncoder httpEncoder, ICacheManager cacheManager,
ILogger logger, IArtistLookupEngine artistLookupEngine, IReleaseLookupEngine releaseLookupEngine,
IAudioMetaDataHelper audioMetaDataHelper)
: base(configuration, httpEncoder, cacheManager, logger, artistLookupEngine, releaseLookupEngine)
{
AudioMetaDataHelper = audioMetaDataHelper;
}
public GenreController(IGenreService genreService, ILogger <GenreController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
GenreService = genreService;
}
/// <summary>
/// Get image data from all sources for either fileanme or MetaData
/// </summary>
/// <param name="filename">Name of the File (ie a CUE file)</param>
/// <param name="metaData">Populated MetaData</param>
/// <returns></returns>
public static AudioMetaDataImage GetPictureForMetaData(IRoadieSettings configuration, string filename, AudioMetaData metaData)
{
SimpleContract.Requires <ArgumentException>(!string.IsNullOrEmpty(filename), "Invalid Filename");
SimpleContract.Requires <ArgumentException>(metaData != null, "Invalid MetaData");
return(ImageForFilename(configuration, filename));
}
public StatsController(IStatisticsService statisticsService, ILogger <StatsController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
StatisticsService = statisticsService;
}
public GenreController(IGenreService genreService, ILoggerFactory logger, ICacheManager cacheManager,
UserManager <ApplicationUser> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
this.Logger = logger.CreateLogger("RoadieApi.Controllers.GenreController");
this.GenreService = genreService;
}
public LabelController(ILabelService labelService, ILogger <LabelController> logger, ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
LabelService = labelService;
}
/// <summary>
/// Full path to Artist folder
/// </summary>
/// <param name="artistSortName">Sort name of Artist to use for folder name</param>
public static string ArtistPath(IRoadieSettings configuration, int artistId, string artistSortName, bool createIfNotFound = false)
{
SimpleContract.Requires <ArgumentException>(!string.IsNullOrEmpty(artistSortName), "Invalid Artist Sort Name");
SimpleContract.Requires <ArgumentException>(configuration.LibraryFolder.Length < MaximumLibraryFolderNameLength, $"Library Folder maximum length is [{ MaximumLibraryFolderNameLength }]");
var asn = new StringBuilder(artistSortName);
foreach (var stringReplacement in FolderSpaceReplacements)
{
if (!asn.Equals(stringReplacement))
{
asn.Replace(stringReplacement, " ");
}
}
var artistFolder = asn.ToString().ToAlphanumericName(false, false).ToFolderNameFriendly().ToTitleCase(false);
if (string.IsNullOrEmpty(artistFolder))
{
throw new Exception($"ArtistFolder [{ artistFolder }] is invalid. ArtistId [{ artistId }], ArtistSortName [{ artistSortName }].");
}
var afUpper = artistFolder.ToUpper();
var fnSubPart1 = afUpper.ToUpper().ToCharArray().Take(1).First();
if (!char.IsLetterOrDigit(fnSubPart1))
{
fnSubPart1 = '#';
}
else if (char.IsNumber(fnSubPart1))
{
fnSubPart1 = '0';
}
var fnSubPart2 = afUpper.Length > 2 ? afUpper.Substring(0, 2) : afUpper;
if (fnSubPart2.EndsWith(" "))
{
var pos = 1;
while (fnSubPart2.EndsWith(" "))
{
pos++;
fnSubPart2 = fnSubPart2.Substring(0, 1) + afUpper.Substring(pos, 1);
}
}
var fnSubPart = Path.Combine(fnSubPart1.ToString(), fnSubPart2);
var fnIdPart = $" [{ artistId }]";
var maxFnLength = (MaximumArtistFolderNameLength - (fnSubPart.Length + fnIdPart.Length)) - 2;
if (artistFolder.Length > maxFnLength)
{
artistFolder = artistFolder.Substring(0, maxFnLength);
}
artistFolder = Path.Combine(fnSubPart, $"{ artistFolder }{ fnIdPart }");
var directoryInfo = new DirectoryInfo(Path.Combine(configuration.LibraryFolder, artistFolder));
if (createIfNotFound && !directoryInfo.Exists)
{
directoryInfo.Create();
}
return(directoryInfo.FullName);
}
public PluginBase(IRoadieSettings configuration, ICacheManager cacheManager, ILogger logger, IID3TagsHelper tagsHelper)
{
this.Configuration = configuration;
this.CacheManager = cacheManager;
this.Logger = logger;
this.TagsHelper = tagsHelper;
CachedAudioDatas = new Dictionary <string, IEnumerable <AudioMetaData> >();
}
public PlayActivityService(IRoadieSettings configuration, IHttpEncoder httpEncoder, IHttpContext httpContext,
IRoadieDbContext dbContext, ICacheManager cacheManager, ILogger <PlayActivityService> logger,
IScrobbleHandler scrobbleHandler, IHubContext <PlayActivityHub> playActivityHub)
: base(configuration, httpEncoder, dbContext, cacheManager, logger, httpContext)
{
PlayActivityHub = playActivityHub;
ScrobblerHandler = scrobbleHandler;
}
public CollectionController(ICollectionService collectionService, ILogger <CollectionController> logger,
ICacheManager cacheManager,
UserManager <User> userManager, IRoadieSettings roadieSettings)
: base(cacheManager, roadieSettings, userManager)
{
Logger = logger;
CollectionService = collectionService;
}
public LookupEngineBase(IRoadieSettings configuration, IHttpEncoder httpEncoder, IRoadieDbContext context, ICacheManager cacheManager, ILogger logger)
{
this.Configuration = configuration;
this.HttpEncoder = httpEncoder;
this.DbContext = context;
this.CacheManager = cacheManager;
this.Logger = logger;
}
public ArtistFactory(IRoadieSettings configuration, IHttpEncoder httpEncoder, IRoadieDbContext context,
ICacheManager cacheManager, ILogger logger, IArtistLookupEngine artistLookupEngine, IReleaseFactory releaseFactory, IImageFactory imageFactory, IReleaseLookupEngine releaseLookupEngine, IAudioMetaDataHelper audioMetaDataHelper)
: base(configuration, context, cacheManager, logger, httpEncoder, artistLookupEngine, releaseLookupEngine)
{
this.ReleaseFactory = releaseFactory;
this.ImageFactory = imageFactory;
this.AudioMetaDataHelper = audioMetaDataHelper;
}
/// <summary>
/// Returns the Full path (FQDN) for given Track details
/// </summary>
/// <param name="metaData">Populated Track MetaData</param>
/// <param name="destinationFolder">Optional Root folder defaults to Library Folder from Settings</param>
/// <param name="artistFolder">Optional ArtistFolder default is to get from MetaData artist</param>
public static string TrackFullPath(IRoadieSettings configuration, AudioMetaData metaData, string destinationFolder = null, string artistFolder = null, string releaseFolder = null)
{
return(FolderPathHelper.TrackFullPath(configuration, metaData.Artist, metaData.Release, SafeParser.ToDateTime(metaData.Year).Value,
metaData.Title, metaData.TrackNumber ?? 0, destinationFolder, metaData.Disc ?? 0,
metaData.TotalTrackNumbers ?? 0,
artistFolder: artistFolder,
releaseFolder: releaseFolder));
}
