public Task <JsonResult> WithingsAuth(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "withings/auth")] HttpRequest req,
[HttpBody(Required = true)] HttpParam <AuthDto> authDto,
[HttpHeader(Name = "Authorization")] HttpParam <string> authorization,
CancellationToken cancellationToken)
{
return(exceptionFilter.FilterExceptions(async() =>
{
var withingsAccessCode = authDto.Value.WithingsAccessCode;
var withingsRedirectUri = authDto.Value.WithingsRedirectUri;
var(userId, _, _) = await auth.ValidateUser(authorization, cancellationToken);
var consent = await consentStore.FetchConsent(userId, cancellationToken);
var newWithingsUserId = await withingsClient.CreateAccount(userId, withingsAccessCode, withingsRedirectUri, cancellationToken);
if (consent == null || !consent.ExternalIds.TryGetValue(withingsToFhirConverter.System, out var withingsUserId) || withingsUserId != newWithingsUserId)
{
consent ??= ConsentFactory.WithId(userId);
consent.ExternalIds[withingsToFhirConverter.System] = newWithingsUserId;
await consentStore.WriteConsent(consent, cancellationToken);
}
return new JsonResult(await userFactory.CreateUser(consent, jobId: null, cancellationToken));
}));
}
public static async Task <IActionResult> GetReplays(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "replays")] HttpRequest req,
[HttpQuery] HttpParam <int> skip,
[HttpQuery] HttpParam <int> limit,
[HttpQuery] HttpParam <string> orderBy,
[HttpQuery] HttpParam <bool> descending,
[HttpQuery] HttpParam <string> name,
[HttpQuery] HttpParam <string> playerName,
[HttpQuery] HttpParam <string> playerUserId,
[HttpQuery] HttpParam <string> map,
[HttpQuery] HttpParam <string> gameMode,
[HttpQuery] HttpParam <int?> nbMaxPlayer,
[HttpQuery] HttpParam <string> victoryCond,
[HttpQuery] HttpParam <int?> incomeRate,
[HttpQuery] HttpParam <int?> initMoney,
[HttpQuery] HttpParam <bool?> rankedMatchesOnly,
[Inject] IMediator mediator,
ILogger log)
{
var result = await mediator.Send(new GetReplayList()
{
Descending = descending, Limit = limit, OrderBy = orderBy, Skip = skip, Query = new GetReplayList.ReplayQuery()
{
GameMode = gameMode, IncomeRate = incomeRate, InitMoney = initMoney, Map = map, Name = name, NbMaxPlayer = nbMaxPlayer,
PlayerName = playerName, PlayerUserId = playerUserId, RankedMatchesOnly = rankedMatchesOnly, VictoryCond = victoryCond
}
});
return(new OkObjectResult(result));
}
public async Task <JsonResult> WithingsCallback(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = CallbackUrl)] HttpRequest req,
[HttpForm(Name = "userid")] HttpParam <int?> withingsUserId,
[HttpForm(Name = "deviceid")] HttpParam <int?> withingsDeviceId,
[HttpForm(Name = "appli")] HttpParam <int?> notificationCategory,
[HttpForm(Name = "startdate")] HttpParam <long?> startDateEpoch,
[HttpForm(Name = "enddate")] HttpParam <long?> endDateEpoch,
[HttpForm(Name = "date")] HttpParam <string> dataOrEventDate,
[HttpForm(Name = "action")] HttpParam <string> action)
{
if (withingsUserId.Value == null || notificationCategory.Value == null || startDateEpoch.Value == null || endDateEpoch.Value == null)
{
log.LogWarning("Skipping Withings notification with missing fields: userid={userid} appli={appli} startdate={startdate} enddate={enddate} deviceid={deviceid} date={date} action={action}", withingsUserId, notificationCategory, startDateEpoch, endDateEpoch, withingsDeviceId, dataOrEventDate, action);
return(new JsonResult("Missing fields"));
}
log.LogInformation("Got Withings notification: userid={userid} appli={appli} startdate={startdate} enddate={enddate}", withingsUserId, notificationCategory, startDateEpoch, endDateEpoch);
await queue.SendMessage(Jobs.NotificationQueueName, new CallbackReceivedMessage
{
WithingsUserId = withingsUserId.Value.Value,
StartDateEpoch = startDateEpoch.Value.Value,
EndDateEpoch = endDateEpoch.Value.Value,
});
return(new JsonResult("Ok"));
}
static void UploadFiles()
{
//string url = "http://*****:*****@"E:\Harbour\150426001201-1.jpg", @"E:\Harbour\150426001201-4.jpg" };
foreach (string fileUrl in filePath)
{
FileInfo fileInfo = new FileInfo(fileUrl);
UploadFileParams uploadFileParams = new UploadFileParams();
uploadFileParams.FileName = fileInfo.Name;
uploadFileParams.FileStream = fileInfo.OpenRead();
httpParam.UploadFiles.Add(uploadFileParams);
}
var sdfs = HttpUtils.Post(httpParam);
}
public static async Task <IActionResult> HttpExtensionsBody4(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
[HttpBody(Required = true)] HttpParam <XmlDocument> body,
ILogger log)
{
return(new OkResult());
}
public static async Task <IActionResult> HttpExtensionsQueryParams3(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
[HttpQuery] HttpParam <Dog> queryParam,
ILogger log)
{
return(new OkResult());
}
public int DeleteFolder(int id)
{
var folder = _fileServices.GetFolderById(id);
if (folder.IsNull())
{
return(-1);
}
var content = new MultipartFormDataContent();
content.Add(new StringContent(folder.Url), "url");
var param = new HttpParam();
param.Content = content;
param.Type = Common.Http.HttpMethod.DELETE.ToString();
var result = HttpRequest.Send <ResponseFileResult>(param);
if (result.IsSuccess)
{
return(_fileServices.DeleteFolder(id));
}
return(-1);
}
public static async Task <IActionResult> HttpExtensionsQueryParams1(
[HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = null)] HttpRequest req,
[HttpQuery("qp", Required = true)] HttpParam <string> queryParam,
ILogger log)
{
return(new OkResult());
}
public static async Task <IActionResult> HttpExtensionsForm2(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
[HttpForm(Required = true)] HttpParam <Dog> formField,
ILogger log)
{
return(new OkResult());
}
public Task <JsonResult> DeleteUser(
[HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "user")] HttpRequest req,
[HttpHeader(Name = "Authorization")] HttpParam <string> authorization,
[DurableClient] IDurableOrchestrationClient jobClient,
CancellationToken cancellationToken)
{
return(exceptionFilter.FilterExceptions(async() =>
{
var(userId, _, _) = await auth.ValidateUser(authorization, cancellationToken);
var jobId = await jobClient.RunSingleton(
userId,
workflow: nameof(AccountDeletionJob.AccountDeletionWorkflow),
jobArguments: new StartAccountDeletionMessage
{
UserId = userId,
},
log,
guidFactory);
return new JsonResult(new UserDeletion
{
JobId = jobId,
})
{
StatusCode = (int?)HttpStatusCode.Accepted,
};
}));
}
public static async Task <IActionResult> HttpExtensionsHeaders2(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
[HttpHeader(Name = "x-header", Required = true)] HttpParam <Dog> header,
ILogger log)
{
return(new OkResult());
}
public string PostHelper(HttpParam hp)
{
HttpWebResponse response = HttpTools.CreatePostHttpResponse(hp.Url, hp.myParam, Encoding.GetEncoding("utf-8"));
string sc = response.StatusCode.ToString();
Stream stream = response.GetResponseStream(); //获取响应的字符串流
StreamReader sr = new StreamReader(stream); //创建一个stream读取流
string html = sr.ReadToEnd(); //从头读到尾，放到字符串html
return(html);
}
public static async Task <IActionResult> Headers(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[FromHeader("x-my-header")] HttpParam <string> hdr,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
log.LogInformation($"{hdr.Value}");
return(new OkObjectResult(""));
}
public async Task <IActionResult> GetDeliveryFee(
[HttpTrigger(AuthorizationLevel.Function, "get")]
HttpRequest req,
[HttpQuery] HttpParam <decimal> cartTotal,
ILogger log,
CancellationToken cancellationToken)
{
var quoteModel = await _mediator.Send(new GetDeliveryFeeQuery { CartTotal = cartTotal }, cancellationToken);
return(new OkObjectResult(quoteModel));
}
public static async Task <IActionResult> Hello(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "hello")] HttpRequest req,
[HttpQuery(Required = true)] HttpParam <string> name,
[HttpQuery(Required = true)] HttpParam <int> age,
ILogger log)
{
return(new OkObjectResult(new MyResponse()
{
Message = $"Hello {name}, {age} is a nice age!"
}));
}
/// <summary>
/// 传入Code
/// </summary>
public static Dictionary<string, string> GetOauth2AccessToken(UserParam param)
{
var param2 = new HttpParam()
{
{"appid",GetConfig.GetAppid(param)},
{"secret", GetConfig.GetSecret(param)},
{"code", param.Code},
{"grant_type", "authorization_code"}
};
var dic = HttpHelper.Get<Dictionary<string, string>>(ApiList.GetOauth2AccessTokenUrl, param2);
return dic;
}
/// <summary>
/// 传入Code
/// </summary>
public static Dictionary <string, string> GetOauth2AccessToken(UserParam param)
{
var param2 = new HttpParam()
{
{ "appid", GetConfig.GetAppid(param) },
{ "secret", GetConfig.GetSecret(param) },
{ "code", param.Code },
{ "grant_type", "authorization_code" }
};
var dic = HttpHelper.Get <Dictionary <string, string> >(ApiList.GetOauth2AccessTokenUrl, param2);
return(dic);
}
public async Task <IActionResult> GetMonthlyPremium(
[HttpTrigger(AuthorizationLevel.Function, "get")]
HttpRequest req,
[HttpQuery] HttpParam <decimal> coverAmount,
[HttpQuery] HttpParam <int> occupationId,
[HttpQuery] HttpParam <decimal> age,
ILogger log,
CancellationToken cancellationToken)
{
var occupations = await _mediator.Send(new GetMonthlyPremiumQuery
{ CoverAmount = coverAmount, OccupationId = occupationId, Age = age }, cancellationToken);
return(new OkObjectResult(occupations));
}
public Task <JsonResult> GetUser(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "user")] HttpRequest req,
[HttpHeader(Name = "Authorization")] HttpParam <string> authorization,
CancellationToken cancellationToken)
{
return(exceptionFilter.FilterExceptions(async() =>
{
var(userId, _, _) = await auth.ValidateUser(authorization, cancellationToken);
var consent = await consentStore.FetchConsent(userId, cancellationToken);
consent = consent.Verify(userId, ignoreFhir: true);
return new JsonResult(await userFactory.CreateUser(consent, jobId: null, cancellationToken));
}));
}
/// <summary>
/// Http请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="body">Http Body</param>
/// <returns>返回请求响应结果</returns>
public static HttpResult Request(HttpParam httpParam, Stream body)
{
if (httpParam == null)
{
throw new ArgumentException("httpParam not null");
}
if (string.IsNullOrWhiteSpace(httpParam.URL))
{
throw new ArgumentException("url not null");
}
if (body == null || body == Stream.Null)
{
throw new ArgumentException("body not null");
}
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
{
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
}
HttpWebRequest request = null;
try {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
var requestStream = request.GetRequestStream();
//写入body
CopyStream(body, requestStream);
return(Process((HttpWebResponse)request.GetResponse()));
} catch (WebException exception) {
if (request != null)
{
request.Abort();
}
//LogContext.GetLogger<HttpRequest>().Error(exception.Message, exception);
return(new HttpResult {
Exception = exception, IsFaulted = true
});
} finally {
body.Close();
}
}
public static async Task <IActionResult> QueryParams(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[FromQuery(Required = true)] HttpParam <int> number,
[FromQuery] HttpParam <List <long> > numberList,
[FromQuery] HttpParam <string> str,
[FromQuery] HttpParam <List <string> > strList,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
log.LogInformation($"{number.Value}");
log.LogInformation($"{numberList.Value}");
log.LogInformation($"{str.Value}");
log.LogInformation($"{strList.Value}");
return(new OkObjectResult(""));
}
public async Task <IActionResult> GetStaticSearchResult(
[HttpTrigger(AuthorizationLevel.Function, "get")]
HttpRequest req,
[HttpQuery] HttpParam <string> searchFor,
[HttpQuery] HttpParam <string> searchInUrl,
[HttpQuery] HttpParam <string> urlOfInterest,
CancellationToken cancellationToken)
{
var response = await _mediator.Send(new GetStaticSearchResultQuery
{
SearchFor = searchFor,
SearchInUrl = searchInUrl,
UrlOfInterest = urlOfInterest
});
return(new OkObjectResult(response));
}
private string SendWebCms(WebCmsSendModel webCmsSendModel)
{
var webCmsAddress = WebConfigurationManager.AppSettings["WebCmsAddress"];
var values = GetSendContent(webCmsSendModel);
var httpParam = new HttpParam()
{
IsUseBase = false,
Method = Common.Http.HttpMethod.POST,
Content = new StringContent(values.Select(value => $"{value.Key}={value.Value}").JoinString("&"), System.Text.Encoding.GetEncoding("GB2312")),
Url = webCmsAddress,
Type = ContentType.FORM_DATA
};
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", Request.Url.Authority.GetMd5Str());
return(HttpRequest.Send(httpParam, httpClient: httpClient));
}
/// <summary>
/// 查询菜单。
/// 取公众号菜单，不需要传入参数。若是开放平台，则需要传入AuthorizerAppid(授权方appid)、AuthorizerRefreshToken（授权方的刷新令牌）、ComponentVerifyTicket(微信后台推送的ticket，此ticket会定时推送)
/// </summary>
/// <returns></returns>
public static MenuResult Get(WeChatParam param = null)
{
//var menuObj = new { menu = new MenuResult() };
var httpParam = new HttpParam();
var aToken = "";
if (param != null && param.WeChatType == EnumHelper.WeChatType.Open)
{
var bs = TokenHelper.GetAuthorizerAccessToken(param);
if (!bs.IsSuccess)
{
return(new MenuResult()
{
IsSuccess = false,
ErrMsg = bs.ErrMsg
});
}
aToken = bs.AuthorizerAccessToken;
}
else
{
var bs = TokenHelper.GetAccessToken();
if (!bs.IsSuccess)
{
return(new MenuResult()
{
IsSuccess = false,
ErrMsg = bs.ErrMsg
});
}
aToken = bs.AccessToken;
}
string json = HttpHelper.Get(ApiList.MenuGetUrl, new { access_token = aToken });
//var or = JsonConvert.DeserializeAnonymousType(json, menuObj);
var or = JSON.ToObject <menuObj>(json);//, menuObj
var result = or.menu;
if (result == null)
{
var retTemp = JSON.ToObject <MenuResult>(json);
return(retTemp);
}
return(result);
}
/// <summary>
///
/// </summary>
public RemoteMedia Upload(LocalMedia media)
{
var checkRet = Check(media);
if (!checkRet.IsSuccess)
throw new WxException(-9999, checkRet.ErrMsg);
var param = new HttpParam
{
{"access_token", Token.GetAccessToken(media)},
{"type", media.MediaType}
};
var rs = HttpHelper.Upload(ApiList.MediaUploadUrl, param, media.MediaPath);
var result = JsonConvert.DeserializeObject<RemoteMedia>(rs);
if (string.IsNullOrEmpty(result.MediaID))
{
var ex = JsonConvert.DeserializeObject<WeChatResult>(rs);
throw new WxException(ex);
}
return result;
}
static void Login()
{
//string url = "http://localhost:8643/login";
string url = "http://39.155.251.32:8643/login";
string param = $"userName=admin&password=admin";
HttpParam httpParam = new HttpParam();
httpParam.Url = url;
httpParam.ContentType = "multipart/form-data";
NameValueCollection nameValues = new NameValueCollection();
nameValues.Add("userName", "admin");
nameValues.Add("password", "admin");
httpParam.RequestParameters = nameValues;
var fsds = HttpUtils.Post(httpParam);
}
public Task <JsonResult> GetJobStatus(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "jobs")] HttpRequest req,
[HttpQuery(Required = true)] HttpParam <string> jobId,
[HttpHeader(Name = "Authorization")] HttpParam <string> authorization,
[DurableClient] IDurableOrchestrationClient orchestrationClient,
CancellationToken cancellationToken)
{
return(exceptionFilter.FilterExceptions(async() =>
{
var(userId, _, _) = await auth.ValidateUser(authorization, cancellationToken);
log.LogInformation("Fetching status of job {jobId} for user {userId}", jobId, userId);
var status = await orchestrationClient.GetStatusAsync(jobId);
log.LogInformation("Fetched status of job {jobId} for user {userId}", jobId, userId);
return new JsonResult(new JobStatus
{
Status = status.RuntimeStatus,
});
}));
}
public Task <JsonResult> GetObservations(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "observations")] HttpRequest req,
[HttpHeader(Name = "Authorization")] HttpParam <string> authorization,
[HttpQuery] HttpParam <long?> afterEpoch,
[HttpQuery] HttpParam <long?> beforeEpoch,
CancellationToken cancellationToken)
{
return(exceptionFilter.FilterExceptions(async() =>
{
var(userId, _, _) = await auth.ValidateUser(authorization, cancellationToken);
var consent = await consentStore.FetchConsent(userId, cancellationToken);
var observations = await fhirClient.FetchObservations(
userId,
fhirUserId: consent.Verify(userId).FhirId,
after: ToDateTimeOffset(afterEpoch),
before: ToDateTimeOffset(beforeEpoch),
cancellationToken: cancellationToken);
return new JsonResult(observations);
}));
}
public static async Task <IActionResult> PostReplay(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "replay")] HttpRequest req,
[HttpForm(Required = true)] HttpParam <string> name,
[HttpForm] HttpParam <string> description,
[HttpForm(Required = true)] HttpParam <IFormFile> file,
[Inject] IMediator mediator,
ILogger log)
{
using (var fileStream = file.Value.OpenReadStream())
{
var replayData = new CreateReplay()
{
Description = description,
Name = name,
File = new CreateReplay.UploadedFile(file.Value.FileName,
file.Value.ContentType,
fileStream)
};
var result = await mediator.Send(replayData);
return(new OkObjectResult(result));
}
}
/// <summary>
/// 传入MediaID，WeChatPublic
/// </summary>
public WeChatResult Download(MediaParam mediaParam)
{
var param = new HttpParam
{
{ "access_token", Token.GetAccessToken(mediaParam) },
{ "media_id", mediaParam.MediaID }
};
var url = string.Format("{0}?{1}", ApiList.MediaGet, param.Format());
var request = HttpHelper.CreateRequest(url);
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
var disposition = response.Headers["Content-disposition"];
if (string.IsNullOrEmpty(disposition))
{
var s = new StreamReader(stream, Encoding.UTF8).ReadToEnd();
return(JsonConvert.DeserializeObject <WeChatResult>(s));
}
var fs = new FileStream(mediaParam.FilePath, FileMode.OpenOrCreate);
try
{
var buffer = new byte[128 * 1024]; //128K
int i;
while ((i = stream.Read(buffer, 0, buffer.Length)) > 0)
{
fs.Write(buffer, 0, i);
}
return(WeChatResult.GetSuccess(mediaParam.FilePath));
}
finally
{
fs.Close();
}
}
}
public async Task <HttpResponseMessage> Upload()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
HttpResponseMessage response = null;
try
{
using (var fileStream = await Request.Content.ReadAsStreamAsync())
{
var content = new MultipartFormDataContent();
var savePath = string.Empty;
content.Add(new StringContent(savePath), nameof(savePath));
content.Add(new StreamContent(fileStream), _uploadName, _uploadName);
var param = new HttpParam();
param.Content = content;
param.Type = Common.Http.HttpMethod.POST.ToString();
param.Url = WebConfigurationManager.AppSettings["FileStorage"];
var result = HttpRequest.Send <ResponseFileResult>(param);
if (!result.IsSuccess)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
response = Request.CreateResponse(HttpStatusCode.Accepted, result);
}
}
catch
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return(response);
}
/// <summary>
///
/// </summary>
public RemoteMedia Upload(LocalMedia media)
{
var checkRet = Check(media);
if (!checkRet.IsSuccess)
{
throw new WxException(-9999, checkRet.ErrMsg);
}
var param = new HttpParam
{
{ "access_token", Token.GetAccessToken(media) },
{ "type", media.MediaType }
};
var rs = HttpHelper.Upload(ApiList.MediaUploadUrl, param, media.MediaPath);
var result = JsonConvert.DeserializeObject <RemoteMedia>(rs);
if (string.IsNullOrEmpty(result.MediaID))
{
var ex = JsonConvert.DeserializeObject <WeChatResult>(rs);
throw new WxException(ex);
}
return(result);
}
/// <summary>
/// 传入MediaID，WeChatPublic
/// </summary>
public WeChatResult Download(MediaParam mediaParam)
{
var param = new HttpParam
{
{"access_token", Token.GetAccessToken(mediaParam)},
{"media_id", mediaParam.MediaID}
};
var url = string.Format("{0}?{1}", ApiList.MediaGet, param.Format());
var request = HttpHelper.CreateRequest(url);
var response = request.GetResponse();
using (var stream = response.GetResponseStream())
{
var disposition = response.Headers["Content-disposition"];
if (string.IsNullOrEmpty(disposition))
{
var s = new StreamReader(stream, Encoding.UTF8).ReadToEnd();
return JsonConvert.DeserializeObject<WeChatResult>(s);
}
var fs = new FileStream(mediaParam.FilePath, FileMode.OpenOrCreate);
try
{
var buffer = new byte[128 * 1024]; //128K
int i;
while ((i = stream.Read(buffer, 0, buffer.Length)) > 0)
{
fs.Write(buffer, 0, i);
}
return WeChatResult.GetSuccess(mediaParam.FilePath);
}
finally
{
fs.Close();
}
}
}
/// <summary>
/// Http请求发送文件
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="files">文件上传的信息</param>
/// <returns>返回请求响应结果</returns>
public static HttpResult Request(HttpParam httpParam, NamedFileStream[] files)
{
if (httpParam == null) {
throw new ArgumentException("httpParam not null");
}
if (httpParam.Method != HttpVerb.Post && httpParam.Method != HttpVerb.Put) {
throw new ArgumentException("Request method must be POST or PUT");
}
if (string.IsNullOrWhiteSpace(httpParam.URL)) {
throw new ArgumentException("url not null");
}
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
Encoding encoding = DefaultEncoding;
if (httpParam.Encoding != null)
encoding = httpParam.Encoding;
if (files.Length == 0)
throw new ArgumentException("files is empty");
HttpWebRequest request = null;
//设置分界线
string boundary = RandomString(12);
try {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
request.ContentType = "multipart/form-data; boundary=" + boundary;
var requestStream = request.GetRequestStream();
//转化网络流对象进行直接射入，省内存
using (StreamWriter writer = new StreamWriter(requestStream, encoding)) {
try {
IDictionary postbody = SerializeQuery(httpParam.Parameters);
string newLine = "\r\n";
//处理form-data
if (postbody != null) {
foreach (string key in postbody.Keys) {
if (postbody[key] != null) {
writer.Write("--" + boundary + newLine);
writer.Write("Content-Disposition: form-data; name=\"{0}\"{1}{1}", key, newLine);
writer.Write(postbody[key] + newLine);
writer.Flush();
}
}
}
//处理文件
foreach (var file in files) {
writer.Write("--" + boundary + newLine);
writer.Write(
"Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"{2}",
file.Name,
file.FileName,
newLine
);
writer.Write("Content-Type: application/octet-stream" + newLine + newLine);
writer.Flush();
//复制文件流到Body
CopyStream(file.Stream, requestStream);
writer.Write(newLine);
writer.Write("--" + boundary + newLine);
writer.Flush();
}
} catch (Exception ex) {
requestStream.Dispose();
//LogContext.GetLogger<HttpRequest>().Error(ex.Message, ex);
return new HttpResult { Exception = ex, IsFaulted = true };
} finally {
//使用完后释放
foreach (var file in files) {
if (file.Stream != null)
file.Stream.Dispose();
}
}
}
return Process((HttpWebResponse)request.GetResponse());
} catch (WebException exception) {
if (request != null)
request.Abort();
//遇到异常时候再次释放一次，防止内存泄漏
foreach (var file in files) {
if (file.Stream != null)
file.Stream.Dispose();
}
//LogContext.GetLogger<HttpRequest>().Error(exception.Message, exception);
return new HttpResult { Exception = exception, IsFaulted = true };
}
}
/// <summary>
/// Http请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <returns>返回请求响应结果</returns>
public static HttpResult Request(HttpParam httpParam)
{
if (httpParam == null) {
throw new ArgumentException("httpParam not null");
}
if (string.IsNullOrWhiteSpace(httpParam.URL)) {
throw new ArgumentException("url not null");
}
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
HttpWebRequest request = null;
Encoding encoding = DefaultEncoding;
if (httpParam.Encoding != null)
encoding = httpParam.Encoding;
try {
if (httpParam.Method == HttpVerb.Delete || httpParam.Method == HttpVerb.Post || httpParam.Method == HttpVerb.Put || httpParam.Method == HttpVerb.Patch) {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
var requestStream = request.GetRequestStream();
//转化网络流对象进行直接射入，省内存
using (StreamWriter writer = new StreamWriter(requestStream, encoding)) {
try {
//序列化参数
string postbody = SerializeQueryString(httpParam.Parameters);
writer.Write(postbody);
writer.Flush();
} catch (Exception ex) {
writer.Dispose();
//LogContext.GetLogger<HttpRequest>().Error(ex.Message, ex);
return new HttpResult { Exception = ex, IsFaulted = true };
}
}
return Process((HttpWebResponse)request.GetResponse());
} else {
if (httpParam.Parameters != null) {
//处理URL参数并接
//src index?id=1 dest index?id=1&age=21
//src index dest index?id=1
UriBuilder b = new UriBuilder(httpParam.URL);
if (!string.IsNullOrWhiteSpace(b.Query)) {
b.Query = b.Query.Substring(1) + "&" + SerializeQueryString(httpParam.Parameters);
} else {
b.Query = SerializeQueryString(httpParam.Parameters);
}
httpParam.URL = b.Uri.ToString();
}
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
return Process((HttpWebResponse)request.GetResponse());
}
} catch (WebException exception) {
if (request != null)
request.Abort();
//LogContext.GetLogger<HttpRequest>().Error(exception.Message, exception);
return new HttpResult { Exception = exception, IsFaulted = true };
}
}
/// <summary>
/// Http请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="body">Http Body</param>
/// <returns>返回请求响应结果</returns>
public static HttpResult Request(HttpParam httpParam, Stream body)
{
if (httpParam == null) {
throw new ArgumentException("httpParam not null");
}
if (string.IsNullOrWhiteSpace(httpParam.URL)) {
throw new ArgumentException("url not null");
}
if (body == null || body == Stream.Null)
throw new ArgumentException("body not null");
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
HttpWebRequest request = null;
try {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
var requestStream = request.GetRequestStream();
//写入body
CopyStream(body, requestStream);
return Process((HttpWebResponse)request.GetResponse());
} catch (WebException exception) {
if (request != null)
request.Abort();
//LogContext.GetLogger<HttpRequest>().Error(exception.Message, exception);
return new HttpResult { Exception = exception, IsFaulted = true };
} finally {
body.Close();
}
}
/// <summary>
/// Http异步请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="body">Http Body</param>
/// <param name="callback">返回请求响应结果回调</param>
/// <param name="userState">状态</param>
public static void Request(HttpParam httpParam, Stream body, Action<HttpResult, object> callback, object userState)
{
Request(httpParam, body, (result) => callback(result, userState));
}
/// <summary>
/// Http异步请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="callback">返回请求响应结果回调</param>
public static void Request(HttpParam httpParam, Action<HttpResult> callback)
{
if (httpParam == null) {
throw new ArgumentException("httpParam not null");
}
if (string.IsNullOrWhiteSpace(httpParam.URL)) {
throw new ArgumentException("url not null");
}
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
HttpWebRequest request = null;
Encoding encoding = DefaultEncoding;
if (httpParam.Encoding != null)
encoding = httpParam.Encoding;
try {
if (httpParam.Method == HttpVerb.Delete || httpParam.Method == HttpVerb.Post || httpParam.Method == HttpVerb.Put || httpParam.Method == HttpVerb.Patch) {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
//开始异步请求
request.BeginGetRequestStream(new AsyncCallback((callbackResult) =>
{
HttpWebRequest _request = (HttpWebRequest)callbackResult.AsyncState;
var requestStream = _request.EndGetRequestStream(callbackResult);
//转化网络流对象进行直接射入，省内存
using (StreamWriter writer = new StreamWriter(requestStream, encoding)) {
try {
string postbody = SerializeQueryString(httpParam.Parameters);
writer.Write(postbody);
writer.Flush();
} catch (Exception ex) {
writer.Dispose();
ProcessFailCallback(callback, ex);
return;
}
}
//异步接收响应，并且设置一个超时时间
IAsyncResult asyncResult = _request.BeginGetResponse(null, _request);
asyncResult.FromAsync((ia, isTimeout) =>
{
if (isTimeout) {
ProcessFailCallback(callback, new TimeoutException("Connection Timeout"));
} else {
ProcessCallback(ia, callback);
}
}, httpParam.Timeout);
}), request);
} else {
//处理URL参数
if (httpParam.Parameters != null) {
UriBuilder b = new UriBuilder(httpParam.URL);
if (!string.IsNullOrWhiteSpace(b.Query)) {
b.Query = b.Query.Substring(1) + "&" + SerializeQueryString(httpParam.Parameters);
} else {
b.Query = SerializeQueryString(httpParam.Parameters);
}
httpParam.URL = b.Uri.ToString();
}
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
IAsyncResult asyncResult = request.BeginGetResponse(null, request);
asyncResult.FromAsync((ia, isTimeout) =>
{
if (isTimeout) {
ProcessFailCallback(callback, new TimeoutException("Connection Timeout"));
} else {
ProcessCallback(ia, callback);
}
}, httpParam.Timeout);
}
} catch (WebException exception) {
if (request != null)
request.Abort();
ProcessFailCallback(callback, exception);
}
}
/// <summary>
/// Http异步请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="files">文件上传的信息</param>
/// <param name="callback">返回请求响应结果回调</param>
public static void Request(HttpParam httpParam, NamedFileStream[] files, Action<HttpResult> callback)
{
if (httpParam == null) {
throw new ArgumentException("httpParam not null");
}
if (httpParam.Method != HttpVerb.Post && httpParam.Method != HttpVerb.Put) {
throw new ArgumentException("Request method must be POST or PUT");
}
if (string.IsNullOrWhiteSpace(httpParam.URL)) {
throw new ArgumentException("url not null");
}
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
Encoding encoding = DefaultEncoding;
if (httpParam.Encoding != null)
encoding = httpParam.Encoding;
if (files.Length == 0)
throw new ArgumentException("files is empty");
HttpWebRequest request = null;
//设置分界线
string boundary = RandomString(12);
try {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
request.ContentType = "multipart/form-data; boundary=" + boundary;
//开始异步请求
request.BeginGetRequestStream(new AsyncCallback((callbackResult) =>
{
HttpWebRequest _request = (HttpWebRequest)callbackResult.AsyncState;
var requestStream = _request.EndGetRequestStream(callbackResult);
//转化网络流对象进行直接射入，省内存
using (StreamWriter writer = new StreamWriter(requestStream, encoding)) {
try {
IDictionary postbody = SerializeQuery(httpParam.Parameters);
string newLine = "\r\n";
//处理form-data
if (postbody != null) {
foreach (string key in postbody.Keys) {
if (postbody[key] != null) {
writer.Write("--" + boundary + newLine);
writer.Write("Content-Disposition: form-data; name=\"{0}\"{1}{1}", key, newLine);
writer.Write(postbody[key] + newLine);
writer.Flush();
}
}
}
//处理文件流
foreach (var file in files) {
writer.Write("--" + boundary + newLine);
writer.Write(
"Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"{2}",
file.Name,
file.FileName,
newLine
);
writer.Write("Content-Type: application/octet-stream" + newLine + newLine);
writer.Flush();
//复制文件流到Body
CopyStream(file.Stream, requestStream);
writer.Write(newLine);
writer.Write("--" + boundary + newLine);
writer.Flush();
}
} catch (Exception ex) {
requestStream.Dispose();
ProcessFailCallback(callback, ex);
return;
} finally {
//使用完后释放
foreach (var file in files)
if (file.Stream != null)
file.Stream.Dispose();
}
}
//异步接收响应，并且设置一个超时时间
IAsyncResult asyncResult = _request.BeginGetResponse(null, _request);
asyncResult.FromAsync((ia, isTimeout) =>
{
if (isTimeout) {
ProcessFailCallback(callback, new TimeoutException("Connection Timeout"));
} else {
ProcessCallback(ia, callback);
}
}, httpParam.Timeout);
}), request);
} catch (WebException exception) {
//遇到异常时候再次释放一次，防止内存泄漏
foreach (var file in files)
if (file.Stream != null)
file.Stream.Dispose();
if (request != null)
request.Abort();
ProcessFailCallback(callback, exception);
}
}
/// <summary>
/// Http异步请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="files">文件上传的信息</param>
/// <param name="callback">返回请求响应结果回调</param>
/// <param name="userState">状态</param>
public static void Request(HttpParam httpParam, NamedFileStream[] files, Action<HttpResult, object> callback, object userState)
{
Request(httpParam, files, (result) => callback(result, userState));
}
/// <summary>
/// 设置请求属性
/// </summary>
/// <param name="request">HttpWebRequest</param>
/// <param name="httpParam">HttpParam</param>
private static void SetRequest(HttpWebRequest request, HttpParam httpParam)
{
// 设置多个证书
if (httpParam.ClentCertificates != null && httpParam.ClentCertificates.Count > 0)
foreach (X509Certificate item in httpParam.ClentCertificates) {
request.ClientCertificates.Add(item);
}
//设置Header参数
if (httpParam.Header != null && httpParam.Header.Count > 0)
foreach (string item in httpParam.Header.AllKeys) {
request.Headers.Add(item, httpParam.Header[item]);
}
// 设置代理
if (httpParam.Proxy != null) {
request.Proxy = httpParam.Proxy;
//设置安全凭证
request.Credentials = CredentialCache.DefaultNetworkCredentials;
}
request.Method = httpParam.Method.ToString();
if (!string.IsNullOrEmpty(httpParam.ContentType))
request.ContentType = httpParam.ContentType;
if (httpParam.Timeout.HasValue)
request.Timeout = Convert.ToInt32(httpParam.Timeout.Value.TotalMilliseconds);
//Accept
request.Accept = httpParam.Accept;
//UserAgent
if (!string.IsNullOrEmpty(httpParam.UserAgent))
request.UserAgent = httpParam.UserAgent;
//Cookie
if (httpParam.CookieCollection != null && httpParam.CookieCollection.Count > 0) {
request.CookieContainer = new CookieContainer();
request.CookieContainer.Add(httpParam.CookieCollection);
}
//来源地址
if (!string.IsNullOrEmpty(httpParam.Referer))
request.Referer = httpParam.Referer;
request.AllowAutoRedirect = false;
request.KeepAlive = false;
//浏览器支持的语言分别是中文和简体中文，优先支持简体中文。
request.Headers.Add("Accept-Language", "zh-CN");
}
/// <summary>
/// Http异步请求发送
/// </summary>
/// <param name="httpParam">请求参数</param>
/// <param name="body">Http Body</param>
/// <param name="callback">返回请求响应结果回调</param>
public static void Request(HttpParam httpParam, Stream body, Action<HttpResult> callback)
{
if (httpParam == null) {
throw new ArgumentException("httpParam not null");
}
if (string.IsNullOrWhiteSpace(httpParam.URL)) {
throw new ArgumentException("url not null");
}
if (body == null || body == Stream.Null)
throw new ArgumentException("body not null");
//使用回调的方法进行证书验证。
if (httpParam.RemoteCertificateValidationCallback != null)
ServicePointManager.ServerCertificateValidationCallback = httpParam.RemoteCertificateValidationCallback;
HttpWebRequest request = null;
try {
request = (HttpWebRequest)HttpWebRequest.Create(new Uri(httpParam.URL));
SetRequest(request, httpParam);
//开始异步请求
request.BeginGetRequestStream(new AsyncCallback((callbackResult) =>
{
HttpWebRequest _request = (HttpWebRequest)callbackResult.AsyncState;
Stream requestStream = _request.EndGetRequestStream(callbackResult);
CopyStream(body, requestStream);//写入Body数据
body.Close();
//异步接收响应，并且设置一个超时时间
IAsyncResult asyncResult = request.BeginGetResponse(null, request);
asyncResult.FromAsync((ia, isTimeout) =>
{
if (isTimeout) {
ProcessFailCallback(callback, new TimeoutException("Connection Timeout"));
} else {
ProcessCallback(ia, callback);
}
}, httpParam.Timeout);
}), request);
} catch (WebException exception) {
if (request != null)
request.Abort();
body.Close();
ProcessFailCallback(callback, exception);
}
}
public HttpTestRequest()
{
_queryString = new HttpInput("QueryString");
_form = new HttpForm();
_param = new HttpParam(_form, _queryString);
}
