public string GetRuleDefinition(JObject ruleName)
        {
            string ruleNameStr = ruleName.ToObject <Name>().name;

            if (NullString(ruleNameStr))
            {
                return("false");
            }
            Rule rule = RulesManager.GetRuleByName(ruleNameStr).Value;

            RuleDefinition ruleDefinition = new RuleDefinition()
            {
                entityName    = rule.EntityName,
                priority      = rule.Priority,
                ruleName      = rule.RuleName,
                ruleCondition = rule.RuleCondition,
                ruleGroup     = rule.RuleGroup
            };

            ruleDefinition.ruleExecution = new List <RuleExecutionDefinition>();
            foreach (var ruleExecution in rule.RuleExecution)
            {
                ruleDefinition.ruleExecution.Add(new RuleExecutionDefinition()
                {
                    propertyName = ruleExecution.PropertyName,
                    execution    = ruleExecution.Execution,
                    order        = ruleExecution.Order
                });
            }

            return(JsonConvert.SerializeObject(ruleDefinition));
        }
Exemple #2
0
        public void Execute()
        {
            Console.Write("Rule name: ");
            string       ruleName = Console.ReadLine();
            RulesManager manager  = new RulesManager();
            Rule         rule     = manager.Find(ruleName);

            if (rule != null)
            {
                Console.Write("Address: ");
                string address = Console.ReadLine();
                if (rule.AddAddress(address))
                {
                    if (manager.Update(rule))
                    {
                        Console.WriteLine("Address added successfully.");
                        return;
                    }
                    Console.WriteLine("Rules file is not loaded.");
                    return;
                }
                Console.WriteLine("Address is already contained in the rule.");
                return;
            }
            Console.WriteLine("Rule not found.");
            return;
        }
        public IHttpActionResult ExecuteRuleGroup(ExecuteRuleDefinition executeRuleDefinition)
        {
            object entity        = executeRuleDefinition.entity;
            string ruleGroupName = executeRuleDefinition.ruleName;

            return(Ok(RulesManager.ExecuteRuleGroup(ruleGroupName, entity)));
        }
Exemple #4
0
        public void AnyEmployeeWithOneShift()
        {
            RulesManager rm = new RulesManager();

            rm.Initialize(@"C:\Projects\X.Scheduler\API\X.Scheduler\bin\Debug\netcoreapp3.1\");
            List <int> inputList = new List <int>();
            Random     rnd       = new Random();

            for (int i = 0; i < 28; i++)
            {
                inputList.Add(rnd.Next(0, 9));
            }
            List <int> resultList = new List <int>();

            resultList = rm.ApplyRules(inputList, 9);

            foreach (var item in resultList)
            {
                int count = resultList.Where(x => x.Equals(item)).Count();

                if (count.Equals(1))
                {
                    Assert.Fail();
                }
            }
        }
Exemple #5
0
        public void AnyEmployeeWithTwoDaysSecondShift()
        {
            RulesManager rm = new RulesManager();

            rm.Initialize(@"C:\Projects\X.Scheduler\API\X.Scheduler\bin\Debug\netcoreapp3.1\");
            List <int> inputList = new List <int>();
            Random     rnd       = new Random();

            for (int i = 0; i < 28; i++)
            {
                inputList.Add(rnd.Next(0, 9));
            }
            List <int> resultList = new List <int>();

            resultList = rm.ApplyRules(inputList, 9);

            int index = 0;

            foreach (var item in resultList)
            {
                while (index > 0 && index % 2 == 0 && item.Equals(resultList[index - 2]))
                {
                    Assert.Fail();
                }
                index++;
            }
        }
        /// <summary>
        /// Validation Rules will be executed if they are defined.
        /// </summary>
        /// <param name="rcvData"></param>
        /// <returns></returns>
        private bool executeValidationRules(TAdapterOutput rcvData,
                                            ICollection <ValidationRuleDescriptor> validatorRules,
                                            out ValidatorRulesResult validationResult)
        {
            validationResult = new ValidatorRulesResult();

            if (validatorRules != null)
            {
                // TODO Log.

                ValidationRulesPipeline pipeline = new ValidationRulesPipeline()
                {
                    EntityInstance = rcvData,
                    Rules          = validatorRules
                };

                validationResult = RulesManager.RunPipeline(pipeline);
            }

            if ((validationResult != null && validationResult.HasFailed == false) ||
                validationResult == null)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #7
0
        public void WaitForClose()
        {
            Task collectorTask = CollectorManager.WaitForCloseToCompleteAsync();
            Task rulesTask     = RulesManager.WaitForCloseToCompleteAsync();

            Task.WaitAll(collectorTask, rulesTask);
        }
        public void Execute()
        {
            Console.Write("Rule name: ");
            string       ruleName = Console.ReadLine();
            RulesManager manager  = new RulesManager();
            Rule         rule     = manager.Find(ruleName);

            if (rule != null)
            {
                Console.Write($"({rule.LocationFolderName} override) \n");
                Console.Write("Folder name: ");
                string folderName = Console.ReadLine();
                Folder folder     = Folder.Find(folderName);
                if (folder != null)
                {
                    rule.LocationFolderName = folder.Name;
                    int mailsMoved = rule.Execute();
                    if (mailsMoved > -1)
                    {
                        Console.Write($"Moved {mailsMoved} mail ");
                        Console.Write($"from {rule.LocationFolderName} ");
                        Console.Write($"to {rule.DestinationFolderName} \n");
                        return;
                    }
                }
                Console.WriteLine("Folder was not found.");
            }
            Console.WriteLine("Rule was not found.");
        }
Exemple #9
0
 //The IsTrading flag is the only state variable that is not reset by the rule that sets it
 override protected bool ExcuteRuleLogic()
 {
     if (BotState.IsAfterTerminateTime || BotState.IsReset)
     {
         RulesManager.Reset();
         BotState.IsTrading = false;
         return(true);
     }
     return(false);
 }
Exemple #10
0
    void Awake()
    {
        // Only allow one in a scene
        if (g != null) {
            DestroyImmediate(gameObject);
            return;
        }

        g = this;
    }
 void Awake()
 {
     if (Instance == null)
     {
         Instance = this;
     }
     else
     {
         Destroy(gameObject);
     }
 }
        public string DeleteRule(JObject ruleName)
        {
            string ruleNameStr = ruleName.ToObject <Name>().name;

            if (NullString(ruleNameStr))
            {
                return("false");
            }

            RulesManager.DeleteRule(ruleNameStr);
            return("true");
        }
        public void Apply_should_apply_rules_for_new_membership()
        {
            //arrange
            var manager    = new RulesManager();
            var notify     = new Mock <INotification <NewMembership> >();
            var membership = Helpers.GetNewMembership(notify.Object);

            //act
            manager.Process(membership);

            //assert
            notify.Verify(n => n.SendNotification(membership), Times.Once());
        }
Exemple #14
0
 void Awake()
 {
     if (instance == null)
     {
         instance = this;
     }
     else
     {
         Destroy(gameObject);
         return;
     }
     DontDestroyOnLoad(gameObject);
 }
    // Use this for initialization
    void Start()
    {
        if (manager == null)
        {
            RulesManager.manager = this;
        }
        else
        {
            Destroy(this);
        }

        turnTimeLeft = turnTime;
    }
Exemple #16
0
        public void Execute()
        {
            Console.Write("Rule name: ");
            string       ruleName = Console.ReadLine();
            RulesManager manager  = new RulesManager();

            if (manager.Remove(ruleName))
            {
                Console.WriteLine("Rule removed succesfully!");
                return;
            }
            Console.WriteLine("Something when wrong.");
        }
        public void Apply_should_apply_rules_for_active_membership()
        {
            //arrange
            var manager    = new RulesManager();
            var notify     = new Mock <INotification <ActiveMembership> >();
            var membership = Helpers.GetActiveMembership(notify.Object);

            //act
            manager.Process(membership);

            //assert
            notify.Verify(n => n.SendNotification(membership), Times.Once());
            Assert.True(DateTime.Now.AddDays(ActiveMembership._days).Date == membership.ExpiryDate.Date);
        }
Exemple #18
0
 public void Start()
 {
     _logger()?.Information("Manager Start Called");
     _logger()?.Information("Starting Collector...");
     CollectorManager.Start();
     _logger()?.Information("Collector Starting Completed");
     _logger()?.Information("Starting Rules...");
     RulesManager.StartAsync().Wait();
     _logger()?.Information("Rules Starting Completed");
     _logger()?.Information("Starting Reports...");
     ReportsManager.Start();
     _logger()?.Information("Rules Starting Completed");
     _logger()?.Information("Manager Start Completed");
 }
Exemple #19
0
        public static async Task RunTestWithConfig(ILogger logger, string logFilePath, string configDir)
        {
            //string rootPath = configDir;
            string repositoryConfigPath     = $"{configDir}{Path.DirectorySeparatorChar}repository.xml.config";
            string machineSubscriptionsPath = $"{configDir}{Path.DirectorySeparatorChar}machines.xml.config";


            string _loggingPath = $"{logFilePath}{Path.DirectorySeparatorChar}RulesEngine{Path.DirectorySeparatorChar}";

            ILogger sublogger = new LoggerConfiguration()
                                .WriteTo.Async(a => a.Logger(logger))
                                .WriteTo.Async(a => a.File($"{_loggingPath}Log_{DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss")}.log").MinimumLevel.Verbose())
                                .MinimumLevel.Verbose()
                                .CreateLogger();

            sublogger.Information("{Class}.{Method} is Starting...", $"{nameof(RAL)}{nameof(RulesEngine)}{nameof(ConsoleTest)}{nameof(Program)}", nameof(RunTestNonConfig));

            RulesManager rulesManager = new RulesManager();

            var RepositoryConfig = new RepositoryFactory().LoadFrom(repositoryConfigPath).Config;


            var rulesFactory = new RulesFactory(sublogger)
                               .LoadFromFile(machineSubscriptionsPath)
                               .WithLogger(sublogger)
                               .WithRepository(
                new RepositoryForRules(
                    new MachineRepository(
                        RepositoryConfig.DatabaseIPaddress,
                        RepositoryConfig.DatabaseName,
                        Convert.ToInt32(RepositoryConfig.DatabasePort)
                        )
                    )
                );

            var rules = rulesFactory.Build();

            rules = rulesManager.Rules = rules;


            await rulesManager.StartAsync();


            sublogger.Information("{Class}.{Method} Waiting Indefinitely...", $"{nameof(RAL)}{nameof(RulesEngine)}{nameof(ConsoleTest)}{nameof(Program)}", nameof(RunTestNonConfig));
            await Task.Run(() => rulesManager.WaitForStop());

            //await rulesManager.StopAsync();
            sublogger.Information("{Class}.{Method} Closing...", $"{nameof(RAL)}{nameof(RulesEngine)}{nameof(ConsoleTest)}{nameof(Program)}", nameof(RunTestNonConfig));
        }
Exemple #20
0
        public TrafficLightUserControlViewModel()
        {
            RulesManager rules = new RulesManager
            {
                States = new Dictionary <int, int>()
                {
                    { (int)PotentialStates.getReady, 2000 }, { (int)PotentialStates.go, 5000 }, { (int)PotentialStates.revertingToDefault, 2000 }
                },
                DefaultState = (int)PotentialStates.stop
            };

            this.trafficLight             = new TrafficLight();
            this.trafficLightManager      = new TrafficLightManager(trafficLight, rules);
            trafficLight.PropertyChanged += (s, e) => SetColors();
        }
        public void Apply_should_not_apply_rules_for_videocontent()
        {
            //arrange
            var manager = new RulesManager();
            var video   = Helpers.GetVideContent();

            video.IsELearning = false;

            //act
            manager.Process(video);

            //assert
            Assert.NotNull(video);
            Assert.DoesNotContain(video.CurrentOrder.Items, o => o is FreeVideoContent);
        }
        public void Apply_should_not_apply_rules_for_active_completed_membership()
        {
            //arrange
            var notification = new Mock <INotification <ActiveMembership> >();
            var manager      = new RulesManager();
            var membership   = Helpers.GetActiveMembership(notification.Object);

            membership.ItemStatus = Status.Completed;

            //act
            manager.Process(membership);

            //assert
            notification.Verify(n => n.SendNotification(membership), Times.Never());
        }
        public void Apply_should_apply_rules_for_videocontent()
        {
            //arrange
            var manager = new RulesManager();
            var video   = Helpers.GetVideContent();

            //book.ItemStatus = Status.Completed;

            //act
            manager.Process(video);

            //assert
            Assert.NotNull(video);
            Assert.Contains(video.CurrentOrder.Items, o => o is FreeVideoContent);
        }
        public void Apply_should_not_apply_rules_for_completed_book()
        {
            //arrange
            var manager = new RulesManager();
            var book    = Helpers.GetBook();

            book.ItemStatus = Status.Completed;

            //act
            manager.Process(book);

            //assert
            Assert.NotNull(book);
            Assert.True(book.PackingSlips == default(List <Packingslip>));
            Assert.True(book.Agent?.CommissionEarned == 0);
        }
Exemple #25
0
        public void should_be_return_invalid_rules_if_pilot_are_alone_with_stewardess()
        {
            var passengers = new List <IPassenger>()
            {
                new PassengerBuilder().IsPilot().Create(),
                new PassengerBuilder().IsStewardess().Create()
            };

            var airplane = new Airplane(passengers);

            var rulesManager = new RulesManager(airplane);

            rulesManager.ValidateRules();

            rulesManager.IsValid().Should().BeFalse();
            rulesManager.Errors.Any().Should().BeTrue();
        }
Exemple #26
0
        public void Execute()
        {
            RulesManager manager = new RulesManager();
            List <Rule>  rules   = manager.Values();

            Console.Write($"{"Name",        -10}\t");
            Console.Write($"{"Location",    -20}\t");
            Console.Write($"{"Destination", -20}\t");
            Console.Write($"{"Addresses",   -10}\n");
            foreach (Rule rule in rules)
            {
                Console.Write($"{rule.Name,                 -10}\t");
                Console.Write($"{rule.LocationFolderName,   -20}\t");
                Console.Write($"{rule.DestinationFolderName,-20}\t");
                Console.Write($"{rule.AddressesCount,       -10}\n");
            }
        }
Exemple #27
0
        public void should_be_return_invalid_rules_if_cabin_chief_are_alone_with_flight_official()
        {
            var passengers = new List <IPassenger>()
            {
                new PassengerBuilder().IsCabinChief().Create(),
                new PassengerBuilder().IsFlightOfficer().Create()
            };

            var airplane = new Airplane(passengers);

            var rulesManager = new RulesManager(airplane);

            rulesManager.ValidateRules();

            rulesManager.IsValid().Should().BeFalse();
            rulesManager.Errors.Any().Should().BeTrue();
        }
        public void Apply_should_apply_rules_for_product()
        {
            //arrange
            var manager = new RulesManager();
            var product = Helpers.GetProduct();

            //act
            manager.Process(product);

            //assert
            Assert.NotNull(product);
            Assert.NotEmpty(product.PackingSlips);
            Assert.True(product.PackingSlips.Last().IsOriginal);
            Assert.NotNull(product.PackingSlips.Last().Id);

            Assert.True(product.Agent?.CommissionEarned == (float)(product.ItemPrice * 0.05));
        }
        public void Execute()
        {
            Console.Write("Rule name: ");
            string       ruleName = Console.ReadLine();
            RulesManager manager  = new RulesManager();
            Rule         rule     = manager.Find(ruleName);

            if (rule != null)
            {
                Console.Write("Folder name: ");
                string folderName = Console.ReadLine();
                rule.LocationFolderName = folderName;
                manager.Update(rule);
                return;
            }
            Console.WriteLine("Rule not found.");
            return;
        }
        public void Apply_should_apply_rules_for_book()
        {
            //arrange
            var manager = new RulesManager();
            var book    = Helpers.GetBook();

            //act
            manager.Process(book);

            //assert
            Assert.NotNull(book);
            Assert.NotEmpty(book.PackingSlips);
            Assert.True(book.PackingSlips.First().IsOriginal);
            Assert.NotNull(book.PackingSlips.First().Id);
            Assert.True(!book.PackingSlips.Last().IsOriginal);
            Assert.NotNull(book.PackingSlips.Last().Id);

            Assert.True(book.Agent?.CommissionEarned == (float)(book.ItemPrice * 0.05));
        }
        public string AddUpdateRule(JObject ruleDefinition)
        {
            var o = ruleDefinition.ToObject <RuleDefinition>();

            if (NullString(o.entityName) ||
                NullString(o.ruleName) ||
                NullString(o.ruleCondition) ||
                NullString(o.ruleGroup))
            {
                return("false");
            }

            Rule rule = new Rule()
            {
                EntityName    = o.entityName,
                Priority      = o.priority,
                RuleName      = o.ruleName,
                RuleCondition = o.ruleCondition,
                RuleGroup     = o.ruleGroup
            };

            rule.RuleExecution = new List <RuleExecution>();
            foreach (var ruleExecution in o.ruleExecution)
            {
                if (NullString(ruleExecution.propertyName) ||
                    NullString(ruleExecution.execution))
                {
                    return("false");
                }

                rule.RuleExecution.Add(new RuleExecution()
                {
                    PropertyName = ruleExecution.propertyName,
                    Execution    = ruleExecution.execution,
                    Order        = ruleExecution.order
                });
            }

            RulesManager.AddorUpdateRule(rule);

            return("true");
        }