public void ReturnDeezerSongIdsWhenPassLength()
{
// arrange
var deezerSong = new List <DeezerSong>
{
new DeezerSong(SongId.Parse("101"), "title1", "artist1"),
new DeezerSong(SongId.Parse("102"), "title2", "artist2"),
new DeezerSong(SongId.Parse("103"), "title3", "artist3")
};
var songEngine = SongEngineBuilder
.Create()
.SetRandomisedSongs(deezerSong).Build();
// act
var actual = songEngine.GetRandomisedSongs(3);
// assert
Assert.AreEqual(3, actual.Count());
Assert.AreEqual(SongId.Parse("101"), actual.ElementAt(0).Id);
Assert.AreEqual(SongId.Parse("102"), actual.ElementAt(1).Id);
Assert.AreEqual(SongId.Parse("103"), actual.ElementAt(2).Id);
Assert.AreEqual("title1", actual.ElementAt(0).Title);
Assert.AreEqual("title2", actual.ElementAt(1).Title);
Assert.AreEqual("title3", actual.ElementAt(2).Title);
Assert.AreEqual("artist1", actual.ElementAt(0).Artist);
Assert.AreEqual("artist2", actual.ElementAt(1).Artist);
Assert.AreEqual("artist3", actual.ElementAt(2).Artist);
}
public void UseRepositoryWhenRadioSongWithDeezerSongIdIsParsed()
{
// arrange
var songId = SongId.Parse("001");
var radioName = "djam";
var title = "title";
var artist = "artist";
var mockedRadioSongRepository = RadioSongRepositoryBuilder.Create();
var radioSongRepository = mockedRadioSongRepository.Build();
var deezerApi = DeezerApiBuilder
.Create()
.SetSong(new DeezerSong(songId, title, artist))
.Build();
var radioSongHandler = new RadioSongHandler(radioSongRepository, deezerApi);
// act
var radioSongParsed = new RadioSongWithDeezerSongIdParsed(radioName, songId);
radioSongHandler.Handle(radioSongParsed);
// assert
var(actualSongId, actualName, actualTitle, actualArtist) = mockedRadioSongRepository.RadioSongs.First();
Assert.AreEqual(songId, actualSongId);
Assert.AreEqual(radioName, actualName);
Assert.AreEqual(title, actualTitle);
Assert.AreEqual(artist, actualArtist);
}
public AmbientSoundPlayer(SongId songId)
{
On <EngineUpdateEvent>(e => Tick(e.DeltaSeconds));
_songId = songId;
_hook = NoteHook;
}
public WaveLibEvent(SongId songId, int instrument, int velocity, int note)
{
SongId = songId;
Instrument = instrument;
Velocity = velocity;
Note = note;
}
public SongAdded(UserId userId, PlaylistId playlistId, SongId songId, string title, string artist)
{
UserId = userId;
PlaylistId = playlistId;
SongId = songId;
Title = title;
Artist = artist;
}
public override int GetHashCode()
{
var hashCode = -16023929;
hashCode = hashCode * -1521134295 + Id.GetHashCode();
hashCode = hashCode * -1521134295 + SongId.GetHashCode();
hashCode = hashCode * -1521134295 + PlayListId.GetHashCode();
return(hashCode);
}
public static void PlaySong(SongId id)
{
LOG.Log($"Starting to play song: {id}");
if (!Object.SoundEnable)
{
return;
}
StopAllSongs();
Object.songInstances[id].start();
}
public override int GetHashCode()
{
var hashCode = -147973881;
hashCode = hashCode * -1521134295 + Id.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Text);
hashCode = hashCode * -1521134295 + Date.GetHashCode();
hashCode = hashCode * -1521134295 + UserId.GetHashCode();
hashCode = hashCode * -1521134295 + SongId.GetHashCode();
return(hashCode);
}
public bool SongExists(SongId songId)
{
using (var cnx = _provider.Create())
{
var commandText = $"select songid from radiosong where songid = {songId.Value}";
cnx.Open();
using (var command = cnx.CreateCommand())
{
command.CommandText = commandText;
using (var reader = command.ExecuteReader())
{
return(reader.HasRows);
}
}
}
}
public void AddSongsToPlaylistDeezer()
{
var playlistId = PlaylistId.Parse("100");
var accessToken = "accessToken";
var songIds = new []
{
SongId.Parse("001"),
SongId.Parse("002"),
SongId.Parse("003")
};
var deezerService = DeezerApiBuilder.Create();
deezerService.Build().AddSongsToPlaylist(accessToken, playlistId, songIds);
Assert.AreEqual(3, deezerService.SongsAdded);
}
public void RaiseMessageWhenAddPlaylistToUser()
{
var stream = new MemoryEventStream();
var deezerApi = DeezerApiBuilder.Create().SetCreatePlaylist(PlaylistId.Parse("100")).Build();
var songRepository = SongRepositoryBuilder.Create()
.SetRandomSongs(1, new[] { new Song(SongId.Parse("100"), "title", "artist") }).Build();
var playlistRepository = PlaylistRepositoryBuilder.Create().Build();
stream.Add(new UserCreated(Identity.Parse("*****@*****.**", "dublow", "12345", "accessToken")));
var publisher = new EventBus(stream);
var user = new User(stream, publisher, deezerApi, songRepository, playlistRepository, 1);
user.AddPlaylist("playlistName");
Assert.IsTrue(stream.GetEvents().Contains(new PlaylistAdded(UserId.Parse("12345"), PlaylistId.Parse("100"), "playlistName")));
}
public Song(string title, string location, int milliseconds, Bpm bpm,
uint playCount, uint?songId = null)
{
SongTitle = title;
Location = location;
Milliseconds = milliseconds;
Bpm = bpm;
PlayCount = playCount;
if (songId != null)
{
SongId.UpdateTagId(songId.Value);
}
Id = songId ?? SongId.GetNextSongId();
IsBadSong = false;
SongError = string.Empty;
CheckSongLocation();
}
public void GetSongFromDeezerWhenSongExists()
{
// arrange
var songId = SongId.Parse("001");
string title = "title";
string artist = "artist";
var accessToken = "accessToken";
var deezerService = DeezerApiBuilder
.Create()
.SetSong(new DeezerSong(songId, title, artist))
.Build();
// act
var actual = deezerService.GetSong(accessToken, title, artist);
// assert
Assert.AreEqual(songId, actual.Id);
Assert.AreEqual(title, actual.Title);
Assert.AreEqual(artist, actual.Artist);
}
public IEnumerable <DeezerSong> GetSongsByPlaylistId(string accessToken, PlaylistId playlistId)
{
var uri = String.Format(Endpoints.GetSongsByPlaylist, playlistId.Value, accessToken);
TrackDeezer GetT(string url)
{
Thread.Sleep(2000);
return(_request.Get(url, JsonConvert.DeserializeObject <TrackDeezer>));
}
var trackItemDeezer = new List <TrackItemDeezer>();
while (!string.IsNullOrEmpty(uri))
{
var trackDeezer = GetT(uri);
trackItemDeezer.AddRange(trackDeezer.Tracks);
uri = trackDeezer.Next;
}
return(trackItemDeezer.Select(x => new DeezerSong(SongId.Parse(x.Id), x.Title, x.Artist.Name)));
}
public void GetSongsByPlaylistIdWithPlaylistId()
{
// arrange
var playlistId = PlaylistId.Parse("100");
var songId = SongId.Parse("001");
var title = "title";
var artist = "artist";
var accessToken = "accessToken";
var deezerService = DeezerApiBuilder
.Create()
.SetSongsByPlaylistId(new [] { new DeezerSong(songId, title, artist) })
.Build();
// act
var actual = deezerService.GetSongsByPlaylistId(accessToken, playlistId);
// assert
Assert.AreEqual(1, actual.Count());
Assert.AreEqual(songId, actual.First().Id);
Assert.AreEqual(title, actual.First().Title);
Assert.AreEqual(artist, actual.First().Artist);
}
public IEnumerable <Song> GetRandomSongs(int size)
{
using (var cnx = _provider.Create())
{
var commandText = $"select songid, title, artist from radiosong order by random() limit {size}";
cnx.Open();
using (var command = cnx.CreateCommand())
{
command.CommandText = commandText;
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var songId = SongId.Parse(reader[0].ToString());
var title = reader[1].ToString();
var artist = reader[2].ToString();
yield return(new Song(songId, title, artist));
}
}
}
}
}
public void UseRepositoryWhenSongIsAdded()
{
// arrange
var userId = UserId.Parse("12345");
var playlistId = PlaylistId.Parse("100");
var songId = SongId.Parse("001");
var title = "title";
var artist = "artist";
var mockedSongRepository = SongRepositoryBuilder.Create();
var songRepository = mockedSongRepository.Build();
var songHandler = new SongHandler(songRepository);
// act
songHandler.Handle(new SongAdded(userId, playlistId, songId, title, artist));
// assert
var(actualUserId, actualPlaylistId, actualSongId, actualTitle, actualArtist) = mockedSongRepository.Songs.First();
Assert.AreEqual(userId, actualUserId);
Assert.AreEqual(playlistId, actualPlaylistId);
Assert.AreEqual(songId, actualSongId);
Assert.AreEqual(title, actualTitle);
Assert.AreEqual(artist, actualArtist);
}
public void Add(SongId songId, string radioName, string title, string artist)
{
if (title.Contains("'"))
{
title = title.Replace("'", " ");
}
if (artist.Contains("'"))
{
artist = artist.Replace("'", " ");
}
using (var cnx = _provider.Create())
{
var commandText = "insert into radiosong (songid, radioname, title, artist) " +
$"values ({songId.Value}, '{radioName}', '{title}', '{artist}')";
cnx.Open();
using (var command = cnx.CreateCommand())
{
command.CommandText = commandText;
command.ExecuteNonQuery();
}
}
}
bool IEquatable <Song> .Equals(Song other)
{
return(SongId.Equals(other.SongId));
}
public SongEvent(SongId songId)
{
SongId = songId;
}
public DeezerSong GetSong(string accessToken, SongId songId)
{
throw new NotImplementedException();
}
public static MapData3D Serdes(AssetInfo info, MapData3D existing, AssetMapping mapping, ISerializer s)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
if (s == null)
{
throw new ArgumentNullException(nameof(s));
}
var map = existing ?? new MapData3D {
Id = info.AssetId
};
map.Flags = s.EnumU8(nameof(Flags), map.Flags); // 0
map.OriginalNpcCount = s.UInt8(nameof(OriginalNpcCount), map.OriginalNpcCount); // 1
int npcCount = NpcCountTransform.Instance.FromNumeric(map.OriginalNpcCount);
var _ = s.UInt8("MapType", (byte)map.MapType); // 2
map.SongId = SongId.SerdesU8(nameof(SongId), map.SongId, mapping, s); // 3
map.Width = s.UInt8(nameof(Width), map.Width); // 4
map.Height = s.UInt8(nameof(Height), map.Height); // 5
map.LabDataId = LabyrinthId.SerdesU8(nameof(LabDataId), map.LabDataId, mapping, s); // 6
map.CombatBackgroundId = SpriteId.SerdesU8(nameof(CombatBackgroundId), map.CombatBackgroundId, AssetType.CombatBackground, mapping, s); // 7 TODO: Verify this is combat background
map.PaletteId = PaletteId.SerdesU8(nameof(PaletteId), map.PaletteId, mapping, s);
map.AmbientSongId = SongId.SerdesU8(nameof(AmbientSongId), map.AmbientSongId, mapping, s);
map.Npcs = s.List(
nameof(Npcs),
map.Npcs,
npcCount,
(n, x, s2) => MapNpc.Serdes(n, x, map.MapType, mapping, s2)).ToArray();
map.Contents ??= new byte[map.Width * map.Height];
map.Floors ??= new byte[map.Width * map.Height];
map.Ceilings ??= new byte[map.Width * map.Height];
for (int i = 0; i < map.Width * map.Height; i++)
{
map.Contents[i] = s.UInt8(null, map.Contents[i]);
map.Floors[i] = s.UInt8(null, map.Floors[i]);
map.Ceilings[i] = s.UInt8(null, map.Ceilings[i]);
}
s.Check();
map.SerdesZones(s);
if (s.IsReading() && s.IsComplete() || s.IsWriting() && map.AutomapGraphics == null)
{
ApiUtil.Assert(map.Zones.Count == 0);
foreach (var npc in map.Npcs)
{
npc.Waypoints = new NpcWaypoint[1];
}
return(map);
}
map.SerdesEvents(mapping, s);
map.SerdesNpcWaypoints(s);
map.SerdesAutomap(s);
map.SerdesChains(s, 64);
if (s.IsReading())
{
map.Unswizzle();
}
return(map);
}
public void Add(UserId userId, PlaylistId playlistId, SongId songId, string title, string artist)
{
Console.WriteLine(
$"UserId:{userId.Value} PlaylistId: {playlistId.Value} SongId: {songId.Value} Title:{title} Artist: {artist}");
}
public AlbionMusicGenerator(SongId songId) => SongId = songId;
public AmbientEvent(SongId songId)
{
SongId = songId;
}
/// <summary> Serves as a hash function for a particular type. </summary>
/// <returns> A hash code for the current <see cref="T:System.Object"/>. </returns>
/// <filterpriority>2</filterpriority>
public override int GetHashCode()
{
return(SongId.GetHashCode() ^ AlbumId.GetHashCode());
}
public bool Equals(Song other)
{
return(SongId.ToLower() == other.SongId.ToLower());
}
public DeezerSong(SongId id, string title, string artist)
{
Id = id;
Title = title;
Artist = artist;
}
public Song(SongId songId, string title, string artist)
{
SongId = songId;
Title = title;
Artist = artist;
}
public bool Equals(BeatSaverSong other)
{
return(SongId.ToLower() == other._id);
}
