private async Task PopUpAlbums(string buttonNumber)
{
var popUp = new PopupAlbums();
popUp.CallbackEvent += (object sender, object e) =>
{
placeholderAlbum = (Model.Album)e;
if ((placeholderAlbum.AlbumId == Album1.AlbumId && placeholderAlbum.AlbumName != "Not Selected") ||
(placeholderAlbum.AlbumId == Album2.AlbumId && placeholderAlbum.AlbumName != "Not Selected") ||
(placeholderAlbum.AlbumId == Album3.AlbumId && placeholderAlbum.AlbumName != "Not Selected"))
{
Application.Current.MainPage.DisplayAlert("Error", "You can't feature an album more than once!", "OK");
}
else
{
if (int.Parse(buttonNumber) == 1)
{
Album1 = placeholderAlbum;
}
else if (int.Parse(buttonNumber) == 2)
{
Album2 = placeholderAlbum;
}
else if (int.Parse(buttonNumber) == 3)
{
Album3 = placeholderAlbum;
}
}
};
await PopupNavigation.Instance.PushAsync(popUp);
}
private async void Button_Clicked(object sender, EventArgs e)
{
_selectedAlbum = new Model.Album {
AlbumId = 0, AlbumName = "Not Selected"
};
await PopupNavigation.Instance.PopAsync();
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
Model.Album album = Service.getAlbumById(Convert.ToInt32(RouteData.Values["albumid"]));
if (album == null)
{
ModelState.AddModelError(String.Empty, "Albumet kunde inte hittas, försök igen med ett annat album.");
NewGenreDDL.Visible = false;
return;
}
else
{
AlbumName.Text = String.Format("Album: {0}", album.AlbumName);
Page.Title = String.Format("{0}: {1}", album.AlbumName, Page.Title);
}
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, "Ett fel uppstod när albumet hämtades.");
return;
}
try
{
NewGenreDDL.DataSource = CreateDataSource();
NewGenreDDL.DataTextField = "GenreName";
NewGenreDDL.DataValueField = "GenreId";
NewGenreDDL.DataBind();
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, "Ett fel uppstod när genrerna hämtades.");
return;
}
}
public ActionResult <Model.Album> Create([FromBody] Model.Album value)
{
try
{
var created = repository.Create(value);
return(CreatedAtAction(nameof(GetDetails), new { name = created.Name, owner = created.Owner }, created));
} catch (ArgumentException e)
{
return(BadRequest(new { error = e.Message }));
}
}
private async void ucAlbumUpsert_Load(object sender, EventArgs e)
{
var artists = await _artistApiService.Get <List <Model.Artist> >(null);
cbArtist.DataSource = artists;
cbArtist.ValueMember = "ID";
cbArtist.DisplayMember = "Name";
BuildAllTracksList();
BuildAlbumTracksList();
var tracksRequest = new TrackSearchRequest()
{
Page = _allTracksPage,
ItemsPerPage = _itemsPerPage
};
await LoadListAllTracks(tracksRequest);
if (_ID.HasValue)
{
_album = await _albumApiService.GetById <Model.Album>(_ID.Value);
txtName.Text = _album.Name;
txtReleaseYear.Text = _album.ReleaseYear.ToString();
if (_album.Image.Length != 0)
{
pbAlbumImage.Image = ImageHelper.ByteArrayToSystemDrawing(_album.Image);
pbAlbumImage.SizeMode = PictureBoxSizeMode.StretchImage;
}
cbArtist.SelectedItem = artists.Where(i => i.ID == _album.ArtistID).SingleOrDefault();
_albumTracks = await _albumApiService.GetTracks <List <Model.Track> >(_ID.Value, null);
var request = new TrackSearchRequest()
{
Page = _albumTracksPage,
ItemsPerPage = _itemsPerPage
};
LoadListAlbumTracks(request);
}
else
{
DataGridViewHelper.PopulateWithList(dgvAlbumTracks, _albumTracks, props);
}
SetButtonSavePosition();
}
// The id parameter name should match the DataKeyNames value set on the control
public void AlbumList_UpdateItem(int AlbumId)
{
if (ModelState.IsValid)
{
try
{
Model.Album album = Service.getAlbumById(AlbumId);
if (album == null)
{
// The item wasn't found
ModelState.AddModelError(String.Empty, String.Format("Item with id {0} was not found", AlbumId));
return;
}
if (TryUpdateModel(album))
{
// Save changes here, e.g. MyDataLayer.SaveChanges();
try
{
Service.saveAlbum(album);
Page.SetTempData("successmessage", "Albumet uppdaterades.");
Response.RedirectToRoute("EditAlbums", new { page = DataPager.StartRowIndex / DataPager.PageSize + 1 });
//SuccessMessage = String.Format("Kontakten uppdaterades.");
//Response.Redirect(String.Format("?page={0}", DataPager.StartRowIndex / DataPager.PageSize + 1), true);
}
catch (System.Data.SqlClient.SqlException ex)
{
ModelState.AddModelError(String.Empty, ex.Message);
//setModelState("Ett oväntat fel inträffade vid uppdateringen av kontakten.");
}
catch (ValidationException vx)
{
var validationResult = vx.Data["validationResult"] as List <ValidationResult>;
validationResult.ForEach(r => ModelState.AddModelError(String.Empty, r.ErrorMessage));
}
}
}
catch (ArgumentException ax)
{
ModelState.AddModelError(String.Empty, ax.Message);
//setModelState(ax.Message);
}
catch (ConnectionException cx)
{
ModelState.AddModelError(String.Empty, cx.Message);
//setModelState(cx.Message);
}
}
}
private Entities.Album toEntity(Model.Album album)
{
List <ObjectId> pictures = new List <ObjectId>();
//foreach(string id in album.Pictures)
//{
// pictures.Add(new ObjectId(id));
//}
return(new Entities.Album
{
AlbumName = album.Name,
Owner = album.Owner,
Pictures = pictures
});
}
public Model.Album Create(Model.Album value)
{
var album = FindByNameAndOwner(value.Name, value.Owner);
if (album == null)
{
var toInsert = toEntity(value);
albumCollection.InsertOne(toInsert);
return(toModel(FindByNameAndOwner(toInsert.AlbumName, toInsert.Owner)));
}
else
{
throw new ArgumentException("This user already has an album under that name");
}
}
public List <Model.Artist> Translate(Json.Music music)
{
var result = new List <Model.Artist>();
if (music == null || music.Artists == null || !music.Artists.Any())
{
return(result);
}
foreach (var artistJson in music.Artists.OrderBy(i => i.Name))
{
var artist = new Model.Artist {
Name = artistJson.Name
};
foreach (var albumJason in artistJson.Albums.OrderBy(i => i.Date))
{
var album = new Model.Album
{
Title = albumJason.Title,
Description = albumJason.Description,
Image = albumJason.Image,
Date = DateTime.Parse(albumJason.Date),
};
foreach (var songJason in albumJason.Songs)
{
var song = new Model.Song
{
Title = songJason.Title,
Length = songJason.Length,
Favorite = songJason.Favorite,
};
album.Songs.Add(song);
}
artist.Albums.Add(album);
}
result.Add(artist);
}
return(result);
}
// The return type can be changed to IEnumerable, however to support
// paging and sorting, the following parameters must be added:
// int maximumRows
// int startRowIndex
// out int totalRowCount
// string sortByExpression
public IEnumerable <Individuellt_arbete.Model.Song> AddSongs_GetData(int maximumRows, int startRowIndex, out int totalRowCount)
{
try
{
Model.Album album = Service.getAlbumById(Convert.ToInt32(RouteData.Values["albumid"]));
if (album == null)
{
ModelState.AddModelError(String.Empty, "Albumet kunde inte hittas, försök igen med ett annat album.");
InsertNewRow.Enabled = false;
totalRowCount = 0;
AddSongsListView.EmptyDataTemplate = null;
return(null);
}
IEnumerable <Model.Song> songList = Service.getSongList(maximumRows, startRowIndex, out totalRowCount, Convert.ToInt32(RouteData.Values["albumid"]));
return(songList);
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, ex.Message);
totalRowCount = 0;
return(null);
}
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
Model.Album album = Service.getAlbumById(Convert.ToInt32(RouteData.Values["albumid"]));
if (album == null)
{
ModelState.AddModelError(String.Empty, "Albumet kunde inte hittas, försök igen med ett annat album.");
Page.Title = "Albumet kunde inte hittas.";
AddSongsListView.Visible = false;
return;
}
else
{
AlbumName.Text = String.Format("Album: {0}", album.AlbumName);
Page.Title = String.Format("{0}: {1}", album.AlbumName, Page.Title);
}
}
catch (Exception ex)
{
ModelState.AddModelError(String.Empty, "Ett fel uppstod när albumet laddades.");
return;
}
}
private async Task SetRecommended()
{
var allArtists = await _artistService.Get <List <Model.Artist> >(null);
var allAlbums = await _albumService.Get <List <Model.Album> >(null);
if (ShownProfile.RecommendedAlbum1.HasValue)
{
Album1 = allAlbums.Where(a => a.AlbumId == ShownProfile.RecommendedAlbum1).FirstOrDefault();
}
else
{
Album1 = new Model.Album()
{
AlbumName = "N/A", AlbumId = 0, AlbumPhoto = File.ReadAllBytes("none.png")
};
}
if (ShownProfile.RecommendedAlbum2.HasValue)
{
Album2 = allAlbums.Where(a => a.AlbumId == ShownProfile.RecommendedAlbum2).FirstOrDefault();
}
else
{
Album2 = new Model.Album()
{
AlbumName = "N/A", AlbumId = 0, AlbumPhoto = File.ReadAllBytes("none.png")
};
}
if (ShownProfile.RecommendedAlbum3.HasValue)
{
Album3 = allAlbums.Where(a => a.AlbumId == ShownProfile.RecommendedAlbum3).FirstOrDefault();
}
else
{
Album3 = new Model.Album()
{
AlbumName = "N/A", AlbumId = 0, AlbumPhoto = File.ReadAllBytes("none.png")
};
}
if (ShownProfile.RecommendedArtist1.HasValue)
{
Artist1 = allArtists.Where(a => a.ArtistId == ShownProfile.RecommendedArtist1).FirstOrDefault();
}
else
{
Artist1 = new Model.Artist()
{
ArtistName = "N/A", ArtistId = 0, ArtistPhoto = File.ReadAllBytes("none.png")
};
}
if (ShownProfile.RecommendedArtist2.HasValue)
{
Artist2 = allArtists.Where(a => a.ArtistId == ShownProfile.RecommendedArtist2).FirstOrDefault();
}
else
{
Artist2 = new Model.Artist()
{
ArtistName = "N/A", ArtistId = 0, ArtistPhoto = File.ReadAllBytes("none.png")
};
}
if (ShownProfile.RecommendedArtist3.HasValue)
{
Artist3 = allArtists.Where(a => a.ArtistId == ShownProfile.RecommendedArtist3).FirstOrDefault();
}
else
{
Artist3 = new Model.Artist()
{
ArtistName = "N/A", ArtistId = 0, ArtistPhoto = File.ReadAllBytes("none.png")
};
}
}
public Album(int artistId, String name)
{
_model = new Model.Album(artistId, name);
}
public Album(int?id)
{
_model = new Model.Album(id);
}
public Album()
{
_model = new Model.Album();
}
private async void ListView_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
_selectedAlbum = await _albumService.GetById <Model.Album>(model.selectedAlbum.AlbumId);
await PopupNavigation.Instance.PopAsync();
}
