public CoreTask UpdateTask(Guid taskId, string taskName, string taskDescription, DateTime taskDateTime, int taskPriority)
{
var coreTask = new CoreTask(taskId: taskId, taskDateTime: taskDateTime, taskDescription: taskDescription, taskPriority: taskPriority, taskName: taskName);
var updatedTask = _dataStore.UpdateTask(coreTask);
return(updatedTask);
}
public CoreTask SaveTask(string taskName, string taskDescription, DateTime taskDateTime, int taskPriority)
{
var coreTask = new CoreTask(taskId: Guid.NewGuid(), taskDateTime: taskDateTime, taskDescription: taskDescription, taskPriority: taskPriority, taskName: taskName);
_dataStore.AddTask(coreTask);
return(coreTask);
}
private void SetEvent()
{
Closing += OnClosing;
Deactivated += OnLostFocus;
entryTask = Core.AddTask(EntryUpdate);
}
internal CoreTask UpdateTask(CoreTask coreTask)
{
taskDataStore.TaskList.RemoveAll(t => t.TaskId == coreTask.TaskId);
taskDataStore.AddTask(coreTask);
var updatedTask = GetTask(coreTask.TaskId);
return(updatedTask);
}
private void RemoveEntryTask()
{
if (entryTask != null)
{
Core.RemoveTask(entryTask);
entryTask = null;
}
}
private void StopExitMotion()
{
if (exitMotionTask == null)
{
return;
}
Core.RemoveTask(exitMotionTask);
exitMotionTask = null;
}
private new void Close()
{
if (closingTask != null)
{
return;
}
RemoveEntryTask();
closingTask = Core.AddTask(ClosingUpdate);
}
public void CreateTaskValidateTaskName(string taskName)
{
var taskId = Guid.NewGuid();
var taskDescription = "testTaskDescription";
var taskDate = DateTime.UtcNow;
var taskPriority = 1;
Assert.Throws <ArgumentException>(() =>
{
var coreTask = new CoreTask(taskId, taskName, taskDescription, taskDate, taskPriority);
});
}
public void CreateTaskValidateTaskDescription()
{
var taskId = Guid.NewGuid();
var taskName = "testTask";
var taskDescription = TestHelper.RandomStringGenerator(202);
var taskDate = DateTime.UtcNow;
var taskPriority = 1;
Assert.Throws <ArgumentException>(() =>
{
var coreTask = new CoreTask(taskId, taskName, taskDescription, taskDate, taskPriority);
});
}
private async void StopEntryMotion()
{
if (entryMotionTask == null)
{
return;
}
Core.RemoveTask(entryMotionTask);
entryMotionTask = null;
await Task.Delay((int)(DelaySeconds * 1000f));
StartExitMotion();
}
public void CreateTaskValidateTaskDescriptionNull()
{
var taskId = Guid.NewGuid();
var taskName = "testTask";
var taskDate = DateTime.UtcNow;
var taskPriority = 1;
var coreTask = new CoreTask(taskId, taskName, null, taskDate, taskPriority);
// Assert properties on the object
Assert.Equal(taskId, coreTask.TaskId);
Assert.Equal(taskName, coreTask.TaskName);
Assert.Null(coreTask.TaskDescription);
Assert.Equal(taskDate, coreTask.TaskDateTime);
Assert.Equal(taskPriority, coreTask.TaskPriority);
}
private void Simulation()
{
_isWorking = true;
Log("Simulation started.");
List <Drone> drones = _db.Drones.Include("Model").ToList();
Random random = new Random(DateTime.Now.GetHashCode());
int max = _db.Stations.ToList().Count;
foreach (Drone drone in drones)
{
string address = "http://localhost:4999/Drone/" + drone.Id;
DroneServiceClient client =
new DroneServiceClient(new WSHttpBinding(), new EndpointAddress(new Uri(address)));
int closestStationId = random.Next(max) + 1;
client.AddTask(new DroneTask(DroneTaskType.GoToStation,
_db.Stations.First(s => s.Id == closestStationId)));
_messageHandler.Handle(String.Format("Drone {0} set to go to station {1}.", drone.Id,
closestStationId));
}
while (_isWorking)
{
if (_tasks.Count > 0)
{
CoreTask task = _tasks.Dequeue();
switch (task.Type)
{
case CoreTaskType.CheckDronesStatus:
CheckDronesStatus();
break;
case CoreTaskType.CheckStationsStatus:
CheckStationsStatus();
break;
}
}
else
{
Thread.Sleep(5000);
_tasks.Enqueue(new CoreTask(CoreTaskType.CheckDronesStatus));
_tasks.Enqueue(new CoreTask(CoreTaskType.CheckStationsStatus));
}
}
_messageHandler.Handle("Simulation stoped.");
}
internal static TaskViewModel ConvertToTaskModel(CoreTask coreTask)
{
if (coreTask == null)
{
return(null);
}
var taskModel = new TaskViewModel()
{
TaskId = coreTask.TaskId,
TaskName = coreTask.TaskName,
TaskDateTime = coreTask.TaskDateTime,
TaskDescription = coreTask.TaskDescription,
TaskPriority = coreTask.TaskPriority
};
return(taskModel);
}
public void Test_NastyaTask()
{
IRunTask <int> nastyaTask = CoreTask.GeCoreTask().GetNastyaTask(5, new[] { 1, 1, 1, 1, 1 });
int resultNastyaTask = nastyaTask.Run();
Assert.AreEqual(resultNastyaTask, 1);
nastyaTask = CoreTask.GeCoreTask().GetNastyaTask(3, new[] { 2, 0, -1 });
resultNastyaTask = nastyaTask.Run();
Assert.AreEqual(resultNastyaTask, 2);
nastyaTask = CoreTask.GeCoreTask().GetNastyaTask(4, new[] { 5, -6, -5, 1 });
resultNastyaTask = nastyaTask.Run();
Assert.AreEqual(resultNastyaTask, 4);
nastyaTask = CoreTask.GeCoreTask().GetNastyaTask(0, new int[] { });
resultNastyaTask = nastyaTask.Run();
Assert.AreEqual(resultNastyaTask, 0);
Assert.Throws <ArgumentNullException>(() => CoreTask.GeCoreTask().GetNastyaTask(3, null));
Assert.Throws <IndexOutOfRangeException>(() => CoreTask.GeCoreTask().GetNastyaTask(1, new[] { 5, -6, -5, 1 }));
}
public void Test_Water()
{
IRunTask <uint> water = CoreTask.GeCoreTask().GetWaterTaskUintValue(new uint[] { 2, 5, 1, 2, 3, 4, 7, 7, 6 });
uint square = water.Run();
Assert.AreEqual(square, 10);
CollectionAssert.AreEqual((water as IInputCollection <uint>).InputValue, new uint[] { 2, 5, 1, 2, 3, 4, 7, 7, 6 });
Assert.AreEqual((water as IResult <uint>).ResultCollection, square);
water = CoreTask.GeCoreTask().GetWaterTaskUintValue(new uint[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
square = water.Run();
Assert.AreEqual(square, 0);
water = CoreTask.GeCoreTask().GetWaterTaskUintValue(null);
Assert.Throws <Exception>(() => water.Run());
water = CoreTask.GeCoreTask().GetWaterTaskUintValue(new uint[] { });
Assert.Throws <Exception>(() => water.Run());
water = CoreTask.GeCoreTask().GetWaterTaskUintValue(new uint[] { 0, 0, 0, 0, 0, 0 });
Assert.Throws <Exception>(() => water.Run());
}
public void Test_BearTask()
{
uint[] array = { 4, 2, 3, 1, 5, 1, 6, 4 };
uint n = (uint)array.Length;
IRunTask <uint> bear = CoreTask.GeCoreTask().GetBearTask(n, 4, new uint[] { 4, 2, 3, 1, 5, 1, 6, 4 });
uint resultBearTask = bear.Run();
Assert.AreEqual(resultBearTask, 5);
CollectionAssert.AreEqual((bear as IInputCollection <uint>).InputValue, array);
Assert.AreEqual((bear as IResult <uint>).ResultCollection, resultBearTask);
array = new uint[] { 3, 1, 2, 1, 3 };
n = (uint)array.Length;
bear = CoreTask.GeCoreTask().GetBearTask(n, 2, array);
resultBearTask = bear.Run();
Assert.AreEqual(resultBearTask, 0);
CollectionAssert.AreEqual((bear as IInputCollection <uint>).InputValue, array);
Assert.AreEqual((bear as IResult <uint>).ResultCollection, resultBearTask);
array = new uint[] { 12, 34, 55, 43, 21 };
n = (uint)array.Length;
bear = CoreTask.GeCoreTask().GetBearTask(n, 100, array);
resultBearTask = bear.Run();
Assert.AreEqual(resultBearTask, 5);
CollectionAssert.AreEqual((bear as IInputCollection <uint>).InputValue, array);
Assert.AreEqual((bear as IResult <uint>).ResultCollection, resultBearTask);
array = new uint[] { 12, 34, 55, 43, 21 };
n = 2;
Assert.Throws <IndexOutOfRangeException>(() => CoreTask.GeCoreTask().GetBearTask(n, 100, array));
array = new uint[] { 12, 34, 55, 43, 21 };
n = (uint)array.Length;
uint k = 101;
Assert.Throws <ArgumentException>(() => CoreTask.GeCoreTask().GetBearTask(n, k, array));
array = new uint[] { 12, 34, 55, 43, 21 };
n = 0;
k = 10;
Assert.Throws <ArgumentException>(() => CoreTask.GeCoreTask().GetBearTask(n, k, array));
array = null;
n = 1;
k = 10;
Assert.Throws <NullReferenceException>(() => CoreTask.GeCoreTask().GetBearTask(n, k, array));
}
private void UpdateFrame()
{
if (MouseInput.RightDown)
{
const float DeltaThreshold = 10f;
int removeIndex = -1;
int addIndex = -1;
//Inspect Exist Point
Vector2 screenCursorPos = this.GraphCursorPos;
Vector2 viewportPos = ScreenToViewport(screenCursorPos);
for (int i = 0; i < pointList.Count; ++i)
{
Vector2 cursorDelta = ViewportToScreen(pointList[i].points[1].Value) - screenCursorPos;
if (cursorDelta.magnitude < 10f)
{
if (i != 0 && i != pointList.Count - 1)
{
removeIndex = i;
}
break;
}
}
//Inspect Line
float graphY = CalcY(viewportPos.x);
float cursorDeltaY = ViewportToScreen(new Vector2(0f, graphY)).y - screenCursorPos.y;
if (Mathf.Abs(cursorDeltaY) < DeltaThreshold * 2f)
{
int rightIndex = FindRightIndex(viewportPos.x);
addIndex = rightIndex;
}
//Create Menu
Queue <MenuWindowItem> menuQueue = new Queue <MenuWindowItem>();
if (addIndex != -1)
{
menuQueue.Enqueue(new MenuWindowItem("포인트 추가", () => {
GPoint point = AddPoint(addIndex);
float pointY = CalcY(viewportPos.x);
point.SetPoint(1, new Vector2(viewportPos.x, pointY));
point.SetDefaultAnchor(0.1f);
RenderGraph();
SetSaveDirtyFlag();
}));
}
if (removeIndex != -1)
{
menuQueue.Enqueue(new MenuWindowItem("포인트 제거", () => {
RemovePoint(pointList[removeIndex]);
RenderGraph();
SetSaveDirtyFlag();
}));
}
if (menuQueue.Count > 0)
{
MenuWindow menu = new MenuWindow(menuQueue.ToArray());
menu.Show();
}
}
const float MaxOffset = 1.5f;
if (MouseInput.LeftDown)
{
if (KeyInput.GetKey(WinKey.Space))
{
if (KeyInput.GetKey(WinKey.LeftControl))
{
const float ZoomStep = 0.005f;
const float ZoomMin = -0.1f;
const float ZoomMax = 1.8f;
float pressPos = MouseInput.AbsolutePosition.x;
float pressWidth = viewportWidth;
bool enable = true;
core.AddTask(() => {
if (!enable)
{
return;
}
if (!MouseInput.LeftAuto)
{
enable = false;
}
float delta = MouseInput.AbsolutePosition.x - pressPos;
viewportWidth = Mathf.Clamp(pressWidth + -delta * ZoomStep, ZoomMin, ZoomMax);
RenderGraph();
UpdatePoints();
}, TaskPriolity.EveryFrame, TaskEvent.MouseUpRemove);
}
else
{
const float OffsetStep = 0.01f;
if (!onDrag)
{
onDrag = true;
float pressPos = MouseInput.AbsolutePosition.y;
float pressOffset = viewportOffset;
bool enable = true;
core.AddTask(() => {
if (!enable)
{
return;
}
if (!MouseInput.LeftAuto)
{
onDrag = false;
enable = false;
}
float delta = MouseInput.AbsolutePosition.y - pressPos;
viewportOffset = Mathf.Clamp(pressOffset + delta * OffsetStep, -MaxOffset, MaxOffset);
RenderGraph();
UpdatePoints();
}, TaskPriolity.EveryFrame, TaskEvent.MouseUpRemove);
}
}
}
}
if (MouseInput.MiddleDown)
{
const float OffsetStep = 0.01f;
if (!onDrag)
{
onDrag = true;
float pressPos = MouseInput.AbsolutePosition.y;
float pressOffset = viewportOffset;
bool enable = true;
CoreTask task = null;
task = core.AddTask(() => {
if (!enable)
{
return;
}
if (!MouseInput.MiddleAuto)
{
onDrag = false;
enable = false;
core.RemoveTask(task);
}
float delta = MouseInput.AbsolutePosition.y - pressPos;
viewportOffset = Mathf.Clamp(pressOffset + delta * OffsetStep, -MaxOffset, MaxOffset);
RenderGraph();
UpdatePoints();
});
}
}
}
internal void AddTask(CoreTask coreTask)
{
taskDataStore.TaskList.Add(coreTask);
}
private void StartExitMotion()
{
exitMotionTask = Core.AddTask(UpdateExitMotion);
}
private void StartEntryMotion()
{
Opacity = 0f;
entryMotionTask = Core.AddTask(UpdateEntryMotion);
}
