public ReportingSearchPage SearchAsync()
{
var res = req.GetJsonAsync <ReportingSearchPage>();
res.Wait();
return(res.Result);
}
private static async Task <List <T> > Load <T>(string parameter, double?lat = null, double?lon = null, CropType?crop = null)
{
IFlurlRequest request = $"{Constants.BemBaseUrl}?type={parameter}&tkn={Constants.BemToken}"
.WithBasicAuth(Constants.BemUsername, Constants.BemPassword);
if (lat != null)
{
request.SetQueryParam("lat", lat.Value.ToString(CultureInfo.InvariantCulture));
}
if (lon != null)
{
request.SetQueryParam("lon", lon.Value.ToString(CultureInfo.InvariantCulture));
}
if (crop != null && crop == CropType.Corn) //TODO: use crop types
{
request.SetQueryParam("cultivo", "Maiz");
}
List <T> data = null;
try
{
data = await request.GetJsonAsync <List <T> >();
}
catch (Exception)
{
}
return(data);
}
public static async Task <CiatData> LoadData(Position position, string crop)
{
string lat = position.Latitude.ToString().Replace(",", ".");
string lon = position.Longitude.ToString().Replace(",", ".");
IFlurlRequest request = Constants
.MatrizBaseUrl
.SetQueryParams(
new
{
lat = lat,
lon = lon,
type = "matriz",
tkn = Constants.BemToken,
cultivo = crop
})
.WithBasicAuth(Constants.BemUsername, Constants.BemPassword);
List <CiatResponseData> responseData;
try
{
responseData = await request.GetJsonAsync <List <CiatResponseData> >();
}
catch (Exception e)
{
return(null);
}
return(CiatData.FromResponse(responseData, request.Url));
}
/// <inheritdoc />
public async Task <TSource?> FindAsync(string docId, bool withConflicts = false,
CancellationToken cancellationToken = default)
{
try
{
IFlurlRequest request = NewRequest()
.AppendPathSegment(docId);
if (withConflicts)
{
request = request.SetQueryParam("conflicts", "true");
}
TSource document = await request
.GetJsonAsync <TSource>(cancellationToken)
.SendRequestAsync()
.ConfigureAwait(false);
InitAttachments(document);
return(document);
}
catch (CouchNotFoundException)
{
return(null);
}
}
public async Task <List <T> > GetAllAfterDateAsync <T>(string resourceUri, DateTime time, int?previousId = null)
{
IFlurlRequest request = _baseApiUrl.AppendPathSegment(resourceUri).WithHeader("X-API-Key", "dummy-secret").SetQueryParam("after", time);
if (previousId.HasValue)
{
request.SetQueryParam("previousId", previousId.Value);
}
return(await request.GetJsonAsync <List <T> >());
}
public async static Task <T> GetJsonWithDefaultAsync <T>(this IFlurlRequest request, System.Net.HttpStatusCode httpStatusCode)
{
try
{
return(await request.GetJsonAsync <T>());
}
catch (FlurlHttpException ex)
{
if (ex.Call.HttpStatus == httpStatusCode)
{
return(default);
public async Task <T> GetAsync <T>(string resourceUri, params string[] query)
{
IFlurlRequest request = _baseApiUrl.AppendPathSegment(resourceUri).WithHeader("X-API-Key", "dummy-secret");
foreach (string param in query)
{
request = request.SetQueryParam(param);
}
//Console.WriteLine(request);
return(await request.GetJsonAsync <T>());
}
async Task <VstsAgent> GetAgentAsync(int poolId, int agentId)
{
string requestPath = string.Format(AgentPathSegmentFormat, DevOpsAccessSetting.AzureOrganization, poolId, agentId);
IFlurlRequest agentRequest = DevOpsAccessSetting.BaseUrl
.AppendPathSegment(requestPath)
.SetQueryParam("api-version", "5.1")
.SetQueryParam("includeCapabilities", "true")
.WithBasicAuth(string.Empty, this.accessSetting.MsazurePAT);
return(await agentRequest.GetJsonAsync <VstsAgent>().ConfigureAwait(false));
}
public async Task <T> Get <T>(object filters = null)
{
IFlurlRequest request = getPath();
if (filters != null)
{
request.SetQueryParams(filters);
}
return(await request.GetJsonAsync <T>());
}
public async Task <List <T> > GetAllAsync <T>(string resourceUri, params string[] query)
{
IFlurlRequest request = _baseApiUrl.AppendPathSegment(resourceUri).WithHeader("X-API-Key", "dummy-secret");
List <T> response = new List <T>();
foreach (string param in query)
{
request = request.SetQueryParam(param);
}
return(await request.GetJsonAsync <List <T> >());
}
public async Task <IEnumerable <PostView> > GetAll(object filters = null)
{
IFlurlRequest request = $"{baseUrl}/{Path}/latest".WithOAuthBearerToken(Token);
;
if (filters != null)
{
request.SetQueryParams(filters);
}
return(await request.GetJsonAsync <IEnumerable <PostView> >());
}
public async Task <List <T> > GetAllBetweenDatesAsync <T>(string resourceUri, DateTime from, DateTime to, int?previousId = null, bool isDone = false)
{
IFlurlRequest request = _baseApiUrl.AppendPathSegment(resourceUri).WithHeader("X-API-Key", "dummy-secret").SetQueryParam("after", from).SetQueryParam("before", to);
if (previousId.HasValue)
{
request.SetQueryParam("previousId", previousId.Value);
}
if (isDone)
{
request.SetQueryParam("isDone", isDone);
}
return(await request.GetJsonAsync <List <T> >());
}
public IEnumerable <AuditLogEntry> Enumerate(IFlurlRequest request)
{
var more = true;
while (more)
{
var result = request.GetJsonAsync <AuditLogEntries>().ConfigureAwait(false).GetAwaiter().GetResult();
foreach (var entry in result.DecoratedAuditLogEntries)
{
yield return(entry);
}
request.SetQueryParam("continuationToken", result.ContinuationToken);
more = result.ContinuationToken != null;
}
}
/// <inheritdoc/>
public Task <CouchViewList <TKey, TValue, TSource> > GetDetailedViewAsync <TKey, TValue>(string design, string view,
CouchViewOptions <TKey>?options = null, CancellationToken cancellationToken = default)
{
Check.NotNull(design, nameof(design));
Check.NotNull(view, nameof(view));
IFlurlRequest request = NewRequest()
.AppendPathSegments("_design", design, "_view", view);
Task <CouchViewList <TKey, TValue, TSource> >?requestTask = options == null
? request.GetJsonAsync <CouchViewList <TKey, TValue, TSource> >(cancellationToken)
: request
.PostJsonAsync(options, cancellationToken)
.ReceiveJson <CouchViewList <TKey, TValue, TSource> >();
return(requestTask.SendRequestAsync());
}
/// <summary>
/// Returns a sorted list of changes made to documents in the database.
/// </summary>
/// <remarks>
/// Only the most recent change for a given document is guaranteed to be provided.
/// </remarks>
/// <param name="options">Options to apply to the request.</param>
/// <param name="filter">A filter to apply to the result.</param>
/// <returns></returns>
public async Task <ChangesFeedResponse <TSource> > GetChangesAsync(ChangesFeedOptions options = null, ChangesFeedFilter filter = null)
{
IFlurlRequest request = NewRequest()
.AppendPathSegment("_changes");
if (options?.LongPoll == true)
{
_ = request.SetQueryParam("feed", "longpoll");
}
SetChangesFeedOptions(request, options);
return(filter == null
? await request.GetJsonAsync <ChangesFeedResponse <TSource> >()
.ConfigureAwait(false)
: await QueryWithFilterAsync(request, filter)
.ConfigureAwait(false));
}
public IEnumerable <TResponse> Enumerate(IFlurlRequest request)
{
request.SetQueryParam("top", Top);
var skip = 0;
var more = true;
while (more)
{
var result = request.GetJsonAsync <Entitlements <TResponse> >().ConfigureAwait(false).GetAwaiter().GetResult();
foreach (var item in result.Items)
{
yield return(item);
}
skip += Top;
request.SetQueryParam("skip", skip);
more = result.Items.Any();
}
}
public async Task <IList <VstsAgent> > GetAgentsAsync(int poolId)
{
string requestPath = string.Format(AgentListPathSegmentFormat, DevOpsAccessSetting.AzureOrganization, poolId);
IFlurlRequest agentListRequest = DevOpsAccessSetting.BaseUrl
.AppendPathSegment(requestPath)
.SetQueryParam("api-version", "5.1")
.WithBasicAuth(string.Empty, this.accessSetting.MsazurePAT);
VstsAgentList agentList = await agentListRequest.GetJsonAsync <VstsAgentList>().ConfigureAwait(false);
// Get capabilities for each agent
var agentsWithCapabilities = new List <VstsAgent>();
foreach (int agentId in agentList.Value.Select(a => a.Id))
{
agentsWithCapabilities.Add(await this.GetAgentAsync(poolId, agentId).ConfigureAwait(false));
}
return(agentsWithCapabilities);
}
/// <inheritdoc />
public async Task <ChangesFeedResponse <TSource> > GetChangesAsync(ChangesFeedOptions?options = null, ChangesFeedFilter?filter = null, CancellationToken cancellationToken = default)
{
IFlurlRequest request = NewRequest()
.AppendPathSegment("_changes");
if (options?.LongPoll == true)
{
_ = request.SetQueryParam("feed", "longpoll");
}
if (options != null)
{
request = request.ApplyQueryParametersOptions(options);
}
return(filter == null
? await request.GetJsonAsync <ChangesFeedResponse <TSource> >(cancellationToken)
.ConfigureAwait(false)
: await request.QueryWithFilterAsync <TSource>(_queryProvider, filter, cancellationToken)
.ConfigureAwait(false));
}
/// <summary>
/// Finds the document with the given ID. If no document is found, then null is returned.
/// </summary>
/// <param name="docId">The document ID.</param>
/// <param name="withConflicts">Set if conflicts array should be included.</param>
/// <returns>A task that represents the asynchronous operation. The task result contains the element found, or null.</returns>
public async Task <TSource> FindAsync(string docId, bool withConflicts = false)
{
try
{
IFlurlRequest request = NewRequest()
.AppendPathSegment(docId);
if (withConflicts)
{
request = request.SetQueryParam("conflicts", true);
}
return(await request
.GetJsonAsync <TSource>()
.SendRequestAsync()
.ConfigureAwait(false));
}
catch (CouchNotFoundException)
{
return(null);
}
}
public static async Task <JObject> GetJObjectAsync(this IFlurlRequest request, CancellationToken cancellationToken = default, HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
{
var json = await request.GetJsonAsync(cancellationToken, completionOption).ConfigureAwait(false);
return(JObject.FromObject(json));
}
private static async Task <TOut> SendAsync <TOut>(IFlurlRequest flurlRequest, WebRequestContext requestContext)
{
TOut result = default;
try
{
requestContext.AttemptCnt++;
if (requestContext.MethodType == WebMethodType.GET)
{
if (requestContext.SerializeType == SerializeType.Json)
{
result = await flurlRequest.GetJsonAsync <TOut>();
}
else
{
var rawData = await flurlRequest.GetBytesAsync();
result = MessagePackSerializer.Deserialize <TOut>(rawData);
}
}
else if (requestContext.MethodType == WebMethodType.POST)
{
if (requestContext.SerializeType == SerializeType.Json)
{
result = await flurlRequest
.PostJsonAsync((string)requestContext)
.ReceiveJson <TOut>();
}
else
{
var rawData = await flurlRequest
.PostAsync(new ByteArrayContent(requestContext))
.ReceiveBytes();
result = MessagePackSerializer.Deserialize <TOut>(rawData);
}
}
}
catch (FlurlHttpException flurlException)
{
if (requestContext.AttemptCnt < WebConfig.ReTryCount)
{
result = await RequestRetryPolicy <TOut>(flurlException, flurlRequest, requestContext);
}
else
{
if (_exceptionHandler != null)
{
await _exceptionHandler.Invoke(flurlException);
}
}
}
catch (Exception ex)
{
if (_exceptionHandler != null)
{
await _exceptionHandler.Invoke(ex);
}
}
return(result);
}
public IAsyncEnumerable <object> Enumerator(IFlurlRequest request) => request.GetJsonAsync <object>().ToAsyncEnumerable();
internal static async Task <JObject> GetJObjectAsync(this IFlurlRequest request)
{
var json = await request.GetJsonAsync().ConfigureAwait(false);
return(json is null ? null : JObject.FromObject(json));
}
public static Task <T> GetAsync <T>(this IFlurlRequest request, CancellationToken cancellation) => request.GetJsonAsync <T>(cancellation);
