public async Task Register()
{
using (var http = new HttpClient())
{
var formData = new Dictionary <string, string>();
formData.Add(nameof(name), name);
formData.Add(ServerAddress.DEVICE_UID, UnityEngine.SystemInfo.deviceUniqueIdentifier);
formData.Add(nameof(hash), hash);
formData.Add(nameof(salt), salt);
formData.Add(nameof(gender), gender);
formData.Add(nameof(birthday), birthday);
var registerForm = new FormUrlEncodedContent(formData);
var response = await http.PostAsync(ServerAddress.RegisterFormAddress, registerForm);
var result = await response.Content.ReadAsStringAsync();
var intResult = Convert.ToInt32(result);
RegisterCompleted.Invoke((RegisterResult)intResult);
registerForm.Dispose();
}
}
/// <summary>
/// Sends a PUT type request including the parameters values from
/// a key value dictionary object
/// </summary>
/// <param name="urlBase">Main resource address</param>
/// <param name="method">Method resource address part</param>
/// <param name="parameters">Parameters to include in request</param>
/// <returns>HttpResponseMessage</returns>
public async Task <HttpResponseMessage> Put(string urlBase, string method, Dictionary <string, string> parameters)
{
//Verify http request integrity
if (!urlBase.IsWebDirectory(out Uri uri) || method.IsNotValid() || parameters.IsNotValid())
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
HttpResponseMessage response;
try
{
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(urlBase);
AddHeaders(client);
using (HttpContent content = new FormUrlEncodedContent(parameters))
{
response = await client.PutAsync(method, content);
content.Dispose();
}
client.Dispose();
}
}
catch (Exception ex)
{
response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(JsonConvert.SerializeObject(ex))
};
}
return(response);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (_http != null)
{
_http.Dispose();
}
if (_content != null)
{
_content.Dispose();
}
if (_contentForToken != null)
{
_contentForToken.Dispose();
}
if (_response != null)
{
_response.Dispose();
}
}
}
disposed = true;
}
public void Dispose()
{
handler.Dispose();
client.Dispose();
content.Dispose();
response.Dispose();
}
public async Task <TokenResponse> ValidateTokenAsync(string code, string clientId, string clientSecret, Uri redirectUri)
{
var parameters = new KeyValuePair <string, string>[] {
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("code", code),
new KeyValuePair <string, string>("client_id", clientId),
new KeyValuePair <string, string>("client_secret", clientSecret),
new KeyValuePair <string, string>("redirect_uri", redirectUri.AbsoluteUri)
};
var formContent = new FormUrlEncodedContent(parameters);
var request = new HttpRequestMessage(HttpMethod.Post, "api/oauth2/token")
{
Content = formContent
};
HttpResponseMessage responseMessage = default;
try
{
responseMessage = await HttpClient.SendAsync(request);
responseMessage.EnsureSuccessStatusCode();
}
catch
{
formContent.Dispose();
request.Dispose();
responseMessage?.Dispose();
throw;
}
formContent.Dispose();
request.Dispose();
var token = JsonSerializer.Deserialize <TokenResponse>(await responseMessage.Content.ReadAsStringAsync());
responseMessage.Dispose();
return(token);
}
protected void WriteRequestBody(HttpRequestMessage httpRequestMessage, object body, MediaTypeHeaderValue contentType)
{
if (body is string)
{
using (var stringWriter = new StringWriter())
{
stringWriter.Write(body as string);
httpRequestMessage.Content = new StringContent(stringWriter.ToString());
if (httpRequestMessage.Content.Headers.ContentLength > 0)
{
httpRequestMessage.Content.Headers.ContentType = contentType;
}
}
}
else if (body is IDictionary <string, string> )
{
var formContent = new FormUrlEncodedContent(body as IDictionary <string, string>);
if (ShareFileClient.Logging.IsDebugEnabled)
{
try
{
var contentAsString = formContent.ReadAsStringAsync();
}
catch (Exception)
{
formContent.Dispose();
throw;
}
}
httpRequestMessage.Content = formContent;
}
else
{
var stringWriter = new StringWriter();
using (var textWriter = new JsonTextWriter(stringWriter))
{
var serializationWatch = new ActionStopwatch("SerializeRequest", ShareFileClient.Logging, RequestId);
ShareFileClient.Serializer.Serialize(textWriter, body);
ShareFileClient.Logging.Trace(serializationWatch);
httpRequestMessage.Content = new StringContent(stringWriter.ToString());
if (httpRequestMessage.Content.Headers.ContentLength > 0)
{
httpRequestMessage.Content.Headers.ContentType = contentType;
}
}
}
}
protected override async Task <OAuthTokenResponse> ExchangeCodeAsync([NotNull] string code, [NotNull] string redirectUri)
{
var credentials = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Options.ClientId}:{Options.ClientSecret}"));
HttpRequestMessage request = null;
HttpResponseMessage response = null;
FormUrlEncodedContent formUrlEncodedContent = null;
try
{
request = new HttpRequestMessage(HttpMethod.Post, Options.TokenEndpoint);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", credentials);
// When a custom user agent is specified in the options, add it to the request headers
// to override the default (generic) user agent used by the OAuth2 base middleware.
if (!string.IsNullOrEmpty(Options.UserAgent))
{
request.Headers.UserAgent.ParseAdd(Options.UserAgent);
}
formUrlEncodedContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["grant_type"] = "authorization_code",
["redirect_uri"] = redirectUri,
["code"] = code
});
request.Content = formUrlEncodedContent;
response = await Backchannel.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, Context.RequestAborted);
if (!response.IsSuccessStatusCode)
{
Logger.LogError("An error occurred while retrieving an access token: the remote server " +
"returned a {Status} response with the following payload: {Headers} {Body}.",
/* Status: */ response.StatusCode,
/* Headers: */ response.Headers.ToString(),
/* Body: */ await response.Content.ReadAsStringAsync());
return(OAuthTokenResponse.Failed(new Exception("An error occurred while retrieving an access token.")));
}
var payload = JObject.Parse(await response.Content.ReadAsStringAsync());
return(OAuthTokenResponse.Success(payload));
}
finally
{
formUrlEncodedContent?.Dispose();
request?.Dispose();
response?.Dispose();
}
}
protected override async Task <OAuthTokenResponse> ExchangeCodeAsync([NotNull] string code, [NotNull] string redirectUri)
{
HttpRequestMessage request = null;
HttpResponseMessage response = null;
FormUrlEncodedContent formUrlEncodedContent = null;
try
{
request = new HttpRequestMessage(HttpMethod.Post, Options.TokenEndpoint);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
formUrlEncodedContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["client_id"] = Options.ClientId,
["redirect_uri"] = redirectUri,
["client_secret"] = Options.ClientSecret,
["code"] = code,
["grant_type"] = "authorization_code"
});
request.Content = formUrlEncodedContent;
response = await Backchannel.SendAsync(request, Context.RequestAborted);
if (!response.IsSuccessStatusCode)
{
Logger.LogError("An error occurred while retrieving an access token: the remote server " +
"returned a {Status} response with the following payload: {Headers} {Body}.",
/* Status: */ response.StatusCode,
/* Headers: */ response.Headers.ToString(),
/* Body: */ await response.Content.ReadAsStringAsync());
return(OAuthTokenResponse.Failed(new Exception("An error occurred while retrieving an access token.")));
}
// Note: Yammer doesn't return a standard OAuth2 response. To make this middleware compatible
// with the OAuth2 generic middleware, a compliant JSON payload is generated manually.
// See https://developer.yammer.com/docs/oauth-2 for more information about this process.
var payload = JObject.Parse(await response.Content.ReadAsStringAsync())["access_token"].Value <JObject>();
payload["access_token"] = payload["token"];
payload["token_type"] = string.Empty;
payload["refresh_token"] = string.Empty;
payload["expires_in"] = string.Empty;
return(OAuthTokenResponse.Success(payload));
}
finally
{
formUrlEncodedContent?.Dispose();
request?.Dispose();
response?.Dispose();
}
}
public void AddItem(string item)
{
var values = new Dictionary <string, string>
{
{ "name", item }
};
var content = new FormUrlEncodedContent(values);
var response = client.PostAsync(url, content).Result.Content.ReadAsStringAsync().Result;
content.Dispose();
items.Add(JsonConvert.DeserializeObject <Item>(response));
}
protected override async Task <OAuthTokenResponse> ExchangeCodeAsync([NotNull] string code, [NotNull] string redirectUri)
{
HttpRequestMessage request = null;
HttpResponseMessage response = null;
FormUrlEncodedContent formUrlEncodedContent = null;
try
{
request = new HttpRequestMessage(HttpMethod.Post, Options.TokenEndpoint);
formUrlEncodedContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["client_id"] = Options.ClientId,
["redirect_uri"] = redirectUri,
["client_secret"] = Options.ClientSecret,
["code"] = code,
["grant_type"] = "authorization_code"
});
request.Content = formUrlEncodedContent;
response = await Backchannel.SendAsync(request, Context.RequestAborted);
if (!response.IsSuccessStatusCode)
{
Logger.LogError("An error occurred while retrieving an access token: the remote server " +
"returned a {Status} response with the following payload: {Headers} {Body}.",
/* Status: */ response.StatusCode,
/* Headers: */ response.Headers.ToString(),
/* Body: */ await response.Content.ReadAsStringAsync());
return(OAuthTokenResponse.Failed(new Exception("An error occurred while retrieving an access token.")));
}
// Note: StackExchange's token endpoint doesn't return JSON but uses application/x-www-form-urlencoded.
// Since OAuthTokenResponse expects a JSON payload, a JObject is manually created using the returned values.
var content = QueryHelpers.ParseQuery(await response.Content.ReadAsStringAsync());
var payload = new JObject();
foreach (var item in content)
{
payload[item.Key] = (string)item.Value;
}
return(OAuthTokenResponse.Success(payload));
}
finally
{
formUrlEncodedContent?.Dispose();
request?.Dispose();
response?.Dispose();
}
}
public async Task Login(string username, string password)
{
using (var http = new HttpClient())
{
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("name", username),
});
try
{
var req = await http.PostAsync(ServerAddress.LoginFormAddress, formContent);
var result = await req.Content.ReadAsStringAsync();
var splittedResult = result.Split('|');
var intResult = Convert.ToInt32(splittedResult[0]);
if (intResult != (int)LoginResult.Success)
{
OnLogin?.Invoke(LoginResult.Failed_Username, null, null, Gender.Female);
return;
}
var hash = splittedResult[1];
var salt = splittedResult[2];
var isPasswordValid = HashSalt.VerifyPassword(password, hash, salt);
if (isPasswordValid == false)
{
OnLogin?.Invoke(LoginResult.Failed_Password, null, null, Gender.Female);
return;
}
var name = splittedResult[3];
var gender = (Gender)Enum.Parse(typeof(Gender), splittedResult[4]);
var birthday = splittedResult[5];
OnLogin?.Invoke(LoginResult.Success, name, birthday, gender);
}
catch
{
OnLogin?.Invoke(LoginResult.Failed_MySQL, null, null, Gender.Female);
}
formContent.Dispose();
}
}
protected override async Task <OAuthTokenResponse> ExchangeCodeAsync([NotNull] string code, [NotNull] string redirectUri)
{
HttpRequestMessage request = null;
FormUrlEncodedContent formUrlEncodedContent = null;
HttpResponseMessage response = null;
try
{
request = new HttpRequestMessage(HttpMethod.Post, Options.TokenEndpoint);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded"));
formUrlEncodedContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["redirect_uri"] = redirectUri,
["client_assertion"] = Options.ClientSecret,
["assertion"] = code,
["grant_type"] = "urn:ietf:params:oauth:grant-type:jwt-bearer",
["client_assertion_type"] = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
});
request.Content = formUrlEncodedContent;
response = await Backchannel.SendAsync(request, Context.RequestAborted);
if (!response.IsSuccessStatusCode)
{
Logger.LogError("An error occurred while retrieving an access token: the remote server " +
"returned a {Status} response with the following payload: {Headers} {Body}.",
/* Status: */ response.StatusCode,
/* Headers: */ response.Headers.ToString(),
/* Body: */ await response.Content.ReadAsStringAsync());
return(OAuthTokenResponse.Failed(new Exception("An error occurred while retrieving an access token.")));
}
var payload = JObject.Parse(await response.Content.ReadAsStringAsync());
return(OAuthTokenResponse.Success(payload));
}
finally
{
formUrlEncodedContent?.Dispose();
request?.Dispose();
response?.Dispose();
}
}
public async Task When_ShellSendsPostData_ItsSendItToRegisteredApplication()
{
var path = "path1";
var shellUri = new Uri(string.Concat(path, "/edit?id=1"), UriKind.Relative);
var client = factory.CreateClientWithWebHostBuilder();
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("field1", "value1"),
new KeyValuePair <string, string>("field2", "value2"),
});
var response = await client.PostAsync(shellUri, formContent).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var responseHtml = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
Assert.Contains("POST, http://www.path1.com/path1/edit, path1, Body, field1=value1, field2=value2", responseHtml, StringComparison.OrdinalIgnoreCase);
formContent.Dispose();
}
private void SendCommand(int command)
{
string playerUrl = DEFAULT_HOST + ":" + DEFAULT_PORT + COMMANDS;
var values = new Dictionary <string, string> {
{ "wm_command", command.ToString(CultureInfo.InvariantCulture) }
};
try {
#pragma warning disable CA2000 // Dispose objects before losing scope
var content = new FormUrlEncodedContent(values);
_ = client.PostAsync(new Uri(playerUrl), content).ContinueWith((requestTask) => {
content.Dispose();
}, TaskScheduler.Current);
#pragma warning restore CA2000 // Dispose objects before losing scope
} catch { }
}
/// <summary>
/// Pobranie danych tokena autoryzującego, używane przy logowaniu
/// </summary>
/// <param name="login">Login</param>
/// <param name="password">Hasło</param>
/// <returns>Dictionary zawierający dane tokena</returns>
public Dictionary <string, string> GetToken(string login, string password)
{
HttpContent content = new FormUrlEncodedContent(new Dictionary <string, string>()
{
{ "grant_type", "password" },
{ "username", login },
{ "password", password }
});
try
{
using (HttpResponseMessage responseMessage = Task.Run(async() => { return(await _httpClient.PostAsync("Token", content)); }).Result)
{
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
content = responseMessage.Content;
string jsonString = Task.Run(async() => { return(await content.ReadAsStringAsync()); }).Result;
Dictionary <string, string> tokenData = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonString);
return(tokenData);
}
else if (responseMessage.StatusCode == HttpStatusCode.BadRequest)
{
_lastErrorMessage = "Niepoprawne dane logowania";
}
else
{
_lastErrorMessage = "Błąd połączenia z serwerem";
}
}
}
catch (Exception exc)
{
_lastErrorMessage = "Błąd połączenia z serwerem";
}
finally
{
content.Dispose();
}
return(null);
}
private async Task <string> GetUsers(string keyword)
{
// TODO : Handle exception from http
using (var http = new HttpClient())
{
var formValue = new Dictionary <string, string>()
{
{ "keyword", keyword }
};
var form = new FormUrlEncodedContent(formValue);
var content = await http.PostAsync(ServerAddress.SearchUserFormAdderss, form);
var result = await content.Content.ReadAsStringAsync();
form.Dispose();
return(result);
}
}
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
}
if (responsibleForClient && client != null)
{
client.Dispose();
}
if (content != null)
{
content.Dispose();
}
disposed = true;
}
public HttpResponseEventArgs Post(string url, Dictionary <string, string> args)
{
HttpResponseEventArgs result = new HttpResponseEventArgs();
try
{
// if (executing)
// throw new Exception("Another request is executing.");
if (!Initialized)
{
throw new Exception("Client was not initialized.");
}
while (executing)
{
Thread.Sleep(100);
}
executing = true;
var content = new FormUrlEncodedContent(args);
using (HttpResponseMessage response = http.PostAsync(url, content).Result)
{
result.SuccessfulRequest = response.IsSuccessStatusCode;
result.StatusCode = Convert.ToInt32(response.StatusCode);
result.HTMLInString = response.Content.ReadAsStringAsync().Result;
}
content.Dispose();
}
catch (Exception ex)
{
result.SuccessfulRequest = false;
result.Message = ex.Message;
}
finally
{
executing = false;
}
return(result);
}
} // MAIN CHECKER
async void Send(string message, string user, string avatar)
{
lb_hint.Text = "Please wait";
Content.Enabled = false;
Username.Enabled = false;
Avatar.Enabled = false;
webhookinput.Enabled = false;
messagesend.Enabled = false;
try
{
var msg = new Dictionary <string, string>
{
{ "content", message },
{ "username", user },
{ "avatar_url", avatar },
};
Content.Text = "";
FormUrlEncodedContent emsg = new FormUrlEncodedContent(msg);
HttpResponseMessage resp = await client.PostAsync(url, emsg);
emsg.Dispose();
resp.Dispose();
msg = null;
lb_hint.Text = "";
webhookinput.Enabled = true;
Content.Enabled = true;
Username.Enabled = true;
Avatar.Enabled = true;
Content.Focus();
}
catch (Exception err)
{
//MessageBox.Show(err.Message, Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
lb_hint.Text = $"{err.GetType().Name}: {err.Message}";
lb_hint.ForeColor = Color.Red;
}
} // MAIN SENDER
public static async Task <string> GetImagesCode(string id)
{
using (var handler = new HttpClientHandler
{
CookieContainer = cookies,
UseProxy = true,
//Proxy = new WebProxy("proxy.hinet.net", 80),
})
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri("http://imgspice.com");
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("op", "my_files"),
new KeyValuePair <string, string>("fld_id", "0"),
new KeyValuePair <string, string>("key", id),
new KeyValuePair <string, string>("create_new_folder", ""),
new KeyValuePair <string, string>("pub", "1"),
new KeyValuePair <string, string>("pub", "1"),
new KeyValuePair <string, string>("to_folder", ""),
new KeyValuePair <string, string>("domain", ""),
});
var fileIds = new List <string>();
using (var response = await client.PostAsync("/", content))
{
var result = await response.Content.ReadAsStringAsync();
const string search = "file_id\" value=\"";
foreach (var s in result.AllIndexesOf(search))
{
var start = s + search.Length;
var end = result.IndexOf("\"", start);
if (end - start < 10)
{
fileIds.Add(result.Substring(start, end - start));
}
}
}
if (!fileIds.Any())
{
return(string.Empty);
}
content.Dispose();
var postData = new List <KeyValuePair <string, string> >();
postData.Add(new KeyValuePair <string, string>("op", "my_files"));
postData.Add(new KeyValuePair <string, string>("fld_id", "0"));
postData.Add(new KeyValuePair <string, string>("key", id));
postData.Add(new KeyValuePair <string, string>("create_new_folder", ""));
foreach (var fileId in fileIds)
{
postData.Add(new KeyValuePair <string, string>("file_id", fileId));
postData.Add(new KeyValuePair <string, string>("pub", "1"));
}
postData.Add(new KeyValuePair <string, string>("to_folder", ""));
postData.Add(new KeyValuePair <string, string>("domain", "http://imgspice.com"));
content = new FormUrlEncodedContent(postData);
using (var response = await client.PostAsync("/", content))
{
var result = await response.Content.ReadAsStringAsync();
var start = result.IndexOf("All Images : HTML Codes for Sites", 0);
if (start >= 0)
{
start = result.IndexOf("<a href=", start);
var end = result.IndexOf("</textarea>", start);
if (end >= 0)
{
return(result.Substring(start, end - start).Replace(Environment.NewLine, "").Replace("\n", ""));
}
}
}
return(string.Empty);
}
}
/// <summary>
/// Get an Access Token in order to call an API.
/// </summary>
/// <param name="httpClient">A <see cref="HttpClient"/> param.</param>
/// <param name="endpoint">The OpenId's Endpoint.</param>
/// <param name="auth0ClientId">The Auth0's client id.</param>
/// <param name="code">The code received from Auth0.</param>
/// <param name="audience">The Auth0's audience domain.</param>
/// <param name="codeVerifier">The code verification token used in the authentication flow</param>
/// <param name="redirectUri">URL to redirect the user after the logout.</param>
/// <param name="secret">The Auth0's client secret</param>
/// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns>
public static async Task <SessionInfo> GetAccessToken(
HttpClient httpClient,
string endpoint,
string auth0ClientId,
string code,
string audience = null,
string codeVerifier = null,
string redirectUri = null,
string secret = null,
RequestModes requestMode = RequestModes.Json)
{
if (httpClient is null)
{
throw new ArgumentNullException(nameof(httpClient));
}
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentException(Resources.NullArgumentExceptionError, nameof(endpoint));
}
if (string.IsNullOrEmpty(auth0ClientId))
{
throw new ArgumentException(Resources.NullArgumentExceptionError, nameof(auth0ClientId));
}
if (string.IsNullOrEmpty(codeVerifier) && string.IsNullOrEmpty(secret))
{
throw new ArgumentException(Resources.MissingPKCERequiredParamError, $"{nameof(secret)} or {nameof(codeVerifier)}");
}
if (!string.IsNullOrEmpty(codeVerifier) && !string.IsNullOrEmpty(secret))
{
throw new ArgumentException(Resources.DuplicatedPKCERequiredParamError, $"{nameof(secret)} and {nameof(codeVerifier)}");
}
SessionInfo response = null;
if (RequestModes.Json == requestMode)
{
using (HttpContent content = new StringContent(
JsonSerializer.Serialize(
new
{
grant_type = "authorization_code",
client_id = auth0ClientId,
audience,
code,
code_verifier = codeVerifier,
redirect_uri = redirectUri,
client_secret = secret,
},
new JsonSerializerOptions
{
IgnoreNullValues = true,
}), Encoding.UTF8,
Resources.ApplicationJsonMediaType
)
)
{
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync($@"{endpoint}", content).ConfigureAwait(false);
var responseText = await httpResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
if (httpResponseMessage.StatusCode == System.Net.HttpStatusCode.OK)
{
response = JsonSerializer.Deserialize <SessionInfo>(responseText);
}
}
}
else
{
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("client_id", auth0ClientId),
new KeyValuePair <string, string>("audience", audience),
new KeyValuePair <string, string>("code", code),
new KeyValuePair <string, string>("code_verifier", codeVerifier),
new KeyValuePair <string, string>("redirect_uri", redirectUri),
new KeyValuePair <string, string>("client_secret", secret),
});
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync($@"{endpoint}", formContent).ConfigureAwait(false);
formContent.Dispose();
var responseText = await httpResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
if (httpResponseMessage.StatusCode == System.Net.HttpStatusCode.OK)
{
response = JsonSerializer.Deserialize <SessionInfo>(responseText);
}
}
return(response);
}
public HttpResponseMessage GetContent(Dictionary <string, string> cookies, string _token, string login, string password)
{
var cookieContainer = new CookieContainer();
using (var handler = new HttpClientHandler()
{
//AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.None,
CookieContainer = cookieContainer,
Proxy = Proxy
})
using (var client = new HttpClient(handler))
{
// установка заголовков
client.DefaultRequestHeaders.Add("Connection", "keep-alive");
client.DefaultRequestHeaders.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
client.DefaultRequestHeaders.Add("Accept-Encoding", "gzip, deflate, br");
client.DefaultRequestHeaders.Add("Accept-Language", "am,uk;q=0.7,ru;q=0.3");
client.DefaultRequestHeaders.Add("Host", "mangalib.me");
client.DefaultRequestHeaders.Add("Referer", "https://mangalib.me/login");
client.DefaultRequestHeaders.Add("TE", "Trailers");
client.DefaultRequestHeaders.Add("Upgrade-Insecure-Requests", "1");
client.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.3; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0");
// POST данные для отправки
var postData = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("email", login),
new KeyValuePair <string, string>("password", password),
new KeyValuePair <string, string>("_token", _token)
});
#if DEBUG
Console.WriteLine(Resources.Log8, login, password, _token);
#endif
// Установка куки
foreach (var obj in cookies)
{
cookieContainer.Add(new Uri(BaseUrl), new Cookie(obj.Key, obj.Value));
#if DEBUG
Console.Write(Resources.Log9, obj.Key, obj.Value);
#endif
}
// запрос
HttpResponseMessage response = client.PostAsync(new Uri(RequestUrl), postData).Result;
TreatmentPostData treatment = new TreatmentPostData(response);
if (treatment.Tests())
{
Loger.AddSuccess(string.Format(CultureInfo.CurrentCulture, "{0}, {1}", login, password));
#if !DEBUG
Console.Write("Login: "******";\tPassword: "******"\tStatus: OK");
#endif
}
Console.WriteLine("Login: "******";\tPassword: "******"\tStatus: NOT");
Loger.AddLog(string.Format(CultureInfo.CurrentCulture, "{0}, {1}", login, password));
postData.Dispose();
return(response);
}
}
