private static async Task<DocumentCollection> CreateDocumentCollection(DocumentClient client, Database database, string collectionId)
{
var collectionSpec = new DocumentCollection { Id = collectionId };
var requestOptions = new RequestOptions { OfferType = "S1" };
return await client.CreateDocumentCollectionAsync(database.SelfLink, collectionSpec, requestOptions);
}
public Task<object> GetAsync(string uri, Type type, RequestOptions requestOptions)
{
if (requestOptions != null)
requestOptions.ResourceLoader = this;
return this.loader.GetAsync(uri, type, requestOptions);
}
public void ClaimCreationWithClaimParamsObjectTest()
{
ClaimParams input = JsonConvert.DeserializeObject<ClaimParams>(ClaimInput);
RequestOptions options = new RequestOptions();
options.IsTest = true;
ClaimResponse actualResponse = claim.Create(input, options);
ClaimSuccessCheck(actualResponse.JsonResponse());
}
private void AssertRequestOptionCall(Action<IRequestOptions> options,
Action<HttpRequestMessage> assertions,
string uri = "http://whatever")
{
var requestMessage = new HttpRequestMessage(HttpMethod.Get, uri);
var requestOptions = new RequestOptions();
options(requestOptions);
requestOptions.ApplyRequestModifications(requestMessage);
assertions(requestMessage);
}
/// <summary>
/// Issues the web request asynchronous.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="method">The method.</param>
/// <param name="input">The input.</param>
/// <param name="options">request options</param>
/// <returns></returns>
public async Task<Response> IssueWebRequestAsync(
string endpoint, string query, string method, Stream input, RequestOptions options)
{
options.Validate();
Stopwatch watch = Stopwatch.StartNew();
UriBuilder builder = new UriBuilder(
_credentials.ClusterUri.Scheme,
_credentials.ClusterUri.Host,
options.Port,
options.AlternativeEndpoint + endpoint);
if (query != null)
{
builder.Query = query;
}
Debug.WriteLine("Issuing request {0} to endpoint {1}", Trace.CorrelationManager.ActivityId, builder.Uri);
HttpWebRequest httpWebRequest = WebRequest.CreateHttp(builder.Uri);
httpWebRequest.ServicePoint.ReceiveBufferSize = options.ReceiveBufferSize;
httpWebRequest.ServicePoint.UseNagleAlgorithm = options.UseNagle;
httpWebRequest.Timeout = options.TimeoutMillis;
httpWebRequest.KeepAlive = options.KeepAlive;
httpWebRequest.Credentials = _credentialCache;
httpWebRequest.PreAuthenticate = true;
httpWebRequest.Method = method;
httpWebRequest.Accept = _contentType;
httpWebRequest.ContentType = _contentType;
// This allows 304 (NotModified) requests to catch
//https://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.allowautoredirect(v=vs.110).aspx
httpWebRequest.AllowAutoRedirect = false;
if (options.AdditionalHeaders != null)
{
foreach (var kv in options.AdditionalHeaders)
{
httpWebRequest.Headers.Add(kv.Key, kv.Value);
}
}
if (input != null)
{
// expecting the caller to seek to the beginning or to the location where it needs to be copied from
using (Stream req = await httpWebRequest.GetRequestStreamAsync())
{
await input.CopyToAsync(req);
}
}
var response = (await httpWebRequest.GetResponseAsync()) as HttpWebResponse;
return new Response()
{
WebResponse = response,
RequestLatency = watch.Elapsed
};
}
public void ClaimCreationWithRequestOptionsTest()
{
RequestOptions options = new RequestOptions();
options.IsTest = true;
options.ApiKey = null;
Hashtable input = JsonConvert.DeserializeObject<Hashtable>(ClaimInput);
ClaimResponse actualResponse = claim.Create(input, options);
ClaimSuccessCheck(actualResponse.JsonResponse());
}
private static async Task ReadOrCreateCollection(string databaseLink)
{
Collection = Client.CreateDocumentCollectionQuery(databaseLink).Where(col => col.Id == _collectionId).AsEnumerable().FirstOrDefault();
if (Collection == null)
{
var collectionSpec = new DocumentCollection {Id = _collectionId};
var requestOptions = new RequestOptions {OfferType = "S1"};
Collection = await Client.CreateDocumentCollectionAsync(databaseLink, collectionSpec, requestOptions);
}
}
/// <summary>
/// Issues the web request asynchronous.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="method">The method.</param>
/// <param name="query">The query.</param>
/// <param name="input">The input.</param>
/// <param name="options">request options</param>
/// <returns></returns>
public async Task<Response> IssueWebRequestAsync(
string endpoint, string method, string query, Stream input, RequestOptions options)
{
options.Validate();
Stopwatch watch = Stopwatch.StartNew();
UriBuilder builder = new UriBuilder(
_credentials.ClusterUri.Scheme,
_credentials.ClusterUri.Host,
options.Port,
options.AlternativeEndpoint + endpoint);
if (query != null)
{
builder.Query = query;
}
Debug.WriteLine("Issuing request {0} to endpoint {1}", Trace.CorrelationManager.ActivityId, builder.Uri);
HttpWebRequest httpWebRequest = WebRequest.CreateHttp(builder.Uri);
httpWebRequest.ServicePoint.ReceiveBufferSize = options.ReceiveBufferSize;
httpWebRequest.ServicePoint.UseNagleAlgorithm = options.UseNagle;
httpWebRequest.Timeout = options.TimeoutMillis;
httpWebRequest.KeepAlive = options.KeepAlive;
httpWebRequest.Credentials = _credentialCache;
httpWebRequest.PreAuthenticate = true;
httpWebRequest.Method = method;
httpWebRequest.Accept = _contentType;
httpWebRequest.ContentType = _contentType;
if (options.AdditionalHeaders != null)
{
foreach (var kv in options.AdditionalHeaders)
{
httpWebRequest.Headers.Add(kv.Key, kv.Value);
}
}
if (input != null)
{
// seek to the beginning, so we copy everything in this buffer
input.Seek(0, SeekOrigin.Begin);
using (Stream req = httpWebRequest.GetRequestStream())
{
await input.CopyToAsync(req);
}
}
var response = (await httpWebRequest.GetResponseAsync()) as HttpWebResponse;
return new Response()
{
WebResponse = response,
RequestLatency = watch.Elapsed
};
}
public ApiRequest(RequestOptions options)
{
// BasicConfigurator.Configure();
requestOptions = options;
client = new RestClient(requestOptions.Url);
request = new RestRequest();
request.AddHeader("Content-Type", "application/json");
request.AddHeader("X-Key", requestOptions.ApiKey);
request.AddHeader("X-Password", requestOptions.Password);
request.AddHeader("X-Dat-Channel", "link-dotnet");
request.RequestFormat = DataFormat.Json;
}
private static async Task<HttpResponseMessage> UrlRequest(string request, HttpMethod httpMethod, Dictionary<string, string> data = null, Dictionary<string, string> cookies = null, string referer = null, RequestOptions requestOptions = RequestOptions.None) {
if (string.IsNullOrEmpty(request) || httpMethod == null) {
return null;
}
HttpResponseMessage responseMessage;
using (HttpRequestMessage requestMessage = new HttpRequestMessage(httpMethod, request)) {
if (data != null) {
try {
requestMessage.Content = new FormUrlEncodedContent(data);
} catch (UriFormatException e) {
Logging.LogGenericException(e);
return null;
}
}
if (cookies != null && cookies.Count > 0) {
StringBuilder cookieHeader = new StringBuilder();
foreach (KeyValuePair<string, string> cookie in cookies) {
cookieHeader.Append(cookie.Key + "=" + cookie.Value + ";");
}
requestMessage.Headers.Add("Cookie", cookieHeader.ToString());
}
if (referer != null) {
requestMessage.Headers.Referrer = new Uri(referer);
}
if (requestOptions.HasFlag(RequestOptions.FakeUserAgent)) {
requestMessage.Headers.UserAgent.ParseAdd(FakeUserAgent);
}
if (requestOptions.HasFlag(RequestOptions.XMLHttpRequest)) {
requestMessage.Headers.Add("X-Requested-With", "XMLHttpRequest");
}
try {
responseMessage = await HttpClient.SendAsync(requestMessage).ConfigureAwait(false);
} catch { // Request failed, we don't need to know the exact reason, swallow exception
return null;
}
}
if (responseMessage == null || !responseMessage.IsSuccessStatusCode) {
return null;
}
return responseMessage;
}
/// <summary>
/// List all Organization Quota Definitions
/// <para>For detailed information, see online documentation at: "http://apidocs.cloudfoundry.org/195/organization_quota_definitions/list_all_organization_quota_definitions.html"</para>
/// </summary>
public async Task<PagedResponseCollection<ListAllOrganizationQuotaDefinitionsResponse>> ListAllOrganizationQuotaDefinitions(RequestOptions options)
{
UriBuilder uriBuilder = new UriBuilder(this.Client.CloudTarget);
uriBuilder.Path = "/v2/quota_definitions";
uriBuilder.Query = options.ToString();
var client = this.GetHttpClient();
client.Uri = uriBuilder.Uri;
client.Method = HttpMethod.Get;
var authHeader = await BuildAuthenticationHeader();
if (!string.IsNullOrWhiteSpace(authHeader.Key))
{
client.Headers.Add(authHeader);
}
var expectedReturnStatus = 200;
var response = await this.SendAsync(client, expectedReturnStatus);
return Utilities.DeserializePage<ListAllOrganizationQuotaDefinitionsResponse>(await response.ReadContentAsStringAsync(), this.Client);
}
protected async void ButtonSend_Click(object sender, EventArgs e)
{
RequestOptions requestOptions = null;
//Request response in JSON format
requestOptions = new RequestOptions();
requestOptions.Headers.Add("Accept", "application/json");
//Send Request
var response = await Global.HelloServiceClient.GetAsync(Uri + TextBoxName.Text, requestOptions);
//Display result
PanelResponse.Visible = true;
LabelResponse.Text = response.Content.ReadAsStringAsync().Result;
}
/// <summary>
/// List all Spaces for the Domain (deprecated)
/// <para>For detailed information, see online documentation at: "http://apidocs.cloudfoundry.org/195/domains__deprecated_/list_all_spaces_for_the_domain_(deprecated).html"</para>
/// </summary>
public async Task<PagedResponseCollection<ListAllSpacesForDomainDeprecatedResponse>> ListAllSpacesForDomainDeprecated(Guid? guid, RequestOptions options)
{
UriBuilder uriBuilder = new UriBuilder(this.Client.CloudTarget);
uriBuilder.Path = string.Format(CultureInfo.InvariantCulture, "/v2/domains/{0}/spaces", guid);
uriBuilder.Query = options.ToString();
var client = this.GetHttpClient();
client.Uri = uriBuilder.Uri;
client.Method = HttpMethod.Get;
var authHeader = await BuildAuthenticationHeader();
if (!string.IsNullOrWhiteSpace(authHeader.Key))
{
client.Headers.Add(authHeader);
}
var expectedReturnStatus = 200;
var response = await this.SendAsync(client, expectedReturnStatus);
return Utilities.DeserializePage<ListAllSpacesForDomainDeprecatedResponse>(await response.ReadContentAsStringAsync(), this.Client);
}
public static Response Get(string uri, RequestOptions options = null)
{
try
{
using (var client = new HttpClient())
{
var result = client.GetAsync(new Uri(uri)).Result;
return new Response
{
Content = result.Content,
StatusCode = result.StatusCode
};
}
} catch(Exception exception) {
throw exception;
}
}
/// <summary>
/// This request is used as a short-hand for create a Statement and fetching the first batch
/// of results in a single call without any parameter substitution.
/// </summary>
public async Task<ExecuteResponse> PrepareAndExecuteRequestAsync(string connectionId, string sql, uint statementId, long maxRowsTotal, int firstFrameMaxSize, RequestOptions options)
{
PrepareAndExecuteRequest req = new PrepareAndExecuteRequest
{
Sql = sql,
ConnectionId = connectionId,
StatementId = statementId,
MaxRowsTotal = maxRowsTotal,
FirstFrameMaxSize = firstFrameMaxSize
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "PrepareAndExecuteRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"PrepareAndExecuteRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteResponse res = ExecuteResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <inheritdoc /> async Task <IReadOnlyCollection <IGuildIntegration> > IGuild.GetIntegrationsAsync(RequestOptions options) => await GetIntegrationsAsync(options).ConfigureAwait(false);
private async static Task<System.Net.Http.HttpResponseMessage> SendMessage(RestBusClient client, RequestOptions requestOptions)
{
//Send Request
var uri = "api/values"; //Substitute "hello/random" for the ServiceStack example
return await client.GetAsync(uri, requestOptions);
}
/// <inheritdoc />
async Task <IReadOnlyCollection <IVoiceChannel> > IGuild.GetVoiceChannelsAsync(CacheMode mode, RequestOptions options)
{
if (mode == CacheMode.AllowDownload)
{
return(await GetVoiceChannelsAsync(options).ConfigureAwait(false));
}
else
{
return(ImmutableArray.Create <IVoiceChannel>());
}
}
/// <inheritdoc /> async Task <IInviteMetadata> IGuild.GetVanityInviteAsync(RequestOptions options) => await GetVanityInviteAsync(options).ConfigureAwait(false);
public Task <RestGuildUser> GetGuildUserAsync(ulong guildId, ulong id, RequestOptions options = null) => ClientHelper.GetGuildUserAsync(this, guildId, id, options);
public Task <RestVoiceRegion> GetVoiceRegionAsync(string id, RequestOptions options = null) => ClientHelper.GetVoiceRegionAsync(this, id, options);
public static Task DeleteUnknownApplicationCommandAsync(BaseDiscordClient client, ulong? guildId, IApplicationCommand command, RequestOptions options = null)
{
return guildId.HasValue
? DeleteGuildCommandAsync(client, guildId.Value, command, options)
: DeleteGlobalCommandAsync(client, command, options);
}
//Use the DocumentCollection if it exists, if not create a new Collection
private static DocumentCollection ReadOrCreateCollection(string databaseLink)
{
var col = Client.CreateDocumentCollectionQuery(databaseLink)
.Where(c => c.Id == CollectionId)
.AsEnumerable()
.FirstOrDefault();
if (col == null)
{
var collectionSpec = new DocumentCollection { Id = CollectionId };
var requestOptions = new RequestOptions { OfferType = "S1" };
col = Client.CreateDocumentCollectionAsync(databaseLink, collectionSpec, requestOptions).Result;
}
return col;
}
public static Task DeleteAllGlobalCommandsAsync(BaseDiscordClient client, RequestOptions options = null)
{
return client.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(Array.Empty<CreateApplicationCommandParams>(), options);
}
public static async Task DeleteGuildCommandAsync(BaseDiscordClient client, ulong guildId, IApplicationCommand command, RequestOptions options = null)
{
Preconditions.NotNull(command, nameof(command));
Preconditions.NotEqual(command.Id, 0, nameof(command.Id));
await client.ApiClient.DeleteGuildApplicationCommandAsync(guildId, command.Id, options).ConfigureAwait(false);
}
public static Task DeleteAllGuildCommandsAsync(BaseDiscordClient client, ulong guildId, RequestOptions options = null)
{
return client.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(guildId, Array.Empty<CreateApplicationCommandParams>(), options);
}
/// <inheritdoc /> async Task <IGuildUser> IGuild.AddGuildUserAsync(ulong userId, string accessToken, Action <AddGuildUserProperties> func, RequestOptions options) => await AddGuildUserAsync(userId, accessToken, func, options);
/// <inheritdoc /> async Task <IRole> IGuild.CreateRoleAsync(string name, GuildPermissions?permissions, Color?color, bool isHoisted, RequestOptions options) => await CreateRoleAsync(name, permissions, color, isHoisted, options).ConfigureAwait(false);
/// <summary>
/// Issues the web request asynchronous.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="method">The method.</param>
/// <param name="input">The input.</param>
/// <param name="options">request options</param>
/// <returns></returns>
public async Task<Response> IssueWebRequestAsync(string endpoint, string query, string method, Stream input, RequestOptions options)
{
options.Validate();
Stopwatch watch = Stopwatch.StartNew();
Trace.CorrelationManager.ActivityId = Guid.NewGuid();
var balancedEndpoint = _balancer.GetEndpoint();
// Grab the host. Use the alternative host if one is specified
string host = (options.AlternativeHost != null) ? options.AlternativeHost : balancedEndpoint.Host;
UriBuilder builder = new UriBuilder(
balancedEndpoint.Scheme,
host,
options.Port,
options.AlternativeEndpoint + endpoint);
if (query != null)
{
builder.Query = query;
}
var target = builder.Uri;
try
{
Debug.WriteLine("Issuing request {0} to endpoint {1}", Trace.CorrelationManager.ActivityId, target);
HttpWebRequest httpWebRequest = WebRequest.CreateHttp(target);
httpWebRequest.ServicePoint.ReceiveBufferSize = options.ReceiveBufferSize;
httpWebRequest.ServicePoint.UseNagleAlgorithm = options.UseNagle;
httpWebRequest.Timeout = options.TimeoutMillis; // This has no influence for calls that are made Async
httpWebRequest.KeepAlive = options.KeepAlive;
httpWebRequest.Credentials = _credentialCache;
httpWebRequest.PreAuthenticate = true;
httpWebRequest.Method = method;
httpWebRequest.Accept = _contentType;
httpWebRequest.ContentType = _contentType;
// This allows 304 (NotModified) requests to catch
//https://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.allowautoredirect(v=vs.110).aspx
httpWebRequest.AllowAutoRedirect = false;
if (options.AdditionalHeaders != null)
{
foreach (var kv in options.AdditionalHeaders)
{
httpWebRequest.Headers.Add(kv.Key, kv.Value);
}
}
long remainingTime = options.TimeoutMillis;
if (input != null)
{
// expecting the caller to seek to the beginning or to the location where it needs to be copied from
Stream req = null;
try
{
req = await httpWebRequest.GetRequestStreamAsync().WithTimeout(
TimeSpan.FromMilliseconds(remainingTime),
"Waiting for RequestStream");
remainingTime = options.TimeoutMillis - watch.ElapsedMilliseconds;
if (remainingTime <= 0)
{
remainingTime = 0;
}
await input.CopyToAsync(req).WithTimeout(
TimeSpan.FromMilliseconds(remainingTime),
"Waiting for CopyToAsync",
CancellationToken.None);
}
catch (TimeoutException)
{
httpWebRequest.Abort();
throw;
}
finally
{
req?.Close();
}
}
try
{
remainingTime = options.TimeoutMillis - watch.ElapsedMilliseconds;
if (remainingTime <= 0)
{
remainingTime = 0;
}
Debug.WriteLine("Waiting for response for request {0} to endpoint {1}", Trace.CorrelationManager.ActivityId, target);
HttpWebResponse response = (HttpWebResponse)await httpWebRequest.GetResponseAsync().WithTimeout(
TimeSpan.FromMilliseconds(remainingTime),
"Waiting for GetResponseAsync");
Debug.WriteLine("Web request {0} to endpoint {1} successful!", Trace.CorrelationManager.ActivityId, target);
return new Response()
{
WebResponse = response,
RequestLatency = watch.Elapsed,
PostRequestAction = (r) =>
{
if (r.WebResponse.StatusCode == HttpStatusCode.OK || r.WebResponse.StatusCode == HttpStatusCode.Created || r.WebResponse.StatusCode == HttpStatusCode.NotModified)
{
_balancer.RecordSuccess(balancedEndpoint);
}
else
{
_balancer.RecordFailure(balancedEndpoint);
}
}
};
}
catch (TimeoutException)
{
httpWebRequest.Abort();
throw;
}
}
catch(WebException we)
{
// 404 is valid response
var resp = we.Response as HttpWebResponse;
if(resp.StatusCode == HttpStatusCode.NotFound)
{
_balancer.RecordSuccess(balancedEndpoint);
Debug.WriteLine("Web request {0} to endpoint {1} successful!", Trace.CorrelationManager.ActivityId, target);
}
else
{
_balancer.RecordFailure(balancedEndpoint);
Debug.WriteLine("Web request {0} to endpoint {1} failed!", Trace.CorrelationManager.ActivityId, target);
}
throw we;
}
catch (Exception e)
{
_balancer.RecordFailure(balancedEndpoint);
Debug.WriteLine("Web request {0} to endpoint {1} failed!", Trace.CorrelationManager.ActivityId, target);
throw e;
}
}
public static async Task SendInteractionResponseAsync(BaseDiscordClient client, UploadInteractionFileParams response,
IDiscordInteraction interaction, IMessageChannel channel = null, RequestOptions options = null)
{
await client.ApiClient.CreateInteractionResponseAsync(response, interaction.Id, interaction.Token, options).ConfigureAwait(false);
}
/// <summary>
/// Create a post trigger that updates metadata: for each inserted doc it will look at doc.size
/// and update aggregate properties: { minSize, maxSize, totalSize } in the metadata doc.
/// In the end print to show the aggregate values of min, max, total for all docs.
/// </summary>
private static async Task RunPostTrigger(string colSelfLink)
{
Random rnd = new Random();
// 1. Create a trigger.
string triggerPath = @"js\UpdateMetadata.js";
string triggerId = Path.GetFileNameWithoutExtension(triggerPath);
string triggerBody = File.ReadAllText(triggerPath);
Trigger trigger = new Trigger
{
Id = Path.GetFileName(triggerId),
Body = triggerBody,
TriggerOperation = TriggerOperation.Create,
TriggerType = TriggerType.Post
};
await TryDeleteStoredProcedure(colSelfLink, trigger.Id);
await client.CreateTriggerAsync(colSelfLink, trigger);
// 2. Create the metadata document.
var metaDoc = new
{
id = "meta",
isMetadata = true,
minSize = 0,
maxSize = 0,
totalSize = 0
};
await client.CreateDocumentAsync(colSelfLink, metaDoc);
// 3. Import a number of docs with trigger. Use client API this time, we already have sample fot using script.
var requestOptions = new RequestOptions { PostTriggerInclude = new List<string> { triggerId } };
await client.CreateDocumentAsync(colSelfLink, new
{
size = rnd.Next(1000),
}, requestOptions);
await client.CreateDocumentAsync(colSelfLink, new
{
size = rnd.Next(1000),
}, requestOptions);
await client.CreateDocumentAsync(colSelfLink, new
{
size = rnd.Next(1000),
}, requestOptions);
await client.CreateDocumentAsync(colSelfLink, new
{
size = rnd.Next(1000),
}, requestOptions);
await client.CreateDocumentAsync(colSelfLink, new
{
size = rnd.Next(1000),
}, requestOptions);
// 4. Print aggregate info from the metadata document.
metaDoc = client.CreateDocumentQuery<dynamic>(colSelfLink, "SELECT * FROM root r WHERE r.isMetadata = true").AsEnumerable().First();
Console.WriteLine("Document statistics: min size: {0}, max size: {1}, total size: {2}", metaDoc.minSize, metaDoc.maxSize, metaDoc.totalSize);
}
public static async Task DeleteInteractionResponseAsync(BaseDiscordClient client, RestInteractionMessage message, RequestOptions options = null)
=> await client.ApiClient.DeleteInteractionFollowupMessageAsync(message.Id, message.Token, options);
/// <inheritdoc />
async Task <IVoiceChannel> IGuild.GetVoiceChannelAsync(ulong id, CacheMode mode, RequestOptions options)
{
if (mode == CacheMode.AllowDownload)
{
return(await GetVoiceChannelAsync(id, options).ConfigureAwait(false));
}
else
{
return(null);
}
}
public static async Task DeleteInteractionResponseAsync(BaseDiscordClient client, IDiscordInteraction interaction, RequestOptions options = null)
=> await client.ApiClient.DeleteInteractionFollowupMessageAsync(interaction.Id, interaction.Token, options);
public Task <IReadOnlyCollection <RestVoiceRegion> > GetVoiceRegionsAsync(RequestOptions options = null) => ClientHelper.GetVoiceRegionsAsync(this, options);
/// <inheritdoc /> async Task <ICategoryChannel> IGuild.CreateCategoryAsync(string name, Action <GuildChannelProperties> func, RequestOptions options) => await CreateCategoryChannelAsync(name, func, options).ConfigureAwait(false);
public Task <RestWebhook> GetWebhookAsync(ulong id, RequestOptions options = null) => ClientHelper.GetWebhookAsync(this, id, options);
/// <inheritdoc /> async Task <IGuildIntegration> IGuild.CreateIntegrationAsync(ulong id, string type, RequestOptions options) => await CreateIntegrationAsync(id, type, options).ConfigureAwait(false);
private async Task<object> SendRequestInnerAsync(string uri,
string httpMethod,
object body,
ISerializationContextProvider provider,
RequestOptions options)
{
if (provider == null)
throw new ArgumentNullException(nameof(provider));
if (uri == null)
throw new ArgumentNullException(nameof(uri));
if (httpMethod == null)
throw new ArgumentNullException(nameof(httpMethod));
if (options == null)
options = new RequestOptions();
if (body is IExtendedResourceProxy)
throw new ArgumentException("SendRequestInner should never get a body of type IExtendedResourceProxy");
var response = await SendHttpRequestAsync(provider, uri, httpMethod, body, null, options);
return response != null ? Deserialize(response, options.ExpectedResponseType, provider) : null;
}
/// <inheritdoc /> async Task <IReadOnlyCollection <IInviteMetadata> > IGuild.GetInvitesAsync(RequestOptions options) => await GetInvitesAsync(options).ConfigureAwait(false);
public async Task<object> SendRequestAsync(string uri,
string httpMethod,
object body,
ISerializationContextProvider provider,
RequestOptions options = null)
{
if (provider == null)
throw new ArgumentNullException(nameof(provider));
if (uri == null)
throw new ArgumentNullException(nameof(uri));
if (httpMethod == null)
throw new ArgumentNullException(nameof(httpMethod));
if (options == null)
options = new RequestOptions();
var innerBody = body;
var proxyBody = body as IExtendedResourceProxy;
if (proxyBody != null)
innerBody = proxyBody.WrappedResource;
// Figure out server side response type
ExtendedResourceInfo responseExtendedTypeInfo;
var responseType = options.ExpectedResponseType;
var innerOptions = options;
var innerResponseType = options.ExpectedResponseType;
if (innerResponseType != null)
{
if (this.typeMapper.TryGetExtendedTypeInfo(innerResponseType, out responseExtendedTypeInfo))
{
innerResponseType = responseExtendedTypeInfo.ServerType;
innerOptions = new RequestOptions(options) { ExpectedResponseType = innerResponseType };
}
}
var innerResult = await SendRequestInnerAsync(uri, httpMethod, innerBody, provider, innerOptions);
if (innerResponseType == null && proxyBody != null && innerResult != null)
{
// Special case: No response type specified, but response has same type as posted body,
// and the posted body was of an extended type. In this case we will wrap the response
// to the same type if possible.
var proxyBodyInfo = proxyBody.UserTypeInfo;
if (proxyBodyInfo.ServerType.IsInstanceOfType(innerResult))
{
responseType = proxyBodyInfo.ExtendedType;
innerResponseType = proxyBodyInfo.ServerType;
}
}
if (responseType != innerResponseType)
return this.typeMapper.WrapResource(innerResult, innerResponseType, responseType);
return innerResult;
}
public object Get(string uri, Type type, RequestOptions requestOptions)
{
throw new LoadException(uri, type);
}
/// <summary>
/// Deletes the documents for the specified where clause.
/// </summary>
/// <param name="whereClause">The where clause.</param>
/// <returns></returns>
public IEnumerable <string> Delete(string whereClause)
{
var query = $"SELECT TOP 500 c.id AS Id, c.{_client.PartitionKey} AS PartitionKey FROM c WHERE {whereClause}";
var uri = UriFactory.CreateDocumentCollectionUri(_client.DatabaseId, _client.CollectionId);
var feedOptions = _client.EnableCrossPartitionQuery ? new FeedOptions {
EnableCrossPartitionQuery = true
} : null;
var retries = 0;
do
{
List <IdPartitionKeyDto> result = null;
try
{
result = _client.Client.CreateDocumentQuery <IdPartitionKeyDto>(uri, query, feedOptions).AsEnumerable().ToList();
}
catch (Exception e)
{
if (++retries >= 10)
{
Console.WriteLine("ERROR: TOO MANY RETRIES. FETCHING DOCUMENTS NOT POSSIBLE. TERMINATING.");
throw;
}
Console.WriteLine($"EXCEPTION WHILE FETCHING DOCUMENTS - {e.Message}");
Task.Delay(1000);
}
if (result != null)
{
retries = 0;
foreach (var doc in result)
{
var docId = doc.Id;
var noException = true;
try
{
RequestOptions requestOptions = null;
if (_client.EnableCrossPartitionQuery)
{
requestOptions = new RequestOptions()
{
PartitionKey = new PartitionKey(doc.PartitionKey)
}
}
;
var docUri = UriFactory.CreateDocumentUri(_client.DatabaseId, _client.CollectionId, docId);
_client.Client.DeleteDocumentAsync(docUri, requestOptions).Wait();
}
catch (Exception e)
{
noException = false;
Console.WriteLine($"EXCEPTION WHILE DELETING {docId} - {e.Message}");
Task.Delay(500);
}
if (noException)
{
yield return(docId);
}
}
}
Task.Delay(1000);
} while (HasResults(whereClause));
}
/// <inheritdoc /> async Task <IReadOnlyCollection <IVoiceRegion> > IGuild.GetVoiceRegionsAsync(RequestOptions options) => await GetVoiceRegionsAsync(options).ConfigureAwait(false);
public object SendRequest(string uri,
string httpMethod,
object body,
ISerializationContextProvider provider,
RequestOptions options = null)
{
try
{
return Task.Run(() => SendRequestAsync(uri, httpMethod, body, provider, options)).Result;
}
catch (AggregateException aggregateException)
when (aggregateException.InnerExceptions.Count == 1 && aggregateException.InnerException is WebClientException)
{
throw aggregateException.InnerException;
}
}
public override void GrabAndParseHtml()
{
//今日
int pageNum = 0;
int page = 1;
int match_type = 2;
do
{
int nTryCount = 0;
string uriFormat = Config.GetString(StaticData.SN_URL, "Uri", configFile, "Uri");
string uri = string.Format(uriFormat, page, match_type);
RequestOptions op = new RequestOptions(uri);
op.Method = Config.GetString(StaticData.SN_URL, "Method", configFile, "GET");
op.Accept = Config.GetString(StaticData.SN_URL, "Accept", configFile, "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8");
op.Referer = Config.GetString(StaticData.SN_URL, "Referer", configFile, "");
//获取网页
html = RequestAction(op);
while (string.IsNullOrEmpty(html) && nTryCount < MAX_TRY_COUNT)
{
html = RequestAction(op);
nTryCount++;
}
if (nTryCount == MAX_TRY_COUNT)
{
ShowLog("抓取失败！");
html = "";
return;
}
else
{
pageNum = Parse();
}
page++;
} while (pageNum == PAGE_MAX_NUM);
//赛前
pageNum = 0;
page = 1;
match_type = 3;
do
{
int nTryCount = 0;
string uriFormat = Config.GetString(StaticData.SN_URL, "Uri", configFile, "Uri");
string uri = string.Format(uriFormat, page, match_type);
RequestOptions op = new RequestOptions(uri);
op.Method = Config.GetString(StaticData.SN_URL, "Method", configFile, "GET");
op.Accept = Config.GetString(StaticData.SN_URL, "Accept", configFile, "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8");
op.Referer = Config.GetString(StaticData.SN_URL, "Referer", configFile, "");
//获取网页
html = RequestAction(op);
while (string.IsNullOrEmpty(html) && nTryCount < MAX_TRY_COUNT)
{
html = RequestAction(op);
nTryCount++;
}
if (nTryCount == MAX_TRY_COUNT)
{
ShowLog("抓取失败！");
html = "";
return;
}
else
{
pageNum = Parse();
}
page++;
} while (pageNum == PAGE_MAX_NUM);
if (betItems.Count > 0)
{
ShowLog(string.Format("页面解析成功，解析个数：{0}！", betItems.Count));
}
}
private async Task<string> SendHttpRequestAsync(ISerializationContextProvider serializationContextProvider,
string uri,
string httpMethod,
object requestBodyEntity,
TypeSpec requestBodyBaseType,
RequestOptions options)
{
byte[] requestBytes = null;
HttpResponseMessage response = null;
if (requestBodyEntity != null)
{
requestBytes = this.serializerFactory
.GetSerializer(serializationContextProvider)
.SerializeToBytes(requestBodyEntity, new SerializeOptions
{
ExpectedBaseType = requestBodyBaseType
});
}
var request = new HttpRequestMessage(new System.Net.Http.HttpMethod(httpMethod), uri);
string responseString = null;
Exception thrownException = null;
try
{
if (options != null)
options.ApplyRequestModifications(request);
AddDefaultHeaders(request);
const string jsonContentType = "application/json; charset=utf-8";
request.Headers.Add("Accept", jsonContentType);
if (requestBytes != null)
{
var requestContent = new ByteArrayContent(requestBytes);
requestContent.Headers.ContentType = MediaTypeHeaderValue.Parse(jsonContentType);
request.Content = requestContent;
}
using (Profiler.Step("client: " + request.Method + " " + request.RequestUri))
{
response = await WebClient.SendAsync(request, CancellationToken.None);
}
if (response.Content != null)
{
responseString = await response.Content.ReadAsStringAsync();
if (responseString.Length == 0)
responseString = null;
}
if ((int)response.StatusCode >= 400)
{
var gotJsonResponseBody = responseString != null && response.Content.Headers.ContentType.MediaType == "application/json";
var responseObject = gotJsonResponseBody
? Deserialize(responseString, null, serializationContextProvider)
: null;
throw WebClientException.Create(this.typeMapper, request, response, responseObject, null);
}
}
catch (Exception ex)
{
thrownException = ex;
throw;
}
finally
{
var eh = RequestCompleted;
if (eh != null)
{
// Since request content has been disposed at this point we recreate it..
if (request.Content != null)
{
var nonDisposedContent = new ByteArrayContent(requestBytes);
nonDisposedContent.Headers.CopyHeadersFrom(request.Content.Headers);
request.Content = nonDisposedContent;
}
eh(this, new ClientRequestLogEventArgs(request, response, thrownException));
}
}
return responseString;
}
public IAsyncEnumerable <IReadOnlyCollection <RestUserGuild> > GetGuildSummariesAsync(RequestOptions options = null) => ClientHelper.GetGuildSummariesAsync(this, null, null, options);
public Task<object> GetAsync(string uri, Type type, RequestOptions requestOptions)
{
throw new LoadException(uri, type);
}
/// <summary>
/// Consultar información de la nota de débito previamente enviada.
/// </summary>
/// <param name="requestOptions"></param>
/// <returns>Información de la nota de débito enviada</returns>
public static string Consultar(RequestOptions requestOptions)
{
Console.WriteLine("Consultando nota de débito");
var apiRequest = new ApiRequest(requestOptions);
return apiRequest.Get();
}
/// <summary>
/// Issues the web request.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="method">The method.</param>
/// <param name="input">The input.</param>
/// <param name="options">request options</param>
/// <returns></returns>
public Response IssueWebRequest(string endpoint, string query, string method, Stream input, RequestOptions options)
{
return IssueWebRequestAsync(endpoint, query, method, input, options).Result;
}
public Task <IReadOnlyCollection <RestGuild> > GetGuildsAsync(bool withCounts, RequestOptions options = null) => ClientHelper.GetGuildsAsync(this, withCounts, options);
/// <summary>
/// Create a pre-trigger that updates the document by the following for each doc:
/// - Validate and canonicalize the weekday name.
/// - Auto-create createdTime field.
/// </summary>
private static async Task RunPreTrigger(string colSelfLink)
{
// 1. Create a trigger.
string triggerId = "CanonicalizeSchedule";
string body = File.ReadAllText(@"JS\CanonicalizeSchedule.js");
Trigger trigger = new Trigger
{
Id = triggerId,
Body = body,
TriggerOperation = TriggerOperation.Create,
TriggerType = TriggerType.Pre
};
await TryDeleteStoredProcedure(colSelfLink, trigger.Id);
await client.CreateTriggerAsync(colSelfLink, trigger);
// 2. Create a few documents with the trigger.
var requestOptions = new RequestOptions { PreTriggerInclude = new List<string> { triggerId } };
await client.CreateDocumentAsync(colSelfLink, new
{
type = "Schedule",
name = "Music",
weekday = "mon",
startTime = DateTime.Parse("18:00", CultureInfo.InvariantCulture),
endTime = DateTime.Parse("19:00", CultureInfo.InvariantCulture)
}, requestOptions);
await client.CreateDocumentAsync(colSelfLink, new
{
type = "Schedule",
name = "Judo",
weekday = "tues",
startTime = DateTime.Parse("17:30", CultureInfo.InvariantCulture),
endTime = DateTime.Parse("19:00", CultureInfo.InvariantCulture)
}, requestOptions);
await client.CreateDocumentAsync(colSelfLink, new
{
type = "Schedule",
name = "Swimming",
weekday = "FRIDAY",
startTime = DateTime.Parse("19:00", CultureInfo.InvariantCulture),
endTime = DateTime.Parse("20:00", CultureInfo.InvariantCulture)
}, requestOptions);
// 3. Read the documents from the store.
var results = client.CreateDocumentQuery<Document>(colSelfLink, "SELECT * FROM root r WHERE r.type='Schedule'");
// 4. Prints the results: see what the trigger did.
Console.WriteLine("Weekly schedule of classes:");
foreach (var result in results)
{
Console.WriteLine("{0}", result);
}
}
public Task <RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null, RequestOptions options = null) => ClientHelper.CreateGuildAsync(this, name, region, jpegIcon, options);
public XHRRequest(RequestOptions options)
{
Method = options.Method ?? "GET";
Uri = options.Uri;
Data = options.Data;
CookieHeaderValue = options.CookieHeaderValue;
}
public Task <RestUser> GetUserAsync(ulong id, RequestOptions options = null) => ClientHelper.GetUserAsync(this, id, options);
public IAsyncEnumerable <IReadOnlyCollection <RestUserGuild> > GetGuildSummariesAsync(ulong fromGuildId, int limit, RequestOptions options = null) => ClientHelper.GetGuildSummariesAsync(this, fromGuildId, limit, options);
/// <inheritdoc />
async Task <IReadOnlyCollection <ICategoryChannel> > IGuild.GetCategoriesAsync(CacheMode mode, RequestOptions options)
{
if (mode == CacheMode.AllowDownload)
{
return(await GetCategoryChannelsAsync(options).ConfigureAwait(false));
}
else
{
return(null);
}
}
/// <summary>
/// Enviar información de la nota de débito para generarla electrónicamente.
/// </summary>
/// <param name="requestOptions"></param>
/// <returns>Información de la nota de débito enviada</returns>
public String Enviar(RequestOptions requestOptions)
{
Console.WriteLine("Enviando nota de débito");
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new SnakeCaseContractResolver(),
NullValueHandling = NullValueHandling.Ignore
};
var json = JsonConvert.SerializeObject(this, jsonSettings);
var apiRequest = new ApiRequest(requestOptions);
return apiRequest.Post(json);
}
public Task <IReadOnlyCollection <RestGuild> > GetGuildsAsync(RequestOptions options = null) => ClientHelper.GetGuildsAsync(this, false, options);
