public AlbumHandler(IAlbumRepository repository, IGenderRepository genderRepository, ICategoryRepository categoryRepository, ISongRepository songRepository = null)
{
this._repository = repository;
this._genderRepository = genderRepository;
this._categoryRepository = categoryRepository;
this._songRepository = songRepository;
}
public SongService(ISongRepository songRepository, IArtistRepository artistRepository,
ISongCategoryRepository songCategoryRepository)
{
_songRepository = songRepository;
_artistRepository = artistRepository;
_songCategoryRepository = songCategoryRepository;
}
public SetRatingHandler(
IValidationService validationService,
ISongRepository songRepository)
{
_validationService = validationService;
_songRepository = songRepository;
}
public SongsController(ISongRepository songRepository, IAlbumRepository albumRepository, ISingerRepository singerRepository)
{
this._songRepository = songRepository;
this._albumRepository = albumRepository;
this._singerRepository = singerRepository;
this._handler = new SongHandler(_songRepository, _albumRepository, _singerRepository);
}
public HomeController(ISongRepository songRepository, IFileProvider fileProvider,
IHostingEnvironment hostingEnvironment)
{
_songRepository = songRepository;
this.fileProvider = fileProvider;
this.hostingEnvironment = hostingEnvironment;
}
public SearchService(ISongRepository songRepository, IAlbumRepository albumRepository, IArtistRepository artistRepository, IGenreRepository genreRepository)
{
_songRepository = songRepository;
_albumRepository = albumRepository;
_artistRepository = artistRepository;
_genreRepository = genreRepository;
}
public PlaylistService(IPlaylistRepository playlistRepository, ISongRepository songRepository)
{
_applicationDbContext = new ApplicationDbContext();
_playlistRepository = new PlaylistRepository(_applicationDbContext);
_songRepository = new SongRepository(_applicationDbContext);
}
public AddAlbumViewModel(ISongRepository songRepository,
IAlbumRepository albumRepository)
{
this.UploadAlbumCommand = new DelegateCommand(this.UploadAlbum_Execute, this.UploadAlbum_CanExecute);
this.AddSongCommand = new DelegateCommand(this.AddSong_Execute);
this.RemoveSongCommand = new DelegateCommand(this.RemoveSong_Execute, this.RemoveSong_CanExecute);
_songRepository = songRepository;
_albumRepository = albumRepository;
this.Album = new AlbumWrapper(new Album());
// this is what notifies the upload button to toggle on whenever a property of album changes
this.Album.PropertyChanged += (s, e) => {
if (e.PropertyName == nameof(Album.HasErrors))
{
((DelegateCommand)UploadAlbumCommand).RaiseCanExecuteChanged();
}
};
base._imageWrapper = this.Album;
#region a trick to trigger validation
this.Album.Title = "";
this.Album.Price = 0;
#endregion
this.Songs.Add(new Song {
Title = "Soul Lady",
Duration = new TimeSpan(0, 3, 24),
Composer = "Jinbae Park",
Lyricist = "Oreo",
Ratings = 5
});
}
public MusicLibraryService(IArtistRepository artists, IAlbumRepository albums, ISongRepository songs, IGenreRepository genres)
{
Artists = artists;
Albums = albums;
Songs = songs;
Genres = genres;
}
public PlaylistsController(IPlaylistsRepository _repo,
IUsersRepository _usersRepo,
ISongRepository _songsRepo)
{
repo = _repo;
usersRepo = _usersRepo;
songsRepo = _songsRepo;
}
public SongListViewModel()
{
songRepository = new DummySongRepository();
var songList = songRepository.GetSongs().Select(s => new SongViewModel(s));
ShowAddSongCommand = new RelayCommand(ShowAddSong, CanShowAddSong);
Songs = new ObservableCollection <SongViewModel>(songList);
}
public LabelService(IMapper mapper, IArtistRepository artistRepository, IRecordlabelRepository recordlabelRepository, ISongRepository songRepository, IAlbumRepository albumRepository)
{
_mapper = mapper;
_artistRepository = artistRepository;
_recordlabelRepository = recordlabelRepository;
_songRepository = songRepository;
_albumRepository = albumRepository;
}
public SongService(ISongRepository songRepository, IRecordingPartyRepository recordingPartyRepository, IUnitOfWork <HljodritEntitiesDb> unitOfWork, IInstrumentRepository instrumentRepository, IMediaRecordingRepository mediaRecordingRepository)
{
_songRepository = songRepository;
_recordingPartyRepository = recordingPartyRepository;
_unitOfWork = unitOfWork;
_instrumentRepository = instrumentRepository;
_mediaRecordingRepository = mediaRecordingRepository;
}
public InventoryService(IGenreRepository genreRepository, IArtistRepository artistRepository, IAlbumRepository albumRepository, ISongRepository songRepository, IUserRepository userRepository)
{
_genreRepository = genreRepository;
_artistRepository = artistRepository;
_albumRepository = albumRepository;
_songRepository = songRepository;
_userRepository = userRepository;
}
public RatingService(ISongRepository songRepository, IArtistRepository artistRepository, IGenreRepository genreRepository, IAlbumRepository albumRepository, IUserRepository userRepository)
{
_songRepository = songRepository;
_artistRepository = artistRepository;
_genreRepository = genreRepository;
_albumRepository = albumRepository;
_userRepository = userRepository;
}
public VotingFinisher(IVotingCandidateRepository votingCandidateRepository, ISongRepository songRepository, ICurrentSongService currentSongService, IVotingCandidateService votingCandidateService, ILogger logger)
{
_votingCandidateRepository = votingCandidateRepository;
_songRepository = songRepository;
_currentSongService = currentSongService;
_votingCandidateService = votingCandidateService;
_logger = logger;
}
public AlbumController(IAlbumRepository albumrepository, IArtistAlbumRepository artistalbumrepository, IArtistRepository artistrepository, ISongRepository songrepository, ISongAlbumRepository songalbumrepository)
{
IAlbumRepository = albumrepository;
IArtistAlbumRepository = artistalbumrepository;
ISongAlbumRepository = songalbumrepository;
ISongRepository = songrepository;
IArtistRepository = artistrepository;
}
public RemoveSongCommandValidator(
ISongRepository songRepository
)
{
_songRepository = songRepository;
RuleFor(x => x.SongId).MustAsync(ValidateSongId).WithMessage("Invalid song");
}
public AlbumsController(IAlbumRepository albumRepository, IGenderRepository genderRepository, ICategoryRepository categoryRepository, ISongRepository songRepository)
{
this._albumRepository = albumRepository;
this._genderRepository = genderRepository;
this._categoryRepository = categoryRepository;
this._songRepository = songRepository;
this._handler = new AlbumHandler(_albumRepository, _genderRepository, _categoryRepository);
}
public SongDetailViewModel(ISongRepository songRepository, IEventAggregator eventAggregator)
{
_songRepository = songRepository;
_eventAggregator = eventAggregator;
SaveCommand = new DelegateCommand(OnSaveExecute, OnSaveCanExecute);
DeleteCommand = new DelegateCommand(OnDeleteExecute);
}
public FinishSongCommandHandler(
ICurrentSongRepository currentSongRepository,
ISongRepository songRepository
)
{
_currentSongRepository = currentSongRepository;
_songRepository = songRepository;
}
public FitnessClassController(IFitnessClassRepository fitnessClassRepository, IInstructorFitnessClassRepository instructorClassRepository, IInstructorRepository instructorRepository, IGymClubFitnessClassRepository gymClubClassRepository, ISongRepository songRepository, IGymClubRepository gymClubRepository)
{
IFitnessClassRepository = fitnessClassRepository;
IInstructorClassRepository = instructorClassRepository;
IInstructorRepository = instructorRepository;
ISongRepository = songRepository;
IGymClubClassRepository = gymClubClassRepository;
IGymClubRepository = gymClubRepository;
}
public AlbumService(IAlbumRepository albumRepository, ISongRepository songRepository, IArtistRepository artistRepository, IGenreRepository genreRepository)
{
_applicationDbContext = new ApplicationDbContext();
_albumRepository = new AlbumRepository(_applicationDbContext);
_songRepository = new SongRepository(_applicationDbContext);
_artistRepository = new ArtistRepository(_applicationDbContext);
_genreRepository = new GenreRepository(_applicationDbContext);
}
public UnitOfWork()
{
// vytvořím instanci DbContextu
_context = new EntitiesContext();
// Vytvoření Repositories
_songs = new SongRepository(_context);
_albums = new Repository <AlbumEntity>(_context);
}
public SongController(ISongRepository songRepository,
IWebHostEnvironment webHostEnvironment,
UserManager <ApplicationUser> userManager, IHttpContextAccessor httpContextAccessor)
{
_songRepository = songRepository;
_webHostEnvironment = webHostEnvironment;
_userManager = userManager;
_httpContextAccessor = httpContextAccessor;
}
public SongsController(ILogger <SongsController> logger,
ISongRepository songRepository, IGoogleSlides googleSlides,
IGetValue valueRetrieval)
{
_logger = logger;
_songRepository = songRepository;
_googleSlides = googleSlides;
_valueRetrieval = valueRetrieval;
}
public PlaylistController(IPlaylistRepository playlistRepository, ISongRepository songRepository, ISongPlaylistRepository songPlaylistRepository, IMoodLinkRepository moodLinkRepository, IMoodRepository moodRepository, IPlaylistMoodRepository playlistMoodRepository)
{
iPlaylistRepository = playlistRepository;
iSongPlaylistRepository = songPlaylistRepository;
iSongRepository = songRepository;
iMoodLinkRepository = moodLinkRepository;
iMoodRepository = moodRepository;
iPlaylistMoodRepository = playlistMoodRepository;
}
public SongService(ISongRepository songRepository, ILinkRepository linkRepository, IArtistRepository artistRepository, IGenreRepository genreRepository)
{
_applicationDbContext = new ApplicationDbContext();
_songRepository = new SongRepository(_applicationDbContext);
_linkRepository = new LinkRepository(_applicationDbContext);
_artistRepository = new ArtistRepository(_applicationDbContext);
_genreRepository = new GenreRepository(_applicationDbContext);
}
public SongListviewModel()
{
songRepository = new DummySongRepository();
var songList = songRepository.ToList().Select(s => new SongViewModel(s));
SongViewModel = new SongViewModel();
Songs = new ObservableCollection<SongViewModel>(songList);
AddSong = new RelayCommand(AddNewSong);
}
public StartSongCommandHandler(
ISongRepository songRepository,
IUserRepository userRepository,
ICurrentSongRepository currentSongRepository
)
{
_songRepository = songRepository;
_userRepository = userRepository;
_currentSongRepository = currentSongRepository;
}
public SongListViewModel()
{
songRepository = new DummySongRepository();
var songList = songRepository.ToList().Select(s => new SongViewModel(s));
AddSong = new RelayCommand(AddNewSong, CanAddNewSong);
SongViewModel = new SongViewModel();
Songs = new ObservableCollection <SongViewModel>(songList);
}
public void Setup()
{
_votingCandidateRepository = Substitute.For <IVotingCandidateRepository>();
_songRepository = Substitute.For <ISongRepository>();
_currentSongService = Substitute.For <ICurrentSongService>();
_votingCandidateService = Substitute.For <IVotingCandidateService>();
_logger = Substitute.For <ILogger>();
_votingFinisher = new VotingFinisher(_votingCandidateRepository, _songRepository, _currentSongService, _votingCandidateService, _logger);
}
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 SongListviewModel()
{
songRepository = new DummySongRepository();
var songList = songRepository.ToList().Select(s => new SongViewModel(s));
SelectedSong = new SongViewModel();
Songs = new ObservableCollection<SongViewModel>(songList);
ClearSong = new RelayCommand(ClearThesong, CanClearSong);
DeleteSongCommand = new RelayCommand(DeleteSong, CanDeleteSong);
AddSong = new RelayCommand(AddNewSong, CanAddSong);
}
public SongSpider(
ILibraryRepository libraryRepository,
ISongRepository songRespository,
IMusicLibraryFactory factory)
{
this._libraryRepository = libraryRepository;
this._songRespository = songRespository;
this._factory = factory;
this._thread = new Thread(new ThreadStart(QueueWatcher));
this._thread.Start();
}
public GenresController ( IGenreRepository genreRepository,
ISongRepository songRepository,
IValidationRules validationRules,
IAccount account)
{
_genreRepository = genreRepository;
_songRepository = songRepository;
_validationRules = validationRules;
var currentUserName = GetCurrentSessionUser();
if (currentUserName.Length > 0)
_currentUser = account.GetUserByUserName(currentUserName);
_common = new CommonSong(account, currentUserName);
}
public ValidationRules(IBandRepository bandRepository,
IMemberRepository memberRepository,
ISongRepository songRepository,
ISetlistRepository setListRepository,
IGigRepository gigRepository,
IInstrumentRepository instrumentRepository)
{
_bandRepository = bandRepository;
_memberRepository = memberRepository;
_songRepository = songRepository;
_setListRepository = setListRepository;
_gigRepository = gigRepository;
_instrumentRepository = instrumentRepository;
}
public SongListViewModel()
{
songRepository = new DummySongRepository();
var songList = songRepository.ToList().Select(s => new SongViewModel(s));
NextSongCommand = new RelayCommand(NextSong, CanNextSong);
PrevSongCommand = new RelayCommand(PrevSong, CanPrevSong);
AddSong = new RelayCommand(AddNewSong, CanAddNewSong);
ClearSongCommand = new RelayCommand(ClearSong);
Songs = new ObservableCollection<SongViewModel>(songList);
SelectedSong = Songs.First();
_index = 0;
}
public BandsController( IUserRepository userRepository,
IBandRepository bandRepository,
ISongRepository songRepository,
IMemberRepository memberRepository,
IValidationRules validationRules,
IAccount account)
{
_userRepository = userRepository;
_bandRepository = bandRepository;
_songRepository = songRepository;
_memberRepository = memberRepository;
_validationRules = validationRules;
var currentUserName = GetCurrentSessionUser();
if (currentUserName.Length > 0)
_currentUser = account.GetUserByUserName(currentUserName);
_common = new CommonSong(account, currentUserName);
}
public SetlistsController( IBandRepository bandRepository,
ISetlistRepository setlistRepository,
ISetSongRepository setSongRepository,
ISongRepository songRepository,
IGigRepository gigRepository,
IAccount account,
IValidationRules validationRules)
{
var currentUserName = GetCurrentSessionUser();
_currentUser = (currentUserName.Length > 0) ? account.GetUserByUserName(currentUserName) : null;
_bandRepository = bandRepository;
_setlistRepository = setlistRepository;
_setSongRepository = setSongRepository;
_songRepository = songRepository;
_gigRepository = gigRepository;
_validationRules = validationRules;
_common = new CommonSong(account, currentUserName);
}
public SongsController( IBandRepository bandRepository,
ISongRepository songRepository,
ISetlistRepository setlistRepository,
IInstrumentRepository instrumentRepository,
IValidationRules validationRules,
IAccount account)
{
_bandRepository = bandRepository;
_songRepository = songRepository;
_setlistRepository = setlistRepository;
_instrumentRepository = instrumentRepository;
_validationRules = validationRules;
var currentUserName = GetCurrentSessionUser();
_common = new CommonSong(account, currentUserName);
if (currentUserName.Length > 0)
_currentUser = account.GetUserByUserName(currentUserName);
}
public MediaItemRepository(IItemRepository itemRepository, ISongRepository songRepository, IVideoRepository videoRepository)
{
if (itemRepository == null)
{
throw new ArgumentNullException("itemRepository");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
if (videoRepository == null)
{
throw new ArgumentNullException("videoRepository");
}
this.itemRepository = itemRepository;
this.songRepository = songRepository;
this.videoRepository = videoRepository;
}
public AlbumArtistRepository(IDatabase database, IItemRepository itemRepository, ISongRepository songRepository)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
if (itemRepository == null)
{
throw new ArgumentNullException("itemRepository");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
this.database = database;
this.itemRepository = itemRepository;
this.songRepository = songRepository;
}
public DefaultJukebox(
IMediaPlayer mediaPlayer,
IMusicLibraryFactory musicLibraryFactory,
ILibraryRepository libraryRepository,
ISongRepository songRepository,
IAffinityTracker affinityTracker,
IUserRepository userRepository,
SongSpider spider)
{
_mediaPlayer = mediaPlayer;
_musicLibraryFactory = musicLibraryFactory;
_libraryRepository = libraryRepository;
_songRepository = songRepository;
_spider = spider;
_affinityTracker = affinityTracker;
_userRepository = userRepository;
_mediaPlayer.SongFinished += _mediaPlayer_SongFinished;
UpdateAllLibraries();
MarkAllUsersAsAway();
}
public MusicHubBot(
IJukebox jukebox,
ILibraryRepository libraryRepository,
IUserRepository userRepository,
IMediaPlayer mediaPlayer,
ISongRepository songRepository,
IMetadataService metadataService,
IKernel kernel,
SongSpider spider)
{
_jukebox = jukebox;
_userRepository = userRepository;
_libraryRepository = libraryRepository;
_mediaPlayer = mediaPlayer;
_libraryRepository = libraryRepository;
_kernel = kernel;
_spider = spider;
_jukebox.SongStarted += _jukebox_SongStarted;
InitializeChatCommandProcessors();
}
public FolderRepository(IDatabase database, IServerSettings serverSettings, ISongRepository songRepository, IVideoRepository videoRepository)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
if (serverSettings == null)
{
throw new ArgumentNullException("serverSettings");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
if (videoRepository == null)
{
throw new ArgumentNullException("videoRepository");
}
this.database = database;
this.serverSettings = serverSettings;
this.songRepository = songRepository;
this.videoRepository = videoRepository;
}
public SongsController(ISongRepository songsRepository)
{
_songsRepository = songsRepository;
}
public NavController(ISongRepository repo)
{
repository = repo;
}
public SongRunner(ISongRepository songRepository, ISettingsRepository settingsRepository)
{
_songRepository = songRepository;
_settingsRepository = settingsRepository;
}
public AdminController(ISongRepository repo)
{
repository = repo;
}
public SongService(IUnitOfWork uow, ISongRepository repository)
{
this._uow = uow;
this._songRepository = repository;
}
public SongsController(IAlbumRepository albumRepository, ISongRepository songRepository)
{
this.albumRepository = albumRepository;
this.songRepository = songRepository;
}
public CartController(ISongRepository repo)
{
repository = repo;
}
public QueueController(ISongRepository songRepository)
{
_songRepository = songRepository;
}
//Song repository and logger are available as they are registered into the conatiner in AppHost
public SongProvider(ISongRepository songRepository, ILog logger)
{
_songRepository = songRepository;
_logger = logger;
}
public SongController(ISettingsRepository settingsRepository, ISongRepository songRepository)
{
_settingsRepository = settingsRepository;
_songRepository = songRepository;
}
public SongService(ISongRepository repo)
{
Checks.Argument.IsNotNull(repo, "repo");
_repo = repo;
}
public SongController(ISongRepository songRepository)
{
this.repository = songRepository;
}
