private WorkerTask(ActivityTask activityTask, IHeartbeatSwfApi heartbeatSwfApi, IErrorHandler errorHandler)
{
_activityTask = activityTask;
_heartbeatSwfApi = heartbeatSwfApi;
_errorHandler = errorHandler;
_execute = ExecuteActivityTask;
}
private async Task ExecuteActivityTaskHandler(Type workerType, ActivityTask activityTask)
{
Exception exception = null;
try
{
using (var worker = (SwfActivityWorker)_serviceProvider.GetService(workerType))
{
await worker.HandleActivityTask(activityTask);
}
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
await _workflow.RespondActivityTaskFailedAsync(new RespondActivityTaskFailedRequest
{
Reason = "exception",
Details = string.Format("{0}\n\n{1}", exception.Message, exception.StackTrace),
TaskToken = activityTask.TaskToken
});
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,TypeOfActivity,ConfirmationNumber,SupplierName,Description,StartDate,StartTime,EndDate,EndTime,Address,Suburb,City,Region,Postcode,Country,NumOfPeopleAttending,TripId")] ActivityTask activityTask)
{
if (id != activityTask.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(activityTask);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ActivityTaskExists(activityTask.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Details", new { activityTask.Id }));
}
return(View(activityTask));
}
public async Task Pass_activity_task_prorperties_to_activity()
{
var activityTask = new ActivityTask
{
ActivityType = new ActivityType {
Name = "TestActivity", Version = "1.0"
},
WorkflowExecution = new WorkflowExecution {
RunId = "runid", WorkflowId = "wid"
},
TaskToken = "token",
Input = "input",
ActivityId = "activityId",
StartedEventId = 10
};
var workerTask = WorkerTask.CreateFor(activityTask, Mock.Of <IHeartbeatSwfApi>());
await workerTask.ExecuteFor(_activityHost);
Assert.That(TestActivity.ActivityArgs.Input, Is.EqualTo(activityTask.Input));
Assert.That(TestActivity.ActivityArgs.ActivityId, Is.EqualTo(activityTask.ActivityId));
Assert.That(TestActivity.ActivityArgs.WorkflowId, Is.EqualTo(activityTask.WorkflowExecution.WorkflowId));
Assert.That(TestActivity.ActivityArgs.WorkflowRunId, Is.EqualTo(activityTask.WorkflowExecution.RunId));
Assert.That(TestActivity.ActivityArgs.TaskToken, Is.EqualTo(activityTask.TaskToken));
Assert.That(TestActivity.ActivityArgs.StartedEventId, Is.EqualTo(activityTask.StartedEventId));
}
void PollAndProcess()
{
while (!_cancellationToken.IsCancellationRequested)
{
try
{
ActivityTask task = Poll();
if (!String.IsNullOrEmpty(task.TaskToken))
{
ProcessTaskAsync(task).Wait();
CompleteTaskAsync(task.TaskToken);
}
}
catch (AggregateException e)
{
var inner = e.InnerException;
Logger.LogMessage("Unknown error while processing activity {0}: {1}\n{2}", this.ActivityType, inner.Message, inner.StackTrace);
}
catch (Exception e)
{
Logger.LogMessage("Unknown error while processing activity {0}: {1}\n{2}", this.ActivityType, e.Message, e.StackTrace);
}
}
Logger.LogMessage("Exiting poll for {0} after getting cancel signal", this.ActivityType);
}
protected async override Task ProcessTaskAsync(ActivityTask task)
{
var pollId = task.Input;
await PollProcessor.Instance.DeactivatePoll(pollId);
Logger.LogMessage("Poll {0} expired", pollId);
}
public JsonResult EditTask(ActivityTask task, List <int> AcSeleUserIds)
{
ModelState.Clear();
if ((AcSeleUserIds == null || AcSeleUserIds.Count == 0) && task.UserId == 0)
{
ModelState.AddModelError("", "Add Responsible Person");
}
else
{
var userId = AcSeleUserIds != null && AcSeleUserIds.Count > 0 ? AcSeleUserIds[0] : task.UserId;
var user = _db.Users.Find(userId);
task.UserName = user.FullName;
task.UserId = user.UserId;
if (task.IsNew)
{
_db.Entry(task).State = System.Data.EntityState.Added;
}
else
{
_db.Entry(task).State = System.Data.EntityState.Modified;
}
_db.SaveChanges();
}
return(GetErrorMsgJSON());
}
static bool GetStoppedAt(ActivityTask task)
{
var stopAtTask = task as ActivityTaskPassengerStopAt;
if (stopAtTask != null)
return stopAtTask.ActArrive != null;
return false;
}
public override void PrepareFrame(ElapsedTime elapsedTime, bool updateFull)
{
base.PrepareFrame(elapsedTime, updateFull);
if (updateFull && Tabs[ActiveTab].Tab == Tab.ActivityTimetable && Owner.Viewer.Simulator.ActivityRun != null)
{
if (LastActivityTask != Owner.Viewer.Simulator.ActivityRun.Current || StoppedAt != GetStoppedAt(LastActivityTask))
{
LastActivityTask = Owner.Viewer.Simulator.ActivityRun.Current;
StoppedAt = GetStoppedAt(LastActivityTask);
Layout();
}
}
else if (updateFull && Tabs[ActiveTab].Tab == Tab.ActivityWorkOrders && Owner.Viewer.Simulator.ActivityRun != null)
{
if (Owner.Viewer.Simulator.ActivityRun.EventList != null)
{
if (Owner.Viewer.Simulator.ActivityRun.LastTriggeredEvent != null && (Owner.Viewer.HelpWindow.lastLastEventID == -1 ||
(Owner.Viewer.Simulator.ActivityRun.LastTriggeredEvent.ParsedObject.ID != Owner.Viewer.HelpWindow.lastLastEventID)))
{
lastLastEventID = Owner.Viewer.Simulator.ActivityRun.LastTriggeredEvent.ParsedObject.ID;
Layout();
}
}
}
if (this.ActivityUpdated == true) //true value is set in ActivityWindow.cs
{
this.ActivityUpdated = false;
Layout();
}
//UpdateActivityStatus();
}
/// <param name="task">アクティビティのタスク</param>
/// <param name="handler">タスク終了時のイベントハンドラ</param>
/// <returns>アクティビティスレッド</returns>
protected Thread Create(ActivityTask task, ActivityEventHandler handler)
{
ThreadStart start = new ThreadStart(delegate
{
ActivityEventArgs args = new ActivityEventArgs();
try
{
task();
args.IsCompleted = true;
}
catch (ThreadAbortException ex)
{
args.IsAborted = true;
args.Exception = ex;
}
catch (Exception ex)
{
args.Exception = ex;
}
finally
{
MotorControler mc = MotorControler.GetInstance(parameterManager);
mc.AbortMoving();
mc.SlowDownStopAll();
if (handler != null)
{
handler(this, args);
}
}
});
return(Create(start));
}
private void AmazonSwfReturns(ActivityTask activityTask)
{
_amazonWorkflowClient.Setup(c => c.PollForActivityTaskAsync(It.IsAny <PollForActivityTaskRequest>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new PollForActivityTaskResponse()
{
ActivityTask = activityTask
}));
}
public PartialViewResult AddTask(int id)
{
var activity = new ActivityTask
{
ActivityId = id
};
ViewBag.Status = activity.Status.ToSelectList();
return(PartialView("EditTask", activity));
}
/// <summary>
/// Creates the activity task contact.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="contact">The contact.</param>
/// <returns>ActivityTaskContact.</returns>
public ActivityTaskContact CreateActivityTaskContact(ActivityTask task = null, Contact contact = null)
{
return(new ActivityTaskContact()
{
Contact = contact,
Task = task,
ContactId = this.CreateInt(),
TaskId = this.CreateInt()
});
}
public async Task <IActionResult> Create([Bind("Id,TypeOfActivity,ConfirmationNumber,SupplierName,Description,StartDate,StartTime,EndDate,EndTime,Address,Suburb,City,Region,Postcode,Country,NumOfPeopleAttending,TripId")] ActivityTask activityTask)
{
if (ModelState.IsValid)
{
_context.Add(activityTask);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { activityTask.Id }));
}
return(View(activityTask));
}
void UpdateLabelLists()
{
var tdb = Owner.Viewer.Simulator.TDB.TrackDB;
var stationStops = Owner.Viewer.Simulator.PlayerLocomotive.Train.StationStops;
var activity = Owner.Viewer.Simulator.ActivityRun;
// Update every 10s or when the current activity task changes.
if (--PlatformUpdate <= 0 || stationStops.Count != StationStopsCount || (activity != null && activity.Current != ActivityCurrentTask))
{
PlatformUpdate = 40;
var platforms = new Dictionary <string, bool>();
var sidings = new Dictionary <string, bool>();
if (tdb.TrackItems != null)
{
foreach (var stop in stationStops)
{
var platformId = stop.PlatformReference;
if (0 <= platformId && platformId < tdb.TrackItems.Length && tdb.TrackItems[platformId] is PlatformItem)
{
platforms[tdb.TrackItems[platformId].ItemName] = true;
}
}
if (activity != null && activity.EventList != null)
{
foreach (var @event in activity.EventList)
{
var eventAction = @event.ParsedObject as ActionActivityEvent;
if (eventAction != null)
{
var sidingId1 = eventAction.SidingId;
var sidingId2 = eventAction.WorkOrderWagons != null && eventAction.WorkOrderWagons.Count > 0 ? eventAction.WorkOrderWagons[0].SidingId : default(uint?);
var sidingId = sidingId1.HasValue ? sidingId1.Value : sidingId2.HasValue ? sidingId2.Value : uint.MaxValue;
if (0 <= sidingId && sidingId < tdb.TrackItems.Length && tdb.TrackItems[sidingId] is SidingItem)
{
sidings[tdb.TrackItems[sidingId].ItemName] = true;
}
}
}
}
}
Platforms = platforms;
Sidings = sidings;
StationStopsCount = stationStops.Count;
if (activity != null)
{
ActivityCurrentTask = activity.Current;
}
}
}
public static void CreateTask(ActivityTaskModel model, ActivityTask entity, string userId)
{
entity.TaskSubject = model.TaskSubject;
entity.TaskDescription = model.TaskDescription;
entity.TaskPurpose = model.TaskPurpose;
entity.TaskDate = model.TaskDate;
entity.TaskTime = model.TaskTime;
entity.UserId = model.UserId;
entity.DescriptionHtml = model.DescriptionHtml;
entity.EntityId = model.EntityId;
entity.EntityMasterId = model.EntityMasterId;
}
/// <summary>
/// Creates the activity task observer user.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="user">The user.</param>
/// <returns>ActivityTaskObserverUser.</returns>
public ActivityTaskObserverUser CreateActivityTaskObserverUser(
ActivityTask task = null,
ApplicationUser user = null)
{
return(new ActivityTaskObserverUser()
{
Task = task,
User = user,
TaskId = this.CreateInt(),
UserId = this.CreateInt()
});
}
public async Task Activity_task_polling_exception_can_be_handled_to_retry()
{
var expectedActivityTask = new ActivityTask();
_amazonWorkflowClient.SetupSequence(s => s.PollForActivityTaskAsync(It.IsAny <PollForActivityTaskRequest>(), It.IsAny <CancellationToken>()))
.Throws(new UnknownResourceException("not found"))
.Returns(Task.FromResult(new PollForActivityTaskResponse()
{
ActivityTask = expectedActivityTask
}));
var domain = _domain.OnPollingError((e) => ErrorAction.Retry);
var activityTask = await domain.PollForActivityTaskAsync(_taskList, _pollingIdentity, _cancellationToken);
Assert.That(activityTask, Is.EqualTo(expectedActivityTask));
}
protected string ProcessActivityTask(ActivityTask task, IWorkflow workflow)
{
Debug.Assert(task != null);
var result = "";
try
{
var input = Utils.GetDataFromStore(task.Input, _storeClient);
if (workflow != null)
{
// Get activity and run processor
var activity = workflow.GetActivity(task.ActivityId);
if (activity != null)
{
result = activity.TaskProcessor(input);
Logger.Fatal("[{0}] Result: [{1}]", task.ActivityId, result);
}
else
{
result = Utils.SerializeToJSON(new StepResult <string>(
$"Activity '{task.ActivityId}' not found.", false));
}
}
else
{
result = TaskProcessor(input);
Logger.Fatal("[{0}] Result: [{1}]", task.ActivityId, result);
}
TaskCompleted(task.TaskToken, Utils.PutDataToStore(result, _storeClient));
}
catch (Exception e)
{
Logger.Error(e, "[{0}]. {1}", task.ActivityId, e.Message);
result = Utils.SerializeToJSON(new StepResult <string>(e.Message, false));
//TaskFailed(task.TaskToken, e.Message, "");
}
return(result);
}
protected async override void DoWorkSafe()
{
ActivityTask activityTask = await this.Poll();
if (!String.IsNullOrEmpty(activityTask.TaskToken))
{
ProcessSwfActivityResult processResult = await ProcessTask(activityTask.Input);
if (string.IsNullOrEmpty(processResult.ErrorMessage))
{
await CompleteTask(activityTask.TaskToken, processResult.Output);
}
else
{
await FailTask(activityTask.TaskToken, activityTask.Input, processResult.ErrorMessage);
}
}
}
public static ActivityTask CreateTask(ActivityTaskModel model, string userId)
{
var task = new ActivityTask
{
TaskSubject = model.TaskSubject,
TaskDescription = model.TaskDescription,
TaskPurpose = model.TaskPurpose,
TaskDate = model.TaskDate,
TaskTime = model.TaskTime,
UserId = model.UserId,
DescriptionHtml = model.DescriptionHtml,
EntityId = model.EntityId,
EntityMasterId = model.EntityMasterId,
CreatedBy = userId ?? "0",
CreatedOn = Utility.GetDateTime()
};
return(task);
}
/// <summary>
/// Finds the activity by subject or create.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="contact">The contact.</param>
/// <param name="user">The user.</param>
/// <param name="activityType">Type of the activity.</param>
/// <param name="task">The task.</param>
/// <param name="dateActivity">The date activity.</param>
/// <param name="dateCreated">The date created.</param>
/// <param name="company">The company.</param>
/// <param name="subject">The subject.</param>
/// <param name="description">The description.</param>
/// <returns>Activity.</returns>
private static Activity FindActivityBySubjectOrCreate(
this ApplicationDbContext context,
Contact contact,
ApplicationUser user,
ActivityType activityType,
ActivityTask task,
DateTime dateActivity,
DateTime dateCreated,
Company company,
string subject,
string description)
{
var result = context.Activities.FirstOrDefault(it => it.Subject == subject);
if (result == null)
{
result = new Activity()
{
Subject = subject,
Task = task,
Type = activityType,
Description = description,
DateActivity = dateActivity,
DateCreated = dateCreated,
Contact = contact,
User = user
};
context.Activities.Add(result);
context.SaveChanges();
}
else
{
result.Task = task;
result.Type = activityType;
result.Description = description;
result.DateActivity = dateActivity;
result.DateCreated = dateCreated;
result.Contact = contact;
result.User = user;
context.SaveChanges();
}
return(result);
}
/// <summary>
/// Creates the task contacts.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="task">The task.</param>
/// <param name="contact">The contact.</param>
/// <returns>ActivityTaskContact.</returns>
private static ActivityTaskContact CreateTaskContacts(
this ApplicationDbContext context,
ActivityTask task,
Contact contact)
{
var result =
context.ActivityTaskContacts.FirstOrDefault(it => (it.TaskId == task.Id) && (it.ContactId == contact.Id));
if (result == null)
{
result = new ActivityTaskContact()
{
Task = task,
Contact = contact
};
context.ActivityTaskContacts.Add(result);
context.SaveChanges();
}
return(result);
}
/// <summary>
/// Creates the task observer users.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="task">The task.</param>
/// <param name="user">The user.</param>
/// <returns>ActivityTaskObserverUser.</returns>
private static ActivityTaskObserverUser CreateTaskObserverUsers(
this ApplicationDbContext context,
ActivityTask task,
ApplicationUser user)
{
var result =
context.ActivityTaskObserverUsers.FirstOrDefault(it => (it.TaskId == task.Id) && (it.UserId == user.Id));
if (result == null)
{
result = new ActivityTaskObserverUser()
{
Task = task,
User = user
};
context.ActivityTaskObserverUsers.Add(result);
context.SaveChanges();
}
return(result);
}
/// <summary>
/// Creates the task organizations.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="task">The task.</param>
/// <param name="organization">The organization.</param>
/// <returns>ActivityTaskOrganization.</returns>
private static ActivityTaskOrganization CreateTaskOrganizations(
this ApplicationDbContext context,
ActivityTask task,
Organization organization)
{
var result =
context.ActivityTaskOrganizations.FirstOrDefault(
it => (it.OrganizationId == organization.Id) && (it.TaskId == task.Id));
if (result == null)
{
result = new ActivityTaskOrganization()
{
Task = task,
Organization = organization
};
context.ActivityTaskOrganizations.Add(result);
context.SaveChanges();
}
return(result);
}
/// <summary>
/// Finds the activity task by subject or create.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="subject">The subject.</param>
/// <param name="status">The status.</param>
/// <param name="userCreatedBy">The user created by.</param>
/// <param name="userAssignTo">The user assign to.</param>
/// <param name="isImportant">if set to <c>true</c> [is important].</param>
/// <param name="dateDeadline">The date deadline.</param>
/// <param name="dateEnd">The date end.</param>
/// <param name="dateCreated">The date created.</param>
/// <param name="goal">The goal.</param>
/// <param name="company">The company.</param>
/// <param name="successFactor">The success factor.</param>
/// <param name="description">The description.</param>
/// <returns>ActivityTask.</returns>
private static ActivityTask FindActivityTaskBySubjectOrCreate(
this ApplicationDbContext context,
string subject,
ActivityTaskStatus status,
ApplicationUser userCreatedBy,
ApplicationUser userAssignTo,
bool isImportant,
DateTime dateDeadline,
DateTime dateEnd,
DateTime dateCreated,
Goal goal,
Company company,
string successFactor,
string description)
{
var task1 = context.ActivityTasks.FirstOrDefault(it => it.Subject == subject);
if (task1 == null)
{
task1 = new ActivityTask()
{
AssignTo = userAssignTo,
CreatedBy = userCreatedBy,
Subject = subject,
DateCreated = dateCreated,
DateDeadline = dateDeadline,
DateEnd = dateEnd,
Description = description,
IsImportant = isImportant,
Status = status,
SuccessFactor = successFactor,
Company = company,
Goal = goal
};
context.ActivityTasks.Add(task1);
context.SaveChanges();
}
return(task1);
}
public async Task <ActionResult <ActivityTask> > PostActivityTask(ActivityTaskDto activityTaskDto, [FromRoute] string userId)
{
if (activityTaskDto.Type == "auto")
{
var activityTask = new ActivityTask();
activityTask.ActivityTaskName = activityTaskDto.ActivityTaskName;
activityTask.ActivityId = activityTaskDto.ActivityId;
activityTask.DonePercentage = "0/" + activityTaskDto.Duration.ToString();
activityTask.Duration = activityTaskDto.Duration;
var act = _context.Activity.Include(o => o.User).Where(a => a.ActivityId == activityTaskDto.ActivityId).FirstOrDefault();
activityTask.Activity = act;
_context.ActivityTask.Add(activityTask);
await _context.SaveChangesAsync();
var activity = _context.Activity.Include(o => o.User).Where(a => a.ActivityId == activityTaskDto.ActivityId).FirstOrDefault();
System.Console.WriteLine(userId);;
System.Console.WriteLine(Int32.Parse(userId));
System.Console.WriteLine(activityTaskDto);
var at = _context.UserActivityType.Include(a => a.ActivityType).ThenInclude(a => a.Activity)
.Where(a => a.ActivityTypeId == activity.ActivityTypeId && a.UserId == Int32.Parse(userId)).FirstOrDefault();
int maxDnevnoSati = at.TimeTo - at.TimeFrom;
int potrebno = activityTaskDto.Duration;
DateTime day = DateTime.Today;
while (potrebno > 0)
{
string shortDay = day.ToShortDateString();
List <Schedule> schedules = _context.Schedule.Include(p => p.ActivityTask).ThenInclude(a => a.Activity).ThenInclude(o => o.User)
.AsEnumerable()
.Where(a => a.Date.ToShortDateString() == shortDay && a.ActivityTask.Activity.UserId == Int32.Parse(userId)).ToList();
if (!schedules.Any()) //prazan raspored taj dan
{
if (maxDnevnoSati >= potrebno)
{
Schedule newSchedule = new Schedule
{
TimeTo = at.TimeFrom + potrebno,
TimeFrom = at.TimeFrom,
Date = day,
Moveable = false,
ActivityTask = activityTask,
ActivityTaskId = activityTask.ActivityTaskId
};
//activityTask.Schedule.Add(newSchedule);
_context.Schedule.Add(newSchedule);
await _context.SaveChangesAsync();
potrebno = 0;
break;
}
else
{
Schedule newSchedule = new Schedule {
TimeTo = at.TimeTo, TimeFrom = at.TimeFrom, Date = day, Moveable = false,
ActivityTask = activityTask,
ActivityTaskId = activityTask.ActivityTaskId
};
_context.Schedule.Add(newSchedule);
await _context.SaveChangesAsync();
potrebno -= maxDnevnoSati;
}
}
day = day.AddDays(1);
}
return(CreatedAtAction("GetActivityTask", new { userId = userId, id = activityTask.ActivityTaskId }, activityTask));
}
else
{
var activityTask = new ActivityTask();
activityTask.ActivityTaskName = activityTaskDto.ActivityTaskName;
activityTask.ActivityId = activityTaskDto.ActivityId;
activityTask.DonePercentage = "0/" + (activityTaskDto.TimeTo - activityTaskDto.TimeFrom).ToString();
activityTask.Duration = activityTaskDto.TimeTo - activityTaskDto.TimeFrom;
var act = _context.Activity.Include(o => o.User).Where(a => a.ActivityId == activityTaskDto.ActivityId).FirstOrDefault();
activityTask.Activity = act;
_context.ActivityTask.Add(activityTask);
await _context.SaveChangesAsync();
Schedule newSchedule = new Schedule
{
TimeTo = activityTaskDto.TimeTo,
TimeFrom = activityTaskDto.TimeFrom,
Date = Convert.ToDateTime(activityTaskDto.FixedDate),
Moveable = false,
ActivityTask = activityTask,
ActivityTaskId = activityTask.ActivityTaskId
};
_context.Schedule.Add(newSchedule);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetActivityTask", new { userId = userId, id = activityTask.ActivityTaskId }, activityTask));
}
}
public static WorkerTask CreateFor(ActivityTask activityTask, IHeartbeatSwfApi heartbeatSwfApi)
{
return(new WorkerTask(activityTask, heartbeatSwfApi, ErrorHandler.Default(e => ErrorAction.Unhandled)));
}
public async Task AddTaskAsync(ActivityTask entity)
{
await _dataContext.ActivityTask.AddAsync(entity);
}
public void EditAsyncTask(ActivityTask entity)
{
_dataContext.ActivityTask.Update(entity);
}
