private void RendererBox_SelectedIndexChanged(object sender, EventArgs e)
{
_selectedItem = RendererBox.SelectedItem as RuleItem;
btnRemove.Enabled = btnUp.Enabled = btnDown.Enabled = btnProperties.Enabled =
_selectedItem != null;
}
/// <summary>
/// Maps a <see cref="LoggingRule" /> entity to a <see cref="RuleResult" /> domain object.
/// </summary>
/// <param name="rule">The rule entity to map to a domain object.</param>
/// <returns>
/// The <see cref="RuleResult" /> domain object.
/// </returns>
public static RuleItem ToRuleItem(LoggingRule rule)
{
Debug.Assert(rule != null, "The rule cannot be null.");
var result = new RuleItem {
Id = rule.Id
};
var options = LoggingRuleOptionsHelpers.Deserialize(rule.Options);
if (options.Conditions != null)
{
foreach (var condition in options.Conditions)
{
result.Conditions.Add(condition);
}
}
if (options.Actions != null)
{
foreach (var action in options.Actions)
{
result.Actions.Add(action);
}
}
return(result);
}
public void MainMorph()
{
var item = new RuleItem();
item.Type = RuleItemType.Morphology;
item.Key = "ед";
check(item, new Dictionary <Token, bool>()
{
{ new Token("тест")
{
Morphs = new []
{
new MorphInfo("тест",
new ReadOnlyDictionary <string, string>(
new Dictionary <string, string>()
{
{ "число", "ед" }
})),
}
}, true },
{ new Token("тесты")
{
Morphs = new []
{
new MorphInfo("тест",
new ReadOnlyDictionary <string, string>(
new Dictionary <string, string>()
{
{ "число", "мн" }
})),
}
}, false },
{ new Token("мост"), false }
});
}
/// <summary>
/// Inserts a rule.
/// </summary>
/// <param name="rule">The rule to insert.</param>
/// <param name="user">The user who owns the rule.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual async Task <ValidationResult> CreateAsync(RuleItem rule, AccountItem user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (rule == null)
{
throw new ArgumentNullException("rule");
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var ruleEntity = new LoggingRule
{
UserId = user.Id,
Options = LoggingRuleOptionsHelpers.Serialize(new LoggingRuleOptions {
Conditions = rule.Conditions, Actions = rule.Actions
})
};
Context.Add(ruleEntity);
await SaveChangesAsync(cancellationToken);
rule.Id = ruleEntity.Id;
return(ValidationResult.Success);
}
private void ShowHideLegend(RuleItem item)
{
if (_renderer == null)
{
return;
}
int index = RendererBox.Items.IndexOf(item);
if (index == -1)
{
return;
}
if (!item.ShowLegend)
{
for (int i = index + 1; i < RendererBox.Items.Count; i++)
{
if (RendererBox.Items[i] is RuleItem)
{
break;
}
RendererBox.Items.RemoveAt(i);
i--;
}
}
else if (item.LegendItem != null)
{
RendererBox.Items.Insert(index + 1, new LegendItem(item.LegendItem));
}
}
private void Show(bool state)
{
if (state)
{
_ruleInfoPanel.SetActive(true);
if (_isNeedClose)
{
_showBtn.SetActive(false);
}
int height = 0;
for (int i = 0, lenth = _rulesParent.transform.childCount; i < lenth; i++)
{
RuleItem ruleItem = _rulesParent.transform.GetChild(i).GetComponent <RuleItem>();
ruleItem.transform.localPosition = new Vector3(0, height);
height -= (ruleItem.ItemHeight + _cellHeight);
}
iTween.MoveTo(_ruleInfoPanel.gameObject, _toPos.position, _moveTime);
}
else
{
iTween.MoveTo(_ruleInfoPanel.gameObject, _fromPos.position, _moveTime);
float showBtnTime = _moveTime - _showPlayBtnTime;
if (showBtnTime <= 0)
{
showBtnTime = 0;
}
Invoke("OnBackFinished", showBtnTime);
}
}
private static IEnumerable <RuleItem> FindUpRule(RuleList ruleList, RuleItem emptyItem, ref List <Used> usedRules)
{
var lead = new HashSet <RuleItem>();
foreach (var rule in ruleList.Rules)
{
var item = rule.Items.Where(x => x.Value == emptyItem.Value).ToList();
if (item.Count != 0)
{
foreach (var index in item.Select(t => rule.Items.IndexOf(t)))
{
if (!usedRules.Contains(new Used(rule, index)))
{
if (index == rule.Items.Count - 1)
{
usedRules.Add(new Used(rule, index));
var newEmptyItem = new RuleItem(rule.NonTerminal, false);
lead.UnionWith(FindUpRule(ruleList, newEmptyItem, ref usedRules));
}
else
{
lead.Add(rule.Items[index + 1]);
}
}
}
}
}
return(lead);
}
public async Task <SaveRuleItemResponse> SaveRuleItem([FromBody] SaveRuleItemRequest request)
{
var response = new SaveRuleItemResponse();
try
{
var ruleItem = new RuleItem
{
Id = request.Id,
RuleId = request.RuleId,
RuleItemType = request.RuleItemType,
ComputeType = request.ComputeType,
Value = request.Value,
Enabled = request.Enabled,
Desciption = request.Desciption
};
await _ruleRepository.SaveRuleItem(ruleItem);
response.Success = true;
}
catch (Exception e)
{
response.Message = e.Message;
_logger.LogError($"SaveRuleItem 出现异常：{e.Message}", e);
}
return(response);
}
public void Ready(RuleItem option)
{
tag = option.Param1.Trim();
var v = option.Param2.Trim().ToUpper();
tagFunc = v != "0" && v != "F" && v != "N" && v != "FALSE" ? "html" : "text";
SplitTag(ref tag, ref tagFunc);
}
public async Task <IActionResult> Index()
{
//SettingsModel settings;
MongoClient _client;
IMongoDatabase _db;
_client = new MongoClient("mongodb://localhost:27017");
_db = _client.GetDatabase("Thermostat");
//var collection = _db.GetCollection<SettingsModel>("Settings");
//var emptyFilter = FilterDefinition<SettingsModel>.Empty;
////new FilterDefinitionBuilder<SettingsModel>().
//var result = await collection.FindAsync(emptyFilter);
//settings = result.FirstOrDefault();
//// TODO: this is a good candidate to move to startup?
//if (settings == null)
//{
// //create the settings
// settings = new SettingsModel();
// await collection.InsertOneAsync(settings);
//}
ViewData["Zones"] = Status.Instance.Zones;
//TODO: show multiple zones in the UI?
ViewData["HeatingStatus"] = _engine.Rules.Evaluate(channel: 0) ? "ON" : "OFF";
//TODO: this is not exactly the MVC way, we should be making a new POST action for this
if (Request.Method == "POST")
{
string newRule = Request.Form["SelectedRules"];
if (newRule != _engine.Rules.GetType().Name)
{
RuleItem rulesEngine = Status.Instance.Rules.Single(x => newRule == x.ClassName);
if (rulesEngine != null)
{
_engine.Enable(rulesEngine.ClassName);
Repository rep = new Repository();
var settings = rep.GetSettings();
settings.ActiveEngine = rulesEngine.ClassName;
rep.UpdateSettings(settings);
}
}
}
var rules = Status.Instance.Rules.Select(x => new SelectListItem {
Text = x.FriendlyName,
Value = x.ClassName,
Selected = _engine.Rules.GetType().Name == x.ClassName
});
ViewData["Rules"] = rules;
return(View());
}
/// <summary>
/// TODO 查詢規則編號，查詢詳細信息
/// </summary>
/// <param name="ruleNo"></param>
/// <returns></returns>
public CodeRule queryRuleById(string ruleNo)
{
CodeRule codeRule = null;
StringBuilder strSql = new StringBuilder();
strSql.Append("SELECT uuid,rule_no,rule_desc,op_user,create_time,update_user,update_time FROM t_rule_info where rule_no=@ruleNo AND del_flag is null");
MySqlParameter[] parameters =
{
new MySqlParameter("@ruleNo", MySqlDbType.VarChar, 900),
};
parameters[0].Value = ruleNo;
DataSet ds = SQLHelper.ExecuteDataset(SQLHelper.ConnectionString, CommandType.Text, strSql.ToString(), parameters);
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
codeRule = new CodeRule();
codeRule.Uuid = ds.Tables[0].Rows[0]["uuid"].ToString();
codeRule.Ruleno = ds.Tables[0].Rows[0]["rule_no"].ToString();
codeRule.RuleDesc = ds.Tables[0].Rows[0]["rule_desc"].ToString();
codeRule.Opuser = ds.Tables[0].Rows[0]["op_user"].ToString();
codeRule.Createtime = ds.Tables[0].Rows[0]["create_time"].ToString();
codeRule.UpdateUser = ds.Tables[0].Rows[0]["update_user"].ToString();
codeRule.Updatetime = ds.Tables[0].Rows[0]["update_time"].ToString();
}
if (codeRule != null)
{
List <RuleItem> ruleItems = null;
StringBuilder strSql1 = new StringBuilder();
strSql1.Append("SELECT uuid,rule_no,seq_no,rule_type,rule_value,rule_length,op_user,create_time,update_user,update_time FROM t_code_rule WHERE rule_no = @ruleNo AND del_flag is null ORDER BY seq_no ASC");
MySqlParameter[] parameters1 =
{
new MySqlParameter("@ruleNo", MySqlDbType.VarChar, 900),
};
parameters1[0].Value = ruleNo;
DataSet ds1 = SQLHelper.ExecuteDataset(SQLHelper.ConnectionString, CommandType.Text, strSql1.ToString(), parameters1);
if (ds1 != null && ds1.Tables.Count > 0 && ds1.Tables[0].Rows.Count > 0)
{
ruleItems = new List <RuleItem>();
foreach (DataRow dr in ds1.Tables[0].Rows)
{
RuleItem ruleItem = new RuleItem();
ruleItem.Uuid = dr["uuid"].ToString();
ruleItem.Ruleno = dr["rule_no"].ToString();
ruleItem.Seqno = dr["seq_no"].ToString();
ruleItem.Ruletype = dr["rule_type"].ToString();
ruleItem.Rulevalue = dr["rule_value"].ToString();
ruleItem.Rulelength = int.Parse(dr["rule_length"].ToString());
ruleItem.Opuser = dr["op_user"].ToString();
ruleItem.Createtime = dr["create_time"].ToString();
ruleItem.UpdateUser = dr["update_user"].ToString();
ruleItem.Updatetime = dr["update_time"].ToString();
ruleItems.Add(ruleItem);
}
}
codeRule.RuleItem = ruleItems;
}
return(codeRule);
}
/// <summary>
/// Returns with a <see cref="RuleResultDto" /> view of the <see cref="RuleItem" /> domain object.
/// </summary>
/// <param name="rule">The domain object to map to a data transfer object (DTO).</param>
/// <returns>
/// The <see cref="RuleResultDto" />.
/// </returns>
public static RuleResultDto ToRuleResultDto(RuleItem rule)
{
return(new RuleResultDto
{
Id = rule.Id,
Actions = rule.Actions,
Conditions = rule.Conditions
});
}
public void EnableRule(string order)
{
RuleItem rule = this.FindRuleByOrder(order);
if (rule != null)
{
rule.Enabled = "true";
}
}
private void _createRules(RuleItem item, out RuleItem resultItem, out IEnumerable <Rule> resultRules)
{
int?min = item.Counter == Counter.Number ? (int?)item.CounterValue.MinValue : null;
int?max = item.Counter == Counter.Number ? (int?)item.CounterValue.MaxValue : null;
var cacheKey = new Tuple <string, Counter, RuleItemType, int?, int?>(item.Key, item.Counter, item.Type, min, max);
if (_cache.ContainsKey(cacheKey))
{
resultItem = new RuleItem(RuleItemType.NonTerminal,
_cache[cacheKey],
conditions: item.Conditions,
localName: item.LocalName);
resultRules = null;
return;
}
string key = item.Type == RuleItemType.NonTerminal ? item.Key : $"TERMINAL_{_termId++}";
key = $"{key}_{_keyPrefix(item.Counter, min, max)}";
resultItem = new RuleItem(RuleItemType.NonTerminal,
key,
conditions: item.Conditions,
localName: item.LocalName);
item.LocalName = null;
switch (item.Counter)
{
case Counter.Star:
{
var starItem = new RuleItem(RuleItemType.NonTerminal,
key,
conditions: item.Conditions);
resultRules = new[]
{
new Rule(key, new [] { item, starItem }, isPossibleList: true),
new Rule(key, new RuleItem[0])
};
break;
}
case Counter.Plus:
{
var starTerm = new RuleItem(item.Type, item.Key, Counter.Star);
_createRules(starTerm, out var rezStarTerm, out var rezStarRules);
var list = new List <Rule>()
{
new Rule(key, new[] { item, rezStarTerm }, isPossibleList: true)
};
list.AddRange(rezStarRules);
resultRules = list;
break;
}
case Counter.Question:
{
resultRules = new[]
public void ModifyRule(string order, string type, string match)
{
RuleItem rule = this.FindRuleByOrder(order);
if (rule != null)
{
rule.Type = type;
rule.Match = match;
}
}
private void Add_Value_Click(object sender, RoutedEventArgs e)
{
Button bt = (Button)sender;
ParamValueItem valueItem = bt.DataContext as ParamValueItem;
RuleItem ruleItem = valueItem.parent;
int index = ruleItem.valuesOfParams.IndexOf(valueItem);
ruleItem.addValueOfParamByIndex("Пустое значение параметра", index + 1);
CollectionViewSource.GetDefaultView(ruleItem.valuesOfParams).Refresh();
}
private void btnEditRule_Click(object sender, RoutedEventArgs e)
{
RuleItem item = (rulesGrid.SelectedItem as RuleItem);
if (item == null)
{
return;
}
firewallPage.ShowRuleWindow(item.Rule);
}
public void WrongConditionArgArray()
{
Assert.Throws <WrongConditionArgsException>(() =>
{
var item = new RuleItem();
item.Type = RuleItemType.Terminal;
item.Key = "123";
item.AddCondition(new Condition("морф", false));
var rezCond = _manager.GetCondition(item);
});
}
public IRule?Render(RuleItem rule)
{
var instance = Render(rule.Name);
if (instance == null)
{
return(null);
}
instance.Ready(rule);
return(instance);
}
public IActionResult On(string applianceId, string accessToken)
{
RuleItem rulesEngine = Status.Instance.Rules.Single(x => applianceId == x.ClassName);
if (rulesEngine != null)
{
_engine.Enable(rulesEngine.ClassName);
}
return(Ok());
}
public void MainText()
{
var item = new RuleItem();
item.Type = RuleItemType.Terminal;
item.Key = "123";
check(item, new Dictionary <Token, bool>()
{
{ new Token("123"), true },
{ new Token("1234"), false }
});
}
public static List <HashSet <RuleItem> > FindLeads(RuleList ruleList)
{
var leads = new List <HashSet <RuleItem> >(ruleList.Rules.Count);
for (var i = 0; i < ruleList.Rules.Count; i++)
{
leads.Add(new HashSet <RuleItem>());
var rule = ruleList.Rules[i];
if (rule.Items[0].Value == Constants.EmptySymbol)
{
var emptyItem = new RuleItem(rule.NonTerminal, false);
var usedRules = new List <Used>();
var lead = FindUpRule(ruleList, emptyItem, ref usedRules).ToHashSet().ToList();
leads[i].UnionWith(lead);
usedRules.Clear();
}
else
{
leads[i].Add(rule.Items[0]);
}
}
while (true)
{
var somethingChanged = false;
foreach (var lead in leads)
{
var nonTerms = lead.Where(x => !x.IsTerminal).ToList();
if (nonTerms.Count > 0)
{
somethingChanged = true;
}
foreach (var nonTerm in nonTerms)
{
lead.Remove(nonTerm);
var rulesWithNonTerm = ruleList.Rules.Select((x, i) => (x, i))
.Where(x => x.x.NonTerminal == nonTerm.Value).Select(x => x.i).ToList();
foreach (var fVal in rulesWithNonTerm.SelectMany(rule => leads[rule]).ToList())
{
lead.Add(fVal);
}
}
}
if (!somethingChanged)
{
break;
}
}
return(leads);
}
public override void ExitRule_inline_expression(CfgGramParser.Rule_inline_expressionContext context)
{
IsInline = false;
var rule = Grammar.Rules.Last();
rule.Name = $"{RulesStack.Peek().Name}:{Guid.NewGuid()}";
rule.WasInline = true;
RuleItem = new RuleItem();
RuleItem.Type = RuleItemType.NonTerminal;
RuleItem.Key = rule.Name;
RuleItem.IsHead = InlineIsHead;
}
private void Delete_Value_Click(object sender, RoutedEventArgs e)
{
Button bt = (Button)sender;
ParamValueItem valueItem = bt.DataContext as ParamValueItem;
RuleItem ruleItem = valueItem.parent;
if (ruleItem.valuesOfParams.Count != 1)
{
ruleItem.removeValueOfParam(valueItem);
CollectionViewSource.GetDefaultView(ruleItem.valuesOfParams).Refresh();
}
}
private void Delete_Rule_Click(object sender, RoutedEventArgs e)
{
Button bt = (Button)sender;
RuleItem ruleItem = bt.DataContext as RuleItem;
if (ruleItems.Count != 1)
{
ruleItems.Remove(ruleItem);
refreshNumbersOfRules(ruleItems);
CollectionViewSource.GetDefaultView(ruleItems).Refresh();
}
}
public void MainRegex()
{
var item = new RuleItem();
item.Type = RuleItemType.Regex;
item.Key = @"123\d*";
check(item, new Dictionary <Token, bool>()
{
{ new Token("123"), true },
{ new Token("1234"), true },
{ new Token("123t"), false }
});
}
private bool Compute(RuleItem ruleItem, Fact fact)
{
#region 参数校验
if (ruleItem.IsNull())
{
throw new ArgumentNullException(nameof(ruleItem));
}
if (fact.IsNull())
{
throw new ArgumentNullException(nameof(fact));
}
if (ruleItem.ComputeType.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(ruleItem.ComputeType));
}
if (ruleItem.Value.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(ruleItem.Value));
}
#endregion
try
{
var ruleValue = ruleItem.Value.Trim().ToLower();
foreach (var factKey in fact.Keys)
{
var factName = factKey.Trim().ToLower();
var factValue = fact[factName].Trim().ToLower();
if (factKey != ruleItem.RuleItemType)
{
continue;
}
//是否为基础运算类型
var isBaseComputeType = Enum.IsDefined(typeof(BaseComputeType), ruleItem.ComputeType);
return(isBaseComputeType
? BaseCompute(ruleItem.ComputeType, ruleValue, factValue)
: CustomCompute(ruleItem.ComputeType, ruleValue, factValue));
}
return(false);
}
catch (Exception ex)
{
throw new RuleComputeException($"规则运算出错:{ex.Message}", ex);
}
}
private void check(RuleItem item, Dictionary <Token, bool> tasks)
{
var rezCond = _manager.GetCondition(item);
foreach (var kp in tasks)
{
var rez = rezCond.IsValid(kp.Key);
Assert.AreEqual(kp.Value,
rez,
"Wrong result for condition '{1}' for text '{0}'",
rezCond,
kp.Key);
}
}
public MainWindow(ClassificatorForm classificatorForm, InfosStorage storage, List <BuiltInCategory> allCats)
{
InitializeComponent();
this.classificatorForm = classificatorForm;
this.storage = storage;
this.ruleItems = new ObservableCollection <RuleItem>();
this.Collection.ItemsSource = ruleItems;
this.settings = new Settings();
this.CollectionParamNames.ItemsSource = settings.paramNameItems;
RuleItem.builtInCats = allCats;
this.checkedExit = true;
if (storage.classificator == null)
{
this.storage.classificator = new List <Classificator>();
this.storage.instanseParams = new List <string>();
RuleItem firstRuleItem = new RuleItem("", "", BuiltInCategory.INVALID);
firstRuleItem.addValueOfParam("Пустое значение параметра");
ruleItems.Add(firstRuleItem);
settings.addParamName("Введите имя параметра");
}
else
{
if (storage.instanceOrType == 1)
{
InstanceRadioButton.IsChecked = true;
}
else if (storage.instanceOrType == 2)
{
TypeRadioButton.IsChecked = true;
}
foreach (var item in storage.classificator)
{
RuleItem ruleItem = new RuleItem(item.FamilyName, item.TypeName, item.BuiltInName);
foreach (var pv in item.paramsValues)
{
ruleItem.addValueOfParam(pv);
}
ruleItem.colourOfRule = "#4C87B3";
ruleItems.Add(ruleItem);
}
foreach (var item in storage.instanseParams)
{
settings.addParamName(item);
}
}
refreshNumbersOfRules(ruleItems);
}
private RuleItem FindRuleByOrder(string order)
{
RuleItem result = null;
foreach (RuleItem item in this.RuleList)
{
if (item.Order == order)
{
result = item;
break;
}
}
return(result);
}
private void LoadRuleList()
{
this.RuleList = new List<RuleItem>();
XmlDocument document = new XmlDocument();
document.Load(FiddlerPath.RuleFilePath);
XmlNodeList ruleNodes = document.DocumentElement.SelectNodes("//InjectionRules/Rule");
RuleItem rule = null;
for (int i = 0, l = ruleNodes.Count; i < l; i++ )
{
rule = new RuleItem();
rule.Type = ruleNodes[i].Attributes["Type"].Value;
rule.Match = ruleNodes[i].Attributes["Match"].Value;
rule.Enabled = ruleNodes[i].Attributes["Enabled"].Value;
rule.Order = ruleNodes[i].Attributes["Order"].Value;
this.RuleList.Add(rule);
}
}
private void SetColorForCompositeRule(FillColorSource? source, string fillAlpha, RuleItem entry, ICompositeRule r)
{
// NOTE: Same naivete as IdentifyColorSource(). Refer to that method for all the gory details
bool bSetFill = false;
foreach (ISymbolInstance symInst in r.CompositeSymbolization.SymbolInstance)
{
if (bSetFill)
break;
var symRef = GetSymbolFromReference(m_editor.ResourceService, symInst.Reference);
var simpleSym = symRef as ISimpleSymbolDefinition;
if (simpleSym == null)
throw new NotSupportedException(Strings.CannotCreateThemeFromCompoundSymbolInstance);
var symName = simpleSym.Name;
//Find the first path graphic with a fill color
foreach (var graphic in simpleSym.Graphics)
{
if (bSetFill)
break;
if (graphic.Type == GraphicElementType.Path)
{
IPathGraphic path = (IPathGraphic)graphic;
if (path.FillColor != null)
{
string color = path.FillColor;
if (source.Value == FillColorSource.PathFillColor)
{
path.FillColor = "0x" + fillAlpha + Utility.SerializeHTMLColor(entry.Color, string.IsNullOrEmpty(fillAlpha));
Debug.WriteLine(string.Format("Set fill color to {0} for symbol instance {1} of symbolization {2} in rule {3}", path.FillColor, symInst.GetHashCode(), r.CompositeSymbolization.GetHashCode(), r.GetHashCode()));
bSetFill = true;
break;
}
//Is this a parameter?
if (color.StartsWith("%") && color.EndsWith("%"))
{
string paramName = color.Substring(1, color.Length - 2);
if (simpleSym.ParameterDefinition != null)
{
foreach (var paramDef in simpleSym.ParameterDefinition.Parameter)
{
if (bSetFill)
break;
if (paramDef.Name == paramName)
{
if (source.Value == FillColorSource.SymbolParameterFillColorDefaultValue)
{
paramDef.DefaultValue = "0x" + fillAlpha + Utility.SerializeHTMLColor(entry.Color, string.IsNullOrEmpty(fillAlpha));
Debug.WriteLine(string.Format("Set fill color default parameter value to {0} for symbol instance {1} of symbolization {2} in rule {3}", paramDef.DefaultValue, symInst.GetHashCode(), r.CompositeSymbolization.GetHashCode(), r.GetHashCode()));
bSetFill = true;
break;
}
//But wait ... Is there an override for this too?
var ov = symInst.ParameterOverrides;
if (ov != null)
{
foreach (var pov in ov.Override)
{
if (bSetFill)
break;
if (pov.SymbolName == symName && pov.ParameterIdentifier == paramName)
{
if (source.Value == FillColorSource.SymbolParameterFillColorOverride)
{
pov.ParameterValue = "0x" + fillAlpha + Utility.SerializeHTMLColor(entry.Color, string.IsNullOrEmpty(fillAlpha));
Debug.WriteLine(string.Format("Set fill color parameter override value to {0} for symbol instance {1} of symbolization {2} in rule {3}", pov.ParameterValue, symInst.GetHashCode(), r.CompositeSymbolization.GetHashCode(), r.GetHashCode()));
bSetFill = true;
break;
}
}
}
}
}
}
}
}
}
else if (path.LineColor != null && simpleSym.LineUsage != null)
{
string color = path.LineColor;
if (source.Value == FillColorSource.PathLineColor)
{
path.LineColor = "0x" + fillAlpha + Utility.SerializeHTMLColor(entry.Color, string.IsNullOrEmpty(fillAlpha));
Debug.WriteLine(string.Format("Set line color to {0} for symbol instance {1} of symbolization {2} in rule {3}", path.FillColor, symInst.GetHashCode(), r.CompositeSymbolization.GetHashCode(), r.GetHashCode()));
bSetFill = true;
break;
}
//Is this a parameter?
if (color.StartsWith("%") && color.EndsWith("%"))
{
string paramName = color.Substring(1, color.Length - 2);
if (simpleSym.ParameterDefinition != null)
{
foreach (var paramDef in simpleSym.ParameterDefinition.Parameter)
{
if (bSetFill)
break;
if (paramDef.Name == paramName)
{
if (source.Value == FillColorSource.SymbolParameterLineColorDefaultValue)
{
paramDef.DefaultValue = "0x" + fillAlpha + Utility.SerializeHTMLColor(entry.Color, string.IsNullOrEmpty(fillAlpha));
Debug.WriteLine(string.Format("Set line color default parameter value to {0} for symbol instance {1} of symbolization {2} in rule {3}", paramDef.DefaultValue, symInst.GetHashCode(), r.CompositeSymbolization.GetHashCode(), r.GetHashCode()));
bSetFill = true;
break;
}
//But wait ... Is there an override for this too?
var ov = symInst.ParameterOverrides;
if (ov != null)
{
foreach (var pov in ov.Override)
{
if (bSetFill)
break;
if (pov.SymbolName == symName && pov.ParameterIdentifier == paramName)
{
if (source.Value == FillColorSource.SymbolParameterLineColorOverride)
{
pov.ParameterValue = "0x" + fillAlpha + Utility.SerializeHTMLColor(entry.Color, string.IsNullOrEmpty(fillAlpha));
Debug.WriteLine(string.Format("Set line color parameter override value to {0} for symbol instance {1} of symbolization {2} in rule {3}", pov.ParameterValue, symInst.GetHashCode(), r.CompositeSymbolization.GetHashCode(), r.GetHashCode()));
bSetFill = true;
break;
}
}
}
}
}
}
}
}
}
}
}
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
public void Run(AdWordsUser user)
{
// Get the UserListService.
AdwordsUserListService userListService =
(AdwordsUserListService) user.GetService(AdWordsService.v201601.AdwordsUserListService);
// First rule item group - users who visited the checkout page and had
// more than one item in their shopping cart.
StringRuleItem checkoutStringRuleItem = new StringRuleItem();
checkoutStringRuleItem.key = new StringKey();
checkoutStringRuleItem.key.name = "ecomm_pagetype";
checkoutStringRuleItem.op = StringRuleItemStringOperator.EQUALS;
checkoutStringRuleItem.value = "checkout";
RuleItem checkoutRuleItem = new RuleItem();
checkoutRuleItem.Item = checkoutStringRuleItem;
NumberRuleItem cartSizeNumberRuleItem = new NumberRuleItem();
cartSizeNumberRuleItem.key = new NumberKey();
cartSizeNumberRuleItem.key.name = "cartsize";
cartSizeNumberRuleItem.op = NumberRuleItemNumberOperator.GREATER_THAN;
cartSizeNumberRuleItem.value = 1;
RuleItem cartSizeRuleItem = new RuleItem();
cartSizeRuleItem.Item = cartSizeNumberRuleItem;
// Combine the two rule items into a RuleItemGroup so AdWords will AND
// their rules together.
RuleItemGroup checkoutMultipleItemGroup = new RuleItemGroup();
checkoutMultipleItemGroup.items = new RuleItem[] { checkoutRuleItem, cartSizeRuleItem };
// Second rule item group - users who check out within the next 3 months.
DateRuleItem startDateDateRuleItem = new DateRuleItem();
startDateDateRuleItem.key = new DateKey();
startDateDateRuleItem.key.name = "checkoutdate";
startDateDateRuleItem.op = DateRuleItemDateOperator.AFTER;
startDateDateRuleItem.value = DateTime.Now.ToString(DATE_FORMAT_STRING);
RuleItem startDateRuleItem = new RuleItem();
startDateRuleItem.Item = startDateDateRuleItem;
DateRuleItem endDateDateRuleItem = new DateRuleItem();
endDateDateRuleItem.key = new DateKey();
endDateDateRuleItem.key.name = "checkoutdate";
endDateDateRuleItem.op = DateRuleItemDateOperator.BEFORE;
endDateDateRuleItem.value = DateTime.Now.AddMonths(3).ToString(DATE_FORMAT_STRING);
RuleItem endDateRuleItem = new RuleItem();
endDateRuleItem.Item = endDateDateRuleItem;
// Combine the date rule items into a RuleItemGroup.
RuleItemGroup checkedOutNextThreeMonthsItemGroup = new RuleItemGroup();
checkedOutNextThreeMonthsItemGroup.items =
new RuleItem[] { startDateRuleItem, endDateRuleItem };
// Combine the rule item groups into a Rule so AdWords will OR the groups
// together.
Rule rule = new Rule();
rule.groups = new RuleItemGroup[] {checkoutMultipleItemGroup,
checkedOutNextThreeMonthsItemGroup};
// Create the user list with no restrictions on site visit date.
ExpressionRuleUserList expressionUserList = new ExpressionRuleUserList();
expressionUserList.name = "Expression based user list created at " + DateTime.Now.ToString(
"yyyyMMdd_HHmmss");
expressionUserList.description = "Users who checked out in three month window OR visited " +
"the checkout page with more than one item in their cart.";
expressionUserList.rule = rule;
// Create the user list restricted to users who visit your site within
// the next six months.
DateTime startDate = DateTime.Now;
DateTime endDate = startDate.AddMonths(6);
DateSpecificRuleUserList dateUserList = new DateSpecificRuleUserList();
dateUserList.name = "Date rule user list created at " +
DateTime.Now.ToString("yyyyMMdd_HHmmss");
dateUserList.description = String.Format("Users who visited the site between {0} and " +
"{1} and checked out in three month window OR visited the checkout page " +
"with more than one item in their cart.", startDate.ToString(DATE_FORMAT_STRING),
endDate.ToString(DATE_FORMAT_STRING));
dateUserList.rule = rule;
// Set the start and end dates of the user list.
dateUserList.startDate = startDate.ToString(DATE_FORMAT_STRING);
dateUserList.endDate = endDate.ToString(DATE_FORMAT_STRING);
// Create operations to add the user lists.
List<UserListOperation> operations = new List<UserListOperation>();
foreach (UserList userList in new UserList[] { expressionUserList, dateUserList }) {
UserListOperation operation = new UserListOperation();
operation.operand = userList;
operation.@operator = Operator.ADD;
operations.Add(operation);
}
try {
// Submit the operations.
UserListReturnValue result = userListService.mutate(operations.ToArray());
// Display the results.
foreach (UserList userListResult in result.value) {
Console.WriteLine("User list added with ID {0}, name '{1}', status '{2}', " +
"list type '{3}', accountUserListStatus '{4}', description '{5}'.",
userListResult.id,
userListResult.name,
userListResult.status,
userListResult.listType,
userListResult.accountUserListStatus,
userListResult.description);
}
} catch (Exception e) {
throw new System.ApplicationException("Failed to add rule based user lists.", e);
}
}
private string GeneratePFX(string word, RuleItem item)
{
int deleteCount = 0;
if (!int.TryParse(item.CharsToDelete, out deleteCount))
{
for (int pos = 0; pos < item.CharsToDelete.Length; pos++)
{
if (item.CharsToDelete[pos] == word[pos])
{
deleteCount++;
}
}
}
string tempWord = word.Substring(deleteCount);
// condition prozatimne
if (item.Conditions.Count == 1 && item.Conditions.First().First() == '.')
{
tempWord = item.StringToAdd + tempWord;
}
return tempWord;
}
private string GenerateSFX(string word, RuleItem item)
{
string tempWord;
bool cond = this.CheckCondition(word, item.Conditions, RuleType.SFX);
if (cond)
{
int deleteCount = 0;
if (!int.TryParse(item.CharsToDelete, out deleteCount))
{
string wordEnd = word.Substring(word.Length - item.CharsToDelete.Length);
if (wordEnd == item.CharsToDelete)
{
deleteCount = item.CharsToDelete.Length;
}
/*for (int pos = word.Length; pos > (word.Length - item.CharsToDelete.Length); pos--)
{
if (item.CharsToDelete[pos - word.Length] == word[pos - 1])
{
deleteCount++;
}
}*/
}
tempWord = word.Substring(0, word.Length - deleteCount) + item.StringToAdd;
}
else
{
tempWord = null;
}
return tempWord;
}
public void AddItem(string key, RuleItem item)
{
rules[key].Add(item);
}
public string AddRule(string type, string match)
{
int newOrder = 1;
if (this.RuleList.Count > 0)
{
newOrder = int.Parse(this.RuleList[this.RuleList.Count - 1].Order) + 1;
}
RuleItem newRule = new RuleItem();
newRule.Type = type;
newRule.Match = match;
newRule.Order = newOrder.ToString();
newRule.Enabled = "true";
this.RuleList.Add(newRule);
return newRule.Order;
}
