static string CreatePoem()
{
Dictionary <string, Rule> rules = RulesFactory.GetDictionaryOfRules("rules.txt");
RulesInterpreter intepreter = new RulesInterpreter(rules);
string poem = intepreter.GetTextForRule("POEM");
return(poem);
}
/**
* Check if the dot can be selected
*/
bool ProcessSelectionRules(GameObject dot)
{
foreach (RulesFactory.AvailableRules rule in Enum.GetValues(typeof(RulesFactory.AvailableRules)))
{
IRule newRule = new RulesFactory().Create(rule);
if (!newRule.Validate(dot, selectedDots[selectedDots.Count - 1]))
{
return(false);
}
}
return(true);
}
// include configuration
private static void RunTool(string sourceFile, string targetFile)
{
Log.Info("Conversion Tool is now running.");
// Define the type of Rules by language type
sourceRules = RulesFactory.GenerateRule(sourceFile);
targetRules = RulesFactory.GenerateRule(targetFile);
ConvertSourceFile();
CreateTargetFile();
// Convert target file to Desired file.
Log.Success($"File is converted. Please check {Path.GetFileName(targetFile)}.");
}
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));
}
public void CreateTest(int[] expectedRuleIds)
{
var services = new ServiceCollection();
var expectedRules = CreateFakeRules(expectedRuleIds).ToList();
var count = expectedRules.Count();
for (var i = 0; i < count; i++)
{
services.AddScoped(typeof(IBaseRule <FakeRequest, FakeResponse>), expectedRules[i].GetType());
}
var serviceProvider = services.BuildServiceProvider();
var factory = new RulesFactory <FakeRequest, FakeResponse>(serviceProvider);
var actualRules = factory.Create().ToList();
for (var i = 0; i < count; i++)
{
Assert.IsInstanceOfType(actualRules[i], expectedRules[i].GetType());
}
}
public async Task <bool> Save(Policy policy)
{
var type = await _policyTypeRepository.GetById(policy.PolicyTypeId);
var rules = await _ruleRepository.GetAll();
rules.Where(x => x.RiskTypeId == policy.RiskTypeId).ToList()
.ForEach(r =>
{
var rule = RulesFactory.Build(r.Type, r.Value);
var x = rule.Invoke(type.Coverage);
if (x)
{
throw new PolicyInvalidException($"{r.Type} {r.Value}");
}
});
return(await _policyRepository.Save(policy));
}
public Dealer(RulesFactory rulesFactory)
{
newGameRule = rulesFactory.GetNewGameRule();
hitRule = rulesFactory.GetHitRule();
winRule = rulesFactory.GetWinRule();
}
