public void UpdateStatus(UpdateTaskStatusModel updateTaskStatusModel)
        {
            var taskToUpdate = _unitOfWork.TaskRepository.GetByID(updateTaskStatusModel.TaskId);

            taskToUpdate.IsCompleted = updateTaskStatusModel.IsCompleted;
            _unitOfWork.TaskRepository.Update(taskToUpdate);
            _unitOfWork.SaveChanges();
        }
        private async Task <TResponse <bool> > CanUpdate(UpdateTaskStatusModel request)
        {
            try
            {
                var taskStatus = await _taskStatusCacheService.GetByName(request.Name);

                if (taskStatus != null &&
                    taskStatus.Id != request.Id)
                {
                    return(await Fail <bool>(ErrorEnum.TASK_STATUS_HAS_EXIST.GetStringValue()));
                }

                if (request.IsSendSms && string.IsNullOrEmpty(request.SmsContent))
                {
                    return(await Fail <bool>(ErrorEnum.SMS_CONTENT_IS_NOT_NULL_OR_EMPTY.GetStringValue()));
                }

                return(await Ok(true));
            }
            catch (Exception exception)
            {
                return(await Fail <bool>(exception));
            }
        }
        public async Task <TResponse <bool> > Update(int userId,
                                                     UpdateTaskStatusModel request,
                                                     int permissionId)
        {
            try
            {
                var checkValid = await _userService.CheckPermission(userId,
                                                                    permissionId);

                if (checkValid.IsSuccess)
                {
                    var canUpdate = await CanUpdate(request);

                    if (canUpdate.IsSuccess)
                    {
                        var result = await WriteRepository.ExecuteAsync(SqlQuery.TASK_STATUS_UPDATE,
                                                                        new
                        {
                            request.Id,
                            request.Name,
                            request.Color,
                            request.SortOrder,
                            request.IsSendSms,
                            request.SmsContent,
                            UserUpdated = userId,
                            DateUpdated = DateTime.Now
                        });

                        if (result.IsSuccess)
                        {
                            if (result.Data > 0)
                            {
                                #region Update redis cache

                                await _taskStatusCacheService.AddOrUpdate(new TaskStatusCacheModel
                                {
                                    Id         = request.Id,
                                    Name       = request.Name,
                                    Color      = request.Color,
                                    SmsContent = request.SmsContent,
                                    IsSendSms  = request.IsSendSms,
                                    SortOrder  = request.SortOrder
                                });

                                #endregion

                                return(await Ok(true));
                            }

                            return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
                        }

                        return(await Fail <bool>(result.Message));
                    }

                    return(await Fail <bool>(canUpdate.Message));
                }

                return(await Fail <bool>(checkValid.Message));
            }
            catch (Exception exception)
            {
                return(await Fail <bool>(exception));
            }
        }
Example #4
0
 public async Task <ActionResult <bool> > Update(UpdateTaskStatusModel request)
 {
     return(Ok(await _taskStatusService.Update(await GetUserId(),
                                               request,
                                               GetPermissionId())));
 }
 public IActionResult UpdateTaskStatus(UpdateTaskStatusModel updateTaskStatusModel)
 {
     _taskService.UpdateStatus(updateTaskStatusModel);
     return(Ok());
 }