public async Task <IActionResult> PutUserTaskModel(int id, UserTaskModel userTaskModel)
{
if (id != userTaskModel.UserID)
{
return(BadRequest());
}
_context.Entry(userTaskModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserTaskModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/**
* 设置taskView上面的内容
*/
public void setTaskView(GameObject taskView, UserTaskModel userTaskModel)
{
Text title = taskView.Find <Text>("ContentView/Viewport/Content/" + taskView.name + "/Title");
Image icon = taskView.Find <Image>("ContentView/Viewport/Content/" + taskView.name + "/Icon");
Text name = taskView.Find <Text>("ContentView/Viewport/Content/" + taskView.name + "/Name");
Text progress = taskView.Find <Text>("ContentView/Viewport/Content/" + taskView.name + "/Progress");
Text describe = taskView.Find <Text>("ContentView/Viewport/Content/" + taskView.name + "/Describe");
if (userTaskModel.already_completed >= userTaskModel.required_num)
{
GameObject receiveobj = GameObject.Find("ContentView/Viewport/Content/" + taskView.name + "/ReceiveBtn");
receiveobj.SetActive(true);
Button receiveBtn = taskView.Find <Button>("ContentView/Viewport/Content/" + taskView.name + "/ReceiveBtn");
receiveBtn.onClick.AddListener(() =>
{
taskReceiveClick(userTaskModel);
});
}
else
{
GameObject receiveobj = GameObject.Find("ContentView/Viewport/Content/" + taskView.name + "/ReceiveBtn");
receiveobj.SetActive(false);
}
title.text = userTaskModel.name;
name.text = userTaskModel.image_describe;
progress.text = userTaskModel.already_completed + "/" + userTaskModel.required_num;
describe.text = userTaskModel.required_describe;
}
public HttpResponseMessage GetUserTask(int siteId, int taskId)
{
WorkflowClientProcessor.UserContext.SiteId = siteId;
UserTaskModel userTask = WorkflowClientProcessor.GetUserTask(taskId);
return(Request.CreateResponse(HttpStatusCode.OK, userTask));
}
/// <summary>
/// Изменяет задачу
/// </summary>
/// <param name="idTask"></param>
/// <param name="task"></param>
/// <returns></returns>
public async Task EditAsync(Guid idTask, UserTaskModel task)
{
if (task == null)
{
throw new NullReferenceException("Модель ссылается на Null");
}
var result = await _context.Tasks.SingleOrDefaultAsync(x => x.TaskId == idTask);
if (result == null)
{
throw new NullReferenceException($"Задачи с Id{idTask} не существует");
}
if (!string.IsNullOrEmpty(task.TextTask))
{
result.TextTask = task.TextTask;
}
result.EndTime = task.EndTime;
if (task.ActualTimeEnd != null)
{
result.ActualTimeEnd = task.ActualTimeEnd.Value;
}
await _context.SaveChangesAsync();
}
public List <UserTaskModel> GetTaskDetails()
{
try
{
List <UserTaskModel> taskModelList = new List <UserTaskModel>();
var taskList = context.UserTasks.ToList();
foreach (var taskItem in taskList)
{
var UTM = new UserTaskModel()
{
Task_ID = taskItem.Task_ID,
ParentTask_ID = taskItem.ParentTask_ID,
ParentTaskDetail = taskList.Where(x => x.ParentTask_ID == taskItem.Task_ID).Select(x => x.TaskDetail).FirstOrDefault() ?? "No parent task",
TaskDetail = taskItem.TaskDetail,
StartDate = taskItem.StartDate,
EndDate = taskItem.EndDate,
Priority = taskItem.Priority,
Status = taskItem.Status
};
taskModelList.Add(UTM);
}
return(taskModelList);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult DeleteConfirmed(int id)
{
UserTaskModel usertaskmodel = db.UserTaskModels.Find(id);
db.UserTaskModels.Remove(usertaskmodel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ChangeTaskCompleted(UserTaskModel item)
{
item.Checked = !item.Checked;
TaskService.UpdateTask(item);
UpdateData();
_view.ShowTaskLists(_lists);
}
/// <summary>
/// The remove task.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="task">
/// The task.
/// </param>
private void RemoveTask(IUserTaskChanged sender, UserTaskModel task)
{
if (this.userTaskManager.Tasks.Contains(task))
{
this.userTaskManager.Tasks.Remove(task);
}
sender.UpdateTasks();
}
/// <summary>
/// The add task.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="task">
/// The task.
/// </param>
private void AddTask(IUserTaskChanged sender, UserTaskModel task)
{
if (!this.userTaskManager.Tasks.Contains(task))
{
this.userTaskManager.Tasks.Add(task);
}
this.taskClients.ToList().ForEach(client => client.UpdateTasks());
}
public ActionResult Edit(UserTaskModel usertaskmodel)
{
if (ModelState.IsValid)
{
db.Entry(usertaskmodel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(usertaskmodel));
}
//
// GET: /UserTask/Delete/5
public ActionResult Delete(int id = 0)
{
UserTaskModel usertaskmodel = db.UserTaskModels.Find(id);
if (usertaskmodel == null)
{
return(HttpNotFound());
}
return(View(usertaskmodel));
}
public ActionResult Create(UserTaskModel usertaskmodel)
{
if (ModelState.IsValid)
{
db.UserTaskModels.Add(usertaskmodel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(usertaskmodel));
}
public ActionResult UserTask(int Id = 0)
{
UserTaskModel userTaskModel = new UserTaskModel();
userTaskModel.TaskId = Id;
if (Request.IsAjaxRequest())
{
return(PartialView(userTaskModel));
}
else
{
return(View(userTaskModel));
}
}
public bool InsertTask(UserTaskModel taskEntity)
{
try
{
bool opCompleted;
var repository = new TaskRepository(_context);
opCompleted = repository.Insert(taskEntity);
return(opCompleted);
}
catch (Exception ex)
{
throw ex;
}
}
public bool InsertTask(UserTaskModel taskEntity)
{
try
{
using (var repository = new DAL.TaskManagerRepository())
{
return(repository.Insert(taskEntity));
}
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult UserTaskIndex()
{
var model = new UserTaskModel
{
Id = GetParams <int>("id"),
UserId = GetParams <int>("userid"),
OrderId = GetParams <int>("orderid"),
Status = GetParams <int>("status"),
Createtime = GetParams <DateTime>("createtime"),
Updatetime = GetParams <DateTime>("updatetime"),
};
return(View(model));
}
/// <summary>
/// GetUserTask
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
public UserTaskModel GetUserTask(int taskId)
{
UserTaskModel userTask = null;
ServiceResponse <UserTaskDC> userTaskServiceResponse = _workflowProxy.Execute(opt => opt.GetUserTask(taskId));
if (userTaskServiceResponse.Status == ResponseStatus.Success)
{
userTask = Mapper.Map <UserTaskDC, UserTaskModel>(userTaskServiceResponse.Result);
}
else
{
HandleError(userTaskServiceResponse.Status, userTaskServiceResponse.ResponseMessage);
}
return(userTask);
}
public static UserTask MapUserTask(UserTaskModel model)
{
if (model == null)
{
return(null);
}
return(new UserTask()
{
Id = model.Id,
Checked = model.Checked,
Name = model.Name,
Description = model.Description
});
}
/// <summary>
/// SaveUserTask
/// </summary>
/// <param name="userTask"></param>
public void SaveUserTask(UserTaskModel userTask)
{
UserTaskDC userTaskDC = Mapper.Map <UserTaskModel, UserTaskDC>(userTask);
ServiceResponse <int> saveUserTaskServiceResponse = _workflowProxy.Execute(opt => opt.SaveUserTask(userTaskDC));
if (saveUserTaskServiceResponse.Status != ResponseStatus.Success)
{
HandleError(saveUserTaskServiceResponse.Status, saveUserTaskServiceResponse.ResponseMessage);
}
else
{
userTask.TaskId = saveUserTaskServiceResponse.Result;
}
}
public static UserTaskPO ToPO(this UserTaskModel item)
{
if (item == null)
{
return(null);
}
return(new UserTaskPO
{
Id = item.Id,
UserId = item.UserId,
OrderId = item.OrderId,
Status = item.Status,
Createtime = item.Createtime,
Updatetime = item.Updatetime,
});
}
public override Dialog OnCreateDialog(Bundle savedInstanceState)
{
AlertDialog.Builder builder = new AlertDialog.Builder(Activity);
LayoutInflater inflater = Activity.LayoutInflater;
var view = inflater.Inflate(Resource.Layout.dialog_userTask, null);
var nameField = view.FindViewById <EditText>(Resource.Id.dialog_userTask_name);
var descriptionField = view.FindViewById <EditText>(Resource.Id.dialog_userTask_description);
var headerText = view.FindViewById <TextView>(Resource.Id.dialog_userTask_text);
if (_taskModel != null)
{
nameField.Text = _taskModel.Name;
descriptionField.Text = _taskModel.Description;
headerText.Text = GetString(Resource.String.editTask);
builder.SetView(view)
.SetPositiveButton(Resource.String.edit, (s, e) =>
{
_taskModel.Name = nameField.Text;
_taskModel.Description = descriptionField.Text;
_listener.OnConfirmTaskEdit(_taskModel);
})
.SetNegativeButton(Resource.String.cancel, (s, e) => { });
}
else
{
headerText.Text = GetString(Resource.String.createNewTask);
builder.SetView(view)
.SetPositiveButton(Resource.String.create, (s, e) =>
{
_taskModel = new UserTaskModel()
{
Name = nameField.Text,
Description = descriptionField.Text,
Checked = false
};
_listener.OnConfirmTaskCreate(_taskModel);
})
.SetNegativeButton(Resource.String.cancel, (s, e) => { });
}
return(builder.Create());
}
/**
* 加载任务界面
*/
public void loadTaskView(bool isCurrentRefresh)
{
if (isCurrentRefresh)
{
List <GameObject> temp = new List <GameObject>();
for (int i = 0; i < currentTasksObject.Count; i++)
{
if (currentTasks.Length > i)
{
setTaskView(currentTasksObject[i], currentTasks[i]);
temp.Add(currentTasksObject[i]);
}
else
{
GameObject.Destroy(currentTasksObject[i]);
}
}
currentTasksObject = temp;
}
else
{
// 加载之前先隐藏之前的view
for (int i = 0; i < currentTasksObject.Count; i++)
{
GameObject.Destroy(currentTasksObject[i]);
}
currentTasksObject.Clear();
GameObject commonUIPrefab = Resources.Load("Prefabs/TaskItem") as GameObject;
GameObject contentFirst = GameObject.Find("ContentView/Viewport/Content");
for (int i = 0; i < currentTasks.Length; i++)
{
UserTaskModel userTaskModel = currentTasks[i];
GameObject taskView = Instantiate(commonUIPrefab) as GameObject;
taskView.transform.parent = contentFirst.transform;
taskView.name = "taskView" + userTaskModel.task_id;
taskView.transform.localPosition = new Vector3(0, -200, 0);
taskView.transform.localScale = new Vector3(1, 1, 0);
setTaskView(taskView, userTaskModel);
currentTasksObject.Add(taskView);
}
}
}
// POST api/values
public void Post([FromBody] UserTaskModel record)
{
try
{
using (var task = new TaskManagerOperations(_taskDataContext))
{
var opSuccess = task.InsertTask(record);
}
}
catch (Exception ex)
{
throw;
}
finally
{
}
}
public async Task Update_Note_Success()
{
var taskId = _context.Tasks.First().TaskId;
var userTask = new UserTaskModel()
{
TextTask = "Какой то текст",
EndTime = DateTime.Now
};
//act
await _service.EditAsync(taskId, userTask);
var resultTask = await _context.Tasks.SingleOrDefaultAsync(x => x.TaskId == taskId);
//assert
Assert.AreEqual(userTask.TextTask, resultTask.TextTask);
Assert.AreEqual(userTask.EndTime, resultTask.EndTime);
}
public async Task Create_UserTask_Success()
{
var containerId = _context.TasksContainers.First().ListId;
var userTask = new UserTaskModel()
{
TextTask = "Какой то текст",
EndTime = DateTime.Now
};
//act
var resultId = await _service.AddAsync(containerId, userTask);
var resultTask = await _context.Tasks.SingleOrDefaultAsync(x => x.TaskId == resultId);
//assert
Assert.AreEqual(userTask.TextTask, resultTask.TextTask);
Assert.AreEqual(userTask.EndTime, resultTask.EndTime);
}
public UserTaskModel GetTaskDetailsById(int id)
{
var taskModel = (from c in context.UserTasks
where c.Task_ID == id
select c).FirstOrDefault();
var UTM = new UserTaskModel()
{
Task_ID = taskModel.Task_ID,
ParentTask_ID = taskModel.ParentTask_ID,
TaskDetail = taskModel.TaskDetail,
StartDate = taskModel.StartDate,
EndDate = taskModel.EndDate,
Priority = taskModel.Priority,
Status = taskModel.Status
};
return(UTM);
}
/// <summary>
/// Добавляет задачу в список
/// </summary>
/// <param name="idContainer"></param>
/// <param name="task">Модель задачи</param>
/// <returns></returns>
public async Task <Guid> AddAsync(Guid idContainer, UserTaskModel task)
{
if (task == null)
{
throw new NullReferenceException("Модель ссылается на Null");
}
var taskContainer = await _context.TasksContainers.SingleOrDefaultAsync(x => x.ListId == idContainer);
if (taskContainer == null)
{
throw new NullReferenceException($"Контейнера с Id{idContainer} не существует");
}
var resultTask = new UserTask(taskContainer.ListId, task.TextTask, task.EndTime);
await _context.Tasks.AddAsync(resultTask);
await _context.SaveChangesAsync();
return(resultTask.TaskId);
}
public bool Insert(UserTaskModel entity)
{
try
{
UserTask userTask = new UserTask();
userTask.ParentTask_ID = entity.ParentTask_ID;
userTask.Priority = entity.Priority;
userTask.Status = entity.Status ?? "Open";
userTask.Project_ID = entity.Project_ID;
userTask.TaskDetail = entity.TaskDetail;
userTask.StartDate = entity.StartDate;
userTask.EndDate = entity.EndDate;
context.UserTasks.Add(userTask);
context.SaveChanges();
return(true);
}
catch (Exception ex)
{
throw ex.InnerException;
}
}
public async Task <ActionResult <UserTaskModel> > PostUserTaskModel(UserTaskModel userTaskModel)
{
_context.UserTaskModels.Add(userTaskModel);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (UserTaskModelExists(userTaskModel.UserID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetUserTaskModel", new { id = userTaskModel.UserID }, userTaskModel));
}
public void CreateTaskData(UserTaskModel item)
{
string insertQuery = string.Empty;
insertQuery = string.Format("INSERT INTO UserTaskModel ( SessionId, TaskId, TaskStatus, TaskDate ) " +
"VALUES ('{0}','{1}','{2}','{3}','{4}')",
item.SessionId, item.TaskId, item.TaskStatus, item.TaskDate);
using (var connection = PrivateConnection())
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
var insertCommand = connection.CreateCommand();
insertCommand.Transaction = transaction;
insertCommand.CommandText = insertQuery;
insertCommand.CommandType = System.Data.CommandType.Text;
insertCommand.ExecuteNonQuery();
transaction.Commit();
}
}
}
