public void UpdatePlaylistFromStrings(Playlist playlist, IEnumerable <string> collection)
{
if (collection is null || playlist is null)
{
return;
}
using (BackgroundWorker worker = new BackgroundWorker())
{
worker.RunWorkerAsync(new object[] { playlist, collection });
worker.DoWork += DoUpdatePlaylist;
worker.RunWorkerCompleted += (s, e) =>
{
if (e.Result is null)
{
return;
}
foreach (SongInfo song in e.Result as IEnumerable <SongInfo> )
{
// add new songs to library and current displayed song collection
if (PlaylistLibrary.SongLocations.Add(song.Uri.LocalPath) || AllSongs.Count < PlaylistLibrary.SongLocations.Count)
{
AllSongs.Add(song);
Helpers.ConsoleLogger.Info($"Added {song.Uri.LocalPath} to {PlaylistLibrary.Name}");
Helpers.ConsoleLogger.Info($"Added {song.Title} is added to AllSongCollection");
}
if (!ReferenceEquals(AllSongs, CurrentSongCollection))
{
CurrentSongCollection.Add(song);
}
}
};
}
}
/// <summary>
/// Cleans up all links to other entries so that this entry can be deleted.
/// </summary>
public virtual void DeleteLinks()
{
var artistLinks = AllArtists.ToArray();
foreach (var artist in artistLinks)
{
artist.Delete();
}
var songLinks = AllSongs.ToArray();
foreach (var song in songLinks)
{
song.Delete();
}
var users = UserCollections.ToArray();
foreach (var user in users)
{
user.Delete();
}
Tags.DeleteUsages();
// Archived versions and comments are cascaded
}
/// <summary>
/// Cleans up all links to other entries so that this entry can be deleted.
/// </summary>
public virtual void DeleteLinks()
{
var artistLinks = AllArtists.ToArray();
foreach (var artist in artistLinks)
{
artist.Delete();
}
var songLinks = AllSongs.ToArray();
foreach (var song in songLinks)
{
song.Delete();
}
var users = UserCollections.ToArray();
foreach (var user in users)
{
user.Delete();
}
//ArchivedVersionsManager.Clear();
//Comments.Clear();
}
private void LoadSongList(Library library)
{
List <Song> Songs;
List <Song> AllSongs;
List <Song> RemainingSongs;
// First load all the songs that are in all the libraries.
AllSongs = Songs = SongLibrary.Songs.OrderBy(S => S.Title).ToList();
// Then get the ones in the selected library and the ones that aren't.
if (library == null)
{
Songs = AllSongs;
RemainingSongs = new List <Song>();
}
else
{
Songs = SongLibrary.Libraries.Where(l => l.Id == library.Id).First()
.Songs
.OrderBy(S => S.Title)
.ToList();
RemainingSongs = AllSongs.Except <Song>(Songs).ToList();
}
LoadListView(Songs, SongsAtStart); // Need to have a separate list independent of Library for the .Except later on.
LoadListView(Songs, SongsInLibrary);
LoadListView(RemainingSongs, SongsAvailable);
}
//Learning Accessory functions
private static ConsensusResults ConsensusLearning(SimParams par, Population pop,
List <int>[] tutors, List <int> learners)
{
//Create a consensus based on songs from several males
List <int>[] ConsensusSongs = new List <int> [learners.Count];
List <int>[] AddSyls = new List <int> [learners.Count];
List <int>[] AllSongs;
List <int> CollapsedSongs;
float Conform;
for (int i = 0; i < learners.Count; i++)
{
ConsensusSongs[i] = new List <int> {
};
AddSyls[i] = new List <int> {
};
AllSongs = ListeningTest(par, pop, tutors[i].ToArray(), par.ListeningThreshold);
CollapsedSongs = AllSongs.SelectMany(x => x).ToList();
ConsensusSongs[i] = CollapsedSongs.Distinct().ToList();
for (int j = 0; j < ConsensusSongs[i].Count(); j++)
{
Conform = ConsensusCalc(par, ConsensusSongs[i][j], CollapsedSongs);
if (par.NextFloat() < Conform)
{
AddSyls[i].Add(ConsensusSongs[i][j]);
}
}
}
ConsensusResults Returnable = new ConsensusResults(AddSyls, ConsensusSongs);
return(Returnable);
}
//Misc
public static Population OverLearn(SimParams par, Population pop,
int[] vacant, List <int> notVacant)
{
//Get learners and tutors
List <int> Learners = vacant.ToList();
List <int>[] Tutors = ChooseMultipleTutors(par, pop, Learners, notVacant, par.NumTutorOverLearn);
List <int>[] TutorSyls = new List <int> [Learners.Count];
//Create combined song with all sylls
List <int>[] AllSongs;
List <int> CollapsedSongs;
for (int i = 0; i < Learners.Count; i++)
{
AllSongs = ListeningTest(par, pop, Tutors[i].ToArray(), par.ListeningThreshold);
CollapsedSongs = AllSongs.SelectMany(x => x).ToList();
TutorSyls[i] = CollapsedSongs.Distinct().ToList();
}
//Add Syls and update song traits
AddSyllables(par, pop, Learners, TutorSyls);
UpdateSongTraits(par, pop, Learners);
return(pop);
}
public async Task SearchSongs(IEnumerable <Music> source, string keyword, SortBy criterion)
{
AllSongs.SetTo(await Task.Run(() => SearchHelper.SearchSongs(source, keyword, criterion)));
Songs.SetTo(AllSongs.Take(SongLimit));
SongsTextBlock.Text = Settings.settings.ShowCount ? Helper.LocalizeText("SongsWithCount", AllSongs.Count) : Helper.LocalizeText("Songs");
SongsViewAllButton.Visibility = AllSongs.Count > SongLimit ? Visibility.Visible : Visibility.Collapsed;
SortSongsButton.Visibility = Songs.Count < 2 ? Visibility.Collapsed : Visibility.Visible;
}
public virtual SongInList AddSong(Song song, int order, string notes)
{
ParamIs.NotNull(() => song);
var link = new SongInList(song, this, order, notes);
AllSongs.Add(link);
return(link);
}
private void Unsubscribe(IEnumerable <Song> songs)
{
foreach (Song song in songs ?? Enumerable.Empty <Song>())
{
CurrentSong.Unsubscribe(song);
OtherSongs.Unsubscribe(song);
AllSongs.Unsubscribe(song);
}
}
public void Initialize()
{
// Create Playlists and Library directory
if (!Directory.Exists(PlaylistDir))
{
Directory.CreateDirectory(PlaylistDir);
}
if (!Directory.Exists(SongDir))
{
Directory.CreateDirectory(SongDir);
}
// load playlists from playlist directory
GetPlaylistFiles();
// load songs from library.xml or Library directory
string library = Path.Combine(Environment.CurrentDirectory, "library.xml");
if (File.Exists(library))
{
PlaylistLibrary = LoadPlaylistFromXmlFile(library);
}
else
{
PlaylistLibrary = CreatePlaylistFromDirectory("library.xml", Path.Combine(Environment.CurrentDirectory, SongDir));
}
if (PlaylistLibrary != null)
{
BackgroundWorker worker = new BackgroundWorker();
LoadSongsFromPlaylist(PlaylistLibrary).ContinueWith((task) =>
{
IEnumerable <SongInfo> songs = task.Result;
foreach (SongInfo item in songs)
{
AllSongs.Add(item);
}
CurrentSelectedPlaylistFile = PlaylistLibrary;
CurrentSongCollection = AllSongs;
});
}
// init media player
mMediaPlayer.MediaOpened += MediaOpened;
mMediaPlayer.MediaEnded += MediaEnded;
mMediaPlayer.MediaFailed += MediaFailed;
mMediaPlayer.LoadedBehavior = MediaState.Manual;
mMediaPlayer.UnloadedBehavior = MediaState.Stop;
mMediaPlayer.Play();
// init timer to update song's position
mSongTimer = new Timer()
{
Enabled = true,
Interval = 1000.0 / 60.0
};
mSongTimer.Elapsed += TimerUpdateSongPosition;
}
public virtual SongInAlbum AddSong(string songName, int trackNum, int discNum)
{
ParamIs.NotNullOrEmpty(() => songName);
var track = new SongInAlbum(songName, this, trackNum, discNum);
AllSongs.Add(track);
return(track);
}
protected void Page_Load(object sender, EventArgs e)
{
Fill_Songs();
if (!Page.IsPostBack)
{
AllSongs.DataBind();
}
Generate_Link();
}
public virtual ArtistForSong AddSong(Song song, bool support, ArtistRoles roles)
{
ParamIs.NotNull(() => song);
var link = new ArtistForSong(song, this, support, roles);
AllSongs.Add(link);
song.AllArtists.Add(link);
return(link);
}
public void DeleteSong(int songId)
{
if (songLookupDictionary.ContainsKey(songId))
{
SongModel songToRemove = songLookupDictionary[songId];
AllSongs.Remove(songToRemove);
songLookupDictionary.Remove(songId);
}
DatabaseManager.Current.DeleteSong(songId);
}
public virtual SongInAlbum AddSong(Song song, int trackNum, int discNum)
{
ParamIs.NotNull(() => song);
var track = new SongInAlbum(song, this, trackNum, discNum);
AllSongs.Add(track);
song.AllAlbums.Add(track);
return(track);
}
private void SortSongsButton_Click(object sender, RoutedEventArgs e)
{
MenuFlyoutHelper.SetSortByMenu(sender, Settings.settings.SearchSongsCriterion, SongsCriteria,
async item =>
{
Settings.settings.SearchSongsCriterion = item;
LoadingProgress.Visibility = Visibility.Visible;
AllSongs.SetTo(await Task.Run(() => SearchHelper.SortSongs(AllSongs, CurrentKeyword.Text, item).ToList()));
Songs.SetTo(AllSongs.Take(Songs.Count));
LoadingProgress.Visibility = Visibility.Collapsed;
});
}
public virtual void OnSongDeleting(SongInAlbum songInAlbum)
{
ParamIs.NotNull(() => songInAlbum);
if (!songInAlbum.Album.Equals(this))
{
throw new ArgumentException("Song is not in album");
}
foreach (var song in Songs.Where(song => song.TrackNumber > songInAlbum.TrackNumber))
{
song.TrackNumber--;
}
AllSongs.Remove(songInAlbum);
}
public static async Task <AllSongs> GetSongInfo(IConfiguration configuration, string url)
{
var song = new AllSongs();
var videoID = GetYouTubeVideoID(url);
if (!string.IsNullOrWhiteSpace(videoID))
{
var ytService = GetYouTubeService(configuration);
if (ytService != null)
{
try
{
var videoRequest = ytService.Videos.List("snippet,contentDetails");
videoRequest.Id = videoID;
var videoItemsResponse = await videoRequest.ExecuteAsync();
var videoItem = videoItemsResponse.Items.FirstOrDefault();
if (videoItem != null)
{
var availableVideo = !(videoItem.Snippet.Title.ToLower().Contains("deleted") &&
videoItem.Snippet.Description.Contains("unavailable"));
if (availableVideo)
{
song = new AllSongs()
{
OriginalGame = "NEW",
OriginalTitle = videoItem.Snippet.Title,
Channel = videoItem.Snippet.ChannelTitle,
Duration = ConvertToTime(videoItem.ContentDetails.Duration),
YouTubeLink = $"https://youtu.be/{videoID}"
};
}
}
}
catch (Exception ex)
{
}
}
}
return(song);
}
private void Subscribe(IEnumerable <Song> songs)
{
foreach (Song song in songs ?? Enumerable.Empty <Song>())
{
bool isCurrentSong = song == song.Parent.Parent.CurrentSong;
if (isCurrentSong)
{
CurrentSong.Subscribe(song);
}
else
{
OtherSongs.Subscribe(song);
}
AllSongs.Subscribe(song);
}
}
public void Reset(IEnumerable <Song> songs, Song currentlyPlaying)
{
Logger.LogDebug("PartyService: Reset");
Console.WriteLine("PartyService: Reset");
AllSongs.Clear();
foreach (Song song in songs)
{
AllSongs.Add(song);
}
AllVotes.Clear();
CanVote = true;
CurrentlyPlaying = currentlyPlaying;
SongListingStream.OnNext(GenerateSongListing(AllSongs, CurrentlyPlaying));
VotingResultsStream.OnNext(GenerateVotingResults(AllSongs, AllVotes, CanVote));
}
public static void LoadPlaylists()
{
if (File.Exists("Playlists.xml"))
{
XElement playlists = XElement.Load("Playlists.xml");
foreach (XElement playlist in playlists.Elements("playlist"))
{
ObservableCollection <Song> songs = new ObservableCollection <Song>();
foreach (XElement song in playlist.Elements("song"))
{
Song songToAdd = AllSongs.FirstOrDefault(s => s.Name == song.Value);
if (songToAdd != null)
{
songs.Add(songToAdd);
}
}
Playlists.Add(new Playlist(playlist.Attribute("name").Value, songs));
}
}
}
public static void LoadAndSortSongs()
{
IEnumerable <string> songFiles = Directory.EnumerateFiles(@"C:\Users\mathewtraylor\Downloads", "*.*", SearchOption.AllDirectories)
.Where(f => f.EndsWith(".mp3", StringComparison.InvariantCultureIgnoreCase) || f.EndsWith(".wav", StringComparison.InvariantCultureIgnoreCase));
foreach (string filename in songFiles)
{
AllSongs.Add(new Song(filename));
}
IEnumerable <IGrouping <string, Song> > artists = AllSongs.GroupBy(s => s.Artists);
foreach (IGrouping <string, Song> artist in artists)
{
Artists.Add(new Artist(artist.Key, artist.Count()));
}
IEnumerable <IGrouping <string, Song> > albums = AllSongs.GroupBy(s => s.Album);
foreach (IGrouping <string, Song> album in albums)
{
Albums.Add(new Album(album.Key, album.Count()));
}
}
public static AllSongs SearchSongFirst(string song, List <AllSongs> playlist)
{
song = song.ToLower();
if (song.Contains("\""))
{
song = song.Replace("\"", string.Empty);
return(playlist.Where(x => x.Title.Contains(song)).FirstOrDefault());
}
song = GetString(song);
AllSongs result = null;
double maxScore = 0;
int maxMatches = 0;
var words = song.Split(' ');
foreach (var p in playlist)
{
var title = GetString(p.Title);
//var title = p.LowerCaseTitle.Replace('/', ' ').Replace(':', ' ').Replace('-', ' ').Replace('(', ' ').Replace(')', ' ');
var pWords = title.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var count = 0;
foreach (var w in words)
{
if (pWords.Contains(w))
{
count++;
}
}
var percentage = count / (double)pWords.Length;
if (count >= maxMatches)
{
if (count > maxMatches)
{
maxScore = percentage;
result = p;
maxMatches = count;
}
else
{
if (percentage > maxScore)
{
maxScore = percentage;
result = p;
maxMatches = count;
}
}
}
}
if (result == null)
{
return(playlist.Where(x => x.Title.Contains(song)).FirstOrDefault());
}
return(result);
}
public void Add(Song song)
{
AllSongs.Add(song);
}
public async Task <ActionResult> Create(IFormCollection collection, AllSongs song)
{
try
{
if (ModelState.IsValid)
{
var youTubeLink = collection["YouTubeLink"].ToString();
if (!string.IsNullOrWhiteSpace(youTubeLink))
{
var table = TableStorageService.ConnectToTable(Constants.AllSongsTableName);
TableContinuationToken tableContinuationToken = null;
int maxKey = 0;
var songExists = false;
do
{
var tableQuerySegment = await table.ExecuteQuerySegmentedAsync(new TableQuery <AllSongs>(), tableContinuationToken);
var songs = tableQuerySegment.Results;
var max = songs.Max(x => x.RowKey);
maxKey = Math.Max(maxKey, int.Parse(max));
tableContinuationToken = tableQuerySegment.ContinuationToken;
songExists = songs.Any(x => x.YouTubeLink == youTubeLink);
}while (tableContinuationToken != null && !songExists);
if (!songExists)
{
var i = (maxKey + 1).ToString("D4");
string title = collection["OriginalTitle"];
string game = collection["OriginalGame"];
var newSong = new AllSongs()
{
RowKey = i,
OriginalGame = game,
Game = game.ToLower(),
OriginalTitle = title,
PartitionKey = StringFunctions.ReplaceChars(game.ToLower()),
Title = StringFunctions.ReplaceChars(title.ToLower()),
Channel = collection["Channel"],
Duration = collection["Duration"],
YouTubeLink = youTubeLink,
LastTimeRequested = null,
RecentlyAdded = "✓",
Counter = 0,
Likes = 0
};
await TableStorageService.InsertEntity(newSong, Constants.AllSongsTableName);
//TODO: add tags from webpage
return(RedirectToAction("Index", "Playlist", new { ac = "The song was successfully added!", type = "success" }));
}
else
{
return(RedirectToAction("Index", "Playlist", new { ac = "The YouTube video URL already exists in the playlist!", type = "danger" }));
}
}
else
{
return(View());
}
}
else
{
return(View());
}
}
catch (Exception)
{
return(View());
}
}
public async Task <ActionResult> RequestSong(string pk, string rk)
{
var tableSong = TableStorageService.ConnectToTable("CurrentSong");
var queryCS = await tableSong.ExecuteQuerySegmentedAsync(new TableQuery <AzureTableSong>(), null);
var currentSong = queryCS.Results.FirstOrDefault();
if (currentSong.RowKey != rk)
{
var song = await TableStorageService.RetrieveEntity <AllSongs>(pk, rk, Constants.AllSongsTableName);
if (song != null)
{
var position = 1;
var channel = CookieService.Get(Request, Constants.ChannelCookieName);
var user = await userManager.GetUserAsync(User);
var userName = user.UserName;
var isModOwner = await userManager.IsInRoleAsync(user, "Moderator") ||
await userManager.IsInRoleAsync(user, "Owner");
var queueSongs = await TableStorageService.RetrieveAllEntities <AzureTableSong>(Constants.QueueTableName);
if (queueSongs.Count > 0)
{
if (!isModOwner)
{
var friend = await TableStorageService.RetrieveEntity <Friends>(channel, "1", Constants.FriendsTableName);
if (friend != null)
{
var friendRequests = queueSongs.Count(x => x.RequestedById == channel);
if (friendRequests > 1)
{
return(RedirectToAction("Index", "Playlist", new { ac = "Error. You already have two song requests on the queue.", type = "danger" }));
}
}
else
{
var userExists = queueSongs.Any(x => x.RequestedById == channel);
if (userExists)
{
return(RedirectToAction("Index", "Playlist", new { ac = "Error. You already have a song request on the queue.", type = "danger" }));
}
}
}
var songExists = queueSongs.Any(x => x.RowKey == rk);
if (songExists)
{
return(RedirectToAction("Index", "Playlist", new { ac = $"Error. That song is already on the queue.", type = "danger" }));
}
queueSongs = queueSongs.OrderBy(x => x.Position).ToList();
position = queueSongs.Last().Position + 1;
}
var lastRequest = (song.LastTimeRequested.HasValue)
? MathFunctions.GetCooldownMinutes(song.LastTimeRequested.Value) : 100;
if (isModOwner || lastRequest > 60)
{
var updateSong = new AllSongs()
{
PartitionKey = song.PartitionKey,
RowKey = song.RowKey,
Counter = song.Counter0 + 1,
LastTimeRequested = DateTime.UtcNow
};
await TableStorageService.MergeEntity(updateSong, Constants.AllSongsTableName);
var newSongQueue = new AzureTableSong()
{
PartitionKey = song.PartitionKey,
RowKey = song.RowKey,
Title = song.OriginalTitle,
OriginalGame = song.OriginalGame,
LowerCaseTitle = song.Title,
Channel = song.Channel,
VideoId = song.YouTubeLink.Replace("https://youtu.be/", string.Empty),
YouTubeLink = song.YouTubeLink,
Duration = song.Duration,
TotalTime = 0,
RecentlyAdded = song.RecentlyAdded,
RequestedBy = userName,
RequestedById = channel,
Counter = song.Counter0 + 1,
Likes = song.Likes0,
Position = position,
LastTimeRequested = song.LastTimeRequested
};
await TableStorageService.InsertEntity(newSongQueue, Constants.QueueTableName);
return(RedirectToAction("Index", "SongsQueue", new { ac = $"The song was added to the queue in position {position}.", type = "success" }));
}
else
{
return(RedirectToAction("Index", "Playlist", new { ac = $"Error. That song is in cooldown. Please wait {60 - lastRequest} minutes to request it again.", type = "danger" }));
}
}
return(RedirectToAction("Index", "Playlist", new { ac = "Error. The song does not exist.", type = "danger" }));
}
else
{
return(RedirectToAction("Index", "Playlist", new { ac = "Error. The song is currently playing.", type = "danger" }));
}
}
