/// <summary>
/// Evaluates the expressions.
/// </summary>
/// <param name="contextEntity">The context entity.</param>
/// <param name="expressions">The expressions.</param>
/// <returns></returns>
private Dictionary <string, EvaluateResult> EvaluateExpressionsInternal(IEntity contextEntity, IDictionary <string, CalcEngineExpression> expressions)
{
var results = new Dictionary <string, EvaluateResult>();
var contextEntityTypeId = new EntityRef(contextEntity.TypeIds.FirstOrDefault());
foreach (var item in expressions)
{
string key = item.Key;
try
{
CalcEngineExpression expression = item.Value;
IExpression compiledExpression = CompileExpression(contextEntityTypeId, expression);
string value = RunExpression(compiledExpression, contextEntity);
results[key] = new EvaluateResult
{
Value = value,
CompiledExpression = compiledExpression
};
}
catch (Exception ex)
{
results[key] = new EvaluateResult
{
Error = ex.ToString()
};
}
}
return(results);
}
public void ToString_OfNonEmptyEvaluateResult_ReturnsMessage()
{
var result = new EvaluateResult("avoid the " + "interning");
var actual = result.ToString();
Assert.AreEqual("avoid the interning", actual);
}
public void Equals_WithNull_ReturnsFalse()
{
var value = new EvaluateResult("");
var condition = value.Equals(null);
Assert.IsFalse(condition);
}
public void Equals_WithSameMessage_ReturnsTrue()
{
var expected = new EvaluateResult("avoid " + "interning");
var actual = new EvaluateResult("avoid" + " interning");
var condition = expected.Equals(actual);
Assert.IsTrue(condition);
}
public void OperatorNotEqual_WithSameMessages_ReturnsFalse()
{
var expected = new EvaluateResult("avoid " + "interning");
var actual = new EvaluateResult("avoid" + " interning");
var condition = expected != actual;
Assert.IsFalse(condition);
}
public void Print_WithNonEmptyResult_PrintsMessage()
{
var parser = new Parser();
var inputOutput = MakeInputOutput();
var rte = MakeRunTimeEnvironment(inputOutput);
var repl = new ReadEvaluatePrintLoop(rte, parser);
var result = new EvaluateResult("message");
repl.Print(result);
Assert.AreEqual("message", inputOutput.OutputStrings[0]);
}
protected override System.Drawing.Color GenerateColor(EvaluateResult er, int index)
{
Color c = Color.White;
if (SecurityEventService.Instance.IsSecurityActionResultExisting(er.ResultGuid))
{
c = Color.FromArgb(SecurityEventService.Instance.GetSecurityActionResult(er.ResultGuid).BackgroundColor);
}
else
{
c = er.BackColor;
}
return(c);
}
public Task <EvaluateResult> EvaluateRoot(Guid permission)
{
if (!UseAuthorization ||
_securityContext.IsAdministrator())
{
return(Task.FromResult(new EvaluateResult(Guid.Empty, permission, true, null)));
}
var defaultRule = _securityOptions
.DefaultSecurityRules
.First(x => x.Rule.Right == permission);
var result = new EvaluateResult(
Guid.Empty,
permission,
defaultRule.Rule.Type == RuleType.Allow,
null);
return(Task.FromResult(result));
}
/// <summary>
/// Gets the calculate engine eval response.
/// </summary>
/// <param name="expressionResults">The expression results.</param>
/// <returns></returns>
private CalcEngineEvalResponse GetCalcEngineEvalResponse(
IDictionary <string, EvaluateResult> expressionResults)
{
var response = new CalcEngineEvalResponse {
Results = new Dictionary <string, CalcEngineEvalResult>()
};
foreach (var kvp in expressionResults)
{
string key = kvp.Key;
EvaluateResult result = kvp.Value;
if (!string.IsNullOrWhiteSpace(result.Error))
{
// Error result
var errorResult = new CalcEngineEvalResult
{
ErrorMessage = result.Error
};
response.Results[key] = errorResult;
}
else
{
IExpression expression = result.CompiledExpression;
// Success Result
var successResult = new CalcEngineEvalResult
{
Value = result.Value,
ResultType = expression.ResultType.Type,
IsList = expression.ResultType.IsList,
EntityTypeId = expression.ResultType.EntityTypeId
};
response.Results[key] = successResult;
}
}
return(response);
}
public byte[] Evaluate(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginEvaluatePlan(PlanHandle, callInfo, paramsValue, null, null);
result.AsyncWaitHandle.WaitOne();
EvaluateResult evaluateResult = channel.EndEvaluatePlan(result);
executeTime = evaluateResult.ExecuteTime;
_programStatistics = executeTime;
paramsValue.Data = evaluateResult.ParamData;
return(evaluateResult.Result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
protected static MockStatement MakeStatement(EvaluateResult result)
{
return(new MockStatement(result));
}
protected abstract string GenerateKey(EvaluateResult er);
protected abstract string GenerateTitle(EvaluateResult er);
public void EvaluateResult_WithFormat_StoresFormattedMessage()
{
var result = new EvaluateResult("{0}", "format");
Assert.AreEqual("format", result.Message);
}
public void EvaluateResult_WithMessage_IsNotNone()
{
var result = new EvaluateResult("message");
Assert.IsTrue(result != EvaluateResult.None);
}
protected abstract Color GenerateColor(EvaluateResult er, int index);
public void EvaluateResult_WithMessage_StoresMessage()
{
var result = new EvaluateResult("message");
Assert.AreEqual("message", result.Message);
}
public void EvaluateResult_WithNullMessage_ThrowsArgumentNullException()
{
var result = new EvaluateResult(null);
}
public MockStatement()
{
this.action = () => { };
this.result = EvaluateResult.None;
}
public MockStatement(Action action)
{
this.action = action;
this.result = EvaluateResult.None;
}
public MockStatement(EvaluateResult result)
{
this.action = () => { };
this.result = result;
}
protected override System.Drawing.Color GenerateColor(EvaluateResult er, int index)
{
return(ColorsPool.Instance.GetColor(index));
}
public override void Execute(LogRecord record, ILogColumnService colSrv)
{
try
{
m_result.Clear();
List <OperateParam> lstParams = new List <OperateParam>();
foreach (SecurityEvent se in m_events)
{
foreach (SecurityAction sa in se.SecurityActions)
{
if (sa.Conditions.Count <= 0)
{
continue;
}
bool result = true;
// 先检查是否满足关系要求
foreach (SecurityCondition condition in sa.Conditions)
{
if (!record.Items.ContainsKey(condition.SourceCol))
{
result = false;
break;
}
lstParams.Clear();
IRelation relation = RelationService.Instance.GetRelation(colSrv.GetLogColumn(condition.SourceCol).Type, condition.RelationName);
if (condition.IsUsingDestCol)
{
foreach (string s in condition.MultiValues)
{
int colIndex = Convert.ToInt32(s);
if (!record.Items.ContainsKey(colIndex))
{
result = false;
goto NextAction;
}
lstParams.Add(new OperateParam(record.Items[colIndex].Conetent));
}
}
else
{
foreach (string s in condition.MultiValues)
{
lstParams.Add(new OperateParam(s));
}
}
// 检测是否满足关系
if (!relation.Validate(lstParams))
{
result = false;
}
else
{
lstParams.Insert(0, new OperateParam(record.Items[condition.SourceCol].Conetent));
result = result && relation.Implement(lstParams);
}
if (!result)
{
break;
}
}
NextAction:
// 如果符合结果
if (result)
{
EvaluateResult er = new EvaluateResult(record.RecordGuid);
er.AppGuid = record.AppGuid;
er.TableGuid = record.TableGuid;
er.ActionName = sa.Name;
er.ActionGuid = sa.ActionGuid;
er.EventName = se.Name;
er.EventGuid = se.EventGuid;
er.ResultGuid = sa.ResultGuid;
m_result.Add(er);
}
}
}
}
catch (Exception ex)
{
throw new Exception("根据策略分析日志记录失败，错误消息为：" + ex.Message);
}
}
