Beispiel #1
0
        public async Task <ActionResult <RoomSong> > AddVoteToSong(string userToken, int roomId, int songId, short songRating)
        {
            if (string.IsNullOrEmpty(userToken))
            {
                throw new ArgumentException();
            }
            if (songRating != -1 && songRating != 1)
            {
                throw new ArgumentException("Invalid vote", nameof(songRating));
            }

            try
            {
                var token = await _context.Tokens.SingleOrDefaultAsync(s => s.JWTToken == userToken);

                var room = await _context.Rooms
                           .Include(e => e.RoomSongs)
                           .ThenInclude(e => e.Song)
                           .Include(e => e.RoomSongs)
                           .ThenInclude(e => e.RoomSongTokens)
                           .Include(e => e.SpotifyPlaylist)
                           .SingleOrDefaultAsync(s => s.Id == roomId);

                if (room == null)
                {
                    return(NotFound());
                }

                var roomSong = room.RoomSongs.SingleOrDefault(s => s.SongId == songId);

                if (roomSong.RoomSongTokens != null && roomSong.RoomSongTokens.Any(s => s.Token == token))
                {
                    return(BadRequest());
                }

                roomSong.SongRating += songRating;

                var roomSongToken = new RoomSongToken()
                {
                    Token   = token,
                    TokenId = token.Id,
                };
                roomSong.RoomSongTokens.Add(roomSongToken);

                await _context.SaveChangesAsync();

                if (room.IsSpotifyEnabled)
                {
                    var service = new SpotifyService(room.SpotifyPlaylist.AuthCode);
                    await service.ReorderPlaylist(room.SpotifyPlaylist, room, roomSong);
                }


                return(roomSong);
            }
            catch (Exception ex)
            {
                throw new SystemWeb.HttpResponseException(HttpStatusCode.InternalServerError);
            }
        }
Beispiel #2
0
        public async Task <Room> AddVoteToSong(string userToken, int roomId, int songId, short vote)
        {
            if (string.IsNullOrEmpty(userToken))
            {
                throw new ArgumentException();
            }
            if (vote != -1 && vote != 1)
            {
                throw new ArgumentException("Invalid vote", nameof(vote));
            }

            try
            {
                var room = await _playlistsContext.Rooms
                           .Include(e => e.RoomSongs)
                           .ThenInclude(e => e.Song)
                           .Include(e => e.RoomSongs)
                           .ThenInclude(e => e.RoomSongTokens)
                           .ThenInclude(e => e.Token)
                           .Include(e => e.SpotifyPlaylist)
                           .SingleOrDefaultAsync(s => s.Id == roomId);

                if (room == null)
                {
                    throw new Exception("Could not find room");
                }

                if (room.RoomSongs.Any(s => s.RoomSongTokens.Any(c => c.Token.JWTToken == userToken) && s.SongId == songId))
                {
                    throw new Exception("User already voted on this song");
                }

                var roomSong = room.RoomSongs.SingleOrDefault(s => s.SongId == songId);
                roomSong.SongRating += vote;

                var existingToken = _playlistsContext.Tokens.FirstOrDefault(s => s.JWTToken == userToken);
                var roomSongToken = new RoomSongToken()
                {
                    Token = existingToken ?? new Token()
                    {
                        JWTToken = userToken
                    },
                    TokenId = existingToken?.Id ?? 0,
                };
                roomSong.RoomSongTokens.Add(roomSongToken);

                await _playlistsContext.SaveChangesAsync();

                return(roomSong.Room);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }