public IHttpActionResult Post([FromBody] AlbumResponseModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var album = new Album
{
Title = model.Title,
Year = model.Year,
Producer = model.Producer
};
foreach (var song in model.Songs)
{
album.Songs.Add(new Song
{
Title = song.Title,
Year = song.Year,
Duration = song.Duration
});
}
this.data.Albums.Add(album);
this.data.SaveChanges();
return(this.Ok(album.Id));
}
private static Tuple <AlbumResponseModel, IEnumerable <TrackModel> > DeserializeResponse(string json, int outputId, int artistId, string genre)
{
dynamic obj = Json.Decode(json);
string Artist = obj.artists[0].name;
string albumName = obj.name;
string release = obj.release_date;
int releaseYear = int.Parse(release.Split('-')[0]);
AlbumResponseModel album = new AlbumResponseModel
{
tytul = albumName,
rok = releaseYear,
_id = outputId,
arists_id = artistId,
gatunek = genre
};
List <TrackModel> tracks = new List <TrackModel>();
foreach (var track in obj.tracks.items)
{
var model = new TrackModel
{
czas_trwania = track.duration_ms,
pozycja = track.track_number,
nazwa = track.name,
albums_id = album._id
};
tracks.Add(model);
}
return(new Tuple <AlbumResponseModel, IEnumerable <TrackModel> >(album, tracks));
}
public IHttpActionResult Create(AlbumResponseModel album)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var addedAlbumId = this.albums.Add(album.Title, album.ReleaseDate, album.Producer);
return(this.Ok(addedAlbumId));
}
/// <summary>
/// Поиск исполнителей по введенному имени, вывод в консоль и сохранение в базу, если ответ апи пуст то вывод из базы
/// </summary>
/// <param name="artist"></param>
/// <returns></returns>
private static async Task <AlbumResponseModel> SearchArtistAlbums(string artist)
{
var validArtist = artist.ValidateArtist();
var url = $"{Consts.iTunes_base_url}/search?term={validArtist}&media=music&entity=album&attribute=artistTerm&limit=200";
var response = await Source.Instance.GetDataAsync(url);
if (response != null)
{
var res = JsonConvert.DeserializeObject <AlbumResponseModel>(response);
if (res.resultCount != 0)
{
res.results = res.results.OrderByDescending(x => x.releaseDate).ToList();
using DB db = new DB();
var rows = db.Albums.Select(x => x.collectionId).ToArray();
foreach (var i in res.results)
{
if (!rows.Contains(i.collectionId))
{
db.Albums.Add(i);
}
}
db.SaveChanges();
return(res);
}
else
{
Console.WriteLine("Nothing was found by request, the result from the database is shown below:");
using DB db = new DB();
var rows = db.Albums.Where(x => x.artistName.ToLower().Contains(artist)).ToList();
if (rows != null && rows.Count > 0)
{
AlbumResponseModel model = new AlbumResponseModel()
{
resultCount = rows.Count,
results = rows
};
return(model);
}
return(null);
}
}
else
{
return(null);
}
}
public IHttpActionResult Update(int id, AlbumResponseModel album)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var existingAlbumId = this.albums.Update(id, album.Title, album.ReleaseDate, album.Producer);
if (existingAlbumId == null)
{
return(this.NotFound());
}
return(this.Ok(existingAlbumId));
}
public IHttpActionResult Put(string title, [FromBody] AlbumResponseModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var album = this.data.Albums
.Find(x => x.Title.ToLowerInvariant() == title.ToLowerInvariant())
.FirstOrDefault();
if (album == null)
{
return(this.BadRequest("No album with that name was found!"));
}
album.Title = model.Title;
album.Producer = model.Producer;
album.Year = model.Year;
var songs = new List <Song>();
foreach (var song in model.Songs)
{
songs.Add(new Song
{
Title = song.Title,
Duration = song.Duration,
Year = song.Year
});
}
album.Songs = songs;
var newTitleInData = this.data.Albums.Find(x => x.Title.ToLowerInvariant() == album.Title.ToLowerInvariant())
.FirstOrDefault();
if (newTitleInData != null)
{
return(this.BadRequest("An album with the same title already exists!"));
}
this.data.Albums.Update(album);
this.data.SaveChanges();
return(this.Ok(album));
}
public static async Task <AlbumResponseModel> FetchAlbumAsync(string albumIdentifier, SpotifyAPICredentials spotifyAPICredentials)
{
var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials);
var album = await spotifyClient.Albums.Get(albumIdentifier);
var artistsRequest = new ArtistsRequest(album.Artists.Select(a => a.Id).ToList());
var artists = await spotifyClient.Artists.GetSeveral(artistsRequest);
var albumResponseModel = new AlbumResponseModel
{
Album = album,
Artists = artists.Artists
};
return(albumResponseModel);
}
public IHttpActionResult Post(AlbumResponseModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(ModelState));
}
var album = new Album
{
Title = model.Title,
Producer = model.Producer,
Year = model.Year
};
this.db.Albums.Add(album);
this.db.SaveChanges();
return(this.Created(this.Url.ToString(), album));
}
public IHttpActionResult Update(int id, AlbumResponseModel model)
{
if (this.ModelState.IsValid)
{
return(this.BadRequest(ModelState));
}
var album = db.Albums.GetById(id);
if (album == null)
{
return(this.BadRequest("There is no album with this Id!"));
}
album.Title = model.Title;
album.Producer = model.Producer;
album.Year = model.Year;
this.db.Albums.Update(album);
this.db.SaveChanges();
return(this.Ok(album));
}
public void TestInitialize()
{
this.controller = new AlbumsController(TestObjectFactory.GetAlbumsService());
this.controller.Configuration = new HttpConfiguration();
this.invalidAlbumModel = TestObjectFactory.GetInvalidAlbumModel();
}
