partial void ExtractFailureContent(
string?content,
ref string?message,
ref string?errorCode,
#pragma warning disable CA1801 // We're not using it now - but see the TODO below
ref IDictionary <string, string>?additionalInfo)
#pragma warning restore CA1801
{
if (!string.IsNullOrEmpty(content))
{
try
{
// Try to parse the failure content and use that as the
// default value for the message, error code, etc.
using JsonDocument doc = JsonDocument.Parse(content);
if (doc.RootElement.TryGetProperty("error", out JsonElement errorElement))
{
SearchError error = SearchError.DeserializeSearchError(errorElement);
message ??= error?.Message;
errorCode ??= error?.Code;
// TODO: #10598 - Determine the correct approach for
// surfacing what appear to be nested SearchError
// instances.
Debug.Assert(!(error?.Details?.Count > 0));
}
}
catch (JsonException)
{
// Ignore any failures - unexpected content will be
// included verbatim in the detailed error message
}
}
}
public PSSearchError(SearchError error)
{
if (error != null)
{
this.Type = error.Type;
this.Message = error.Message;
}
}
public void can_create_a_bad_request_result_with_a_single_error()
{
var error = new SearchError();
var result = SearchResult <object> .WasBadRequest(error);
result
.Match(
ok: value => Assert.False(true),
badRequest: errors => Assert.True(errors.Contains(error))
);
}
public async void SearchInSystems(SpanshSearchSystems _search, Action <SpanshSystemsResult> _method, Action <SearchError> _onFailedMethod)
{
string _spanshJson = string.Empty;
SearchError error = SearchError.None;
try
{
_spanshJson = JsonConvert.SerializeObject(_search, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});;
NxLog.log(NxLog.Type.Debug, "SearchInSystems. json={0}", _spanshJson);
}
catch (Exception ex)
{
NexHudEngine.Log(NxLog.Type.Error, ex.Message);
_onFailedMethod?.Invoke(error = SearchError.SerializationFailed);
return;
}
Task <string> task = new Task <string>(() => requestPOSTFromURL(URL_SYSTEMS, _spanshJson, out error));
task.Start();
string json = await task;
if (error != SearchError.None)
{
_onFailedMethod?.Invoke(error);
}
else
{
// string json = requestPOSTFromURL(URL_BODIES, _spanshJson);
try
{
SpanshSystemsResult result = JsonConvert.DeserializeObject <SpanshSystemsResult>(json, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
NxLog.log(NxLog.Type.Debug, "Search Successful! Search ID = " + result.search_reference);
_method?.Invoke(result);
}
catch (Exception ex)
{
NexHudEngine.Log(NxLog.Type.Error, ex.Message);
NexHudEngine.Log(NxLog.Type.Error, ex.StackTrace);
_onFailedMethod?.Invoke(error = SearchError.DeserializationFailed);
}
}
}
public SearchViewModel(IStationSearchApi stationSearchApi)
{
_stationSearchApi = stationSearchApi ?? throw new ArgumentNullException(nameof(stationSearchApi));
SearchResults = new ObservableCollection <Station>();
Search = ReactiveCommand.CreateFromTask <string, List <Station> >(SearchAsync, CanSearch());
Search.ObserveOn(RxApp.MainThreadScheduler).Subscribe(LoadSearchResult);
Search.ThrownExceptions.Subscribe(async ex => await SearchError.Handle("An error occured."));
this.WhenAnyValue(x => x.SearchQuery)
.Throttle(TimeSpan.FromMilliseconds(300), TaskPoolScheduler.Default)
.Do(x => System.Diagnostics.Debug.WriteLine($"Throttle fired for {x}"))
.ObserveOn(RxApp.MainThreadScheduler)
.InvokeCommand(Search);
}
private string requestPOSTFromURL(string _url, string _json, out SearchError error)
{
if (m_lastRequest != null)
{
m_lastRequest.Abort();
}
m_lastRequest = (HttpWebRequest)WebRequest.Create(_url);
m_lastRequest.ContentType = "application/json";
m_lastRequest.Method = "POST";
using (var streamWriter = new StreamWriter(m_lastRequest.GetRequestStream()))
{
streamWriter.Write(_json);
}
try
{
var httpResponse = (HttpWebResponse)m_lastRequest.GetResponse();
m_lastRequest = null;
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
error = SearchError.None;
return(result);
}
}
catch (Exception ex)
{
error = SearchError.Unknow;
if (ex is WebException)
{
if (((WebException)ex).Status == WebExceptionStatus.RequestCanceled)
{
error = SearchError.Aborded;
NexHudEngine.Log(NxLog.Type.Warning, ex.Message);
}
}
else
{
NexHudEngine.Log(NxLog.Type.Error, ex.Message);
}
}
return(string.Empty);
}
public async Task<SearchResult> Search(SearchArea searchArea)
{
SearchError error = null;
List<CoffeeShop> coffeeShops = new List<CoffeeShop>();
int numFound;
int offset = 0;
do
{
numFound = 0;
SearchOptions query = new SearchOptions
{
GeneralOptions = new GeneralOptions
{
category_filter = "coffee",
offset = offset,
limit = 20,
sort = 1,
},
LocationOptions = new BoundOptions
{
sw_latitude = searchArea.SouthwestCorner.latitude,
sw_longitude = searchArea.SouthwestCorner.longitude,
ne_latitude = searchArea.NortheastCorner.latitude,
ne_longitude = searchArea.NortheastCorner.longitude,
},
};
Task<SearchResults> searchTask = this._yelp.Search(query);
SearchResults results = await searchTask;
if (results.error != null)
{
YelpSharp.Data.SearchError yelpError = results.error;
error = new SearchError
{
Id = ErrorId.YelpError,
Description = string.Format("ID: {0}; Description: {1}; Text: {2}; Field: {3}",
yelpError.id, yelpError.description, yelpError.text, yelpError.field),
};
}
else if (results.total >= MaxSearchResults)
{
error = new SearchError
{
Id = ErrorId.TooManyResults,
Description = string.Format("Maximum number of results exceeded, use a smaller region. Max Results: {0}", MaxSearchResults),
};
}
else
{
numFound = results.businesses.Count;
IEnumerable<CoffeeShop> newShops = results.businesses
.Where(b => b.location.city.IndexOf("seattle", StringComparison.OrdinalIgnoreCase) != -1)
.Select(b => new CoffeeShop
{
Name = b.name,
Location = new Coordinates
{
Latitude = b.location.coordinate.latitude,
Longitude = b.location.coordinate.longitude,
},
YelpId = b.id,
});
coffeeShops.AddRange(newShops);
offset += numFound;
}
} while (error == null && numFound > 0);
return new SearchResult
{
Error = error,
Results = coffeeShops,
};
}
