示例#1
0
        /// <summary>
        /// File the case to the corresponding case folder.
        /// </summary>
        public void FileCase()
        {
            CaseFolder folder = FilingCabinet.Instance.FetchFolderByCase(caseNumber);

            folder.FilePage(this);
            int             newIdAmount = 0;
            UnderlineRender UR          = folder.GetComponentInChildren <UnderlineRender>();

            foreach (var TG in GetComponentsInChildren <TextCreator>())
            {
                TG.SetText(UR.GetIDCount() + newIdAmount);
                TG.clickText.underLiner = UR;
                TG.clickText.caseFolder = folder;
                foreach (var link in TG.clickText.textField.textInfo.linkInfo)
                {
                    if (link.GetLinkID() != "")
                    {
                        newIdAmount++;
                    }
                }
            }
            UR.AddPage(newIdAmount);
            _fileButton.SetActive(false);

            if (TutorialManager.Instance._doTutorial &&
                TutorialManager.Instance.currentState == TutorialManager.TutorialState.PrintCase)
            {
                TutorialManager.Instance.AdvanceTutorial();
            }
        }
        public async Task TrackingEvents_AddCaseFolder_Success()
        {
            var unitOfWork           = _provider.GetService <UnitOfWork>();
            var caseFolderRepository = _provider.GetService <ICaseFolderRepository>();
            var caseTypeRepository   = _provider.GetService <ICaseTypeRepository>();

            CaseFolder caseFolder;

            using (unitOfWork.Begin())
            {
                caseFolder = new CaseFolder();
                caseFolder.AddCaseCard(caseTypeRepository.GetFirst(), Guid.NewGuid());
                await caseFolderRepository.Add(caseFolder);

                await unitOfWork.CommitAsync();
            }

            using (unitOfWork.Begin())
            {
                CaseFolder fromDb = await caseFolderRepository.GetById(caseFolder.Id);

                Assert.NotNull(fromDb);
                Assert.Equal(caseFolder.Id, fromDb.Id);
                Assert.NotNull(fromDb.Cases);
                Assert.True(fromDb.Cases.Any());
                Assert.True(fromDb.TrackingEvents.Any());
            }
        }
        /// <summary>
        /// Создать DTO с информацией о статусах карточек в CaseFolder
        /// </summary>
        /// <param name="caseFolder"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public Result <CaseStatusesInfoDto> GetStatusInfoDto(CaseFolder caseFolder, UserDto user)
        {
            var currentCaseResult = caseFolder.GetCaseForUser(user.Id);

            if (currentCaseResult.IsFailure)
            {
                return(Result.Failure <CaseStatusesInfoDto>(currentCaseResult.ErrorCode));
            }

            var cases        = caseFolder.Cases;
            var caseStatuses = cases.Select(x => new CaseStatusDto
            {
                CaseCardId = x.Id,
                Status     = x.Status
            })
                               .ToList();

            var statusesInfo = new CaseStatusesInfoDto
            {
                Statuses         = caseStatuses,
                CanCloseCaseCard = currentCaseResult.Value.IsInProgress()
            };

            return(Result.Success(statusesInfo));
        }
示例#4
0
    /// <summary>
    /// Create a folder for the opened emaillisting.
    /// </summary>
    /// <returns></returns>
    public CaseFolder CreateFolder()
    {
        // TODO add better placement script here
        GameObject newFolderObj = Instantiate(_caseFolderPrefab, transform.position, Quaternion.Euler(new Vector3(270, 0, Random.Range(0f, 360f))));
        CaseFolder newFolder    = newFolderObj.GetComponent <CaseFolder>();

        caseFolders.Add(newFolder);
        return(newFolder);
    }
 protected override void ReadAttributeEvent(object sender, ReadElementEventArgs eventArgs)
 {
     if (IdentifiesCaseFolder(eventArgs))
     {
         _currentCaseFolder = new CaseFolder {
             ArchivePartSystemId = _currentArchivePartSystemId
         }
     }
     ;
 }
        protected override void ReadEndElementEvent(object sender, ReadElementEventArgs eventArgs)
        {
            // TODO: Handle non-casefolder-type subfolders?

            if (eventArgs.NameEquals("mappe") && _currentCaseFolder != null)
            {
                _folders.Add(_currentCaseFolder);
                _currentCaseFolder = null;
            }
        }
        private async Task SaveCaseFolder(CaseFolder caseFolder)
        {
            var unitOfWork = _provider.GetScopedService <UnitOfWork>();

            using (unitOfWork.Begin())
            {
                var caseFolderRepository = new CaseFolderRepository(unitOfWork);
                await caseFolderRepository.Add(caseFolder);

                await unitOfWork.CommitAsync();
            }
        }
        /// <summary>
        /// Перезвонить заявителю
        /// </summary>
        public async Task <Result <CallBackToApplicantStatus> > CallBackToApplicant(Guid userId, CallBackToApplicantDto model)
        {
            using (_unitOfWork.Begin())
            {
                var        caseFolderId = model.CaseFolderId;
                CaseFolder caseFolder   = await _caseFolderRepository.GetById(caseFolderId);

                if (caseFolder == null)
                {
                    _logger.Warning($"CaseFolder with Id {caseFolderId} not found");
                    return(Result.Failure <CallBackToApplicantStatus>(ErrorCodes.CaseFolderNotFound));
                }

                var participantResult = await GetApplicant(caseFolder);

                if (participantResult.IsFailure)
                {
                    _logger.Warning(participantResult.ErrorMessage);
                    return(Result.Failure <CallBackToApplicantStatus>(participantResult.ErrorCode));
                }

                Result <UserClientDto> userResult = await _userManagementServiceClient.GetUserById(userId);

                if (userResult.IsFailure)
                {
                    _logger.Warning($"CallBackToApplicant. Error get user by Id. {userResult.ErrorMessage}");
                    return(Result.Failure(ErrorCodes.UserNotFound));
                }

                var user = _mapper.Map <UserDto>(userResult.Value);

                var clientModel = new CallBackToApplicantClientDto
                {
                    UserExtension        = user.Extension,
                    ParticipantExtension = participantResult.Value.ParticipantExtension,
                    CaseFolderId         = caseFolderId,
                };
                var result = await _callManagementServiceClient.CallBackToApplicant(clientModel);

                if (result.IsFailure)
                {
                    _logger.Warning($"CallBackToApplicant. {result.ErrorMessage}");
                    return(Result.Failure <CallBackToApplicantStatus>(ErrorCodes.UnableToCallBackToApplicant));
                }

                await _unitOfWork.CommitAsync();

                await _phoneHubMessageService.NotifyUserAboutStartedExternalCall(userId, result.Value.LineId);

                return(Result.Success(CallBackToApplicantStatus.Ok));
            }
        }
示例#9
0
    /// <summary>
    /// The create folder method for when the player loads a save.
    /// </summary>
    /// <returns></returns>
    public CaseFolder CreateFolderLoad()
    {
        Physics.Raycast(transform.position, Vector3.down, out RaycastHit hit);
        GameObject newFolderObj = Instantiate(_caseFolderPrefab, hit.point, Quaternion.Euler(new Vector3(270, 0, Random.Range(0f, 360f))));
        CaseFolder newFolder    = newFolderObj.GetComponent <CaseFolder>();

        caseFolders.Add(newFolder);

        Rigidbody rb = newFolder.GetComponent <Rigidbody>();

        rb.useGravity  = false;
        rb.isKinematic = true;
        newFolder.GetComponent <HoverOverObject>().SetOriginPoints();
        return(newFolder);
    }
        /// <summary>
        /// Оповестить клиентов о добавлении местоположения абонента.
        /// </summary>
        private async Task NotifyGisFacadeAboutNewApplicantLocation(CaseFolder caseFolder, Guid operatorId)
        {
            Result <SmsLocationData> applicantLocationDataResult = caseFolder.GetLocationData();

            if (applicantLocationDataResult.IsFailure)
            {
                _logger.Warning($"CaseService. Не удалось получить данные о местоположении из CaseFolder. {applicantLocationDataResult.ErrorMessage}");
            }

            if (applicantLocationDataResult.IsSuccess && !caseFolder.IsClosed)
            {
                var applicantLocationDto = _mapper.Map <LocationDataClientDto>(applicantLocationDataResult.Value);
                await _gisFacadeClient.AddApplicantLocationMarker(caseFolder.Id, applicantLocationDto);

                await _phoneHubMessageService.NotifyClientsAboutApplicantLocationUpdateAsync(caseFolder.Id, operatorId);
            }
        }
        public async void Add_CaseWithoutCall_SuccessfullySaved()
        {
            //Arrange
            var  unitOfWork             = _provider.GetService <UnitOfWork>();
            var  caseCardRepository     = _provider.GetService <ICaseRepository>();
            var  caseCardTypeRepository = _provider.GetService <ICaseTypeRepository>();
            Guid case112TypeId          = new Guid(AddCaseTableAndCaseTemplateTable.CaseTypeId112);

            //Action
            CaseType caseType;

            using (unitOfWork.Begin())
            {
                caseType = await caseCardTypeRepository.GetById(case112TypeId);

                await caseCardTypeRepository.Add(caseType);

                await unitOfWork.CommitAsync();
            }

            Case caseCard;

            using (unitOfWork.Begin())
            {
                var caseTypeFromDb = await caseCardTypeRepository.GetById(caseType.Id);

                var caseFolder = new CaseFolder();
                caseFolder.AddCaseCard(caseTypeFromDb, Guid.NewGuid());
                caseCard = caseFolder.Cases.FirstOrDefault();
                await caseCardRepository.Add(caseCard);

                await unitOfWork.CommitAsync();
            }

            //Assert
            using (unitOfWork.Begin())
            {
                var caseCardFromDb = await caseCardRepository.GetById(caseCard.Id);

                caseCardFromDb.ShouldNotBeNull();
                caseCardFromDb.Type.ShouldNotBeNull();
            }
        }
        public async void Remove_CaseFolder_CaseMustBeRemoved()
        {
            //Arrange
            var caseType   = GetCaseType();
            var caseFolder = new CaseFolder();

            caseFolder.AddCaseCard(caseType, new Guid());
            var caseCard = caseFolder.Cases.FirstOrDefault();

            await SaveCaseFolder(caseFolder);

            //action
            await RemoveEntity(caseFolder);

            var result = await GetEntity <Case>(x => x.Id == caseCard.Id);

            //arrange
            result.ShouldBeNull();
        }
        /// <summary>
        /// Создание Line, CaseFolder и добавление Data к CaseFolder
        /// </summary>
        /// <param name="caseData"></param>
        /// <returns>LineId</returns>
        private async Task <Guid> CreateCaseFolder(string caseData, Guid userId)
        {
            using var uow = _provider.GetScopedService <UnitOfWork>();
            uow.Begin();
            var caseTypeRepo = new CaseTypeRepository(uow);
            var caseType     = await caseTypeRepo.GetById(_case112TypeId);

            var caseFolder = new CaseFolder {
                Data = caseData
            };

            caseFolder.AddCaseCard(caseType, userId);
            var caseFolderRepository = new CaseFolderRepository(uow);
            await caseFolderRepository.Add(caseFolder);

            await uow.CommitAsync();

            return(caseFolder.Id);
        }
        private async Task <Result <Guid> > PrepareCase(UserItemClientDto userItem)
        {
            Result <CallClientDto> callInfoResult = await _callManagementServiceClient.GetCallById(userItem.ItemId);

            if (callInfoResult.IsFailure)
            {
                _logger.Error($"ProcessCall. {callInfoResult.ErrorMessage}");
                return(Result.Failure(callInfoResult.ErrorCode, callInfoResult.ErrorMessage));
            }

            var caseFolderIdResult = callInfoResult.Value.Line.CaseFolderId;

            if (!userItem.CreateCaseCard)
            {
                if (caseFolderIdResult.HasValue)
                {
                    return(Result.Success(caseFolderIdResult.Value));
                }

                var newEmptyCaseFolder = new CaseFolder();
                await _caseFolderRepository.Add(newEmptyCaseFolder);

                return(Result.Success(newEmptyCaseFolder.Id));
            }

            var caseType = await _caseTypeRepository.GetById(userItem.CaseTypeId);

            if (caseFolderIdResult.HasValue)
            {
                var caseFolder = await _caseFolderRepository.GetById(caseFolderIdResult.Value);

                caseFolder.AddCaseCard(caseType, userItem.UserId);
                return(Result.Success(caseFolderIdResult.Value));
            }

            var newCaseFolder = new CaseFolder();

            newCaseFolder.AddCaseCard(caseType, userItem.UserId);
            await _caseFolderRepository.Add(newCaseFolder);

            return(Result.Success(newCaseFolder.Id));
        }
        private async Task <Result <Participant> > GetApplicant(CaseFolder caseFolder)
        {
            if (caseFolder.Sms != null)
            {
                return(Result.Success(caseFolder.Sms.Applicant));
            }

            Result <List <LineByCaseFolderClientDto> > linesResult = await _callManagementServiceClient.GetLinesByCaseFolderId(caseFolder.Id);

            if (linesResult.IsFailure)
            {
                _logger.Warning($"GetApplicant. Failed to get line by caseFolderId: {caseFolder.Id}");
                return(Result.Failure <Participant>(ErrorCodes.UnableToCallBackToApplicant));
            }

            var lines = _mapper.Map <List <LineDto> >(linesResult.Value);

            if (lines == null)
            {
                _logger.Warning($"Lines not found for CaseFolder: {caseFolder.Id}");
                return(Result.Failure <Participant>(ErrorCodes.LineNotFound));
            }

            var callerId = lines.FirstOrDefault(l => l.ExternalCallerId.HasValue)?.ExternalCallerId;

            if (callerId == null)
            {
                _logger.Warning("Error getting applicant call from CaseFolder");
                return(Result.Failure <Participant>(ErrorCodes.UnableToGetApplicant));
            }

            var participant = await GetParticipant(callerId.Value);

            if (participant == null)
            {
                _logger.Warning($"Participant not found. Id: {callerId}");
                return(Result.Failure <Participant>(ErrorCodes.UserNotFound));
            }

            return(Result.Success(participant));
        }
        /// <summary>
        /// Принять СМС
        /// </summary>
        /// <param name="sms"></param>
        /// <param name="caseType"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        private Result <CaseFolder> AcceptSms(Sms sms, CaseType caseType, Guid userId)
        {
            var applicantExt = sms.Applicant.ParticipantExtension;

            sms.Status = SmsStatus.Accepted;

            var caseFolder = new CaseFolder {
                Sms = sms
            };

            caseFolder.AddCaseCard(caseType, userId);

            var result = caseFolder.FillSmsData(applicantExt, sms);

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

            return(Result.Success(caseFolder));
        }
        public async Task TrackingEvents_UpdateCase_Success()
        {
            var unitOfWork           = _provider.GetService <UnitOfWork>();
            var caseFolderRepository = _provider.GetService <ICaseFolderRepository>();
            var caseRepository       = _provider.GetService <ICaseRepository>();
            var caseTypeRepository   = _provider.GetService <ICaseTypeRepository>();

            Guid       caseId;
            CaseFolder caseFolder;

            using (unitOfWork.Begin())
            {
                caseFolder = new CaseFolder();
                caseFolder.AddCaseCard(caseTypeRepository.GetFirst(), Guid.NewGuid());
                await caseFolderRepository.Add(caseFolder);

                caseId = caseFolder.Cases.FirstOrDefault().Id;
                await unitOfWork.CommitAsync();
            }

            using (unitOfWork.Begin())
            {
                var caseFromDb = await caseRepository.GetById(caseId);

                caseFromDb.Status = "Closed";
                await unitOfWork.CommitAsync();
            }

            using (unitOfWork.Begin())
            {
                CaseFolder caseFolderFromDb = await caseFolderRepository.GetById(caseFolder.Id);

                var caseCard = caseFolderFromDb.Cases.First();

                Assert.Equal(4, caseFolderFromDb.TrackingEvents.Count);
                Assert.Equal(3, caseCard.Root.TrackingEvents.Count(t => t.OperationType == EventType.Inserted));
                Assert.Equal(1, caseCard.Root.TrackingEvents.Count(t => t.OperationType == EventType.Updated));
            }
        }
        // ReSharper disable once InconsistentNaming
        public async void Get_Case_ShouldExists()
        {
            //arrange
            _unitOfWork.Begin();

            var caseType   = _caseTypeRepository.GetFirst();
            var userId     = Guid.NewGuid();
            var caseFolder = new CaseFolder();

            caseFolder.AddCaseCard(caseType, userId);

            await _caseFolderRepository.Add(caseFolder);

            await _unitOfWork.CommitAsync();

            //action
            SetCurrentUserId(userId);

            demoResult <CaseDto> caseCardResult = await _caseController.GetCase(caseFolder.Id);

            //Assert
            caseCardResult.Result.ShouldBeOfType <demoOkResult <CaseDto> >();
        }
        public async Task TrackingEvents_UpdateBaseEntity_Success()
        {
            var unitOfWork         = _provider.GetService <UnitOfWork>();
            var caseRepository     = _provider.GetService <ICaseRepository>();
            var caseTypeRepository = _provider.GetService <ICaseTypeRepository>();

            Case caseCard;

            using (unitOfWork.Begin())
            {
                var caseTypeFromDb = caseTypeRepository.GetFirst();
                var caseFolder     = new CaseFolder();
                caseFolder.AddCaseCard(caseTypeFromDb, Guid.NewGuid());
                caseCard = caseFolder.Cases.FirstOrDefault();
                await caseRepository.Add(caseCard);

                await unitOfWork.CommitAsync();
            }

            using (unitOfWork.Begin())
            {
                caseCard = await caseRepository.GetById(caseCard.Id);

                caseCard.Updated = DateTime.Now;
                await unitOfWork.CommitAsync();
            }

            using (unitOfWork.Begin())
            {
                caseCard = await caseRepository.GetById(caseCard.Id);

                Assert.NotNull(caseCard.Root);
                Assert.Equal(1, caseCard.CaseFolder.TrackingEvents.Count(t => t.OperationType == EventType.Updated));
                Assert.Equal(3, caseCard.CaseFolder.TrackingEvents.Count(t => t.OperationType == EventType.Inserted));
            }
        }