/// <summary>
/// プレイリストを生成する(スレッド)
/// </summary>
private void CreatePlaylistProc()
{
SetupConnection();
while (true)
{
try
{
CreatePlaylistRequest req;
if (Request.QueryText == null)
{
Thread.Sleep(System.Threading.Timeout.Infinite);
}
//createPlaylistからinterruptが連続で発行されたとき、このsleep内で捕捉する
Thread.Sleep(10);
req = Request;
Request = new CreatePlaylistRequest();
CreatePlaylistTableInDB(req.QueryText);
Controller._PlaylistUpdated(req.IsReloadOnly ? null : req.QueryText);
if (req.PlayOnCreate)
{
AppCore.PlayPlaylistItem(0);
}
}
catch (ThreadInterruptedException) { }
}
}
public async Task ShouldCreatePlaylistWithAllParams()
{
// Arrange
var request = new CreatePlaylistRequest()
{
Name = "Test Playlist",
Description = "Test Playlist Description",
Collaborative = true,
Public = true
};
this.MockHttp
.ExpectSpotifyRequest(HttpMethod.Post, $"users/{TestsBase.UserId}/playlists")
.WithExactQueryString(string.Empty)
.WithJsonContent(j =>
j.EnumerateObject().Count() == 4 &&
j.TryGetProperty("name", out var name) && name.GetString() == request.Name &&
j.TryGetProperty("description", out var description) && description.GetString() == request.Description &&
j.TryGetProperty("collaborative", out var collaborative) && collaborative.GetBoolean() == request.Collaborative &&
j.TryGetProperty("public", out var @public) && @public.GetBoolean() == request.Public)
.Respond(HttpStatusCode.OK, "application/json", "{}");
// Act
var builder = this.GetPlaylistsBuilder();
var result = await builder.CreateAsync(request);
// Assert
this.MockHttp.VerifyNoOutstandingExpectation();
result.Should().NotBeNull();
}
/// <summary>
/// プレイリストを生成
/// </summary>
/// <param name="query">クエリ</param>
/// <param name="playOnCreate">生成後に再生開始</param>
internal void CreatePlaylist(string query, bool playOnCreate = false)
{
Logger.Log("createPlaylist " + query);
Request = new CreatePlaylistRequest(query: query, playOnCreate: playOnCreate);
LibraryDB.interrupt();
PlaylistCreateThread.Interrupt();
}
public async Task <ValidationResponse> CreatePlayListAsync(CreatePlaylistRequest request)
{
var response = new ValidationResponse {
Success = true, HttpStatusCode = 200
};
spotifyApi = new SpotifyWebAPI
{
AccessToken = request.AccessToken,
TokenType = request.TokenType
};
var userId = await spotifyApi.GetPrivateProfileAsync();
var playlist = await spotifyApi.CreatePlaylistAsync(userId.Id, $"SpotifyTree - {request.PlaylistName}");
var addToPlaylist = await spotifyApi.AddPlaylistTracksAsync(playlist.Id, request.SongIds.ToList());
if (addToPlaylist.Error != null)
{
response.Success = false;
response.Message = addToPlaylist.Error.Message;
response.StatusCode = addToPlaylist.Error.Status;
response.HttpStatusCode = (int)addToPlaylist.StatusCode();
}
return(response);
}
public PlaylistResult CreatePlaylist([FromBody] CreatePlaylistRequest request)
{
CheckTokenResult checkTokenResult = _authService.CheckToken(AccessToken);
if (!checkTokenResult.Ok)
{
return(new PlaylistResult(checkTokenResult));
}
return(_playlistService.CreatePlaylist(checkTokenResult.AuthToken.UserId, request));
}
public async Task <IActionResult> CreatePlaylist([FromBody] CreatePlaylistRequest request)
{
var response = await _crawler.CreatePlayListAsync(request);
if (response.Success)
{
return(Ok());
}
else
{
return(BadRequest($"Error while creating playlist: {response.Message}; StatusCode: {response.StatusCode}"));
}
}
public async Task <ActionResult> Create([FromBody] CreatePlaylistRequest request)
{
var entity = new Playlist
{
Name = request.Name,
IsPublic = request.IsPublic,
OwnerId = UserId.Value
};
entity = _dbContext.Playlist.Add(entity).Entity;
_dbContext.SaveChanges();
return(CreatedAtAction(nameof(Create), entity));
}
public static Playlist CreatePlayList(SpotifyTokens spotifyTokens, string userId, string listName)
{
var client = GetClient();
client.Headers.Add("Authorization", "Bearer " + spotifyTokens.AccessToken);
client.Headers.Add("Content-Type", "application/json");
var request = new CreatePlaylistRequest
{
Name = listName,
Public = true
};
var serializedRequest = JsonConvert.SerializeObject(request);
var urlToCall = string.Format(Constants.SpotifyUrls.SpotifyUsersPlaylistsUrlWithPlaceholder, userId);
var result = client.UploadString(urlToCall, serializedRequest);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <Playlist>(result);
return(deserialized);
}
public async Task ShouldCreatePlaylist()
{
// Arrange
var request = new CreatePlaylistRequest()
{
Name = "Test Playlist"
};
this.MockHttp
.ExpectSpotifyRequest(HttpMethod.Post, $"users/{TestsBase.UserId}/playlists")
.WithExactQueryString(string.Empty)
.WithJsonContent(j => j.EnumerateObject().Count() == 1 && j.TryGetProperty("name", out var name) && name.GetString() == request.Name)
.Respond(HttpStatusCode.OK, "application/json", "{}");
// Act
var builder = this.GetPlaylistsBuilder();
var result = await builder.CreateAsync(request);
// Assert
this.MockHttp.VerifyNoOutstandingExpectation();
result.Should().NotBeNull();
}
public PlaylistResult CreatePlaylist(Guid userId, CreatePlaylistRequest request)
{
return(BaseInvokeCheckModel(request, () =>
{
var playlist = new DataModel.Playlist()
{
Id = Guid.NewGuid(),
IsGeneral = false,
OrderValue = 0,
OwnerId = userId,
Title = request.Title,
};
_dbContext.Playlists.Add(playlist);
_dbContext.SaveChanges();
return ResponseBuilder <PlaylistResult> .SuccessBuild(new PlaylistResult()
{
Playlist = PlaylistMapper.ToApi.FromData(playlist),
});
}));
}
public async Task <IActionResult> SpotParams([FromBody] CreatePlaylistRequest spotParams)
{
//get auth cookie
HttpContext.Request.Cookies.TryGetValue("spotauthtoke", out string auth);
if (!string.IsNullOrEmpty(spotParams.Id))
{
spotParams.AudioFeatures = true;
}
spotParams.Tempo = string.IsNullOrEmpty(spotParams.Tempo) ? null : spotParams.Tempo.Trim();
spotParams.Dance = string.IsNullOrEmpty(spotParams.Dance) ? null : spotParams.Dance.Trim();
spotParams.Energy = string.IsNullOrEmpty(spotParams.Energy) ? null : spotParams.Energy.Trim();
spotParams.Valence = string.IsNullOrEmpty(spotParams.Valence) ? null : spotParams.Valence.Trim();
//jsonify params
var jsonParams = JsonSerializer.Serialize(spotParams);
//send to spot api
var res = await _sas.Access("post", auth, "/Create", jsonParams).ConfigureAwait(true);
//get the response and be able to return a partial view
var playlistResponse = JsonSerializer.Deserialize <PlaylistResponse>(res, null);
if (playlistResponse.TrackCount == 0)
{
playlistResponse.Title = "Huh, maybe delete this one, nothing was added for " + playlistResponse.Title;
}
if (playlistResponse.Length < spotParams.Length * .90)
{
playlistResponse.Title = "Just FYI, your choices allowed " + playlistResponse.Title + " to not fully populate";
}
//returns okay response with a redirect to viewing the tracks?
return(PartialView("ViewPlaylists", new List <PlaylistResponse>()
{
playlistResponse
}));
}
public Task <Playlist> CreateAsync(CreatePlaylistRequest createPlaylistRequest, CancellationToken cancellationToken)
{
SpotifyArgumentAssertUtils.ThrowIfNull(createPlaylistRequest, nameof(createPlaylistRequest));
return(this.SendBodyAsync <CreatePlaylistRequest, Playlist>(HttpMethod.Post, createPlaylistRequest, cancellationToken));
}
public async Task <JsonResult> CreatePlaylist([FromBody] CreatePlaylistRequest req)
{
string ClaimsUserID = User.Claims.FirstOrDefault()?.Value;
return(new JsonResult(await _playlist.CreatePlaylist(req.Name, ClaimsUserID, req.Favourite)));
}
public abstract Task <Response <Playlist, object> > CreatePlaylist(CreatePlaylistRequest request);
/// <summary>
/// 直前に生成したプレイリストと同クエリでプレイリストを再生成
/// </summary>
internal void RefreshPlaylist()
{
Request = new CreatePlaylistRequest(query: LatestPlaylistQueryExpanded, isReloadOnly: true);
LibraryDB.interrupt();
PlaylistCreateThread.Interrupt();
}
