private static void DisplaySoloArtists(ArtistRepository artistRepo) { var artists = artistRepo.GetSoloArtists(); Console.WriteLine("Solo artists found"); if (artists.Any()) artists.ForEach(a => WriteArtist(a)); else Console.WriteLine("No Solo artists found"); }
public ActionResult Delete(int comicBookId, int id) { if (!ArtistRepository.Delete(id)) { return(new HttpStatusCodeResult(HttpStatusCode.NotFound)); } TempData["Message"] = "Your artist was successfully deleted!"; return(RedirectToAction("Detail", "ComicBooks", new { id = comicBookId })); }
public async Task handle_should_return_right_items_using_artist_id(string id) { var artistRepository = new ArtistRepository(_catalogContextFactory.ContextInstance); var itemRepository = new ItemRepository(_catalogContextFactory.ContextInstance); var sut = new ArtistService(artistRepository, itemRepository, _catalogContextFactory.ArtistMapper, _catalogContextFactory.ItemMapper); var result = await sut.GetItemByArtistIdAsync(new GetArtistRequest { Id = new Guid(id) }); result.ShouldNotBeNull(); }
public async Task getartist_should_return_right_data() { var repository = new ArtistRepository(_catalogDataContextFactory.ContextInstance); var sut = new GetArtistsHandler(repository, new Mapper(new MapperConfiguration(cfg => cfg.AddProfile <CatalogProfile>()))); var result = await sut.Handle(new GetArtistsCommand(), CancellationToken.None); result.Count.ShouldBe(2); }
private void CreateRepositories() { HttpClient = new HttpClient(); HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken); Albums = new AlbumRepository(HttpClient, new Uri(BaseUri, AlbumRepository.DEFAULT_ENDPOINT)); Artists = new ArtistRepository(HttpClient, new Uri(BaseUri, ArtistRepository.DEFAULT_ENDPOINT)); Browse = new BrowseRepository(HttpClient, new Uri(BaseUri, BrowseRepository.DEFAULT_ENDPOINT)); Episodes = new EpisodeRepository(HttpClient, new Uri(BaseUri, EpisodeRepository.DEFAULT_ENDPOINT)); Recommendations = new RecommendationsRepository(HttpClient, new Uri(BaseUri, RecommendationsRepository.DEFAULT_ENDPOINT)); _search = new SearchRepository(HttpClient, new Uri(BaseUri, SearchRepository.DEFAULT_ENDPOINT)); }
public async Task should_add_new_item(Artist artist) { artist.ArtistId = Guid.NewGuid(); var sut = new ArtistRepository(_factory.ContextInstance); sut.Add(artist); await sut.UnitOfWork.SaveEntitiesAsync(); _factory.ContextInstance.Artists .FirstOrDefault(a => a.ArtistId == artist.ArtistId) .ShouldNotBeNull(); }
public async Task <IEnumerable <object> > ArtistLookup(string search = null) { if (string.IsNullOrEmpty(search)) { return(new List <object>()); } var repo = new ArtistRepository(context); var term = search.ToLower(); return(await repo.ArtistLookup(term)); }
/// <summary> /// DeleteButton action /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// <remarks> /// Delete Artist and all its tracks /// </remarks> private void DeleteButton_Click(object sender, RoutedEventArgs e) { var trackRepo = new TrackRepository(); var artistRepo = new ArtistRepository(); Artist artist = displayArtist.SelectedItem as Artist; foreach (Track t in artist.Tracks) { trackRepo.DeleteTrack(t.TrackId); } artistRepo.DeleteArtist(artist.ArtistId); this.NavigationService.Navigate(new DisplayArtistPage()); }
private void GetAlbumButton_Click_1(object sender, RoutedEventArgs e) { string idboxinput = AlbumIdBox.Text; int id = IntegerHandling(idboxinput); Album selectedAlbum = new Album(); selectedAlbum = AlbumRepository.GetAlbumById(id); GenreCombo.Text = GenreRepository.GetGenreById(selectedAlbum.GenreId).Name; ArtistCombo.Text = ArtistRepository.GetArtistNameById(selectedAlbum.ArtistId); TitleBox.Text = selectedAlbum.Title; PriceBox.Text = selectedAlbum.Price.ToString(); AlbumUrlBox.Text = selectedAlbum.AlbumArtUrl; }
public ArtistRepositoryTests() { var mockArtistSet = new Mock <DbSet <Artist> >(); var artists = TestDataGraph.Artists.ArtistsRaw; var data = artists.AsQueryable(); SetupMockDbSet(mockArtistSet, data); SetupMockSetOnMockContext(mockArtistSet); _repository = new ArtistRepository(MockContext.Object); }
public async Task should_add_new_item(Artist request) { request.ArtistId = Guid.NewGuid(); var sut = new ArtistRepository(_testDataContextFactory.ContextInstance); sut.Add(request); await sut.UnitOfWork.SaveEntitiesAsync(); _testDataContextFactory.ContextInstance.Artists .FirstOrDefault(x => x.ArtistId == request.ArtistId) .ShouldNotBeNull(); }
private async Task <AlbumController> CreateAlbumControllerAsync(IEnumerable <Album> testData) { await context.Albums.AddRangeAsync(testData); await context.SaveChangesAsync(); var albumRepository = new AlbumRepository(context); var artistRepository = new ArtistRepository(context); var pieceRepository = new PieceRepository(context); var service = new AlbumManager(albumRepository, artistRepository, pieceRepository); return(new AlbumController(service)); }
public UpdateAlbumsPage() { InitializeComponent(); IList <Genre> genreList = new List <Genre>(); genreList = GenreRepository.GetGenres(); GenreCombo.ItemsSource = genreList; List <Artist> ArtistList = new List <Artist>(); ArtistList = ArtistRepository.GetAllArtists(); ArtistCombo.ItemsSource = ArtistList; }
public void NullArtistIdIsSubmitted_ThrowException() { var options = new DbContextOptionsBuilder <VinylStoreDbContext>() .UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name) .Options; using (var context = new VinylStoreDbContext(options)) { var artistRepository = new ArtistRepository(context); Assert.ThrowsException <ArgumentNullException>(() => artistRepository.GetById(Guid.Empty)); } }
/// <summary> /// Validates an artist on the server /// before adding a new record or updating an existing record. /// </summary> /// <param name="artist">The artist to validate.</param> private void ValidateArtist(Artist artist) { // If there aren't any "Name" field validation errors... if (ModelState.IsValidField("Name")) { // Then make sure that the provided name is unique. if (ArtistRepository.UniqueArtist(artist)) { ModelState.AddModelError("Name", "The provided Name is in use by another artist."); } } }
public static IList <AlbumSummary> GetAlbumSummariesByGenre(int genreId) { IList <AlbumSummary> albumSummaries = new List <AlbumSummary>(); IList <Album> albums = AlbumRepository.GetAlbumsByGenre(genreId); string artist; foreach (var album in albums) { artist = ArtistRepository.GetArtistNameById(album.ArtistId); albumSummaries.Add(new AlbumSummary(album.Title, artist, string.Format("€{0:N2}", album.Price))); } return(albumSummaries); }
public AlbumService(AlbumRepository albumRepository, AlbumListQuery albumListQuery, AlbumReviewListQuery albumReviewListQuery, AlbumReviewRepository albumReviewRepository, ArtistRepository artistRepository, SongListQuery songListQuery, SongRepository songRepository, ArtistListQuery artistListQuery, ClientRepository clientRepository) { this.albumRepository = albumRepository; this.albumListQuery = albumListQuery; this.albumReviewRepository = albumReviewRepository; this.albumReviewListQuery = albumReviewListQuery; this.artistRepository = artistRepository; this.songListQuery = songListQuery; this.songRepository = songRepository; this.artistListQuery = artistListQuery; this.clientRepository = clientRepository; }
/// <summary> /// Initializes the view model. /// </summary> public override void Init(Repository repository, ComicBookSeriesRepository seriesRepo, ArtistRepository artistRepo ) { base.Init(repository, seriesRepo, artistRepo); ArtistSelectListItems = new SelectList( artistRepo.GetList(), "Id", "Name"); RoleSelectListItems = new SelectList( repository.GetRoles(), "Id", "Name"); }
static void Main(string[] args) { var artistRepo = new ArtistRepository(); WriteConnectionString(artistRepo); AddOrUpdateArtistIfExists(artistRepo); DisplayArtists(artistRepo); DisplaySoloArtists(artistRepo); Console.ReadKey(); }
/// <summary> /// Check if track of this name exist in choosen artist collection /// </summary> /// <param name="trackName">Name of track </param> /// <param name="artistName">Name of artist</param> /// <returns> Returns true if track exits in artis collection or false if doesn't </returns> private bool TrackAlreadyExist(string trackName, string artistName) { var artistRepo = new ArtistRepository(); var tracks = artistRepo.GetArtist(artistName).Tracks; foreach (Track t in tracks) { if (t.Name == trackName) { return(true); } } return(false); }
public async void GetAllArtists() { // Arrange var _db = ArrangeDesignData.Arrange_Db(); var _artistRepository = new ArtistRepository(_db); // Action var Artists = await _artistRepository.GetAll(); // Assert Assert.AreEqual(2, Artists.Count(), "Expected 2 artists to be returned"); }
/// <summary> /// Constructor of UpdateTrackPage /// </summary> /// <param name="track"> Track that we want to update, requires Track object </param> /// <remarks> /// Fill boxes with oldTrack data and initilaize combobox /// </remarks> public UpdateTrackPage(Track track) { InitializeComponent(); IArtistRepository repo = new ArtistRepository(); string[] artistsNames = repo.GetArtistNames(); uArtistSelect.ItemsSource = artistsNames; oldTrack = track; uArtistSelect.SelectedItem = track.Artist.Name; uTrackNameBox.Text = track.Name; uYoutubeTrackPathBox.Text = track.YoutubePath; }
private async Task <ChartManager> CreateChartService(IEnumerable <Chart> testData) { await context.Charts.AddRangeAsync(testData); await context.SaveChangesAsync(); var chartRepository = new ChartRepository(context); var pieceRepository = new PieceRepository(context); var albumRepository = new AlbumRepository(context); var artistRepository = new ArtistRepository(context); var service = new ChartManager(chartRepository, albumRepository, pieceRepository, artistRepository); return(service); }
public AlbumViewerApiController( AlbumViewerContext ctx, IServiceProvider svcProvider, ArtistRepository artistRepo, AlbumRepository albumRepo, IConfiguration config) { context = ctx; serviceProvider = svcProvider; Configuration = config; AlbumRepo = albumRepo; ArtistRepo = artistRepo; }
public override void OnInitMain(Wildcat.DB.System.Block block) { if(Params.ContainsKey("id")) { Repository.ArtistRepository repository = new ArtistRepository(); Model = repository.GetByUrl(Params["id"]); } Albums albums = new Albums(); albums.Parent = this; albums.Name = "albums"; Blocks.Add(albums.Name, albums); base.OnInitMain(block); }
private static void DisplaySoloArtists(ArtistRepository artistRepo) { var artists = artistRepo.GetSoloArtists(); Console.WriteLine("Solo artists found"); if (artists.Any()) { artists.ForEach(a => WriteArtist(a)); } else { Console.WriteLine("No Solo artists found"); } }
public async Task getartist_should_return_right_data() { var artistRepository = new ArtistRepository(_catalogContextFactory.ContextInstance); var itemRepository = new ItemRepository(_catalogContextFactory.ContextInstance); var sut = new ArtistService(artistRepository, itemRepository, _catalogContextFactory.ArtistMapper, _catalogContextFactory.ItemMapper); var result = await sut.GetArtistsAsync(); result .ToList().Count.ShouldBe(2); }
private async Task <ReviewManager> CreateReviewService(IEnumerable <Review> testData) { await context.Reviews.AddRangeAsync(testData); await context.SaveChangesAsync(); var reviewRepository = new ReviewRepository(context); var userRepository = new UserRepository(context); var pieceRepository = new PieceRepository(context); var albumRepository = new AlbumRepository(context); var artistRepository = new ArtistRepository(context); var service = new ReviewManager(reviewRepository, pieceRepository, albumRepository, artistRepository, userRepository); return(service); }
public ActionResult Edit(Artist artist) { ValidateArtist(artist); if (ModelState.IsValid) { ArtistRepository.Update(artist); TempData["Message"] = "Your artist was successfully updated!"; return(RedirectToAction("Detail", new { id = artist.Id })); } return(View(artist)); }
/// <summary> /// Initializes the view model. /// </summary> public override void Init(Repository repository, SeriesRepository seriesRepository, ArtistRepository artistRepository) { base.Init(repository, seriesRepository, artistRepository); ArtistSelectListItems = new SelectList( artistRepository.GetList(), "Id", "Name"); // TODO Get the artitsts list. RoleSelectListItems = new SelectList( repository.GetRoles(), "Id", "Name"); // TODO Get the roles list. }
public IActionResult GetByName(string name) { ArtistRepository repo = new ArtistRepository(_configuration); var result = repo.GetByName(name); if (result.Id != 0) { return(Ok(result)); } else { return(Ok(null)); } }
public IActionResult GetById(int id) { ArtistRepository repo = new ArtistRepository(_configuration); var result = repo.GetById(id); if (result.Id != 0) { return(Ok(result)); } else { return(Ok(null)); } }
public async void InitializeWindow() { SingletonMainWindows.SetSingletonWindow(this); loadProgressTrackTimer = new DispatcherTimer(); loadProgressTrackTimer.Tick += new EventHandler(PrintProgress); loadProgressTrackTimer.Interval = new TimeSpan(0, 0, 0, 1); if (SingletonSesion.GetSingletonSesion().account.contentCreator) { ItemCreator.Visibility = Visibility.Visible; if (await ArtistRepository.GetArtistOfAccount(SingletonSesion.GetSingletonSesion().account.idAccount)) { Console.WriteLine("Artist profile loaded: " + SingletonArtist.GetSingletonArtist().name); } } }
private static void AddOrUpdateArtistIfExists(ArtistRepository artistRepo) { var artist = Artist.Generate("First artist", Address.Generate("1", "BB Street"), "The first artist"); artist.Add(Album.Generate("First Title")); artist.Add(Album.Generate("Second Title")); var existingArtist = artistRepo.GetByName(artist.Name).FirstOrDefault(); if (existingArtist == null) { artistRepo.Add(artist); } else { existingArtist.SetNickName(string.Format("Artist updated {0}", DateTime.Now)); artistRepo.Update(existingArtist); } artistRepo.SaveChanges(); }
/// <summary> /// Metodo encargado de interactuar con la capa de datos para realizar las inserciones en la base de datos local /// </summary> /// <param name="tracksToInsert">Lista de tracks por ingresar</param> private void InsertIntoDatabase(List<TrackInfo> tracksToInsert) { ArtistRepository artistRepo = new ArtistRepository(); AlbumRepository albumRepo =new AlbumRepository(); TrackRepository trackRepo =new TrackRepository(); UserTrackRepository usertracksRepo = new UserTrackRepository(); foreach (TrackInfo trackInfo in tracksToInsert) { Artist trackArtist = GetArtistByTitle(trackInfo.ArtistTitle); if (trackArtist == null) { //Creates new artist and insert into database trackArtist = new Artist() {ArtistID = Guid.NewGuid(), Title = trackInfo.ArtistTitle}; artistRepo.Add(trackArtist); artistRepo.SaveChanges(); } else { //artistRepo.Attach(trackArtist); } Album trackAlbum = GetAlbumByTitleAndArtistTitle(trackInfo.AlbumTitle,trackArtist.Title); if (trackAlbum == null) { //Set trackAlbum as new Album trackAlbum= new Album() {AlbumID = Guid.NewGuid(),ArtistID = trackArtist.ArtistID,Title = trackInfo.AlbumTitle, ReleaseYear = trackInfo.Year}; albumRepo.Add(trackAlbum); albumRepo.SaveChanges(); } else { //albumRepo.Attach(trackAlbum); } //Creates new track Track newTrack=new Track() {AlbumID = trackAlbum.AlbumID,Title = trackInfo.Title, Genre =trackInfo.Genre,Lyrics = trackInfo.Lyric,Path = trackInfo.SongPath,TrackID = trackInfo.TrackId}; usertracksRepo.Add(new UserTrack() {UserID = SessionManager.Instance.UserId,TrackID = trackRepo.Add(newTrack).TrackID,IsSync = false}); //artistRepo.SaveChanges(); trackRepo.SaveChanges(); } usertracksRepo.SaveChanges(); artistRepo.Dispose(); trackRepo.Dispose(); usertracksRepo.Dispose(); }
/// <summary> /// Obtiene el artista almacenado en la base de datos por su nombre /// </summary> /// <param name="artistTitle">Nombre de Artista</param> /// <returns>Retorna el artista si existe, sino retorna null</returns> private Artist GetArtistByTitle(string artistTitle) { ArtistRepository repository = new ArtistRepository(); List<Artist> artists = repository.GetArtistByTitle(artistTitle); Artist artist=null; if (artists.Count>0) artist = artists.First(); repository.Dispose(); return artist; }
public ArtistController() { this.context = new ArtistRepository(new MusicSystemDbContext()); }
protected override void OnResume() { base.OnResume(); // Referenser i OnResume() _repository = new ArtistRepository(); }
public RepositoryRegistry() { For<ICredentialRepository>() .Use(factory => { return new CredentialRepository(factory.GetInstance<Entities>()); }); For<IProfileRepository>() .Use(factory => { var repository = new ProfileRepository(factory.GetInstance<Entities>()); return repository; }); For<IProfileActivityRepository>() .Use(factory => { var repository = new ProfileActivityRepository(factory.GetInstance<Entities>()); return repository; }); For<IGrunkerRepository>() .Use(factory => { var repository = new GrunkerRepository(factory.GetInstance<Entities>()); return repository; }); For<IActivityTypeRepository>() .Use(factory => { var repository = new ActivityTypeRepository(factory.GetInstance<Entities>()); return repository; }); For<IPictureRepository>() .Use(factory => { var repository = new PictureRepository(factory.GetInstance<Entities>()); return repository; }); For<IGenreRepository>() .Use(factory => { var repository = new GenreRepository(factory.GetInstance<Entities>()); return repository; }); For<IArtistRepository>() .Use(factory => { var repository = new ArtistRepository(factory.GetInstance<Entities>()); return repository; }); For<IAlbumRepository>() .Use(factory => { var repository = new AlbumRepository(factory.GetInstance<Entities>()); return repository; }); For<IPurchaseRepository>() .Use(factory => { var repository = new PurchaseRepository(factory.GetInstance<Entities>()); return repository; }); For<IReviewRepository>() .Use(factory => { var repository = new ReviewRepository(factory.GetInstance<Entities>()); return repository; }); For<IReviewLinkRepository>() .Use(factory => { var repository = new ReviewLinkRepository(factory.GetInstance<Entities>()); return repository; }); For<IStoreDetailsRepository>() .Use(factory => { var repository = new StoreDetailsRepository(HttpContext.Current.Server.MapPath("~/App_Data/storedetails.xml")); return repository; }); For<IStaticTextRepository>() .Use(factory => { var repository = new StaticTextRepository(factory.GetInstance<Entities>()); return repository; }); }
public void Save() { Database db = Microsoft.Practices.EnterpriseLibrary.Data.DatabaseFactory.CreateDatabase(); if (_artist.ArtistId == 0) { //ADD ARTIST IRepository<IArtist> artist = new ArtistRepository(db); IRepositoryBLL<IArtist> artistRepoBll = new ArtistRepositoryBLL(artist); _artist = artistRepoBll.Add(_artist); //ADD ARTIST CONTACT IRepository<IArtistContact> contact1 = new ArtistContactRepository(db); IRepositoryBLL<IArtistContact> contactBll = new ArtistContactRepositoryBLL(contact1); _artistContact.ArtistId = _artist.ArtistId; _artistContact = contactBll.Add(_artistContact); //ADD DISCOGRAPHY IRepository<IDiscography> disco = new DiscographyRepository(db); IRepositoryBLL<IDiscography> discoBll = new DiscographyRepositoryBLL(disco); _discography.ArtistId = _artist.ArtistId; _discography = discoBll.Add(_discography); } if (_album.AlbumId == 0) { //ADD ALBUM IRepository<IAlbum> album1 = new AlbumRepository(db); IRepositoryBLL<IAlbum> albumBll = new AlbumRepositoryBLL(album1); _album.ArtistId = _artist.ArtistId; _album = albumBll.Add(_album); } //ADD SONGS IRepository<ISong> song1 = new SongRepository(db); IRepositoryBLL<ISong> songBll = new SongRepositoryBLL(song1); foreach (Song item in _songs) { item.AlbumId = _album.AlbumId; songBll.Add(item); } }
private static void WriteConnectionString(ArtistRepository artistRepo) { Console.WriteLine(string.Format("Connection string: {0}", artistRepo.ConnectionString)); }