private async Task <string> RequestGetAsync()
{
string requestUrl = "https://www.tumblr.com/";
HttpWebRequest request = webRequestFactory.CreateGetReqeust(requestUrl);
return(await webRequestFactory.ReadReqestToEnd(request).TimeoutAfter(shellService.Settings.TimeOut));
}
private async Task <string> GetRequestAsync()
{
const string requestUrl = "https://www.tumblr.com/";
HttpWebRequest request = webRequestFactory.CreateGetReqeust(requestUrl);
return(await webRequestFactory.ReadReqestToEndAsync(request));
}
public void PerformTumblrLogout()
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust("https://www.tumblr.com/");
cookieService.GetUriCookie(request.CookieContainer, new Uri("https://www.tumblr.com/"));
cookieService.RemoveUriCookie(new Uri("https://www.tumblr.com"));
var tosCookie = request.CookieContainer.GetCookies(new Uri("https://www.tumblr.com/"))["pfg"];
var tosCookieCollection = new CookieCollection();
tosCookieCollection.Add(tosCookie);
cookieService.SetUriCookie(tosCookieCollection);
}
public void PerformTumblrLogout()
{
var request = webRequestFactory.CreateGetReqeust("https://www.tumblr.com/");
cookieService.GetUriCookie(request.CookieContainer, new Uri("https://www.tumblr.com/"));
cookieService.RemoveUriCookie(new Uri("https://www.tumblr.com"));
var tosCookie =
request.CookieContainer.GetCookies(
new Uri("https://www.tumblr.com/"))["pfg"]; // pfg cookie contains ToS/GDPR agreement
var tosCookieCollection = new CookieCollection
{
tosCookie
};
cookieService.SetUriCookie(tosCookieCollection);
}
private async Task <string> RequestTumblrKey()
{
string url = "https://www.tumblr.com/login";
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url);
cookieService.GetUriCookie(request.CookieContainer, new Uri("https://www.tumblr.com/"));
using (var response = await request.GetResponseAsync() as HttpWebResponse)
{
cookieService.SetUriCookie(response.Cookies);
using (var stream = webRequestFactory.GetStreamForApiRequest(response.GetResponseStream()))
{
using (var buffer = new BufferedStream(stream))
{
using (var reader = new StreamReader(buffer))
{
return(reader.ReadToEnd());
}
}
}
}
}
private async Task <string> GetUrlRedirection(string url)
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url);
request.Method = "GET";
string location;
using (HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse)
{
location = response.ResponseUri.ToString();
}
return(location);
}
private async Task <string> GetUrlRedirection(string url)
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url);
cookieService.GetUriCookie(request.CookieContainer, new Uri("https://www.tumblr.com/"));
string location;
using (var response = await request.GetResponseAsync() as HttpWebResponse)
{
location = response.ResponseUri.ToString();
}
return(location);
}
protected async Task <string> RequestDataAsync(string url, Dictionary <string, string> headers = null,
IEnumerable <string> cookieHosts = null)
{
var requestRegistration = new CancellationTokenRegistration();
try
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url, "", headers);
cookieHosts = cookieHosts ?? new List <string>();
foreach (string cookieHost in cookieHosts)
{
cookieService.GetUriCookie(request.CookieContainer, new Uri(cookieHost));
}
requestRegistration = ct.Register(() => request.Abort());
return(await webRequestFactory.ReadReqestToEndAsync(request));
}
finally
{
requestRegistration.Dispose();
}
}
public virtual async Task <string> RequestImgurAlbumSite(string imgurAlbumUrl)
{
var requestRegistration = new CancellationTokenRegistration();
try
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(imgurAlbumUrl);
requestRegistration = ct.Register(() => request.Abort());
return(await webRequestFactory.ReadReqestToEnd(request));
}
finally
{
requestRegistration.Dispose();
}
}
protected virtual async Task <string> RequestDataAsync(string url, params string[] cookieHosts)
{
var requestRegistration = new CancellationTokenRegistration();
try
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url);
foreach (string cookieHost in cookieHosts)
{
cookieService.GetUriCookie(request.CookieContainer, new Uri(cookieHost));
}
requestRegistration = ct.Register(() => request.Abort());
return(await webRequestFactory.ReadReqestToEnd(request).TimeoutAfter(shellService.Settings.TimeOut));
}
finally
{
requestRegistration.Dispose();
}
}
public async Task <string> GetLatestReleaseFromServer()
{
version = null;
downloadLink = null;
try
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust("https://api.github.com/repos/tumblthreeapp/tumblthree/releases/latest");
string result = await webRequestFactory.ReadReqestToEndAsync(request);
XmlDictionaryReader jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(result), new XmlDictionaryReaderQuotas());
XElement root = XElement.Load(jsonReader);
version = root.Element("tag_name").Value;
downloadLink = root.Element("assets").Element("item").Element("browser_download_url").Value;
}
catch (Exception exception)
{
Logger.Error(exception.ToString());
return(exception.Message);
}
return(null);
}
protected virtual async Task <string> RequestDataAsync(string url, params string[] cookieHosts)
{
var requestRegistration = new CancellationTokenRegistration();
try
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url);
foreach (string cookieHost in cookieHosts)
{
cookieService.GetUriCookie(request.CookieContainer, new Uri(cookieHost));
}
string username = blog.Name + ".tumblr.com";
string password = blog.Password;
string encoded = System.Convert.ToBase64String(System.Text.Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));
request.Headers.Add("Authorization", "Basic " + encoded);
//request.Credentials = new NetworkCredential(blog.Name + ".tumblr.com", blog.Password);
requestRegistration = ct.Register(() => request.Abort());
return(await webRequestFactory.ReadReqestToEnd(request).TimeoutAfter(shellService.Settings.TimeOut));
}
finally
{
requestRegistration.Dispose();
}
}
// TODO: Needs a complete rewrite. Also a append/cache function for resuming incomplete files on the disk.
// Should be in separated class with support for events for downloadspeed, is resumable file?, etc.
// Should check if file is complete, else it will trigger an WebException -- 416 requested range not satisfiable at every request
public async Task <bool> DownloadFileWithResumeAsync(string url, string destinationPath)
{
long totalBytesReceived = 0;
var attemptCount = 0;
int bufferSize = settings.BufferSize * 4096;
if (File.Exists(destinationPath))
{
var fileInfo = new FileInfo(destinationPath);
totalBytesReceived = fileInfo.Length;
if (totalBytesReceived >= await CheckDownloadSizeAsync(url).TimeoutAfter(settings.TimeOut))
{
return(true);
}
}
if (ct.IsCancellationRequested)
{
return(false);
}
FileMode fileMode = totalBytesReceived > 0 ? FileMode.Append : FileMode.Create;
using (var fileStream = new FileStream(destinationPath, fileMode, FileAccess.Write, FileShare.Read, bufferSize, true))
{
while (true)
{
attemptCount += 1;
if (attemptCount > settings.MaxNumberOfRetries)
{
return(false);
}
var requestRegistration = new CancellationTokenRegistration();
try
{
HttpWebRequest request = webRequestFactory.CreateGetReqeust(url);
requestRegistration = ct.Register(() => request.Abort());
request.AddRange(totalBytesReceived);
long totalBytesToReceive = 0;
using (WebResponse response = await request.GetResponseAsync().TimeoutAfter(settings.TimeOut))
{
totalBytesToReceive = totalBytesReceived + response.ContentLength;
using (Stream responseStream = response.GetResponseStream())
{
using (Stream throttledStream = GetStreamForDownload(responseStream))
{
var buffer = new byte[4096];
var bytesRead = 0;
//Stopwatch sw = Stopwatch.StartNew();
while ((bytesRead = await throttledStream
.ReadAsync(buffer, 0, buffer.Length, ct)
.TimeoutAfter(settings.TimeOut)) > 0)
{
await fileStream.WriteAsync(buffer, 0, bytesRead);
totalBytesReceived += bytesRead;
//float currentSpeed = totalBytesReceived / (float)sw.Elapsed.TotalSeconds;
//OnProgressChanged(new DownloadProgressChangedEventArgs(totalBytesReceived,
// totalBytesToReceive, (long)currentSpeed));
}
}
}
}
if (totalBytesReceived >= totalBytesToReceive)
{
break;
}
}
catch (IOException ioException)
{
// file in use
long win32ErrorCode = ioException.HResult & 0xFFFF;
if (win32ErrorCode == 0x21 || win32ErrorCode == 0x20)
{
return(false);
}
// retry (IOException: Received an unexpected EOF or 0 bytes from the transport stream)
}
catch (WebException webException)
{
if (webException.Status == WebExceptionStatus.ConnectionClosed)
{
// retry
}
else
{
throw;
}
}
finally
{
requestRegistration.Dispose();
}
}
return(true);
}
}
