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 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 IMessage GetMessage(QueuedTrack queuedTrack)
{
IMessage message = null;
if (queuedTrack.LikeCount == GangbustersCount)
{
message = new Message(Gangbusters, queuedTrack.Track.Name);
}
return message;
}
public IMessage GetMessage(QueuedTrack queuedTrack)
{
IMessage message = null;
if(queuedTrack.LikeCount == FizzBungCount)
{
message = new Message(FizzBung,queuedTrack.Track.Name);
}
return 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 void SetUp()
{
queuedTrack = new QueuedTrack
{
Track = new Track
{
Name = "Test Track name",
Album = new Album { Name = "Test Album name" }
}
};
}
public QueuedTrack Execute(QueuedTrack trackToQueue)
{
logger.Debug("HistoryRandomizer, {0}", trackToQueue.ToLoggerFriendlyTrackName());
var nextTrack = queuedTrackDataService.GetAll().Random().FirstOrDefault();
if (nextTrack != null)
{
return nextTrack;
}
return trackToQueue;
}
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 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 string Enqueue(string id, string provider)
{
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
};
var errors = client.QueueTrack(queuedTrack);
return errors;
}
}
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;
queuedTrack.Track = tracksMusicProvider.GetTrack(qt._id, Constants.AutoplayUserName);
queuedTrack.User = Constants.AutoplayUserName;
_tracksForAutoplaying.Push(queuedTrack);
}
}
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 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 int RequiredVetoCount(QueuedTrack track)
{
return skipRules.Min(rule => rule.GetRequiredVetoCount(track));
}
public QueuedTrack Execute(QueuedTrack trackToQueue)
{
logger.Debug("PassThroughRandomizer, {0}", trackToQueue.ToLoggerFriendlyTrackName());
return trackToQueue;
}
public void PlayingTrackChanged(QueuedTrack track)
{
var context = GlobalHost.ConnectionManager.GetHubContext<QueueHub>();
context.Clients.All.updateCurrentTrack(track);
}
public bool CantVetoTrack(string vetoedByUser, QueuedTrack track)
{
return track.Vetoes.Any(v => v.ByUser == vetoedByUser);
}
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 QueuedTrack ResetAlreadyQueued(QueuedTrack queuedTrack, string user)
{
queuedTrack.Track = ResetAlreadyQueued(queuedTrack.Track, user);
return queuedTrack;
}
public int GetRequiredVetoCount(QueuedTrack track)
{
int minimumVetoCount = track.LikeCount;
return (settings.VetoCount > minimumVetoCount) ? settings.VetoCount : minimumVetoCount;
}
public bool CantVetoTrack(string vetoedByUser, QueuedTrack track)
{
int vetoCount = queuedTrackDataService.GetAll().Count(q => q.StartedPlayingDateTime > nowHelper.Now.Date && q.Vetoes.Any(v => v.ByUser == vetoedByUser));
return vetoCount >= vetoHelperSettings.DailyVetoLimit;
}
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 int GetRequiredVetoCount(QueuedTrack track)
{
const int minVetoCount = 2;
return (string.Compare(track.User, Constants.AutoplayUserName, StringComparison.CurrentCultureIgnoreCase) == 0) ? minVetoCount : int.MaxValue;
}
public bool CantVetoTrack(string vetoedByUser, QueuedTrack track)
{
return vetoRules.Any(r => r.CantVetoTrack(vetoedByUser, track));
}
public int GetRequiredVetoCount(QueuedTrack track)
{
return (track.Vetoes.Any(v => v.ByUser == track.User)) ? 1 : int.MaxValue;
}
public int GetRequiredVetoCount(QueuedTrack track)
{
const int requiredVetoCount = 1;
return (IsOutOfHours()) ? requiredVetoCount : int.MaxValue;
}
public void Enqueue(QueuedTrack trackToQueue)
{
queue.Enqueue(trackToQueue);
}
public IMessage GetMessage(QueuedTrack queuedTrack)
{
return broadcastMessageRules.OrderByDescending(r => r.Priority)
.Select(r => r.GetMessage(queuedTrack))
.FirstOrDefault(m => m != null);
}
