Exemplo n.º 1
0
        protected override void OnModelCreation(ConfigurationSetModelBuilder <SampleConfigSet> modelBuilder)
        {
            var configBuilder = modelBuilder.Config(s => s.SampleConfig, "Sample Config", "Basic Configuration");

            configBuilder.Property(p => p.IsLlamaFarmer);
            configBuilder.Property(p => p.Decimal).WithDisplayName("Value").WithDescription("Is a value in decimal");
            configBuilder.Property(p => p.LlamaCapacity)
            .WithDescription("Is the capacity of llama")
            .WithMinValue(0)
            .WithMaxValue(50);
            configBuilder.Property(p => p.StartDate)
            .WithMinValue(new DateTime(2013, 10, 10));
            configBuilder.Property(p => p.Name).WithMaxLength(250);
            configBuilder.PropertyWithOption(p => p.Option, (SampleConfigSet set) => set.OptionFromProvider)
            .WithDescription("Is a selected option");
            configBuilder.PropertyWithMultipleOptions(p => p.MoarOptions, (SampleConfigSet set) => set.OptionFromProvider)
            .WithDescription("Is a multi select option");
            configBuilder.Collection(p => p.ListOfConfigs);
            configBuilder.PropertyWithOption(p => p.OptionFromConfigSet, (SampleConfigSet set) => set.Options)
            .WithDescription("Options from the option set");
            configBuilder.PropertyWithMultipleOptions(p => p.MoarOptionFromConfigSet, (SampleConfigSet set) => set.Options)
            .WithDescription("Multiple Options from the option set");
            modelBuilder.Options(s => s.Options, o => o.Id, o => o.Description, "Options", "Options for sample config");
            modelBuilder.Options(s => s.OptionFromProvider, o => o.Id, o => o.Description, (IOptionProvider provider) => provider.GetOptions(), "Options From provider", "Options from provider for sample config");
        }
Exemplo n.º 2
0
        public void CanBuildModel_WithDefaultTag()
        {
            var builder = new ConfigurationSetModelBuilder <TestConfigSet>(setName, setDescription);
            var model   = builder.Build();

            Assert.Null(model.RequiredClientTag);
        }
 public void CanBuildModel_WithBasicProperties()
 {
     var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
     var setModel = builder.Build();
     Assert.Equal(setName, setModel.Name);
     Assert.Equal(setDescription, setModel.Description);
     Assert.Equal(typeof(TestConfigSet), setModel.ConfigSetType);
 }
Exemplo n.º 4
0
        public void CanBuildModel_WithTagFromAttribute()
        {
            var builder = new ConfigurationSetModelBuilder <TestConfigSetWithTag>(setName, setDescription);
            var model   = builder.Build();

            Assert.NotNull(model.RequiredClientTag);
            Assert.Equal(requiredTag, model.RequiredClientTag.Value);
        }
Exemplo n.º 5
0
        public void CanBuildModel_CanAddTag()
        {
            var builder = new ConfigurationSetModelBuilder <TestConfigSet>(setName, setDescription);

            builder.SetRequiredClientTag(requiredTag);
            var model = builder.Build();

            Assert.NotNull(model.RequiredClientTag);
            Assert.Equal(requiredTag, model.RequiredClientTag.Value);
        }
 public void CanBuildModel_WithOption_WithName()
 {
     var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
     var name = "test";
     builder.Options(x => x.OptionsOne, x => x.Id, x => x.Value, name);
     var setModel = builder.Build();
     var configModel = setModel.Get<OptionOne>();
     Assert.Equal(typeof(OptionOne), configModel.Type);
     Assert.Equal(string.Empty, configModel.ConfigurationDescription);
     Assert.Equal(name, configModel.ConfigurationDisplayName);
 }
 public void CanBuildModel_WithConfig_HasDefaultValues()
 {
     var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
     builder.Config(x=> x.Sample);
     var setModel = builder.Build();
     var configModel = setModel.Get<SimpleConfig>();
     Assert.Equal(typeof(SimpleConfig), configModel.Type);
     Assert.Equal(string.Empty, configModel.ConfigurationDescription);
     Assert.Equal(typeof(SimpleConfig).Name, configModel.ConfigurationDisplayName);
     Assert.Equal(nameof(TestConfigSet.Sample), configModel.Name);
 }
 public void CanBuildModel_WithOption_HasDefaultValues()
 {
     var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
     builder.Options(x => x.OptionsOne, x=> x.Id, x=> x.Value);
     var setModel = builder.Build();
     var configModel = setModel.Get<OptionOne>() as ConfigurationOptionModel;
     Assert.NotNull(configModel);
     Assert.Equal(typeof(OptionOne), configModel.Type);
     Assert.Equal(string.Empty, configModel.ConfigurationDescription);
     Assert.Equal(typeof(OptionOne).Name, configModel.ConfigurationDisplayName);
     Assert.Equal(nameof(TestConfigSet.OptionsOne), configModel.Name);
 }
Exemplo n.º 9
0
        public void CanBuildModel_WithOption_LongKey_HasUniqueKey()
        {
            var builder  = new ConfigurationSetModelBuilder <TestConfigSet>(setName, setDescription);
            var name     = "test";
            var descript = "test descript";

            builder.Options(x => x.OptionsThree, x => x.Key, x => x.Description, name, descript);
            var setModel    = builder.Build();
            var configModel = setModel.Get <OptionThree>();

            Assert.Equal(nameof(OptionThree.Key), configModel.KeyPropertyName);
        }
        public void CanBuildModel_WithOption_LongKey_WithNameDescription()
        {
            var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
            var name = "test";
            var descript = "test descript";

            builder.Options(x => x.OptionsThree, x => x.Key, x => x.Description, name, descript);
            var setModel = builder.Build();
            var configModel = setModel.Get<OptionThree>();
            Assert.Equal(typeof(OptionThree), configModel.Type);
            Assert.Equal(descript, configModel.ConfigurationDescription);
            Assert.Equal(name, configModel.ConfigurationDisplayName);
        }
        public void CanBuildModel_WithConfig_WithNameDescription()
        {
            var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
            var name = "test";
            var descript = "test descript";

            builder.Config(x=> x.Sample, name, descript);
            var setModel = builder.Build();
            var configModel = setModel.Get<SimpleConfig>();
            Assert.Equal(typeof(SimpleConfig), configModel.Type);
            Assert.Equal(descript, configModel.ConfigurationDescription);
            Assert.Equal(name, configModel.ConfigurationDisplayName);

        }
            protected override void OnModelCreation(ConfigurationSetModelBuilder <TestConfiguationModule> modelBuilder)
            {
                modelBuilder.Options(set => set.Options, r => r.Id, r => r.Description);
                modelBuilder.Options(set => set.OptionsFromProvider, r => r.Id, r => r.Description, (IOptionProvider provider) => provider.GetOptions());

                var optionConfig = modelBuilder.Options(set => set.OptionDependentOnAnotherOption, r => r.Id, r => r)
                                   .PropertyWithOption(r => r.ExternalOption, (TestConfiguationModule option) => option.Options);

                var configBuilder = modelBuilder.Config(set => set.TestConfig);

                configBuilder.PropertyWithOption(p => p.ExternalOption, (TestConfiguationModule provider) => provider.Options);
                configBuilder.PropertyWithOption(p => p.Option, (TestConfiguationModule provider) => provider.OptionsFromProvider);
                configBuilder.PropertyWithMultipleOptions(p => p.MoarOptions, (TestConfiguationModule provider) => provider.OptionsFromProvider);
            }
        public void CanBuildModel_WithOption_CanBuildOptionSet()
        {
            var builder = new ConfigurationSetModelBuilder<TestConfigSet>(setName, setDescription);
            builder.Options(x => x.OptionsOne, x => x.Id, x => x.Value);
            var setModel = builder.Build();
            var options = new List<OptionOne>
            {
                new OptionOne { Id = 1, Value = 12},
                new OptionOne { Id = 2, Value = 32}
            };
            var configModel = setModel.Get<OptionOne>() as ConfigurationOptionModel;
            var optionSet = configModel.BuildOptionSet(options) as OptionSet<OptionOne>;
            Assert.NotNull(optionSet);
            Assert.Equal(options.Count, optionSet.Count);
            Assert.Equal(options[0].Value, optionSet["1"].Value);
            Assert.Equal(options[1].Value, optionSet["2"].Value);

        }
Exemplo n.º 14
0
        protected override void OnModelCreation(ConfigurationSetModelBuilder <SampleConfigSet> modelBuilder)
        {
            var configBuilder = modelBuilder.Config(s => s.SampleConfig, "Sample Config", "Basic Configuration");

            configBuilder.Property(p => p.IsLlamaFarmer);
            configBuilder.Property(p => p.Decimal)
            .WithDisplayName("Value")
            .WithDescription("Is a value in decimal");

            configBuilder.Property(p => p.LlamaCapacity)
            .WithDescription("Is the capacity of llama")
            .WithMinValue(0)
            .WithMaxValue(50);
            configBuilder.Property(p => p.SpareLlamaCapacity)
            .WithDescription("Some spare capacity for LLamas")
            .WithMaxValue(50);

            configBuilder.Property(p => p.StartDate)
            .WithMinValue(new DateTime(2013, 10, 10));

            configBuilder.Property(p => p.Name).WithMaxLength(250);
            configBuilder.PropertyWithOption(p => p.Option, (SampleConfigSet set) => set.OptionFromProvider)
            .WithDescription("Is a selected option");

            configBuilder.PropertyWithMultipleOptions(p => p.MoarOptions, (SampleConfigSet set) => set.OptionFromProvider)
            .WithDescription("Is a multi select option");

            configBuilder.Collection(p => p.ListOfConfigs)
            .WithUniqueKey(x => x.Name);
            configBuilder.PropertyWithOptionValue(p => p.OptionId, (SampleConfigSet set) => set.OptionFromProvider, option => option.Id);

            configBuilder.Collection(p => p.ListOfInts).HasUniqueValues();
            configBuilder.Collection(p => p.ListOfStrings).HasUniqueValues();



            modelBuilder.Options(s => s.Options, o => o.Id, o => o.Description, "Options", "Options for sample config");
            modelBuilder.Options(s => s.OptionFromProvider, o => o.Id, o => o.Description, (IOptionProvider optionProvider) => optionProvider.GetOptions(), "Options", "Options for sample config");
        }
Exemplo n.º 15
0
 protected override void OnModelCreation(ConfigurationSetModelBuilder <TestConfiguationModule> modelBuilder)
 {
     //modelBuilder.Options(set => set.Options, r => r.Id, r => r.Description);
     //var configBuilder = modelBuilder.Config(set => set.TestConfig);
     //configBuilder.PropertyWithOptions
 }