/// <summary>
/// 点击规则列表的内容时触发的事件，编辑和删除两项
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dgv_wenjianmingrules_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
string ruleName = dgv_wenjianmingrules.Rows[e.RowIndex].Cells["jieximingcheng"].Value.ToString();
//点击编辑按钮时
if (dgv_wenjianmingrules.Columns[e.ColumnIndex].Name == "bianjianniu" && e.RowIndex >= 0)
{
//获得规则的信息ruleinfo
RuleInfo myri = new RuleInfo(ruleName, "文件名标准化");
myri.GetRuleInfo();
//把ruleinfo传给wjmruleform窗体,立刻加载信息
WjmRuleForm myform = new WjmRuleForm(myri);
if (myform.ShowDialog() == DialogResult.OK)
{
//UpdateWenjianmingRules();
}
}
//点击删除按钮时
if (dgv_wenjianmingrules.Columns[e.ColumnIndex].Name == "shanchuanniu" && e.RowIndex >= 0)
{
DialogResult mydr = MessageBox.Show($"是否删除规则 {ruleName} ?", "消息提醒", MessageBoxButtons.YesNoCancel);
if (mydr == DialogResult.Yes)
{
string str_sql = $"delete from 数据解析库.规则信息表 where 规则名称='{ruleName}' and 删除=0";
MySqlHelper.ExecuteNonQuery(SystemInfo._strConn, str_sql);
//更新下拉列表
////删除列表成功提示
//刷新格则列表显示
UpdateRules("文件名标准化", string.Empty, dgv_wenjianmingrules);
SelectRules(cbb_formatName1.Text, dgv_wenjianmingrules);
MessageBox.Show($"规则 {ruleName} 已删除成功！");
}
}
}
/// <summary>
/// 将规则编码和参数信息更新至巷道信息表
/// 注意：当传入的参数为null时，说明该巷道未绑定规则编码，此时仍需更新数据库
/// </summary>
/// <param name="tunnelID">巷道ID</param>
/// <param name="info">巷道绑定的所有规则ID和参数信息</param>
/// <returns>更新成功返回True</returns>
public static bool UpdateRuleIdsAndParams2TunnelTable(int tunnelID,
RuleInfo[] info)
{
string ruleIds = "";
string warningParams = "";
if (info != null)
{
int n = info.Length;
for (int i = 0; i < n; i++)
{
RuleInfo cvtInfo =
PreWarningRulesBLL.ConvertOneRuleCodeAndParamInfo2DBString(info[i]);
ruleIds += cvtInfo.RuleCodesStr;
warningParams += cvtInfo.ParamsInfoStr;
}
}
string sql = "UPDATE " +
TunnelInfoDbConstNames.TABLE_NAME + " SET " +
TunnelInfoDbConstNames.RULE_IDS + "='" + ruleIds + "'," +
TunnelInfoDbConstNames.PRE_WARNING_PARAMS + "='" +
warningParams + "' WHERE " +
TunnelInfoDbConstNames.ID + "=" + tunnelID;
ManageDataBase db = new
ManageDataBase(DATABASE_TYPE.GeologyMeasureDB);
return(db.OperateDB(sql));
}
/// <summary>
/// 点击查重清晰模块下的规则列表时触发的事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dgv_chachong_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
string ruleName = dgv_chachong.Rows[e.RowIndex].Cells[1].Value.ToString();
//点击编辑按钮时
if (e.ColumnIndex == 4 && e.RowIndex >= 0)
{
//获得规则的信息ruleinfo
RuleInfo myri = new RuleInfo(ruleName, "查重清洗");
myri.GetRuleInfo();
//把ruleinfo传给wjmruleform窗体,立刻加载信息
CcqxRuleForm myForm = new CcqxRuleForm(myri);
if (myForm.ShowDialog() == DialogResult.OK)
{
MessageBox.Show($"规则 {myForm._ruleInfo.ruleName} 保存成功！");
}
}
//点击删除按钮时
if (e.ColumnIndex == 5 && e.RowIndex >= 0)
{
DialogResult mydr = MessageBox.Show($"是否删除规则 {ruleName} ?", "消息提醒", MessageBoxButtons.YesNoCancel);
if (mydr == DialogResult.Yes)
{
string str_sql = $"delete from 数据解析库.规则信息表 where 规则名称='{ruleName}' and 删除=0";
MySqlHelper.ExecuteNonQuery(SystemInfo._strConn, str_sql);
//更新下拉列表
////删除列表成功提示
//刷新格则列表显示
UpdateRules("查重清洗", string.Empty, dgv_chachong);
SelectRules(cbb_format3.Text, dgv_chachong);
MessageBox.Show($"规则 {ruleName} 已成功删除！");
}
}
}
private void GenerateRealFemalePersona(int siteId)
{
PersonalDataStructure personalData = new RealPersonalDataGenerator().GeneratePersonalData(UserGenderEnum.Female);
PersonaInfo persona = new PersonaInfo
{
PersonaDisplayName = personalData.FirstName + " " + personalData.LastName + " (female)",
PersonaName = "Persona-" + Guid.NewGuid(),
PersonaSiteID = siteId,
PersonaPointsThreshold = 100,
PersonaEnabled = true
};
persona.Insert();
var rule = new RuleInfo
{
RuleScoreID = persona.PersonaScoreID,
RuleDisplayName = "Is female",
RuleName = "Rule-" + Guid.NewGuid(),
RuleValue = 1000,
RuleType = RuleTypeEnum.Attribute,
RuleParameter = "ContactGender",
RuleCondition = "<condition><attribute name=\"ContactGender\"><value>2</value></attribute><wherecondition>ContactGender = 2</wherecondition></condition>",
RuleSiteID = siteId
};
rule.Insert();
}
public Hashtable Put(int id, string content)
{
Hashtable ht = new Hashtable();
RuleInfo ai = new RuleInfo();
Hashtable data = new Hashtable();
try
{
// ht.Add("state", ai.AddOne(id, name, birthday, admin, work));
if (ai.ChangeContext(id, content))
{
ht.Add("code", 20000);
data.Add("id", id);
}
else
{
ht.Add("code", 40000);
data.Add("message", "error");
}
}
catch (Exception e)
{
ht.Add("code", 40000);
data.Add("message", e.Message);
}
ht.Add("data", data);
return(ht);
}
private Func <Data, bool> GetRule(RuleInfo rule)
{
Type propType = TypeToType[rule.ValueType];
var convertMethod = TypeToConvert[rule.ValueType];
var paramValue = Expression.Parameter(typeof(Data));
var methodInfo = typeof(Convert).GetMethod(
convertMethod,
new Type[] { typeof(string) },
null);
var left = Expression.Property(paramValue, nameof(Data.Value));
MethodCallExpression convertedLeft = Expression.Call(methodInfo, left);
Func <Data, bool> func = (data) => false;
// if its .net defined operator
if ((int)rule.Operator <= MaxExprType)
{
if (Enum.TryParse(rule.Operator.ToString(), out ExpressionType expressionType))
{
var right = Expression.Constant(Convert.ChangeType(rule.Value[0], propType));
func =
Expression.Lambda <Func <Data, bool> >
(
Expression.MakeBinary(expressionType, convertedLeft, right), paramValue
).Compile();
}
}
return(func);
}
private void lbl_baocun_Click(object sender, EventArgs e)
{
//构造一个root传入ruleinfo中
JJmodel.WjmRuleRoot ruleRoot = new WjmRuleRoot();
ruleRoot.ruleExplain = tb_explain.Text;
foreach (Control myc in flp_my.Controls)
{
CheckBox cb = myc as CheckBox;
if (cb.Checked)
{
ruleRoot.position.Add(cb.Text);
}
}
ruleRoot.delete = tb_delete.Text;
ruleRoot.newText = tb_new.Text;
ruleRoot.replace0 = tb_replace0.Text;
ruleRoot.replace = tb_replace.Text;
//构造一个ruleinfo
RuleInfo ri = new RuleInfo(tb_rulename.Text, SystemInfo._currentModule, ruleRoot, SystemInfo._userInfo._shiming,
DateTime.Now.ToString("yyyy-MM-dd"));
//保存到数据库的规则信息表中
ri.SaveRuleInfo();
this.DialogResult = DialogResult.OK;
}
private object gridElem_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerCSafe())
{
case "validity":
DataRowView rowView = (DataRowView)parameter;
RuleInfo rule = new RuleInfo(rowView.Row);
return(GetValidity(rule));
case "ruletype":
string name = "om.score.";
name += Enum.GetName(typeof(RuleTypeEnum), parameter);
return(GetString(name));
case "delete":
if ((ModifyPermissions != null) && !ModifyPermissions.Value)
{
CMSGridActionButton imgDel = (CMSGridActionButton)sender;
imgDel.Enabled = false;
imgDel.Style.Add("cursor", "default");
return(imgDel);
}
break;
}
return(sender);
}
private void OnRefreshOne()
{
var list = GetData <List <object> >();
if (list == null)
{
return;
}
var listCount = list.Count;
TabDatas = new TabData[listCount];
for (var i = 0; i < listCount; i++)
{
var info = list[i];
var dict = info as IDictionary;
if (dict == null)
{
continue;
}
var ruleInfo = new RuleInfo(dict, TabDefaultIndex);
var tabData = new TabData
{
Name = ruleInfo.Name,
Data = ruleInfo,
Index = i
};
TabDatas[i] = tabData;
}
}
private object gridElem_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerCSafe())
{
case "validity":
DataRowView rowView = (DataRowView)parameter;
RuleInfo rule = new RuleInfo(rowView.Row);
return(GetValidity(rule));
case "ruletype":
string name = "om.score.";
name += Enum.GetName(typeof(RuleTypeEnum), parameter);
return(GetString(name));
case "delete":
if (!CurrentUser.IsAuthorizedPerResource(ModuleNameForPermissionCheck, PermissionsEnum.Modify.ToString()))
{
var imgDel = (CMSGridActionButton)sender;
imgDel.Enabled = false;
imgDel.Style.Add("cursor", "default");
return(imgDel);
}
break;
}
return(sender);
}
private void AddRuleUser(RuleInfo item, UserPrincipal user)
{
var userInfo = new UserInfo
{
Comment = Helpers.DistinguishedName(user.DistinguishedName),
DisplayName = user.DisplayName,
Enabled = (bool)user.Enabled,
Family = user.Surname,
IsDanger = (bool)user.Enabled && item.IsDanger,
IsSelected = false,
IsTransit = item.IsTransit,
Name = user.GivenName,
UserName = user.SamAccountName,
UserPrincipal = user
};
int i = UserInfos.IndexOf(userInfo);
if (i < 0)
{
if (!item.Deny)
{
UserInfos.Add(userInfo);
}
}
else if (UserInfos[i].Enabled && !UserInfos[i].IsDanger && userInfo.IsDanger)
{
UserInfos[i].IsDanger = true;
}
}
//private void AddLocalUser(string principal)
//{
// string group, user;
// if (principal.Contains("\\"))
// {
// string[] account = principal.Split('\\');
// group = account[0];
// user = account[1];
// }
// else
// {
// group = string.Empty;
// user = principal;
// }
// var userInfo = new UserInfo(
// user,
// false,
// principal,
// user,
// group,
// Environment.MachineName + ", " + principal,
// false
// );
// if (!UserInfos.Contains(userInfo))
// {
// UserInfos.Add(userInfo);
// }
//}
#endregion Users
#region Groups
private void AddNestedGroups(RuleInfo item)
{
Trace.Assert(item.Principal != null, "No RuleInfo.Pricipal");
var members = ((GroupPrincipal)item.Principal).GetMembers(); //TODO recursive doesn't work - help required!
try
{
foreach (Principal member in members)
{
if (member is GroupPrincipal group)
{
if (Helpers.IsSystemName(true, group.Name))
{
continue;
}
var groupInfo = new GroupInfo
{
Description = group.Description ?? group.DisplayName ?? group.SamAccountName,
GroupName = group.Name,
GroupPrincipal = group,
//IsDanger = item.IsDanger,
IsSelected = false
};
if (!GroupInfos.Contains(groupInfo))
{
GroupInfos.Add(groupInfo);
}
}
}
}
catch { } // No network
}
private RuleInfo GenerateRule(
string displayName,
int value,
int scoreId,
string ruleCondition,
RuleTypeEnum ruleType,
string ruleParameter = null,
bool belongsToPersona = true)
{
var codeName = ValidationHelper.GetCodeName(displayName, 100);
var ruleInfo = RuleInfoProvider.GetRules().WithCodeName(codeName).FirstOrDefault();
if (ruleInfo != null)
{
return(ruleInfo);
}
var ruleObj = new RuleInfo
{
RuleScoreID = scoreId,
RuleDisplayName = displayName,
RuleName = codeName,
RuleValue = value,
RuleType = ruleType,
RuleParameter = ruleParameter,
RuleCondition = ruleCondition,
RuleBelongsToPersona = belongsToPersona
};
RuleInfoProvider.SetRuleInfo(ruleObj);
return(ruleObj);
}
/// <summary>
/// Initializes a new instance of the <see cref="AnyBall.Rule.CS_RuleSet"/> class.
/// </summary>
/// <param name="g_rule">the rule to initialize with.</param>
public CS_RuleSet(CS_Rule g_rule)
{
myRules = new List <CS_Rule> ();
myRules.Add(g_rule);
myRuleInfo = g_rule.GetInfo();
}
private static RuleInfo ReadRule(SqlDataReader reader)
{
try
{
IMetadataManager iMetadataManager = new MetadataManager.Contracts.MetadataManager();
List <SourceInfo> lstSource = reader.IsDBNull(4) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject <List <SourceInfo> >(reader.GetString(4));
List <TargetInfo> lstTarget = reader.IsDBNull(5) ? null : Newtonsoft.Json.JsonConvert.DeserializeObject <List <TargetInfo> >(reader.GetString(5));
RuleTypeEnum ruleType = reader.IsDBNull(3) ? RuleTypeEnum.Visibility : (RuleTypeEnum)reader.GetInt32(3);
string strRuleTypeName = ruleType.ToString();
string entityId = reader.IsDBNull(8) ? string.Empty : reader.GetString(8);
string entityName = (entityId == null) ? string.Empty : iMetadataManager.GetEntityNameByEntityContext(entityId);
var rule = new RuleInfo
{
TenantId = reader.IsDBNull(0) ? Guid.Empty : reader.GetGuid(0),
Id = reader.IsDBNull(1) ? Guid.Empty : reader.GetGuid(1),
RuleName = reader.IsDBNull(2) ? string.Empty : reader.GetString(2),
RuleType = reader.IsDBNull(3) ? RuleTypeEnum.Visibility : (RuleTypeEnum)reader.GetInt32(3),
Source = reader.IsDBNull(4) ? string.Empty : reader.GetString(4),
Target = reader.IsDBNull(5) ? string.Empty : reader.GetString(5),
SourceList = lstSource,
TargetList = lstTarget,
UpdatedBy = reader.IsDBNull(7) ? Guid.Empty : reader.GetGuid(7),
RuleTypeName = strRuleTypeName,
EntityId = entityId,
EntityName = entityName
};
return(rule);
}
catch (System.Exception ex)
{
throw ex.InnerException;
}
}
public IActionResult Put([FromBody] RuleInfo rule, string entityName)
{
try
{
var stopwatch = StopwatchLogger.Start(_log);
_log.Info("Called RuleController Put {0}=", JsonConvert.SerializeObject(rule));
if (!String.IsNullOrEmpty(rule.EntityName))
{
rule.EntityId = _iMetadataManager.GetEntityContextByEntityName(entityName);
}
string strMsg = string.Empty;
var retVal = _manageRule.Update(TenantCode, rule, ref strMsg);
if (!String.IsNullOrEmpty(strMsg) && retVal == false)
{
return(StatusCode((int)HttpStatusCode.AlreadyReported, strMsg));
}
stopwatch.StopAndLog("End RuleController put");
return(Ok(retVal));
}
catch (Exception ex)
{
_log.Error(ExceptionFormatter.SerializeToString(ex));
return(StatusCode((int)HttpStatusCode.InternalServerError, ApiConstant.CustomErrorMessage));
}
}
internal bool Update(Guid tenantId, RuleInfo ruleInfo, ref string strMsg)
{
try
{
var cmd = CreateProcedureCommand("dbo.Rule_Update");
cmd.AppendGuid("@guidTenantId", tenantId);
cmd.AppendGuid("@guidId", ruleInfo.Id);
cmd.AppendMediumText("@strRuleName", ruleInfo.RuleName);
cmd.AppendSmallInt("@intRuleType", (Int16)ruleInfo.RuleType);
cmd.AppendXLargeText("@strSource", ruleInfo.Source);
cmd.AppendXLargeText("@strTarget", ruleInfo.Target);
cmd.AppendGuid("@guidUpdatedBy", ruleInfo.UpdatedBy);
cmd.AppendXSmallText("@strEntityId", ruleInfo.EntityId);
cmd.AppendVarChar("@strMessage", 100);
int retVal = ExecuteCommand(cmd);
strMsg = cmd.OutputParameterValue("@strMessage");
if (!String.IsNullOrEmpty(strMsg))
{
return(false);
}
strMsg = "Data updated successfully";
return(true);
}
catch (SqlException e)
{
throw ReportAndTranslateException(e, "Rule::Rule_Update");
}
}
//TODO: Edit
private List <RuleInfo> LoadRules(string path)
{
if (!File.Exists(path))
{
return(new List <RuleInfo>());
}
using (StreamReader sr = new StreamReader(path))
{
string json = sr.ReadToEnd();
sr.Close();
JArray array = JArray.Parse(json);
List <RuleInfo> rules = new List <RuleInfo>();
foreach (var rule in array.Children <JObject>())
{
rules.Add(RuleInfo.Deserialize(rule));
}
return(rules);
}
}
void InitCustomEvaluator(RuleInfo ruleInfo)
{
string customEvaluator = ruleInfo._customEvaluator;
if (customEvaluator == null ||
customEvaluator.Trim().Length == 0)
{
ruleInfo._customEvaluatorType = null;
return;
}
ruleInfo._customEvaluatorType = ConfigUtil.GetType(ruleInfo._customEvaluator,
"custom", ruleInfo._customEvaluatorConfig);
// Make sure the type support WebBaseEvent
HandlerBase.CheckAssignableType(ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].Source,
ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].LineNumber,
typeof(System.Web.Management.IWebEventCustomEvaluator), ruleInfo._customEvaluatorType);
// Create a public instance of the custom evaluator
if (_customEvaluatorInstances[ruleInfo._customEvaluatorType] == null)
{
_customEvaluatorInstances[ruleInfo._customEvaluatorType] = HttpRuntime.CreatePublicInstance(ruleInfo._customEvaluatorType);
}
}
// GET api/<controller>
public Hashtable Get(int id)
{
Hashtable ht = new Hashtable();
Hashtable data = new Hashtable();
RuleInfo ai = new RuleInfo();
if (ai.HasUsed(id))
{
ht.Add("code", 40000);
data.Add("message", "条款已被使用，无法删除");
}
else
{
try
{
if (ai.DeleteOne(id))
{
ht.Add("code", 20000);
data.Add("status", "success");
}
else
{
ht.Add("code", 40000);
data.Add("message", "failed");
}
}
catch (Exception e)
{
ht.Add("code", 40000);
data.Add("message", e.Message);
}
}
ht.Add("data", data);
return(ht);
}
protected void Page_Init(object sender, EventArgs e)
{
// Request to this page has to have all three following query parameters set
int personaId = QueryHelper.GetInteger("personaid", 0);
// Persona has to be connected with current score
var personaInfo = PersonaInfoProvider.GetPersonaInfoById(personaId);
if (personaInfo == null)
{
RedirectToAccessDenied(GetString("general.invalidparameters"));
}
if (!personaInfo.CheckPermissions(PermissionsEnum.Read, CurrentSiteName, CurrentUser))
{
RedirectToAccessDenied(personaInfo.TypeInfo.ModuleName, "Read");
}
RuleInfo rule = EditedObject as RuleInfo;
// Editing existing rule
if (rule != null)
{
// Rule has to be connected with current score
if ((rule.RuleScoreID != personaInfo.PersonaScoreID))
{
RedirectToAccessDenied(GetString("general.invalidparameters"));
}
}
editElem.ResourceName = ModuleName.PERSONAS;
editElem.ScoreId = personaInfo.PersonaScoreID;
editElem.NewRuleUrl = string.Format("Tab_Rules_Edit.aspx?personaid={0}", personaId);
editElem.RedirectUrlAfterCreate = string.Format("Tab_Rules_Edit.aspx?ruleid={{%EditedObject.ID%}}&personaid={0}&saved=1", personaId);
}
// POST api/<controller>
/*public Hashtable Post([FromBody] int article_id, [FromBody] int num_id, [FromBody] string context)
* {
* Hashtable ht = new Hashtable();
* RuleInfo ai = new RuleInfo();
* if (ai.HasName(article_id, num_id))
* {
* ht.Add("state", false);
* ht.Add("reason", "条款已存在");
* }
* else
* {
* try
* {
* ht.Add("state", ai.AddOne(article_id, num_id, context));
* }
* catch (Exception e)
* {
* ht.Add("state", false);
* ht.Add("reason", e.Message);
* }
* }
* return ht;
* }*/
public Hashtable Post(string content)
{
Hashtable ht = new Hashtable();
RuleInfo ai = new RuleInfo();
Hashtable data = new Hashtable();
try
{
if (ai.AddOne(0, 0, content))
{
ht.Add("code", 20000);
data.Add("id", ai.GetId(content));
}
else
{
ht.Add("code", 40000);
data.Add("message", "error");
}
}
catch (Exception e)
{
ht.Add("code", 40000);
data.Add("message", e.Message);
}
ht.Add("data", data);
return(ht);
}
public void RunRuleByID_RuleNotApplicableForNonMatchingCondition()
{
// This test has the side effect of ensuring IRule.Evaluate is not called
// when the condition is not matched.
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(false).Verifiable();
var infoStub = new RuleInfo();
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.NotApplicable, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(infoStub, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
bool IDuplicateRecordsManager.CheckDuplicatesData(Guid tenantId, string entityname, JObject resource, Guid?id)
{
string EntityConextId = _IMetadataManager.GetEntityContextByEntityName(entityname);
if (string.IsNullOrEmpty(EntityConextId))
{
throw new ArgumentException("Entity is not found");
}
RuleInfo uniqueRuleObj = _ManageRule.GetUniqueFieldsRuleByEntity(tenantId, EntityConextId);
if (uniqueRuleObj == null)
{
return(false);
}
var fieldsArr = uniqueRuleObj.TargetList.Select(t => t.Name).ToList();
Dictionary <string, dynamic> fields = new Dictionary <string, dynamic>();
foreach (var fieldname in fieldsArr)
{
var value = GetJArrayValue(resource, fieldname);
fields.Add(fieldname, value);
}
//var fields = string.Join(",", fieldsArr);
var status = _IMetadataManager.GetDuplicateStatus(entityname, fields, id);
return(false);
}
public void RunRuleByID_FrameworkIssueLinkIsNotNull_PropagatesToResult()
{
const string frameworkIssueLink = "https://docs.microsoft.com/known-framework-link";
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(true).Verifiable();
var infoStub = new RuleInfo
{
ErrorCode = EvaluationCode.NeedsReview,
FrameworkIssueLink = frameworkIssueLink,
};
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.PassesTest(e)).Returns(true).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(frameworkIssueLink, result.RuleInfo.FrameworkIssueLink);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
public void RunRuleByID_ReturnsExecutionErrorWhenConditionMatchesThrowsException()
{
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Throws <Exception>().Verifiable();
var infoStub = new RuleInfo();
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.RuleExecutionError, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(infoStub, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
public async Task Commit(IInputElement inputElement)
{
var existingRule = await SelectedRuleProvider.FindByName(Name);
if (existingRule != null)
{
existingRule.Rule = _saveRuleMessage.Rule;
existingRule.DateUpdated = DateTime.UtcNow;
await SelectedRuleProvider.Update(existingRule);
Close(inputElement);
return;
}
_saveRuleMessage.Rule.Name = Name;
var ruleInfo = new RuleInfo
{
Author = Environment.UserName,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow,
Group = SelectedGroup,
Id = Guid.NewGuid(),
Rule = _saveRuleMessage.Rule,
Name = _saveRuleMessage.Rule.Name
};
await SelectedRuleProvider.Add(ruleInfo);
Close(inputElement);
}
public void RunRuleByID_ReturnsExpectedEvaluationCodeWhenPassesTestFalse()
{
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(true).Verifiable();
var infoStub = new RuleInfo
{
ErrorCode = EvaluationCode.NeedsReview,
};
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.PassesTest(e)).Returns(false).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.NeedsReview, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(ruleMock.Object.Info, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
public async Task <bool> Add(RuleInfo ruleInfo)
{
var rules = await Load();
rules.Add(ruleInfo);
Write(rules, Path);
return(true);
}
public void Enqueue(RuleInfo rule)
{
if (!_ruleSet.TryGetValue(rule.Signal, out IRuleEngine ruleEngine))
{
_ruleSet[rule.Signal] = new RuleEngine(_failedResultBag, _failedResultSet);
}
_ruleSet[rule.Signal].Enqueue(rule);
}
public IEnumerable<RuleInfo> Parse(byte[] data)
{
var rules = new List<RuleInfo>();
var reader = new PacketReader(data);
var header = reader.ReadByte();
var numberOfRules = reader.ReadShort();
for (short i = 1; i <= numberOfRules; i++)
{
if (!reader.IsEnd)
{
var rule = new RuleInfo();
rule.Index = i;
rule.Name = reader.ReadUTFString();
rule.Value = reader.ReadUTFString();
rules.Add(rule);
}
}
return rules;
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
scoreId = QueryHelper.GetInteger("scoreid", 0);
rule = RuleInfoProvider.GetRuleInfo(QueryHelper.GetInteger("ruleid", 0));
EditForm.OnBeforeSave += new EventHandler(EditForm_OnBeforeSave);
EditForm.RedirectUrlAfterSave = "Tab_Rules_Edit.aspx?ruleid={%EditedObject.ID%}&scoreid=" + scoreId + "&saved=1";
InitHeaderActions();
}
internal FiringRuleInfo(RuleInfo ruleInfo) {
_ruleInfo = ruleInfo;
_indexOfFirstRuleInfoWithSameProvider = -1;
}
void InitCustomEvaluator(RuleInfo ruleInfo) {
string customEvaluator = ruleInfo._customEvaluator;
if (customEvaluator == null ||
customEvaluator.Trim().Length == 0) {
ruleInfo._customEvaluatorType = null;
return;
}
ruleInfo._customEvaluatorType = ConfigUtil.GetType(ruleInfo._customEvaluator,
"custom", ruleInfo._customEvaluatorConfig);
// Make sure the type support WebBaseEvent
HandlerBase.CheckAssignableType(ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].Source,
ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].LineNumber,
typeof(System.Web.Management.IWebEventCustomEvaluator), ruleInfo._customEvaluatorType);
// Create a public instance of the custom evaluator
if (_customEvaluatorInstances[ruleInfo._customEvaluatorType] == null) {
_customEvaluatorInstances[ruleInfo._customEvaluatorType] = HttpRuntime.CreatePublicInstance(ruleInfo._customEvaluatorType);
}
}
private void DisplayRuleInfo(RuleInfo ruleInfo)
{
}
private static RuleInfo GenerateBasicScoringRule(ScoreInfo score, string displayName, int ruleValue, RuleTypeEnum ruleType, string ruleCondition, string ruleParameter = null)
{
var rule = new RuleInfo
{
RuleScoreID = score.ScoreID,
RuleDisplayName = displayName,
RuleName = "Rule-" + Guid.NewGuid(),
RuleValue = ruleValue,
RuleType = ruleType,
RuleParameter = ruleParameter,
RuleCondition = ruleCondition,
RuleSiteID = score.ScoreSiteID,
RuleBelongsToPersona = false,
RuleIsRecurring = false
};
rule.Insert();
return rule;
}
private object gridElem_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerCSafe())
{
case "validity":
DataRowView rowView = (DataRowView)parameter;
RuleInfo rule = new RuleInfo(rowView.Row);
return GetValidity(rule);
case "ruletype":
string name = "om.score.";
name += Enum.GetName(typeof (RuleTypeEnum), parameter);
return GetString(name);
case "delete":
if ((ModifyPermissions != null) && !ModifyPermissions.Value)
{
CMSGridActionButton imgDel = (CMSGridActionButton)sender;
imgDel.Enabled = false;
imgDel.Style.Add("cursor", "default");
return imgDel;
}
break;
}
return sender;
}
/// <summary>
/// Gets validity string. Either in units of time (xx days) or an expiration date.
/// </summary>
private static string GetValidity(RuleInfo rule)
{
if (rule.RuleValidUntil != DateTimeHelper.ZERO_TIME)
{
return rule.RuleValidUntil.ToShortDateString();
}
if (rule.RuleValidity != ValidityEnum.Until)
{
return rule.RuleValidFor + " " + Enum.GetName(typeof (ValidityEnum), rule.RuleValidity).ToLowerCSafe();
}
return String.Empty;
}
private void GenerateRealMalePersona(int siteId)
{
PersonalDataStructure personalData = new RealPersonalDataGenerator().GeneratePersonalData(UserGenderEnum.Male);
PersonaInfo persona = new PersonaInfo
{
PersonaDisplayName = personalData.FirstName + " " + personalData.LastName + " (male)",
PersonaName = "Persona-" + Guid.NewGuid(),
PersonaSiteID = siteId,
PersonaPointsThreshold = 100,
PersonaEnabled = true
};
persona.Insert();
var rule = new RuleInfo
{
RuleScoreID = persona.PersonaScoreID,
RuleDisplayName = "Is male",
RuleName = "Rule-" + Guid.NewGuid(),
RuleValue = 1000,
RuleType = RuleTypeEnum.Attribute,
RuleParameter = "ContactGender",
RuleCondition = "<condition><attribute name=\"ContactGender\"><value>1</value></attribute><wherecondition>ContactGender = 1</wherecondition></condition>",
RuleSiteID = siteId
};
rule.Insert();
}
private void LoadValidationRules(XmlTextReader xtr)
{
if (xtr.IsEmptyElement) return;
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement
&& xtr.LocalName.ToLower() == "validationrules")
break; //reach end of property node
if (xtr.NodeType == XmlNodeType.Element
&& Enum.IsDefined(typeof(CommonRuleHandler), xtr.LocalName))
{
RuleInfo rule = new RuleInfo(this, xtr);
_validationRules.Add(rule);
}
}
}
private void InitReferencedProvider(RuleInfo ruleInfo)
{
string str = ruleInfo._ruleSettings.Provider;
if (!string.IsNullOrEmpty(str))
{
WebEventProvider provider = this._providerInstances[str];
ruleInfo._referencedProvider = provider;
}
}
private void MergeValuesWithProfile(RuleInfo ruleInfo)
{
ProfileSettings settings = null;
if (ruleInfo._ruleSettings.ElementInformation.Properties["profile"].ValueOrigin != PropertyValueOrigin.Default)
{
settings = this._section.Profiles[ruleInfo._ruleSettings.Profile];
}
if ((settings != null) && (ruleInfo._ruleSettings.ElementInformation.Properties["minInstances"].ValueOrigin == PropertyValueOrigin.Default))
{
ruleInfo._minInstances = settings.MinInstances;
}
else
{
ruleInfo._minInstances = ruleInfo._ruleSettings.MinInstances;
}
if ((settings != null) && (ruleInfo._ruleSettings.ElementInformation.Properties["maxLimit"].ValueOrigin == PropertyValueOrigin.Default))
{
ruleInfo._maxLimit = settings.MaxLimit;
}
else
{
ruleInfo._maxLimit = ruleInfo._ruleSettings.MaxLimit;
}
if ((settings != null) && (ruleInfo._ruleSettings.ElementInformation.Properties["minInterval"].ValueOrigin == PropertyValueOrigin.Default))
{
ruleInfo._minInterval = settings.MinInterval;
}
else
{
ruleInfo._minInterval = ruleInfo._ruleSettings.MinInterval;
}
if ((settings != null) && (ruleInfo._ruleSettings.ElementInformation.Properties["custom"].ValueOrigin == PropertyValueOrigin.Default))
{
ruleInfo._customEvaluator = settings.Custom;
ruleInfo._customEvaluatorConfig = settings;
}
else
{
ruleInfo._customEvaluator = ruleInfo._ruleSettings.Custom;
ruleInfo._customEvaluatorConfig = ruleInfo._ruleSettings;
}
}
RuleInfo CreateRuleInfo(RuleSettings ruleSettings) {
RuleInfo ruleInfo = new RuleInfo(ruleSettings, _section);
// Inherit values from profile
MergeValuesWithProfile(ruleInfo);
// Find out which provider it's referencing
InitReferencedProvider(ruleInfo);
// Initialize the cutom evaluator type
InitCustomEvaluator(ruleInfo);
return ruleInfo;
}
private void InitCustomEvaluator(RuleInfo ruleInfo)
{
string str = ruleInfo._customEvaluator;
if ((str == null) || (str.Trim().Length == 0))
{
ruleInfo._customEvaluatorType = null;
}
else
{
ruleInfo._customEvaluatorType = ConfigUtil.GetType(ruleInfo._customEvaluator, "custom", ruleInfo._customEvaluatorConfig);
System.Web.Configuration.HandlerBase.CheckAssignableType(ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].Source, ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].LineNumber, typeof(IWebEventCustomEvaluator), ruleInfo._customEvaluatorType);
if (this._customEvaluatorInstances[ruleInfo._customEvaluatorType] == null)
{
this._customEvaluatorInstances[ruleInfo._customEvaluatorType] = HttpRuntime.CreatePublicInstance(ruleInfo._customEvaluatorType);
}
}
}
void InitReferencedProvider(RuleInfo ruleInfo) {
String providerName;
WebEventProvider provider;
Debug.Assert(ruleInfo._referencedProvider == null, "ruleInfo._referencedProvider == null");
providerName = ruleInfo._ruleSettings.Provider;
if (String.IsNullOrEmpty(providerName)) {
return;
}
provider = _providerInstances[providerName];
Debug.Assert(provider != null, "provider != null");
ruleInfo._referencedProvider = provider;
}
void MergeValuesWithProfile(RuleInfo ruleInfo) {
ProfileSettings profileSettings = null;
if (ruleInfo._ruleSettings.ElementInformation.Properties["profile"].ValueOrigin != PropertyValueOrigin.Default) {
profileSettings = _section.Profiles[ruleInfo._ruleSettings.Profile];
Debug.Assert(profileSettings != null, "profileSettings != null");
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["minInstances"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._minInstances = profileSettings.MinInstances;
}
else {
ruleInfo._minInstances = ruleInfo._ruleSettings.MinInstances;
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["maxLimit"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._maxLimit = profileSettings.MaxLimit;
}
else {
ruleInfo._maxLimit = ruleInfo._ruleSettings.MaxLimit;
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["minInterval"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._minInterval = profileSettings.MinInterval;
}
else {
ruleInfo._minInterval = ruleInfo._ruleSettings.MinInterval;
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["custom"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._customEvaluator = profileSettings.Custom;
ruleInfo._customEvaluatorConfig = profileSettings;
}
else {
ruleInfo._customEvaluator = ruleInfo._ruleSettings.Custom;
ruleInfo._customEvaluatorConfig = ruleInfo._ruleSettings;
}
}
void DisplayRuleInfo(RuleInfo ruleInfo) {
#if DEBUG
Debug.Trace("BuildRuleInfos", "====================== Rule Info =======================");
Debug.Trace("BuildRuleInfos", "name:" + ruleInfo._ruleSettings.Name);
Debug.Trace("BuildRuleInfos", "type:" + ruleInfo._eventMappingSettings.RealType.Name);
Debug.Trace("BuildRuleInfos", "minInstances:" + ruleInfo._minInstances);
Debug.Trace("BuildRuleInfos", "maxLimit:" + ruleInfo._maxLimit);
Debug.Trace("BuildRuleInfos", "minInterval:" + ruleInfo._minInterval);
Debug.Trace("BuildRuleInfos", "provider:" + ruleInfo._ruleSettings.Provider);
Debug.Trace("BuildRuleInfos", "referenced provider:" + (ruleInfo._referencedProvider == null ? String.Empty : ruleInfo._referencedProvider.GetType().Name));
Debug.Trace("BuildRuleInfos", "=========================================================");
#endif
}
private RuleInfo CreateRuleInfo(RuleSettings ruleSettings)
{
RuleInfo ruleInfo = new RuleInfo(ruleSettings, this._section);
this.MergeValuesWithProfile(ruleInfo);
this.InitReferencedProvider(ruleInfo);
this.InitCustomEvaluator(ruleInfo);
return ruleInfo;
}
