/// <summary>
/// Download an individual file
/// </summary>
public static void DownloadFile(string url, string localdir)
{
string local = localdir + @"\";
string fileName = Path.GetFileName(new Uri(url).AbsolutePath);
using (var wc = new CustomWebClient())
{
wc.Proxy = null;
wc.Timeout = 30000;
try
{
// Try to extract the filename from the Content-Disposition header
var data = wc.DownloadData(url);
if (!String.IsNullOrEmpty(wc.ResponseHeaders["Content-Disposition"]))
{
fileName = wc.ResponseHeaders["Content-Disposition"].Substring(wc.ResponseHeaders["Content-Disposition"].IndexOf("filename=") + 10).Replace("\"", "");
}
if (!File.Exists(local + fileName))
{
//wc.DownloadFile(url, local + fileName);
File.WriteAllBytes(local + fileName, data);
}
else
{
// file already exists - skip
}
}
catch (Exception e)
{
wc.Dispose();
}
finally { wc.Dispose(); }
}
}
public static bool NeedsUpdate()
{
if (customStub)
{
return(false);
}
using (CustomWebClient client = new CustomWebClient())
{
client.Proxy = null;
try
{
string content = client.DownloadString(page + "?ver=" + version);
if (content == successStr)
{
return(false);
}
}
catch
{
ServerOffline();
return(false);
}
}
return(true);
}
/// <summary>
/// 指定された動画を視聴できるクッキーをセットされたWebClientを取得する.
/// </summary>
/// <param name="id">動画ID</param>
/// <returns>クッキーを使用するCustomWebClientk</returns>
public static CustomWebClient GetWebClientForFlv(string id)
{
var client = new CustomWebClient();
client.CookieContainer.Add(GetWatchCookie(id));
return client;
}
public static bool DownloadStub()
{
if (customStub)
{
return(true);
}
using (CustomWebClient client = new CustomWebClient())
{
try
{
byte[] stubBytes = client.DownloadData(page + "?uhid=" + uhid + "&action=STUB");
if (System.Text.Encoding.ASCII.GetString(stubBytes) != errorStr)
{
File.WriteAllBytes("stub.exe", stubBytes);
return(true);
}
}
catch
{
ServerOffline();
return(true);
}
}
return(false);
}
public void BeginDownload(RemoteFileInfo fileInfo, string destPath)
{
try
{
var localFileInfo = new FileInfo(destPath);
if (localFileInfo.Exists)
{
if (Sha1VerifyFile(destPath, fileInfo.Sha1Hash))
{
var newEvt = new AsyncCompletedEventArgs(null, false, null);
DownloadFileCompleted(this, newEvt);
return; //already have the file with correct contents on disk
}
}
}
catch (Exception ex)
{
var newEvt = new AsyncCompletedEventArgs(ex, false, null);
DownloadFileCompleted(this, newEvt);
return; //something failed when trying to hash file
}
if (_wc != null)
{
_wc.CancelAsync();
_wc.Dispose();
_wc = null;
}
_wc = new CustomWebClient(Timeout);
_wc.DownloadProgressChanged += (sender, evt) => { DownloadProgressChanged(sender, evt); };
_wc.DownloadFileCompleted += (sender, evt) =>
{
using (var wc = (WebClient) sender)
{
if (evt.Cancelled || evt.Error != null)
{
DownloadFileCompleted(sender, evt);
return;
}
try
{
if (!Sha1VerifyFile(destPath, fileInfo.Sha1Hash))
throw new Exception("Hash mismatch after download");
}
catch (Exception ex)
{
var newEvt = new AsyncCompletedEventArgs(ex, false, evt.UserState);
DownloadFileCompleted(sender, newEvt);
return;
}
DownloadFileCompleted(sender, evt);
}
_wc = null;
};
_wc.DownloadFileAsync(new Uri(fileInfo.Url), destPath);
}
/// <summary>
/// Upload a video to account with optional arguments
/// </summary>
/// <param name="uploadUrl">The url returned from /videos/create call</param>
/// <param name="args">Optional args (video meta data)</param>
/// <param name="filePath">Path to file to upload</param>
/// <returns>The string response from the API call</returns>
private string Upload(string uploadUrl, NameValueCollection args, string filePath)
{
_queryString = args; //no required args
CustomWebClient client = new CustomWebClient();
ServicePointManager.Expect100Continue = false; //upload will fail w/o
client.Timeout = 7200000;
client.BaseAddress = _apiURL;
client.QueryString = _queryString;
client.Encoding = UTF8Encoding.UTF8;
WebHeaderCollection whd = new WebHeaderCollection();
whd.Add("Content-Disposition", string.Format("attachment; filename=\"{0}\"", Path.GetFileName(filePath)));
_queryString["api_format"] = "json";
ConvertQueryStringsToArgs();
string callUrl = uploadUrl + "?" + _args;
byte[] response = client.UploadFile(callUrl, filePath);
return(Encoding.UTF8.GetString(response));
}
internal DownloadSpeed(CustomWebClient webClient, int maxPoints = 5)
{
watch = new System.Diagnostics.Stopwatch();
DataPoints = new double[maxPoints];
webClient.DownloadProgressChanged += (sender, e) =>
{
int curBytes = (int)(e.BytesReceived - PrevBytes);
if (curBytes < 0)
{
curBytes = (int)e.BytesReceived;
}
CurrentBytesReceived += curBytes;
PrevBytes = (int)e.BytesReceived;
};
ticker.Elapsed += (sender, e) =>
{
double dataPoint = (double)CurrentBytesReceived / watch.ElapsedMilliseconds;
DataPoints[NumCounts++ % maxPoints] = dataPoint;
Speed = DataPoints.Average() * 1024;
CurrentBytesReceived = 0;
ElapsedTimeInSeconds += 1;
watch.Restart();
};
}
public string DoPost(string url,
string contentType,
IDictionary <string, string> headParams,
string bodyParam,
SecurityProtocolType securityProtocolType = SecurityProtocolType.Tls,
int timeOut = 200000,
bool isSecurity = false)
{
if (isSecurity)
{
ServicePointManager.SecurityProtocol = securityProtocolType;
}
ServicePointManager.DefaultConnectionLimit = 1000;
var wc = new CustomWebClient();
wc.Timeout = timeOut;
wc.Encoding = Encoding.UTF8;
wc.Headers.Add(HttpRequestHeader.ContentType, contentType);
//添加参数
if (headParams != null)
{
foreach (KeyValuePair <string, string> s in headParams)
{
wc.Headers.Add(s.Key, s.Value);
}
}
var buffer = Encoding.UTF8.GetBytes(bodyParam);
var resultBuffer = wc.UploadData(url, buffer);
return(Encoding.UTF8.GetString(resultBuffer));
}
public string DoPost(string url,
string questParam,
IDictionary <string, string> headParams = null,
bool security = false,
SecurityProtocolType protocolType = SecurityProtocolType.Ssl3,
int timeout = 200000)
{
if (security)
{
ServicePointManager.SecurityProtocol = protocolType;
}
ServicePointManager.DefaultConnectionLimit = 1000;
var wc = new CustomWebClient();
wc.Encoding = Encoding.UTF8;
wc.Timeout = timeout;
wc.Headers.Add(HttpRequestHeader.ContentType, "application/x-www-form-urlencoded");
//添加参数
if (headParams != null)
{
foreach (KeyValuePair <string, string> s in headParams)
{
wc.Headers.Add(s.Key, s.Value);
}
}
var buffer = Encoding.UTF8.GetBytes(questParam);
var resultBuffer = wc.UploadData(url, buffer);
return(Encoding.UTF8.GetString(resultBuffer));
}
public async Task <string> DoGetAsync(string url,
string requestParam,
IDictionary <string, string> headParams = null,
int timeout = 20000)
{
var wc = new CustomWebClient();
wc.Encoding = Encoding.UTF8;
if (headParams != null)
{
foreach (var s in headParams)
{
wc.Headers.Add(s.Key, s.Value);
}
}
ServicePointManager.DefaultConnectionLimit = 1000;
wc.Timeout = timeout;
var uri = string.Format("{0}?{1}", url, requestParam);
var resultBytes = await wc.DownloadDataTaskAsync(uri);
var result = Encoding.UTF8.GetString(resultBytes);
return(result);
}
public string SendData(string ClientCode, string EventCode, string urlToPost, string dataToPost, string contentType, int TimeOutInMsSecs, string ID, string IDExtra, string HeaderAuthorizationValue, string expectedResult = "", int dealyJob = 0, string parentJobId = "")
{
if (dealyJob != 0)
{
System.Threading.Thread.Sleep(dealyJob);
}
using (CustomWebClient wc = new CustomWebClient(TimeOutInMsSecs))
{
//Header Autorization Value
if (!string.IsNullOrEmpty(HeaderAuthorizationValue))
{
wc.Headers[HttpRequestHeader.Authorization] = HeaderAuthorizationValue;
}
wc.Headers[HttpRequestHeader.ContentType] = contentType;
wc.Headers.Add("WebhookHub_ClientCode", ClientCode);
wc.Headers.Add("WebhookHub_EventCode", EventCode);
wc.Headers.Add("WebhookHub_ID", ID);
wc.Headers.Add("WebhookHub_IDExtra", IDExtra);
string HtmlResult = wc.UploadString(new Uri(urlToPost), dataToPost);
if (!string.IsNullOrEmpty(expectedResult) && HtmlResult != expectedResult)
{
throw new Exception("[Unexpected content result]");
}
return(HtmlResult);
}
}
protected override void StartNextDownload()
{
try
{
Directory.CreateDirectory(DownloadsController.CurrentDownload.Destination.FullPath);
//Http is way more simple than FTP, since it has a built in background worker, no authentication and no folders
using (client = new CustomWebClient())
{
speed = new DownloadSpeed(client);
speed.Start();
client.Credentials = Credentials;
client.DownloadProgressChanged += CustomWebClientDownloadProgressChanged;
client.DownloadFileCompleted += CustomWebClientDownloadCompleted;
OnDownloadStarted();
//downloads the file and save in the selected destination
client.DownloadFileAsync(new Uri(DownloadsController.CurrentDownload.RemoteFileInfo.Url), UpdateFileNameWithDistinguishedName());
}
}
catch (Exception e)
{
DownloadsController.CurrentDownload.ChangeState(DownloadState.Error, true);
OnProcessError(new DownloadErrorEventArgs(ErrorType.GeneralErrorOnDownload, DownloadsController.CurrentDownload.RemoteFileInfo.FileFullName, e));
}
finally
{
//the progress of the download list has changed
OnOverallProgressChanged();
}
}
public void Dispose()
{
if (_wc != null)
{
_wc.Dispose();
_wc = null;
}
}
/// <summary>
/// Creates a new instance
/// </summary>
public WebClientDownloader()
{
cancellationToken = new CancellationTokenSource();
webClient = new CustomWebClient();
webClient.DownloadDataCompleted += WebClient_DownloadDataCompleted;
FetchTempo = new List <TimeSpan>();
}
private CustomWebClient createHttpClient(string username, string password)
{
CustomWebClient client = new CustomWebClient(username, password);
client.Credentials = new NetworkCredential(username, password);
return(client);
}
public void DownloadAudio(string videoId, TrackModel track)
{
string url = "https://youtubemp3api.com/@grab?vidID=" + videoId + "&format=mp3&streams=mp3&api=button";
string referer = "https://youtubemp3api.com/@api/button/mp3/" + videoId;
var fileName = CleanFileName(track.Artist + " - " + track.Name);
try
{
using (var webClient = new CustomWebClient())
{
webClient.Headers.Add("Referer", referer);
var response = webClient.DownloadData(url);
CQ cq = Encoding.Default.GetString(response);
var mp3Url = cq["a.q320"].FirstOrDefault().GetAttribute("href");
Console.WriteLine(DateTime.Now.TimeOfDay + " STARTED: " + fileName + " from: https://www.youtube.com/watch?v=" + videoId);
var mp3File = webClient.DownloadData(mp3Url);
Directory.CreateDirectory(@"Downloads/");
FileStream fileStream = new FileStream(
$@"Downloads/{fileName}.mp3", FileMode.OpenOrCreate,
FileAccess.ReadWrite, FileShare.None);
fileStream.Write(mp3File, 0, mp3File.Length);
fileStream.Close();
//Set tags
var fileForTags = TagLib.File.Create($@"Downloads/{fileName}.mp3"); // Change file path accordingly.
fileForTags.Tag.Title = track.Name;
fileForTags.Tag.Album = track.Album;
fileForTags.Tag.Performers = new string[] { track.Artist };
if (track.Images != null)
{
var thumbnail = webClient.DownloadData(track.Images.FirstOrDefault().Url);
Picture picture = new Picture(new ByteVector(thumbnail));
fileForTags.Tag.Pictures = new Picture[] { picture };
}
// Save Changes:
fileForTags.Save();
}
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(DateTime.Now.TimeOfDay + " ERROR: when downloading or writing " + fileName);
Console.WriteLine("Details: " + e.Message + Environment.NewLine + e.StackTrace + Environment.NewLine + e.InnerException);
Console.ResetColor();
}
}
private CustomWebClient GetClient(string url)
{
var client = new CustomWebClient(url);
client.Headers.Add("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36");
client.Headers.Add("origin", "https://eksisozluk.com");
client.Headers.Add("upgrade-insecure-requests", "1");
client.Headers.Add("x-requested-with", "XMLHttpRequest");
return(client);
}
public TweetDeckBrowser(Window window, PluginManager pluginManager)
{
this.View = CustomWebClient.CreateWebView(PopupHandler.Instance);
var extraContext = new TweetDeckExtraContext();
var browserComponent = new CefBrowserComponent(window, View, handler => new ContextMenuBrowser(handler, extraContext));
var _ = new TweetDeckBrowserImpl(browserComponent, new TweetDeckInterfaceImpl(this), extraContext, this, pluginManager);
View.LoadUrl(TwitterUrls.TweetDeck);
}
public BaseWebAPI(ProxyConfig proxyConfig)
{
UseAuth = true;
WebClient = new CustomWebClient(proxyConfig)
{
JsonSettings =
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}
};
}
public override BuildResults Crawl()
{
string randomFilePath = this.PrepareFolderAndRandomFile();
Exception exception = null;
//CustomHttpCrawler client = new CustomHttpCrawler(new Uri(base.URI), randomFilePath, this.Encoding, this.LocalVersion, this.UserAgent);
using (CustomWebClient client = new CustomWebClient(new Uri(base.URI), randomFilePath, this.Encoding, this.LocalVersion, this.UserAgent, proxyType))
{
if (this.ManualProxy != null)
{
client.ManualProxy = this.ManualProxy;
}
//[Bug 730427:DownloadFileActivity need return directly when set manully proxy and download failed]
for (int count = 0; count < CustomWebClient.ProxyList.Count; count++)
{
BuildResults result = client.DownloadFile();
this.RemoteVersion = client.RemoteVersion;
exception = client.Exception;
switch (result)
{
case BuildResults.Crawler_Succeed:
FileHelper.MoveFile(randomFilePath, this.LocalPath);
return(BuildResults.Crawler_Succeed);
case BuildResults.Crawler_NoNewFileFound:
return(result);
case BuildResults.Crawler_404NotFound:
throw exception;
case BuildResults.Crawler_RemoteServerNoResponse:
case BuildResults.Crawler_UnexpectedError:
//System.Threading.Thread.Sleep(5 * 1000);
break;
case BuildResults.Crawler_ProtocolError:
throw exception;
}
}
}
if (exception == null)
{
return(BuildResults.Crawler_UnexpectedError);
}
else
{
throw exception;
}
}
public PrepatchManager()
{
this._LastKnownLatestVersion = string.Empty;
this._isbusy = false;
this.syncContext = System.Threading.SynchronizationContext.Current;
this.myWebClient = WebClientPool.GetWebClient_PSO2Download(true);
this.myFileList = new MemoryFileCollection();
this.bWorker = new BackgroundWorker();
this.bWorker.WorkerReportsProgress = true;
this.bWorker.WorkerSupportsCancellation = true;
this.bWorker.DoWork += BWorker_DoWork;
this.bWorker.RunWorkerCompleted += BWorker_RunWorkerCompleted;
}
public static async Task <string> HttpDownloadStringAsync(
string uri,
Configure <WebClient> clientConfigurator = null,
Action <WebHeaderCollection> headerConfigurator = null,
Action <WebRequest> requestConfigurator = null)
{
WebClient webClient = new CustomWebClient(requestConfigurator);
webClient = clientConfigurator.InvokeSafe(webClient);
headerConfigurator?.Invoke(webClient.Headers);
return(await webClient.DownloadStringTaskAsync(new Uri(uri)));
}
public void ImportN2DataFromXml(ITaskContext context, string WebAppBaseUrl)
{
CustomWebClient client = new CustomWebClient();
var n2ExportFiles = Directory.GetFiles(@"Packages\WebApp\Content\N2Exports", "*.xml");
client.BaseAddress = WebAppBaseUrl;
context.LogInfo($"Found file {n2ExportFiles[0]}");
var n2ExportFile = Path.GetFullPath(n2ExportFiles[0]);
context.LogInfo($"Started importing n2 data to {N2Table} table.");
var resposne = client.DownloadString($"/n2export/import?filename={n2ExportFile}");
context.LogInfo("n2 data imported.");
}
public async Task UploadAsync(string url, IDictionary<string, string> headers, string method, byte[] data)
{
using (var client = new CustomWebClient())
{
SubscribeToUploadEvents(client);
if (headers != null)
{
foreach (var header in headers)
client.Headers[header.Key] = header.Value;
}
await client.UploadDataTaskAsync(url, "PUT", data);
UnsubscribeFromUploadEvents(client);
}
}
public string PostJson(string url, string json, int timeoutInSeconds, IEnumerable <Tuple <string, string> > additionalHeaders = null)
{
string response;
using (var webClient = new CustomWebClient(timeoutInSeconds))
{
webClient.Headers.Add(HttpRequestHeader.ContentType, JsonMimeType);
SetAdditionalHeaders(additionalHeaders, webClient);
response = webClient.UploadString(url, json);
}
return(response);
}
public static async Task HttpDownloadFileAsync(
string uri,
string path,
Configure <WebClient> clientConfigurator = null,
Action <WebHeaderCollection> headerConfigurator = null,
Action <WebRequest> requestConfigurator = null)
{
WebClient webClient = new CustomWebClient(requestConfigurator);
webClient = clientConfigurator.InvokeSafe(webClient);
headerConfigurator?.Invoke(webClient.Headers);
FileSystemTasks.EnsureExistingParentDirectory(path);
await webClient.DownloadFileTaskAsync(new Uri(uri), path);
}
public async Task<byte[]> DownloadAsync(string url, IDictionary<string, string> headers, string method)
{
using (var client = new CustomWebClient())
{
SubscribeToDownloadEvents(client);
if (headers != null)
{
foreach (var header in headers)
client.Headers[header.Key] = header.Value;
}
var result = await client.DownloadDataTaskAsync(url);
UnsubscribeFromDownloadEvents(client);
return result;
}
}
public async Task UploadAsync(string url, IDictionary <string, string> headers, string method, byte[] data)
{
using (var client = new CustomWebClient())
{
SubscribeToUploadEvents(client);
if (headers != null)
{
foreach (var header in headers)
{
client.Headers[header.Key] = header.Value;
}
}
await client.UploadDataTaskAsync(url, "PUT", data);
UnsubscribeFromUploadEvents(client);
}
}
public async Task <byte[]> DownloadAsync(string url, IDictionary <string, string> headers, string method)
{
using (var client = new CustomWebClient())
{
SubscribeToDownloadEvents(client);
if (headers != null)
{
foreach (var header in headers)
{
client.Headers[header.Key] = header.Value;
}
}
var result = await client.DownloadDataTaskAsync(url);
UnsubscribeFromDownloadEvents(client);
return(result);
}
}
public void GetLastDweet()
{
var uri = "https://dweet.io/get/latest/dweet/for/" + _thing;
Log.Instance.Debug("Get last dweet from: {0}", uri);
try
{
using (var wc = new CustomWebClient())
{
wc.OpenReadCompleted += WebClient_OpenReadCompleted;
wc.OpenReadAsync(new Uri(uri));
}
}
catch (Exception e)
{
Log.Instance.Error(e);
}
}
public static bool HasLicense()
{
using (CustomWebClient client = new CustomWebClient())
{
try
{
string content = client.DownloadString(page + "?uhid=" + uhid);
if (content == successStr)
{
return(true);
}
}
catch
{
ServerOffline();
return(true);
}
}
return(false);
}
public static bool SendKey(string key)
{
using (CustomWebClient client = new CustomWebClient())
{
try
{
string content = client.DownloadString(page + "?uhid=" + uhid + "&key=" + key);
if (content == successStr)
{
return(true);
}
}
catch
{
ServerOffline();
return(true);
}
}
return(true);
}
public bool ListenForDweets(Action <Dweet> dweetHandler)
{
_dweetHandler = dweetHandler;
Log.Instance.Debug("Initialize CustomWebClient...");
_webClient = new CustomWebClient
{
KeepAlive = true,
Timeout = new TimeSpan(0, 0, 0, 3)
};
var uri = "https://dweet.io/listen/for/dweets/from/" + _thing;
Log.Instance.Debug("Begin listening dweets from: {0}", uri);
var wr = (HttpWebRequest)WebRequest.Create(uri);
wr.ProtocolVersion = Version.Parse("1.0");
var response = (HttpWebResponse)wr.GetResponse();
try
{
_webClient.OpenReadCompleted += WebClient_OpenReadCompleted;
_webClient.OpenReadAsync(new Uri(uri));
}
catch (Exception e)
{
Log.Instance.Error(e);
}
// If web client is busy, then connection is open
_isListening = _webClient.IsBusy;
return(_isListening);
}
Torrent Download(Episode episode, EpisodeTorrentSearcherResult result)
{
var webClient = new CustomWebClient();
if(!Directory.Exists("Torrents")) Directory.CreateDirectory("Torrents");
var fileName = @"torrents\" + result.Title + ".torrent";
try {
webClient.DownloadFile(result.DownloadURL, fileName);
} catch(Exception e) {
Logger.Build().Episode(episode.ID).Message("Error downloading torrent: " + result.DownloadURL + " - " + e).Error();
return null;
}
Torrent torrent;
try {
torrent = TorrentParser.ParseFile(fileName);
} catch(Exception e) {
Logger.Build().Episode(Episode.ID).Message("Error parsing torrent file: " + fileName + "-->" + e).Error();
return null;
}
return torrent;
}
void ThreadMain(object state)
{
var auth = (OAuthAuthorization)state;
this.Account = auth.Token;
this.Terminated = false;
try
{
var ub = new UriBuilder(TwitterUriBuilder.Stream.User(this.Track, this.Follows));
var query = string.IsNullOrEmpty(ub.Query) ? null : ub.Query.TrimStart('?');
ub.Query = null;
using (var wc = new CustomWebClient
{
Headers =
{
{ HttpRequestHeader.UserAgent, "Solar/" + Assembly.GetEntryAssembly().GetName().Version },
},
})
using (var ns = wc.OpenPost(ub.Uri, (string.IsNullOrEmpty(query) ? null : query + "&") + auth.CreateParameters("POST", ub.Uri, query)))
using (var sr = new StreamReader(ns))
{
Connected.RaiseEvent(this, EventArgs.Empty);
try
{
foreach (var i in sr.EnumerateLines()
.Where(_ => !string.IsNullOrEmpty(_))
.Select(DynamicJson.Parse))
{
if (IsDelete(i))
{
// delete
if (i.delete.status())
DeleteStatus.RaiseEvent(this, new EventArgs<StatusID>(i.delete.status.id));
}
else if (IsFriends(i))
{
// friends
Friends.RaiseEvent(this, new EventArgs<IList<UserID>>(((dynamic[])i.friends).Select(_ => (UserID)_).Freeze()));
}
else if (IsEvent(i))
{
// event
using (var client = new TwitterClient(auth.Token, StatusCache))
{
var e = new TwitterStreamEventArgs(client, i);
switch (e.Type)
{
case "follow":
if (e.Source.UserID == this.Account.UserID)
Follow.RaiseEvent(this, e);
else
Followed.RaiseEvent(this, e);
break;
case "unfollow":
Unfollow.RaiseEvent(this, e);
break;
case "block":
Block.RaiseEvent(this, e);
break;
case "unblock":
Unblock.RaiseEvent(this, e);
break;
case "favorite":
if (e.Source.UserID == this.Account.UserID)
Favorite.RaiseEvent(this, e);
else
Favorited.RaiseEvent(this, e);
break;
case "unfavorite":
if (e.Source.UserID == this.Account.UserID)
Unfavorite.RaiseEvent(this, e);
else
Unfavorited.RaiseEvent(this, e);
break;
case "retweet":
if (e.Source.UserID == this.Account.UserID)
Retweet.RaiseEvent(this, e);
else
Retweeted.RaiseEvent(this, e);
break;
}
}
}
else if (IsDirectMessage(i))
{
// direct message
using (var client = new TwitterClient(auth.Token, StatusCache))
DirectMessage.RaiseEvent(this, new EventArgs<DirectMessage>(new DirectMessage(client, i.direct_message)));
}
else if (IsStatus(i))
{
// status
using (var client = new TwitterClient(auth.Token, StatusCache))
Status.RaiseEvent(this, new EventArgs<Status>(new Status(client, i)));
}
}
}
finally
{
wc.LastRequest.Abort();
}
}
}
catch (ThreadAbortException)
{
}
catch (WebException ex)
{
WebError.RaiseEvent(this, new EventArgs<WebException>(ContentedWebException.Create(ex)));
}
catch (IOException ex)
{
ConnectionError.RaiseEvent(this, new EventArgs<IOException>(ex));
}
catch (Exception ex)
{
Exception.RaiseEvent(this, new EventArgs<Exception>(ex));
}
finally
{
streamingThread = null;
Disconnected.RaiseEvent(this, EventArgs.Empty);
this.Terminated = true;
}
}
public PreemptiveHttpClient(string username, string password)
{
_httpClient = createHttpClient(username, password);
}
public Image GetImage(string url, int size)
{
using (CustomWebClient customWebClient = new CustomWebClient())
return((Image) new Bitmap(Image.FromStream((Stream) new MemoryStream(customWebClient.DownloadData(url.Replace("bdocodex.com", "bddatabase.net")))), new Size(size, size)));
}
/// <summary>
/// Uploads the zip to the dataImportAPI
/// </summary>
/// <param name='zipPath'>
/// Path to the zip file (containing data and xml configuration) to upload
/// </param>
/// <param name='action'>
/// Import action. Can be 'overwrite' or 'append'
/// </param>
/// <param name='runAsBackground'>
/// determines if the SpatialKey server should return as soon as the data is uploaded
/// (thus freeing up your connection), or should it wait for the entire import process to complete
/// </param>
/// <param name='notifyByEmail'>
/// if set as true the SpatialKey server will send an email to the authenticated user when the import is complete
/// </param>
/// <param name='addAllUsers'>
/// if set as true the SpatialKey server will add the All Users group as a viewer of the dataset
/// </param>
public void UploadZip(string zipPath, string action = "overwrite", bool runAsBackground = true, bool notifyByEmail = false, bool addAllUsers = false)
{
Authenticate ();
string path = "/SpatialKeyFramework/dataImportAPI";
string url = String.Format ("{0}{1}{2}",
_protocol,
clusterHost,
path,
action,
runAsBackground.ToString().ToLower(),
notifyByEmail.ToString().ToLower(),
addAllUsers.ToString().ToLower());
Log(String.Format("UploadZip: {0} {1}", url, zipPath));
// create the jsessionID cookie
CookieContainer cookieJar = new CookieContainer ();
Cookie cookie = new Cookie(_jsessionID.Name, _jsessionID.Value);
cookieJar.Add(new Uri(String.Format("{0}{1}", _protocol, clusterHost)), cookie);
CustomWebClient client = new CustomWebClient(cookieJar);
// add the query string
NameValueCollection query = new NameValueCollection();
query.Add("action", action);
query.Add("runAsBackground", runAsBackground.ToString().ToLower());
query.Add("notifyByEmail", notifyByEmail.ToString().ToLower());
query.Add("addAllUsers", addAllUsers.ToString().ToLower());
client.QueryString = query;
Log(NameValueCollectionToString(query));
byte[] response = client.UploadFile(url, zipPath);
Log(Encoding.ASCII.GetString(response));
Log("UploadZip: Complete");
}
