public CharterScheduleDto AnsweredBy(Actor actor)
{
var location = actor.AsksFor(LastResponse.Header(HttpHeaders.Location));
actor.AttemptsTo(Get.ResourceAt(location));
return(actor.AsksFor(LastResponse.Content <CharterScheduleDto>()));
}
public async override Task <PageResponse <LastStation> > HandleResponse(HttpResponseMessage response)
{
string json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
JToken jtoken = JsonConvert.DeserializeObject <JToken>(json).SelectToken("recentstations");
var stationsToken = jtoken.SelectToken("station");
var stations = stationsToken.Children().Select(LastStation.ParseJToken).ToList();
var pageresponse = PageResponse <LastStation> .CreateSuccessResponse(stations);
var attrToken = jtoken.SelectToken("@attr");
pageresponse.AddPageInfoFromJToken(attrToken);
return(pageresponse);
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastStation> >(status));
}
}
public async override Task <PageResponse <LastTrack> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastFmApiError error;
if (LastFm.IsResponseValid(json, out error) && response.IsSuccessStatusCode)
{
JToken jtoken = JsonConvert.DeserializeObject <JToken>(json).SelectToken("recenttracks");
var tracksToken = jtoken.SelectToken("track");
var tracks = new List <LastTrack>();
foreach (var track in tracksToken.Children())
{
var t = LastTrack.ParseJToken(track);
tracks.Add(t);
}
var pageresponse = PageResponse <LastTrack> .CreateSuccessResponse(tracks);
var attrToken = jtoken.SelectToken("@attr");
pageresponse.AddPageInfoFromJToken(attrToken);
return(pageresponse);
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastTrack> >(error));
}
}
private void ThrowIfError(LastResponse resp)
{
if (resp.Error != LastFmApiError.None)
{
throw new LastException(resp.Error.ToString(), "API Error");
}
}
public async Task <bool> Login(string username, string password)
{
LastResponse response = await Client.Auth.GetSessionTokenAsync(username, password);
if (response.Success)
{
LastUserSession us = Client.Auth.UserSession;
var userResponse = await Client.User.GetInfoAsync(us.Username);
LastUser user = userResponse.Content;
if (user != null)
{
//MessageDialog md = new MessageDialog($"Welcome, {user.FullName}");
//await md.ShowAsync();
ApplicationSettings.LastFmSessionToken = us.Token;
ApplicationSettings.LastFmSessionUsername = us.Username;
ApplicationSettings.LastFmSessionUserImageUri = user.Avatar.Large.AbsoluteUri;
this.Connected?.Invoke(user);
}
}
return(response.Success);
}
public string Execute(string command)
{
command += '\r';
LastResponse = Connection.WriteAndRead(command);
if (string.IsNullOrEmpty(LastResponse))
{
return(null);
}
LastResponse = Regex.Replace(LastResponse, @"[\0\n\r>]", "");
LastResponse = LastResponse.Trim();
if (LastResponse.Contains("SEARCHING..."))
{
LastResponse = LastResponse.Replace("SEARCHING...", "");
}
if (LastResponse.Contains("UNABLE TO CONNECT"))
{
throw new ObdException("Connection to OBD not possible. Check the ignition.");
}
if (LastResponse.Contains("NO DATA") || LastResponse.Contains("STOPPED") ||
LastResponse == "?" || LastResponse == "")
{
return(null);
}
return(LastResponse);
}
public override async Task <T> ExecuteAsync()
{
SetParameters();
Url = BuildRequestUrl();
var apisig = Auth.GenerateMethodSignature(Method, Parameters);
var postContent = LastFm.CreatePostBody(Method,
Auth.ApiKey,
apisig,
Parameters);
try
{
var httpClient = GetHttpClient();
var response = await httpClient.PostAsync(Url, postContent);
return(await HandleResponse(response));
}
catch (HttpRequestException)
{
if (LastFm.CatchRequestExceptions)
{
return(LastResponse.CreateErrorResponse <T>(LastFmApiError.RequestFailed));
}
else
{
throw;
}
}
}
protected async Task <T> ExecuteAsyncInternal()
{
SetParameters();
var toRemove = Parameters.Where(p => String.IsNullOrEmpty(p.Value)).ToList();
foreach (var parameter in toRemove)
{
Parameters.Remove(parameter.Key);
}
Url = BuildRequestUrl();
var apisig = Auth.GenerateMethodSignature(Method, Parameters);
var postContent = LastFm.CreatePostBody(Method,
Auth.ApiKey,
apisig,
Parameters);
try
{
var httpClient = HttpClient;
using (var response = await httpClient.PostAsync(Url, postContent))
{
return(await HandleResponse(response));
}
}
catch (HttpRequestException)
{
return(LastResponse.CreateErrorResponse <T>(LastResponseStatus.RequestFailed));
}
}
public void UpdateMessages(RtspMessage request, RtspMessage response)
{
if (Common.IDisposedExtensions.IsNullOrDisposed(request).Equals(false) &&
Common.IDisposedExtensions.IsNullOrDisposed(LastRequest).Equals(false))
{
LastRequest.IsPersistent = false;
LastRequest.Dispose();
}
if (Common.IDisposedExtensions.IsNullOrDisposed(LastRequest = request).Equals(false))
{
LastRequest.IsPersistent = true;
}
if (Common.IDisposedExtensions.IsNullOrDisposed(LastResponse).Equals(false))
{
LastResponse.IsPersistent = false;
LastResponse.Dispose();
}
if (Common.IDisposedExtensions.IsNullOrDisposed(LastResponse = response).Equals(false))
{
LastResponse.IsPersistent = true;
}
}
public async override Task <T> ExecuteAsync()
{
SetParameters();
EscapeParameters();
Url = BuildRequestUrl();
try
{
var httpClient = GetHttpClient();
var response = await httpClient.GetAsync(Url);
return(await HandleResponse(response));
}
catch (HttpRequestException)
{
if (LastFm.CatchRequestExceptions)
{
return(LastResponse.CreateErrorResponse <T>(LastFmApiError.RequestFailed));
}
else
{
throw;
}
}
}
// Artist info
public async Task <LastImageSet> GetArtistImageAsync(string artistName)
{
LastResponse <LastArtist> artist = await LastfmClient.Artist.GetInfoAsync(artistName).ConfigureAwait(false);
var artist2 = await LastfmClient.Artist.GetInfoByMbidAsync(artist.Content.Mbid).ConfigureAwait(false);
return(artist2?.Content?.MainImage);
}
public void should_return_last_http_status_code()
{
this.SetupResponse(new HttpResponseBuilder().WithHttpStatusCode(HttpStatusCode.NotFound).Build());
Actor.AttemptsTo(Get.ResourceAt("api/resource"));
Actor.Should(See.That(LastResponse.StatusCode())).IsEqualTo(HttpStatusCode.NotFound);
}
public override Task <T> ExecuteAsync()
{
if (!Auth.Authenticated)
{
return(Task.FromResult(LastResponse.CreateErrorResponse <T>(LastResponseStatus.BadAuth)));
}
return(ExecuteAsyncInternal());
}
/// <summary>
/// Fetches the tracklist of the clicked release and displays it.
/// </summary>
/// <param name="sender">Clicked release as <see cref="LastAlbum"/>.</param>
/// <param name="e">Ignored.</param>
public async void ReleaseClicked(object sender, EventArgs e)
{
if (EnableControls)
{
EnableControls = false;
try
{
var release = sender as Release;
OnStatusUpdated("Trying to fetch tracklist from '" + release.Name + "'");
LastResponse <LastAlbum> detailedRelease = null;
if (release.Mbid != null && release.Mbid != "")
{
detailedRelease = await _lastfmAlbumAPI.GetInfoByMbidAsync(release.Mbid);
}
else
{
detailedRelease = await _lastfmAlbumAPI.GetInfoAsync(release.ArtistName, release.Name);
}
if (detailedRelease.Success)
{
FetchedTracks.Clear();
foreach (var t in detailedRelease.Content.Tracks)
{
FetchedTrackViewModel vm = new FetchedTrackViewModel(new ScrobbleBase(t.Name, t.ArtistName, t.AlbumName, "", t.Duration), release.Image);
vm.ToScrobbleChanged += ToScrobbleChanged;
FetchedTracks.Add(vm);
}
if (FetchedTracks.Count != 0)
{
CurrentView = _trackResultView;
OnStatusUpdated("Successfully fetched tracklist from '" + release.Name + "'");
}
else
{
OnStatusUpdated("'" + release.Name + "' has no tracks");
}
}
else
{
OnStatusUpdated("Error while fetching tracklist from '" + release.Name + "'");
}
}
catch (Exception ex)
{
OnStatusUpdated("Fatal error while fetching tracklist from release: " + ex.Message);
}
finally
{
EnableControls = true;
}
}
}
/// <summary>
/// Fetches the tracklist of the clicked release and displays it.
/// </summary>
/// <param name="sender">Clicked release as <see cref="LastAlbum"/>.</param>
/// <param name="e">Ignored.</param>
public async void ReleaseClicked(object sender, EventArgs e)
{
if (EnableControls)
{
EnableControls = false;
try
{
var release = sender as Release;
OnStatusUpdated(string.Format("Trying to fetch tracklist from release '{0}'", release.Name));
LastResponse <LastAlbum> response = null;
if (!string.IsNullOrEmpty(release.Mbid))
{
response = await _lastfmAlbumAPI.GetInfoByMbidAsync(release.Mbid);
}
else
{
response = await _lastfmAlbumAPI.GetInfoAsync(release.ArtistName, release.Name);
}
if (response.Success && response.Status == LastResponseStatus.Successful)
{
FetchedTracks.Clear();
foreach (var t in response.Content.Tracks)
{
FetchedTrackViewModel vm = new FetchedTrackViewModel(new ScrobbleBase(t.Name, t.ArtistName, t.AlbumName, "", t.Duration), release.Image);
vm.ToScrobbleChanged += ToScrobbleChanged;
FetchedTracks.Add(vm);
}
if (FetchedTracks.Count != 0)
{
CurrentView = _trackResultView;
OnStatusUpdated(string.Format("Successfully fetched tracklist from release '{0}'", release.Name));
}
else
{
OnStatusUpdated(string.Format("Release '{0}' has no tracks", release.Name));
}
}
else
{
OnStatusUpdated(string.Format("Error while fetching tracklist from release '{0}': {1}", release.Name, response.Status));
}
}
catch (Exception ex)
{
OnStatusUpdated(string.Format("Fatal error while fetching tracklist from release: {0}", ex.Message));
}
finally
{
EnableControls = true;
}
}
}
public void should_return_last_http_headers_by_key()
{
var locationHeaderValue = "http://localhost:5000/api/resource/1";
SetupResponse(new HttpResponseBuilder().WithHeader(HttpHeaders.Location, locationHeaderValue).Build());
Actor.AttemptsTo(Post.DataAsJson(new { }).To("api/resource"));
Actor.Should(See.That(LastResponse.Header(HttpHeaders.Location))).IsEqualTo(locationHeaderValue);
}
public void PerformAs <T>(T actor) where T : Actor
{
var requestBody = GetRequestBody();
actor.AttemptsTo(Post.Data(requestBody).To(endpointUrl));
if (actor.AsksFor(LastResponse.StatusCode()) == HttpStatusCode.OK)
{
var response = actor.AsksFor(LastResponse.Content <OAuthToken>());
actor.Remember(TokenConstants.TokenKey, response);
}
}
private async Task LoadAlbumInfo()
{
TracksState = ContentState.Loading;
WikiState = ContentState.Loading;
LastResponse <LastAlbum> response = null;
if (String.IsNullOrEmpty(AlbumBase.Mbid))
{
response = await _lfClient.Album.GetInfoAsync(AlbumBase.ArtistName, AlbumBase.Name, true, _locService.CurrentLanguage.ToLastFmLang());
}
else
{
response = await _lfClient.Album.GetInfoByMbidAsync(AlbumBase.Mbid, true, _locService.CurrentLanguage.ToLastFmLang());
}
if (response.Success)
{
if (response.Content.Tracks != null && response.Content.Tracks.Any())
{
var tracksList = response.Content.Tracks.ToList();
foreach (var track in tracksList)
{
track.Images = response.Content.Images;
}
response.Content.Tracks = tracksList;
TracksState = ContentState.Normal;
}
else
{
TracksState = ContentState.NoData;
}
Album = response.Content;
if (Album.Wiki != null)
{
Album.Wiki.Content = Album.Wiki.Content.Split(
new string[] { "<a href" }, StringSplitOptions.RemoveEmptyEntries)[0];
WikiState = ContentState.Normal;
}
else
{
WikiState = ContentState.NoData;
}
}
else
{
TracksState = ContentState.Error;
WikiState = ContentState.Error;
}
}
public void Fetch_user_by_id()
{
var jack = Actor.Named("Jack").WhoCan(CallAnApi.At("https://reqres.in"));
var expectedResponse = new GetUserByIdResponse(id: 2, name: "fuchsia rose");
jack.AttemptsTo(FetchUserById(2));
jack.Should(See.That(LastResponse.Content <GetUserByIdResponse>()))
.Considering().All.Properties.HasFieldsWithSameValues(expectedResponse);
jack.Should(See.That(LastResponse.StatusCode())).IsEqualTo(HttpStatusCode.OK);
}
private HttpResponseMessage SendRequest(HttpRequestMessage request)
{
var task = HttpClient.SendAsync(request);
LastResponse = task.Result;
if (!IgnoreErrors)
{
LastResponse.EnsureSuccessStatusCode();
}
return(LastResponse);
}
public override string ToString()
{
if (LastResponse != null)
{
return(LastResponse.ToString());
}
else
{
return(this.GetType().ToString());
}
}
public void Delete_an_user()
{
var jack = Actor.Named("Jack").WhoCan(CallAnApi.At("https://reqres.in"));
var user = new User {
Name = "Sarah", Job = "Software Architect"
};
jack.AttemptsTo(DeleteAn(user));
jack.Should(See.That(LastResponse.Content <object>())).IsNull();
jack.Should(See.That(LastResponse.StatusCode())).IsEqualTo(HttpStatusCode.NoContent);
}
public async Task <Song> GetSong(string singerName, string songName)
{
LastResponse <LastTrack> resp = await new TrackApi(_lastAuth).GetInfoAsync(songName, singerName);
return(new Song
{
Name = resp.Content.Name,
SongId = resp.Content.Name,
SingerId = resp.Content.ArtistName,
});
//Создать папку в веб проекте и оти туда дергать урлы
}
public async Task <Singer> GetSingerInfoAsync(string singerName)
{
LastResponse <LastArtist> singerResp = await new ArtistApi(_lastAuth).GetArtistInfoAsync(singerName);
Singer singer = new Singer
{
SingerId = singerResp.Content.Name,
Name = singerResp.Content.Name,
Photo = new Image(singerResp.Content.MainImage.ExtraLarge)
};
return(singer);
}
public void Modify_part_of_an_user()
{
var jack = Actor.Named("Jack").WhoCan(CallAnApi.At("https://reqres.in"));
var user = new User {
Name = "Sarah", Job = "Software Architect"
};
jack.AttemptsTo(ModifyPartOf(user));
jack.Should(See.That(LastResponse.Content <ModifyUserResponse>()))
.Considering().All.Properties.HasFieldsWithSameValues(user);
jack.Should(See.That(LastResponse.StatusCode())).IsEqualTo(HttpStatusCode.OK);
}
public void should_return_last_http_content()
{
var response = "{firstname:'foo', lastname:'bar'}";
this.SetupResponse(new HttpResponseBuilder().WithContent(response).Build());
var expectedCustomer = new Customer {
Firstname = "foo", Lastname = "bar"
};
Actor.AttemptsTo(Get.ResourceAt("api/resource"));
Actor.Should(See.That(LastResponse.Content <Customer>())).HasPropertiesWithSameValues(expectedCustomer);
}
public override async Task <LastResponse <string> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
if (LastFm.IsResponseValid(json, out LastResponseStatus status) && response.IsSuccessStatusCode)
{
var token = JsonConvert.DeserializeObject <JObject>(json).GetValue("token");
return(LastResponse <string> .CreateSuccessResponse(token.Value <string>()));
}
else
{
return(LastResponse.CreateErrorResponse <LastResponse <string> >(status));
}
}
public async Task <IEnumerable <ArtistTileData> > RecentTopArtists()
{
var pageNum = 1;
var scrobblers = new List <LastTrack>();
IEnumerable <LastTrack> pagedTracks = null;
do
{
pagedTracks = await LoadScrobbles(pageNum);
scrobblers.AddRange(pagedTracks);
pageNum++;
} while (pagedTracks.Any());
scrobblers.ForEach(x => Debug.WriteLine(x.ArtistName));
var artists = scrobblers
.GroupBy(x => new { Id = x.ArtistMbid, Name = x.ArtistName })
.OrderByDescending(x => x.Count())
.Select(x => new ArtistTileData()
{
Id = x.Key.Id,
Name = x.Key.Name,
Count = x.Count()
})
.Take(5)
.ToList();
foreach (var item in artists)
{
LastResponse <LastArtist> artistInfo = null;
if (!string.IsNullOrWhiteSpace(item.Id))
{
artistInfo = await client.Artist.GetInfoByMbidAsync(item.Id);
}
else
{
artistInfo = await client.Artist.GetInfoAsync(item.Name, autocorrect : true);
}
item.Url = artistInfo.Content?.MainImage?.Large?.OriginalString ?? artistInfo.Content?.MainImage?.LastOrDefault(x => !string.IsNullOrWhiteSpace(x?.OriginalString))?.OriginalString;
}
Debug.WriteLine("TOP ARTISTS: ");
artists.ForEach(x => Debug.WriteLine($"Artist: {x.Name} Count: {x.Count}"));
return(artists);
}
/// <summary>
/// Reads the response from the mozrepl server.
/// </summary>
/// <param name="checkForErrors">
/// The check For Errors.
/// </param>
public void ReadResponse(bool checkForErrors)
{
var stream = new NetworkStream(_telnetSocket);
LastResponse = string.Empty;
LastResponseRaw = string.Empty;
const int bufferSize = 4096;
var buffer = new byte[bufferSize];
while (!stream.CanRead)
{
// TODO: need to work out a better way for this
System.Threading.Thread.Sleep(10);
}
var readData = String.Empty;
var EOR = string.Format("{0}{1}", PromptName, _promptSuffix);
const string emergency = "Host context unloading! Going back to creation context.";
do
{
var read = stream.Read(buffer, 0, bufferSize);
readData += Encoding.UTF7.GetString(buffer, 0, read);
Logger.LogDebug("readdata on {1}: {0}", readData, _prompt);
// Recover
if (readData.Contains(emergency))
{
readData = string.Empty;
SendCommand(";");
}
}while (!readData.EndsWith(EOR));
LastResponseRaw += readData;
AddToLastResponse(CleanTelnetResponse(readData));
// Convert \n to newline
if (LastResponse != null)
{
LastResponse = LastResponse.Replace("\n", Environment.NewLine);
}
Response.Append(LastResponse);
if (checkForErrors)
{
CheckForError(LastResponse);
}
}
public async Task <LastResponse> GetSessionTokenAsync(string username, string password)
{
var command = new GetMobileSessionCommand(this, username, password);
var response = await command.ExecuteAsync();
if (response.Success)
{
UserSession = response.Content;
return(LastResponse.CreateSuccessResponse());
}
else
{
return(LastResponse.CreateErrorResponse <LastResponse>(response.Error));
}
}
