public void PlayTrack(QueuedTrack trackToPlay)
{
logger.Trace("MusicService.PlayTrack");
logger.Debug("Attempting to play track {0}", trackToPlay.ToLoggerFriendlyTrackName());
//Reset the paused data
lastPaused = null;
totalPausedDuration = 0;
currentProvider = musicProviderFactory.GetMusicProviderByIdentifier(trackToPlay.Track.MusicProvider.Identifier);
//Either play the original queued track or the Big Rick if tthe track is rickrolled
var rickRollTrack = rickRollService.RickRoll(trackToPlay.Track, trackToPlay.User);
currentProvider.PlayTrack(rickRollTrack);
trackToPlay.StartedPlayingDateTime = nowHelper.Now;
queuedTrackDataService.InsertOrUpdate(trackToPlay);
int total;
var recentlyPlayed = queuedTrackDataService.GetAll()
.GetQueuedTracksByUser(null, 1, 5, out total)
.Select(r => alreadyQueuedHelper.ResetAlreadyQueued(r, trackToPlay.User)).ToList();
callbackClient.TrackHistoryChanged(new PagedResult <QueuedTrack> {
HasMorePages = false, PageData = recentlyPlayed
});
currentlyPlayingTrack = trackToPlay;
callbackClient.PlayingTrackChanged(CurrentlyPlayingTrack);
logger.Debug("Playing track {0} queued by {1}", trackToPlay.ToLoggerFriendlyTrackName(), trackToPlay.User);
}
public async Task <QueuedTrack> GetPlayingTrackAsync()
{
QueuedTrack track = null;
await Task.Run(() =>
{
try
{
using (var conn = this.factory.GetConnection())
{
try
{
track = conn.Query <QueuedTrack>("SELECT * FROM QueuedTrack WHERE IsPlaying=1;").FirstOrDefault();
}
catch (Exception ex)
{
LogClient.Error("Could not get the playing queued Track. Exception: {0}", ex.Message);
}
}
}
catch (Exception ex)
{
LogClient.Error("Could not connect to the database. Exception: {0}", ex.Message);
}
});
return(track);
}
private void FillBagWithAutoplayTracks(object stateInfo)
{
var scoredTracks = PickTracks();
if (scoredTracks == null)
{
return;
}
var chosenTracks = scoredTracks;
foreach (var qt in chosenTracks)
{
var queuedTrack = new QueuedTrack();
var tracksMusicProvider = musicProviderFactory.GetMusicProviderByIdentifier(qt.value.Track.MusicProvider.Identifier);
if (!tracksMusicProvider.IsEnabled)
{
continue;
}
var t = tracksMusicProvider.GetTrack(qt._id, Constants.AutoplayUserName);
if (t == null)
{
continue;
}
queuedTrack.Track = t;
queuedTrack.User = Constants.AutoplayUserName;
_tracksForAutoplaying.Push(queuedTrack);
}
}
public void if_playing_track_paused_CurrentPlayTrack_shows_correct_paused_time()
{
//Arrange
var playingTrack = new QueuedTrack {
Track = new Track {
}
};
var providerFactoryMock = GetMock <IMusicProviderFactory>();
var providerMock = GetMock <IMusicProvider>();
var playerMock = GetMock <IPlayer>();
providerFactoryMock.Setup(m => m.GetMusicProviderByIdentifier(It.IsAny <string>()))
.Returns(providerMock.Object);
providerMock.Setup(m => m.Player).Returns(playerMock.Object);
var nowMock = GetMock <INowHelper>();
var startTime = new DateTime(2013, 01, 01, 1, 0, 0);
var firstPause = new DateTime(2013, 01, 01, 1, 0, 1);
var firstResume = new DateTime(2013, 01, 01, 1, 0, 3);
var secondPause = new DateTime(2013, 01, 01, 1, 0, 5);
var secondResume = new DateTime(2013, 01, 01, 1, 0, 8);
nowMock.Setup(m => m.Now).ReturnsInOrder(startTime, firstPause, firstResume, secondPause, secondResume);
//Act
var classUnderTest = ClassUnderTest;
classUnderTest.PlayTrack(playingTrack);
classUnderTest.PauseTrack("");
classUnderTest.ResumeTrack("");
classUnderTest.PauseTrack("");
classUnderTest.ResumeTrack("");
//Assert
Assert.That(classUnderTest.CurrentlyPlayingTrack.PausedDurationAsMilliseconds, Is.EqualTo(5000));
}
public string QueueTrack(QueuedTrack trackToQueue)
{
if (trackToQueue == null)
{
return("Track could not be found.");
}
var errors = queueRuleHelper.CannotQueueTrack(trackToQueue.Track, trackToQueue.User).ToList();
if (errors.Any(e => e != string.Empty))
{
return(errors.FirstOrDefault(e => e != string.Empty));
}
trackToQueue.Id = DataObject.GenerateId();
queueManager.Enqueue(trackToQueue);
//for some reason no track is playing then dequeue and play this track
if (musicPlayer.CurrentlyPlayingTrack == null)
{
PlayNextTrack();
}
logger.Debug("Track {0} queued by {1}", trackToQueue.ToLoggerFriendlyTrackName(), trackToQueue.User);
callbackClient.QueueChanged(GetQueue());
return(string.Empty);
}
public IMessage GetMessage(QueuedTrack queuedTrack)
{
IMessage message = null;
if (queuedTrack.LikeCount == FizzBungCount)
{
message = new Message(FizzBung, queuedTrack.Track.Name);
}
return(message);
}
public IMessage GetMessage(QueuedTrack queuedTrack)
{
IMessage message = null;
if (queuedTrack.LikeCount == GangbustersCount)
{
message = new Message(Gangbusters, queuedTrack.Track.Name);
}
return(message);
}
public void SetUp()
{
queuedTrack = new QueuedTrack
{
StartedPlayingDateTime = playedTime,
User = "******",
Track = new Track
{
Name = "Test Track name",
Album = new Album {
Name = "Test Album name"
}
}
};
queuedTrack2 = new QueuedTrack
{
StartedPlayingDateTime = playedTime,
User = "******",
Track = new Track
{
Name = "Test Track name2",
Album = new Album {
Name = "Test Album name2"
}
}
};
queuedTrack3 = new QueuedTrack
{
StartedPlayingDateTime = playedTime,
User = "******",
Track = new Track
{
Name = "Test Track name2",
Album = new Album {
Name = "Test Album name"
}
}
};
queuedTrack4 = new QueuedTrack
{
StartedPlayingDateTime = playedTime,
User = "******",
Track = new Track
{
Name = "Test Track name",
Album = new Album {
Name = "Test Album name2"
}
}
};
}
public void PlayFinishHim(int requiredVetos, QueuedTrack foundTrack)
{
if (soundBoardSettings.IsEnabled)
{
var howManyVetosToGo = (requiredVetos - foundTrack.VetoCount);
if (foundTrack.LikeCount > 5 && howManyVetosToGo == 1)
{
player.PlayFromFile(pathBuilder.BuildFilePath("finishhim.wav"));
}
}
}
public void SetUp()
{
queuedTrack = new QueuedTrack
{
Track = new Track
{
Name = "Test Track name",
Album = new Album {
Name = "Test Album name"
}
}
};
}
public async Task SaveQueuedTracksAsync()
{
if (!this.isQueueChanged)
{
return;
}
this.saveQueuedTracksTimer.Stop();
this.isSavingQueuedTracks = true;
try
{
var queuedTracks = new List <QueuedTrack>();
OrderedDictionary <string, PlayableTrack> tracks = this.Queue;
KeyValuePair <string, PlayableTrack> currentTrack = this.CurrentTrack;
long progressSeconds = Convert.ToInt64(this.GetCurrentTime.TotalSeconds);
int orderID = 0;
foreach (KeyValuePair <string, PlayableTrack> track in tracks)
{
var queuedTrack = new QueuedTrack();
queuedTrack.QueueID = track.Key;
queuedTrack.Path = track.Value.Path;
queuedTrack.SafePath = track.Value.SafePath;
queuedTrack.OrderID = orderID;
queuedTrack.IsPlaying = 0;
queuedTrack.ProgressSeconds = 0;
if (track.Key.Equals(currentTrack.Key))
{
queuedTrack.IsPlaying = 1;
queuedTrack.ProgressSeconds = progressSeconds;
}
queuedTracks.Add(queuedTrack);
orderID++;
}
await this.queuedTrackRepository.SaveQueuedTracksAsync(queuedTracks);
LogClient.Info("Saved {0} queued tracks", queuedTracks.Count.ToString());
}
catch (Exception ex)
{
LogClient.Info("Could not save queued tracks. Exception: {0}", ex.Message);
}
this.isSavingQueuedTracks = false;
}
public void PlayingTrackChanged(QueuedTrack track)
{
try
{
using (var client = new SpotifyCallbackServiceClient())
{
client.PlayingTrackChanged(track);
}
}
catch (Exception ex)
{
logger.Error("PlayingTrackChanged failed with exception {0}", ex.Message);
}
}
public void Broadcast(QueuedTrack queuedTrack)
{
var message = broadcastMessageRuleResolver.GetMessage(queuedTrack);
if (message == null)
{
return;
}
foreach (var broadcastService in broadcasters.Where(b => b.IsEnabled))
{
broadcastService.Broadcast(message);
}
}
public QueuedTrack Execute(QueuedTrack trackToQueue)
{
if (DateTime.Now.Second % settings.RandomizerRatio == 0)
{
return(trackToQueue);
}
if (trackToQueue.Track.MusicProvider == null || trackToQueue.Track.MusicProvider.Identifier != "sp")
{
return(trackToQueue);
}
musicProvider = musicProviderFactory.GetMusicProviderByIdentifier(trackToQueue.Track.MusicProvider.Identifier);
var browse = musicProvider.BrowseArtist(trackToQueue.Track.Artists.First().Link, false);
var artist = browse.Profile.SimilarArtists.Random().FirstOrDefault();
if (artist == null)
{
return(trackToQueue);
}
var randomAlbum = musicProvider.BrowseArtist(artist.Link, false).Albums.Random().Take(1).ToList();
if (randomAlbum.Any())
{
var albumLink = randomAlbum.Random().First();
var tracks = musicProvider.BrowseAlbum(albumLink.Link, trackToQueue.User);
if (tracks.Tracks != null && tracks.Tracks.Any())
{
var track = tracks.Tracks.Random().FirstOrDefault();
if (track != null)
{
logger.Debug("Similar Artist Randomizer, converting track {0}", trackToQueue.ToLoggerFriendlyTrackName());
trackToQueue.Track = track;
trackToQueue.Track.Album = albumLink;
trackToQueue.User = "******";
trackToQueue.Id = DataObject.GenerateId(); //if you don't do this then the autoplayed song will update over the user requested song
}
}
}
return(trackToQueue);
}
public string GetTransmitInfo(out int num_tracks)
{
StringBuilder sb = new StringBuilder();
int i;
for (i = 0; i < queue.Count; i++)
{
/* we queue a maximum of 10 tracks per request */
if (i == 9)
{
break;
}
QueuedTrack track = (QueuedTrack)queue[i];
//s=<sessionID>
//a[0]=<artist>
//t[0]=<track>
//i[0]=<time>
//o[0]=<source>
//r[0]=<rating>
//l[0]=<secs>
//b[0]=<album>
//n[0]=<tracknumber>
//m[0}=<mb-trackid>
string trackNr = track.TrackNr > 0 ? Convert.ToString(track.TrackNr) : String.Empty;
sb.AppendFormat(
"&a[{0}]={1}&t[{0}]={2}&i[{0}]={3}&o[{0}]={4}&r[{0}]={5}&l[{0}]={6}&b[{0}]={7}&n[{0}]={8}&m[{0}]={9}",
i, // number of queued items = 0
AudioscrobblerBase.getValidURLLastFMString(AudioscrobblerBase.UndoArtistPrefix(track.Artist)), // artist = 1
HttpUtility.UrlEncode(track.Title), // track = 2
track.StartTime, // time = 3
track.Source, // source = 4
track.Rating, // rating = 5
track.Duration.ToString(), // secs = 6
AudioscrobblerBase.getValidURLLastFMString(track.Album), // album = 7
trackNr, // tracknumber = 8
String.Empty // The MusicBrainz Track ID, or empty if not known.
);
}
num_tracks = i;
return(sb.ToString());
}
public string GetTransmitInfo(out int numtracks)
{
StringBuilder sb = new StringBuilder();
int i;
for (i = 0; i < queue.Count; i++)
{
/* Last.fm 1.2 can handle up to 50 songs in one request */
if (i == 49)
{
break;
}
QueuedTrack track = (QueuedTrack)queue[i];
string str_track_number = String.Empty;
if (track.TrackNumber != 0)
{
str_track_number = track.TrackNumber.ToString();
}
string source = "P"; /* chosen by user */
if (track.TrackAuth.Length != 0)
{
// from last.fm
source = "L" + track.TrackAuth;
}
sb.AppendFormat(
"&a[{9}]={0}&t[{9}]={1}&i[{9}]={2}&o[{9}]={3}&r[{9}]={4}&l[{9}]={5}&b[{9}]={6}&n[{9}]={7}&m[{9}]={8}",
HttpUtility.UrlEncode(track.Artist),
HttpUtility.UrlEncode(track.Title),
track.StartTime.ToString(),
source,
"" /* rating: L/B/S */,
track.Duration.ToString(),
HttpUtility.UrlEncode(track.Album),
str_track_number,
track.MusicBrainzId,
i);
}
numtracks = i;
return(sb.ToString());
}
public void if_upcoming_track_is_vetoed_VetoTrack_adds_veto_but_doesnt_skip()
{
// Arrange
var trackId = Guid.NewGuid();
var queueManager = GetMock <IQueueManager>();
var skipHelper = GetMock <ISkipHelper>();
var track = new QueuedTrack();
queueManager.Setup(m => m.Contains(trackId)).Returns(true);
queueManager.Setup(m => m.Get(trackId)).Returns(track);
skipHelper.Setup(m => m.RequiredVetoCount(track)).Returns(3);
// Act
ClassUnderTest.VetoTrack(trackId, "a user");
// Assert
Assert.That(track.Vetoes.Count, Is.EqualTo(1));
Assert.That(track.IsSkipped, Is.EqualTo(false));
}
public static string ToLoggerFriendlyTrackName(this QueuedTrack track)
{
if (track == null || track.Track == null)
{
return(String.Empty);
}
var artistName = String.Empty;
if (track.Track.Artists != null)
{
var artist = track.Track.Artists.FirstOrDefault();
if (artist != null)
{
artistName = artist.Name + ", ";
}
}
return(String.Format("{0}{1}", artistName, track.Track));
}
public QueuedTrack Execute(QueuedTrack trackToQueue)
{
if (trackToQueue.Track.MusicProvider == null || trackToQueue.Track.MusicProvider.Identifier != "sp")
{
return(trackToQueue);
}
if (DateTime.Now.Second % settings.RandomizerRatio == 0)
{
return(trackToQueue);
}
musicProvider = musicProviderFactory.GetMusicProviderByIdentifier(trackToQueue.Track.MusicProvider.Identifier);
var album = trackToQueue.Track.Album;
if (album == null)
{
return(trackToQueue);
}
var tracks = musicProvider.BrowseAlbum(album.Link, trackToQueue.User);
if (tracks.Tracks != null && tracks.Tracks.Any())
{
var track = tracks.Tracks.Random().FirstOrDefault();
if (track != null)
{
logger.Debug("Off Same Album Randomizer, converting track {0}", trackToQueue.ToLoggerFriendlyTrackName());
trackToQueue.Track = track;
trackToQueue.Track.Album = album;
trackToQueue.User = "******";
trackToQueue.Id = DataObject.GenerateId(); //if you don't do this then the autoplayed song will update over the user requested song
}
}
return(trackToQueue);
}
public void if_upcoming_track_has_reached_required_number_of_vetoes_VetoTrack_adds_veto_and_will_be_skipped()
{
// Arrange
var trackId = Guid.NewGuid();
var queueManager = GetMock <IQueueManager>();
var vetoHelper = GetMock <IVetoHelper>();
var skipHelper = GetMock <ISkipHelper>();
var track = new QueuedTrack {
Vetoes = new List <Veto>()
};
queueManager.Setup(m => m.Contains(trackId)).Returns(true);
queueManager.Setup(m => m.Get(trackId)).Returns(track);
skipHelper.Setup(m => m.RequiredVetoCount(track)).Returns(1);
// Act
ClassUnderTest.VetoTrack(trackId, "a user");
// Assert
Assert.That(track.Vetoes.Count == 1);
Assert.That(track.IsSkipped);
}
public QueuedTrack FindTrack()
{
if (_tracksForAutoplaying.Count <= settings.MinAutoplayableTracks)
{
if (_tracksForAutoplaying.Count == 0)
{
//If we have no tracks, we're probably just starting the service, just get the last track played
FillBagWithLastTrack();
}
// Fill the bag as a non-blocking call
ThreadPool.QueueUserWorkItem(FillBagWithAutoplayTracks);
}
QueuedTrack track = null;
if (_tracksForAutoplaying.LongCount() > 0)
{
track = randomizerFactory.Randomize.Execute(_tracksForAutoplaying.Pop());
}
return(track);
}
public void if_current_track_has_reached_required_number_of_vetoes_VetoTrack_adds_veto_and_skips()
{
// Arrange
var vetoHelper = GetMock <IVetoHelper>();
var skipHelper = GetMock <ISkipHelper>();
var musicPlayer = GetMock <IMusicPlayer>();
var track = new QueuedTrack();
musicPlayer.SetupGet(m => m.CurrentlyPlayingTrack).Returns(track);
skipHelper.Setup(m => m.RequiredVetoCount(track)).Returns(1);
var ds = GetMock <IDataService <QueuedTrack> >();
// Act
ClassUnderTest.VetoTrack(new Guid(), "a user");
// Assert
vetoHelper.Verify(m => m.CantVetoTrack("a user", track), Times.Once());
ds.Verify(m => m.Update(track));
musicPlayer.Verify(m => m.EndTrack(), Times.Once());
}
public string Enqueue(JObject json)
{
dynamic trackToQueue = json;
string id = trackToQueue.id;
string provider = trackToQueue.provider;
string reason = trackToQueue.reason;
var user = User.Identity.Name;
using (var client = new MusicServiceClient())
{
var track = client.GetTrack(id, provider, user);
var queuedTrack = new QueuedTrack
{
Track = track,
User = user,
Reason = reason
};
var errors = client.QueueTrack(queuedTrack);
return(errors);
}
}
public void If_a_dequeued_track_is_skipped_Dequeue_logs_it_and_dequeues_next_track()
{
// Arrange
var logger = GetMock <ILogger>();
var vetoHelperMock = GetMock <ISkipHelper>();
vetoHelperMock.Setup(v => v.RequiredVetoCount(It.IsAny <QueuedTrack>())).Returns(2); // One veto needed
var skippedTrack = new QueuedTrack {
Track = new Track {
Name = "TrackA"
}, IsSkipped = true
}; // Two vetoes
var anotherSkippedTrack = new QueuedTrack {
Track = new Track {
Name = "TrackB"
}, IsSkipped = true
}; // Two vetoes
var goodTrack = new QueuedTrack {
Track = new Track {
Name = "TrackC"
}
}; // not skipped
IConcurrentQueueOfQueuedTrack queue = new ConcurrentQueueOfQueuedTrack();
Register(queue);
queue.Enqueue(skippedTrack);
queue.Enqueue(anotherSkippedTrack);
queue.Enqueue(goodTrack);
// Act
var result = ClassUnderTest.Dequeue();
// Assert
logger.Verify(x => x.Debug(It.IsAny <string>(), It.IsAny <object[]>()));
Assert.That(result, Is.Not.Null);
Assert.That(result.Track.Name, Is.EqualTo("TrackC"));
}
public void Add(object track, DateTime started_at)
{
TrackInfo t = (track as TrackInfo);
if (t != null)
{
QueuedTrack new_queued_track = new QueuedTrack(t, started_at);
//FIXME Just log invalid tracks until we determine the root cause
if (IsInvalidQueuedTrack(new_queued_track))
{
Log.WarningFormat(
"Invalid data detected while adding to audioscrobbler queue for " +
"track '{0}', original start time: '{1}'", new_queued_track, started_at
);
}
queue.Add(new_queued_track);
dirty = true;
RaiseTrackAdded(this, new EventArgs());
}
}
public void Enqueue(QueuedTrack trackToQueue)
{
queue.Enqueue(trackToQueue);
}
public int GetRequiredVetoCount(QueuedTrack track)
{
const int minVetoCount = 2;
return((string.Compare(track.User, Constants.AutoplayUserName, StringComparison.CurrentCultureIgnoreCase) == 0) ? minVetoCount : int.MaxValue);
}
public QueuedTrack ResetAlreadyQueued(QueuedTrack queuedTrack, string user)
{
queuedTrack.Track = ResetAlreadyQueued(queuedTrack.Track, user);
return(queuedTrack);
}
public int GetRequiredVetoCount(QueuedTrack track)
{
const int requiredVetoCount = 1;
return((IsOutOfHours()) ? requiredVetoCount : int.MaxValue);
}
public void Add (object track, DateTime started_at)
{
TrackInfo t = (track as TrackInfo);
if (t != null) {
QueuedTrack new_queued_track = new QueuedTrack (t, started_at);
//FIXME Just log invalid tracks until we determine the root cause
if (IsInvalidQueuedTrack (new_queued_track)) {
Log.WarningFormat (
"Invalid data detected while adding to audioscrobbler queue for " +
"track '{0}', original start time: '{1}'", new_queued_track, started_at
);
}
queue.Add (new_queued_track);
dirty = true;
RaiseTrackAdded (this, new EventArgs ());
}
}
public QueuedTrack Execute(QueuedTrack trackToQueue)
{
logger.Debug("PassThroughRandomizer, {0}", trackToQueue.ToLoggerFriendlyTrackName());
return(trackToQueue);
}
