public TextRule ReadScoringRule(XmlNode nodeRepresentation)
{
TextPredicate criteria = null;
double score = 0;
foreach (XmlNode child in nodeRepresentation.ChildNodes)
{
if (child.Name == ScoringRulePredicate_Tag)
{
foreach (XmlNode grandchild in child.ChildNodes)
{
criteria = this.ReadTextPredicate(grandchild);
continue;
}
}
if (child.Name == this.ScoreTag)
{
score = this.ReadDouble(child);
continue;
}
}
TextRule rule = new TextRule(criteria, score);
return(rule);
}
public UserPreferences_Database ParseUserPreferences(string text)
{
UserPreferences_Database db = new UserPreferences_Database();
IEnumerable <XmlNode> nodes = this.ParseToXmlNodes(text);
List <string> feedUrls = new List <string>();
List <TextRule> scoringRules = new List <TextRule>();
foreach (XmlNode node in nodes)
{
if (node.Name == this.FeedTag)
{
foreach (XmlNode child in node.ChildNodes)
{
if (child.Name == this.FeedUrl_Tag)
{
string url = this.ReadText(child);
feedUrls.Add(url);
}
}
}
if (node.Name == this.ScoringRule_Tag)
{
TextRule rule = this.ReadScoringRule(node);
scoringRules.Add(rule);
}
}
db.FeedUrls = feedUrls;
db.ScoringRules = scoringRules;
return(db);
}
public string ConvertToString(TextRule rule)
{
Dictionary <string, string> properties = new Dictionary <string, string>();
properties[this.ScoreTag] = this.ConvertToStringBody(rule.ScoreIfMatches);
properties[this.ScoringRulePredicate_Tag] = this.ConvertToString(rule.Criteria);
return(this.ConvertToString(properties, this.ScoringRule_Tag));
}
public void OnBack(LayoutChoice_Set layout)
{
if (layout == this.newRule_layout)
{
TextRule rule = this.newRule_layout.GetRule();
if (rule != null)
{
this.newRule_layout.Clear();
this.userPreferencesDatabase.AddScoringRule(rule);
this.viewLayout.UpdateLayout();
}
}
}
public RuleViewModelBase AddTextRule()
{
var textRule = new TextRule()
{
Name = nameof(TextRule)
};
_model.Rules.Add(textRule);
var vm = _rulesFactory.Create(textRule, this);
_rules.Add(vm);
vm.Focus();
return(vm);
}
public TextRule GetRule()
{
TextPredicate predicate = this.getPredicate();
if (predicate == null)
{
return(null);
}
double score = this.getScore();
if (score == 0)
{
return(null);
}
this.openPredicates.Clear();
this.newWord_box.Text = "";
this.scoreBox.Text = "";
TextRule rule = new TextRule(predicate, score);
return(rule);
}
public TextRuleViewModel(TextRule rule)
: base(rule)
{
_rule = rule;
RefreshName();
}
public void AddScoringRule(TextRule rule)
{
this.rules.Add(rule);
}
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);
}
);
}