public ActionResult ExecuteRuleRequest(RuleExecutionRequest request, FormCollection form)
{
try
{
// assign ruleset parameters from form fields
this.PopulateParametersFromForm(request, form, Literals.RuleSetParamPrefix);
this.PopulateEndPointOverridesFromForm(form, request, Literals.EndPointOverridePrefix);
var client = new RuleClient();
var response = client.ExecuteRuleRequest(request);
if (!String.IsNullOrWhiteSpace(response.Error))
{
return(PartialView("_AjaxError", response.Error));
}
return(PartialView("_ExecuteRuleResponse", response));
}
catch (WebException ex)
{
return(PartialView("_AjaxError", this.DigestWebErrorBody(ex)));
}
catch (Exception ex)
{
return(PartialView("_AjaxError", ex.ToString()));
}
}
public RuleExecutionResponse ExecuteRuleRequest(RuleExecutionRequest request)
{
var requestUri = String.Format(Constants.ExecuteRuleRequestTemplate, GetRuleServiceUri());
Headers.Add("Content-Type", "text/xml");
return(GetObjectFromXml <RuleExecutionResponse>(UploadData(requestUri, GetXmlBytesFromObject(request))));
}
public static void PopulateParametersFromForm(this Controller controller, RuleExecutionRequest request, FormCollection form, string controlPrefix)
{
if (request == null || form == null)
{
throw new Exception("Cannot populate Rule Set Parameters. Request is null.");
}
request.Parameters = GetParameterListFromForm(form, controlPrefix);
}
public async Task <ActionResult> RunAsync([FromBody] RuleExecutionRequest model)
{
var databaseEnvironment = await _databaseEnvironmentService
.GetAsync(model.DatabaseEnvironmentId);
var result = await _executionService
.ExecuteRuleByEnvironmentIdAsync(model.RuleId, databaseEnvironment);
if (result != null)
{
return(Ok(result));
}
return(BadRequest());
}
/// <summary>
/// Method used when performing a GET request to execute auto fire rule sets.
/// Builds a RuleExecutionRequest and calls the ExecuteRuleRequest method where all rule processing is handled.
/// </summary>
/// <param name="ruleApp">The rule application to load from the catalog</param>
/// <param name="entity">The name of the entity to load into the rulesession</param>
/// <param name="entityXml">The state XML to load into the entity</param>
/// <param name="returnEntity">The entity whose XML will be returned in the response</param>
/// <param name="responseType">Specifies what will be returned in the response</param>
/// <returns>Stream (supports variable response types)</returns>
public Stream ApplyRules(string ruleApp, string entity, string entityXml, string returnEntity, string responseType)
{
var request = new RuleExecutionRequest
{
RuleApp = ruleApp,
Entity = entity,
EntityXml = entityXml,
ReturnEntity = returnEntity,
ResponseType = responseType
};
var response = ExecuteRuleRequest(request);
return(new MemoryStream(Encoding.UTF8.GetBytes(response.ResponseText)));
}
/// <summary>
/// Method used when performing a GET request to execute an explicit or independent rule set.
/// Builds a RuleExecutionRequest and calls the ExecuteRuleRequest method where all rule processing is handled.
/// </summary>
/// <param name="ruleApp">The rule application to load from the catalog</param>
/// <param name="ruleset">The explicit rule set that will be executed</param>
/// <param name="entity">The name of the entity to load into the rulesession</param>
/// <param name="entityXml">The state XML to load into the entity</param>
/// <param name="returnEntity">The enitity whose XML will be returned in the response</param>
/// <param name="responseType">Specifies what will be returned in the response</param>
/// <returns>Stream (supports variable response types)</returns>
public Stream ExecuteRuleSet(string ruleApp, string ruleset, string entity, string entityXml, string returnEntity, string responseType)
{
var request = new RuleExecutionRequest
{
RuleApp = ruleApp,
RuleSet = ruleset,
Entity = entity,
EntityXml = entityXml,
ReturnEntity = returnEntity,
Parameters = GetParameters(),
ResponseType = responseType
};
var response = ExecuteRuleRequest(request);
return(new MemoryStream(Encoding.UTF8.GetBytes(response.ResponseText)));
}
public static string GetReturnEntityXml(RuleExecutionRequest request, RuleSession session, Entity entity)
{
var xml = string.Empty;
if (String.IsNullOrEmpty(request.ReturnEntity))
{
xml = GetEntityXml(entity);
}
else
{
var returnEntity = GetEntityFromRuleSession(session, request.ReturnEntity);
if (returnEntity != null)
{
xml = GetEntityXml(entity);
}
}
return(xml);
}
private static List <object> BuildRuleSetParameters(RuleExecutionRequest request, RuleSession session)
{
RuleSetDef ruleSetDef;
// get the rule set definition so we can get the names of the parameters
if (String.IsNullOrEmpty(request.Entity))
{
// independent rule set
ruleSetDef = session.GetRuleApplicationDef().RuleSets[request.RuleSet] as RuleSetDef;
}
else
{
// entity rule set
ruleSetDef = session.GetRuleApplicationDef().Entities[request.Entity].GetRuleSet(request.RuleSet);
}
var parameters = new List <object>();
var parmCount = request.Parameters.Count - 1;
var parms = new Object[parmCount - 1];
var i = 0;
foreach (var parameter in request.Parameters)
{
var parmDef = ruleSetDef.Parameters[parameter.Name];
if (parmDef != null && parmDef.DataType == DataType.Entity)
{
// if parm is an entity type, create the entity using the value as the XML andd add
var entity = session.CreateEntity(parmDef.DataTypeEntityName, parameter.Value);
parms[i] = entity;
}
else
{
// add the value based parameter
parms[i] = parameter.Value;
}
i++;
}
return(parameters);
}
public static void OverrideEndPoints(RuleSession session, RuleExecutionRequest request)
{
if (request != null && request.EndPointOverrides != null && request.EndPointOverrides.Count > 0)
{
// apply each submitted override
foreach (var overrideRequest in request.EndPointOverrides)
{
// attempt to lookup the endpoint in the rule application
var targetEndPoint = session.GetRuleApplicationDef().EndPoints[overrideRequest.EndPointName];
if (targetEndPoint == null)
{
throw new Exception(String.Format("Cannot locate endpoint to override for '{0}'", overrideRequest.EndPointName));
}
// apply each overridden property
foreach (var prop in overrideRequest.Properties)
{
AssignEndPointOverrideProperty(session, targetEndPoint, prop);
}
}
}
}
/// <summary>
/// Method used when performing a POST request and by public GET methods to centralize all rule execution.
/// Auto, explicit and independent rules can be executed in the method, based on the type of request specified.
/// </summary>
/// <param name="request">A RuleExecutionRequest that contains all execution information required to run rules.</param>
/// <returns>RuleExecutionResponse</returns>
public RuleExecutionResponse ExecuteRuleRequest(RuleExecutionRequest request)
{
var response = new RuleExecutionResponse();
try
{
// get rule application using settings from web.config
var ruleApp = GetRuleApp(request.RuleApp);
using (var session = new RuleSession(ruleApp))
{
// override end points
RuleServiceHelper.OverrideEndPoints(session, request);
// if the performance stats report was requested, turn on the details
if (request.ResponseType != null && request.ResponseType.Contains(RuleExecutionResponseType.PerformanceStatisticsReport.ToString()))
{
session.Settings.LogOptions = EngineLogOptions.SummaryStatistics | EngineLogOptions.DetailStatistics;
}
// if the execution report or execution log was requested, turn on the execution and state change settings
if (request.ResponseType != null && (request.ResponseType.Contains(RuleExecutionResponseType.RuleExecutionReport.ToString()) ||
request.ResponseType.Contains(RuleExecutionResponseType.ExecutionLogText.ToString()) ||
request.ResponseType.Contains(RuleExecutionResponseType.ExecutionLogXml.ToString())))
{
session.Settings.LogOptions = EngineLogOptions.Execution | EngineLogOptions.StateChanges;
}
response.ResponseType = request.ResponseType;
Entity entity = null;
if (!String.IsNullOrEmpty(request.Entity))
{
// if an entity was specified, this is an entity based rule set
entity = session.CreateEntity(request.Entity);
// if state was passed in, load it
if (!String.IsNullOrEmpty(request.EntityXml))
{
entity.ParseXml(request.EntityXml);
}
// if an explicit rule set was not specified, call ApplyRules
if (String.IsNullOrEmpty(request.RuleSet))
{
session.ApplyRules();
}
else
{
// this is an explicit rule set, if parameters were passed in, pass them to the explicit rule set
if (request.Parameters.Count > 0)
{
var parameters = BuildRuleSetParameters(request, session);
entity.ExecuteRuleSet(request.RuleSet, parameters.ToArray());
}
else
{
entity.ExecuteRuleSet(request.RuleSet);
}
}
}
else
{
// if no entity name was passed in, this is an independent rule set, pass parameters if applicable
if (request.Parameters.Count > 0)
{
var parameters = BuildRuleSetParameters(request, session);
session.ExecuteIndependentRuleSet(request.RuleSet, parameters.ToArray());
}
else
{
session.ExecuteIndependentRuleSet(request.RuleSet);
}
}
// if output entity was specified,
Entity returnEntity;
if (string.IsNullOrEmpty(request.ReturnEntity))
{
returnEntity = entity;
}
else
{
// retrieve output entity
returnEntity = RuleServiceHelper.GetEntityFromRuleSession(session, request.ReturnEntity);
}
// set the response text based on the request type
RuleServiceHelper.SetResponseText(session, returnEntity, response);
}
}
catch (Exception ex)
{
RuleServiceHelper.HandleWebException(ex, response);
}
return(response);
}
public static void PopulateEndPointOverridesFromForm(this Controller controller, FormCollection form, RuleExecutionRequest request, string controlPrefix)
{
if (form == null || request == null)
{
throw new Exception("Cannot populate Rule Set Parameters. Form or Request was null.");
}
var tempContainer = new List <RuleExecutionEndPointOverride>();
foreach (var fieldName in form.AllKeys)
{
if (fieldName.StartsWith(controlPrefix) && fieldName.EndsWith(Literals.EndPointOverrideKeyNamePart))
{
var endPointName = form[fieldName];
if (!String.IsNullOrWhiteSpace(endPointName))
{
var endPointOverride = new RuleExecutionEndPointOverride {
EndPointName = endPointName
};
var paramContainer = new List <RuleExecutionEndPointProperty>();
var prefixText = Regex.Match(fieldName, "^" + controlPrefix + @"\d+", RegexOptions.RightToLeft);
foreach (var childFieldName in form.AllKeys)
{
if (childFieldName.StartsWith(prefixText + Literals.ParamNameKeyPart))
{
var paramName = form[childFieldName];
if (!String.IsNullOrWhiteSpace(paramName))
{
var parameter = new RuleExecutionEndPointProperty {
Name = paramName.Trim()
};
var suffixText = Regex.Match(childFieldName, @"\d+$", RegexOptions.RightToLeft);
if (suffixText.Success)
{
int suffixCount;
if (int.TryParse(suffixText.Value, out suffixCount))
{
parameter.Value = form[prefixText + Literals.ParamValueKeyPart + suffixCount];
}
}
paramContainer.Add(parameter);
}
}
}
endPointOverride.Properties = paramContainer;
tempContainer.Add(endPointOverride);
}
}
}
request.EndPointOverrides = tempContainer;
}
