public void IsUserNotFoundSignIn()
{
SqlLiteDatabaseTest(options =>
{
var authService = _server.Host.Services.GetService(typeof(IAuthService)) as IAuthService;
var inviteService = _server.Host.Services.GetService(typeof(IInviteService)) as IInviteService;
using (var context = new PlayCatDbContext(options))
{
authService.SetDbContext(context);
SignUpInResult resultSignIn = authService.SignIn(new SignInRequest()
{
Email = "*****@*****.**",
Password = "******",
});
Assert.NotNull(resultSignIn);
Assert.False(resultSignIn.Ok);
Assert.Null(resultSignIn.User);
Assert.Null(resultSignIn.AuthToken);
Assert.Null(resultSignIn.Errors);
Assert.Equal("Email or password is incorrect", resultSignIn.Info);
Assert.True(resultSignIn.ShowInfo);
}
});
}
public void IsDescendingOrder()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
CreateAndAddAudio(context, playlist.Id, 5);
context.SaveChanges();
UserPlaylistsResult result = playListService.GetUserPlaylists(userId, playlist.Id, 0, 5);
CheckIfSuccess(result);
Assert.Equal(playlist.Id, result.Playlists.FirstOrDefault().Id);
Assert.Equal(playlist.Title, result.Playlists.FirstOrDefault().Title);
Assert.Equal(1, result.Playlists.Count());
Assert.Equal(5, result.Playlists.FirstOrDefault().Audios.Count());
for (int i = 0; i < 4; i++)
{
Assert.True(result.Playlists.FirstOrDefault().Audios.ElementAt(i).DateAdded >
result.Playlists.FirstOrDefault().Audios.ElementAt(i + 1).DateAdded);
}
}
});
}
public void ShouldFailOnUploadInOneTime()
{
SqlLiteDatabaseTest(options =>
{
var uploadService = _server.Host.Services.GetService(typeof(IUploadService)) as IUploadService;
var fileResolver = _server.Host.Services.GetService(typeof(IFileResolver)) as IFileResolver;
using (var context = new PlayCatDbContext(options))
{
uploadService.SetDbContext(context);
var uploadAudioRequest = new UploadAudioRequest
{
Artist = "Flume",
Song = "Say It (feat. Tove Lo) (Illenium Remix)",
Url = "https://www.youtube.com/watch?v=80AlC3LaPqQ"
};
Guid userId = GetUserId(context);
Task.Run(() => {
uploadService.UploadAudioAsync(userId, uploadAudioRequest);
string audioFilePath = fileResolver.GetAudioFolderPath(StorageType.FileSystem);
File.Delete(Path.Combine(audioFilePath, "80AlC3LaPqQ.mp3"));
});
Thread.Sleep(500);
UploadResult result = uploadService.UploadAudioAsync(userId, uploadAudioRequest).Result;
CheckIfFail(result);
Assert.Equal("User already uploading audio", result.Info);
}
});
}
public void ShouldCreatePlaylist()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
//create general
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
context.SaveChanges();
string playlistTitle = "Test";
var result = playListService.CreatePlaylist(userId, new CreatePlaylistRequest()
{
Title = playlistTitle,
});
CheckIfSuccess(result);
var playlists = context.Playlists.ToList();
Assert.True(playlists.Any(x => x.Title == playlistTitle && !x.IsGeneral));
}
});
}
public void ShouldAddToPlaylist()
{
SqlLiteDatabaseTest(options =>
{
var audioService = _server.Host.Services.GetService(typeof(IAudioService)) as IAudioService;
using (var context = new PlayCatDbContext(options))
{
audioService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist generalPlaylist = context.CreatePlaylist(true, userId, null, 0);
CreateAndAddAudio(context, generalPlaylist.Id, 10);
DataModel.Playlist playlist = context.CreatePlaylist(false, userId, "Rock", 0);
context.SaveChanges();
var audio = context.Audios.FirstOrDefault();
var result = audioService.AddToPlaylist(userId, new AddRemovePlaylistRequest()
{
AudioId = audio.Id,
PlaylistId = playlist.Id,
});
var audioPlaylists = context.AudioPlaylists.ToList();
var addedAP = audioPlaylists.FirstOrDefault(x => x.PlaylistId == playlist.Id);
CheckIfSuccess(result);
Assert.Equal(audioPlaylists.Count, 11);
Assert.NotNull(addedAP);
Assert.Equal(addedAP.AudioId, audio.Id);
}
});
}
public void ShouldReturnPlaylists()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
//create general
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
DataModel.Playlist playlist1 = context.CreatePlaylist(false, userId, "playlist1", 0);
DataModel.Playlist playlist2 = context.CreatePlaylist(false, userId, "playlist2", 0);
DataModel.Playlist playlist3 = context.CreatePlaylist(false, userId, "playlist3", 0);
context.SaveChanges();
UserPlaylistsResult result = playListService.GetUserPlaylists(userId, null, 0, 10);
CheckIfSuccess(result);
Assert.Equal(4, result.Playlists.Count());
Assert.True(result.Playlists.All(x => !x.Audios.Any()));
}
});
}
public void ShouldReturnNotGeneralPlaylist()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist playlist = context.CreatePlaylist(false, userId, "My playlist", 0);
CreateAndAddAudio(context, playlist.Id, 10);
context.SaveChanges();
UserPlaylistsResult result = playListService.GetUserPlaylists(userId, playlist.Id, 0, 10);
CheckIfSuccess(result);
Assert.Equal(playlist.Id, result.Playlists.FirstOrDefault().Id);
Assert.Equal(playlist.Title, result.Playlists.FirstOrDefault().Title);
Assert.Equal(10, result.Playlists.FirstOrDefault().Audios.Count());
}
});
}
public void IsValidUrl(string url)
{
SqlLiteDatabaseTest(options =>
{
var uploadService = _server.Host.Services.GetService(typeof(IUploadService)) as IUploadService;
using (var context = new PlayCatDbContext(options))
{
uploadService.SetDbContext(context);
var request = new UrlRequest()
{
Url = url,
};
GetInfoResult result = uploadService.GetInfo(request);
CheckIfSuccess(result);
Assert.NotNull(result.UrlInfo);
Assert.Equal("Flume", result.UrlInfo.Artist);
Assert.Equal("Say It (feat. Tove Lo) (Illenium Remix)", result.UrlInfo.Song);
Assert.Equal(8023661, result.UrlInfo.ContentLength);
}
});
}
public void IsGetAllAudios(int count, int skip, int take, int actualCount)
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
CreateAndAddAudio(context, playlist.Id, count);
context.SaveChanges();
UserPlaylistsResult result = playListService.GetUserPlaylists(userId, playlist.Id, skip, take);
CheckIfSuccess(result);
Assert.Equal(playlist.Id, result.Playlists.FirstOrDefault().Id);
Assert.Equal(playlist.Title, result.Playlists.FirstOrDefault().Title);
Assert.Equal(actualCount, result.Playlists.FirstOrDefault().Audios.Count());
}
});
}
public void ShouldDeletePlaylist()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
//create general
DataModel.Playlist generalPlaylist = context.CreatePlaylist(true, userId, null, 0);
DataModel.Playlist playlist = context.CreatePlaylist(false, userId, "My playlist", 0);
CreateAndAddAudio(context, playlist.Id, 10);
context.SaveChanges();
Assert.Equal(context.AudioPlaylists.Count(), 10);
var result = playListService.DeletePlaylist(userId, playlist.Id);
CheckIfSuccess(result);
Assert.Equal(context.AudioPlaylists.Count(), 0);
}
});
}
public void IsValidModelSignUp()
{
SqlLiteDatabaseTest(options =>
{
var authService = _server.Host.Services.GetService(typeof(IAuthService)) as IAuthService;
var inviteService = _server.Host.Services.GetService(typeof(IInviteService)) as IInviteService;
using (var context = new PlayCatDbContext(options))
{
authService.SetDbContext(context);
SignUpInResult result = authService.SignUp(new SignUpRequest()
{
FirstName = "vlad",
LastName = "Kuz",
Password = "******",
ConfirmPassword = "******",
Email = "*****@*****.**",
VerificationCode = inviteService.GenerateInvite(),
});
Assert.NotNull(result);
Assert.True(result.Ok);
Assert.NotNull(result.User);
Assert.NotNull(result.AuthToken);
Assert.Null(result.Errors);
Assert.Null(result.Info);
}
});
}
public void ShouldReturnGeneralPlaylist()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
DataModel.Playlist playlist2 = context.CreatePlaylist(false, userId, "Rock", 0);
DataModel.Playlist playlist3 = context.CreatePlaylist(false, userId, "RnB", 0);
CreateAndAddAudio(context, playlist3.Id, 10);
context.SaveChanges();
UserPlaylistsResult result = playListService.GetUserPlaylists(userId, playlist3.Id, 0, 10);
CheckIfSuccess(result);
Assert.True(result.Playlists.Where(x => x.Id != playlist3.Id).All(x => !x.Audios.Any()));
Assert.Equal(10, result.Playlists.FirstOrDefault(x => x.Id == playlist3.Id).Audios.Count());
}
});
}
public void ShouldRemoveIfAudioNotExists()
{
SqlLiteDatabaseTest(options =>
{
var audioService = _server.Host.Services.GetService(typeof(IAudioService)) as IAudioService;
using (var context = new PlayCatDbContext(options))
{
audioService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist generalPlaylist = context.CreatePlaylist(true, userId, null, 0);
DataModel.Playlist playlist = context.CreatePlaylist(false, userId, "Rock", 0);
context.SaveChanges();
var result = audioService.RemoveFromPlaylist(userId, new AddRemovePlaylistRequest()
{
AudioId = Guid.Empty,
PlaylistId = playlist.Id,
});
CheckIfSuccess(result);
}
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, PlayCatDbContext dbContext)
{
app.UseCors(builder => builder.AllowAnyMethod()
.AllowAnyHeader()
.AllowAnyOrigin());
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c => { c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1"); });
app.Use(async(context, next) =>
{
await next();
if (context.Response.StatusCode == 404 &&
!Path.HasExtension(context.Request.Path.Value) &&
!context.Request.Path.Value.StartsWith("/api/"))
{
context.Request.Path = "/index.html";
await next();
}
});
app.UseDeveloperExceptionPage();
ServeFromDirectory(app, env, "Audio");
app.UseMvc();
}
public void ShouldFailCreatePlaylist()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
//create general
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
context.SaveChanges();
var result = playListService.CreatePlaylist(userId, new CreatePlaylistRequest()
{
Title = "13",
});
CheckIfFail(result);
}
});
}
public void SearchByStartsWithAndOrder()
{
SqlLiteDatabaseTest(options =>
{
var audioService = _server.Host.Services.GetService(typeof(IAudioService)) as IAudioService;
using (var context = new PlayCatDbContext(options))
{
audioService.SetDbContext(context);
context.CreateAudio(DateTime.Now, "0", artist: "B", song: "B", extension: "", filename: "", videoId: "A", uploaderId: null);
context.CreateAudio(DateTime.Now, "1", artist: "B", song: "A", extension: "", filename: "", videoId: "B", uploaderId: null);
context.CreateAudio(DateTime.Now, "2", artist: "A", song: "B", extension: "", filename: "", videoId: "C", uploaderId: null);
context.SaveChanges();
var result = audioService.SearchAudios("A", 0, 10);
CheckIfSuccess(result);
Assert.Equal(result.Audios.Count(), 3);
Assert.Equal(result.Audios.ElementAt(0).AccessUrl, "0");
Assert.Equal(result.Audios.ElementAt(1).AccessUrl, "1");
Assert.Equal(result.Audios.ElementAt(2).AccessUrl, "2");
}
});
}
public void ShouldFailUpdateOnWrongPlaylistId()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IPlaylistService)) as IPlaylistService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
Guid userId = GetUserId(context);
//create general
DataModel.Playlist playlist = context.CreatePlaylist(true, userId, null, 0);
string newTitle = "New title";
var updatePlaylist = context.CreatePlaylist(false, userId, "Top", 0);
context.SaveChanges();
var result = playListService.UpdatePlaylist(userId, new UpdatePlaylistRequest()
{
PlaylistId = Guid.Empty,
Title = newTitle,
});
CheckIfFail(result);
Assert.Equal("Playlist not found", result.Info);
}
});
}
public void ShouldUpdateProfile()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IProfileService)) as IProfileService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
var user = context.CreateUser("*****@*****.**", "v", "last", "m", "123", "123");
context.SaveChanges();
string newFirstName = "newFirstName";
string newLastName = "newLastName";
string newNickname = "newNickName";
var result = playListService.UpdateProfile(new DataService.Request.UpdateProfileRequest()
{
Id = user.Id,
FirstName = newFirstName,
LastName = newLastName,
NickName = newNickname,
});
CheckIfSuccess(result);
Assert.NotNull(result.User);
Assert.Equal(newFirstName, result.User.FirstName);
Assert.Equal(newLastName, result.User.LastName);
Assert.Equal(newNickname, result.User.NickName);
}
});
}
public void ShouldSuccessReturnProfile()
{
SqlLiteDatabaseTest(options =>
{
var playListService = _server.Host.Services.GetService(typeof(IProfileService)) as IProfileService;
using (var context = new PlayCatDbContext(options))
{
playListService.SetDbContext(context);
string email = "*****@*****.**";
string firstName = "v";
string lastName = "last";
string nickName = "mef";
string password = "******";
string inviteCode = "123";
var user = context.CreateUser(email, firstName, lastName, nickName, password, inviteCode);
context.SaveChanges();
var result = playListService.GetProfile(user.Id);
CheckIfSuccess(result);
Assert.NotNull(result.User);
Assert.Equal(email, result.User.Email);
Assert.Equal(firstName, result.User.FirstName);
Assert.Equal(lastName, result.User.LastName);
Assert.Equal(nickName, result.User.NickName);
}
});
}
public void ShouldTrueRemoveFromGeneral()
{
SqlLiteDatabaseTest(options =>
{
var audioService = _server.Host.Services.GetService(typeof(IAudioService)) as IAudioService;
using (var context = new PlayCatDbContext(options))
{
audioService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist generalPlaylist = context.CreatePlaylist(true, userId, null, 0);
CreateAndAddAudio(context, generalPlaylist.Id, 1);
context.SaveChanges();
var audio = context.Audios.FirstOrDefault();
var result = audioService.RemoveFromPlaylist(userId, new AddRemovePlaylistRequest()
{
AudioId = audio.Id,
PlaylistId = generalPlaylist.Id,
});
CheckIfSuccess(result);
Assert.Equal(context.AudioPlaylists.Count(), 0);
}
});
}
public void ShouldFailAddToPlaylistNotOwner()
{
SqlLiteDatabaseTest(options =>
{
var audioService = _server.Host.Services.GetService(typeof(IAudioService)) as IAudioService;
using (var context = new PlayCatDbContext(options))
{
audioService.SetDbContext(context);
Guid userId = GetUserId(context);
DataModel.Playlist generalPlaylist = context.CreatePlaylist(true, userId, null, 0);
DataModel.Playlist playlist = context.CreatePlaylist(false, userId, "Rock", 0);
CreateAndAddAudio(context, playlist.Id, 1);
context.SaveChanges();
var audio = context.Audios.FirstOrDefault();
var result = audioService.AddToPlaylist(Guid.Empty, new AddRemovePlaylistRequest()
{
AudioId = audio.Id,
PlaylistId = playlist.Id,
});
CheckIfFail(result);
Assert.True(result.Info.Any());
}
});
}
public static AuthToken CreateToken(this PlayCatDbContext context, DateTime dateExpired, bool isActive, Guid userId)
{
return(context.AuthTokens.Add(new DataModel.AuthToken()
{
Id = Guid.NewGuid(),
DateExpired = dateExpired,
IsActive = isActive,
UserId = userId,
}).Entity);
}
public static AudioPlaylist CreateAudioPlaylist(this PlayCatDbContext context, DateTime dateAdded, Guid audioId, Guid playlistId, int order)
{
return(context.AudioPlaylists.Add(new AudioPlaylist()
{
AudioId = audioId,
DateCreated = dateAdded,
PlaylistId = playlistId,
Order = order,
}).Entity);
}
public static Playlist CreatePlaylist(this PlayCatDbContext context, bool isGeneral, Guid ownerId, string title, int orderValue)
{
return(context.Playlists.Add(new DataModel.Playlist()
{
Id = Guid.NewGuid(),
IsGeneral = isGeneral,
OwnerId = ownerId,
Title = title,
OrderValue = orderValue,
}).Entity);
}
protected Guid GetUserId(PlayCatDbContext context)
{
string password = "******";
string email = "*****@*****.**";
User user = context.CreateUser(email, "test", "test", "m", password);
AuthToken authToken = context.CreateToken(DateTime.Now.AddDays(-1), false, user.Id);
context.SaveChanges();
return(user.Id);
}
public void IsUpdateTokenSignIn()
{
SqlLiteDatabaseTest(options =>
{
var authService = _server.Host.Services.GetService(typeof(IAuthService)) as IAuthService;
var inviteService = _server.Host.Services.GetService(typeof(IInviteService)) as IInviteService;
using (var context = new PlayCatDbContext(options))
{
authService.SetDbContext(context);
string password = "******";
string email = "*****@*****.**";
string salt = Crypto.GenerateSalt();
string passwordHah = Crypto.HashPassword(password + salt);
var user = context.Users.Add(new DataModel.User()
{
Id = Guid.NewGuid(),
Email = email,
FirstName = "test",
LastName = "test",
PasswordHash = passwordHah,
PasswordSalt = salt,
RegisterDate = DateTime.Now,
VerificationCode = inviteService.GenerateInvite(),
});
var authToken = context.AuthTokens.Add(new DataModel.AuthToken()
{
Id = Guid.NewGuid(),
DateExpired = DateTime.Now.AddDays(-1),
IsActive = false,
UserId = user.Entity.Id,
});
context.SaveChanges();
SignUpInResult result = authService.SignIn(new SignInRequest()
{
Email = email,
Password = password,
});
var updatedAuthToken = context.AuthTokens.FirstOrDefault();
Assert.NotNull(updatedAuthToken);
Assert.True(updatedAuthToken.DateExpired > DateTime.Now);
Assert.True(updatedAuthToken.IsActive);
}
});
}
public void IsValidUrl()
{
SqlLiteDatabaseTest(options =>
{
var uploadService = _server.Host.Services.GetService(typeof(IUploadService)) as IUploadService;
var fileResolver = _server.Host.Services.GetService(typeof(IFileResolver)) as IFileResolver;
using (var context = new PlayCatDbContext(options))
{
uploadService.SetDbContext(context);
var uploadAudioRequest = new UploadAudioRequest
{
Artist = "Flume",
Song = "Say It (feat. Tove Lo) (Illenium Remix)",
Url = "https://www.youtube.com/watch?v=80AlC3LaPqQ"
};
Guid userId = GetUserId(context);
UploadResult result = uploadService.UploadAudioAsync(userId, uploadAudioRequest).Result;
_output.WriteLine(JsonConvert.SerializeObject(result));
CheckIfSuccess(result);
var audio = context.Audios.Single();
Assert.Equal("Say It (feat. Tove Lo) (Illenium Remix)", result.Audio.Song);
Assert.Equal("Flume", result.Audio.Artist);
Assert.Equal("80AlC3LaPqQ", audio.UniqueIdentifier);
var audioPlaylists = context.AudioPlaylists.Single();
var generalPlaylist = context.Playlists.Single();
Assert.True(generalPlaylist.IsGeneral);
Assert.Equal(generalPlaylist.OwnerId, userId);
Assert.Equal(generalPlaylist.OrderValue, 1);
Assert.Equal(audioPlaylists.Order, 0);
Assert.Equal(audioPlaylists.AudioId, audio.Id);
Assert.Equal(audioPlaylists.PlaylistId, generalPlaylist.Id);
string audioFilePath = fileResolver.GetAudioFolderPath(StorageType.FileSystem);
string videoFilePath = fileResolver.GetVideoFolderPath(StorageType.FileSystem);
Assert.True(File.Exists(Path.Combine(audioFilePath, "80AlC3LaPqQ.mp3")));
Assert.False(File.Exists(Path.Combine(videoFilePath, "80AlC3LaPqQ.mp4")));
File.Delete(Path.Combine(audioFilePath, "80AlC3LaPqQ.mp3"));
}
});
}
private new Guid GetUserId(PlayCatDbContext context)
{
string password = "******";
string email = "*****@*****.**";
User user = context.CreateUser(email, "test", "test", "m", password);
Playlist playlist = context.CreatePlaylist(true, user.Id, "General", 0);
AuthToken authToken = context.CreateToken(DateTime.Now.AddDays(-1), false, user.Id);
context.SaveChanges();
return(user.Id);
}
protected Guid GetUserId(PlayCatDbContext context)
{
var inviteService = _server.Host.Services.GetService(typeof(IInviteService)) as IInviteService;
string password = "******";
string email = "*****@*****.**";
DataModel.User user = context.CreateUser(email, "test", "test", "m", password, inviteService.GenerateInvite());
DataModel.AuthToken authToken = context.CreateToken(DateTime.Now.AddDays(-1), false, user.Id);
context.SaveChanges();
return(user.Id);
}
private void CreateAndAddAudio(PlayCatDbContext context, Guid playlistId, int count)
{
if (count < -0)
{
return;
}
for (int i = 0; i < count; i++)
{
DataModel.Audio audio = context.CreateAudio(DateTime.Now.AddMinutes(i), "access" + i, "artist" + i, "song" + i, BaseAudioExtension, i.ToString(), i.ToString(), null);
DataModel.AudioPlaylist audioPlaylist = context.CreateAudioPlaylist(DateTime.Now.AddMinutes(i), audio.Id, playlistId, i);
}
}
