public async Task <ActionResult <Music> > Delete(
[FromServices] DataContext context,
[FromServices] MusicRepository repository,
int id)
{
try
{
var music = await repository.GetByIdAsync(id);
if (music == null)
{
return(NotFound(new { message = "A música não foi localizada." }));
}
repository.Delete(music);
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = ErrorMessage.Internal }));
}
}
public async Task <ActionResult> DeleteEventMusics(
[FromServices] DataContext context,
[FromServices] EventRepository eventRepository,
[FromServices] MusicRepository musicRepository,
int eventId, int musicId)
{
try
{
var eventExists = eventRepository.CheckExistsById(eventId);
if (!eventExists)
{
return(NotFound(new { message = "O Evento não foi localizado." }));
}
var musicExists = musicRepository.CheckExistsById(musicId);
if (!musicExists)
{
return(NotFound(new { message = "A música não foi localizada." }));
}
eventRepository.DeleteMusic(eventId, musicId);
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = ErrorMessage.Internal }));
}
}
public void Music_DeleteById_ValidId_ValidatesRemoval(int id)
{
MusicRepository repository = new MusicRepository(_context, _mapper);
Assert.DoesNotThrow(() => repository.DeleteById(id));
Assert.Null(repository.GetById(id));
}
public void Store(string originalFileName, string guid)
{
string mediaServerUrlBase = ConfigurationManager.AppSettings["MediaServerSaveBaseUrl"];
string fullName = Path.Combine(mediaServerUrlBase, guid);
using (SmartPlayerEntities context = new SmartPlayerEntities())
{
MusicRepository repo = new MusicRepository(context);
var allSongs = repo.GetAll()
.Select(x => new AnalyzableSong {
Id = x.Id, PhysicalFileName = x.Guid
})
.ToList();
allSongs.ForEach(x => x.PhysicalFileName = Path.Combine(mediaServerUrlBase, x.PhysicalFileName));
List <double> correlationCoefficients = Analyzer.GetCorreleationCoefficientsFor(fullName, allSongs);
Song song = new Song()
{
Name = originalFileName,
Guid = guid
};
for (int i = 0; i < correlationCoefficients.Count; i++)
{
song.CorrelationsAsPrimary.Add(new SongSongCorrelation {
SecondarySongId = allSongs[i].Id, CorrelationScore = correlationCoefficients[i]
});
}
repo.Create(song);
}
}
public MainViewModel()
{
using (var repository = new MusicRepository())
{
MusicGroups = repository.MusicGroups;
}
}
public async Task <ActionResult <Music> > Post(
[FromServices] MusicRepository repository,
[FromServices] DataContext context,
[FromBody] AddMusicCommand command)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var music = new Music(
command.Title.Trim(),
command.Reminder.Trim(),
command.Singer.Trim(),
command.Lirycs,
command.Notation,
command.Video,
command.Play);
repository.Add(music);
await context.SaveChangesAsync();
return(Ok(new { music }));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = ErrorMessage.Internal }));
}
}
public UnitOfWork(RdioContext context)
{
_context = context;
Musics = new MusicRepository(_context);
Generos = new GeneroRepository(_context);
Artistas = new ArtistaRepository(_context);
Albums = new AlbumRepository(_context);
}
public MusicController(
ApplicationDbContext dbContext,
IWebHostEnvironment appEnv)
{
_musicRepo = new MusicRepository(dbContext);
_playlistRepo = new PlaylistRepository(dbContext);
_appEnv = appEnv;
}
// search music method
public JsonResult SearchMusic(string id)
{
// create music repo obj
MusicRepository musicRepo = new MusicRepository();
// return json
return(Json(musicRepo.SearchMusic(id), JsonRequestBehavior.AllowGet));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var uniqueId = (int)e.Parameter;
using (var repository = new MusicRepository())
{
viewModel.Songs = repository.MusicGroups.First(m => m.UniqueId.Equals(uniqueId)).Songs.ToList();
}
}
public void Music_Update_WithoutGenre_ThrowsElementUpdateException()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
Music music = repository.GetAll().First();
music.Genre = null;
Assert.Throws <ElementUpdateException <Music> >(() => repository.Update(music));
}
public void GetOldestSongs()
{
var musicRepository = new MusicRepository();
var songs = musicRepository.GetSongs(null, "Oldest", 0, null, null);
foreach (var s in songs)
{
testContextInstance.WriteLine("{0} {1} {2}", s.GENRE, s.ID, s.LOCATION);
}
}
public void Music_Insert_DuplicateMusic_ThrowsElementInsertException()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
Music baseMusic = repository.GetAll().First();
Music music = new Music {
Name = baseMusic.Name, Artist = baseMusic.Artist, Genre = baseMusic.Genre
};
Assert.Throws <ElementInsertException <Music> >(() => repository.Insert(music));
}
public void GetRandomElectronic()
{
var musicRepository = new MusicRepository();
var songs = musicRepository.GetSongs("Electronic", "Random", 0, null, null);
foreach (var s in songs)
{
testContextInstance.WriteLine("{0} {1} {2}", s.ID, s.LOCATION, s.TITLE);
}
}
public void GetGenres()
{
var musicRepository = new MusicRepository();
var genres = musicRepository.GetGenres();
foreach (var genre in genres)
{
testContextInstance.WriteLine(genre.Name);
}
}
public void Music_Insert_WithoutGenre_ThrowsElementInsertException()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
Music baseMusic = repository.GetAll().First();
Music music = new Music {
Name = "SomeName", Artist = baseMusic.Artist
};
Assert.Throws <ElementInsertException <Music> >(() => repository.Insert(music));
}
public void GetAlbums()
{
var musicRepository = new MusicRepository();
var albums = musicRepository.GetAlbums(0);
foreach (var album in albums)
{
testContextInstance.WriteLine("{0}", album);
}
}
public void GetSongsByLocation()
{
var musicRepository = new MusicRepository();
var songs = musicRepository.GetSongs(null, null, 0, null, "KEXP");
foreach (var s in songs)
{
testContextInstance.WriteLine("{0} {1} {2}", s.ID, s.LOCATION, s.TITLE);
}
}
public void GetSongs()
{
var musicRepository = new MusicRepository();
var songs = musicRepository.GetSongs(null, null, 0, null, null);
foreach (var s in songs)
{
testContextInstance.WriteLine("{0}, {1}, {2}", s.TITLE, s.LOCATION, s.ID);
}
}
public void GetSongsByGenreAndSequence()
{
var musicRepository = new MusicRepository();
var songs = musicRepository.GetSongs("Electronic", "Newest", 0, null, null);
foreach (var s in songs)
{
testContextInstance.WriteLine("{0} {1} {2}", s.GENRE, s.ID, s.LOCATION);
}
}
public void Music_Update_ValidMusic_ValidatesItsUpdate()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
string name = "newName";
Music music = repository.GetAll().First();
music.Name = name;
Assert.DoesNotThrow(() => repository.Update(music));
Assert.AreEqual(music, repository.GetByName(name));
}
public void Music_Update_InvalidMusicId_ThrowsElementUpdateException()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
string name = "name";
Music baseMusic = repository.GetAll().First();
Music music = new Music {
ID = -1, Name = name, Artist = baseMusic.Artist, Genre = baseMusic.Genre
};
Assert.Throws <ElementUpdateException <Music> >(() => repository.Update(music));
}
public void DeleteAudio(int id)
{
mr = new MusicRepository();
var myAudio = mr.GetAudios(id);
if (myAudio != null)
{
mr.DeleteAudio(myAudio);
}
}
public async Task <RequestEngineResult> ApproveAlbum(AlbumRequest request)
{
if (request == null)
{
return(new RequestEngineResult
{
ErrorMessage = "Request does not exist"
});
}
request.MarkedAsApproved = DateTime.Now;
request.Approved = true;
request.Denied = false;
await MusicRepository.Update(request);
var canNotify = await RunSpecificRule(request, SpecificRules.CanSendNotification);
if (canNotify.Success)
{
NotificationHelper.Notify(request, NotificationType.RequestApproved);
}
if (request.Approved)
{
var result = await _musicSender.Send(request);
if (result.Success && result.Sent)
{
return(new RequestEngineResult
{
Result = true
});
}
if (!result.Success)
{
Logger.LogWarning("Tried auto sending album but failed. Message: {0}", result.Message);
return(new RequestEngineResult
{
Message = result.Message,
ErrorMessage = result.Message,
Result = false
});
}
// If there are no providers then it's successful but movie has not been sent
}
return(new RequestEngineResult
{
Result = true
});
}
public List <SongDto> SearchSong(string query)
{
using (SmartPlayerEntities context = new SmartPlayerEntities())
{
MusicRepository repo = new MusicRepository(context);
var requestedSongs = repo.SearchByTerm(query);
return(requestedSongs.Select(x => new SongDto()
{
Id = x.Id, SongName = x.Name
}).ToList());
}
}
public void Music_Update_InvalidMusicName_ThrowsElementUpdateException()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
Music music = repository.GetAll().First();
Music secondMusic = repository.GetAll().Last();
music.Name = secondMusic.Name;
music.Artist = secondMusic.Artist;
music.Genre = secondMusic.Genre;
Assert.Throws <ElementUpdateException <Music> >(() => repository.Update(music));
}
public async Task <ActionResult <Music> > GetById([FromServices] MusicRepository repository, int id)
{
try
{
return(Ok(await repository.GetByIdAsync(id)));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = ErrorMessage.Internal }));
}
}
public void Music_Insert_ValidMusic_ValidatesItsInsertion()
{
MusicRepository repository = new MusicRepository(_context, _mapper);
string name = "test";
Music baseMusic = repository.GetAll().First();
Music music = new Music {
Name = name, Artist = baseMusic.Artist, Genre = baseMusic.Genre
};
Assert.DoesNotThrow(() => repository.Insert(music));
Assert.AreEqual(music, repository.GetByName(name));
}
public async Task <int> GetTotal()
{
var shouldHide = await HideFromOtherUsers();
if (shouldHide.Hide)
{
return(await MusicRepository.GetWithUser(shouldHide.UserId).CountAsync());
}
else
{
return(await MusicRepository.GetWithUser().CountAsync());
}
}
public void GetSongs()
{
bool songsReturned = false;
var musicRepository = new MusicRepository();
var songs = musicRepository.GetSongs(0, null, null);
foreach (var song in songs)
{
testContextInstance.WriteLine(string.Format("{0} : {1} : {2}: {3} {4}", song.Artist, song.Title, song.PartitionKey, song.RowKey, song.Location));
songsReturned = true;
}
Assert.IsTrue(songsReturned);
}
public PlayerSongDto GetSong(int songId, string username)
{
using(SmartPlayerEntities context = new SmartPlayerEntities())
{
MusicRepository repo = new MusicRepository(context);
var requestedSong = repo.GetSongById(songId);
var songUrl = ExtractSongUrl(requestedSong);
PlayerSongDto song = ExtractSongResult(username, context, requestedSong, songUrl);
return song;
}
}
public List<SongDto> GetAllSongs()
{
using(SmartPlayerEntities context = new SmartPlayerEntities())
{
MusicRepository repo = new MusicRepository(context);
var allSongs = repo.GetAll()
.Select(x => new SongDto
{
Id = x.Id,
SongName = x.Name
})
.ToList();
return allSongs;
}
}
private static Song GetNextSong(NextSongDto songRequest, string username, SmartPlayerEntities context)
{
MusicRepository musicRepo = new MusicRepository(context);
var excludedSongIdList = songRequest.PlayedSongIds;
var recommendedSongs = GetRecommendedSongsForUser(username, context);
recommendedSongs = recommendedSongs.Where(x => !excludedSongIdList.Contains(x.Id)).ToList();
var similarSongs = musicRepo.GetNextSongBasedOnUserAndGrade(songRequest.CurrentSongId);
similarSongs = similarSongs.Where(x => !excludedSongIdList.Contains(x.Id)).ToList();
var safetySet = new Lazy<List<Song>>(() => musicRepo.GetNextSongBasedOnUserAndGrade(songRequest.CurrentSongId, excludedSongIdList));
var selectedSong = GetNextSong(recommendedSongs, similarSongs, safetySet);
return selectedSong;
}
public List<SongDto> SearchSong(string query)
{
using(SmartPlayerEntities context = new SmartPlayerEntities())
{
MusicRepository repo = new MusicRepository(context);
var requestedSongs = repo.SearchByTerm(query);
return requestedSongs.Select(x => new SongDto() { Id = x.Id, SongName = x.Name }).ToList();
}
}
public void Store(string originalFileName, string guid)
{
string mediaServerUrlBase = ConfigurationManager.AppSettings["MediaServerSaveBaseUrl"];
string fullName = Path.Combine(mediaServerUrlBase, guid);
using(SmartPlayerEntities context = new SmartPlayerEntities())
{
MusicRepository repo = new MusicRepository(context);
var allSongs = repo.GetAll()
.Select(x => new AnalyzableSong { Id = x.Id, PhysicalFileName = x.Guid })
.ToList();
allSongs.ForEach(x => x.PhysicalFileName = Path.Combine(mediaServerUrlBase, x.PhysicalFileName));
List<double> correlationCoefficients = Analyzer.GetCorreleationCoefficientsFor(fullName, allSongs);
Song song = new Song()
{
Name = originalFileName,
Guid = guid
};
for(int i = 0; i < correlationCoefficients.Count; i++)
{
song.CorrelationsAsPrimary.Add(new SongSongCorrelation { SecondarySongId = allSongs[i].Id, CorrelationScore = correlationCoefficients[i] });
}
repo.Create(song);
}
}
