示例#1
0
        /// <summary>
        /// Translates the specified clinical payor coverage.
        /// </summary>
        /// <param name="clinicalPayorCoverage">The clinical payor coverage.</param>
        /// <returns>A billing PayorCoverage.</returns>
        public PayorCoverage Translate(PayorCoverageCache clinicalPayorCoverage)
        {
            if (clinicalPayorCoverage == null)
            {
                return(null);
            }

            var payor = _payorRepository.GetByKey(clinicalPayorCoverage.PayorCache.Key);

            var clinicalPayorSubscriber         = clinicalPayorCoverage.PayorSubscriberCache;
            var payorSubscriberRelationshipType =
                _lookupValueRepository.GetLookupByWellKnownName <PayorSubscriberRelationshipType> (
                    clinicalPayorSubscriber.PayorSubscriberRelationshipCacheType.WellKnownName);
            var payorSubscriber = new PayorSubscriber(
                clinicalPayorSubscriber.Address,
                clinicalPayorSubscriber.BirthDate,
                clinicalPayorSubscriber.AdministrativeGender,
                clinicalPayorSubscriber.Name,
                payorSubscriberRelationshipType);

            var payorCoverageType =
                _lookupValueRepository.GetLookupByWellKnownName <PayorCoverageType> (clinicalPayorCoverage.PayorCoverageCacheType.WellKnownName);

            var billingPayorCoverage = new PayorCoverage(
                payor, payorSubscriber, clinicalPayorCoverage.MemberNumber, clinicalPayorCoverage.EffectiveDateRange, payorCoverageType);

            return(billingPayorCoverage);
        }
        public void Translate_PayorCoverageIsNull_ReturnsNullPayorCoverage()
        {
            // Setup
            var fixture = new Fixture().Customize(new AutoMoqCustomization());

            var sut = fixture.CreateAnonymous <PayorCoverageTranslator> ();

            PayorCoverageCache payorCoverageCache = null;

            // Exercise
            var billingPayorCoverage = sut.Translate(payorCoverageCache);

            // Verify
            Assert.IsNull(billingPayorCoverage);
        }
        public void ExecuteRules_Duplicate_HasRuleViolations()
        {
            var payorCoverageTypeMock = new Mock <PayorCoverageCacheType>();

            payorCoverageTypeMock.SetupGet(pct => pct.WellKnownName).Returns("Test");

            var payorCoverageCache = new PayorCoverageCache(
                new Mock <Patient>().Object,
                new Mock <PayorCache>().Object,
                new DateRange(DateTime.Now, null),
                "12345",
                new PayorSubscriberCache(
                    new Address(
                        "Test",
                        null,
                        "City",
                        new Mock <CountyArea>().Object,
                        new Mock <StateProvince>().Object,
                        new Mock <Country>().Object,
                        new PostalCode("12345")),
                    null,
                    new Mock <AdministrativeGender>().Object,
                    new PersonName(string.Empty, "Fred", null, "Savage", null),
                    new Mock <PayorSubscriberRelationshipCacheType>().Object),
                payorCoverageTypeMock.Object);

            var repositoryMock = new Mock <IPayorCoverageCacheRepository>();

            repositoryMock.Setup(
                rep => rep.AnyPayorCoverageTypeInEffectiveDateRange(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <PayorCoverageCacheType>(), It.IsAny <DateRange>())).Returns(
                true);
            var ruleCollection = new PayorCoverageCacheRuleCollection(repositoryMock.Object);
            var ruleEngine     = new RuleEngine <PayorCoverageCache>(ruleCollection);

            var ruleContext = new RuleEngineContext <PayorCoverageCache>(payorCoverageCache);

            ruleContext.WorkingMemory.AddContextObject(payorCoverageCache.PayorCoverageCacheType);
            ruleContext.WorkingMemory.AddContextObject(payorCoverageCache.EffectiveDateRange);

            var results = ruleEngine.ExecuteRules(ruleContext);

            Assert.IsTrue(results.HasRuleViolation);
        }