// Fetch given album and from there its release year
public async Task <string> GetAlbumReleaseYearAsync(string token, string albumID)
{
string releaseYear = null;
string Endpoint = "https://api.spotify.com/v1/albums/";
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
string value = "Bearer " + token;
client.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", value);
HttpResponseMessage response = new HttpResponseMessage();
string requestParameters = albumID;
string uri = Endpoint + requestParameters;
response = await client.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
var httpContent = response.Content;
StreamReader reader = new StreamReader(await httpContent.ReadAsStreamAsync(), Encoding.UTF8);
AlbumDTO album = (AlbumDTO)JsonConvert.DeserializeObject(reader.ReadToEnd(), typeof(AlbumDTO));
// determine release year
releaseYear = album.Release_Date.Substring(0, 4);
}
return(releaseYear);
}
public List <SongDTO> loadAllSongs()
{
int songID;
string title, lyrics, dateRelease, linkOpen, linkDownLoad, image;
ArtistDTO artis;
int artisID;
string artisName;
AlbumDTO album;
int albumID;
string albumName;
SongDTO song = null;
List <SongDTO> result = new List <SongDTO>();
using (sqlConnection = new SqlConnection(connectionString))
{
try
{
sqlConnection.Open();
using (command = new SqlCommand("" +
"Select Songs.ID, Songs.title,Songs.lyrics,Songs.dateRelease,Songs.linkOpen,Songs.linkDownLoad,Songs.image,Artists.ID,Artists.name,Albums.ID,Albums.name " +
"From Songs, Artists, Albums, Song_Album_Artist " +
"Where Song_Album_Artist.albumID = Albums.ID AND Song_Album_Artist.songID = Songs.ID AND Song_Album_Artist.artistID = Artists.ID",
sqlConnection))
using (reader = command.ExecuteReader())
{
while (reader.Read())
{
//songs
songID = reader.GetInt32(0);
title = reader.GetString(1);
lyrics = reader.GetString(2);
dateRelease = reader.GetDateTime(3).ToString("yyyy-MM-dd");
linkOpen = reader.GetString(4);
linkDownLoad = reader.GetString(5);
image = reader.GetString(6);
//artis
artisID = reader.GetInt32(7);
artisName = reader.GetString(8);
artis = new ArtistDTO(artisID, artisName);
//album
albumID = reader.GetInt32(9);
albumName = reader.GetString(10);
album = new AlbumDTO(albumID, albumName);
song = new SongDTO(songID, title, lyrics, dateRelease, linkOpen, linkDownLoad, image, artis, album);
result.Add(song);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
finally
{
closeConnect();
}
}
return(result);
}
public void CreateAlbumTest()
{
Assert.AreEqual(2, _albumService.ListAlbums(null).Count());
var interpret3 = new InterpretDTO
{
ID = 3,
Name = "Kabat",
Language = Language.Czech,
IsPublic = false
};
_interpretService.CreateInterpret(interpret3);
var album3 = new AlbumDTO
{
ID = 3,
InterpretId = _interpret1Id,
Name = "Dole v dole",
Year = 2003
};
_albumService.CreateAlbum(album3, interpret3.ID);
Assert.AreEqual(3, _albumService.ListAlbums(null).Count());
}
private void btUpdate_Click(object sender, EventArgs e)
{
string id = txtID.Text;
string name = txtAlbumName.Text;
if (addNew)
{
if (checkValidate())
{
AlbumDTO albumDTO = new AlbumDTO(int.Parse(id), name, "albumDefault.jpg");
if (albumDAO.addAlbum(albumDTO))
{
MessageBox.Show("Add new successfully");
}
else
{
MessageBox.Show("Add new failed");
}
}
}
else
{
AlbumDTO albumDTO = new AlbumDTO(int.Parse(id), name);
if (albumDAO.updateAlbum(albumDTO))
{
MessageBox.Show("Update successfully");
}
else
{
MessageBox.Show("Update failed");
}
}
refreshUI();
}
public Boolean updateAlbum(AlbumDTO dto)
{
Boolean check = false;
using (sqlConnection = new SqlConnection(connectionString))
{
try
{
sqlConnection.Open();
command = new SqlCommand("UPDATE Albums SET name = @name " +
"WHERE ID = @id", sqlConnection);
command.Parameters.AddWithValue("@id", dto.Id);
command.Parameters.AddWithValue("@name", dto.Name);
check = command.ExecuteNonQuery() > 0;
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
finally
{
closeConnect();
}
}
return(check);
}
public void SortTest()
{
Assert.AreEqual(_albumReview2.Rating,
_albumReviewService.ListAlbumReviews(new AlbumReviewFilter {
SortAscending = true
}).First().Rating);
var albumId = 3;
var album3 = new AlbumDTO
{
ID = albumId,
InterpretId = _interpret2Id,
Name = "Hybrid Theory",
Year = 2000
};
_albumService.CreateAlbum(album3, _interpret2Id);
var albumReview = new AlbumReviewDTO
{
AlbumId = albumId,
Note = "Not bad",
Rating = 9,
ID = _albumReview2Id
};
_albumReviewService.CreateAlbumReview(albumReview, albumId);
Assert.AreEqual(_albumReview1.Rating,
_albumReviewService.ListAlbumReviews(new AlbumReviewFilter {
SortAscending = false
}).First().Rating);
}
public void create()
{
AlbumDTO aDTO = new AlbumDTO(name, releaseYear, genre, interpret, coverpath);
AlbumDAO aDAO = new AlbumDAO();
aDAO.insertAlbum(aDTO);
}
public ArtistController()
{
services = new GoogleDriveServices(HttpContext.Current.Server.MapPath("~/"));
dto = new ArtistDTO(HttpContext.Current.Request.Url);
albumDto = new AlbumDTO(HttpContext.Current.Request.Url);
songDto = new SongDTO(HttpContext.Current.Request.Url);
}
public void UpdateAlbum(AlbumDTO albumDTO)
{
Album album = mapperDTOToEntity.Map <AlbumDTO, Album>(albumDTO);
Database.Albums.Update(album);
SaveChangesInDatabase();
}
private void btnSave_Click(object sender, EventArgs e)
{
FunctionController fc = new FunctionController();
AlbumDTO aDTO = new AlbumDTO(edDetailEditingAlbumName.Text, edDetailEditingAlbumYear.Text, fc.getGenreIdByName(edDetailEditingAlbumGenre.Text), fc.getInterpretIdByName(edDetailEditingAlbumInterpret.Text), coverpath);
fc.updateAlbum(aDTO);
}
public async Task <ActionResult <AlbumDTO> > GetAlbum(string title)
{
Album album = await _context.Albums
.Include(a => a.Artist)
.Include(s => s.Songs)
.FirstOrDefaultAsync(x => x.Title.ToLower() == title.ToLower());
if (album == null)
{
return(NotFound("Not found"));
}
List <SongDTO> songs = new List <SongDTO>();
foreach (var song in album.Songs)
{
songs.Add(SongToDto(song));
}
songs.Sort((o, t) => o.TrackNo - t.TrackNo ?? 0);
AlbumDTO albumDTO = new AlbumDTO
{
Artist = album.Artist.Name,
Songs = songs,
Id = album.Id,
ArtistId = album.ArtistId,
Title = album.Title,
ReleaseDate = album.ReleaseDate
};
return(Ok(albumDTO));
}
public Boolean addAlbum(AlbumDTO dto)
{
Boolean check = false;
using (sqlConnection = new SqlConnection(connectionString))
{
try
{
sqlConnection.Open();
using (command = new SqlCommand("Insert into " +
" Albums(ID,name,image) " +
" Values (@ID, @name,@image)", sqlConnection))
{
command.Parameters.AddWithValue("@ID", dto.Id);
command.Parameters.AddWithValue("@name", dto.Name);
command.Parameters.AddWithValue("@image", dto.Image);
check = command.ExecuteNonQuery() > 0;
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
finally
{
closeConnect();
}
}
return(check);
}
public async Task <ActionResult <Album> > Post([FromBody] AlbumDTO model, [FromServices] MaiaContext context)
{
var album = model.ToEntity();
try
{
context.Add(album);
var artista = await context.Artistas.Where(a => a.Id == album.ArtistaId).FirstOrDefaultAsync();
foreach (var musica in album.Musicas)
{
context.ArtistaMusicas.Add(new ArtistaMusica()
{
Artista = artista, Musica = musica
});
}
if (await context.SaveChangesAsync() > 0)
{
return(Created($"albuns/id/{album.Id}", album));
}
return(BadRequest());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
AlbumDTO albumDto = await albumService.FindByIdAsync((int)id);
if (albumDto == null)
{
return(HttpNotFound());
}
Mapper.Initialize(cfg => cfg.CreateMap <AlbumDTO, AlbumViewModel>()
);
AlbumViewModel albumVM = Mapper.Map <AlbumDTO, AlbumViewModel>(albumDto);
if (albumVM.Public == false && albumVM.UserId != User.Identity.GetUserId())
{
return(View("PrivateAlbum"));
}
UserDTO userDto = await userService.FindByIdAsync(albumDto.UserId);
albumVM.UserName = userDto.UserName;
IQueryable <PostDTO> posts = postService.GetAll()
.Where(x => x.AlbumId == albumDto.Id);
Mapper.Initialize(cfg => cfg.CreateMap <PostDTO, PostViewModel>());
albumVM.Posts = Mapper.Map <IQueryable <PostDTO>, IEnumerable <PostViewModel> >(posts);
return(View(albumVM));
}
public void Post(AlbumDTO value)
{
Album model = new Album()
{
Name = value.Name,
ReleaseYear = value.ReleaseYear,
StudioId = value.StudioId
};
IAlbumRepository.Create(model);
for (int i = 0; i < value.ArtistId.Count; i++)
{
ArtistAlbum ArtistAlbum = new ArtistAlbum()
{
AlbumId = model.Id,
ArtistId = value.ArtistId[i]
};
IArtistAlbumRepository.Create(ArtistAlbum);
}
for (int i = 0; i < value.SongId.Count; i++)
{
SongAlbum SongAlbum = new SongAlbum()
{
AlbumId = model.Id,
SongId = value.ArtistId[i]
};
ISongAlbumRepository.Create(SongAlbum);
}
}
public ContentResult GetDirectAlbumLink(Guid id)
{
AlbumDTO albumDto = _albumServices.GetAlbum(id);
string link = Request.Url.GetLeftPart(UriPartial.Authority) + "/" + albumDto.TitleSlug;
return(Content(link));
}
public UpdateAlbum()
{
_album = new AlbumDTO();
_load = new LoadDTO();
_engine = new Engine();
_read = new ReadAlbum();
}
/// <summary>
/// Creates new album
/// </summary>
/// <param name="item">Album</param>
/// <exception cref="ArgumentNullException">When input item is null</exception>
/// <exception cref="UserNotFoundException">When user not found</exception>
public void AddAlbum(AlbumDTO item)
{
if (item == null)
{
throw new ArgumentNullException();
}
var user = Database.Users.Get(item.UserId);
if (user == null)
{
throw new UserNotFoundException();
}
var album = new Album()
{
Name = item.Name,
Description = item.Description,
UserId = user.Id,
User = user,
Pictures = Mapper.Map <ICollection <PictureDTO>, ICollection <Picture> >(item.Pictures)
};
Database.Albums.Create(album);
Database.Save();
}
public async Task <ActionResult> Create(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AlbumDTO albumDto = await albumService.FindByIdAsync((int)id);
if (albumDto == null)
{
return(HttpNotFound());
}
string userId = albumDto.UserId;
if (userId != User.Identity.GetUserId())
{
return(RedirectToAction("Index", "Home"));
}
CreatePostViewModel postVM = new CreatePostViewModel()
{
AlbumId = albumDto.Id
};
return(View(postVM));
}
// GET: Albums/Edit/5
public ActionResult Display(string id, AlbumDTO album)
{
AlbumDisplayViewModel vm = new AlbumDisplayViewModel();
vm.Photos = _service.ListPhotos(album);
vm.Title = id;
return(View(vm));
}
//
// GET: /StoreManager/Edit/5
public async Task <IActionResult> Edit(int id)
{
AlbumDTO album = await _catalogService.GetMusic(id);
GetArtistsAndGenres(album);
return(View(album));
}
private void parseAlbum(IViewModel viewModel, AlbumDTO output)
{
IAlbumViewModel input = viewModel as IAlbumViewModel;
output.Id = input.Id;
output.Naziv = input.Naziv;
output.KataloskiBroj = input.KataloskiBroj;
output.GodinaIzdanja = input.GodinaIzdanja;
}
public ActionResult CreateAlbum(AlbumDTO albumDTO)
{
if (ModelState.IsValid)
{
albumDTO.amountOfLikes = 0;
_photoAlbumsService.CreateAlbum(albumDTO);
}
return(RedirectToAction("EditAlbum", "Home", new { albumId = albumDTO.Id, userId = albumDTO.UserId, name = albumDTO.Name, description = albumDTO.Description }));
}
private Album createModel(AlbumDTO albumDTO)
{
return(new Album
{
AlbumId = albumDTO.AlbumId,
Name = albumDTO.Name,
Year = albumDTO.Year
});
}
public List <ArtistDTO> GetArtists(ArtistsPageFilter filter)
{
//var filterArtists = Builders<Artist>.Filter.ElemMatch(x => x.Name, Builders<Album>.Filter.AnyIn(x => x.SongsIds, songsIds));
//var filterArtists = Builders<Artist>.Filter.Regex(x => x.Name,".*"+ filter.SearchText+ ".*");
var filterArtists = Builders <Artist> .Filter.Regex(x => x.Name, new BsonRegularExpression($".*{filter.SearchText}.*"));
var userLibSongIds = libraryDbList.Find(l => l.Id == filter.LibraryId).FirstOrDefault().SongsIds;
var artists = artistsDbList.Find(filterArtists).Skip(filter.PageIndex * filter.PageSize)
.Limit(filter.PageSize).ToList();
var allSongsIds = artists.SelectMany(a => a.Albums.SelectMany(aa => aa.SongsIds));
var songsFilter = Builders <Song> .Filter.In(x => x.Id, allSongsIds);
var songs = songsDbList.Find(songsFilter).ToList();
var artistsDTOs = new List <ArtistDTO>();
foreach (var artist in artists)
{
var artistDTO = new ArtistDTO();
artistDTO.Id = artistDTO.Id;
artistDTO.Name = artist.Name;
artistDTO.UrlPicture = artist.UrlPicture;
artistDTO.Albums = new List <AlbumDTO>();
foreach (var album in artist.Albums)
{
var albumDTO = new AlbumDTO();
albumDTO.Id = album.Id;
albumDTO.Name = album.Name;
albumDTO.UrlPicture = album.UrlPicture;
albumDTO.Songs = new List <SongSimpleDTO>();
foreach (var songId in album.SongsIds)
{
var song = songs.FirstOrDefault(s => s.Id == songId);
var songDTO = new SongSimpleDTO()
{
Id = song.Id,
Name = song.Name,
Url = song.Url,
IsInLibrary = userLibSongIds.Contains(song.Id)
};
albumDTO.Songs.Add(songDTO);
}
artistDTO.Albums.Add(albumDTO);
}
artistsDTOs.Add(artistDTO);
}
return(artistsDTOs);
}
public ActionResult Edit(AlbumDetailViewModel albumDetailViewModel)
{
if (ModelState.IsValid)
{
AlbumDTO albumDto = Mapper.Map <AlbumDTO>(albumDetailViewModel);
_albumServices.UpdateAlbum(albumDto);
return(RedirectToAction("Manage", new { id = albumDetailViewModel.Id }));
}
return(View(albumDetailViewModel));
}
public async Task <ActionResult> Delete(int id)
{
AlbumDTO albumDto = await albumService.FindByIdAsync(id);
if (albumDto.UserId == User.Identity.GetUserId())
{
await albumService.DeleteByIdAsync(id);
}
return(RedirectToAction("MyAlbums"));
}
// GET: Photos
public ActionResult Photos(int albumId)
{
AlbumDTO album = _photoAlbumsService.GetAlbum(albumId);
ViewBag.Album = album;
IEnumerable <PhotoDTO> photos = _photoAlbumsService.GetPhotosOfAlbum(albumId);
return(View(photos));
}
public async Task UpdateAlbumAsync(AlbumDTO album)
{
if (album == null)
{
throw new ArgumentNullException();
}
Album albumToUpdate = new Album(album.AlbumId, album.Title, album.Price);
await _albumRepository.UpdateAsync(albumToUpdate);
}
public AlbumController()
{
services = new GoogleDriveServices(HttpContext.Current.Server.MapPath("~/"));
Uri uri = HttpContext.Current.Request.Url;
dto = new AlbumDTO(uri);
songDto = new SongDTO(uri);
commentDto = new CommentDTO(uri);
rankingAlbumDto = new RankingAlbumDTO(uri);
}
