private void ReloadEverything() { // Set the caption string caption = "Transliterator Editor "; if (sourceLanguage != null) { caption += sourceLanguage.Code; } if (destinationLanguage != null) { caption += " -> " + destinationLanguage.Code; } Title = caption; // Load rules rules = new RuleCollection(repository); dataGridRules.ItemsSource = rules; transliterator = new Transliterator(repository, sourceLanguage.Code, destinationLanguage.Code); TransliterationExample.Transliterator = (s => transliterator.Transliterate(s, false)); TransliterationExample.Trans_li_te_rator = (s => transliterator.Transliterate(s, true)); rules.MyTransliterator = transliterator; // Load TransliterationExamples examplesCollection = new ExampleCollection(repository); dataGridExamples.ItemsSource = examplesCollection; TransliterationExample.DestinationFunc = Oggy.TransliterationEditor.WordDistance.CalculateDistance; TextBox_TextChanged(null, null); }
protected override RuleCollection ParseRules(IEnumerable <TransportRule> adTransportRules, RuleHealthMonitor ruleHealthMonitor) { RuleCollection ruleCollection = base.ParseRules(adTransportRules, ruleHealthMonitor); RuleCollection ruleCollection2 = new RuleCollection(ruleCollection.Name); foreach (Rule rule in ruleCollection) { PolicyTipRule policyTipRule = (PolicyTipRule)rule; foreach (Microsoft.Exchange.MessagingPolicies.Rules.Action action in policyTipRule.Actions) { if (action is SenderNotify) { if (policyTipRule.ForkConditions != null && policyTipRule.ForkConditions.Count > 0) { AndCondition andCondition = new AndCondition(); foreach (Condition item in policyTipRule.ForkConditions) { andCondition.SubConditions.Add(item); } andCondition.SubConditions.Add(policyTipRule.Condition); policyTipRule.Condition = andCondition; policyTipRule.ForkConditions = null; } ruleCollection2.Add(policyTipRule); break; } } } return(ruleCollection2); }
/// <summary> /// Initialize a new instance of <see cref="InfoDescriptor"/>. Exposed for testing purposes. /// </summary> /// <param name="Type"></param> /// <param name="name">The name of the <see cref="InfoDescriptor"/>.</param> /// <exception cref="ArgumentNullException"><paramref name="name"/> is null.</exception> /// <exception cref="ArgumentException"><paramref name="name"/> is a <see cref="string.Empty"/>.</exception> /// <exclude/> protected InfoDescriptor(Type runtimeType, string name) { Guard.ArgumentNotNullOrEmptyString(name, "name"); RuntimeType = runtimeType; Name = name; Rules = new RuleCollection(this); }
internal static bool IsPolicyTipsEnabled(OrganizationId organizationId) { if (organizationId == null) { ExTraceGlobals.UserContextCallTracer.TraceError(0L, "Find OrganizationConfig-PolicyTipRules was called with null OrganizationId."); return(false); } try { RuleCollection ruleCollection = ADUtils.GetPolicyTipRulesPerTenantSettings(organizationId).RuleCollection; return(ruleCollection != null && ruleCollection.Count > 0); } catch (ADTransientException arg) { ExTraceGlobals.UserContextCallTracer.TraceError <OrganizationId, ADTransientException>(0L, "Find OrganizationConfig-PolicyTipRules for {0} threw exception: {1}", organizationId, arg); } catch (DataValidationException arg2) { ExTraceGlobals.UserContextCallTracer.TraceError <OrganizationId, DataValidationException>(0L, "Find OrganizationConfig-PolicyTipRules for {0} threw exception: {1}", organizationId, arg2); } catch (DataSourceOperationException arg3) { ExTraceGlobals.UserContextCallTracer.TraceError <OrganizationId, DataSourceOperationException>(0L, "Find OrganizationConfig-PolicyTipRules for {0} threw exception: {1}", organizationId, arg3); } catch (TransientException arg4) { ExTraceGlobals.UserContextCallTracer.TraceError <OrganizationId, TransientException>(0L, "Find OrganizationConfig-PolicyTipRules for {0} threw exception: {1}", organizationId, arg4); } return(false); }
public void TestGetRuleByName() { RuleCollection rc = new RuleCollection((IRandom)m_Random.MockInstance); Rule rule1 = new Rule(); rule1.Name = "r"; rule1.Probability = 1.0; rc.Add(rule1); m_Random.ExpectAndReturn("NextDouble", 0.0); Assert.AreSame(rule1, rc.GetRuleByName("r")); Rule rule2 = new Rule(); rule2.Name = "r"; rule2.Probability = 1.0; rc.Add(rule2); m_Random.ExpectAndReturn("NextDouble", 0.2); Assert.AreSame(rule1, rc.GetRuleByName("r"), "rule 1 expected"); m_Random.ExpectAndReturn("NextDouble", 0.6); Assert.AreSame(rule2, rc.GetRuleByName("r"), "rule 2 expected"); m_Random.Verify(); }
private static ReduceAction CreateReduceAction(ActionSubRecord record, SymbolCollection symbols, RuleCollection rules) { SymbolTerminal symbol = symbols[record.SymbolIndex] as SymbolTerminal; Rule rule = rules[record.Target]; return new ReduceAction(symbol, rule); }
/// <summary> /// Creates a new action by specifying the needed information. /// </summary> /// <param name="record">A part of the LALR record from the file content.</param> /// <param name="states">The LALR states.</param> /// <param name="symbols">The symbols.</param> /// <param name="rules">The rules.</param> /// <returns>A new action object.</returns> public static Action CreateAction(ActionSubRecord record, StateCollection states, SymbolCollection symbols, RuleCollection rules) { Action action; switch (record.Action) { case 1: action = CreateShiftAction(record, symbols, states); break; case 2: action = CreateReduceAction(record, symbols, rules); break; case 3: action = CreateGotoAction(record, symbols, states); break; case 4: action = CreateAcceptAction(record, symbols); break; default: return(null); //todo: make exception } return(action); }
public WorldEditor() { m_rootRoom = new Room_2D(DEFAULT_WIDTH, DEFAULT_HEIGHT); m_liveRules = new RuleCollection(); m_deathRules = new RuleCollection(); m_rebornRules = new RuleCollection(); }
public ActionResult CreateRule(policyData vData, int linkId) { vData.PolicyLink = new PolicyLinkEntity(linkId); vData.Policy = vData.PolicyLink.Policy; vData.Rule = new RuleEntity(); vData.Rule.Policy = vData.Policy; vData.Rule.Condition.Type = constants.conditionType; vData.Condition = vData.Rule.Condition; vData.Condition.CombineAnd = true; RuleCollection maxColl = new RuleCollection(); PredicateExpression pe = new PredicateExpression(RuleFields.PolicyId == vData.PolicyLink.PolicyId); object maxObj = maxColl.GetScalar(RuleFieldIndex.Order, null, AggregateFunction.Max, pe); if (maxObj != null && maxObj != DBNull.Value) { vData.Rule.Order = (int)maxObj + 1; } else { vData.Rule.Order = 0; } EffectCollection ecoll = new EffectCollection(); ecoll.GetMulti((EffectFields.Name == "permit")); vData.Rule.EffectId = ecoll[0].Id; vData.Rule.Save(true); return(RedirectToAction("EditRule", new { id = vData.Rule.Id, linkId = linkId })); }
public override void Apply(Cart cart) { cart.Total = 0; var distinctProducts = cart.Items.Select(x => x.ItemCode).Distinct().ToList(); foreach (var productCode in distinctProducts) { var productRule = RuleCollection.Where(x => x.ProductCode == productCode).FirstOrDefault(); var productPrice = cart.Items.Where(x => x.ItemCode == productCode) .Select(x => x.Price).First(); var productListCount = cart.Items.Where(x => x.ItemCode == productCode).Count(); if (productRule != null) { var groupOfferCount = productListCount / productRule.Quantity; var remainingCount = productListCount % productRule.Quantity; cart.Total += groupOfferCount * productRule.Amount; cart.Total += remainingCount * productPrice; } else { cart.Total += productPrice * productListCount; } } }
public void RegisterScripts() { _validator.ControlToValidate = "txtClientName"; const string propertyName = "ClientName"; _validator.PropertyName = propertyName; Type bookingType = typeof(Booking); _validator.ModelType = bookingType.AssemblyQualifiedName; ValidationAttribute[] attributes = new ValidationAttribute[] { new RequiredAttribute() }; _mockValidationRunner.Setup( runner => runner.GetValidators(bookingType, propertyName)).Returns( attributes).Verifiable(); RuleCollection rules = new RuleCollection(new List <Rule> { new Rule { Name = "required", Options = true } }); _mockRuleProvider.Setup(provider => provider.GetRules(attributes)).Returns( rules).Verifiable(); _mockScriptManager.Setup(manager => manager.RegisterScripts(rules)).Verifiable(); _validator.RegisterScripts(); _mockRuleProvider.Verify(); _mockValidationRunner.Verify(); _mockScriptManager.Verify(); }
public GridViewer() { InitializeComponent(); gridMap = new Map(); rules = new RuleCollection(); gridController = new GameController(gridMap, rules); }
/// <summary> /// Deletes all Inbox rules named MoveInterestingToJunk. Deletion to the Inbox rules /// collection can be batched into a single EWS call. /// </summary> /// <param name="service">An ExchangeService object with credentials and the EWS URL.</param> static void DeleteInboxRule(ExchangeService service) { // Get all the Inbox rules in the user's mailbox. This results in a GetInboxRules operation // call to EWS. RuleCollection ruleCollection = service.GetInboxRules(); Console.WriteLine("Returned your inbox rules from Exchange..."); // Inbox rule updates, including deletions, can be batched into a single call to EWS. Collection <RuleOperation> ruleOperations = new Collection <RuleOperation>(); foreach (Rule rule in ruleCollection) { if (rule.DisplayName == "MoveInterestingToJunk") { Console.WriteLine("Found an Inbox rule to delete..."); DeleteRuleOperation deleteRule = new DeleteRuleOperation(rule.Id); // Add each rule to deletion into a RuleOperation collection. Update operations // can also be added to batch up changes to Inbox rules. ruleOperations.Add(deleteRule); Console.WriteLine("Added the Inbox rule to the collection of rules to update..."); } } // The inbox rules are deleted here. This results in an UpdateInboxrules operaion call to EWS. service.UpdateInboxRules(ruleOperations, true); Console.WriteLine("Deleted Inbox rule(s)..."); }
private void RuleRibbonToggleButton_PressedButtonChanged(object sender, EventArgs e) { if (!(sender is RibbonToggleButton pressedRule)) { return; } string ruleName = pressedRule.Text; bool pressed = pressedRule.Pressed; IRule newRule = _rules.Where(x => x.Name == ruleName).FirstOrDefault(); newRule.AppliesTo.Add(new FieldRange(new string[] { "Product", "Country", "Color", "Discount" })); RuleCollection appliedRules = _rulesManager.Rules; IRule existingRule = appliedRules.Where(x => x.Name == ruleName).FirstOrDefault(); if (!pressed && appliedRules.Contains(existingRule)) { appliedRules.Remove(existingRule); } if (pressed && existingRule is null) { appliedRules.Add(newRule); } }
private void AddExamples_Click(object sender, RoutedEventArgs e) { RuleCollection rules = (RuleCollection)(dataGridRules.ItemsSource); List <string> words = new List <string>(); foreach (var rule in rules) { if (rule.Examples != null) { words.AddRange(rule.Examples.Split(new char[] { ' ', ',', ';' }, StringSplitOptions.RemoveEmptyEntries)); } if (rule.CounterExamples != null) { words.AddRange(rule.CounterExamples.Split(new char[] { ' ', ',', ';' }, StringSplitOptions.RemoveEmptyEntries)); } } ExampleCollection examples = (ExampleCollection)(dataGridExamples.ItemsSource); var wordsInExamples = examples.Select(example => example.Source); // Show the dialog var addExamplesWindow = new AddExamples(words.Distinct().Except(wordsInExamples), examples); addExamplesWindow.ShowDialog(); }
protected override RuleCollection <Item> ConfigureRules(RuleCollection <Item> ruleCollection) { return(ruleCollection .AddRule(e => e.Id, new RequiredRule()) .AddRule(e => e.Text, new RequiredRule()) .AddRule(e => e.Description, new MaxLengthRule(20))); }
internal WorldMap(Room_2D room, RuleCollection deathRules, RuleCollection rebornRules, RuleCollection liveRules) { m_room = room; m_deathRules = deathRules; m_rebornRules = rebornRules; m_liveRules = liveRules; m_worldViews = new LinkedList <WorldView>(); }
public void RuleConstructorTest() { Dictionary <char, string> jokers = new Dictionary <char, string>(); RuleCollection collection = new RuleCollection(); collection.Add(new Rule("ate", "ejt", jokers, collection)); }
protected override RuleCollection <Address> ConfigureRules(RuleCollection <Address> ruleCollection) { return(ruleCollection .AddRule(e => e.City, new RequiredRule()) .AddRule(e => e.CountryIsoCode, new CountryIsoCodeRule()) .AddRule(e => e.PostalCode, new PostalCodeRule()) .AddRule(e => e.StreetAddress, new RequiredRule(), new MaxLengthRule(100))); }
/// <summary> /// Populates the Rules ListView object with the provided RuleCollection object /// </summary> /// <param name="collection">RuleCollection to be processed into the Rules ListView object</param> private void PopulateRulesList(RuleCollection collection) { LVRulesList.Items.Clear(); foreach (RuleRef r in collection.Rules) { LVRulesList.Items.Add(r.Title); } }
private static ReduceAction CreateReduceAction(ActionSubRecord record, SymbolCollection symbols, RuleCollection rules) { SymbolTerminal symbol = symbols[record.SymbolIndex] as SymbolTerminal; Rule rule = rules[record.Target]; return(new ReduceAction(symbol, rule)); }
private void RulesReferencer_Load(object sender, EventArgs e) { //fill the rule collection fullRuleset = new RuleCollection(@"DND5ERulesList.xml"); //populate the controls PopulateRulesList(fullRuleset); }
//gavdcodeend 20 //gavdcodebegin 21 static void GetInboxRules(ExchangeService ExService) { RuleCollection allRules = ExService.GetInboxRules("*****@*****.**"); foreach (Rule oneRule in allRules) { Console.WriteLine(oneRule.DisplayName + " - " + oneRule.Id); } }
public void ExecuteViaUnity() { UnityContainer container = new UnityContainer(); container.RegisterType<IEngine<string>,Engine<string>>(); IRuleCollection<string> coll = new RuleCollection<string>(); container.RegisterInstance(coll); var engine = container.Resolve<IEngine<string>>(); Assert.IsNotNull(engine); }
/// <summary> /// /// </summary> public LanguageDefinition() { File.WriteAllText(FileDefinitionPath.DestPath + "HtmlTransform.xslt", Resources.HtmlTransform); File.WriteAllText(FileDefinitionPath.DestPath + "langageDefinition.xml", Resources.langageDefinition); File.WriteAllText(FileDefinitionPath.DestPath + "RtfTransform.xslt", Resources.RtfTransform); File.WriteAllText(FileDefinitionPath.DestPath + "StructureDefinitionLangage.xml", Resources.StructureDefinitionLangage); File.WriteAllText(FileDefinitionPath.DestPath + "StructureFichierXML.xml", Resources.StructureFichierXML); File.WriteAllText(FileDefinitionPath.DestPath + "Style.css", Resources.Style); rules = new RuleCollection(); }
// Token: 0x06001A26 RID: 6694 RVA: 0x0005F260 File Offset: 0x0005D460 internal static string GetRuleNamesForTracking(RuleCollection ruleCollection) { StringBuilder stringBuilder = new StringBuilder(); foreach (Rule rule in ruleCollection) { stringBuilder.Append(rule.Name); stringBuilder.Append(","); } return(stringBuilder.ToString()); }
public async Task InsertRules(List <RuleModel> rules, string connectionString) { string parameterName = "rules"; RuleCollection ruleCollection = new RuleCollection(); foreach (var rule in rules) { ruleCollection.Add(rule); } await _db.InsertWithUDT("dbo.spInsertRules", parameterName, ruleCollection, connectionString); }
private void OK_Click(object sender, RoutedEventArgs e) { RuleCollection newRules = (RuleCollection)(dataGridExamples.ItemsSource); foreach (var rule in newRules) { oldRules.Add(rule); } this.DialogResult = true; this.Close(); }
// Token: 0x06001A24 RID: 6692 RVA: 0x0005F09C File Offset: 0x0005D29C internal static ExecutionStatus RunRules(RuleCollection rules, ScanResultStorageProvider scanResultStorageProvider, Item storeItem, string fromAddress, ShortList <string> recipients, out List <DlpPolicyMatchDetail> dlpPolicyMatchDetails, out bool noContentMatch, out string ruleEvalLatency, out string ruleEvalResult, PolicyTipRequestLogger policyTipRequestLogger) { OwaRulesEvaluationContext owaRulesEvaluationContext = new OwaRulesEvaluationContext(rules, scanResultStorageProvider, storeItem, fromAddress, recipients, policyTipRequestLogger); OwaRulesEvaluator owaRulesEvaluator = new OwaRulesEvaluator(owaRulesEvaluationContext); owaRulesEvaluator.Run(); dlpPolicyMatchDetails = owaRulesEvaluationContext.DlpPolicyMatchDetails; noContentMatch = owaRulesEvaluationContext.NoContentMatch; ruleEvalLatency = owaRulesEvaluationContext.RuleEvalLatency; ruleEvalResult = owaRulesEvaluationContext.RuleEvalLResult; return(owaRulesEvaluationContext.ExecutionStatus); }
/// <summary> /// Searches through the full rules collection for any Rule objects which contain the search term in their title or their text. /// </summary> /// <param name="searchTerm"></param> private void SearchRules(string searchTerm) { searchedRuleset = new RuleCollection(); foreach (RuleRef r in fullRuleset) { if (r.Title.ToUpper().Contains(searchTerm.ToUpper()) || r.Details.ToUpper().Contains(searchTerm.ToUpper())) { searchedRuleset.Add(r); } } PopulateRulesList(searchedRuleset); }
public void ThereCanOnlybeOneInstanceOfARuleInACollection() { RuleCollection ruleList = new RuleCollection(); SingleRule testRule = new SingleRule(7, SpawnOrSurviveRule.SpawnRule); SingleRule testRule2 = new SingleRule(7, SpawnOrSurviveRule.SpawnRule); ruleList.Add(testRule); ruleList.Add(testRule2); Assert.AreEqual(1, ruleList.Count); }
public void ExecuteViaUnity() { UnityContainer container = new UnityContainer(); container.RegisterType <IEngine <string>, Engine <string> >(); container.RegisterType <IResultsFormatter, NoopFormatter>(); IRuleCollection <string> coll = new RuleCollection <string>(); container.RegisterInstance(coll); var engine = container.Resolve <IEngine <string> >(); Assert.IsNotNull(engine); }
public ClientAccessRulesEvaluationContext(RuleCollection rules, string username, IPEndPoint remoteEndpoint, ClientAccessProtocol protocol, ClientAccessAuthenticationMethod authenticationType, IReadOnlyPropertyBag userPropertyBag, ObjectSchema userSchema, Action <ClientAccessRulesEvaluationContext> denyAccessDelegate, Action <Rule, ClientAccessRulesAction> whatIfActionDelegate, long traceId) : base(rules) { this.AuthenticationType = authenticationType; this.UserName = username; this.RemoteEndpoint = remoteEndpoint; this.Protocol = protocol; this.User = userPropertyBag; this.UserSchema = userSchema; this.DenyAccessDelegate = denyAccessDelegate; this.WhatIfActionDelegate = whatIfActionDelegate; this.WhatIf = (whatIfActionDelegate != null); base.Tracer = new ClientAccessRulesTracer(traceId); }
/// <summary> /// Creates a new action by specifying the needed information. /// </summary> /// <param name="record">A part of the LALR record from the file content.</param> /// <param name="states">The LALR states.</param> /// <param name="symbols">The symbols.</param> /// <param name="rules">The rules.</param> /// <returns>A new action object.</returns> public static Action CreateAction(ActionSubRecord record, StateCollection states, SymbolCollection symbols, RuleCollection rules) { Action action; switch (record.Action) { case 1: action = CreateShiftAction(record,symbols,states); break; case 2: action = CreateReduceAction(record,symbols,rules); break; case 3: action = CreateGotoAction(record,symbols,states); break; case 4: action = CreateAcceptAction(record,symbols); break; default: return null; //todo: make exception } return action; }
/// <summary> /// The evaluation implementation in the pseudo-code described in the specification. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="rules">The policies that must be evaluated.</param> /// <returns>The final decission for the combination of the rule evaluation.</returns> public Decision Evaluate( EvaluationContext context, RuleCollection rules ) { Decision decision = Decision.Indeterminate; context.Trace( "Evaluating rules..." ); context.AddIndent(); try { foreach( Rule rule in rules ) { decision = rule.Evaluate( context ); context.TraceContextValues(); if( decision == Decision.Deny ) { decision = Decision.Deny; return decision; } if( decision == Decision.Permit ) { decision = Decision.Permit; return decision; } if( decision == Decision.NotApplicable ) { continue; } if( decision == Decision.Indeterminate ) { decision = Decision.Indeterminate; return decision; } } return Decision.NotApplicable; } finally { context.Trace( "Rule combination algorithm: {0}", decision.ToString() ); context.RemoveIndent(); } }
public Project(ProjectNode root) { m_Random = root.Serializer.Random; m_Rules = new RuleCollection(m_Random); foreach (IProjectNode node in root.Children) { switch (node.NodeType) { case ProjectNodeType.TokenSetDeclaration: this.TokenSets.Add(new TokenSet(node, m_Random)); break; case ProjectNodeType.RuleDeclaration: this.Rules.Add(new Rule(node as RuleNode)); break; case ProjectNodeType.StartingRuleDeclaration: StartingRuleNode srn = node as StartingRuleNode; this.StartRules.Add(srn.Name, srn.Amount); break; case ProjectNodeType.ColumnDeclaration: ColumnNode cn = node as ColumnNode; this.Columns.Add(cn.Title, cn.Expression); break; default: break; } } foreach (Rule r in this.Rules) { foreach (Whee.WordBuilder.Model.Commands.CommandBase c in r.Commands) { c.CheckSanity(this, root.Serializer); } } }
public void InitializeNodes() { LSystem ls = new LSystem(); RuleCollection rc = new RuleCollection(); rc.GenerateRules(); Debug.Log("Size = " + rc.GetCollection().Count); int selectedIndex = Random.Range(0, rc.GetCollection().Count); LRule r = (LRule)rc.GetCollection()[selectedIndex]; ls.axiom = r.axiom; ls.delta = r.delta; // JUST GO THROUGH THE RANDOMLY SELECTED RULE, USE ITS COLLECTION IN THE EXPAND AND INTERPRET Debug.Log(r.name); ls.expand(r.expandingIterations, r.rules); ls.interpret(); }
public Project(IRandom random) { m_Random = random; m_Rules = new RuleCollection(m_Random); }
public ActionResult CreateRule(policyData vData, int linkId) { vData.PolicyLink = new PolicyLinkEntity(linkId); vData.Policy = vData.PolicyLink.Policy; vData.Rule = new RuleEntity(); vData.Rule.Policy = vData.Policy; vData.Rule.Condition.Type = constants.conditionType; vData.Condition = vData.Rule.Condition; vData.Condition.CombineAnd = true; RuleCollection maxColl = new RuleCollection(); PredicateExpression pe = new PredicateExpression(RuleFields.PolicyId == vData.PolicyLink.PolicyId); object maxObj = maxColl.GetScalar(RuleFieldIndex.Order, null, AggregateFunction.Max, pe); if (maxObj != null && maxObj != DBNull.Value) vData.Rule.Order = (int)maxObj + 1; else vData.Rule.Order = 0; EffectCollection ecoll = new EffectCollection(); ecoll.GetMulti((EffectFields.Name == "permit")); vData.Rule.EffectId = ecoll[0].Id; vData.Rule.Save(true); return RedirectToAction("EditRule", new { id = vData.Rule.Id, linkId = linkId }); }
public ActionResult RuleOrder(policyData vData, int id, int linkId, FormCollection collection) { RuleEntity rule = new RuleEntity(id); RuleCollection coll = new RuleCollection(); PredicateExpression pe = new PredicateExpression(RuleFields.Id != rule.Id); pe.Add(RuleFields.PolicyId == rule.PolicyId); SortExpression se = null; if (collection["up"] != null) { // Find all categories with display index less than ours. pe.Add(RuleFields.Order <= rule.Order); // Order by display index, highest first. se = new SortExpression(RuleFields.Order | SortOperator.Descending); } else { // Find all categories with display index greater than ours. pe.Add(RuleFields.Order >= rule.Order); // Order by display index, lowest first. se = new SortExpression(RuleFields.Order | SortOperator.Ascending); } // Swap with closest one. if (coll.GetMulti(pe, 1, se) && coll.Count > 0) { int temp = coll[0].Order; coll[0].Order = rule.Order; rule.Order = temp; rule.Save(); coll.SaveMulti(); } return RedirectToAction("EditPolicy", new { id = linkId }); }
/// <summary> /// The evaluation implementation in the pseudo-code described in the specification. /// </summary> /// <param name="context">The evaluation context instance.</param> /// <param name="rules">The policies that must be evaluated.</param> /// <returns>The final decission for the combination of the rule evaluation.</returns> public Decision Evaluate(EvaluationContext context, RuleCollection rules) { if (context == null) throw new ArgumentNullException("context"); if (rules == null) throw new ArgumentNullException("rules"); var decision = Decision.Indeterminate; bool atLeastOneError = false; bool potentialPermit = false; bool atLeastOneDeny = false; context.Trace("Evaluating rules..."); context.AddIndent(); try { foreach (Rule rule in rules) { decision = rule.Evaluate(context); context.TraceContextValues(); if (decision == Decision.Deny) { atLeastOneDeny = true; continue; } if (decision == Decision.Permit) { decision = Decision.Permit; return decision; } if (decision == Decision.NotApplicable) { continue; } if (decision == Decision.Indeterminate) { atLeastOneError = true; if (rule.RuleDefinition.Effect == Effect.Permit) { potentialPermit = true; } continue; } } if (potentialPermit) { decision = Decision.Indeterminate; return decision; } if (atLeastOneDeny) { decision = Decision.Deny; return decision; } if (atLeastOneError) { decision = Decision.Indeterminate; return decision; } decision = Decision.NotApplicable; return decision; } finally { context.Trace("Rule combination algorithm: {0}", decision.ToString()); context.RemoveIndent(); } }
/// <summary> /// Initializes a new instance of the <see cref="GetInboxRulesResponse"/> class. /// </summary> internal GetInboxRulesResponse() : base() { this.ruleCollection = new RuleCollection(); }