void TaskFinished(UpdateTask obj)
{
_task.Finished -= TaskFinished;
_task.StateChanged -= TaskStateChanged;
Close();
}
public async Task <IActionResult> Update([FromRoute] int id, [FromBody] UpdateTask updateTask)
{
if (id != updateTask.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var entity = await this.taskService.Get(id);
if (entity == null)
{
return(NotFound());
}
await this.taskService.Update(TaskMapper.Map(new Model.Task(), updateTask));
return(NoContent());
}
catch (Exception ex)
{
this.logger.LogError(ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public ActionResult updateTaskDescription(UpdateTask task)
{
if (ModelState.IsValid)
{
return(Ok(service.UpdateTaskDescription(task.Id, task.Description)));
}
return(BadRequest());
}
public ActionResult updateTaskName(UpdateTask task)
{
if (ModelState.IsValid)
{
return(Ok(service.UpdateTaskName(task.Id, task.Name)));
}
return(BadRequest());
}
public ActionResult updateTaskStatus(UpdateTask task)
{
if (ModelState.IsValid)
{
Status status = (Status)Enum.Parse(typeof(Status), task.Status, true);
return(Ok(service.UpdateTaskStatus(task.Id, status)));
}
return(BadRequest());
}
public async Task <IHttpActionResult> UpdateTasks(int id, [FromBody] UpdateTask updateTask)
{
var task = await _dbContext.Tasks.FindAsync(id);
_dbContext.Entry(task).CurrentValues.SetValues(updateTask);
await _dbContext.SaveChangesAsync();
return(Ok());
}
public async Task <IHttpActionResult> UpdateTaskAsync(UpdateTask updateTask)
{
var response = await _task.UpdateTaskAsync(updateTask.IdTask, updateTask.State);
if (response.IsSuccess)
{
return(Ok(response));
}
return(BadRequest(response.Message));
}
public void ApplyUpdate(AppInfo appInfo, UpdateInfo info, UpdateHost updateInfoSource)
{
string lockFile = InstallationSettings.InstallationFolder + "/Updater.lock";
if (File.Exists(lockFile))
{
throw new Exception("Could not update: the application folder is already locked by another updater instance.");
}
else
{
File.Create(lockFile).Close();
}
TriggerProgressEvent(0, "Calculating updater tasks");
FileIndex index = FileIndex.Deserialize(InstallationSettings.InstallationFolder + "/UpdateIndex.dat");
UpdateTask[] tasks = GetUpdaterTasks(appInfo, info, updateInfoSource, index);
List <UpdateTask> failedTasks = RunTasks(tasks, true, 10);
TriggerProgressEvent(percentageDone, "Retrying failed tasks");
for (int i = 0; i < failedTasks.Count; i++)
{
UpdateTask task = failedTasks[i];
try {
task.Run();
} catch (WebException ex) {
if (MessageBox.Show("Updater could not download file: " + ex.Message + "\r\n(" + ex.Data["Target"] + ")", "Failed to download file", MessageBoxButtons.RetryCancel, MessageBoxIcon.Error).Equals(DialogResult.Retry))
{
i--; //Retry
}
else
{
Application.Exit();
}
} catch (UnauthorizedAccessException ex) {
if (MessageBox.Show("Updater could access file or folder: " + ex.Message + "\r\n(" + ex.Data["Target"] + ")", "Failed to download file", MessageBoxButtons.RetryCancel, MessageBoxIcon.Error).Equals(DialogResult.Retry))
{
i--; //Retry
}
else
{
Application.Exit();
}
}
}
TriggerProgressEvent(98, "Updating local file index");
index = new FileIndex(index.appID);
index.applicationVersion = info.version;
index.files.AddRange(info.fileChecksums.Keys);
index.Serialize(InstallationSettings.InstallationFolder + "/UpdateIndex.dat");
File.Delete(lockFile);
}
internal void ChangeParametrs()
{
Console.WriteLine("enter new parameters");
var taskParametrs = AddTask();
int numberTaskChange = SelectNumberTask();
CheckParametrs(taskParametrs, numberTaskChange);
UpdateTask update = ConsoleReadWrite.PrintNumberUpdateTask;
update(numberTaskChange);
}
private void Update()
{
if (!this._manager.IsReady)
{
MessageBox.Show("Please wait for Store to be ready before attempting to make a SPARQL Update", "Store Not Ready", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
UpdateTask task = new UpdateTask(this._manager, this.txtSparqlUpdate.Text);
this.AddTask <TaskResult>(task, this.UpdateCallback);
}
public ICollection <UpdateTask> GetUpdates(ICollection <ClanObject> newClans)
{
var tasks = new List <UpdateTask>();
var newList = newClans.ToDictionary(c => c.Tag);
var oldList = db.Clans.ToDictionary(c => c.Tag);
foreach (var oldItem in oldList)
{
var task = new UpdateTask
{
ID = Guid.NewGuid(),
ClanTag = oldItem.Key,
ClanName = oldItem.Value.Name
};
if (newList.TryGetValue(oldItem.Key, out ClanObject newItem))
{
task.Mode = UpdateTaskMode.Update;
task.ClanGroup = newItem.Group;
}
else
{
task.Mode = UpdateTaskMode.Delete;
}
tasks.Add(task);
}
foreach (var newItem in newList)
{
if (!oldList.ContainsKey(newItem.Key))
{
var task = new UpdateTask
{
ID = Guid.NewGuid(),
ClanTag = newItem.Key,
ClanName = newItem.Value.Name,
ClanGroup = newItem.Value.Group,
Mode = UpdateTaskMode.Insert
};
tasks.Add(task);
}
}
foreach (var task in tasks)
{
db.UpdateTasks.Add(task);
}
db.SaveChanges();
return(tasks);
}
public async Task UpdateTask(Guid taskId, UpdateTask update)
{
var task = await _dataContext.UserTasks.FindAsync(taskId);
if (task == null)
{
throw new NotFoundException(new[] { "Task not found." });
}
task.Name = update.Name;
task.TargetDate = update.TargetDate;
task.Priority = update.Priority;
await _dataContext.SaveChangesAsync();
}
public ActionResult EditTask(List <string> _Fields)
{
UpdateTask updateTask = new UpdateTask(_Fields);
updateTask.Edit();
var r = updateTask.GetTask();
var Result = new
{
rName = r.Name,
rObjective = r.Objective,
rCategory = r.Category.Name,
rPriority = r.Priority.Name
};
return(Json(Result));//RedirectToAction("ToDo");
}
public async Task Run_ReturnsNoContentOnSuccess()
{
var handler = new Mock <ICommandHander <UpdateTaskCommand> >();
var container = new Container();
var task = new TaskDTO();
var listId = Guid.NewGuid().ToString();
var taskId = Guid.NewGuid().ToString();
handler.Setup(h => h.Execute(It.IsAny <UpdateTaskCommand>())).Returns(Task.CompletedTask);
container.RegisterInstance(handler.Object);
container.RegisterInstance(_telemetryClient);
UpdateTask.Container = container;
var result = await UpdateTask.Run(task, listId, taskId) as NoContentResult;
Assert.IsNotNull(result);
}
public async Task Run_ReturnsServerErrorOnServerError()
{
var handler = new Mock <ICommandHander <UpdateTaskCommand> >();
var container = new Container();
var task = new TaskDTO();
var listId = Guid.NewGuid().ToString();
var taskId = Guid.NewGuid().ToString();
handler.Setup(h => h.Execute(It.IsAny <UpdateTaskCommand>()))
.ThrowsAsync(new Exception());
container.RegisterInstance(handler.Object);
container.RegisterInstance(_telemetryClient);
UpdateTask.Container = container;
var result = await UpdateTask.Run(task, listId, taskId) as InternalServerErrorResult;
Assert.IsNotNull(result);
}
public DataPortalResult Update(object obj, DataPortalContext context)
{
Thread t = new Thread(DoUpdate);
UpdateTask task = new UpdateTask();
task.Obj = obj;
task.Context = context;
t.Start(task);
t.Join();
return task.Result;
}
public async Task<DataPortalResult> Update(object obj, DataPortalContext context, bool isSync)
{
//Security.BusinessPrincipal
//var temp = new DataPortalContext(new UnauthenticatedPrincipal(), context.IsRemotePortal);
var task =
new UpdateTask
{
Obj = obj,
Context = context
};
if (isSync)
DoUpdate(task);
else
await Task.Factory.StartNew(DoUpdate, task);
if (task.ResultException != null)
throw task.ResultException;
return task.Result;
}
public void EnqueueTask(UpdateTask task)
{
Contract.Requires(task != null);
taskQueue.Enqueue(task);
}
public bool ContainsTask(UpdateTask task)
{
Contract.Requires(task != null);
return taskQueue.Contains(task);
}
public void EnqueueRunOnceTask(UpdateTask task)
{
if (!updateTasks.Contains(task))
updateTasks.Enqueue(task);
}
internal int AddTask( Task task, int interval ){
UpdateTask newTask = new UpdateTask();
newTask.nextTime = DateTime.Now;
newTask.callback = task;
newTask.interval = interval;
updateTasks.Add( updateTaskCounter, newTask );
return updateTaskCounter++;
}
public void UpdateTaskDescriptionTitleDueDateUtc(UpdateTaskDescriptionTitleAndDueDateUtc req)
{
if (req.TaskId == Guid.Empty)
throw ApiHelpers.ServerError("Request contains an invalid task id");
var taskClient = _clientFactory.GetTaskQueryServiceClient();
var task = taskClient.GetTaskById(req.TaskId);
if (task == null) throw ApiHelpers.ServerError("Task for which an update was requested does not exist");
if (task.TaskType != TaskType.Consultant && task.TaskType != TaskType.Customer && !String.IsNullOrEmpty(task.Title))
{
req.Title = task.Title;
}
var command = new UpdateTask
{
CustomerFirstName = task.CustomerFirstName,
CustomerId = task.CustomerId,
CustomerLastName = task.CustomerLastName,
Description = task.Description,
DueDateUtc = task.DueDateUtc,
Metadata = task.Metadata,
OrderId = task.OrderId,
ProductId = task.ProductId,
SampleRequestId = task.SampleRequestId,
TaskId = task.TaskId,
TaskType = task.TaskType,
Title = req.Title
};
if (!string.IsNullOrWhiteSpace(req.Description))
command.Description = req.Description;
if (req.DueDateUtc.HasValue)
command.DueDateUtc = req.DueDateUtc.Value.ToUniversalTime();
_clientFactory.GetCommandServiceClient().Execute(command);
}
