protected virtual Uri BuildUri()
{
RegisterDefaultUrlParams();
var queryBuilder = new StringBuilder();
for (var i = 0; i < UrlParams.Count; i++)
{
var item = UrlParams.ElementAt(i);
queryBuilder.Append(i == 0 ? "?" : "&");
var query = string.Format("{0}={1}", item.Key, item.Value);
if (encryptUriQuery)
{
query = query.Encrypt(cryptoKey);
}
var escapeStr = Uri.EscapeDataString(query);
queryBuilder.Append(escapeStr);
}
var uriBuilder = new UriBuilder(HostUrl)
{
Query = queryBuilder.ToString(),
};
return(uriBuilder.Uri);
}
/// <summary>
/// 初始化获取post请求参数
/// </summary>
private static void InitHttpRequestParams()
{
m_RequestParams = new ConcurrentDictionary <string, object>();
foreach (var param in HttpContext.Current.Request.Form)
{
string param_name = param.ToString();
object val = HttpContext.Current.Request.Params[param_name];
if (UrlParams != null)
{
if (UrlParams.ContainsKey(param_name)) //如果地址传的参数是否与post的参数键名相同
{
string v = val.ToString();
Type t = val.GetType();
v = v.Replace(",", string.Empty);
v = v.Replace(m_UrlParams[param_name].ToString(), string.Empty); //将地址上的参数的值替换为空
val = v; //剩下post的该参数的值
}
}
m_RequestParams.TryAdd(param_name, val);
}
}
public static UrlParams DecodeUrl(string hostname)
{
UrlParams output = new UrlParams();
//Check to make sure the hostname is even correct.
//Hostname: en_US-token-prod.voice.get-rpws.com
if (!hostname.EndsWith(".voice.get-rpws.com"))
{
throw new Exception("Incorrect domain. Hostname must end with \".voice.get-rpws.com\".");
}
//Trim off of the end ".voice.get-rpws.com".
hostname = hostname.Substring(0, hostname.Length - ".voice.get-rpws.com".Length);
//Hostname: en_US-token-prod
//Split the URL into parts
string[] parts = hostname.Split('-');
//Parse the language region.
output.languageRegion = ParseLangRegion(parts[0]);
//Grab others
output.accessToken = parts[1]; //Uh oh
output.enviornment = parts[2];
return(output);
}
protected virtual string GenerateRelativeUrl(CopyDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.SrcRev);
return string.Format("/{0}{1}", new UrlSegment(request.SrcId), new QueryString(urlParams));
}
protected virtual string GenerateRelativeUrl(DeleteDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddRequired("rev", request.Rev);
return string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams));
}
protected virtual string GenerateRelativeUrl(string entityId, string entityRev)
{
var urlParams = new UrlParams();
urlParams.AddRequired("rev", entityRev);
return(string.Format("/{0}{1}", new UrlSegment(entityId), new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(PostDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfTrue("batch", request.Batch, "ok");
return string.Format("/{0}", new QueryString(urlParams));
}
protected virtual string GenerateRelativeUrl <T>(PostEntityRequest <T> request) where T : class
{
var urlParams = new UrlParams();
urlParams.AddIfTrue("batch", request.Batch, "ok");
return(string.Format("/{0}", new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(DeleteDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddRequired("rev", request.Rev);
return(string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(CopyDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.SrcRev);
return(string.Format("/{0}{1}", new UrlSegment(request.SrcId), new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(PostDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfTrue("batch", request.Batch, "ok");
return(string.Format("/{0}", new QueryString(urlParams)));
}
public Item(string name, ulong actionId, string type = null)
{
this.name = name;
label = Labels[name];
url = Urls[name];
urlParams = new UrlParams {
id = actionId
}; //, type = type};
}
protected virtual string GenerateRelativeUrl(PutDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.Rev);
urlParams.AddIfTrue("batch", request.Batch, "ok");
return string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams));
}
protected virtual string GenerateRelativeUrl(string entityId, string entityRev, bool batch)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", entityRev);
urlParams.AddIfTrue("batch", batch);
return(string.Format("/{0}{1}", new UrlSegment(entityId), new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(GetEntityRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.Rev);
urlParams.AddIfTrue("conflicts", request.Conflicts);
return(string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(PutDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.Rev);
urlParams.AddIfTrue("batch", request.Batch, "ok");
return(string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams)));
}
protected virtual string GenerateRelativeUrl(GetEntityRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.Rev);
urlParams.AddIfTrue("conflicts", request.Conflicts);
return string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams));
}
public string GetUrl()
{
if (UrlParams == null || UrlParams.Count == 0)
{
return(EndPoint);
}
return(string.Format("{0}?{1}", EndPoint, string.Join("&", UrlParams.Select(kvp => string.Format("{0}={1}", kvp.Key, kvp.Value)))));
}
public QueryString(UrlParams parameters)
{
var queryParameters = parameters
.Where(p => p != null && p.HasValue)
.Select(p => string.Concat(p.Key, "=", p.Value)).ToList();
Value = queryParameters.Any()
? string.Join("&", queryParameters).PrependWith("?")
: string.Empty;
}
protected virtual string GenerateRelativeUrl(PutAttachmentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.DocRev);
return string.Format("/{0}/{1}{2}",
new UrlSegment(request.DocId),
new UrlSegment(request.Name),
new QueryString(urlParams));
}
protected virtual string GenerateRelativeUrl(GetAttachmentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.DocRev);
return(string.Format("/{0}/{1}{2}",
new UrlSegment(request.DocId),
new UrlSegment(request.Name),
new QueryString(urlParams)));
}
protected RestRequest(HttpMethod method, UrlParams urlParameters, HeaderParams headerParameters, QueryParams queryParameters,
BodyParams bodyParameters, DataParams dataParameters)
{
Method = method;
UrlParameters = urlParameters.ThrowIfNull(nameof(urlParameters)).ToList();
HeaderParameters = headerParameters.ThrowIfNull(nameof(headerParameters)).ToList();
QueryParameters = queryParameters.ThrowIfNull(nameof(queryParameters)).ToList();
BodyParameters = bodyParameters.ThrowIfNull(nameof(bodyParameters))
.Select(p => new FieldRequestData(p.Name, p.Value))
.Concat(dataParameters.ThrowIfNull(nameof(dataParameters)))
.ToList();
}
/// <summary>
/// 拼装api参数
/// </summary>
/// <param name="urlParanms">url参数</param>
/// <param name="sign">签名</param>
/// <returns></returns>
private ParameterCollection GetUrlParmCollection(string sign)
{
ParameterCollection ps = new ParameterCollection();
Dictionary <string, string> .Enumerator i = UrlParams.GetEnumerator();
while (i.MoveNext())
{
ps.Add(i.Current.Key, i.Current.Value);
}
if (!string.IsNullOrEmpty(sign))
{
ps.Add("_aop_signature", sign);
}
return(ps);
}
public static IActionResult Subscribers(RequestHandler <IActionResult> req)
{
int limit = 100;
int total = int.MaxValue;
User user = UserManager.GetUserTwitch("gogomic");
JArray subs = new JArray();
HashSet <string> ids = new HashSet <string>();
for (int offset = 0; offset + limit <= total; offset += limit)
{
UrlParams param = new UrlParams();
param.Add("limit", limit.ToString());
param.Add("offset", offset.ToString());
// TODO: Chain requests if gogomic ever gets over 100 subs.
string url = "https://api.twitch.tv/kraken/channels/" + user.TwitchId
+ "/subscriptions" + param.ToString();
GetRequest getReq = new GetRequest(url);
getReq.AddHeader(HttpRequestHeader.Accept, "application/vnd.twitchtv.v5+json");
getReq.AddHeader("Client-ID", Config.TwitchOAuth.ClientId);
getReq.AddHeader("Authorization", "OAuth " + user.TwitchToken);
JObject resp = getReq.GetResponseJson();
foreach (JToken sub in (JArray)resp["subscriptions"])
{
string id = (string)sub["user"]["_id"];
if (ids.Contains(id) || id == user.TwitchId)
{
continue;
}
ids.Add(id);
subs.Add(sub);
}
total = (int)resp["_total"];
}
req.View.Subs = subs;
return(req.Controller.View());
}
/// <summary>
/// 加密
/// </summary>
/// <param name="infor"></param>
/// <param name="funname"></param>
/// <param name="parms"></param>
/// <returns></returns>
private string GetSignature()
{
string p1 = Secret.ApiParmUrl + FunName + "/" + Secret.AppKey;
List <string> p2 = new List <string>();
Dictionary <string, string> .Enumerator itemator = UrlParams.GetEnumerator();
while (itemator.MoveNext())
{
p2.Add(itemator.Current.Key + itemator.Current.Value);
}
//排序
p2.Sort(delegate(string a, string b)
{
int i;
for (i = 0; i < a.Length; i++)
{
if (i >= b.Length)
{
return(1); //a比b长
}
if (a[i] < b[i])
{
return(-1);
}
if (a[i] > b[i])
{
return(1);
}
}
if (i < b.Length)
{ //a比b短
return(-1);
}
return(0);
});
p2.ForEach(delegate(string item) { p1 += item; });
byte[] signatureKey = Encoding.UTF8.GetBytes(Secret.AppSecret);
HMACSHA1 hmacsha1 = new HMACSHA1(signatureKey);
hmacsha1.ComputeHash(Encoding.UTF8.GetBytes(p1));
byte[] hash = hmacsha1.Hash;
return(BitConverter.ToString(hash).Replace("-", string.Empty).ToUpper());
}
public static IActionResult Index(RequestHandler <IActionResult> req)
{
UrlParams param = new UrlParams();
param.Add("client_id", Config.TwitchOAuth.ClientId);
param.Add("redirect_uri", Config.OAuthRedirect);
param.Add("response_type", "code");
param.Add("scope", Config.TwitchScope);
param.Add("force_verify", "true");
param.Add("state", TokenGenerator.Generate()); // TODO: Generate token for this.
string twitchUrl = "https://api.twitch.tv/kraken/oauth2/authorize"
+ param.ToString();
req.View.TwitchUrl = twitchUrl;
return(req.Controller.View());
}
public static UrlParams GetUrlParams()
{
UrlParams urlparam = (UrlParams)WebContext.Current[UrlParams.DATA_TAG];
if (urlparam == null)
{
urlparam = new UrlParams();
foreach (string key in WebContext.Current.Request.QueryString.Keys)
{
if (key != null && key != "OrderField" && key != "PageCount" && key != "PageIndex" && key != "PageSize" && key != "RecordCount")
{
urlparam.Add(key, WebContext.Current.Request.QueryString[key]);
}
}
WebContext.Current[UrlParams.DATA_TAG] = urlparam;
}
return(urlparam);
}
public Item(uint actionId, uint profileId, string name)
{
this.name = name.Replace("un_", "");
label = Labels[name];
url = Urls[name];
urlParams = new UrlParams {
action_id = actionId
};
if (name == "hide")
{
urlParams.type = "activity_action";
} //; urlParams.id = actionId; }
//else if (name == "report_feed") { urlParams.type = "activity_action"; urlParams.hide_report = 1; }
else if (name == "")
{
feed_link =
$"https://beta.koobeca.com/profile/{profileId}/action_id/{actionId}"; ///show_comments/1"
}
}
public static string GetToken(string code, string state)
{
PostRequest req = new PostRequest(
"https://api.twitch.tv/kraken/oauth2/token");
UrlParams param = new UrlParams();
param.Add("client_id", Config.TwitchOAuth.ClientId);
param.Add("client_secret", Config.TwitchOAuth.Secret);
param.Add("code", code);
param.Add("grant_type", "authorization_code");
param.Add("redirect_uri", Config.OAuthRedirect);
param.Add("state", state);
req.AddHeader(HttpRequestHeader.ContentType, "application/x-www-form-urlencoded");
req.BodyString = param.ToPostString();
JObject resp = req.GetResponseJson();
return((string)resp["access_token"]);
}
private Uri BuildUri()
{
RegisterDefaultUrlParams();
var queryBuilder = new StringBuilder();
for (var i = 0; i < UrlParams.Count; i++)
{
var item = UrlParams.ElementAt(i);
queryBuilder.Append(i == 0 ? "?" : "&");
var query = string.Format("{0}={1}", item.Key, item.Value);
queryBuilder.Append(Uri.EscapeUriString(query));
}
var uriBuilder = new UriBuilder(HostUrl)
{
Query = queryBuilder.ToString(),
};
return(uriBuilder.Uri);
}
/// <summary>
/// Handles the Load event of the MainForm control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void MainForm_Load(object sender, EventArgs e)
{
urlParams = UrlParams.Load();
InitUrls();
// global hot keys
keyboardHook.KeyDown += keyboardHook_KeyDown;
keyboardHook.Start();
SetWindowPosition();
Visible = false;
Hide();
}
/// <summary>
/// Create a new GetRequest.
/// </summary>
/// <param name="urlParams">Template replacements for an API's URL.</param>
/// <param name="headers">HTTP headers to add to the request.</param>
/// <param name="query">Parameters for the query string.</param>
protected GetRestRequest(UrlParams urlParams, HeaderParams headers, QueryParams query) :
base(HttpMethod.Get, urlParams, headers, query, BodyParams.Empty, DataParams.Empty)
{
}
/// <summary>
/// Create a new <see cref="JsonPostRestRequest"/>.
/// </summary>
/// <param name="urlParameters">The URL parameters.</param>
/// <param name="headers">The header parameters.</param>
/// <param name="body">The body parameters.</param>
protected JsonPostRestRequest(UrlParams urlParameters, HeaderParams headers, BodyParams body)
: base(HttpMethod.Post, urlParameters, headers, body)
{
}
public static async Task OnHttpRequest(Microsoft.AspNetCore.Http.HttpContext e)
{
//Authenticate this user using the hostname used. We must use the hostname because that's the most I can change from the Pebble configuration.
UrlParams urlParams = RpwsAuth.DecodeUrlParams.DecodeUrl(e.Request.Host.Host);
//Check the voice token against our database
VoiceToken me = Program.AuthenticateVoiceToken(urlParams.accessToken);
if (me == null)
{
throw new Exception("Invalid access token!");
}
//Grab their user account
VoiceAccount account = RpwsQuota.RpwsVoiceAuth.GetAccount(me.rpws_uid);
//Award new tokens
RpwsQuota.RpwsVoiceAuth.AwardNewCredits(account);
//Send the welcome email if we haven't
/*if(!account.b_has_sent_welcome_email)
* RpwsAuth.EmailService.SendWelcomeEmail(me);
* account.b_has_sent_welcome_email = true;*/
//Save account and log
Console.WriteLine($"Voice request by {account._id}, credits remaining: {account.credits}");
RpwsQuota.RpwsVoiceAuth.SaveAccount(account);
//Stop request if needed
if (account.credits < 1)
{
throw new Exception("Quota reached.");
}
//Pass this into the HTTPDecoder
Tuple <RequestData, List <Stream> > payload = VoiceService.HttpDecoder.DecodeHttpData(e).Result;
RequestData requestConfig = payload.Item1;
//Now, convert this to base64 request
string audioData = VoiceService.SpeexWithHeaderByteConverter.CreateBase64Payload(payload.Item2);
//Now, form a Google request and send it.
GoogleReply textData = await VoiceService.GoogleRequester.DoRequest(audioData, urlParams.languageRegion, Program.config.googleApiKey);
//Now, convert to a fake Nuance response
List <GoogleReply_Result> results = new List <GoogleReply_Result>();
bool ok = true;
if (textData != null)
{
results = textData.results;
ok = false;
}
else
{
ok = textData.results.Count != 0;
}
//Save
account.credits -= 0.5f;
if (ok)
{
account.credits -= 0.5f;
}
RpwsQuota.RpwsVoiceAuth.SaveAccount(account);
//Now, form a reply that the Pebble will be happy with.
NuanceResponse reply = VoiceService.FakeNuanceResponse.ConvertResponse(results, requestConfig);
//Write this out
await VoiceService.NuanceResponder.RespondWithData(e, JsonConvert.SerializeObject(reply));
}
/// <summary>
/// Create a new MultipartRequest.
/// </summary>
/// <param name="method">The HTTP method for this request.</param>
/// <param name="urlParams">Template replacements for an API's URL.</param>
/// <param name="headers">HTTP headers to add to the request.</param>
/// <param name="post">Parameters for the body.</param>
/// <param name="data">File references to be sent as part of the request.</param>
protected MultipartRestRequest(HttpMethod method, UrlParams urlParams, HeaderParams headers, BodyParams post, DataParams data) :
base(method, urlParams, headers, QueryParams.Empty, post, data)
{
}
public HttpResponseMessage GetResponse()
{
#if DEBUG
System.Diagnostics.Debug.WriteLine(FullURL);
#endif
#region Local Variables
WebRequestPostContentType postContentType = PostContentType;
String strPostContent = PostContent;
HttpClient httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(BaseURL);
HttpResponseMessage httpResponse = null;
#endregion Local Variables
#region Resolve Headers
foreach (KeyValuePair <String, String> kvp in Headers)
{
httpClient.DefaultRequestHeaders.TryAddWithoutValidation(kvp.Key, kvp.Value);
}
#endregion Resolve Headers
#region Resolve URL Path
String strParam = URLParamsString;
RequestPath = RequestPath.Replace('\\', '/');
String urlPath = string.Format("{0}{1}{2}{3}", RequestPath, RequestPath.EndsWith("/") || strParam == "" ? "" : "/", strParam != "" ? "?" : "", strParam);
#endregion Resolve URL Path
switch (RequestType)
{
case WebRequestType.GET_OFFSET:
case WebRequestType.GET_PAGE:
case WebRequestType.POST_OFFSET:
case WebRequestType.POST_PAGE:
Int32 limit = 100, offset = 0, page = 0, maxPages = 20, maxChildren = 0;
JObject jObjectMerged = new JObject(), jObjectTemp;
Dictionary <string, string> dictPostContent = null; //Used for POST_OFFSET and POST_PAGE
#region Initialization by Request Type
switch (RequestType)
{
case WebRequestType.GET_OFFSET:
if (UrlParams.ContainsKey(LimitField))
{
Int32.TryParse(UrlParams[LimitField], out limit);
}
else
{
UrlParams.Add(LimitField, limit.ToString());
}
if (UrlParams.ContainsKey(OffsetField))
{
Int32.TryParse(UrlParams[OffsetField], out offset);
}
else
{
UrlParams.Add(OffsetField, offset.ToString());
}
break;
case WebRequestType.GET_PAGE:
if (UrlParams.ContainsKey(LimitField))
{
Int32.TryParse(UrlParams[LimitField], out limit);
}
else
{
UrlParams.Add(LimitField, limit.ToString());
}
if (UrlParams.ContainsKey(PageField))
{
Int32.TryParse(UrlParams[PageField], out page);
}
else
{
UrlParams.Add(PageField, page.ToString());
}
break;
case WebRequestType.POST_OFFSET:
dictPostContent = new Dictionary <string, string>
{
{ LimitField, Limit.ToString() },
{ OffsetField, offset.ToString() }
};
break;
case WebRequestType.POST_PAGE:
dictPostContent = new Dictionary <string, string>
{
{ LimitField, Limit.ToString() },
{ PageField, page.ToString() }
};
break;
}
#endregion Initialization by Request Type
do
{
#region Loop Initialization
switch (RequestType)
{
case WebRequestType.GET_OFFSET:
UrlParams[OffsetField] = offset.ToString();
break;
case WebRequestType.GET_PAGE:
UrlParams[PageField] = page.ToString();
break;
case WebRequestType.POST_OFFSET:
dictPostContent[OffsetField] = offset.ToString();
break;
case WebRequestType.POST_PAGE:
dictPostContent[PageField] = page.ToString();
break;
}
#endregion Loop Initialization
strParam = URLParamsString;
urlPath = string.Format("{0}{1}{2}{3}", RequestPath, RequestPath.EndsWith("/") ? "" : "/", strParam != "" ? "?" : "", strParam);
#region Get the Response by Request Type
switch (RequestType)
{
case WebRequestType.GET_OFFSET:
case WebRequestType.GET_PAGE:
httpResponse = httpClient.GetAsync(urlPath).Result;
break;
case WebRequestType.POST_OFFSET:
case WebRequestType.POST_PAGE:
FormUrlEncodedContent postContent = new FormUrlEncodedContent(dictPostContent);
httpResponse = httpClient.PostAsync(urlPath, postContent).Result;
break;
}
#endregion Get the Response by Request Type
#region Break out if StatusCode is not OK
if (httpResponse.StatusCode != HttpStatusCode.OK)
{
break;
}
#endregion Break out if StatusCode is not OK
String strResponse = httpResponse.Content.ReadAsStringAsync().Result;
if (strResponse.StartsWith("[") && strResponse.EndsWith("]"))
{
strResponse = $"{{\"root\":{strResponse}}}";
}
jObjectTemp = JObject.Parse(strResponse);
IEnumerable <JToken> allTokens = jObjectTemp.SelectTokens("*");
maxChildren = allTokens.Select(t => t.Count()).Max();
jObjectMerged.Merge(jObjectTemp);
page++;
offset += limit;
} while (maxChildren > 1 && maxChildren >= limit && page <= maxPages);
httpResponse.Content = new StringContent(jObjectMerged.ToString(), Encoding.UTF8, "application/json");
break;
case WebRequestType.CANCEL:
httpClient.CancelPendingRequests();
break;
case WebRequestType.DELETE:
httpResponse = httpClient.DeleteAsync(urlPath).Result;
break;
case WebRequestType.GET:
default:
httpResponse = httpClient.GetAsync(urlPath).Result;
break;
case WebRequestType.POST:
case WebRequestType.PUT:
case WebRequestType.SEND:
#region Resolve MediaType
String mediaType;
switch (postContentType)
{
case WebRequestPostContentType.STRING:
case WebRequestPostContentType.FORM_URL_ENCODED:
default:
mediaType = "text/plain";
break;
case WebRequestPostContentType.JSON:
mediaType = "application/json";
break;
case WebRequestPostContentType.XML:
case WebRequestPostContentType.SOAP:
case WebRequestPostContentType.SOAP_STRING:
mediaType = "text/xml";
break;
}
#endregion Resolve MediaType
#region Resolve Content
HttpContent content;
switch (postContentType)
{
case WebRequestPostContentType.XML:
case WebRequestPostContentType.JSON:
case WebRequestPostContentType.STRING:
default:
content = new StringContent(strPostContent, Encoding.UTF8, mediaType);
break;
case WebRequestPostContentType.FORM_URL_ENCODED:
Dictionary <String, String> formData = strPostContent.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries)
.Select(part => part.Split('='))
.ToDictionary(split => split[0], split => split[1]);
content = new FormUrlEncodedContent(formData);
break;
case WebRequestPostContentType.SOAP:
case WebRequestPostContentType.SOAP_STRING:
content = new StringContent(String.Format(@"<?xml version=""1.0"" encoding=""utf-8""?>
<s:Envelope xmlns:s=""http://schemas.xmlsoap.org/soap/envelope/"">
<s:Body>
{0}
</s:Body>
</s:Envelope>", strPostContent), Encoding.UTF8, mediaType);
break;
}
#endregion Resolve Content
switch (RequestType)
{
case WebRequestType.POST:
httpResponse = httpClient.PostAsync(urlPath, content).Result;
break;
case WebRequestType.PUT:
httpResponse = httpClient.PutAsync(urlPath, content).Result;
break;
case WebRequestType.SEND:
HttpRequestMessage httpContent = new HttpRequestMessage(HttpMethod.Post, urlPath)
{
Content = content, Version = HttpVersion.Version11
};
httpResponse = httpClient.SendAsync(httpContent).Result;
break;
}
break;
}
return(httpResponse);
}
/// <summary>
/// Create a new REST request whose body is a JSON object containing the parameters.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="urlParameters">The URL parameters.</param>
/// <param name="headers">The header parameters.</param>
/// <param name="body">The body parameters.</param>
protected JsonRestRequest(HttpMethod method, UrlParams urlParameters, HeaderParams headers, BodyParams body)
: base(method, urlParameters, headers, QueryParams.Empty, body, DataParams.Empty)
{
}
/// <summary>
/// Create a new multipart POST request.
/// </summary>
/// <param name="urlParams">The parameters in the URL.</param>
/// <param name="headerParams">The parameters in the HTTP headerParams.</param>
/// <param name="bodyParams">The parameters in the HTTP body.</param>
/// <param name="dataParams">The data parameters.</param>
protected MultipartPostRestRequest(UrlParams urlParams, HeaderParams headerParams, BodyParams bodyParams, DataParams dataParams)
: base(HttpMethod.Post, urlParams, headerParams, bodyParams, dataParams) { }
