public void SetMember(UserTaskDTO userTaskDTO)
{
var userTask = TasksMapper.Map <UserTaskDTO, vUserTask>(userTaskDTO);
Database.vUserTasks.Add(userTask);
Database.Save();
}
/// <summary>
/// 从erp中获取文件
/// </summary>
/// <param name="remark_id"></param>
/// <returns></returns>
public TaskDTO buildFromErp(String remark_id)
{
OrderRedisService orderRedisService = new OrderRedisService();
UserTaskDTO userTaskDTO = orderRedisService.getTaskById <UserTaskDTO>(remark_id);
return(TaskService.TaskDTO_UserTaskDTO_Change(this, userTaskDTO).buildDoJson(this.data));
}
public bool CreateUserTask(UserTaskDTO userTaskDTO)
{
var planTask = db.PlanTasks.Get(userTaskDTO.PlanTaskId);
if (planTask == null)
{
throw new InternalServiceException($"No task [ID:{planTask.Task_Id}] in plan [ID:{planTask.Plan_Id}]", "");
}
if (db.Users.Get(userTaskDTO.UserId) == null)
{
throw new InternalServiceException($"No user [ID:{userTaskDTO.UserId}] in db", "");
}
UserTask userTask = new UserTask()
{
User_Id = userTaskDTO.UserId,
PlanTask_Id = userTaskDTO.PlanTaskId,
State = userTaskDTO.State,
End_Date = userTaskDTO.EndDate,
Result = userTaskDTO.Result,
Propose_End_Date = userTaskDTO.ProposeEndDate,
//todo mentor auto-setting logic by planId
Mentor_Id = userTaskDTO.MentorId
};
db.UserTasks.Add(userTask);
db.Save();
return(true);
}
public UserTaskDTO GetUserTaskByUserTaskPlanIds(int userId, int taskId, int planId)
{
int?planTaskId = db.PlanTasks.GetIdByTaskAndPlan(taskId, planId);
if (planTaskId == null)
{
throw new InternalServiceException($"Task(ID:{taskId}) does not exist in plan(ID:{planId}).", "");
}
UserTask ut = db.UserTasks.GetByPlanTaskForUser(planTaskId.Value, userId);
if (ut == null)
{
throw new InternalServiceException($"Users task for this plan does not exist.", "");
}
var dto = new UserTaskDTO(ut.Id,
userId,
ut.PlanTask_Id,
ut.End_Date,
ut.Propose_End_Date,
ut.Mentor_Id,
ut.State,
ut.Result);
return(dto);
}
public void AddUserTaskDTO(UserTaskDTO task)
{
UserTask userTask = new UserTask();
string nab = userTask.User.FirstName;
UserTaskDAL.AddUserTask(MapperGlobel.mapper.Map <UserTask>(task));
}
public bool CreateUserTask(UserTaskDTO userTaskDTO)
{
var planTask = db.PlanTasks.Get(userTaskDTO.PlanTaskId);
if (planTask == null)
{
return(false);
}
if (db.Users.Get(userTaskDTO.UserId) == null)
{
return(false);
}
var userTask = new UserTask()
{
User_Id = userTaskDTO.UserId,
PlanTask_Id = userTaskDTO.PlanTaskId,
State = userTaskDTO.State,
End_Date = userTaskDTO.EndDate,
Result = userTaskDTO.Result,
Propose_End_Date = userTaskDTO.ProposeEndDate,
Mentor_Id = userTaskDTO.MentorId
};
db.UserTasks.Add(userTask);
db.Save();
return(true);
}
public async Task <ActionResult <UserTaskViewModel> > PatchUserTask(int id, UserTaskDTO userTaskUpdate)
{
var userTask = await _context.UserTasks.FindAsync(id);
if (userTask == null)
{
return(NotFound());
}
userTask.Name = userTaskUpdate.Name ?? userTask.Name;
userTask.Status = userTaskUpdate.Status;
userTask.User = await _context.Users.FindAsync(userTaskUpdate.UserId);
userTask.Deadline = userTaskUpdate.Deadline;
_context.Entry(userTask).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(new UserTaskViewModel
{
Id = userTask.Id,
Name = userTask.Name ?? "No-name",
Deadline = userTask.Deadline ?? DateTime.Now,
UserId = userTask?.User.Id,
Status = userTask?.Status.ToString() ?? Models.TaskStatus.New.ToString(),
GroupId = userTask?.TaskGroup?.Id
});
}
public async Task <ActionResult <UserTaskViewModel> > PostUserTask(UserTaskDTO userTask)
{
var taskGroup = await _context.TaskGroups.FindAsync(userTask.GroupId);
if (taskGroup == null)
{
return(BadRequest("Invalid task group specified"));
}
var newTask = new UserTask();
newTask.Name = userTask.Name;
newTask.Deadline = userTask.Deadline;
newTask.Status = userTask.Status;
newTask.User = _context.Users.Find(userTask.UserId);
newTask.TaskGroup = taskGroup;
taskGroup?.UserTasks.Add(newTask);
_context.UserTasks.Add(newTask);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetUserTask), new { id = newTask.Id }, new UserTaskViewModel
{
Id = newTask.Id,
Name = newTask.Name ?? "New Task",
Deadline = newTask.Deadline ?? DateTime.Now,
UserId = newTask?.User?.Id,
Status = newTask?.Status.ToString() ?? Models.TaskStatus.New.ToString(),
GroupId = newTask?.TaskGroup.Id
}));
}
public async Task <ActionResult> PostNewUserTaskAsync([FromBody] UserTaskDTO newUserTask)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
bool success = await taskService.CreateUserTaskAsync(newUserTask);
if (success)
{
var message = $"Succesfully created task with id = {newUserTask.Id} for user with id = {newUserTask.UserId}";
logger.LogInformation("Error : {0}", message);
return(Ok(message));
}
logger.LogInformation("Error : {0}", HttpStatusCode.NoContent);
return(NoContent());
}
catch (Exception e)
{
logger.LogInformation("Error : {0}", e.Message);
return(BadRequest(e));
}
}
public async Task <IHttpActionResult> AddTask(AddTaskViewModel model)
{
try
{
if (string.IsNullOrWhiteSpace(model.Title))
{
return(BadRequest("The title field cannot be empty."));
}
UserTaskBO userTask = new UserTaskBO
{
Title = model.Title,
Description = model.Description,
DateCreated = DateTime.UtcNow,
UserId = CurrentUserId,
DateUserAccepted = DateTime.UtcNow,
BeginDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
Audit = new Entity.Entities.Audit(CurrentUserId)
};
zeus.evaluationManager.Add(userTask);
await AddNotificationAsync(NotificationType.NewTask, CurrentUserId, CurrentUserId, "supervisor/unacceptedtasks");
return(Ok(UserTaskDTO.Map(userTask, zeus)));
}
catch (Exception ex)
{
LogError(ex, CurrentUserId);
return(BadRequest("An Error occured while processing your request, please try again"));
}
}
/// <summary>
/// 存任务
/// </summary>
/// <param name="orderId"></param>
/// <param name="userTaskDTO"></param>
/// <returns></returns>
public bool saveTask(String orderId, UserTaskDTO userTaskDTO)
{
// 保存数据
bool dataCached = new RedisCacheHelper().StringSet(userTaskDTO.ID, FunctionHelper.JsonSerialization(userTaskDTO));
// 保存关系
bool relationCached = new RedisCacheHelper().SetAdd(orderId + TASK, userTaskDTO.ID);
return(dataCached && relationCached);
}
public void Update(UserTaskDTO userTaskDTO)
{
var userTask = Database.UserTasks.GetById(userTaskDTO.UserTaskId);
if (userTask != null)
{
_mapper.Map(userTaskDTO, userTask);
Database.Save();
}
}
public void UpdateTask(UserTaskDTO userTaskDTO)
{
var task = Database.Tasks.Get(userTaskDTO.TaskId);
if (task != null)
{
Mapper.Map(userTaskDTO, task);
Database.Save();
}
}
public void Edit(UserTaskDTO userTask)
{
if (userTask == null)
{
throw new ValidationException("The ID does not exists", "");
}
var userTaskResult = MapperForCRUD(userTask);
Database.UserTasks.Update(userTaskResult);
Database.Save();
}
public void PostNewUserTaskTest_ShouldCheckNotValidInputParameterAndReturnBadRequestResponse()
{
taskServiceMock.Setup(mts => mts.CreateUserTask(It.IsAny <UserTaskDTO>()))
.Returns(true);
var newUserTask = new UserTaskDTO();
ValidateViewModel(taskController, newUserTask);
var response = taskController.PostNewUserTask(newUserTask);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void UpdateTaskForUser(UserTaskDTO userDTO)
{
if (userDTO.TaskName.Length > 50)
{
throw new ValidationException($"The length od {nameof(userDTO.TaskName)} must be less then 50");
}
var userTask = Database.vUserTasks.Get(userDTO.UserId, userDTO.TaskId);
if (userTask != null)
{
Mapper.Map(userDTO, userTask);
Database.Save();
}
}
public void SaveTask(UserTaskDTO userTaskDTO)
{
var task = new vUserTask
{
UserId = userTaskDTO.UserId,
TaskId = userTaskDTO.TaskId,
TaskName = userTaskDTO.TaskName,
Description = userTaskDTO.Description,
StartDate = userTaskDTO.StartDate,
DeadlineDate = userTaskDTO.DeadlineDate,
State = userTaskDTO.State
};
Database.vUserTasks.Add(task);
Database.Save();
}
public void Save(UserTaskDTO userTaskDTO)
{
var userTask = new UserTask
{
Task = _mapper.Map <TaskDTO, EntityTask>(userTaskDTO.Task),
TaskId = userTaskDTO.TaskId,
StateId = userTaskDTO.StateId,
TaskState = _mapper.Map <TaskStateDTO, TaskState>(userTaskDTO.TaskState),
UserId = userTaskDTO.UserId,
UserProfile = _mapper.Map <UserProfileDTO, UserProfile>(userTaskDTO.UserProfile),
TaskTracks = _mapper.Map <IEnumerable <TaskTrackDTO>, List <TaskTrack> >(userTaskDTO.TaskTracks)
};
Database.UserTasks.Create(userTask);
Database.Save();
}
public void SaveTaskForUser(UserTaskDTO userDTO)
{
if (userDTO.TaskName.Length > 25)
{
throw new ValidationException($"The length of {nameof(userDTO.TaskName)} must be less then 25");
}
var userTask = new UserTask
{
TaskId = userDTO.TaskId,
UserId = userDTO.UserId,
StateId = 1
};
Database.UserTasks.Add(userTask);
Database.Save();
}
public UserTaskDTO GetUserTaskByUserPlanTaskId(int userId, int planTaskId)
{
var userTask = db.UserTasks.GetByPlanTaskForUser(planTaskId, userId);
if (userTask == null)
{
return(null);
}
var userTaskDto = new UserTaskDTO(userTask.Id,
userTask.User_Id,
userTask.PlanTask_Id,
userTask.End_Date,
userTask.Propose_End_Date,
userTask.Mentor_Id,
userTask.State,
userTask.Result);
return(userTaskDto);
}
/// <summary>
/// usertaskdto转成taskdto
/// </summary>
/// <param name="taskDTO"></param>
/// <param name="userTaskDTO"></param>
/// <returns></returns>
public static TaskDTO TaskDTO_UserTaskDTO_Change(TaskDTO taskDTO, UserTaskDTO userTaskDTO)
{
taskDTO.remark_id = userTaskDTO.ID;
taskDTO.template_id = userTaskDTO.TEMPLATE_ID;
taskDTO.order_id = userTaskDTO.ORDER_ID;
taskDTO.style_id = userTaskDTO.STYLE_ID;
taskDTO.ref_style_id = userTaskDTO.REF_STYLE_ID;
taskDTO.principal = userTaskDTO.PRINCIPAL;
taskDTO.remark = userTaskDTO.REMARK;
taskDTO.file_name = userTaskDTO.FILE_NAME;
taskDTO.parent_id = userTaskDTO.PARENT_ID;
taskDTO.version = userTaskDTO.VERSION;
taskDTO.data = userTaskDTO.DATA;
taskDTO.template_name = userTaskDTO.TEMPLATE_NAME;
taskDTO.serial_number = userTaskDTO.SERIAL_NUMBER;
taskDTO.status = userTaskDTO.STATUS;
taskDTO.CREATE_DATE = userTaskDTO.CREATE_DATE;
return(taskDTO);
}
public UserTaskDTO GetUserTaskByUserTaskPlanId(int userId, int planTaskId)
{
UserTask userTask = db.UserTasks.GetByPlanTaskForUser(planTaskId, userId);
if (userTask == null)
{
throw new InternalServiceException($"Users task for this plan does not exist.", "");
}
var userTaskdto = new UserTaskDTO(userTask.Id,
userTask.User_Id,
userTask.PlanTask_Id,
userTask.End_Date,
userTask.Propose_End_Date,
userTask.Mentor_Id,
userTask.State,
userTask.Result);
return(userTaskdto);
}
public async Task <UserTaskDTO> GetUserTaskByUserPlanTaskIdAsync(int userId, int planTaskId)
{
UserTask userTask = await db.UserTasks.GetByPlanTaskForUserAsync(planTaskId, userId);
if (userTask == null)
{
return(null);
}
var userTaskDto = new UserTaskDTO(userTask.Id,
userTask.User_Id,
userTask.PlanTask_Id,
userTask.End_Date,
userTask.Propose_End_Date,
userTask.Mentor_Id,
userTask.State,
userTask.Result);
return(userTaskDto);
}
public HttpResponseMessage PostNewUserTask([FromBody] UserTaskDTO newUserTask)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
bool success = taskService.CreateUserTask(newUserTask);
if (success)
{
return(Request.CreateResponse(HttpStatusCode.OK, $"Succesfully created task for user."));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Creation error."));
}
catch (Exception exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception));
}
}
public async Task <IHttpActionResult> GetUserTaskInfo(Guid userTaskId)
{
try
{
UserTaskDTO result = await Task.Run(() => zeus.evaluationManager.UserTasks(u => u.Audit.RecordState == RecordStateType.Active && u.Id == userTaskId)
.Include(u => u.User)
.Select(u => new UserTaskDTO
{
UserTaskId = u.Id,
AssignedToId = u.UserId,
TaskTitle = u.Title,
AssignedTo = u.User.FirstName + " " + u.User.LastName,
Description = u.Description,
}).FirstOrDefault());
return(Ok(result));
}
catch (Exception ex)
{
LogError(ex, CurrentUserId);
return(BadRequest());
}
}
public async Task <ActionResult> GetUserTaskAsync(int planTaskId, int userId)
{
try
{
var currentId = userIdentityService.GetUserId();
var currentRole = userIdentityService.GetUserRole();
if (!(userId == currentId || currentRole == Constants.Roles.Mentor))
{
return(BadRequest());
}
UserTaskDTO userTask = await taskService.GetUserTaskByUserPlanTaskIdAsync(userId, planTaskId);
if (userTask != null)
{
return(Ok(userTask));
}
return(NoContent());
}
catch (Exception e)
{
logger.LogInformation("Error : {0}", e.Message);
return(BadRequest());
}
}
public HttpResponseMessage PostNewUserTask([FromBody] UserTaskDTO newUserTask)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
var success = taskService.CreateUserTask(newUserTask);
if (success)
{
var message = $"Succesfully created task with id = {newUserTask.Id} for user with id = {newUserTask.UserId}";
tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, message);
return(Request.CreateResponse(HttpStatusCode.OK, "Succesfully created task for user."));
}
tracer.Warn(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, "Error occured on user task creating");
return(Request.CreateErrorResponse(HttpStatusCode.NoContent, "There is no user or task in database"));
}
catch (EntityException e)
{
tracer.Error(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, e);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public CreateUserTasksViewModel()
{
userTaskDTO = new UserTaskDTO();
}
public ActionResult EditUserTasks(UserTaskDTO userTaskdto)
{
updateUserTaskCommand.ExecuteCommand(userTaskdto);
return(RedirectToAction("Index"));
}
public ActionResult Edit(UserTaskDTO userTaskdto)
{
return(View(userTaskdto));
}
