Example #1
0
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <ApiResult <string> > UpdateAsync(UpdateOperationRequest request)
        {
            return(await ExecuteResultAsync(async query =>
            {
                var rsp = new ApiResult <string>();
                var entity = await query.FirstOrDefaultAsync(p => p.Id == request.Id);
                if (entity == null)
                {
                    rsp.Message = "找不到要修改的信息.";
                    return rsp;
                }

                entity.OperationGroupId = request.OperationGroupId;
                entity.Name = request.Name;
                entity.Code = request.Code;
                entity.Tips = request.Tips;
                entity.Sort = request.Sort;
                // 修改
                RegisterDirty(entity);
                // 提交
                var flag = await CommitAsync();

                rsp.Message = flag ? "更新成功" : "更新失败";
                rsp.Success = flag;
                rsp.Data = entity.Id;
                return rsp;
            }));
        }
Example #2
0
        public UpdateOperationResponse UpdateOperation(UpdateOperationRequest request)
        {
            bool isKpiExisted =
                DataContext.KeyOperationConfigs.Include(x => x.Kpi).FirstOrDefault(x => x.Kpi.Id == request.KpiId) != null;

            if (request.Id == 0 && !isKpiExisted)
            {
                var operationConfig = new KeyOperationConfig();
                operationConfig.IsActive = request.IsActive.HasValue && request.IsActive.Value;
                operationConfig.Order    = request.Order.HasValue ? request.Order.Value : 0;
                operationConfig.Kpi      = DataContext.Kpis.Single(x => x.Id == request.KpiId);
                if (request.KeyOperationGroupId > 0)
                {
                    operationConfig.KeyOperationGroup =
                        DataContext.KeyOperationGroups.Single(x => x.Id == request.KeyOperationGroupId);
                }

                DataContext.KeyOperationConfigs.Add(operationConfig);
                DataContext.SaveChanges();
                return(new UpdateOperationResponse
                {
                    IsSuccess = true,
                    Message = "Operation Config has been saved succesfully",
                    Id = operationConfig.Id
                });
            }
            else
            {
                var operationConfig = DataContext.KeyOperationConfigs
                                      .Include(x => x.KeyOperationGroup)
                                      .Single(x => x.Id == request.Id);
                if (request.IsActive.HasValue)
                {
                    operationConfig.IsActive = request.IsActive.Value;
                }

                if (request.Order.HasValue)
                {
                    operationConfig.Order = request.Order.Value;
                }

                if (request.KeyOperationGroupId != 0)
                {
                    var group = new KeyOperationGroup {
                        Id = request.KeyOperationGroupId
                    };
                    DataContext.KeyOperationGroups.Attach(group);
                    operationConfig.KeyOperationGroup = group;
                }

                DataContext.SaveChanges();
                return(new UpdateOperationResponse
                {
                    IsSuccess = true,
                    Message = "Operation Config has been saved succesfully",
                    Id = operationConfig.Id
                });
            }
        }
Example #3
0
        public async Task <IActionResult> Produce(UpdateOperationRequest request)
        {
            var validatorActionResult = await _validationArrangement.Validate(request);

            var actionResult = await _operationArrangement.Process(request, validatorActionResult);

            return(actionResult);
        }
        /// <summary>
        /// 修改操作
        /// </summary>
        /// <param name="request">请求</param>
        public async Task UpdateAsync(UpdateOperationRequest request)
        {
            var operation = await OperationRepository.FindAsync(request.Id.ToGuid());

            request.MapTo(operation);
            await ValidateUpdateAsync(operation);

            operation.InitPinYin();
            await OperationRepository.UpdateAsync(operation);

            await UnitOfWork.CommitAsync();
        }
        public async Task <IActionResult> Update([FromRoute] UpdateOperationFromRoute route,
                                                 [FromQuery] UpdateOperationFromQuery query,
                                                 [FromHeader] UpdateOperationFromHeader header)
        {
            string bodyAsString = await Request.GetRawBodyStringAsync();

            var body = new UpdateOperationFromBody {
                Patch = bodyAsString
            };

            var request = new UpdateOperationRequest(route, query, header, body);

            var result = await _apiResult.Produce(request);

            return(result);
        }
Example #6
0
        public UpdateOperationCommand Map(UpdateOperationRequest request)
        {
            var id = new Guid(request.RouteId);

            var valuePairs = _jsonProvider.ToDictionary(request.BodyPatch);

            Optional <string> name                = valuePairs.GetOptional("name");
            Optional <string> description         = valuePairs.GetOptional("description");
            Optional <IEnumerable <string> > tags = valuePairs.GetOptionalEnumerable("tags");

            var version = ToVersion(request.HeaderIfMatch);

            var result = new UpdateOperationCommand(id, name, description, null, tags, version);

            return(result);
        }
        public async Task<IActionResult> Process(UpdateOperationRequest request, IValidatorActionResult validatorActionResult)
        {
            IActionResult actionResult;

            if (validatorActionResult.Result == null)
            {
                var call = _cqsMapper.Map(request);

                var result = await _mediator.Send(call);

                actionResult = result.IsFailure ? _apiResponse.Fail(result)
                                                : _apiResponse.Updated(result.Version.ToString());
            }
            else
            {
                actionResult = validatorActionResult.Result;
            }

            return actionResult;
        }
Example #8
0
        public async Task <IActionResult> UpdateAsync([FromBody] UpdateOperationRequest request)
        {
            await Service.UpdateAsync(request);

            return(Success());
        }
Example #9
0
 public async Task <ApiResult <string> > Update([FromBody] UpdateOperationRequest request)
 {
     return(await _operationService.UpdateAsync(request));
 }