public static void AddToQueue(ParsedUrl parsedUrl, Action <ParsedUrl> callback)
{
parsedUrl.AddLog(LoggerTypes.Debug, $"Added url to activation queue");
parsedUrl.Status = StatusType.Pending;
Items.Enqueue(new Task(() => ClickUrl(parsedUrl, callback)));
QueueNotifier.Set();
}
public override void Start()
{
var fileContent = "";
using (var sr = new StreamReader(Settings.Path))
{
fileContent = sr.ReadToEnd();
}
var matches = _reg.Matches(fileContent);
if (matches.Count == 0)
{
return;
}
_total = _total + matches.Count;
ImapEvent?.Invoke(this, $"A: {_activatedCount}, P: {_processedCount}, T: {_total}");
foreach (Match match in matches)
{
var url = match.Value;
var parsedUrl = new ParsedUrl
{
Url = url,
Status = StatusType.Pending
};
Interlocked.Increment(ref _processedCount);
parsedUrl.AddLog(LoggerTypes.Success, $"Added url {url}");
ParsedUrls.Add(parsedUrl);
OnParsedLinkEvent(this, parsedUrl);
ActivateQueue.AddToQueue(parsedUrl, Callback);
}
ImapEvent?.Invoke(this, $"A: {_activatedCount}, P: {_processedCount}, T: {_total}");
}
private async void Callback(ParsedUrl parsedUrl)
{
if (!parsedUrl.Verified)
{
ActivateQueue.AddToQueue(parsedUrl, Callback);
ProxyHandlerSingleton.Instance.IncreaseFailCounter(parsedUrl.Proxy);
}
else if (_worker.Client.IsConnected && _worker.Client.IsAuthenticated)
{
try
{
try
{
await _worker.Client.Inbox.OpenAsync(FolderAccess.ReadWrite);
}
catch (Exception e)
{
parsedUrl.AddLog(LoggerTypes.Exception, $"Marked Uid {parsedUrl.Uid} as seen", e);
}
Interlocked.Increment(ref _activatedCount);
await _worker.Client.Inbox.AddFlagsAsync(parsedUrl.Uid, MessageFlags.Seen, true);
parsedUrl.AddLog(LoggerTypes.Debug, $"Marked Uid {parsedUrl.Uid} as seen");
parsedUrl.Proxy = null;
}
catch (Exception e)
{
parsedUrl.AddLog(LoggerTypes.Exception, $"Marked Uid {parsedUrl.Uid} as seen", e);
}
}
}
public LogForm(ParsedUrl account)
{
this._parsedUrl = account;
InitializeComponent();
this._parsedUrl.EventLogAdded += EventLogAdded;
this.Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
objectListView1.BackColor = Color.FromArgb(43, 43, 43);
objectListView1.ForeColor = Color.LightGray;
}
private void Callback(ParsedUrl parsedUrl)
{
if (!parsedUrl.Verified)
{
ActivateQueue.AddToQueue(parsedUrl, Callback);
ProxyHandlerSingleton.Instance.IncreaseFailCounter(parsedUrl.Proxy);
}
else
{
Interlocked.Increment(ref _activatedCount);
parsedUrl.AddLog(LoggerTypes.Debug, $"{parsedUrl.Url} was verified");
}
}
private void WorkerOnParsedLinkEvent(object sender, ParsedUrlEventArgs parsedUrlEventArgs)
{
var parsedUrl = new ParsedUrl
{
Url = parsedUrlEventArgs.ParsedUrl,
Uid = parsedUrlEventArgs.UniqueId,
Status = StatusType.Pending
};
parsedUrl.AddLog(LoggerTypes.Success, $"URL TO: {parsedUrlEventArgs.To}, FROM: {parsedUrlEventArgs.From}");
ParsedUrls.Add(parsedUrl);
OnParsedLinkEvent(this, parsedUrl);
ActivateQueue.AddToQueue(parsedUrl, Callback);
}
private async void Callback(ParsedUrl parsedUrl)
{
if (!parsedUrl.Verified)
{
ActivateQueue.AddToQueue(parsedUrl, Callback);
ProxyHandlerSingleton.Instance.IncreaseFailCounter(parsedUrl.Proxy);
}
else
{
var wasOpen = true;
try
{
try
{
if (!_worker.Client.IsConnected)
{
await _worker.Client.ConnectAsync(_worker.EmailUrlParserConfiguration.GetUri())
.ConfigureAwait(false);
}
if (!_worker.Client.IsAuthenticated)
{
await _worker.Client.AuthenticateAsync(_worker.EmailUrlParserConfiguration.GetCredential());
}
if (!_worker.Client.Inbox.IsOpen)
{
wasOpen = false;
await _worker.Client.Inbox.OpenAsync(FolderAccess.ReadWrite);
}
}
catch (Exception e)
{
parsedUrl.AddLog(LoggerTypes.Exception, $"Failed to activate {parsedUrl.Uid}", e);
}
Interlocked.Increment(ref _activatedCount);
await _worker.Client.Inbox.AddFlagsAsync((UniqueId)parsedUrl.Uid, MessageFlags.Seen, true);
parsedUrl.AddLog(LoggerTypes.Debug, $"Marked Uid {parsedUrl.Uid} as seen");
parsedUrl.Proxy = null;
}
catch (Exception e)
{
parsedUrl.AddLog(LoggerTypes.Exception, $"Failed to activate {parsedUrl.Uid}", e);
}
}
}
private void AssertStandardRouteValuesArePresentAndCorrect(ParsedUrl actual, int index, int expectedQty, string expectedCode, DateTime expectedStateDate)
{
var qtyKey = string.Format(StandardQtyRouteValueKey, index);
Assert.IsTrue(actual.RouteValues.ContainsKey(qtyKey));
Assert.AreEqual(expectedQty, actual.RouteValues[qtyKey]);
var codeKey = string.Format(StandardCodeRouteValueKey, index);
Assert.IsTrue(actual.RouteValues.ContainsKey(codeKey));
Assert.AreEqual(expectedCode, actual.RouteValues[codeKey]);
var startDateKey = string.Format(StandardStartDateRouteValueKey, index);
Assert.IsTrue(actual.RouteValues.ContainsKey(startDateKey));
Assert.AreEqual(expectedStateDate, actual.RouteValues[startDateKey]);
}
public void FormatHttpUrlWithPortOtherThan80()
{
var parsedUrl = new ParsedUrl
{
Scheme = "http",
Host = "www.test.local",
Port = 8080,
Path = "/some/path"
};
var urlFormatted = _urlFormatter.Format(
parsedUrl);
Assert.IsNotNull(urlFormatted);
Assert.AreEqual(
"http://www.test.local:8080/some/path",
urlFormatted);
}
public void FormatHttpUrl()
{
var parsedUrl = new ParsedUrl
{
Scheme = "http",
Host = "www.test.local",
Port = 80,
Path = "/"
};
var urlFormatted = _urlFormatter.Format(
parsedUrl);
Assert.IsNotNull(urlFormatted);
Assert.AreEqual(
"http://www.test.local/",
urlFormatted);
}
private static async void ClickUrl(ParsedUrl parsedUrl, Action <ParsedUrl> callback)
{
try
{
var proxy = ProxyHandlerSingleton.Instance.GetRandomProxy();
while (proxy == null)
{
parsedUrl.AddLog(LoggerTypes.Warning, "No proxies available, checking again in 5 seconds....");
await Task.Delay(5000);
proxy = ProxyHandlerSingleton.Instance.GetRandomProxy();
}
parsedUrl.Status = StatusType.Activating;
parsedUrl.Proxy = proxy;
using (var webClient = new MyWebClient())
{
if (!proxy.Address.Equals("127.0.0.1"))
{
webClient.Proxy = proxy.AsWebProxy();
}
webClient.Headers.Add("Upgrade-Insecure-Requests", "1");
webClient.Headers.Add("User-Agent", UserAgent.GenerateUserAgent());
webClient.DownloadString(parsedUrl.Url);
}
parsedUrl.Status = StatusType.Activated;
parsedUrl.Verified = true;
parsedUrl.AddLog(LoggerTypes.Success, "Url Clicked!");
}
catch (Exception e)
{
parsedUrl.Status = StatusType.Failed;
parsedUrl.Verified = false;
parsedUrl.AddLog(LoggerTypes.Exception, "Url Clicked!", e);
}
finally
{
Interlocked.Decrement(ref _queueCounter);
callback(parsedUrl);
}
}
protected virtual void OnParsedLinkEvent(object arg1, ParsedUrl arg2)
{
ParsedLinkEvent?.Invoke(arg1, arg2);
}
static public string BackToUrl(ParsedUrl parsedUrl) =>
parsedUrl.repository +
(parsedUrl.inRepository == null
? "" :
"/" + parsedUrl.inRepository.objectType + "/" + parsedUrl.inRepository.@ref + "/" + parsedUrl.inRepository.path);
