コード例 #1
0
 public virtual void Visit(CompositeRule visitee)
 {
     foreach (Rule child in visitee.Rules)
     {
         child.Accept(this);
     }
 }
コード例 #2
0
        public override string Part2()
        {
            rules[8] = new CompositeRule
            {
                Self     = 8,
                Subrules = new List <List <int> >
                {
                    new List <int> {
                        42
                    },
                    new List <int> {
                        42, 8
                    },
                },
            };

            rules[11] = new CompositeRule
            {
                Self     = 11,
                Subrules = new List <List <int> >
                {
                    new List <int> {
                        42, 31
                    },
                    new List <int> {
                        42, 11, 31
                    },
                },
            };

            return(messages.Where(m => match(m, new[] { 0 })).Count().ToString());
        }
コード例 #3
0
        public void Test_ShouldNotUpdateSlip()
        {
            var rule = new CompositeRule(
                new ActivateRule());
            var book = new Book("book01", "CLRS");
            IReadOnlyCollection <ICommand> commands = rule.Handle(book);

            Assert.AreEqual(commands.Count, 0);
        }
コード例 #4
0
        public void TestForBookProducts()
        {
            var rule = new CompositeRule(new SlipForShippingRule(),
                                         new SlipForRoyaltyRule());
            var book = new Book("book01", "CLRS");
            IReadOnlyCollection <ICommand> commands = rule.Handle(book);

            // Shall return 2 objects, for shipping and royality department
            Assert.AreEqual(commands.Count, 2);
        }
コード例 #5
0
        public CompositeRuleViewModel(CompositeRule rule, RuleViewModelFactory rulesFactory, IEventAggregator eventAggregator)
            : base(rule, eventAggregator)
        {
            _model           = rule;
            _rulesFactory    = rulesFactory;
            _eventAggregator = eventAggregator;

            _rules = new BindableCollection <RuleViewModelBase>(rule.Rules.Select(r => rulesFactory.Create(r, this)));
            Rules  = _rules;
        }
コード例 #6
0
        public void AddCompositeRule()
        {
            var compositeRule = new CompositeRule()
            {
                Name = nameof(CompositeRule)
            };

            _model.Rules.Add(compositeRule);
            _rules.Add(_rulesFactory.Create(compositeRule, this));
        }
コード例 #7
0
        public void TestCommisionPayment()
        {
            var rule = new CompositeRule(
                new PaymentCommissionRule());
            var physicalProduct = new PhysicalProduct("pp01", "computer");

            Assert.AreEqual(false, physicalProduct.isCommissionGenerated);
            IReadOnlyCollection <ICommand> commands = rule.Handle(physicalProduct);

            Assert.AreEqual(true, physicalProduct.isCommissionGenerated);
        }
コード例 #8
0
        public void TestUpgradeMembership()
        {
            var rule = new CompositeRule(
                new UpgradeRule());
            var membership = new Membership("regular", "regular membership");

            Assert.AreEqual("Regular", membership.membershipType.ToString());
            IReadOnlyCollection <ICommand> commands = rule.Handle(membership);

            Assert.AreEqual("Premium", membership.membershipType.ToString());
        }
コード例 #9
0
        public void TestActiveMembership()
        {
            var rule = new CompositeRule(
                new ActivateRule());
            var membership = new Membership("regular", "regular membership");

            Assert.AreEqual(false, membership.IsActive);
            IReadOnlyCollection <ICommand> commands = rule.Handle(membership);

            Assert.AreEqual(true, membership.IsActive);
        }
コード例 #10
0
        public void MembershipTests()
        {
            var rule =
                new CompositeRule(
                    new SlipForShippingRule(),
                    new ActivateRule());

            var membership = new MembershipGood("John Smith");
            var commands   = rule.Handle(membership);
            var command    = commands.First() as ActivateCommand;

            Assert.Equal("John Smith", command.Membership);
        }
コード例 #11
0
        public void BooksTest()
        {
            var rule =
                new CompositeRule(
                    new SlipForShippingRule(),
                    new ActivateRule());

            var book     = new Book("The Annotated Turing");
            var commands = rule.Handle(book);
            var command  = commands.First() as SlipCommand;

            Assert.Equal(book, command.Good);
            Assert.Equal("Shipping", command.Action);
        }
コード例 #12
0
        public void EvaluateShouldInvokeAllComposedRules()
        {
            // arrange
            var target = new CompositeRule<int>()
            {
                new Rule<int, int>( i => ++i ),
                new Rule<int, int>( i => ++i ),
                new Rule<int, int>( i => ++i )
            };
            var seed = 0;

            // act
            var actual = target.Evaluate( seed );

            // assert
            Assert.Equal( 3, actual );
        }
コード例 #13
0
ファイル: LIteDbMapper.cs プロジェクト: szogun1987/analog
        private void Initialize()
        {
            var mapper = BsonMapper.Global;

            mapper.Entity <RuleInfo>()
            .Id(x => x.Id);

            mapper.RegisterType <CompositeRule>(rule =>
            {
                var bson = new BsonDocument
                {
                    ["Type"] = new BsonValue(rule.GetType().Name),
                    [nameof(rule.SelectedType)] = new BsonValue(rule.SelectedType.ToString()),
                    [nameof(rule.IsEnabled)]    = new BsonValue(rule.IsEnabled),
                    [nameof(rule.Name)]         = new BsonValue(rule.Name)
                };
                bson.Add(nameof(rule.Rules), new BsonArray(rule.Rules.Select(r => mapper.ToDocument(r))));
                return(bson);
            }, value =>
            {
                var rule          = new CompositeRule();
                rule.IsEnabled    = value.AsDocument[nameof(rule.IsEnabled)].AsBoolean;
                rule.Name         = value.AsDocument[nameof(rule.Name)].AsString;
                rule.SelectedType =
                    (RuleGroupType)
                    Enum.Parse(typeof(RuleGroupType), value.AsDocument[nameof(rule.SelectedType)].AsString);
                rule.Rules = value.AsDocument[nameof(rule.Rules)].AsArray.Select(v =>
                {
                    var type =
                        typeof(RuleBase).Assembly.GetType(
                            $"{typeof(RuleBase).Namespace}.{v.AsDocument["Type"].AsString}", true);
                    return(mapper.ToObject(type, v.AsDocument) as IRule);
                }).ToList();

                return(rule);
            });
            mapper.RegisterType <TextRule>(
                serialize: rule =>
            {
                var bson = new BsonDocument
                {
                    ["Type"]                       = new BsonValue(rule.GetType().Name),
                    [nameof(rule.Name)]            = new BsonValue(rule.Name),
                    [nameof(rule.IsEnabled)]       = new BsonValue(rule.IsEnabled),
                    [nameof(rule.SelectedAction)]  = new BsonValue(rule.SelectedAction.ToString()),
                    [nameof(rule.Text)]            = new BsonValue(rule.Text),
                    [nameof(rule.IsCaseSensitive)] = new BsonValue(rule.IsCaseSensitive)
                };
                return(bson);
            },
                deserialize: bson =>
            {
                var rule             = new TextRule();
                rule.Name            = bson.AsDocument[nameof(rule.Name)].AsString;
                rule.IsEnabled       = bson.AsDocument[nameof(rule.IsEnabled)].AsBoolean;
                rule.IsCaseSensitive = bson.AsDocument[nameof(rule.IsCaseSensitive)].AsBoolean;
                rule.SelectedAction  =
                    (TextRuleAction)
                    Enum.Parse(typeof(TextRuleAction), bson.AsDocument[nameof(rule.SelectedAction)].AsString);
                rule.Text = bson.AsDocument[nameof(rule.Text)].AsString;


                return(rule);
            });

            mapper.RegisterType <DateRule>(
                serialize: rule =>
            {
                var bson = new BsonDocument
                {
                    ["Type"]                      = new BsonValue(rule.GetType().Name),
                    [nameof(rule.Name)]           = new BsonValue(rule.Name),
                    [nameof(rule.IsEnabled)]      = new BsonValue(rule.IsEnabled),
                    [nameof(rule.SelectedAction)] = new BsonValue(rule.SelectedAction.ToString()),
                    [nameof(rule.Date)]           = !rule.Date.HasValue ? BsonValue.Null : new BsonValue(rule.Date)
                };
                return(bson);
            },
                deserialize: bson =>
            {
                var rule            = new DateRule();
                rule.Name           = bson.AsDocument[nameof(rule.Name)].AsString;
                rule.IsEnabled      = bson.AsDocument[nameof(rule.IsEnabled)].AsBoolean;
                rule.SelectedAction = (DateRuleAction)Enum.Parse(typeof(DateRuleAction), bson.AsDocument[nameof(rule.SelectedAction)].AsString);
                rule.Date           = bson.AsDocument[nameof(rule.Date)].IsNull
                        ? new DateTime?()
                        : bson.AsDocument[nameof(rule.Date)].AsDateTime;

                return(rule);
            });

            mapper.RegisterType <RegexRule>(
                serialize: rule =>
            {
                var bson = new BsonDocument
                {
                    ["Type"]                      = new BsonValue(rule.GetType().Name),
                    [nameof(rule.Name)]           = new BsonValue(rule.Name),
                    [nameof(rule.IsEnabled)]      = new BsonValue(rule.IsEnabled),
                    [nameof(rule.SelectedAction)] = new BsonValue(rule.SelectedAction.ToString()),
                    [nameof(rule.Pattern)]        = new BsonValue(rule.Pattern)
                };
                return(bson);
            },
                deserialize: bson =>
            {
                var rule            = new RegexRule();
                rule.Name           = bson.AsDocument[nameof(rule.Name)].AsString;
                rule.IsEnabled      = bson.AsDocument[nameof(rule.IsEnabled)].AsBoolean;
                rule.SelectedAction = (RegexRuleAction)
                                      Enum.Parse(typeof(RegexRuleAction), bson.AsDocument[nameof(rule.SelectedAction)].AsString);
                rule.Pattern = bson.AsDocument[nameof(rule.Pattern)].AsString;
                return(rule);
            });

            mapper.RegisterType <IRule>(
                serialize: rule => mapper.ToDocument(rule.GetType(), rule),
                deserialize: value =>
            {
                var type =
                    typeof(RuleBase).Assembly.GetType(
                        $"{typeof(RuleBase).Namespace}.{value.AsDocument["Type"].AsString}", true);
                return(mapper.ToObject(type, value.AsDocument) as IRule);
            }
                );
        }
コード例 #14
0
 public override void Visit(CompositeRule visitee)
 {
     //root = false;
     visitee.Rules.Aggregate(this, (visitor, r) => r.Accept(visitor));
 }