public object Run(int agentId, int taskId, [System.Web.Http.FromBody] Dictionary <string, string> parameters)
{
var id = User.Identity.GetUserId();
var user = db.Query <UserDto>().Single(x => x.Id == id);
if (!user.ConfigurationManager && !user.Administrator)
{
return(new { Success = false, Error = "Only an administrator or configuration manager can execute tasks" });
}
using (var session = WebApiApplication.Store.OpenSession())
{
var deploy = new MaintenanceTask()
{
TemplatedTaskId = taskId,
AgentId = agentId,
Status = Status.Queud,
StartDate = System.DateTime.UtcNow,
UserId = User.Identity.GetUserId()
};
session.Save(deploy);
session.Flush();
BackgroundJob.Enqueue(() => MaintenanceJob.Execute(deploy.Id, parameters));
return(new { Success = true });
};
}
public async Task <IHttpActionResult> PutMaintenanceTask(int id, MaintenanceTask maintenanceTask)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != maintenanceTask.ID)
{
return(BadRequest());
}
db.Entry(maintenanceTask).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MaintenanceTaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
void Lv_ItemTapped(object sender, ItemTappedEventArgs e)
{
var action = ((ListView)sender).SelectedItem;
MaintenanceTask tsk = (MaintenanceTask)action;
this.Navigation.PushModalAsync(new MaintenanceDetail(tsk));
}
public void GetMaintenanceTasks_ShouldReturnCorrectTasks_GivenVINWithMultipleTasks()
{
var vin = "newVin11";
var expectedTask1 = new MaintenanceTask()
{
Id = 99969, VIN = vin, type = TaskType.OilChange
};
_repo.InsertMaintenanceTask(expectedTask1);
var expectedTask2 = new MaintenanceTask()
{
Id = 688886, VIN = vin, type = TaskType.GlowPlugReplacement
};
_repo.InsertMaintenanceTask(expectedTask2);
var actualTasks = _repo.GetMaintenanceTasks(expectedTask1.VIN);
var task1 = actualTasks.FirstOrDefault(t => t.Id == expectedTask1.Id);
Assert.IsNotNull(task1);
Assert.AreEqual(expectedTask1.Id, task1.Id);
Assert.AreEqual(expectedTask1.VIN, task1.VIN);
var task2 = actualTasks.FirstOrDefault(t => t.Id == expectedTask2.Id);
Assert.IsNotNull(task2);
Assert.AreEqual(expectedTask2.Id, task2.Id);
Assert.AreEqual(expectedTask2.VIN, task2.VIN);
}
private void gridControl1_Click(object sender, EventArgs e)
{
_selectedTask = (MaintenanceTask)TasksBindingSource.Current;
btnDeleteTask.Enabled = true;
AuthorizeForm();
}
public async Task <IActionResult> Edit(int id, [Bind("MaintenanceTaskId,VehicleId,MaintenanceTaskTitle,MaintenanceTaskDescription,TaskDueAtMileage,IsComplete,CreatedDate,TargetCompleteDate")] MaintenanceTask maintenanceTask)
{
if (id != maintenanceTask.MaintenanceTaskId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(maintenanceTask);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MaintenanceTaskExists(maintenanceTask.MaintenanceTaskId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(maintenanceTask));
}
internal void TaskAdded(MaintenanceTask _maintenanceTask)
{
_workOrder.Tasks.Add(_maintenanceTask);
BtnSave.Enabled = true;
CalculateLabour();
CalculateParts();
CalculateTotal();
}
/// <summary>
/// Sends an update of a Maintenancetask to the server , if there is a connection
/// </summary>
/// <param name="t"></param>
internal void UpdateMaintenanceTask(MaintenanceTask t)
{
if (serverConnection)
{
List <MaintenanceTask> tL = new List <MaintenanceTask>();
tL.Add(t);
restMng.PutMaintenanceTaskAsync(tL);
}
}
private void CreateMenu()
{
var pdfAction = new MenuItem {
Text = "Vis dokument"
};
pdfAction.SetBinding(MenuItem.CommandParameterProperty, new Binding("."));
pdfAction.Clicked += (sender, e) =>
{
var mi = ((MenuItem)sender);
MaintenanceTask _task = (MaintenanceTask)mi.CommandParameter;
MaintenancePage mp = new MaintenancePage();
mp.ShowPDF(_task);
};
var doneAction = new MenuItem {
Text = "Udført"
};
doneAction.SetBinding(MenuItem.CommandParameterProperty, new Binding("."));
doneAction.Clicked += (sender, e) =>
{
var mi = ((MenuItem)sender);
MaintenanceTask _task = (MaintenanceTask)mi.CommandParameter;
MaintenancePage mp = new MaintenancePage();
mp.SetDone(_task);
};
var mapAction = new MenuItem {
Text = "Kort"
};
mapAction.SetBinding(MenuItem.CommandParameterProperty, new Binding("."));
mapAction.Clicked += (sender, e) =>
{
var mi = ((MenuItem)sender);
MaintenanceTask _task = (MaintenanceTask)mi.CommandParameter;
MaintenancePage mp = new MaintenancePage();
mp.ShowOnMap(_task);
};
var StopTimeRegAction = new MenuItem {
Text = "Stop"
};
StopTimeRegAction.SetBinding(MenuItem.CommandParameterProperty, new Binding("."));
StopTimeRegAction.Clicked += async(sender, e) =>
{
MaintenanceDetail md = new MaintenanceDetail(new MaintenanceTask());
md.StopCurrentJobRec();
};
//ContextActions.Add(pdfAction);
//ContextActions.Add(mapAction);
ContextActions.Add(doneAction);
ContextActions.Add(StopTimeRegAction);
}
public async Task <IActionResult> CreateConfirmed([Bind("MaintenanceTaskId,VehicleId,MaintenanceTaskTitle,MaintenanceTaskDescription,TaskDueAtMileage,IsComplete,TargetCompleteDate")] MaintenanceTask maintenanceTask)
{
if (ModelState.IsValid)
{
_context.Add(maintenanceTask);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(NotFound());
}
public void Restore(string entityName, IEnumerable <string> keys, IEnumerable <string> entitiesToSkip = null)
{
EntityType entityType = GetEntityType(entityName);
IEntityTypeFilter filter = SetUpFilter(entitiesToSkip);
IDependencyResolver dependencyResolver = new DependencyResolver(backupRepository);
var restoreTask = new MaintenanceTask(metadataWorkspace, backupRepository, productionRepository, dependencyResolver, filter);
var entityKeyMembers = GetEntityKeys(entityType, keys.ToArray());
restoreTask.Save(entityName, entityKeyMembers);
}
public async Task <IHttpActionResult> GetMaintenanceTask(int id)
{
MaintenanceTask maintenanceTask = await db.MaintenanceTasks.FindAsync(id);
if (maintenanceTask == null)
{
return(NotFound());
}
return(Ok(maintenanceTask));
}
public async Task <IHttpActionResult> PostMaintenanceTask(MaintenanceTask maintenanceTask)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.MaintenanceTasks.Add(maintenanceTask);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = maintenanceTask.ID }, maintenanceTask));
}
public void InsertMaintenanceTask_ShouldThrowArgumentExcption_GivenTaskWithDuplicateId()
{
var expectedTask = new MaintenanceTask()
{
Id = 9, VIN = "5555"
};
_repo.InsertMaintenanceTask(expectedTask);
_repo.InsertMaintenanceTask(expectedTask);
_repo.GetTask(expectedTask.Id);
}
private void BtnNewTask_Click(object sender, EventArgs e)
{
var mtv = new MaintenaceTaskView();
var mt = new MaintenanceTask();
mtv.ShowObject(mt);
var result = mtv.ShowDialog();
if (result == DialogResult.OK)
{
_workOrder.Tasks.Add(mtv.CurrentTask);
}
}
public void PostMaintenanceTask_ShouldCallRepository_InsertTask()
{
var _mockRepo = new Mock <IMaintenanceTaskRepository>();
var controller = new MaintenanceTaskController(_mockRepo.Object);
var newAuto = new MaintenanceTask()
{
Id = 1
};
controller.PostMaintenanceTask(newAuto);
_mockRepo.Verify(m => m.InsertMaintenanceTask(newAuto));
}
public void SaveChanges()
{
if (!ValidateForm())
{
return;
}
maintenaceTaskBindingSource.EndEdit();
partsBindingSource.EndEdit();
labourBindingSource.EndEdit();
_maintenanceTask = (MaintenanceTask)maintenaceTaskBindingSource.DataSource;
_hasChange = false;
this.DialogResult = DialogResult.OK;
}
public void ShowOnMap(MaintenanceTask _task)
{
//if (_task.longitude != 0 && _task.latitude != 0)
//{
// string s = "https://www.google.dk/maps/place/" + _task.latitude + "," + _task.longitude + "/" + _task.latitude + "," + _task.longitude + "z/";
// Uri uri = new Uri(s);
// Device.OpenUri(uri);
//}
//else
//{
// DisplayAlert("Ingen koordinater", "Der er ingen koordinater på opgaven. Bekræft at opgaven er afsluttet, og prøv igen.", "OK");
//}
}
public JobRecLineForm(MaintenanceTask task)
{
recLine = new JobRecLine();
taskGlobal = task;
workTypePicker = new Picker()
{
VerticalOptions = LayoutOptions.Start
};
workTypePicker.Title = "Vælg arbejdstype";
workTypePicker.SelectedIndexChanged += WorkTypePicker_SelectedIndexChanged;
resourceMachinePicker = new Picker()
{
VerticalOptions = LayoutOptions.Start
};
resourceMachinePicker.Title = "Vælg Maskine";
resourceMachinePicker.SelectedIndexChanged += ResourceMachinePicker_SelectedIndexChanged;
SetItemssources();
start = new Button {
Text = "Start opgave", BackgroundColor = Color.FromRgb(135, 206, 250), TextColor = Color.White, VerticalOptions = LayoutOptions.Start
};
cancel = new Button {
Text = "Cancel", BackgroundColor = Color.FromRgb(135, 206, 250), TextColor = Color.White, VerticalOptions = LayoutOptions.Start
};
datePicker = new DatePicker()
{
Format = "D",
Date = DateTime.Today
};
start.Clicked += Start_Clicked;
cancel.Clicked += Cancel_Clicked;
layout = new StackLayout
{
Children =
{
//datePicker,
workTypePicker,
resourceMachinePicker,
start,
cancel
}
};
layout.VerticalOptions = LayoutOptions.Center;
if (Device.RuntimePlatform.Equals("iOS"))
{
// move layout under the status bar
layout.Padding = new Thickness(0, 20, 0, 0);
}
Content = layout;
}
public async Task <IHttpActionResult> DeleteMaintenanceTask(int id)
{
MaintenanceTask maintenanceTask = await db.MaintenanceTasks.FindAsync(id);
if (maintenanceTask == null)
{
return(NotFound());
}
db.MaintenanceTasks.Remove(maintenanceTask);
await db.SaveChangesAsync();
return(Ok(maintenanceTask));
}
public void InsertMaintenanceTask(MaintenanceTask task)
{
if (task == null || string.IsNullOrWhiteSpace(task.VIN) || task.type == TaskType.Invalid)
{
throw new ArgumentException("Invalid task, either task is null, vin is invalid, or task type is invalid");
}
var existingTask = GetTask(task.Id);
if (existingTask != null)
{
throw new ArgumentException("Duplicate id is not allowed");
}
_storedTasks.Add(task);
}
public async void CreateModifyAndDeleteMT()
{
var fdId = 1;
var dt = DateTime.Now;
var desc = "testing creation";
var crit = 0;
using (var context = new FactoryContext(builder.Options)) {
IMaintenanceTaskService service = new MaintenanceTaskService(context);
MaintenanceTask created = await CreateMT(
service,
new MaintenanceTask {
FactoryDeviceId = fdId,
Time = dt,
Description = desc,
Criticality = (Criticality)crit
});
Assert.NotNull(created);
Assert.Equal(fdId, created.FactoryDeviceId);
Assert.Equal(dt, created.Time);
Assert.Equal(desc, created.Description);
Assert.Equal((Criticality)crit, created.Criticality);
Assert.False(created.Done);
created.FactoryDeviceId = 2;
created.Description = "testing modification";
created.Criticality = Criticality.Minor;
created.Done = true;
MaintenanceTask updated = await UpdateMT(service, created);
Assert.NotNull(updated);
Assert.Equal(created.Id, updated.Id);
Assert.NotEqual(fdId, updated.FactoryDeviceId);
Assert.Equal(created.FactoryDeviceId, updated.FactoryDeviceId);
Assert.Equal(dt, updated.Time);
Assert.NotEqual(desc, updated.Description);
Assert.Equal(created.Description, updated.Description);
Assert.NotEqual((Criticality)crit, updated.Criticality);
Assert.Equal(created.Criticality, updated.Criticality);
Assert.True(created.Done);
bool deleted = await DeleteMT(service, updated.Id);
Assert.True(deleted);
Assert.Null(await service.Get(updated.Id));
}
}
public void GetMaintenanceTasks_ShouldReturn_InsertedTask()
{
var expectedTask = new MaintenanceTask()
{
Id = 11, VIN = "1011", type = TaskType.OilChange
};
_repo.InsertMaintenanceTask(expectedTask);
var tasks = _repo.GetMaintenanceTasks();
var actualtask = tasks.FirstOrDefault(a => a.VIN == expectedTask.VIN);
Assert.IsNotNull(actualtask);
Assert.AreEqual(expectedTask.VIN, actualtask.VIN);
}
//==========================CREATE===============================//
public async Task <bool> CreateMaintenanceTask(MaintenanceTaskCreate model)
{
var entity =
new MaintenanceTask()
{
MaintenanceTaskName = model.MaintenanceTaskName,
MaintenanceTaskDescription = model.MaintenanceTaskDescription,
Active = true,
MaintenanceTaskInterval = Convert.ToInt64(model.MaintenanceTaskIntervalHours * 36000000000),
MachineId = model.MachineId
};
_context.Tasks.Add(entity);
return(await _context.SaveChangesAsync() == 1);
}
public void DeleteMaintenanceTask_ShouldDeleteExistingTask()
{
var existingTask = new MaintenanceTask()
{
Id = 789977, VIN = "vin for deletion", type = TaskType.OilChange
};
_repo.InsertMaintenanceTask(existingTask);
_repo.DeleteMaintenanceTask(existingTask.Id);
var actuaTask = _repo.GetTask(existingTask.Id);
Assert.IsNull(actuaTask);
}
/// <summary>
/// Adds task specific information to view from given task
/// </summary>
/// <param name="t">Task</param>
private void SetData(Task t)
{
this.SetGeneralData(t);
if (t is TransportTask)
{
TransportTask tt = t as TransportTask;
this.TargetBuilding = tt.TargetLocation.Building;
this.TargetFloor = tt.TargetLocation.Floor;
this.TargetRoom = tt.TargetLocation.Room;
}
if (t is MaintenanceTask)
{
MaintenanceTask mt = t as MaintenanceTask;
}
}
private void gridControl1_DoubleClick(object sender, EventArgs e)
{
TasksBindingSource.EndEdit();
_selectedTask = (MaintenanceTask)TasksBindingSource.Current;
var mtv = new MaintenaceTaskView();
mtv.ShowObject(_selectedTask);
var result = mtv.ShowDialog();
if (result == DialogResult.OK)
{
_workOrder.Tasks.Add(mtv.CurrentTask);
BtnSave.Enabled = true;
}
}
public IHttpActionResult PostMaintenanceTask(MaintenanceTask newTask)
{
if (newTask == null)
{
return(BadRequest());
}
try {
_repository.InsertMaintenanceTask(newTask);
}
catch (Exception e)
{
return(InternalServerError(e));
}
return(Content(HttpStatusCode.Accepted, newTask));
}
public void ShowObject(object keyValue)
{
_maintenanceTask = keyValue as MaintenanceTask;
maintenaceTaskBindingSource.DataSource = _maintenanceTask;
partsBindingSource.DataSource = _maintenanceTask.Parts;
labourBindingSource.DataSource = _maintenanceTask.Labours;
_newMode = true;
isItemizedCheckBox.Checked = true;
LoadLookUps();
BtnSave.Enabled = true;
if (_maintenanceTask.TaskId != 0)
{
ServiceLookUp.Enabled = false;
_newMode = false;
}
}
public void MaintenanceTaskRepository_ShouldRetainListOfTasks_GivenMultipleInstances()
{
var expectedTask = new MaintenanceTask()
{
Id = 33, VIN = "1111", type = TaskType.OilChange
};
_repo.InsertMaintenanceTask(expectedTask);
var repo2 = new MaintenanceTaskRepository();
var actualtask = repo2.GetTask(expectedTask.Id);
Assert.IsNotNull(actualtask);
Assert.AreEqual(expectedTask.VIN, actualtask.VIN);
}
