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; }