protected override async Task ExecuteAsync(WorkerRequest @event, ProcessNotificationRequest notificationRequest)
{
var jobAssignmentId = notificationRequest.JobAssignmentId;
var notification = notificationRequest.Notification;
var notificationJobPayload = notification.Content.ToMcmaObject <JobBase>();
var table = new DynamoDbTable <JobAssignment>(@event.TableName());
var jobAssignment = await table.GetAsync(jobAssignmentId);
jobAssignment.Status = notificationJobPayload.Status;
jobAssignment.StatusMessage = notificationJobPayload.StatusMessage;
if (notificationJobPayload.Progress != null)
{
jobAssignment.Progress = notificationJobPayload.Progress;
}
jobAssignment.JobOutput = notificationJobPayload.JobOutput;
jobAssignment.DateModified = DateTime.UtcNow;
await table.PutAsync(jobAssignmentId, jobAssignment);
var resourceManager = @event.GetAwsV4ResourceManager();
await resourceManager.SendNotificationAsync(jobAssignment, jobAssignment.NotificationEndpoint);
}
public FluentRecordBase AddWorkerRequest(Worker worker = null, DateTime?datecreated = null,
DateTime?dateupdated = null)
{
//
// DEPENDENCIES
_servWR = container.GetRequiredService <IWorkerRequestService>();
if (_wo == null)
{
AddWorkOrder();
}
//
// ARRANGE
_wr = (WorkerRequest)Records.request.Clone();
//_wr.workOrder = (WorkOrder)_wo.Clone();
//_wr.workerRequested = (Worker)_w.Clone();
_wr.workOrder = _wo;
_wr.workerRequested = worker ?? AddWorker();
if (datecreated != null)
{
_wr.datecreated = (DateTime)datecreated;
}
if (dateupdated != null)
{
_wr.dateupdated = (DateTime)dateupdated;
}
// ACT //huh?
// var Wentry = _dbContext.Entry(_w);
// var WOentry = _dbContext.Entry(_wo);
// var WRentry = _dbContext.Entry(_wr);
_servWR.Create(_wr, _user);
return(this);
}
public async Task Handler(WorkerRequest @event, ILambdaContext context)
{
Logger.Debug(@event.ToMcmaJson().ToString());
Logger.Debug(context.ToMcmaJson().ToString());
await Worker.DoWorkAsync(@event);
}
public void Test1()
{
var boardState = new List <PointState>[7] {
new List <PointState>()
{
PointState.White
},
new List <PointState>(),
new List <PointState>(),
new List <PointState>(),
new List <PointState>(),
new List <PointState>(),
new List <PointState>()
};
var request = new WorkerRequest()
{
board = boardState,
potezRacunala = true
};
var worker = new Worker();
var response = worker.HandleRequest(request);
Assert.IsTrue(response.parentState == (int)State.Unresolved);
Assert.IsTrue(response.children[0] == (int)State.Unresolved);
Assert.IsTrue(response.children[1] == (int)State.Unresolved);
Assert.IsTrue(response.children[2] == (int)State.Unresolved);
Assert.IsTrue(response.children[3] == (int)State.Unresolved);
Assert.IsTrue(response.children[4] == (int)State.Unresolved);
Assert.IsTrue(response.children[5] == (int)State.Unresolved);
Assert.IsTrue(response.children[6] == (int)State.Unresolved);
}
public Message GetMessage(WorkerRequest body)
{
return(new Message(body)
{
Formatter = new XmlMessageFormatter(new[] { typeof(WorkerRequest) })
});
}
public MockHttpContext(bool isSecure)
: this()
{
Thread.GetDomain().SetData(
MockHttpContext.ThreadDataKeyAppPath, MockHttpContext.ThreadDataKeyAppPathValue);
Thread.GetDomain().SetData(
MockHttpContext.ThreadDataKeyAppVPath, MockHttpContext.ThreadDataKeyAppVPathValue);
SimpleWorkerRequest request = new WorkerRequest(MockHttpContext.WorkerRequestPage,
string.Empty, new StringWriter(), isSecure);
this.context = new HttpContext(request);
HttpSessionStateContainer container = new HttpSessionStateContainer(
Guid.NewGuid().ToString("N"), new SessionStateItemCollection(), new HttpStaticObjectsCollection(),
5, true, HttpCookieMode.AutoDetect, SessionStateMode.InProc, false);
HttpSessionState state = Activator.CreateInstance(
typeof(HttpSessionState),
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.CreateInstance,
null,
new object[] { container }, CultureInfo.CurrentCulture) as HttpSessionState;
this.context.Items[ContextKeyAspSession] = state;
}
public Response <TaskRequest> RequestWork(WorkerRequest request)
{
Logger.Info(string.Format("RequestWork Begin {0} {1}", DateTime.Now.Ticks,
Thread.CurrentThread));
lock (_object)
{
var registration = _registry.GetRegistration(request.Token);
Assumes.NotNull(registration);
WorkItem workItem =
_repository.Query <WorkItem>().FirstOrDefault(wi => wi.Status == (WorkItemStatus.Pending));
Task task = null;
if (workItem != null)
{
task = _mappingEngine.Map <Task>(workItem);
workItem.AssignTo(registration);
_repository.Put(workItem);
}
var taskRequest = new TaskRequest {
NoWorkAvailable = task == null, Task = task
};
Logger.Info("RequestWork End " + DateTime.Now.Ticks + " " + Thread.CurrentThread);
return(new Response <TaskRequest>(true, "", taskRequest));
}
}
private void BtnRunTestTask_Click(object sender, EventArgs e)
{
WorkerRequest req = RequestManager.CreateRequest("test");
RequestManager.SendWorkerRequest(req);
DisplayTaskOutput("test");
}
internal static async Task ProcessNotificationAsync(WorkerRequest @event, ProcessNotificationRequest notificationRequest)
{
var jobId = notificationRequest.JobId;
var notification = notificationRequest.Notification;
var notificationJob = notification.Content.ToMcmaObject <JobBase>();
var table = new DynamoDbTable <Job>(@event.TableName());
var job = await table.GetAsync(jobId);
// not updating job if it already was marked as completed or failed.
if (job.Status == JobStatus.Completed || job.Status == JobStatus.Failed)
{
Logger.Warn("Ignoring update of job that tried to change state from " + job.Status + " to " + notificationJob.Status);
return;
}
job.Status = notificationJob.Status;
job.StatusMessage = notificationJob.StatusMessage;
job.Progress = notificationJob.Progress;
job.JobOutput = notificationJob.JobOutput;
job.DateModified = DateTime.UtcNow;
await table.PutAsync(jobId, job);
var resourceManager = @event.GetAwsV4ResourceManager();
await resourceManager.SendNotificationAsync(job, job.NotificationEndpoint);
}
/// <summary>
/// Sets the referer for the request. Uses a fluent interface.
/// </summary>
/// <param name="referer"></param>
/// <returns></returns>
public HttpSimulator SetReferer(Uri referer)
{
if(WorkerRequest != null)
WorkerRequest.SetReferer(referer);
_referer = referer;
return this;
}
private void BtnRunMonthlyTask_Click(object sender, EventArgs e)
{
WorkerRequest req = RequestManager.CreateRequest("monthly", ChkNoEmail.Checked);
RequestManager.SendWorkerRequest(req);
DisplayTaskOutput("monthly");
}
public static void SendWorkerRequest(WorkerRequest req)
{
var msgq = GetMessageQueue();
var msg = GetMessage(req);
msgq.Send(msg);
}
public ActionResult Create(WorkerRequestViewModel vm)
{
if (ModelState.IsValid)
{
db = new VirsagiContext();
var workerRequest = new WorkerRequest
{
RequestType = vm.RequestType,
ContactPerson = vm.ContactPerson,
ContactNumber = vm.ContactNumber,
CompanyUENNumber = vm.CompanyUENNumber,
CompanyName = vm.CompanyName,
Email = vm.Email,
Details = vm.Details,
SpecialRequest = vm.SpecialRequest,
CreatedDate = vm.CreatedDate
};
db.WorkerRequests.Add(workerRequest);
db.SaveChanges();
TempData["isSuccess"] = 1;
return(RedirectToAction("Index"));
}
TempData["isSuccess"] = 0;
return(View("Index", vm));
}
public GenericResult HandleCommand()
{
if (Task == "interlock-test")
{
return(HandleInterlockTest());
}
try
{
var req = new WorkerRequest {
Command = "RunTask", Args = new[] { Task }
};
string message = Provider.Worker.Execute(req);
return(new GenericResult
{
Success = true,
Message = message,
Data = $"task-{Task}"
});
}
catch (Exception ex)
{
return(new GenericResult
{
Success = false,
Message = ex.Message
});
}
}
// PUT api/<controller>/5
/// <summary>
/// Modifica un usuario
/// </summary>
/// <param name="Worker">Usuario a modificar</param>
/// <returns></returns>
public IHttpActionResult Put(int id, WorkerRequest Worker)
{
var originalWorker = WorkerService.GetById(id);
var ret = WorkerService.UpdateWorker(originalWorker, Worker);
return(Ok());
}
public IHttpActionResult Post(WorkerRequest Worker)
{
var result = WorkerService.CreateWorker(Worker);
return(Created <Entidad>("", new Entidad {
Id = result.Id
}));
}
private Message GetMessage(WorkerRequest body)
{
var result = new Message(body)
{
Formatter = new XmlMessageFormatter(new[] { typeof(WorkerRequest) })
};
return(result);
}
public Worker CreateWorker(WorkerRequest Worker)
{
var entityToInsert = new Worker()
{
User = this.UserRepository.GetById(Worker.UserId)
};
WorkerRepository.Insert(entityToInsert);
return(entityToInsert);
}
public async Task <CoffeeServiceResult> PeekAsync()
{
WorkerRequest request = new WorkerRequest();
if (!ExtractCredentials(request, out var errorResult))
{
return(errorResult);
}
return(ToCoffeeServiceResult(await _performer.WorkAsync(request)));
}
private bool ExtractCredentials(WorkerRequest request, out CoffeeServiceResult errorResult)
{
var result = _accessor.HttpContext.Request.TryExtractBasicCredentials(out string username, out string password);
request.Username = username;
request.Password = password;
errorResult = result ? null : new CoffeeServiceResult(StatusCodes.Status401Unauthorized)
{
Message = "HTTP basic authentication is required"
};
return(result);
}
public static async Task DeleteJobAssignmentAsync(WorkerRequest request, DeleteJobAssignmentRequest deleteRequest)
{
var jobAssignmentId = deleteRequest.JobAssignmentId;
try
{
var resourceManager = request.GetAwsV4ResourceManager();
await resourceManager.DeleteAsync <JobAssignment>(jobAssignmentId);
}
catch (Exception error)
{
Logger.Exception(error);
}
}
public CreateResponse Create(WorkerRequest request)
{
try
{
var worker = TypeAdapter.Adapt <Worker>(request);
_workerValidator.ValidateAndThrowException(worker, "Base");
_workerRepository.Add(worker);
return(new CreateResponse(worker.Id));
}
catch (DataAccessException)
{
throw new ApplicationException();
}
}
public string Execute(WorkerRequest req)
{
if (string.IsNullOrEmpty(req.Command))
{
throw new Exception($"The Command property cannot be empty.");
}
var msgq = GetMessageQueue();
var message = GetMessage(req);
msgq.Send(message);
return($"Enqueued command {req.Command} at {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
}
internal static async Task DeleteJobProcessAsync(WorkerRequest @event, DeleteJobProcessRequest deleteRequest)
{
var jobProcessId = deleteRequest.JobProcessId;
try
{
var resourceManager = AwsEnvironment.GetAwsV4ResourceManager();
await resourceManager.DeleteAsync <JobProcess>(jobProcessId);
}
catch (Exception error)
{
Logger.Exception(error);
}
}
public static void SendWorkerRequest(string[] args)
{
if (args.Length > 0 && args[0].Length > 0)
{
WorkerRequest req = new WorkerRequest()
{
Command = args[0],
Args = args.Skip(1).ToArray()
};
SendWorkerRequest(req);
}
else
{
throw new Exception($"At least one argument is required (Command).");
}
}
public async Task <WorkerResponse> WorkAsync(WorkerRequest request)
{
request.Guid = Guid.NewGuid();
WorkItem item;
using (CancellationTokenSource cancellation = new CancellationTokenSource())
{
item = new WorkItem
{
Cancellation = cancellation
};
lock (_pendingLock)
{
_pending.Add(request.Guid, item);
}
await _hub.Clients.All.RequestAsync(request);
try
{
await Task.Delay(WorkerTimeoutMillis, cancellation.Token);
}
catch (TaskCanceledException)
{
// We *expect* the task to be cancelled: that's the point.
}
// The below lock and removal must be within the 'using' to ensure that
// HandleResponse cannot get a CancellationTokenSource which has been disposed.
lock (_pendingLock)
{
_pending.Remove(request.Guid);
}
}
var response = item.Response;
if (response == null)
{
_log.LogWarning("Request {RequestGuid} timed out after {TimeoutMillis} milliseconds", request.Guid, WorkerTimeoutMillis);
}
return(item.Response);
}
public Response WorkComplete(WorkerRequest <TaskExecutionResult> result2)
{
var result = result2.Body;
var workItem = _repository.Get <WorkItem>(result.WorkItemId);
if (workItem == null)
{
return(Response.Failure("WorkItemId {WorkItemId} not found".FormatWith(new { result.WorkItemId })));
}
if (workItem.Status.Equals(WorkItemStatus.InProgress))
{
workItem.Complete(Successful(result.Status),
result.Messages.Count > 0? result.Messages.Aggregate((current, next) => current + next):"", result.Artifacts);
_repository.Put(workItem);
return(Response.Successful());
}
return(Response.Failure(string.Format("WorkItem must be InProgress before it can be completed {0}", workItem.ToString())));
}
public static WorkerRequest CreateRequest(string task, bool noEmail)
{
var result = new WorkerRequest()
{
Command = "RunTask"
};
if (task == "daily" || task == "monthly")
{
result.Args = new[] { task, noEmail ? "true" : "false" }
}
;
else
{
throw new ArgumentException("Allowed values: daily, monthly", "task");
}
return(result);
}
public SuccessResponse Update(WorkerRequest request)
{
try
{
var currentWorker = _workerRepository.FindBy(request.Id);
currentWorker.ThrowExceptionIfRecordIsNull();
var workerToCopy = TypeAdapter.Adapt <Worker>(request);
TypeAdapter.Adapt(workerToCopy, currentWorker);
_workerValidator.ValidateAndThrowException(currentWorker, "Base");
_workerRepository.Update(currentWorker);
return(new SuccessResponse {
IsSuccess = true
});
}
catch (DataAccessException)
{
throw new ApplicationException();
}
}
public static WorkerRequest CreateRequest(string task)
{
var result = new WorkerRequest()
{
Command = "RunTask"
};
if (task == "5min" || task == "test")
{
result.Args = new[] { task }
}
;
else
{
throw new ArgumentException("Allowed values: 5min", "task");
}
return(result);
}
public MockHttpContext(bool isSecure)
: this()
{
Thread.GetDomain().SetData(ThreadDataKeyAppPath, ThreadDataKeyAppPathValue);
Thread.GetDomain().SetData(ThreadDataKeyAppVPath, ThreadDataKeyAppVPathValue);
SimpleWorkerRequest request = new WorkerRequest(WorkerRequestPage, string.Empty, new StringWriter(), isSecure);
_context = new HttpContext(request);
HttpSessionStateContainer container = new HttpSessionStateContainer(
Guid.NewGuid().ToString("N"), new SessionStateItemCollection(), new HttpStaticObjectsCollection(),
5, true, HttpCookieMode.AutoDetect, SessionStateMode.InProc, false);
HttpSessionState state = Activator.CreateInstance(
typeof(HttpSessionState),
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.CreateInstance,
null,
new object[] { container }, CultureInfo.CurrentCulture) as HttpSessionState;
_context.Items[ContextKeyAspSession] = state;
}
public void WorkOrderController_edit_post_workerRequests_finds_duplicates()
{
//Arrange
int testid = 4242;
WorkOrder fakeworkOrder = new WorkOrder();
fakeworkOrder.workerRequests = workerRequest;
WorkerRequest foo1 = new WorkerRequest
{
ID = 111,
WorkerID = 1,
WorkOrderID = testid,
workerRequested = new Worker { ID = 1, dwccardnum = 12345 }
};
WorkerRequest foo2 = new WorkerRequest
{
ID = 222,
WorkerID = 2,
WorkOrderID = testid,
workerRequested = new Worker { ID = 2, dwccardnum = 12346 }
};
workerRequest.Add(foo1);
workerRequest.Add(foo2);
WorkOrder savedworkOrder = new WorkOrder();
string user = "";
_serv.Setup(p => p.Get(testid)).Returns(fakeworkOrder);
_serv.Setup(x => x.Save(It.IsAny<WorkOrder>(),
It.IsAny<string>())
).Callback((WorkOrder p, string str) =>
{
savedworkOrder = p;
user = str;
});
_wrServ.Setup(x => x.GetWorkerRequestsByNum(testid, 1)).Returns(foo1);
_wrServ.Setup(x => x.GetWorkerRequestsByNum(testid, 2)).Returns(foo2);
_ctrlr.SetFakeControllerContext();
_ctrlr.ValueProvider = fakeform.ToValueProvider();
List<WorkerRequest> list = new List<WorkerRequest>();
list.Add(new WorkerRequest { WorkerID = 12345 });
list.Add(new WorkerRequest { WorkerID = 30002 });
list.Add(new WorkerRequest { WorkerID = 30311 });
list.Add(new WorkerRequest { WorkerID = 30420 });
list.Add(new WorkerRequest { WorkerID = 30421 });
//Act
var result = _ctrlr.Edit(testid, fakeform, "UnitTest", list) as JsonResult;
//Assert
//Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual(fakeworkOrder, savedworkOrder);
Assert.AreEqual(savedworkOrder.workerRequests.Count(), 5);
Assert.AreEqual(savedworkOrder.workerRequests.Count(a => a.WorkerID == 12345), 1);
Assert.AreEqual(savedworkOrder.workerRequests.Count(a => a.WorkerID == 30002), 1);
Assert.AreEqual(savedworkOrder.workerRequests.Count(a => a.WorkerID == 30311), 1);
Assert.AreEqual(savedworkOrder.workerRequests.Count(a => a.WorkerID == 30420), 1);
Assert.AreEqual(savedworkOrder.workerRequests.Count(a => a.WorkerID == 30421), 1);
Assert.AreEqual(savedworkOrder.workerRequests.Count(a => a.WorkerID == 12346), 0);
}
public ActionResult Create(WorkOrder wo, string userName, string workerAssignments)
{
UpdateModel(wo);
// Retrieve user ID of signed in Employer
string userID = HttpContext.User.Identity.GetUserId();
// Retrieve Employer record
Employer onlineEmployer = eServ.GetRepo().GetAllQ().Where(e => e.onlineSigninID == userID).FirstOrDefault();
if (onlineEmployer != null)
{
// Employer has created profile or work order already
// Associate WO with Employer
wo.EmployerID = onlineEmployer.ID;
}
else
{
// Employer has NOT created profile or work order yet
Employer employer = new Employer();
// Set up default values from WO
employer.name = wo.contactName;
employer.phone = wo.phone;
employer.address1 = wo.workSiteAddress1;
employer.address2 = wo.workSiteAddress2;
employer.city = wo.city;
employer.state = wo.state;
employer.zipcode = wo.zipcode;
// Set up default online Employer profile
employer.isOnlineProfileComplete = true;
employer.onlineSigninID = userID;
employer.email = HttpContext.User.Identity.GetUserName(); // The Employer's username is their email address
employer.active = true;
employer.business = false;
employer.blogparticipate = false;
employer.onlineSource = true;
employer.returnCustomer = false;
employer.receiveUpdates = true;
employer.business = false;
Employer newEmployer = eServ.Create(employer, userName);
if (newEmployer != null)
{
wo.EmployerID = newEmployer.ID;
}
}
// Set disclosure agreement - to get here, the user had to accept
wo.disclosureAgreement = true;
if (workerAssignments == "")
{
// Set WA counter
wo.waPseudoIDCounter = 0;
}
// Create Work Order
WorkOrder neworder = woServ.Create(wo, userName);
if (workerAssignments != "")
{
// Create Work Assignments
dynamic parsedWorkerRequests = JObject.Parse(workerAssignments);
// Set WA counter
wo.waPseudoIDCounter = parsedWorkerRequests["assignments"].Count;
woServ.Save(neworder, userName);
for (int i = 0; i < parsedWorkerRequests["assignments"].Count; i++)
{
WorkAssignment wa = new WorkAssignment();
// Create WA from Employer data
wa.workOrderID = neworder.ID;
wa.skillID = parsedWorkerRequests["assignments"][i].skillId;
wa.hours = parsedWorkerRequests["assignments"][i].hours;
wa.weightLifted = parsedWorkerRequests["assignments"][i].weight;
wa.hourlyWage = parsedWorkerRequests["assignments"][i].hourlyWage; // TODO: consider looking this up instead - however, this is the value quoted to the customer online
wa.pseudoID = i + 1;
wa.description = parsedWorkerRequests["assignments"][i].desc;
// Set up defaults
wa.active = true;
wa.englishLevelID = 0; // TODO: note- all incoming online work assignments won't have the proper English level set (this needs to be set by the worker center)
wa.surcharge = 0.0;
wa.days = 1;
wa.qualityOfWork = 0;
wa.followDirections = 0;
wa.attitude = 0;
wa.reliability = 0;
wa.transportProgram = 0;
WorkAssignment newWa = waServ.Create(wa, userName);
}
// TODO: test
// New Worker Requests to add
for (int i = 0; i < parsedWorkerRequests["requests"].Count; i++)
{
WorkerRequest wr = new WorkerRequest();
// Create Worker Request from Employer data
wr.WorkOrderID = neworder.ID;
wr.WorkerID = parsedWorkerRequests["requests"][i].workerId;
WorkerRequest newWr = wrServ.Create(wr, userName);
}
}
if (neworder.transportFee > 0)
{
return View("IndexPrePaypal", neworder);
}
else
{
return View("IndexComplete", neworder);
}
}
