/// <summary>
        /// Сообщаяет о том, что нужно изменить статус в "Closed"
        /// </summary>
        /// <returns></returns>
        public async Task <Result> CloseCaseCard(Guid userId, CloseCaseCardDto model)
        {
            using (_unitOfWork.Begin())
            {
                var caseCard = await _caseRepository.GetById(model.CaseCardId);

                if (caseCard == null)
                {
                    _logger.Warning($"Case with Id {model.CaseCardId} not found");
                    return(Result.Failure(ErrorCodes.CaseNotFound));
                }

                var caseCardResult = caseCard.Close();
                if (caseCardResult.IsFailure)
                {
                    _logger.Warning(caseCardResult.ErrorMessage);
                    return(Result.Failure(caseCardResult.ErrorCode));
                }

                var isCaseFolderClosed = caseCard.CaseFolder.IsClosed;
                var caseFolderId       = caseCard.CaseFolder.Id;

                await _unitOfWork.CommitAsync();

                if (isCaseFolderClosed)
                {
                    await _gisFacadeClient.DeleteIncidentMarker(caseFolderId);

                    await _gisFacadeClient.DeleteApplicantLocationMarker(caseFolderId);
                }

                return(Result.Success());
            }
        }
        public async Task <demoResult> CloseCaseCard([FromBody] CloseCaseCardDto dto)
        {
            if (dto == null || !dto.IsValid())
            {
                _logger.Warning($"Model {nameof(dto)} not valid");
                return(BadRequest(ErrorCodes.ValidationError));
            }

            var result = await _caseService.CloseCaseCard(GetUserId(), dto);

            if (result.IsFailure)
            {
                return(BadRequest(result.ErrorCode));
            }

            return(Ok());
        }
        // ReSharper disable once InconsistentNaming
        public async void UpdateCaseFolderStatus_WhenCaseStatusIsClosed_ShouldBeSuccess()
        {
            //Arrange
            var  fieldId  = new Guid("81fa8ce9-e2e6-0001-0001-000000000001");
            var  caseData = $"[{{\"fieldId\":\"{fieldId.ToString()}\",\"blockId\":\"81fa8ce9-e2e6-0001-0001-000000000000\",\"value\":\"SomeValue\"}}]";
            Guid userId   = UsersMetadata.UserIdOperator112;

            var caseFolderId = await CreateCaseFolder(caseData, userId);

            SetCurrentUserId(userId);

            //Action

            var caseDtoResult = (await _caseController.GetCase(caseFolderId)).Result as demoOkResult <CaseDto>;
            var caseDto       = caseDtoResult?.Value as CaseDto;

            var closeCaseCardDto = new CloseCaseCardDto
            {
                CaseCardId = caseDto.CaseId,
            };

            var closeCaseResult = await _caseController.CloseCaseCard(closeCaseCardDto);

            CaseFolder caseFolder;

            using (_unitOfWork.Begin())
            {
                caseFolder = await _caseFolderRepository.GetById(caseFolderId);
            }

            var caseStatusesDtoResult = (await _caseController.Statuses(caseFolderId)).Result as demoOkResult <CaseStatusesInfoDto>;
            var caseStatusesDto       = caseStatusesDtoResult.Value as CaseStatusesInfoDto;

            //Assert
            closeCaseResult.ShouldBeOfType <demoResult>();
            closeCaseResult.HttpStatusCode.ShouldBe(HttpStatusCode.OK);
            caseFolder.Status.ShouldBe(CaseFolderStatus.Closed);
            caseStatusesDto.CanCloseCaseCard.ShouldBeFalse();
            caseStatusesDto.Statuses.ShouldContain(x => x.Status == Case112Status.Closed.ToString());
        }