public async Task Init()
{
try
{
if (genresList.Count == 0)
{
var genres = await genreService.Get <List <MGenre> >(null);
foreach (var genre in genres)
{
genresList.Add(genre);
}
}
if (SelectedGenre != null)
{
AlbumSearchRequest search = new AlbumSearchRequest
{
GenreID = SelectedGenre.GenreID
};
albumsList.Clear();
var albumsGenre = await albumService.Get <List <MAlbum> >(search);
foreach (var album in albumsGenre)
{
if (album.Price > 0)
{
albumsList.Add(album);
}
}
}
}
catch (Exception)
{
}
}
public async Task <T> GetAlbums <T>(int id, AlbumSearchRequest search)
{
try
{
var url = $"{Properties.Settings.Default.APIUrl}/{_route}/{id}/Albums";
if (search != null)
{
url += "?";
url += await search.ToQueryString();
}
return(await url.WithBasicAuth(Username, Password).GetJsonAsync <T>());
}
catch (FlurlHttpException ex)
{
var errors = await ex.GetResponseJsonAsync <Dictionary <string, string[]> >();
var stringBuilder = new StringBuilder();
foreach (var error in errors)
{
stringBuilder.AppendLine($"{error.Key}, ${string.Join(",", error.Value)}");
}
MessageBox.Show(stringBuilder.ToString(), "Greška", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(default(T));
}
}
public async Task <List <Model.Album> > GetFavouriteAlbums(int id, AlbumSearchRequest request)
{
var query = _context.UserFavouriteAlbums
.Where(i => i.UserID == id)
.Select(i => i.Album)
.Select
(
i => new Database.Album()
{
ID = i.ID,
Image = i.Image,
ReleaseYear = i.ReleaseYear,
Name = i.Name,
Artist = i.Artist
}
)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request?.Name))
{
query = query.Where(x => x.Name.StartsWith(request.Name));
}
query = query.Skip((request.Page - 1) * request.ItemsPerPage);
if (request.ItemsPerPage > 0)
{
query = query.Take(request.ItemsPerPage);
}
var list = await query.ToListAsync();
return(_mapper.Map <List <Model.Album> >(list));
}
public async Task <T> GetAlbums <T>(int id, AlbumSearchRequest search)
{
try
{
var url = $"{APIUrl}/{_route}/{id}/Albums";
if (search != null)
{
url += "?";
url += await search.ToQueryString();
}
return(await url.WithBasicAuth(Username, Password).GetJsonAsync <T>());
}
catch (FlurlHttpException ex)
{
var errors = await ex.GetResponseJsonAsync <Dictionary <string, string[]> >();
var stringBuilder = new StringBuilder();
foreach (var error in errors)
{
stringBuilder.AppendLine($"{error.Key}, ${string.Join(",", error.Value)}");
}
await Application.Current.MainPage.DisplayAlert("Error", stringBuilder.ToString(), "OK");
return(default(T));
}
}
private async Task LoadList(AlbumSearchRequest request)
{
var result = await albumService.Get <List <MAlbum> >(request);
dgvAlbums.AutoGenerateColumns = false;
dgvAlbums.ReadOnly = true;
dgvAlbums.DataSource = result;
}
private async void btnSearchAlbum_Click(object sender, EventArgs e)
{
AlbumSearchRequest obj = new AlbumSearchRequest {
Name = txtboxAlbumName.Text
};
dgvAlbum.DataSource = await _albumService.Get <List <Album> >(obj, null);
}
private async Task Search(object query)
{
var request = new AlbumSearchRequest()
{
Name = query as string
};
await Init(request);
}
public List <Album> Get(AlbumSearchRequest album)
{
if (album.Name == null)
{
return(_context.Album.Include(b => b.Genre).Include(x => x.Performer).ToList());
}
return(_context.Album.Include(b => b.Genre).Include(x => x.Performer).Where(x => x.Name.Contains(album.Name)).ToList());
}
private async void ucAlbumList_Load(object sender, EventArgs e)
{
var request = new AlbumSearchRequest()
{
Page = 1,
ItemsPerPage = _itemsPerPage
};
await LoadList(request);
}
private async void btnSearch_Click(object sender, EventArgs e)
{
var search = txtSearch.Text;
var request = new AlbumSearchRequest()
{
Name = search
};
await LoadList(request);
}
private async void btnNext_Click(object sender, EventArgs e)
{
var request = new AlbumSearchRequest()
{
Page = _page + 1,
ItemsPerPage = _itemsPerPage,
Name = Convert.ToString(txtSearch.Text)
};
await LoadList(request);
}
public async Task <List <MAlbum> > GetAlbums(int ID, AlbumSearchRequest request)
{
var query = _context.Albums
.Include(i => i.AlbumTracks)
.Include(i => i.Artist)
.Where(i => i.ArtistID == ID)
.AsQueryable();
var list = await query.ToListAsync();
return(_mapper.Map <List <MAlbum> >(list));
}
private async void btnSearchAlbums_Click(object sender, EventArgs e)
{
var search = Convert.ToString(txtSearchAlbums.Text);
var request = new AlbumSearchRequest()
{
Page = 1,
ItemsPerPage = _itemsPerPage,
Name = search
};
await LoadListAlbums(request);
}
public async Task Init(AlbumSearchRequest request = null)
{
AlbumsList.Clear();
try
{
var albums = await _service.GetAlbums <List <Album> >(Artist.ID, request);
foreach (var album in albums)
{
AlbumsList.Add(new AlbumViewModel(album));
}
}
catch
{
}
}
public async Task Init(AlbumSearchRequest request = null)
{
AlbumsList.Clear();
try
{
var UserID = SignedInUserHelper.User.ID;
var albums = await _service.GetActivityAlbums(UserID, request);
foreach (var album in albums)
{
AlbumsList.Add(album);
}
}
catch
{
}
}
private async void cbGenreList_SelectedIndexChanged(object sender, EventArgs e)
{
var genre = cbGenreList.SelectedItem as MGenre;
var genreID = genre.GenreID;
if (genre.Name == "All Genres")
{
await LoadList(null);
}
else
{
var request = new AlbumSearchRequest()
{
GenreID = genreID
};
await LoadList(request);
}
}
public async Task Init(AlbumSearchRequest request = null)
{
AlbumsList.Clear();
try
{
int ID = SignedInUserHelper.User.ID;
var albums = await _service.GetFavouriteAlbums(ID, request);
foreach (var album in albums)
{
AlbumsList.Add(new AlbumViewModel(album));
}
}
catch
{
}
}
private async Task LoadList(AlbumSearchRequest request)
{
var list = await _apiService.Get <List <Model.Track> >(request);
if (list.Count > 0)
{
dgvAlbums.ColumnCount = 0;
DataGridViewHelper.PopulateWithList(dgvAlbums, list, _props);
_page = request.Page;
}
else if (!string.IsNullOrEmpty(Convert.ToString(txtSearch.Text)) && request.Page == 1)
{
dgvAlbums.ColumnCount = 0;
DataGridViewHelper.PopulateWithList(dgvAlbums, list, _props);
_page = 1;
}
btnPageNumber.Text = Convert.ToString(_page);
}
public async Task <List <Model.Album> > GetAlbums(int ID, AlbumSearchRequest request)
{
var query = _context.Albums
.Where(i => i.ArtistID == ID)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request?.Name))
{
query = query.Where(x => x.Name.StartsWith(request.Name));
}
query = query.Skip((request.Page - 1) * request.ItemsPerPage);
if (request.ItemsPerPage > 0)
{
query = query.Take(request.ItemsPerPage);
}
var list = await query.ToListAsync();
return(_mapper.Map <List <Model.Album> >(list));
}
private async Task LoadListAlbums(AlbumSearchRequest request)
{
var list = await _apiService.GetAlbums <List <Model.Album> >(_ID.Value, request);
if (list.Count > 0)
{
dgvAlbums.ColumnCount = 0;
DataGridViewHelper.PopulateWithList(dgvAlbums, list, albumProps);
_albumsPage = request.Page;
}
else if (!string.IsNullOrEmpty(Convert.ToString(txtSearchAlbums.Text)) && request.Page == 1)
{
dgvAlbums.ColumnCount = 0;
DataGridViewHelper.PopulateWithList(dgvAlbums, list, albumProps);
_albumsPage = 1;
}
btnPageNumberAlbums.Text = Convert.ToString(_albumsPage);
}
private async void ucArtistUpsert_Load(object sender, EventArgs e)
{
if (_ID.HasValue)
{
var artist = await _apiService.GetById <Model.Artist>(_ID.Value);
txtName.Text = artist.Name;
if (artist.Image.Length != 0)
{
pbArtistImage.Image = ImageHelper.ByteArrayToSystemDrawing(artist.Image);
pbArtistImage.SizeMode = PictureBoxSizeMode.StretchImage;
}
gbAlbums.Visible = true;
gbTracks.Visible = true;
BuildAlbumsList();
var albumRequest = new AlbumSearchRequest()
{
Page = _albumsPage,
ItemsPerPage = _itemsPerPage
};
await LoadListAlbums(albumRequest);
BuildTracksList();
var trackRequest = new TrackSearchRequest()
{
Page = _tracksPage,
ItemsPerPage = _itemsPerPage
};
await LoadListTracks(trackRequest);
gbTracks.Location = new Point(gbAlbums.Location.X, gbAlbums.Location.Y + gbAlbums.Height);
SetButtonSavePosition();
}
}
public async Task <List <Model.UserActivityAlbum> > GetActivityAlbums(int id, AlbumSearchRequest request)
{
var query = _context.UserActivityAlbums
.Where(i => i.UserID == id)
.Include(i => i.Album)
.OrderByDescending(i => i.InteractedAt)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request?.Name))
{
query = query.Where(x => x.Album.Name.StartsWith(request.Name));
}
query = query.Skip((request.Page - 1) * request.ItemsPerPage);
if (request.ItemsPerPage > 0)
{
query = query.Take(request.ItemsPerPage);
}
var list = await query.ToListAsync();
return(_mapper.Map <List <Model.UserActivityAlbum> >(list));
}
public ActionResult <List <Album> > Get([FromQuery] AlbumSearchRequest searchReq)
{
return(_service.Get(searchReq));
}
public async Task <List <Album> > GetFavouriteAlbums(int id, [FromQuery] AlbumSearchRequest request)
{
return(await _service.GetFavouriteAlbums(id, request));
}
public async Task <List <UserActivityAlbum> > GetActivityAlbums(int id, [FromQuery] AlbumSearchRequest request)
{
return(await _service.GetActivityAlbums(id, request));
}
