public string Compile(Facet targetFacet, Facet currentFacet, FacetConfig2 config)
        {
            if (targetFacet.FacetCode == currentFacet.FacetCode || !config.HasPicks())
            {
                return("");
            }

            string criteria = SqlCompileUtility.InExpr(currentFacet.CategoryIdExpr, config.GetPickValues());

            return(criteria);
        }
Example #2
0
        public string Compile(Facet targetFacet, Facet currentFacet, FacetConfig2 config)
        {
            if (!config.HasPicks())
            {
                return(currentFacet.Criteria);
            }

            var picks = config.GetPickValues(true);

            return(SqlCompileUtility.BetweenExpr(currentFacet.CategoryIdExpr, picks[0], picks[1])
                   .GlueIf(currentFacet.Criteria, " AND "));
        }
        public bool IsPriorTo(FacetConfig2 facetConfig, List <string> facetCodes, Facet targetFacet)
        {
            if (!facetConfig.HasConstraints())
            {
                // FIXME Is this a relevant condition?
                return(false);
            }

            if (targetFacet.FacetCode == facetConfig.FacetCode)
            {
                return(targetFacet.FacetType.ReloadAsTarget);
            }

            return(facetCodes.IndexOf(targetFacet.FacetCode) > facetCodes.IndexOf(facetConfig.FacetCode));
        }
        public void HasPicks_WhenFacetHasNoPicks_IsFalse()
        {
            // Arrange
            var facetConfig2 = new FacetConfig2 {
                FacetCode = "dummy_code",
                Facet     = new Mock <Facet>().Object,
                Position  = 0,
                Picks     = new List <FacetConfigPick>()
            };
            // Act
            var result = facetConfig2.HasPicks();

            // Assert
            Assert.False(result);
        }
        public void HasPicks_WhenRangeFacetHasPicks_IsTrue()
        {
            // Arrange
            var facetConfig2 = new FacetConfig2 {
                FacetCode = "dummy_code",
                Facet     = new Mock <Facet>().Object,
                Position  = 0,
                Picks     = FacetConfigPick.CreateLowerUpper(3M, 52M)
            };
            // Act
            var result = facetConfig2.HasPicks();

            // Assert
            Assert.True(result);
        }
        public void Compile_WhenHasPicksAndTargetAndCurrentFacetAreNotTheSame_ReturnsCriteria()
        {
            // Arrange
            var discreteFacetPickFilterCompiler = new DiscreteFacetPickFilterCompiler();
            var picks = new List <int>()
            {
                1, 2, 3
            };
            Facet        targetFacet  = Registry.Facets.GetByCode("sites");
            Facet        currentFacet = Registry.Facets.GetByCode("country");
            FacetConfig2 config       = new FacetConfig2(targetFacet, 1, "", FacetConfigPick.CreateDiscrete(picks));

            // Act
            var result = discreteFacetPickFilterCompiler.Compile(targetFacet, currentFacet, config);

            // Assert
            Assert.NotEqual($"({currentFacet.CategoryIdExpr}::text in ({picks.BuildString<int>(", ", "'")})) ", result);
        }
        public void HasPicks_WhenDiscreteFacetHasPicks_IsTrue()
        {
            // Arrange
            var facetConfig2 = new FacetConfig2 {
                FacetCode = "dummy_code",
                Facet     = new Mock <Facet>().Object,
                Position  = 0,
                Picks     = FacetConfigPick.CreateDiscrete(new List <int>()
                {
                    1, 2, 3
                })
            };
            // Act
            var result = facetConfig2.HasPicks();

            // Assert
            Assert.True(result);
        }
        public void ClearPicks_StateUnderTest_ExpectedBehavior()
        {
            // Arrange
            var facetConfig2 = new FacetConfig2 {
                FacetCode = "dummy_code",
                Facet     = new Mock <Facet>().Object,
                Position  = 0,
                Picks     = FacetConfigPick.CreateDiscrete(new List <int>()
                {
                    1, 2, 3
                })
            };

            // Act
            facetConfig2.ClearPicks();

            // Assert
            Assert.False(facetConfig2.HasPicks());
        }
        public void Compile_WhenNoPicks_ReturnsEmptyString()
        {
            // Arrange
            var          discreteFacetPickFilterCompiler = new DiscreteFacetPickFilterCompiler();
            Facet        targetFacet  = Registry.Facets.GetByCode("sites");
            Facet        currentFacet = Registry.Facets.GetByCode("country");
            FacetConfig2 config       = new FacetConfig2(
                targetFacet,
                1,
                "",
                FacetConfigPick.CreateDiscrete(new List <int>()
            {
            })
                );

            // Act
            var result = discreteFacetPickFilterCompiler.Compile(targetFacet, currentFacet, config);

            // Assert
            Assert.Equal("", result);
        }
        public void GetPickValues_WhenHasPicks_Success()
        {
            // Arrange
            var facetConfig2 = new FacetConfig2 {
                FacetCode = "dummy_code",
                Facet     = new Mock <Facet>().Object,
                Position  = 0,
                Picks     = FacetConfigPick.CreateDiscrete(new List <int>()
                {
                    1, 2, 3
                })
            };
            bool sort = false;

            // Act
            var result = facetConfig2.GetPickValues(sort);

            // Assert
            Assert.Equal(3, result.Count);
            Assert.Equal(1, result[0]);
            Assert.Equal(2, result[1]);
            Assert.Equal(3, result[2]);
        }
        public void GetJoinTables_StateUnderTest_Success()
        {
            // Arrange
            var facet        = Registry.Facets.GetByCode("result_facet");
            var facetConfig2 = new FacetConfig2 {
                FacetCode = "result_facet",
                Facet     = facet,
                Position  = 0,
                Picks     = FacetConfigPick.CreateDiscrete(new List <int>()
                {
                    1, 2, 3
                })
            };
            // Act
            var result = facetConfig2.GetJoinTables();

            // Assert
            var expected = new List <string>()
            {
                "tbl_analysis_entities", "tbl_datasets", "tbl_physical_samples"
            };

            Assert.Equal(expected, result);
        }
 public FacetConfig2 Reconstitute(FacetConfig2 facetConfig)
 {
     facetConfig.Facet = GetFacetByCode(facetConfig.FacetCode);
     return facetConfig;
 }
 public string Compile(Facet targetFacet, Facet currentFacet, FacetConfig2 config)
 {
     throw new ArgumentException();
 }
Example #14
0
 public string Compile(Facet targetFacet, Facet currentFacet, FacetConfig2 config)
 {
     throw new NotImplementedException();
 }
Example #15
0
 protected IPickFilterCompiler PickCompiler(FacetConfig2 c)
 {
     return(PickCompilers.Locate(c.Facet.FacetTypeId));
 }