//private MusicStoreEntities db = new MusicStoreEntities();
public StoreManagerController(IUnitOfWork unitOfWork, IGenreRepository genres, IAlbumsRepository albums, IArtistRepository artists)
{
_unitOfWork = unitOfWork;
_genres = genres;
_albums = albums;
_artists = artists;
}
public MusicLibraryService(IArtistRepository artists, IAlbumRepository albums, ISongRepository songs, IGenreRepository genres)
{
Artists = artists;
Albums = albums;
Songs = songs;
Genres = genres;
}
public EventOrchestrator(IMapper mapper, IArtistRepository repository, IFacebookExternalRepository facebookExternalRepository, ILastFmExternalRepository lastFmExternalRepository)
{
_mapper = mapper;
_repository = repository;
_facebookExternalRepository = facebookExternalRepository;
_lastFmExternalRepository = lastFmExternalRepository;
}
public AuthenticateController(IMapper mapper, IAuthenticationService authenticationService, ITokenRepository tokenRepository, IUserLoginRepository userLoginRepository, IArtistRepository artistRepository)
{
_mapper = mapper;
_authenticationService = authenticationService;
_tokenRepository = tokenRepository;
_userLoginRepository = userLoginRepository;
_artistRepository = artistRepository;
}
public AlbumService(IAlbumRepository albumRepository, IArtistRepository artistRepository, IGenreRepository genreRepository,
IUnitOfWork uow)
{
_albumRepository = albumRepository;
_artistRepository = artistRepository;
_genreRepository = genreRepository;
_uow = uow;
}
public ProductService(IGenreRepository genreRepository, IPictureService pictureService, IPictureRepository pictureRepository, IArtistRepository artistRepository, IAlbumRepository albumRepository, IPurchaseRepository purchaseRepository)
{
this.GenreRepository = genreRepository;
this.PictureRepository = pictureRepository;
this.PictureService = pictureService;
this.ArtistRepository = artistRepository;
this.AlbumRepository = albumRepository;
this.PurchaseRepository = purchaseRepository;
}
public ArtistRepositoryController(IArtistRepository artistRepository, ISearchRequestedHandler searchRequestedHandler, IInitializeRepositoriesHandler initializeRepositoriesHandler)
{
_artistRepository = artistRepository;
searchRequestedHandler.Controller = this;
initializeRepositoriesHandler.Controller = this;
AddHandler(searchRequestedHandler);
AddHandler(initializeRepositoriesHandler);
}
public FavoriteRepository(IDatabase database, IAlbumArtistRepository albumArtistRepository, IAlbumRepository albumRepository, IArtistRepository artistRepository, IFolderRepository folderRepository, IGenreRepository genreRepository, IPlaylistRepository playlistRepository, ISongRepository songRepository, IVideoRepository videoRepository, IItemRepository itemRepository)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
if (albumRepository == null)
{
throw new ArgumentNullException("albumRepository");
}
if (albumArtistRepository == null)
{
throw new ArgumentNullException("albumArtistRepository");
}
if (artistRepository == null)
{
throw new ArgumentNullException("artistRepository");
}
if (folderRepository == null)
{
throw new ArgumentNullException("folderRepository");
}
if (genreRepository == null)
{
throw new ArgumentNullException("genreRepository");
}
if (playlistRepository == null)
{
throw new ArgumentNullException("playlistRepository");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
if (videoRepository == null)
{
throw new ArgumentNullException("videoRepository");
}
if (itemRepository == null)
{
throw new ArgumentNullException("itemRepository");
}
this.database = database;
this.albumArtistRepository = albumArtistRepository;
this.albumRepository = albumRepository;
this.artistRepository = artistRepository;
this.folderRepository = folderRepository;
this.genreRepository = genreRepository;
this.playlistRepository = playlistRepository;
this.songRepository = songRepository;
this.videoRepository = videoRepository;
this.itemRepository = itemRepository;
}
public EventAdministrationController(IConcertRepository concertRepository, IArtistRepository artistRepository, IVenueRepository venueRepository, ICityRepository cityRepository)
{
// Setup Fields
_concertRepository = concertRepository;
_artistRepository = artistRepository;
_venueRepository = venueRepository;
_cityRepository = cityRepository;
// Setup Callbacks
_concertRepository.StatusCallback = DisplayMessage;
_artistRepository.StatusCallback = DisplayMessage;
_venueRepository.StatusCallback = DisplayMessage;
_cityRepository.StatusCallback = DisplayMessage;
}
/// <summary>
/// ctor: Initialise the AlbumModelDataService
/// </summary>
/// <param name="AlbumRepository">Instance of the AlbumRepository</param>
/// <param name="ArtistRepository">Instance of the ArtistRepository</param>
/// <param name="GenreRepository">Instance of the GenreRepository</param>
/// <param name="PlaylistRepository">Instance of the PlaylistRepository</param>
public AlbumModelDataService(IAlbumRepository AlbumRepository, IArtistRepository ArtistRepository, IGenreRepository GenreRepository, IPlaylistRepository PlaylistRepository)
{
if (AlbumRepository == null)
throw new ArgumentNullException("AlbumRepository", "No valid Repository supplied");
_albumRepository = AlbumRepository;
if (ArtistRepository == null)
throw new ArgumentNullException("ArtistRepository", "No valid Repository supplied");
_artistRepository = ArtistRepository;
if (GenreRepository == null)
throw new ArgumentNullException("GenreRepository", "No valid Repository supplied");
_genreRepository = GenreRepository;
if (PlaylistRepository == null)
throw new ArgumentNullException("PlaylistRepository", "No valid Repository supplied");
_playlistRepository = PlaylistRepository;
}
public ArtistsInBandsController()
{
artistRepository = new ArtistRepository();
}
public ArtistService(IArtistRepository artistRepository, IUnitOfWork uow)
{
_artistRepository = artistRepository;
_uow = uow;
}
public ArtistController(IMapper mapper, IArtistRepository artistRepository)
{
_mapper = mapper;
_artistRepository = artistRepository;
}
public ArtistType(IArtistRepository artistRepository)
{
_artistRepository = artistRepository;
Define();
}
public BandsController(IBandRepository _bandRepository, IArtistRepository _artistRepository)
{
bandRepository = _bandRepository;
artistRepository = _artistRepository;
}
/// <summary>
/// Artist Service Constructor
/// </summary>
/// <param name="artistRepository"></param>
/// <param name="mapper"></param>
public ArtistService(IArtistRepository artistRepository, IMapper mapper)
{
this._artistRepository = artistRepository;
_mapper = mapper;
}
public CollectionArtistsViewModel(IUnityContainer container) : base(container)
{
// Dependency injection
this.collectionService = container.Resolve <ICollectionService>();
this.metadataService = container.Resolve <IMetadataService>();
this.playbackService = container.Resolve <IPlaybackService>();
this.playlistService = container.Resolve <IPlaylistService>();
this.indexingService = container.Resolve <IIndexingService>();
this.dialogService = container.Resolve <IDialogService>();
this.searchService = container.Resolve <ISearchService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
this.artistRepository = container.Resolve <IArtistRepository>();
// Commands
this.ToggleArtistOrderCommand = new DelegateCommand(async() => await this.ToggleArtistOrderAsync());
this.ToggleTrackOrderCommand = new DelegateCommand(async() => await this.ToggleTrackOrderAsync());
this.ToggleAlbumOrderCommand = new DelegateCommand(async() => await this.ToggleAlbumOrderAsync());
this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.RemoveTracksFromCollectionAsync(this.SelectedTracks), () => !this.IsIndexing);
this.RemoveSelectedTracksFromDiskCommand = new DelegateCommand(async() => await this.RemoveTracksFromDiskAsync(this.SelectedTracks), () => !this.IsIndexing);
this.AddArtistsToPlaylistCommand = new DelegateCommand <string>(async(iPlaylistName) => await this.AddArtistsToPlaylistAsync(this.SelectedArtists, iPlaylistName));
this.SelectedArtistsCommand = new DelegateCommand <object>(async(iParameter) => await this.SelectedArtistsHandlerAsync(iParameter));
this.ShowArtistsZoomCommand = new DelegateCommand(async() => await this.ShowSemanticZoomAsync());
this.AddArtistsToNowPlayingCommand = new DelegateCommand(async() => await this.AddArtistsToNowPlayingAsync(this.SelectedArtists));
this.ShuffleSelectedArtistsCommand = new DelegateCommand(async() => await this.playbackService.EnqueueAsync(this.SelectedArtists, true, false));
this.SemanticJumpCommand = new DelegateCommand <string>((header) =>
{
this.HideSemanticZoom();
this.eventAggregator.GetEvent <PerformSemanticJump>().Publish(new Tuple <string, string>("Artists", header));
});
// Settings
SettingsClient.SettingChanged += async(_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating"))
{
this.EnableRating = (bool)e.SettingValue;
this.SetTrackOrder("ArtistsTrackOrder");
await this.GetTracksAsync(this.SelectedArtists, null, this.SelectedAlbums, this.TrackOrder);
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove"))
{
this.EnableLove = (bool)e.SettingValue;
this.SetTrackOrder("ArtistsTrackOrder");
await this.GetTracksAsync(this.SelectedArtists, null, this.SelectedAlbums, this.TrackOrder);
}
};
// PubSub Events
this.eventAggregator.GetEvent <ShellMouseUp>().Subscribe((_) => this.IsArtistsZoomVisible = false);
// Events
this.metadataService.MetadataChanged += MetadataChangedHandlerAsync;
this.indexingService.RefreshArtwork += async(_, __) => await this.collectionService.RefreshArtworkAsync(this.Albums);
// Set the initial ArtistOrder
this.ArtistOrder = (ArtistOrder)SettingsClient.Get <int>("Ordering", "ArtistsArtistOrder");
// Set the initial AlbumOrder
this.AlbumOrder = (AlbumOrder)SettingsClient.Get <int>("Ordering", "ArtistsAlbumOrder");
// Set the initial TrackOrder
this.SetTrackOrder("ArtistsTrackOrder");
// Set width of the panels
this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "ArtistsLeftPaneWidthPercent");
this.RightPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "ArtistsRightPaneWidthPercent");
// Cover size
this.SetCoversizeAsync((CoverSizeType)SettingsClient.Get <int>("CoverSizes", "ArtistsCoverSize"));
}
public GetArtistHandler(IArtistRepository artistRepository)
{
_artistRepository = artistRepository;
}
public ArtistType(IArtistRepository artistRepository)
{
Field(x => x.ID);
Field(x => x.Name, nullable: true);
}
public QuerySearchIndexArtistsHandler(ISearchIndex searchIndex, IArtistRepository artistRepository)
{
_searchIndex = searchIndex;
_artistRepository = artistRepository;
}
//
// GET: /v1/Notification/
public NotificationController(IMapper mapper, IArtistRepository artistRepository)
{
_mapper = mapper;
_artistRepository = artistRepository;
}
public IndexingService(ICacheService cacheService, ITrackRepository trackRepository, IAlbumRepository albumRepository, IGenreRepository genreRepository, IArtistRepository artistRepository, IFolderRepository folderRepository)
{
// Initialize services
// -------------------
this.cacheService = cacheService;
// Initialize repositories
// -----------------------
this.trackRepository = trackRepository;
this.albumRepository = albumRepository;
this.genreRepository = genreRepository;
this.artistRepository = artistRepository;
this.folderRepository = folderRepository;
// Initialize values
// -----------------
this.needsIndexing = true;
this.isIndexing = false;
}
public LyricStatisticsService(IArtistRepository artistRepository, ILyricsRepository lyricsRepository)
{
_artistRepository = artistRepository;
_lyricsRepository = lyricsRepository;
}
public HomeController(IArtistRepository rep)
{
m_repository = rep;
}
public DeleteFacebookEventCommandHandler(IArtistRepository artistRepository)
{
_artistRepository = artistRepository;
}
public void AlbumTestFixtureSetup()
{
_connection = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ConnectionString);
_artistRepository = new ArtistRepository(_connection);
}
public AlbumEditViewModel(IAlbumRepository albumRepository, IArtistRepository artistRepository)
{
_albumRepository = albumRepository;
_artistRepository = artistRepository;
}
public ArtistController(IArtistRepository repo, ILogger <ArtistController> logger)
{
_artistMapper = new ArtistMapper();
_repo = repo;
_logger = logger;
}
public FlickrController(IFlickrApi flickrApi, IArtistRepository artistRepository)
{
_flickrApi = flickrApi;
_artistRepository = artistRepository;
}
public Artist(IArtistRepository artistRepository)
{
ArtistRepository = artistRepository;
Albums = new ObservableCollection <Album>();
ArtistGenres = new ObservableCollection <ArtistGenre>();
}
public ArtistsController(IArtistRepository artistRepository)
{
_artistRepository = artistRepository;
}
public ArtistsInBandsController()
{
artistRepository = new ArtistRepository();
}
public CreateArtistHandler(IArtistRepository artistRepository, IFileUtils fileUtils)
{
_artistRepository = artistRepository;
_fileUtils = fileUtils;
}
public ArtistService(IArtistRepository artistRepository)
{
_artistRepository = artistRepository;
}
public TokenAuthentication()
{
_artistRepository = DependencyResolver.Current.GetService<IArtistRepository>();
_tokenRepository = DependencyResolver.Current.GetService<ITokenRepository>();
}
// GET: Artist
public ArtistController(IArtistRepository artistRepository)
{
this.repository = artistRepository;
}
public ArtistController(IArtistRepository repo)
{
_repo = repo;
}
public AdminController(IEventRepository repo, ICategoryRepository catRepository, ITicketRepository ticketRepo, IArtistRepository artistRepo)
{
_repository = repo;
_catRepo = catRepository;
_ticketRepository = ticketRepo;
_artistRepository = artistRepo;
}
public FlickrController(IFlickrApi flickrApi, IArtistRepository artistRepository)
{
_flickrApi = flickrApi;
_artistRepository = artistRepository;
}
public AlbumRepository(MusicContext context, IArtistRepository artistrepo)
{
_context = context;
_artistrepo = artistrepo;
}
public LastFmExternalRepository(ILastFmApi lastFmApi, IArtistRepository artistRepository)
{
_lastFmApi = lastFmApi;
_artistRepository = artistRepository;
}
public ArtistsModel(IArtistRepository artistRepository)
{
Artists = new ObservableCollection <Artist>(artistRepository.GetAllArtists());
_artistRepository = artistRepository;
}
public ArtistService(IUnitOfWork uow, IArtistRepository repository)
{
this._uow = uow;
this._artistRepository = repository;
}
public AddArtistLogonHandleCommand(IArtistRepository artistRepository)
{
_artistRepository = artistRepository;
}
public ArtistService()
{
artistRepo = new ArtistRepository();
}
public ListArtistsQueryHandler(IArtistRepository artistRepository,
IConfigurationProvider configurationProvider)
{
_artistRepository = artistRepository;
_configurationProvider = configurationProvider;
}
public LastFmController(IArtistRepository artistRepository, IMapper mapper)
{
_artistRepository = artistRepository;
_mapper = mapper;
}
public AlbumService(IAlbumRepository albumRepository, IArtistRepository artistRepository, IGenreRepository genreRepository)
{
_albumRepository = albumRepository;
_artistRepository = artistRepository;
_genreRepository = genreRepository;
}
public ArtistsController(IArtistRepository artistRepository)
{
this.artistRepository = artistRepository;
}
public ArtistRepositoryTest()
{
dbContext = new ChinookDBModel();
artistRepository = new ArtistRepository(dbContext);
unitOfWork = new UnitOfWork(dbContext);
}
public TokenController(IMapper mapper, IArtistRepository artistRepository, ITokenRepository tokenRepository)
{
_mapper = mapper;
_artistRepository = artistRepository;
_tokenRepository = tokenRepository;
}
public ArtistController(IMapper mapper, IArtistRepository artistRepository)
{
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_artistRepo = artistRepository ?? throw new ArgumentNullException(nameof(artistRepository));
}
public GetArtistByIdHandler(IArtistRepository artistRepository)
{
_artistRepository = artistRepository ?? throw new ArgumentNullException(nameof(artistRepository));
}
public ArtistService(IArtistRepository repository) : base(repository)
{
songRepository = repository;
}
public GetArtistListQuery(IArtistRepository artistRepository)
{
this.artistRepository = artistRepository;
}
public ArtistsController()
{
_artsitsRepository = new ArtistsRepository();
}
