public ApiRequestProcessorAttribute(string description, string subUri, ApiHttpMethod method, bool authRequired = true, string remarks = null)
{
Description = description;
SubUri = subUri;
Method = method;
AuthRequired = authRequired;
Remarks = remarks;
}
/// <summary>
/// Post object to web api
/// </summary>
/// <param name="pItem"></param>
/// <param name="url"></param>
/// <param name="apiHttpMethod"></param>
/// <returns></returns>
public async Task <T> PostObject(T pItem, string url, ApiHttpMethod apiHttpMethod)
{
T item = default(T);
using (var client = new HttpClient())
{
string body = string.Empty;
if (apiHttpMethod == ApiHttpMethod.POST ||
apiHttpMethod == ApiHttpMethod.PUT)
{
body = Newtonsoft.Json.JsonConvert.SerializeObject(pItem);
}
HttpContent content = new StringContent(body);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(cntType);
HttpResponseMessage response;
switch (apiHttpMethod)
{
case ApiHttpMethod.POST:
response = client.PostAsync(url, content).Result;
break;
case ApiHttpMethod.PUT:
response = client.PutAsync(url, content).Result;
break;
case ApiHttpMethod.DELETE:
response = client.DeleteAsync(url).Result;
break;
default:
throw new NotSupportedException();
}
if (response.IsSuccessStatusCode)
{
var data = await response.Content.ReadAsStringAsync();
item = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(data);
}
}
return(item);
}
/// <summary>
/// Creates new <see cref="ApiViewAttribute"/> instance
/// </summary>
/// <param name="httpMethod">
/// Target HTTP method(s). One view SHOULD NOT be used for both reads (GET) and writes (PUT,POST).
/// </param>
public ApiViewAttribute(ApiHttpMethod httpMethod)
{
HttpMethod = httpMethod;
}
public static ApiResult <TResult> Call <TResult, TData>(string url, TData data, ApiHttpMethod method = 0, int timeout = 180000, NameValueCollection headers = null)
{
string empty = string.Empty;
ApiResult <TResult> apiResult = new ApiResult <TResult>();
TResult tResult;
JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
try
{
using (var client = new HttpClient())
{
Task <HttpResponseMessage> response = null;
if (method == ApiHttpMethod.POST)
{
HttpContent content = new StringContent(javaScriptSerializer.Serialize(data), Encoding.UTF8, "application/json");
response = client.PostAsync(url, content);
}
else
{
response = client.GetAsync(url);
}
response.Result.EnsureSuccessStatusCode();
apiResult.StatusCode = response.Result.StatusCode;
empty = response.Result.Content.ReadAsStringAsync().Result;
if (typeof(TResult) == typeof(bool))
{
tResult = default(TResult);
apiResult.Result = empty.ToGetValue <TResult>(tResult);
}
else if (!(typeof(TResult) == typeof(string)))
{
apiResult.Result = javaScriptSerializer.Deserialize <TResult>(empty);
}
else
{
tResult = default(TResult);
apiResult.Result = empty.ToGetValue <TResult>(tResult);
}
}
}
catch (Exception ex)
{
apiResult.ExceptionMessage = ex.Message;
DebugUtil.LogException(ex);
DebugUtil.CollectDebugInfo(ex, "TGOP.Foundation.Common.ProxyBase.Call");
}
return(apiResult);
}
public static ApiResult <TResult> Call <TResult, TData>(string domain, string controller, string action, TData data, ApiHttpMethod method = 0, int timeout = 180000)
{
domain = domain.TrimEnd('/') + "/";
ApiResult <TResult> apiResult = ProxyBase.Call <TResult, TData>(string.Format("{0}{1}/{2}", domain, controller, action), data, method, timeout, null);
return(apiResult);
}
