// 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); }