public static BlockingActivity FromActivity(ActivityRecord activity)
{
return(new BlockingActivity
{
ActivityId = activity.ActivityId, IsStart = activity.IsStart, Name = activity.TypeName
});
}
public ActionResult Create([Bind(Include = "Id,Title,ActivityStatus,PublishDateTime,Source,Clicks,Photo,IsTop,SDate,EDate,Count,AddUser,DateTime,EditUser,LastEditDateTime")] ActivityRecord activityRecord, HttpPostedFileBase photo)
{
if (ModelState.IsValid)
{
//相片上傳
if (photo != null)
{
if (photo.ContentType.IndexOf("image", System.StringComparison.Ordinal) == -1)
{
ViewBag.message = "檔案類型錯誤";
return(View());
}
activityRecord.Photo = Utility.SaveUpImage(photo);
Utility.GenerateThumbnailImage(activityRecord.Photo, photo.InputStream, Server.MapPath("~/UpFile/Images"),
"s", 167, 115);
}
activityRecord.DateTime = DateTime.Now;
activityRecord.AddUser = Utility.GetUserTickets().UserCodeName;
activityRecord.LastEditDateTime = DateTime.Now;
db.ActivityRecords.Add(activityRecord);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(activityRecord));
}
public void TestShortActivityThenIdleLoggingInEmptyLog()
{
// | Short Activity, Idle
var settings = GetActivityTrackingSettingsFake();
var activitiesRepository = GetActivitiesRepositoryFake();
var userInputTracker = GetUserInputTrackerFake();
var records = new List <ActivityRecord>();
var activityRecordsRepository = GetActivityRecordsRepositoryFake(records);
var tracker = new UserActivityTracker(
activityRecordsRepository,
activitiesRepository,
settings,
userInputTracker);
tracker.Start();
DateTime timeStamp = DateTime.Now;
userInputTracker.RaiseUserInputDetectedEvent(timeStamp);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.GetShortActivityDuration());
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumIdleDuration);
records.Should().HaveCount(1);
ActivityRecord idleRecord = records[0];
idleRecord.Idle.Should().Be(true);
idleRecord.Duration.Should().Be(settings.MinimumIdleDuration + settings.GetShortActivityDuration());
idleRecord.Activity.Should().Be(BreakActivity);
tracker.Stop();
}
public async Task <IActionResult> Create(string activityName, ActivityEditViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageWorkflows))
{
return(Forbid());
}
var workflowType = await _session.GetAsync <WorkflowType>(model.WorkflowTypeId);
var activity = _activityLibrary.InstantiateActivity(activityName);
var activityEditor = await _activityDisplayManager.UpdateEditorAsync(activity, _updateModelAccessor.ModelUpdater, isNew : true);
if (!ModelState.IsValid)
{
activityEditor.Metadata.Type = "Activity_Edit";
model.Activity = activity;
model.ActivityEditor = activityEditor;
return(View(model));
}
var activityRecord = new ActivityRecord
{
ActivityId = model.ActivityId,
Name = activity.Name,
Properties = activity.Properties,
};
workflowType.Activities.Add(activityRecord);
_session.Save(workflowType);
_notifier.Success(H["Activity added successfully."]);
return(Url.IsLocalUrl(model.ReturnUrl) ? (IActionResult)Redirect(model.ReturnUrl) : RedirectToAction("Edit", "WorkflowType", new { id = model.WorkflowTypeId }));
}
public void TestIdleThenActivityThenIdleLoggingWithLastRecordIndicatingActivityInLog()
{
// Activity | Idle, Activity, Idle
var settings = GetActivityTrackingSettingsFake();
var activitiesRepository = GetActivitiesRepositoryFake();
var userInputTracker = GetUserInputTrackerFake();
var records = new List <ActivityRecord>();
var activityRecordsRepository = GetActivityRecordsRepositoryFake(records);
var tracker = new UserActivityTracker(
activityRecordsRepository,
activitiesRepository,
settings,
userInputTracker);
tracker.Start();
DateTime timeStamp = DateTime.Now;
records.Add(
new ActivityRecord(1)
{
Activity = WorkActivity,
Idle = false,
StartTime = timeStamp - settings.MinimumActivityDuration,
EndTime = timeStamp
});
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumIdleDuration);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumActivityDuration);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumIdleDuration);
records.Should().HaveCount(4);
ActivityRecord initialRecord = records[0];
initialRecord.Idle.Should().Be(false);
initialRecord.Duration.Should().Be(settings.MinimumActivityDuration);
ActivityRecord idleRecord = records[1];
idleRecord.Idle.Should().Be(true);
idleRecord.Duration.Should().Be(settings.MinimumIdleDuration);
idleRecord.StartTime.Should().Be(initialRecord.EndTime);
ActivityRecord activityRecord = records[2];
activityRecord.Idle.Should().Be(false);
activityRecord.Duration.Should().Be(settings.MinimumActivityDuration);
activityRecord.StartTime.Should().Be(idleRecord.EndTime);
ActivityRecord lastIdleRecord = records[3];
lastIdleRecord.Idle.Should().Be(true);
lastIdleRecord.Duration.Should().Be(settings.MinimumIdleDuration);
lastIdleRecord.StartTime.Should().Be(activityRecord.EndTime);
tracker.Stop();
}
private ActivityContext CreateActivityContext(ActivityRecord activityRecord, IDictionary <string, object> tokens)
{
return(new ActivityContext {
Record = activityRecord,
Activity = _activitiesManager.GetActivityByName(activityRecord.Name),
State = new Lazy <dynamic>(() => GetState(activityRecord.State, tokens))
});
}
public ActionResult DeleteConfirmed(int id)
{
ActivityRecord activityRecord = db.ActivityRecords.Find(id);
db.ActivityRecords.Remove(activityRecord);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static double CompareActivities(ActivityRecord record, ActivityWindow window, DynamicTimeWarpingCalculationType dtwType, DynamicTimeWarpingPathTypes pathType = DynamicTimeWarpingPathTypes.Standart, bool toUseSakoeChibaBand = false, double bandWidthInProcentage = 0.1)
{
double similarity = 0.0f;
double[,] DTW = new double[record.Frames.Count, window.Frames.Count];
for (int i = 1; i < window.Frames.Count; i++)
{
DTW[0, i] = double.PositiveInfinity;
}
for (int i = 1; i < record.Frames.Count; i++)
{
DTW[i, 0] = double.PositiveInfinity;
}
DTW[0, 0] = 0;
var windowPresentedByImportedSkeletons = new List<ImportedSkeleton>();
foreach (var skeleton in window.Frames)
{
windowPresentedByImportedSkeletons.Add(new ImportedSkeleton(skeleton));
}
int bandWidth = (int)(windowPresentedByImportedSkeletons.Count * bandWidthInProcentage);
if (toUseSakoeChibaBand)
{
for (int i = 1; i < record.Frames.Count; i++)
{
for (int j = 1; j < windowPresentedByImportedSkeletons.Count; j++)
{
int currentCellOnMiddleDiagonal = (int)((j * windowPresentedByImportedSkeletons.Count) / record.Frames.Count);
if (j > currentCellOnMiddleDiagonal - bandWidth && j < currentCellOnMiddleDiagonal + bandWidth) // Checking if the current cell is in the range
{
similarity = SkeletonComparer.CompareWithSMIJ(record.Frames[i], windowPresentedByImportedSkeletons[j], record.MostInformativeJoints);
FillDTWTableCell(pathType, DTW, i, j, similarity);
}
}
}
}
else //Start a DTW search without using Sakoe-Chiba band
{
for (int i = 1; i < record.Frames.Count; i++)
{
for (int j = 1; j < windowPresentedByImportedSkeletons.Count; j++)
{
similarity = SkeletonComparer.CompareWithSMIJ(record.Frames[i], windowPresentedByImportedSkeletons[j], record.MostInformativeJoints);
FillDTWTableCell(pathType, DTW, i, j, similarity);
}
}
}
return DTW[record.Frames.Count - 1, window.Frames.Count - 1] / record.MostInformativeJoints.Count;
}
public void TestActivityThenForceLogThenIdleThenActivityThenIdleLoggingInEmptyLog()
{
// | Activity, Force Log, Idle, Activity, Idle
var settings = GetActivityTrackingSettingsFake();
var activitiesRepository = GetActivitiesRepositoryFake();
var userInputTracker = GetUserInputTrackerFake();
var records = new List <ActivityRecord>();
var activityRecordsRepository = GetActivityRecordsRepositoryFake(records);
var tracker = new UserActivityTracker(
activityRecordsRepository,
activitiesRepository,
settings,
userInputTracker);
tracker.Start();
DateTime timeStamp = DateTime.Now;
userInputTracker.RaiseUserInputDetectedEvent(timeStamp);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumActivityDuration);
tracker.LogUserActivity(false, true, timeStamp);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumIdleDuration);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumActivityDuration);
userInputTracker.RaiseUserInputDetectedEvent(ref timeStamp, settings.MinimumIdleDuration);
records.Should().HaveCount(4);
ActivityRecord activityRecord = records[0];
activityRecord.Idle.Should().Be(false);
activityRecord.Duration.Should().Be(settings.MinimumActivityDuration);
activityRecord.Activity.Should().Be(WorkActivity);
ActivityRecord idleRecord = records[1];
idleRecord.Idle.Should().Be(true);
idleRecord.Duration.Should().Be(settings.MinimumIdleDuration);
idleRecord.Activity.Should().Be(BreakActivity);
idleRecord.StartTime.Should().Be(activityRecord.EndTime);
activityRecord = records[2];
activityRecord.Idle.Should().Be(false);
activityRecord.Duration.Should().Be(settings.MinimumActivityDuration);
activityRecord.Activity.Should().Be(WorkActivity);
activityRecord.StartTime.Should().Be(idleRecord.EndTime);
idleRecord = records[3];
idleRecord.Idle.Should().Be(true);
idleRecord.Duration.Should().Be(settings.MinimumIdleDuration);
idleRecord.Activity.Should().Be(BreakActivity);
idleRecord.StartTime.Should().Be(activityRecord.EndTime);
tracker.Stop();
}
public static double CompareActivities(ActivityRecord record, ActivityWindow window, DynamicTimeWarpingCalculationType dtwType, DynamicTimeWarpingPathTypes pathType = DynamicTimeWarpingPathTypes.Standart, bool toUseSakoeChibaBand = false, double bandWidthInProcentage = 0.1)
{
double similarity = 0.0f;
double[,] DTW = new double[record.Frames.Count, window.Frames.Count];
for (int i = 1; i < window.Frames.Count; i++)
{
DTW[0, i] = double.PositiveInfinity;
}
for (int i = 1; i < record.Frames.Count; i++)
{
DTW[i, 0] = double.PositiveInfinity;
}
DTW[0, 0] = 0;
var windowPresentedByImportedSkeletons = new List <ImportedSkeleton>();
foreach (var skeleton in window.Frames)
{
windowPresentedByImportedSkeletons.Add(new ImportedSkeleton(skeleton));
}
int bandWidth = (int)(windowPresentedByImportedSkeletons.Count * bandWidthInProcentage);
if (toUseSakoeChibaBand)
{
for (int i = 1; i < record.Frames.Count; i++)
{
for (int j = 1; j < windowPresentedByImportedSkeletons.Count; j++)
{
int currentCellOnMiddleDiagonal = (int)((j * windowPresentedByImportedSkeletons.Count) / record.Frames.Count);
if (j > currentCellOnMiddleDiagonal - bandWidth && j < currentCellOnMiddleDiagonal + bandWidth) // Checking if the current cell is in the range
{
similarity = SkeletonComparer.CompareWithSMIJ(record.Frames[i], windowPresentedByImportedSkeletons[j], record.MostInformativeJoints);
FillDTWTableCell(pathType, DTW, i, j, similarity);
}
}
}
}
else //Start a DTW search without using Sakoe-Chiba band
{
for (int i = 1; i < record.Frames.Count; i++)
{
for (int j = 1; j < windowPresentedByImportedSkeletons.Count; j++)
{
similarity = SkeletonComparer.CompareWithSMIJ(record.Frames[i], windowPresentedByImportedSkeletons[j], record.MostInformativeJoints);
FillDTWTableCell(pathType, DTW, i, j, similarity);
}
}
}
return(DTW[record.Frames.Count - 1, window.Frames.Count - 1] / record.MostInformativeJoints.Count);
}
public void AddRecord(ActivityRecord record)
{
if (_activityRecords.Any(r => r.ActivityRecordId == record.ActivityRecordId))
{
return;
}
_activityRecords.Add(record);
}
/// <summary>
/// Starts a new workflow using the specified workflow definition.
/// </summary>
public static Task <WorkflowExecutionContext> StartWorkflowAsync <T>(this IWorkflowManager workflowManager,
ActivityRecord startActivity = null, IDictionary <string, object> input = null, string correlationId = null)
where T : IWorkflow, new()
{
var builder = workflowManager.ServiceProvide.GetService <IWorkflowBuilder>();
var workflowType = builder.Build <T>();
return(workflowManager.StartWorkflowAsync(workflowType, startActivity, input, correlationId));
}
public ActionResult PhotoDetail([Bind(Include = "Id,Title,ActivityStatus,PublishDateTime,Source,Clicks,Photo,IsTop,SDate,EDate,Count,AddUser,DateTime,EditUser,LastEditDateTime")] ActivityRecord activityRecord)
{
if (ModelState.IsValid)
{
db.Entry(activityRecord).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(activityRecord));
}
public async Task DeleteAsync(ActivityRecord activityRecord)
{
var allActivityRecordsInDayRecord = await _activityRecordsRepository.BrowseAsync(new BrowseQuery(activityRecord.DayRecordId));
var allActivityRecordsWithGreaterOrder = allActivityRecordsInDayRecord.Where(activityRecordFromDayRecord => activityRecordFromDayRecord.Order > activityRecord.Order).ToList();
allActivityRecordsWithGreaterOrder.ForEach(activityRecordWithGreaterOrder => activityRecordWithGreaterOrder.SetNewOrder(activityRecordWithGreaterOrder.Order.Smaller()));
_activityRecordsRepository.Remove(activityRecord);
}
private static ActivityRecord Clone(ActivityRecord record)
{
return(new ActivityRecord(record.ActivityRecordId)
{
Activity = Clone(record.Activity),
EndTime = record.EndTime,
Idle = record.Idle,
StartTime = record.StartTime,
ActivityRecordId = record.ActivityRecordId
});
}
public void TryCalculatingAggregateTimes()
{
var fixture = ActivityRecord.FetchRescueTimeData("B633MZSjMrwOV7N8lueArTYcauGGkYMUEIVgPCGW").First();
var lookup = fixture.ToLookup(x => x.Time);
var debugCalc = EnumerableEx.Generate(fixture.Min(x => x.Time), x => x <= fixture.Max(y => y.Time), x => x.AddMinutes(5.0), x => x)
.Select(x => new { Key = x, Sum = lookup[x].Sum(y => y.ProductivityInSeconds), Len = lookup[x].Count() })
.Scan0(new { Time = 0.0, Date = DateTime.MinValue }, (acc, x) => {
var toAdd = x.Sum;
if (x.Len == 0)
{
toAdd = 60.0 * (acc.Time > 0 ? -1.0 : 1.0);
}
var secs = (acc.Time + toAdd).Clamp(-10 * 60.0, 5 * 60.0);
if (secs <= -10 * 60.0 && x.Sum != 0.0)
{
secs += 5 * 60.0;
}
return(new { Time = secs, Date = x.Key });
}).ToList();
/*
* var debugCalc = fixture
* .ToLookup(x => x.Time)
* .Select(x => new {x.Key, Sum = x.Sum(y => y.ProductivityInSeconds)})
* .Scan0(new { Time = 0.0, Date = DateTime.MinValue } , (acc, x) => {
* var secs = (acc.Time + x.Sum).Clamp(-10 * 60.0, 5 * 60.0);
* if (secs <= -10 * 60.0 && x.Sum != 0.0) {
* secs += 5 * 60.0;
* }
* return new {Time = secs, Date = x.Key};
* }).ToList();
*/
var series = EnumerableEx.Generate(fixture.Min(x => x.Time), x => x <= fixture.Max(y => y.Time), x => x.AddMinutes(5.0), x => x)
.Select(x => new { Key = x, Sum = lookup[x].Sum(y => y.ProductivityInSeconds), Len = lookup[x].Count() })
.Aggregate(new { List = new List <DateTime>(), Secs = 0.0 }, (acc, x) => {
var toAdd = x.Sum;
if (x.Len == 0)
{
toAdd = 60.0 * (acc.Secs > 0 ? -1.0 : 1.0);
}
var secs = (acc.Secs + toAdd).Clamp(-10 * 60.0, 5 * 60.0);
if (secs <= -10 * 60.0 && x.Sum != 0.0)
{
acc.List.Add(x.Key);
secs += 5 * 60.0;
}
return(new { acc.List, Secs = secs });
}).List;
Assert.True(false);
}
public override void Execute(RecipeExecutionContext context)
{
foreach (var workflowDefinitionElement in context.RecipeStep.Step.Elements())
{
var workflowName = workflowDefinitionElement.Attribute("Name").Value;
Logger.Information("Importing workflow '{0}'.", workflowName);
try {
var workflowDefinition = GetOrCreateWorkflowDefinition(workflowName);
var activitiesElement = workflowDefinitionElement.Element("Activities");
var transitionsElement = workflowDefinitionElement.Element("Transitions");
var activitiesDictionary = new Dictionary <int, ActivityRecord>();
workflowDefinition.Enabled = Boolean.Parse(workflowDefinitionElement.Attribute("Enabled").Value);
foreach (var activityElement in activitiesElement.Elements())
{
var localId = Int32.Parse(activityElement.Attribute("Id").Value);
var activityName = activityElement.Attribute("Name").Value;
Logger.Information("Importing activity '{0}' with ID '{1}'.", activityName, localId);
var activity = new ActivityRecord {
Name = activityName,
Start = Boolean.Parse(activityElement.Attribute("Start").Value),
X = Int32.Parse(activityElement.Attribute("X").Value),
Y = Int32.Parse(activityElement.Attribute("Y").Value),
State = activityElement.Element("State").Value
};
activitiesDictionary.Add(localId, activity);
workflowDefinition.ActivityRecords.Add(activity);
}
foreach (var transitionElement in transitionsElement.Elements())
{
var sourceActivityId = Int32.Parse(transitionElement.Attribute("SourceActivityId").Value);
var sourceEndpoint = transitionElement.Attribute("SourceEndpoint").Value;
var destinationActivityId = Int32.Parse(transitionElement.Attribute("DestinationActivityId").Value);
var destinationEndpoint = transitionElement.Attribute("DestinationEndpoint").Value;
Logger.Information("Importing transition between activities '{0}' and '{1}'.", sourceActivityId, destinationActivityId);
workflowDefinition.TransitionRecords.Add(new TransitionRecord {
SourceActivityRecord = activitiesDictionary[sourceActivityId],
SourceEndpoint = sourceEndpoint,
DestinationActivityRecord = activitiesDictionary[destinationActivityId],
DestinationEndpoint = destinationEndpoint
});
}
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing workflow '{0}'.", workflowName);
throw;
}
}
}
public ActionResult EditPost(int id, string localId, string data)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to edit workflows")))
{
return(new HttpUnauthorizedResult());
}
var workflowDefinitionRecord = _workflowDefinitionRecords.Get(id);
if (workflowDefinitionRecord == null)
{
return(HttpNotFound());
}
workflowDefinitionRecord.Enabled = true;
var state = FormParametersHelper.FromJsonString(data);
var activitiesIndex = new Dictionary <string, ActivityRecord>();
workflowDefinitionRecord.ActivityRecords.Clear();
workflowDefinitionRecord.WorkflowRecords.Clear();
foreach (var activity in state.Activities)
{
ActivityRecord activityRecord;
workflowDefinitionRecord.ActivityRecords.Add(activityRecord = new ActivityRecord {
Name = activity.Name,
X = activity.Left,
Y = activity.Top,
Start = activity.Start,
State = FormParametersHelper.ToJsonString(activity.State),
WorkflowDefinitionRecord = workflowDefinitionRecord
});
activitiesIndex.Add((string)activity.ClientId, activityRecord);
}
workflowDefinitionRecord.TransitionRecords.Clear();
foreach (var connection in state.Connections)
{
workflowDefinitionRecord.TransitionRecords.Add(new TransitionRecord {
SourceActivityRecord = activitiesIndex[(string)connection.SourceId],
DestinationActivityRecord = activitiesIndex[(string)connection.TargetId],
SourceEndpoint = connection.SourceEndpoint,
WorkflowDefinitionRecord = workflowDefinitionRecord
});
}
Services.Notifier.Information(T("Workflow saved successfully"));
return(RedirectToAction("Edit", new { id, localId }));
}
public void SplitLinesInBufferTest()
{
string input = "Hello World\nTest\n\nOther Stuff\n\n";
string[] expected = new[] { "Hello World", "Test", "Other Stuff" };
var output = ActivityRecord.splitLinesInBuffer(input).ToArray();
Assert.Equal(expected.Length, output.Length);
expected.Zip(output, (e, a) => new { e, a }).Run(x => Assert.Equal(x.e, x.a));
}
public void ExecuteRecipeStep(RecipeContext recipeContext)
{
if (!String.Equals(recipeContext.RecipeStep.Name, "Workflows", StringComparison.OrdinalIgnoreCase))
{
return;
}
foreach (var workflowDefinitionElement in recipeContext.RecipeStep.Step.Elements())
{
var workflowDefinition = new WorkflowDefinitionRecord {
Name = ProbeWorkflowDefinitionName(workflowDefinitionElement.Attribute("Name").Value),
Enabled = Boolean.Parse(workflowDefinitionElement.Attribute("Enabled").Value)
};
_workflowDefinitionRepository.Create(workflowDefinition);
var activitiesElement = workflowDefinitionElement.Element("Activities");
var transitionsElement = workflowDefinitionElement.Element("Transitions");
var activitiesDictionary = new Dictionary <int, ActivityRecord>();
foreach (var activityElement in activitiesElement.Elements())
{
var localId = Int32.Parse(activityElement.Attribute("Id").Value);
var activity = new ActivityRecord {
Name = activityElement.Attribute("Name").Value,
Start = Boolean.Parse(activityElement.Attribute("Start").Value),
X = Int32.Parse(activityElement.Attribute("X").Value),
Y = Int32.Parse(activityElement.Attribute("Y").Value),
State = activityElement.Element("State").Value
};
activitiesDictionary.Add(localId, activity);
workflowDefinition.ActivityRecords.Add(activity);
}
foreach (var transitionElement in transitionsElement.Elements())
{
var sourceActivityId = Int32.Parse(transitionElement.Attribute("SourceActivityId").Value);
var sourceEndpoint = transitionElement.Attribute("SourceEndpoint").Value;
var destinationActivityId = Int32.Parse(transitionElement.Attribute("DestinationActivityId").Value);
var destinationEndpoint = transitionElement.Attribute("DestinationEndpoint").Value;
workflowDefinition.TransitionRecords.Add(new TransitionRecord {
SourceActivityRecord = activitiesDictionary[sourceActivityId],
SourceEndpoint = sourceEndpoint,
DestinationActivityRecord = activitiesDictionary[destinationActivityId],
DestinationEndpoint = destinationEndpoint
});
}
}
recipeContext.Executed = true;
}
public ActionResult Edit([Bind(Include = "Id,ActivityDate,ActivityID,DemandID,ProjectID,Size,ActualEffort_Hours,Comment")] ActivityRecord activityRecord)
{
if (ModelState.IsValid)
{
db.Entry(activityRecord).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ActivityID = new SelectList(db.Activities, "Id", "Name", activityRecord.ActivityID);
ViewBag.DemandID = new SelectList(db.Demands, "Id", "DemandType", activityRecord.DemandID);
ViewBag.ProjectID = new SelectList(db.Projects, "Id", "ProjectName", activityRecord.ProjectID);
return(View(activityRecord));
}
private void OnUnknownActivityLogged(ActivityRecord idleActivity)
{
if (!idleActivity.Idle)
{
_log.Warn("Unknown activity notification posted for non idle activity.");
return;
}
if (UnknownActivityLogged != null)
{
UnknownActivityLogged(this, new ActivityRecordEventArgs(idleActivity));
}
}
// GET: ActivityRecords/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ActivityRecord activityRecord = db.ActivityRecords.Find(id);
if (activityRecord == null)
{
return(HttpNotFound());
}
return(View(activityRecord));
}
public override void RemoveById(ActivityRecord record)
{
string procName = "spDeleteActivity";
if (record.Type == "D-Session")
{
procName = "spConsensusActivitiesSessionRemoveById";
}
DbCommand command = this.Provider.GetStoredProcedure(procName);
this.MapParameterIn(command, "@PA_USER_LOGIN_ID", "dev");
this.MapParametersIn(command, record, false);
this.Execute(command);
this.MapParametersOut(command, record);
}
private void SetIdleRecordActivity(ActivityRecord activityRecord)
{
if (activityRecord.StartTime.Date != activityRecord.EndTime.Date)
{
activityRecord.Activity = _homeActivity;
}
else if (activityRecord.Duration < _settings.MaximumBreakDuration)
{
activityRecord.Activity = _breakActivity;
}
else
{
activityRecord.Activity = null;
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ActivityRecord = await _context.ActivityRecord.FirstOrDefaultAsync(m => m.ID == id);
if (ActivityRecord == null)
{
return(NotFound());
}
return(Page());
}
public void Add(ActivityRecord activityRecord)
{
using (var entities = new UserActivityLogEntities())
{
if (activityRecord.Activity != null)
{
activityRecord.Activity =
entities.Activities.Single(a => a.ActivityId == activityRecord.Activity.ActivityId);
}
var record = entities.ActivityRecords.Add(activityRecord);
entities.SaveChanges();
activityRecord.ActivityRecordId = record.ActivityRecordId;
}
}
public void Add(ActivityRecord activityRecord)
{
using (var entities = new UserActivityLogEntities())
{
if (activityRecord.Activity != null)
{
activityRecord.Activity =
entities.Activities.Single(a => a.ActivityId == activityRecord.Activity.ActivityId);
}
var record = entities.ActivityRecords.Add(activityRecord);
entities.SaveChanges();
activityRecord.ActivityRecordId = record.ActivityRecordId;
}
}
public override void Modify(ActivityRecord record)
{
string procName = "spInsertUpdateActivity";
if (record.Type == "D-Session")
{
procName = "spInsertUpdateSession";
}
DbCommand command = this.Provider.GetStoredProcedure(procName);
this.MapParameterIn(command, "@PA_USER_LOGIN_ID", "dev");
this.MapParametersIn(command, record, true);
this.Execute(command);
this.MapParametersOut(command, record);
}
// GET: ActivityRecords/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ActivityRecord activityRecord = db.ActivityRecords.Find(id);
if (activityRecord == null)
{
return(HttpNotFound());
}
ViewBag.ActivityID = new SelectList(db.Activities, "Id", "Name", activityRecord.ActivityID);
ViewBag.DemandID = new SelectList(db.Demands, "Id", "DemandType", activityRecord.DemandID);
ViewBag.ProjectID = new SelectList(db.Projects, "Id", "ProjectName", activityRecord.ProjectID);
return(View(activityRecord));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ActivityRecord = await _context.ActivityRecord.FindAsync(id);
if (ActivityRecord != null)
{
_context.ActivityRecord.Remove(ActivityRecord);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public Task <ActivityContext> CreateActivityExecutionContextAsync(ActivityRecord activityRecord, JObject properties)
{
var activity = _activityLibrary.InstantiateActivity <IActivity>(activityRecord.Name, properties);
if (activity == null)
{
_logger.LogWarning("Requested activity '{ActivityName}' does not exist in the library. This could indicate a changed name or a missing feature. Replacing it with MissingActivity.", activityRecord.Name);
activity = new MissingActivity(_missingActivityLocalizer, _missingActivityLogger, activityRecord);
}
var context = new ActivityContext
{
ActivityRecord = activityRecord,
Activity = activity
};
return(Task.FromResult(context));
}
private static ActivityRecord Clone(ActivityRecord record)
{
return new ActivityRecord(record.ActivityRecordId)
{
Activity = Clone(record.Activity),
EndTime = record.EndTime,
Idle = record.Idle,
StartTime = record.StartTime,
ActivityRecordId = record.ActivityRecordId
};
}
public void Update(ActivityRecord activityRecord)
{
using (var entities = new UserActivityLogEntities())
{
var existingState =
entities.ActivityRecords.Single(s => s.ActivityRecordId == activityRecord.ActivityRecordId);
existingState.StartTime = activityRecord.StartTime;
existingState.EndTime = activityRecord.EndTime;
existingState.Idle = activityRecord.Idle;
if (activityRecord.Activity != null)
{
existingState.Activity =
entities.Activities.Single(a => a.ActivityId == activityRecord.Activity.ActivityId);
}
entities.SaveChanges();
}
}
public async Task Send(ActivityRecord activityRecord)
{
var message = new ActivityRecordMessage(activityRecord);
var jsonMessage = JsonConvert.SerializeObject(message, jsonSerializerSettings);
Debug.WriteLine("Send Activity-Record To Multiplayer-Server", message);
await Send(jsonMessage);
}
public async Task Send (ActivityRecord input)
{
string message = JsonConvert.SerializeObject (input, jsonSerializerSettings);
await Send (message);
}
public ActivityRecordMessage(ActivityRecord activityRecord)
{
this.ActivityRecord = activityRecord;
}
