/// <summary>
/// The WriteJsonAsync.
/// </summary>
/// <param name="response">The response<see cref="Microsoft.AspNetCore.Http.HttpResponse"/>.</param>
/// <param name="json">The json<see cref="string"/>.</param>
/// <param name="contentType">The contentType<see cref="string"/>.</param>
/// <returns>The <see cref="Task"/>.</returns>
public static async Task WriteJsonAsync(this Microsoft.AspNetCore.Http.HttpResponse response, string json, string contentType = null)
{
response.ContentType = (contentType ?? "application/json; charset=UTF-8");
await response.WriteAsync(json);
await response.Body.FlushAsync();
}
public Response(IRequestContext requestContext, HttpContext context)
{
this.res = context.Response;
this.baseBody = context.Response.Body;
this.Context = requestContext;
this.Headers = new Headers(context.Response.Headers);
}
static public void AssignPlayerCookies(CreateGameModel model, Microsoft.AspNetCore.Http.HttpResponse Response)
{
CookieOptions cookie = new CookieOptions();
cookie.Expires = DateTime.Now.AddHours(1);
Response.Cookies.Append("gameid", model.GameId.ToString(), cookie);
}
private async Task <string> FormatResponse(Microsoft.AspNetCore.Http.HttpResponse response)
{
var text = string.Empty;
if (response.StatusCode == (int)HttpStatusCode.OK)
{
response.Body.Seek(0, SeekOrigin.Begin);
text = await new StreamReader(response.Body).ReadToEndAsync();
response.Body.Seek(0, SeekOrigin.Begin);
}
else if (response.StatusCode == (int)HttpStatusCode.Unauthorized)
{
text = "Not Authorized";
}
else if (response.StatusCode == (int)HttpStatusCode.Forbidden)
{
if (response.HttpContext.User.Identity.IsAuthenticated)
{
text = "Authenticated but Forbidden";
}
else
{
text = "Not Authorized";
}
}
return($"Response {text}");
}
/// <summary>
/// 覆盖 JsonResult 的方法；
/// </summary>
/// <param name="context"></param>
public override void ExecuteResult(ControllerContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
HttpResponseBase response = context.HttpContext.Response;
if (!string.IsNullOrEmpty(this.ContentType))
{
response.ContentType = this.ContentType;
}
else
{
response.ContentType = "application/json";
}
var data = this.GetJsonResultValue();
if (data != null)
{
IsoDateTimeConverter timeConvert = new IsoDateTimeConverter();
timeConvert.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
string content = "";
if (data is SerializeToJson)
{
content = ((SerializeToJson)data).SerializeToJson();
}
else
{
content = JsonConvert.SerializeObject(content, Newtonsoft.Json.Formatting.None, timeConvert);
}
response.Write(content);
}
}
public static void WriteJson <T>(this Microsoft.AspNetCore.Http.HttpResponse response, T obj, string contentType = null)
{
response.ContentType = contentType ?? "application/json";
var json = JsonSerializer.Serialize(obj, obj.GetType());
response.WriteAsync(json, Encoding.UTF8);
}
public ExtractedResponse(HttpResponse response)
{
using (var reader = new StreamReader(response.Body))
{
Body = reader.ReadToEnd();
}
StatusCode = (HttpStatusCode)response.StatusCode;
}
public static void ApagaCookie(Microsoft.AspNetCore.Http.HttpResponse response, Microsoft.AspNetCore.Http.HttpRequest request)
{
foreach (var cookie in request.Cookies)
{
try
{
if (cookie.Key.ToUpper().StartsWith("GLOBAL_"))
{
response.Cookies.Delete(cookie.Key);
}
}
catch (Exception ex)
{
string strMessage = ex.Message;
}
}
}
public override void ExecuteResult(Microsoft.AspNetCore.Mvc.ActionContext context)
{
Microsoft.AspNetCore.Http.HttpResponse response = context.HttpContext.Response;
//if (this.m_data == null)
//{
// response.StatusCode = StatusCodes.Status500InternalServerError;
// return;
//}
byte[] data = this.m_enc.GetBytes(this.m_text);
response.StatusCode = StatusCodes.Status200OK;
response.ContentLength = data.Length;
response.ContentType = this.m_MimeType + "; charset=" + this.Encoding.WebName;
response.Body.Write(data, 0, data.Length);
}
public async Task ProcessAsync(HttpRequest httpRequest, HttpResponse httpResponse, IBot bot, CancellationToken cancellationToken = default)
{
if (httpRequest == null)
{
throw new ArgumentNullException(nameof(httpRequest));
}
if (httpResponse == null)
{
throw new ArgumentNullException(nameof(httpResponse));
}
if (bot == null)
{
throw new ArgumentNullException(nameof(bot));
}
if (_options.ValidateIncomingZoomRequests &&
httpRequest.Headers.TryGetValue("HeaderAuthorization", out StringValues headerAuthorization) &&
headerAuthorization.FirstOrDefault() != _options.VerificationToken)
{
throw new AuthenticationException("Failed to validate incoming request. Mismatched verification token.");
}
string body;
using (var sr = new StreamReader(httpRequest.Body))
{
body = await sr.ReadToEndAsync();
}
var zoomRequest = JsonConvert.DeserializeObject <ZoomRequest>(body, JsonSerializerSettings);
var activity = RequestToActivity(zoomRequest);
using (var context = new TurnContext(this, activity))
{
await RunPipelineAsync(context, bot.OnTurnAsync, cancellationToken).ConfigureAwait(false);
var statusCode = Convert.ToInt32(context.TurnState.Get <string>("httpStatus"), CultureInfo.InvariantCulture);
var text = context.TurnState.Get <object>("httpBody") != null?context.TurnState.Get <object>("httpBody").ToString() : string.Empty;
await WriteAsync(httpResponse, statusCode, text, Encoding.UTF8, cancellationToken).ConfigureAwait(false);
}
}
public override async Task <string> Handle(HttpRequest request, HttpResponse response)
{
try {
string url = HttpUtility.UrlDecode(request.QueryString.Value);
if (request.Method == "POST")
{
using (var readStream = new StreamReader(request.Body, Encoding.UTF8)) {
url = readStream.ReadToEnd();
}
}
if (url.StartsWith("s=B"))
{
url = url.Substring(3);
string contentId = FileList.GetContentId(url);
return(await GetFileList(FileList.GetFileList(contentId, "content_id"), contentId, "content_id"));
}
else if (url.StartsWith("torrenturl="))
{
url = url.Substring(11);
url = HttpUtility.UrlDecode(url);
if (url.StartsWith("torrent://"))
{
url = url.Substring(10);
}
var data = await HTTPUtility.GetBytesRequestAsync(url);
string contentId = FileList.GetContentId(data);
return(await GetFileList(FileList.GetFileList(contentId, "content_id"), contentId, "content_id"));
}
else if (url.StartsWith("magnet="))
{
url = url.Substring(7);
return(await GetFileList(FileList.GetFileList(url, "magnet"), url, "magnet"));
}
return(string.Empty);
} catch (Exception exception) {
Log.LogError(exception);
return(exception.Message);
}
}
public override void ExecuteResult(Microsoft.AspNetCore.Mvc.ActionContext context)
{
Microsoft.AspNetCore.Http.HttpResponse response = context.HttpContext.Response;
//if (this.m_data == null)
//{
// response.StatusCode = StatusCodes.Status500InternalServerError;
// return;
//}
response.StatusCode = StatusCodes.Status200OK;
response.ContentType = "application/javascript; charset=utf-8";
Services.JsonSerializer ser = (Services.JsonSerializer)context.HttpContext
.RequestServices.GetService(typeof(Services.JsonSerializer));
ser.SerializeJsonp(context.HttpContext.Response.Body, "callback"
, this.m_data, this.m_prettyPrint);
}
public static void CarregaCookie(Microsoft.AspNetCore.Http.HttpResponse response, ISession session)
{
CookieOptions option = new CookieOptions();
option.Expires = DateTime.Now.AddDays(1);
foreach (string key in session.Keys)
{
try
{
if (key.ToUpper().StartsWith("GLOBAL_"))
{
response.Cookies.Append(key, session.GetString(key), option);
}
}
catch (Exception ex)
{
string strMessage = ex.Message;
}
}
}
public async Task LunchPaymentPage(HttpContext httpContext, string authorizationUrl)
{
Microsoft.AspNetCore.Http.HttpResponse response = httpContext.Response;
response.Clear();
StringBuilder form = new StringBuilder();
form.Append("<html>");
form.AppendFormat("<body onload='document.forms[0].submit()'>");
form.AppendFormat("<form action='{0}' method='post'>", authorizationUrl);
form.Append("</form>");
form.Append("</body>");
form.Append("</html>");
HasLunchedPaymentPage = true;
await response.WriteAsync(form.ToString());
//response.Write(form.ToString());
//response.End();
}
public async Task WriteFileByteStreamToBody(Microsoft.AspNetCore.Http.HttpResponse Response, Guid id)
{
var _data = await ge_DbContext.ge_data
.Include(d => d.project)
.SingleOrDefaultAsync(m => m.Id == id);
Response.StatusCode = 200;
Response.Headers.Add(HeaderNames.ContentDisposition, $"attachment; filename=\"{Path.GetFileName( _data.filename )}\"");
Response.Headers.Add(HeaderNames.ContentType, _data.filetype);
string data_field = _data.GetContentFieldName();
Encoding encode = _data.GetEncoding();
using (var connection = _context.Database.GetDbConnection()) {
DbCommand command = connection.CreateCommand();
command.CommandText = $"SELECT {data_field} FROM ge_data where id='{id}'";
command.CommandTimeout = 0;
connection.Open();
using (var dataReader = command.ExecuteReader()) {
dataReader.Read();
using (var inputStream = dataReader.GetCharStream(data_field, encode)) {
using (var outputStream = Response.Body) {;
const int bufferSize = 8192;
var buffer = new byte[bufferSize];
while (true)
{
var bytesRead = await inputStream.ReadAsync(buffer, 0, bufferSize);
if (bytesRead == 0)
{
break;
}
await outputStream.WriteAsync(buffer, 0, bytesRead);
}
await outputStream.FlushAsync(); }
}
}
}
}
public static async Task WriteAsync(HttpResponse response, int code, string text, Encoding encoding, CancellationToken cancellationToken)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
if (text == null)
{
throw new ArgumentNullException(nameof(text));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
response.ContentType = "text/plain";
response.StatusCode = code;
var data = encoding.GetBytes(text);
await response.Body.WriteAsync(data, 0, data.Length, cancellationToken).ConfigureAwait(false);
}
public DCRadiumResponse(Microsoft.AspNetCore.Http.HttpResponse res)
{
this.res = res;
}
/// <summary>
/// 写给定字符串到 响应端;
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static void Write(this HttpResponseBase response, string content)
{
var contents = System.Text.Encoding.UTF8.GetBytes(content);
response.Body.Write(contents, 0, contents.Length);
}
public async Task <ResponseStructure> UpdatePassword(HttpRequest httpRequest, Microsoft.AspNetCore.Http.HttpResponse response, int userId)
{
try
{
UserModel userModel = await this.GetById(userId);
if (userModel == null)
{
return(ResponseModel.Error("Your login token has expired.", new { EXPIREDTOKEN = true }));
}
var data = httpRequest.Headers["PasswordUpdate"];
var dec = Barayand.Common.Services.CryptoJsService.DecryptStringAES(data);
RegisterModel rm = JsonConvert.DeserializeObject <RegisterModel>(dec);
if (!Barayand.Common.Services.CryptoJsService.verifyPassword(userModel.U_Password, rm.CurrentPassword))
{
return(ResponseModel.Error("Current password was incorrect."));
}
if (rm.ConfirmPassword != rm.Password)
{
return(ResponseModel.Error("Password and confirm password does not match."));
}
userModel.U_Password = Barayand.Common.Services.CryptoJsService.HashPassword(rm.Password);
response.Cookies.Delete("ValhallaUser");
return(await this.Update(userModel));
}
catch (Exception ex)
{
return(ResponseModel.ServerInternalError(data: ex));
}
}
public HttpResponse(Microsoft.AspNetCore.Http.HttpResponse httpResponse, ILogger logger)
{
_httpResponse = httpResponse;
_logger = logger;
}
protected abstract bool ShouldLog(Microsoft.AspNetCore.Http.HttpRequest request, Microsoft.AspNetCore.Http.HttpResponse response);
public HttpResponse(Microsoft.AspNetCore.Http.HttpResponse httpResponse, ISerializer serializer, ILogger logger)
{
_httpResponse = httpResponse;
_serializer = serializer;
_logger = logger;
}
public static Task WriteJson <T>(this Microsoft.AspNetCore.Http.HttpResponse response, T obj)
{
response.ContentType = "application/json";
return(response.WriteAsync(Newtonsoft.Json.JsonConvert.SerializeObject(obj)));
} // End Function MapAny
public static void Remove(this Microsoft.AspNetCore.Http.HttpResponse HttpResponse, string key)
{
HttpResponse.Cookies.Delete(key);
}
public NetCoreCookies(Microsoft.AspNetCore.Http.HttpResponse response)
{
this.response = response;
}
public HttpResponse(HttpContext context)
{
this.res = context.Response;
this.Headers = new Headers(new HttpHeaders(context.Response.Headers));
}
public static bool IsSuccessfulResponse(this HttpResponse httpResponse)
{
return(httpResponse.StatusCode >= (int)HttpStatusCode.OK && httpResponse.StatusCode <= 299);
}
