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);
}
static void Main(string[] args)
{
var artistRepo = new ArtistRepository();
WriteConnectionString(artistRepo);
AddOrUpdateArtistIfExists(artistRepo);
DisplayArtists(artistRepo);
DisplaySoloArtists(artistRepo);
Console.ReadKey();
}
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));
}
