/// <summary>
/// Gets an instance of <see cref="IHttpPostData"/> representing the POST parameters.
/// </summary>
public IHttpPostData GetPostData()
{
IHttpPostData postData = new HttpPostData();
if (IsDefault)
{
postData.Add("is_default", "true");
}
if (string.IsNullOrWhiteSpace(Location) == false)
{
postData.Add("location", Location);
}
if (string.IsNullOrWhiteSpace(Message) == false)
{
postData.Add("message", Message);
}
if (string.IsNullOrWhiteSpace(Name) == false)
{
postData.Add("name", Name);
}
if (string.IsNullOrWhiteSpace(Place) == false)
{
postData.Add("place", Place);
}
if (Privacy != null && Privacy.Value != FacebookPrivacy.Default)
{
postData.Add("privacy", Privacy.ToString());
}
return(postData);
}
/// <summary>
/// Gets an instance of <see cref="IHttpQueryString"/> representing the GET parameters.
/// </summary>
public IHttpPostData GetPostData()
{
// Both "Title" or "Description" should be specified
if (string.IsNullOrWhiteSpace(Title))
{
throw new PropertyNotSetException("Title");
}
if (string.IsNullOrWhiteSpace(Description))
{
throw new PropertyNotSetException("Description");
}
// Append the options to the POST data (if specified)
HttpPostData data = new HttpPostData();
data.Add("title", Title);
data.Add("description", Description);
if (!string.IsNullOrWhiteSpace(PrimaryPhotoId))
{
data.Add("primary_photo_id ", PrimaryPhotoId);
}
// TODO: The "full_result" parameter should be supported as well, but the Flickr API documentation doesn't specify it's type
return(data);
}
/// <summary>
/// Gets an instance of <see cref="IHttpPostData"/> representing the POST parameters.
/// </summary>
public IHttpPostData GetPostData()
{
IHttpPostData postData = new HttpPostData {
IsMultipart = !String.IsNullOrWhiteSpace(Source)
};
if (!String.IsNullOrWhiteSpace(Source))
{
postData.AddFile("source", Source);
}
if (!String.IsNullOrWhiteSpace(Url))
{
postData.Add("url", Url);
}
if (!String.IsNullOrWhiteSpace(Message))
{
postData.Add("message", Message);
}
if (!String.IsNullOrWhiteSpace(Place))
{
postData.Add("place", Place);
}
if (NoStory)
{
postData.Add("no_story", "true");
}
return(postData);
}
/// <summary>
/// Query this method with the provided HTTP POST data
/// </summary>
/// <typeparam name="T">The subtype to deserialize (the deserialized type being <see cref="APIResult{T}"/>).</typeparam>
/// <param name="method">The method to query</param>
/// <param name="postData">The http POST data</param>
/// <param name="transform">The XSL transform to apply, may be null.</param>
/// <returns>The deserialized object</returns>
private APIResult <T> QueryMethod <T>(APIMethods method, HttpPostData postData, XslCompiledTransform transform)
{
// Download
string url = GetMethodUrl(method);
var result = Util.DownloadAPIResult <T>(url, postData, transform);
// On failure with a custom method, fallback to CCP
if (ShouldRetryWithCCP(result))
{
return(s_ccpProvider.QueryMethod <T>(method, postData, transform));
}
// If the result is a character sheet, we store the result
if (method == APIMethods.CharacterSheet && !result.HasError)
{
SerializableAPICharacterSheet sheet = (SerializableAPICharacterSheet)(Object)result.Result;
LocalXmlCache.Save(sheet.Name, result.XmlDocument);
}
// If the result is a conquerable station list, we store the result
if (method == APIMethods.ConquerableStationList && !result.HasError)
{
LocalXmlCache.Save(method.ToString(), result.XmlDocument);
}
// Returns
return(result);
}
/// <summary>
/// Query a method with the provided arguments for a character messages.
/// </summary>
/// <param name="userID">The account's ID</param>
/// <param name="apiKey">The account's API key</param>
/// <param name="messageID">The message ID.</param>
/// <returns></returns>
public void QueryMethodAsync <T>(APIMethods method, long userID, string apiKey, long characterID, long messageID, QueryCallback <T> callback)
{
HttpPostData postData = new HttpPostData(String.Format(
"userID={0}&apiKey={1}&characterID={2}&ids={3}", userID, apiKey, characterID, messageID));
QueryMethodAsync <T>(method, postData, RowsetsTransform, callback);
}
/// <summary>
/// Exchanges the specified authorization code for an access token.
/// </summary>
/// <param name="authCode">The authorization code received from the Meetup OAuth dialog.</param>
/// <returns>An instance of <see cref="MeetupTokenResponse"/> representing the response.</returns>
public MeetupTokenResponse GetAccessTokenFromAuthCode(string authCode)
{
// Some validation
if (String.IsNullOrWhiteSpace(ClientId))
{
throw new PropertyNotSetException("ClientId");
}
if (String.IsNullOrWhiteSpace(ClientSecret))
{
throw new PropertyNotSetException("ClientSecret");
}
if (String.IsNullOrWhiteSpace(RedirectUri))
{
throw new PropertyNotSetException("RedirectUri");
}
if (String.IsNullOrWhiteSpace(authCode))
{
throw new ArgumentNullException(nameof(authCode));
}
// Initialize the query string
HttpPostData data = new HttpPostData {
{ "client_id", ClientId },
{ "client_secret", ClientSecret },
{ "grant_type", "authorization_code" },
{ "redirect_uri", RedirectUri },
{ "code", authCode }
};
// Make the call to the API
IHttpResponse response = HttpUtils.Http.DoHttpPostRequest("https://secure.meetup.com/oauth2/access", null, data);
// Parse the response
return(MeetupTokenResponse.ParseResponse(response));
}
/// <summary>
/// Gets an instance of <see cref="IHttpPostData"/> representing the POST parameters.
/// </summary>
/// <returns>An instance of <see cref="IHttpPostData"/>.</returns>
public IHttpPostData GetPostData()
{
if (ListId == 0)
{
throw new PropertyNotSetException(nameof(ListId));
}
if (UserId == 0 && String.IsNullOrWhiteSpace(ScreenName))
{
throw new PropertyNotSetException(nameof(UserId));
}
IHttpPostData data = new HttpPostData {
{ "list_id", ListId }
};
if (UserId > 0)
{
data.Add("user_id", UserId);
}
if (!String.IsNullOrWhiteSpace(ScreenName))
{
data.Add("screen_name", ScreenName);
}
return(data);
}
/// <summary>
/// Asynchrnoneously queries this method with the provided HTTP POST data
/// </summary>
/// <typeparam name="T">The subtype to deserialize (the deserialized type being <see cref="APIResult{T}"/>).</typeparam>
/// <param name="method">The method to query</param>
/// <param name="postData">The http POST data</param>
/// <param name="callback">The callback to invoke once the query has been completed. It will be done on the data actor (see <see cref="DataObject.CommonActor"/>).</param>
/// <param name="transform">The XSL transform to apply, may be null.</param>
private void QueryMethodAsync <T>(APIMethods method, HttpPostData postData, XslCompiledTransform transform, QueryCallback <T> callback)
{
// Check callback not null
if (callback == null)
{
throw new ArgumentNullException("The callback cannot be null.", "callback");
}
// Lazy download
string url = GetMethodUrl(method);
Util.DownloadAPIResultAsync <T>(url, postData, transform, (result) =>
{
// On failure with a custom method, fallback to CCP
if (ShouldRetryWithCCP(result))
{
result = s_ccpProvider.QueryMethod <T>(method, postData, transform);
}
// If the result is a character sheet, we store the result
if (method == APIMethods.CharacterSheet && !result.HasError)
{
SerializableAPICharacter sheet = (SerializableAPICharacter)(Object)result.Result;
LocalXmlCache.Save(sheet.Name, result.XmlDocument);
}
// Invokes the callback
callback(result);
});
}
/// <summary>
/// Writes the value to the specified <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The stream the value should be written to.</param>
/// <param name="boundary">The multipart boundary.</param>
/// <param name="newLine">The characters used to indicate a new line.</param>
/// <param name="isLast">Whether the value is the last in the request body.</param>
public void WriteToMultipartStream(Stream stream, string boundary, string newLine, bool isLast)
{
HttpPostData.Write(stream, "--" + boundary + newLine);
HttpPostData.Write(stream, "Content-Disposition: form-data; name=\"" + Name + "\"" + newLine);
HttpPostData.Write(stream, newLine);
HttpPostData.Write(stream, Value);
HttpPostData.Write(stream, newLine);
HttpPostData.Write(stream, "--" + boundary + (isLast ? "--" : "") + newLine);
}
private static void L_OnDataReceived(HttpPostData data)
{
Console.WriteLine($"Query string: {data.Query}");
foreach (var header in data.Headers)
{
Console.WriteLine($"Header: {header.Name} Value: {header.Value}");
}
Console.WriteLine($"Data: {Encoding.UTF8.GetString(data.Message)}");
Console.WriteLine();
}
public void SetPostData()
{
IHttpPostData data = new HttpPostData {
{ "hello", "there" }
};
IHttpRequest request = HttpRequest
.New()
.SetPostData(data);
Assert.AreEqual("hello=there", request.PostData.ToString());
}
/// <summary>
/// Asynchronously downloads a JSON object from a JSON stream.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url">The URL.</param>
/// <param name="token">The ESI token.</param>
/// <param name="acceptEncoded">if set to <c>true</c> [accept encoded].</param>
/// <param name="postData">The post data.</param>
/// <returns></returns>
public static async Task <JsonResult <T> > DownloadJsonAsync <T>(Uri url, string token,
bool acceptEncoded = false, string postData = null, string postContentType = null)
where T : class
{
// Create POST data body
HttpPostData content = null;
if (postData != null)
{
content = new HttpPostData(postData, contentType: postContentType);
}
JsonResult <T> result;
try
{
DownloadResult <T> asyncResult = await HttpWebClientService.DownloadStreamAsync <T>(
url, ParseJSONObject <T>, acceptEncoded, content, token);
var error = asyncResult.Error;
T data;
// Was there an HTTP error?
if (error != null)
{
result = new JsonResult <T>(error);
}
else if ((data = asyncResult.Result) == default(T))
{
// This will become a json error
result = new JsonResult <T>(new InvalidOperationException("null JSON response"));
}
else
{
result = new JsonResult <T>(asyncResult.ResponseCode, data)
{
CurrentTime = asyncResult.ServerTime
}
};
}
catch (InvalidOperationException e)
{
result = new JsonResult <T>(e);
ExceptionHandler.LogException(e, true);
}
catch (InvalidDataContractException e)
{
result = new JsonResult <T>(e);
ExceptionHandler.LogException(e, true);
}
return(result);
}
/// <summary>
/// Writes the value to the specified <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The stream the value should be written to.</param>
/// <param name="boundary">The multipart boundary.</param>
/// <param name="newLine">The characters used to indicate a new line.</param>
/// <param name="isLast">Whether the value is the last in the request body.</param>
public void WriteToMultipartStream(Stream stream, string boundary, string newLine, bool isLast)
{
HttpPostData.Write(stream, "--" + boundary + newLine);
HttpPostData.Write(stream, "Content-Disposition: form-data; name=\"" + Name + "\"; filename=\"" + FileName + "\"" + newLine);
HttpPostData.Write(stream, "Content-Type: " + ContentType + newLine);
HttpPostData.Write(stream, newLine);
stream.Write(Data, 0, Data.Length);
HttpPostData.Write(stream, newLine);
HttpPostData.Write(stream, newLine);
HttpPostData.Write(stream, "--" + boundary + (isLast ? "--" : "") + newLine);
}
/// <returns>An instance of <see cref="HttpResponse"/> representing the raw response.</returns>
protected virtual IHttpResponse GetAccessTokenResponse(string verifier)
{
// Some error checking
if (string.IsNullOrWhiteSpace(AccessTokenUrl))
{
throw new PropertyNotSetException(nameof(AccessTokenUrl));
}
// Initialize the POST data
IHttpPostData postData = new HttpPostData();
postData.Add("oauth_verifier", verifier);
// Make the call to the API/provider
return(Post(AccessTokenUrl, null, postData));
}
/// <summary>
/// Exchanges the specified authorization <paramref name="code"/> for a short-lived access token.
/// </summary>
/// <param name="code">The authorization code.</param>
/// <returns>An instance of <see cref="InstagramShortLivedTokenResponse"/> representing the API response.</returns>
/// <see>
/// <cref>https://developers.facebook.com/docs/instagram-basic-display-api/reference/oauth-access-token</cref>
/// </see>
public InstagramShortLivedTokenResponse GetAccessTokenFromAuthCode(string code)
{
// Initialize the POST data
IHttpPostData post = new HttpPostData {
{ "client_id", ClientId },
{ "client_secret", ClientSecret },
{ "code", code },
{ "grant_type", "authorization_code" },
{ "redirect_uri", RedirectUri }
};
// Make a POST request to the API
IHttpResponse response = HttpUtils.Requests.Post("https://api.instagram.com/oauth/access_token", post);
// Wrap the raw response
return(new InstagramShortLivedTokenResponse(response));
}
/// <summary>
/// Gets an instance of <see cref="IHttpPostData"/> representing the POST parameters.
/// </summary>
/// <returns>An instance of <see cref="IHttpPostData"/>.</returns>
public IHttpPostData GetPostData()
{
if (String.IsNullOrWhiteSpace(Name))
{
throw new ArgumentNullException(nameof(Name));
}
IHttpPostData data = new HttpPostData();
data.Set("name", Name);
data.Set("mode", StringUtils.ToCamelCase(Mode));
if (!String.IsNullOrWhiteSpace(Description))
{
data.Add("description", Description);
}
return(data);
}
/// <summary>
/// Synchronously download an XML and deserializes it into the specified type
/// </summary>
/// <typeparam name="T">The inner type to deserialize</typeparam>
/// <param name="url">The url to query</param>
/// <param name="postData">The HTTP POST data to send, may be null.</param>
/// <param name="transform">The XSL transform to apply, may be null.</param>
internal static APIResult <T> DownloadAPIResult <T>(string url, HttpPostData postData, XslCompiledTransform transform)
{
APIResult <T> result = new APIResult <T>(APIErrors.Http, "Time out on querying " + url);
// Query async and wait.
using (var wait = new EventWaitHandle(false, EventResetMode.AutoReset))
{
EveClient.HttpWebService.DownloadXmlAsync(url, postData, (asyncResult, userState) =>
{
try
{
// Was there an HTTP error ??
if (asyncResult.Error != null)
{
result = new APIResult <T>(asyncResult.Error);
}
// No http error, let's try to deserialize
else
{
result = DeserializeAPIResultCore <T>(transform, asyncResult.Result);
}
}
catch (Exception e)
{
ExceptionHandler.LogException(e, true);
result = new APIResult <T>(APIErrors.Http, e.Message);
}
finally
{
// We got the result, so we resume the calling thread
wait.Set();
}
},
null);
// Wait for the completion of the backgound thread.
wait.WaitOne();
}
// Returns
return(result);
}
/// <summary>
/// Exchanges the specified authorization code for an access token.
/// </summary>
/// <param name="authCode">The authorization code received from the Vimeo OAuth dialog.</param>
/// <returns>An instance of <see cref="VimeoTokenResponse"/> representing the response.</returns>
public VimeoTokenResponse GetAccessTokenFromAuthCode(string authCode)
{
// Some validation
if (string.IsNullOrWhiteSpace(ClientId))
{
throw new PropertyNotSetException(nameof(ClientId));
}
if (string.IsNullOrWhiteSpace(ClientSecret))
{
throw new PropertyNotSetException(nameof(ClientSecret));
}
if (string.IsNullOrWhiteSpace(RedirectUri))
{
throw new PropertyNotSetException(nameof(RedirectUri));
}
if (string.IsNullOrWhiteSpace(authCode))
{
throw new ArgumentNullException(nameof(authCode));
}
// Initialize the POST data
IHttpPostData data = new HttpPostData();
data.Add("grant_type", "authorization_code");
data.Add("code", authCode);
data.Add("redirect_uri", RedirectUri);
// Initialize the request
IHttpRequest request = new HttpRequest {
Method = HttpMethod.Post,
Url = "https://api.vimeo.com/oauth/access_token",
PostData = data,
Authorization = "basic " + SecurityUtils.Base64Encode(ClientId + ":" + ClientSecret)
};
// Make the call to the API
IHttpResponse response = request.GetResponse();
// Parse the response
return(new VimeoTokenResponse(response));
}
/// <summary>
/// Asynchronously download an object from an XML stream.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url">The url to download from</param>
/// <param name="postData">The http POST data to pass with the url. May be null.</param>
/// <param name="callback">A callback invoked on the UI thread</param>
/// <returns></returns>
public static void DownloadXMLAsync <T>(string url, HttpPostData postData, DownloadCallback <T> callback)
where T : class
{
EveClient.HttpWebService.DownloadXmlAsync(url, postData,
// Callback
(asyncResult, userState) =>
{
T result = null;
string errorMessage = "";
// Was there an HTTP error ??
if (asyncResult.Error != null)
{
errorMessage = asyncResult.Error.Message;
}
// No http error, let's try to deserialize
else
{
try
{
// Deserialize
using (XmlNodeReader reader = new XmlNodeReader(asyncResult.Result))
{
XmlSerializer xs = new XmlSerializer(typeof(T));
result = (T)xs.Deserialize(reader);
}
}
// An error occured during the deserialization
catch (InvalidOperationException exc)
{
ExceptionHandler.LogException(exc, true);
errorMessage = (exc.InnerException == null ? exc.Message : exc.InnerException.Message);
}
}
// We got the result, let's invoke the callback on this actor
Dispatcher.Invoke(() => callback.Invoke(result, errorMessage));
},
null);
}
/// <summary>
/// Asynchronously download an XML and deserializes it into the specified type
/// </summary>
/// <typeparam name="T">The inner type to deserialize</typeparam>
/// <param name="url">The url to query</param>
/// <param name="postData">The HTTP POST data to send, may be null.</param>
/// <param name="transform">The XSL transform to apply, may be null.</param>
/// <param name="callback">The callback to call once the query has been completed. It will be done on the data actor (see <see cref="DataObject.CommonActor"/>).</param>
internal static void DownloadAPIResultAsync <T>(string url, HttpPostData postData, XslCompiledTransform transform, QueryCallback <T> callback)
{
EveClient.HttpWebService.DownloadXmlAsync(url, postData, (asyncResult, userState) =>
{
APIResult <T> result;
// Was there an HTTP error ?
if (asyncResult.Error != null)
{
result = new APIResult <T>(asyncResult.Error);
}
// No http error, let's try to deserialize
else
{
result = DeserializeAPIResultCore <T>(transform, asyncResult.Result);
}
// We got the result, let's invoke the callback on this actor
Dispatcher.Invoke(() => callback.Invoke(result));
},
null);
}
/// <summary>
/// Gets an instance of <see cref="IHttpPostData"/> representing the POST parameters.
/// </summary>
/// <returns>An instance of <see cref="IHttpPostData"/>.</returns>
public IHttpPostData GetPostData()
{
// Validate required properties
if (String.IsNullOrWhiteSpace(Status))
{
throw new PropertyNotSetException(nameof(Status));
}
// Initialize a new instance with required parameters
IHttpPostData data = new HttpPostData();
data.Set("status", Status);
// Append optional parameters to be POST data
if (ReplyTo > 0)
{
data.Add("in_reply_to_status_id", ReplyTo);
}
if (IsPossiblySensitive)
{
data.Add("possibly_sensitive", "true");
}
if (Math.Abs(Latitude) > Double.Epsilon && Math.Abs(Longitude) > Double.Epsilon)
{
data.Add("lat", Latitude);
data.Add("long", Longitude);
}
if (PlaceId != null)
{
data.Add("place_id", PlaceId);
}
if (DisplayCoordinates)
{
data.Add("display_coordinates", "true");
}
return(data);
}
/// <summary>
/// Gets an instance of <see cref="IHttpPostData"/> representing the POST parameters.
/// </summary>
public IHttpPostData GetPostData()
{
IHttpPostData postData = new HttpPostData();
if (string.IsNullOrWhiteSpace(Message) == false)
{
postData.Add("message", Message);
}
if (string.IsNullOrWhiteSpace(Link) == false)
{
postData.Add("link", Link);
}
if (string.IsNullOrWhiteSpace(Picture) == false)
{
postData.Add("picture", Picture);
}
if (string.IsNullOrWhiteSpace(Name) == false)
{
postData.Add("name", Name);
}
if (string.IsNullOrWhiteSpace(Caption) == false)
{
postData.Add("caption", Caption);
}
if (string.IsNullOrWhiteSpace(Description) == false)
{
postData.Add("description", Description);
}
if (string.IsNullOrWhiteSpace(Place) == false)
{
postData.Add("place", Place);
}
if (Tags != null && Tags.Length > 0)
{
postData.Add("tags", string.Join(",", Tags));
}
return(postData);
}
/// <summary>
/// Exchanges the specified authorization code for an access token.
/// </summary>
/// <param name="authCode">The authorization code received from the Mailchimp OAuth dialog.</param>
/// <returns>An access token based on the specified <paramref name="authCode"/>.</returns>
public MailchimpTokenResponse GetAccessTokenFromAuthCode(string authCode)
{
// Some validation
if (String.IsNullOrWhiteSpace(authCode))
{
throw new ArgumentNullException(nameof(authCode));
}
// Initialize the query string
IHttpPostData query = new HttpPostData {
{ "grant_type", "authorization_code" },
{ "client_id", ClientId },
{ "client_secret", ClientSecret },
{ "redirect_uri", RedirectUri },
{ "code", authCode }
};
// Make the call to the API
IHttpResponse response = HttpUtils.Http.DoHttpPostRequest("https://login.mailchimp.com/oauth2/token", null, query);
// Parse the response
return(MailchimpTokenResponse.ParseResponse(response));
}
public void GenerateSignature()
{
// These are not real tokens, but randomly generated GUIDs
const string a = "45b998c8-3ee3-4cb0-86c8-ef4ef81e52fe";
const string b = "afee51a6-6aca-49a2-9d3e-084b4d372a97";
const string c = "401fdd6d-4708-4174-ad2e-29c6ea054ec6";
const string d = "3642df43-fc23-469e-9d5b-4bee66b5fc4b";
const string timestamp = "1568285417";
const string nonce = "a random value";
OAuthClient client = new OAuthClient {
ConsumerKey = a,
ConsumerSecret = b,
Token = c,
TokenSecret = d,
AutoReset = false,
Nonce = nonce,
Timestamp = timestamp
};
HttpQueryString query = new HttpQueryString {
{ "hello", "world" }
};
HttpPostData post = new HttpPostData {
{ "alpha", "bravo" }
};
string signature = client.GenerateSignature(HttpMethod.Post, "https://example.org/", query, post);
Assert.AreEqual("hcmLTxgZgsZuTh9ywU68PFGZLL0=", signature);
string header = client.GenerateHeaderString(signature);
Assert.AreEqual("OAuth realm=\"\",oauth_consumer_key=\"45b998c8-3ee3-4cb0-86c8-ef4ef81e52fe\",oauth_nonce=\"a%20random%20value\",oauth_signature=\"hcmLTxgZgsZuTh9ywU68PFGZLL0%3D\",oauth_signature_method=\"HMAC-SHA1\",oauth_timestamp=\"1568285417\",oauth_token=\"401fdd6d-4708-4174-ad2e-29c6ea054ec6\",oauth_version=\"1.0\"", header);
}
/// <summary>
/// Query the characters list for the provided account.
/// </summary>
/// <param name="userID">The account's ID</param>
/// <param name="apiKey">The account's API key</param>
public APIResult <SerializableAPICharacters> QueryCharactersList(long userID, string apiKey)
{
HttpPostData postData = new HttpPostData(String.Format("userID={0}&apiKey={1}", userID, apiKey));
return(QueryMethod <SerializableAPICharacters>(APIMethods.CharacterList, postData, RowsetsTransform));
}
/// <summary>
/// Query a method with the provided arguments for a character.
/// </summary>
/// <typeparam name="T">The type of the deserialization object.</typeparam>
/// <param name="method"></param>
/// <param name="userID"></param>
/// <param name="apiKey"></param>
/// <param name="charID"></param>
/// <param name="callback">The callback to invoke once the query has been completed. It will be done on the data actor (see <see cref="DataObject.CommonActor"/>).</param>
public void QueryMethodAsync <T>(APIMethods method, long userID, string apiKey, long charID, QueryCallback <T> callback)
{
HttpPostData postData = new HttpPostData("userID=" + userID + "&apiKey=" + apiKey + "&characterID=" + charID.ToString());
QueryMethodAsync <T>(method, postData, RowsetsTransform, callback);
}
/// <summary>
/// Query the account balance for a character. Requires full api key. Used to test whether a key is a full or limited one.
/// </summary>
/// <param name="userID"></param>
/// <param name="apiKey"></param>
/// <param name="charID"></param>
/// <returns></returns>
public APIResult <SerializableAPIAccountBalance> QueryCharacterAccountBalance(long userID, string apiKey, long charID)
{
HttpPostData postData = new HttpPostData(String.Format("userID={0}&apiKey={1}&characterID={2}", userID, apiKey, charID));
return(QueryMethod <SerializableAPIAccountBalance>(APIMethods.CharacterAccountBalance, postData, RowsetsTransform));
}
/// <summary>
/// Query the status for the provided account. Requires full api key.
/// </summary>
/// <param name="userID">The account's ID</param>
/// <param name="apiKey">The account's API key</param>
public APIResult <SerializableAPIAccountStatus> QueryAccountStatus(long userID, string apiKey)
{
HttpPostData postData = new HttpPostData(String.Format("userID={0}&apiKey={1}", userID, apiKey));
return(QueryMethod <SerializableAPIAccountStatus>(APIMethods.AccountStatus, postData, RowsetsTransform));
}
/// <summary>
/// Query the character name from the provided list of IDs.
/// </summary>
public APIResult <SerializableAPICharacterName> QueryCharacterName(string IDs)
{
HttpPostData postData = new HttpPostData(String.Format("ids={0}", IDs));
return(QueryMethod <SerializableAPICharacterName>(APIMethods.CharacterName, postData, RowsetsTransform));
}
/// <summary>
/// Query a method with the provided arguments for an account.
/// </summary>
/// <typeparam name="T">The type of the deserialization object.</typeparam>
/// <param name="method"></param>
/// <param name="userID"></param>
/// <param name="apiKey"></param>
/// <param name="callback">The callback to invoke once the query has been completed. It will be done on the data actor (see <see cref="DataObject.CommonActor"/>).</param>
public void QueryMethodAsync <T>(APIMethods method, long userID, string apiKey, QueryCallback <T> callback)
{
HttpPostData postData = new HttpPostData(String.Format("userID={0}&apiKey={1}", userID, apiKey));
QueryMethodAsync <T>(method, postData, RowsetsTransform, callback);
}
