protected void uploadFile(object sender, EventArgs e)
{
try
{
if (FileUpload1.HasFile)
{
objsong = new SongHelper();
FileUpload1.PostedFile.SaveAs(Server.MapPath("~/Data/") + FileUpload1.FileName);
string filename = FileUpload1.FileName;
objsong.SongPath = filename;
objsong.SingerID = ddlsinger.SelectedValue.Trim();
objsong.TypeID = ddlcategory.SelectedValue.Trim();
objsong.SongName = txtsongname.Text.Trim();
ScriptManager.RegisterClientScriptBlock(Page, Page.GetType(), "Exception", "alert('" + objsong.saveSong() + "');", true);
}
}
catch (Exception ex)
{
lblmsg.Text = ex.Message.ToString();
lblmsg.ForeColor = Color.Red;
}
finally
{
ddlsinger.SelectedValue = "-1";
ddlcategory.SelectedValue = "-1";
txtsongname.Text = "";
}
}
public void CountWords_WhenSongLyricsIsNull_ShouldReturnZero()
{
var song = new Song();
var result = SongHelper.CountWords(song);
result.Should().Be(0);
}
public SongRepository(IHttpContextAccessor http_context, MintPlayerContext mintplayer_context, UserManager <Entities.User> user_manager, SongHelper song_helper, SubjectHelper subject_helper, Jobs.IElasticSearchJobRepository elasticSearchJobRepository)
{
this.http_context = http_context;
this.mintplayer_context = mintplayer_context;
this.user_manager = user_manager;
this.song_helper = song_helper;
this.subject_helper = subject_helper;
this.elasticSearchJobRepository = elasticSearchJobRepository;
}
public void CountWords_WhenSongIsInstrumental_ShouldWordCount()
{
var song = new Song {
Lyrics = "instrumental"
};
var result = SongHelper.CountWords(song);
result.Should().Be(1);
}
public void CountWords_WhenSongHasLyrics_ShouldWordCount()
{
var song = new Song {
Lyrics = "hello world"
};
var result = SongHelper.CountWords(song);
result.Should().Be(2);
}
public void CountWords_WhenSongLyricsIsEmpty_ShouldReturnZero()
{
var song = new Song {
Lyrics = string.Empty
};
var result = SongHelper.CountWords(song);
result.Should().Be(0);
}
public void HasLyrics_WhenSongHasLyrics_ShouldReturnTrue()
{
var song = new Song
{
Lyrics = "hello world"
};
var result = SongHelper.HasLyrics(song);
result.Should().BeTrue();
}
public void HasLyrics_WhenSongHasEmptyLyrics_ShouldReturnFalse()
{
var song = new Song
{
Lyrics = string.Empty
};
var result = SongHelper.HasLyrics(song);
result.Should().BeFalse();
}
public void IsInstrumental_WhenSongHasOneWord_ShouldReturnFalse()
{
var song = new Song
{
Lyrics = "test"
};
var result = SongHelper.IsInstrumental(song);
result.Should().BeFalse();
}
public void IsInstrumental_WhenSongIsNotInstrumental_ShouldReturnFalse()
{
var song = new Song
{
Lyrics = "hello world"
};
var result = SongHelper.IsInstrumental(song);
result.Should().BeFalse();
}
public void IsInstrumental_WhenSongIsInstrumental_ShouldReturnTrue()
{
var song = new Song
{
Lyrics = "(instrumental)"
};
var result = SongHelper.IsInstrumental(song);
result.Should().BeTrue();
}
private async Task <IEnumerable <Song> > GetSongLyricsForBatch(Artist artist, IEnumerable <Work> works)
{
var songsWithLyrics = new HashSet <Song>();
foreach (var work in works)
{
var song = await GetSongLyrics(artist, work);
if (SongHelper.HasLyrics(song) && !SongHelper.IsInstrumental(song))
{
songsWithLyrics.Add(song);
}
}
return(songsWithLyrics);
}
static void Main(string[] args)
{
var songs = SongHelper.GetAllSongs();
var fans = PersonHelper.GetAllFans();
//Select the person Jerry and add all the songs which start with the letter B
List <Song> songsStartingWithB = songs.Where(song => song.Title.StartsWith("B")).ToList();
fans.Where(fan => fan.FirstName == "Jerry").Select(fan => fan.FavouriteSongs = songsStartingWithB).ToList();
//Select the person Maria and add all the songs with length longer than 6 mins
List <Song> songsLongerThan6 = songs.Where(song => song.Length > 360).ToList();
fans.Where(fan => fan.FirstName == "Maria").Select(fan => fan.FavouriteSongs = songsLongerThan6).ToList();
//Select the person Jane and add all the songs that are of genre Rock
List <Song> rockSongs = songs.Where(song => song.Genre == Genre.Rock).ToList();
fans.Where(fan => fan.FirstName == "Jane").Select(fan => fan.FavouriteSongs = rockSongs).ToList();
//Select the person Stefan and add all songs shorter than 3 mins and of genre Hip - Hop
List <Song> hipHopShorterThan3 = songs.Where(song => song.Genre == Genre.Hip_Hop && song.Length < 180).ToList();
fans.Where(fan => fan.FirstName == "Stefan").Select(fan => fan.FavouriteSongs = hipHopShorterThan3).ToList();
//Select all persons from the persons array that have 4 or more songs
List <Person> fansWithMoreThan4Songs = fans.Where(fan => fan.FavouriteSongs.Count >= 4).ToList();
foreach (var item in fansWithMoreThan4Songs)
{
Console.WriteLine(item.FirstName);
}
Person jane = fans.FirstOrDefault(x => x.FirstName == "Jane");
Person stefan = fans.FirstOrDefault(x => x.Id == 2);
Person maria = fans.FirstOrDefault(x => x.Age == 43);
jane.GetFavSong();
Console.WriteLine("---------------------------------");
stefan.GetFavSong();
Console.WriteLine("---------------------------------");
maria.GetFavSong();
}
public string RunCommand(SpeechRecognizedEventArgs e)
{
switch (e.Result.Text)
{
case "next song":
case "play the next song":
case "skip this song":
case "play next song":
SongHelper.NextSong();
break;
case "last song":
case "previous song":
case "play the last song":
case "play the previous song":
SongHelper.PreviousSong();
break;
case "pause song":
case "pause this song":
case "pause song playback":
SongHelper.Pause();
break;
case "stop song":
case "stop song playback":
case "stop the music":
SongHelper.Stop();
break;
case "resume playback":
case "resume song":
case "resume playing":
SongHelper.Resume();
break;
}
return("");
}
private ArtistSongsStats ExtractStatsFromSongs(IEnumerable <Song> songs)
{
if (songs == null || !songs.Any())
{
return(new ArtistSongsStats());
}
var shortestSongWordCount = songs.Min(x => SongHelper.CountWords(x));
var shortestSong = songs.Where(x => SongHelper.CountWords(x) == shortestSongWordCount).FirstOrDefault();
var longestSongWordCount = songs.Max(x => SongHelper.CountWords(x));
var longestSong = songs.Where(x => SongHelper.CountWords(x) == longestSongWordCount).FirstOrDefault();
return(new ArtistSongsStats
{
SongsCount = songs.Count(),
AverageWordsInSongs = (int)songs.Average(s => SongHelper.CountWords(s)),
ShortestSongWordCount = shortestSongWordCount,
LongestSongWordCount = longestSongWordCount,
ShortestSong = shortestSong.Work.Title,
LongestSong = longestSong.Work.Title
});
}
public string RunCommand(SpeechRecognizedEventArgs e)
{
if (e.Result.Text.StartsWith("play song"))
{
SongHelper.Shuffle(false);
if (!SongHelper.PlaySong(e.Result.Text.Replace("play song ", "")))
{
return("I don't know that song.");
}
}
else if (e.Result.Text.StartsWith("play playlist"))
{
SongHelper.Shuffle(false);
if (SongHelper.PlayPlaylist(e.Result.Text.Replace("play playlist ", "")))
{
return("I don't have that playlist in my library.");
}
}
else if (e.Result.Text.StartsWith("shuffle playlist"))
{
SongHelper.Shuffle(true);
if (!SongHelper.PlayPlaylist(e.Result.Text.Replace("shuffle playlist ", "")))
{
return("I don't have that playlist in my library");
}
}
else if (e.Result.Text.StartsWith("shuffle all songs"))
{
SongHelper.Shuffle(true);
if (!SongHelper.PlayRandom())
{
return("I don't have any songs to shuffle...");
}
}
return("");
}
public Grammar BuildGrammar()
{
Choices choiceBuilder = new Choices();
// Songs
if (SongHelper.SongCount() > 0) // it freaks out if there's nothing in the one-of bit.
{
GrammarBuilder songBuilder = new GrammarBuilder();
songBuilder.Append("play song");
songBuilder.Append(SongHelper.GenerateSongChoices());
choiceBuilder.Add(songBuilder);
}
GrammarBuilder shuffleBuilder = new GrammarBuilder();
shuffleBuilder.Append("shuffle all songs");
choiceBuilder.Add(shuffleBuilder);
// Playlists
if (SongHelper.PlaylistCount() > 0)
{
GrammarBuilder playListBuilder = new GrammarBuilder();
playListBuilder.Append("play playlist");
playListBuilder.Append(SongHelper.GeneratePlaylistChoices());
choiceBuilder.Add(playListBuilder);
GrammarBuilder shufflePlayListBuilder = new GrammarBuilder();
shufflePlayListBuilder.Append("shuffle playlist");
shufflePlayListBuilder.Append(SongHelper.GeneratePlaylistChoices());
choiceBuilder.Add(shufflePlayListBuilder);
}
Grammar gram = new Grammar(new GrammarBuilder(choiceBuilder));
return(gram);
}
public void CountWords_WhenSongIsNull_ShouldReturnZero()
{
var result = SongHelper.CountWords(null);
result.Should().Be(0);
}
private string ApplyFormat(SongInAlbum track, string format, ContentLanguagePreference languagePreference)
{
var album = track.Album;
var sb = new StringBuilder(format);
sb.Replace("%album%", GetField(album.Names.SortNames[languagePreference]));
sb.Replace("%artists%", GetField(track.Song.ArtistString[languagePreference]));
sb.Replace("%discnumber%", track.DiscNumber.ToString());
sb.Replace("%producers%", GetField(string.Join(", ", ArtistHelper.GetProducerNames(track.Song.Artists, SongHelper.IsAnimation(track.Song.SongType), languagePreference))));
sb.Replace("%title%", GetField(track.Song.Names.SortNames[languagePreference]));
sb.Replace("%track%", track.TrackNumber.ToString());
sb.Replace("%vocalists%", GetField(string.Join(", ", ArtistHelper.GetVocalistNames(track.Song.Artists, languagePreference))));
return(sb.ToString());
}
public virtual void UpdateArtistString()
{
ArtistString = ArtistHelper.GetArtistString(Artists, SongHelper.IsAnimation(SongType));
}
public SongDetails(SongDetailsContract contract, IUserPermissionContext userContext, PVHelper pvHelper)
{
ParamIs.NotNull(() => contract);
Contract = contract;
AdditionalNames = contract.AdditionalNames;
Albums = contract.Albums;
AlternateVersions = contract.AlternateVersions.Where(a => a.SongType != SongType.Original).ToArray();
ArtistString = contract.ArtistString;
BrowsedAlbumId = contract.Album?.Id;
CanEdit = EntryPermissionManager.CanEdit(userContext, contract.Song);
CanEditPersonalDescription = contract.CanEditPersonalDescription;
CanRemoveTagUsages = contract.CanRemoveTagUsages;
CommentCount = contract.CommentCount;
CreateDate = contract.CreateDate;
DefaultLanguageSelection = contract.TranslatedName.DefaultLanguage;
Deleted = contract.Deleted;
Draft = contract.Song.Status == EntryStatus.Draft;
FavoritedTimes = contract.Song.FavoritedTimes;
Hits = contract.Hits;
Id = contract.Song.Id;
IsFavorited = contract.UserRating != SongVoteRating.Nothing;
LatestComments = contract.LatestComments;
Length = contract.Song.LengthSeconds;
LikedTimes = contract.LikeCount;
ListCount = contract.ListCount;
Lyrics = contract.LyricsFromParents;
MergedTo = contract.MergedTo;
Name = contract.Song.Name;
NicoId = contract.Song.NicoId;
Notes = contract.Notes;
OriginalVersion = (contract.Song.SongType != SongType.Original ? contract.OriginalVersion : null);
Pools = contract.Pools;
PublishDate = contract.Song.PublishDate;
RatingScore = contract.Song.RatingScore;
ReleaseEvent = contract.ReleaseEvent;
PersonalDescriptionText = contract.PersonalDescriptionText;
PersonalDescriptionAuthor = contract.PersonalDescriptionAuthor;
SongType = contract.Song.SongType;
SongTypeTag = contract.SongTypeTag;
Status = contract.Song.Status;
Suggestions = contract.Suggestions;
Tags = contract.Tags;
UserRating = contract.UserRating;
WebLinks = contract.WebLinks.ToList();
ContentFocus = SongHelper.GetContentFocus(SongType);
Animators = contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Animator)).ToArray();
Bands = contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Band)).ToArray();
Illustrators = ContentFocus == ContentFocus.Illustration ? contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Illustrator)).ToArray() : null;
Performers = contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Vocalist)).ToArray();
Producers = contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Producer)).ToArray();
var subjectsForThis = contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Subject)).ToArray();
Subject = subjectsForThis.Any() ? subjectsForThis : contract.SubjectsFromParents;
OtherArtists = contract.Artists.Where(a => a.Categories.HasFlag(ArtistCategories.Circle) ||
a.Categories.HasFlag(ArtistCategories.Label) ||
a.Categories.HasFlag(ArtistCategories.Other) ||
(ContentFocus != ContentFocus.Illustration && a.Categories.HasFlag(ArtistCategories.Illustrator))).ToArray();
var pvs = contract.PVs;
OriginalPVs = pvs.Where(p => p.PVType == PVType.Original).ToArray();
OtherPVs = pvs.Where(p => p.PVType != PVType.Original).ToArray();
PrimaryPV = pvHelper.PrimaryPV(pvs);
ThumbUrl = VideoServiceHelper.GetThumbUrlPreferNotNico(pvs);
ThumbUrlMaxSize = VideoServiceHelper.GetMaxSizeThumbUrl(pvs) ?? ThumbUrl;
if (PrimaryPV == null && !string.IsNullOrEmpty(NicoId))
{
PrimaryPV = new PVContract {
PVId = NicoId, Service = PVService.NicoNicoDouga
}
}
;
if (pvs.All(p => p.Service != PVService.Youtube))
{
var nicoPV = VideoServiceHelper.PrimaryPV(pvs, PVService.NicoNicoDouga);
var query = HttpUtility.UrlEncode((nicoPV != null && !string.IsNullOrEmpty(nicoPV.Name))
? nicoPV.Name
: $"{ArtistString} {Name}");
WebLinks.Add(new WebLinkContract($"http://www.youtube.com/results?search_query={query}",
ViewRes.Song.DetailsStrings.SearchYoutube, WebLinkCategory.Other, disabled: false));
}
JsonModel = new SongDetailsAjax(this, contract.PreferredLyrics, contract.Song.Version);
MinMilliBpm = contract.MinMilliBpm;
MaxMilliBpm = contract.MaxMilliBpm;
}
private string GetProducerStr(Song song, ContentLanguagePreference languagePreference)
{
return(string.Join(", ", ArtistHelper.GetProducerNames(song.Artists, SongHelper.GetContentFocus(song.SongType), languagePreference)));
}
private string GetFieldValue(string fieldName, SongInAlbum track, ContentLanguagePreference languagePreference)
{
var album = track.Album;
switch (fieldName.ToLowerInvariant())
{
// Album title
case "album":
return(album.Names.SortNames[languagePreference]);
// Artists for album
case "albumartist":
return(album.ArtistString[languagePreference]);
case "album artist": // foobar style
return(album.ArtistString[languagePreference]);
case "albummaincircle":
var circle = ArtistHelper.GetMainCircle(album.Artists.ToArray(), AlbumHelper.IsAnimation(album.DiscType));
return(circle != null ? circle.TranslatedName[languagePreference] : GetAlbumMainProducersStr(album, languagePreference));
// Artists for song, both producers and vocalists
case "artist":
return(track.Song != null ? track.Song.ArtistString[languagePreference] : string.Empty);
case "track artist": // foobar style
return(track.Song != null ? track.Song.ArtistString[languagePreference] : string.Empty);
case "catalognum":
return(album.OriginalRelease != null ? album.OriginalRelease.CatNum : string.Empty);
case "disccount":
return((album.Songs.Any() ? album.Songs.Max(s => s.DiscNumber) : 0).ToString());
// Disc number
case "discnumber":
return(track.DiscNumber.ToString());
// List of vocalists, separated by comma, with "feat." in the beginning if there are any vocalists, otherwise empty.
case "featvocalists":
var vocalistStr = GetVocalistStr(track, languagePreference);
return(vocalistStr.Any() ? " feat. " + vocalistStr : string.Empty);
case "genres":
return(string.Join(", ", SongHelper.GetGenreTags(track).Select(t => t.NameWithSpaces)));
// List of producers
case "producers":
return(GetProducerStr(track, languagePreference));
// Album release date
case "releasedate":
return(track.Album.OriginalReleaseDate.ToString());
case "releaseyear":
return(track.Album.OriginalReleaseDate.Year.ToString());
case "releaseevent":
return(album.OriginalReleaseEventName);
// Song title
case "title":
return(track.Song != null ? track.Song.Names.SortNames[languagePreference] : track.Name);
case "totaltrackcount":
return(album.Songs.Count().ToString());
// Track number
case "track":
return(track.TrackNumber.ToString());
case "tracknumber": // foobar style
return(track.TrackNumber.ToString());
// List of vocalists, separated by comma.
case "vocalists":
return(GetVocalistStr(track, languagePreference));
default:
return(string.Empty);
}
}
private string GetProducerStr(SongInAlbum track, ContentLanguagePreference languagePreference)
{
if (track.Song == null)
{
return(string.Empty);
}
return(string.Join(", ", ArtistHelper.GetProducerNames(track.Song.Artists, SongHelper.IsAnimation(track.Song.SongType), languagePreference)));
}
private Artist[] GetMainArtists(Song song, IList <IArtistLinkWithRoles> creditableArtists)
{
return(ArtistHelper.GetProducers(creditableArtists, SongHelper.GetContentFocus(song.SongType)).Select(a => a.Artist).ToArray());
}
protected override string GetFieldValue(string fieldName, SongInAlbum track, ContentLanguagePreference languagePreference)
{
var album = track.Album;
switch (fieldName)
{
// Album title
case "album":
return(album.Names.SortNames[languagePreference]);
case "albumid":
return(album.Id.ToString());
// Artists for album
case "albumartist":
return(album.ArtistString[languagePreference]);
case "album artist": // foobar style
return(album.ArtistString[languagePreference]);
case "albummaincircle":
var circle = ArtistHelper.GetMainCircle(album.Artists.ToArray(), AlbumHelper.GetContentFocus(album.DiscType));
return(circle != null ? circle.TranslatedName[languagePreference] : GetAlbumMainProducersStr(album, languagePreference));
case "catalognum":
return(album.OriginalRelease != null ? album.OriginalRelease.CatNum : string.Empty);
case "disccount":
return((album.Songs.Any() ? album.Songs.Max(s => s.DiscNumber) : 0).ToString());
// Disc number
case "discnumber":
return(track.DiscNumber.ToString());
case "genres":
return(string.Join(", ", SongHelper.GetGenreTags(track).Select(t => t.Names.SortNames[languagePreference])));
// Album release date
case "releasedate":
return(track.Album.OriginalReleaseDate.ToString());
case "releaseyear":
return(track.Album.OriginalReleaseDate.Year.ToString());
case "releaseevent":
return(album.OriginalReleaseEvent?.TranslatedName[languagePreference]);
// Song title
case "title":
return(track.Song != null ? track.Song.Names.SortNames[languagePreference] : track.Name);
case "totaltrackcount":
return(album.Songs.Count().ToString());
// Track number
case "track":
return(track.TrackNumber.ToString());
case "tracknumber": // foobar style
return(track.TrackNumber.ToString());
default:
return(GetFieldValue(fieldName, (ISongLink)track, languagePreference));
}
}
public bool IsValid(Song song, int instrumentalTagId)
{
ParamIs.NotNull(() => song);
var errors = new List <string>();
if (song.SongType == SongType.Unspecified)
{
errors.Add(SongValidationErrors.NeedType);
}
var derivedTypes = new[] { SongType.Remaster, SongType.Cover, SongType.Instrumental, SongType.MusicPV, SongType.Other, SongType.Remix };
if (song.Notes.IsEmpty && !song.HasOriginalVersion && derivedTypes.Contains(song.SongType))
{
errors.Add(SongValidationErrors.NeedOriginal);
}
if (song.Artists.All(a => a.Artist == null))
{
errors.Add(SongValidationErrors.NeedArtist);
}
if (song.Names.Names.All(n => n.Language == ContentLanguageSelection.Unspecified))
{
errors.Add(SongValidationErrors.UnspecifiedNames);
}
if (song.SongType != SongType.Instrumental &&
song.SongType != SongType.DramaPV &&
!song.Tags.HasTag(instrumentalTagId) &&
!ArtistHelper.GetVocalists(song.Artists.ToArray()).Any())
{
errors.Add(SongValidationErrors.NonInstrumentalSongNeedsVocalists);
}
if (!song.Artists.Any(a => a.Artist != null && ArtistHelper.IsProducerRole(a, SongHelper.GetContentFocus(song.SongType))))
{
errors.Add(SongValidationErrors.NeedProducer);
}
if (song.Artists.GroupBy(a => (a.Artist != null ? a.Artist.Id.ToString() : a.Name) + a.IsSupport).Any(a => a.Count() > 1))
{
errors.Add(SongValidationErrors.DuplicateArtist);
}
return(!errors.Any());
}
private Artist[] GetMainArtists(Song song, IList <IArtistWithSupport> creditableArtists)
{
return(ArtistHelper.GetProducers(creditableArtists, SongHelper.IsAnimation(song.SongType)).Select(a => a.Artist).ToArray());
}
public void HasLyrics_WhenSongIsNull_ShouldReturnFalse()
{
var result = SongHelper.HasLyrics(null);
result.Should().BeFalse();
}
