public async Task <IActionResult> Edit(int id, [Bind("IssueCategory,Priority,ConsultationId,Id")] QueueDTO queue)
{
if (id != queue.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _service.UpdateAsync(queue);
}
catch (DbUpdateConcurrencyException)
{
if (!_service.QueueExists(queue.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
var consultations = await _consultationService.GetAllAsync();
ViewData["ConsultationId"] = new SelectList(consultations, "Id", "Id", queue.ConsultationId);
return(View(queue));
}
public void SetUp()
{
_queueService = new Mock <IQueueService>();
_queueController = new QueueController(_queueService.Object);
queue = new QueueDTO {
Id = 1, ConsultationId = 1, IssueCategory = IssueCategory.Pass, Priority = 1
};
}
public async Task InsertQueueItemAsync(QueueDTO queueItem)
{
await _sqlService
.ExecuteAsync
(
_connectionString,
INSERT_QUEUE_ITEM,
queueItem,
commandType : CommandType.Text
).ConfigureAwait(false);
}
public async Task UpdateQueueItemAsync(QueueDTO queueItem)
{
await _sqlService
.ExecuteAsync
(
_connectionString,
UPDATE_QUEUE_DATA_BY_QUEUEID_DESC,
queueItem,
commandType : CommandType.Text
).ConfigureAwait(false);
}
public static Queue AdaptToQueue(this QueueDTO p1)
{
return(p1 == null ? null : new Queue()
{
IssueCategory = p1.IssueCategory.ToString(),
Priority = p1.Priority,
ConsultationId = p1.ConsultationId,
Id = p1.Id,
Consultation = p1.Consultation.AdaptToConsultation()
});
}
public async Task <IActionResult> Update([FromBody] QueueDTO queue)
{
if (queue is null)
{
return(BadRequest());
}
await _queueService.UpdateAsync(queue);
return(Ok());
}
public async Task <IActionResult> Create([Bind("IssueCategory,Priority,ConsultationId,Id")] QueueDTO queue)
{
if (ModelState.IsValid)
{
await _service.AddAsync(queue);
return(RedirectToAction(nameof(Index)));
}
var consultations = await _consultationService.GetAllAsync();
ViewData["ConsultationId"] = new SelectList(consultations, "Id", "Id", queue.ConsultationId);
return(View(queue));
}
public async Task <IActionResult> Add([FromBody] QueueDTO queue)
{
try
{
await _queueService.AddAsync(queue);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(CreatedAtAction(nameof(Add), new { queue.Id }, queue));
}
public static QueueDTO AdaptTo(this Queue p6, QueueDTO p7)
{
if (p6 == null)
{
return(null);
}
QueueDTO result = p7 ?? new QueueDTO();
result.IssueCategory = (IssueCategory)Enum.Parse(typeof(IssueCategory), p6.IssueCategory);
result.Priority = p6.Priority;
result.ConsultationId = p6.ConsultationId;
result.Consultation = p6.Consultation.AdaptToDTO();
result.Id = p6.Id;
return(result);
}
public static Queue AdaptTo(this QueueDTO p2, Queue p3)
{
if (p2 == null)
{
return(null);
}
Queue result = p3 ?? new Queue();
result.IssueCategory = p2.IssueCategory.ToString();
result.Priority = p2.Priority;
result.ConsultationId = p2.ConsultationId;
result.Consultation = p2.Consultation.AdaptToConsultation();
result.Id = p2.Id;
return(result);
}
public async Task UpdateAsync(QueueDTO queue)
{
_unitOfWork.QueueRepository.Update(queue.AdaptToQueue());
await _unitOfWork.CommitAsync();
}
public async Task AddAsync(QueueDTO queue)
{
await _unitOfWork.QueueRepository.InsertAsync(queue.AdaptToQueue());
await _unitOfWork.CommitAsync();
}
public int TaskFunction(QueueDTO item, ProxyDTO proxy = null)
{
int code = -1;
Console.WriteLine("{0} started", item.id);
int views = item.views_work;
int likes = item.likes_work;
var url = item.url;
if (likes > views)
{
views = likes;
item.views_work = item.likes_work;
}
Console.WriteLine("Started");
try
{
if (proxy != null)
{
this.SetProxy(proxy);
}
driver.Navigate().GoToUrl(url);
Actions action = new Actions(driver);
var elems = driver.FindElements(By.ClassName("Project-projectStat-6Y3"));
Console.WriteLine("Waiting for views\\likes\\comments block");
elems = (new WebDriverWait(driver, TimeSpan.FromMinutes(2))).
Until(SeleniumExtras.WaitHelpers.ExpectedConditions.VisibilityOfAllElementsLocatedBy(By.ClassName("Project-projectStat-6Y3")));
action.MoveToElement(elems[1]);
var visits = elems[1].GetAttribute("innerHTML");
int pFrom = visits.IndexOf(">") + ">".Length;
int pTo = visits.LastIndexOf("<");
String result = visits.Substring(pFrom, pTo - pFrom);
Console.WriteLine("Waiting for jQuery to finish");
(new WebDriverWait(driver, TimeSpan.FromMinutes(2))).Until(
d => (bool)(d as IJavaScriptExecutor).ExecuteScript("return window.jQuery != undefined && jQuery.active === 0"));
if (item.likes_work > 0)
{
var like = driver.FindElement(By.ClassName("Appreciate-wrapper-9hi"));
var inner_before = like.GetAttribute("innerHTML");
action.MoveToElement(like);
Console.WriteLine("Waiting for like button");
like = (new WebDriverWait(driver, TimeSpan.FromMinutes(2))).
Until(SeleniumExtras.WaitHelpers.ExpectedConditions.ElementIsVisible(By.ClassName("Appreciate-wrapper-9hi")));
action.MoveToElement(like);
like.Click();
Console.WriteLine("Waiting for jQuery to finish");
(new WebDriverWait(driver, TimeSpan.FromMinutes(2))).Until(
d => (bool)(d as IJavaScriptExecutor).ExecuteScript("return window.jQuery != undefined && jQuery.active === 0"));
var inner_after = like.GetAttribute("innerHTML");
if (inner_after.Contains("Appreciate-count-") && !inner_after.Equals(inner_before))
{
item.likes_work -= 1;
}
}
Console.WriteLine("Done");
this.Sleep((new Random()).Next(5000, 10001));
Console.WriteLine("Done sleeping");
item.views_work -= 1;
code = 1;
}
catch (Exception e)
{
Console.WriteLine("Error");
System.Console.WriteLine(e.Message);
code = -1;
}
return(code);
}
async Task DoMain()
{
try
{
var services = InitializeDependencyInjection();
ConfigureServices(services);
using var provider = services.BuildServiceProvider();
var dickinsonBrosSQLRunnerDBService = provider.GetRequiredService <IDickinsonBrosSQLRunnerDBService>();
var hostApplicationLifetime = provider.GetService <IHostApplicationLifetime>();
var queueItem = new QueueDTO
{
Payload = @"{""X"": ""1""}"
};
var queueItems = new List <QueueDTO>
{
queueItem,
queueItem,
queueItem,
queueItem,
queueItem
};
//ExecuteAsync (Delete, Insert Item, Insert Items)
await dickinsonBrosSQLRunnerDBService.DeleteAllMixedItemsAsync().ConfigureAwait(false);
await dickinsonBrosSQLRunnerDBService.DeleteAllQueueItemsAsync().ConfigureAwait(false);
await dickinsonBrosSQLRunnerDBService.InsertQueueItemAsync(queueItem).ConfigureAwait(false);
await dickinsonBrosSQLRunnerDBService.InsertQueueItemsAsync(queueItems).ConfigureAwait(false);
//BulkCopyAsync
await dickinsonBrosSQLRunnerDBService.BulkInsertQueueItemsAsync(queueItems).ConfigureAwait(false);
await dickinsonBrosSQLRunnerDBService.BulkInsertQueueItemsViaIEnumerableAsync(queueItems).ConfigureAwait(false);
//Note: This is looking for most common cases, and common edge cases
var mixedItems = new List <MixedDTO>
{
GeneratingMixedDTO(),
GeneratingMixedDTO(),
GeneratingMixedDTO()
};
await dickinsonBrosSQLRunnerDBService.BulkInsertMixedItemsViaIEnumerableAsync(mixedItems).ConfigureAwait(false);
//QueryFirstAsync
var queueItemObserved = await dickinsonBrosSQLRunnerDBService.QueryQueueFirstAsync().ConfigureAwait(false);
//QueryFirstOrDefaultAsync
var queueItemOrDefaultObserved = await dickinsonBrosSQLRunnerDBService.QueryQueueFirstOrDefaultAsync().ConfigureAwait(false);
//QueryAsync
var queueItemsObserved = await dickinsonBrosSQLRunnerDBService.SelectLast50QueueItemsProc().ConfigureAwait(false);
//ExecuteAsync (Update)
queueItemObserved.Payload = @"{""X"": ""2""}";
await dickinsonBrosSQLRunnerDBService.UpdateQueueItemAsync(queueItemObserved).ConfigureAwait(false);
Console.WriteLine("HostApplicationLifetime StopApplication");
hostApplicationLifetime.StopApplication();
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
Console.WriteLine("End...");
Console.ReadKey();
}
}
