// GET: Compositions
public async Task <IActionResult> Index(string searchString)
{
var compositions = new List <CompositionViewModel>();
var compositionsF = await _context.Composition
.Include(c => c.Album.AlbumsArtists)
.ThenInclude(c => c.Artist)
.Include(c => c.Song)
.ToListAsync();
foreach (var composition in compositionsF)
{
var compositionVM = new CompositionViewModel();
compositionVM.Composition = composition;
var favourit = await _context.FavouriteSongs
.Where(f => f.UserId == new Guid(User.FindFirst(x => x.Type == "id").Value))
.FirstOrDefaultAsync(f => f.CompositionId == composition.CompositionId);
if (favourit != null)
{
compositionVM.IsFavourite = true;
}
compositions.Add(compositionVM);
}
return(View(compositions));
//var musicOnContext = _context.Composition.Include(c => c.Album).Include(c => c.Song);
//return View(await musicOnContext.ToListAsync());
}
// GET: Compositions/Details/5
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var composition = await _context.Composition
.Include(c => c.Album.AlbumsArtists)
.ThenInclude(ga => ga.Artist)
.Include(c => c.Song)
.FirstOrDefaultAsync(m => m.CompositionId == id);
if (composition == null)
{
return(NotFound());
}
CompositionViewModel compositionView = new CompositionViewModel();
if (User.Identity.IsAuthenticated)
{
var currentUserId = new Guid(User.FindFirst(x => x.Type == "id").Value);
compositionView = ViewModelConstructor.FavouriteSongs(new List <Composition> {
composition
}, _context, currentUserId).First();
}
else
{
compositionView.Composition = composition;
}
return(View(compositionView));
}
public CompositionViewModel GetCompositionViewModel(Composition composition, string userId)
{
List <Tag> tags = GetTagsForComposition(composition);
CompositionViewModel compositionViewModel = new CompositionViewModel
{
Id = composition.Id,
Name = composition.Name,
AuthorName = composition.User.Name,
Genre = composition.GenreOfComposition,
Description = composition.Description,
DateOfCreation = composition.DateOfCreation.ToString("dd.MM.yyyy "),
Date = composition.DateOfCreation,
Tags = tags,
Comments = composition.Comments,
Chapters = composition.Chapters,
TagsForEdit = string.Join(",", tags.Select(x => x.Name)),
};
compositionViewModel.Rating = composition.Ratings.Count > 0 ? composition.Ratings.Average(r => r.RatingValue) : 0;
var rating = FindRatingForCompositionFromUser(composition.Id, userId);
if (rating != null)
{
compositionViewModel.CurrentUserRating = rating.RatingValue;
}
else
{
compositionViewModel.CurrentUserRating = 0;
}
return(compositionViewModel);
}
public IActionResult ReadChapter(int compositionId, int chapterIndex)
{
var userId = FindUserId();
var composition = compositionService.FindComposition(compositionId);
CompositionViewModel model = compositionService.GetCompositionViewModel(composition, userId);
ViewData["PreviousIndex"] = null;
ViewData["NextIndex"] = null;
ViewData["Index"] = chapterIndex;
ViewData["IsLast"] = false;
ViewData["IsFirst"] = false;
if (chapterIndex == 0)
{
ViewData["IsFirst"] = true;
}
if (chapterIndex == (model.Chapters.Count() - 1))
{
ViewData["IsLast"] = true;
}
if (model.Chapters.Count() - 1 > chapterIndex)
{
ViewData["NextIndex"] = chapterIndex + 1;
}
if (chapterIndex > 0)
{
ViewData["PreviousIndex"] = chapterIndex - 1;
}
return(View(model));
}
public ActionResult IncubatorPost(CompositionViewModel viewModel)
{
if (ModelState.IsValid)
{
var client = new WebClient();
client.Encoding = System.Text.Encoding.UTF8;
var query = string.Format("{0}://{1}:{2}/api/incubate?key={3}&mode={4}¬es={5}&drone={6}",
Request.Url.Scheme,
Request.Url.Host,
Request.Url.Port,
viewModel.Key,
viewModel.Mode,
viewModel.GermJson,
viewModel.Drone);
var variationsJson = client.DownloadString(query);
var serializer = new JavaScriptSerializer();
var incubator = serializer.Deserialize <MusicMaker.Incubator>(variationsJson);
viewModel.SmoothSequences = incubator.SmoothSequences;
viewModel.Retrograde = incubator.Retrograde;
viewModel.Inverse = incubator.Inverse;
viewModel.ChromaticInverse = incubator.ChromaticInverse;
viewModel.SumTones = incubator.SumTones;
viewModel.DifferenceTones = incubator.DifferenceTones;
return(View(viewModel));
}
else
{
return(View(new CompositionViewModel()));
}
}
public IActionResult EditComposition(CompositionViewModel compositionView)
{
if (ModelState.IsValid)
{
compositionService.EditComposition(compositionView);
return(RedirectToAction("Index", "User"));
}
return(View(compositionView));
}
// GET: MixTapes/Details/5
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var mixTape = await _context.MixTape
.FirstOrDefaultAsync(m => m.MixTapeId == id);
if (mixTape == null)
{
return(NotFound());
}
var compositions = await _context.MixtapesCompositions
.Where(mc => mc.MixTapeId == id)
.Join
(
_context.Composition
.Include(c => c.Album.AlbumsArtists)
.ThenInclude(ga => ga.Artist)
.Include(c => c.Song),
mc => mc.CompositionId,
c => c.CompositionId,
(mc, c) => new { mc, c }
)
.Select(mcc => mcc.c)
.ToListAsync();
MixTapeViewModel mixTapeView = new MixTapeViewModel();
mixTapeView.MixTape = mixTape;
if (User.Identity.IsAuthenticated)
{
var currentUserId = new Guid(User.FindFirst(x => x.Type == "id").Value);
mixTapeView.Compositions = ViewModelConstructor.FavouriteSongs(compositions, _context, currentUserId);
}
else
{
foreach (var comp in compositions)
{
var compVM = new CompositionViewModel()
{
Composition = comp
};
mixTapeView.Compositions.Add(compVM);
}
}
return(View(mixTapeView));
}
public void EditComposition(CompositionViewModel compositionViewModel)
{
var composition = FindComposition(compositionViewModel.Id);
RemoveTagComposition(composition);
composition.Name = compositionViewModel.Name;
composition.GenreOfComposition = compositionViewModel.Genre;
composition.Description = compositionViewModel.Description;
AddTagToComposition(compositionViewModel.TagsForEdit, composition);
context.Compositions.Update(composition);
context.SaveChanges();
}
public async Task <IActionResult> Index()
{
var compositions = from c in _context.Composition
.Include(c => c.Album.AlbumsArtists)
.ThenInclude(c => c.Artist)
.Include(c => c.Song)
.OrderByDescending(c => c.FavouriteSongs.Count)
.Take(10)
select c;
var albums = from c in _context.Album
.Include(c => c.AlbumsArtists)
.ThenInclude(c => c.Artist)
.OrderByDescending(c => c.Date)
.Take(10)
select c;
var compositionsF = await compositions.ToListAsync();
var home = new HomeModel
{
Albums = await albums.ToListAsync(),
};
if (User.Identity.IsAuthenticated)
{
var userId = new Guid(User.FindFirst(x => x.Type == "id").Value);
home.Compositions = ViewModelConstructor.FavouriteSongs(compositionsF, _context, userId);
}
else
{
foreach (var comp in compositionsF)
{
var compVM = new CompositionViewModel()
{
Composition = comp
};
home.Compositions.Add(compVM);
}
}
//var userId = new Guid(User.FindFirst(x => x.Type == "id").Value);
//home.Compositions = ViewModelConstructor.FavouriteSongs(compositionsF, _context, userId);
return(View(home));
}
public static List <CompositionViewModel> AlbumSongs(List <Composition> compositionsF, MusicOnContext _context, Guid userId)
{
List <CompositionViewModel> compositions = new List <CompositionViewModel>();
foreach (var composition in compositionsF)
{
var compositionVM = new CompositionViewModel();
compositionVM.Composition = composition;
var favourit = _context.FavouriteSongs
.Where(f => f.UserId == userId)
.FirstOrDefault(f => f.CompositionId == composition.CompositionId);
if (favourit != null)
{
compositionVM.IsFavourite = true;
}
compositions.Add(compositionVM);
}
return(compositions);
}
// GET: Albums/Details/5
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var album = await _context.Album
.Include(a => a.Genre)
.Include(a => a.AlbumsArtists)
.ThenInclude(a => a.Artist)
.Include(a => a.Composition)
.ThenInclude(c => c.Song)
.FirstOrDefaultAsync(m => m.AlbumId == id);
if (album == null)
{
return(NotFound());
}
AlbumViewModel albumView = new AlbumViewModel();
if (User.Identity.IsAuthenticated)
{
var currentUserId = new Guid(User.FindFirst(x => x.Type == "id").Value);
albumView.Compositions = ViewModelConstructor.FavouriteSongs(album.Composition.ToList(), _context, currentUserId);
}
else
{
foreach (var comp in album.Composition.ToList())
{
var compVM = new CompositionViewModel()
{
Composition = comp
};
albumView.Compositions.Add(compVM);
}
}
albumView.Album = album;
return(View(albumView));
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
CompositionViewModel formData = validationContext.ObjectInstance as CompositionViewModel;
if (formData == null)
{
return(ValidationResult.Success);
}
int minPitch = (int)formData.MinPitch;
int maxPitch = (int)formData.MaxPitch;
if (CompositionContext.IsPitchRangeValid(minPitch, maxPitch, out string errorMessage))
{
return(ValidationResult.Success);
}
else
{
return(new ValidationResult(errorMessage));
}
}
public ActionResult AddNewComposition(CompositionViewModel model)
{
try
{
if (ModelState.IsValid)
{
model.IngredientId = IngredientService.AddItem(new IngredientModel {
Name = model.IngredientName
});
CompositionService.AddItem(CompositionViewMapper.ConvertCompositonViewModelToCompositionModel(model));
return(RedirectToAction("EditRecipe", new { id = model.RecipeId }));
}
return(RedirectToAction("EditRecipe", new { id = model.RecipeId }));
}
catch (Exception e)
{
Logger.InitLogger();
Logger.Log.Error("Error: " + e);
return(View("_Error"));
}
}
public async Task <ActionResult> UpdateComposition([FromBody] CompositionViewModel composition)
{
try
{
if (composition == null)
{
logger.LogError($"Composition object sent from client is null");
return(BadRequest("Composition object is null"));
}
await compositionAdapter.UpdateComposition(composition).ConfigureAwait(false);
logger.LogInformation($"Composition {composition.Title} is successfully updated");
return(Ok());
}
catch (Exception ex)
{
logger.LogError($"Something went wrong inside UpdateComposition action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <ActionResult> Compose(int?songId = null)
{
// fetch id of current logged-in user (if user is indeed logged-in...)
string userId = User?.Identity?.GetUserId();
// fetch songs from db according to user's privilages
List <Song> authorizedSongs = User?.IsInRole(RoleName.Admin) ?? false
? await _databaseGateway.Songs.GetAllAsync()
: await _databaseGateway.Songs.FindAsync(s => s.IsPublic || s.UserId.Equals(userId));
// project artist and song name from song list and sort the list accordingly
var sortedProjectedSongs = authorizedSongs.Select(s => new
{
Id = s.Id,
Title = s.Artist + " - " + s.Title
}).OrderBy(s => s.Title).ToList();
// if user requested a specific song, select it
int?selectedSongId = authorizedSongs.Exists(s => s.Id == songId)
? songId
: authorizedSongs.FirstOrDefault()?.Id;
// build select list for the songs
SelectList songSelectList = new SelectList(sortedProjectedSongs, "Id", "Title", songId);
// build a view model with the prebuilt song list
CompositionViewModel viewModel = new CompositionViewModel
{
SongSelectList = songSelectList,
MusicalInstrument = MusicalInstrument.ElectricGrandPiano,
OverallNoteDurationFeel = OverallNoteDurationFeel.Medium,
PitchSelectList = new SelectList(_pitchSelectList, "Pitch", "Description"),
MinPitch = NotePitch.C4,
MaxPitch = NotePitch.G6,
useExistingMelodyAsSeed = false
};
// pass the view model to the view to render
return(View(viewModel));
}
public async Task <ActionResult> Compose(CompositionViewModel model)
{
// validate that sum of weights is equal to 100
double weightSum = model.WeightSum;
if (weightSum != 100)
{
string errorMessage =
$"The total weights of all fitness function " +
$"evaluators must sum up to 100.\n" +
$"The current sum is {weightSum}";
this.ModelState.AddModelError(nameof(model.AccentedBeats), errorMessage);
}
// assure all other validations passed okay
if (!ModelState.IsValid)
{
CompositionViewModel viewModel = new CompositionViewModel
{
SongSelectList = new SelectList(_databaseGateway.Songs.GetAll().OrderBy(s => s.Title), nameof(Song.Id), nameof(Song.Title)),
PitchSelectList = new SelectList(_pitchSelectList, nameof(PitchRecord.Pitch), nameof(PitchRecord.Description)),
};
return(View(viewModel));
}
// fetch song from datasource
Song song = _databaseGateway.Songs.Get(model.SongId);
// get the chord and file paths on the file server
string chordFilePath = await SongsController.GetSongPath(song.Id, _databaseGateway, User, SongFileType.ChordProgressionFile);
string midiFilePath = await SongsController.GetSongPath(song.Id, _databaseGateway, User, SongFileType.MidiOriginalFile);
// create a compositon instance
CompositionContext composition = new CompositionContext(
chordProgressionFilePath: chordFilePath,
midiFilePath: midiFilePath,
melodyTrackIndex: song.MelodyTrackIndex);
// build evaluators weights
MelodyEvaluatorsWeights weights = new MelodyEvaluatorsWeights
{
AccentedBeats = model.AccentedBeats,
ContourDirection = model.ContourDirection,
ContourStability = model.ContourStability,
DensityBalance = model.DensityBalance,
ExtremeIntervals = model.ExtremeIntervals,
PitchRange = model.PitchRange,
PitchVariety = model.PitchVariety,
SmoothMovement = model.SmoothMovement,
Syncopation = model.Syncopation
};
// Compose some melodies and fetch the best one
IMidiFile midiFile = composition.Compose(
strategy: CompositionStrategy.GeneticAlgorithmStrategy,
overallNoteDurationFeel: model.OverallNoteDurationFeel,
musicalInstrument: model.MusicalInstrument,
minPitch: model.MinPitch,
maxPitch: model.MaxPitch,
useExistingMelodyAsSeed: model.useExistingMelodyAsSeed,
customParams: weights)
.FirstOrDefault();
// save the midifile output internally
_midiFile = midiFile;
ViewBag.MidiFile = midiFile;
// save file on the file server
string directoryPath = HomeController.GetFileServerPath() + "Outputs" +
Path.DirectorySeparatorChar + song.Id + Path.DirectorySeparatorChar;
Directory.CreateDirectory(directoryPath);
string filePath = _midiFile.SaveFile(outputPath: directoryPath);
// return the file to the client client for downloading
string fileName = Path.GetFileName(filePath);
byte[] fileBytes = System.IO.File.ReadAllBytes(filePath);
return(File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName));
}
// GET: SearchResults
public async Task <IActionResult> Index(string searchString)
{
var search = new SearchModel();
var compositions = from c in _context.Composition
.Include(c => c.Album.AlbumsArtists)
.ThenInclude(c => c.Artist)
.Include(c => c.Song)
select c;
if (!String.IsNullOrEmpty(searchString))
{
compositions = compositions.Where(s => s.Song.Title.Contains(searchString));
}
var compositionsF = await compositions.ToListAsync();
if (User.Identity.IsAuthenticated)
{
var userId = new Guid(User.FindFirst(x => x.Type == "id").Value);
search.Compositions = ViewModelConstructor.FavouriteSongs(compositionsF, _context, userId);
}
else
{
foreach (var comp in compositionsF)
{
var compVM = new CompositionViewModel()
{
Composition = comp
};
search.Compositions.Add(compVM);
}
}
var artists = from c in _context.Artist
.Include(c => c.AlbumsArtists)
.ThenInclude(c => c.Album)
.ThenInclude(c => c.Genre)
select c;
if (!String.IsNullOrEmpty(searchString))
{
artists = artists.Where(s => s.Name.Contains(searchString));
}
var artistsF = await artists.ToListAsync();
if (User.Identity.IsAuthenticated)
{
var userId = new Guid(User.FindFirst(x => x.Type == "id").Value);
search.Artists = ViewModelConstructor.FavouriteArtists(artistsF, _context, userId);
}
else
{
foreach (var art in artistsF)
{
var artVM = new ArtistsViewModel()
{
Artist = art
};
search.Artists.Add(artVM);
}
}
var albums = from c in _context.Album
.Include(c => c.AlbumsArtists)
.ThenInclude(c => c.Artist)
select c;
if (!String.IsNullOrEmpty(searchString))
{
albums = albums.Where(s => s.Title.Contains(searchString));
}
search.Albums = await albums.ToListAsync();
var mixTapes = from c in _context.MixTape
select c;
if (!String.IsNullOrEmpty(searchString))
{
mixTapes = mixTapes.Where(s => s.Title.Contains(searchString));
}
search.MixTapes = await mixTapes.ToListAsync();
return(View(search));
}
public async Task <int> CreateComposition(CompositionViewModel composition)
{
return(await compositionService.CreateComposition(mapper.Map <Composition>(composition)).ConfigureAwait(false));
}
public async Task UpdateComposition(CompositionViewModel composition)
{
var updatedComposition = mapper.Map <Composition>(composition);
await compositionService.UpdateAsync(updatedComposition).ConfigureAwait(false);
}
