コード例 #1
0
        public async Task with_non_duplicated_person_CreateCompensationClaim_should_create_new_Claim()
        {
            var compensation = new CompensationClaimEntity()
            {
                ClaimNumber = "normal",
                Person      = new SSG_Person()
                {
                    IsDuplicated = false
                },
                BankInformationEntity = new BankingInformationEntity()
                {
                    AccountNumber = "newbank"
                },
                EmploymentEntity = new EmploymentEntity()
                {
                    BusinessName = "newEmployer"
                }
            };
            var result = await _sut.CreateCompensationClaim(compensation, CancellationToken.None);

            Assert.AreEqual(_testCompensationId, result.CompensationClaimId);
            _odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
            _odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
                                    .Set(It.IsAny <BankingInformationEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
            _odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentContactEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
        }
コード例 #2
0
        public async Task <SSG_Asset_WorkSafeBcClaim> CreateCompensationClaim(CompensationClaimEntity claim, CancellationToken cancellationToken)
        {
            SSG_Asset_WorkSafeBcClaim returnedClaim   = null;
            SSG_Asset_WorkSafeBcClaim duplicatedClaim = await GetDuplicatedCompensation(claim, cancellationToken);

            SSG_Employment ssg_employment = null;

            if (duplicatedClaim != null && duplicatedClaim.IsDuplicated)
            {
                ssg_employment = duplicatedClaim.Employment;
                returnedClaim  = duplicatedClaim;
            }
            else
            {
                SSG_Asset_BankingInformation ssg_bank = claim.BankInformationEntity == null ? null : await CreateBankInfo(claim.BankInformationEntity, cancellationToken);

                ssg_employment = claim.EmploymentEntity == null ? null : await CreateEmployment(claim.EmploymentEntity, cancellationToken);

                claim.BankingInformation = ssg_bank;
                claim.Employment         = ssg_employment;
                SSG_Asset_WorkSafeBcClaim ssg_Claim = await this._oDataClient.For <SSG_Asset_WorkSafeBcClaim>().Set(claim).InsertEntryAsync(cancellationToken);

                returnedClaim = ssg_Claim;
            }

            if (claim.EmploymentEntity != null && claim.EmploymentEntity.EmploymentContactEntities != null)
            {
                foreach (EmploymentContactEntity contact in claim.EmploymentEntity.EmploymentContactEntities)
                {
                    contact.Employment = ssg_employment;
                    await CreateEmploymentContact(contact, cancellationToken);
                }
            }
            return(returnedClaim);
        }
コード例 #3
0
ファイル: SearchResultService.cs プロジェクト: bcgov/fams3
        private async Task <bool> UploadCompensationClaims()
        {
            if (_foundPerson.CompensationClaims == null)
            {
                return(true);
            }
            try
            {
                _logger.LogDebug($"Attempting to create compnsation claims records for SearchRequest[{_searchRequest.SearchRequestId}]");

                foreach (CompensationClaim claim in _foundPerson.CompensationClaims)
                {
                    BankingInformationEntity bankEntity = null;
                    if (claim.BankInfo != null)
                    {
                        bankEntity = _mapper.Map <BankingInformationEntity>(claim.BankInfo);
                        bankEntity.InformationSource = _providerDynamicsID;
                    }

                    EmploymentEntity employmentEntity = null;
                    if (claim.Employer != null)
                    {
                        employmentEntity = _mapper.Map <EmploymentEntity>(claim.Employer);
                        employmentEntity.InformationSource = _providerDynamicsID;
                        employmentEntity.Date1             = claim.ReferenceDates?.SingleOrDefault(m => m.Index == 0)?.Value.DateTime;
                        employmentEntity.Date1Label        = claim.ReferenceDates?.SingleOrDefault(m => m.Index == 0)?.Key;
                        //FAMS3-3742: OpenShift to stop creating Employment Contact records
                        //List<EmploymentContactEntity> contacts = new List<EmploymentContactEntity>();
                        //if (claim.Employer.Phones != null)
                        //{
                        //    foreach (var phone in claim.Employer.Phones)
                        //    {
                        //        EmploymentContactEntity p = _mapper.Map<EmploymentContactEntity>(phone);
                        //        contacts.Add(p);
                        //    }
                        //}
                        //employmentEntity.EmploymentContactEntities = contacts.ToArray();
                    }

                    CompensationClaimEntity ssg_claim = _mapper.Map <CompensationClaimEntity>(claim);
                    ssg_claim.SearchRequest         = _searchRequest;
                    ssg_claim.InformationSource     = _providerDynamicsID;
                    ssg_claim.Person                = _returnedPerson;
                    ssg_claim.BankInformationEntity = bankEntity;
                    ssg_claim.EmploymentEntity      = employmentEntity;

                    SSG_Asset_WorkSafeBcClaim ssg_Claim = await _searchRequestService.CreateCompensationClaim(ssg_claim, _cancellationToken);
                    await CreateResultTransaction(ssg_Claim);
                }
                return(true);
            }
            catch (Exception ex)
            {
                LogException(ex);
                return(false);
            }
        }
コード例 #4
0
        public async Task with_duplicated_person_contains_same_claim_different_banking_CreateCompensationClaim_should_create_new_Claim()
        {
            Guid originalGuid = Guid.NewGuid();

            _duplicateServiceMock.Setup(x => x.Exists(It.Is <SSG_Person>(m => m.PersonId == _testId), It.Is <CompensationClaimEntity>(m => m.ClaimNumber == "contains")))
            .Returns(Task.FromResult(_testCompensationId));

            _odataClientMock.Setup(x => x.For <SSG_Asset_WorkSafeBcClaim>(null)
                                   .Key(It.Is <Guid>(m => m == _testCompensationId))
                                   .Expand(x => x.BankingInformation)
                                   .Expand(x => x.Employment)
                                   .FindEntryAsync(It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult(new SSG_Asset_WorkSafeBcClaim()
            {
                CompensationClaimId = originalGuid,
                ClaimNumber         = "original"
            }));

            _duplicateServiceMock.Setup(x => x.Same(It.IsAny <BankingInformationEntity>(), It.IsAny <SSG_Asset_BankingInformation>()))
            .Returns(Task.FromResult(false));

            var compensationClaim = new CompensationClaimEntity()
            {
                ClaimNumber = "contains",
                Person      = new SSG_Person()
                {
                    PersonId     = _testId,
                    IsDuplicated = true
                },
                EmploymentEntity = new EmploymentEntity()
                {
                    BusinessName = "newEmployer",
                    EmploymentContactEntities = new List <EmploymentContactEntity>()
                    {
                        new EmploymentContactEntity()
                        {
                            PhoneNumber = "123"
                        }
                    }.ToArray()
                }
            };
            var result = await _sut.CreateCompensationClaim(compensationClaim, CancellationToken.None);

            Assert.AreEqual(_testCompensationId, result.CompensationClaimId);
            _odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
            _odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
                                    .Set(It.IsAny <BankingInformationEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
            _odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentContactEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
        }
コード例 #5
0
        public async Task with_duplicated_person_not_contains_same_claim_CreateCompensationClaim_should_create_new_Claim()
        {
            _duplicateServiceMock.Setup(x => x.Exists(It.Is <SSG_Person>(m => m.PersonId == _testId), It.Is <CompensationClaimEntity>(m => m.ClaimNumber == "notContain")))
            .Returns(Task.FromResult(Guid.Empty));

            var claim = new CompensationClaimEntity()
            {
                ClaimNumber = "notContain",
                Person      = new SSG_Person()
                {
                    PersonId     = _testId,
                    IsDuplicated = true
                },
                BankInformationEntity = new BankingInformationEntity()
                {
                    AccountNumber = "newbank"
                },
                EmploymentEntity = new EmploymentEntity()
                {
                    BusinessName = "newEmployer",
                    EmploymentContactEntities = new List <EmploymentContactEntity>()
                    {
                        new EmploymentContactEntity()
                        {
                            PhoneNumber = "123"
                        }
                    }.ToArray()
                }
            };
            var result = await _sut.CreateCompensationClaim(claim, CancellationToken.None);

            Assert.AreEqual(_testCompensationId, result.CompensationClaimId);
            _odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
            _odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
                                    .Set(It.IsAny <BankingInformationEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
            _odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentContactEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
        }
コード例 #6
0
        public async Task person_does_not_contain_same_compensation_Exists_should_return_empty_guid()
        {
            DuplicateDetectionService._configs = null;
            Guid       existedCompensationID = Guid.NewGuid();
            SSG_Person person = new SSG_Person()
            {
                SSG_Asset_WorkSafeBcClaims = new List <SSG_Asset_WorkSafeBcClaim>()
                {
                    new SSG_Asset_WorkSafeBcClaim()
                    {
                        ClaimNumber = "2222", CompensationClaimId = existedCompensationID
                    }
                }.ToArray()
            };
            CompensationClaimEntity entity = new CompensationClaimEntity()
            {
                ClaimNumber = "11111"
            };
            Guid guid = await _sut.Exists(person, entity);

            Assert.AreEqual(Guid.Empty, guid);
        }
コード例 #7
0
        private async Task <SSG_Asset_WorkSafeBcClaim> GetDuplicatedCompensation(CompensationClaimEntity claim, CancellationToken cancellationToken)
        {
            if (claim.Person != null && claim.Person.IsDuplicated)
            {
                Guid duplicatedCompensationId = await _duplicateDetectService.Exists(claim.Person, claim);

                if (duplicatedCompensationId != Guid.Empty)
                {
                    var duplicatedClaim = await _oDataClient.For <SSG_Asset_WorkSafeBcClaim>()
                                          .Key(duplicatedCompensationId)
                                          .Expand(x => x.BankingInformation)
                                          .Expand(x => x.Employment)
                                          .FindEntryAsync(cancellationToken);

                    if (await _duplicateDetectService.Same(claim.BankInformationEntity, duplicatedClaim.BankingInformation))
                    {
                        if (await _duplicateDetectService.Same(claim.EmploymentEntity, duplicatedClaim.Employment))
                        {
                            duplicatedClaim.IsDuplicated = true;
                            if (duplicatedClaim.Employment != null)
                            {
                                Guid duplicatedEmploymentId = duplicatedClaim.Employment.EmploymentId;
                                duplicatedClaim.Employment = await _oDataClient.For <SSG_Employment>()
                                                             .Key(duplicatedEmploymentId)
                                                             .Expand(x => x.SSG_EmploymentContacts)
                                                             .FindEntryAsync(cancellationToken);

                                duplicatedClaim.Employment.IsDuplicated = true;
                            }
                            return(duplicatedClaim);
                        }
                    }
                }
            }
            return(null);
        }
コード例 #8
0
        public void Init()
        {
            _loggerMock = new Mock <ILogger <SearchResultService> >();
            _searchRequestServiceMock = new Mock <ISearchRequestService>();
            _mapper = new Mock <IMapper>();
            var validRequestId = Guid.NewGuid();

            var validVehicleId         = Guid.NewGuid();
            var validOtherAssetId      = Guid.NewGuid();
            var validBankInformationId = Guid.NewGuid();
            var validEmploymentId      = Guid.NewGuid();

            _fakePersoneIdentifier = new IdentifierEntity
            {
                Identification = "1234567",
                SearchRequest  = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                }
            };

            _fakeSourceIdentifier = new SSG_Identifier
            {
                SearchRequest = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                }
            };

            _fakePersonAddress = new AddressEntity
            {
                SearchRequest = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                },
                AddressLine1 = "addressLine1"
            };
            _fakeEmployment = new EmploymentEntity
            {
                SearchRequest = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                }
            };

            _fakeEmploymentContact = new EmploymentContactEntity
            {
                PhoneNumber = "11111111"
            };

            _fakePersonPhoneNumber = new PhoneNumberEntity
            {
                SearchRequest = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                }
            };

            _fakeRelatedPerson = new RelatedPersonEntity
            {
                SearchRequest = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                }
            };

            _fakeName = new AliasEntity
            {
                SearchRequest = new SSG_SearchRequest
                {
                    SearchRequestId = validRequestId
                }
            };

            _ssg_fakePerson = new PersonEntity
            {
            };

            _searchRequest = new SSG_SearchRequest
            {
                SearchRequestId = validRequestId
            };

            _fakeBankInfo = new BankingInformationEntity
            {
                BankName = "bank"
            };

            _fakeVehicleEntity = new VehicleEntity
            {
                SearchRequest = _searchRequest,
                PlateNumber   = "AAA.BBB"
            };

            _fakeAssetOwner = new SSG_AssetOwner()
            {
                OrganizationName = "Ford Inc."
            };

            _fakeOtherAsset = new AssetOtherEntity()
            {
                SearchRequest   = _searchRequest,
                TypeDescription = "type description"
            };

            _fakeWorkSafeBcClaim = new CompensationClaimEntity()
            {
                SearchRequest      = _searchRequest,
                ClaimNumber        = "claimNumber",
                BankingInformation = new SSG_Asset_BankingInformation()
                {
                    BankingInformationId = validBankInformationId
                },
                Employment = new SSG_Employment()
                {
                    EmploymentId = validEmploymentId
                }
            };

            _fakeCompensationEmployment = new EmploymentEntity()
            {
                BusinessName = COMPENSATION_BUISNESS_NAME
            };

            _fakeIcbcClaim = new ICBCClaimEntity()
            {
                ClaimNumber = "icbcClaimNumber"
            };

            _fakeInvolvedParty = new SSG_InvolvedParty()
            {
                OrganizationName = "name"
            };

            _fakeSimplePhone = new SSG_SimplePhoneNumber()
            {
                PhoneNumber = "0"
            };

            _fakePerson = new Person()
            {
                DateOfBirth = DateTime.Now,
                FirstName   = "TEST1",
                LastName    = "TEST2",
                Identifiers = new List <PersonalIdentifier>()
                {
                    new PersonalIdentifier()
                    {
                        Value    = "test",
                        IssuedBy = "test",
                        Type     = PersonalIdentifierType.BCDriverLicense
                    }
                },
                Addresses = new List <Address>()
                {
                    new Address()
                    {
                        AddressLine1   = "AddressLine1",
                        AddressLine2   = "AddressLine2",
                        AddressLine3   = "AddressLine3",
                        StateProvince  = "Manitoba",
                        City           = "testCity",
                        Type           = "residence",
                        CountryRegion  = "canada",
                        ZipPostalCode  = "p3p3p3",
                        ReferenceDates = new List <ReferenceDate>()
                        {
                            new ReferenceDate()
                            {
                                Index = 0, Key = "Start Date", Value = new DateTime(2019, 9, 1)
                            },
                            new ReferenceDate()
                            {
                                Index = 1, Key = "End Date", Value = new DateTime(2020, 9, 1)
                            }
                        },
                        Description = "description"
                    }
                },
                Phones = new List <Phone>()
                {
                    new Phone()
                    {
                        PhoneNumber = "4005678900"
                    }
                },
                Names = new List <Name>()
                {
                    new Name()
                    {
                        FirstName = "firstName"
                    }
                },
                RelatedPersons = new List <RelatedPerson>()
                {
                    new RelatedPerson()
                    {
                        FirstName = "firstName"
                    }
                },

                Employments = new List <Employment>()
                {
                    new Employment()
                    {
                        Occupation = "Occupation",
                        Employer   = new Employer()
                        {
                            Phones = new List <Phone>()
                            {
                                new Phone()
                                {
                                    PhoneNumber = "1111111", Type = "Phone"
                                }
                            }
                        }
                    }
                },

                BankInfos = new List <BankInfo>()
                {
                    new BankInfo()
                    {
                        BankName = "BankName",
                    }
                },
                Vehicles = new List <Vehicle>()
                {
                    new Vehicle()
                    {
                    },
                    new Vehicle()
                    {
                        Owners = new List <InvolvedParty>()
                        {
                            new InvolvedParty()
                            {
                            }
                        }
                    }
                },
                OtherAssets = new List <OtherAsset>()
                {
                    new OtherAsset()
                    {
                        Owners = new List <InvolvedParty>()
                        {
                            new InvolvedParty()
                            {
                            }
                        }
                    }
                },
                CompensationClaims = new List <CompensationClaim>()
                {
                    new CompensationClaim()
                    {
                        ClaimNumber = "claimNumber",
                        BankInfo    = new BankInfo()
                        {
                            BankName = "compensationBankName"
                        },
                        Employer = new Employer()
                        {
                            Name = COMPENSATION_BUISNESS_NAME
                        },
                        ReferenceDates = new ReferenceDate[]
                        {
                            new ReferenceDate()
                            {
                                Index = 0, Key = "Start Date", Value = new DateTime(2019, 9, 1)
                            }
                        }
                    }
                },
                InsuranceClaims = new List <InsuranceClaim>()
                {
                    new InsuranceClaim()
                    {
                        ClaimNumber    = "icbcClaimNumber",
                        InsuredParties = new List <InvolvedParty>()
                        {
                            new InvolvedParty()
                            {
                                Organization = "insuranceClaimOrg"
                            }
                        },
                        ClaimCentre = new ClaimCentre()
                        {
                            ContactNumber = new List <Phone>()
                            {
                                new Phone()
                                {
                                    PhoneNumber = "9999"
                                }
                            }
                        }
                    }
                }
            };

            _providerProfile = new ProviderProfile()
            {
                Name = "Other"
            };


            _fakeToken = new CancellationToken();

            _mapper.Setup(m => m.Map <IdentifierEntity>(It.IsAny <PersonalIdentifier>()))
            .Returns(_fakePersoneIdentifier);

            _mapper.Setup(m => m.Map <PhoneNumberEntity>(It.IsAny <Phone>()))
            .Returns(_fakePersonPhoneNumber);

            _mapper.Setup(m => m.Map <AddressEntity>(It.IsAny <Address>()))
            .Returns(_fakePersonAddress);

            _mapper.Setup(m => m.Map <AliasEntity>(It.IsAny <Name>()))
            .Returns(_fakeName);

            _mapper.Setup(m => m.Map <PersonEntity>(It.IsAny <Person>()))
            .Returns(_ssg_fakePerson);

            _mapper.Setup(m => m.Map <EmploymentEntity>(It.Is <Employer>(m => m.Name == COMPENSATION_BUISNESS_NAME)))
            .Returns(_fakeCompensationEmployment);

            _mapper.Setup(m => m.Map <EmploymentEntity>(It.IsAny <Employment>()))
            .Returns(_fakeEmployment);

            _mapper.Setup(m => m.Map <EmploymentContactEntity>(It.IsAny <Phone>()))
            .Returns(_fakeEmploymentContact);

            _mapper.Setup(m => m.Map <RelatedPersonEntity>(It.IsAny <RelatedPerson>()))
            .Returns(_fakeRelatedPerson);

            _mapper.Setup(m => m.Map <BankingInformationEntity>(It.IsAny <BankInfo>()))
            .Returns(_fakeBankInfo);

            _mapper.Setup(m => m.Map <VehicleEntity>(It.IsAny <Vehicle>()))
            .Returns(_fakeVehicleEntity);

            _mapper.Setup(m => m.Map <AssetOwnerEntity>(It.IsAny <InvolvedParty>()))
            .Returns(_fakeAssetOwner);

            _mapper.Setup(m => m.Map <AssetOtherEntity>(It.IsAny <OtherAsset>()))
            .Returns(_fakeOtherAsset);

            _mapper.Setup(m => m.Map <CompensationClaimEntity>(It.IsAny <CompensationClaim>()))
            .Returns(_fakeWorkSafeBcClaim);

            _mapper.Setup(m => m.Map <ICBCClaimEntity>(It.IsAny <InsuranceClaim>()))
            .Returns(_fakeIcbcClaim);

            _mapper.Setup(m => m.Map <InvolvedPartyEntity>(It.Is <InvolvedParty>(m => m.Organization == "insuranceClaimOrg")))
            .Returns(_fakeInvolvedParty);

            _mapper.Setup(m => m.Map <SimplePhoneNumberEntity>(It.Is <Phone>(m => m.PhoneNumber == "9999")))
            .Returns(_fakeSimplePhone);

            _searchRequestServiceMock.Setup(x => x.CreateIdentifier(It.IsAny <IdentifierEntity>(), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Identifier>(new SSG_Identifier()
            {
            }));

            _searchRequestServiceMock.Setup(x => x.CreateAddress(It.Is <AddressEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Address>(new SSG_Address()
            {
                AddressLine1 = "test full line"
            }));

            _searchRequestServiceMock.Setup(x => x.CreatePhoneNumber(It.Is <PhoneNumberEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_PhoneNumber>(new SSG_PhoneNumber()
            {
                TelePhoneNumber = "4007678231"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateName(It.Is <AliasEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Aliase>(new SSG_Aliase()
            {
                FirstName = "firstName"
            }));

            _searchRequestServiceMock.Setup(x => x.SavePerson(It.Is <PersonEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Person>(new SSG_Person()
            {
                FirstName = "First"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateEmployment(It.Is <EmploymentEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Employment>(new SSG_Employment()
            {
                EmploymentId = Guid.NewGuid(),
                Occupation   = "Occupation"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateEmploymentContact(It.IsAny <EmploymentContactEntity>(), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_EmploymentContact>(new SSG_EmploymentContact()
            {
                PhoneNumber = "4007678231"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateRelatedPerson(It.Is <RelatedPersonEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Identity>(new SSG_Identity()
            {
                FirstName = "firstName"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateBankInfo(It.Is <BankingInformationEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Asset_BankingInformation>(new SSG_Asset_BankingInformation()
            {
                BankingInformationId = validBankInformationId,
                BankName             = "bankName"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateVehicle(It.Is <VehicleEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Asset_Vehicle>(new SSG_Asset_Vehicle()
            {
                VehicleId = validVehicleId
            }));

            _searchRequestServiceMock.Setup(x => x.CreateAssetOwner(It.Is <SSG_AssetOwner>(x => x.Vehicle.VehicleId == validVehicleId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_AssetOwner>(new SSG_AssetOwner()
            {
                Type = "Owner"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateOtherAsset(It.Is <AssetOtherEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Asset_Other>(new SSG_Asset_Other()
            {
                AssetOtherId = validOtherAssetId
            }));

            _searchRequestServiceMock.Setup(x => x.CreateCompensationClaim(It.Is <CompensationClaimEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Asset_WorkSafeBcClaim>(new SSG_Asset_WorkSafeBcClaim()
            {
                ClaimNumber = "claimNumber"
            }));

            _searchRequestServiceMock.Setup(x => x.CreateEmployment(It.Is <EmploymentEntity>(x => x.BusinessName == COMPENSATION_BUISNESS_NAME && x.Date1 == new DateTime(2019, 9, 1)), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Employment>(new SSG_Employment()
            {
                EmploymentId = Guid.NewGuid(),
            }));

            _searchRequestServiceMock.Setup(x => x.CreateInsuranceClaim(It.Is <ICBCClaimEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_Asset_ICBCClaim>(new SSG_Asset_ICBCClaim()
            {
                ICBCClaimId = Guid.NewGuid()
            }));

            _searchRequestServiceMock.Setup(x => x.CreateInvolvedParty(It.IsAny <SSG_InvolvedParty>(), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_InvolvedParty>(new SSG_InvolvedParty()
            {
            }));

            _searchRequestServiceMock.Setup(x => x.CreateSimplePhoneNumber(It.IsAny <SSG_SimplePhoneNumber>(), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_SimplePhoneNumber>(new SSG_SimplePhoneNumber()
            {
            }));

            _searchRequestServiceMock.Setup(x => x.CreateTransaction(It.IsAny <SSG_SearchRequestResultTransaction>(), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult <SSG_SearchRequestResultTransaction>(new SSG_SearchRequestResultTransaction()
            {
            }));

            _sut = new SearchResultService(_searchRequestServiceMock.Object, _loggerMock.Object, _mapper.Object);
        }
コード例 #9
0
        public async Task with_duplicated_person_contains_same_claim_same_banking_same_employment_CreateCompensationClaim_return_existed_claim()
        {
            Guid originalClaimGuid      = Guid.NewGuid();
            Guid originalEmploymentGuid = Guid.NewGuid();

            _duplicateServiceMock.Setup(x => x.Exists(It.Is <SSG_Person>(m => m.PersonId == _testId), It.Is <CompensationClaimEntity>(m => m.ClaimNumber == "contains")))
            .Returns(Task.FromResult(_testCompensationId));

            _odataClientMock.Setup(x => x.For <SSG_Asset_WorkSafeBcClaim>(null)
                                   .Key(It.Is <Guid>(m => m == _testCompensationId))
                                   .Expand(x => x.BankingInformation)
                                   .Expand(x => x.Employment)
                                   .FindEntryAsync(It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult(new SSG_Asset_WorkSafeBcClaim()
            {
                CompensationClaimId = originalClaimGuid,
                ClaimNumber         = "original",
                Employment          = new SSG_Employment()
                {
                    EmploymentId = originalEmploymentGuid
                }
            }));

            _duplicateServiceMock.Setup(x => x.Same(It.IsAny <object>(), It.IsAny <object>()))
            .Returns(Task.FromResult(true));

            _odataClientMock.Setup(x => x.For <SSG_Employment>(null)
                                   .Key(It.Is <Guid>(m => m == originalEmploymentGuid))
                                   .Expand(x => x.SSG_EmploymentContacts)
                                   .FindEntryAsync(It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult(new SSG_Employment()
            {
                EmploymentId = originalEmploymentGuid
            }));

            var compensationClaim = new CompensationClaimEntity()
            {
                ClaimNumber = "contains",
                Person      = new SSG_Person()
                {
                    PersonId     = _testId,
                    IsDuplicated = true
                },
                Employment = new SSG_Employment()
                {
                    EmploymentId = originalEmploymentGuid
                }
            };
            var result = await _sut.CreateCompensationClaim(compensationClaim, CancellationToken.None);

            Assert.AreEqual(originalClaimGuid, result.CompensationClaimId);
            Assert.AreEqual(originalEmploymentGuid, result.Employment.EmploymentId);
            Assert.AreEqual(true, result.IsDuplicated);
            Assert.AreEqual(true, result.Employment.IsDuplicated);
            _odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
            _odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
                                    .Set(It.IsAny <BankingInformationEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
            _odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
                                    .Set(It.IsAny <EmploymentContactEntity>())
                                    .InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
        }