// GET: Artists
public IActionResult Index()
{
List <Artist> artists = artistService.GetAllArtists();
if (!artists.Any())
{
return(NotFound());
}
return(View(artists));
}
// GET: /Admin/Album/Create
public ActionResult Create()
{
var model = new CreateAlbumViewModel
{
GenreLookupList = _genreService.GetAllGenres().Genres.OrderBy(g => g.Name),
ArtistLookupList = _artistService.GetAllArtists().Artists.OrderBy(a => a.Name)
};
return(View(model));
}
public override HealthCheck Check()
{
var missingRootFolders = _artistService.GetAllArtists()
.Select(s => _diskProvider.GetParentFolder(s.Path))
.Distinct()
.Where(s => !_diskProvider.FolderExists(s))
.ToList();
missingRootFolders.AddRange(_importListFactory.All()
.Select(s => s.RootFolderPath)
.Distinct()
.Where(s => !_diskProvider.FolderExists(s))
.ToList());
missingRootFolders = missingRootFolders.Distinct().ToList();
if (missingRootFolders.Any())
{
if (missingRootFolders.Count == 1)
{
return(new HealthCheck(GetType(), HealthCheckResult.Error, "Missing root folder: " + missingRootFolders.First(), "#missing-root-folder"));
}
var message = string.Format("Multiple root folders are missing: {0}", string.Join(" | ", missingRootFolders));
return(new HealthCheck(GetType(), HealthCheckResult.Error, message, "#missing-root-folder"));
}
return(new HealthCheck(GetType()));
}
private IEnumerable <string> GetArtistRootPaths()
{
return(_artistService.GetAllArtists()
.Where(s => _diskProvider.FolderExists(s.Path))
.Select(s => _diskProvider.GetPathRoot(s.Path))
.Distinct());
}
public IActionResult Create()
{
var model = new CreateEventViewModel();
List <Artist> artists = artistService.GetAllArtists();
List <EventType> eventTypes = eventTypeService.GetAllTypes();
List <EventSubType> eventSubTypes = eventSubTypeService.GetAllSubTypes();
List <Location> locations = locationService.GetAllLocations();
model.Artists = artists;
model.EventSubTypes = eventSubTypes;
model.EventTypes = eventTypes;
model.Locations = locations;
model.Event = new Event();
return(View(model));
}
public IActionResult BrowseArtists(string searchString)
{
var artists = _artistService.GetAllArtists(searchString: searchString);
var artistsVM = artists.Select(x => _mapper.Map <ArtistVM>(x)).ToList();
return(View(artistsVM));
}
public void HandleAsync(ArtistDeletedEvent message)
{
if (message.DeleteFiles)
{
var artist = message.Artist;
var allArtists = _artistService.GetAllArtists();
foreach (var s in allArtists)
{
if (s.Id == artist.Id)
{
continue;
}
if (artist.Path.IsParentPath(s.Path))
{
_logger.Error("Artist path: '{0}' is a parent of another artist, not deleting files.", artist.Path);
return;
}
if (artist.Path.PathEquals(s.Path))
{
_logger.Error("Artist path: '{0}' is the same as another artist, not deleting files.", artist.Path);
return;
}
}
if (_diskProvider.FolderExists(message.Artist.Path))
{
_recycleBinProvider.DeleteFolder(message.Artist.Path);
}
}
}
public List <TagDetails> Details()
{
var tags = All();
var delayProfiles = _delayProfileService.All();
var importLists = _importListFactory.All();
var notifications = _notificationFactory.All();
var restrictions = _releaseProfileService.All();
var artists = _artistService.GetAllArtists();
var details = new List <TagDetails>();
foreach (var tag in tags)
{
details.Add(new TagDetails
{
Id = tag.Id,
Label = tag.Label,
DelayProfileIds = delayProfiles.Where(c => c.Tags.Contains(tag.Id)).Select(c => c.Id).ToList(),
ImportListIds = importLists.Where(c => c.Tags.Contains(tag.Id)).Select(c => c.Id).ToList(),
NotificationIds = notifications.Where(c => c.Tags.Contains(tag.Id)).Select(c => c.Id).ToList(),
RestrictionIds = restrictions.Where(c => c.Tags.Contains(tag.Id)).Select(c => c.Id).ToList(),
ArtistIds = artists.Where(c => c.Tags.Contains(tag.Id)).Select(c => c.Id).ToList()
}
);
}
return(details);
}
public IActionResult Artists(string filter = null)
{
ListArtistViewModel model = new ListArtistViewModel();
model.artists = _mapper.Map <List <ArtistModel> >(_artistService.GetAllArtists());
return(View(model));
}
public async Task <ActionResult <IEnumerable <ArtistResource> > > GetAllArtists()
{
var artists = await _artistService.GetAllArtists();
var artistResources = _mapper.Map <IEnumerable <Artist>, IEnumerable <ArtistResource> >(artists);
return(Ok(artistResources));
}
public async Task <IActionResult> Get()
{
var artists = await _artistService.GetAllArtists();
var artistsViewModels = artists.Select(x => x.ToViewModel());
return(Ok(artists));
}
public IActionResult AddSongToAlbum(int id)
{
AddSongToAlbumViewModel model = new AddSongToAlbumViewModel();
model.album = _mapper.Map <AlbumModel>(_albumService.GetAlbum(id));
model.artists = _mapper.Map <List <ArtistModel> >(_artistService.GetAllArtists());
return(View(model));
}
protected override bool IsValid(PropertyValidatorContext context)
{
if (context.PropertyValue == null)
{
return(true);
}
return(!_artistService.GetAllArtists().Any(s => context.PropertyValue.ToString().IsParentPath(s.Path)));
}
protected override bool IsValid(PropertyValidatorContext context)
{
if (context.PropertyValue == null)
{
return(true);
}
return(!_artistService.GetAllArtists().Exists(s => s.Metadata.Value.ForeignArtistId == context.PropertyValue.ToString()));
}
public void Delete(int id)
{
if (_artistService.GetAllArtists().Any(c => c.QualityProfileId == id) || _importListFactory.All().Any(c => c.ProfileId == id))
{
var profile = _profileRepository.Get(id);
throw new QualityProfileInUseException(profile.Name);
}
_profileRepository.Delete(id);
}
// GET: /Admin/Artist
public ActionResult Index()
{
var response = _artistService.GetAllArtists();
var model = new IndexArtistViewModel {
Artists = response.Artists.OrderBy(g => g.Name)
};
return(View(model));
}
// GET: ArtistsController
public IActionResult Index(int?pageNumber = 1,
string sortOrder = "",
string searchString = "")
{
pageNumber = pageNumber ?? 1;
var artistsVM = _artistService.GetAllArtists(pageNumber, sortOrder, searchString)
.Select(g => _mapper.Map <ArtistVM>(g))
.ToPagedList((int)pageNumber, 24);
return(View(artistsVM));
}
private List <ArtistResource> AllArtists()
{
var artistStats = _artistStatisticsService.ArtistStatistics();
var artistsResources = _artistService.GetAllArtists().ToResource();
MapCoversToLocal(artistsResources.ToArray());
LinkNextPreviousAlbums(artistsResources.ToArray());
LinkArtistStatistics(artistsResources, artistStats);
//PopulateAlternateTitles(seriesResources);
return(artistsResources);
}
protected override bool IsValid(PropertyValidatorContext context)
{
if (context.PropertyValue == null)
{
return(true);
}
dynamic instance = context.ParentContext.InstanceToValidate;
var instanceId = (int)instance.Id;
return(!_artistService.GetAllArtists().Exists(s => s.Path.PathEquals(context.PropertyValue.ToString()) && s.Id != instanceId));
}
public IActionResult Collections()
{
Pictures model = new Pictures(pictureService.GetAllPics().ToList(),
artistService.GetAllArtists().ToList(), pictureService.GetAllTechniqes().ToList());
return(View(model));
}
public void Execute(RefreshArtistCommand message)
{
var trigger = message.Trigger;
var isNew = message.IsNewArtist;
if (message.ArtistId.HasValue)
{
var artist = _artistService.GetArtist(message.ArtistId.Value);
bool updated = false;
try
{
updated = RefreshEntityInfo(artist, null, true, false);
_logger.Trace($"Artist {artist} updated: {updated}");
RescanArtist(artist, isNew, trigger, updated);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't refresh info for {0}", artist);
RescanArtist(artist, isNew, trigger, updated);
throw;
}
}
else
{
var allArtists = _artistService.GetAllArtists().OrderBy(c => c.Name).ToList();
foreach (var artist in allArtists)
{
var manualTrigger = message.Trigger == CommandTrigger.Manual;
if (manualTrigger || _checkIfArtistShouldBeRefreshed.ShouldRefresh(artist))
{
bool updated = false;
try
{
updated = RefreshEntityInfo(artist, null, manualTrigger, false);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't refresh info for {0}", artist);
}
RescanArtist(artist, false, trigger, updated);
}
else
{
_logger.Info("Skipping refresh of artist: {0}", artist.Name);
RescanArtist(artist, false, trigger, false);
}
}
}
}
public async Task <ActionResult> GetAllArtists()
{
var artists = await _artistService.GetAllArtists();
var artistsResource = _mapper.Map <IEnumerable <Artist>, IEnumerable <ArtistResource> >(artists);
var response = new Response <IEnumerable <ArtistResource> >
{
status = 200,
message = "Artists retrieved successfully",
data = artistsResource
};
return(Ok(response));
}
public void Delete(int id)
{
var profile = _profileRepository.Get(id);
if (profile.Name == NONE_PROFILE_NAME ||
_artistService.GetAllArtists().Any(c => c.MetadataProfileId == id) ||
_importListFactory.All().Any(c => c.MetadataProfileId == id) ||
_rootFolderService.All().Any(c => c.DefaultMetadataProfileId == id))
{
throw new MetadataProfileInUseException(profile.Name);
}
_profileRepository.Delete(id);
}
public void Execute(RefreshArtistCommand message)
{
var trigger = message.Trigger;
var isNew = message.IsNewArtist;
if (message.ArtistId.HasValue)
{
RefreshSelectedArtists(new List <int> {
message.ArtistId.Value
}, isNew, trigger);
}
else
{
var updated = false;
var artists = _artistService.GetAllArtists().OrderBy(c => c.Name).ToList();
var artistIds = artists.Select(x => x.Id).ToList();
var updatedMusicbrainzArtists = new HashSet <string>();
if (message.LastExecutionTime.HasValue && message.LastExecutionTime.Value.AddDays(14) > DateTime.UtcNow)
{
updatedMusicbrainzArtists = _artistInfo.GetChangedArtists(message.LastStartTime.Value);
}
foreach (var artist in artists)
{
var manualTrigger = message.Trigger == CommandTrigger.Manual;
if ((updatedMusicbrainzArtists == null && _checkIfArtistShouldBeRefreshed.ShouldRefresh(artist)) ||
(updatedMusicbrainzArtists != null && updatedMusicbrainzArtists.Contains(artist.ForeignArtistId)) ||
manualTrigger)
{
try
{
updated |= RefreshEntityInfo(artist, null, manualTrigger, false, message.LastStartTime);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't refresh info for {0}", artist);
}
}
else
{
_logger.Info("Skipping refresh of artist: {0}", artist.Name);
}
}
Rescan(artists, isNew, trigger, updated);
}
}
public async Task <ActionResult <IEnumerable <ArtistResource> > > GETAllArtist()
{
try
{
IEnumerable <Artist> artists = await _serviceArtist.GetAllArtists();
IEnumerable <ArtistResource> artistResources = _mapperService.Map <IEnumerable <Artist>, IEnumerable <ArtistResource> >(artists);
return(Ok(artistResources));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public override HealthCheck Check()
{
// Not best for optimization but due to possible symlinks and junctions, we get mounts based on series path so internals can handle mount resolution.
var mounts = _artistService.GetAllArtists()
.Select(artist => _diskProvider.GetMount(artist.Path))
.Where(m => m != null && m.MountOptions != null && m.MountOptions.IsReadOnly)
.DistinctBy(m => m.RootDirectory)
.ToList();
if (mounts.Any())
{
return(new HealthCheck(GetType(), HealthCheckResult.Error, "Mount containing a artist path is mounted read-only: " + string.Join(",", mounts.Select(m => m.Name)), "#artist-mount-ro"));
}
return(new HealthCheck(GetType()));
}
public void Execute(RescanArtistCommand message)
{
if (message.ArtistId.HasValue)
{
var artist = _artistService.GetArtist(message.ArtistId.Value);
Scan(artist, message.Filter);
}
else
{
var allArtists = _artistService.GetAllArtists();
foreach (var artist in allArtists)
{
Scan(artist, message.Filter);
}
}
}
//[Authorize]
public async Task <ActionResult <IEnumerable <Artist> > > GetAllArtists()
{
try
{
var artists = await _artistService.GetAllArtists();
if (artists == null)
{
return(NotFound("Artists not found"));
}
var artistResources = _mapperService.Map <IEnumerable <Artist>, IEnumerable <ArtistResource> >(artists);
return(Ok(artistResources));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void Clean()
{
if (!_configService.CleanupMetadataImages)
{
return;
}
var artists = _artistService.GetAllArtists();
var imageExtensions = new List <string> {
".jpg", ".png", ".gif"
};
foreach (var artist in artists)
{
var images = _metaFileService.GetFilesByArtist(artist.Id)
.Where(c => c.LastUpdated > new DateTime(2014, 12, 27) && imageExtensions.Any(x => c.RelativePath.EndsWith(x, StringComparison.InvariantCultureIgnoreCase)));
foreach (var image in images)
{
try
{
var path = Path.Combine(artist.Path, image.RelativePath);
if (!IsValid(path))
{
_logger.Debug("Deleting invalid image file " + path);
DeleteMetadata(image.Id, path);
}
}
catch (Exception e)
{
_logger.Error(e, "Couldn't validate image {0}", image.RelativePath);
}
}
}
_configService.CleanupMetadataImages = false;
}
private List <ArtistResource> AllArtists()
{
var mbId = Request.GetGuidQueryParameter("mbId");
var artistStats = _artistStatisticsService.ArtistStatistics();
var artistsResources = new List <ArtistResource>();
if (mbId != Guid.Empty)
{
artistsResources.AddIfNotNull(_artistService.FindById(mbId.ToString()).ToResource());
}
else
{
artistsResources.AddRange(_artistService.GetAllArtists().ToResource());
}
MapCoversToLocal(artistsResources.ToArray());
LinkNextPreviousAlbums(artistsResources.ToArray());
LinkArtistStatistics(artistsResources, artistStats);
artistsResources.ForEach(LinkRootFolderPath);
//PopulateAlternateTitles(seriesResources);
return(artistsResources);
}