public void DtoRegexRulePatternAtEntityScopeWithManyExclusions()
{
var dtoRules = new DTO.CustomizationRule()
{
RegexRules = new DTO.RegexRule[]
{
new DTO.RegexRule()
{
pattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
scope = DTO.RuleScope.Entity,
Exclude = new string[] {
"new_incorrect_Naming", "new_INcorrect", "not_SoGood"
}
}
}
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as RegexRule;
Assert.Equal(@"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
rule.Pattern.ToString());
Assert.Equal(RuleScope.Entity, rule.Scope);
var excluded = GetInstanceField(rule.GetType(),
rule,
"_excludedSchemaNames") as ICollection <string>;
Assert.Equal(3, excluded.Count);
Assert.Contains("new_incorrect_Naming", excluded);
Assert.Contains("new_INcorrect", excluded);
Assert.Contains("not_SoGood", excluded);
}
public RepositoryManager()
{
TcModel = new SplitterEntities();
UserRepository = new UserRepository(TcModel);
RuleRepository = new RuleRepository(TcModel);
StatisticRepository = new StatisticRepository(TcModel);
}
public void DtoRegexRulePatternAtAttributeScopeWithOneExclusion()
{
var dtoRules = new DTO.CustomizationRule()
{
RegexRules = new DTO.RegexRule[]
{
new DTO.RegexRule()
{
pattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
scope = DTO.RuleScope.Attribute,
Exclude = new string[] { "new_incorrect_Naming.my_field" }
}
}
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as RegexRule;
Assert.Equal(@"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
rule.Pattern.ToString());
Assert.Equal(RuleScope.Attribute, rule.Scope);
var excluded = GetInstanceField(rule.GetType(),
rule,
"_excludedSchemaNames") as ICollection <string>;
Assert.Single(excluded);
Assert.Contains("new_incorrect_Naming.my_field", excluded);
}
/// <summary>
/// Initialize the facility
/// </summary>
protected override void Init()
{
Kernel.Register(Component.For <NRules.IDependencyResolver>()
.UsingFactoryMethod(k => new WindsorDependencyResolver(k), true)
.LifestyleSingleton());
Kernel.Register(Component.For <IRuleRepository>().UsingFactoryMethod(k =>
{
var r = new RuleRepository {
Activator = new WindsorRuleActivator(Kernel)
};
r.Load(_loadSpecAction ?? OnLoadSpecAction);
return(r);
}).LifestyleSingleton());
Kernel.Register(Component.For <ISessionFactory>().UsingFactoryMethod(k =>
{
var s = k.Resolve <IRuleRepository>().Compile();
s.DependencyResolver = k.Resolve <NRules.IDependencyResolver>();
return(s);
}));
Kernel.Register(Component.For <ISession>().UsingFactoryMethod(k =>
k.Resolve <ISessionFactory>().CreateSession()));
Kernel.ComponentRegistered += OnComponentRegistered;
}
public void Test_GetQueries_SubjectWithAccessRuleButNoPermissions()
{
QueryRepository queryRepository;
SecurableEntity securableEntityType;
AccessRule accessRule;
Role subject;
ICollection <AccessRule> result;
IEntityRepository entityRepository = Factory.EntityRepository;
using (DatabaseContext.GetContext(true))
{
securableEntityType = Entity.Create <EntityType>().As <SecurableEntity>();
securableEntityType.Save();
accessRule = Entity.Create <AccessRule>();
accessRule.AccessRuleEnabled = true;
accessRule.ControlAccess = securableEntityType;
accessRule.Save();
subject = Entity.Create <Role>();
subject.AllowAccess.Add(accessRule.As <AccessRule>());
subject.Save();
queryRepository = new QueryRepository();
result = new RuleRepository(entityRepository).GetAccessRules(subject.Id, Permissions.Read, new [] { securableEntityType.Id });
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.Empty);
}
}
private ISessionFactory CreateTarget()
{
var repository = new RuleRepository();
repository.Load(x => x.NestedTypes().From(typeof(TestRule)));
return(repository.Compile());
}
public async Task <string> TipMessageAsync()
{
TipList = new List <Tip>();
var tipList = await MainDialog.QueryTipsAsync();
// Rules engine here
// Load rules
var repository = new RuleRepository();
repository.Load(x => x.From(typeof(TipChooseRule).Assembly));
// Compile rules
var factory = repository.Compile();
// Create a working session
var session = factory.CreateSession();
// Insert facts into rules engine's memory
session.Insert(PersonalDetailsDialog.PersonalDetails);
foreach (Tip obj in tipList)
{
session.Insert(obj);
}
// Start match/resolve/act cycle
session.Fire();
return(RandomiseList(TipList.Select(l => l.TipMessage).ToList()));
}
public static IMessageExpression GetInstance(ILoggingService loggingService, int ruleId)
{
loggingService.Log($"New create instance call has been recieved for ruleId{ruleId}");
var repository = new RuleRepository();
return(new MessageExppression(loggingService, repository, ruleId));
}
private static void RestReaminingSample()
{
//Load rules
var repository = new RuleRepository();
repository.Load(x => x.From(typeof(NoticeNewRequestRule).Assembly));
//Compile rules
var factory = repository.Compile();
//Create a working session
var session = factory.CreateSession();
//Fake Web Action
var fakeAction = new FakeAction();
//設定補修只有2天
var person = fakeAction.GetFakePerson("皓之", 2);
session.Insert(person);
session.Fire();
//請假
var request = fakeAction.SendAskForRestRequest();
session.Insert(request);
session.Fire();
}
public bool Shipped([FromBody] Shipment s)
{
Shipment shipment = _context.Shipment
.Where(x => x.TrackingNumber == s.TrackingNumber)
.FirstOrDefault();
shipment.IsFullShipment = true;
//When the shipment is done,
//then update the shipment
_context.Shipment.Update(shipment);
SalesOrder salesOrder = _context.SalesOrder.Where(s1 => s1.SalesOrderId == shipment.SalesOrderId).Single();
Customer customer = _context.Customer.Where(cust => cust.CustomerId == salesOrder.CustomerId).Single();
salesOrder.OrderProgressTypeId = OrderProgressStatus.CLOSED;
//rule start
var repository = new RuleRepository();
repository.Load(x => x.From(Assembly.GetExecutingAssembly()));
var factory = repository.Compile();
var session = factory.CreateSession();
session.Insert(salesOrder);
session.Fire();
//rule end
_context.SaveChanges();
return(true);
}
static void Main(string[] args)
{
var repository = new RuleRepository();
repository.Load(x => x.From(typeof(AssignFirstSeat).Assembly));
var factory = repository.Compile();
var session = factory.CreateSession();
session.Events.FactInsertingEvent += EventProviderOnFactInsertingEvent;
session.Events.FactUpdatingEvent += EventProviderOnFactUpdatingEvent;
session.Events.FactRetractingEvent += EventProviderOnFactRetractingEvent;
session.Events.ActivationCreatedEvent += EventProviderOnActivationCreatedEvent;
session.Events.ActivationDeletedEvent += EventProviderOnActivationDeletedEvent;
session.Events.RuleFiringEvent += EventProviderOnRuleFiringEvent;
session.Insert(new Guest("N1", Gender.Male, new Hobby("H1")));
session.Insert(new Guest("N2", Gender.Female, new Hobby("H1")));
session.Insert(new Guest("N2", Gender.Female, new Hobby("H3")));
session.Insert(new Guest("N3", Gender.Male, new Hobby("H3")));
session.Insert(new Guest("N4", Gender.Male, new Hobby("H1")));
session.Insert(new Guest("N4", Gender.Female, new Hobby("H2")));
session.Insert(new Guest("N4", Gender.Female, new Hobby("H3")));
session.Insert(new Guest("N5", Gender.Female, new Hobby("H2")));
session.Insert(new Guest("N5", Gender.Female, new Hobby("H1")));
session.Insert(new Count(1));
session.Insert(new LastSeat(5));
var context = new Context();
session.Insert(context);
session.Fire();
}
public void Compile()
{
//Load rules
var repository = new RuleRepository();
// Here is for the scriptedAssembly ...
// repository.Load(x => x.From(typeof(PreferredCustomerDiscountRule).Assembly));
// Compile rules
var factory = repository.Compile();
//Create a working session
var session = factory.CreateSession();
//Load domain model
// var customer = new Customer("John Doe") { IsPreferred = true };
// var order1 = new Order(123456, customer, 2, 25.0);
// var order2 = new Order(123457, customer, 1, 100.0);
//Insert facts into rules engine's memory
// session.Insert(customer);
// session.Insert(order1);
// session.Insert(order2);
//Start match/resolve/act cycle
session.Fire();
}
public void Test1()
{
//Load rules
var repository = new RuleRepository();
repository.Load(x => x.From(typeof(PreferredCustomerDiscountRule).Assembly));
//Compile rules
var factory = repository.Compile();
//Create a working session
var session = factory.CreateSession();
//Load domain model
var customer = new Customer("John Doe")
{
IsPreferred = true
};
var order1 = new Order(123456, customer, 2, 25.0);
var order2 = new Order(123457, customer, 1, 100.0);
session.Insert(customer);
session.Insert(order1);
session.Insert(order2);
session.Fire();
}
public void RuleRepositoryExtension_Compile_CancellationRequested()
{
using (var cancellationSource = new CancellationTokenSource())
{
// Arrange
var ruleCompiler = new RuleCompiler();
var rule1 = CreateRuleDefinitionMock();
var rule2 = CreateRuleDefinitionMock();
rule2.Setup(r => r.LeftHandSide).Returns(() =>
{
cancellationSource.Cancel();
return(new AndElement(Enumerable.Empty <RuleElement>()));
});
var rule3 = CreateRuleDefinitionMock();
var rules = new RuleSet("R1");
rules.Add(new[] { rule1.Object, rule2.Object, rule3.Object });
var ruleRepository = new RuleRepository();
ruleRepository.Add(rules);
// Act
ruleRepository.Compile(cancellationSource.Token);
// Assert
rule1.Verify(r => r.LeftHandSide, Times.AtLeastOnce);
rule2.Verify(r => r.LeftHandSide, Times.AtLeastOnce);
rule3.Verify(r => r.LeftHandSide, Times.Never);
}
}
static void Main(string[] args)
{
//Load rules
var repository = new RuleRepository();
repository.Load(x => x.From(typeof(PreferredCustomerDiscountRule).Assembly));
//Compile rules
var factory = repository.Compile();
//Create a working session
var session = factory.CreateSession();
//Load domain model
var customer = new Customer("John Doe")
{
IsPreferred = true
};
var order1 = new Order(123456, customer, 2, 25.0);
var order2 = new Order(123457, customer, 1, 100.0);
Console.WriteLine($"Order1 price: {order1.Price}");
Console.WriteLine($"Order2 price: {order2.Price}");
//Insert facts into rules engine's memory
session.Insert(customer);
session.Insert(order1);
session.Insert(order2);
//Start match/resolve/act cycle
session.Fire();
Console.WriteLine($"Order1 price: {order1.Price}");
Console.WriteLine($"Order2 price: {order2.Price}");
}
/// <summary>
/// ازروی شناسه قانون غالب و شناسه گروه قانون , قانون را استخراج میکند
/// </summary>
/// <param name="ruleTmpId">شناسه قانون قالب</param>
/// <param name="ruleCategoryCode">شناسه گروه قانون</param>
public BRuleParameter(decimal ruleTmpId, decimal ruleCategoryCode)
{
IList <Rule> list = new RuleRepository(false).GetByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new Rule().TemplateId), ruleTmpId),
new CriteriaStruct(Utility.GetPropertyName(() => new Rule().Category), new RuleCategory()
{
ID = ruleCategoryCode
}));
if (list.Count == 1)
{
workingRule = list.First();
}
else if (list.Count == 0)
{
UIValidationExceptions exception = new UIValidationExceptions();
exception.Add(ExceptionResourceKeys.AssignParameterRuleIDInvalid, "پارامترهای ارسال شده معرف قانونی نمیباشد", ExceptionSrc);
throw exception;
}
else
{
UIValidationExceptions exception = new UIValidationExceptions();
exception.Add(ExceptionResourceKeys.AssignParameterRuleIDInvalid, "پارامترهای ارسال شده معرف بیش از یک قانون میباشد", ExceptionSrc);
throw exception;
}
}
public void Test_GetQueries_NullSecurableEntityType()
{
Role testSubject;
EntityType testSecurableEntityType;
AccessRule accessRule;
SecurableEntity securableEntityType;
ICollection <AccessRule> result;
IEntityRepository entityRepository = Factory.EntityRepository;
using (DatabaseContext.GetContext(true))
{
securableEntityType = Entity.Create <EntityType>( ).As <SecurableEntity>( );
securableEntityType.Save( );
accessRule = Entity.Create <AccessRule>( );
accessRule.AccessRuleEnabled = true;
accessRule.PermissionAccess.Add(Permissions.Read.Entity.As <Permission>( ));
accessRule.Save( );
testSubject = Entity.Create <Role>( );
testSubject.AllowAccess.Add(accessRule.As <AccessRule>( ));
testSubject.Save();
testSecurableEntityType = Entity.Create <EntityType>();
testSecurableEntityType.Save();
result = null;
Assert.That(() => result = new RuleRepository(entityRepository).GetAccessRules(testSubject.Id, Permissions.Read, null),
Throws.Nothing);
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(1));
Assert.That(result.First( ).Id, Is.EqualTo(accessRule.Id));
}
}
private static void Main(string[] args)
{
//Load rules
var repository = new RuleRepository();
repository.Load(x => x.From(Assembly.GetExecutingAssembly()));
//Compile rules
var factory = repository.Compile();
//Create a working session
var session = factory.CreateSession();
//Load domain model
var ToWinMarket = new Market("ToWin");
var Scoreboard = new Scoreboard();
//Insert facts into rules engine's memory
session.Insert(ToWinMarket);
session.Insert(Scoreboard);
//Start match/resolve/act cycle
//session.Update(ToWinMarket);
session.Fire();
foreach (Participant part in ToWinMarket.Participants)
{
Console.WriteLine(part.Description + " - " + part.isWinner);
}
Console.ReadLine();
}
static void Main(string[] args)
{
//Load rules
var repository = new RuleRepository();
repository.Load(x => x.From(typeof(PreferredCustomerDiscountRule).Assembly));
//Compile rules
var factory = repository.Compile();
//Create a working session
var session = factory.CreateSession();
//Load domain model
var customer = new Customer("John Doe")
{
IsPreferred = false
};
var order1 = new Order(123456, customer, 2, 25.0);
var order2 = new Order(123457, customer, 1, 100.0);
session.Insert(customer);
session.Insert(order1);
session.Insert(order2);
var fire = session.Fire();
Console.WriteLine(fire);
Console.Read();
}
protected override void InsertValidate(RuleTemplate obj)
{
GeneralValidation(obj);
UIValidationExceptions exception = new UIValidationExceptions();
RuleRepository ruleRepository = new RuleRepository();
//if (ruleRepository.GetCountByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => obj.Name), obj.Name)) > 0)
//if (ruleRepository.GetCountByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => new RuleTemplate().Name), obj.Name.ToLower())) > 0)
IList <RuleTemplate> NamequeryOnRule = NHSession.QueryOver <RuleTemplate>()
.Where(x => x.Name == obj.Name)
.List <RuleTemplate>();
if (NamequeryOnRule.Count > 0)
{
//if (54ll().Any(x => x.Name.ToUpper().Equals(obj.Name.ToUpper())))
exception.Add(ExceptionResourceKeys.BRuleCodeRepeated, "نام تكراري است", ExceptionSrc);
}
//if (GetAll().Any(x => x.IdentifierCode.Equals(obj.IdentifierCode)))
//if (ruleRepository.GetCountByCriteria(new CriteriaStruct(Utility.GetPropertyName(() => obj.IdentifierCode), obj.IdentifierCode)) > 0)
IList <RuleTemplate> CodequeryOnRule = NHSession.QueryOver <RuleTemplate>().Where(x => x.IdentifierCode == obj.IdentifierCode).List <RuleTemplate>();
if (CodequeryOnRule.Count > 0)
{
exception.Add(ExceptionResourceKeys.BRuleCodeRepeated, "كد تكراري است", ExceptionSrc);
}
if (exception.Count > 0)
{
throw exception;
}
}
public void TestScenario4()
{
//1 Arrange
// setup inputs
RuleRepository promotionDB = new RuleRepository();
var lstFestivalOffers = promotionDB.GetFestivalOffers();
ProductRepository productContext = new ProductRepository();
var products = productContext.Products;
/*
* Setup unitPrices
* Set Active Promotions
* 3 of A's for 130
* 2 of B's for 45
* C 80% off for 4
*
* Scenario
*
* 3 *A 130
* 5 * B 45 +45 + 1* 30
* 2 * C - 8
* Total = 258
*
*/
decimal expected = 258;
decimal actual = 0;//
//2 Act
// initialize cart
Cart cart = new Cart();
// addproducts
cart.AddProduct(products.First(p => p.SKU == "A"), 3);
cart.AddProduct(products.First(p => p.SKU == "B"), 5);
cart.AddProduct(products.First(p => p.SKU == "C"), 2);
cart.AddPromotions(lstFestivalOffers);
// setup promotions to cart
// need to introduce a way to handle promotions to Cart and robust Product handling mechanism
//checkout
cart.Checkout();
actual = cart.Total;
//3 Assert
Assert.AreEqual(actual, expected);
}
public IEnumerable <IRuleSet> GetRuleSets()
{
var rules = new RuleRepository().GetRules();
_ruleSet.Add(rules.Select(BuildRule).ToArray());
return(new [] { _ruleSet });
}
public RuleService(
RuleRepository ruleRepository,
ILogger logger,
IRulesRunner rulesRunner)
: base(ruleRepository, logger)
{
_rulesRunner = rulesRunner;
}
public DailyJob(AttendanceSystemContext context)
{
monthlyAllowanceRuleRepository = new MonthlyAllowanceRuleRepository(context);
offenseRepository = new OffenseRepository(context);
ruleRepository = new RuleRepository(context);
usersRepository = new ApplicationUserRepository(context);
workingDayRepository = new WorkingDayRepository(context);
}
protected void SetupRule <T>() where T : Rule
{
var repository = new RuleRepository();
repository.Load(x => x.NestedTypes().PrivateTypes().From(xx => xx.Type(typeof(T))));
Factory = repository.Compile();
}
public void Load_InvalidTypes_Throws()
{
//Arrange
RuleRepository target = CreateTarget();
//Act
//Assert
Assert.Throws <ArgumentException>(() => target.Load("Test", x => x.From(typeof(string))));
}
public void TestScenario1()
{
//1 Arrange
// setup inputs
RuleRepository promotionDB = new RuleRepository();
var lstActivePromotions = promotionDB.GetActiveRules();
ProductRepository productContext = new ProductRepository();
var products = productContext.Products;
/*
* Setup unitPrices
* Set Active Promotions
* 3 of A's for 130
* 2 of B's for 45
* C & D for 30
*
* Scenario
*
* 1 *A 50
* 1 * B 30
* 1 * C 20
* Total =100
*/
decimal expected = 100;
decimal actual = 0;//
//2 Act
// initialize cart
Cart cart = new Cart();
// addproducts
cart.AddProduct(products.First(p => p.SKU == "A"), 1);
cart.AddProduct(products.First(p => p.SKU == "B"), 1);
cart.AddProduct(products.First(p => p.SKU == "C"), 1);
cart.AddPromotions(lstActivePromotions);
// setup promotions to cart
// need to introduce a way to handle promotions to Cart and robust Product handling mechanism
//checkout
cart.Checkout();
actual = cart.Total;
//3 Assert
Assert.AreEqual(actual, expected);
}
private static IServiceCollection RegisterRepository(this IServiceCollection services, Action <RuleRepository> initAction)
{
var ruleRepo = new RuleRepository();
initAction(ruleRepo);
services.AddSingleton(ruleRepo);
return(services);
}
public void ResetRepositories()
{
_quizRepository = null;
_ruleRepository = null;
_stageRepository = null;
_questionRepository = null;
_endingRepository = null;
_fileRepository = null;
}
private static void RunNrules()
{
//Load rules
RuleRepository repository = new RuleRepository();
repository.Load(x => x.From(typeof(DiscountRule).Assembly));
//Compile rules
RuleCompiler compiler = new RuleCompiler();
var sessionFactory = compiler.Compile(repository.GetRuleSets());
//Create a working session
var session = sessionFactory.CreateSession();
//Load domain model
var customer = new Customer("John Doe")
{
IsPreferred = true
};
var order1 = new Order(123456, customer, 2, 25.0);
var order2 = new Order(123457, customer, 1, 100.0);
//Insert facts into rules engine's memory
//session.Insert(customer);
//session.Insert(order1);
//session.Insert(order2);
//Start match/resolve/act cycle
var rulesExecuted = session.Fire();
Console.WriteLine("Rules executed: {0}", rulesExecuted.ToString());
//Insert facts into rules engine's memory
session.InsertAll(new List <object> {
customer, order2, order1
});
var customer2 = new Customer("Test customer")
{
IsPreferred = true
};
//var order3 = new Order(1234, customer2, 2, 25.0);
//Insert facts into rules engine's memory
session.InsertAll(new List <object> {
customer2
});
rulesExecuted = session.Fire();
Console.WriteLine("Rules executed: {0}", rulesExecuted.ToString());
rulesExecuted = session.Fire();
Console.WriteLine("Rules executed: {0}", rulesExecuted.ToString());
}
public void Load_CannotActivateRule_Throws()
{
//Arrange
RuleRepository target = CreateTarget();
//Act - Assert
var ex = Assert.Throws <RuleActivationException>(() => target.Load(x => x.From(typeof(CannotActivateRule))));
Assert.AreEqual(typeof(CannotActivateRule), ex.RuleType);
}
