public void TestSaveCommand()
{
var vm = TrackViewModel.Create(new TrackInfo()
{
Name = INITIAL_TRACKNAME
});
vm.Name = MODIFIED_TRACKNAME;
//Testing the Save command...
vm.Save();
Assert.That(vm.Name, Is.EqualTo(MODIFIED_TRACKNAME));
}
public void TestCancelCommand()
{
var vm = TrackViewModel.Create(new TrackInfo()
{
Name = INITIAL_TRACKNAME
});
vm.Name = MODIFIED_TRACKNAME;
//Testing the Revert command...
vm.Revert();
Assert.That(vm.Name, Is.EqualTo(INITIAL_TRACKNAME));
}
private TrackViewModel EditViewModelInitializer(Track track)
{
TrackViewModel result = new TrackViewModel
{
AlbumName = db.Albums.Find(track.AlbumId).Name,
Id = track.TrackId,
list = GetItemList(),
Name = track.Name,
Rate = track.Rate
};
return(result);
}
public IActionResult Details(TrackViewModel model)
{
this.SetViewByUserAuthentication();
Track track = this.trackService.GetTrack(model.TrackId);
this.Model["name"] = track.Name;
this.Model["price"] = track.Price.ToString("F2").Replace('.', ',');
this.Model["link"] = HttpUtility.UrlDecode(track.Link).Replace("watch?v=", "embed/");
this.Model["albumId"] = model.AlbumId;
return(this.View());
}
private void EditItem(TrackViewModel model)
{
Track track = new Track
{
AlbumId = GetAlbumId(model.AlbumName),
Name = model.Name,
Rate = model.Rate,
TrackId = model.Id
};
db.Entry(track).State = EntityState.Modified;
db.SaveChanges();
}
public static Track UpdateData(this Track dbItem, TrackViewModel item)
{
if (item == null)
{
return(dbItem);
}
dbItem.TrackId = item.TrackId;
dbItem.TrackName = item.TrackName;
dbItem.TrackURL = item.TrackURL;
dbItem.AlbumId = item.AlbumId;
dbItem.ArtistId = item.ArtistId;
return(dbItem);
}
public void SetUp()
{
destinationFilename = "anArtist - aName.ext";
track = new Track(new TrackElement(), false, true);
fileSystemBrowser = new FileSystemBrowserStub()
{
DestinationFilename = destinationFilename
};
webAccessProxy = new WebAccessProxyStub();
downloadingMediaContent = Features.DownloadingMediaContent;
trackViewModel = new TrackViewModel(track, fileSystemBrowser, webAccessProxy);
}
private void AddTrack(ISearchResultViewModel album, TrackViewModel track)
{
var existing = album.Tracks.Where(x => x.Id == track.Id).FirstOrDefault();
if (existing != null)
{
return;
}
Action action = () => album.AddTrack(track);
Dispatcher.Invoke(action, DispatcherPriority.DataBind);
}
public virtual ActionResult Track(TrackViewModel model)
{
ModelState["SubmittedComplaint.Order"].Errors.Clear();
var order = _orderRepository.GetByAccessToken(model.AccessToken);
if (order == null)
{
return(FailedAsync(Views.Track, Views._Track, null, Resources.Error_NotFound_Order));
}
model.Order = order;
if (model.ComplaintIsNew)
{
model.SubmittedComplaint.Order = order;
model.SubmittedComplaint.SubmitDateUtc = DateTime.UtcNow;
model.SubmittedComplaint.Status = ComplaintStatus.Pending;
_orderComplaintRepository.AddOrUpdate(model.SubmittedComplaint);
_orderComplaintRepository.SaveChanges();
return(SucceededAsync(Views.Track, Views._Track, model, Resources.Success_OrderComplaintSubmitted));
}
if (model.ComplaintIsUpdated)
{
var dbOrderComplaint = _orderComplaintRepository.GetByOrder(order);
dbOrderComplaint.Message = model.SubmittedComplaint.Message;
dbOrderComplaint.Priority = model.SubmittedComplaint.Priority;
_orderComplaintRepository.AddOrUpdate(dbOrderComplaint);
_orderComplaintRepository.SaveChanges();
model.SubmittedComplaint = dbOrderComplaint;
return(SucceededAsync(Views.Track, Views._Track, model, Resources.Success_OrderComplaintUpdated));
}
model.SubmittedComplaint = _orderComplaintRepository.GetByOrder(order);
if (model.SubmittedComplaint == null)
{
model.SubmittedComplaint = new OrderComplaintModel {
Order = order,
Priority = ComplaintPriority.Normal
};
}
return(ViewAsync(Views.Track, Views._Track, model));
}
public void UpdateTrackInfo(TrackViewModel _Track)
{
var existingTrack = repo.GetByQuery(i => i.TrackId == _Track.TrackId).FirstOrDefault();
AlbumViewModel ThisAlbum = AddAlbum(_Track.AlbumName);
ArtistViewModel ThisArtist = AddArtist(_Track.ArtistName);
existingTrack.TrackName = _Track.TrackName;
existingTrack.AlbumId = ThisAlbum.AlbumId;
existingTrack.ArtistId = ThisArtist.ArtistId;
existingTrack.TrackURL = _Track.TrackURL;
repo.Update(existingTrack.UpdateData(existingTrack.ToModel()));
repo.SaveChanges();
}
private static async Task PlayAsyncInner(TrackViewModel track)
{
var mpi = await CreateMediaPlaybackItemAsync(track);
Player.Source = mpi;
Player.Play();
NewTrackPlayed.OnNext(new TrackMixed
{
Track = track,
PlaybackItem = mpi,
});
IsPlaying.OnNext(true);
}
public void Edit(Track track)
{
_editedTrack = track;
var artists = _library.Artists.ToList();
artists.Insert(0, new Artist {
Name = AddNew
});
var tags = artists.SelectMany(a => a.Tracks).SelectMany(t => t.Tags).Distinct().OrderBy(t => t).ToList();
Track = new TrackViewModel(_messenger, _webAlbumInfoService, _imageProcessingService, _webBrowserService, _fileDialogService, artists, tags, track);
}
public async Task <IActionResult> PostTrack([FromBody] TrackViewModel trackViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var track = Mapper.Map <Track>(trackViewModel);
this.context.Tracks.Add(track);
await this.context.SaveChangesAsync();
return(Ok(new { trackId = track.RecordId }));
}
private void ClearPlaybackInfo()
{
this.PlaybackInfoViewModel = new PlaybackInfoViewModel
{
Title = string.Empty,
Artist = string.Empty,
Album = string.Empty,
Year = string.Empty,
CurrentTime = string.Empty,
TotalTime = string.Empty
};
this.track = null;
}
public async Task StopIfPlayingAsync(TrackViewModel track)
{
if (track.SafePath.Equals(this.CurrentTrack.SafePath))
{
if (this.Queue.Count == 1)
{
this.Stop();
}
else
{
await this.PlayNextAsync();
}
}
}
private TrackViewModel CreateTrackViewModel(Track track)
{
TrackViewModel trackViewModel = new TrackViewModel()
{
Name = track.Name,
AlbumName = track.AlbumName,
Artists = string.Join(", ", track.Artists.ToArray()),
//Duration = track.Duration.ToString(),
Duration = TimeSpan.FromMilliseconds((double)track.Duration).ToString(@"mm\:ss"),
Popularity = track.Popularity
};
return(trackViewModel);
}
public void ShouldUpdateTrackDetails()
{
TrackViewModel _Track = new TrackViewModel
{
TrackId = 1,
TrackName = "1",
AlbumId = 1,
ArtistId = 1,
TrackURL = "C:\\Media\\Music\\Track1.mp3",
};
repos.UpdateTrackInfo(_Track);
Assert.IsTrue(context.Object.Tracks.Count(i => i.TrackName == "1") == 1);
}
public async Task <IActionResult> Post([FromBody] TrackViewModel input, CancellationToken ct = default(CancellationToken))
{
try
{
if (input == null)
{
return(BadRequest());
}
return(Ok(await _chinookSupervisor.AddTrackAsync(input, ct)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public static async Task AddFromClipboard(
this SourceList <TrackViewModel> sourceList,
string name,
CompositeDisposable disposable
)
{
var vm = await TrackViewModel.PasteFromClipboard();
vm.DisposeWith(disposable);
if (vm == null)
{
return;
}
vm.AddAndSetName(name, sourceList);
}
public static TrackViewModel Convert(Track track)
{
var trackViewModel = new TrackViewModel();
trackViewModel.TrackId = track.TrackId;
trackViewModel.Name = track.Name;
trackViewModel.AlbumId = track.AlbumId;
trackViewModel.MediaTypeId = track.MediaTypeId;
trackViewModel.GenreId = track.GenreId;
trackViewModel.Composer = track.Composer;
trackViewModel.Milliseconds = track.Milliseconds;
trackViewModel.Bytes = track.Bytes;
trackViewModel.UnitPrice = track.UnitPrice;
return(trackViewModel);
}
public async Task <ActionResult <Track> > PostPlayist(TrackViewModel tvm)
{
Track t = new Track()
{
Name = tvm.Name.Trim(),
Description = tvm.Description?.Trim(),
Id = Guid.NewGuid(),
Playlist = _context.Playlists.Find(Guid.Parse(tvm.Playlist))
};
_context.Tracks.Add(t);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetTrack), new { id = t.Id }, t));
}
public static Track ToData(this TrackViewModel item)
{
if (item == null)
{
return(null);
}
return(new Track
{
TrackId = item.TrackId,
TrackName = item.TrackName,
ArtistId = item.ArtistId,
AlbumId = item.AlbumId,
TrackURL = item.TrackURL,
});
}
// GET: Tracks/Create
public ActionResult Create()
{
var artists = db.Artists.ToList();
var albums = db.Albums.ToList();
var audioFiles = db.AudioFiles.ToList();
var viewModel = new TrackViewModel
{
Artists = artists,
Albums = albums,
AudioFiles = audioFiles
};
return(View(viewModel));
}
private void CommandBinding_ExecuteRenameTrack(object sender, ExecutedRoutedEventArgs e)
{
TrackViewModel track = (e.Parameter != null ? (TrackViewModel)e.Parameter : sequencer.SelectedTrack);
PromptWindow prompt = new PromptWindow("Rename track");
prompt.Owner = this;
prompt.PromptText = track.Label;
prompt.AllowEmpty = false;
if (prompt.ShowDialog() == true)
{
track.Label = prompt.PromptText;
}
}
public PartialViewResult GetTopTracks(string name, int count = 24, int page = 1)
{
var nameForRequest = name.Replace(" ", "+");
List <Track> tracks = _trackService.GetTopTracks(nameForRequest, count, page);
List <TrackViewModel> listTrack = new List <TrackViewModel>();
foreach (var tr in tracks)
{
var model = new TrackViewModel()
{
Name = tr.Name
};
listTrack.Add(model);
}
return(PartialView(listTrack));
}
public IActionResult Create(TrackViewModel model)
{
var track = Mapper.Map <Track>(model);
string albumId = this.Request.QueryData[IRunesConstants.AlbumIdFromTrackCreateFormThroughRequestQeury].ToString();
var trackId = this.TrackService.CreateTrack(track, albumId);
var trackDetails = new TrackDetailsViewModel
{
trackId = trackId,
albumId = albumId
};
return(this.Details(trackDetails));
}
public void AddTrack(TrackViewModel model)
{
var track = new Track
{
Name = model.Name,
Link = model.Link,
Price = decimal.Parse(model.Price),
AlbumId = model.AlbumId
};
using (var db = new IRunesContext())
{
db.Tracks.Add(track);
db.SaveChanges();
}
}
public void TestResetNameCommandYes()
{
var vm = TrackViewModel.Create(new TrackInfo()
{
Name = INITIAL_TRACKNAME
});
var serviceContainer = (vm as ISupportServices).ServiceContainer;
IMessageBoxService msgSvc = new DummyServiceForMessageBox(MessageResult.Yes);
serviceContainer.RegisterService(msgSvc);
//Testing the ResetName command while clicking Yes on the confirmation dialog...
vm.ResetName();
Assert.That(vm.Name, Is.EqualTo(""));
}
public async Task <ActionResult> Edit(int artistID, int albumID, int trackID)
{
Track desiredTrack = await backend.TrackGetByIDAsync(albumID, trackID);
// Was the track found?
if (desiredTrack != null)
{ // Yes
// Allow track to be edited
TrackViewModel viewModel = autoMapper.Map <TrackViewModel>(desiredTrack);
viewModel.ArtistID = artistID;
return(View(viewModel));
}
// Track wasn't found, redirect back to list
return(RedirectToAction("Details", "Album", routeValues: new { artistID = artistID, albumID = albumID }));
}
public async Task <IViewComponentResult> InvokeAsync(long playlistId)
{
TrackViewModel trackViewModel = new TrackViewModel()
{
PlaylistId = playlistId
};
var getAllTracks = await _tracksServices.GetAllTrack();
//ViewBag.Tracks = new SelectList(getAllTracks, "Id", "TrackURL");
ViewBag.Tracks = getAllTracks.Select(e => new SelectListItem {
Value = e.TrackURL.Substring(e.TrackURL.LastIndexOf('/') + 1), Text = e.TrackURL.Substring(e.TrackURL.LastIndexOf('/') + 1)
}).ToList();
return(await Task.FromResult((IViewComponentResult)View("AddTrack", trackViewModel)));
}
public void TrackAsGeoJson()
{
var track = new TrackViewModel();
track.Positions.Add(new[] { 102.0M, 0.0M });
track.Positions.Add(new[] { 103.0M, 1.0M });
track.Positions.Add(new[] { 104.0M, 0.0M });
track.Positions.Add(new[] { 105.0M, 1.0M });
track.Properties.Add("prop0", "value0");
track.Properties.Add("prop1", 0.0M);
var json = JsonConvert.SerializeObject(track.GeoJson);
System.Console.WriteLine(json);
Assert.True(true);
}
